Your next page is taking shape...

Opening Your Next Page…

Loading the guide and preparing its examples for you to explore. The page will appear here automatically when it’s ready, so you can keep this view open without refreshing.

Made for Preact. Built to be yours.

Layout Block

A left and right sidebar. Adapt the Sidebar components from @kamod-ch/ui to your navigation, branding and page content. Replace sample destinations with your own routes, then check the Mobile Layout and Keyboard Navigation in the live demo. The source and setup steps show which files belong to this variant.


Interactive Live Preview
Try it. Make it yours.

Variant 15 of 16

Download this variant into your Preact project, install the dependencies you are missing and connect your own navigation and page content. The source stays local, so you can change its layout without introducing another application framework.

  1. Download this variant and extract its sidebar-15 folder into src/components/blocks. Install the dependencies below, then import the component. The folder includes its own helpers and demo data; no other sidebar variants are needed. Relative imports are already set up inside the folder, so you can move it as a unit and replace the sample navigation and content with your own. The archive already contains the outer sidebar-15/ folder: extract it once, rather than creating a second nested folder with the same name. The import examples assume src/App.tsx.

    Download Block
    Install Dependencies
    Prefer Manual Copying?

    Open the Showcase’s Code Tab and copy each listed file into the same folder structure above. Its labels are the destination paths inside sidebar-15/, and its imports already match the download. Keep the included license with your copy.

  2. Install only what your app does not already have. Preact renders the block, Kamod UI provides its interactive components, and Icons supplies its icons. Themes and Signals support the shared Kamod setup.

    Install PackagesTerminal
    pnpm add @kamod-ch/ui @kamod-ch/icons preact @kamod-ch/themes @preact/signals
  3. Follow the Theme and Tailwind Setup. Import your global stylesheet and make sure Tailwind scans the copied source and Kamod components. Keep your existing setup if the app already uses Kamod.

    Import SetupTypeScript
    import { Sidebar15 } from "./components/blocks/sidebar-15";
    Import from your local source

    The @kamod-ch/blocks/sidebar/sidebar-15 path identifies source in this repository; the blocks package is private. Use the local import above rather than trying to install that path as a published package.

    Check the First Render

    The sidebar, borders and page background should follow your app’s theme. If the layout appears unstyled, check the global CSS import and Tailwind source detection before changing the block’s classes. If an import fails, first compare your folder paths with the copy list; renaming only one file can break its relative imports.

Start with the complete preview composition, then adapt its local source to your app. The exported Sidebar15 takes No Props; navigation, content and behavior are configured inside your copied files.

Think of this block as an Editable Starting Layout. Rendering <Sidebar15 /> runs the JSX already written in your copied file: its sidebar, header, sample data and placeholder content. The supplied wrapper does not read navigation props or children, so your own content needs to be connected inside that composition first.

A block such as Application Shell 1 exposes a defined API for navigationGroups, breadcrumbs and children. These sidebar variants instead expose their arrangement as source you can edit. That lets a documentation sidebar, a two-pane layout and a settings dialog each keep their own structure without fitting every difference into one configuration object. You get direct control over the layout, with the responsibility of wiring it to your app.

The Sidebar15 wrapper is your local page: it arranges the sidebar, header and content area. The core Sidebar inside it remains a configurable UI component. Edit that arrangement in the entry file, keeping the existing provider and layout structure around the pieces you replace.

Keep the Provider and Its Controls Together. The trigger and navigation share sidebar state through their existing provider. Start with a small visible edit, such as a heading or label, then check the desktop toggle and mobile navigation before moving structural elements.

The no-props entrypoint does not remove the inner components’ APIs. Your copied file passes data and options to its helpers. Replace the sample values in data/ or pass application values at those call sites. Follow Adapt the Local Composition for this variant’s example.

Keep the Data Shape, Replace the Demo Values. Check the helper’s required fields before changing the records it receives. A new label changes what people read; a destination changes where they go. Neither automatically connects active styling to your router or turns a placeholder action into application behavior.

Replace the placeholder panels inside the existing SidebarInset. Retain the surrounding header and navigation. Your router decides which page to show; the block does not choose routes or fetch application data.

Edit Inside the Existing Layout. This excerpt replaces only the content area in your copied file. Keep the shell’s current props and main landmark; use a section for the new content instead of adding a second main.

