@commercetools/nimbus 3.1.0 → 3.2.0

package/dist/chunks/use-responsive-splitter-sizes-9vsaSgGW.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-responsive-splitter-sizes-9vsaSgGW.cjs.js","names":[],"sources":["../../src/components/splitter/splitter.slots.tsx","../../src/components/splitter/splitter.context.ts","../../src/components/splitter/utils/clamped-resize.ts","../../src/components/splitter/utils/compute-aria-bounds.ts","../../src/components/splitter/utils/normalize-sizes.ts","../../src/components/splitter/utils/derive-initial-sizes.ts","../../src/components/splitter/utils/sizes-equal.ts","../../src/components/splitter/hooks/use-splitter-state.ts","../../src/components/splitter/components/splitter.root.tsx","../../src/components/splitter/hooks/use-splitter-context.ts","../../src/components/splitter/components/splitter.pane.tsx","../../src/components/splitter/components/splitter.aside.tsx","../../src/components/splitter/components/splitter.main.tsx","../../src/components/splitter/hooks/use-handle-keyboard.ts","../../src/components/splitter/hooks/use-handle-resize.ts","../../src/components/splitter/intl/en.ts","../../src/components/splitter/intl/de.ts","../../src/components/splitter/intl/es.ts","../../src/components/splitter/intl/fr-FR.ts","../../src/components/splitter/intl/pt-BR.ts","../../src/components/splitter/splitter.messages.ts","../../src/components/splitter/components/splitter.handle.tsx","../../src/components/splitter/splitter.tsx","../../src/components/splitter/utils/size-tokens.ts","../../src/components/splitter/utils/responsive-size.ts","../../src/components/splitter/utils/responsive-size-storage.ts","../../src/components/splitter/hooks/use-responsive-splitter-sizes.ts"],"sourcesContent":["import {\n  createSlotRecipeContext,\n  type HTMLChakraProps,\n  type RecipeVariantProps,\n} from \"@chakra-ui/react/styled-system\";\nimport type { splitterSlotRecipe } from \"./splitter.recipe\";\n\nconst { withProvider, withContext } = createSlotRecipeContext({\n  key: \"nimbusSplitter\",\n});\n\n// ============================================================\n// Root Slot\n// ============================================================\n\nexport type SplitterRootSlotProps = HTMLChakraProps<\n  \"div\",\n  RecipeVariantProps<typeof splitterSlotRecipe>\n>;\n\nexport const SplitterRootSlot = withProvider<\n  HTMLDivElement,\n  SplitterRootSlotProps\n>(\"div\", \"root\");\n\n// ============================================================\n// Pane Slot\n// ============================================================\n\nexport type SplitterPaneSlotProps = HTMLChakraProps<\"div\">;\n\nexport const SplitterPaneSlot = withContext<\n  HTMLDivElement,\n  SplitterPaneSlotProps\n>(\"div\", \"pane\");\n\n// ============================================================\n// Handle Slot\n// ============================================================\n\nexport type SplitterHandleSlotProps = HTMLChakraProps<\"div\">;\n\nexport const SplitterHandleSlot = withContext<\n  HTMLDivElement,\n  SplitterHandleSlotProps\n>(\"div\", \"handle\");\n","import { createContext } from \"react\";\nimport type { SplitterContextValue } from \"./splitter.types\";\n\n/**\n * Internal context shared between `Splitter.Root`, the pane components\n * (`Splitter.Aside` / `Splitter.Main`), and `Splitter.Handle`. Carries the\n * single aside `size`, role-based pane registration, commands, and the\n * configuration needed by the handle to compute its keyboard behavior and ARIA\n * attributes.\n *\n * @internal\n */\nexport const SplitterContext = createContext<SplitterContextValue | undefined>(\n  undefined\n);\n","export type ClampedResizeArgs = {\n  /** Current aside size (%), `0–100`. */\n  size: number;\n  /**\n   * Δ in percentage points applied to the aside size. Accepts floats. The\n   * handle translates its \"grow the leading pane\" gesture into an aside Δ before\n   * calling (aside leading → `+Δ`; aside trailing → `−Δ`).\n   */\n  delta: number;\n  /** Aside lower bound (%). */\n  minSize: number;\n  /** Aside upper bound (%) — caps aside growth; main's floor is `100 − maxSize`. */\n  maxSize: number;\n};\n\n/**\n * Apply Δ to the aside size, clamped into the aside's `[minSize, maxSize]`\n * window. With one boundary, that window fully describes the constraint: the\n * main pane's floor is the complement (`100 − maxSize`), enforced here by the\n * `maxSize` ceiling. The result preserves full float precision (no rounding).\n *\n * @see specs/nimbus-splitter/spec.md \"Aside size constraints with clamping\"\n */\nexport const clampedResize = ({\n  size,\n  delta,\n  minSize,\n  maxSize,\n}: ClampedResizeArgs): number =>\n  Math.min(Math.max(size + delta, minSize), maxSize);\n","import type { ResolvedAsideConfig } from \"../splitter.types\";\n\n/**\n * The lowest size the aside can reach. Normally its `minSize`, but a collapsible\n * aside can sit at its `collapsedSize` (the discrete collapse state, below\n * `minSize`), so the floor must include that — otherwise `aria-valuenow` would\n * fall outside the announced range while the aside is collapsed.\n */\nconst asideFloor = (cfg: ResolvedAsideConfig): number =>\n  cfg.collapsible ? Math.min(cfg.minSize, cfg.collapsedSize) : cfg.minSize;\n\n/**\n * Compute the W3C window-splitter ARIA bounds for the boundary, expressed for\n * the **leading** pane (the handle's `aria-valuenow` tracks the leading pane's\n * size). The aside's allowed window is `[asideFloor, maxSize]`; the bounds are\n * mapped onto whichever pane leads:\n *\n *   - aside leads → `{ min: asideFloor, max: maxSize }`\n *   - main leads  → `{ min: 100 − maxSize, max: 100 − asideFloor }`\n *\n * Bounds are collapse-aware so `aria-valuenow` stays in range even when the\n * aside is collapsed below its `minSize`.\n *\n * @param asideConfig - Resolved aside constraints.\n * @param asideLeads - True when the aside is the leading (prev) sibling.\n * @returns `{ min, max }` for `aria-valuemin` / `aria-valuemax`.\n *\n * @example\n * computeAriaBounds({ minSize: 10, maxSize: 80, collapsible: false, collapsedSize: 0 }, true);\n * // → { min: 10, max: 80 }\n */\nexport const computeAriaBounds = (\n  asideConfig: ResolvedAsideConfig,\n  asideLeads: boolean\n): { min: number; max: number } => {\n  const floor = asideFloor(asideConfig);\n  const ceil = asideConfig.maxSize;\n  return asideLeads\n    ? { min: floor, max: ceil }\n    : { min: 100 - ceil, max: 100 - floor };\n};\n","/**\n * Normalize an aside size (a single percentage) into the valid `0–100` range,\n * with full float precision preserved (no rounding, no `minSize` clamp). Used\n * both to seed the initial size from `defaultSize` and to reconcile an inbound\n * controlled `size` prop.\n *\n * Returns `null` when the value is not a finite number — letting callers\n * distinguish \"valid size\" from \"nothing usable\" rather than silently inventing\n * a layout. A finite but out-of-range value is clamped into `[0, 100]`.\n *\n * @param size - The aside size as a percentage (e.g. `defaultSize` or `size`).\n * @returns A percentage in `[0, 100]`, or `null` when the input is unusable.\n *\n * @example\n * normalizeSize(25);   // → 25\n * normalizeSize(150);  // → 100\n * normalizeSize(NaN);  // → null\n */\nexport const normalizeSize = (\n  size: number | null | undefined\n): number | null => {\n  if (typeof size !== \"number\" || !Number.isFinite(size)) return null;\n  return Math.min(Math.max(size, 0), 100);\n};\n","import { normalizeSize } from \"./normalize-sizes\";\n\n/**\n * Derive the initial aside size (%) for a splitter from `defaultSize`. There is\n * a single initialization path:\n *   1. Explicit `defaultSize` (clamped into `0–100`, full float precision).\n *   2. Otherwise an equal 50/50 split.\n *\n * @param defaultSize - Optional explicit aside size from `Splitter.Root`.\n * @returns The aside size as a percentage (`0–100`).\n *\n * @example\n * deriveInitialSize(31.25); // → 31.25\n * deriveInitialSize(undefined); // → 50\n */\nexport const deriveInitialSize = (defaultSize: number | undefined): number =>\n  normalizeSize(defaultSize) ?? 50;\n","// Aside sizes are compared within this tolerance so a value re-normalized on the\n// way in (e.g. a consumer feeding back the value we just emitted) reads as equal\n// despite last-ULP float drift — looser than that drift, far tighter than any\n// meaningful proportion change.\nconst SIZE_EPSILON = 1e-6;\n\n/**\n * Value equality for two aside sizes, within `SIZE_EPSILON`. Used to\n * short-circuit the controlled-`size` reconcile effect when the incoming value\n * already matches internal state (no write, no loop).\n *\n * @example\n * sizeEqual(30, 30);        // → true\n * sizeEqual(30, 30.0000001); // → true\n * sizeEqual(30, 31);         // → false\n */\nexport const sizeEqual = (\n  a: number | null | undefined,\n  b: number | null | undefined\n): boolean => {\n  if (a === b) return true;\n  if (a == null || b == null) return false;\n  return Math.abs(a - b) <= SIZE_EPSILON;\n};\n","import { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\nimport { deriveInitialSize, normalizeSize, sizeEqual } from \"../utils\";\nimport type {\n  ResolvedAsideConfig,\n  SplitterContextValue,\n  SplitterPaneRole,\n} from \"../splitter.types\";\n\ndeclare const process: { env: Record<string, string | undefined> } | undefined;\n\nconst COLLAPSE_TOLERANCE = 0.001;\n\ntype UseSplitterStateOptions = {\n  /** Splitter orientation; determines layout axis and active arrow keys. */\n  orientation: \"horizontal\" | \"vertical\";\n  /** Explicit initial aside size (read once on mount). */\n  defaultSize?: number;\n  /** Controlled aside size (settle-only). When set, size is controlled. */\n  size?: number;\n  /** Resolved aside constraints (clamping, collapse). */\n  asideConfig: ResolvedAsideConfig;\n  /** Keyboard step in percentage points per arrow-key press. */\n  keyboardStep: number;\n  /** When true, the handle ignores double-clicks. */\n  isDoubleClickDisabled: boolean;\n  /** When true, the whole splitter is non-interactive. */\n  isDisabled: boolean;\n  /** Controlled collapsed state of the aside. When set, collapse is controlled. */\n  collapsed?: boolean;\n  /** Uncontrolled initial collapsed state. */\n  defaultCollapsed?: boolean;\n  /** Fired on every size change, including each drag tick. */\n  onSizeChange?: (size: number) => void;\n  /** Fired once when a size interaction settles. */\n  onSizeChangeEnd?: (size: number) => void;\n  /** Fired whenever the aside collapses or expands. */\n  onCollapsedChange?: (collapsed: boolean) => void;\n};\n\n/** True once both the aside and main panes have registered. */\nconst bothRegistered = (order: SplitterPaneRole[]): boolean =>\n  order.includes(\"aside\") && order.includes(\"main\");\n\n/**\n * Owns the size state machine for `Splitter.Root`: role-based pane registration,\n * lazy initial-size derivation on mount, controlled/uncontrolled collapse of the\n * aside with size reconciliation, and the memoized context value handed to the\n * pane components and `Splitter.Handle`.\n *\n * The single source of truth is the aside's `size` (%); the main pane is always\n * `100 − size`. Sizes carry full float precision end-to-end — no rounding\n * anywhere in this pipeline (the only rounding lives on the handle's\n * `aria-valuenow`, an AT announcement that does not affect layout).\n *\n * Two change channels: `setSize` is the live drag channel (fires `onSizeChange`\n * only); `commitSize` is the settled channel (fires `onSizeChangeEnd`, the\n * persistence seam). Collapse is plain controlled/uncontrolled boolean state.\n */\nexport const useSplitterState = (\n  options: UseSplitterStateOptions\n): SplitterContextValue => {\n  const {\n    orientation,\n    defaultSize,\n    size: sizeProp,\n    asideConfig,\n    keyboardStep,\n    isDoubleClickDisabled,\n    isDisabled,\n    collapsed: collapsedProp,\n    defaultCollapsed,\n    onSizeChange,\n    onSizeChangeEnd,\n    onCollapsedChange,\n  } = options;\n\n  // Pane registration: role order in DOM, and the DOM id rendered on each.\n  const [paneOrder, setPaneOrder] = useState<SplitterPaneRole[]>([]);\n  const [paneDomIds, setPaneDomIds] = useState<\n    Partial<Record<SplitterPaneRole, string>>\n  >({});\n\n  // Size: controlled (prop provided) or uncontrolled (internal state). Control\n  // is settle-only — internal `size` stays authoritative during interaction; the\n  // prop is reconciled in at rest by the effect below.\n  const isSizeControlled = sizeProp !== undefined;\n  const isCollapseControlled = collapsedProp !== undefined;\n\n  // Initial layout, derived synchronously from props so the FIRST committed\n  // paint is correct — no 50/50 flash before an effect runs. Controlled `size`\n  // seeds the layout when present + valid; else the uncontrolled `defaultSize`\n  // path (with its 50/50 fallback). If the aside starts collapsed it shows\n  // `collapsedSize`, and the uncollapsed value is stashed as the expand target.\n  const initialBase =\n    (isSizeControlled ? normalizeSize(sizeProp) : null) ??\n    deriveInitialSize(defaultSize);\n  const initiallyCollapsed =\n    (collapsedProp ?? defaultCollapsed ?? false) && asideConfig.collapsible;\n  const initialDisplay = initiallyCollapsed\n    ? asideConfig.collapsedSize\n    : initialBase;\n\n  // Aside size state, seeded synchronously (above); the ref mirrors state so\n  // settled-commit and collapse reconciliation read the current value\n  // synchronously.\n  const [size, setSizeState] = useState<number>(initialDisplay);\n  const sizeRef = useRef<number>(initialDisplay);\n\n  // The controlled value the reconcile effect last acted on. Seeded to the raw\n  // prop so the effect's first run is a no-op; gates it against the *prop*\n  // changing, independent of internal drift.\n  const lastReconciledSizeRef = useRef<number | null>(sizeProp ?? null);\n  const didWarnControlledSizeRef = useRef(false);\n\n  // Mount snapshot for double-click restore; pre-collapse snapshot for expand\n  // (seeded to the uncollapsed value when the aside starts collapsed).\n  const initialSizeRef = useRef<number>(initialBase);\n  const preCollapseSizeRef = useRef<number | null>(\n    initiallyCollapsed ? initialBase : null\n  );\n\n  // Collapse: controlled (prop provided) or uncontrolled (internal state).\n  const [internalCollapsed, setInternalCollapsed] = useState<boolean>(\n    defaultCollapsed ?? false\n  );\n  const collapsed = isCollapseControlled\n    ? (collapsedProp ?? false)\n    : internalCollapsed;\n  // Whether the size state already reflects the collapse state. Seeded to the\n  // initial collapse so the reconciliation effect's mount run is a no-op; lets\n  // it skip when sizes already match, and lets an expand-by-resize clear\n  // collapse without the effect fighting it.\n  const appliedCollapseRef = useRef<boolean>(initiallyCollapsed);\n\n  // Single low-level size writer. `commit` additionally fires onSizeChangeEnd.\n  // Also detects expand-by-resize: if the aside grows past its collapsedSize\n  // (e.g. a double-click restore), collapse state is cleared.\n  const writeSize = useCallback(\n    (next: number, opts: { commit: boolean }) => {\n      sizeRef.current = next;\n      setSizeState(next);\n      onSizeChange?.(next);\n      if (opts.commit) onSizeChangeEnd?.(next);\n\n      if (\n        appliedCollapseRef.current &&\n        next > asideConfig.collapsedSize + COLLAPSE_TOLERANCE\n      ) {\n        appliedCollapseRef.current = false;\n        preCollapseSizeRef.current = null;\n        if (!isCollapseControlled) setInternalCollapsed(false);\n        onCollapsedChange?.(false);\n      }\n    },\n    [\n      onSizeChange,\n      onSizeChangeEnd,\n      asideConfig.collapsedSize,\n      isCollapseControlled,\n      onCollapsedChange,\n    ]\n  );\n\n  const setSize = useCallback(\n    (next: number) => writeSize(next, { commit: false }),\n    [writeSize]\n  );\n\n  const commitSize = useCallback(\n    (next?: number) => {\n      if (next !== undefined) {\n        writeSize(next, { commit: true });\n      } else {\n        onSizeChangeEnd?.(sizeRef.current);\n      }\n    },\n    [writeSize, onSizeChangeEnd]\n  );\n\n  // Initial size + collapse are seeded synchronously above (defaults are read\n  // once on mount, per spec — no onSizeChange on mount), so there is no\n  // registration-gated init effect. The reconcile effects below only wait for\n  // both panes to register before reacting to later prop/state changes.\n\n  // Reconcile size when the resolved collapsed state changes (controlled prop\n  // change or internal toggle). The mount case is a no-op (state already matches\n  // the seeded collapse).\n  useEffect(() => {\n    if (!bothRegistered(paneOrder)) return;\n    const cur = collapsed;\n    const prev = appliedCollapseRef.current;\n    if (cur === prev) return;\n    // Can't collapse a non-collapsible aside — leave the layout, stay a no-op.\n    if (cur && !asideConfig.collapsible) return;\n    appliedCollapseRef.current = cur;\n\n    if (cur) {\n      if (!prev) preCollapseSizeRef.current = sizeRef.current;\n      commitSize(asideConfig.collapsedSize);\n    } else {\n      const restore = preCollapseSizeRef.current;\n      preCollapseSizeRef.current = null;\n      commitSize(restore ?? initialSizeRef.current);\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [collapsed, paneOrder]);\n\n  // Reconcile a controlled `size` prop into internal state at rest — only when\n  // the prop changes, never on a drag tick (internal state stays authoritative\n  // during interaction). Declared after the collapse effect so collapse settles\n  // first. The write is silent (no callbacks): the value is the consumer's own.\n  useEffect(() => {\n    if (!isSizeControlled) return;\n    if (!bothRegistered(paneOrder)) return;\n    // Prop unchanged since last reconcile → nothing to do. Covers the post-init\n    // no-op and the \"consumer never feeds the value back\" case (no snap-back).\n    if (sizeEqual(sizeProp, lastReconciledSizeRef.current)) return;\n\n    const normalized = normalizeSize(sizeProp);\n    if (normalized === null) return; // malformed input → ignore, keep state\n    lastReconciledSizeRef.current = sizeProp ?? null;\n\n    // Collapse owns the aside's size. While collapsed, don't overwrite the\n    // collapsed layout — stash the controlled value as the expand target so a\n    // later expand restores it.\n    if (collapsed) {\n      preCollapseSizeRef.current = normalized;\n      return;\n    }\n\n    // Internal already matches (e.g. consumer fed back the emitted value) → no\n    // write. `size` is not a dep, so a silent write can't re-trigger this.\n    if (sizeEqual(normalized, sizeRef.current)) return;\n    sizeRef.current = normalized;\n    setSizeState(normalized);\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [sizeProp, paneOrder, collapsed]);\n\n  // Dev-time guidance on controlled-`size` misuse. Fires at most once.\n  useEffect(() => {\n    if (typeof process === \"undefined\" || process.env.NODE_ENV === \"production\")\n      return;\n    if (didWarnControlledSizeRef.current || !isSizeControlled) return;\n    if (defaultSize !== undefined) {\n      didWarnControlledSizeRef.current = true;\n      console.warn(\n        \"[Splitter] Both `size` (controlled) and `defaultSize` (uncontrolled) were provided. `defaultSize` is ignored — pass one or the other.\"\n      );\n    } else if (onSizeChangeEnd === undefined) {\n      didWarnControlledSizeRef.current = true;\n      console.warn(\n        \"[Splitter] `size` is controlled but `onSizeChangeEnd` is not set. After a drag or keyboard resize the splitter keeps that value and behaves as uncontrolled. Wire `onSizeChangeEnd` and feed the value back to stay controlled.\"\n      );\n    }\n  }, [isSizeControlled, defaultSize, onSizeChangeEnd]);\n\n  const registerPane = useCallback((role: SplitterPaneRole, domId: string) => {\n    setPaneOrder((order) => (order.includes(role) ? order : [...order, role]));\n    setPaneDomIds((map) =>\n      map[role] === domId ? map : { ...map, [role]: domId }\n    );\n  }, []);\n\n  const unregisterPane = useCallback((role: SplitterPaneRole) => {\n    setPaneOrder((order) => order.filter((r) => r !== role));\n    setPaneDomIds((map) => {\n      if (!(role in map)) return map;\n      const next = { ...map };\n      delete next[role];\n      return next;\n    });\n  }, []);\n\n  const setCollapsed = useCallback(\n    (next: boolean) => {\n      if (isDisabled) return;\n      if (next === collapsed) return;\n      if (next && !asideConfig.collapsible) return;\n      if (!isCollapseControlled) setInternalCollapsed(next);\n      onCollapsedChange?.(next);\n      // Size reconciliation happens in the collapse effect reacting to the\n      // resolved collapsed change (covers controlled + uncontrolled).\n    },\n    [\n      isDisabled,\n      collapsed,\n      asideConfig.collapsible,\n      isCollapseControlled,\n      onCollapsedChange,\n    ]\n  );\n\n  const restoreDefaults = useCallback(() => {\n    if (!bothRegistered(paneOrder)) return;\n    const initial = initialSizeRef.current;\n    if (collapsed) {\n      // Only touch internal collapse bookkeeping when uncontrolled. In\n      // controlled mode the prop is the source of truth — resetting the refs\n      // here would desync them from a prop that hasn't changed yet; instead we\n      // just fire the callback so the consumer can clear `collapsed`.\n      if (!isCollapseControlled) {\n        appliedCollapseRef.current = false;\n        preCollapseSizeRef.current = null;\n        setInternalCollapsed(false);\n      }\n      onCollapsedChange?.(false);\n    }\n    commitSize(initial);\n  }, [\n    paneOrder,\n    collapsed,\n    isCollapseControlled,\n    onCollapsedChange,\n    commitSize,\n  ]);\n\n  return useMemo<SplitterContextValue>(\n    () => ({\n      size,\n      setSize,\n      commitSize,\n      orientation,\n      keyboardStep,\n      isDoubleClickDisabled,\n      isDisabled,\n      asideConfig,\n      paneOrder,\n      paneDomIds,\n      registerPane,\n      unregisterPane,\n      collapsed,\n      setCollapsed,\n      restoreDefaults,\n    }),\n    [\n      size,\n      setSize,\n      commitSize,\n      orientation,\n      keyboardStep,\n      isDoubleClickDisabled,\n      isDisabled,\n      asideConfig,\n      paneOrder,\n      paneDomIds,\n      registerPane,\n      unregisterPane,\n      collapsed,\n      setCollapsed,\n      restoreDefaults,\n    ]\n  );\n};\n","import { useEffect, useMemo } from \"react\";\nimport { useSlotRecipe } from \"@chakra-ui/react/styled-system\";\nimport { extractStyleProps } from \"@/utils\";\nimport { SplitterRootSlot } from \"../splitter.slots\";\nimport { SplitterContext } from \"../splitter.context\";\nimport { useSplitterState } from \"../hooks/use-splitter-state\";\nimport type { ResolvedAsideConfig, SplitterRootProps } from \"../splitter.types\";\n\ndeclare const process: { env: Record<string, string | undefined> } | undefined;\n\n/**\n * Splitter root container. Owns the single aside `size` and resolves\n * controlled/uncontrolled size + collapse. Wrap one `Splitter.Aside` and one\n * `Splitter.Main` with one `Splitter.Handle` between them (aside on either side).\n *\n * @see https://www.w3.org/WAI/ARIA/apg/patterns/windowsplitter/\n * @supportsStyleProps\n */\nexport const SplitterRoot = ({\n  children,\n  orientation = \"horizontal\",\n  defaultSize,\n  size,\n  minSize,\n  maxSize,\n  collapsible,\n  collapsedSize,\n  onSizeChange,\n  onSizeChangeEnd,\n  collapsed,\n  defaultCollapsed,\n  onCollapsedChange,\n  keyboardStep = 5,\n  isDoubleClickDisabled = false,\n  isDisabled = false,\n  ref,\n  ...props\n}: SplitterRootProps) => {\n  const recipe = useSlotRecipe({ key: \"nimbusSplitter\" });\n  const [recipeProps, restRecipeProps] = recipe.splitVariantProps({\n    orientation,\n    ...props,\n  });\n  const [styleProps, restProps] = extractStyleProps(restRecipeProps);\n\n  const asideConfig = useMemo<ResolvedAsideConfig>(\n    () => ({\n      minSize: minSize ?? 0,\n      maxSize: maxSize ?? 100,\n      collapsible: collapsible ?? false,\n      collapsedSize: collapsedSize ?? 0,\n    }),\n    [minSize, maxSize, collapsible, collapsedSize]\n  );\n\n  const contextValue = useSplitterState({\n    orientation,\n    defaultSize,\n    size,\n    asideConfig,\n    collapsed,\n    defaultCollapsed,\n    keyboardStep,\n    isDoubleClickDisabled,\n    isDisabled,\n    onSizeChange,\n    onSizeChangeEnd,\n    onCollapsedChange,\n  });\n\n  // Dev-time warning: the Splitter primitive is strictly aside + main. Evaluated\n  // in an effect (not during render) so it fires after pane registration settles\n  // — panes register via effects, so a transient 1-pane commit (StrictMode\n  // double-invoke, staggered child mounts) is normal and must not warn.\n  const paneCount = contextValue.paneOrder.length;\n  useEffect(() => {\n    if (\n      typeof process !== \"undefined\" &&\n      process.env.NODE_ENV !== \"production\" &&\n      paneCount > 0 &&\n      paneCount !== 2\n    ) {\n      console.warn(\n        `[Splitter] Expected one <Splitter.Aside> and one <Splitter.Main>, got ${paneCount} pane(s). The Splitter primitive is 2-pane; nest a second Splitter inside a pane for 3+ regions.`\n      );\n    }\n  }, [paneCount]);\n\n  return (\n    <SplitterContext.Provider value={contextValue}>\n      <SplitterRootSlot\n        ref={ref}\n        {...recipeProps}\n        {...styleProps}\n        {...restProps}\n      >\n        {children}\n      </SplitterRootSlot>\n    </SplitterContext.Provider>\n  );\n};\n\nSplitterRoot.displayName = \"Splitter.Root\";\n","import { useContext } from \"react\";\nimport { SplitterContext } from \"../splitter.context\";\n\nexport const useSplitterContext = () => {\n  const context = useContext(SplitterContext);\n  if (!context) {\n    throw new Error(\"useSplitterContext must be used within a Splitter.Root\");\n  }\n  return context;\n};\n","import { useEffect, useId } from \"react\";\nimport { SplitterPaneSlot } from \"../splitter.slots\";\nimport { useSplitterContext } from \"../hooks/use-splitter-context\";\nimport type { SplitterAsideProps, SplitterPaneRole } from \"../splitter.types\";\n\ntype SplitterPaneBaseProps = SplitterAsideProps & {\n  /** Which pane this is — drives sizing and handle resolution. */\n  paneRole: SplitterPaneRole;\n};\n\n/**\n * Internal base shared by `Splitter.Aside` and `Splitter.Main`. Registers its\n * role + DOM id with the splitter (so the handle can resolve siblings and wire\n * `aria-controls`) and applies its size from context: the aside renders `size`%,\n * the main pane renders the remainder (`100 − size`%).\n *\n * @internal\n */\nexport const SplitterPaneBase = ({\n  paneRole,\n  id,\n  children,\n  style,\n  ref,\n  ...props\n}: SplitterPaneBaseProps) => {\n  const { size, orientation, registerPane, unregisterPane } =\n    useSplitterContext();\n\n  // Stable DOM id used by the handle's `aria-controls`. A consumer-provided `id`\n  // wins so analytics / test hooks resolve to a known element.\n  const generatedDomId = useId();\n  const domId = id ?? generatedDomId;\n\n  useEffect(() => {\n    registerPane(paneRole, domId);\n    return () => unregisterPane(paneRole);\n  }, [paneRole, domId, registerPane, unregisterPane]);\n\n  const paneSize = paneRole === \"aside\" ? size : 100 - size;\n  const sizeProperty = orientation === \"horizontal\" ? \"width\" : \"height\";\n  const paneStyle = { [sizeProperty]: `${paneSize}%`, ...style };\n\n  return (\n    <SplitterPaneSlot ref={ref} id={domId} style={paneStyle} {...props}>\n      {children}\n    </SplitterPaneSlot>\n  );\n};\n","import { SplitterPaneBase } from \"./splitter.pane\";\nimport type { SplitterAsideProps } from \"../splitter.types\";\n\n/**\n * The configurable pane inside a `Splitter.Root`. Its size is driven by Root's\n * `size` / `defaultSize` (and the `minSize` / `maxSize` / collapse config);\n * carries only its content and an optional `id`. May be placed before or after\n * `Splitter.Main`.\n *\n * @supportsStyleProps\n */\nexport const SplitterAside = (props: SplitterAsideProps) => (\n  <SplitterPaneBase paneRole=\"aside\" {...props} />\n);\n\nSplitterAside.displayName = \"Splitter.Aside\";\n","import { SplitterPaneBase } from \"./splitter.pane\";\nimport type { SplitterMainProps } from \"../splitter.types\";\n\n/**\n * The primary content pane inside a `Splitter.Root`. Always takes the space the\n * aside does not (`100 − size`); never configured directly. Carries only its\n * content and an optional `id`. May be placed before or after `Splitter.Aside`.\n *\n * @supportsStyleProps\n */\nexport const SplitterMain = (props: SplitterMainProps) => (\n  <SplitterPaneBase paneRole=\"main\" {...props} />\n);\n\nSplitterMain.displayName = \"Splitter.Main\";\n","import { useCallback } from \"react\";\nimport type { KeyboardEvent } from \"react\";\nimport { useSplitterContext } from \"./use-splitter-context\";\n\ntype UseHandleKeyboardOptions = {\n  /** True once both panes are registered. */\n  isReady: boolean;\n  /**\n   * Clamped size writer from `useHandleResize`. Already a no-op while disabled\n   * or collapse-locked, so the arrow / Home / End cases need no extra guard.\n   */\n  applyDelta: (delta: number, commit: boolean) => void;\n};\n\n/**\n * Owns the handle's keyboard model (W3C window splitter): orientation-aware\n * arrow keys move by `keyboardStep`, Home/End jump to min/max, Enter toggles\n * the aside's collapse. Each keypress commits (settled), unlike a live drag tick.\n *\n * Δ is expressed as \"grow the leading pane\"; `useHandleResize` translates it to\n * an aside Δ. Collapse is aside-only, so Enter simply toggles the boolean.\n */\nexport const useHandleKeyboard = ({\n  isReady,\n  applyDelta,\n}: UseHandleKeyboardOptions) => {\n  const {\n    orientation,\n    keyboardStep,\n    isDisabled,\n    collapsed,\n    setCollapsed,\n    asideConfig,\n  } = useSplitterContext();\n\n  const toggleCollapse = useCallback(() => {\n    if (!isReady || isDisabled) return;\n    // If collapsed, Enter expands; otherwise collapse the aside (when allowed).\n    if (collapsed) {\n      setCollapsed(false);\n      return;\n    }\n    if (asideConfig.collapsible) setCollapsed(true);\n  }, [isReady, isDisabled, collapsed, asideConfig.collapsible, setCollapsed]);\n\n  const onKeyDown = useCallback(\n    (event: KeyboardEvent) => {\n      if (!isReady || isDisabled) return;\n      switch (event.key) {\n        case \"ArrowLeft\":\n          if (orientation === \"horizontal\") {\n            event.preventDefault();\n            applyDelta(-keyboardStep, true);\n          }\n          return;\n        case \"ArrowRight\":\n          if (orientation === \"horizontal\") {\n            event.preventDefault();\n            applyDelta(keyboardStep, true);\n          }\n          return;\n        case \"ArrowUp\":\n          if (orientation === \"vertical\") {\n            event.preventDefault();\n            applyDelta(-keyboardStep, true);\n          }\n          return;\n        case \"ArrowDown\":\n          if (orientation === \"vertical\") {\n            event.preventDefault();\n            applyDelta(keyboardStep, true);\n          }\n          return;\n        case \"Home\":\n          event.preventDefault();\n          applyDelta(-100, true);\n          return;\n        case \"End\":\n          event.preventDefault();\n          applyDelta(100, true);\n          return;\n        case \"Enter\":\n          event.preventDefault();\n          toggleCollapse();\n          return;\n      }\n    },\n    [isReady, isDisabled, orientation, keyboardStep, applyDelta, toggleCollapse]\n  );\n\n  return { onKeyDown };\n};\n","import { useCallback, useRef } from \"react\";\nimport type { HTMLAttributes, RefObject } from \"react\";\nimport { useMove } from \"react-aria\";\nimport { useSplitterContext } from \"./use-splitter-context\";\nimport { clampedResize } from \"../utils\";\n\n// Drag deltas (in percentage points) below this are accumulated rather than\n// dropped, so slow / sub-pixel movement still registers once it adds up.\nconst MOVE_TOLERANCE = 0.0001;\n\ntype UseHandleResizeOptions = {\n  /** Ref to the handle, used to measure the container for px→% conversion. */\n  handleRef: RefObject<HTMLDivElement | null>;\n  /** True when the aside is the leading (prev) sibling — flips the Δ sign. */\n  asideLeads: boolean;\n  /** True once both panes are registered. */\n  isReady: boolean;\n  /** Locked while the aside is collapsed (resize would only snap to `minSize`). */\n  isResizeLocked: boolean;\n};\n\n/**\n * Owns the handle's resize mechanics: `applyDelta` (a clamped size writer,\n * returned so the keyboard hook reuses it) and `moveProps` (pointer drag via\n * react-aria `useMove`, converting px deltas to container percentages).\n *\n * The handle's gesture grows the *leading* pane by Δ. This is translated into an\n * aside Δ before clamping: aside leading → `+Δ`, aside trailing → `−Δ`. The\n * single aside size is then clamped into `[minSize, maxSize]`.\n */\nexport const useHandleResize = ({\n  handleRef,\n  asideLeads,\n  isReady,\n  isResizeLocked,\n}: UseHandleResizeOptions) => {\n  const { size, setSize, commitSize, orientation, isDisabled, asideConfig } =\n    useSplitterContext();\n\n  const applyDelta = useCallback(\n    (delta: number, commit: boolean) => {\n      if (!isReady || isDisabled || isResizeLocked) return;\n      const asideDelta = asideLeads ? delta : -delta;\n      const next = clampedResize({\n        size,\n        delta: asideDelta,\n        minSize: asideConfig.minSize,\n        maxSize: asideConfig.maxSize,\n      });\n      if (commit) {\n        commitSize(next);\n      } else {\n        setSize(next);\n      }\n    },\n    [\n      isReady,\n      isDisabled,\n      isResizeLocked,\n      asideLeads,\n      size,\n      asideConfig.minSize,\n      asideConfig.maxSize,\n      setSize,\n      commitSize,\n    ]\n  );\n\n  // Accumulate per-event deltas across a single drag so movements smaller than\n  // MOVE_TOLERANCE aren't dropped — they build up until they clear the gate.\n  const dragAccumRef = useRef(0);\n\n  const { moveProps } = useMove({\n    onMoveStart() {\n      dragAccumRef.current = 0;\n    },\n    onMove(e) {\n      if (!isReady || isDisabled || isResizeLocked) return;\n      const parent = handleRef.current?.parentElement;\n      if (!parent) return;\n      const containerSize =\n        orientation === \"horizontal\" ? parent.offsetWidth : parent.offsetHeight;\n      if (containerSize <= 0) return;\n      const deltaPx = orientation === \"horizontal\" ? e.deltaX : e.deltaY;\n      dragAccumRef.current += (deltaPx / containerSize) * 100;\n      const wholeDelta = dragAccumRef.current;\n      if (Math.abs(wholeDelta) < MOVE_TOLERANCE) return;\n      dragAccumRef.current -= wholeDelta;\n      applyDelta(wholeDelta, false);\n    },\n    onMoveEnd() {\n      if (!isReady || isDisabled || isResizeLocked) return;\n      // Settle: fire onSizeChangeEnd with the current size (the persistence seam).\n      commitSize();\n    },\n  });\n\n  return { moveProps, applyDelta } as {\n    moveProps: HTMLAttributes<HTMLElement>;\n    applyDelta: (delta: number, commit: boolean) => void;\n  };\n};\n","/**\n * Pre-compiled en messages for Splitter\n * Generated by @internationalized/string-compiler\n * DO NOT EDIT MANUALLY\n */\n\nexport default { resizePanes: `Resize panes` };\n","/**\n * Pre-compiled de messages for Splitter\n * Generated by @internationalized/string-compiler\n * DO NOT EDIT MANUALLY\n */\n\nexport default { resizePanes: `Resize panes` };\n","/**\n * Pre-compiled es messages for Splitter\n * Generated by @internationalized/string-compiler\n * DO NOT EDIT MANUALLY\n */\n\nexport default { resizePanes: `Resize panes` };\n","/**\n * Pre-compiled fr-FR messages for Splitter\n * Generated by @internationalized/string-compiler\n * DO NOT EDIT MANUALLY\n */\n\nexport default { resizePanes: `Resize panes` };\n","/**\n * Pre-compiled pt-BR messages for Splitter\n * Generated by @internationalized/string-compiler\n * DO NOT EDIT MANUALLY\n */\n\nexport default { resizePanes: `Resize panes` };\n","/**\n * Pre-compiled localized messages for Splitter component\n *\n * Generated by scripts/generate-dictionaries.ts\n * DO NOT EDIT MANUALLY\n *\n * @see https://react-spectrum.adobe.com/react-aria/internationalization.html\n */\n\nimport {\n  type LocalizedString,\n  type LocalizedStrings,\n} from \"@internationalized/string\";\nimport { normalizeMessages } from \"../../utils/normalize-messages\";\n\n// Pre-compiled message functions\nimport splitterMessages_en from \"./intl/en\";\nimport splitterMessages_de from \"./intl/de\";\nimport splitterMessages_es from \"./intl/es\";\nimport splitterMessages_fr from \"./intl/fr-FR\";\nimport splitterMessages_pt from \"./intl/pt-BR\";\n\n// Raw LocalizedStrings object for use with useLocalizedStringFormatter hook\nexport const splitterMessagesStrings: LocalizedStrings<\n  string,\n  LocalizedString\n> = {\n  en: normalizeMessages(splitterMessages_en),\n  de: normalizeMessages(splitterMessages_de),\n  es: normalizeMessages(splitterMessages_es),\n  \"fr-FR\": normalizeMessages(splitterMessages_fr),\n  \"pt-BR\": normalizeMessages(splitterMessages_pt),\n} as LocalizedStrings<string, LocalizedString>;\n\n/**\n * Available message keys for Splitter component\n */\nexport type SplitterMessageKey = \"resizePanes\";\n","import { useCallback, useRef } from \"react\";\nimport {\n  mergeProps,\n  useFocusRing,\n  useObjectRef,\n  useSeparator,\n} from \"react-aria\";\nimport { useLocalizedStringFormatter } from \"@/hooks\";\nimport { mergeRefs } from \"@/utils\";\nimport { SplitterHandleSlot } from \"../splitter.slots\";\nimport {\n  useSplitterContext,\n  useHandleResize,\n  useHandleKeyboard,\n} from \"../hooks\";\nimport { computeAriaBounds } from \"../utils\";\nimport { splitterMessagesStrings } from \"../splitter.messages\";\nimport type { SplitterHandleProps } from \"../splitter.types\";\n\n/**\n * Interactive `role=\"separator\"` between `Splitter.Aside` and `Splitter.Main`,\n * exposing the W3C window-splitter ARIA value attributes. Takes no per-handle\n * config (that lives on `Splitter.Root`); delegates drag, keyboard, and ARIA\n * bounds to focused hooks/utils. The aria value tracks the *leading* pane, so it\n * works whichever side the aside is on.\n *\n * @supportsStyleProps\n */\nexport const SplitterHandle = ({\n  \"aria-label\": ariaLabelProp,\n  \"aria-labelledby\": ariaLabelledBy,\n  style,\n  ref: forwardedRef,\n  ...props\n}: SplitterHandleProps) => {\n  const {\n    size,\n    orientation,\n    isDoubleClickDisabled,\n    isDisabled,\n    asideConfig,\n    paneOrder,\n    paneDomIds,\n    collapsed,\n    restoreDefaults,\n  } = useSplitterContext();\n\n  const msg = useLocalizedStringFormatter(splitterMessagesStrings);\n  const ariaLabel = ariaLabelProp ?? msg.format(\"resizePanes\");\n\n  const localRef = useRef<HTMLDivElement>(null);\n  const handleRef = useObjectRef(mergeRefs(localRef, forwardedRef));\n\n  // Resolve the two panes this handle controls from registration (DOM) order.\n  // The first registered role is the \"leading\" (left/top) pane; the aside can be\n  // on either side, so the single `size` maps to the leading pane accordingly.\n  const prevRole = paneOrder[0];\n  const nextRole = paneOrder[1];\n  const isReady = !!prevRole && !!nextRole && prevRole !== nextRole;\n  const asideLeads = prevRole === \"aside\";\n\n  // A collapsed aside sits below its `minSize`, so any resize could only snap\n  // back to `minSize` — lock resizing while collapsed (reopen via Enter,\n  // double-click, or the controlled prop).\n  const isResizeLocked = collapsed;\n\n  const { moveProps, applyDelta } = useHandleResize({\n    handleRef,\n    asideLeads,\n    isReady,\n    isResizeLocked,\n  });\n  const { onKeyDown } = useHandleKeyboard({ isReady, applyDelta });\n\n  const { separatorProps } = useSeparator({\n    orientation,\n    \"aria-label\": ariaLabel,\n    \"aria-labelledby\": ariaLabelledBy,\n  });\n  const { focusProps, isFocusVisible } = useFocusRing();\n\n  const handleDoubleClick = useCallback(() => {\n    if (isDisabled || isDoubleClickDisabled) return;\n    restoreDefaults();\n  }, [isDisabled, isDoubleClickDisabled, restoreDefaults]);\n\n  const { min: ariaValueMin, max: ariaValueMax } = computeAriaBounds(\n    asideConfig,\n    asideLeads\n  );\n\n  // The boundary position = the leading pane's size. With the aside leading\n  // that is `size`; with the main pane leading it is the remainder.\n  const prevSize = isReady ? (asideLeads ? size : 100 - size) : 0;\n  const ariaControls = isReady ? paneDomIds[prevRole] : undefined;\n  const roundedValueNow = isReady ? Math.round(prevSize) : undefined;\n\n  // Position the absolute-positioned handle on the boundary between the two\n  // panes. The recipe's `transform: translate(±50%)` centers the visible\n  // track on this offset so the interactive area straddles both panes.\n  const positionStyle =\n    orientation === \"horizontal\"\n      ? { left: `${prevSize}%` }\n      : { top: `${prevSize}%` };\n\n  const combinedProps = mergeProps(\n    separatorProps,\n    moveProps,\n    focusProps,\n    {\n      // `role=\"separator\"` comes from `separatorProps` (useSeparator) above.\n      tabIndex: isDisabled ? -1 : 0,\n      \"aria-valuenow\": roundedValueNow,\n      \"aria-valuemin\": ariaValueMin,\n      \"aria-valuemax\": ariaValueMax,\n      \"aria-valuetext\":\n        roundedValueNow !== undefined ? `${roundedValueNow}%` : undefined,\n      \"aria-orientation\": orientation,\n      \"aria-controls\": ariaControls,\n      \"aria-disabled\": isDisabled || undefined,\n      \"data-focus-visible\": isFocusVisible || undefined,\n      \"data-disabled\": isDisabled || undefined,\n      \"data-resize-locked\": isResizeLocked || undefined,\n      onKeyDown,\n      onDoubleClick: handleDoubleClick,\n      style: { ...positionStyle, ...style },\n    },\n    props\n  );\n\n  return <SplitterHandleSlot ref={handleRef} {...combinedProps} />;\n};\n\nSplitterHandle.displayName = \"Splitter.Handle\";\n","// Import from the barrel export index for consistent module resolution.\nimport {\n  SplitterRoot,\n  SplitterAside,\n  SplitterMain,\n  SplitterHandle,\n} from \"./components\";\n\n/**\n * Splitter\n * ============================================================\n * Compound primitive for a user-resizable 2-pane layout: a configurable\n * `Splitter.Aside` and a `Splitter.Main` that fills the remaining space.\n *\n * @see {@link https://www.w3.org/WAI/ARIA/apg/patterns/windowsplitter/}\n *\n * @example\n * ```tsx\n * <Splitter.Root defaultSize={30} minSize={15}>\n *   <Splitter.Aside>Navigation</Splitter.Aside>\n *   <Splitter.Handle />\n *   <Splitter.Main>Content</Splitter.Main>\n * </Splitter.Root>\n * ```\n */\nexport const Splitter = {\n  /**\n   * # Splitter.Root\n   *\n   * The root container that owns the single aside `size` and the flat sizing /\n   * collapse configuration. Must wrap one `Splitter.Aside` and one\n   * `Splitter.Main` with one `Splitter.Handle` between them (aside on either\n   * side).\n   *\n   * @example\n   * ```tsx\n   * <Splitter.Root orientation=\"horizontal\" defaultSize={40}>\n   *   <Splitter.Aside>Left</Splitter.Aside>\n   *   <Splitter.Handle />\n   *   <Splitter.Main>Right</Splitter.Main>\n   * </Splitter.Root>\n   * ```\n   */\n  Root: SplitterRoot,\n  /**\n   * # Splitter.Aside\n   *\n   * The configurable pane. Its size is driven by `Splitter.Root`'s `size` /\n   * `defaultSize` (and `minSize` / `maxSize` / collapse config); carries only\n   * its content and an optional `id`.\n   *\n   * @example\n   * ```tsx\n   * <Splitter.Aside>Sidebar content</Splitter.Aside>\n   * ```\n   */\n  Aside: SplitterAside,\n  /**\n   * # Splitter.Main\n   *\n   * The primary content pane. Always takes the space the aside does not\n   * (`100 − size`); never configured directly. Carries only its content and an\n   * optional `id`.\n   *\n   * @example\n   * ```tsx\n   * <Splitter.Main>Main content</Splitter.Main>\n   * ```\n   */\n  Main: SplitterMain,\n  /**\n   * # Splitter.Handle\n   *\n   * The interactive separator between the aside and main panes. Drag, arrow\n   * keys, and Home/End move the boundary; Enter toggles the aside's collapse\n   * (also controllable via `Splitter.Root`'s `collapsed`); double-click restores\n   * the boundary to its initial size.\n   *\n   * @example\n   * ```tsx\n   * <Splitter.Handle aria-label=\"Resize navigation\" />\n   * ```\n   */\n  Handle: SplitterHandle,\n};\n\n// Underscore-prefixed re-exports exist solely so the react-docgen-typescript\n// script can extract per-subcomponent prop tables. Consumers should use the\n// namespaced `Splitter.Root` / `Splitter.Aside` / `Splitter.Main` /\n// `Splitter.Handle`.\nexport {\n  SplitterRoot as _SplitterRoot,\n  SplitterAside as _SplitterAside,\n  SplitterMain as _SplitterMain,\n  SplitterHandle as _SplitterHandle,\n};\n","import { themeTokens } from \"@commercetools/nimbus-tokens\";\n\n/**\n * The curated set of `sizes` design tokens accepted by\n * `useResponsiveSplitterSizes` as size values and threshold keys: the named\n * t-shirt scale (`3xs`–`8xl`) and the `breakpoint-*` sizes.\n *\n * Hand-authored on purpose — deriving from `keyof typeof themeTokens.size` would\n * also pull in the numeric scale (`\"25\"`…`\"9600\"`), which both pollutes\n * autocomplete and makes a string like `\"400\"` ambiguous against the pixel\n * `number` `400`. A unit test asserts every member still exists in\n * `themeTokens.size`, so a token rename/removal becomes a build failure rather\n * than a silent runtime miss.\n */\nexport const SPLITTER_SIZE_TOKENS = [\n  \"3xs\",\n  \"2xs\",\n  \"xs\",\n  \"sm\",\n  \"md\",\n  \"lg\",\n  \"xl\",\n  \"2xl\",\n  \"3xl\",\n  \"4xl\",\n  \"5xl\",\n  \"6xl\",\n  \"7xl\",\n  \"8xl\",\n  \"breakpoint-sm\",\n  \"breakpoint-md\",\n  \"breakpoint-lg\",\n  \"breakpoint-xl\",\n  \"breakpoint-2xl\",\n] as const;\n\n/** A size token name accepted by `useResponsiveSplitterSizes`. */\nexport type SplitterSizeToken = (typeof SPLITTER_SIZE_TOKENS)[number];\n\nconst TOKEN_SET: ReadonlySet<string> = new Set(SPLITTER_SIZE_TOKENS);\n\n/** Type guard: is `value` one of the curated splitter size tokens? */\nexport const isSplitterSizeToken = (\n  value: unknown\n): value is SplitterSizeToken =>\n  typeof value === \"string\" && TOKEN_SET.has(value);\n\n/**\n * Resolve a size token to its pixel value via `themeTokens.size`. Returns `null`\n * when the token is missing or its value is not a finite pixel number.\n *\n * @example\n * resolveTokenToPx(\"breakpoint-sm\"); // → 480\n * resolveTokenToPx(\"md\");            // → 448\n */\nexport const resolveTokenToPx = (token: SplitterSizeToken): number | null => {\n  const entry = (\n    themeTokens.size as Record<string, { value: string } | undefined>\n  )[token];\n  if (!entry) return null;\n  const px = parseFloat(entry.value);\n  return Number.isFinite(px) ? px : null;\n};\n","import type {\n  ResponsiveSplitterSizeConfig,\n  ResponsiveSplitterSizeValue,\n} from \"../splitter.types\";\nimport { isSplitterSizeToken, resolveTokenToPx } from \"./size-tokens\";\n\n/** A finite, positive container measurement is required to convert pixels/tokens. */\nconst isMeasurable = (px: number | null | undefined): px is number =>\n  typeof px === \"number\" && Number.isFinite(px) && px > 0;\n\nconst PERCENT_PATTERN = /^-?\\d+(?:\\.\\d+)?%$/;\nconst NUMERIC_KEY_PATTERN = /^-?\\d+(?:\\.\\d+)?$/;\n\n/** Type guard: a `` `${number}%` `` string. */\nexport const isPercentValue = (value: unknown): value is `${number}%` =>\n  typeof value === \"string\" && PERCENT_PATTERN.test(value);\n\n/**\n * Resolve a single size value to a percentage of `containerPx`. A bare `number`\n * is pixels, a token resolves to pixels, a `\"N%\"` string passes through. Returns\n * `null` when unresolvable — a pixel/token value without a usable measurement,\n * or an unknown token.\n */\nexport const valueToPercent = (\n  value: ResponsiveSplitterSizeValue,\n  containerPx: number | null\n): number | null => {\n  if (typeof value === \"number\") {\n    return isMeasurable(containerPx) ? (value / containerPx) * 100 : null;\n  }\n  if (isPercentValue(value)) {\n    const n = parseFloat(value);\n    return Number.isFinite(n) ? n : null;\n  }\n  if (isSplitterSizeToken(value)) {\n    const px = resolveTokenToPx(value);\n    if (px === null || !isMeasurable(containerPx)) return null;\n    return (px / containerPx) * 100;\n  }\n  return null;\n};\n\n/** Clamp a percentage into `[min, max]` (defaults `[0, 100]`). */\nexport const clampPercent = (percent: number, min = 0, max = 100): number =>\n  Math.min(max, Math.max(min, percent));\n\n/** Convert a percentage back to pixels for persistence. */\nexport const percentToPx = (percent: number, containerPx: number): number =>\n  (percent / 100) * containerPx;\n\n/** A resolved band: the container min-width threshold (px) and its size value. */\nexport type SizeBand = {\n  thresholdPx: number;\n  value: ResponsiveSplitterSizeValue;\n};\n\nconst thresholdKeyToPx = (key: string): number | null => {\n  if (NUMERIC_KEY_PATTERN.test(key)) {\n    const n = parseFloat(key);\n    return Number.isFinite(n) ? n : null;\n  }\n  if (isSplitterSizeToken(key)) return resolveTokenToPx(key);\n  return null;\n};\n\n/** True when the config is a threshold map rather than a single value. */\nexport const isThresholdMap = (\n  config: ResponsiveSplitterSizeConfig\n): config is Partial<Record<string, ResponsiveSplitterSizeValue>> =>\n  config !== null && typeof config === \"object\";\n\n/**\n * Resolve a config into bands sorted ascending by threshold. A single value\n * becomes one band at threshold `0`; map keys resolve to pixels (numeric or\n * token), and unresolvable keys/values are dropped.\n */\nexport const toBands = (config: ResponsiveSplitterSizeConfig): SizeBand[] => {\n  if (!isThresholdMap(config)) {\n    return [{ thresholdPx: 0, value: config }];\n  }\n  const bands: SizeBand[] = [];\n  for (const [key, value] of Object.entries(config)) {\n    if (value === undefined) continue;\n    const thresholdPx = thresholdKeyToPx(key);\n    if (thresholdPx === null) continue;\n    bands.push({ thresholdPx, value });\n  }\n  bands.sort((a, b) => a.thresholdPx - b.thresholdPx);\n  return bands;\n};\n\n/** The configured value at a given threshold (for persistence unit lookup). */\nexport const bandValueAt = (\n  config: ResponsiveSplitterSizeConfig,\n  thresholdPx: number\n): ResponsiveSplitterSizeValue | undefined =>\n  toBands(config).find((b) => b.thresholdPx === thresholdPx)?.value;\n\n/**\n * Select the active band for a measured size: the largest threshold `≤`\n * measured, with the smallest band applying below it. When an `activeThresholdPx`\n * is supplied, a hysteresis `deadbandPx` keeps the active band until the measured\n * size crosses the band's boundaries by more than the deadband, preventing\n * per-frame flapping at a threshold.\n */\nexport const selectBand = (\n  bands: SizeBand[],\n  measuredPx: number,\n  opts?: { activeThresholdPx?: number | null; deadbandPx?: number }\n): SizeBand | null => {\n  if (bands.length === 0) return null;\n\n  const pick = (m: number): SizeBand => {\n    let chosen = bands[0]!;\n    for (const band of bands) {\n      if (band.thresholdPx <= m) chosen = band;\n      else break;\n    }\n    return chosen;\n  };\n\n  const candidate = pick(measuredPx);\n  const active = opts?.activeThresholdPx;\n  const deadband = opts?.deadbandPx ?? 0;\n  if (active == null || deadband <= 0 || candidate.thresholdPx === active) {\n    return candidate;\n  }\n\n  const activeIdx = bands.findIndex((b) => b.thresholdPx === active);\n  if (activeIdx === -1) return candidate;\n  const activeBand = bands[activeIdx]!;\n  const upperBound = bands[activeIdx + 1]?.thresholdPx ?? Infinity;\n  // The active band covers [active, upperBound). Keep it until the measured size\n  // is clearly outside that range by more than the deadband.\n  if (measuredPx >= active - deadband && measuredPx < upperBound + deadband) {\n    return activeBand;\n  }\n  return candidate;\n};\n\n/** A persisted band value: a pixel width or a percentage. */\nexport type StoredBand = { unit: \"px\" | \"pct\"; value: number };\n\n/**\n * Resolve one size dimension to a percentage given the current measurement,\n * optional hysteresis state, and (for the size dimension) an optional stored\n * override that takes precedence over the config default for the active band.\n *\n * Returns the resolved `percent` (or `null` when not yet resolvable — a\n * pixel/token value awaiting measurement) and the active band's `thresholdPx`\n * (the persistence key).\n */\nexport const resolveDimension = (\n  config: ResponsiveSplitterSizeConfig,\n  measuredPx: number | null,\n  opts?: {\n    activeThresholdPx?: number | null;\n    deadbandPx?: number;\n    stored?: Record<number, StoredBand> | null;\n  }\n): { percent: number | null; thresholdPx: number | null } => {\n  const bands = toBands(config);\n  if (bands.length === 0) return { percent: null, thresholdPx: null };\n\n  let active: SizeBand | null;\n  if (bands.length === 1) {\n    active = bands[0]!;\n  } else {\n    if (!isMeasurable(measuredPx)) return { percent: null, thresholdPx: null };\n    active = selectBand(bands, measuredPx, {\n      activeThresholdPx: opts?.activeThresholdPx,\n      deadbandPx: opts?.deadbandPx,\n    });\n  }\n  if (!active) return { percent: null, thresholdPx: null };\n\n  const stored = opts?.stored?.[active.thresholdPx];\n  if (stored) {\n    const pct =\n      stored.unit === \"pct\"\n        ? stored.value\n        : isMeasurable(measuredPx)\n          ? (stored.value / measuredPx) * 100\n          : null;\n    // A stored px without a measurement yet → fall through to the config default.\n    if (pct !== null) return { percent: pct, thresholdPx: active.thresholdPx };\n  }\n\n  return {\n    percent: valueToPercent(active.value, measuredPx),\n    thresholdPx: active.thresholdPx,\n  };\n};\n","import type { SplitterSizesStorage } from \"../splitter.types\";\nimport type { StoredBand } from \"./responsive-size\";\n\n/** Current persisted-payload schema version. Bump + migrate on shape changes. */\nexport const STORAGE_VERSION = 1;\n\ntype StoredPayload = {\n  v: number;\n  /** Bands keyed by resolved pixel threshold (as a string, per JSON). */\n  bands: Record<string, StoredBand>;\n};\n\nconst isStoredBand = (value: unknown): value is StoredBand => {\n  if (value === null || typeof value !== \"object\") return false;\n  const band = value as Record<string, unknown>;\n  return (\n    (band.unit === \"px\" || band.unit === \"pct\") &&\n    typeof band.value === \"number\" &&\n    Number.isFinite(band.value)\n  );\n};\n\n/**\n * Parse a raw stored payload string into a threshold-keyed band map. Tolerates\n * absent, corrupt, or older/unknown-version data by returning `null` (the caller\n * then resolves from config defaults). Versioned so future shape changes can\n * migrate rather than silently misread.\n */\nexport const parseStoredBands = (\n  raw: string | null\n): Record<number, StoredBand> | null => {\n  if (!raw) return null;\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch {\n    return null;\n  }\n  if (parsed === null || typeof parsed !== \"object\") return null;\n  const payload = parsed as Partial<StoredPayload>;\n  if (payload.v !== STORAGE_VERSION || typeof payload.bands !== \"object\") {\n    // Unknown/older version: no migration defined yet → ignore.\n    return null;\n  }\n  const out: Record<number, StoredBand> = {};\n  for (const [key, value] of Object.entries(payload.bands ?? {})) {\n    const thresholdPx = Number(key);\n    if (!Number.isFinite(thresholdPx)) continue;\n    if (isStoredBand(value)) out[thresholdPx] = value;\n  }\n  return out;\n};\n\n/** Serialize a band map into the versioned payload string. */\nexport const serializeStoredBands = (\n  bands: Record<number, StoredBand>\n): string => JSON.stringify({ v: STORAGE_VERSION, bands });\n\n/**\n * A `localStorage`-backed {@link SplitterSizesStorage} that never throws and\n * no-ops when `localStorage` is unavailable (SSR, privacy mode, quota). Used as\n * the default adapter.\n */\nexport const createLocalStorageAdapter = (): SplitterSizesStorage => ({\n  getItem: (key) => {\n    try {\n      if (typeof localStorage === \"undefined\") return null;\n      return localStorage.getItem(key);\n    } catch {\n      return null;\n    }\n  },\n  setItem: (key, value) => {\n    try {\n      if (typeof localStorage === \"undefined\") return;\n      localStorage.setItem(key, value);\n    } catch {\n      // Quota / denied — persistence is best-effort.\n    }\n  },\n});\n","import { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\nimport type {\n  ResponsiveSplitterRootProps,\n  UseResponsiveSplitterSizesOptions,\n  UseResponsiveSplitterSizesResult,\n} from \"../splitter.types\";\nimport {\n  bandValueAt,\n  clampPercent,\n  isPercentValue,\n  percentToPx,\n  resolveDimension,\n  type StoredBand,\n} from \"../utils/responsive-size\";\nimport {\n  createLocalStorageAdapter,\n  parseStoredBands,\n  serializeStoredBands,\n} from \"../utils/responsive-size-storage\";\n\n/**\n * Emitted `size` only changes when it moves by more than this many percentage\n * points — coarser than the component's internal `1e-6` epsilon so pixel↔percent\n * round-trips under `ResizeObserver` ticks don't thrash the controlled prop.\n */\nconst EMIT_TOLERANCE = 0.05;\n/** Ignore sub-pixel measurement noise. */\nconst MEASURE_TOLERANCE = 0.5;\n/** Hysteresis deadband (px) around band thresholds. */\nconst BAND_DEADBAND = 2;\n\n/** Module-level default so the adapter identity is stable across renders. */\nconst defaultStorage = createLocalStorageAdapter();\n\n/**\n * Translate a pixel-/token-/percent size config — optionally responsive by\n * container width — into the percentage `Splitter.Root` consumes, returning\n * `rootProps` to spread onto the root.\n *\n * The hook is the **pixel/token → percentage translator** the component\n * deliberately omits: `Splitter.Root` stays percentage-native; all pixel math,\n * container-width resolution, hook-side clamping, and per-band persistence live\n * here. It drives the component's settle-only controlled `size` channel and\n * feeds the settled value back, so the controlled loop stays closed with no\n * snap-back. A bare `number` is **always pixels**.\n *\n * @example\n * const { rootProps } = useResponsiveSplitterSizes({\n *   orientation: \"horizontal\",\n *   persistKey: \"app:main-splitter\",\n *   size: { 0: 320, 768: \"30%\" }, // 320px below 768px container width, 30% above\n * });\n * return (\n *   <Splitter.Root {...rootProps} collapsible>\n *     <Splitter.Aside>…</Splitter.Aside>\n *     <Splitter.Handle />\n *     <Splitter.Main>…</Splitter.Main>\n *   </Splitter.Root>\n * );\n */\nexport const useResponsiveSplitterSizes = (\n  options: UseResponsiveSplitterSizesOptions\n): UseResponsiveSplitterSizesResult => {\n  const {\n    orientation = \"horizontal\",\n    size,\n    minSize,\n    maxSize,\n    collapsedSize,\n    persistKey,\n    storage = defaultStorage,\n    onCollapsedChange,\n  } = options;\n\n  // Latest measured container size on the relevant axis (null until observed).\n  const [measured, setMeasured] = useState<number | null>(null);\n  const measuredRef = useRef<number | null>(null);\n\n  // Persisted bands for the size dimension, keyed by resolved px threshold.\n  const [storedBands, setStoredBands] = useState<Record<number, StoredBand>>(\n    () =>\n      persistKey ? (parseStoredBands(storage.getItem(persistKey)) ?? {}) : {}\n  );\n  const storedBandsRef = useRef(storedBands);\n  storedBandsRef.current = storedBands;\n\n  // Hysteresis: the band the size dimension currently resolves to.\n  const activeThresholdRef = useRef<number | null>(null);\n  // Gate for the emitted controlled size.\n  const lastEmittedRef = useRef<number | null>(null);\n  const [emittedSize, setEmittedSize] = useState<number | undefined>(undefined);\n  // Whether the aside is currently collapsed (so settles aren't persisted).\n  const collapsedRef = useRef(false);\n\n  // Latest config snapshot for the (stable) settle handler.\n  const latestRef = useRef({ size, persistKey, onCollapsedChange });\n  latestRef.current = { size, persistKey, onCollapsedChange };\n\n  // --- Resolution (recomputed each render; cheap + pure) ---------------------\n  const sizeRes = resolveDimension(size, measured, {\n    activeThresholdPx: activeThresholdRef.current,\n    deadbandPx: BAND_DEADBAND,\n    stored: storedBands,\n  });\n  const minPct =\n    minSize !== undefined\n      ? (resolveDimension(minSize, measured).percent ?? undefined)\n      : undefined;\n  const maxPct =\n    maxSize !== undefined\n      ? (resolveDimension(maxSize, measured).percent ?? undefined)\n      : undefined;\n  const collapsedPct =\n    collapsedSize !== undefined\n      ? (resolveDimension(collapsedSize, measured).percent ?? undefined)\n      : undefined;\n\n  const targetSize =\n    sizeRes.percent === null\n      ? null\n      : clampPercent(sizeRes.percent, minPct ?? 0, maxPct ?? 100);\n\n  // Commit the active band + gated emitted size after render (never during).\n  useEffect(() => {\n    if (sizeRes.thresholdPx !== null) {\n      activeThresholdRef.current = sizeRes.thresholdPx;\n    }\n    if (targetSize === null) return;\n    if (\n      lastEmittedRef.current !== null &&\n      Math.abs(targetSize - lastEmittedRef.current) < EMIT_TOLERANCE\n    ) {\n      return;\n    }\n    lastEmittedRef.current = targetSize;\n    setEmittedSize(targetSize);\n  }, [targetSize, sizeRes.thresholdPx]);\n\n  // --- Container measurement (ResizeObserver) --------------------------------\n  const ref = useCallback(\n    (node: HTMLDivElement | null) => {\n      if (!node) return;\n\n      const read = (width: number, height: number) => {\n        const next = orientation === \"vertical\" ? height : width;\n        if (!Number.isFinite(next) || next <= 0) return;\n        measuredRef.current = next;\n        setMeasured((prev) =>\n          prev !== null && Math.abs(prev - next) < MEASURE_TOLERANCE\n            ? prev\n            : next\n        );\n      };\n\n      if (typeof ResizeObserver === \"undefined\") {\n        // No observer (SSR/older runtimes): best-effort one-shot measurement so\n        // px/token configs can still resolve once; %-only config is unaffected.\n        const rect = node.getBoundingClientRect();\n        read(rect.width, rect.height);\n        return;\n      }\n\n      const observer = new ResizeObserver((entries) => {\n        const entry = entries[0];\n        if (!entry) return;\n        read(entry.contentRect.width, entry.contentRect.height);\n      });\n      observer.observe(node);\n      return () => observer.disconnect();\n    },\n    [orientation]\n  );\n\n  // --- Settle handler: persist (unless collapsed) + feed value back ----------\n  const handleSizeChangeEnd = useCallback(\n    (settledPct: number) => {\n      // Collapse fires `onCollapsedChange(true)` before this settle, so a\n      // collapse-driven settle is suppressed here: no feedback (keep the\n      // controlled value at the expanded size, which becomes the expand target)\n      // and no persistence.\n      if (collapsedRef.current) return;\n\n      lastEmittedRef.current = settledPct;\n      setEmittedSize(settledPct);\n\n      const { size: sizeCfg, persistKey: key } = latestRef.current;\n      const containerPx = measuredRef.current;\n      if (!key || containerPx === null || containerPx <= 0) return;\n\n      const { thresholdPx } = resolveDimension(sizeCfg, containerPx, {\n        activeThresholdPx: activeThresholdRef.current,\n        deadbandPx: BAND_DEADBAND,\n      });\n      if (thresholdPx === null) return;\n\n      const configured = bandValueAt(sizeCfg, thresholdPx);\n      const unit: StoredBand[\"unit\"] = isPercentValue(configured)\n        ? \"pct\"\n        : \"px\";\n      const value =\n        unit === \"pct\" ? settledPct : percentToPx(settledPct, containerPx);\n\n      const nextBands = {\n        ...storedBandsRef.current,\n        [thresholdPx]: { unit, value },\n      };\n      storedBandsRef.current = nextBands;\n      setStoredBands(nextBands);\n      try {\n        storage.setItem(key, serializeStoredBands(nextBands));\n      } catch {\n        // Best-effort; resolution still works from in-memory state.\n      }\n    },\n    [storage]\n  );\n\n  const handleCollapsedChange = useCallback((collapsed: boolean) => {\n    collapsedRef.current = collapsed;\n    latestRef.current.onCollapsedChange?.(collapsed);\n  }, []);\n\n  // Prefer the gated `emittedSize` (stable across sub-tolerance resize ticks),\n  // but fall back to the freshly-resolved `targetSize` before the gate's effect\n  // first runs. This is what makes a synchronously-resolvable config (e.g. a\n  // `%` value, which needs no measurement) drive the controlled `size` on the\n  // very first render — so the component honors it on first paint with no flash,\n  // rather than briefly showing its uncontrolled default.\n  const resolvedSize = emittedSize ?? targetSize ?? undefined;\n\n  const rootProps = useMemo<ResponsiveSplitterRootProps>(() => {\n    const props: ResponsiveSplitterRootProps = {\n      ref,\n      orientation,\n      onSizeChangeEnd: handleSizeChangeEnd,\n      onCollapsedChange: handleCollapsedChange,\n    };\n    if (resolvedSize !== undefined) props.size = resolvedSize;\n    if (minPct !== undefined) props.minSize = minPct;\n    if (maxPct !== undefined) props.maxSize = maxPct;\n    if (collapsedPct !== undefined) props.collapsedSize = collapsedPct;\n    return props;\n  }, [\n    ref,\n    orientation,\n    handleSizeChangeEnd,\n    handleCollapsedChange,\n    resolvedSize,\n    minPct,\n    maxPct,\n    collapsedPct,\n  ]);\n\n  return { rootProps };\n};\n"],"mappings":"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"}