@amboss/design-system 3.48.12 → 3.49.1

package/build/esm/components/Internal/Sandwich/useSandwichContext.d.ts

@@ -0,0 +1,12 @@
+import type { SandwichEdges } from "./-types";
+/**
+ * Context decouples the parts: `Body` reports edge visibility via `setEdges`,
+ * `Header` / `Footer` read `atTop` / `atBottom`. The link is the context, not
+ * child order, so the parts may be authored in any order.
+ */
+export type SandwichContextValue = SandwichEdges & {
+    setEdges: (edges: Partial<SandwichEdges>) => void;
+};
+export declare const SandwichProvider: React.Provider<SandwichContextValue>;
+/** Read the Sandwich context, or throw if used outside `<Sandwich>`. */
+export declare function useSandwichContext(): SandwichContextValue;

package/build/esm/components/Internal/Sandwich/useSandwichContext.js

@@ -0,0 +1 @@
+import{createContext,useContext}from"react";let SandwichContext=createContext(null);export const SandwichProvider=SandwichContext.Provider;export function useSandwichContext(){let ctx=useContext(SandwichContext);if(!ctx)throw Error("Sandwich.Header / Sandwich.Footer / Sandwich.Body must be used within <Sandwich>.");return ctx}

package/build/esm/components/Layout/-constants.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Slot keys — the single source of truth. The key *types* (`SlotKey`,
+ * `SidePanelKey`, `PanelKey`) are derived from these const values below and
+ * re-exported by `-types.ts`, so the literals are written exactly once.
+ */
+/** Slot keys as named constants — reference these instead of bare literals. */
+export declare const Slot: {
+    readonly sidebar: "sidebar";
+    readonly content: "content";
+    readonly splitview: "splitview";
+    readonly rightPanel: "rightPanel";
+};
+/** Side panels (open/close), left + right. */
+export declare const SIDE_PANELS: readonly ["sidebar", "rightPanel"];
+/** Flex panels — content is always shown; splitview toggles. */
+export declare const PANELS: readonly ["content", "splitview"];
+/** Left-to-right panel order in the resizable row (the full slot set). */
+export declare const PANEL_ORDER: readonly ["sidebar", "content", "splitview", "rightPanel"];
+export type SlotKey = (typeof PANEL_ORDER)[number];
+export type SidePanelKey = (typeof SIDE_PANELS)[number];
+export type PanelKey = (typeof PANELS)[number];
+/** Slide-animation timing. Injected on `:root` by `Layout.Provider` (`SlideVars`)
+ *  from the theme's `navSlide` token; read by animated layout surfaces. */
+export declare const SLIDE_VAR: {
+    readonly duration: "--ds-layout-slide-duration";
+    readonly easing: "--ds-layout-slide-easing";
+};
+/** Vertical offset for the right panel — set this (e.g. to a sticky subnav's
+ *  height) and the panel tracks it; defaults to `0` when unset. */
+export declare const SUBNAV_OFFSET_VAR = "--ds-layout-subnav-offset";

package/build/esm/components/Layout/-constants.js

@@ -0,0 +1 @@
+export const Slot={sidebar:"sidebar",content:"content",splitview:"splitview",rightPanel:"rightPanel"};export const SIDE_PANELS=[Slot.sidebar,Slot.rightPanel];export const PANELS=[Slot.content,Slot.splitview];export const PANEL_ORDER=[Slot.sidebar,Slot.content,Slot.splitview,Slot.rightPanel];export const SLIDE_VAR={duration:"--ds-layout-slide-duration",easing:"--ds-layout-slide-easing"};export const SUBNAV_OFFSET_VAR="--ds-layout-subnav-offset";

package/build/esm/components/Layout/-types.d.ts

