mirror of
https://github.com/hanzoai/skills.git
synced 2026-11-19 00:47:36 +00:00
hanzoskills.com/llms.txt now opens with the install line, the API reference index and the company index, so an agent that lands on any one of the three can find the rest. robots.txt claimed 537 documents while llms.txt counts 920. The number is gone from robots.txt; llms.txt derives it. public/ is regenerated from scripts/site.py, which it had fallen behind: the copy-prompt menu and agent bar were in the generator and not in the committed pages. tests/site.mjs passes against the result. Co-authored-by: Hanzo Dev <[email protected]>
790 lines
31 KiB
HTML
790 lines
31 KiB
HTML
<!doctype html>
|
|
<html lang="en"><head>
|
|
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
|
|
<title>frontend-react-component-patterns</title>
|
|
<meta name="color-scheme" content="dark">
|
|
<style>
|
|
/* Committed to one visual world: a dark instrument panel. No light variant —
|
|
the dot field and the hairline rules only read on black, and a naive
|
|
inversion would wash both out. Every colour is painted explicitly so the page
|
|
never borrows a host background. */
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
|
|
|
|
:root{
|
|
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
|
|
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
|
|
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
|
|
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
|
|
--font-zen-pixel-square:'Zen Pixel Square',monospace;
|
|
--mono:var(--font-zen-mono);
|
|
--sans:var(--font-zen-sans);
|
|
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
|
|
--r:999px; --r-soft:14px;
|
|
}
|
|
*{box-sizing:border-box}
|
|
html{-webkit-text-size-adjust:100%}
|
|
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
|
|
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
|
|
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
|
|
|
|
/* The dot field. A halftone made of one repeating radial-gradient, faded out
|
|
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
|
|
/* No overflow clip here: the dot field is inset to the box already, and a clip
|
|
would cut off the copy-prompt menu. */
|
|
.hero{position:relative;border-bottom:1px solid var(--line)}
|
|
.hero::before{content:"";position:absolute;inset:0;
|
|
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
|
|
background-size:7px 7px;
|
|
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
pointer-events:none}
|
|
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
|
|
|
|
nav{border-bottom:1px solid var(--line)}
|
|
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
|
|
justify-content:space-between;align-items:center;gap:1rem}
|
|
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--ink);text-decoration:none;
|
|
display:inline-flex;align-items:center;gap:.6rem}
|
|
.brand i{font-style:normal;color:var(--faint)}
|
|
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
|
|
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--soft);text-decoration:none}
|
|
nav a.up:hover{color:var(--ink)}
|
|
|
|
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
|
|
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
|
|
h1 em{font-style:normal;color:var(--faint)}
|
|
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
|
|
|
|
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
|
|
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
|
|
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
|
|
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
|
|
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
|
|
line-height:1.2;font-weight:400}
|
|
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
|
|
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
|
|
.btn.solid:hover{background:#d8d8d4}
|
|
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
|
|
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
|
|
|
|
/* Copy-prompt selector. Each row copies the prompt for its own target. */
|
|
.copy{position:relative;display:inline-flex}
|
|
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
|
|
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
|
|
padding:.4rem;display:flex;flex-direction:column;
|
|
box-shadow:0 12px 32px rgba(0,0,0,.75)}
|
|
.menu[hidden]{display:none}
|
|
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
|
|
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
|
|
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
|
|
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
|
|
white-space:nowrap}
|
|
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
|
|
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
|
|
.mi:hover .mark{color:var(--ink)}
|
|
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
|
|
letter-spacing:.1em;text-transform:uppercase}
|
|
|
|
/* Works-with bar: one scrolling row, name and mark per agent. */
|
|
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
|
|
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
|
|
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
|
|
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
|
|
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
|
|
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
|
|
display:flex;align-items:center}
|
|
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
|
|
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
|
|
-webkit-overflow-scrolling:touch;
|
|
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
|
|
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
|
|
.bar::-webkit-scrollbar{display:none}
|
|
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
|
|
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
|
|
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
|
|
text-decoration:none;background:var(--ground)}
|
|
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
|
|
.agent .mark{width:.95rem;height:.95rem}
|
|
|
|
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
|
|
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
|
|
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
|
|
p{margin:0 0 1rem;max-width:70ch}
|
|
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
|
|
li{margin:.22rem 0}
|
|
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
|
|
text-decoration-color:var(--line-hi)}
|
|
a:hover{text-decoration-color:var(--ink)}
|
|
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
|
|
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
|
|
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
|
|
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
|
|
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
|
|
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
|
|
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
|
|
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
|
|
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
|
|
display:block;overflow-x:auto}
|
|
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
|
|
|
|
.curl{display:block;background:var(--panel);border:1px solid var(--line);
|
|
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
|
|
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
|
|
white-space:pre;line-height:1.9}
|
|
.curl b{color:var(--ink);font-weight:400}
|
|
.curl i{font-style:normal;color:var(--faint)}
|
|
|
|
/* index */
|
|
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
|
|
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
|
|
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
|
|
#q:focus{outline:none;border-color:var(--soft)}
|
|
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
|
|
text-transform:uppercase;margin:0 0 2rem}
|
|
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
|
|
padding-bottom:.45rem}
|
|
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
|
|
border-radius:var(--r-soft);text-decoration:none}
|
|
.row:hover{background:#0a0a0a}
|
|
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
|
|
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
|
|
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
|
|
color:var(--faint);font-size:.85rem}
|
|
footer a{color:var(--soft)}
|
|
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
|
|
margin:0 0 2rem;font-size:.85rem}
|
|
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
|
|
border-bottom:1px solid var(--line);padding-bottom:.4rem}
|
|
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
|
|
.fmap a:hover{text-decoration:underline}
|
|
.fmap div{color:var(--faint);line-height:1.5}
|
|
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
|
|
|
|
@media (max-width:640px){
|
|
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
|
|
.btns{gap:.5rem}
|
|
.btn{padding:.75rem 1.15rem;font-size:.68rem}
|
|
.copy,.copy .btn{width:100%;justify-content:center}
|
|
.menu{left:0;right:0;min-width:0}
|
|
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
|
|
.strip b{border-right:0;padding-right:0}
|
|
.bar{width:100%}
|
|
}
|
|
</style>
|
|
<link rel="alternate" type="text/markdown" href="/frontend-react-component-patterns.md">
|
|
|
|
<link rel="icon" href="/favicon.svg">
|
|
<link rel="canonical" href="https://hanzoskills.com/frontend-react-component-patterns">
|
|
</head>
|
|
<!-- Reading this with a machine? Every page here is also plain markdown.
|
|
This one: https://hanzoskills.com/frontend-react-component-patterns.md
|
|
Index: https://hanzoskills.com/llms.txt
|
|
Corpus: https://hanzoskills.com/all.md
|
|
Append .md to any path for the markdown twin. -->
|
|
<body>
|
|
<nav><div class="in">
|
|
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
|
|
<a class="up" href="/">All skills</a>
|
|
</div></nav>
|
|
|
|
<div class="wrap">
|
|
<h1>frontend-react-component-patterns</h1><p class="lede">Designing component architecture</p><h1>React Component Patterns</h1>
|
|
<p><strong>Scope</strong>: Composition patterns, custom hooks, memoization, code splitting, component organization <strong>Lines</strong>: ~320 <strong>Last Updated</strong>: 2025-10-18</p>
|
|
<h2>When to Use This Skill</h2>
|
|
<p>Activate this skill when:</p>
|
|
<ul><li>Designing component architecture</li><li>Optimizing component re-renders</li><li>Creating reusable component patterns</li><li>Building custom hooks</li><li>Implementing code splitting</li><li>Refactoring large components</li><li>Managing component state and props</li></ul>
|
|
<h2>Core Concepts</h2>
|
|
<h3>Component Types</h3>
|
|
<p><strong>Presentation Components</strong> (Dumb/Stateless):</p>
|
|
<ul><li>Display UI based on props</li><li>No business logic</li><li>No state management</li><li>Easy to test and reuse</li></ul>
|
|
<p><strong>Container Components</strong> (Smart/Stateful):</p>
|
|
<ul><li>Handle business logic</li><li>Manage state</li><li>Connect to data sources</li><li>Pass data to presentation components</li></ul>
|
|
<hr>
|
|
<h2>Composition Patterns</h2>
|
|
<h3>Children Prop Pattern</h3>
|
|
<pre><code class="lang-tsx">// Layout component using children
|
|
function Card({ children, title }: { children: React.ReactNode; title: string }) {
|
|
return (
|
|
<div className="card">
|
|
<h2>{title}</h2>
|
|
<div className="card-body">{children}</div>
|
|
</div>
|
|
);
|
|
}
|
|
|
|
// Usage
|
|
<Card title="User Profile">
|
|
<UserAvatar />
|
|
<UserInfo />
|
|
</Card></code></pre>
|
|
<p><strong>Good for</strong>:</p>
|
|
<ul><li>Layout components</li><li>Wrappers (modals, tooltips)</li><li>Generic containers</li></ul>
|
|
<h3>Render Props Pattern</h3>
|
|
<pre><code class="lang-tsx">// Data fetcher using render prop
|
|
function DataFetcher<T>({
|
|
url,
|
|
render
|
|
}: {
|
|
url: string;
|
|
render: (data: T | null, loading: boolean, error: Error | null) => React.ReactNode;
|
|
}) {
|
|
const [data, setData] = useState<T | null>(null);
|
|
const [loading, setLoading] = useState(true);
|
|
const [error, setError] = useState<Error | null>(null);
|
|
|
|
useEffect(() => {
|
|
fetch(url)
|
|
.then(res => res.json())
|
|
.then(setData)
|
|
.catch(setError)
|
|
.finally(() => setLoading(false));
|
|
}, [url]);
|
|
|
|
return <>{render(data, loading, error)}</>;
|
|
}
|
|
|
|
// Usage
|
|
<DataFetcher<User>
|
|
url="/api/users/42"
|
|
render={(user, loading, error) => {
|
|
if (loading) return <Spinner />;
|
|
if (error) return <Error message={error.message} />;
|
|
if (!user) return null;
|
|
return <UserProfile user={user} />;
|
|
}}
|
|
/></code></pre>
|
|
<p><strong>Good for</strong>:</p>
|
|
<ul><li>Sharing logic with different UI</li><li>Data fetching patterns</li><li>Animation wrappers</li></ul>
|
|
<p><strong>Modern alternative</strong>: Custom hooks (preferred in most cases)</p>
|
|
<h3>Compound Component Pattern</h3>
|
|
<pre><code class="lang-tsx">// Tabs compound component
|
|
const TabsContext = createContext<{
|
|
activeTab: string;
|
|
setActiveTab: (tab: string) => void;
|
|
} | null>(null);
|
|
|
|
function Tabs({ children, defaultTab }: { children: React.ReactNode; defaultTab: string }) {
|
|
const [activeTab, setActiveTab] = useState(defaultTab);
|
|
|
|
return (
|
|
<TabsContext.Provider value={{ activeTab, setActiveTab }}>
|
|
<div className="tabs">{children}</div>
|
|
</TabsContext.Provider>
|
|
);
|
|
}
|
|
|
|
function TabList({ children }: { children: React.ReactNode }) {
|
|
return <div className="tab-list">{children}</div>;
|
|
}
|
|
|
|
function Tab({ id, children }: { id: string; children: React.ReactNode }) {
|
|
const context = useContext(TabsContext);
|
|
if (!context) throw new Error('Tab must be used within Tabs');
|
|
|
|
const { activeTab, setActiveTab } = context;
|
|
const isActive = activeTab === id;
|
|
|
|
return (
|
|
<button
|
|
className={isActive ? 'tab active' : 'tab'}
|
|
onClick={() => setActiveTab(id)}
|
|
>
|
|
{children}
|
|
</button>
|
|
);
|
|
}
|
|
|
|
function TabPanel({ id, children }: { id: string; children: React.ReactNode }) {
|
|
const context = useContext(TabsContext);
|
|
if (!context) throw new Error('TabPanel must be used within Tabs');
|
|
|
|
const { activeTab } = context;
|
|
if (activeTab !== id) return null;
|
|
|
|
return <div className="tab-panel">{children}</div>;
|
|
}
|
|
|
|
// Export as namespace
|
|
export const TabsComponent = Object.assign(Tabs, {
|
|
List: TabList,
|
|
Tab,
|
|
Panel: TabPanel
|
|
});
|
|
|
|
// Usage
|
|
<TabsComponent defaultTab="profile">
|
|
<TabsComponent.List>
|
|
<TabsComponent.Tab id="profile">Profile</TabsComponent.Tab>
|
|
<TabsComponent.Tab id="settings">Settings</TabsComponent.Tab>
|
|
</TabsComponent.List>
|
|
|
|
<TabsComponent.Panel id="profile">
|
|
<UserProfile />
|
|
</TabsComponent.Panel>
|
|
<TabsComponent.Panel id="settings">
|
|
<UserSettings />
|
|
</TabsComponent.Panel>
|
|
</TabsComponent></code></pre>
|
|
<p><strong>Good for</strong>:</p>
|
|
<ul><li>Complex UI components (tabs, accordions, dropdowns)</li><li>Component APIs that need tight coupling</li><li>Flexible component composition</li></ul>
|
|
<h3>Higher-Order Component (HOC) Pattern</h3>
|
|
<pre><code class="lang-tsx">// withAuth HOC
|
|
function withAuth<P extends object>(Component: React.ComponentType<P>) {
|
|
return function AuthenticatedComponent(props: P) {
|
|
const { user, loading } = useAuth();
|
|
|
|
if (loading) return <Spinner />;
|
|
if (!user) return <Navigate to="/login" />;
|
|
|
|
return <Component {...props} />;
|
|
};
|
|
}
|
|
|
|
// Usage
|
|
const ProtectedPage = withAuth(DashboardPage);</code></pre>
|
|
<p><strong>Good for</strong>:</p>
|
|
<ul><li>Cross-cutting concerns (auth, logging, analytics)</li><li>Legacy codebases</li></ul>
|
|
<p><strong>Modern alternative</strong>: Custom hooks (preferred)</p>
|
|
<hr>
|
|
<h2>Custom Hooks Patterns</h2>
|
|
<h3>Data Fetching Hook</h3>
|
|
<pre><code class="lang-tsx">function useFetch<T>(url: string) {
|
|
const [data, setData] = useState<T | null>(null);
|
|
const [loading, setLoading] = useState(true);
|
|
const [error, setError] = useState<Error | null>(null);
|
|
|
|
useEffect(() => {
|
|
let cancelled = false;
|
|
|
|
setLoading(true);
|
|
setError(null);
|
|
|
|
fetch(url)
|
|
.then(res => {
|
|
if (!res.ok) throw new Error(`HTTP ${res.status}`);
|
|
return res.json();
|
|
})
|
|
.then(data => {
|
|
if (!cancelled) setData(data);
|
|
})
|
|
.catch(err => {
|
|
if (!cancelled) setError(err);
|
|
})
|
|
.finally(() => {
|
|
if (!cancelled) setLoading(false);
|
|
});
|
|
|
|
return () => {
|
|
cancelled = true;
|
|
};
|
|
}, [url]);
|
|
|
|
return { data, loading, error };
|
|
}
|
|
|
|
// Usage
|
|
function UserProfile({ userId }: { userId: string }) {
|
|
const { data: user, loading, error } = useFetch<User>(`/api/users/${userId}`);
|
|
|
|
if (loading) return <Spinner />;
|
|
if (error) return <Error message={error.message} />;
|
|
if (!user) return null;
|
|
|
|
return <div>{user.name}</div>;
|
|
}</code></pre>
|
|
<h3>Local Storage Hook</h3>
|
|
<pre><code class="lang-tsx">function useLocalStorage<T>(key: string, initialValue: T) {
|
|
// State to store value
|
|
const [storedValue, setStoredValue] = useState<T>(() => {
|
|
try {
|
|
const item = window.localStorage.getItem(key);
|
|
return item ? JSON.parse(item) : initialValue;
|
|
} catch (error) {
|
|
console.error(error);
|
|
return initialValue;
|
|
}
|
|
});
|
|
|
|
// Return wrapped version of useState's setter function
|
|
const setValue = (value: T | ((val: T) => T)) => {
|
|
try {
|
|
// Allow value to be function (same API as useState)
|
|
const valueToStore = value instanceof Function ? value(storedValue) : value;
|
|
setStoredValue(valueToStore);
|
|
window.localStorage.setItem(key, JSON.stringify(valueToStore));
|
|
} catch (error) {
|
|
console.error(error);
|
|
}
|
|
};
|
|
|
|
return [storedValue, setValue] as const;
|
|
}
|
|
|
|
// Usage
|
|
function ThemeToggle() {
|
|
const [theme, setTheme] = useLocalStorage('theme', 'light');
|
|
|
|
return (
|
|
<button onClick={() => setTheme(theme === 'light' ? 'dark' : 'light')}>
|
|
{theme === 'light' ? '🌙' : '☀️'}
|
|
</button>
|
|
);
|
|
}</code></pre>
|
|
<h3>Debounce Hook</h3>
|
|
<pre><code class="lang-tsx">function useDebounce<T>(value: T, delay: number): T {
|
|
const [debouncedValue, setDebouncedValue] = useState(value);
|
|
|
|
useEffect(() => {
|
|
const handler = setTimeout(() => {
|
|
setDebouncedValue(value);
|
|
}, delay);
|
|
|
|
return () => {
|
|
clearTimeout(handler);
|
|
};
|
|
}, [value, delay]);
|
|
|
|
return debouncedValue;
|
|
}
|
|
|
|
// Usage
|
|
function SearchInput() {
|
|
const [searchTerm, setSearchTerm] = useState('');
|
|
const debouncedSearchTerm = useDebounce(searchTerm, 300);
|
|
|
|
useEffect(() => {
|
|
if (debouncedSearchTerm) {
|
|
// API call only happens after 300ms of no typing
|
|
fetch(`/api/search?q=${debouncedSearchTerm}`);
|
|
}
|
|
}, [debouncedSearchTerm]);
|
|
|
|
return (
|
|
<input
|
|
type="text"
|
|
value={searchTerm}
|
|
onChange={(e) => setSearchTerm(e.target.value)}
|
|
/>
|
|
);
|
|
}</code></pre>
|
|
<hr>
|
|
<h2>Memoization Patterns</h2>
|
|
<h3>React.memo for Component Optimization</h3>
|
|
<pre><code class="lang-tsx">// Expensive component that re-renders unnecessarily
|
|
function ExpensiveComponent({ data }: { data: string[] }) {
|
|
// Heavy computation
|
|
const processedData = data.map(item => /* expensive operation */ item);
|
|
|
|
return <div>{processedData.join(', ')}</div>;
|
|
}
|
|
|
|
// Memoized version - only re-renders when data changes
|
|
const MemoizedExpensiveComponent = React.memo(ExpensiveComponent);
|
|
|
|
// With custom comparison function
|
|
const MemoizedExpensiveComponent = React.memo(
|
|
ExpensiveComponent,
|
|
(prevProps, nextProps) => {
|
|
// Return true if props are equal (skip re-render)
|
|
return prevProps.data.length === nextProps.data.length;
|
|
}
|
|
);</code></pre>
|
|
<p><strong>When to use</strong>:</p>
|
|
<ul><li>Component renders often with same props</li><li>Component is expensive to render</li><li>Parent re-renders frequently</li></ul>
|
|
<p><strong>When NOT to use</strong>:</p>
|
|
<ul><li>Component always renders with new props</li><li>Cheap rendering cost</li><li>Premature optimization</li></ul>
|
|
<h3>useMemo for Expensive Calculations</h3>
|
|
<pre><code class="lang-tsx">function ProductList({ products, filter }: { products: Product[]; filter: string }) {
|
|
// Expensive filtering only runs when products or filter changes
|
|
const filteredProducts = useMemo(() => {
|
|
return products.filter(product =>
|
|
product.name.toLowerCase().includes(filter.toLowerCase())
|
|
);
|
|
}, [products, filter]);
|
|
|
|
return (
|
|
<div>
|
|
{filteredProducts.map(product => (
|
|
<ProductCard key={product.id} product={product} />
|
|
))}
|
|
</div>
|
|
);
|
|
}</code></pre>
|
|
<p><strong>When to use</strong>:</p>
|
|
<ul><li>Expensive calculations</li><li>Creating objects/arrays passed to child components</li><li>Filtering/sorting large datasets</li></ul>
|
|
<p><strong>When NOT to use</strong>:</p>
|
|
<ul><li>Simple calculations (memoization overhead > calculation cost)</li><li>Premature optimization</li></ul>
|
|
<h3>useCallback for Function Stability</h3>
|
|
<pre><code class="lang-tsx">function TodoList() {
|
|
const [todos, setTodos] = useState<Todo[]>([]);
|
|
|
|
// Without useCallback: new function every render
|
|
const handleToggle = (id: string) => {
|
|
setTodos(todos.map(todo =>
|
|
todo.id === id ? { ...todo, completed: !todo.completed } : todo
|
|
));
|
|
};
|
|
|
|
// With useCallback: same function reference across renders
|
|
const handleToggle = useCallback((id: string) => {
|
|
setTodos(todos => todos.map(todo =>
|
|
todo.id === id ? { ...todo, completed: !todo.completed } : todo
|
|
));
|
|
}, []); // Empty deps because we use functional update
|
|
|
|
return (
|
|
<div>
|
|
{todos.map(todo => (
|
|
<TodoItem key={todo.id} todo={todo} onToggle={handleToggle} />
|
|
))}
|
|
</div>
|
|
);
|
|
}
|
|
|
|
// Child component is memoized
|
|
const TodoItem = React.memo(({ todo, onToggle }: {
|
|
todo: Todo;
|
|
onToggle: (id: string) => void;
|
|
}) => {
|
|
return (
|
|
<div onClick={() => onToggle(todo.id)}>
|
|
{todo.title}
|
|
</div>
|
|
);
|
|
});</code></pre>
|
|
<p><strong>When to use</strong>:</p>
|
|
<ul><li>Passing callbacks to memoized child components</li><li>Dependency in useEffect/useMemo</li><li>Stable function reference needed</li></ul>
|
|
<p><strong>When NOT to use</strong>:</p>
|
|
<ul><li>Not passing to memoized children</li><li>Premature optimization</li></ul>
|
|
<hr>
|
|
<h2>Code Splitting Patterns</h2>
|
|
<h3>Route-Based Code Splitting</h3>
|
|
<pre><code class="lang-tsx">import { lazy, Suspense } from 'react';
|
|
import { BrowserRouter, Routes, Route } from 'react-router-dom';
|
|
|
|
// Lazy load route components
|
|
const Home = lazy(() => import('./pages/Home'));
|
|
const Dashboard = lazy(() => import('./pages/Dashboard'));
|
|
const Profile = lazy(() => import('./pages/Profile'));
|
|
|
|
function App() {
|
|
return (
|
|
<BrowserRouter>
|
|
<Suspense fallback={<Spinner />}>
|
|
<Routes>
|
|
<Route path="/" element={<Home />} />
|
|
<Route path="/dashboard" element={<Dashboard />} />
|
|
<Route path="/profile" element={<Profile />} />
|
|
</Routes>
|
|
</Suspense>
|
|
</BrowserRouter>
|
|
);
|
|
}</code></pre>
|
|
<h3>Component-Based Code Splitting</h3>
|
|
<pre><code class="lang-tsx">// Heavy component loaded on demand
|
|
const HeavyChart = lazy(() => import('./components/HeavyChart'));
|
|
|
|
function Dashboard() {
|
|
const [showChart, setShowChart] = useState(false);
|
|
|
|
return (
|
|
<div>
|
|
<button onClick={() => setShowChart(true)}>Show Chart</button>
|
|
|
|
{showChart && (
|
|
<Suspense fallback={<div>Loading chart...</div>}>
|
|
<HeavyChart />
|
|
</Suspense>
|
|
)}
|
|
</div>
|
|
);
|
|
}</code></pre>
|
|
<h3>Named Export Code Splitting</h3>
|
|
<pre><code class="lang-tsx">// utils.ts
|
|
export function heavyFunction() { /* ... */ }
|
|
export function lightFunction() { /* ... */ }
|
|
|
|
// App.tsx - only load heavyFunction when needed
|
|
const loadHeavyFunction = () => import('./utils').then(mod => mod.heavyFunction);
|
|
|
|
function Component() {
|
|
const handleClick = async () => {
|
|
const heavyFn = await loadHeavyFunction();
|
|
heavyFn();
|
|
};
|
|
|
|
return <button onClick={handleClick}>Run Heavy Task</button>;
|
|
}</code></pre>
|
|
<hr>
|
|
<h2>Component Organization Patterns</h2>
|
|
<h3>Feature-Based Structure</h3>
|
|
<pre><code>src/
|
|
features/
|
|
auth/
|
|
components/
|
|
LoginForm.tsx
|
|
RegisterForm.tsx
|
|
hooks/
|
|
useAuth.ts
|
|
api/
|
|
authApi.ts
|
|
types.ts
|
|
index.ts
|
|
todos/
|
|
components/
|
|
TodoList.tsx
|
|
TodoItem.tsx
|
|
hooks/
|
|
useTodos.ts
|
|
api/
|
|
todosApi.ts
|
|
types.ts
|
|
index.ts
|
|
shared/
|
|
components/
|
|
Button.tsx
|
|
Input.tsx
|
|
hooks/
|
|
useLocalStorage.ts
|
|
utils/
|
|
formatDate.ts</code></pre>
|
|
<h3>Colocation Pattern</h3>
|
|
<pre><code class="lang-tsx">// UserProfile.tsx
|
|
import { useState } from 'react';
|
|
import { UserAvatar } from './UserAvatar';
|
|
import { useUserData } from './useUserData';
|
|
import type { User } from './types';
|
|
import './UserProfile.css';
|
|
|
|
// Keep related files together
|
|
// - UserProfile.tsx (component)
|
|
// - UserAvatar.tsx (sub-component)
|
|
// - useUserData.ts (hook)
|
|
// - types.ts (types)
|
|
// - UserProfile.css (styles)
|
|
// - UserProfile.test.tsx (tests)</code></pre>
|
|
<hr>
|
|
<h2>Anti-Patterns to Avoid</h2>
|
|
<h3>1. Prop Drilling</h3>
|
|
<pre><code class="lang-tsx">// ❌ Bad: Passing props through many levels
|
|
function App() {
|
|
const [user, setUser] = useState<User | null>(null);
|
|
return <Layout user={user} setUser={setUser} />;
|
|
}
|
|
|
|
function Layout({ user, setUser }) {
|
|
return <Sidebar user={user} setUser={setUser} />;
|
|
}
|
|
|
|
function Sidebar({ user, setUser }) {
|
|
return <UserMenu user={user} setUser={setUser} />;
|
|
}
|
|
|
|
// ✅ Good: Use Context
|
|
const UserContext = createContext<{
|
|
user: User | null;
|
|
setUser: (user: User | null) => void;
|
|
} | null>(null);
|
|
|
|
function App() {
|
|
const [user, setUser] = useState<User | null>(null);
|
|
return (
|
|
<UserContext.Provider value={{ user, setUser }}>
|
|
<Layout />
|
|
</UserContext.Provider>
|
|
);
|
|
}
|
|
|
|
function UserMenu() {
|
|
const { user, setUser } = useContext(UserContext)!;
|
|
// Use directly without prop drilling
|
|
}</code></pre>
|
|
<h3>2. Large Components</h3>
|
|
<pre><code class="lang-tsx">// ❌ Bad: 500-line component doing everything
|
|
function Dashboard() {
|
|
// 50 lines of state
|
|
// 100 lines of effects
|
|
// 200 lines of handlers
|
|
// 150 lines of JSX
|
|
return <div>...</div>;
|
|
}
|
|
|
|
// ✅ Good: Extract logical pieces
|
|
function Dashboard() {
|
|
return (
|
|
<div>
|
|
<DashboardHeader />
|
|
<DashboardStats />
|
|
<DashboardCharts />
|
|
<DashboardTables />
|
|
</div>
|
|
);
|
|
}</code></pre>
|
|
<h3>3. Premature Memoization</h3>
|
|
<pre><code class="lang-tsx">// ❌ Bad: Memoizing everything
|
|
const Component = React.memo(() => {
|
|
const value = useMemo(() => 1 + 1, []);
|
|
const handler = useCallback(() => console.log('click'), []);
|
|
return <button onClick={handler}>{value}</button>;
|
|
});
|
|
|
|
// ✅ Good: Only memoize when needed (profiling shows performance issue)
|
|
function Component() {
|
|
return <button onClick={() => console.log('click')}>2</button>;
|
|
}</code></pre>
|
|
<hr>
|
|
<h2>Quick Reference</h2>
|
|
<h3>When to Use Each Pattern</h3>
|
|
<pre><code>Composition:
|
|
- Children prop → Layouts, wrappers
|
|
- Render props → Logic sharing with different UI (rare)
|
|
- Compound components → Complex UI with tight coupling
|
|
- HOC → Legacy code, cross-cutting concerns
|
|
|
|
Custom Hooks:
|
|
- Data fetching → useFetch, useQuery
|
|
- Side effects → useDebounce, useLocalStorage
|
|
- Logic reuse → useAuth, useForm
|
|
|
|
Memoization:
|
|
- React.memo → Expensive components with stable props
|
|
- useMemo → Expensive calculations
|
|
- useCallback → Stable function refs for memoized children
|
|
|
|
Code Splitting:
|
|
- Route-based → Always for routes
|
|
- Component-based → Heavy components, modals, charts
|
|
- Function-based → Rarely needed</code></pre>
|
|
<hr>
|
|
<h2>Related Skills</h2>
|
|
<ul><li><code>nextjs-app-router.md</code> - Server vs Client Components, App Router patterns</li><li><code>react-state-management.md</code> - Context, Zustand, Jotai patterns</li><li><code>react-data-fetching.md</code> - SWR, React Query for data fetching</li><li><code>frontend-performance.md</code> - Bundle optimization, Core Web Vitals</li><li><code>web-accessibility.md</code> - ARIA patterns, keyboard navigation</li></ul>
|
|
<hr>
|
|
<p><strong>Last Updated</strong>: 2025-10-18 <strong>Format Version</strong>: 1.0 (Atomic)</p>
|
|
<footer>
|
|
<div class="fmap">
|
|
<div><b>Build</b>
|
|
<a href="https://hanzo.app">hanzo.app</a> app builder
|
|
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
|
|
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
|
|
<div><b>Run</b>
|
|
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
|
|
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
|
|
<div><b>Account</b>
|
|
<a href="https://hanzo.id">hanzo.id</a> sign in
|
|
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
|
|
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
|
|
<div><b>Company</b>
|
|
<a href="https://hanzo.ai">hanzo.ai</a> canonical
|
|
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
|
|
</div>
|
|
<div class="fend"><a href="/frontend-react-component-patterns.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
|
|
</footer>
|
|
</div></body></html> |