@neut/ui 0.0.16 → 0.0.18

package/dist/components/resizable/ResizablePanelGroup/useDragCursor.js

@@ -0,0 +1,17 @@
+import { createEffect as e, onCleanup as t } from "solid-js";
+//#region src/components/resizable/ResizablePanelGroup/useDragCursor.ts
+function n(n, r) {
+	e(() => {
+		if (!n()) return;
+		let e = r() === "horizontal" ? "ew-resize" : "ns-resize", i = document.createElement("style");
+		i.setAttribute("data-resizable-drag", ""), i.textContent = `*, *:hover { cursor: ${e} !important; }`, document.head.appendChild(i);
+		let a = document.body.style.userSelect;
+		document.body.style.userSelect = "none", t(() => {
+			i.remove(), document.body.style.userSelect = a;
+		});
+	});
+}
+//#endregion
+export { n as useDragCursor };
+
+//# sourceMappingURL=useDragCursor.js.map

package/dist/components/resizable/ResizablePanelGroup/useDragCursor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDragCursor.js","names":["useDragCursor","dragging","cursor","orientation","sheet","previousUserSelect","onCleanup"],"sources":["../../../../src/components/resizable/ResizablePanelGroup/useDragCursor.ts"],"sourcesContent":["import { type Accessor, createEffect, onCleanup } from \"solid-js\";\nimport type { ResizableOrientation } from \"../resizable.types\";\n\n/**\n * 拖拽期间强制全局双箭头光标：注入一条 `*, *:hover { cursor: … !important }`，\n * 这样指针经过面板/文字/链接时也不会变回默认光标；顺带禁用文本选择，\n * 避免拖拽中选中内容。拖拽结束（或组件卸载）时还原。\n *\n * 与 react-resizable-panels 的行为一致，因此单独成 hook——\n * 它只依赖\"是否拖拽中\"与方向，跟布局引擎、渲染都无关。\n */\nexport function useDragCursor(\n  dragging: Accessor<boolean>,\n  orientation: Accessor<ResizableOrientation>,\n) {\n  createEffect(() => {\n    if (!dragging()) return;\n\n    const cursor = orientation() === \"horizontal\" ? \"ew-resize\" : \"ns-resize\";\n    const sheet = document.createElement(\"style\");\n    sheet.setAttribute(\"data-resizable-drag\", \"\");\n    sheet.textContent = `*, *:hover { cursor: ${cursor} !important; }`;\n    document.head.appendChild(sheet);\n\n    const previousUserSelect = document.body.style.userSelect;\n    document.body.style.userSelect = \"none\";\n\n    onCleanup(() => {\n      sheet.remove();\n      document.body.style.userSelect = previousUserSelect;\n    });\n  });\n}\n"],"mappings":";;AAWA,SAAgBA,EACd,GACA,GACA;CACA,QAAmB;EACjB,IAAI,CAACC,EAAS,GAAG;EAEjB,IAAMC,IAASC,EAAY,MAAM,eAAe,cAAc,aACxDC,IAAQ,SAAS,cAAc,OAAO;EAG5C,AAFAA,EAAM,aAAa,uBAAuB,EAAE,GAC5C,EAAM,cAAc,wBAAwBF,EAAO,iBACnD,SAAS,KAAK,YAAYE,CAAK;EAE/B,IAAMC,IAAqB,SAAS,KAAK,MAAM;EAG/C,AAFA,SAAS,KAAK,MAAM,aAAa,QAEjCC,QAAgB;GAEd,AADAF,EAAM,OAAO,GACb,SAAS,KAAK,MAAM,aAAaC;EACnC,CAAC;CACH,CAAC;AACH"}

package/dist/components/resizable/index.d.ts

@@ -0,0 +1,4 @@
+export { ResizablePanelGroup } from './ResizablePanelGroup';
+export { ResizablePanel } from './ResizablePanel';
+export { ResizableHandle } from './ResizableHandle';
+export type { ResizableOrientation, ResizableSize, ResizableLayout, ResizablePanelHandle, ResizablePanelGroupProps, ResizablePanelProps, ResizableHandleProps, } from './resizable.types';

package/dist/components/resizable/index.js

@@ -0,0 +1,4 @@
+import { ResizablePanelGroup as e } from "./ResizablePanelGroup/ResizablePanelGroup.js";
+import { ResizablePanel as t } from "./ResizablePanel/ResizablePanel.js";
+import { ResizableHandle as n } from "./ResizableHandle/ResizableHandle.js";
+export { n as ResizableHandle, t as ResizablePanel, e as ResizablePanelGroup };

package/dist/components/resizable/resizable.collapse.d.ts

@@ -0,0 +1,27 @@
+import { ResizablePanelMeta } from './resizable.types';
+/**
+ * 折叠相关的决策与记忆。
+ *
+ * 单一职责：回答两个问题——"这次切换该折还是该展"（纯决策）与
+ * "展开时回到哪个尺寸"（记忆）。都不碰 store、不读信号，
+ * 决策只依赖相邻面板的 `collapsible` 与当前尺寸。
+ */
+export interface CollapseAction {
+    id: string;
+    action: "collapse" | "expand";
+}
+/**
+ * 分隔条上的 Enter/Space 该对谁做什么：
+ * 优先取相邻对里**前一个**可折叠面板，没有则取后一个；都不行则不动作。
+ */
+export declare function nextCollapseAction(adjacent: {
+    prev: ResizablePanelMeta;
+    next: ResizablePanelMeta;
+}, getSize: (id: string) => number): CollapseAction | undefined;
+export interface CollapseMemory {
+    /** 折叠前记下尺寸，供展开时还原 */
+    remember(id: string, size: number): void;
+    /** 取回记忆中的尺寸；没有记忆时用调用方给的兜底值 */
+    recall(id: string, fallback: number): number;
+}
+export declare function createCollapseMemory(): CollapseMemory;

package/dist/components/resizable/resizable.collapse.js

@@ -0,0 +1,24 @@
+import { isCollapsedSize as e } from "./resizable.constraints.js";
+//#region src/components/resizable/resizable.collapse.ts
+function t(t, n) {
+	let r = [t.prev, t.next].find((e) => e.collapsible());
+	if (r) return {
+		id: r.id,
+		action: e(r, n(r.id)) ? "expand" : "collapse"
+	};
+}
+function n() {
+	let e = /* @__PURE__ */ new Map();
+	return {
+		remember(t, n) {
+			e.set(t, n);
+		},
+		recall(t, n) {
+			return e.get(t) ?? n;
+		}
+	};
+}
+//#endregion
+export { n as createCollapseMemory, t as nextCollapseAction };
+
+//# sourceMappingURL=resizable.collapse.js.map

