@amboss/design-system 4.0.4 → 4.0.6

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

@@ -1,6 +1,6 @@
 import type React from "react";
 import type { PanelKey, SidePanelKey, SlotKey } from "./-constants";
-import type { IconProps } from "../Icon/Icon";
+import type { PanelHeaderTitle } from "../Internal/PanelHeader/PanelHeader";
 /**
  * Surface = compound components (`Layout.LeftPanel` / `Layout.RightPanel` /
  * `Layout.Content` / `Layout.Split`) + one control hook
@@ -17,8 +17,15 @@ export type Size = number | string;
  * - `offcanvas` - detached desktop overlay. ⚠️ **RESERVED - not implemented yet.**
  *   Currently treated like `sidebar` (renders in-flow); the overlay
  *   implementation lands in a later commit.
+ * - `float` - detached floating window pinned to the bottom-right viewport
+ *   corner. Right panel only - the per-slot unions below make `"float"`
+ *   unrepresentable on the left panel at compile time.
  */
-export type Variant = "sidebar" | "offcanvas";
+export type Variant = "sidebar" | "offcanvas" | "float";
+/** Variants the left panel supports (`float` is right-panel only). */
+export type LeftPanelVariant = Exclude<Variant, "float">;
+/** Variants the right panel supports (all of them). */
+export type RightPanelVariant = Variant;
 export type { PanelKey, SidePanelKey, SlotKey };
 export type SidePanelState = {
     kind: "sidePanel";
@@ -49,10 +56,10 @@ export type LayoutState = {
     content: PanelState;
     splitview: PanelState;
 };
-export type SidePanelConfig = {
+export type SidePanelConfig<V extends Variant = Variant> = {
     defaultVisible?: boolean;
     collapsible?: boolean;
-    variant?: Variant;
+    variant?: V;
     defaultSize?: Size;
     minSize?: Size;
     maxSize?: Size;
@@ -63,9 +70,23 @@ export type PanelConfig = {
     minSize?: Size;
     maxSize?: Size;
 };
+/**
+ * Master switch for the side/split panels.
+ * - `false` (default) - panel markers declare nothing and render nothing;
+ *   only `Layout.Content` shows.
+ * - `"mobile"` - only the mobile overlay presentations render (left-panel
+ *   drawer, right-panel sheet). They are portals, so the resizable row - and
+ *   with it the react-resizable-panels library - never mounts. Desktop
+ *   viewports show no panels.
+ * - `true` - everything: docked resizable columns, float window, drawer,
+ *   sheet.
+ */
+export type LayoutPanelsMode = boolean | "mobile";
 export type LayoutConfig = {
-    leftPanel?: SidePanelConfig;
-    rightPanel?: SidePanelConfig;
+    /** See {@link LayoutPanelsMode}. Default `false`. */
+    enablePanels?: LayoutPanelsMode;
+    leftPanel?: SidePanelConfig<LeftPanelVariant>;
+    rightPanel?: SidePanelConfig<RightPanelVariant>;
     content?: PanelConfig;
     splitview?: PanelConfig;
 };
@@ -105,7 +126,7 @@ export type LayoutStorage = {
     getItem: (key: string) => string | null;
     setItem: (key: string, value: string) => void;
 };
-export type SidePanelHandle = {
+export type SidePanelHandle<V extends Variant = Variant> = {
     /** Live state for this slot (visibility, size, variant). */
     state: SidePanelState;
     /** Whether the slot is currently shown. */
@@ -116,8 +137,9 @@ export type SidePanelHandle = {
     hide: () => void;
     /** Set the slot size (number = px, unitless string = %). */
     resize: (size: Size) => void;
-    /** Switch render variant (reserved - `offcanvas` not implemented). */
-    setVariant: (variant: Variant) => void;
+    /** Switch render variant. The union is per-slot: `"float"` compiles only on
+     *  the right panel; `offcanvas` stays reserved (not implemented). */
+    setVariant: (variant: V) => void;
     /** Restore this slot to its config default (hides it for page panels). */
     reset: () => void;
 };
@@ -132,14 +154,18 @@ export type PanelHandle = {
 };
 export type LayoutValue = {
     state: LayoutState;
-    leftPanel: SidePanelHandle;
-    rightPanel: SidePanelHandle;
+    leftPanel: SidePanelHandle<LeftPanelVariant>;
+    rightPanel: SidePanelHandle<RightPanelVariant>;
     content: PanelHandle;
     splitview: PanelHandle;
 };
-export type SidePanelProps = {
+export type SidePanelProps<V extends Variant = Variant> = {
+    /** Panel content in source order. Header/footer components
+     *  (e.g. `<Layout.LeftPanelHeader />`) stick to the edges; the rest scrolls. */
     children: React.ReactNode;
-    variant?: Variant;
+    /** Accessible name; when set, the panel renders as a `region` landmark. */
+    "aria-label"?: string;
+    variant?: V;
     collapsible?: boolean;
     /** Number = pixels, unitless string = percent (e.g. `"30%"`). */
     defaultSize?: Size;
@@ -148,6 +174,11 @@ export type SidePanelProps = {
     /** Called whenever the panel's visibility changes, with the new value. */
     onVisibleChange?: (visible: boolean) => void;
 };
+export type LeftPanelProps = SidePanelProps & {
+    /** Accessible name for the panel. Used to label the modal drawer it renders
+     *  as on mobile (`role="dialog"`). Ignored by the docked desktop panel. */
+    "aria-label": string;
+};
 export type ContentProps = {
     children: React.ReactNode;
     /** Number = pixels, unitless string = percent (e.g. `"30%"`). */
@@ -155,7 +186,11 @@ export type ContentProps = {
     maxSize?: Size;
 };
 export type SplitProps = {
+    /** Panel content in source order. `<Layout.SplitHeader />` /
+     *  `<Layout.SplitFooter />` children stick to the edges; the rest scrolls. */
     children: React.ReactNode;
+    /** Accessible name; when set, the panel renders as a `region` landmark. */
+    "aria-label"?: string;
     /** Number = pixels, unitless string = percent (e.g. `"30%"`). */
     defaultSize?: Size;
     minSize?: Size;
@@ -178,44 +213,78 @@ export type LayoutProps = {
     storage?: LayoutStorage;
 };
 /**
- * Title shown in the panel header. `label` always provides the panel's
- * accessible name (even when the title block is visually hidden).
+ * Shared contract of the per-panel header components
+ * (`Layout.LeftPanelHeader` / `Layout.RightPanelHeader` / `Layout.SplitHeader`).
+ * Place among the panel's children; it sticks to the top.
  */
-export type RightPanelContainerTitle = {
-    /** Visible label and the panel's accessible name. */
-    label: string;
-    /** Optional leading icon. Decorative — the visible title label names it. */
-    icon?: Omit<IconProps, "size" | "aria-label" | "aria-labelledby" | "role">;
-    /** 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. */
+export type PanelSlotHeaderProps = {
+    /** Rendered at the header start. */
+    leftSlot?: React.ReactNode;
+    /** Rendered at the header end. */
+    rightSlot?: React.ReactNode;
+    "data-e2e-test-id"?: string;
+};
+/**
+ * Shared contract of the per-panel footer components
+ * (`Layout.LeftPanelFooter` / `Layout.RightPanelFooter` / `Layout.SplitFooter`).
+ * Place among the panel's children; it sticks to the bottom.
+ */
+export type PanelSlotFooterProps = {
+    children: React.ReactNode;
+    "data-e2e-test-id"?: string;
+};
+export type LeftPanelHeaderProps = PanelSlotHeaderProps;
+export type LeftPanelFooterProps = PanelSlotFooterProps;
+/**
+ * Title shown in the right panel header, after `leftSlot`. Visual only — the
+ * panel's accessible name comes from `Layout.RightPanel`'s `aria-label`.
+ */
+export type RightPanelHeaderTitle = PanelHeaderTitle;
+export type RightPanelHeaderSlotProps = {
+    /** Props for the built-in close button, rendered at the header end after
+     *  `rightSlot`. Clicking it hides the panel. */
     closeButton: {
         "aria-label": string;
     };
+    /** Props for the built-in variant-toggle button, rendered before the close
+     *  button. Docked it minimizes the panel into the floating window
+     *  (`minimizeLabel`); floating it docks the panel back (`dockLabel`). */
+    variantButton: {
+        minimizeLabel: string;
+        dockLabel: string;
+    };
+};
+export type RightPanelHeaderProps = PanelSlotHeaderProps & {
+    /** Title block (icon + heading), rendered after `leftSlot`. */
+    title?: RightPanelHeaderTitle;
+    /** Props forwarded to internal sub-components. */
+    slotProps: RightPanelHeaderSlotProps;
 };
-export type RightPanelContainerProps = {
-    title: RightPanelContainerTitle;
-    /** Scrollable body content. */
+export type RightPanelFooterProps = PanelSlotFooterProps;
+export type SplitHeaderProps = PanelSlotHeaderProps;
+export type SplitFooterProps = PanelSlotFooterProps;
+export type PanelContainerProps = {
+    /** Content in source order. Per-panel header/footer components stick to the
+     *  edges; everything else scrolls. */
     children: React.ReactNode;
-    /** Called when the (always rendered) close button is clicked. */
-    onClose?: () => void;
-    slotProps: RightPanelContainerSlotProps;
+    /** Accessible name; when set, the container renders as a `region` landmark. */
+    "aria-label"?: string;
+    /** Forwarded to the scroll container element (scroll restoration etc.). */
+    scrollContainerRef?: React.Ref<HTMLDivElement>;
+    /** Forwarded to the scroll container's scroll handler. */
+    onScroll?: React.UIEventHandler<HTMLDivElement>;
+    /** Draws a separator border on the panel's left edge. */
+    showBorderLeft?: boolean;
+    "data-e2e-test-id"?: string;
+};
+export type RightPanelProps = SidePanelProps<RightPanelVariant> & {
+    /** Accessible name for the panel's `region` landmark. */
+    "aria-label": string;
     /** 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;
+    /** Called whenever the panel's render variant changes (docked ↔ float),
+     *  with the new value. Not called on initial mount. */
+    onVariantChange?: (variant: RightPanelVariant) => void;
 };
-export type RightPanelProps = SidePanelProps & Omit<RightPanelContainerProps, "data-e2e-test-id">;

package/build/esm/components/Layout/{Content.d.ts → Content/Content.d.ts}

@@ -1,5 +1,5 @@
 import type React from "react";
-import type { ContentProps } from "./-types";
+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.

package/build/esm/components/Layout/Content/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

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

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

@@ -1 +1 @@
-import React,{useEffect,useMemo,useState}from"react";import styled from"@emotion/styled";import{Panel}from"../Internal/Panel/Panel";import{PANEL_ORDER,PANEL_WIDTH_VAR,Slot}from"./-constants";import{useLayoutPersistence}from"./context";import{LayoutProvider}from"./LayoutProvider";import{Content}from"./Content";import{RightPanel}from"./RightPanel";import{LeftPanel}from"./LeftPanel";import{Split}from"./Split";import{LayoutPortalContext,PanelRegistryContext}from"./registry";import{usePortalContainerRefs}from"./usePortalContainerRefs";import{useLayoutVar}from"./LayoutCssVars";import{useLayout}from"./useLayout";let useGlobalCssVariables=nodes=>{let contentWidthCssVar=useLayoutVar(PANEL_WIDTH_VAR.content),rightPanelWidthCssVar=useLayoutVar(PANEL_WIDTH_VAR.rightPanel);useEffect(()=>{let targets=[[Slot.content,contentWidthCssVar],[Slot.rightPanel,rightPanelWidthCssVar]],observers=[];return targets.forEach(([slot,handle])=>{let node=nodes[slot]??null;if(!node)return void handle.set("0px");let publishNodeWidth=()=>handle.set(`${node.getBoundingClientRect().width}px`);if(publishNodeWidth(),"undefined"==typeof ResizeObserver)return;let observer=new ResizeObserver(publishNodeWidth);observer.observe(node),observers.push(observer)}),()=>observers.forEach(observer=>observer.disconnect())},[contentWidthCssVar,rightPanelWidthCssVar,nodes])},StyledLayout=styled("div",{target:"e1dnkj9b0",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, { useEffect, 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, PANEL_WIDTH_VAR, Slot } from \"./-constants\";\nimport { useLayoutPersistence } from \"./context\";\nimport { LayoutProvider } from \"./LayoutProvider\";\nimport { Content } from \"./Content\";\nimport { RightPanel } from \"./RightPanel\";\nimport { LeftPanel } from \"./LeftPanel\";\nimport { Split } from \"./Split\";\nimport {\n  LayoutPortalContext,\n  PanelRegistryContext,\n  type HostNodes,\n  type PanelReg,\n  type PanelRegistry,\n} from \"./registry\";\nimport { usePortalContainerRefs } from \"./usePortalContainerRefs\";\nimport { useLayoutVar, type LayoutVarHandle } from \"./LayoutCssVars\";\nimport { useLayout } from \"./useLayout\";\nimport type { LayoutProps, Size, SlotKey } from \"./-types\";\n\n/**\n * Publishes each panel's live pixel width as a layout CSS var (e.g.\n * `--ds-layout-rightPanel-width`), tracking drag- and window-resizes. A hidden\n * part (no host node) reads `0px`, so the var is always defined. One\n * `useLayoutVar` per slot in `PANEL_WIDTH_VAR`.\n */\nconst useGlobalCssVariables = (nodes: HostNodes): void => {\n  const contentWidthCssVar = useLayoutVar(PANEL_WIDTH_VAR.content);\n  const rightPanelWidthCssVar = useLayoutVar(PANEL_WIDTH_VAR.rightPanel);\n\n  useEffect(() => {\n    const targets: [SlotKey, LayoutVarHandle][] = [\n      [Slot.content, contentWidthCssVar],\n      [Slot.rightPanel, rightPanelWidthCssVar],\n    ];\n    const observers: ResizeObserver[] = [];\n\n    targets.forEach(([slot, handle]) => {\n      const node = nodes[slot] ?? null;\n      if (!node) {\n        handle.set(\"0px\");\n        return;\n      }\n      const publishNodeWidth = (): void =>\n        handle.set(`${node.getBoundingClientRect().width}px`);\n      publishNodeWidth();\n      // jsdom (and old browsers) lack ResizeObserver — skip live tracking there.\n      if (typeof ResizeObserver === \"undefined\") return;\n      const observer = new ResizeObserver(publishNodeWidth);\n      observer.observe(node);\n      observers.push(observer);\n    });\n\n    return () => observers.forEach((observer) => observer.disconnect());\n  }, [contentWidthCssVar, rightPanelWidthCssVar, nodes]);\n};\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  useGlobalCssVariables(nodes);\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/LeftPanel/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  LeftPanel: typeof LeftPanel;\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.LeftPanel = LeftPanel;\nLayout.RightPanel = RightPanel;\nLayout.Content = Content;\nLayout.Split = Split;\n"],"names":[],"mappings":"AAgEqB"} */"),StyledSoloHost=styled("div",{target:"e1dnkj9b1",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, { useEffect, 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, PANEL_WIDTH_VAR, Slot } from \"./-constants\";\nimport { useLayoutPersistence } from \"./context\";\nimport { LayoutProvider } from \"./LayoutProvider\";\nimport { Content } from \"./Content\";\nimport { RightPanel } from \"./RightPanel\";\nimport { LeftPanel } from \"./LeftPanel\";\nimport { Split } from \"./Split\";\nimport {\n  LayoutPortalContext,\n  PanelRegistryContext,\n  type HostNodes,\n  type PanelReg,\n  type PanelRegistry,\n} from \"./registry\";\nimport { usePortalContainerRefs } from \"./usePortalContainerRefs\";\nimport { useLayoutVar, type LayoutVarHandle } from \"./LayoutCssVars\";\nimport { useLayout } from \"./useLayout\";\nimport type { LayoutProps, Size, SlotKey } from \"./-types\";\n\n/**\n * Publishes each panel's live pixel width as a layout CSS var (e.g.\n * `--ds-layout-rightPanel-width`), tracking drag- and window-resizes. A hidden\n * part (no host node) reads `0px`, so the var is always defined. One\n * `useLayoutVar` per slot in `PANEL_WIDTH_VAR`.\n */\nconst useGlobalCssVariables = (nodes: HostNodes): void => {\n  const contentWidthCssVar = useLayoutVar(PANEL_WIDTH_VAR.content);\n  const rightPanelWidthCssVar = useLayoutVar(PANEL_WIDTH_VAR.rightPanel);\n\n  useEffect(() => {\n    const targets: [SlotKey, LayoutVarHandle][] = [\n      [Slot.content, contentWidthCssVar],\n      [Slot.rightPanel, rightPanelWidthCssVar],\n    ];\n    const observers: ResizeObserver[] = [];\n\n    targets.forEach(([slot, handle]) => {\n      const node = nodes[slot] ?? null;\n      if (!node) {\n        handle.set(\"0px\");\n        return;\n      }\n      const publishNodeWidth = (): void =>\n        handle.set(`${node.getBoundingClientRect().width}px`);\n      publishNodeWidth();\n      // jsdom (and old browsers) lack ResizeObserver — skip live tracking there.\n      if (typeof ResizeObserver === \"undefined\") return;\n      const observer = new ResizeObserver(publishNodeWidth);\n      observer.observe(node);\n      observers.push(observer);\n    });\n\n    return () => observers.forEach((observer) => observer.disconnect());\n  }, [contentWidthCssVar, rightPanelWidthCssVar, nodes]);\n};\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  useGlobalCssVariables(nodes);\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/LeftPanel/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  LeftPanel: typeof LeftPanel;\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.LeftPanel = LeftPanel;\nLayout.RightPanel = RightPanel;\nLayout.Content = Content;\nLayout.Split = Split;\n"],"names":[],"mappings":"AAyEuB"} */");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);useGlobalCssVariables(nodes);let 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.LeftPanel=LeftPanel,Layout.RightPanel=RightPanel,Layout.Content=Content,Layout.Split=Split;
+import React,{useCallback,useEffect,useMemo,useRef,useState}from"react";import styled from"@emotion/styled";import{Panel}from"../Internal/Panel/Panel";import{LayoutFloat}from"../Internal/LayoutFloat/LayoutFloat";import{useBreakpoints}from"../../shared/useBreakpoints";import{PANEL_ORDER,PANEL_WIDTH_VAR,Slot}from"./-constants";import{useLayoutPanelsEnabled,useLayoutPersistence}from"./context";import{LayoutProvider}from"./LayoutProvider";import{Content}from"./Content/Content";import{RightPanel}from"./RightPanel/RightPanel";import{RightPanelHeader}from"./RightPanel/RightPanelHeader";import{RightPanelFooter}from"./RightPanel/RightPanelFooter";import{LeftPanel}from"./LeftPanel/LeftPanel";import{LeftPanelHeader}from"./LeftPanel/LeftPanelHeader";import{LeftPanelFooter}from"./LeftPanel/LeftPanelFooter";import{Split}from"./Split/Split";import{SplitHeader}from"./Split/SplitHeader";import{SplitFooter}from"./Split/SplitFooter";import{LayoutPortalContext,PanelRegistryContext,PanelPresenceContext,PanelAnimationContext}from"./registry";import{useFloatablePortalTargets}from"./useFloatablePortalTargets";import{useLayoutVar}from"./LayoutCssVars";import{useLayout}from"./useLayout";let useGlobalCssVariables=slotHosts=>{let contentWidthCssVar=useLayoutVar(PANEL_WIDTH_VAR.content),rightPanelWidthCssVar=useLayoutVar(PANEL_WIDTH_VAR.rightPanel);useEffect(()=>{let targets=[[Slot.content,contentWidthCssVar],[Slot.rightPanel,rightPanelWidthCssVar]],observers=[];return targets.forEach(([slot,handle])=>{let node=slotHosts[slot]??null;if(!node)return void handle.set("0px");let publishNodeWidth=()=>handle.set(`${node.getBoundingClientRect().width}px`);if(publishNodeWidth(),"undefined"==typeof ResizeObserver)return;let observer=new ResizeObserver(publishNodeWidth);observer.observe(node),observers.push(observer)}),()=>observers.forEach(observer=>observer.disconnect())},[contentWidthCssVar,rightPanelWidthCssVar,slotHosts])},StyledLayout=styled("div",{target:"e1exnax50",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, {\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { PanelImperativeHandle } from \"react-resizable-panels\";\nimport { Panel } from \"../Internal/Panel/Panel\";\nimport type { PanelItem } from \"../Internal/Panel/Panel\";\nimport { LayoutFloat } from \"../Internal/LayoutFloat/LayoutFloat\";\nimport { useBreakpoints } from \"../../shared/useBreakpoints\";\nimport { PANEL_ORDER, PANEL_WIDTH_VAR, Slot } from \"./-constants\";\nimport { useLayoutPanelsEnabled, useLayoutPersistence } from \"./context\";\nimport { LayoutProvider } from \"./LayoutProvider\";\nimport { Content } from \"./Content/Content\";\nimport { RightPanel } from \"./RightPanel/RightPanel\";\nimport { RightPanelHeader } from \"./RightPanel/RightPanelHeader\";\nimport { RightPanelFooter } from \"./RightPanel/RightPanelFooter\";\nimport { LeftPanel } from \"./LeftPanel/LeftPanel\";\nimport { LeftPanelHeader } from \"./LeftPanel/LeftPanelHeader\";\nimport { LeftPanelFooter } from \"./LeftPanel/LeftPanelFooter\";\nimport { Split } from \"./Split/Split\";\nimport { SplitHeader } from \"./Split/SplitHeader\";\nimport { SplitFooter } from \"./Split/SplitFooter\";\nimport {\n  LayoutPortalContext,\n  PanelRegistryContext,\n  PanelPresenceContext,\n  PanelAnimationContext,\n  type PortalTargets,\n  type PanelReg,\n  type PanelRegistry,\n  type PanelPresence,\n  type PanelAnimationControl,\n} from \"./registry\";\nimport { useFloatablePortalTargets } from \"./useFloatablePortalTargets\";\nimport { useLayoutVar, type LayoutVarHandle } from \"./LayoutCssVars\";\nimport { useLayout } from \"./useLayout\";\nimport type { LayoutProps, Size, SlotKey } from \"./-types\";\n\n/**\n * Publishes each panel's live pixel width as a layout CSS var (e.g.\n * `--ds-layout-rightPanel-width`), tracking drag- and window-resizes. A hidden\n * part (no host node) reads `0px`, so the var is always defined. One\n * `useLayoutVar` per slot in `PANEL_WIDTH_VAR`.\n */\nconst useGlobalCssVariables = (slotHosts: PortalTargets): void => {\n  const contentWidthCssVar = useLayoutVar(PANEL_WIDTH_VAR.content);\n  const rightPanelWidthCssVar = useLayoutVar(PANEL_WIDTH_VAR.rightPanel);\n\n  useEffect(() => {\n    const targets: [SlotKey, LayoutVarHandle][] = [\n      [Slot.content, contentWidthCssVar],\n      [Slot.rightPanel, rightPanelWidthCssVar],\n    ];\n    const observers: ResizeObserver[] = [];\n\n    targets.forEach(([slot, handle]) => {\n      const node = slotHosts[slot] ?? null;\n      if (!node) {\n        handle.set(\"0px\");\n        return;\n      }\n      const publishNodeWidth = (): void =>\n        handle.set(`${node.getBoundingClientRect().width}px`);\n      publishNodeWidth();\n      // jsdom (and old browsers) lack ResizeObserver — skip live tracking there.\n      if (typeof ResizeObserver === \"undefined\") return;\n      const observer = new ResizeObserver(publishNodeWidth);\n      observer.observe(node);\n      observers.push(observer);\n    });\n\n    return () => observers.forEach((observer) => observer.disconnect());\n  }, [contentWidthCssVar, rightPanelWidthCssVar, slotHosts]);\n};\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  // Below the mobile breakpoint the rightPanel renders as a bottom sheet (its\n  // marker renders the Sheet itself) - an automatic, render-level adaptation.\n  // The stored variant is untouched, so resizing back to desktop restores the\n  // exact presentation (docked or floating) the user left.\n  const { isMobile } = useBreakpoints();\n  const isRightPanelSheet = isMobile;\n\n  // A floating rightPanel stays visible (its marker keeps rendering content)\n  // but leaves the resizable row - exactly like a hidden panel does. The\n  // mobile sheet takes precedence over the floating window. Float is a\n  // desktop presentation, so only mode `true` enables it.\n  const panelsEnabled = useLayoutPanelsEnabled();\n  const isRightPanelFloating =\n    panelsEnabled === true &&\n    !isRightPanelSheet &&\n    layoutState[Slot.rightPanel].variant === \"float\";\n\n  const isShown = (slot: SlotKey): boolean =>\n    layoutState[slot].visible &&\n    !(slot === Slot.rightPanel && (isRightPanelFloating || isRightPanelSheet));\n\n  // Slots kept mounted through their exit animation (reported via\n  // `usePanelPresence`). A present-but-hidden slot stays in the row so its\n  // close animation can play; it's removed once presence flips false.\n  const [present, setPresent] = useState<Partial<Record<SlotKey, boolean>>>({});\n  const presence = useMemo<PanelPresence>(\n    () => ({\n      setPresent: (slot, isPresent) =>\n        setPresent((prev) =>\n          prev[slot] === isPresent ? prev : { ...prev, [slot]: isPresent }\n        ),\n    }),\n    []\n  );\n\n  // Animation control for the docked side panels' open/close width slide. All\n  // ref-based on purpose: registering handles/elements and toggling suppression\n  // happen during commits and per-frame - none of it may re-render the Layout.\n  const panelHandles = useRef<\n    Partial<Record<SlotKey, PanelImperativeHandle | null>>\n  >({});\n  const panelElements = useRef<Partial<Record<SlotKey, HTMLElement | null>>>(\n    {}\n  );\n  const resizeSuppressed = useRef<Partial<Record<SlotKey, boolean>>>({});\n  const animationControl = useMemo<PanelAnimationControl>(\n    () => ({\n      setHandle: (slot, handle) => {\n        panelHandles.current[slot] = handle;\n      },\n      getHandle: (slot) => panelHandles.current[slot] ?? null,\n      setElement: (slot, element) => {\n        panelElements.current[slot] = element;\n      },\n      getElement: (slot) => panelElements.current[slot] ?? null,\n      setResizeSuppressed: (slot, suppressed) => {\n        resizeSuppressed.current[slot] = suppressed;\n      },\n    }),\n    []\n  );\n  // Stable per-slot ref callbacks - a fresh callback identity per render would\n  // make React detach/reattach the refs on every Layout re-render.\n  const panelRefCallbacks = useMemo(() => {\n    const handleCallbacks = new Map<\n      string,\n      (handle: PanelImperativeHandle | null) => void\n    >();\n    const elementCallbacks = new Map<\n      string,\n      (element: HTMLDivElement | null) => void\n    >();\n    return {\n      handleFor: (id: string) => {\n        let callback = handleCallbacks.get(id);\n        if (!callback) {\n          callback = (handle) =>\n            animationControl.setHandle(id as SlotKey, handle);\n          handleCallbacks.set(id, callback);\n        }\n        return callback;\n      },\n      elementFor: (id: string) => {\n        let callback = elementCallbacks.get(id);\n        if (!callback) {\n          callback = (element) =>\n            animationControl.setElement(id as SlotKey, element);\n          elementCallbacks.set(id, callback);\n        }\n        return callback;\n      },\n    };\n  }, [animationControl]);\n  const shouldSuppressLayoutCallback = useCallback(\n    () => Object.values(resizeSuppressed.current).some(Boolean),\n    []\n  );\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 { portalTargets, slotHosts, slotHostRefs, floatHostRef } =\n    useFloatablePortalTargets({\n      slots: PANEL_ORDER,\n      floatableSlot: Slot.rightPanel,\n      isFloating: isRightPanelFloating,\n    });\n\n  useGlobalCssVariables(slotHosts);\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/LeftPanel/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 OR mid-exit). A\n  // hidden-but-present slot lingers so its close animation can play; otherwise\n  // closed panels reserve no space.\n  const panelItems: PanelItem[] = PANEL_ORDER.filter(\n    (slot) => declared[slot] && (isShown(slot) || present[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  // Solo mode hosts the lone panel in a plain div, no resizable Group. A hidden\n  // lone panel renders nothing (Content is always shown).\n  const soloHost =\n    soloSlot && isShown(soloSlot) ? (\n      <StyledSoloHost ref={slotHostRefs[soloSlot]} />\n    ) : null;\n\n  // The resizable Group. `key` = the persistence namespace: react-resizable-panels\n  // reads stored sizes only on mount, so remount when the key changes to load\n  // that instance's sizes (per-route size memory). The key never changes on\n  // panel open/close, so normal toggling stays remount-free.\n  const panelGroup =\n    panelItems.length > 0 ? (\n      <Panel\n        key={resolvedKey}\n        panels={panelItems}\n        persistenceKey={resolvedKey}\n        storage={resolvedStorage}\n        hostFor={(id) => slotHostRefs[id as SlotKey]}\n        onResize={(id, size) => panelCallbacks[id as SlotKey].resize(size)}\n        onCollapse={(id) => panelCallbacks[id as SlotKey].hide()}\n        panelHandleFor={panelRefCallbacks.handleFor}\n        panelElementFor={panelRefCallbacks.elementFor}\n        shouldSuppressLayoutCallback={shouldSuppressLayoutCallback}\n      />\n    ) : null;\n\n  return (\n    <PanelRegistryContext.Provider value={registry}>\n      <PanelPresenceContext.Provider value={presence}>\n        <PanelAnimationContext.Provider value={animationControl}>\n          <LayoutPortalContext.Provider value={portalTargets}>\n            <StyledLayout data-ds-id=\"Layout\">\n              {isSolo ? soloHost : panelGroup}\n              {isRightPanelFloating && layoutState[Slot.rightPanel].visible && (\n                <LayoutFloat hostRef={floatHostRef} />\n              )}\n              {children}\n            </StyledLayout>\n          </LayoutPortalContext.Provider>\n        </PanelAnimationContext.Provider>\n      </PanelPresenceContext.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  LeftPanel: typeof LeftPanel;\n  LeftPanelHeader: typeof LeftPanelHeader;\n  LeftPanelFooter: typeof LeftPanelFooter;\n  RightPanel: typeof RightPanel;\n  RightPanelHeader: typeof RightPanelHeader;\n  RightPanelFooter: typeof RightPanelFooter;\n  Content: typeof Content;\n  Split: typeof Split;\n  SplitHeader: typeof SplitHeader;\n  SplitFooter: typeof SplitFooter;\n};\n\nexport const Layout = LayoutBase as LayoutComponent;\n\nLayout.Provider = LayoutProvider;\nLayout.LeftPanel = LeftPanel;\nLayout.LeftPanelHeader = LeftPanelHeader;\nLayout.LeftPanelFooter = LeftPanelFooter;\nLayout.RightPanel = RightPanel;\nLayout.RightPanelHeader = RightPanelHeader;\nLayout.RightPanelFooter = RightPanelFooter;\nLayout.Content = Content;\nLayout.Split = Split;\nLayout.SplitHeader = SplitHeader;\nLayout.SplitFooter = SplitFooter;\n"],"names":[],"mappings":"AAmFqB"} */"),StyledSoloHost=styled("div",{target:"e1exnax51",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, {\n  useCallback,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { PanelImperativeHandle } from \"react-resizable-panels\";\nimport { Panel } from \"../Internal/Panel/Panel\";\nimport type { PanelItem } from \"../Internal/Panel/Panel\";\nimport { LayoutFloat } from \"../Internal/LayoutFloat/LayoutFloat\";\nimport { useBreakpoints } from \"../../shared/useBreakpoints\";\nimport { PANEL_ORDER, PANEL_WIDTH_VAR, Slot } from \"./-constants\";\nimport { useLayoutPanelsEnabled, useLayoutPersistence } from \"./context\";\nimport { LayoutProvider } from \"./LayoutProvider\";\nimport { Content } from \"./Content/Content\";\nimport { RightPanel } from \"./RightPanel/RightPanel\";\nimport { RightPanelHeader } from \"./RightPanel/RightPanelHeader\";\nimport { RightPanelFooter } from \"./RightPanel/RightPanelFooter\";\nimport { LeftPanel } from \"./LeftPanel/LeftPanel\";\nimport { LeftPanelHeader } from \"./LeftPanel/LeftPanelHeader\";\nimport { LeftPanelFooter } from \"./LeftPanel/LeftPanelFooter\";\nimport { Split } from \"./Split/Split\";\nimport { SplitHeader } from \"./Split/SplitHeader\";\nimport { SplitFooter } from \"./Split/SplitFooter\";\nimport {\n  LayoutPortalContext,\n  PanelRegistryContext,\n  PanelPresenceContext,\n  PanelAnimationContext,\n  type PortalTargets,\n  type PanelReg,\n  type PanelRegistry,\n  type PanelPresence,\n  type PanelAnimationControl,\n} from \"./registry\";\nimport { useFloatablePortalTargets } from \"./useFloatablePortalTargets\";\nimport { useLayoutVar, type LayoutVarHandle } from \"./LayoutCssVars\";\nimport { useLayout } from \"./useLayout\";\nimport type { LayoutProps, Size, SlotKey } from \"./-types\";\n\n/**\n * Publishes each panel's live pixel width as a layout CSS var (e.g.\n * `--ds-layout-rightPanel-width`), tracking drag- and window-resizes. A hidden\n * part (no host node) reads `0px`, so the var is always defined. One\n * `useLayoutVar` per slot in `PANEL_WIDTH_VAR`.\n */\nconst useGlobalCssVariables = (slotHosts: PortalTargets): void => {\n  const contentWidthCssVar = useLayoutVar(PANEL_WIDTH_VAR.content);\n  const rightPanelWidthCssVar = useLayoutVar(PANEL_WIDTH_VAR.rightPanel);\n\n  useEffect(() => {\n    const targets: [SlotKey, LayoutVarHandle][] = [\n      [Slot.content, contentWidthCssVar],\n      [Slot.rightPanel, rightPanelWidthCssVar],\n    ];\n    const observers: ResizeObserver[] = [];\n\n    targets.forEach(([slot, handle]) => {\n      const node = slotHosts[slot] ?? null;\n      if (!node) {\n        handle.set(\"0px\");\n        return;\n      }\n      const publishNodeWidth = (): void =>\n        handle.set(`${node.getBoundingClientRect().width}px`);\n      publishNodeWidth();\n      // jsdom (and old browsers) lack ResizeObserver — skip live tracking there.\n      if (typeof ResizeObserver === \"undefined\") return;\n      const observer = new ResizeObserver(publishNodeWidth);\n      observer.observe(node);\n      observers.push(observer);\n    });\n\n    return () => observers.forEach((observer) => observer.disconnect());\n  }, [contentWidthCssVar, rightPanelWidthCssVar, slotHosts]);\n};\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  // Below the mobile breakpoint the rightPanel renders as a bottom sheet (its\n  // marker renders the Sheet itself) - an automatic, render-level adaptation.\n  // The stored variant is untouched, so resizing back to desktop restores the\n  // exact presentation (docked or floating) the user left.\n  const { isMobile } = useBreakpoints();\n  const isRightPanelSheet = isMobile;\n\n  // A floating rightPanel stays visible (its marker keeps rendering content)\n  // but leaves the resizable row - exactly like a hidden panel does. The\n  // mobile sheet takes precedence over the floating window. Float is a\n  // desktop presentation, so only mode `true` enables it.\n  const panelsEnabled = useLayoutPanelsEnabled();\n  const isRightPanelFloating =\n    panelsEnabled === true &&\n    !isRightPanelSheet &&\n    layoutState[Slot.rightPanel].variant === \"float\";\n\n  const isShown = (slot: SlotKey): boolean =>\n    layoutState[slot].visible &&\n    !(slot === Slot.rightPanel && (isRightPanelFloating || isRightPanelSheet));\n\n  // Slots kept mounted through their exit animation (reported via\n  // `usePanelPresence`). A present-but-hidden slot stays in the row so its\n  // close animation can play; it's removed once presence flips false.\n  const [present, setPresent] = useState<Partial<Record<SlotKey, boolean>>>({});\n  const presence = useMemo<PanelPresence>(\n    () => ({\n      setPresent: (slot, isPresent) =>\n        setPresent((prev) =>\n          prev[slot] === isPresent ? prev : { ...prev, [slot]: isPresent }\n        ),\n    }),\n    []\n  );\n\n  // Animation control for the docked side panels' open/close width slide. All\n  // ref-based on purpose: registering handles/elements and toggling suppression\n  // happen during commits and per-frame - none of it may re-render the Layout.\n  const panelHandles = useRef<\n    Partial<Record<SlotKey, PanelImperativeHandle | null>>\n  >({});\n  const panelElements = useRef<Partial<Record<SlotKey, HTMLElement | null>>>(\n    {}\n  );\n  const resizeSuppressed = useRef<Partial<Record<SlotKey, boolean>>>({});\n  const animationControl = useMemo<PanelAnimationControl>(\n    () => ({\n      setHandle: (slot, handle) => {\n        panelHandles.current[slot] = handle;\n      },\n      getHandle: (slot) => panelHandles.current[slot] ?? null,\n      setElement: (slot, element) => {\n        panelElements.current[slot] = element;\n      },\n      getElement: (slot) => panelElements.current[slot] ?? null,\n      setResizeSuppressed: (slot, suppressed) => {\n        resizeSuppressed.current[slot] = suppressed;\n      },\n    }),\n    []\n  );\n  // Stable per-slot ref callbacks - a fresh callback identity per render would\n  // make React detach/reattach the refs on every Layout re-render.\n  const panelRefCallbacks = useMemo(() => {\n    const handleCallbacks = new Map<\n      string,\n      (handle: PanelImperativeHandle | null) => void\n    >();\n    const elementCallbacks = new Map<\n      string,\n      (element: HTMLDivElement | null) => void\n    >();\n    return {\n      handleFor: (id: string) => {\n        let callback = handleCallbacks.get(id);\n        if (!callback) {\n          callback = (handle) =>\n            animationControl.setHandle(id as SlotKey, handle);\n          handleCallbacks.set(id, callback);\n        }\n        return callback;\n      },\n      elementFor: (id: string) => {\n        let callback = elementCallbacks.get(id);\n        if (!callback) {\n          callback = (element) =>\n            animationControl.setElement(id as SlotKey, element);\n          elementCallbacks.set(id, callback);\n        }\n        return callback;\n      },\n    };\n  }, [animationControl]);\n  const shouldSuppressLayoutCallback = useCallback(\n    () => Object.values(resizeSuppressed.current).some(Boolean),\n    []\n  );\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 { portalTargets, slotHosts, slotHostRefs, floatHostRef } =\n    useFloatablePortalTargets({\n      slots: PANEL_ORDER,\n      floatableSlot: Slot.rightPanel,\n      isFloating: isRightPanelFloating,\n    });\n\n  useGlobalCssVariables(slotHosts);\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/LeftPanel/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 OR mid-exit). A\n  // hidden-but-present slot lingers so its close animation can play; otherwise\n  // closed panels reserve no space.\n  const panelItems: PanelItem[] = PANEL_ORDER.filter(\n    (slot) => declared[slot] && (isShown(slot) || present[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  // Solo mode hosts the lone panel in a plain div, no resizable Group. A hidden\n  // lone panel renders nothing (Content is always shown).\n  const soloHost =\n    soloSlot && isShown(soloSlot) ? (\n      <StyledSoloHost ref={slotHostRefs[soloSlot]} />\n    ) : null;\n\n  // The resizable Group. `key` = the persistence namespace: react-resizable-panels\n  // reads stored sizes only on mount, so remount when the key changes to load\n  // that instance's sizes (per-route size memory). The key never changes on\n  // panel open/close, so normal toggling stays remount-free.\n  const panelGroup =\n    panelItems.length > 0 ? (\n      <Panel\n        key={resolvedKey}\n        panels={panelItems}\n        persistenceKey={resolvedKey}\n        storage={resolvedStorage}\n        hostFor={(id) => slotHostRefs[id as SlotKey]}\n        onResize={(id, size) => panelCallbacks[id as SlotKey].resize(size)}\n        onCollapse={(id) => panelCallbacks[id as SlotKey].hide()}\n        panelHandleFor={panelRefCallbacks.handleFor}\n        panelElementFor={panelRefCallbacks.elementFor}\n        shouldSuppressLayoutCallback={shouldSuppressLayoutCallback}\n      />\n    ) : null;\n\n  return (\n    <PanelRegistryContext.Provider value={registry}>\n      <PanelPresenceContext.Provider value={presence}>\n        <PanelAnimationContext.Provider value={animationControl}>\n          <LayoutPortalContext.Provider value={portalTargets}>\n            <StyledLayout data-ds-id=\"Layout\">\n              {isSolo ? soloHost : panelGroup}\n              {isRightPanelFloating && layoutState[Slot.rightPanel].visible && (\n                <LayoutFloat hostRef={floatHostRef} />\n              )}\n              {children}\n            </StyledLayout>\n          </LayoutPortalContext.Provider>\n        </PanelAnimationContext.Provider>\n      </PanelPresenceContext.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  LeftPanel: typeof LeftPanel;\n  LeftPanelHeader: typeof LeftPanelHeader;\n  LeftPanelFooter: typeof LeftPanelFooter;\n  RightPanel: typeof RightPanel;\n  RightPanelHeader: typeof RightPanelHeader;\n  RightPanelFooter: typeof RightPanelFooter;\n  Content: typeof Content;\n  Split: typeof Split;\n  SplitHeader: typeof SplitHeader;\n  SplitFooter: typeof SplitFooter;\n};\n\nexport const Layout = LayoutBase as LayoutComponent;\n\nLayout.Provider = LayoutProvider;\nLayout.LeftPanel = LeftPanel;\nLayout.LeftPanelHeader = LeftPanelHeader;\nLayout.LeftPanelFooter = LeftPanelFooter;\nLayout.RightPanel = RightPanel;\nLayout.RightPanelHeader = RightPanelHeader;\nLayout.RightPanelFooter = RightPanelFooter;\nLayout.Content = Content;\nLayout.Split = Split;\nLayout.SplitHeader = SplitHeader;\nLayout.SplitFooter = SplitFooter;\n"],"names":[],"mappings":"AA4FuB"} */");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,{isMobile}=useBreakpoints(),isRightPanelFloating=!0===useLayoutPanelsEnabled()&&!isMobile&&"float"===layoutState[Slot.rightPanel].variant,isShown=slot=>layoutState[slot].visible&&!(slot===Slot.rightPanel&&(isRightPanelFloating||isMobile)),[present,setPresent]=useState({}),presence=useMemo(()=>({setPresent:(slot,isPresent)=>setPresent(prev=>prev[slot]===isPresent?prev:{...prev,[slot]:isPresent})}),[]),panelHandles=useRef({}),panelElements=useRef({}),resizeSuppressed=useRef({}),animationControl=useMemo(()=>({setHandle:(slot,handle)=>{panelHandles.current[slot]=handle},getHandle:slot=>panelHandles.current[slot]??null,setElement:(slot,element)=>{panelElements.current[slot]=element},getElement:slot=>panelElements.current[slot]??null,setResizeSuppressed:(slot,suppressed)=>{resizeSuppressed.current[slot]=suppressed}}),[]),panelRefCallbacks=useMemo(()=>{let handleCallbacks=new Map,elementCallbacks=new Map;return{handleFor:id=>{let callback=handleCallbacks.get(id);return callback||(callback=handle=>animationControl.setHandle(id,handle),handleCallbacks.set(id,callback)),callback},elementFor:id=>{let callback=elementCallbacks.get(id);return callback||(callback=element=>animationControl.setElement(id,element),elementCallbacks.set(id,callback)),callback}}},[animationControl]),shouldSuppressLayoutCallback=useCallback(()=>Object.values(resizeSuppressed.current).some(Boolean),[]),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})}),[]),{portalTargets,slotHosts,slotHostRefs,floatHostRef}=useFloatablePortalTargets({slots:PANEL_ORDER,floatableSlot:Slot.rightPanel,isFloating:isRightPanelFloating});useGlobalCssVariables(slotHosts);let 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)||present[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)})),soloHost=soloSlot&&isShown(soloSlot)?React.createElement(StyledSoloHost,{ref:slotHostRefs[soloSlot]}):null,panelGroup=panelItems.length>0?React.createElement(Panel,{key:resolvedKey,panels:panelItems,persistenceKey:resolvedKey,storage:resolvedStorage,hostFor:id=>slotHostRefs[id],onResize:(id,size)=>panelCallbacks[id].resize(size),onCollapse:id=>panelCallbacks[id].hide(),panelHandleFor:panelRefCallbacks.handleFor,panelElementFor:panelRefCallbacks.elementFor,shouldSuppressLayoutCallback:shouldSuppressLayoutCallback}):null;return React.createElement(PanelRegistryContext.Provider,{value:registry},React.createElement(PanelPresenceContext.Provider,{value:presence},React.createElement(PanelAnimationContext.Provider,{value:animationControl},React.createElement(LayoutPortalContext.Provider,{value:portalTargets},React.createElement(StyledLayout,{"data-ds-id":"Layout"},isSolo?soloHost:panelGroup,isRightPanelFloating&&layoutState[Slot.rightPanel].visible&&React.createElement(LayoutFloat,{hostRef:floatHostRef}),children)))))};Layout.Provider=LayoutProvider,Layout.LeftPanel=LeftPanel,Layout.LeftPanelHeader=LeftPanelHeader,Layout.LeftPanelFooter=LeftPanelFooter,Layout.RightPanel=RightPanel,Layout.RightPanelHeader=RightPanelHeader,Layout.RightPanelFooter=RightPanelFooter,Layout.Content=Content,Layout.Split=Split,Layout.SplitHeader=SplitHeader,Layout.SplitFooter=SplitFooter;

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

@@ -1 +1 @@
-import React,{useMemo,useRef}from"react";import{LayoutPersistenceProvider,LayoutStoreProvider}from"./context";import{LayoutCssVars,LayoutCssVarStoreProvider}from"./LayoutCssVars";import{createLayoutCssVarStore}from"./cssVarStore";import{createInitialState}from"./reducer";import{createLayoutStore}from"./store";export function LayoutProvider({children,config,store,persistenceKey,storage}){let storeRef=useRef(null);null===storeRef.current&&(storeRef.current=store??createLayoutStore(createInitialState(config)));let cssVarStoreRef=useRef(null);null===cssVarStoreRef.current&&(cssVarStoreRef.current=createLayoutCssVarStore());let persistence=useMemo(()=>({persistenceKey,storage}),[persistenceKey,storage]);return React.createElement(LayoutStoreProvider,{value:storeRef.current},React.createElement(LayoutPersistenceProvider,{value:persistence},React.createElement(LayoutCssVarStoreProvider,{value:cssVarStoreRef.current},React.createElement(LayoutCssVars,null),children)))}
+import React,{useMemo,useRef}from"react";import{LayoutPanelsEnabledProvider,LayoutPersistenceProvider,LayoutStoreProvider}from"./context";import{LayoutCssVars,LayoutCssVarStoreProvider}from"./LayoutCssVars";import{createLayoutCssVarStore}from"./cssVarStore";import{createInitialState}from"./reducer";import{createLayoutStore}from"./store";export function LayoutProvider({children,config,store,persistenceKey,storage}){let storeRef=useRef(null);null===storeRef.current&&(storeRef.current=store??createLayoutStore(createInitialState(config)));let cssVarStoreRef=useRef(null);null===cssVarStoreRef.current&&(cssVarStoreRef.current=createLayoutCssVarStore());let persistence=useMemo(()=>({persistenceKey,storage}),[persistenceKey,storage]);return React.createElement(LayoutStoreProvider,{value:storeRef.current},React.createElement(LayoutPanelsEnabledProvider,{value:config?.enablePanels??!1},React.createElement(LayoutPersistenceProvider,{value:persistence},React.createElement(LayoutCssVarStoreProvider,{value:cssVarStoreRef.current},React.createElement(LayoutCssVars,null),children))))}

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

@@ -0,0 +1,9 @@
+import React from "react";
+import type { LeftPanelProps } from "../-types";
+/**
+ * Left side panel. Picks its presentation by breakpoint: an in-flow resizable
+ * column on desktop ({@link LeftPanelDocked}) and a modal left-edge drawer on
+ * mobile ({@link LeftPanelDrawer}). Both are driven by the same `leftPanel`
+ * layout state, so `useLayout()` controls it the same way at any width.
+ */
+export declare const LeftPanel: React.FC<LeftPanelProps>;

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

@@ -0,0 +1 @@
+import React from"react";import{useBreakpoints}from"../../../shared/useBreakpoints";import{Slot}from"../-constants";import{useVisibleChange}from"../registry";import{useLayout}from"../useLayout";import{useCanRenderPanel}from"../context";import{LeftPanelDocked}from"./LeftPanelDocked";import{LeftPanelDrawer}from"./LeftPanelDrawer";export const LeftPanel=({children,defaultSize,minSize,maxSize,collapsible=!0,onVisibleChange,"aria-label":ariaLabel})=>{let{isMobile}=useBreakpoints(),{isVisible,hide}=useLayout()[Slot.leftPanel],canRender=useCanRenderPanel();return(useVisibleChange(isVisible,onVisibleChange),canRender)?isMobile?React.createElement(LeftPanelDrawer,{isVisible:isVisible,hide:hide,"aria-label":ariaLabel},children):React.createElement(LeftPanelDocked,{"aria-label":ariaLabel,defaultSize:defaultSize,minSize:minSize,maxSize:maxSize,collapsible:collapsible},children):null};

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

@@ -0,0 +1,20 @@
+import React from "react";
+import type { Size } from "../-types";
+export type LeftPanelDockedProps = {
+    children: React.ReactNode;
+    "aria-label"?: string;
+    defaultSize?: Size;
+    minSize?: Size;
+    maxSize?: Size;
+    collapsible?: boolean;
+};
+/**
+ * Docked (desktop) left panel. Declares the `leftPanel` slot and portals its
+ * content into the Group's host - an in-flow, resizable column whose width
+ * slides open/closed via {@link usePanelDockedSlide} (when collapsible). Content
+ * lives in a {@link PanelContainer} so `Layout.LeftPanelHeader` /
+ * `Layout.LeftPanelFooter` children stick to the edges. The mobile presentation
+ * lives in {@link LeftPanelDrawer}; `LeftPanel` picks between the two by
+ * breakpoint.
+ */
+export declare const LeftPanelDocked: React.FC<LeftPanelDockedProps>;

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

@@ -0,0 +1 @@
+import React from"react";import{Slot}from"../-constants";import{useLayoutPortal}from"../registry";import{usePanelDockedSlide}from"../usePanelDockedSlide";import{PanelSlideBody}from"../PanelSlideBody";import{PanelContainer}from"../PanelContainer";export const LeftPanelDocked=({children,"aria-label":ariaLabel,defaultSize,minSize,maxSize,collapsible=!0})=>{let{isMounted,pinnedWidth}=usePanelDockedSlide({slot:Slot.leftPanel,defaultSize,minSize,maxSize,collapsible});return useLayoutPortal(Slot.leftPanel,isMounted?React.createElement(PanelSlideBody,{anchor:"right",pinnedWidth:pinnedWidth},React.createElement(PanelContainer,{"aria-label":ariaLabel},children)):null)};

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

@@ -0,0 +1,15 @@
+import React from "react";
+export type LeftPanelDrawerProps = {
+    children: React.ReactNode;
+    isVisible: boolean;
+    hide: () => void;
+    "aria-label": string;
+};
+/**
+ * Mobile left panel. Renders its content as a modal {@link Drawer} pinned to the
+ * left edge instead of an in-flow column - so it does NOT declare a resizable
+ * slot. Visibility is the shared `leftPanel` layout state, so `useLayout()`
+ * drives it identically to the docked desktop panel; outside-click / Escape
+ * routes back through `hide`.
+ */
+export declare const LeftPanelDrawer: React.FC<LeftPanelDrawerProps>;

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

@@ -0,0 +1 @@
+import React from"react";import styled from"@emotion/styled";import{Drawer}from"../../Internal/Drawer/Drawer";import{PanelContainer}from"../PanelContainer";let StyledLeftPanelBody=styled("div",{target:"e14wbnl40",label:"StyledLeftPanelBody"})({width:"80vw",height:"100dvh"},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export const LeftPanelDrawer=({children,isVisible,hide,"aria-label":ariaLabel})=>React.createElement(Drawer,{isVisible:isVisible,positionX:"left",handleClose:hide,"aria-label":ariaLabel},React.createElement(StyledLeftPanelBody,null,React.createElement(PanelContainer,null,children)));

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

@@ -0,0 +1,7 @@
+import React from "react";
+import type { LeftPanelFooterProps } from "../-types";
+/**
+ * Optional sticky footer for `Layout.LeftPanel` - place it among the panel's
+ * children; it sticks to the bottom while the rest of the content scrolls.
+ */
+export declare function LeftPanelFooter({ children, "data-e2e-test-id": dataE2eTestId, }: LeftPanelFooterProps): React.ReactElement;

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

@@ -0,0 +1 @@
+import React from"react";import{Sandwich}from"../../Internal/Sandwich/Sandwich";export function LeftPanelFooter({children,"data-e2e-test-id":dataE2eTestId}){return React.createElement(Sandwich.Footer,{"data-e2e-test-id":dataE2eTestId},children)}

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

@@ -0,0 +1,7 @@
+import React from "react";
+import type { LeftPanelHeaderProps } from "../-types";
+/**
+ * Optional sticky header for `Layout.LeftPanel` - place it among the panel's
+ * children; it sticks to the top while the rest of the content scrolls.
+ */
+export declare function LeftPanelHeader({ leftSlot, rightSlot, "data-e2e-test-id": dataE2eTestId, }: LeftPanelHeaderProps): React.ReactElement;

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

@@ -0,0 +1 @@
+import React from"react";import{Sandwich}from"../../Internal/Sandwich/Sandwich";import{PanelHeader}from"../../Internal/PanelHeader/PanelHeader";export function LeftPanelHeader({leftSlot,rightSlot,"data-e2e-test-id":dataE2eTestId}){return React.createElement(Sandwich.Header,{"data-e2e-test-id":dataE2eTestId},React.createElement(PanelHeader,{leftSlot:leftSlot,rightSlot:rightSlot}))}

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

@@ -0,0 +1,9 @@
+import React from "react";
+import type { PanelContainerProps } from "./-types";
+/**
+ * Shared shell of every layout panel: a flat, square-cornered Container
+ * hosting one scrollable region. Panel header/footer components
+ * (`Layout.LeftPanelHeader` etc.) render anywhere among `children` and stick
+ * to the edges; everything else scrolls.
+ */
+export declare function PanelContainer({ children, "aria-label": ariaLabel, scrollContainerRef, onScroll, showBorderLeft, "data-e2e-test-id": dataE2eTestId, }: PanelContainerProps): React.ReactElement;

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

@@ -0,0 +1 @@
+import React from"react";import styled from"@emotion/styled";import{Sandwich}from"../Internal/Sandwich/Sandwich";import{Container}from"../Container/Container";let CustomContainer=styled(Container,{shouldForwardProp:prop=>"showBorderLeft"!==prop,target:"e1wvnxfu0",label:"CustomContainer"})(({theme,showBorderLeft})=>({height:"100%",borderLeft:showBorderLeft?`1px solid ${theme.values.color.border.secondary.default}`:void 0}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export function PanelContainer({children,"aria-label":ariaLabel,scrollContainerRef,onScroll,showBorderLeft=!1,"data-e2e-test-id":dataE2eTestId}){return React.createElement(CustomContainer,{elevation:0,squareCorners:!0,role:ariaLabel?"region":void 0,"aria-label":ariaLabel,showBorderLeft:showBorderLeft,"data-ds-id":"PanelContainer","data-e2e-test-id":dataE2eTestId},React.createElement(Sandwich,{scrollRef:scrollContainerRef,onScroll:onScroll},children))}

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

@@ -0,0 +1,18 @@
+import React from "react";
+/** Edge the body is pinned to while the column slides - the panel's docked
+ *  edge (`right` for the left panel, `left` for the right panel). */
+export type PanelSlideAnchor = "left" | "right";
+export type PanelSlideBodyProps = {
+    /** Body width (px) while sliding; `null` at rest (fills the column). Comes
+     *  from {@link usePanelDockedSlide}. */
+    pinnedWidth: number | null;
+    /** The edge the panel docks against. */
+    anchor: PanelSlideAnchor;
+    children: React.ReactNode;
+};
+/**
+ * The clipped, edge-anchored body a docked side panel's content lives in so
+ * its open/close width animation reads as a drawer slide. Pair with
+ * {@link usePanelDockedSlide}, which supplies `pinnedWidth`.
+ */
+export declare const PanelSlideBody: React.FC<PanelSlideBodyProps>;

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

@@ -0,0 +1 @@
+import React from"react";import styled from"@emotion/styled";let StyledPanelSlideClip=styled("div",{target:"eak7i850",label:"StyledPanelSlideClip"})({position:"relative",width:"100%",height:"100%",overflow:"hidden"},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */"),StyledPanelSlideBody=styled("div",{shouldForwardProp:prop=>"pinnedWidth"!==prop&&"anchor"!==prop,target:"eak7i851",label:"StyledPanelSlideBody"})(({pinnedWidth,anchor})=>({width:"100%",height:"100%",...null!=pinnedWidth&&{position:"absolute",top:0,[anchor]:0,width:`${pinnedWidth}px`}}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export const PanelSlideBody=({pinnedWidth,anchor,children})=>React.createElement(StyledPanelSlideClip,null,React.createElement(StyledPanelSlideBody,{pinnedWidth:pinnedWidth,anchor:anchor},children));