@@ -0,0 +1,214 @@
+import type React from "react";
+import type { PanelKey, SidePanelKey, SlotKey } from "./-constants";
+import type { IconProps } from "../Icon/Icon";
+/**
+ * Surface = compound components (`Layout.Sidebar` / `Layout.RightPanel` /
+ * `Layout.Content` / `Layout.Split`) + one control hook
+ * (`useLayout()`). The manager owns the open/collapsed/size state; components
+ * render per that state. State engine is replaceable (see `LayoutStore`).
+ *
+ * Slots (max 4 panels, max 3 visible at once — budget enforcement deferred):
+ *   sidebar | content | splitview | rightPanel
+ */
+/** A size: plain number = pixels; unitless string = percentage ("10%"). */
+export type Size = number | string;
+/**
+ * - `sidebar` — in-flow resizable panel.
+ * - `offcanvas` — detached desktop overlay. ⚠️ **RESERVED — not implemented yet.**
+ *   Currently treated like `sidebar` (renders in-flow); the overlay
+ *   implementation lands in a later commit.
+ */
+export type Variant = "sidebar" | "offcanvas";
+export type { PanelKey, SidePanelKey, SlotKey };
+export type SidePanelState = {
+    kind: "sidePanel";
+    /** Shown vs hidden. */
+    visible: boolean;
+    /** Whether it can collapse at all. */
+    collapsible: boolean;
+    /** Render style. */
+    variant: Variant;
+    /** Current size (px number or "%" string). */
+    size?: Size;
+    /** Constraint from config (component prop overrides). */
+    minSize?: Size;
+    maxSize?: Size;
+};
+export type PanelState = {
+    kind: "panel";
+    /** content is always visible; splitview is toggleable. */
+    visible: boolean;
+    size?: Size;
+    /** Constraint from config (component prop overrides). */
+    minSize?: Size;
+    maxSize?: Size;
+};
+export type LayoutState = {
+    sidebar: SidePanelState;
+    rightPanel: SidePanelState;
+    content: PanelState;
+    splitview: PanelState;
+};
+export type SidePanelConfig = {
+    defaultVisible?: boolean;
+    collapsible?: boolean;
+    variant?: Variant;
+    defaultSize?: Size;
+    minSize?: Size;
+    maxSize?: Size;
+};
+export type PanelConfig = {
+    defaultVisible?: boolean;
+    defaultSize?: Size;
+    minSize?: Size;
+    maxSize?: Size;
+};
+export type LayoutConfig = {
+    sidebar?: SidePanelConfig;
+    rightPanel?: SidePanelConfig;
+    content?: PanelConfig;
+    splitview?: PanelConfig;
+};
+export type LayoutAction = {
+    type: "setVisible";
+    slot: SlotKey;
+    visible: boolean;
+} | {
+    type: "setVariant";
+    panel: SidePanelKey;
+    variant: Variant;
+} | {
+    type: "resize";
+    slot: SlotKey;
+    size: Size;
+}
+/** Restore one slot (or all, if omitted) to its config-default state.
+ *  Page panels default hidden, so this also hides them — handy on unmount. */
+ | {
+    type: "reset";
+    slot?: SlotKey;
+};
+export type LayoutReducer = (state: LayoutState, action: LayoutAction, 
+/** Config-default state, used by the `reset` action. */
+initial?: LayoutState) => LayoutState;
+/**
+ * Replaceable state engine. Matches `useSyncExternalStore` + zustand/redux
+ * conventions. The manager depends only on this interface, so a zustand-backed
+ * store can be injected via `<LayoutProvider store={…}>`.
+ */
+export type LayoutStore = {
+    getState: () => LayoutState;
+    dispatch: (action: LayoutAction) => void;
+    subscribe: (listener: () => void) => () => void;
+};
+export type LayoutStorage = {
+    getItem: (key: string) => string | null;
+    setItem: (key: string, value: string) => void;
+};
+export type SidePanelHandle = {
+    state: SidePanelState;
+    isVisible: boolean;
+    show: () => void;
+    hide: () => void;
+    resize: (size: Size) => void;
+    setVariant: (variant: Variant) => void;
+    /** Restore this slot to its config default (hides it for page panels). */
+    reset: () => void;
+};
+export type PanelHandle = {
+    state: PanelState;
+    isVisible: boolean;
+    show: () => void;
+    hide: () => void;
+    resize: (size: Size) => void;
+    /** Restore this slot to its config default (hides it for page panels). */
+    reset: () => void;
+};
+export type LayoutValue = {
+    state: LayoutState;
+    sidebar: SidePanelHandle;
+    rightPanel: SidePanelHandle;
+    content: PanelHandle;
+    splitview: PanelHandle;
+};
+export type SidePanelProps = {
+    children: React.ReactNode;
+    variant?: Variant;
+    collapsible?: boolean;
+    defaultSize?: Size;
+    minSize?: Size;
+    maxSize?: Size;
+    /** Called whenever the panel's visibility changes, with the new value. */
+    onVisibleChange?: (visible: boolean) => void;
+};
+export type ContentProps = {
+    children: React.ReactNode;
+    minSize?: Size;
+    maxSize?: Size;
+};
+export type SplitProps = {
+    children: React.ReactNode;
+    defaultSize?: Size;
+    minSize?: Size;
+    maxSize?: Size;
+};
+export type LayoutProviderProps = {
+    children: React.ReactNode;
+    config?: LayoutConfig;
+    store?: LayoutStore;
+    /** Persistence config for the whole layout namespace. The Provider does NOT
+     *  read these — it publishes them to the nested `<Layout>` (which owns
+     *  persistence). Kept here so consumers configure everything in one place. */
+    persistenceKey?: string;
+    storage?: LayoutStorage;
+};
+export type LayoutProps = {
+    children: React.ReactNode;
+    /** Persist panel SIZES (via react-resizable-panels), keyed by this. Open/
+     *  visible/variant ("intent") persistence is separate and deferred. Falls
+     *  back to the values on `Layout.Provider` when omitted. */
+    persistenceKey?: string;
+    storage?: LayoutStorage;
+};
+/**
+ * Title shown in the panel header. `label` always provides the panel's
+ * accessible name (even when the title block is visually hidden).
+ */
+export type RightPanelContainerTitle = {
+    /** Visible label and the panel's accessible name. */
+    label: string;
+    /** Optional leading icon. */
+    icon?: IconProps;
+    /** Show the visible label+icon block. Default `true`. When `false` the block
+     *  is hidden but `label` is still exposed as the accessible name. */
+    isVisible?: boolean;
+};
+export type RightPanelContainerSlotProps = {
+    /** Header slots around the title. */
+    header?: {
+        /** Rendered at the header start, before the title. */
+        leftSlot?: React.ReactNode;
+        /** Rendered at the header end, after the title and before the close button. */
+        rightSlot?: React.ReactNode;
+    };
+    /** Sticky footer content. Footer is omitted entirely when not provided. */
+    footer?: React.ReactNode;
+    /** Props for the always-rendered close button. */
+    closeButton: {
+        "aria-label": string;
+    };
+};
+export type RightPanelContainerProps = {
+    title: RightPanelContainerTitle;
+    /** Scrollable body content. */
+    children: React.ReactNode;
+    /** Called when the (always rendered) close button is clicked. */
+    onClose?: () => void;
+    slotProps: RightPanelContainerSlotProps;
+    /** Forwarded to the scrollable body element (scroll restoration etc.). */
+    scrollContainerRef?: React.Ref<HTMLDivElement>;
+    /** Forwarded to the scrollable body's scroll handler. */
+    onScroll?: React.UIEventHandler<HTMLDivElement>;
+    "data-e2e-test-id"?: string;
+};
+export type RightPanelProps = SidePanelProps & Omit<RightPanelContainerProps, "data-e2e-test-id">;

package/build/esm/components/Layout/-types.js

@@ -0,0 +1 @@
+export{};

package/build/esm/components/Layout/Content.d.ts

@@ -0,0 +1,7 @@
+import type React from "react";
+import type { ContentProps } from "./-types";
+/**
+ * Primary content panel. Always shown (never collapsible) and flexes to fill the
+ * space the side panels leave. Declares the `content` slot and portals into it.
+ */
+export declare const Content: React.FC<ContentProps>;

package/build/esm/components/Layout/Content.js

@@ -0,0 +1 @@
+import{Slot}from"./-constants";import{useDeclarePanel,useLayoutPortal}from"./registry";export const Content=({children,minSize,maxSize})=>(useDeclarePanel(Slot.content,{minSize,maxSize,collapsible:!1}),useLayoutPortal(Slot.content,children));

package/build/esm/components/Layout/Layout.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import { LayoutProvider } from "./LayoutProvider";
+import { Content } from "./Content";
+import { RightPanel } from "./RightPanel";
+import { Sidebar } from "./Sidebar";
+import { Split } from "./Split";
+import type { LayoutProps } from "./-types";
+declare function LayoutBase({ children, persistenceKey, storage, }: LayoutProps): React.ReactElement;
+type LayoutComponent = typeof LayoutBase & {
+    Provider: typeof LayoutProvider;
+    Sidebar: typeof Sidebar;
+    RightPanel: typeof RightPanel;
+    Content: typeof Content;
+    Split: typeof Split;
+};
+export declare const Layout: LayoutComponent;
+export {};

package/build/esm/components/Layout/Layout.js