package/dist/components/resizable/resizable.collapse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizable.collapse.js","names":["nextCollapseAction","target","adjacent","meta","isCollapsedSize","getSize","createCollapseMemory","memory","id","size","fallback"],"sources":["../../../src/components/resizable/resizable.collapse.ts"],"sourcesContent":["import { isCollapsedSize } from \"./resizable.constraints\";\nimport type { ResizablePanelMeta } from \"./resizable.types\";\n\n/**\n * 折叠相关的决策与记忆。\n *\n * 单一职责：回答两个问题——\"这次切换该折还是该展\"（纯决策）与\n * \"展开时回到哪个尺寸\"（记忆）。都不碰 store、不读信号，\n * 决策只依赖相邻面板的 `collapsible` 与当前尺寸。\n */\n\nexport interface CollapseAction {\n  id: string;\n  action: \"collapse\" | \"expand\";\n}\n\n/**\n * 分隔条上的 Enter/Space 该对谁做什么：\n * 优先取相邻对里**前一个**可折叠面板，没有则取后一个；都不行则不动作。\n */\nexport function nextCollapseAction(\n  adjacent: { prev: ResizablePanelMeta; next: ResizablePanelMeta },\n  getSize: (id: string) => number,\n): CollapseAction | undefined {\n  const target = [adjacent.prev, adjacent.next].find((meta) =>\n    meta.collapsible(),\n  );\n  if (!target) return undefined;\n\n  return {\n    id: target.id,\n    action: isCollapsedSize(target, getSize(target.id)) ? \"expand\" : \"collapse\",\n  };\n}\n\nexport interface CollapseMemory {\n  /** 折叠前记下尺寸，供展开时还原 */\n  remember(id: string, size: number): void;\n  /** 取回记忆中的尺寸；没有记忆时用调用方给的兜底值 */\n  recall(id: string, fallback: number): number;\n}\n\nexport function createCollapseMemory(): CollapseMemory {\n  const memory = new Map<string, number>();\n\n  return {\n    remember(id, size) {\n      memory.set(id, size);\n    },\n    recall(id, fallback) {\n      return memory.get(id) ?? fallback;\n    },\n  };\n}\n"],"mappings":";;AAoBA,SAAgBA,EACd,GACA,GAC4B;CAC5B,IAAMC,IAAS,CAACC,EAAS,MAAMA,EAAS,IAAI,CAAC,CAAC,MAAM,MAClDC,EAAK,YAAY,CACnB;CACA,IAAKF,GAEL,OAAO;EACL,IAAIA,EAAO;EACX,QAAQG,EAAgBH,GAAQI,EAAQJ,EAAO,EAAE,CAAC,IAAI,WAAW;CACnE;AACF;AASA,SAAgBK,IAAuC;CACrD,IAAMC,oBAAS,IAAI,IAAoB;CAEvC,OAAO;EACL,SAAS,GAAI,GAAM;GACjB,EAAO,IAAIC,GAAIC,CAAI;EACrB;EACA,OAAO,GAAI,GAAU;GACnB,OAAOF,EAAO,IAAIC,CAAE,KAAKE;EAC3B;CACF;AACF"}

package/dist/components/resizable/resizable.commands.d.ts

@@ -0,0 +1,32 @@
+import { PanelRegistry } from './resizable.registry';
+import { PanelSizes } from './resizable.sizes';
+import { ResizablePanelMeta } from './resizable.types';
+export interface PanelCommandsContext {
+    /** 按 DOM 顺序排列的面板 */
+    metas: () => ResizablePanelMeta[];
+    registry: PanelRegistry;
+    sizes: PanelSizes;
+    /** 通知 + 持久化 */
+    commit: () => void;
+}
+export interface PanelCommands {
+    /** 折叠指定面板；不可折叠或已折叠时返回 false */
+    collapsePanel: (id: string) => boolean;
+    /** 展开指定面板（回到折叠前的尺寸，但不小于 minSize）；不可展开时返回 false */
+    expandPanel: (id: string) => boolean;
+    /** 命令式设置尺寸 */
+    setPanelSize: (id: string, size: number) => void;
+    /** 该面板当前是否处于折叠态 */
+    isPanelCollapsed: (id: string) => boolean;
+    /** 按分隔条解析出的相邻对，折叠或展开其中的可折叠面板 */
+    toggleHandleCollapse: (handleEl: HTMLElement) => void;
+}
+/**
+ * 面板的命令式尺寸操作（collapse / expand / setSize / 键盘切换）。
+ *
+ * 单一职责：把"命令"翻译成一次 `PanelSizes` 写入 + 一次 `commit`，
+ * 并维护"折叠前的尺寸"这份记忆（`resizable.collapse`）。
+ * 决策（该折还是该展）也来自 `resizable.collapse.nextCollapseAction`，
+ * 这里只负责执行与前后置校验。
+ */
+export declare function createPanelCommands(ctx: PanelCommandsContext): PanelCommands;

package/dist/components/resizable/resizable.commands.js

@@ -0,0 +1,40 @@
+import { isCollapsedSize as e } from "./resizable.constraints.js";
+import { createCollapseMemory as t, nextCollapseAction as n } from "./resizable.collapse.js";
+//#region src/components/resizable/resizable.commands.ts
+function r(r) {
+	let i = t(), a = (e) => r.metas().find((t) => t.id === e) ?? null, o = (t) => {
+		let n = a(t);
+		if (!n?.collapsible()) return !1;
+		let o = r.sizes.sizeOf(t);
+		return !e(n, o) && (i.remember(t, o), r.sizes.applyPanelTarget(n, n.collapsedSize()), r.commit(), !0);
+	}, s = (t) => {
+		let n = a(t);
+		if (!n?.collapsible()) return !1;
+		let o = r.sizes.sizeOf(t);
+		if (!e(n, o)) return !1;
+		let s = i.recall(t, n.minSize());
+		return r.sizes.applyPanelTarget(n, Math.max(s, n.minSize())), r.commit(), !0;
+	};
+	return {
+		collapsePanel: o,
+		expandPanel: s,
+		setPanelSize: (e, t) => {
+			let n = a(e);
+			n && (r.sizes.applyPanelTarget(n, t), r.commit());
+		},
+		isPanelCollapsed: (t) => {
+			let n = a(t);
+			return n ? e(n, r.sizes.sizeOf(t)) : !1;
+		},
+		toggleHandleCollapse: (e) => {
+			let t = r.registry.adjacent(e, r.sizes.sizeOf);
+			if (!t) return;
+			let i = n(t, r.sizes.sizeOf);
+			i && (i.action === "expand" ? s(i.id) : o(i.id));
+		}
+	};
+}
+//#endregion
+export { r as createPanelCommands };
+
+//# sourceMappingURL=resizable.commands.js.map