src/components/blocks/sidebar-15/sidebar-15.tsx5 lines
// Replace the placeholder panels in sidebar-15.tsx.
<section class="space-y-2 p-4" aria-labelledby="page-title">
  <h1 id="page-title">Projects</h1>
  <p class="text-muted-foreground">Choose a project to open its workspace.</p>
</section>
You Can Introduce Your Own Props Later

If multiple routes need the same layout, add a typed children prop or navigation inputs to your local Sidebar15, then explicitly forward them to the relevant helpers. The downloaded wrapper does not do that automatically. Start by rendering the original below, then make the local edits one step at a time.

Render the block once in your page or route layout. It already includes its own SidebarProvider, so you do not need another provider around this example.

Usage PatternTypeScript
import { Sidebar15 } from "./components/blocks/sidebar-15";

export const App = () => <Sidebar15 />;

Your copied sidebar-15.tsx contains the complete composition. Start with its imports from data/ to replace sample labels and destinations, then update the local components that consume them. The snippet below replaces one part of that file; keep the surrounding provider and layout in place.

Usage PatternTypeScript
// In sidebar-15.tsx; keep the surrounding layout.
<NavMain items={[{
  title: "Projects", url: "/projects", icon: "frame", isActive: true,
  items: [{ title: "Overview", url: "/projects/overview" }],
}]} />
Local edits, local ownership

These are local edits, not props to pass to <Sidebar15 />. See Local Props and Data for the helpers this variant actually includes and their supported inputs.

Replace the placeholder panels inside the existing SidebarInset with your page content. Keep the surrounding header and trigger, and update the breadcrumb labels and links alongside your route. The inset already supplies the main landmark.

  • Routing and Actions. Real URLs navigate normally; # links are placeholders. For client-side routing, adapt the local links to your router and derive active styling from its current route. Expanding a navigation group does not select a destination. Connect any search, account or form controls you keep to real application handlers.
  • Close Mobile Navigation Deliberately. The demo link helper only prevents # navigation. It does not close the mobile sheet after a client-side route change. In a helper rendered inside the existing provider, use useSidebar() and call setOpenMobile(false) after handling an ordinary destination click. Preserve modified clicks and avoid closing the sheet when a user only expands a branch.
  • Preserve the Layout. Keep the existing main landmark and keep sidebar controls inside their existing provider. Keep the composition mounted across page changes to retain its local UI state. Review this variant’s Responsive Behavior before moving controls; desktop and mobile navigation can differ. Follow the Production Checklist before shipping.

Sidebar15 is a ready-made demonstration page with no public props. The reference below describes the Local Helpers and Data you can configure after copying the source. Definitions come directly from the implementation; descriptions explain where your application takes over. Start with the component or data shape you want to change, then follow its type link to the complete definition. Keep sample values in data/ separate from the behavior in your copied components. This lets you replace labels and destinations without rewriting the surrounding layout in sidebar-15.tsx.

API reference
Your API, from source

The signatures below come from the copied source files. Use the Data Type Reference to inspect complete definitions and required fields. Optional callbacks do not imply that a backend is included. Select a table row’s type name to open its definition automatically. Use import type from the corresponding copied file when typing your own data or component inputs. This reference describes the shipped source; changes in your local files will not update this page.