@@ -0,0 +1 @@
+import React,{useMemo,useState}from"react";import styled from"@emotion/styled";import{Panel}from"../Internal/Panel/Panel";import{PANEL_ORDER,Slot}from"./-constants";import{useLayoutPersistence}from"./context";import{LayoutProvider}from"./LayoutProvider";import{Content}from"./Content";import{RightPanel}from"./RightPanel";import{Sidebar}from"./Sidebar";import{Split}from"./Split";import{LayoutPortalContext,PanelRegistryContext}from"./registry";import{usePortalContainerRefs}from"./usePortalContainerRefs";import{useLayout}from"./useLayout";let StyledLayout=styled("div",{target:"eu1s17s0",label:"StyledLayout"})({position:"relative",height:"100%",width:"100%"},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Layout/Layout.tsx","sources":["src/components/Layout/Layout.tsx"],"sourcesContent":["import React, { useMemo, useState } from \"react\";\nimport styled from \"@emotion/styled\";\nimport { Panel } from \"../Internal/Panel/Panel\";\nimport type { PanelItem } from \"../Internal/Panel/Panel\";\nimport { PANEL_ORDER, Slot } from \"./-constants\";\nimport { useLayoutPersistence } from \"./context\";\nimport { LayoutProvider } from \"./LayoutProvider\";\nimport { Content } from \"./Content\";\nimport { RightPanel } from \"./RightPanel\";\nimport { Sidebar } from \"./Sidebar\";\nimport { Split } from \"./Split\";\nimport {\n  LayoutPortalContext,\n  PanelRegistryContext,\n  type PanelReg,\n  type PanelRegistry,\n} from \"./registry\";\nimport { usePortalContainerRefs } from \"./usePortalContainerRefs\";\nimport { useLayout } from \"./useLayout\";\nimport type { LayoutProps, Size, SlotKey } from \"./-types\";\n\n/* -------------------------------------------------------------------------- */\n/* Layout — registry + hosts; markers declare/portal; the resizable panel row   */\n/* -------------------------------------------------------------------------- */\n\nconst StyledLayout = styled.div({\n  position: \"relative\",\n  height: \"100%\",\n  width: \"100%\",\n});\n\n// Solo-mode host: a lone panel (no resizable sibling) is hosted here instead of\n// inside react-resizable-panels. Matches the per-panel host the Group renders\n// (`relative` + full-bleed) so content reflows/scrolls identically either way.\nconst StyledSoloHost = styled.div({\n  position: \"relative\",\n  height: \"100%\",\n  width: \"100%\",\n});\n\nfunction LayoutBase({\n  children,\n  persistenceKey,\n  storage,\n}: LayoutProps): React.ReactElement {\n  const [declared, setDeclared] = useState<Partial<Record<SlotKey, PanelReg>>>(\n    {}\n  );\n  const { state: layoutState, ...panelCallbacks } = useLayout();\n  const persistence = useLayoutPersistence();\n  const resolvedKey = persistenceKey ?? persistence.persistenceKey;\n  const resolvedStorage = storage ?? persistence.storage;\n\n  const isShown = (slot: SlotKey): boolean => layoutState[slot].visible;\n\n  const registry = useMemo<PanelRegistry>(\n    () => ({\n      register: (slot, reg) =>\n        setDeclared((prev) => ({ ...prev, [slot]: reg })),\n      unregister: (slot) =>\n        setDeclared((prev) => {\n          if (!(slot in prev)) return prev;\n          const next = { ...prev };\n          delete next[slot];\n          return next;\n        }),\n    }),\n    []\n  );\n\n  const [nodes, hostRefs] = usePortalContainerRefs(PANEL_ORDER);\n\n  // Panels that exist in the layout, regardless of visibility. Drives the\n  // solo-vs-resizable decision below — keyed on DECLARED (not shown) so that\n  // showing/hiding a panel never flips the mode.\n  const declaredSlots = PANEL_ORDER.filter((slot) => declared[slot]);\n\n  // Solo mode: a single panel is declared (e.g. just `Content`, with no\n  // RightPanel/Sidebar/Split in the tree) — nothing to resize against, so host\n  // it in a plain div and skip react-resizable-panels entirely. Because the\n  // check is on DECLARED panels, toggling a *declared* panel's visibility keeps\n  // the mode stable, so `Content` is never remounted by a show/hide. The mode\n  // only flips when a panel marker is added to / removed from the tree (a\n  // structural change), where a one-time remount is acceptable.\n  const isSolo = declaredSlots.length <= 1;\n  const soloSlot = declaredSlots[0];\n\n  // content flexes (no fixed size); others use the declared default, falling\n  // back to the persisted/config size.\n  const defaultSizeFor = (slot: SlotKey): Size | undefined => {\n    if (slot === Slot.content) return undefined;\n    return declared[slot]?.defaultSize ?? layoutState[slot].size;\n  };\n\n  // Only the panels that are declared AND currently shown. Closed/hidden panels\n  // are not rendered at all — no reserved space.\n  const panelItems: PanelItem[] = PANEL_ORDER.filter(\n    (slot) => declared[slot] && isShown(slot)\n  ).map((slot) => ({\n    id: slot,\n    defaultSize: defaultSizeFor(slot),\n    minSize: declared[slot]?.minSize ?? layoutState[slot].minSize,\n    maxSize: declared[slot]?.maxSize ?? layoutState[slot].maxSize,\n    collapsible: slot !== Slot.content && (declared[slot]?.collapsible ?? true),\n  }));\n\n  return (\n    <PanelRegistryContext.Provider value={registry}>\n      <LayoutPortalContext.Provider value={nodes}>\n        <StyledLayout data-ds-id=\"Layout\">\n          {isSolo\n            ? // Lone panel — host it in a plain div, no resizable Group. Hidden\n              // lone panels render nothing (Content is always shown).\n              soloSlot &&\n              isShown(soloSlot) && <StyledSoloHost ref={hostRefs[soloSlot]} />\n            : panelItems.length > 0 && (\n                // `key` = the persistence namespace. react-resizable-panels\n                // reads stored sizes only on mount, and this group stays\n                // mounted across navigation — so remount it when the key\n                // changes to load THAT instance's sizes. Use case:\n                // per-route/per-instance size memory (e.g.\n                // `persistenceKey={`layout:${routeId}`}`) — drag the chat wide\n                // on page A, switch to page B (its own widths), come back to A\n                // and find A's widths restored. The key only changes on\n                // instance switch, never on panel open/close, so normal\n                // toggling stays remount-free.\n                <Panel\n                  key={resolvedKey}\n                  panels={panelItems}\n                  persistenceKey={resolvedKey}\n                  storage={resolvedStorage}\n                  hostFor={(id) => hostRefs[id as SlotKey]}\n                  onResize={(id, size) =>\n                    panelCallbacks[id as SlotKey].resize(size)\n                  }\n                  onCollapse={(id) => panelCallbacks[id as SlotKey].hide()}\n                />\n              )}\n          {children}\n        </StyledLayout>\n      </LayoutPortalContext.Provider>\n    </PanelRegistryContext.Provider>\n  );\n}\n\n/* -------------------------------------------------------------------------- */\n/* Public Layout — the resizable panel row + compound parts as statics         */\n/* -------------------------------------------------------------------------- */\n\ntype LayoutComponent = typeof LayoutBase & {\n  Provider: typeof LayoutProvider;\n  Sidebar: typeof Sidebar;\n  RightPanel: typeof RightPanel;\n  Content: typeof Content;\n  Split: typeof Split;\n};\n\nexport const Layout = LayoutBase as LayoutComponent;\n\nLayout.Provider = LayoutProvider;\nLayout.Sidebar = Sidebar;\nLayout.RightPanel = RightPanel;\nLayout.Content = Content;\nLayout.Split = Split;\n"],"names":[],"mappings":"AAyBqB"} */"),StyledSoloHost=styled("div",{target:"eu1s17s1",label:"StyledSoloHost"})({position:"relative",height:"100%",width:"100%"},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Layout/Layout.tsx","sources":["src/components/Layout/Layout.tsx"],"sourcesContent":["import React, { useMemo, useState } from \"react\";\nimport styled from \"@emotion/styled\";\nimport { Panel } from \"../Internal/Panel/Panel\";\nimport type { PanelItem } from \"../Internal/Panel/Panel\";\nimport { PANEL_ORDER, Slot } from \"./-constants\";\nimport { useLayoutPersistence } from \"./context\";\nimport { LayoutProvider } from \"./LayoutProvider\";\nimport { Content } from \"./Content\";\nimport { RightPanel } from \"./RightPanel\";\nimport { Sidebar } from \"./Sidebar\";\nimport { Split } from \"./Split\";\nimport {\n  LayoutPortalContext,\n  PanelRegistryContext,\n  type PanelReg,\n  type PanelRegistry,\n} from \"./registry\";\nimport { usePortalContainerRefs } from \"./usePortalContainerRefs\";\nimport { useLayout } from \"./useLayout\";\nimport type { LayoutProps, Size, SlotKey } from \"./-types\";\n\n/* -------------------------------------------------------------------------- */\n/* Layout — registry + hosts; markers declare/portal; the resizable panel row   */\n/* -------------------------------------------------------------------------- */\n\nconst StyledLayout = styled.div({\n  position: \"relative\",\n  height: \"100%\",\n  width: \"100%\",\n});\n\n// Solo-mode host: a lone panel (no resizable sibling) is hosted here instead of\n// inside react-resizable-panels. Matches the per-panel host the Group renders\n// (`relative` + full-bleed) so content reflows/scrolls identically either way.\nconst StyledSoloHost = styled.div({\n  position: \"relative\",\n  height: \"100%\",\n  width: \"100%\",\n});\n\nfunction LayoutBase({\n  children,\n  persistenceKey,\n  storage,\n}: LayoutProps): React.ReactElement {\n  const [declared, setDeclared] = useState<Partial<Record<SlotKey, PanelReg>>>(\n    {}\n  );\n  const { state: layoutState, ...panelCallbacks } = useLayout();\n  const persistence = useLayoutPersistence();\n  const resolvedKey = persistenceKey ?? persistence.persistenceKey;\n  const resolvedStorage = storage ?? persistence.storage;\n\n  const isShown = (slot: SlotKey): boolean => layoutState[slot].visible;\n\n  const registry = useMemo<PanelRegistry>(\n    () => ({\n      register: (slot, reg) =>\n        setDeclared((prev) => ({ ...prev, [slot]: reg })),\n      unregister: (slot) =>\n        setDeclared((prev) => {\n          if (!(slot in prev)) return prev;\n          const next = { ...prev };\n          delete next[slot];\n          return next;\n        }),\n    }),\n    []\n  );\n\n  const [nodes, hostRefs] = usePortalContainerRefs(PANEL_ORDER);\n\n  // Panels that exist in the layout, regardless of visibility. Drives the\n  // solo-vs-resizable decision below — keyed on DECLARED (not shown) so that\n  // showing/hiding a panel never flips the mode.\n  const declaredSlots = PANEL_ORDER.filter((slot) => declared[slot]);\n\n  // Solo mode: a single panel is declared (e.g. just `Content`, with no\n  // RightPanel/Sidebar/Split in the tree) — nothing to resize against, so host\n  // it in a plain div and skip react-resizable-panels entirely. Because the\n  // check is on DECLARED panels, toggling a *declared* panel's visibility keeps\n  // the mode stable, so `Content` is never remounted by a show/hide. The mode\n  // only flips when a panel marker is added to / removed from the tree (a\n  // structural change), where a one-time remount is acceptable.\n  const isSolo = declaredSlots.length <= 1;\n  const soloSlot = declaredSlots[0];\n\n  // content flexes (no fixed size); others use the declared default, falling\n  // back to the persisted/config size.\n  const defaultSizeFor = (slot: SlotKey): Size | undefined => {\n    if (slot === Slot.content) return undefined;\n    return declared[slot]?.defaultSize ?? layoutState[slot].size;\n  };\n\n  // Only the panels that are declared AND currently shown. Closed/hidden panels\n  // are not rendered at all — no reserved space.\n  const panelItems: PanelItem[] = PANEL_ORDER.filter(\n    (slot) => declared[slot] && isShown(slot)\n  ).map((slot) => ({\n    id: slot,\n    defaultSize: defaultSizeFor(slot),\n    minSize: declared[slot]?.minSize ?? layoutState[slot].minSize,\n    maxSize: declared[slot]?.maxSize ?? layoutState[slot].maxSize,\n    collapsible: slot !== Slot.content && (declared[slot]?.collapsible ?? true),\n  }));\n\n  return (\n    <PanelRegistryContext.Provider value={registry}>\n      <LayoutPortalContext.Provider value={nodes}>\n        <StyledLayout data-ds-id=\"Layout\">\n          {isSolo\n            ? // Lone panel — host it in a plain div, no resizable Group. Hidden\n              // lone panels render nothing (Content is always shown).\n              soloSlot &&\n              isShown(soloSlot) && <StyledSoloHost ref={hostRefs[soloSlot]} />\n            : panelItems.length > 0 && (\n                // `key` = the persistence namespace. react-resizable-panels\n                // reads stored sizes only on mount, and this group stays\n                // mounted across navigation — so remount it when the key\n                // changes to load THAT instance's sizes. Use case:\n                // per-route/per-instance size memory (e.g.\n                // `persistenceKey={`layout:${routeId}`}`) — drag the chat wide\n                // on page A, switch to page B (its own widths), come back to A\n                // and find A's widths restored. The key only changes on\n                // instance switch, never on panel open/close, so normal\n                // toggling stays remount-free.\n                <Panel\n                  key={resolvedKey}\n                  panels={panelItems}\n                  persistenceKey={resolvedKey}\n                  storage={resolvedStorage}\n                  hostFor={(id) => hostRefs[id as SlotKey]}\n                  onResize={(id, size) =>\n                    panelCallbacks[id as SlotKey].resize(size)\n                  }\n                  onCollapse={(id) => panelCallbacks[id as SlotKey].hide()}\n                />\n              )}\n          {children}\n        </StyledLayout>\n      </LayoutPortalContext.Provider>\n    </PanelRegistryContext.Provider>\n  );\n}\n\n/* -------------------------------------------------------------------------- */\n/* Public Layout — the resizable panel row + compound parts as statics         */\n/* -------------------------------------------------------------------------- */\n\ntype LayoutComponent = typeof LayoutBase & {\n  Provider: typeof LayoutProvider;\n  Sidebar: typeof Sidebar;\n  RightPanel: typeof RightPanel;\n  Content: typeof Content;\n  Split: typeof Split;\n};\n\nexport const Layout = LayoutBase as LayoutComponent;\n\nLayout.Provider = LayoutProvider;\nLayout.Sidebar = Sidebar;\nLayout.RightPanel = RightPanel;\nLayout.Content = Content;\nLayout.Split = Split;\n"],"names":[],"mappings":"AAkCuB"} */");export const Layout=function({children,persistenceKey,storage}){let[declared,setDeclared]=useState({}),{state:layoutState,...panelCallbacks}=useLayout(),persistence=useLayoutPersistence(),resolvedKey=persistenceKey??persistence.persistenceKey,resolvedStorage=storage??persistence.storage,isShown=slot=>layoutState[slot].visible,registry=useMemo(()=>({register:(slot,reg)=>setDeclared(prev=>({...prev,[slot]:reg})),unregister:slot=>setDeclared(prev=>{if(!(slot in prev))return prev;let next={...prev};return delete next[slot],next})}),[]),[nodes,hostRefs]=usePortalContainerRefs(PANEL_ORDER),declaredSlots=PANEL_ORDER.filter(slot=>declared[slot]),isSolo=declaredSlots.length<=1,soloSlot=declaredSlots[0],defaultSizeFor=slot=>{if(slot!==Slot.content)return declared[slot]?.defaultSize??layoutState[slot].size},panelItems=PANEL_ORDER.filter(slot=>declared[slot]&&isShown(slot)).map(slot=>({id:slot,defaultSize:defaultSizeFor(slot),minSize:declared[slot]?.minSize??layoutState[slot].minSize,maxSize:declared[slot]?.maxSize??layoutState[slot].maxSize,collapsible:slot!==Slot.content&&(declared[slot]?.collapsible??!0)}));return React.createElement(PanelRegistryContext.Provider,{value:registry},React.createElement(LayoutPortalContext.Provider,{value:nodes},React.createElement(StyledLayout,{"data-ds-id":"Layout"},isSolo?soloSlot&&isShown(soloSlot)&&React.createElement(StyledSoloHost,{ref:hostRefs[soloSlot]}):panelItems.length>0&&React.createElement(Panel,{key:resolvedKey,panels:panelItems,persistenceKey:resolvedKey,storage:resolvedStorage,hostFor:id=>hostRefs[id],onResize:(id,size)=>panelCallbacks[id].resize(size),onCollapse:id=>panelCallbacks[id].hide()}),children)))};Layout.Provider=LayoutProvider,Layout.Sidebar=Sidebar,Layout.RightPanel=RightPanel,Layout.Content=Content,Layout.Split=Split;