package/dist/components/resizable/resizable.commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizable.commands.js","names":["createPanelCommands","collapsedMemory","createCollapseMemory","findMeta","ctx","item","id","collapsePanel","meta","current","isCollapsedSize","expandPanel","remembered","size","adjacent","handleEl","decision","nextCollapseAction"],"sources":["../../../src/components/resizable/resizable.commands.ts"],"sourcesContent":["import { createCollapseMemory, nextCollapseAction } from \"./resizable.collapse\";\nimport { isCollapsedSize } from \"./resizable.constraints\";\nimport type { PanelRegistry } from \"./resizable.registry\";\nimport type { PanelSizes } from \"./resizable.sizes\";\nimport type { ResizablePanelMeta } from \"./resizable.types\";\n\nexport interface PanelCommandsContext {\n  /** 按 DOM 顺序排列的面板 */\n  metas: () => ResizablePanelMeta[];\n  registry: PanelRegistry;\n  sizes: PanelSizes;\n  /** 通知 + 持久化 */\n  commit: () => void;\n}\n\nexport interface PanelCommands {\n  /** 折叠指定面板；不可折叠或已折叠时返回 false */\n  collapsePanel: (id: string) => boolean;\n  /** 展开指定面板（回到折叠前的尺寸，但不小于 minSize）；不可展开时返回 false */\n  expandPanel: (id: string) => boolean;\n  /** 命令式设置尺寸 */\n  setPanelSize: (id: string, size: number) => void;\n  /** 该面板当前是否处于折叠态 */\n  isPanelCollapsed: (id: string) => boolean;\n  /** 按分隔条解析出的相邻对，折叠或展开其中的可折叠面板 */\n  toggleHandleCollapse: (handleEl: HTMLElement) => void;\n}\n\n/**\n * 面板的命令式尺寸操作（collapse / expand / setSize / 键盘切换）。\n *\n * 单一职责：把\"命令\"翻译成一次 `PanelSizes` 写入 + 一次 `commit`，\n * 并维护\"折叠前的尺寸\"这份记忆（`resizable.collapse`）。\n * 决策（该折还是该展）也来自 `resizable.collapse.nextCollapseAction`，\n * 这里只负责执行与前后置校验。\n */\nexport function createPanelCommands(ctx: PanelCommandsContext): PanelCommands {\n  const collapsedMemory = createCollapseMemory();\n\n  const findMeta = (id: string) =>\n    ctx.metas().find((item) => item.id === id) ?? null;\n\n  const collapsePanel = (id: string) => {\n    const meta = findMeta(id);\n    if (!meta?.collapsible()) return false;\n\n    const current = ctx.sizes.sizeOf(id);\n    if (isCollapsedSize(meta, current)) return false;\n\n    // 记下折叠前的尺寸，展开时回到这里（而不是 minSize）\n    collapsedMemory.remember(id, current);\n    ctx.sizes.applyPanelTarget(meta, meta.collapsedSize());\n    ctx.commit();\n    return true;\n  };\n\n  const expandPanel = (id: string) => {\n    const meta = findMeta(id);\n    if (!meta?.collapsible()) return false;\n\n    const current = ctx.sizes.sizeOf(id);\n    if (!isCollapsedSize(meta, current)) return false;\n\n    const remembered = collapsedMemory.recall(id, meta.minSize());\n    ctx.sizes.applyPanelTarget(meta, Math.max(remembered, meta.minSize()));\n    ctx.commit();\n    return true;\n  };\n\n  const setPanelSize = (id: string, size: number) => {\n    const meta = findMeta(id);\n    if (!meta) return;\n    ctx.sizes.applyPanelTarget(meta, size);\n    ctx.commit();\n  };\n\n  const isPanelCollapsed = (id: string) => {\n    const meta = findMeta(id);\n    return meta ? isCollapsedSize(meta, ctx.sizes.sizeOf(id)) : false;\n  };\n\n  const toggleHandleCollapse = (handleEl: HTMLElement) => {\n    const adjacent = ctx.registry.adjacent(handleEl, ctx.sizes.sizeOf);\n    if (!adjacent) return;\n\n    const decision = nextCollapseAction(adjacent, ctx.sizes.sizeOf);\n    if (!decision) return;\n\n    if (decision.action === \"expand\") expandPanel(decision.id);\n    else collapsePanel(decision.id);\n  };\n\n  return {\n    collapsePanel,\n    expandPanel,\n    setPanelSize,\n    isPanelCollapsed,\n    toggleHandleCollapse,\n  };\n}\n"],"mappings":";;;AAoCA,SAAgBA,EAAoB,GAA0C;CAC5E,IAAMC,IAAkBC,EAAqB,GAEvCC,KAAY,MAChBC,EAAI,MAAM,CAAC,CAAC,MAAM,MAASC,EAAK,OAAOC,CAAE,KAAK,MAE1CC,KAAiB,MAAe;EACpC,IAAMC,IAAOL,EAASG,CAAE;EACxB,IAAI,CAACE,GAAM,YAAY,GAAG,OAAO;EAEjC,IAAMC,IAAUL,EAAI,MAAM,OAAOE,CAAE;EAOnC,OANA,CAAII,EAAgBF,GAAMC,CAAO,MAGjCR,EAAgB,SAASK,GAAIG,CAAO,GACpCL,EAAI,MAAM,iBAAiBI,GAAMA,EAAK,cAAc,CAAC,GACrDJ,EAAI,OAAO,GACJ;CACT,GAEMO,KAAe,MAAe;EAClC,IAAMH,IAAOL,EAASG,CAAE;EACxB,IAAI,CAACE,GAAM,YAAY,GAAG,OAAO;EAEjC,IAAMC,IAAUL,EAAI,MAAM,OAAOE,CAAE;EACnC,IAAI,CAACI,EAAgBF,GAAMC,CAAO,GAAG,OAAO;EAE5C,IAAMG,IAAaX,EAAgB,OAAOK,GAAIE,EAAK,QAAQ,CAAC;EAG5D,OAFAJ,EAAI,MAAM,iBAAiBI,GAAM,KAAK,IAAII,GAAYJ,EAAK,QAAQ,CAAC,CAAC,GACrEJ,EAAI,OAAO,GACJ;CACT;CAyBA,OAAO;EACL;EACA;EACA,eA1BoB,GAAY,MAAiB;GACjD,IAAMI,IAAOL,EAASG,CAAE;GACxB,AAAKE,MACLJ,EAAI,MAAM,iBAAiBI,GAAMK,CAAI,GACrCT,EAAI,OAAO;EACb;EAsBE,mBApBwB,MAAe;GACvC,IAAMI,IAAOL,EAASG,CAAE;GACxB,OAAOE,IAAOE,EAAgBF,GAAMJ,EAAI,MAAM,OAAOE,CAAE,CAAC,IAAI;EAC9D;EAkBE,uBAhB4B,MAA0B;GACtD,IAAMQ,IAAWV,EAAI,SAAS,SAASW,GAAUX,EAAI,MAAM,MAAM;GACjE,IAAI,CAACU,GAAU;GAEf,IAAME,IAAWC,EAAmBH,GAAUV,EAAI,MAAM,MAAM;GAC9D,AAAKY,MAEDA,EAAS,WAAW,WAAUL,EAAYK,EAAS,EAAE,IACpDT,EAAcS,EAAS,EAAE;EAChC;CAQA;AACF"}

package/dist/components/resizable/resizable.constraints.d.ts

@@ -0,0 +1,23 @@
+import { PairConstraints } from './resizable.resize';
+import { ResizablePanelMeta } from './resizable.types';
+/**
+ * Resizable 的「约束代数」。
+ *
+ * 单一职责：把 panel 的响应式约束（min/max/collapsible/collapsedSize）摊平成
+ * 可以参与计算的数字与结构。不读信号以外的状态、不写 store、不碰 DOM，
+ * 因此拖拽边界、折叠判定、归一化边界都能单独断言。
+ */
+/**
+ * 拖拽实际能到的最小值：可折叠时是 `collapsedSize`（继续拖会吸附到折叠），
+ * 否则是 `minSize`。
+ */
+export declare function effectiveMin(meta: ResizablePanelMeta): number;
+/** 尺寸是否落在「已折叠」区间（含 EPSILON 容差，避免浮点误差来回抖动） */
+export declare function isCollapsedSize(meta: ResizablePanelMeta, size: number): boolean;
+/** 全部 panel 的 `[min, max]` 边界，顺序与注册顺序一致（归一化按此顺序） */
+export declare function constraintBounds(metas: readonly ResizablePanelMeta[]): {
+    min: number;
+    max: number;
+}[];
+/** 把一对相邻 panel 摊平成 `resolvePairSize` 需要的约束 */
+export declare function pairConstraintsOf(prev: ResizablePanelMeta, next: ResizablePanelMeta): PairConstraints;

package/dist/components/resizable/resizable.constraints.js

@@ -0,0 +1,32 @@
+import "./resizable.resize.js";
+//#region src/components/resizable/resizable.constraints.ts
+function e(e) {
+	return e.collapsible() ? e.collapsedSize() : e.minSize();
+}
+function t(e, t) {
+	return e.collapsible() && t <= e.collapsedSize() + .001;
+}
+function n(t) {
+	return t.map((t) => ({
+		min: e(t),
+		max: t.maxSize()
+	}));
+}
+function r(t, n) {
+	return {
+		prevMin: e(t),
+		prevMax: t.maxSize(),
+		prevCollapsible: t.collapsible(),
+		prevCollapsedSize: t.collapsedSize(),
+		prevFloor: t.minSize(),
+		nextMin: e(n),
+		nextMax: n.maxSize(),
+		nextCollapsible: n.collapsible(),
+		nextCollapsedSize: n.collapsedSize(),
+		nextFloor: n.minSize()
+	};
+}
+//#endregion
+export { n as constraintBounds, e as effectiveMin, t as isCollapsedSize, r as pairConstraintsOf };
+
+//# sourceMappingURL=resizable.constraints.js.map