Each field includes its type and integration behavior. The asterisk
marks required fields. Navigation helpers require their data; omitted optional fields use the defaults described below. The definitions retain the actual source’s optional markers and callback return types. Read each field together with its owning type: the same name can have a different purpose on another helper. A ? means the field may be omitted, not that every optional field has a fallback value. When a field accepts an array, its required marker means you must supply the array; check the helper’s behavior before using an empty [].
Local helper props and data fields
Prop / typeDescription
items
NavigationItem[]NavMainProps
Primary navigation rows, in display order, with icon-map keys and optional child links. Each row without children navigates directly; rows with children follow the collapsible setting. Supply your own data and derive active markers from your router because NavMain does not discover the current route. An empty array leaves the Platform label with no destination rows.
collapsible
booleanNavMainProps
Controls how NavMain presents items that have children; defaults to true. With true, clicking the parent toggles its submenu and an active parent starts open. With false, the parent becomes a normal link and its child links remain visible. Items without children stay links in either mode. This option controls navigation submenus, not the sidebar’s desktop or mobile open state.
name
stringProject
Project label shown beside its icon in the Projects group. Keep names distinguishable and unique within the list because the helper uses them as rendering keys. This is presentation data, not a project identifier sent to a backend. Put the actual destination in url and manage project loading and permissions in your application.
url
stringProject
Destination used when the item renders as a link. Replace the demo’s # with an application route or a real URL; the shared click handler prevents navigation only for that exact placeholder. A parent with children may instead act as a disclosure or dropdown trigger, so its URL is not necessarily followed. Router-specific link components must be wired into the copied helper.
icon
keyof typeof iconMapProject
Key selecting a component from the copied navigation-icons.ts map. Use one of that map’s supported keys; an arbitrary icon name or SVG string will not resolve to a component. To introduce a new symbol, import a Kamod icon and add it to the map before using its key in your data. The adjacent text remains the destination’s visible label.
projects
Project[]NavProjectsProps
Project links rendered in the supplied order beneath the Projects label. Each entry provides its own name, URL and icon-map key; the helper does not fetch projects or decide which ones the user may access. An empty array leaves the group label without links, so omit the helper if the entire group should disappear. The group is hidden when the sidebar collapses to icons.
title
stringSecondaryItem
Visible destination label used in navigation rows and, where supported, collapsed-sidebar tooltips. Choose short, distinguishable names and keep titles unique within each list because the helpers also use them as rendering keys. Changing a title does not change its URL or select the current route.
url
stringSecondaryItem
Destination used when the item renders as a link. Replace the demo’s # with an application route or a real URL; the shared click handler prevents navigation only for that exact placeholder. A parent with children may instead act as a disclosure or dropdown trigger, so its URL is not necessarily followed. Router-specific link components must be wired into the copied helper.
icon
ComponentTypeSecondaryItem
Preact component rendered before this secondary link’s label. Pass the icon component itself, such as LifeBuoyIcon, rather than a string key or an already-created JSX element. Unlike primary navigation, this helper does not resolve an icon-map name. Choose an icon that remains legible at the sidebar’s compact size; the adjacent title provides the destination text.
items
SecondaryItem[]NavSecondaryProps
Secondary destinations such as support or feedback, rendered in array order in a group with an automatic top margin. Each entry supplies its label, URL and icon component. The helper provides links only, not the support action or service behind them. An empty array renders an empty group; omit the helper when that space should disappear too.
name
stringUser
User-facing display name shown above the email in the sidebar’s account row. It is rendered as text and truncated to fit the compact layout. Provide it from your profile data rather than assuming it is a login identifier. Changing the name does not update an account or attach behavior to the row.
email
stringUser
Secondary account label shown beneath the user’s name, truncated when space is limited. Unlike form submission values, this field is display-only: NavUser does not validate it, create a mail link or verify account ownership. Supply the appropriate profile email from your app. It is not automatically synchronized with the standalone login or signup forms.
avatar
stringUser
Short text rendered inside the user row’s colored avatar frame, typically initials. The string is displayed directly: supplying an image URL will show that URL as text rather than load an image. Generate an appropriate fallback from your user data, or replace the frame with a core Avatar when profile pictures are needed.
user
UserNavUserProps
Display data for the sidebar’s user row: name, email and avatar fallback text. Supply it from your application’s session or profile state; the helper does not retrieve or validate the user. The current row has no account menu or action handler, so rendering it does not add logout, profile editing or authentication. Add those behaviors explicitly when adapting the composition.
icon
keyof typeof iconMapNavigationItem
Key selecting a component from the copied navigation-icons.ts map. Use one of that map’s supported keys; an arbitrary icon name or SVG string will not resolve to a component. To introduce a new symbol, import a Kamod icon and add it to the map before using its key in your data. The adjacent text remains the destination’s visible label.
items
NavigationLink[]NavigationItem
Optional nested destinations for this primary navigation item. Omit it or supply an empty array to keep the parent as a direct link. NavMain renders children inline, optionally behind a disclosure, while NavMainDropdowns places them in a dropdown. These children are NavigationLink entries, so this shape supports one child level rather than an arbitrary recursive tree. Child active markers are not rendered by these submenu helpers.
title
stringNavigationLink
Visible destination label used in navigation rows and, where supported, collapsed-sidebar tooltips. Choose short, distinguishable names and keep titles unique within each list because the helpers also use them as rendering keys. Changing a title does not change its URL or select the current route.
url
stringNavigationLink
Destination used when the item renders as a link. Replace the demo’s # with an application route or a real URL; the shared click handler prevents navigation only for that exact placeholder. A parent with children may instead act as a disclosure or dropdown trigger, so its URL is not necessarily followed. Router-specific link components must be wired into the copied helper.
isActive
booleanNavigationLink
Optional current-destination marker; omitting it leaves the item unmarked. Documentation links and direct primary links use it for their active styling and aria-current. Collapsible groups use active data for their initial open state, not as controlled disclosure state. Nested primary links, dropdown entries and Favorites do not currently read this marker; adapt those renderers if you need route highlighting there.
name
stringTeam
Workspace name displayed in the selected-team trigger and dropdown choices. TeamSwitcher also uses this value as its selection identity and rendering key, so names must be unique and stable while the list is mounted. Renaming or removing the selected name makes the display fall back to the first available team. If names are editable in your product, consider adapting the helper to use a separate stable ID.
logo
stringTeam
Workspace mark shown both in the selected-team trigger and in the dropdown list. The exact string kamod renders the included Kamod brand icon; any other string is displayed as text, such as initials or an emoji. This is not an image URL prop. Adapt the logo renderer if you need uploaded logos or another image component.
plan
stringTeam
Secondary text displayed beneath the selected workspace’s name, such as Enterprise or Personal workspace. The switcher treats it as a display label only; it does not enforce subscription permissions or determine available features. Keep it short enough for the compact trigger, where longer text is truncated.
teams
Team[]TeamSwitcherProps
Workspaces available in the switcher, in display order. The first entry is selected initially, and an empty array hides the switcher entirely. Selection is stored locally by team name; if that name disappears from the array, the display falls back to the first entry. Choosing a team does not change routes, fetch workspace data or persist an account preference—connect those actions in your copied switcher.
Configure the copied sidebar

