@dialpad/dialtone-vue 3.222.0-next.2 → 3.222.1

package/dist/resizable-CPaF9dgG.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizable-CPaF9dgG.js","names":[],"sources":["../components/resizable/composables/useResizablePanelState.ts","../components/resizable/composables/useResizablePanelControls.ts","../components/resizable/composables/computeLayout.ts","../components/resizable/composables/useResizableStorage.ts","../components/resizable/composables/useResizableGroup.ts","../components/resizable/composables/useResizableDrag.ts","../components/resizable/composables/useResizableAnnouncements.ts","../components/resizable/composables/useResizableOffset.ts","../components/resizable/resizable.vue"],"sourcesContent":["/**\n * Panel State Model\n *\n * Pure functions for panel state creation, constraint calculation, and validation.\n * Single source of truth for all constraint-related logic.\n *\n * Constraint math has been extracted to constraintResolver.ts.\n */\n\nimport { DEFAULT_PANEL_SIZE } from '../resizable_constants';\nimport type { ResizablePanelConfig, ResizablePanelState } from '../resizable_constants';\nimport { parseSizeToPixels } from '../resizable_utils';\nimport { clampToTier } from './constraintResolver';\n\nimport { calculateConstraintHierarchy } from './constraintResolver';\n\n// Re-export constraint types and functions from constraintResolver\nexport type { ConstraintHierarchy } from './constraintResolver';\nexport { calculateConstraintHierarchy } from './constraintResolver';\n\n/**\n * Apply constraints to a pixel size for a panel.\n *\n * Updates panel's constraint pixel values and returns the constrained size.\n *\n * @param panel - Panel state to update constraints on\n * @param pixelSize - Desired pixel size before constraints\n * @param containerSize - Current container size in pixels\n * @param constraintType - Which constraints to apply: 'user' (default) or 'system'\n * @returns Constrained pixel size respecting bounds\n */\nexport function applyPanelPixelConstraints(\n  panel: ResizablePanelState,\n  pixelSize: number,\n  containerSize: number,\n  constraintType: 'user' | 'system' = 'user'\n): number {\n  const constraints = calculateConstraintHierarchy(panel, containerSize);\n\n  panel.userMinSizePixels = constraints.userMinSizePixels;\n  panel.userMaxSizePixels = constraints.userMaxSizePixels;\n  panel.systemMinSizePixels = constraints.systemMinSizePixels;\n  panel.systemMaxSizePixels = constraints.systemMaxSizePixels;\n  panel.collapseSizePixels = constraints.collapseSizePixels;\n\n  return clampToTier(pixelSize, constraints, constraintType);\n}\n\n// ============================================================================\n// PANEL STATE CREATION\n// ============================================================================\n\nfunction applyConstraintsToSize(pixelSize: number, minSizePixels?: number, maxSizePixels?: number): number {\n  let constrained = pixelSize;\n  if (minSizePixels !== undefined) {\n    constrained = Math.max(constrained, minSizePixels);\n  }\n  if (maxSizePixels !== undefined) {\n    constrained = Math.min(constrained, maxSizePixels);\n  }\n  return constrained;\n}\n\nfunction derivePanelBehavioralState(\n  panelConfig: ResizablePanelConfig,\n  existingPanel?: ResizablePanelState\n): { collapsed: boolean; manualTargetSize: number | undefined } {\n  return {\n    collapsed: existingPanel?.collapsed ?? Boolean(panelConfig.collapsed),\n    manualTargetSize: existingPanel?.manualTargetSize,\n  };\n}\n\n/**\n * Create initial panel state from configuration.\n */\nexport function createPanelState(\n  panelConfig: ResizablePanelConfig,\n  containerSize: number,\n  existingPanel?: ResizablePanelState\n): ResizablePanelState {\n  const constraints = calculateConstraintHierarchy(panelConfig, containerSize);\n\n  const rawPixelSize = parseSizeToPixels(panelConfig.initialSize ?? DEFAULT_PANEL_SIZE, containerSize);\n  const pixelSize = applyConstraintsToSize(rawPixelSize, constraints.userMinSizePixels, constraints.userMaxSizePixels);\n\n  const behavioralState = derivePanelBehavioralState(panelConfig, existingPanel);\n  const autoCollapsed = existingPanel?.autoCollapsed;\n\n  return {\n    ...panelConfig,\n    pixelSize,\n    ...behavioralState,\n    userMinSizePixels: constraints.userMinSizePixels,\n    userMaxSizePixels: constraints.userMaxSizePixels,\n    systemMinSizePixels: constraints.systemMinSizePixels,\n    systemMaxSizePixels: constraints.systemMaxSizePixels,\n    collapseSizePixels: constraints.collapseSizePixels,\n    autoCollapsed,\n  };\n}\n\n/**\n * Create panel states for all panels in a configuration array.\n */\nexport function createBasicPanelStates(\n  allPanels: ResizablePanelConfig[],\n  containerSize: number,\n  existingPanels?: ResizablePanelState[]\n): ResizablePanelState[] {\n  return allPanels.map(panelConfig => {\n    const existingPanel = existingPanels?.find(p => p.id === panelConfig.id);\n    return createPanelState(panelConfig, containerSize, existingPanel);\n  });\n}\n\n// ============================================================================\n// PANEL STATE VALIDATION\n// ============================================================================\n\n/**\n * Check if a panel pair should be skipped during constraint processing.\n */\nexport function shouldSkipPanelPair(beforePanel: ResizablePanelState, afterPanel: ResizablePanelState): boolean {\n  return (\n    beforePanel.resizable === false ||\n    !!beforePanel.collapsed ||\n    afterPanel.resizable === false ||\n    !!afterPanel.collapsed\n  );\n}\n\n/**\n * Check if a panel pair can be reset to initial sizes.\n */\nexport function canResetPanelPair(beforePanel: ResizablePanelState, afterPanel: ResizablePanelState): boolean {\n  return (\n    beforePanel.resizable !== false && !beforePanel.collapsed && afterPanel.resizable !== false && !afterPanel.collapsed\n  );\n}\n","/**\n * Panel Controls Controller\n *\n * Operations for manipulating panel state: resize, collapse, reset.\n * Receives resizeHandler from Integration layer (single instance pattern).\n */\n\nimport type { Ref } from 'vue';\nimport { DEFAULT_PANEL_SIZE } from '../resizable_constants';\nimport type {\n  ResizablePanelState,\n  ResizableSizeValue,\n  CollapseRule,\n} from '../resizable_constants';\nimport { parseSizeToPixels } from '../resizable_utils';\nimport { applyPanelPixelConstraints, canResetPanelPair } from './useResizablePanelState';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\n/**\n * State snapshot captured before a panel is collapsed.\n */\nexport interface PreCollapseState {\n  sizes: Map<string, number>;\n  manualTargets: Map<string, number | undefined>;\n  containerSize: number;\n}\n\nexport type CollapseRequestSource =\n  | 'user'\n  | 'system'\n  | 'prop'\n  | 'storage';\n\nexport interface CollapseRequest {\n  panelId: string;\n  action: 'collapse' | 'expand';\n  source: CollapseRequestSource;\n}\n\nexport interface CollapseRequestResult {\n  success: boolean;\n  reason?: string;\n  panelId: string;\n  newState: 'collapsed' | 'expanded' | 'unchanged';\n}\n\nexport interface CollapseOptions {\n  isAutoCollapse?: boolean;\n}\n\nexport interface ResizablePanelControlsOptions {\n  panels: Ref<ResizablePanelState[]>;\n  containerSize: Ref<number>;\n  containerRef: Ref<HTMLElement | null>;\n  onPanelResize: (panelId: string, pixelSize: number) => void;\n  onPanelCollapse: (panelId: string, collapsed: boolean) => void;\n  updateSavedPanel: (panelId: string, updates: Partial<import('./useResizableStorage').SavedPanelData>) => void;\n}\n\n// ============================================================================\n// MAIN COMPOSABLE\n// ============================================================================\n\nexport function useResizablePanelControls(options: ResizablePanelControlsOptions) {\n  const {\n    panels,\n    containerSize,\n    containerRef,\n    onPanelResize,\n    onPanelCollapse,\n    updateSavedPanel,\n  } = options;\n\n  const preCollapseStates = new Map<string, PreCollapseState>();\n\n  // ---- Size Conversion ----\n\n  function convertToPixelSize(initialSize: ResizableSizeValue): number {\n    return parseSizeToPixels(initialSize, containerSize.value);\n  }\n\n  // ============================================================================\n  // CENTRALIZED COLLAPSE LOGIC\n  // ============================================================================\n\n  function processCollapseRequest(request: CollapseRequest): CollapseRequestResult {\n    const { panelId, action, source } = request;\n    const panel = panels.value.find(p => p.id === panelId);\n    const isCollapse = action === 'collapse';\n\n    const validationResult = validateCollapseRequest(panelId, panel, isCollapse);\n    if (validationResult) return validationResult;\n\n    if (isCollapse) {\n      executeCollapse(panel!, source);\n    } else {\n      executeExpand(panel!);\n    }\n\n    onPanelCollapse(panelId, isCollapse);\n    if (containerRef.value) {\n      containerRef.value.dispatchEvent(new CustomEvent('panels-updated'));\n    }\n\n    const newState = isCollapse ? 'collapsed' : 'expanded';\n\n    return { success: true, panelId, newState };\n  }\n\n  function validateCollapseRequest(\n    panelId: string,\n    panel: ResizablePanelState | undefined,\n    isCollapse: boolean\n  ): CollapseRequestResult | undefined {\n    if (!panel) {\n      return { success: false, reason: 'Panel not found', panelId, newState: 'unchanged' };\n    }\n\n    const currentlyCollapsed = panel.collapsed;\n    if (isCollapse && currentlyCollapsed) {\n      return { success: true, reason: 'Already collapsed', panelId, newState: 'unchanged' };\n    }\n    if (!isCollapse && !currentlyCollapsed) {\n      return { success: true, reason: 'Already expanded', panelId, newState: 'unchanged' };\n    }\n    if (isCollapse && !panel.collapsible) {\n      return { success: false, reason: 'Panel is not collapsible', panelId, newState: 'unchanged' };\n    }\n\n    return undefined;\n  }\n\n  function executeCollapse(panel: ResizablePanelState, source: CollapseRequestSource): void {\n    const state: PreCollapseState = {\n      sizes: new Map(),\n      manualTargets: new Map(),\n      containerSize: containerSize.value,\n    };\n    panels.value.forEach(p => {\n      state.sizes.set(p.id, p.pixelSize);\n      state.manualTargets.set(p.id, p.manualTargetSize);\n    });\n    preCollapseStates.set(panel.id, state);\n\n    updateSavedPanel(panel.id, { collapsed: true, autoCollapsed: source === 'system' });\n\n    // Clear manual ratios so remaining panels fill the freed space\n    panels.value.forEach(p => {\n      if (p.id !== panel.id && !p.collapsed) {\n        updateSavedPanel(p.id, { manualTargetRatio: undefined });\n      }\n    });\n  }\n\n  function executeExpand(panel: ResizablePanelState): void {\n    const wasAutoCollapsed = panel.autoCollapsed ?? false;\n\n    const preCollapse = preCollapseStates.get(panel.id);\n\n    if (preCollapse) {\n      const viewportChangeRatio = Math.abs(containerSize.value - preCollapse.containerSize)\n        / preCollapse.containerSize;\n      const viewportChanged = viewportChangeRatio > 0.1;\n      const shouldRestoreSizes = !viewportChanged || !wasAutoCollapsed;\n\n      if (shouldRestoreSizes) {\n        const savedPanelSize = preCollapse.sizes.get(panel.id);\n        if (savedPanelSize !== undefined) {\n          updateSavedPanel(panel.id, { pixelSize: savedPanelSize, collapsed: false, autoCollapsed: undefined });\n        } else {\n          updateSavedPanel(panel.id, { collapsed: false, autoCollapsed: undefined });\n        }\n\n        panels.value.forEach(p => {\n          if (p.id === panel.id) return;\n          const savedSize = preCollapse.sizes.get(p.id);\n          const hadManualTargetBefore = preCollapse.manualTargets.get(p.id) !== undefined;\n          const hasManualTargetNow = p.manualTargetSize !== undefined;\n\n          if (!hadManualTargetBefore && !hasManualTargetNow && savedSize !== undefined) {\n            updateSavedPanel(p.id, { pixelSize: savedSize });\n          }\n        });\n      } else {\n        updateSavedPanel(panel.id, { collapsed: false, autoCollapsed: undefined });\n      }\n\n      preCollapseStates.delete(panel.id);\n    } else {\n      const initialSize = parseSizeToPixels(panel.initialSize ?? DEFAULT_PANEL_SIZE, containerSize.value);\n      const constrainedSize = applyPanelPixelConstraints(panel, initialSize, containerSize.value, 'system');\n      updateSavedPanel(panel.id, { pixelSize: constrainedSize, collapsed: false, autoCollapsed: undefined });\n    }\n  }\n\n  // ---- Panel Operations ----\n\n  function commitPanelSize(panelId: string, pixels: number): void {\n    const rounded = Math.round(pixels);\n    const cSize = containerSize.value;\n    const ratio = cSize > 0 ? rounded / cSize : undefined;\n    updateSavedPanel(panelId, { pixelSize: rounded, manualTargetRatio: ratio });\n  }\n\n  function resizePanel(panelId: string, newPixelSize: number) {\n    const panel = panels.value.find(p => p.id === panelId);\n    if (!panel || panel.collapsed) return;\n\n    const constrainedSize = applyPanelPixelConstraints(panel, newPixelSize, containerSize.value);\n    commitPanelSize(panelId, constrainedSize);\n\n    onPanelResize(panelId, constrainedSize);\n  }\n\n  /**\n   */\n  function collapsePanel(panelId: string, collapsed: boolean, options?: CollapseOptions) {\n    const source: CollapseRequestSource = options?.isAutoCollapse ? 'system' : 'prop';\n\n    processCollapseRequest({\n      panelId,\n      action: collapsed ? 'collapse' : 'expand',\n      source,\n    });\n  }\n\n  // ---- Panel Reset Operations ----\n\n  function resetAdjacentPanels(beforePanel: ResizablePanelState, afterPanel: ResizablePanelState) {\n    const combinedSpace = beforePanel.pixelSize + afterPanel.pixelSize;\n    const beforeInitial = convertToPixelSize(beforePanel.initialSize || DEFAULT_PANEL_SIZE);\n    const afterInitial = convertToPixelSize(afterPanel.initialSize || DEFAULT_PANEL_SIZE);\n    const totalInitial = beforeInitial + afterInitial;\n\n    const beforeSize = totalInitial > 0\n      ? Math.round(combinedSpace * (beforeInitial / totalInitial))\n      : Math.round(combinedSpace / 2);\n    const afterSize = combinedSpace - beforeSize;\n\n    updateSavedPanel(beforePanel.id, {\n      pixelSize: beforeSize, manualTargetRatio: undefined,\n    });\n    updateSavedPanel(afterPanel.id, {\n      pixelSize: afterSize, manualTargetRatio: undefined,\n    });\n\n    onPanelResize(beforePanel.id, beforeSize);\n    onPanelResize(afterPanel.id, afterSize);\n  }\n\n  function resetAllPanelPairs() {\n    for (let i = 0; i < panels.value.length - 1; i++) {\n      const currentPanel = panels.value[i];\n      const nextPanel = panels.value[i + 1];\n\n      if (canResetPanelPair(currentPanel, nextPanel)) {\n        resetAdjacentPanels(currentPanel, nextPanel);\n      }\n    }\n  }\n\n  function resetSpecificPanelPair(beforePanelId?: string, afterPanelId?: string) {\n    const beforePanel = beforePanelId ? panels.value.find(p => p.id === beforePanelId) : undefined;\n    const afterPanel = afterPanelId ? panels.value.find(p => p.id === afterPanelId) : undefined;\n\n    if (beforePanel && afterPanel && canResetPanelPair(beforePanel, afterPanel)) {\n      resetAdjacentPanels(beforePanel, afterPanel);\n    }\n  }\n\n  function resetSinglePanel(panelId?: string) {\n    if (!panelId) return;\n    const panel = panels.value.find(p => p.id === panelId);\n    if (!panel || panel.collapsed || panel.resizable === false) return;\n\n    const initialSize = convertToPixelSize(panel.initialSize || DEFAULT_PANEL_SIZE);\n    const delta = initialSize - panel.pixelSize;\n\n    const panelIndex = panels.value.indexOf(panel);\n    const adjacentPanel = panels.value.find((p, i) =>\n      i !== panelIndex && !p.collapsed && p.resizable !== false\n    );\n\n    if (!adjacentPanel) return;\n\n    const newAdjacentSize = adjacentPanel.pixelSize - delta;\n\n    updateSavedPanel(panel.id, {\n      pixelSize: initialSize, manualTargetRatio: undefined,\n    });\n    updateSavedPanel(adjacentPanel.id, { pixelSize: newAdjacentSize });\n\n    onPanelResize(panel.id, initialSize);\n    onPanelResize(adjacentPanel.id, newAdjacentSize);\n  }\n\n  function resetPanels(\n    beforePanelId?: string,\n    afterPanelId?: string,\n    behavior: 'both' | 'before' | 'after' | 'all' = 'all'\n  ) {\n    try {\n      if (behavior === 'all') {\n        resetAllPanelPairs();\n      } else if (behavior === 'before') {\n        resetSinglePanel(beforePanelId);\n      } else if (behavior === 'after') {\n        resetSinglePanel(afterPanelId);\n      } else {\n        resetSpecificPanelPair(beforePanelId, afterPanelId);\n      }\n    } catch (error) {\n      console.error('[resizable] Error in resetPanels:', error);\n    }\n  }\n\n  // ---- Auto-Collapse/Expand ----\n\n  function checkAutoCollapse(): string[] {\n    const collapsedPanels: string[] = [];\n    const currentContainerSize = containerSize.value;\n\n    for (const panel of panels.value) {\n      if (panel.collapsed || !panel.collapsible || !panel.collapseSizePixels) {\n        continue;\n      }\n\n      if (currentContainerSize < panel.collapseSizePixels) {\n        const result = processCollapseRequest({\n          panelId: panel.id,\n          action: 'collapse',\n          source: 'system',\n        });\n\n        if (result.newState === 'collapsed') {\n          collapsedPanels.push(panel.id);\n        }\n      }\n    }\n\n    return collapsedPanels;\n  }\n\n  function checkAutoExpand(): string[] {\n    const expandedPanels: string[] = [];\n    const currentContainerSize = containerSize.value;\n\n    for (const panel of panels.value) {\n      if (!panel.collapsed || !panel.autoCollapsed || !panel.collapseSizePixels) {\n        continue;\n      }\n\n      if (currentContainerSize >= panel.collapseSizePixels) {\n        const result = processCollapseRequest({\n          panelId: panel.id,\n          action: 'expand',\n          source: 'system',\n        });\n\n        if (result.newState === 'expanded') {\n          expandedPanels.push(panel.id);\n        }\n      }\n    }\n\n    return expandedPanels;\n  }\n\n  function processAutoCollapseExpand(): { collapsed: string[]; expanded: string[] } {\n    const expanded = checkAutoExpand();\n    const collapsed = checkAutoCollapse();\n\n    return { collapsed, expanded };\n  }\n\n  return {\n    commitPanelSize,\n    resizePanel,\n    collapsePanel,\n    resetPanels,\n    processCollapseRequest,\n    checkAutoCollapse,\n    checkAutoExpand,\n    processAutoCollapseExpand,\n  };\n}\n\n// ============================================================================\n// COLLAPSE RULE UTILITIES\n// ============================================================================\n\n/**\n * Sorts collapse rules by priority (lower numbers collapse first).\n * Creates a new sorted array - does not mutate the original.\n * Maintains stable sort for rules with equal priority.\n */\nexport function sortCollapseRules(rules: CollapseRule[]): CollapseRule[] {\n  if (!rules || rules.length === 0) {\n    return [];\n  }\n\n  const indexed = rules.map((rule, index) => ({ rule, index }));\n\n  indexed.sort((a, b) => {\n    const priorityDiff = a.rule.priority - b.rule.priority;\n    if (priorityDiff !== 0) {\n      return priorityDiff;\n    }\n    return a.index - b.index;\n  });\n\n  return indexed.map(item => item.rule);\n}\n\n// ============================================================================\n// AUTO-COLLAPSE UTILITIES\n// ============================================================================\n\nfunction getCollapseThreshold(\n  panel: ResizablePanelState,\n  rule: CollapseRule,\n  containerSize: number\n): number | undefined {\n  if (rule.minSizeBeforeCollapse !== undefined) {\n    return parseSizeToPixels(rule.minSizeBeforeCollapse, containerSize);\n  }\n  return panel.userMinSizePixels;\n}\n\nfunction shouldPanelCollapse(\n  panels: ResizablePanelState[],\n  rule: CollapseRule,\n  containerSize: number\n): string | undefined {\n  const panel = panels.find(p => p.id === rule.panelId);\n\n  if (!panel || panel.collapsed) {\n    return undefined;\n  }\n\n  const threshold = getCollapseThreshold(panel, rule, containerSize);\n\n  if (threshold === undefined) {\n    return undefined;\n  }\n\n  return panel.pixelSize <= threshold ? panel.id : undefined;\n}\n\n/**\n * Checks which panels should auto-collapse based on their current size and collapse rules.\n * Returns panel IDs in priority order (lowest priority first = first to collapse).\n */\nexport function checkAutoCollapseRules(\n  panels: ResizablePanelState[],\n  collapseRules: CollapseRule[],\n  containerSize: number\n): string[] {\n  if (!panels || panels.length === 0 || !collapseRules || collapseRules.length === 0) {\n    return [];\n  }\n\n  const sortedRules = sortCollapseRules(collapseRules);\n\n  return sortedRules\n    .map(rule => shouldPanelCollapse(panels, rule, containerSize))\n    .filter((id): id is string => id !== undefined);\n}\n","/**\n * computeLayout — Pure Layout Engine\n *\n * Takes panel configs + container size and returns positions for every panel\n * and handle. Constraints are applied WITHIN the computation, not after.\n *\n * This is a pure function: no DOM access, no Vue reactivity, no localStorage,\n * no side effects. It takes data in and returns data out.\n *\n * Key design: proportional scaling\n * - Panels with manualTargetRatio scale to their stored ratio each render\n * - Panels without a ratio distribute remaining space proportionally\n * - Fixed panels (resizable: false) keep their exact pixel size\n * - Min/max constraints clamp results; overflow is redistributed in the same pass\n *\n * @see constraintResolver.ts\n */\n\nimport { DEFAULT_PANEL_SIZE, buildHandleId } from '../resizable_constants';\nimport type { ResizablePanelConfig } from '../resizable_constants';\nimport { parseSizeToPixels } from '../resizable_utils';\nimport { calculateConstraintHierarchy, clampToTier, type ConstraintHierarchy } from './constraintResolver';\n\n// ============================================================================\n// SAVED STATE TYPE (inlined from useResizableStorage — ported in Task #2)\n// ============================================================================\n\n/**\n * Data shape for a single panel's saved state in localStorage.\n * Defined here so computeLayout stays self-contained without depending\n * on the storage composable. useResizableStorage will re-export this\n * type when it is ported.\n */\nexport interface SavedPanelData {\n  id: string;\n  pixelSize: number;\n  collapsed?: boolean;\n  /** Whether this panel was auto-collapsed by the system (vs manually by user) */\n  autoCollapsed?: boolean;\n  /** Proportion of container this panel should occupy (set by drag, used for viewport scaling) */\n  manualTargetRatio?: number;\n}\n\n// ============================================================================\n// INPUT / OUTPUT TYPES\n// ============================================================================\n\n/**\n * Input to the layout computation.\n * All values must be resolved before calling (no lazy-loading, no Vue refs).\n */\nexport interface LayoutInput {\n  /** Registered panel configurations, in render order */\n  panels: ResizablePanelConfig[];\n  /** Current container width (row direction) or height (column direction), in pixels */\n  containerSize: number;\n  /**\n   * Saved state from localStorage (optional).\n   * When provided, sizes and collapsed state are restored from here.\n   * IDs that do not match current panels are ignored.\n   * Values that fail validation fall back to initialSize.\n   */\n  savedState?: SavedPanelData[];\n}\n\n/**\n * Computed position for a single panel.\n * All values are in pixels, relative to the container's top-left corner.\n */\nexport interface PanelPosition {\n  id: string;\n  /** Distance from the container's left edge to this panel's left edge */\n  left: number;\n  /** Distance from this panel's right edge to the container's right edge */\n  right: number;\n  /** Rendered width of the panel (0 when collapsed) */\n  width: number;\n  /** Whether the panel is currently collapsed */\n  collapsed: boolean;\n  /** Resolved constraints for this panel at the current container size */\n  constraints: ConstraintHierarchy;\n}\n\n/**\n * Computed position for a single drag handle.\n * Handles sit between adjacent visible panels.\n */\nexport interface HandlePosition {\n  /** Handle identifier: \"{beforePanelId}:{afterPanelId}\" */\n  id: string;\n  beforePanelId: string;\n  afterPanelId: string;\n  /** Pixel offset from the container's left edge to the handle's left edge */\n  left: number;\n  /**\n   * True when the handle should be non-interactive.\n   * Set when either adjacent panel is collapsed or resizable: false.\n   */\n  disabled: boolean;\n}\n\n/**\n * Output of computeLayout.\n * Immutable — create a new layout by calling computeLayout again.\n */\nexport interface LayoutResult {\n  panels: Map<string, PanelPosition>;\n  handles: HandlePosition[];\n}\n\n// ============================================================================\n// INTERNAL WORKING STATE\n// ============================================================================\n\n/**\n * Internal representation while computing sizes before positions are finalized.\n */\ninterface WorkingPanel {\n  config: ResizablePanelConfig;\n  constraints: ConstraintHierarchy;\n  width: number;\n  collapsed: boolean;\n  /** True when resizable: false — panel keeps its exact pixel size, no handle rendered */\n  isFixed: boolean;\n  /**\n   * The manual ratio stored from a previous drag (0–1, fraction of container).\n   * When present, this panel's target width = manualTargetRatio * containerSize,\n   * still subject to constraints.\n   */\n  manualTargetRatio?: number;\n}\n\n// ============================================================================\n// HELPERS\n// ============================================================================\n\n/**\n * Resolve initial pixel size for a panel from saved state or initialSize config.\n * Returns the raw size before constraint clamping.\n */\nfunction resolveRawSize(\n  config: ResizablePanelConfig,\n  containerSize: number,\n  savedPanel: SavedPanelData | undefined\n): number {\n  if (savedPanel !== undefined) {\n    const saved = savedPanel.pixelSize;\n    // Reject corrupted saved values\n    if (!isFinite(saved) || saved < 0 || (containerSize > 0 && saved > containerSize * 2)) {\n      return parseSizeToPixels(config.initialSize ?? DEFAULT_PANEL_SIZE, containerSize);\n    }\n    return saved;\n  }\n\n  return parseSizeToPixels(config.initialSize ?? DEFAULT_PANEL_SIZE, containerSize);\n}\n\n/**\n * Determine whether a panel should be collapsed for a given input.\n * Priority: savedState.collapsed > config.collapsed\n */\nfunction resolveCollapsed(config: ResizablePanelConfig, savedPanel: SavedPanelData | undefined): boolean {\n  if (savedPanel !== undefined && savedPanel.collapsed !== undefined) {\n    return savedPanel.collapsed;\n  }\n  return Boolean(config.collapsed);\n}\n\n/**\n * Clamp a width to the constraint window.\n * Returns the clamped value and the amount of overflow/underflow.\n *\n * @param tier - Which constraints to apply:\n *   'user'   — user-min/max (for ratio panels, user-dragged sizes)\n *   'system' — system-min/max falling back to user (for proportional panels,\n *              viewport-driven redistribution)\n */\nfunction clampToConstraints(\n  width: number,\n  constraints: ConstraintHierarchy,\n  tier: 'user' | 'system' = 'system'\n): { clamped: number; delta: number } {\n  const clamped = clampToTier(width, constraints, tier);\n  return { clamped, delta: clamped - width };\n}\n\n/**\n * Build the index of saved state for O(1) lookup during panel iteration.\n * Returns undefined if saved state is structurally incompatible with current panels.\n *\n * Incompatible = current panel IDs have entries NOT present in saved state.\n * (Panel IDs that exist in saved state but not current panels are simply ignored.)\n */\nfunction buildSavedIndex(\n  savedState: SavedPanelData[] | undefined\n): Map<string, SavedPanelData> | undefined {\n  if (!savedState) return undefined;\n  return new Map<string, SavedPanelData>(savedState.map(s => [s.id, s]));\n}\n\n// ============================================================================\n// ALGORITHM\n// ============================================================================\n\n/**\n * Step 1: Build working panels with constraints and raw sizes.\n */\nfunction buildWorkingPanels(\n  panels: ResizablePanelConfig[],\n  containerSize: number,\n  savedIndex: Map<string, SavedPanelData> | undefined\n): WorkingPanel[] {\n  return panels.map(config => {\n    const constraints = calculateConstraintHierarchy(config, containerSize);\n    const savedPanel = savedIndex?.get(config.id);\n    const collapsed = resolveCollapsed(config, savedPanel);\n    const isFixed = config.resizable === false;\n\n    const savedRatio = savedPanel?.manualTargetRatio;\n\n    let rawWidth: number;\n    if (collapsed) {\n      rawWidth = 0;\n    } else if (savedRatio !== undefined && containerSize > 0) {\n      // Scale from ratio — the panel wants (ratio * container) pixels\n      rawWidth = savedRatio * containerSize;\n    } else {\n      rawWidth = resolveRawSize(config, containerSize, savedPanel);\n    }\n\n    return {\n      config,\n      constraints,\n      width: rawWidth,\n      collapsed,\n      isFixed,\n      manualTargetRatio: savedRatio,\n    };\n  });\n}\n\n/**\n * Allocate space for Tier 1 (fixed) and Tier 2 (ratio) panels.\n * Mutates panel widths in place. Returns the total reserved space.\n */\nfunction allocateReservedPanels(visiblePanels: WorkingPanel[], containerSize: number): number {\n  // Tier 1: Fixed panels (resizable: false)\n  let reservedTotal = 0;\n  for (const p of visiblePanels) {\n    if (p.isFixed) {\n      const { clamped } = clampToConstraints(p.width, p.constraints);\n      p.width = clamped;\n      reservedTotal += clamped;\n    }\n  }\n\n  // Tier 2: Ratio panels (manualTargetRatio) — user constraints only.\n  const ratioPanels = visiblePanels.filter(p => !p.isFixed && p.manualTargetRatio !== undefined);\n  for (const p of ratioPanels) {\n    const targetWidth = (p.manualTargetRatio ?? 0) * containerSize;\n    const { clamped } = clampToConstraints(targetWidth, p.constraints, 'user');\n    p.width = clamped;\n    reservedTotal += clamped;\n  }\n\n  return reservedTotal;\n}\n\n/**\n * Iteratively clamp proportional panels to their constraint windows and\n * redistribute overflow/underflow to unclamped panels. Applies a final\n * clamp pass to catch floating-point drift.\n */\nfunction constrainAndRedistribute(propPanels: WorkingPanel[]): void {\n  const maxPasses = propPanels.length + 1;\n\n  for (let pass = 0; pass < maxPasses; pass++) {\n    let totalDelta = 0;\n    const clampedIds = new Set<string>();\n\n    for (const p of propPanels) {\n      const { clamped, delta } = clampToConstraints(p.width, p.constraints);\n      if (delta !== 0) {\n        p.width = clamped;\n        clampedIds.add(p.config.id);\n        totalDelta += delta;\n      }\n    }\n\n    if (totalDelta === 0) break;\n\n    const freePanels = propPanels.filter(p => !clampedIds.has(p.config.id));\n    if (freePanels.length === 0) break;\n\n    const changePerPanel = -totalDelta / freePanels.length;\n    for (const p of freePanels) {\n      p.width += changePerPanel;\n    }\n  }\n\n  // Final clamp to catch any floating-point drift\n  for (const p of propPanels) {\n    const { clamped } = clampToConstraints(p.width, p.constraints);\n    p.width = clamped;\n  }\n}\n\n/**\n * If total allocated width < containerSize (all proportional panels hit max),\n * expand the last non-fixed visible panel to absorb the gap.\n */\nfunction applyFillGuarantee(visiblePanels: WorkingPanel[], propPanels: WorkingPanel[], containerSize: number): void {\n  const allocatedTotal = visiblePanels.reduce((sum, p) => sum + p.width, 0);\n  const gap = containerSize - allocatedTotal;\n  if (gap > 1) {\n    const lastFlexible = [...propPanels].reverse().find(p => !p.isFixed);\n    if (lastFlexible) {\n      lastFlexible.width += gap;\n    }\n  }\n}\n\n/**\n * Step 2: Distribute container space among non-collapsed panels.\n *\n * Distribution order (priority, highest first):\n *   1. Fixed panels (`resizable: false`) — keep exact initial pixel size\n *   2. Ratio panels (`manualTargetRatio`) — target (ratio × container), constrained\n *   3. Proportional panels — share remaining space using raw widths as weights\n *\n * After initial allocation, constraints are applied.\n * When a panel is min-clamped (forced larger), the extra space it consumed is\n * taken from unclamped proportional panels. When a panel is max-clamped (forced\n * smaller), the freed space is given back to unclamped proportional panels.\n * This redistribution iterates until stable (all panels within constraints) or\n * until no unclamped panels remain.\n */\nfunction distributeSpace(working: WorkingPanel[], containerSize: number): void {\n  // Early exit for zero container\n  if (containerSize <= 0) {\n    working.forEach(p => {\n      if (!p.collapsed) p.width = 0;\n    });\n    return;\n  }\n\n  const visiblePanels = working.filter(p => !p.collapsed);\n  if (visiblePanels.length === 0) return;\n\n  // ── Tier 1 + 2: Fixed and ratio panels ────────────────────────────────────\n  const reservedTotal = allocateReservedPanels(visiblePanels, containerSize);\n\n  // ── Tier 3: Proportional panels ───────────────────────────────────────────\n  const propPanels = visiblePanels.filter(p => !p.isFixed && p.manualTargetRatio === undefined);\n  const remainingSpace = Math.max(0, containerSize - reservedTotal);\n\n  if (propPanels.length === 0) return;\n\n  // Use current raw widths as proportional weights\n  const totalPropWeight = propPanels.reduce((sum, p) => sum + Math.max(0, p.width), 0);\n\n  // Initial allocation: proportional share of remaining space\n  for (const p of propPanels) {\n    if (totalPropWeight > 0) {\n      p.width = (p.width / totalPropWeight) * remainingSpace;\n    } else {\n      // All weights are zero — distribute equally\n      p.width = remainingSpace / propPanels.length;\n    }\n  }\n\n  // ── Constraint pass with overflow redistribution ──────────────────────────\n  constrainAndRedistribute(propPanels);\n\n  // ── Fill guarantee ──────────────────────────────────────────────────────\n  applyFillGuarantee(visiblePanels, propPanels, containerSize);\n}\n\n/**\n * Distribute +1px to panels with the largest fractional remainders,\n * skipping panels that are at their max constraint or fixed.\n */\nfunction distributeShortfall(remainders: { panel: WorkingPanel; remainder: number }[], shortfall: number): void {\n  remainders.sort((a, b) => b.remainder - a.remainder);\n  let remaining = shortfall;\n  for (const { panel } of remainders) {\n    if (remaining <= 0) break;\n    const max = panel.constraints.systemMaxSizePixels ?? panel.constraints.userMaxSizePixels ?? Infinity;\n    if (panel.width < max && !panel.isFixed) {\n      panel.width += 1;\n      remaining -= 1;\n    }\n  }\n}\n\n/**\n * Step 3: Round widths to integers and fix up rounding error.\n *\n * After distributing floating-point widths, some panels get ceil'd and some\n * floor'd. We use a \"largest remainder\" approach so the total always equals\n * the container size exactly (when not fully clamped by constraints).\n */\nfunction roundWidths(working: WorkingPanel[], containerSize: number): void {\n  if (containerSize <= 0) return;\n\n  const visiblePanels = working.filter(p => !p.collapsed);\n  if (visiblePanels.length === 0) return;\n\n  // Floor all widths first, collect remainders\n  const remainders: { panel: WorkingPanel; remainder: number }[] = [];\n\n  for (const p of visiblePanels) {\n    const floored = Math.floor(p.width);\n    remainders.push({ panel: p, remainder: p.width - floored });\n    p.width = floored;\n  }\n\n  const currentTotal = visiblePanels.reduce((s, p) => s + p.width, 0);\n  const shortfall = containerSize - currentTotal;\n\n  distributeShortfall(remainders, shortfall);\n}\n\n/**\n * Step 4: Compute absolute left/right positions for each panel.\n */\nfunction computePositions(working: WorkingPanel[], containerSize: number): Map<string, PanelPosition> {\n  const result = new Map<string, PanelPosition>();\n  let cursor = 0;\n\n  for (const p of working) {\n    const width = p.collapsed ? 0 : p.width;\n    const left = cursor;\n    const right = Math.max(0, containerSize - left - width);\n\n    result.set(p.config.id, {\n      id: p.config.id,\n      left,\n      right,\n      width,\n      collapsed: p.collapsed,\n      constraints: p.constraints,\n    });\n\n    cursor += width;\n  }\n\n  return result;\n}\n\n/**\n * Step 5: Compute handle positions.\n *\n * A handle is only generated for pairs of adjacent panels where BOTH panels\n * are resizable (resizable !== false). Pairs involving a fixed panel are\n * skipped entirely — no ResizableHandle component exists between them, and\n * including them in the array would shift the autoIndex values that handle\n * components use to look up their own position.\n *\n * Its left position equals the right edge of the before-panel.\n * It is disabled when either adjacent panel is collapsed.\n */\nfunction computeHandles(\n  panels: ResizablePanelConfig[],\n  positions: Map<string, PanelPosition>,\n): HandlePosition[] {\n  const handles: HandlePosition[] = [];\n\n  for (let i = 0; i < panels.length - 1; i++) {\n    const before = panels[i];\n    const after = panels[i + 1];\n\n    // Skip pairs that involve a fixed (non-resizable) panel.\n    // No ResizableHandle component is placed between fixed panels, so\n    // generating an entry would misalign autoIndex → handles[] lookups.\n    if (before.resizable === false || after.resizable === false) continue;\n\n    const beforePos = positions.get(before.id);\n    const afterPos = positions.get(after.id);\n\n    if (!beforePos || !afterPos) continue;\n\n    const disabled = beforePos.collapsed || afterPos.collapsed;\n\n    handles.push({\n      id: buildHandleId(before.id, after.id),\n      beforePanelId: before.id,\n      afterPanelId: after.id,\n      left: beforePos.left + beforePos.width,\n      disabled,\n    });\n  }\n\n  return handles;\n}\n\n// ============================================================================\n// PUBLIC API\n// ============================================================================\n\n/**\n * Compute the complete layout for a group of resizable panels.\n *\n * This is a pure function — it has no side effects and does not read from\n * or write to the DOM, Vue reactivity, or localStorage.\n *\n * @param input - Panel configs, container size, and optional saved state\n * @returns Immutable layout result with panel positions and handle positions\n *\n * @example\n * const layout = computeLayout({\n *   panels: registeredPanels,\n *   containerSize: containerWidth,\n *   savedState: loadFromStorage(),\n * });\n * const feedPos = layout.panels.get('feed-panel');\n * // feedPos.left, feedPos.width, feedPos.right, feedPos.collapsed\n */\nexport function computeLayout(input: LayoutInput): LayoutResult {\n  const { panels, containerSize, savedState } = input;\n\n  // Degenerate cases\n  if (panels.length === 0) {\n    return { panels: new Map(), handles: [] };\n  }\n\n  // Build saved-state lookup (returns undefined if incompatible with current panels)\n  const savedIndex = buildSavedIndex(savedState);\n\n  const working = buildWorkingPanels(panels, containerSize, savedIndex);\n  distributeSpace(working, containerSize);\n  roundWidths(working, containerSize);\n  const positions = computePositions(working, containerSize);\n  const handles = computeHandles(panels, positions);\n\n  return { panels: positions, handles };\n}\n","import { DEFAULT_PANEL_SIZE } from '../resizable_constants';\nimport type { ResizablePanelConfig, ResizablePanelState } from '../resizable_constants';\nimport type { ResizableStorageAdapter, ResizableStoragePanelData } from '../resizable_constants';\nimport { parseSizeToPixels } from '../resizable_utils';\n\n// Re-export for backward compatibility\nexport type SavedPanelData = ResizableStoragePanelData;\n\n// ============================================================================\n// VALIDATION\n// ============================================================================\n\nfunction validateRequiredProperties(data: Record<string, unknown>): boolean {\n  return typeof data.id === 'string' && typeof data.pixelSize === 'number' && data.pixelSize >= 0;\n}\n\nfunction validateOptionalProperties(data: Record<string, unknown>): boolean {\n  return (\n    (data.collapsed === undefined || typeof data.collapsed === 'boolean') &&\n    (data.autoCollapsed === undefined || typeof data.autoCollapsed === 'boolean')\n  );\n}\n\nfunction isSavedPanelData(obj: unknown): obj is ResizableStoragePanelData {\n  if (typeof obj !== 'object' || obj === null) return false;\n  const data = obj as Record<string, unknown>;\n  return validateRequiredProperties(data) && validateOptionalProperties(data);\n}\n\nfunction isSavedPanelDataArray(obj: unknown): obj is ResizableStoragePanelData[] {\n  return Array.isArray(obj) && obj.every(item => isSavedPanelData(item));\n}\n\n/**\n * Validates a stored panel size against container bounds and returns a safe value.\n *\n * Checks for non-finite values, negative values, and oversized values (> 2x container).\n */\nexport function validateStoredPanelSize(\n  storedSize: number,\n  containerSize: number,\n  panelConfig: ResizablePanelConfig\n): number {\n  if (!isFinite(storedSize) || storedSize < 0) {\n    return parseSizeToPixels(panelConfig.initialSize || DEFAULT_PANEL_SIZE, containerSize);\n  }\n\n  if (containerSize > 0 && storedSize > containerSize * 2) {\n    console.warn(\n      `[resizable] Stored size ${storedSize}px for panel '${panelConfig.id}' exceeds 2x container (${containerSize}px). Resetting.`\n    );\n    return parseSizeToPixels(panelConfig.initialSize || DEFAULT_PANEL_SIZE, containerSize);\n  }\n\n  return storedSize;\n}\n\n// ============================================================================\n// LOCALSTORAGE ADAPTER\n// ============================================================================\n\n/**\n * Create a localStorage-backed storage adapter.\n *\n * @param key - The localStorage key to use\n * @returns A ResizableStorageAdapter backed by localStorage\n *\n * @example\n * ```vue\n * <dt-resizable :storage=\"localStorageAdapter('my-layout')\">\n * ```\n */\nexport function localStorageAdapter(key: string): ResizableStorageAdapter {\n  return {\n    save(data: ResizableStoragePanelData[]): void {\n      try {\n        localStorage.setItem(key, JSON.stringify(data));\n      } catch (error) {\n        console.error('[resizable] Failed to save to localStorage:', error);\n      }\n    },\n\n    load(): ResizableStoragePanelData[] | null {\n      try {\n        const saved = localStorage.getItem(key);\n        if (!saved) return null;\n\n        let parsed: unknown;\n        try {\n          parsed = JSON.parse(saved);\n        } catch {\n          localStorage.removeItem(key);\n          return null;\n        }\n\n        if (!isSavedPanelDataArray(parsed)) {\n          localStorage.removeItem(key);\n          return null;\n        }\n\n        return parsed;\n      } catch (error) {\n        console.warn('[resizable] Failed to load from localStorage:', error);\n        try { localStorage.removeItem(key); } catch { /* ignore */ }\n        return null;\n      }\n    },\n\n    clear(): void {\n      try {\n        localStorage.removeItem(key);\n      } catch { /* ignore */ }\n    },\n  };\n}\n\n// ============================================================================\n// COMPOSABLE\n// ============================================================================\n\n/**\n * Composable for managing panel persistence.\n *\n * Accepts either a storageKey (string → auto-creates localStorage adapter)\n * or a custom ResizableStorageAdapter. The adapter takes precedence.\n *\n * @param storageKeyOrAdapter - localStorage key string, or null\n * @param customAdapter - Optional custom adapter (overrides storageKey)\n */\nexport function useResizableStorage(\n  storageKeyOrAdapter: string | null,\n  customAdapter?: ResizableStorageAdapter\n) {\n  // Resolve the adapter: custom > storageKey > null\n  const adapter: ResizableStorageAdapter | null = customAdapter\n    ?? (storageKeyOrAdapter ? localStorageAdapter(storageKeyOrAdapter) : null);\n\n  function saveToStorage(panels: ResizableStoragePanelData[] | ResizablePanelState[]): void {\n    if (!adapter) return;\n\n    const data: ResizableStoragePanelData[] = panels.map(panel => ({\n      id: panel.id,\n      pixelSize: panel.pixelSize,\n      collapsed: panel.collapsed,\n      autoCollapsed: panel.autoCollapsed,\n    }));\n\n    adapter.save(data);\n  }\n\n  function loadFromStorage(): ResizableStoragePanelData[] | null {\n    if (!adapter) return null;\n\n    const data = adapter.load();\n    if (!data) return null;\n\n    // Re-validate even if adapter returned data (defense in depth)\n    if (!isSavedPanelDataArray(data)) {\n      adapter.clear();\n      return null;\n    }\n\n    return data;\n  }\n\n  function restorePanelFromStorage(panel: ResizablePanelState, savedPanel: ResizableStoragePanelData): void {\n    if (panel.restoredFromStorage) return;\n\n    if (savedPanel.pixelSize !== undefined) {\n      panel.pixelSize = savedPanel.pixelSize;\n    }\n    if (savedPanel.collapsed !== undefined) {\n      panel.collapsed = savedPanel.collapsed;\n    }\n    if (savedPanel.autoCollapsed !== undefined) {\n      panel.autoCollapsed = savedPanel.autoCollapsed;\n    }\n\n    panel.restoredFromStorage = true;\n  }\n\n  function loadFromStorageWithValidation(panels: ResizablePanelState[]): boolean {\n    const savedState = loadFromStorage();\n    if (!savedState) return false;\n\n    const currentPanelIds = new Set(panels.map(p => p.id));\n    const savedPanelIds = new Set(savedState.map(p => p.id));\n\n    // Clear if current panels don't all exist in saved (panel config changed)\n    const hasIncompatiblePanels = Array.from(currentPanelIds).some(id => !savedPanelIds.has(id));\n    if (hasIncompatiblePanels) {\n      if (adapter) adapter.clear();\n      return false;\n    }\n\n    savedState.forEach(savedPanel => {\n      const panel = panels.find(p => p.id === savedPanel.id);\n      if (panel) restorePanelFromStorage(panel, savedPanel);\n    });\n\n    return true;\n  }\n\n  function clearStorage(): void {\n    if (adapter) adapter.clear();\n  }\n\n  return {\n    saveToStorage,\n    loadFromStorage,\n    loadFromStorageWithValidation,\n    restorePanelFromStorage,\n    clearStorage,\n  };\n}\n","/**\n * useResizableGroup — Reactive Layout Controller\n *\n * Replaces the timer-based initialization flow with a Vue `computed` that\n * re-runs synchronously whenever panels or the container size change.\n *\n * Responsibilities:\n * - Maintain the `registeredPanels` ref (panels call registerPanel/unregisterPanel)\n * - Track `containerSize` via a ResizeObserver (set up here, not in the component)\n * - Load saved state ONCE synchronously at creation time\n * - Expose `layout` computed that calls `computeLayout()`\n * - Expose `syncedPanels` computed that converts `LayoutResult` to `ResizablePanelState[]`\n *\n * @see computeLayout.ts — the pure layout engine\n */\n\nimport { ref, computed, watch, nextTick, type ComputedRef, type Ref } from 'vue';\nimport type { ResizablePanelConfig, ResizablePanelState, ResizableDirection } from '../resizable_constants';\nimport type { LayoutResult } from './computeLayout';\nimport type { SavedPanelData } from './useResizableStorage';\nimport { computeLayout } from './computeLayout';\nimport { useResizableStorage } from './useResizableStorage';\nimport { calculateConstraintHierarchy } from './constraintResolver';\nimport { validateContainerSize } from '../resizable_utils';\n\n// ============================================================================\n// OPTIONS\n// ============================================================================\n\nexport interface UseResizableGroupOptions {\n  storageKey: string | null;\n  direction: ComputedRef<ResizableDirection>;\n  containerRef: Ref<HTMLElement | null>;\n  /** Custom storage adapter. Overrides storageKey when provided. */\n  storageAdapter?: import('../resizable_constants').ResizableStorageAdapter;\n}\n\n// ============================================================================\n// HELPERS\n// ============================================================================\n\n/** Clamp a container dimension to a valid range. Delegates to the shared utility. */\nconst clampContainerSize = validateContainerSize;\n\n/**\n * Build a `ResizablePanelState` from a panel config + the layout result.\n * Reads `manualTargetRatio` and `autoCollapsed` from savedState.\n */\nfunction buildPanelState(\n  config: ResizablePanelConfig,\n  containerSize: number,\n  layoutResult: LayoutResult,\n  saved: SavedPanelData | undefined\n): ResizablePanelState {\n  const position = layoutResult.panels.get(config.id);\n  const constraints = position?.constraints ?? calculateConstraintHierarchy(config, containerSize);\n\n  const pixelSize = position?.width ?? 0;\n  const collapsed = position?.collapsed ?? Boolean(config.collapsed);\n\n  return {\n    ...config,\n    pixelSize,\n    collapsed,\n    userMinSizePixels: constraints.userMinSizePixels,\n    userMaxSizePixels: constraints.userMaxSizePixels,\n    systemMinSizePixels: constraints.systemMinSizePixels,\n    systemMaxSizePixels: constraints.systemMaxSizePixels,\n    collapseSizePixels: constraints.collapseSizePixels,\n    manualTargetRatio: saved?.manualTargetRatio,\n    autoCollapsed: saved?.autoCollapsed,\n  };\n}\n\n// ============================================================================\n// COMPOSABLE\n// ============================================================================\n\nexport function useResizableGroup(options: UseResizableGroupOptions) {\n  const { storageKey, direction, containerRef } = options;\n\n  // ── Panel registry ──────────────────────────────────────────────────────────\n  const registeredPanels = ref<ResizablePanelConfig[]>([]);\n\n  // ── Container size ──────────────────────────────────────────────────────────\n  const containerSize = ref(0);\n\n  // ── Storage ─────────────────────────────────────────────────────────────────\n  const storage = useResizableStorage(storageKey, options.storageAdapter);\n  const savedState = ref<SavedPanelData[] | null>(storage.loadFromStorage());\n\n  // ── isInitializing ─────────────────────────────────────────────────────────\n  const isInitializing = ref(true);\n\n  // ── Layout computed ─────────────────────────────────────────────────────────\n  const layout = computed((): LayoutResult => {\n    const panels = registeredPanels.value;\n    const size = containerSize.value;\n\n    if (panels.length === 0 || size <= 0) {\n      return { panels: new Map(), handles: [] };\n    }\n\n    return computeLayout({\n      panels,\n      containerSize: size,\n      savedState: savedState.value ?? undefined,\n    });\n  });\n\n  // ── syncedPanels computed ───────────────────────────────────────────────────\n  const syncedPanels = computed((): ResizablePanelState[] => {\n    const result = layout.value;\n    const size = containerSize.value;\n    const savedMap = new Map(savedState.value?.map(s => [s.id, s]) ?? []);\n\n    return registeredPanels.value.map(config => {\n      const saved = savedMap.get(config.id);\n      return buildPanelState(config, size, result, saved);\n    });\n  });\n\n  // Flip isInitializing to false after first successful layout\n  watch(\n    layout,\n    result => {\n      if (result.panels.size > 0 && isInitializing.value) {\n        isInitializing.value = false;\n      }\n    },\n    { immediate: true }\n  );\n\n  // ── Panel index (O(1) lookup by id) ────────────────────────────────────────\n  const panelMap = computed((): Map<string, ResizablePanelState> => {\n    const map = new Map<string, ResizablePanelState>();\n    for (const p of syncedPanels.value) map.set(p.id, p);\n    return map;\n  });\n\n  // ── Panel registration ──────────────────────────────────────────────────────\n\n  let sortScheduled = false;\n\n  function registerPanel(config: ResizablePanelConfig): void {\n    if (config.id.includes(':')) {\n      console.warn(\n        `[resizable] Panel id \"${config.id}\" contains ':' which is reserved as the handle separator. Use kebab-case.`\n      );\n    }\n\n    const index = registeredPanels.value.findIndex(p => p.id === config.id);\n    if (index !== -1) {\n      registeredPanels.value = registeredPanels.value.map((p, i) => (i === index ? config : p));\n    } else {\n      registeredPanels.value = [...registeredPanels.value, config];\n\n      if (!sortScheduled) {\n        sortScheduled = true;\n        nextTick(() => {\n          registeredPanels.value = sortByDOMOrder(registeredPanels.value);\n          sortScheduled = false;\n        });\n      }\n    }\n  }\n\n  /**\n   * Sort panel configs to match DOM order inside the container element.\n   */\n  function sortByDOMOrder(panels: ResizablePanelConfig[]): ResizablePanelConfig[] {\n    const container = containerRef.value;\n    if (!container) return panels;\n\n    const panelElements = Array.from(container.querySelectorAll<HTMLElement>('.d-resizable-panel[data-panel-id]'));\n    if (panelElements.length === 0) return panels;\n\n    const domOrder = new Map<string, number>();\n    panelElements.forEach((el, i) => {\n      const id = el.getAttribute('data-panel-id');\n      if (id) domOrder.set(id, i);\n    });\n\n    return [...panels].sort((a, b) => {\n      const aPos = domOrder.get(a.id) ?? Infinity;\n      const bPos = domOrder.get(b.id) ?? Infinity;\n      return aPos - bPos;\n    });\n  }\n\n  function unregisterPanel(id: string): void {\n    registeredPanels.value = registeredPanels.value.filter(p => p.id !== id);\n  }\n\n  // ── Storage operations ──────────────────────────────────────────────────────\n\n  function saveCurrentLayout(panels: ResizablePanelState[]): void {\n    storage.saveToStorage(panels);\n    savedState.value = panels.map(p => ({\n      id: p.id,\n      pixelSize: p.pixelSize,\n      collapsed: p.collapsed,\n      autoCollapsed: p.autoCollapsed,\n      manualTargetRatio: p.manualTargetRatio,\n    }));\n  }\n\n  function updateSavedPanel(panelId: string, updates: Partial<SavedPanelData>): void {\n    if (!savedState.value) savedState.value = [];\n    const idx = savedState.value.findIndex(s => s.id === panelId);\n    if (idx >= 0) {\n      savedState.value[idx] = { ...savedState.value[idx], ...updates };\n    } else {\n      // Use current computed size as default, not 0\n      const currentPanel = syncedPanels.value.find(p => p.id === panelId);\n      const currentSize = currentPanel?.pixelSize ?? 0;\n      savedState.value.push({ id: panelId, pixelSize: currentSize, ...updates });\n    }\n    savedState.value = [...savedState.value]; // trigger reactivity\n\n    // Persist to external storage\n    storage.saveToStorage(savedState.value);\n  }\n\n  function reloadFromStorage(): void {\n    savedState.value = storage.loadFromStorage();\n  }\n\n  function clearSavedState(): void {\n    storage.clearStorage();\n    savedState.value = null;\n  }\n\n  // ── ResizeObserver ─────────────────────────────────────────────────────────\n\n  // Guard against SSR (Node.js) where ResizeObserver is not defined.\n  // The no-op stub keeps the observe/unobserve/disconnect call-sites valid so\n  // the composable can be imported and set up server-side without throwing.\n  const resizeObserver = typeof ResizeObserver !== 'undefined'\n    ? new ResizeObserver(entries => {\n      for (const entry of entries) {\n        const dim = direction.value === 'row' ? entry.contentRect.width : entry.contentRect.height;\n        containerSize.value = clampContainerSize(Math.round(dim));\n      }\n    })\n    : { observe: () => {}, unobserve: () => {}, disconnect: () => {} } as ResizeObserver;\n\n  function disconnectObserver(): void {\n    resizeObserver.disconnect();\n  }\n\n  watch(\n    containerRef,\n    (el, prev) => {\n      if (prev) resizeObserver.unobserve(prev);\n      if (el) {\n        const initial = direction.value === 'row' ? el.clientWidth : el.clientHeight;\n        containerSize.value = clampContainerSize(initial);\n        resizeObserver.observe(el);\n      }\n    },\n    { immediate: true }\n  );\n\n  // ── Expose ─────────────────────────────────────────────────────────────────\n\n  return {\n    layout,\n    syncedPanels,\n    panelMap,\n    containerSize,\n    isInitializing,\n\n    registerPanel,\n    unregisterPanel,\n\n    saveCurrentLayout,\n    updateSavedPanel,\n    reloadFromStorage,\n    clearSavedState,\n\n    disconnectObserver,\n  };\n}\n","/**\n * useResizableDrag — Per-group drag state composable\n *\n * Each ResizableGroup instance gets its own drag composable, so nested groups can\n * drag independently without conflict.\n *\n * Key design: shadow state during drag.\n * - proposedBeforeSize / proposedAfterSize track the \"what-if\" layout during the drag.\n * - These are applied directly to DOM elements as inline styles (performance).\n * - The reactive layout state is NOT mutated during drag.\n * - On commit (mouseup / touchend): onDragEnd callback receives the final sizes.\n * - On cancel (Escape / unmount): inline styles are removed, DOM returns to layout state.\n */\n\nimport { reactive, onUnmounted, type ComputedRef, type Ref } from 'vue';\nimport type { ResizableDirection, ResizablePanelState } from '../resizable_constants';\nimport type { ResizeHandler } from './useResizableCalculations';\n\n// ============================================================================\n// TYPES\n// ============================================================================\n\nexport type DragState = DragStateIdle | DragStateActive;\n\nexport interface DragStateIdle {\n  isActive: false;\n  handleId: null;\n  beforePanelId: null;\n  afterPanelId: null;\n  proposedBeforeSize: 0;\n  proposedAfterSize: 0;\n}\n\nexport interface DragStateActive {\n  isActive: true;\n  handleId: string;\n  beforePanelId: string;\n  afterPanelId: string;\n  /** Proposed before-panel size during drag (shadow — not committed to layout yet) */\n  proposedBeforeSize: number;\n  /** Proposed after-panel size during drag (shadow — not committed to layout yet) */\n  proposedAfterSize: number;\n}\n\n/** Initial idle state for reactive() initialization. */\nconst IDLE_STATE: DragStateIdle = {\n  isActive: false,\n  handleId: null,\n  beforePanelId: null,\n  afterPanelId: null,\n  proposedBeforeSize: 0,\n  proposedAfterSize: 0,\n};\n\nexport interface UseResizableDragOptions {\n  direction: ComputedRef<ResizableDirection>;\n  containerRef: Ref<HTMLElement | null>;\n  panels: ComputedRef<ResizablePanelState[]> | Ref<ResizablePanelState[]>;\n  containerSize: ComputedRef<number> | Ref<number>;\n  resizeHandler: ResizeHandler;\n  onDragEnd: (\n    beforePanelId: string,\n    afterPanelId: string,\n    beforeSize: number,\n    afterSize: number,\n    sizesChanged: boolean\n  ) => void;\n  onDragStart?: (handleId: string) => void;\n}\n\n// ============================================================================\n// DOM HELPERS\n// ============================================================================\n\nfunction findPanelElement(container: HTMLElement, panelId: string): HTMLElement | null {\n  return container.querySelector<HTMLElement>(`[data-panel-id=\"${panelId}\"]`);\n}\n\nfunction findHandleElement(container: HTMLElement, handleId: string): HTMLElement | null {\n  return container.querySelector<HTMLElement>(`[data-handle-id=\"${handleId}\"]`);\n}\n\nfunction applyPanelDragStyle(element: HTMLElement, start: number, end: number): void {\n  element.style.insetInlineStart = `${start}px`;\n  element.style.insetInlineEnd = `${end}px`;\n  element.style.inlineSize = '';\n}\n\nfunction clearDragStyle(element: HTMLElement): void {\n  element.style.insetInlineStart = '';\n  element.style.insetInlineEnd = '';\n  element.style.inlineSize = '';\n}\n\nfunction applyHandleDragStyle(element: HTMLElement, position: number): void {\n  element.style.insetInlineStart = `${Math.max(0, position)}px`;\n}\n\nfunction clearHandleDragStyle(element: HTMLElement): void {\n  element.style.insetInlineStart = '';\n}\n\n// ============================================================================\n// PANEL LOOKUP\n// ============================================================================\n\n/**\n * Find the before/after panel pair for a given handle ID.\n * Handle IDs are formatted as \"{beforePanelId}:{afterPanelId}\".\n */\nexport function findPanelsForHandle(\n  handleId: string,\n  panels: ResizablePanelState[]\n): { beforePanel: ResizablePanelState | null; afterPanel: ResizablePanelState | null } {\n  const sepIndex = handleId.indexOf(':');\n  if (sepIndex === -1) return { beforePanel: null, afterPanel: null };\n\n  const beforeId = handleId.slice(0, sepIndex);\n  const afterId = handleId.slice(sepIndex + 1);\n\n  const beforePanel = panels.find(p => p.id === beforeId) ?? null;\n  const afterPanel = panels.find(p => p.id === afterId) ?? null;\n  return { beforePanel, afterPanel };\n}\n\n// ============================================================================\n// COMPOSABLE\n// ============================================================================\n\n/**\n * Must be called from component setup context (uses `onUnmounted` lifecycle hook).\n */\nexport function useResizableDrag(options: UseResizableDragOptions) {\n  const { direction, containerRef, panels, containerSize, resizeHandler, onDragEnd, onDragStart } = options;\n\n  const dragState = reactive<DragState>({ ...IDLE_STATE });\n\n  let beforePanelEl: HTMLElement | null = null;\n  let afterPanelEl: HTMLElement | null = null;\n  let handleEl: HTMLElement | null = null;\n\n  let cachedBeforePanel: ResizablePanelState | null = null;\n  let cachedAfterPanel: ResizablePanelState | null = null;\n\n  let originalBeforeSize = 0;\n  let originalAfterSize = 0;\n  let beforePanelLeft = 0;\n  let cachedContainerRect: DOMRect | null = null;\n\n  let boundPointerMove: ((e: PointerEvent) => void) | null = null;\n  let boundPointerUp: ((e: PointerEvent) => void) | null = null;\n\n  function attachDocumentListeners(): void {\n    boundPointerMove = (e: PointerEvent) => onDragMove(e);\n    boundPointerUp = () => commitDrag();\n\n    document.addEventListener('pointermove', boundPointerMove);\n    document.addEventListener('pointerup', boundPointerUp);\n    document.addEventListener('pointercancel', boundPointerUp);\n    document.addEventListener('keydown', handleKeydown);\n  }\n\n  function removeDocumentListeners(): void {\n    if (boundPointerMove) {\n      document.removeEventListener('pointermove', boundPointerMove);\n      boundPointerMove = null;\n    }\n    if (boundPointerUp) {\n      document.removeEventListener('pointerup', boundPointerUp);\n      document.removeEventListener('pointercancel', boundPointerUp);\n      boundPointerUp = null;\n    }\n    document.removeEventListener('keydown', handleKeydown);\n  }\n\n  function cleanup(): void {\n    removeDocumentListeners();\n\n    document.body.style.userSelect = '';\n    document.body.style.cursor = '';\n\n    Object.assign(dragState, IDLE_STATE);\n\n    beforePanelEl = null;\n    afterPanelEl = null;\n    handleEl = null;\n    cachedBeforePanel = null;\n    cachedAfterPanel = null;\n    originalBeforeSize = 0;\n    originalAfterSize = 0;\n    beforePanelLeft = 0;\n    cachedContainerRect = null;\n  }\n\n  function locateDragElements(\n    container: HTMLElement,\n    handleId: string,\n    panelList: ResizablePanelState[]\n  ): {\n    beforePanel: ResizablePanelState;\n    afterPanel: ResizablePanelState;\n    beforeEl: HTMLElement;\n    afterEl: HTMLElement;\n    handleElement: HTMLElement | null;\n  } | null {\n    const { beforePanel, afterPanel } = findPanelsForHandle(handleId, panelList);\n    if (!beforePanel || !afterPanel) {\n      console.warn(`[resizable] No panel pair found for handle \"${handleId}\"`);\n      return null;\n    }\n\n    const beforeEl = findPanelElement(container, beforePanel.id);\n    const afterEl = findPanelElement(container, afterPanel.id);\n    const handleElement = findHandleElement(container, handleId);\n\n    if (!beforeEl || !afterEl) {\n      console.warn(`[resizable] Panel element(s) not found for handle \"${handleId}\"`);\n      return null;\n    }\n\n    return { beforePanel, afterPanel, beforeEl, afterEl, handleElement };\n  }\n\n  function startDrag(handleId: string): void {\n    const container = containerRef.value;\n    if (!container) return;\n\n    const elements = locateDragElements(container, handleId, panels.value);\n    if (!elements) return;\n\n    beforePanelEl = elements.beforeEl;\n    afterPanelEl = elements.afterEl;\n    handleEl = elements.handleElement;\n\n    cachedBeforePanel = elements.beforePanel;\n    cachedAfterPanel = elements.afterPanel;\n\n    originalBeforeSize = elements.beforePanel.pixelSize;\n    originalAfterSize = elements.afterPanel.pixelSize;\n\n    beforePanelLeft = parseFloat(beforePanelEl.style.insetInlineStart || '0');\n    cachedContainerRect = container.getBoundingClientRect();\n\n    Object.assign(dragState, {\n      isActive: true,\n      handleId,\n      beforePanelId: elements.beforePanel.id,\n      afterPanelId: elements.afterPanel.id,\n      proposedBeforeSize: originalBeforeSize,\n      proposedAfterSize: originalAfterSize,\n    } satisfies DragStateActive);\n\n    document.body.style.userSelect = 'none';\n    document.body.style.cursor = direction.value === 'row' ? 'ew-resize' : 'ns-resize';\n\n    attachDocumentListeners();\n    onDragStart?.(handleId);\n  }\n\n  function computeDragPosition(\n    event: PointerEvent,\n    dir: ResizableDirection\n  ): number {\n    const rect = cachedContainerRect!;\n    return dir === 'row' ? event.clientX - rect.left : event.clientY - rect.top;\n  }\n\n  function isDragMoveReady(): boolean {\n    return (\n      dragState.isActive &&\n      !!containerRef.value &&\n      !!beforePanelEl &&\n      !!afterPanelEl &&\n      !!dragState.handleId &&\n      !!cachedBeforePanel &&\n      !!cachedAfterPanel\n    );\n  }\n\n  function onDragMove(event: PointerEvent): void {\n    if (!isDragMoveReady()) return;\n\n    const rawCursorPosition = computeDragPosition(event, direction.value);\n\n    const result = resizeHandler.processResizeMove(\n      rawCursorPosition,\n      cachedBeforePanel!,\n      cachedAfterPanel!,\n      containerSize.value,\n      dragState.handleId!,\n      panels.value,\n      beforePanelLeft\n    );\n\n    if (!result.isValidResize) return;\n\n    if (dragState.proposedBeforeSize !== result.beforePanelSize) {\n      dragState.proposedBeforeSize = result.beforePanelSize;\n    }\n    if (dragState.proposedAfterSize !== result.afterPanelSize) {\n      dragState.proposedAfterSize = result.afterPanelSize;\n    }\n\n    const containerSizeValue = containerSize.value;\n    const constrainedCursor = result.constrainedCursorPosition;\n    const beforeRight = containerSizeValue - constrainedCursor;\n    const handlePos = constrainedCursor - 2;\n\n    const afterRight = containerSizeValue - constrainedCursor - result.afterPanelSize;\n\n    applyPanelDragStyle(beforePanelEl!, beforePanelLeft, beforeRight);\n    applyPanelDragStyle(afterPanelEl!, constrainedCursor, Math.max(0, afterRight));\n\n    if (handleEl) {\n      applyHandleDragStyle(handleEl, handlePos);\n    }\n  }\n\n  function commitDrag(): void {\n    if (!dragState.isActive) return;\n\n    const beforePanelId = dragState.beforePanelId;\n    const afterPanelId = dragState.afterPanelId;\n    const beforeSize = dragState.proposedBeforeSize;\n    const afterSize = dragState.proposedAfterSize;\n\n    const capturedOriginalBeforeSize = originalBeforeSize;\n    const capturedOriginalAfterSize = originalAfterSize;\n\n    if (beforePanelEl) clearDragStyle(beforePanelEl);\n    if (afterPanelEl) clearDragStyle(afterPanelEl);\n    if (handleEl) clearHandleDragStyle(handleEl);\n\n    cleanup();\n\n    const sizesChanged = beforeSize !== capturedOriginalBeforeSize || afterSize !== capturedOriginalAfterSize;\n\n    if (beforePanelId && afterPanelId) {\n      onDragEnd(beforePanelId, afterPanelId, beforeSize, afterSize, sizesChanged);\n    }\n  }\n\n  function cancelDrag(): void {\n    if (!dragState.isActive) return;\n\n    if (beforePanelEl && afterPanelEl) {\n      clearDragStyle(beforePanelEl);\n      clearDragStyle(afterPanelEl);\n    }\n    if (handleEl) {\n      clearHandleDragStyle(handleEl);\n    }\n\n    cleanup();\n  }\n\n  function handleKeydown(event: KeyboardEvent): void {\n    if (event.key === 'Escape' && dragState.isActive) {\n      event.preventDefault();\n      cancelDrag();\n    }\n  }\n\n  onUnmounted(() => {\n    cancelDrag();\n  });\n\n  return {\n    dragState,\n    startDrag,\n    onDragMove,\n    commitDrag,\n    cancelDrag,\n    cleanup,\n  };\n}\n","import { onMounted, onUnmounted } from 'vue';\n\n// ─── Announcements (aria-live singleton with ref counting) ───────────────\n\nlet announcementElement: HTMLElement | null = null;\nlet announcementTimeout: ReturnType<typeof setTimeout> | undefined;\nlet announcementRefCount = 0;\n\nfunction getAnnouncementElement(): HTMLElement {\n  if (!announcementElement) {\n    announcementElement = document.getElementById('d-resizable-announcements');\n\n    if (!announcementElement) {\n      announcementElement = document.createElement('div');\n      announcementElement.id = 'd-resizable-announcements';\n      announcementElement.setAttribute('aria-live', 'polite');\n      announcementElement.setAttribute('aria-atomic', 'true');\n      announcementElement.style.position = 'absolute';\n      announcementElement.style.left = '-10000px';\n      announcementElement.style.width = '1px';\n      announcementElement.style.height = '1px';\n      announcementElement.style.overflow = 'hidden';\n      document.body.appendChild(announcementElement);\n    }\n  }\n  return announcementElement;\n}\n\nfunction announce(message: string): void {\n  if (!message.trim()) return;\n\n  if (announcementTimeout) {\n    clearTimeout(announcementTimeout);\n  }\n\n  const element = getAnnouncementElement();\n  element.textContent = '';\n\n  announcementTimeout = setTimeout(() => {\n    element.textContent = message;\n    setTimeout(() => { element.textContent = ''; }, 1000);\n  }, 100);\n}\n\n// ─── Composable ───────────────────────────────────────────────────────────\n\n/**\n * Manages a shared aria-live announcements region for all DtResizable\n * instances. Uses ref counting to create/destroy the singleton DOM element.\n */\nexport function useResizableAnnouncements() {\n  onMounted(() => {\n    announcementRefCount++;\n    getAnnouncementElement();\n  });\n\n  onUnmounted(() => {\n    if (announcementTimeout) {\n      clearTimeout(announcementTimeout);\n    }\n\n    announcementRefCount--;\n    if (announcementRefCount <= 0 && announcementElement) {\n      announcementElement.remove();\n      announcementElement = null;\n      announcementRefCount = 0;\n    }\n  });\n\n  return { announce };\n}\n","/**\n * Offset positioning composable for resize handles.\n *\n * Calculates dynamic offsets from DOM elements (e.g. a fixed header/toolbar)\n * so handles and panel content can avoid overlapping external UI.\n */\n\nimport {\n  ref,\n  computed,\n  onMounted,\n  type Ref,\n  type ComputedRef,\n} from 'vue';\n\n// ─── Types ────────────────────────────────────────────────────────────────\n\nexport interface ResizableOffsetOptions {\n  /** CSS selector for the element to measure offset from (auto-measures block-size) */\n  offsetElement?: string | null;\n  /** Explicit pixel offset. Overrides offsetElement measurement when both provided. */\n  offsetAmount?: number | null;\n  /** Which edge(s) the offset applies to (default: 'start') */\n  offsetDirection?: 'start' | 'end' | 'both';\n  /** Layout direction — affects which dimension is measured */\n  direction?: ComputedRef<'row' | 'column'> | Ref<'row' | 'column'>;\n}\n\nexport interface ResizableOffsetResult {\n  calculatedOffset: Ref<number>;\n  updateOffset: () => void;\n  handleStyles: ComputedRef<Record<string, string>>;\n  contentStyles: ComputedRef<Record<string, string>>;\n}\n\n// ─── Composable ───────────────────────────────────────────────────────────\n\nexport function useResizableOffset(\n  options: ResizableOffsetOptions = {},\n): ResizableOffsetResult {\n  const {\n    offsetElement = null,\n    offsetAmount = null,\n    offsetDirection = 'start',\n    direction = ref('row'),\n  } = options;\n\n  const calculatedOffset = ref(0);\n\n  function updateOffset(): void {\n    // Explicit amount wins over element measurement\n    if (offsetAmount != null && offsetAmount > 0) {\n      calculatedOffset.value = offsetAmount;\n      return;\n    }\n\n    if (!offsetElement) { calculatedOffset.value = 0; return; }\n\n    try {\n      const element = document.querySelector(offsetElement);\n      if (!element) { calculatedOffset.value = 0; return; }\n\n      const rect = element.getBoundingClientRect();\n      const dim = direction.value === 'row' ? rect.height : rect.width;\n      calculatedOffset.value = dim;\n    } catch (error) {\n      console.warn('[resizable] Failed to measure offset element:', error);\n      calculatedOffset.value = 0;\n    }\n  }\n\n  // ── Computed styles — logical properties rotate with writing-mode ──\n\n  const handleStyles = computed(() => {\n    const styles: Record<string, string> = {};\n    if (calculatedOffset.value <= 0) return styles;\n    const px = `${calculatedOffset.value}px`;\n    if (offsetDirection === 'start' || offsetDirection === 'both') styles.insetBlockStart = px;\n    if (offsetDirection === 'end' || offsetDirection === 'both') styles.insetBlockEnd = px;\n    return styles;\n  });\n\n  const contentStyles = computed(() => {\n    const styles: Record<string, string> = {};\n    if (calculatedOffset.value <= 0) return styles;\n    const px = `${calculatedOffset.value}px`;\n    if (offsetDirection === 'start' || offsetDirection === 'both') styles.paddingBlockStart = px;\n    if (offsetDirection === 'end' || offsetDirection === 'both') styles.paddingBlockEnd = px;\n    return styles;\n  });\n\n  onMounted(() => { updateOffset(); });\n\n  return { calculatedOffset, updateOffset, handleStyles, contentStyles };\n}\n","<template>\n  <div\n    ref=\"containerRef\"\n    :class=\"[\n      'd-resizable',\n      `d-resizable--${currentDirection}`,\n      { 'd-resizable--resizing': isResizing },\n      props.class,\n    ]\"\n    :data-storage-key=\"props.storageKey || undefined\"\n  >\n    <!-- @slot Container for panels and handles. -->\n    <slot\n      :panels=\"group.syncedPanels.value\"\n      :direction=\"currentDirection\"\n      :is-resizing=\"isResizing\"\n      :space-allocation-strategy=\"props.spaceAllocationStrategy\"\n      :resize-panel=\"resizePanel\"\n      :collapse-panel=\"collapsePanel\"\n      :start-resize=\"startResize\"\n      :stop-resize=\"stopResize\"\n    />\n  </div>\n</template>\n\n<script setup>\nimport {\n  ref,\n  computed,\n  watch,\n  onUnmounted,\n  provide,\n} from 'vue';\nimport { RESIZABLE_CONTEXT_KEY, buildHandleId } from './resizable_constants';\nimport {\n  useResizablePanelControls,\n  useResizableGroup,\n  useResizeHandling,\n  checkAutoCollapseRules,\n  useResizableAnnouncements,\n  useResizableOffset,\n} from './composables';\nimport { useResizableDrag } from './composables/useResizableDrag';\n\nconst props = defineProps({\n  /**\n   * Layout direction. 'row' for horizontal, 'column' for vertical.\n   * @values 'row', 'column'\n   */\n  direction: {\n    type: String,\n    default: 'row',\n  },\n  /** localStorage key for persisting panel sizes across page loads. */\n  storageKey: {\n    type: String,\n    default: null,\n  },\n  /** Additional CSS classes applied to the container element. */\n  class: {\n    type: [String, Object, Array],\n    default: '',\n  },\n  /**\n   * Panel configurations array. When provided, panels are initialized\n   * from this array instead of registering via child DtResizablePanel components.\n   */\n  panels: {\n    type: Array,\n    default: () => [],\n  },\n  /**\n   * Strategy for redistributing space when panels open/close.\n   * @values 'proportional', 'preserve-manual'\n   */\n  spaceAllocationStrategy: {\n    type: String,\n    default: 'proportional',\n    validator: (val) => ['proportional', 'preserve-manual'].includes(val),\n  },\n  /** Rules defining which panels collapse first when space is constrained */\n  collapseRules: {\n    type: Array,\n    default: () => [],\n  },\n  /** Custom storage adapter. Overrides storageKey when both are provided. */\n  storage: {\n    type: Object,\n    default: null,\n  },\n  /** CSS selector for a fixed element to offset handles and panel content from. */\n  offsetElement: { type: String, default: null },\n  /** Explicit pixel offset. Overrides offsetElement measurement when both provided. */\n  offsetAmount: { type: Number, default: null },\n  /**\n   * Which edge(s) the offset applies to.\n   * @values 'start', 'end', 'both'\n   */\n  offsetDirection: { type: String, default: 'start' },\n  /**\n   * i18n message overrides for screen reader announcements.\n   * Accepts keys from ResizableKeyboardMessages.\n   */\n  messages: {\n    type: Object,\n    default: () => ({}),\n  },\n});\n\nconst emit = defineEmits(\n  /**\n   * @event panel-resize - Emitted when a panel is resized. Payload: (panelId, size).\n   * @event panel-collapse - Emitted when a panel collapses or expands. Payload: (panelId, collapsed).\n   * @event resize-start - Emitted when a resize drag begins. Payload: (handleId).\n   * @event resize-end - Emitted when a resize drag ends. Payload: (handleId).\n   */\n  ['panel-resize', 'panel-collapse', 'resize-start', 'resize-end'],\n);\n\nconst containerRef = ref(null);\n\nconst currentDirection = computed(() => props.direction);\n\n// Note: storageKey and storage are captured at mount time. If they need to\n// change dynamically in the future, useResizableGroup should accept refs.\nconst group = useResizableGroup({\n  storageKey: props.storageKey ?? null,\n  direction: currentDirection,\n  containerRef,\n  storageAdapter: props.storage ?? undefined,\n});\n\nconst isResizing = ref(false);\nconst activeHandleId = ref(undefined);\n\nconst resizeHandler = useResizeHandling(() => group.containerSize.value);\n\nconst isInitializing = group.isInitializing;\nconst registerPanel = (config) => group.registerPanel(config);\nconst unregisterPanel = (id) => group.unregisterPanel(id);\nconst saveToStorage = (panels) => group.saveCurrentLayout(panels);\n\nconst {\n  commitPanelSize,\n  resizePanel,\n  collapsePanel,\n  resetPanels: originalResetPanels,\n  processAutoCollapseExpand,\n} = useResizablePanelControls({\n  panels: group.syncedPanels,\n  containerSize: group.containerSize,\n  containerRef,\n  onPanelResize: (panelId, size) => emit('panel-resize', panelId, size),\n  onPanelCollapse: (panelId, collapsed) => emit('panel-collapse', panelId, collapsed),\n  updateSavedPanel: (panelId, updates) => group.updateSavedPanel(panelId, updates),\n});\n\nfunction resetPanels (beforePanelId, afterPanelId, behavior = 'all') {\n  originalResetPanels(beforePanelId, afterPanelId, behavior);\n\n  if (behavior === 'all') {\n    group.syncedPanels.value.forEach(p => group.updateSavedPanel(p.id, { manualTargetRatio: undefined }));\n    group.clearSavedState();\n  } else {\n    if (beforePanelId) group.updateSavedPanel(beforePanelId, { manualTargetRatio: undefined });\n    if (afterPanelId) group.updateSavedPanel(afterPanelId, { manualTargetRatio: undefined });\n  }\n}\n\nfunction processAutoCollapse () {\n  processAutoCollapseExpand();\n  if (!props.collapseRules?.length) return;\n  const panels = group.syncedPanels.value;\n  const panelsToCollapse = checkAutoCollapseRules(panels, props.collapseRules, group.containerSize.value);\n  if (panelsToCollapse.length === 0) return;\n  const panel = panels.find(p => p.id === panelsToCollapse[0]);\n  if (panel && !panel.collapsed) collapsePanel(panelsToCollapse[0], true);\n}\n\nconst { announce } = useResizableAnnouncements();\n\nconst offset = useResizableOffset({\n  offsetElement: props.offsetElement,\n  offsetAmount: props.offsetAmount,\n  offsetDirection: props.offsetDirection,\n  direction: currentDirection,\n});\n\nconst handleInstances = new Set();\nfunction registerHandle (inst) { handleInstances.add(inst); }\nfunction unregisterHandle (inst) { handleInstances.delete(inst); }\n\nconst drag = useResizableDrag({\n  direction: currentDirection,\n  containerRef,\n  panels: group.syncedPanels,\n  containerSize: group.containerSize,\n  resizeHandler,\n  onDragStart (handleId) {\n    isResizing.value = true;\n    activeHandleId.value = handleId;\n    emit('resize-start', handleId);\n  },\n  onDragEnd (beforePanelId, afterPanelId, beforeSize, afterSize, sizesChanged) {\n    const handleId = drag.dragState.handleId ?? buildHandleId(beforePanelId, afterPanelId);\n    isResizing.value = false;\n    activeHandleId.value = undefined;\n\n    if (sizesChanged) {\n      commitPanelSize(beforePanelId, beforeSize);\n      commitPanelSize(afterPanelId, afterSize);\n\n      emit('resize-end', handleId);\n      processAutoCollapse();\n    }\n  },\n});\n\nfunction startResize (handleId) { drag.startDrag(handleId); }\nfunction stopResize () { drag.cancelDrag(); }\nfunction savePanelsToStorage () { saveToStorage(group.syncedPanels.value); }\nfunction emitPanelResize (panelId, size) { emit('panel-resize', panelId, size); }\n\nwatch(group.syncedPanels, (panels) => {\n  if (panels.length > 0 && !isInitializing.value) {\n    processAutoCollapse();\n  }\n}, { flush: 'post' });\n\nonUnmounted(() => {\n  group.disconnectObserver();\n  drag.cancelDrag();\n});\n\n// Provide single context object for child components\nprovide(RESIZABLE_CONTEXT_KEY, {\n  layout: group.layout,\n  panels: group.syncedPanels,\n  panelMap: group.panelMap,\n  direction: currentDirection,\n  containerSize: group.containerSize,\n  containerElement: computed(() => containerRef.value),\n  isResizing: computed(() => isResizing.value),\n  activeHandleId: computed(() => activeHandleId.value),\n  isInitializing: computed(() => isInitializing.value),\n  messages: props.messages,\n  startResize: (handleId) => startResize(handleId),\n  resetPanels,\n  registerHandle,\n  unregisterHandle,\n  registerPanel,\n  unregisterPanel,\n  saveToStorage: savePanelsToStorage,\n  announce,\n  offsetHandleStyles: offset.handleStyles,\n  offsetContentStyles: offset.contentStyles,\n  collapsePanel,\n  emitPanelResize,\n  commitPanelSize,\n  updateSavedPanel: (panelId, updates) => group.updateSavedPanel(panelId, updates),\n});\n\n// Expose methods for programmatic control\ndefineExpose({\n  resizePanel,\n  collapsePanel,\n  resetPanels,\n  state: computed(() => ({\n    direction: currentDirection.value,\n    panels: group.syncedPanels.value,\n    containerSize: group.containerSize.value,\n    isResizing: isResizing.value,\n    activeHandleId: activeHandleId.value,\n  })),\n  panelConfigs: computed(() => props.panels),\n  allocationStrategy: computed(() => props.spaceAllocationStrategy),\n});\n</script>\n"],"mappings":"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"}