package/dist/components/resizable/resizable.constraints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizable.constraints.js","names":["effectiveMin","meta","isCollapsedSize","size","constraintBounds","metas","pairConstraintsOf","prev","next"],"sources":["../../../src/components/resizable/resizable.constraints.ts"],"sourcesContent":["import { EPSILON, type PairConstraints } from \"./resizable.resize\";\nimport type { ResizablePanelMeta } from \"./resizable.types\";\n\n/**\n * Resizable 的「约束代数」。\n *\n * 单一职责：把 panel 的响应式约束（min/max/collapsible/collapsedSize）摊平成\n * 可以参与计算的数字与结构。不读信号以外的状态、不写 store、不碰 DOM，\n * 因此拖拽边界、折叠判定、归一化边界都能单独断言。\n */\n\n/**\n * 拖拽实际能到的最小值：可折叠时是 `collapsedSize`（继续拖会吸附到折叠），\n * 否则是 `minSize`。\n */\nexport function effectiveMin(meta: ResizablePanelMeta): number {\n  return meta.collapsible() ? meta.collapsedSize() : meta.minSize();\n}\n\n/** 尺寸是否落在「已折叠」区间（含 EPSILON 容差，避免浮点误差来回抖动） */\nexport function isCollapsedSize(\n  meta: ResizablePanelMeta,\n  size: number,\n): boolean {\n  return meta.collapsible() && size <= meta.collapsedSize() + EPSILON;\n}\n\n/** 全部 panel 的 `[min, max]` 边界，顺序与注册顺序一致（归一化按此顺序） */\nexport function constraintBounds(\n  metas: readonly ResizablePanelMeta[],\n): { min: number; max: number }[] {\n  return metas.map((meta) => ({\n    min: effectiveMin(meta),\n    max: meta.maxSize(),\n  }));\n}\n\n/** 把一对相邻 panel 摊平成 `resolvePairSize` 需要的约束 */\nexport function pairConstraintsOf(\n  prev: ResizablePanelMeta,\n  next: ResizablePanelMeta,\n): PairConstraints {\n  return {\n    prevMin: effectiveMin(prev),\n    prevMax: prev.maxSize(),\n    prevCollapsible: prev.collapsible(),\n    prevCollapsedSize: prev.collapsedSize(),\n    prevFloor: prev.minSize(),\n    nextMin: effectiveMin(next),\n    nextMax: next.maxSize(),\n    nextCollapsible: next.collapsible(),\n    nextCollapsedSize: next.collapsedSize(),\n    nextFloor: next.minSize(),\n  };\n}\n"],"mappings":";;AAeA,SAAgBA,EAAa,GAAkC;CAC7D,OAAOC,EAAK,YAAY,IAAIA,EAAK,cAAc,IAAIA,EAAK,QAAQ;AAClE;AAGA,SAAgBC,EACd,GACA,GACS;CACT,OAAOD,EAAK,YAAY,KAAKE,KAAQF,EAAK,cAAc,IAAA;AAC1D;AAGA,SAAgBG,EACd,GACgC;CAChC,OAAOC,EAAM,KAAK,OAAU;EAC1B,KAAKL,EAAaC,CAAI;EACtB,KAAKA,EAAK,QAAQ;CACpB,EAAE;AACJ;AAGA,SAAgBK,EACd,GACA,GACiB;CACjB,OAAO;EACL,SAASN,EAAaO,CAAI;EAC1B,SAASA,EAAK,QAAQ;EACtB,iBAAiBA,EAAK,YAAY;EAClC,mBAAmBA,EAAK,cAAc;EACtC,WAAWA,EAAK,QAAQ;EACxB,SAASP,EAAaQ,CAAI;EAC1B,SAASA,EAAK,QAAQ;EACtB,iBAAiBA,EAAK,YAAY;EAClC,mBAAmBA,EAAK,cAAc;EACtC,WAAWA,EAAK,QAAQ;CAC1B;AACF"}

package/dist/components/resizable/resizable.context.d.ts

@@ -0,0 +1,38 @@
+import { Accessor } from 'solid-js';
+import { ResizableOrientation, ResizablePanelMeta } from './resizable.types';
+interface AdjacentPanels {
+    prev: ResizablePanelMeta;
+    next: ResizablePanelMeta;
+    prevSize: number;
+    total: number;
+}
+export interface ResizablePanelGroupContextValue {
+    orientation: Accessor<ResizableOrientation>;
+    /** id -> 百分比;store 代理,按 id 读取可精确追踪 */
+    sizes: () => Record<string, number>;
+    groupElement: Accessor<HTMLElement | undefined>;
+    setGroupElement: (el: HTMLElement | undefined) => void;
+    dragging: Accessor<boolean>;
+    keyboardResizeBy: Accessor<number>;
+    registerPanel: (meta: ResizablePanelMeta) => () => void;
+    /** 拖拽/键盘:根据 handle 的相邻兄弟解析出前后两个 panel */
+    resolveAdjacent: (handleEl: HTMLElement) => AdjacentPanels | undefined;
+    setAdjacentSize: (handleEl: HTMLElement, targetPrevSize: number) => void;
+    nudgeAdjacent: (handleEl: HTMLElement, deltaPercent: number) => void;
+    toggleHandleCollapse: (handleEl: HTMLElement) => void;
+    /** 沿主轴的可拖拽长度(px),用于 px -> % 换算 */
+    groupSizePx: () => number;
+    isRtl: () => boolean;
+    beginDrag: () => void;
+    endDrag: () => void;
+    commitLayout: () => void;
+    /** 命令式 panel 操作 */
+    setPanelSize: (id: string, size: number) => void;
+    collapsePanel: (id: string) => boolean;
+    expandPanel: (id: string) => boolean;
+    isPanelCollapsed: (id: string) => boolean;
+    getPanelSize: (id: string) => number;
+}
+export declare const ResizablePanelGroupContext: import('solid-js').Context<ResizablePanelGroupContextValue | undefined>;
+export declare function useResizablePanelGroupContext(component: string): ResizablePanelGroupContextValue;
+export {};

package/dist/components/resizable/resizable.context.js

@@ -0,0 +1,12 @@
+import { createContext as e, useContext as t } from "solid-js";
+//#region src/components/resizable/resizable.context.ts
+var n = e();
+function r(e) {
+	let r = t(n);
+	if (!r) throw Error(`<${e}> 必须渲染在 <ResizablePanelGroup> 内部`);
+	return r;
+}
+//#endregion
+export { n as ResizablePanelGroupContext, r as useResizablePanelGroupContext };
+
+//# sourceMappingURL=resizable.context.js.map

package/dist/components/resizable/resizable.context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizable.context.js","names":["ResizablePanelGroupContext","createContext","useResizablePanelGroupContext","ctx","useContext","component"],"sources":["../../../src/components/resizable/resizable.context.ts"],"sourcesContent":["import { createContext, useContext, type Accessor } from \"solid-js\";\nimport type {\n  ResizableOrientation,\n  ResizablePanelMeta,\n} from \"./resizable.types\";\n\ninterface AdjacentPanels {\n  prev: ResizablePanelMeta;\n  next: ResizablePanelMeta;\n  prevSize: number;\n  total: number;\n}\n\nexport interface ResizablePanelGroupContextValue {\n  orientation: Accessor<ResizableOrientation>;\n  /** id -> 百分比;store 代理,按 id 读取可精确追踪 */\n  sizes: () => Record<string, number>;\n  groupElement: Accessor<HTMLElement | undefined>;\n  setGroupElement: (el: HTMLElement | undefined) => void;\n  dragging: Accessor<boolean>;\n  keyboardResizeBy: Accessor<number>;\n  registerPanel: (meta: ResizablePanelMeta) => () => void;\n\n  /** 拖拽/键盘:根据 handle 的相邻兄弟解析出前后两个 panel */\n  resolveAdjacent: (handleEl: HTMLElement) => AdjacentPanels | undefined;\n  setAdjacentSize: (handleEl: HTMLElement, targetPrevSize: number) => void;\n  nudgeAdjacent: (handleEl: HTMLElement, deltaPercent: number) => void;\n  toggleHandleCollapse: (handleEl: HTMLElement) => void;\n  /** 沿主轴的可拖拽长度(px),用于 px -> % 换算 */\n  groupSizePx: () => number;\n  isRtl: () => boolean;\n  beginDrag: () => void;\n  endDrag: () => void;\n  commitLayout: () => void;\n\n  /** 命令式 panel 操作 */\n  setPanelSize: (id: string, size: number) => void;\n  collapsePanel: (id: string) => boolean;\n  expandPanel: (id: string) => boolean;\n  isPanelCollapsed: (id: string) => boolean;\n  getPanelSize: (id: string) => number;\n}\n\nexport const ResizablePanelGroupContext =\n  createContext<ResizablePanelGroupContextValue>();\n\nexport function useResizablePanelGroupContext(\n  component: string,\n): ResizablePanelGroupContextValue {\n  const ctx = useContext(ResizablePanelGroupContext);\n  if (!ctx) {\n    throw new Error(`<${component}> 必须渲染在 <ResizablePanelGroup> 内部`);\n  }\n  return ctx;\n}\n"],"mappings":";;AA2CA,IAAaA,IACXC,EAA+C;AAEjD,SAAgBC,EACd,GACiC;CACjC,IAAMC,IAAMC,EAAWJ,CAA0B;CACjD,IAAI,CAACG,GACH,MAAU,MAAM,IAAIE,EAAU,iCAAiC;CAEjE,OAAOF;AACT"}