Configure the core Sidebar directly in your copied page: side chooses left or right, variant controls the surface, and collapsible chooses offcanvas, icon or none. The references here list only types included in this variant’s download. Inherited types are shown separately: NavigationItem adds an icon and optional children to NavigationLink, which owns the required title and URL. Read both definitions when building a navigation item.

Expand a definition to copy its exact TypeScript shape. Required fields are listed below each summary for fields declared in that definition. The code header shows the file's installation path; copy the definition with the button beside it. For intersections, also inspect the referenced base type’s required fields. Local types can be imported from the same files as your copied components; they are not added to the zero-prop page wrapper.

2 declared fields
NavMainProps
Local helper inputs from components/nav-main.tsx. These configure the helper inside the copied page, not the exported variant itself. Inspect the Complete Definition of NavMainProps before adapting it.
Required fields
items
3 declared fields
Project
Data shape from components/nav-projects.tsx. Supply real application values using the required and optional fields below. Inspect the Complete Definition of Project before adapting it.
Required fields
name, url, icon
1 declared field
NavProjectsProps
Local helper inputs from components/nav-projects.tsx. These configure the helper inside the copied page, not the exported variant itself. Inspect the Complete Definition of NavProjectsProps before adapting it.
Required fields
projects
3 declared fields
SecondaryItem
Data shape from components/nav-secondary.tsx. Supply real application values using the required and optional fields below. Inspect the Complete Definition of SecondaryItem before adapting it.
Required fields
title, url, icon
1 declared field
NavSecondaryProps
Local helper inputs from components/nav-secondary.tsx. These configure the helper inside the copied page, not the exported variant itself. Inspect the Complete Definition of NavSecondaryProps before adapting it.
Required fields
items
3 declared fields
User
Data shape from components/nav-user.tsx. Supply real application values using the required and optional fields below. Inspect the Complete Definition of User before adapting it.
Required fields
name, email, avatar
1 declared field
NavUserProps
Local helper inputs from components/nav-user.tsx. These configure the helper inside the copied page, not the exported variant itself. Inspect the Complete Definition of NavUserProps before adapting it.
Required fields
user
2 declared fields
NavigationItem
Data shape from components/navigation-types.ts. Supply real application values using the required and optional fields below. Inspect the Complete Definition of NavigationItem before adapting it.
Required fields
icon
3 declared fields
NavigationLink
Data shape from components/navigation.ts. Supply real application values using the required and optional fields below. Inspect the Complete Definition of NavigationLink before adapting it.
Required fields
title, url
3 declared fields
Team
Data shape from components/team-switcher.tsx. Supply real application values using the required and optional fields below. Inspect the Complete Definition of Team before adapting it.
Required fields
name, logo, plan
1 declared field
TeamSwitcherProps
Local helper inputs from components/team-switcher.tsx. These configure the helper inside the copied page, not the exported variant itself. Inspect the Complete Definition of TeamSwitcherProps before adapting it.
Required fields
teams