package/dist/resizable_handle-BlKBiWnx.js

@@ -0,0 +1,307 @@
+import { d as e, f as t, s as n } from "./resizable_utils-BComtrMV.js";
+import { t as r } from "./useResizableCalculations-DAajatT4.js";
+import { computed as i, createElementBlock as a, createElementVNode as o, getCurrentInstance as s, inject as c, normalizeClass as l, normalizeStyle as u, onMounted as d, onUnmounted as f, openBlock as p, ref as m, unref as h } from "vue";
+//#region components/resizable/composables/useResizableKeyboard.ts
+var g = {
+	resizeAnnouncement: "{beforeId}: {beforePx}px, {afterId}: {afterPx}px",
+	collapseAnnouncement: "{panelId} collapsed",
+	expandAnnouncement: "{panelId} expanded",
+	resetAnnouncement: "{beforeId} and {afterId} reset",
+	ariaValueText: "{panelId}: {pixels}px",
+	handleAriaLabel: "Resize handle between {before} and {after} panels"
+}, _ = {
+	fine: 1,
+	normal: 8,
+	large: 24
+};
+function v(e) {
+	let { panels: n, direction: i, containerSize: a, beforePanelId: o, afterPanelId: s, handleElement: c, onResize: l, onCollapse: u, onReset: d, onSizeAnnouncement: f, messages: p } = e, h = {
+		...g,
+		...p
+	}, v = m(!1), y = r(() => a.value);
+	function b() {
+		return {
+			beforePanel: n.value.find((e) => e.id === o.value),
+			afterPanel: n.value.find((e) => e.id === s.value)
+		};
+	}
+	function x(e) {
+		return e.metaKey || e.ctrlKey ? _.fine : e.shiftKey ? _.large : _.normal;
+	}
+	function S(e, t) {
+		return t === "row" ? {
+			ArrowLeft: "decrease",
+			ArrowRight: "increase"
+		}[e] || null : {
+			ArrowUp: "decrease",
+			ArrowDown: "increase"
+		}[e] || null;
+	}
+	function C(e, t) {
+		let n = Math.round(e.pixelSize), r = Math.round(t.pixelSize);
+		return h.resizeAnnouncement.replace("{beforeId}", e.id).replace("{afterId}", t.id).replace("{beforePx}", String(n)).replace("{afterPx}", String(r));
+	}
+	function w(e, t, n, r, i) {
+		e.style.insetInlineStart = e.style.insetInlineStart || "0px", e.style.insetInlineEnd = `${i}px`, e.style.inlineSize = "", t.style.insetInlineStart = `${r}px`, t.style.inlineSize = "", n && (n.style.insetInlineStart = `${Math.max(0, r - 2)}px`);
+	}
+	function T(e, t, n) {
+		e.style.insetInlineStart = "", e.style.insetInlineEnd = "", e.style.inlineSize = "", t.style.insetInlineStart = "", t.style.inlineSize = "", n && (n.style.insetInlineStart = "");
+	}
+	function E(e, n, r, i) {
+		let u = Math.round(r), d = Math.round(i), f = r, p = c.value?.closest(".d-resizable"), m = null, h = null, g = null;
+		if (p && (m = p.querySelector(`[data-panel-id="${o.value}"]`), h = p.querySelector(`[data-panel-id="${s.value}"]`), g = p.querySelector(`[data-handle-id="${t(o.value, s.value)}"]`), m && h)) {
+			let e = a.value - f;
+			w(m, h, g, f, e);
+		}
+		l(o.value, u, s.value, d), m && h && T(m, h, g);
+	}
+	function D(e, r, i, c) {
+		let l = i === "increase" ? c : -c, u = e.pixelSize + l, d = y.processResizeMove(u, e, r, a.value, t(o.value, s.value), n.value, 0);
+		return d.isValidResize ? (E(e, r, d.beforePanelSize, d.afterPanelSize), f && f(C(e, r)), !0) : !1;
+	}
+	function O(e) {
+		let t = S(e.key, i.value);
+		if (!t) return;
+		e.preventDefault(), e.stopPropagation();
+		let { beforePanel: n, afterPanel: r } = b();
+		!n || !r || D(n, r, t, x(e));
+	}
+	function k(e) {
+		let { beforePanel: t } = b();
+		if (!t?.collapsible || !u) return;
+		e.preventDefault();
+		let n = !t.collapsed;
+		u(t.id, n), f && f((n ? h.collapseAnnouncement : h.expandAnnouncement).replace("{panelId}", t.id));
+	}
+	function A(e) {
+		e.preventDefault();
+		let { beforePanel: t, afterPanel: n } = b();
+		if (!t || !n) return;
+		let r = (t.userMinSizePixels ?? 10) - t.pixelSize;
+		r !== 0 && D(t, n, r > 0 ? "increase" : "decrease", Math.abs(r));
+	}
+	function j(e) {
+		e.preventDefault();
+		let { beforePanel: t, afterPanel: n } = b();
+		if (!t || !n) return;
+		let r = n.userMinSizePixels ?? 10, i = t.userMaxSizePixels ?? a.value - r, o = Math.min(i, a.value - r) - t.pixelSize;
+		o !== 0 && D(t, n, o > 0 ? "increase" : "decrease", Math.abs(o));
+	}
+	function M(e) {
+		if (e.ctrlKey || e.metaKey || e.altKey || e.shiftKey) return;
+		e.preventDefault();
+		let { beforePanel: t, afterPanel: n } = b();
+		!t || !n || !d || (d(t.id, n.id), f && f(h.resetAnnouncement.replace("{beforeId}", t.id).replace("{afterId}", n.id)));
+	}
+	function N(e) {
+		e.preventDefault(), c.value?.blur();
+	}
+	function P(e) {
+		if (v.value) {
+			switch (e.key) {
+				case "Enter":
+					k(e);
+					return;
+				case "Home":
+					A(e);
+					return;
+				case "End":
+					j(e);
+					return;
+				case "r":
+				case "R":
+					M(e);
+					return;
+				case "Escape":
+					N(e);
+					return;
+			}
+			O(e);
+		}
+	}
+	function F() {
+		v.value = !0;
+	}
+	function I() {
+		v.value = !1;
+	}
+	function L() {
+		c.value?.focus();
+	}
+	return {
+		isFocused: v,
+		focusHandle: L,
+		handleKeyDown: P,
+		handleFocus: F,
+		handleBlur: I,
+		KEYBOARD_INCREMENTS: _
+	};
+}
+//#endregion
+//#region components/resizable/resizable_handle.vue
+var y = [
+	"data-handle-id",
+	"tabindex",
+	"aria-orientation",
+	"aria-label",
+	"aria-valuenow",
+	"aria-valuemin",
+	"aria-valuemax",
+	"aria-controls",
+	"aria-valuetext",
+	"aria-disabled"
+], b = {
+	__name: "resizable_handle",
+	props: {
+		beforePanelId: {
+			type: String,
+			default: null
+		},
+		afterPanelId: {
+			type: String,
+			default: null
+		},
+		disabled: {
+			type: Boolean,
+			default: !1
+		},
+		class: {
+			type: [
+				String,
+				Object,
+				Array
+			],
+			default: ""
+		},
+		disableResetOnDoubleClick: {
+			type: Boolean,
+			default: !1
+		},
+		resetBehavior: {
+			type: String,
+			default: "both"
+		},
+		ariaLabel: {
+			type: String,
+			default: null
+		}
+	},
+	setup(r) {
+		let g = r, _ = c(e, null), b = _?.layout ?? i(() => ({
+			panels: /* @__PURE__ */ new Map(),
+			handles: []
+		})), x = _?.panels ?? i(() => []), S = _?.direction ?? i(() => "row"), C = _?.containerSize ?? i(() => 1e3), w = _?.activeHandleId ?? i(() => void 0), T = _?.startResize ?? (() => {}), E = _?.resetPanels ?? (() => {}), D = _?.registerHandle ?? (() => 0), O = _?.unregisterHandle ?? (() => {}), k = _?.saveToStorage ?? null, A = _?.collapsePanel ?? null, j = _?.commitPanelSize ?? null, M = _?.announce ?? null, N = _?.panelMap ?? i(() => /* @__PURE__ */ new Map()), P = _?.messages ?? {}, F = s(), I = m(0), L = i(() => {
+			let e = b.value;
+			if (e.handles.length === 0) return null;
+			if (g.beforePanelId && g.afterPanelId) {
+				let n = t(g.beforePanelId, g.afterPanelId);
+				return e.handles.find((e) => e.id === n) ?? null;
+			}
+			return e.handles[I.value] ?? null;
+		}), R = i(() => L.value?.id ?? ""), z = i(() => L.value?.beforePanelId ?? g.beforePanelId ?? ""), B = i(() => L.value?.afterPanelId ?? g.afterPanelId ?? ""), V = i(() => !!(R.value && w.value === R.value)), H = i(() => g.disabled || (L.value?.disabled ?? !1)), U = S, W = i(() => {
+			let e = L.value;
+			return e ? {
+				insetInlineStart: `${Math.max(0, e.left)}px`,
+				visibility: "",
+				...Q.value
+			} : { visibility: "hidden" };
+		}), G = i(() => {
+			if (g.ariaLabel) return g.ariaLabel;
+			let e = z.value || "first", t = B.value || "second";
+			return (P.handleAriaLabel ?? "Resize handle between {before} and {after} panels").replace("{before}", e).replace("{after}", t);
+		}), K = i(() => {
+			let e = N.value.get(z.value);
+			return e ? (P.ariaValueText ?? "{panelId}: {pixels}px").replace("{panelId}", z.value).replace("{pixels}", String(Math.round(e.pixelSize))) : "";
+		}), q = i(() => {
+			let e = N.value.get(z.value), t = C.value;
+			return !e || !t ? 0 : Math.floor(n(e.collapsed ? 0 : e.pixelSize || 0, t));
+		}), J = i(() => {
+			let e = N.value.get(z.value), t = C.value;
+			return !e || !t ? 0 : Math.floor(n(e.userMinSizePixels || 0, t));
+		}), Y = i(() => {
+			let e = N.value.get(z.value), t = C.value;
+			return !e || !t ? 100 : Math.floor(n(e.userMaxSizePixels || t, t));
+		}), X = m(null), Z = v({
+			panels: x,
+			direction: S,
+			containerSize: C,
+			beforePanelId: z,
+			afterPanelId: B,
+			handleElement: X,
+			onResize(e, t, n, r) {
+				j ? (j(e, t), j(n, r)) : k?.();
+			},
+			onCollapse(e, t) {
+				A?.(e, t);
+			},
+			onReset(e, t) {
+				E?.(e, t, "both");
+			},
+			onSizeAnnouncement(e) {
+				M?.(e);
+			},
+			messages: P
+		}), Q = _?.offsetHandleStyles ?? i(() => ({}));
+		d(() => {
+			D(F);
+			let e = X.value;
+			if (e?.parentElement) {
+				let t = Array.from(e.parentElement.querySelectorAll(".d-resizable-handle")).indexOf(e);
+				t >= 0 && (I.value = t);
+			}
+		}), f(() => {
+			O(F);
+		});
+		function $(e) {
+			H.value || (e.preventDefault(), T(R.value));
+		}
+		function ee() {
+			if (g.disableResetOnDoubleClick || H.value) return;
+			let e = z.value, t = B.value;
+			!e || !t || E(e, t, g.resetBehavior);
+		}
+		function te(e) {
+			Z.handleKeyDown(e);
+		}
+		function ne() {
+			Z.handleFocus();
+		}
+		function re() {
+			Z.handleBlur();
+		}
+		return (e, t) => (p(), a("div", {
+			ref_key: "handleElement",
+			ref: X,
+			class: l([
+				"d-resizable-handle",
+				`d-resizable-handle--${h(U)}`,
+				g.class,
+				{
+					"d-resizable-handle--active": V.value,
+					"d-resizable-handle--disabled": H.value
+				}
+			]),
+			style: u(W.value),
+			"data-handle-id": R.value,
+			tabindex: H.value ? "-1" : "0",
+			role: "separator",
+			"aria-orientation": h(U) === "row" ? "vertical" : "horizontal",
+			"aria-label": G.value,
+			"aria-valuenow": q.value,
+			"aria-valuemin": J.value,
+			"aria-valuemax": Y.value,
+			"aria-controls": `dt-resizable-panel-${z.value}`,
+			"aria-valuetext": K.value,
+			"aria-disabled": H.value || void 0,
+			onPointerdown: $,
+			onDblclick: ee,
+			onKeydown: te,
+			onFocus: ne,
+			onBlur: re
+		}, [...t[0] || (t[0] = [o("div", { class: "d-resizable-handle__indicator" }, null, -1)])], 46, y));
+	}
+};
+//#endregion
+export { b as t };
+
+//# sourceMappingURL=resizable_handle-BlKBiWnx.js.map