package/dist/components/resizable/resizable.lifecycle.d.ts

@@ -0,0 +1,35 @@
+import { PanelRegistry } from './resizable.registry';
+import { PanelSizes } from './resizable.sizes';
+import { ResizableLayout, ResizablePanelMeta } from './resizable.types';
+export interface PanelLifecycleContext {
+    /** 按 DOM 顺序排列的面板 */
+    metas: () => ResizablePanelMeta[];
+    registry: PanelRegistry;
+    sizes: PanelSizes;
+    /** 读取已持久化的布局 */
+    readSaved: () => ResizableLayout | undefined;
+    /** props 上传入的初始布局 */
+    defaultLayout: () => ResizableLayout | undefined;
+    /** 通知 + 持久化 */
+    commit: () => void;
+    /** 注册表发生变化（挂载/卸载）时的通知，用于让消费方重算 */
+    onRegistryChange: () => void;
+}
+export interface PanelLifecycle {
+    /** 注册面板并返回注销函数；首个面板挂载会在微任务里做一次初始化 */
+    registerPanel: (meta: ResizablePanelMeta) => () => void;
+    /** 首次布局：分配初始尺寸并归一化（SSR 与空列表下不动作） */
+    initialize: () => void;
+    /** 是否已经初始化过 */
+    isInitialized: () => boolean;
+}
+/**
+ * 面板的生命周期：注册、首帧初始化、以及"初始化之后动态新增面板"的尺寸分配。
+ *
+ * 单一职责：决定"什么时候算初始布局""新面板该拿多少"。初始分配委托
+ * `resizable.resize.distributeInitialSizes`，写入委托 `PanelSizes`。
+ *
+ * 为什么初始化要延后到微任务：面板是逐个挂载的，第一个面板挂载时后面几个还没注册，
+ * 若立刻算布局就会给第一个面板 100%，等其余面板挂载后再推翻重排，用户会看到跳动。
+ */
+export declare function createPanelLifecycle(ctx: PanelLifecycleContext): PanelLifecycle;

package/dist/components/resizable/resizable.lifecycle.js

@@ -0,0 +1,32 @@
+import { distributeInitialSizes as e } from "./resizable.resize.js";
+import { constraintBounds as t } from "./resizable.constraints.js";
+import { normalizeSizes as n } from "./resizable.utils.js";
+//#region src/components/resizable/resizable.lifecycle.ts
+function r(r) {
+	let i = !1, a = () => t(r.metas()), o = () => {
+		let t = r.metas(), n = r.readSaved() ?? r.defaultLayout();
+		return e(t.map((e) => e.id), n, t.map((e) => e.defaultSize));
+	}, s = () => {
+		i || typeof window < "u" && r.metas().length !== 0 && (i = !0, r.sizes.applyAll(n(o(), a()), !1), r.commit());
+	}, c = () => {
+		typeof window < "u" && queueMicrotask(() => {
+			i || s();
+		});
+	}, l = (e) => {
+		let t = r.metas(), i = t.map((n) => n.id === e.id ? n.defaultSize ?? 100 / t.length : r.sizes.sizeOf(n.id));
+		r.sizes.applyAll(n(i, a())), r.commit();
+	};
+	return {
+		initialize: s,
+		isInitialized: () => i,
+		registerPanel(e) {
+			return r.registry.add(e), r.onRegistryChange(), i ? r.sizes.store[e.id] === void 0 && l(e) : c(), () => {
+				r.registry.remove(e), r.onRegistryChange(), r.sizes.remove(e.id);
+			};
+		}
+	};
+}
+//#endregion
+export { r as createPanelLifecycle };
+
+//# sourceMappingURL=resizable.lifecycle.js.map