The left application sidebar can collapse to icons; a second, static sidebar on the right contains calendar utilities. The right pane is not controlled by the left toggle. Keep primary navigation and optional contextual tools clearly separated.

Find the right file

Edit sidebar-15.tsx for layout and data/ for example content. Reusable interactions live in components/. Each variant is an explicit composition; there is no configuration switch or dependency on another variant.

A three-area desktop layout with application navigation on the left, the active workspace in the center and calendar utilities on the right. The left navigation can collapse to icons, while the right sidebar is a separate static region. Each side has a different purpose rather than duplicating the same list of destinations.

Where this layout adds value
Useful when people need persistent application navigation and occasional reference information alongside a document, task list or project workspace. Keeping utility content on the opposite side can reduce interruptions to the central task. The arrangement works best when the right-hand tools are genuinely useful but not required for every interaction.
The tradeoff to consider
Two side regions leave less width for the main page, particularly on medium screens. The right sidebar disappears below 768px and is not opened by the left navigation toggle. Essential calendar tasks therefore need another reachable location; hiding a utility pane is only appropriate when it does not hide the user's only path to a task.

Choose by the way people move through your app, not only by the preview’s appearance. These nearby variants change a specific part of that experience; they are alternatives, not files you need to install alongside this block.

Sidebar 8
Offers application, project and utility links in one sidebar with an inset workspace, preserving more horizontal room for the page.
Sidebar 12
Makes date selection the main sidebar task rather than a secondary tool on the far side of application content.

The left icon-collapsible Sidebar combines team, main, project, secondary and account helpers. SidebarInset contains a sticky page header and centered placeholders. The right Sidebar uses side="right" and collapsible="none", with a calendar beneath a static month label and medium-breakpoint visibility classes.

The defining composition choice. This is a focused excerpt from this variant’s Composition File, with its existing imports and data in scope.

Usage PatternTypeScript
<Sidebar side="right" collapsible="none" class="sticky top-0 hidden h-svh border-l md:flex">

This is a static utility pane, not a second panel opened by the navigation toggle. Give essential date-related tasks a mobile entry point in your page content.

In the downloaded folder, index.ts exports Sidebar15. Its sidebar-15.tsx owns the arrangement. Any included helpers live in components/, fixtures in data/, and any included brand artwork in branding/. These paths describe your installation folder, which is generated from the actual implementation with its relative imports rewritten together.

Edit the Composition Where It Is Assembled. The exported wrapper does not accept a navigation configuration or forward children. Its inner components still have their own inputs. Replace data at their call sites and insert your content in the existing page area; the Usage Guide shows the appropriate insertion point for this variant. You can introduce a typed wrapper API later if multiple routes need to reuse your adapted layout.

The provider's toggle affects the collapsible left navigation, not the static right pane. The right Calendar has no selected value or application callback, so clicking a day does not retain a selected-day highlight. Its displayed month can change internally, while the October 2024 heading is fixed. No date selection is connected to the central workspace or any scheduling service.

Presentation state belongs to the layout
An open menu is local interface state. An expanded branch or selected demo value describes the interface at that moment. It does not automatically load data, authorize access or change the URL. Preserve useful local UI state while letting your application own the current page and real records.
Route state belongs to your application
Derive location from one source. Active destinations, page content and breadcrumbs should follow the same route or selection model. An isActive flag supplies styling; it is not a router. Where a helper initializes a disclosure with defaultOpen, decide whether later route changes should also update that disclosure.
Check the public inputs

Inspect Local Props and Data before wiring a callback. Only the inputs documented for the copied helper are available; introducing another callback also requires updating its implementation.

The right utility sidebar is hidden below 768px. Essential calendar tasks need another mobile entry point; the left navigation uses the normal sheet.

Below 768px, collapsible core sidebars use the mobile sheet. Desktop open and mobile openMobile are separate states in SidebarProvider; restoring a desktop preference does not open the sheet. Static regions using collapsible="none" follow their own layout and visibility classes instead.

Test the space left for your actual content. Use a data table or form instead of only the empty panels. Long navigation labels, a wide data table and a short viewport can expose different constraints. Let text wrap where it carries meaning, keep any necessary scrolling local to its content, and offer another way to reach essential controls when a secondary pane is hidden.

Distinguish primary navigation from utility content with meaningful labels. Do not make keyboard users traverse a redundant second navigation area to reach the page. Check the mobile replacement for every essential control hidden with the right pane.

