@amboss/design-system 4.0.4 → 4.0.5

package/build/esm/components/Internal/Sandwich/-types.d.ts

@@ -1,10 +1,13 @@
 import type React from "react";
 export type SandwichProps = {
+    /** Content in source order; `Sandwich.Header` / `Sandwich.Footer` children
+     *  stick to the edges, everything else scrolls. */
     children: React.ReactNode;
-    "data-e2e-test-id"?: string;
-    /** Override the root's `data-ds-id` (e.g. when a wrapper component owns the node). */
-    "data-ds-id"?: string;
-} & React.HTMLAttributes<HTMLDivElement>;
+    /** Forwarded scroll handler; fires after the internal edge measurement. */
+    onScroll?: React.UIEventHandler<HTMLDivElement>;
+    /** Forwarded to the scroll container element (e.g. for scroll restoration). */
+    scrollRef?: React.Ref<HTMLDivElement>;
+};
 /**
  * Separator visibility:
  * - `auto`: show only while the content is scrolled away from the edge (default).
@@ -15,19 +18,14 @@ export type SandwichSeparator = "auto" | "always" | "never";
 export type SandwichHeaderProps = {
     children: React.ReactNode;
     showSeparator?: SandwichSeparator;
+    "data-e2e-test-id"?: string;
 };
 export type SandwichFooterProps = {
     children: React.ReactNode;
     showSeparator?: SandwichSeparator;
+    "data-e2e-test-id"?: string;
 };
-export type SandwichBodyProps = {
-    children: React.ReactNode;
-    /** Forwarded scroll handler; fires after the internal edge measurement. */
-    onScroll?: React.UIEventHandler<HTMLDivElement>;
-    /** Forwarded to the scroll container element (e.g. for scroll restoration). */
-    scrollRef?: React.Ref<HTMLDivElement>;
-};
-/** Scroll-edge visibility published by `Body`, consumed by `Header` / `Footer`. */
+/** Scroll-edge visibility published by the root, consumed by `Header` / `Footer`. */
 export type SandwichEdges = {
     /** Start of the scroll content is visible (not scrolled down). */
     atTop: boolean;

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

@@ -1,23 +1,23 @@
 import React from "react";
 import type { SandwichProps } from "./-types";
-import { SandwichBody } from "./SandwichBody";
 import { SandwichHeader } from "./SandwichHeader";
 import { SandwichFooter } from "./SandwichFooter";
 /**
- * Internal compound component: a scrollable middle region (`Sandwich.Body`)
- * flanked by a sticky `Sandwich.Header` / `Sandwich.Footer` that reveal a border
- * only while content is scrolled under them. Edge state is shared through
- * context (see `useSandwichContext.tsx`).
+ * Internal compound component: ONE scrollable region that hosts
+ * `Sandwich.Header` / `Sandwich.Footer` in the flow of its children —
+ * `position: sticky` pins them to the edges — so consumers author
+ * `<Header />{body}<Footer />` in source order, with no slot extraction.
+ * Header/footer reveal a border only while content is scrolled under them;
+ * edge state is shared through context (see `useSandwichContext.tsx`).
  */
-declare function SandwichRoot({ children, ...rest }: SandwichProps): React.ReactElement;
+declare function SandwichRoot({ children, scrollRef, onScroll, }: SandwichProps): React.ReactElement;
 /**
- * Compound export: `Sandwich` with `.Header`, `.Body`, `.Footer` attached.
+ * Compound export: `Sandwich` with `.Header` / `.Footer` attached.
  * Object.assign keeps the static sub-components typed on the root
  * (function-declaration statics don't type-check).
  */
 export declare const Sandwich: typeof SandwichRoot & {
     Header: typeof SandwichHeader;
-    Body: typeof SandwichBody;
     Footer: typeof SandwichFooter;
 };
 export {};

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

@@ -1 +1 @@
-import React,{useCallback,useMemo,useState}from"react";import styled from"@emotion/styled";import{SandwichProvider}from"./useSandwichContext";import{SandwichBody}from"./SandwichBody";import{SandwichHeader}from"./SandwichHeader";import{SandwichFooter}from"./SandwichFooter";let StyledRoot=styled("div",{target:"e164s6zy0",label:"StyledRoot"})({display:"flex",flexDirection:"column",minHeight:0,height:"100%",width:"100%"},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvSW50ZXJuYWwvU2FuZHdpY2gvU2FuZHdpY2gudHN4Iiwic291cmNlcyI6WyJzcmMvY29tcG9uZW50cy9JbnRlcm5hbC9TYW5kd2ljaC9TYW5kd2ljaC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0LCB7IHVzZUNhbGxiYWNrLCB1c2VNZW1vLCB1c2VTdGF0ZSB9IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IHN0eWxlZCBmcm9tIFwiQGVtb3Rpb24vc3R5bGVkXCI7XG5pbXBvcnQgdHlwZSB7IFNhbmR3aWNoRWRnZXMsIFNhbmR3aWNoUHJvcHMgfSBmcm9tIFwiLi8tdHlwZXNcIjtcbmltcG9ydCB7IFNhbmR3aWNoUHJvdmlkZXIgfSBmcm9tIFwiLi91c2VTYW5kd2ljaENvbnRleHRcIjtcbmltcG9ydCB7IFNhbmR3aWNoQm9keSB9IGZyb20gXCIuL1NhbmR3aWNoQm9keVwiO1xuaW1wb3J0IHsgU2FuZHdpY2hIZWFkZXIgfSBmcm9tIFwiLi9TYW5kd2ljaEhlYWRlclwiO1xuaW1wb3J0IHsgU2FuZHdpY2hGb290ZXIgfSBmcm9tIFwiLi9TYW5kd2ljaEZvb3RlclwiO1xuXG4vLyBDb2x1bW4gbGF5b3V0OiBoZWFkZXIvZm9vdGVyIHNpdCBhYm92ZS9iZWxvdyBhIHNpbmdsZSBzY3JvbGwgcmVnaW9uLiBUaGVcbi8vIHJvb3QgaXRzZWxmIGRvZXMgbm90IHNjcm9sbCDigJQgYEJvZHlgIG93bnMgdGhlIG92ZXJmbG93LlxuY29uc3QgU3R5bGVkUm9vdCA9IHN0eWxlZC5kaXYoe1xuICBkaXNwbGF5OiBcImZsZXhcIixcbiAgZmxleERpcmVjdGlvbjogXCJjb2x1bW5cIixcbiAgbWluSGVpZ2h0OiAwLFxuICBoZWlnaHQ6IFwiMTAwJVwiLFxuICB3aWR0aDogXCIxMDAlXCIsXG59KTtcblxuLyoqXG4gKiBJbnRlcm5hbCBjb21wb3VuZCBjb21wb25lbnQ6IGEgc2Nyb2xsYWJsZSBtaWRkbGUgcmVnaW9uIChgU2FuZHdpY2guQm9keWApXG4gKiBmbGFua2VkIGJ5IGEgc3RpY2t5IGBTYW5kd2ljaC5IZWFkZXJgIC8gYFNhbmR3aWNoLkZvb3RlcmAgdGhhdCByZXZlYWwgYSBib3JkZXJcbiAqIG9ubHkgd2hpbGUgY29udGVudCBpcyBzY3JvbGxlZCB1bmRlciB0aGVtLiBFZGdlIHN0YXRlIGlzIHNoYXJlZCB0aHJvdWdoXG4gKiBjb250ZXh0IChzZWUgYHVzZVNhbmR3aWNoQ29udGV4dC50c3hgKS5cbiAqL1xuZnVuY3Rpb24gU2FuZHdpY2hSb290KHtcbiAgY2hpbGRyZW4sXG4gIC4uLnJlc3Rcbn06IFNhbmR3aWNoUHJvcHMpOiBSZWFjdC5SZWFjdEVsZW1lbnQge1xuICAvLyBEZWZhdWx0OiBldmVyeXRoaW5nIHZpc2libGUgKG5vIHNjcm9sbGluZyBuZWVkZWQpIOKGkiBubyBib3JkZXJzLlxuICBjb25zdCBbZWRnZXMsIHNldEVkZ2VzU3RhdGVdID0gdXNlU3RhdGU8U2FuZHdpY2hFZGdlcz4oe1xuICAgIGF0VG9wOiB0cnVlLFxuICAgIGF0Qm90dG9tOiB0cnVlLFxuICB9KTtcblxuICBjb25zdCBzZXRFZGdlcyA9IHVzZUNhbGxiYWNrKChuZXh0OiBQYXJ0aWFsPFNhbmR3aWNoRWRnZXM+KSA9PiB7XG4gICAgc2V0RWRnZXNTdGF0ZSgocHJldikgPT4ge1xuICAgICAgY29uc3QgbWVyZ2VkID0geyAuLi5wcmV2LCAuLi5uZXh0IH07XG4gICAgICBpZiAobWVyZ2VkLmF0VG9wID09PSBwcmV2LmF0VG9wICYmIG1lcmdlZC5hdEJvdHRvbSA9PT0gcHJldi5hdEJvdHRvbSkge1xuICAgICAgICByZXR1cm4gcHJldjtcbiAgICAgIH1cbiAgICAgIHJldHVybiBtZXJnZWQ7XG4gICAgfSk7XG4gIH0sIFtdKTtcblxuICBjb25zdCB2YWx1ZSA9IHVzZU1lbW8oKCkgPT4gKHsgLi4uZWRnZXMsIHNldEVkZ2VzIH0pLCBbZWRnZXMsIHNldEVkZ2VzXSk7XG5cbiAgcmV0dXJuIChcbiAgICA8U2FuZHdpY2hQcm92aWRlciB2YWx1ZT17dmFsdWV9PlxuICAgICAgPFN0eWxlZFJvb3QgZGF0YS1kcy1pZD1cIlNhbmR3aWNoXCIgey4uLnJlc3R9PlxuICAgICAgICB7Y2hpbGRyZW59XG4gICAgICA8L1N0eWxlZFJvb3Q+XG4gICAgPC9TYW5kd2ljaFByb3ZpZGVyPlxuICApO1xufVxuXG4vKipcbiAqIENvbXBvdW5kIGV4cG9ydDogYFNhbmR3aWNoYCB3aXRoIGAuSGVhZGVyYCwgYC5Cb2R5YCwgYC5Gb290ZXJgIGF0dGFjaGVkLlxuICogT2JqZWN0LmFzc2lnbiBrZWVwcyB0aGUgc3RhdGljIHN1Yi1jb21wb25lbnRzIHR5cGVkIG9uIHRoZSByb290XG4gKiAoZnVuY3Rpb24tZGVjbGFyYXRpb24gc3RhdGljcyBkb24ndCB0eXBlLWNoZWNrKS5cbiAqL1xuZXhwb3J0IGNvbnN0IFNhbmR3aWNoID0gT2JqZWN0LmFzc2lnbihTYW5kd2ljaFJvb3QsIHtcbiAgSGVhZGVyOiBTYW5kd2ljaEhlYWRlcixcbiAgQm9keTogU2FuZHdpY2hCb2R5LFxuICBGb290ZXI6IFNhbmR3aWNoRm9vdGVyLFxufSk7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBVW1CIn0= */");export const Sandwich=Object.assign(function({children,...rest}){let[edges,setEdgesState]=useState({atTop:!0,atBottom:!0}),setEdges=useCallback(next=>{setEdgesState(prev=>{let merged={...prev,...next};return merged.atTop===prev.atTop&&merged.atBottom===prev.atBottom?prev:merged})},[]),value=useMemo(()=>({...edges,setEdges}),[edges,setEdges]);return React.createElement(SandwichProvider,{value:value},React.createElement(StyledRoot,{"data-ds-id":"Sandwich",...rest},children))},{Header:SandwichHeader,Body:SandwichBody,Footer:SandwichFooter});
+import React,{useCallback,useEffect,useLayoutEffect,useMemo,useRef,useState}from"react";import styled from"@emotion/styled";import{SandwichProvider}from"./useSandwichContext";import{SandwichHeader}from"./SandwichHeader";import{SandwichFooter}from"./SandwichFooter";let useScrollEdgeTracking=({scrollRef,onScroll,setEdges})=>{let containerRef=useRef(null),contentRef=useRef(null),setContainerRef=useCallback(node=>{containerRef.current=node,"function"==typeof scrollRef?scrollRef(node):scrollRef&&(scrollRef.current=node)},[scrollRef]),recalculateEdges=useCallback(()=>{let el=containerRef.current;if(!el)return;let{scrollTop,scrollHeight,clientHeight}=el;setEdges({atTop:scrollTop<=1,atBottom:scrollTop+clientHeight>=scrollHeight-1})},[setEdges]),onContainerScroll=useCallback(event=>{recalculateEdges(),onScroll?.(event)},[recalculateEdges,onScroll]);return useLayoutEffect(recalculateEdges,[recalculateEdges]),useEffect(()=>{if("undefined"==typeof ResizeObserver)return;let observer=new ResizeObserver(()=>recalculateEdges());return containerRef.current&&observer.observe(containerRef.current),contentRef.current&&observer.observe(contentRef.current),()=>observer.disconnect()},[recalculateEdges]),{setContainerRef,contentRef,onContainerScroll}},useSandwichEdgesState=()=>{let[edges,setEdgesState]=useState({atTop:!0,atBottom:!0}),setEdges=useCallback(next=>{setEdgesState(prev=>{let merged={...prev,...next};return merged.atTop===prev.atTop&&merged.atBottom===prev.atBottom?prev:merged})},[]);return useMemo(()=>({...edges,setEdges}),[edges,setEdges])},StyledScrollRoot=styled("div",{target:"e1milkm30",label:"StyledScrollRoot"})({height:"100%",overflowY:"auto",position:"relative"},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Internal/Sandwich/Sandwich.tsx","sources":["src/components/Internal/Sandwich/Sandwich.tsx"],"sourcesContent":["import React, {\n  useCallback,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { SandwichEdges, SandwichProps } from \"./-types\";\nimport { SandwichProvider } from \"./useSandwichContext\";\nimport type { SandwichContextValue } from \"./useSandwichContext\";\nimport { SandwichHeader } from \"./SandwichHeader\";\nimport { SandwichFooter } from \"./SandwichFooter\";\n\n// px tolerance — sub-pixel rounding shouldn't leave a divider stuck on.\nconst EDGE_THRESHOLD = 1;\n\ntype ScrollEdgeTrackingParams = {\n  /** Consumer ref forwarded to the scroll container (scroll restoration etc.). */\n  scrollRef?: React.Ref<HTMLDivElement>;\n  /** Consumer scroll handler; fires after the internal edge measurement. */\n  onScroll?: React.UIEventHandler<HTMLDivElement>;\n  /** Edge sink — the root's `setEdges`. */\n  setEdges: (edges: Partial<SandwichEdges>) => void;\n};\n\ntype ScrollEdgeTracking = {\n  /** Callback ref for the scroll container element. */\n  setContainerRef: (node: HTMLDivElement | null) => void;\n  /** Ref for the content element inside the container (growth tracking). */\n  contentRef: React.MutableRefObject<HTMLDivElement | null>;\n  /** Scroll handler for the container; measures, then calls `onScroll`. */\n  onContainerScroll: React.UIEventHandler<HTMLDivElement>;\n};\n\n/**\n * Publishes the scroll container's edge visibility (`atTop` / `atBottom`) to\n * `setEdges` — on mount, on scroll, and on size changes of the container or\n * its content (via ResizeObserver).\n */\nconst useScrollEdgeTracking = ({\n  scrollRef,\n  onScroll,\n  setEdges,\n}: ScrollEdgeTrackingParams): ScrollEdgeTracking => {\n  const containerRef = useRef<HTMLDivElement | null>(null);\n  const contentRef = useRef<HTMLDivElement | null>(null);\n\n  // Keep the internal ref (used for measuring) while also forwarding the node to\n  // the consumer's `scrollRef` — a callback ref handles both forms.\n  const setContainerRef = useCallback(\n    (node: HTMLDivElement | null) => {\n      containerRef.current = node;\n      if (typeof scrollRef === \"function\") {\n        scrollRef(node);\n      } else if (scrollRef) {\n        const mutableRef =\n          scrollRef as React.MutableRefObject<HTMLDivElement | null>;\n        mutableRef.current = node;\n      }\n    },\n    [scrollRef]\n  );\n\n  const recalculateEdges = useCallback(() => {\n    const el = containerRef.current;\n    if (!el) return;\n    const { scrollTop, scrollHeight, clientHeight } = el;\n    setEdges({\n      atTop: scrollTop <= EDGE_THRESHOLD,\n      atBottom: scrollTop + clientHeight >= scrollHeight - EDGE_THRESHOLD,\n    });\n  }, [setEdges]);\n\n  const onContainerScroll = useCallback(\n    (event: React.UIEvent<HTMLDivElement>) => {\n      recalculateEdges();\n      onScroll?.(event);\n    },\n    [recalculateEdges, onScroll]\n  );\n\n  // Measure on mount only — the ResizeObserver + scroll handler below cover the\n  // rest. Do NOT drop the deps: a dep-less effect re-measures every render and can\n  // infinite-loop when the height is briefly unstable (setEdges → reflow → repeat).\n  useLayoutEffect(recalculateEdges, [recalculateEdges]);\n\n  // Re-measure on size changes that DON'T trigger a React render: the content\n  // growing/shrinking (image load, accordion expand, text reflow) and the\n  // viewport itself resizing. Observe both nodes.\n  useEffect(() => {\n    if (typeof ResizeObserver === \"undefined\") return undefined;\n    const observer = new ResizeObserver(() => recalculateEdges());\n    if (containerRef.current) observer.observe(containerRef.current);\n    if (contentRef.current) observer.observe(contentRef.current);\n    return () => observer.disconnect();\n  }, [recalculateEdges]);\n\n  return { setContainerRef, contentRef, onContainerScroll };\n};\n\n/**\n * Owns the scroll-edge state the root provides through context: everything\n * visible by default (no scrolling needed → no borders), `setEdges` merges\n * partial updates and bails out when nothing changed so scroll handlers can't\n * re-render-loop.\n */\nconst useSandwichEdgesState = (): SandwichContextValue => {\n  const [edges, setEdgesState] = useState<SandwichEdges>({\n    atTop: true,\n    atBottom: true,\n  });\n\n  const setEdges = useCallback((next: Partial<SandwichEdges>) => {\n    setEdgesState((prev) => {\n      const merged = { ...prev, ...next };\n      if (merged.atTop === prev.atTop && merged.atBottom === prev.atBottom) {\n        return prev;\n      }\n      return merged;\n    });\n  }, []);\n\n  return useMemo(() => ({ ...edges, setEdges }), [edges, setEdges]);\n};\n\nconst StyledScrollRoot = styled.div({\n  height: \"100%\",\n  overflowY: \"auto\",\n  position: \"relative\",\n});\n\n// `min-height` lets short content fill the area without clipping taller\n// content. Flex column so a `Sandwich.Footer` child can pin itself to the\n// bottom via `margin-top: auto`.\nconst StyledScrollContent = styled.div({\n  minHeight: \"100%\",\n  display: \"flex\",\n  flexDirection: \"column\",\n});\n\n/**\n * Internal compound component: ONE scrollable region that hosts\n * `Sandwich.Header` / `Sandwich.Footer` in the flow of its children —\n * `position: sticky` pins them to the edges — so consumers author\n * `<Header />{body}<Footer />` in source order, with no slot extraction.\n * Header/footer reveal a border only while content is scrolled under them;\n * edge state is shared through context (see `useSandwichContext.tsx`).\n */\nfunction SandwichRoot({\n  children,\n  scrollRef,\n  onScroll,\n}: SandwichProps): React.ReactElement {\n  const edgesValue = useSandwichEdgesState();\n  const { setContainerRef, contentRef, onContainerScroll } =\n    useScrollEdgeTracking({\n      scrollRef,\n      onScroll,\n      setEdges: edgesValue.setEdges,\n    });\n\n  return (\n    <SandwichProvider value={edgesValue}>\n      {/* tabIndex makes the scroll region keyboard-accessible (a11y: scrollable\n          regions must be focusable so keyboard users can scroll them). */}\n      <StyledScrollRoot\n        ref={setContainerRef}\n        onScroll={onContainerScroll}\n        tabIndex={0}\n        data-ds-id=\"Sandwich\"\n      >\n        <StyledScrollContent ref={contentRef}>{children}</StyledScrollContent>\n      </StyledScrollRoot>\n    </SandwichProvider>\n  );\n}\n\n/**\n * Compound export: `Sandwich` with `.Header` / `.Footer` attached.\n * Object.assign keeps the static sub-components typed on the root\n * (function-declaration statics don't type-check).\n */\nexport const Sandwich = Object.assign(SandwichRoot, {\n  Header: SandwichHeader,\n  Footer: SandwichFooter,\n});\n"],"names":[],"mappings":"AA+HyB"} */"),StyledScrollContent=styled("div",{target:"e1milkm31",label:"StyledScrollContent"})({minHeight:"100%",display:"flex",flexDirection:"column"},"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"src/components/Internal/Sandwich/Sandwich.tsx","sources":["src/components/Internal/Sandwich/Sandwich.tsx"],"sourcesContent":["import React, {\n  useCallback,\n  useEffect,\n  useLayoutEffect,\n  useMemo,\n  useRef,\n  useState,\n} from \"react\";\nimport styled from \"@emotion/styled\";\nimport type { SandwichEdges, SandwichProps } from \"./-types\";\nimport { SandwichProvider } from \"./useSandwichContext\";\nimport type { SandwichContextValue } from \"./useSandwichContext\";\nimport { SandwichHeader } from \"./SandwichHeader\";\nimport { SandwichFooter } from \"./SandwichFooter\";\n\n// px tolerance — sub-pixel rounding shouldn't leave a divider stuck on.\nconst EDGE_THRESHOLD = 1;\n\ntype ScrollEdgeTrackingParams = {\n  /** Consumer ref forwarded to the scroll container (scroll restoration etc.). */\n  scrollRef?: React.Ref<HTMLDivElement>;\n  /** Consumer scroll handler; fires after the internal edge measurement. */\n  onScroll?: React.UIEventHandler<HTMLDivElement>;\n  /** Edge sink — the root's `setEdges`. */\n  setEdges: (edges: Partial<SandwichEdges>) => void;\n};\n\ntype ScrollEdgeTracking = {\n  /** Callback ref for the scroll container element. */\n  setContainerRef: (node: HTMLDivElement | null) => void;\n  /** Ref for the content element inside the container (growth tracking). */\n  contentRef: React.MutableRefObject<HTMLDivElement | null>;\n  /** Scroll handler for the container; measures, then calls `onScroll`. */\n  onContainerScroll: React.UIEventHandler<HTMLDivElement>;\n};\n\n/**\n * Publishes the scroll container's edge visibility (`atTop` / `atBottom`) to\n * `setEdges` — on mount, on scroll, and on size changes of the container or\n * its content (via ResizeObserver).\n */\nconst useScrollEdgeTracking = ({\n  scrollRef,\n  onScroll,\n  setEdges,\n}: ScrollEdgeTrackingParams): ScrollEdgeTracking => {\n  const containerRef = useRef<HTMLDivElement | null>(null);\n  const contentRef = useRef<HTMLDivElement | null>(null);\n\n  // Keep the internal ref (used for measuring) while also forwarding the node to\n  // the consumer's `scrollRef` — a callback ref handles both forms.\n  const setContainerRef = useCallback(\n    (node: HTMLDivElement | null) => {\n      containerRef.current = node;\n      if (typeof scrollRef === \"function\") {\n        scrollRef(node);\n      } else if (scrollRef) {\n        const mutableRef =\n          scrollRef as React.MutableRefObject<HTMLDivElement | null>;\n        mutableRef.current = node;\n      }\n    },\n    [scrollRef]\n  );\n\n  const recalculateEdges = useCallback(() => {\n    const el = containerRef.current;\n    if (!el) return;\n    const { scrollTop, scrollHeight, clientHeight } = el;\n    setEdges({\n      atTop: scrollTop <= EDGE_THRESHOLD,\n      atBottom: scrollTop + clientHeight >= scrollHeight - EDGE_THRESHOLD,\n    });\n  }, [setEdges]);\n\n  const onContainerScroll = useCallback(\n    (event: React.UIEvent<HTMLDivElement>) => {\n      recalculateEdges();\n      onScroll?.(event);\n    },\n    [recalculateEdges, onScroll]\n  );\n\n  // Measure on mount only — the ResizeObserver + scroll handler below cover the\n  // rest. Do NOT drop the deps: a dep-less effect re-measures every render and can\n  // infinite-loop when the height is briefly unstable (setEdges → reflow → repeat).\n  useLayoutEffect(recalculateEdges, [recalculateEdges]);\n\n  // Re-measure on size changes that DON'T trigger a React render: the content\n  // growing/shrinking (image load, accordion expand, text reflow) and the\n  // viewport itself resizing. Observe both nodes.\n  useEffect(() => {\n    if (typeof ResizeObserver === \"undefined\") return undefined;\n    const observer = new ResizeObserver(() => recalculateEdges());\n    if (containerRef.current) observer.observe(containerRef.current);\n    if (contentRef.current) observer.observe(contentRef.current);\n    return () => observer.disconnect();\n  }, [recalculateEdges]);\n\n  return { setContainerRef, contentRef, onContainerScroll };\n};\n\n/**\n * Owns the scroll-edge state the root provides through context: everything\n * visible by default (no scrolling needed → no borders), `setEdges` merges\n * partial updates and bails out when nothing changed so scroll handlers can't\n * re-render-loop.\n */\nconst useSandwichEdgesState = (): SandwichContextValue => {\n  const [edges, setEdgesState] = useState<SandwichEdges>({\n    atTop: true,\n    atBottom: true,\n  });\n\n  const setEdges = useCallback((next: Partial<SandwichEdges>) => {\n    setEdgesState((prev) => {\n      const merged = { ...prev, ...next };\n      if (merged.atTop === prev.atTop && merged.atBottom === prev.atBottom) {\n        return prev;\n      }\n      return merged;\n    });\n  }, []);\n\n  return useMemo(() => ({ ...edges, setEdges }), [edges, setEdges]);\n};\n\nconst StyledScrollRoot = styled.div({\n  height: \"100%\",\n  overflowY: \"auto\",\n  position: \"relative\",\n});\n\n// `min-height` lets short content fill the area without clipping taller\n// content. Flex column so a `Sandwich.Footer` child can pin itself to the\n// bottom via `margin-top: auto`.\nconst StyledScrollContent = styled.div({\n  minHeight: \"100%\",\n  display: \"flex\",\n  flexDirection: \"column\",\n});\n\n/**\n * Internal compound component: ONE scrollable region that hosts\n * `Sandwich.Header` / `Sandwich.Footer` in the flow of its children —\n * `position: sticky` pins them to the edges — so consumers author\n * `<Header />{body}<Footer />` in source order, with no slot extraction.\n * Header/footer reveal a border only while content is scrolled under them;\n * edge state is shared through context (see `useSandwichContext.tsx`).\n */\nfunction SandwichRoot({\n  children,\n  scrollRef,\n  onScroll,\n}: SandwichProps): React.ReactElement {\n  const edgesValue = useSandwichEdgesState();\n  const { setContainerRef, contentRef, onContainerScroll } =\n    useScrollEdgeTracking({\n      scrollRef,\n      onScroll,\n      setEdges: edgesValue.setEdges,\n    });\n\n  return (\n    <SandwichProvider value={edgesValue}>\n      {/* tabIndex makes the scroll region keyboard-accessible (a11y: scrollable\n          regions must be focusable so keyboard users can scroll them). */}\n      <StyledScrollRoot\n        ref={setContainerRef}\n        onScroll={onContainerScroll}\n        tabIndex={0}\n        data-ds-id=\"Sandwich\"\n      >\n        <StyledScrollContent ref={contentRef}>{children}</StyledScrollContent>\n      </StyledScrollRoot>\n    </SandwichProvider>\n  );\n}\n\n/**\n * Compound export: `Sandwich` with `.Header` / `.Footer` attached.\n * Object.assign keeps the static sub-components typed on the root\n * (function-declaration statics don't type-check).\n */\nexport const Sandwich = Object.assign(SandwichRoot, {\n  Header: SandwichHeader,\n  Footer: SandwichFooter,\n});\n"],"names":[],"mappings":"AAwI4B"} */");export const Sandwich=Object.assign(function({children,scrollRef,onScroll}){let edgesValue=useSandwichEdgesState(),{setContainerRef,contentRef,onContainerScroll}=useScrollEdgeTracking({scrollRef,onScroll,setEdges:edgesValue.setEdges});return React.createElement(SandwichProvider,{value:edgesValue},React.createElement(StyledScrollRoot,{ref:setContainerRef,onScroll:onContainerScroll,tabIndex:0,"data-ds-id":"Sandwich"},React.createElement(StyledScrollContent,{ref:contentRef},children)))},{Header:SandwichHeader,Footer:SandwichFooter});

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

@@ -1,3 +1,3 @@
 import React from "react";
 import type { SandwichFooterProps } from "./-types";
-export declare function SandwichFooter({ children, showSeparator, }: SandwichFooterProps): React.ReactElement;
+export declare function SandwichFooter({ children, showSeparator, "data-e2e-test-id": dataE2eTestId, }: SandwichFooterProps): React.ReactElement;

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

@@ -1 +1 @@
-import React from"react";import styled from"@emotion/styled";import{useSandwichContext}from"./useSandwichContext";let StyledFooter=styled("div",{shouldForwardProp:prop=>"showBorder"!==prop,target:"esecync0",label:"StyledFooter"})(({theme,showBorder})=>({position:"sticky",bottom:0,flex:"0 0 auto",zIndex:1,borderTopWidth:1,borderTopStyle:"solid",borderTopColor:showBorder?theme.values.color.border.secondary.default:"transparent",transition:"border-color 0.15s ease"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvSW50ZXJuYWwvU2FuZHdpY2gvU2FuZHdpY2hGb290ZXIudHN4Iiwic291cmNlcyI6WyJzcmMvY29tcG9uZW50cy9JbnRlcm5hbC9TYW5kd2ljaC9TYW5kd2ljaEZvb3Rlci50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IHN0eWxlZCBmcm9tIFwiQGVtb3Rpb24vc3R5bGVkXCI7XG5pbXBvcnQgdHlwZSB7IFNhbmR3aWNoRm9vdGVyUHJvcHMgfSBmcm9tIFwiLi8tdHlwZXNcIjtcbmltcG9ydCB7IHVzZVNhbmR3aWNoQ29udGV4dCB9IGZyb20gXCIuL3VzZVNhbmR3aWNoQ29udGV4dFwiO1xuXG5jb25zdCBCT1JERVJfV0lEVEggPSAxO1xuXG5jb25zdCBTdHlsZWRGb290ZXIgPSBzdHlsZWQoXCJkaXZcIiwge1xuICBzaG91bGRGb3J3YXJkUHJvcDogKHByb3ApID0+IHByb3AgIT09IFwic2hvd0JvcmRlclwiLFxufSk8eyBzaG93Qm9yZGVyOiBib29sZWFuIH0+KCh7IHRoZW1lLCBzaG93Qm9yZGVyIH0pID0+ICh7XG4gIHBvc2l0aW9uOiBcInN0aWNreVwiLFxuICBib3R0b206IDAsXG4gIGZsZXg6IFwiMCAwIGF1dG9cIixcbiAgekluZGV4OiAxLFxuICAvLyBSZXNlcnZlIHRoZSBib3JkZXIgYm94IGF0IGFsbCB0aW1lczsgb25seSB0aGUgY29sb3IgdG9nZ2xlcyBzbyB0aGUgZGl2aWRlclxuICAvLyBhcHBlYXJzIHdpdGhvdXQgc2hpZnRpbmcgbGF5b3V0LlxuICBib3JkZXJUb3BXaWR0aDogQk9SREVSX1dJRFRILFxuICBib3JkZXJUb3BTdHlsZTogXCJzb2xpZFwiLFxuICBib3JkZXJUb3BDb2xvcjogc2hvd0JvcmRlclxuICAgID8gdGhlbWUudmFsdWVzLmNvbG9yLmJvcmRlci5zZWNvbmRhcnkuZGVmYXVsdFxuICAgIDogXCJ0cmFuc3BhcmVudFwiLFxuICB0cmFuc2l0aW9uOiBcImJvcmRlci1jb2xvciAwLjE1cyBlYXNlXCIsXG59KSk7XG5cbmV4cG9ydCBmdW5jdGlvbiBTYW5kd2ljaEZvb3Rlcih7XG4gIGNoaWxkcmVuLFxuICBzaG93U2VwYXJhdG9yID0gXCJhdXRvXCIsXG59OiBTYW5kd2ljaEZvb3RlclByb3BzKTogUmVhY3QuUmVhY3RFbGVtZW50IHtcbiAgY29uc3QgeyBhdEJvdHRvbSB9ID0gdXNlU2FuZHdpY2hDb250ZXh0KCk7XG4gIC8vIERpdmlkZXIgd2hpbGUgY29udGVudCByZW1haW5zIGJlbG93IHRoZSBmb2xkIChvciBwZXIgYHNob3dTZXBhcmF0b3JgKS5cbiAgY29uc3Qgc2hvd0JvcmRlciA9XG4gICAgc2hvd1NlcGFyYXRvciA9PT0gXCJhbHdheXNcIiB8fCAoc2hvd1NlcGFyYXRvciA9PT0gXCJhdXRvXCIgJiYgIWF0Qm90dG9tKTtcbiAgcmV0dXJuIDxTdHlsZWRGb290ZXIgc2hvd0JvcmRlcj17c2hvd0JvcmRlcn0+e2NoaWxkcmVufTwvU3R5bGVkRm9vdGVyPjtcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFPcUIifQ== */");export function SandwichFooter({children,showSeparator="auto"}){let{atBottom}=useSandwichContext();return React.createElement(StyledFooter,{showBorder:"always"===showSeparator||"auto"===showSeparator&&!atBottom},children)}
+import React from"react";import styled from"@emotion/styled";import{useSandwichContext}from"./useSandwichContext";let StyledFooter=styled("div",{shouldForwardProp:prop=>"showBorder"!==prop,target:"e6qp72i0",label:"StyledFooter"})(({theme,showBorder})=>({position:"sticky",bottom:0,flex:"0 0 auto",marginTop:"auto",zIndex:1,borderTopWidth:1,borderTopStyle:"solid",borderTopColor:showBorder?theme.values.color.border.secondary.default:"transparent",transition:"border-color 0.15s ease"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export function SandwichFooter({children,showSeparator="auto","data-e2e-test-id":dataE2eTestId}){let{atBottom}=useSandwichContext();return React.createElement(StyledFooter,{showBorder:"always"===showSeparator||"auto"===showSeparator&&!atBottom,"data-e2e-test-id":dataE2eTestId},children)}

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

@@ -1,3 +1,3 @@
 import React from "react";
 import type { SandwichHeaderProps } from "./-types";
-export declare function SandwichHeader({ children, showSeparator, }: SandwichHeaderProps): React.ReactElement;
+export declare function SandwichHeader({ children, showSeparator, "data-e2e-test-id": dataE2eTestId, }: SandwichHeaderProps): React.ReactElement;

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

@@ -1 +1 @@
-import React from"react";import styled from"@emotion/styled";import{useSandwichContext}from"./useSandwichContext";let StyledHeader=styled("div",{shouldForwardProp:prop=>"showBorder"!==prop,target:"erdgd190",label:"StyledHeader"})(({theme,showBorder})=>({position:"sticky",top:0,flex:"0 0 auto",zIndex:1,borderBottomWidth:1,borderBottomStyle:"solid",borderBottomColor:showBorder?theme.values.color.border.secondary.default:"transparent",transition:"border-color 0.15s ease"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvSW50ZXJuYWwvU2FuZHdpY2gvU2FuZHdpY2hIZWFkZXIudHN4Iiwic291cmNlcyI6WyJzcmMvY29tcG9uZW50cy9JbnRlcm5hbC9TYW5kd2ljaC9TYW5kd2ljaEhlYWRlci50c3giXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFJlYWN0IGZyb20gXCJyZWFjdFwiO1xuaW1wb3J0IHN0eWxlZCBmcm9tIFwiQGVtb3Rpb24vc3R5bGVkXCI7XG5pbXBvcnQgdHlwZSB7IFNhbmR3aWNoSGVhZGVyUHJvcHMgfSBmcm9tIFwiLi8tdHlwZXNcIjtcbmltcG9ydCB7IHVzZVNhbmR3aWNoQ29udGV4dCB9IGZyb20gXCIuL3VzZVNhbmR3aWNoQ29udGV4dFwiO1xuXG5jb25zdCBCT1JERVJfV0lEVEggPSAxO1xuXG5jb25zdCBTdHlsZWRIZWFkZXIgPSBzdHlsZWQoXCJkaXZcIiwge1xuICBzaG91bGRGb3J3YXJkUHJvcDogKHByb3ApID0+IHByb3AgIT09IFwic2hvd0JvcmRlclwiLFxufSk8eyBzaG93Qm9yZGVyOiBib29sZWFuIH0+KCh7IHRoZW1lLCBzaG93Qm9yZGVyIH0pID0+ICh7XG4gIHBvc2l0aW9uOiBcInN0aWNreVwiLFxuICB0b3A6IDAsXG4gIGZsZXg6IFwiMCAwIGF1dG9cIixcbiAgekluZGV4OiAxLFxuICAvLyBSZXNlcnZlIHRoZSBib3JkZXIgYm94IGF0IGFsbCB0aW1lczsgb25seSB0aGUgY29sb3IgdG9nZ2xlcyBzbyB0aGUgZGl2aWRlclxuICAvLyBhcHBlYXJzIHdpdGhvdXQgc2hpZnRpbmcgbGF5b3V0LlxuICBib3JkZXJCb3R0b21XaWR0aDogQk9SREVSX1dJRFRILFxuICBib3JkZXJCb3R0b21TdHlsZTogXCJzb2xpZFwiLFxuICBib3JkZXJCb3R0b21Db2xvcjogc2hvd0JvcmRlclxuICAgID8gdGhlbWUudmFsdWVzLmNvbG9yLmJvcmRlci5zZWNvbmRhcnkuZGVmYXVsdFxuICAgIDogXCJ0cmFuc3BhcmVudFwiLFxuICB0cmFuc2l0aW9uOiBcImJvcmRlci1jb2xvciAwLjE1cyBlYXNlXCIsXG59KSk7XG5cbmV4cG9ydCBmdW5jdGlvbiBTYW5kd2ljaEhlYWRlcih7XG4gIGNoaWxkcmVuLFxuICBzaG93U2VwYXJhdG9yID0gXCJhdXRvXCIsXG59OiBTYW5kd2ljaEhlYWRlclByb3BzKTogUmVhY3QuUmVhY3RFbGVtZW50IHtcbiAgY29uc3QgeyBhdFRvcCB9ID0gdXNlU2FuZHdpY2hDb250ZXh0KCk7XG4gIC8vIERpdmlkZXIgb25jZSB0aGUgc3RhcnQgb2YgdGhlIGNvbnRlbnQgaXMgc2Nyb2xsZWQgYXdheSAob3IgcGVyIGBzaG93U2VwYXJhdG9yYCkuXG4gIGNvbnN0IHNob3dCb3JkZXIgPVxuICAgIHNob3dTZXBhcmF0b3IgPT09IFwiYWx3YXlzXCIgfHwgKHNob3dTZXBhcmF0b3IgPT09IFwiYXV0b1wiICYmICFhdFRvcCk7XG4gIHJldHVybiA8U3R5bGVkSGVhZGVyIHNob3dCb3JkZXI9e3Nob3dCb3JkZXJ9PntjaGlsZHJlbn08L1N0eWxlZEhlYWRlcj47XG59XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBT3FCIn0= */");export function SandwichHeader({children,showSeparator="auto"}){let{atTop}=useSandwichContext();return React.createElement(StyledHeader,{showBorder:"always"===showSeparator||"auto"===showSeparator&&!atTop},children)}
+import React from"react";import styled from"@emotion/styled";import{useSandwichContext}from"./useSandwichContext";let StyledHeader=styled("div",{shouldForwardProp:prop=>"showBorder"!==prop,target:"e1k5spef0",label:"StyledHeader"})(({theme,showBorder})=>({position:"sticky",top:0,flex:"0 0 auto",zIndex:1,borderBottomWidth:1,borderBottomStyle:"solid",borderBottomColor:showBorder?theme.values.color.border.secondary.default:"transparent",transition:"border-color 0.15s ease"}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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 */");export function SandwichHeader({children,showSeparator="auto","data-e2e-test-id":dataE2eTestId}){let{atTop}=useSandwichContext();return React.createElement(StyledHeader,{showBorder:"always"===showSeparator||"auto"===showSeparator&&!atTop,"data-e2e-test-id":dataE2eTestId},children)}

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

@@ -1,8 +1,8 @@
 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.
+ * Context decouples the parts: the scrollable root 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;

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

@@ -1 +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}
+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 must be used within <Sandwich>.");return ctx}

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
@@ -138,7 +138,11 @@ export type LayoutValue = {
     splitview: PanelHandle;
 };
 export type SidePanelProps = {
+    /** Panel content in source order. Header/footer components
+     *  (e.g. `<Layout.LeftPanelHeader />`) stick to the edges; the rest scrolls. */
     children: React.ReactNode;
+    /** Accessible name; when set, the panel renders as a `region` landmark. */
+    "aria-label"?: string;
     variant?: Variant;
     collapsible?: boolean;
     /** Number = pixels, unitless string = percent (e.g. `"30%"`). */
@@ -155,7 +159,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 +186,68 @@ 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;
     };
 };
-export type RightPanelContainerProps = {
-    title: RightPanelContainerTitle;
-    /** Scrollable body content. */
+export type RightPanelHeaderProps = PanelSlotHeaderProps & {
+    /** Title block (icon + heading), rendered after `leftSlot`. */
+    title?: RightPanelHeaderTitle;
+    /** Props forwarded to internal sub-components. */
+    slotProps: RightPanelHeaderSlotProps;
+};
+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 & {
+    /** 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;
 };
-export type RightPanelProps = SidePanelProps & Omit<RightPanelContainerProps, "data-e2e-test-id">;

package/build/{cjs/components/Layout → esm/components/Layout/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,{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/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}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:"e13g6fyp0",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/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  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  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":"AAsEqB"} */"),StyledSoloHost=styled("div",{target:"e13g6fyp1",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/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  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  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":"AA+EuB"} */");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.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/LeftPanel/LeftPanel.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import type { SidePanelProps } from "../-types";
+/**
+ * Left side panel. Declares the `leftPanel` 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. `Layout.LeftPanelHeader` /
+ * `Layout.LeftPanelFooter` children stick to the panel edges; the remaining
+ * content scrolls.
+ */
+export declare const LeftPanel: React.FC<SidePanelProps>;

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

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

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/{RightPanel.d.ts → RightPanel/RightPanel.d.ts}

@@ -1,9 +1,11 @@
 import React from "react";
-import type { RightPanelProps } from "./-types";
+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.
+ * that tracks the `--ds-layout-subnav-offset` var. `Layout.RightPanelHeader`
+ * / `Layout.RightPanelFooter` children stick to the panel edges; the
+ * remaining content scrolls.
  */
 export declare const RightPanel: React.FC<RightPanelProps>;

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

@@ -0,0 +1 @@
+import React from"react";import styled from"@emotion/styled";import{Slot,SUBNAV_OFFSET_VAR}from"../-constants";import{useDeclarePanel,useLayoutPortal,useVisibleChange}from"../registry";import{useLayout}from"../useLayout";import{PanelContainer}from"../PanelContainer";let StyledRightPanelSlot=styled("div",{target:"e4qhg680",label:"StyledRightPanelSlot"})(({theme})=>({position:"absolute",left:0,right:0,bottom:0,top:`var(${SUBNAV_OFFSET_VAR}, 0px)`,overflow:"hidden",transition:`top ${theme.variables.animation.navSlide.open.duration} ${theme.variables.animation.navSlide.open.timingFunction}`}),"/*# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3JjL2NvbXBvbmVudHMvTGF5b3V0L1JpZ2h0UGFuZWwvUmlnaHRQYW5lbC50c3giLCJzb3VyY2VzIjpbInNyYy9jb21wb25lbnRzL0xheW91dC9SaWdodFBhbmVsL1JpZ2h0UGFuZWwudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCBmcm9tIFwicmVhY3RcIjtcbmltcG9ydCBzdHlsZWQgZnJvbSBcIkBlbW90aW9uL3N0eWxlZFwiO1xuaW1wb3J0IHsgU2xvdCwgU1VCTkFWX09GRlNFVF9WQVIgfSBmcm9tIFwiLi4vLWNvbnN0YW50c1wiO1xuaW1wb3J0IHtcbiAgdXNlRGVjbGFyZVBhbmVsLFxuICB1c2VMYXlvdXRQb3J0YWwsXG4gIHVzZVZpc2libGVDaGFuZ2UsXG59IGZyb20gXCIuLi9yZWdpc3RyeVwiO1xuaW1wb3J0IHsgdXNlTGF5b3V0IH0gZnJvbSBcIi4uL3VzZUxheW91dFwiO1xuaW1wb3J0IHsgUGFuZWxDb250YWluZXIgfSBmcm9tIFwiLi4vUGFuZWxDb250YWluZXJcIjtcbmltcG9ydCB0eXBlIHsgUmlnaHRQYW5lbFByb3BzIH0gZnJvbSBcIi4uLy10eXBlc1wiO1xuXG4vLyBCdWlsdC1pbiBzbG90OiBvZmZzZXRzIHRoZSBwYW5lbCBjb250ZW50IGJ5IHRoZSBzdWJuYXYtb2Zmc2V0IHZhciAoMCB3aGVuXG4vLyB1bnNldCksIHRyYW5zaXRpb25lZCB3aXRoIHRoZSB0aGVtZSdzIGBuYXZTbGlkZWAgdGltaW5nIOKAlCBzbyB0aGUgcmlnaHQgcGFuZWxcbi8vIHRyYWNrcyBhIHN0aWNreSBzdWJuYXYgd2l0aCBubyB3aXJpbmcgb24gdGhlIGNvbnN1bWVyJ3Mgc2lkZS5cbmNvbnN0IFN0eWxlZFJpZ2h0UGFuZWxTbG90ID0gc3R5bGVkLmRpdigoeyB0aGVtZSB9KSA9PiAoe1xuICBwb3NpdGlvbjogXCJhYnNvbHV0ZVwiLFxuICBsZWZ0OiAwLFxuICByaWdodDogMCxcbiAgYm90dG9tOiAwLFxuICB0b3A6IGB2YXIoJHtTVUJOQVZfT0ZGU0VUX1ZBUn0sIDBweClgLFxuICBvdmVyZmxvdzogXCJoaWRkZW5cIixcbiAgdHJhbnNpdGlvbjogYHRvcCAke3RoZW1lLnZhcmlhYmxlcy5hbmltYXRpb24ubmF2U2xpZGUub3Blbi5kdXJhdGlvbn0gJHt0aGVtZS52YXJpYWJsZXMuYW5pbWF0aW9uLm5hdlNsaWRlLm9wZW4udGltaW5nRnVuY3Rpb259YCxcbn0pKTtcblxuLyoqXG4gKiBSaWdodCBzaWRlIHBhbmVsLiBEZWNsYXJlcyB0aGUgYHJpZ2h0UGFuZWxgIHNsb3QgYW5kIHBvcnRhbHMgaXRzIGNvbnRlbnQgaW50b1xuICogdGhlIEdyb3VwJ3MgaG9zdCB3aGlsZSB2aXNpYmxlLiBSZW5kZXJzIGluLWZsb3cgKGEgcmVzaXphYmxlIGNvbHVtbikgLSB0aGVcbiAqIG9mZmNhbnZhcyBvdmVybGF5IC8gbW9iaWxlIHNoZWV0IGlzIGRlZmVycmVkLiBDb250ZW50IGlzIHdyYXBwZWQgaW4gYSBzbG90XG4gKiB0aGF0IHRyYWNrcyB0aGUgYC0tZHMtbGF5b3V0LXN1Ym5hdi1vZmZzZXRgIHZhci4gYExheW91dC5SaWdodFBhbmVsSGVhZGVyYFxuICogLyBgTGF5b3V0LlJpZ2h0UGFuZWxGb290ZXJgIGNoaWxkcmVuIHN0aWNrIHRvIHRoZSBwYW5lbCBlZGdlczsgdGhlXG4gKiByZW1haW5pbmcgY29udGVudCBzY3JvbGxzLlxuICovXG5leHBvcnQgY29uc3QgUmlnaHRQYW5lbDogUmVhY3QuRkM8UmlnaHRQYW5lbFByb3BzPiA9ICh7XG4gIGNoaWxkcmVuLFxuICBkZWZhdWx0U2l6ZSA9IDM3OCxcbiAgbWluU2l6ZSA9IDMyOCxcbiAgbWF4U2l6ZSA9IFwiMzAlXCIsXG4gIGNvbGxhcHNpYmxlID0gZmFsc2UsXG4gIG9uVmlzaWJsZUNoYW5nZSxcbiAgXCJhcmlhLWxhYmVsXCI6IGFyaWFMYWJlbCxcbiAgc2Nyb2xsQ29udGFpbmVyUmVmLFxuICBvblNjcm9sbCxcbn0pID0+IHtcbiAgY29uc3QgeyBpc1Zpc2libGUgfSA9IHVzZUxheW91dCgpW1Nsb3QucmlnaHRQYW5lbF07XG4gIHVzZURlY2xhcmVQYW5lbChTbG90LnJpZ2h0UGFuZWwsIHtcbiAgICBkZWZhdWx0U2l6ZSxcbiAgICBtaW5TaXplLFxuICAgIG1heFNpemUsXG4gICAgY29sbGFwc2libGUsXG4gIH0pO1xuICB1c2VWaXNpYmxlQ2hhbmdlKGlzVmlzaWJsZSwgb25WaXNpYmxlQ2hhbmdlKTtcbiAgcmV0dXJuIHVzZUxheW91dFBvcnRhbChcbiAgICBTbG90LnJpZ2h0UGFuZWwsXG4gICAgaXNWaXNpYmxlID8gKFxuICAgICAgPFN0eWxlZFJpZ2h0UGFuZWxTbG90PlxuICAgICAgICA8UGFuZWxDb250YWluZXJcbiAgICAgICAgICBhcmlhLWxhYmVsPXthcmlhTGFiZWx9XG4gICAgICAgICAgc2Nyb2xsQ29udGFpbmVyUmVmPXtzY3JvbGxDb250YWluZXJSZWZ9XG4gICAgICAgICAgb25TY3JvbGw9e29uU2Nyb2xsfVxuICAgICAgICAgIHNob3dCb3JkZXJMZWZ0XG4gICAgICAgID5cbiAgICAgICAgICB7Y2hpbGRyZW59XG4gICAgICAgIDwvUGFuZWxDb250YWluZXI+XG4gICAgICA8L1N0eWxlZFJpZ2h0UGFuZWxTbG90PlxuICAgICkgOiBudWxsXG4gICk7XG59O1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWU2QiJ9 */");export const RightPanel=({children,defaultSize=378,minSize=328,maxSize="30%",collapsible=!1,onVisibleChange,"aria-label":ariaLabel,scrollContainerRef,onScroll})=>{let{isVisible}=useLayout()[Slot.rightPanel];return useDeclarePanel(Slot.rightPanel,{defaultSize,minSize,maxSize,collapsible}),useVisibleChange(isVisible,onVisibleChange),useLayoutPortal(Slot.rightPanel,isVisible?React.createElement(StyledRightPanelSlot,null,React.createElement(PanelContainer,{"aria-label":ariaLabel,scrollContainerRef:scrollContainerRef,onScroll:onScroll,showBorderLeft:!0},children)):null)};