package/dist/components/resizable/resizable.lifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizable.lifecycle.js","names":["createPanelLifecycle","initialized","bounds","constraintBounds","ctx","buildInitial","list","saved","distributeInitialSizes","meta","initialize","normalizeSizes","scheduleInitialize","adoptNewPanel","raw","item"],"sources":["../../../src/components/resizable/resizable.lifecycle.ts"],"sourcesContent":["import { constraintBounds } from \"./resizable.constraints\";\nimport type { PanelRegistry } from \"./resizable.registry\";\nimport { distributeInitialSizes } from \"./resizable.resize\";\nimport type { PanelSizes } from \"./resizable.sizes\";\nimport type { ResizableLayout, ResizablePanelMeta } from \"./resizable.types\";\nimport { normalizeSizes } from \"./resizable.utils\";\n\nexport interface PanelLifecycleContext {\n  /** 按 DOM 顺序排列的面板 */\n  metas: () => ResizablePanelMeta[];\n  registry: PanelRegistry;\n  sizes: PanelSizes;\n  /** 读取已持久化的布局 */\n  readSaved: () => ResizableLayout | undefined;\n  /** props 上传入的初始布局 */\n  defaultLayout: () => ResizableLayout | undefined;\n  /** 通知 + 持久化 */\n  commit: () => void;\n  /** 注册表发生变化（挂载/卸载）时的通知，用于让消费方重算 */\n  onRegistryChange: () => void;\n}\n\nexport interface PanelLifecycle {\n  /** 注册面板并返回注销函数；首个面板挂载会在微任务里做一次初始化 */\n  registerPanel: (meta: ResizablePanelMeta) => () => void;\n  /** 首次布局：分配初始尺寸并归一化（SSR 与空列表下不动作） */\n  initialize: () => void;\n  /** 是否已经初始化过 */\n  isInitialized: () => boolean;\n}\n\n/**\n * 面板的生命周期：注册、首帧初始化、以及\"初始化之后动态新增面板\"的尺寸分配。\n *\n * 单一职责：决定\"什么时候算初始布局\"\"新面板该拿多少\"。初始分配委托\n * `resizable.resize.distributeInitialSizes`，写入委托 `PanelSizes`。\n *\n * 为什么初始化要延后到微任务：面板是逐个挂载的，第一个面板挂载时后面几个还没注册，\n * 若立刻算布局就会给第一个面板 100%，等其余面板挂载后再推翻重排，用户会看到跳动。\n */\nexport function createPanelLifecycle(\n  ctx: PanelLifecycleContext,\n): PanelLifecycle {\n  let initialized = false;\n\n  const bounds = () => constraintBounds(ctx.metas());\n\n  const buildInitial = (): number[] => {\n    const list = ctx.metas();\n    const saved = ctx.readSaved() ?? ctx.defaultLayout();\n    return distributeInitialSizes(\n      list.map((meta) => meta.id),\n      saved,\n      list.map((meta) => meta.defaultSize),\n    );\n  };\n\n  const initialize = () => {\n    if (initialized) return;\n    // SSR 不计算布局：首屏由 Panel 的 defaultSize fallback 撑起，客户端再归一化\n    if (typeof window === \"undefined\") return;\n    if (ctx.metas().length === 0) return;\n\n    initialized = true;\n    ctx.sizes.applyAll(normalizeSizes(buildInitial(), bounds()), false);\n    ctx.commit();\n  };\n\n  const scheduleInitialize = () => {\n    if (typeof window === \"undefined\") return;\n    queueMicrotask(() => {\n      if (!initialized) initialize();\n    });\n  };\n\n  /** 初始化之后新增的面板：给它默认尺寸，并把其它面板等比压回 100 */\n  const adoptNewPanel = (meta: ResizablePanelMeta) => {\n    const list = ctx.metas();\n    const raw = list.map((item) =>\n      item.id === meta.id\n        ? (item.defaultSize ?? 100 / list.length)\n        : ctx.sizes.sizeOf(item.id),\n    );\n    ctx.sizes.applyAll(normalizeSizes(raw, bounds()));\n    ctx.commit();\n  };\n\n  return {\n    initialize,\n    isInitialized: () => initialized,\n    registerPanel(meta) {\n      ctx.registry.add(meta);\n      ctx.onRegistryChange();\n\n      if (!initialized) {\n        scheduleInitialize();\n      } else if (ctx.sizes.store[meta.id] === undefined) {\n        adoptNewPanel(meta);\n      }\n\n      return () => {\n        ctx.registry.remove(meta);\n        ctx.onRegistryChange();\n        ctx.sizes.remove(meta.id);\n      };\n    },\n  };\n}\n"],"mappings":";;;;AAwCA,SAAgBA,EACd,GACgB;CAChB,IAAIC,IAAc,IAEZC,UAAeC,EAAiBC,EAAI,MAAM,CAAC,GAE3CC,UAA+B;EACnC,IAAMC,IAAOF,EAAI,MAAM,GACjBG,IAAQH,EAAI,UAAU,KAAKA,EAAI,cAAc;EACnD,OAAOI,EACLF,EAAK,KAAK,MAASG,EAAK,EAAE,GAC1BF,GACAD,EAAK,KAAK,MAASG,EAAK,WAAW,CACrC;CACF,GAEMC,UAAmB;EACvB,AAAIT,KAEA,OAAO,SAAW,OAClBG,EAAI,MAAM,CAAC,CAAC,WAAW,MAE3B,IAAc,IACdA,EAAI,MAAM,SAASO,EAAeN,EAAa,GAAGH,EAAO,CAAC,GAAG,EAAK,GAClEE,EAAI,OAAO;CACb,GAEMQ,UAA2B;EAC/B,AAAI,OAAO,SAAW,OACtB,qBAAqB;GACnB,AAAKX,KAAaS,EAAW;EAC/B,CAAC;CACH,GAGMG,KAAiB,MAA6B;EAClD,IAAMP,IAAOF,EAAI,MAAM,GACjBU,IAAMR,EAAK,KAAK,MACpBS,EAAK,OAAON,EAAK,KACZM,EAAK,eAAe,MAAMT,EAAK,SAChCF,EAAI,MAAM,OAAOW,EAAK,EAAE,CAC9B;EAEA,AADAX,EAAI,MAAM,SAASO,EAAeG,GAAKZ,EAAO,CAAC,CAAC,GAChDE,EAAI,OAAO;CACb;CAEA,OAAO;EACL;EACA,qBAAqBH;EACrB,cAAc,GAAM;GAUlB,OATAG,EAAI,SAAS,IAAIK,CAAI,GACrBL,EAAI,iBAAiB,GAEhBH,IAEMG,EAAI,MAAM,MAAMK,EAAK,QAAQ,KAAA,KACtCI,EAAcJ,CAAI,IAFlBG,EAAmB,SAKR;IAGX,AAFAR,EAAI,SAAS,OAAOK,CAAI,GACxBL,EAAI,iBAAiB,GACrBA,EAAI,MAAM,OAAOK,EAAK,EAAE;GAC1B;EACF;CACF;AACF"}

package/dist/components/resizable/resizable.registry.d.ts

@@ -0,0 +1,31 @@
+import { ResizablePanelMeta } from './resizable.types';
+export interface AdjacentPanels {
+    prev: ResizablePanelMeta;
+    next: ResizablePanelMeta;
+    /** 前一个面板的当前尺寸 */
+    prevSize: number;
+    /** 相邻两者尺寸之和（拖拽时保持不变的部分） */
+    total: number;
+}
+export interface PanelRegistry {
+    /** 注册面板：注册顺序即渲染顺序 */
+    add(meta: ResizablePanelMeta): void;
+    remove(meta: ResizablePanelMeta): void;
+    /** 已注册面板，按注册顺序（跳过已卸载的空位） */
+    ordered(): ResizablePanelMeta[];
+    /** 句柄两侧最近的已注册面板，中间的非面板节点（如把手装饰）会被跳过 */
+    adjacent(handleEl: HTMLElement, getSize: (id: string) => number): AdjacentPanels | undefined;
+    /** 某个面板在注册顺序里的前后邻居 */
+    neighbors(meta: ResizablePanelMeta): {
+        prev: ResizablePanelMeta | undefined;
+        next: ResizablePanelMeta | undefined;
+    };
+}
+/**
+ * Resizable 的面板注册表。
+ *
+ * 单一职责：维护「元素 → meta」与「注册顺序」，并据此解析相邻关系。
+ * 它不持有尺寸（尺寸通过 `getSize` 注入）、不写 store、不触发回调，
+ * 因此相邻解析可以脱离布局引擎直接断言。
+ */
+export declare function createPanelRegistry(): PanelRegistry;

package/dist/components/resizable/resizable.registry.js

@@ -0,0 +1,38 @@
+//#region src/components/resizable/resizable.registry.ts
+function e() {
+	let e = /* @__PURE__ */ new Map(), t = [];
+	return {
+		add(n) {
+			e.set(n.element, n), t = [...t, n.element];
+		},
+		remove(n) {
+			e.delete(n.element), t = t.filter((e) => e !== n.element);
+		},
+		ordered: () => t.map((t) => e.get(t)).filter((e) => !!e),
+		adjacent(t, n) {
+			let r = t.previousElementSibling;
+			for (; r && !e.has(r);) r = r.previousElementSibling;
+			let i = t.nextElementSibling;
+			for (; i && !e.has(i);) i = i.nextElementSibling;
+			if (!r || !i) return;
+			let a = e.get(r), o = e.get(i), s = n(a.id);
+			return {
+				prev: a,
+				next: o,
+				prevSize: s,
+				total: s + n(o.id)
+			};
+		},
+		neighbors(n) {
+			let r = t.indexOf(n.element), i = t[r + 1], a = t[r - 1];
+			return {
+				prev: a ? e.get(a) : void 0,
+				next: i ? e.get(i) : void 0
+			};
+		}
+	};
+}
+//#endregion
+export { e as createPanelRegistry };
+
+//# sourceMappingURL=resizable.registry.js.map