package/build/esm/components/Layout/LayoutProvider.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import type { LayoutProviderProps } from "./-types";
+/**
+ * Owns the state engine + the public persistence-config surface. Mount once,
+ * above the router. Pass `store` to replace the default vanilla engine with a
+ * zustand/redux-backed one; otherwise a default store is built from `config`.
+ *
+ * `storage`/`persistenceKey` are accepted here so consumers configure the whole
+ * layout in one provider — but the Provider **never reads storage itself**.
+ * It publishes them to the nested, which owns persistence.
+ * Two tracks: panel sizes (via react-resizable-panels, working today) and the panels'
+ * "intent" — open/visible/variant (restore on mount + save on store.subscribe, still deferred).
+ * That deferral is the default store's; a bring-your-own store can persist intent itself.
+ */
+export declare function LayoutProvider({ children, config, store, persistenceKey, storage, }: LayoutProviderProps): React.ReactElement;

package/build/esm/components/Layout/LayoutProvider.js

@@ -0,0 +1 @@
+import React,{useMemo,useRef}from"react";import{useTheme}from"@emotion/react";import{SLIDE_VAR}from"./-constants";import{LayoutPersistenceProvider,LayoutStoreProvider}from"./context";import{LayoutVars,LayoutVarStoreProvider,useLayoutVar}from"./LayoutVars";import{createLayoutVarStore}from"./varStore";import{createInitialState}from"./reducer";import{createLayoutStore}from"./store";function SlideVars(){let theme=useTheme(),open=theme.variables?.animation?.navSlide?.open;return useLayoutVar(SLIDE_VAR.duration,open?.duration??""),useLayoutVar(SLIDE_VAR.easing,open?.timingFunction??""),null}export function LayoutProvider({children,config,store,persistenceKey,storage}){let storeRef=useRef(null);null===storeRef.current&&(storeRef.current=store??createLayoutStore(createInitialState(config)));let varStoreRef=useRef(null);null===varStoreRef.current&&(varStoreRef.current=createLayoutVarStore());let persistence=useMemo(()=>({persistenceKey,storage}),[persistenceKey,storage]);return React.createElement(LayoutStoreProvider,{value:storeRef.current},React.createElement(LayoutPersistenceProvider,{value:persistence},React.createElement(LayoutVarStoreProvider,{value:varStoreRef.current},React.createElement(LayoutVars,null),React.createElement(SlideVars,null),children)))}

