React Glossary
Key terms from the React course, linked to the lesson that introduces each one.
288 terms.
A
- Accordions
- The accordion container manages which sections are open. Each <AccordionItem> needs access to that state to render correctly. Each <AccordionTrigger> needs to update that state. All these pieces are tightly related.
- Lesson 1087 — When to Use This Pattern
- action
- The action is the second parameter, and it's typically a plain JavaScript object that describes what happened in your application.
- Lesson 756 — Action Parameter: Instruction ObjectLesson 1484 — The useActionState Signature
- Action creators
- Action creators are simple functions that return action objects.
- Lesson 765 — Action Creators: Functions That Return Actions
- Actions
- Actions are functions you define inside your store that call set() internally.
- Lesson 1711 — Actions Inside the Store
- Analogy
- Don't buy a sports car to drive two blocks to the store. If the journey is already instant, optimization is wasted effort.
- Lesson 1038 — Dynamic Hook Calls in Code GeneratorsLesson 1441 — When NOT to Use useTransition
- app-level error boundary
- An app-level error boundary is the ultimate safety net at ground level—it catches any uncaught render error before it reaches the user as a blank white screen.
- Lesson 1308 — App-Level Boundary: The Safety Net
- Async code without proper waiting
- A setTimeout, Promise, or API call updates state after your test ends
- Lesson 2149 — act() Warnings and What They Mean
- atom family
- An atom family is a factory function that creates atoms on-demand based on a parameter (like an ID).
- Lesson 1726 — Atom Families for Dynamic Collections
- Authentication status
- Nearly every component might need to know if a user is logged in
- Lesson 810 — Context for Truly Global State
- automatically
- This function gets called automatically with the DOM node when the element mounts, and with null when it unmounts.
- Lesson 720 — The Ref Callback Pattern
B
- Babel
- Babel is a transpiler—it converts modern JavaScript (including JSX) into older JavaScript that all browsers understand.
- Lesson 54 — Webpack from Scratch
- barrel
- A barrel is an index.js file that re-exports everything from a folder.
- Lesson 65 — Barrel Exports: index.js for Cleaner Imports
- basic API
- The basic API is simple: your component accepts a reducer function as a prop.
- Lesson 1175 — The Basic State Reducer API
- Batching
- Batching is React's optimization where multiple state updates that happen close together are grouped into a single re-render.
- Lesson 417 — What is Batching and Why It Matters
- before
- vi.mock() hooks into Vitest's module system to intercept this process—it must be called before the module you're testing imports the dependency.
- Lesson 2076 — Vitest's vi.mock() Basics
- Better alternatives
- The standard Profiler workflow—recording interactions and filtering by commit duration—proved sufficient for most debugging
- Lesson 2217 — Using the Interactions Tab (Legacy)
- Better way
- You call ahead while driving. Your coffee is ready when you arrive. Total: 5 minutes.
- Lesson 643 — The Waterfall Problem
- Blocked main thread
- Blocked main thread means the UI can't respond to user input during the flush
- Lesson 447 — The Performance Cost of flushSync
- Blogs
- Posts don't change after publishing (or change rarely enough that rebuilding is acceptable)
- Lesson 1677 — SSG Trade-offs: Speed vs Freshness
- BrowserRouter
- BrowserRouter is the classic component-based approach.
- Lesson 1844 — createBrowserRouter vs BrowserRouter
- Bug Reproduction
- A user reports a bug but can't explain the steps. With Redux DevTools, they export their session. You import it, hit "play," and watch the exact sequence of actions that triggered the problem—no guessing required.
- Lesson 1744 — Time-Travel Debugging and Audit Requirements
- Build Logs
- The compiler can log which components it optimized and which it skipped. Look for warnings like "Could not optimize ComponentName due to..." in your build output.
- Lesson 1510 — Debugging Compiler Output
- bundle budget
- A bundle budget is your performance contract: specific size thresholds that trigger action when exceeded.
- Lesson 1421 — Bundle Budget Strategy: Setting Thresholds
- Bundle size
- The entire CSS-in-JS library ships to every user (~15-30 KB for styled-components, ~8-15 KB for Emotion).
- Lesson 1931 — Performance Tradeoffs: Runtime Style Injection
C
- Caching
- Once fetched, data is reused across your app without refetching
- Lesson 596 — Why Libraries Handle This Better
- Calendars
- Rows are weeks, columns are days—only visible weeks render.
- Lesson 2299 — Virtualized Grids and Multi-Column Layouts
- Cascading patterns
- A parent component with many wide children suggests a rendering cascade where updates flow through multiple layers unnecessarily.
- Lesson 2223 — Reading the Profiler Flamegraph
- child components
- In compound components, you have a special relationship where a parent component manages the overall state and behavior, while child components are specialized pieces that render specific parts of the UI.
- Lesson 1078 — The Parent + Children Relationship
- children
- The children are specialized staff—the host, server, and chef.
- Lesson 1078 — The Parent + Children RelationshipLesson 1338 — The Suspense Component API
- Class component syntax
- Class component syntax is the clearest sign:
- Lesson 326 — Documentation and Tutorials: Recognizing Outdated Content
- className
- Best when transitions are fixed design choices
- Lesson 1958 — Adding transition Property to React Components
- Cleaner components
- Less noise from optimization hooks means easier-to-read code
- Lesson 1513 — Long-Term Impact on React Development
- Cleaner URLs
- /dashboard is simpler than /dashboard/home
- Lesson 1836 — Index Routes: Default Child Content
- cleanup function
- A cleanup function is an optional function you can return from a useEffect.
- Lesson 550 — What Cleanup Functions Are
- Client state
- Client state is fundamentally different:
- Lesson 1704 — Server State vs Client State Separation
- Client-side rendering
- Think of it like a restaurant: Client-side rendering is ordering ingredients delivered to your home—you cook the meal yourself.
- Lesson 1630 — What Server-Side Rendering Actually Means
- closure
- The function captures all the variables it references at that moment — this is called a closure.
- Lesson 883 — Stale Closures in Memoized Functions
- Co-locating
- Co-locating means keeping multiple components in the same file.
- Lesson 202 — Co-locating Helper Components
- Co-location
- Co-location means placing your context provider as close as possible to the subtree that actually needs it.
- Lesson 841 — Co-locating Context with Its Consumers
- Cognitive load
- Cognitive load is the mental effort required to understand code.
- Lesson 745 — The Cognitive Load of Many useState Calls
- Cognitive overhead
- Readers must understand why something is memoized
- Lesson 2283 — The Trap of Memoizing Everything
- Colocation
- Colocation means keeping files that belong together physically close in your folder structure.
- Lesson 209 — Colocating Tests and Styles with Components
- Color-coded flame graphs
- gray means fast, yellow/red means slow
- Lesson 70 — Profiler Tab: Recording Performance Sessions
- Combinations
- Show banner when both isLoggedIn and hasBanner are true
- Lesson 1143 — Conditional Rendering of Prop Content
- commit
- In React profiling terminology, a commit represents a single render pass—from the moment React starts calculating what needs to change through to when those changes are actually applied to the DOM.
- Lesson 2211 — Understanding Commit Information
- Comparing
- The director checks if this take differs from the last one
- Lesson 411 — Render Does Not Mean DOM Update
- Complex child hierarchies
- Deep nesting means more measurements
- Lesson 1987 — Layout Animation Performance
- component
- The React component to render when this route matches
- Lesson 1876 — Defining Routes with createRoute
- component composition
- This is called component composition, and it's the fundamental pattern for building React applications.
- Lesson 182 — Components Can Call Other Components
- Component name
- The actual function or class name from your code
- Lesson 68 — Components Tab: Inspecting the Component Tree
- Component state
- Show errorMessage prop only when hasError is true
- Lesson 1143 — Conditional Rendering of Prop Content
- Component-level
- Component-level is for truly independent widgets that don't distract when loading separately.
- Lesson 1383 — Suspense Boundary Placement Patterns
- Components that didn't need the data
- A component using only user.name from context still re-renders when user.preferences changes
- Lesson 2322 — Measuring Context Performance Impact
- Composition
- Composition is like handing someone a locked suitcase—they just carry it without needing to know the contents.
- Lesson 274 — Preview of Solutions: Composition
- Compound Components
- The consumer controls which pieces to use and their order
- Lesson 1153 — What is Inversion of Control in React?
- Conditional rendering logic
- If a UserProfile should only show an "Edit" button when isOwner={true}, verify that button appears in one case and is absent in the other.
- Lesson 2184 — Unit Tests for Component Logic
- Consumer
- Consumer is how components originally accessed that value (before hooks).
- Lesson 789 — The Context Object Structure
- consumer-provided reducer override
- In the State Reducer pattern, the consumer-provided reducer override is where the magic happens.
- Lesson 1177 — Consumer-Provided Reducer Override
- container
- Imagine a restaurant kitchen: the container is like the chef who handles all the recipe logic, ingredient prep, and cooking decisions.
- Lesson 191 — Container and Presentational ComponentsLesson 2043 — The render Function from RTL
- Context
- Context is XState's solution: an object that lives inside your machine, traveling alongside your finite states.
- Lesson 1754 — Context: Extended State in Machines
- Context's limit
- No built-in selectors means you can't subscribe to part of an object without re-rendering.
- Lesson 1718 — Zustand vs Context vs Redux: The Tradeoffs
- controlled component
- A controlled component is one where React state is the single source of truth for the component's current value.
- Lesson 450 — What Makes a Component 'Controlled'
- controlled text input
- A controlled text input is an <input> element whose value is explicitly managed by React state.
- Lesson 455 — Controlled Text Inputs
- Core functionality
- The main feature your app is built around (e.g., posting content, booking appointments)
- Lesson 2183 — E2E Tests Cover Critical User Journeys
- Core Web Vitals
- Google's Core Web Vitals are three standardized metrics that capture the moments users care about most:
- Lesson 2258 — Core Web Vitals: LCP, FID, CLS
- createBrowserRouter
- createBrowserRouter is the newer function-based approach that creates a router object before rendering.
- Lesson 1844 — createBrowserRouter vs BrowserRouter
- CSS Modules
- CSS Modules are regular CSS files with a twist: the build tool (Webpack, Vite, etc.) transforms every class name into a unique identifier.
- Lesson 1900 — What CSS Modules Are
- currentTarget
- currentTarget is the element you attached the handler to.
- Lesson 2354 — The currentTarget vs target Distinction
- custom hook
- A custom hook is just a JavaScript function with two distinguishing characteristics:
- Lesson 958 — What Makes a Custom Hook
D
- Data fetching with Suspense
- Data fetching with Suspense is the tricky part.
- Lesson 1346 — The Suspense-Ready Ecosystem
- Date stamps matter
- Posts from 2018 or earlier are almost certainly pre-hooks. Even 2019 content might be outdated depending on the publish month (hooks released February 2019).
- Lesson 326 — Documentation and Tutorials: Recognizing Outdated Content
- Debouncing
- Debouncing means waiting until the user stops typing for a brief moment (say, 300ms) before actually updating state.
- Lesson 477 — Mitigating Cost: Debouncing State Updates
- Debugging
- Temporarily disable optimization to isolate whether the compiler is causing issues
- Lesson 1507 — The 'use memo' Directive (Opt-Out)
- Declaration merging
- Declaration merging is interface's superpower.
- Lesson 2330 — Props Interface vs Type Alias
- dependency array
- The dependency array is the optional second argument to useEffect:
- Lesson 536 — What is the Dependency Array?
- Depth harms clarity
- /app/workspace/project/settings/billing/history is exhausting
- Lesson 1842 — When to Nest vs Flatten Routes
- Derived state
- Derived state is any value that can be computed directly from existing props or state, rather than stored in its own separate state variable.
- Lesson 663 — What is Derived State?
- dirty checking
- Behind the scenes, Angular used a technique called dirty checking.
- Lesson 21 — Angular 1.x: Two-Way Binding and Digest Cycles
- discriminated union
- A discriminated union is a TypeScript pattern where you define multiple specific types, each with a unique literal value in a common property (usually type).
- Lesson 762 — TypeScript: Discriminated Unions for Actions
- DispatchContext
- Think of a restaurant: the StateContext is the menu board that changes daily (you check it to see what's available), while DispatchContext is the ordering counter—it never moves.
- Lesson 778 — Creating the Context Pair: State and Dispatch
- Domain knowledge
- You know a complex calculation is stable based on business logic the compiler can't understand
- Lesson 1508 — Compiler vs Manual: Performance Comparison
- Dot notation
- Quick access, fewer properties, or when the item name adds clarity (user.email is self-documenting).
- Lesson 143 — Accessing Item Data in .map()
- Drilling
- Drilling is like telling each person in a chain exactly what's inside so they can repack it.
- Lesson 274 — Preview of Solutions: Composition
- Dropdowns
- A <Dropdown> manages open/closed state. The <DropdownTrigger> needs to toggle it. The <DropdownMenu> needs to read it. The <DropdownItem> components might need to close the dropdown when clicked.
- Lesson 1087 — When to Use This Pattern
E
- early return
- An early return means checking for a condition at the start of your component and returning immediately if it's met.
- Lesson 186 — Early Returns for Conditional Logic
- ease
- The easing function (e.g., "easeIn", "easeOut", "linear")
- Lesson 1970 — The transition Prop: Controlling Animation Timing
- Easier to debug
- The value is right there where you can see it
- Lesson 653 — The Fix: Compute During Render
- Easier to reason about
- The data lives next to the logic that uses it
- Lesson 1680 — The Local-First Principle
- effect
- An effect is code that runs because something changed and needs to stay synchronized.
- Lesson 657 — Events vs Effects: The Fundamental Distinction
- Effects
- Effects are the cleaning crew who work after service ends
- Lesson 675 — Why useEffect is Wrong for Click Handlers
- error
- The actual error object with message and stack
- Lesson 608 — Built-In Loading, Error, and Success StatesLesson 1302 — Logging Errors to ServicesLesson 1323 — ErrorBoundary Props: fallback and FallbackComponentLesson 1739 — RTK Query: Auto-Generated Hooks
- esbuild
- esbuild is a newer transpiler written in Go, making it 10-100x faster than Babel.
- Lesson 79 — The Role of Babel and Modern Transpilers
- ESLint Plugin
- The eslint-plugin-react-compiler shows inline warnings when code patterns prevent optimization—right in your editor as you type.
- Lesson 1510 — Debugging Compiler Output
- event
- An event is code that runs because the user did something specific.
- Lesson 657 — Events vs Effects: The Fundamental Distinction
- Event handlers
- Event handlers are the line cooks who respond to orders immediately
- Lesson 535 — Why Effects are Often OverusedLesson 675 — Why useEffect is Wrong for Click Handlers
- Every component needs interactivity
- Your entire page is buttons, charts, drag-and-drop interfaces, and real-time updates
- Lesson 1652 — When to Skip SSR: SPAs and Hydration-Heavy Apps
- Exact strings
- Exact strings are strict by default—whitespace and case must match perfectly.
- Lesson 2062 — TextMatch: String, Regex, and Function
F
- fallback
- A React element to display during loading (spinners, skeletons, "Loading..." text)
- Lesson 1338 — The Suspense Component API
- Familiar API
- Vitest intentionally mirrors Jest's API (describe, it, expect), so migration is straightforward. You get modern tooling without relearning fundamentals.
- Lesson 2024 — Why Vitest Over Jest for Modern React
- Faster parsing
- The browser processes less code upfront
- Lesson 1384 — What Code Splitting Is and Why It Matters
- Feature-specific components
- Feature-specific components are like specialized tools (a sushi rolling mat, pasta maker) that only matter for certain recipes—those stay near where you use them.
- Lesson 63 — The Components Folder: Shared vs Feature-Specific
- Filtered lists
- You have an array in state and a search term—the filtered results are derived
- Lesson 663 — What is Derived State?
- Flexible ordering
- The component controls layout, not insertion order
- Lesson 1130 — Props as Slots: The Basic Pattern
- formAction
- A wrapped version of your action function that you pass to a form's action prop. This wrapper handles the state transitions automatically.
- Lesson 1484 — The useActionState Signature
- full E2E tests
- But in React apps, pure unit tests (testing components in complete isolation) create brittle test suites that break during refactors, while full E2E tests are slow and flaky.
- Lesson 2135 — The Integration Test Sweet Spot
- Full failure
- Full failure is appropriate for critical features (checkout forms, authentication).
- Lesson 1319 — Degraded UI vs Full Failure
- Function Children
- The consumer decides how to transform data into UI
- Lesson 1153 — What is Inversion of Control in React?
- function component
- A function component is simply a JavaScript function that returns JSX.
- Lesson 177 — What is a Function Component?
- functional update syntax
- This is called functional update syntax.
- Lesson 370 — Functional Update Syntax
G
- generic context factory
- A generic context factory is a function that takes a type parameter and returns everything you need for a fully-typed context: the provider component, the consumer hook, and proper type safety.
- Lesson 2379 — Generic Context Factories
- getByTestId
- getByTestId is your escape hatch when semantic locators aren't practical.
- Lesson 2164 — Locators: Finding Elements the Right Way
- Granularity
- The compiler can memoize at a finer level than you'd reasonably do by hand. It might memoize individual JSX expressions or small computation branches, which would feel excessive to write manually.
- Lesson 1508 — Compiler vs Manual: Performance Comparison
- guard clause
- A guard clause is a condition that checks for a special case and exits early.
- Lesson 128 — Early Returns for Guard Clauses
H
- Hard to test
- Mocking timings, race conditions, and cleanup in tests is painful.
- Lesson 605 — The Problem with Manual useEffect Data Fetching
- Headless
- Headless is the philosophy that ties these patterns together—maximum logic reuse, zero style opinions.
- Lesson 1183 — What 'Headless' Means: Logic Without Styling
- High-frequency cascades
- A parent component re-renders 10+ times per second, triggering expensive child tree updates
- Lesson 2237 — Tracking vs Fixing: When to Act
- High-frequency updates
- A WebSocket connection updating every 100ms will hammer all context consumers, even those displaying static data derived from other parts of the context value.
- Lesson 2257 — Comparing Context Overhead to Alternatives
- Highly Interactive Apps
- Think Figma, code editors, or complex dashboards. These apps are tools, not content. Users expect to wait briefly while the app loads, then enjoy zero-latency interactions. Every click, drag, and keystroke happens instantly because the entire interface is already hydrated.
- Lesson 1673 — CSR Trade-offs: Interactivity vs Initial Load
- Hiring and Collaboration
- React developers are abundant. If you're building a team, you'll find far more candidates with React experience than Svelte or Solid. This isn't about React being "better"—it's about market reality.
- Lesson 30 — Ecosystem Size as a Decision Factor
- Hook order or presence
- Whether useState or useReducer is used
- Lesson 2115 — What Are Implementation Details?
- Hot reloading
- Class methods are harder to hot-swap during development without losing state
- Lesson 311 — Classes Confuse Both People and Machines
I
- imperative choreography
- GSAP timelines (gsap.timeline()) let you script animations like a movie director: "Element A enters, waits 0.5s, then B and C animate together while A continues, pause here for user input, then resume." This imperative choreography is GSAP's superpower.
- Lesson 2008 — When GSAP Beats Framer Motion: Timeline Complexity
- Implementation details
- Implementation details are the internal mechanics of how your component works—things like state variable names, hook calls, private functions, effect dependencies, and component structure.
- Lesson 2115 — What Are Implementation Details?
- index route
- An index route is a special route that renders by default when only the parent path matches.
- Lesson 1836 — Index Routes: Default Child Content
- Initial value
- The argument to useState(initialValue) replaces what you assigned in the constructor
- Lesson 316 — From constructor State to useState
- initialState
- The starting value for your state before any action runs. This could be an empty object, null, or any initial data structure you need.
- Lesson 1484 — The useActionState Signature
- Inline arrow functions
- Inline arrow functions are convenient when you need to pass arguments: () => handleClick(id)
- Lesson 234 — Inline Arrow Functions vs Stable References
- Installation
- Installation is straightforward via npm or yarn:
- Lesson 1769 — Installation and QueryClient Setup
- interaction-based lazy loading pattern
- The interaction-based lazy loading pattern means loading these components only when the user clicks, hovers, or otherwise signals intent.
- Lesson 1404 — The Interaction-Based Lazy Loading Pattern
- isPending
- True while the request is in-flight
- Lesson 1484 — The useActionState SignatureLesson 1792 — useMutation Basics
- isRefetching
- True whenever a fetch is happening in the background while cached data is already available
- Lesson 1791 — The isRefetching Flag
- It's infrequent
- A component that re-renders once on route change doesn't need memoization
- Lesson 2237 — Tracking vs Fixing: When to Act
K
L
- layout route
- A layout route is a parent route that doesn't render a specific page itself—instead, it renders shared UI (like a header or sidebar) and uses <Outlet /> to display whichever child route is currently active.
- Lesson 1834 — Creating a Layout Route with Outlet
- Lazy import
- You wait until the exact moment the component is needed (like when a modal opens). This keeps your initial bundle minimal, but users experience a brief loading delay.
- Lesson 1410 — The Prefetch/Import Timing Tradeoff
- Lazy init
- Lazy init is choosing expensive materials only once when you build the foundation (mount)
- Lesson 393 — Lazy Init vs useMemo: Different Tools
- Lifting state up
- Lifting state up means hoisting state to <App>, then threading props through multiple layers that don't care about them.
- Lesson 1700 — The Problem of Shared State Across Distant Components
- List animations
- Items move naturally when others are added/removed
- Lesson 1984 — Layout Animations with layout Prop
- loader
- A loader is a function you attach to a route definition.
- Lesson 1843 — The Data Router Paradigm Shift in v6.4
- Local context
- Local context means wrapping only a specific subtree of components with a provider, rather than your entire application.
- Lesson 817 — Local Context for Component Subtrees
- Logging priority
- Page errors are high-priority, widget errors are informational
- Lesson 1316 — Contextual Error Messages by Location
- Long-Term Stability
- Companies invest heavily in React. Meta (Facebook) depends on it for their core products. This means the framework isn't going anywhere soon, reducing the risk that you'll need to rewrite your app in five years.
- Lesson 30 — Ecosystem Size as a Decision Factor
M
- Maintenance
- Refactoring is straightforward—just follow the chain
- Lesson 269 — When Drilling Isn't a Problem
- Maintenance burden
- Each boundary is code to write, test, and maintain. Twenty boundaries means twenty potential places for logging logic to drift out of sync.
- Lesson 1312 — Avoiding Boundary Overuse
- Marketing sites
- Your homepage, about page, pricing page—these rarely change, and when they do, a rebuild is fine
- Lesson 1677 — SSG Trade-offs: Speed vs Freshness
- Measurable performance impact
- The Profiler shows a commit taking >16ms (causing dropped frames)
- Lesson 2237 — Tracking vs Fixing: When to Act
- Memoization
- Memoization is exactly this strategy applied to computation: instead of recalculating the same result every time, you cache (store) the result the first time and return the cached version when the inputs haven't changed.
- Lesson 864 — What is Memoization?
- memoizedState
- the hook's current value (state, memo result, etc.)
- Lesson 1013 — The Fiber Tree and Hook Chains
- mouse tracker
- A mouse tracker is the classic render prop example because mouse position is stateful logic (tracking coordinates) that's completely separate from presentation (how you display those coordinates).
- Lesson 1051 — Classic Example: Mouse Position Tracker
- Multiple props
- Multiple props are being threaded through the same path
- Lesson 809 — The Prop Drilling ThresholdLesson 1686 — The Prop Drilling Pain Threshold
- Mutations
- Mutations are more powerful in TanStack Query with built-in optimistic update patterns, but require more setup than SWR's simpler approach.
- Lesson 1811 — Migration Considerations: SWR to TanStack Query
N
- name
- A string identifying this slice (e.g., "counter")
- Lesson 1732 — Slices: State + Reducers + Actions Together
- No ESLint configuration file
- If .eslintrc or eslint.config.js is missing, create one and extend the recommended React config
- Lesson 1024 — Integration with Modern Tooling (Vite, Next.js)
- No Provider
- Atoms are global, shared across the whole app
- Lesson 1727 — The Provider Component (When Needed)
- No static optimization
- Because styles are in JavaScript, build tools can't extract, deduplicate, or preload them as separate .css files.
- Lesson 1931 — Performance Tradeoffs: Runtime Style Injection
- No user impact
- If users can't perceive the slowness, your time is better spent elsewhere
- Lesson 2237 — Tracking vs Fixing: When to Act
- Non-critical
- The app remains useful even if this feature is temporarily down
- Lesson 1310 — Feature-Level Boundaries
- normalizer
- Defines how whitespace/casing is normalized before matching
- Lesson 2063 — Query Options: exact, normalizer, hidden
O
- Observable
- This is when you'd actually see changes appear in the browser
- Lesson 412 — The Commit Phase: Applying Changes to the DOM
- onAllReady
- Every single dish is plated and ready. Nothing's in the kitchen anymore.
- Lesson 1636 — The onShellReady and onAllReady Callbacks
- onKeyDown
- Fires when a key is first pressed down
- Lesson 2356 — Keyboard Event Handlers: KeyboardEvent<HTMLInputElement>
- onKeyUp
- Fires when a key is released
- Lesson 2356 — Keyboard Event Handlers: KeyboardEvent<HTMLInputElement>
- onShellReady
- The table is set, the ambiance is ready, guests can sit down. The appetizers are still cooking, but the experience can begin.
- Lesson 1636 — The onShellReady and onAllReady Callbacks
- Opt-in children
- Opt-in children means you only install doors where they belong, making the architecture's intent obvious at a glance.
- Lesson 2394 — Children: Opt-In vs Implicit
P
- parent
- Think of it like a restaurant: the parent is the restaurant manager who coordinates reservations, seating arrangements, and overall flow.
- Lesson 1078 — The Parent + Children Relationship
- Parent has data the content needs
- A list component passing each item's data to render functions
- Lesson 1149 — When Render Props Win: Dynamic Behavior
- path
- The URL segment for this route (like "/about" or "/users/$userId")
- Lesson 1876 — Defining Routes with createRoute
- Performance
- Re-rendering is usually fast, but it's not free. Batching prevents unnecessary work—React only recalculates your component tree and updates the DOM once instead of multiple times.
- Lesson 151 — Keys Preserve Component IdentityLesson 417 — What is Batching and Why It Matters
- Performance cost
- Stringifying large objects on every render is expensive
- Lesson 639 — JSON.stringify as a Last Resort
- Performance profiling
- Measuring actual impact by comparing optimized vs unoptimized
- Lesson 1507 — The 'use memo' Directive (Opt-Out)
- Prefetching
- Prefetching means loading chunks in advance during idle time.
- Lesson 2290 — Prefetching Split Chunks
- presentational component
- The presentational component is like the waiter who beautifully plates and serves the food—they don't cook, they just present what they're given.
- Lesson 191 — Container and Presentational Components
- Preserving return-to URLs
- Preserving return-to URLs means remembering their original destination and completing their interrupted trip.
- Lesson 1870 — Preserving Return-To URLs
- Product pages
- Individual product details that are stable
- Lesson 1677 — SSG Trade-offs: Speed vs Freshness
- Profiler
- The Profiler is a tab in React DevTools (the browser extension) that records your app's rendering behavior.
- Lesson 70 — Profiler Tab: Recording Performance SessionsLesson 416 — Visualizing Renders with React DevTools Profiler
- Progressive disclosure
- Progressive disclosure is your friend: provide sensible defaults that work out-of-the-box, but allow power users to override specific behaviors through props or slots when needed.
- Lesson 1154 — The Flexibility vs Simplicity Tradeoff
- progressive enhancement
- This approach is called progressive enhancement: start with something that works everywhere (basic HTML), then optionally add JavaScript for a nicer experience.
- Lesson 32 — Simple Forms and Progressive EnhancementLesson 1086 — Advantages Over Monolithic ComponentsLesson 1611 — The action Prop on Forms
- Progressive hydration on interaction
- Progressive hydration on interaction means delaying hydration until the user actually tries to interact with that component—clicking a button, hovering, focusing an input, etc.
- Lesson 1649 — Progressive Hydration: Hydrating on Interaction
- Prop conditions
- Render sidebar only if showSidebar prop is true
- Lesson 1143 — Conditional Rendering of Prop Content
- prop drilling
- This tedious pattern is called prop drilling.
- Lesson 787 — What is Context and Why It Exists
- prop getter
- A prop getter is just a function that returns an object.
- Lesson 1166 — Prop Getter Basics: Returning an Object
- Prop getters
- Prop getters are functions that return a pre-configured object of props.
- Lesson 1164 — What is the Prop Getters Pattern?
- Props
- Props are like instructions from a parent: "Wear this jacket today." The child doesn't get to change what jacket was chosen.
- Lesson 228 — Props vs State: Who Owns the Data
- Provider
- Provider is a component that wraps part of your tree and supplies a value.
- Lesson 789 — The Context Object Structure
- pure function
- A pure function is predictable: given the same inputs, it always returns the same result.
- Lesson 179 — Components are Pure Functions of Props
Q
R
- Ranked chart
- A sorted list of slowest components first
- Lesson 416 — Visualizing Renders with React DevTools Profiler
- Rarely changing data
- If props update once per user session, drilling is simpler than any state solution.
- Lesson 2257 — Comparing Context Overhead to Alternatives
- React DevTools Profiler
- The React DevTools Profiler is your measurement tool.
- Lesson 844 — Measuring Impact with React DevTools Profiler
- react-virtualized
- react-virtualized is the older, feature-rich library.
- Lesson 2296 — React Window vs React Virtualized
- react-window
- react-window is the newer, lighter, and more focused library.
- Lesson 2296 — React Window vs React Virtualized
- ReactElement
- Rarely used explicitly—it's the technical type behind JSX, but JSX.Element or ReactNode are clearer choices.
- Lesson 1135 — Type Safety for Slot PropsLesson 2338 — Typing Component Return Values
- ReactNode
- The broadest type, accepts anything React can render: JSX elements, strings, numbers, arrays, fragments, null, undefined, and booleans. This is your go-to for most slot props.
- Lesson 1135 — Type Safety for Slot PropsLesson 1145 — Type Safety with JSX Props
- Readability
- Multiple variables are often clearer
- Lesson 384 — Performance: Object vs Multiple Variables
- Receives
- The initialArg (second parameter to useReducer)
- Lesson 773 — init Function Signature and Arguments
- recipe
- A recipe is vanilla-extract's answer to runtime style variants.
- Lesson 1940 — Dynamic Runtime Styles with Recipes
- reconciliation
- Instead, React uses a process called reconciliation — a smart comparison algorithm (also called "diffing") that looks at the old virtual DOM tree and the new virtual DOM tree side-by-side to find the minimal set of changes needed.
- Lesson 13 — Reconciliation: React's Diffing AlgorithmLesson 171 — How Stable Keys Enable ReconciliationLesson 408 — The Virtual DOM (Reconciliation)
- reducer
- A reducer is a pure function that takes two arguments—the current state and an action object—and returns the next state.
- Lesson 754 — Reducer Function: (state, action) => newState
- reducers
- An object where each key becomes both a reducer case AND an auto-generated action creator
- Lesson 1732 — Slices: State + Reducers + Actions Together
- ref
- A ref is like a box that holds a mutable value in its .current property.
- Lesson 398 — useRef for Mutable Current Values
- Refs
- Refs are like quietly updating a Post-it note on your desk.
- Lesson 498 — Refs Don't Trigger Re-renders
- Removing items from lists
- If a list item component is removed, any state it held is gone forever.
- Lesson 363 — Unmounting Destroys State
- render phase
- In the previous lesson, you learned that the render phase is where React calculates what needs to change by comparing the old and new virtual DOM.
- Lesson 415 — Why Renders Are Usually FastLesson 428 — Render Phase: Pure CalculationLesson 429 — Commit Phase: Applying Changes to the DOMLesson 431 — Why Effects Can't Run During Render
- render prop
- A render prop is a function that you pass as a prop to a component, and that component calls your function to determine what it should render.
- Lesson 275 — What is a Render Prop?Lesson 276 — Basic Render Prop ImplementationLesson 1042 — What is a Render Prop?
- Render props
- Render props are dynamic: you pass in a function that the component calls with data.
- Lesson 1136 — Slots vs Render Props: The Tradeoff
- Resetting
- Resetting means clearing the error state so the component tree can try rendering again.
- Lesson 1305 — Resetting Error Boundaries
- Resumability
- Resumability is Qwik's radical alternative: instead of re-running components on the client, Qwik serializes the entire application state (component boundaries, event listeners, closures) directly into the HTML.
- Lesson 1651 — Resumability: Qwik's Alternative to Hydration
- Reusable
- Clear purpose means clear use cases
- Lesson 1002 — The Cohesion Test: Does the Hook Have a Clear Purpose?
- Review
- Changes to page interactions are visible in Page Object diffs, not scattered across test files
- Lesson 2199 — Page Objects in CI: Keeping Tests DRY
- right now
- Whatever value that Provider has in its value prop right now is what useContext returns to you.
- Lesson 801 — useContext Returns the Current Value
- route context
- In TanStack Router, route context is a way to pass shared, typed data down through your route hierarchy.
- Lesson 1883 — Route Context and beforeLoad
- Route-level splitting
- Route-level splitting means creating separate bundles for each major route in your application.
- Lesson 1423 — Route-Level Splitting: The Sweet Spot
- Runtime safety
- Clear error messages if components are used incorrectly
- Lesson 1094 — Type-Safe Context for Compound Components
S
- Scenario A
- A simple text counter component renders 50 times during an animation. Each render takes 0.5ms. Total time: 25ms.
- Lesson 2270 — Measuring Render Count vs Render Time
- Scenario B
- A complex data table renders once when a user clicks "Load More". That single render takes 200ms.
- Lesson 2270 — Measuring Render Count vs Render Time
- Server Actions
- Server Actions are optimized for mutations triggered by React components—form submissions, button clicks, or any user interaction originating from your UI.
- Lesson 1609 — When to Use Server Actions vs API Routes
- Server-first data flow
- Server-first data flow means your data originates at the top of your tree in Server Components that run on the backend.
- Lesson 1574 — The New Mental Model: Server-First Data Flow
- shallow immutability
- This is called shallow immutability—the reference is protected, but the nested data isn't.
- Lesson 229 — Shallow Immutability: Objects and Arrays
- Shared components
- Shared components are like basic utensils (knives, spoons, measuring cups) that you use everywhere—they belong in a common drawer.
- Lesson 63 — The Components Folder: Shared vs Feature-Specific
- Shared element transitions
- An image smoothly transitions from thumbnail to full-screen using layoutId
- Lesson 2010 — Framer Motion for Component-Driven UI Animations
- side effect
- A side effect is any operation that reaches outside your component's render calculation.
- Lesson 524 — What is a Side Effect?
- Simple URLs suffice
- Sometimes /checkout is clearer than nesting under /store/cart/checkout
- Lesson 1842 — When to Nest vs Flatten Routes
- Simpler mental model
- Data routers are powerful but conceptually lighter than TanStack's full type-safe approach
- Lesson 1885 — When TanStack Router Fits vs React Router
- single source of truth
- The single source of truth is the official scorekeeper's record.
- Lesson 463 — What 'Single Source of Truth' Means
- size
- The height (or width for horizontal lists) of this item in pixels
- Lesson 1280 — The Virtual Items Array
- Slots
- Slots are static: you pass in pre-built JSX elements as props.
- Lesson 1136 — Slots vs Render Props: The TradeoffLesson 1153 — What is Inversion of Control in React?
- Smaller bundle size matters
- TanStack Query is lighter and has no GraphQL parser overhead
- Lesson 1830 — When Apollo Fits vs TanStack Query
- Source maps
- Source maps are special files that map minified code back to your original source.
- Lesson 1334 — Source Maps for Readable Stack Traces
- Specific component types
- Specific component types are the most restrictive — they enforce that a particular component is used.
- Lesson 1135 — Type Safety for Slot Props
- Speed perception matters
- Social feeds, chat apps, collaborative tools where instant feedback is expected
- Lesson 1802 — Pessimistic vs Optimistic: When to Choose
- SSR
- SSR is ordering a fully prepared meal—it arrives ready to eat, though you might add garnish (interactivity) after.
- Lesson 1630 — What Server-Side Rendering Actually MeansLesson 1673 — CSR Trade-offs: Interactivity vs Initial Load
- Stable
- They don't change between renders (assuming parent and child IDs are stable)
- Lesson 1249 — Composite Keys for Nested Lists
- stable key
- A stable key is one that never changes for a given item, no matter what happens to the list around it.
- Lesson 170 — What Makes a Key 'Stable'
- Stable references
- Stable references are better when no arguments are needed: handleClick
- Lesson 234 — Inline Arrow Functions vs Stable References
- start
- The absolute position (in pixels) from the top of the virtual container where this item should begin
- Lesson 1280 — The Virtual Items Array
- State
- State is like announcing something over a loudspeaker—everyone hears it, everyone reacts, the whole room responds.
- Lesson 228 — Props vs State: Who Owns the DataLesson 498 — Refs Don't Trigger Re-rendersLesson 1484 — The useActionState Signature
- State domains
- State domains are groups of related data that:
- Lesson 839 — Identifying Independent State Domains
- State persistence
- A reused component keeps its local state
- Lesson 151 — Keys Preserve Component Identity
- StateContext
- Think of a restaurant: the StateContext is the menu board that changes daily (you check it to see what's available), while DispatchContext is the ordering counter—it never moves.
- Lesson 778 — Creating the Context Pair: State and Dispatch
- status
- a string ('pending', 'error', 'success') for more detailed states
- Lesson 608 — Built-In Loading, Error, and Success States
- Suspense boundary
- A Suspense boundary is a dividing line in your component tree.
- Lesson 1637 — Suspense Boundaries in Streaming SSR
- switch statement
- While you could use a chain of if-else statements, the switch statement is the standard pattern that makes reducers clean and scannable.
- Lesson 760 — Switch Statement Pattern
T
- Tabs
- A <TabList> needs to know which tab is active. Each <Tab> needs that same information. The <TabPanel> components also need to know. Rather than passing activeTab and setActiveTab to each piece separately, Compound Components let them share this state implicitly.
- Lesson 1087 — When to Use This Pattern
- tagged template literals
- styled-components leverages a special JavaScript feature called tagged template literals.
- Lesson 1923 — styled-components Basics: Tagged Template Literals
- target
- target is the element that actually triggered the event.
- Lesson 2354 — The currentTarget vs target Distinction
- Testability
- Easy to test because behavior is consistent
- Lesson 230 — Props Read-Only Rule and Pure Components
- Testable
- Single responsibility is easier to verify
- Lesson 1002 — The Cohesion Test: Does the Hook Have a Clear Purpose?
- theme contract
- In vanilla-extract, a theme contract is like a blueprint that defines which design tokens exist (colors, spacing, typography) without initially specifying their values.
- Lesson 1936 — Type-Safe Theme Contracts
- They also create false positives
- A component can have perfect internal state but render nothing to the user—and your detail-focused test would pass.
- Lesson 2034 — Why RTL Discourages Testing Details
- Time slicing
- Time slicing is React's solution: instead of rendering everything in one continuous block, React breaks the work into small chunks (typically 5ms each).
- Lesson 1459 — Time Slicing: Yielding Control Back to the Browser
- Total duration
- The cumulative time spent rendering that component across all renders
- Lesson 2215 — Component Render Count and Duration Totals
- Tree-shaking
- Unused methods in classes are harder to detect and remove
- Lesson 311 — Classes Confuse Both People and Machines
- tRPC router
- A tRPC router is where you define all your API endpoints (called "procedures") on the server.
- Lesson 1814 — Creating a tRPC Router on the Server
- Truly global state
- Truly global state is data that a large portion of your component tree needs to access, regardless of where those components sit in the hierarchy.
- Lesson 810 — Context for Truly Global State
- type
- The action type (e.g., InputKeyDownEnter, ItemClick)
- Lesson 763 — Action Objects: type and payloadLesson 1180 — State Reducer in Downshift
U
- uncontrolled components
- For these cases, uncontrolled components are the perfect fit.
- Lesson 507 — Simple Forms Without Real-Time Validation
- uncontrolled components with submit-time reading
- In these cases, uncontrolled components with submit-time reading are more appropriate than controlled components that update state on every change.
- Lesson 523 — When Submit-Time Reading is Appropriate
- Unique
- The combination prevents collisions across all nesting levels
- Lesson 1249 — Composite Keys for Nested Lists
- Unmount
- Unmount is when React removes the component from the screen entirely.
- Lesson 296 — The Three Lifecycle Phases: Mount, Update, Unmount
- useGSAP hook
- A React-safe wrapper for GSAP code with automatic cleanup
- Lesson 2001 — Installing GSAP and Basic Setup in React
- useMemo
- useMemo is reusing cleaned windows instead of washing them again every day (re-renders)
- Lesson 393 — Lazy Init vs useMemo: Different Tools
- Utility functions
- Utility functions are plain JavaScript functions that perform calculations or transformations without any React features.
- Lesson 970 — Custom Hooks vs Utility Functions
V
- Vite Integration
- If you're already using Vite (which powers modern React tooling like Create-React-App alternatives), Vitest reuses your exact Vite config. No duplicate configuration for TypeScript, path aliases, CSS modules, or environment variables. Your app code and test code are processed identically.
- Lesson 2024 — Why Vitest Over Jest for Modern React
- Vitest
- Vitest is your test runner—it finds, executes, and reports on your tests.
- Lesson 2025 — Installing Vitest and Testing Dependencies
W
- Web Components
- While React provides a component-based architecture through JavaScript, Web Components are built directly into browser standards.
- Lesson 27 — Web Components: Standards-Based Approach
- Webpack
- Webpack is a module bundler—it takes all your separate JavaScript files, CSS, images, and other assets and combines them into optimized bundles that browsers can load efficiently.
- Lesson 54 — Webpack from Scratch
- When to annotate explicitly
- If the inferred type is too broad (like string instead of a literal type), or you want to enforce a specific shape:
- Lesson 2388 — Typing useMemo and useCallback
- Why JSX exists
- Writing nested UIs this way is brutally verbose
- Lesson 76 — JSX Without a Transpiler: The Raw API
- wrapper component
- A wrapper component is a component whose primary job is to "wrap around" other components and add something extra — like styling, error handling, or common layout structure.
- Lesson 193 — Wrapper Components for Shared BehaviorLesson 252 — Wrapper Components with Children
Y
- You're already using TanStack Query
- The integration is seamless and eliminates boilerplate
- Lesson 1885 — When TanStack Router Fits vs React Router
- You're testing integration points
- The value is in how pieces work together
- Lesson 2083 — When NOT to Mock: Testing Philosophy
Z
- Zero-runtime
- Zero-runtime means your styling solution extracts all CSS at build time and ships static .css files to the browser—no JavaScript executes at runtime to generate, inject, or manage styles.
- Lesson 1933 — What Zero-Runtime Means
- Zod
- Zod is a TypeScript-first schema validation library.
- Lesson 1225 — Schema Validation with Zod Resolver