package/dist/components/resizable/resizable.registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizable.registry.js","names":["createPanelRegistry","metas","order","meta","element","prevEl","handleEl","nextEl","prev","next","prevSize","getSize","index","nextElement","prevElement"],"sources":["../../../src/components/resizable/resizable.registry.ts"],"sourcesContent":["import type { ResizablePanelMeta } from \"./resizable.types\";\n\nexport interface AdjacentPanels {\n  prev: ResizablePanelMeta;\n  next: ResizablePanelMeta;\n  /** 前一个面板的当前尺寸 */\n  prevSize: number;\n  /** 相邻两者尺寸之和（拖拽时保持不变的部分） */\n  total: number;\n}\n\nexport interface PanelRegistry {\n  /** 注册面板：注册顺序即渲染顺序 */\n  add(meta: ResizablePanelMeta): void;\n  remove(meta: ResizablePanelMeta): void;\n  /** 已注册面板，按注册顺序（跳过已卸载的空位） */\n  ordered(): ResizablePanelMeta[];\n  /** 句柄两侧最近的已注册面板，中间的非面板节点（如把手装饰）会被跳过 */\n  adjacent(\n    handleEl: HTMLElement,\n    getSize: (id: string) => number,\n  ): AdjacentPanels | undefined;\n  /** 某个面板在注册顺序里的前后邻居 */\n  neighbors(meta: ResizablePanelMeta): {\n    prev: ResizablePanelMeta | undefined;\n    next: ResizablePanelMeta | undefined;\n  };\n}\n\n/**\n * Resizable 的面板注册表。\n *\n * 单一职责：维护「元素 → meta」与「注册顺序」，并据此解析相邻关系。\n * 它不持有尺寸（尺寸通过 `getSize` 注入）、不写 store、不触发回调，\n * 因此相邻解析可以脱离布局引擎直接断言。\n */\nexport function createPanelRegistry(): PanelRegistry {\n  const metas = new Map<HTMLElement, ResizablePanelMeta>();\n  let order: HTMLElement[] = [];\n\n  const ordered = (): ResizablePanelMeta[] =>\n    order\n      .map((element) => metas.get(element))\n      .filter((meta): meta is ResizablePanelMeta => !!meta);\n\n  return {\n    add(meta) {\n      metas.set(meta.element, meta);\n      order = [...order, meta.element];\n    },\n    remove(meta) {\n      metas.delete(meta.element);\n      order = order.filter((element) => element !== meta.element);\n    },\n    ordered,\n    adjacent(handleEl, getSize) {\n      let prevEl = handleEl.previousElementSibling as HTMLElement | null;\n      while (prevEl && !metas.has(prevEl)) {\n        prevEl = prevEl.previousElementSibling as HTMLElement | null;\n      }\n      let nextEl = handleEl.nextElementSibling as HTMLElement | null;\n      while (nextEl && !metas.has(nextEl)) {\n        nextEl = nextEl.nextElementSibling as HTMLElement | null;\n      }\n      if (!prevEl || !nextEl) return undefined;\n\n      // 循环只在「已注册」的元素上停下，因此这里必然命中\n      const prev = metas.get(prevEl)!;\n      const next = metas.get(nextEl)!;\n\n      const prevSize = getSize(prev.id);\n      const nextSize = getSize(next.id);\n      return { prev, next, prevSize, total: prevSize + nextSize };\n    },\n    neighbors(meta) {\n      const index = order.indexOf(meta.element);\n      const nextElement = order[index + 1];\n      const prevElement = order[index - 1];\n      return {\n        prev: prevElement ? metas.get(prevElement) : undefined,\n        next: nextElement ? metas.get(nextElement) : undefined,\n      };\n    },\n  };\n}\n"],"mappings":";AAoCA,SAAgBA,IAAqC;CACnD,IAAMC,oBAAQ,IAAI,IAAqC,GACnDC,IAAuB,CAAC;CAO5B,OAAO;EACL,IAAI,GAAM;GAER,AADAD,EAAM,IAAIE,EAAK,SAASA,CAAI,GAC5B,IAAQ,CAAC,GAAGD,GAAOC,EAAK,OAAO;EACjC;EACA,OAAO,GAAM;GAEX,AADAF,EAAM,OAAOE,EAAK,OAAO,GACzB,IAAQD,EAAM,QAAQ,MAAYE,MAAYD,EAAK,OAAO;EAC5D;EACA,eAbAD,EACG,KAAK,MAAYD,EAAM,IAAIG,CAAO,CAAC,CAAC,CACpC,QAAQ,MAAqC,CAAC,CAACD,CAAI;EAYtD,SAAS,GAAU,GAAS;GAC1B,IAAIE,IAASC,EAAS;GACtB,OAAOD,KAAU,CAACJ,EAAM,IAAII,CAAM,IAChC,IAASA,EAAO;GAElB,IAAIE,IAASD,EAAS;GACtB,OAAOC,KAAU,CAACN,EAAM,IAAIM,CAAM,IAChC,IAASA,EAAO;GAElB,IAAI,CAACF,KAAU,CAACE,GAAQ;GAGxB,IAAMC,IAAOP,EAAM,IAAII,CAAM,GACvBI,IAAOR,EAAM,IAAIM,CAAM,GAEvBG,IAAWC,EAAQH,EAAK,EAAE;GAEhC,OAAO;IAAE;IAAM;IAAM;IAAU,OAAOE,IADrBC,EAAQF,EAAK,EACmB;GAAS;EAC5D;EACA,UAAU,GAAM;GACd,IAAMG,IAAQV,EAAM,QAAQC,EAAK,OAAO,GAClCU,IAAcX,EAAMU,IAAQ,IAC5BE,IAAcZ,EAAMU,IAAQ;GAClC,OAAO;IACL,MAAME,IAAcb,EAAM,IAAIa,CAAW,IAAI,KAAA;IAC7C,MAAMD,IAAcZ,EAAM,IAAIY,CAAW,IAAI,KAAA;GAC/C;EACF;CACF;AACF"}

package/dist/components/resizable/resizable.reporting.d.ts

@@ -0,0 +1,36 @@
+import { PersistContext } from './resizable.storage';
+import { ResizableLayout, ResizablePanelMeta } from './resizable.types';
+export interface LayoutReportingContext {
+    /** 按 DOM 顺序排列的面板元数据 */
+    metas: () => readonly ResizablePanelMeta[];
+    /** 读取某个面板当前的百分比尺寸 */
+    sizeOf: (id: string) => number;
+    /** 布局变化回调（拖拽的每一帧都会调用） */
+    onLayoutChange: (layout: ResizableLayout) => void;
+    /** 持久化上下文（autoSaveId + storage） */
+    persist: () => PersistContext;
+}
+export interface LayoutReporting {
+    /** 把 store 里的尺寸整理成对外的布局快照 */
+    snapshot: () => ResizableLayout;
+    /** 只通知布局变化，不写 storage（拖拽的每一帧） */
+    notify: () => void;
+    /** 通知 + 持久化（离散操作与拖拽结束） */
+    commit: () => void;
+    /** 读回已保存的布局 */
+    readSaved: () => ResizableLayout | undefined;
+    /**
+     * 上报单个面板的尺寸变化：
+     * 始终回调 `onResize`；可折叠面板还会在"折叠 ⇄ 展开"越过阈值时报 `onCollapse` /
+     * `onExpand`，普通尺寸变化不触发这两个回调。
+     */
+    reportSizeChange: (meta: ResizablePanelMeta, oldSize: number, newSize: number) => void;
+}
+/**
+ * 布局的对外汇报与持久化。
+ *
+ * 单一职责：把内部的百分比 store 翻译成对外的 `onLayoutChange` 回调、
+ * 尺寸/折叠/展开的通知，以及 `autoSaveId` 驱动的持久化。
+ * 不写 store、不做约束求解——只管"告诉外面发生了什么"。
+ */
+export declare function createLayoutReporting(ctx: LayoutReportingContext): LayoutReporting;

package/dist/components/resizable/resizable.reporting.js