Current location and meaningful names
Use real links for destinations and buttons for actions. Set aria-current="page" on the current destination; visible selection alone is insufficient. Give icon-only controls meaningful names, and make breadcrumbs agree with the page being shown rather than leaving their sample labels unchanged.
Keyboard, focus and content landmarks
Retain core disclosure, menu and overlay behavior. Check Tab, Shift+Tab, Enter, Space and Escape where applicable, including focus return after dismissal. The existing page area already provides a main landmark; insert content within it rather than adding nested main elements. Give distinct navigation regions meaningful labels when your adaptation contains more than one. The core provider also registers Ctrl/Cmd+B to toggle navigation; check this shortcut against your application’s editor or other global shortcuts, and avoid mounting duplicate providers for the same layout.
Try the complete journey

Validate your finished integration at 320px, 768px, 1024px and 1440px, with keyboard-only input, 200% zoom, both color modes and long real content. Check short screens and the on-screen keyboard as well. Follow the complete journey checklist with your real content. Reusing the primitives helps preserve behavior, but cannot guarantee accessibility after your structure changes.

Define which tools truly need persistent desktop space, and remove the right pane if they can live within page content. If keeping the calendar, connect its selection and displayed period to real data. Give mobile users an explicit utility entry point and test wide tables with both sidebars present before choosing final widths.

Keep appearance changes in the sidebar token family: pair bg-sidebar with text-sidebar-foreground, and use border-sidebar-border for its edge. The block styling guide explains when to change a primitive’s props and when to edit the composition.

  1. Replace Demo Navigation. Supply real URLs: the shared stopNavigation helper only cancels links whose destination is #. Add your router’s link handling if needed. Connect actions to your services and show useful pending, empty or failure states where they apply. Hiding a link does not replace authorization in your application.
  2. Make State Ownership Deliberate. Keep the layout mounted if its UI state should survive route changes. If desktop collapse must survive a reload, restore an initial or controlled value through SidebarProvider. Its cookie write alone does not read and restore that preference for your app.
  3. Replace Placeholders before Tuning the Layout. Test your real pages and theme first, then adjust widths, spacing and overflow. Use semantic tokens so borders, backgrounds and interactive states continue to follow light and dark mode.

Start with Connect Your Application for the integration point, then use the Data Type Reference to shape your inputs. Keep the copied folder together while changing its internals; there is no dependency on another sidebar variant’s installation.

Use the Checked-in Kamod Implementation as your reference when adapting this variant. The Showcase’s Code Tab includes its supporting files, and the Setup Instructions explain where to place them and how to keep their imports intact. Before changing a helper, trace where it is used in the composition and check its inputs in the Props and Data Reference. This helps you adapt one part of the block without overlooking the files or behavior it depends on.

Keep your local copy focused on the layout and interactions your app actually uses. Start with the data and content, then adjust composition and styling using the same semantic theme tokens.

Ready to integrate? Follow Add This Block and the Local Usage Example.

This variant follows the corresponding sidebar design in the shadcn/ui collection. Use the reference to compare the division between primary navigation and a separate right-hand utility pane. When adapting the Kamod version, start with your navigation hierarchy and page content, then follow the Local Composition Example to connect the layout to your app.

Kamod expresses this layout with Preact components, its own sidebar behavior and semantic theme tokens. The copied variant keeps its composition, helpers and demo data together; your application supplies real destinations, content and actions.

Inspect the Original Variant’s Source for the reference composition. The Variant Details above describe this implementation’s behavior and integration boundaries.

Use the original as a design reference. To install the Preact version shown here, follow Add This Block and use this page’s download or Code tab. Its files and imports are prepared for Kamod.

Take the Next Useful Step

You have the pieces. Put them into one real interaction, keep its state in one place, and check the result with the content your application will actually show.

Connect the Foundation

Return to Bring a Complete Layout into Your App to connect this reference to a working screen. Keep global CSS in one entrypoint and import only the components that screen needs.

Build the Surrounding Screen

Find a neighboring interaction in the Component Library, or start with a complete Block. Replace sample content and destinations before refining the layout; a local class change can stay with the composition.

Make the Result Hold Up

Use shared theme roles for changes that belong everywhere. Then review the whole journey: keyboard focus, long labels, narrow screens and a clear way to recover when something fails.

Keep a link to the source and note your intentional changes. Your next edit should begin with a clear decision, not another search.