{"success":true,"data":{"query":"reference documentation","limit":10,"count":10,"sources":["web_1779060046.hat","wiki_dallas.hat","web_1779060034.hat","wiki_real_estate.hat"],"synced":[],"results":[{"source":"web_1779060046.hat","text":"API Reference Copy page Copy React Reference Overview This section provides detailed reference documentation for working with React. For an introduction to React, please visit the Learn section. The React reference documentation is broken down into functional subsections: React Programmatic React features: Hooks - Use different React features from your components. Components - Built-in components that you can use in your JSX. APIs - APIs that are useful for defining components. Directives - Provide instructions to bundlers compatible with React Server Components. React DOM React DOM contains features that are only supported for web applications (which run in the browser DOM environment). This section is broken into the following: Hooks - Hooks for web applications which run in the browser DOM environment. Components - React supports all of the browser built-in HTML and SVG components. APIs - The react-dom package contains methods supported only in web applications. Client APIs - The react-dom/client APIs let you render React components on the client (in the browser). Server APIs - The react-dom/server APIs let you render React components to HTML on the server. Static APIs - The react-dom/static APIs let you generate static HTML for React components. React Compiler The React Compiler is a build-time optimization tool that automatically memoizes your React components and values: Configuration - Configuration options for React Compiler. Directives - Function-level directives to control compilation. Compiling Libraries - Guide for shipping pre-compiled library code. ESLint Plugin React Hooks The ESLint plugin for React Hooks helps enforce the Rules of React: Lints - Detailed documentation for each lint with examples. Rules of React React has idioms — or rules — for how to express patterns in a way that is easy to understand and yields high-quality applications: Components and Hooks must be pure – Purity makes your code easier to understand, debug, and allows React to automatically optimize your components and hooks correctly. React calls Components and Hooks – React is responsible for rendering components and hooks when necessary to optimize the user experience. Rules of Hooks – Hooks are defined using JavaScript functions, but they represent a special type of reusable UI logic with restrictions on where they can be called. Legacy APIs Legacy APIs - Exported from the react package, but not recommended for use in newly written code. Next Hooks","score":62.12400931168676,"links":[]},{"source":"wiki_dallas.hat","text":"Politics\nSince 2023, Dallas has been the largest city in the United States with a Republican mayor after Eric Johnson switched parties after winning re-election. He ran and was elected as a Democrat. However, the city is normally a Democratic stronghold, with over 60% of voters supporting Kamala Harris in the 2024 presidential election, 69% of voters supporting Joe Biden in the 2020 presidential election and 67% of voters supporting Hillary Clinton in the 2016 presidential election (excluding write-ins). Democratic voters dominate the majority of the city, especially the central urban core and southern sectors, with Republicans spreading a sliver of suburban neighborhoods in North Dallas. In the 2004 U.S. presidential election, 57% of voters in Dallas' city limits voted for John Kerry over George W. Bush. Dallas County was closely divided, with 50% of voters voting for Bush and 49% voting for Kerry. Results in the 2008 and 2012 elections favored Barack Obama, with the 44th President receiving 57% of Dallas County voters in both years, with greater margins in the city of Dallas. In the 2016 U.S. presidential election, approximately 66% of Dallas voters voted for Hillary Clinton, with 28% of city voters voting for Donald Trump. Dallas County as a whole saw 61% of voters voting for Clinton, with 35% support for Trump. In 2004, Lupe Valdez was elected Dallas County Sheriff. An open lesbian, Valdez was the only female sheriff in the state of Texas until her resignation. Despite controversies in her handling of county jails, she won re-election in 2008 with a 10-point victory over Republican challenger Lowell Cannaday. In the 2024 United States presidential election, Donald Trump, achieved 34.1% of the vote in the city of Dallas. This marked the highest level of support for a Republican candidate in the city since the 2012 election, when Mitt Romney received a comparable percentage. Trump's performance in Dallas has been attributed in part to a notable shift in Hispanic voter preferences within Texas. Trump garnered an estimated 55% of the Hispanic vote statewide, a significant improvement from his performance among Hispanic voters in 2016.","score":38.92137578884761,"links":[]},{"source":"wiki_dallas.hat","text":"Languages\nAccording to the 2022 American Community Survey, the most commonly spoken languages in Dallas by people aged 5 years and over (1,207,230 people):\n\nSpeak only English: 57.4%\nLanguage other than English: 42.6%\nSpanish: 36.3%\nOther Indo-European languages: 2.4%\nOther languages: 2%\nAsian languages and Pacific Island languages: 1.9%\n\nReligion\nAccording to a 2014 study by the Pew Research Center, Christianity is the most prevalent religion in Dallas and its metropolitan statistical area (78%).\n\nSee also\nDemographics of Dallas-Fort Worth\nDemographics of Texas\nDemographics of Houston\nDemographics of San Antonio\n\n\n== References ==\n\n--- NEXT ARTICLE ---\n\nARTICLE: Knoll Trail station\nKnoll Trail station is a DART Silver Line commuter rail station in Dallas, Texas.\nThe station is located in Far North Dallas near the intersection of Arapaho Road and the Dallas North Tollway. It serves adjacent apartment and office complexes, as well as Prestonwood Town Center. Unlike most DART stations, Knoll Trail does not have a dedicated parking lot.\nThe station is decorated with an \"urban refuge\" theme.","score":38.92137578884761,"links":[]},{"source":"wiki_dallas.hat","text":"History\nIn 1990, Dallas Area Rapid Transit (DART) purchased a former St. Louis Southwestern Railway corridor between Fort Worth and Plano for a future commuter rail line.\nIn 2006, the city of Dallas proposed a development plan for the Far North Dallas segment of the corridor. The plan proposed three stations on the segment, including one at Knoll Trail. The other two Far North Dallas stations (located at Preston Road and Coit Road) would later be removed from the plan, but Knoll Trail was retained.\nIn 2017, developers for the Dallas Midtown project (located 2.5 miles (4.0 km) south of the rail line at the former site of Valley View Center) proposed an elevated transit system connecting the project and Knoll Trail station.\nThe station opened, alongside the rest of the Silver Line, on October 25, 2025.\n\nReferences\nExternal links\nDallas Area Rapid Transit – Knoll Trail Station\n\n--- NEXT ARTICLE ---","score":38.92137578884761,"links":[]},{"source":"web_1779060034.hat","text":"Menu Using App Router Features available in /app Latest Version 16.2.6 For an index of Next.js documentation , see /docs/llms.txt . Next.js Docs Welcome to the Next.js documentation! What is Next.js? Next.js is a React framework for building full-stack web applications. You use React Components to build user interfaces, and Next.js for additional features and optimizations. It also automatically configures lower-level tools like bundlers and compilers. You can instead focus on building your product and shipping quickly. Whether you're an individual developer or part of a larger team, Next.js can help you build interactive, dynamic, and fast React applications. How to use the docs The docs are organized into 3 sections: Getting Started : Step-by-step tutorials to help you create a new application and learn the core Next.js features. Guides : Tutorials on specific use cases, choose what's relevant to you. API Reference : Detailed technical reference for every feature. Use the sidebar to navigate through the sections, or search ( Ctrl+K or Cmd+K ) to quickly find a page. App Router and Pages Router Next.js has two different routers: App Router : The newer router that supports new React features like Server Components. Pages Router : The original router, still supported and being improved. At the top of the sidebar, you'll notice a dropdown menu that allows you to switch between the App Router and the Pages Router docs. React version handling The App Router and Pages Router handle React versions differently: App Router : Uses React canary releases built-in, which include all the stable React 19 changes, as well as newer features being validated in frameworks, prior to a new React release. Pages Router : Uses the React version installed in your project's package.json . This approach ensures new React features work reliably in the App Router while maintaining backwards compatibility for existing Pages Router applications. Pre-requisite knowledge Our documentation assumes some familiarity with web development. Before getting started, it'll help if you're comfortable with: HTML CSS JavaScript React If you're new to React or need a refresher, we recommend starting with our React Foundations course , and the Next.js Foundations course that has you building an application as you learn. Accessibility For the best experience when using a screen reader, we recommend using Firefox and NVDA, or Safari and VoiceOver. Join our Community If you have questions about anything related to Next.js, you're always welcome to ask our community on GitHub Discussions , Discord , X (Twitter) , and Reddit . Next Steps Create your first application and learn the core Next.js features. Getting Started Learn how to create full-stack web applications with the Next.js App Router. Was this helpful? supported. Send","score":37.12400931168676,"links":[]},{"source":"web_1779060034.hat","text":"Menu Using App Router Features available in /app Latest Version 16.2.6 This page is also available as Markdown at /docs/app/api-reference.md . For an index of Next.js documentation , see /docs/llms.txt . Copy page API Reference Last updated May 13, 2026 Directives Directives are used to modify the behavior of your Next.js application. Components API Reference for Next.js built-in components. File-system conventions API Reference for Next.js file-system conventions. Functions API Reference for Next.js Functions and Hooks. Configuration Learn how to configure Next.js applications. CLI API Reference for the Next.js Command Line Interface (CLI) tools. Adapters Build deployment adapters for Next.js platforms and infrastructure. Edge Runtime API Reference for the Edge Runtime. Turbopack Turbopack is an incremental bundler optimized for JavaScript and TypeScript, written in Rust, and built into Next.js. Was this helpful? supported. Send","score":37.12400931168676,"links":[]},{"source":"web_1779060034.hat","text":"Menu Using App Router Features available in /app Latest Version 16.2.6 This page is also available as Markdown at /docs/pages.md . For an index of Next.js Pages Router documentation , see /docs/pages/llms.txt . Copy page Pages Router Last updated May 13, 2026 You're viewing the documentation for the Pages Router. See the App Router documentation for the latest features. The Pages Router uses an intuitive file-system router to map each file to a route. Before Next.js 13, the Pages Router was the main way to create routes in Next.js. It's still supported in newer versions of Next.js, but we recommend migrating to the new App Router to leverage React's latest features. Getting Started Learn how to create full-stack web applications with Next.js with the Pages Router. Guides Learn how to implement common UI patterns and use cases using Next.js Building Your Application Learn how to use Next.js features to build your application. API Reference Next.js API Reference for the Pages Router. Was this helpful? supported. Send","score":37.12400931168676,"links":[]},{"source":"web_1779060046.hat","text":"Learn React Copy page Copy Quick Start Welcome to the React documentation! This page will give you an introduction to 80% of the React concepts that you will use on a daily basis. You will learn How to create and nest components How to add markup and styles How to display data How to render conditions and lists How to respond to events and update the screen How to share data between components Creating and nesting components React apps are made out of components . A component is a piece of the UI (user interface) that has its own logic and appearance. A component can be as small as a button, or as large as an entire page. React components are JavaScript functions that return markup: function MyButton ( ) { return ( < button > I'm a button </ button > ) ; } Now that you’ve declared MyButton , you can nest it into another component: export default function MyApp ( ) { return ( < div > < h1 > Welcome to my app </ h1 > < MyButton /> </ div > ) ; } Notice that <MyButton /> starts with a capital letter. That’s how you know it’s a React component. React component names must always start with a capital letter, while HTML tags must be lowercase. Have a look at the result: App.js App.js Reload Clear Fork function MyButton ( ) { return ( < button > I'm a button </ button > ) ; } export default function MyApp ( ) { return ( < div > < h1 > Welcome to my app </ h1 > < MyButton /> </ div > ) ; } Show more The export default keywords specify the main component in the file. If you’re not familiar with some piece of JavaScript syntax, MDN and javascript.info have great references. Writing markup with JSX The markup syntax you’ve seen above is called JSX . It is optional, but most React projects use JSX for its convenience. All of the tools we recommend for local development support JSX out of the box. JSX is stricter than HTML. You have to close tags like <br /> . Your component also can’t return multiple JSX tags. You have to wrap them into a shared parent, like a <div>...</div> or an empty <>...</> wrapper: function AboutPage ( ) { return ( < > < h1 > About </ h1 > < p > Hello there. < br /> How do you do? </ p > </ > ) ; } If you have a lot of HTML to port to JSX, you can use an online converter. Adding styles In React, you specify a CSS class with className . It works the same way as the HTML class attribute: < img className = \"avatar\" /> Then you write the CSS rules for it in a separate CSS file: /* In your CSS */ .avatar { border-radius : 50 % ; } React does not prescribe how you add CSS files. In the simplest case, you’ll add a <link> tag to your HTML. If you use a build tool or a framework, consult its documentation to learn how to add a CSS file to your project. Displaying data JSX lets you put markup into JavaScript. Curly braces let you “escape back” into JavaScript so that you can embed some variable from your code and display it to the user. For example, this will display user.name : return ( < h1 > { user . name } </ h1 > ) ; You can also “escape into JavaScript” from JSX attributes, but you have to use curly braces instead of quotes. For example, className=\"avatar\" passes the \"avatar\" string as the CSS class, but src={user.imageUrl} reads the JavaScript user.imageUrl variable value, and then passes that value as the src attribute: return ( < img className = \"avatar\" src = { user . imageUrl } /> ) ; You can put more complex expressions inside the JSX curly braces too, for example, string concatenation : App.js App.js Reload Clear Fork const user = { name : 'Hedy Lamarr' , imageUrl : 'https://react.dev/images/docs/scientists/yXOvdOSs.jpg' , imageSize : 90 , } ; export default function Profile ( ) { return ( < > < h1 > { user . name } </ h1 > < img className = \"avatar\" src = { user . imageUrl } alt = { 'Photo of ' + user . name } style = { { width : user . imageSize , height : user . imageSize } } /> </ > ) ; } Show more In the above example, style={{}} is not a special syntax, but a regular {} object inside the style={ } JSX curly braces. You can use the style attribute when your styles depend on JavaScript variables. Conditional rendering In React, there is no special syntax for writing conditions. Instead, you’ll use the same techniques as you use when writing regular JavaScript code. For example, you can use an if statement to conditionally include JSX: let content ; if ( isLoggedIn ) { content = < AdminPanel /> ; } else { content = < LoginForm /> ; } return ( < div > { content } </ div > ) ; If you prefer more compact code, you can use the conditional ? operator. Unlike if , it works inside JSX: < div > { isLoggedIn ? ( < AdminPanel /> ) : ( < LoginForm /> ) } </ div > When you don’t need the else branch, you can also use a shorter logical && syntax : < div > { isLoggedIn && < AdminPanel /> } </ div > All of these approaches also work for conditionally specifying attributes. If you’re unfamiliar with some of this JavaScript syntax, you can start by always using if...else . Rendering lists You will rely on JavaScript features like for loop and the array map() function to render lists of components. For example, let’s say you have an array of products: const products = [ { title : 'Cabbage' , id : 1 } , { title : 'Garlic' , id : 2 } , { title : 'Apple' , id : 3 } , ] ; Inside your component, use the map() function to transform an array of products into an array of <li> items: const listItems = products . map ( product => < li key = { product . id } > { product . title } </ li > ) ; return ( < ul > { listItems } </ ul > ) ; Notice how <li> has a key attribute. For each item in a list, you should pass a string or a number that uniquely identifies that item among its siblings. Usually, a key should be coming from your data, such as a database ID. React uses your keys to know what happened if you later insert, delete, or reorder the items. App.js App.js Reload Clear Fork const products = [ { title : 'Cabbage' , isFruit : false , id : 1 } , { title : 'Garlic' , isFruit : false , id : 2 } , { title : 'Apple' , isFruit : true , id : 3 } , ] ; export default function ShoppingList ( ) { const listItems = products . map ( product => < li key = { product . id } style = { { color : product . isFruit ? 'magenta' : 'darkgreen' } } > { product . title } </ li > ) ; return ( < ul > { listItems } </ ul > ) ; } Show more Responding to events You can respond to events by declaring event handler functions inside your components: function MyButton ( ) { function handleClick ( ) { alert ( 'You clicked me!' ) ; } return ( < button onClick = { handleClick } > Click me </ button > ) ; } Notice how onClick={handleClick} has no parentheses at the end! Do not call the event handler function: you only need to pass it down . React will call your event handler when the user clicks the button. Updating the screen Often, you’ll want your component to “remember” some information and display it. For example, maybe you want to count the number of times a button is clicked. To do this, add state to your component. First, import useState from React: import { useState } from 'react' ; Now you can declare a state variable inside your component: function MyButton ( ) { const [ count , setCount ] = useState ( 0 ) ; // ... You’ll get two things from useState : the current state ( count ), and the function that lets you update it ( setCount ). You can give them any names, but the convention is to write [something, setSomething] . The first time the button is displayed, count will be 0 because you passed 0 to useState() . When you want to change state, call setCount() and pass the new value to it. Clicking this button will increment the counter: function MyButton ( ) { const [ count , setCount ] = useState ( 0 ) ; function handleClick ( ) { setCount ( count + 1 ) ; } return ( < button onClick = { handleClick } > Clicked { count } times </ button > ) ; } React will call your component function again. This time, count will be 1 . Then it will be 2 . And so on. If you render the same component multiple times, each will get its own state. Click each button separately: App.js App.js Reload Clear Fork import { useState } from 'react' ; export default function MyApp ( ) { return ( < div > < h1 > Counters that update separately </ h1 > < MyButton /> < MyButton /> </ div > ) ; } function MyButton ( ) { const [ count , setCount ] = useState ( 0 ) ; function handleClick ( ) { setCount ( count + 1 ) ; } return ( < button onClick = { handleClick } > Clicked { count } times </ button > ) ; } Show more Notice how each button “remembers” its own count state and doesn’t affect other buttons. Using Hooks Functions starting with use are called Hooks . useState is a built-in Hook provided by React. You can find other built-in Hooks in the API reference. You can also write your own Hooks by combining the existing ones. Hooks are more restrictive than other functions. You can only call Hooks at the top of your components (or other Hooks). If you want to use useState in a condition or a loop, extract a new component and put it there. Sharing data between components In the previous example, each MyButton had its own independent count , and when each button was clicked, only the count for the button clicked changed: Initially, each MyButton ’s count state is 0 The first MyButton updates its count to 1 However, often you’ll need components to share data and always update together . To make both MyButton components display the same count and update together, you need to move the state from the individual buttons “upwards” to the closest component containing all of them. In this example, it is MyApp : Initially, MyApp ’s count state is 0 and is passed down to both children On click, MyApp updates its count state to 1 and passes it down to both children Now when you click either button, the count in MyApp will change, which will change both of the counts in MyButton . Here’s how you can express this in code. First, move the state up from MyButton into MyApp : export default function MyApp ( ) { const [ count , setCount ] = useState ( 0 ) ; function handleClick ( ) { setCount ( count + 1 ) ; } return ( < div > < h1 > Counters that update separately </ h1 > < MyButton /> < MyButton /> </ div > ) ; } function MyButton ( ) { // ... we're moving code from here ... } Then, pass the state down from MyApp to each MyButton , together with the shared click handler. You can pass information to MyButton using the JSX curly braces, just like you previously did with built-in tags like <img> : export default function MyApp ( ) { const [ count , setCount ] = useState ( 0 ) ; function handleClick ( ) { setCount ( count + 1 ) ; } return ( < div > < h1 > Counters that update together </ h1 > < MyButton count = { count } onClick = { handleClick } /> < MyButton count = { count } onClick = { handleClick } /> </ div > ) ; } The information you pass down like this is called props . Now the MyApp component contains the count state and the handleClick event handler, and passes both of them down as props to each of the buttons. Finally, change MyButton to read the props you have passed from its parent component: function MyButton ( { count , onClick } ) { return ( < button onClick = { onClick } > Clicked { count } times </ button > ) ; } When you click the button, the onClick handler fires. Each button’s onClick prop was set to the handleClick function inside MyApp , so the code inside of it runs. That code calls setCount(count + 1) , incrementing the count state variable. The new count value is passed as a prop to each button, so they all show the new value. This is called “lifting state up”. By moving state up, you’ve shared it between components. App.js App.js Reload Clear Fork import { useState } from 'react' ; export default function MyApp ( ) { const [ count , setCount ] = useState ( 0 ) ; function handleClick ( ) { setCount ( count + 1 ) ; } return ( < div > < h1 > Counters that update together </ h1 > < MyButton count = { count } onClick = { handleClick } /> < MyButton count = { count } onClick = { handleClick } /> </ div > ) ; } function MyButton ( { count , onClick } ) { return ( < button onClick = { onClick } > Clicked { count } times </ button > ) ; } Show more Next Steps By now, you know the basics of how to write React code! Check out the Tutorial to put them into practice and build your first mini-app with React. Next Tutorial: Tic-Tac-Toe","score":37.12400931168676,"links":[]},{"source":"wiki_real_estate.hat","text":"History\nThe first known reference to an activity-based analysis of office work modes was by American architect Robert Luchetti in the late 1970s. in 1983, Luchetti co-invented the now widely accepted concept of the office as a series of \"activity settings\". In an activity settings-based environment, multiple settings are provided which have different technical and physical attributes assembled to support the variety of performance \"modes\" that take place in a work environment.\nThe term \"Activity Based Working\" was first coined in the book the Art of Working by Erik Veldhoen, a Dutch consultant with Veldhoen + Company, and author of the book The Demise of the Office.  Activity Based Working was first implemented in the Netherlands by Interpolis in collaboration with Veldhoen + Company in the nineties. Interpolis is one of largest insurance companies in the Netherlands. The company gained wide recognition with its advertising campaign \"Interpolis. Crystal clear\", which was adopted from their vision and brought to life in their new way of working.","score":36.327294707324214,"links":[]},{"source":"wiki_real_estate.hat","text":"Activity-based offices of the future\nTo create a successful work environment, it is important to have insight into the demands and behaviours of the employees using this environment. It has been trending in recent years as offices seek to adopt a “fewer desks, more open spaces” approach. Recently there has also been a move towards understanding interior design features underpinning occupants' higher satisfaction results in ABW, open-plan offices\nHowever, the three fundamental pillars that support a new way of working continue to be the same - the (1) behavioural, (2) virtual and (3) physical work environments, which can be linked to the working processes of human resources, IT and facility management in the work environment. Access to new technologies and analysis methods such as Organisational Network Analysis and other workplace metrics will continue to shape the future of leaders ability to understand and plan for the future of their organisations.\n\nSee also\nHot desking\n\n\n== References ==\n\n--- NEXT ARTICLE ---","score":36.327294707324214,"links":[]}]},"metadata":{},"timestamp":"2026-07-08T22:44:53.978Z"}