@@ -0,0 +1,33 @@
+import { isCollapsedSize as e } from "./resizable.constraints.js";
+import { roundPercent as t } from "./resizable.utils.js";
+import { persistLayout as n, readSavedLayout as r } from "./resizable.storage.js";
+//#region src/components/resizable/resizable.reporting.ts
+function i(i) {
+	let a = () => {
+		let e = {};
+		for (let n of i.metas()) e[n.id] = t(i.sizeOf(n.id));
+		return e;
+	};
+	return {
+		snapshot: a,
+		notify() {
+			i.onLayoutChange(a());
+		},
+		commit() {
+			let e = a();
+			i.onLayoutChange(e), n(i.persist(), e);
+		},
+		readSaved() {
+			return r(i.persist());
+		},
+		reportSizeChange(n, r, i) {
+			if (n.onResize?.(t(i)), !n.collapsible()) return;
+			let a = e(n, r), o = e(n, i);
+			!a && o ? n.onCollapse?.() : a && !o && n.onExpand?.();
+		}
+	};
+}
+//#endregion
+export { i as createLayoutReporting };
+
+//# sourceMappingURL=resizable.reporting.js.map

package/dist/components/resizable/resizable.reporting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resizable.reporting.js","names":["createLayoutReporting","snapshot","result","meta","ctx","roundPercent","next","persistLayout","readSavedLayout","newSize","was","isCollapsedSize","oldSize","now"],"sources":["../../../src/components/resizable/resizable.reporting.ts"],"sourcesContent":["import { isCollapsedSize } from \"./resizable.constraints\";\nimport {\n  persistLayout,\n  readSavedLayout,\n  type PersistContext,\n} from \"./resizable.storage\";\nimport type { ResizableLayout, ResizablePanelMeta } from \"./resizable.types\";\nimport { roundPercent } from \"./resizable.utils\";\n\nexport interface LayoutReportingContext {\n  /** 按 DOM 顺序排列的面板元数据 */\n  metas: () => readonly ResizablePanelMeta[];\n  /** 读取某个面板当前的百分比尺寸 */\n  sizeOf: (id: string) => number;\n  /** 布局变化回调（拖拽的每一帧都会调用） */\n  onLayoutChange: (layout: ResizableLayout) => void;\n  /** 持久化上下文（autoSaveId + storage） */\n  persist: () => PersistContext;\n}\n\nexport interface LayoutReporting {\n  /** 把 store 里的尺寸整理成对外的布局快照 */\n  snapshot: () => ResizableLayout;\n  /** 只通知布局变化，不写 storage（拖拽的每一帧） */\n  notify: () => void;\n  /** 通知 + 持久化（离散操作与拖拽结束） */\n  commit: () => void;\n  /** 读回已保存的布局 */\n  readSaved: () => ResizableLayout | undefined;\n  /**\n   * 上报单个面板的尺寸变化：\n   * 始终回调 `onResize`；可折叠面板还会在\"折叠 ⇄ 展开\"越过阈值时报 `onCollapse` /\n   * `onExpand`，普通尺寸变化不触发这两个回调。\n   */\n  reportSizeChange: (\n    meta: ResizablePanelMeta,\n    oldSize: number,\n    newSize: number,\n  ) => void;\n}\n\n/**\n * 布局的对外汇报与持久化。\n *\n * 单一职责：把内部的百分比 store 翻译成对外的 `onLayoutChange` 回调、\n * 尺寸/折叠/展开的通知，以及 `autoSaveId` 驱动的持久化。\n * 不写 store、不做约束求解——只管\"告诉外面发生了什么\"。\n */\nexport function createLayoutReporting(\n  ctx: LayoutReportingContext,\n): LayoutReporting {\n  const snapshot = (): ResizableLayout => {\n    const result: ResizableLayout = {};\n    for (const meta of ctx.metas()) {\n      result[meta.id] = roundPercent(ctx.sizeOf(meta.id));\n    }\n    return result;\n  };\n\n  return {\n    snapshot,\n    notify() {\n      ctx.onLayoutChange(snapshot());\n    },\n    commit() {\n      const next = snapshot();\n      ctx.onLayoutChange(next);\n      persistLayout(ctx.persist(), next);\n    },\n    readSaved() {\n      return readSavedLayout(ctx.persist());\n    },\n    reportSizeChange(meta, oldSize, newSize) {\n      meta.onResize?.(roundPercent(newSize));\n      if (!meta.collapsible()) return;\n\n      const was = isCollapsedSize(meta, oldSize);\n      const now = isCollapsedSize(meta, newSize);\n      if (!was && now) meta.onCollapse?.();\n      else if (was && !now) meta.onExpand?.();\n    },\n  };\n}\n"],"mappings":";;;;AAgDA,SAAgBA,EACd,GACiB;CACjB,IAAMC,UAAkC;EACtC,IAAMC,IAA0B,CAAC;EACjC,KAAK,IAAMC,KAAQC,EAAI,MAAM,GAC3B,EAAOD,EAAK,MAAME,EAAaD,EAAI,OAAOD,EAAK,EAAE,CAAC;EAEpD,OAAOD;CACT;CAEA,OAAO;EACL;EACA,SAAS;GACP,EAAI,eAAeD,EAAS,CAAC;EAC/B;EACA,SAAS;GACP,IAAMK,IAAOL,EAAS;GAEtB,AADAG,EAAI,eAAeE,CAAI,GACvBC,EAAcH,EAAI,QAAQ,GAAGE,CAAI;EACnC;EACA,YAAY;GACV,OAAOE,EAAgBJ,EAAI,QAAQ,CAAC;EACtC;EACA,iBAAiB,GAAM,GAAS,GAAS;GAEvC,IADAD,EAAK,WAAWE,EAAaI,CAAO,CAAC,GACjC,CAACN,EAAK,YAAY,GAAG;GAEzB,IAAMO,IAAMC,EAAgBR,GAAMS,CAAO,GACnCC,IAAMF,EAAgBR,GAAMM,CAAO;GACzC,AAAI,CAACC,KAAOG,IAAKV,EAAK,aAAa,IAC1BO,KAAO,CAACG,KAAKV,EAAK,WAAW;EACxC;CACF;AACF"}

package/dist/components/resizable/resizable.resize.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Resizable 的相邻面板尺寸算法。
+ *
+ * 单一职责：给定「一对相邻面板」的约束，算出拖动后的两个尺寸。
+ * 不碰 store、不读 DOM，因此 min / max / collapsible 吸附的每个分支都可独立单测。
+ */
+/** 浮点比较容差（对齐上游语义） */
+export declare const EPSILON = 0.001;
+/** 一对相邻面板的约束 */
+export interface PairConstraints {
+    /** 前一个面板拖动能到的最小值（可折叠时是 collapsedSize） */
+    prevMin: number;
+    prevMax: number;
+    prevCollapsible: boolean;
+    /** 折叠态尺寸（仅 `prevCollapsible` 时有意义） */
+    prevCollapsedSize: number;
+    /** 非折叠时拖动能到的最小值 */
+    prevFloor: number;
+    nextMin: number;
+    nextMax: number;
+    nextCollapsible: boolean;
+    nextCollapsedSize: number;
+    nextFloor: number;
+}
+/**
+ * 把目标尺寸夹到「两个面板的可行区间」内。
+ * 下界取「prev 自己的最小值」与「total 减去 next 最大值」的较大者；
+ * 上界取「prev 最大值」与「total 减去 next 最小值」的较小者。
+ */
+export declare function pairBounds(constraints: PairConstraints, total: number): {
+    lo: number;
+    hi: number;
+};
+/**
+ * 计算拖动后「前一个面板」的最终尺寸。
+ *
+ * 步骤：夹到可行区间 → 对 prev 做折叠吸附 → 对 next 做折叠吸附 → 再夹一次
+ * （吸附可能让尺寸越界）。返回的 `next` 永远等于 `total - prev`，因此两者之和守恒。
+ */
+export declare function resolvePairSize(constraints: PairConstraints, targetPrev: number, total: number): number;
+/**
+ * 计算面板的初始尺寸。
+ *
+ * 规则：优先用 `saved[id]`，否则用面板自己的 `defaultSize`；
+ * 没有指定尺寸的面板平分剩余空间（剩余为负时按 0 分）。
+ */
+export declare function distributeInitialSizes(ids: string[], saved: Record<string, number> | undefined, defaults: Array<number | undefined>): number[];