package/build/esm/components/Layout/LayoutVars.d.ts

@@ -0,0 +1,18 @@
+import React from "react";
+import type { LayoutVarStore } from "./varStore";
+export declare const LayoutVarStoreProvider: React.Provider<LayoutVarStore>;
+/**
+ * Publish one layout CSS var. Call it from the component that owns the logic of
+ * *why* the value changes (e.g. the subnav: `compact ? 0 : height`). The value
+ * is registered on mount/update and removed on unmount, so the var only exists
+ * while its producer is mounted. An empty-string value is treated as unset (the
+ * var is removed) — lets a producer opt out without breaking hook order. No-op
+ * outside a `Layout.Provider`.
+ */
+export declare function useLayoutVar(name: string, value: string): void;
+/**
+ * The single sink: renders every registered layout var in ONE place. Today it
+ * targets `:root`; to scope the vars to a host element later, change only this
+ * component — producers are untouched.
+ */
+export declare function LayoutVars(): React.ReactElement;

package/build/esm/components/Layout/LayoutVars.js

@@ -0,0 +1 @@
+import React,{createContext,useContext,useEffect,useSyncExternalStore}from"react";import{Global}from"@emotion/react";let LayoutVarStoreContext=createContext(null);export const LayoutVarStoreProvider=LayoutVarStoreContext.Provider;let EMPTY_VARS={},NOOP_SUBSCRIBE=()=>()=>{};export function useLayoutVar(name,value){let store=useContext(LayoutVarStoreContext);useEffect(()=>{if(store)return""===value?void store.remove(name):(store.set(name,value),()=>store.remove(name))},[store,name,value])}export function LayoutVars(){let vars=function(){let store=useContext(LayoutVarStoreContext);return useSyncExternalStore(store?.subscribe??NOOP_SUBSCRIBE,store?store.getSnapshot:()=>EMPTY_VARS,()=>EMPTY_VARS)}();return React.createElement(Global,{styles:[{":root":vars},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"]})}

package/build/esm/components/Layout/RightPanel.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { RightPanelProps } from "./-types";
+/**
+ * Right side panel. Declares the `rightPanel` slot and portals its content into
+ * the Group's host while visible. Renders in-flow (a resizable column) — the
+ * offcanvas overlay / mobile sheet is deferred. Content is wrapped in a slot
+ * that tracks the `--ds-layout-subnav-offset` var.
+ */
+export declare const RightPanel: React.FC<RightPanelProps>;

package/build/esm/components/Layout/RightPanel.js

@@ -0,0 +1 @@
+import React from"react";import styled from"@emotion/styled";import{SLIDE_VAR,Slot,SUBNAV_OFFSET_VAR}from"./-constants";import{useDeclarePanel,useLayoutPortal,useVisibleChange}from"./registry";import{useLayout}from"./useLayout";import{RightPanelContainer}from"./RightPanelContainer";let StyledRightPanelSlot=styled("div",{target:"e1jmp3pg0",label:"StyledRightPanelSlot"})({position:"absolute",left:0,right:0,bottom:0,top:`var(${SUBNAV_OFFSET_VAR}, 0px)`,overflow:"hidden",transition:`top var(${SLIDE_VAR.duration}) var(${SLIDE_VAR.easing})`},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export const RightPanel=({children,defaultSize=378,minSize=328,maxSize="30%",collapsible=!1,onVisibleChange,title,onClose,slotProps,scrollContainerRef,onScroll})=>{let{isVisible,hide}=useLayout()[Slot.rightPanel];return useDeclarePanel(Slot.rightPanel,{defaultSize,minSize,maxSize,collapsible}),useVisibleChange(isVisible,onVisibleChange),useLayoutPortal(Slot.rightPanel,isVisible?React.createElement(StyledRightPanelSlot,null,React.createElement(RightPanelContainer,{title:title,onClose:()=>{hide(),onClose?.()},slotProps:slotProps,scrollContainerRef:scrollContainerRef,onScroll:onScroll},children)):null)};

package/build/esm/components/Layout/RightPanelContainer.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import type { RightPanelContainerProps } from "./-types";
+export declare function RightPanelContainer({ title, children, onClose, slotProps, scrollContainerRef, onScroll, "data-e2e-test-id": dataE2eTestId, }: RightPanelContainerProps): React.ReactElement;

package/build/esm/components/Layout/RightPanelContainer.js

@@ -0,0 +1 @@
+import React from"react";import styled from"@emotion/styled";import{Sandwich}from"../Internal/Sandwich/Sandwich";import{Icon}from"../Icon/Icon";import{H5}from"../Typography/Header/Header";import{Box}from"../Box/Box";import{Inline}from"../Inline/Inline";import{PictogramButton}from"../PictogramButton/PictogramButton";import{Divider}from"../Divider/Divider";import{Container}from"../Container/Container";let CustomContainer=styled(Container,{target:"e5j03vd0",label:"CustomContainer"})({height:"100%"},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export function RightPanelContainer({title,children,onClose,slotProps,scrollContainerRef,onScroll,"data-e2e-test-id":dataE2eTestId}){let{isVisible:isTitleVisible=!0}=title;return React.createElement(CustomContainer,{elevation:0,squareCorners:!0,"data-ds-id":"RightPanelContainer","data-e2e-test-id":dataE2eTestId},React.createElement(Sandwich,{role:"region","aria-label":title.label},React.createElement(Sandwich.Header,{showSeparator:"always"},React.createElement(Box,{space:"s",vSpace:"xs"},React.createElement(Inline,{alignItems:"spaceBetween",vAlignItems:"center",noWrap:!0,fullWidth:!0},React.createElement(Inline,{space:"xs",vAlignItems:"center",noWrap:!0},slotProps.header?.leftSlot,isTitleVisible&&React.createElement(Inline,{space:"xs",vAlignItems:"center",noWrap:!0},title.icon&&React.createElement(Icon,title.icon),React.createElement(H5,null,title.label))),React.createElement(Inline,{space:"xxs",vAlignItems:"center",noWrap:!0},slotProps.header?.rightSlot,slotProps.header?.rightSlot&&React.createElement(Divider,{orientation:"vertical"}),React.createElement(PictogramButton,{icon:"x",size:"s",variant:"tertiary","aria-label":slotProps.closeButton["aria-label"],onClick:()=>onClose?.()}))))),React.createElement(Sandwich.Body,{scrollRef:scrollContainerRef,onScroll:onScroll},children),slotProps.footer&&React.createElement(Sandwich.Footer,{showSeparator:"never"},slotProps.footer)))}

package/build/esm/components/Layout/Sidebar.d.ts

@@ -0,0 +1,8 @@
+import type React from "react";
+import type { SidePanelProps } from "./-types";
+/**
+ * Left side panel. Declares the `sidebar` slot and portals its content into the
+ * Group's host while visible. Renders in-flow (a resizable column) — the
+ * offcanvas overlay / mobile sheet is deferred.
+ */
+export declare const Sidebar: React.FC<SidePanelProps>;

package/build/esm/components/Layout/Sidebar.js

@@ -0,0 +1 @@
+import{Slot}from"./-constants";import{useDeclarePanel,useLayoutPortal,useVisibleChange}from"./registry";import{useLayout}from"./useLayout";export const Sidebar=({children,defaultSize,minSize,maxSize,collapsible=!0,onVisibleChange})=>{let{isVisible}=useLayout()[Slot.sidebar];return useDeclarePanel(Slot.sidebar,{defaultSize,minSize,maxSize,collapsible}),useVisibleChange(isVisible,onVisibleChange),useLayoutPortal(Slot.sidebar,isVisible?children:null)};

package/build/esm/components/Layout/Split.d.ts

@@ -0,0 +1,7 @@
+import type React from "react";
+import type { SplitProps } from "./-types";
+/**
+ * Split view panel. Declares the `splitview` slot and portals its content while
+ * visible — a toggleable in-flow column beside `content`.
+ */
+export declare const Split: React.FC<SplitProps>;

package/build/esm/components/Layout/Split.js

@@ -0,0 +1 @@
+import{Slot}from"./-constants";import{useDeclarePanel,useLayoutPortal}from"./registry";import{useLayout}from"./useLayout";export const Split=({children,defaultSize,minSize,maxSize})=>{let{isVisible}=useLayout()[Slot.splitview];return useDeclarePanel(Slot.splitview,{defaultSize,minSize,maxSize,collapsible:!0}),useLayoutPortal(Slot.splitview,isVisible?children:null)};

package/build/esm/components/Layout/context.d.ts

@@ -0,0 +1,22 @@
+import type { LayoutState, LayoutStorage, LayoutStore } from "./-types";
+export declare const LayoutStoreProvider: React.Provider<LayoutStore>;
+/** Get the store from context, or throw if used outside the provider. */
+export declare function useLayoutStore(): LayoutStore;
+/**
+ * Persistence config for the layout namespace. Set on `Layout.Provider` (single
+ * external surface) and read by the nested `<Layout>`. The Provider only
+ * forwards it — it never touches storage itself.
+ */
+export type LayoutPersistence = {
+    persistenceKey?: string;
+    storage?: LayoutStorage;
+};
+export declare const LayoutPersistenceProvider: React.Provider<LayoutPersistence>;
+/** Persistence config from the nearest `Layout.Provider` (empty if none). */
+export declare function useLayoutPersistence(): LayoutPersistence;
+/**
+ * Subscribe to a slice of layout state via `useSyncExternalStore`. The selector
+ * should return a stable reference when nothing relevant changed — the reducer
+ * preserves references for untouched positions, so slice selectors are safe.
+ */
+export declare function useLayoutSelector<T>(selector: (state: LayoutState) => T): T;

package/build/esm/components/Layout/context.js

@@ -0,0 +1 @@
+import{createContext,useContext,useSyncExternalStore}from"react";let LayoutStoreContext=createContext(null);export const LayoutStoreProvider=LayoutStoreContext.Provider;export function useLayoutStore(){let store=useContext(LayoutStoreContext);if(!store)throw Error("useLayout must be used within a <LayoutProvider>.");return store}let LayoutPersistenceContext=createContext({});export const LayoutPersistenceProvider=LayoutPersistenceContext.Provider;export function useLayoutPersistence(){return useContext(LayoutPersistenceContext)}export function useLayoutSelector(selector){let store=useLayoutStore(),getSnapshot=()=>selector(store.getState());return useSyncExternalStore(store.subscribe,getSnapshot,getSnapshot)}

package/build/esm/components/Layout/index.d.ts

@@ -0,0 +1,9 @@
+export { SLIDE_VAR, SUBNAV_OFFSET_VAR } from "./-constants";
+export { Layout } from "./Layout";
+export { LayoutProvider } from "./LayoutProvider";
+export { useLayoutVar } from "./LayoutVars";
+export { useLayout } from "./useLayout";
+export { RightPanelContainer } from "./RightPanelContainer";
+export { createLayoutStore } from "./store";
+export { createInitialState, layoutReducer } from "./reducer";
+export * from "./-types";

package/build/esm/components/Layout/index.js

@@ -0,0 +1 @@
+export{SLIDE_VAR,SUBNAV_OFFSET_VAR}from"./-constants";export{Layout}from"./Layout";export{LayoutProvider}from"./LayoutProvider";export{useLayoutVar}from"./LayoutVars";export{useLayout}from"./useLayout";export{RightPanelContainer}from"./RightPanelContainer";export{createLayoutStore}from"./store";export{createInitialState,layoutReducer}from"./reducer";export*from"./-types";

package/build/esm/components/Layout/reducer.d.ts

@@ -0,0 +1,5 @@
+import type { LayoutConfig, LayoutReducer, LayoutState } from "./-types";
+/** Build the initial state from optional config. */
+export declare function createInitialState(config?: LayoutConfig): LayoutState;
+/** Pure reducer. Returns the same reference when nothing changes. */
+export declare const layoutReducer: LayoutReducer;

package/build/esm/components/Layout/reducer.js

@@ -0,0 +1 @@
+function sidePanel(config={}){return{kind:"sidePanel",visible:config.defaultVisible??!0,collapsible:config.collapsible??!0,variant:config.variant??"sidebar",size:config.defaultSize,minSize:config.minSize,maxSize:config.maxSize}}function panelState(config={}){return{kind:"panel",visible:config.defaultVisible??!0,size:config.defaultSize,minSize:config.minSize,maxSize:config.maxSize}}export function createInitialState(config={}){return{sidebar:sidePanel(config.sidebar),rightPanel:sidePanel({defaultVisible:!1,...config.rightPanel}),content:panelState(config.content),splitview:panelState({defaultVisible:!1,...config.splitview})}}export const layoutReducer=(state,action,initial)=>{switch(action.type){case"setVisible":{let slot=state[action.slot];if(slot.visible===action.visible)return state;return{...state,[action.slot]:{...slot,visible:action.visible}}}case"setVariant":{let panel=state[action.panel];if(panel.variant===action.variant)return state;return{...state,[action.panel]:{...panel,variant:action.variant}}}case"resize":{let slot=state[action.slot];if(slot.size===action.size)return state;return{...state,[action.slot]:{...slot,size:action.size}}}case"reset":if(!initial)return state;if(!action.slot)return initial;if(state[action.slot]===initial[action.slot])return state;return{...state,[action.slot]:initial[action.slot]};default:return state}};

package/build/esm/components/Layout/registry.d.ts

@@ -0,0 +1,31 @@
+import { type ReactNode } from "react";
+import type { Size, SlotKey } from "./-types";
+export type HostNodes = Partial<Record<SlotKey, HTMLElement | null>>;
+export declare const LayoutPortalContext: React.Context<Partial<Record<"content" | "sidebar" | "splitview" | "rightPanel", HTMLElement>>>;
+/**
+ * Portal `children` into the host DOM node registered for `slot`. Returns the
+ * portal (or `null` if the host isn't mounted yet). Call unconditionally —
+ * gate content by passing `null` as `children`, not by skipping the call.
+ */
+export declare function useLayoutPortal(slot: SlotKey, children: ReactNode): ReactNode;
+/**
+ * Panel descriptor a marker contributes. The Group renders one resizable Panel
+ * per *declared* panel that is currently shown — regardless of nesting depth.
+ * So a page can drop `<Layout.Split>` deep in its tree and it joins the app's
+ * single Layout as a panel; toggling a panel never remounts the others.
+ */
+export type PanelReg = {
+    defaultSize?: Size;
+    minSize?: Size;
+    maxSize?: Size;
+    collapsible?: boolean;
+};
+export type PanelRegistry = {
+    register: (slot: SlotKey, reg: PanelReg) => void;
+    unregister: (slot: SlotKey) => void;
+};
+export declare const PanelRegistryContext: React.Context<PanelRegistry>;
+/** Register this slot as a panel for the marker's lifetime. */
+export declare function useDeclarePanel(slot: SlotKey, reg: PanelReg): void;
+/** Fire `onChange(visible)` when `visible` transitions (not on initial mount). */
+export declare function useVisibleChange(visible: boolean, onChange?: (visible: boolean) => void): void;

package/build/esm/components/Layout/registry.js

@@ -0,0 +1 @@
+import{createContext,useContext,useEffect,useLayoutEffect,useRef}from"react";import{createPortal}from"react-dom";export const LayoutPortalContext=createContext({});export function useLayoutPortal(slot,children){let slotNode=useContext(LayoutPortalContext)[slot]??null;return slotNode?createPortal(children,slotNode):null}export const PanelRegistryContext=createContext(null);export function useDeclarePanel(slot,reg){let registry=useContext(PanelRegistryContext),{defaultSize,minSize,maxSize,collapsible}=reg;useLayoutEffect(()=>{if(registry)return registry.register(slot,{defaultSize,minSize,maxSize,collapsible}),()=>registry.unregister(slot)},[registry,slot,defaultSize,minSize,maxSize,collapsible])}export function useVisibleChange(visible,onChange){let prev=useRef(visible);useEffect(()=>{prev.current!==visible&&(prev.current=visible,onChange?.(visible))},[visible,onChange])}

package/build/esm/components/Layout/store.d.ts

@@ -0,0 +1,10 @@
+import type { LayoutState, LayoutStore } from "./-types";
+/**
+ * Default, dependency-free `LayoutStore` implementation: a tiny pub/sub wrapper
+ * around the pure `layoutReducer`. Skips notifying subscribers when an action is
+ * a no-op (reducer returns the same reference).
+ *
+ * Swap this for a zustand/redux-backed store by implementing the same
+ * `LayoutStore` interface — bindings and primitives are unaffected.
+ */
+export declare function createLayoutStore(initial: LayoutState): LayoutStore;

package/build/esm/components/Layout/store.js

@@ -0,0 +1 @@
+import{layoutReducer}from"./reducer";export function createLayoutStore(initial){let state=initial,listeners=new Set;return{getState:()=>state,dispatch:action=>{let next=layoutReducer(state,action,initial);next!==state&&(state=next,listeners.forEach(listener=>listener()))},subscribe:listener=>(listeners.add(listener),()=>{listeners.delete(listener)})}}

package/build/esm/components/Layout/useLayout.d.ts

@@ -0,0 +1,7 @@
+import type { LayoutValue } from "./-types";
+/**
+ * The single control hook. Returns `state` plus a typed handle per slot. Works
+ * from any descendant of `<LayoutProvider>` — remote control without prop
+ * drilling.
+ */
+export declare function useLayout(): LayoutValue;

package/build/esm/components/Layout/useLayout.js

@@ -0,0 +1 @@
+import{useLayoutSelector,useLayoutStore}from"./context";let selectAll=state=>state;function sidePanelHandle(panel,state,dispatch){let slot=state[panel];return{state:slot,isVisible:slot.visible,show:()=>dispatch({type:"setVisible",slot:panel,visible:!0}),hide:()=>dispatch({type:"setVisible",slot:panel,visible:!1}),resize:size=>dispatch({type:"resize",slot:panel,size}),setVariant:variant=>dispatch({type:"setVariant",panel,variant}),reset:()=>dispatch({type:"reset",slot:panel})}}function panelHandle(panel,state,dispatch){let slot=state[panel];return{state:slot,isVisible:slot.visible,show:()=>dispatch({type:"setVisible",slot:panel,visible:!0}),hide:()=>dispatch({type:"setVisible",slot:panel,visible:!1}),resize:size=>dispatch({type:"resize",slot:panel,size}),reset:()=>dispatch({type:"reset",slot:panel})}}export function useLayout(){let store=useLayoutStore(),state=useLayoutSelector(selectAll),{dispatch}=store;return{state,sidebar:sidePanelHandle("sidebar",state,dispatch),rightPanel:sidePanelHandle("rightPanel",state,dispatch),content:panelHandle("content",state,dispatch),splitview:panelHandle("splitview",state,dispatch)}}

package/build/esm/components/Layout/usePanelRefs.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Track a set of DOM elements by key, with stable per-key ref callbacks.
+ *
+ * Given a fixed list of keys, returns `[elements, refs]`:
+ *  - `refs[key]` — a ref callback to attach to an element; captures it into
+ *    `elements[key]` (and clears it to `null` on unmount).
+ *  - `elements[key]` — the currently-attached element (undefined until set).
+ *
+ * The callbacks are **stable** across renders, so React invokes them only on
+ * mount/unmount — not detach/attach every render. (An inline `ref={el => …}`
+ * that calls setState would get a new identity each render and loop.)
+ *
+ * Agnostic utility — useful whenever something needs the live DOM node of a
+ * child: portal targets, measurement, focus management, etc.
+ */
+export declare function usePanelRefs<K extends string>(keys: readonly K[]): [
+    Partial<Record<K, HTMLElement | null>>,
+    Record<K, (el: HTMLElement | null) => void>
+];

package/build/esm/components/Layout/usePanelRefs.js

@@ -0,0 +1 @@
+import{useMemo,useState}from"react";export function usePanelRefs(keys){let[elements,setElements]=useState({});return[elements,useMemo(()=>{let map={};return keys.forEach(key=>{map[key]=el=>setElements(prev=>prev[key]===el?prev:{...prev,[key]:el})}),map},[keys])]}