ropav 0.4.0 → 0.6.0

package/dist/components/splitter/splitter.state.js

@@ -0,0 +1,322 @@
+import { sortByDocumentOrder } from "../../utils/document-order.js";
+import { calculateFlexSizes, getMaxSize, getMinSize, isStaticSize } from "../../utils/flex-sizing.js";
+import { computed, shallowRef, toValue } from "vue";
+//#region src/components/splitter/splitter.state.ts
+var PERCENT_UNIT = /%$/;
+var FRACTION_UNIT = /fr$/;
+/** Which family a declared size belongs to, so a drag can write its result back in the same one. */
+var unitOf = (size) => {
+	if (size == null) return "fraction";
+	if (typeof size === "number") return "pixels";
+	if (PERCENT_UNIT.test(size)) return "percent";
+	if (FRACTION_UNIT.test(size)) return "fraction";
+	return isStaticSize(size) ? "pixels" : "fraction";
+};
+/** Trim the float a division leaves behind, without pinning the value to whole pixels. */
+var round = (value) => Number(value.toFixed(4));
+var isSameLayout = (a, b) => a.length === b.length && a.every((size, index) => size === b[index]);
+var isSameSet = (a, b) => {
+	if (a.size !== b.size) return false;
+	for (const key of a) if (!b.has(key)) return false;
+	return true;
+};
+var registry = () => {
+	const items = /* @__PURE__ */ new Map();
+	const version = shallowRef(0);
+	return {
+		get: (key) => {
+			return items.get(key);
+		},
+		keys: computed(() => {
+			return sortByDocumentOrder([...items.entries()], ([, meta]) => meta.element()).map(([key]) => key);
+		}),
+		register: (key, meta) => {
+			items.set(key, meta);
+			version.value += 1;
+			return () => {
+				if (items.get(key) === meta) {
+					items.delete(key);
+					version.value += 1;
+				}
+			};
+		}
+	};
+};
+var useSplitterState = (options) => {
+	const panels = registry();
+	const handles = registry();
+	const containerSize = shallowRef(0);
+	const resizingHandle = shallowRef(null);
+	const stored = shallowRef(/* @__PURE__ */ new Map());
+	const collapsed = shallowRef(/* @__PURE__ */ new Set());
+	/** What a collapsible panel held before it shut, so re-opening returns it there. */
+	const remembered = /* @__PURE__ */ new Map();
+	const orientation = computed(() => toValue(options.orientation) ?? "horizontal");
+	const isDisabled = computed(() => toValue(options.isDisabled) ?? false);
+	const isControlled = computed(() => toValue(options.sizes) !== void 0);
+	const handleTotal = computed(() => handles.keys.value.reduce((total, key) => total + (handles.get(key)?.size() ?? 0), 0));
+	const availableSize = computed(() => Math.max(0, containerSize.value - handleTotal.value));
+	/** The declared size the layout should use for a panel, before the solver resolves it. */
+	const declaredOf = (key, index) => {
+		const panel = panels.get(key);
+		if (!panel) return void 0;
+		if (collapsed.value.has(key)) return panel.collapsedSize() ?? 0;
+		const controlled = toValue(options.sizes)?.[index];
+		if (controlled !== void 0) return controlled;
+		return stored.value.get(key) ?? panel.size() ?? toValue(options.defaultSizes)?.[index] ?? panel.defaultSize();
+	};
+	const definitionsOf = () => panels.keys.value.map((key, index) => {
+		const panel = panels.get(key);
+		const isShut = collapsed.value.has(key);
+		return {
+			defaultSize: panel.defaultSize(),
+			maxSize: isShut ? void 0 : panel.maxSize(),
+			minSize: isShut ? 0 : panel.minSize(),
+			size: declaredOf(key, index)
+		};
+	});
+	const layout = computed(() => {
+		const available = availableSize.value;
+		if (available <= 0 || panels.keys.value.length === 0) return [];
+		return calculateFlexSizes(available, definitionsOf(), () => "1fr", () => 0);
+	});
+	const indexOf = (key) => panels.keys.value.indexOf(key);
+	const getPanelSize = (key) => layout.value[indexOf(key)] ?? 0;
+	const boundsOf = (index) => {
+		const panel = panels.get(panels.keys.value[index]);
+		const available = availableSize.value;
+		const min = getMinSize(panel.minSize(), available);
+		const shut = panel.isCollapsible() ? getMinSize(panel.collapsedSize() ?? 0, available) : min;
+		return {
+			floor: Math.min(shut, min),
+			isCollapsible: panel.isCollapsible(),
+			max: getMaxSize(panel.maxSize(), available),
+			min
+		};
+	};
+	/**
+	* The nearest size a panel may legally hold.
+	*
+	* A collapsible panel has a gap in its range — everything between its collapsed size and its
+	* minimum is unreachable — so a size that lands in the gap snaps to whichever end is nearer.
+	* The midpoint is the threshold, which needs no constant of its own and scales with whatever
+	* minimum the caller chose.
+	*/
+	const legalize = (index, intended) => {
+		const { floor, isCollapsible, max, min } = boundsOf(index);
+		if (intended > max) return max;
+		if (!isCollapsible) return Math.max(intended, min);
+		if (intended >= min) return intended;
+		return intended < (floor + min) / 2 ? floor : min;
+	};
+	/**
+	* Move the edge at `handleIndex` by `delta`, taking from one side and giving it to the other.
+	*
+	* The shrinking side cascades: a neighbour already sitting on its floor is walked past, so a
+	* three-panel group keeps responding once the middle panel is spent. The growing side
+	* deliberately does not, because spreading growth outward would move a handle nobody touched.
+	*/
+	const resolveDelta = (base, handleIndex, delta) => {
+		if (delta === 0) return [...base];
+		const growing = delta > 0 ? handleIndex : handleIndex + 1;
+		const step = delta > 0 ? 1 : -1;
+		const first = delta > 0 ? handleIndex + 1 : handleIndex;
+		const release = (demand) => {
+			const next = [...base];
+			let taken = 0;
+			for (let i = first; i >= 0 && i < base.length && taken < demand; i += step) {
+				const intended = base[i] - (demand - taken);
+				const landing = legalize(i, intended);
+				const give = base[i] - landing;
+				if (give > 0) {
+					next[i] = landing;
+					taken += give;
+				}
+			}
+			return {
+				next,
+				taken
+			};
+		};
+		let released = release(Math.abs(delta));
+		let applied = legalize(growing, base[growing] + released.taken) - base[growing];
+		if (round(applied) !== round(released.taken)) {
+			released = release(Math.max(applied, 0));
+			applied = legalize(growing, base[growing] + released.taken) - base[growing];
+		}
+		if (round(applied) > round(released.taken)) return [...base];
+		const next = released.next;
+		next[growing] = base[growing] + applied;
+		return next;
+	};
+	/** Write pixel sizes back in the unit each panel declared, so intent survives a resize. */
+	const toDeclared = (pixels) => {
+		const keys = panels.keys.value;
+		const available = availableSize.value;
+		const units = keys.map((key, index) => unitOf(declaredOf(key, index)));
+		const fractionIndexes = units.flatMap((unit, index) => unit === "fraction" ? [index] : []);
+		const fractionPixels = fractionIndexes.reduce((total, index) => total + pixels[index], 0);
+		const next = /* @__PURE__ */ new Map();
+		keys.forEach((key, index) => {
+			const size = pixels[index];
+			if (units[index] === "pixels") next.set(key, round(size));
+			else if (units[index] === "percent") next.set(key, `${round(available > 0 ? size / available * 100 : 0)}%`);
+			else {
+				const weight = fractionPixels > 0 ? size / fractionPixels * fractionIndexes.length : 1;
+				next.set(key, `${round(weight)}fr`);
+			}
+		});
+		return next;
+	};
+	const sizes = computed(() => panels.keys.value.map((key, index) => declaredOf(key, index) ?? "1fr"));
+	const commit = (next) => {
+		if (!isControlled.value) stored.value = next;
+		options.onSizesChange?.(panels.keys.value.map((key) => next.get(key) ?? "1fr"));
+	};
+	/** The pixel layout a drag measures its deltas against, taken once when the drag opens. */
+	let snapshot = [];
+	/** What this drag last committed, so a move resolving to the same layout can be dropped. */
+	let committed = null;
+	const applyPixels = (pixels) => {
+		const next = toDeclared(pixels);
+		const wasCollapsed = new Set(collapsed.value);
+		const shut = /* @__PURE__ */ new Set();
+		panels.keys.value.forEach((key, index) => {
+			if (!panels.get(key).isCollapsible()) return;
+			const { floor, min } = boundsOf(index);
+			if (pixels[index] <= floor && floor < min) shut.add(key);
+		});
+		for (const key of shut) if (!wasCollapsed.has(key)) remembered.set(key, stored.value.get(key) ?? "1fr");
+		if (!isSameSet(collapsed.value, shut)) collapsed.value = shut;
+		commit(next);
+		for (const key of shut) if (!wasCollapsed.has(key)) options.onCollapse?.(key);
+		for (const key of wasCollapsed) if (!shut.has(key)) options.onExpand?.(key);
+	};
+	const resolveNeighbours = (handleKey) => {
+		const element = handles.get(handleKey)?.element();
+		if (!element) return null;
+		const before = panels.keys.value.filter((key) => {
+			const panel = panels.get(key)?.element();
+			return panel && panel.compareDocumentPosition(element) & Node.DOCUMENT_POSITION_FOLLOWING;
+		}).length - 1;
+		if (before < 0 || before + 1 >= panels.keys.value.length) return null;
+		return {
+			after: before + 1,
+			before
+		};
+	};
+	const neighbourCache = computed(() => {
+		return /* @__PURE__ */ new Map();
+	});
+	const neighboursOf = (handleKey) => {
+		const cache = neighbourCache.value;
+		const hit = cache.get(handleKey);
+		if (hit !== void 0) return hit;
+		const pair = resolveNeighbours(handleKey);
+		cache.set(handleKey, pair);
+		return pair;
+	};
+	const collapse = (key) => {
+		const panel = panels.get(key);
+		if (!panel?.isCollapsible() || collapsed.value.has(key)) return;
+		remembered.set(key, stored.value.get(key) ?? panel.size() ?? panel.defaultSize() ?? "1fr");
+		collapsed.value = new Set(collapsed.value).add(key);
+		options.onCollapse?.(key);
+	};
+	const expand = (key) => {
+		if (!collapsed.value.has(key)) return;
+		const next = new Set(collapsed.value);
+		next.delete(key);
+		collapsed.value = next;
+		const panel = panels.get(key);
+		const restored = new Map(stored.value);
+		restored.set(key, remembered.get(key) ?? panel?.defaultSize() ?? panel?.minSize() ?? "1fr");
+		if (!isControlled.value) stored.value = restored;
+		options.onExpand?.(key);
+	};
+	const handleRange = (handleKey) => {
+		const pair = neighboursOf(handleKey);
+		const base = layout.value;
+		if (!pair || base.length === 0) return null;
+		return {
+			max: resolveDelta(base, pair.before, Number.MAX_SAFE_INTEGER)[pair.before],
+			min: resolveDelta(base, pair.before, -Number.MAX_SAFE_INTEGER)[pair.before],
+			now: base[pair.before]
+		};
+	};
+	return {
+		availableSize,
+		cancelResize: () => {
+			if (resizingHandle.value == null) return;
+			if (snapshot.length > 0 && !isSameLayout(committed ?? [], snapshot)) applyPixels(snapshot);
+			committed = null;
+			resizingHandle.value = null;
+			options.onResizeEnd?.(sizes.value);
+		},
+		collapse,
+		endResize: () => {
+			const wasResizing = resizingHandle.value != null;
+			committed = null;
+			resizingHandle.value = null;
+			if (wasResizing) options.onResizeEnd?.(sizes.value);
+		},
+		expand,
+		getPanel: (key) => panels.get(key),
+		getPanelSize,
+		handleRange,
+		isCollapsed: (key) => collapsed.value.has(key),
+		isDisabled,
+		layout,
+		neighbours: neighboursOf,
+		orientation,
+		panelKeys: panels.keys,
+		registerHandle: handles.register,
+		registerPanel: panels.register,
+		reset: (keys) => {
+			const next = new Map(stored.value);
+			const stillShut = new Set(collapsed.value);
+			for (const key of keys) {
+				next.delete(key);
+				stillShut.delete(key);
+				remembered.delete(key);
+			}
+			collapsed.value = stillShut;
+			if (!isControlled.value) stored.value = next;
+			options.onSizesChange?.(sizes.value);
+		},
+		resize: (handleKey, totalDelta) => {
+			if (resizingHandle.value !== handleKey || snapshot.length === 0) return;
+			const pair = neighboursOf(handleKey);
+			if (!pair) return;
+			const pixels = resolveDelta(snapshot, pair.before, totalDelta);
+			if (committed && isSameLayout(committed, pixels)) return;
+			committed = pixels;
+			applyPixels(pixels);
+		},
+		resizingHandle: computed(() => resizingHandle.value),
+		setAvailableSize: (size) => {
+			containerSize.value = size;
+		},
+		setSizes: (next) => {
+			const keyed = /* @__PURE__ */ new Map();
+			panels.keys.value.forEach((key, index) => {
+				const size = next[index];
+				if (size !== void 0) keyed.set(key, size);
+			});
+			commit(keyed);
+		},
+		sizes,
+		startResize: (handleKey) => {
+			snapshot = [...layout.value];
+			committed = snapshot;
+			resizingHandle.value = handleKey;
+			options.onResizeStart?.(sizes.value);
+		},
+		toggleCollapse: (key) => {
+			if (collapsed.value.has(key)) expand(key);
+			else collapse(key);
+		}
+	};
+};
+//#endregion
+export { useSplitterState };

package/dist/components/splitter/splitter.storage.d.ts

@@ -0,0 +1,15 @@
+import type { CollectionKey } from "../../composables/use-collection.js";
+import type { SplitterOrientation, SplitterSize } from "./splitter.state.js";
+export interface SplitterLayout {
+    sizes: SplitterSize[];
+    collapsed: string[];
+}
+/**
+ * The layout stored under `id`, or `null` when there is nothing usable there.
+ *
+ * Validated against the panels actually on screen rather than trusted: a stored layout whose
+ * panels no longer match would apply sizes to the wrong ones, which is worse than starting fresh.
+ */
+export declare const readSplitterLayout: (id: string, orientation: SplitterOrientation, keys: CollectionKey[]) => SplitterLayout | null;
+export declare const writeSplitterLayout: (id: string, orientation: SplitterOrientation, keys: CollectionKey[], sizes: SplitterSize[], collapsed: (key: CollectionKey) => boolean) => void;
+export declare const clearSplitterLayout: (id: string) => void;

package/dist/components/splitter/splitter.storage.js

@@ -0,0 +1,56 @@
+//#region src/components/splitter/splitter.storage.ts
+var VERSION = 1;
+var keyFor = (id) => `ropav:splitter:${id}`;
+/**
+* Storage can throw rather than merely fail — Safari's private mode raises on access, not only on
+* write — so every call is guarded, and an unreadable store is treated as an empty one.
+*/
+var storage = () => {
+	try {
+		return typeof window === "undefined" ? null : window.localStorage;
+	} catch {
+		return null;
+	}
+};
+/**
+* The layout stored under `id`, or `null` when there is nothing usable there.
+*
+* Validated against the panels actually on screen rather than trusted: a stored layout whose
+* panels no longer match would apply sizes to the wrong ones, which is worse than starting fresh.
+*/
+var readSplitterLayout = (id, orientation, keys) => {
+	const store = storage();
+	if (!store) return null;
+	try {
+		const raw = store.getItem(keyFor(id));
+		if (!raw) return null;
+		const parsed = JSON.parse(raw);
+		if (parsed?.v !== VERSION || parsed.o !== orientation || !Array.isArray(parsed.p)) return null;
+		if (parsed.p.length !== keys.length) return null;
+		if (parsed.p.some((panel, index) => panel.k !== String(keys[index]))) return null;
+		return {
+			collapsed: parsed.p.filter((panel) => panel.c).map((panel) => panel.k),
+			sizes: parsed.p.map((panel) => panel.s)
+		};
+	} catch {
+		return null;
+	}
+};
+var writeSplitterLayout = (id, orientation, keys, sizes, collapsed) => {
+	const store = storage();
+	if (!store) return;
+	const layout = {
+		o: orientation,
+		p: keys.map((key, index) => ({
+			...collapsed(key) ? { c: true } : {},
+			k: String(key),
+			s: sizes[index] ?? "1fr"
+		})),
+		v: VERSION
+	};
+	try {
+		store.setItem(keyFor(id), JSON.stringify(layout));
+	} catch {}
+};
+//#endregion
+export { readSplitterLayout, writeSplitterLayout };

package/dist/components/splitter/splitter.types.d.ts

@@ -0,0 +1,98 @@
+import type { CollectionKey } from "../../composables/use-collection.js";
+import type { SplitterOrientation, SplitterSize } from "./splitter.state.js";
+export interface SplitterRootProps {
+    class?: string;
+    /**
+     * Axis the panels are laid out along. A horizontal group puts its panels side by side, which
+     * makes each handle a vertical line. @default "horizontal"
+     */
+    orientation?: SplitterOrientation;
+    /** Every panel's size, in order. Set, a drag reports what it would do rather than doing it. */
+    sizes?: SplitterSize[];
+    /** Sizes the splitter starts at, when the caller is not controlling them. */
+    defaultSizes?: SplitterSize[];
+    /**
+     * Where the layout is remembered between visits, under `ropav:splitter:<id>` in `localStorage`.
+     * Read once after mount, and discarded unless it still matches the panels on screen.
+     */
+    autoSaveId?: string;
+    /** Suppresses every handle. */
+    isDisabled?: boolean;
+    /** How far one arrow press moves a handle, in pixels. @default 10 */
+    keyboardStep?: number;
+    /** How far a shift-arrow press moves a handle, in pixels. @default 50 */
+    keyboardLargeStep?: number;
+    /** Accessible name, for a splitter with no visible label. */
+    ariaLabel?: string;
+    /** Ids of the elements that name the splitter. */
+    ariaLabelledby?: string;
+}
+export interface SplitterPanelProps {
+    class?: string;
+    /**
+     * Identity of the panel. Falls back to a generated key — but an explicit id is what lets a
+     * stored layout survive a panel being added, removed or reordered.
+     */
+    id?: CollectionKey;
+    /** A size the caller controls. A drag never writes to it. */
+    size?: SplitterSize;
+    /** The size the panel starts at, and what a double-click on its handle restores. @default "1fr" */
+    defaultSize?: SplitterSize;
+    /** Smallest size a drag may reach. Cannot be given in `fr`. @default 0 */
+    minSize?: SplitterSize;
+    /** Largest size a drag may reach. Cannot be given in `fr`. */
+    maxSize?: SplitterSize;
+    /** Whether dragging past the minimum snaps the panel shut instead of stopping there. */
+    isCollapsible?: boolean;
+    /**
+     * The size a collapsed panel keeps. `0` takes it out of the layout; `48` leaves an icon rail.
+     * Cannot be given in `fr`. @default 0
+     */
+    collapsedSize?: SplitterSize;
+}
+export interface SplitterHandleProps {
+    class?: string;
+    /** Identity of the handle. Falls back to a generated key. */
+    id?: CollectionKey;
+    /** Disables this handle alone; the splitter being disabled also counts. */
+    isDisabled?: boolean;
+    /** Whether a double-click puts both neighbours back to their default size. @default true */
+    resetOnDoubleClick?: boolean;
+    /**
+     * Draws a grip across the middle of the divider, purely decorative — the grab area reaches well
+     * past it either way. @default false
+     */
+    showGrip?: boolean;
+    /**
+     * Accessible name. Declared as `ariaLabel`, not `aria-label`: Vue normalises prop names, so a
+     * hyphenated declaration would never be matched. @default "Resize panel"
+     */
+    ariaLabel?: string;
+    /** Ids of the elements that name the handle. */
+    ariaLabelledby?: string;
+}
+/** State the root hands to its slot. */
+export interface SplitterSlotProps {
+    orientation: SplitterOrientation;
+    /** Every panel's resolved size, in pixels and in order. Empty until the container is measured. */
+    layout: number[];
+    isDragging: boolean;
+    isDisabled: boolean;
+}
+/** State a panel hands to its slot. */
+export interface SplitterPanelSlotProps {
+    /** The panel's resolved size in pixels, or `0` before the container has been measured. */
+    size: number;
+    isCollapsed: boolean;
+    isCollapsible: boolean;
+    orientation: SplitterOrientation;
+}
+/** State a handle hands to its slot. */
+export interface SplitterHandleSlotProps {
+    isDragging: boolean;
+    isHovered: boolean;
+    isFocused: boolean;
+    isFocusVisible: boolean;
+    isDisabled: boolean;
+    orientation: SplitterOrientation;
+}

package/dist/components/switch/switch-content.js

@@ -19,7 +19,7 @@ var switch_content_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@_
 		const setInputEl = (element) => {
 			inputEl.value = element instanceof HTMLInputElement ? element : null;
 		};
-		useFormReset(inputEl, defaultSelected, setSelected);
+		useFormReset(inputEl, defaultSelected, setSelected, form);
 		watch([inputEl, isSelected], ([input, selected]) => setFormChecked(input, selected), {
 			flush: "post",
 			immediate: true

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

@@ -100,10 +100,10 @@ export declare const Table: ((__VLS_props: NonNullable<Awaited<typeof __VLS_setu
             allowsSorting?: boolean;
             id?: import("../../index.js").CollectionKey;
             isRowHeader?: boolean;
-            width?: import("../../index.js").TableColumnSize;
-            defaultWidth?: import("../../index.js").TableColumnSize;
-            minWidth?: import("../../index.js").TableColumnSize;
-            maxWidth?: import("../../index.js").TableColumnSize;
+            width?: import("./use-table-column-layout.js").TableColumnSize;
+            defaultWidth?: import("./use-table-column-layout.js").TableColumnSize;
+            minWidth?: import("./use-table-column-layout.js").TableColumnSize;
+            maxWidth?: import("./use-table-column-layout.js").TableColumnSize;
         } & (typeof globalThis extends {
             __VLS_PROPS_FALLBACK: infer P;
         } ? P : {});
@@ -323,13 +323,13 @@ export declare const Table: ((__VLS_props: NonNullable<Awaited<typeof __VLS_setu
         slots: {
             default?: () => unknown;
         };
-        emit: ((evt: "resize", widths: Map<import("../../index.js").CollectionKey, import("../../index.js").TableColumnSize>) => void) & ((evt: "resizeEnd", widths: Map<import("../../index.js").CollectionKey, import("../../index.js").TableColumnSize>) => void) & ((evt: "resizeStart", widths: Map<import("../../index.js").CollectionKey, import("../../index.js").TableColumnSize>) => void);
+        emit: ((evt: "resize", widths: Map<import("../../index.js").CollectionKey, import("../../utils/flex-sizing.js").FlexSize>) => void) & ((evt: "resizeEnd", widths: Map<import("../../index.js").CollectionKey, import("../../utils/flex-sizing.js").FlexSize>) => void) & ((evt: "resizeStart", widths: Map<import("../../index.js").CollectionKey, import("../../utils/flex-sizing.js").FlexSize>) => void);
     }, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>['expose'], __VLS_setup?: Promise<{
         props: import('vue').PublicProps & {
             class?: string;
-            onResize?: ((widths: Map<import("../../index.js").CollectionKey, import("../../index.js").TableColumnSize>) => any) | undefined;
-            onResizeEnd?: ((widths: Map<import("../../index.js").CollectionKey, import("../../index.js").TableColumnSize>) => any) | undefined;
-            onResizeStart?: ((widths: Map<import("../../index.js").CollectionKey, import("../../index.js").TableColumnSize>) => any) | undefined;
+            onResize?: ((widths: Map<import("../../index.js").CollectionKey, import("../../utils/flex-sizing.js").FlexSize>) => any) | undefined;
+            onResizeEnd?: ((widths: Map<import("../../index.js").CollectionKey, import("../../utils/flex-sizing.js").FlexSize>) => any) | undefined;
+            onResizeStart?: ((widths: Map<import("../../index.js").CollectionKey, import("../../utils/flex-sizing.js").FlexSize>) => any) | undefined;
         } & (typeof globalThis extends {
             __VLS_PROPS_FALLBACK: infer P;
         } ? P : {});
@@ -338,7 +338,7 @@ export declare const Table: ((__VLS_props: NonNullable<Awaited<typeof __VLS_setu
         slots: {
             default?: () => unknown;
         };
-        emit: ((evt: "resize", widths: Map<import("../../index.js").CollectionKey, import("../../index.js").TableColumnSize>) => void) & ((evt: "resizeEnd", widths: Map<import("../../index.js").CollectionKey, import("../../index.js").TableColumnSize>) => void) & ((evt: "resizeStart", widths: Map<import("../../index.js").CollectionKey, import("../../index.js").TableColumnSize>) => void);
+        emit: ((evt: "resize", widths: Map<import("../../index.js").CollectionKey, import("../../utils/flex-sizing.js").FlexSize>) => void) & ((evt: "resizeEnd", widths: Map<import("../../index.js").CollectionKey, import("../../utils/flex-sizing.js").FlexSize>) => void) & ((evt: "resizeStart", widths: Map<import("../../index.js").CollectionKey, import("../../utils/flex-sizing.js").FlexSize>) => void);
     }>) => import('vue').VNode & {
         __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
     };
@@ -458,5 +458,6 @@ export declare const Table: ((__VLS_props: NonNullable<Awaited<typeof __VLS_setu
 };
 export { TableRoot, TableScrollContainer, TableResizableContainer, TableContent, TableHeader, TableColumn, TableColumnResizer, TableBody, TableRow, TableCell, TableExpandTrigger, TableDragHandle, TableDropIndicator, TableFooter, TableLoadMore, TableLoadMoreContent, TableSelectionCheckbox, TableSortableColumnHeader, };
 export type { TableRootProps, TableRootProps as TableProps, TableScrollContainerProps, TableResizableContainerProps, TableContentProps, TableHeaderProps, TableHeaderSlotProps, TableColumnProps, TableColumnResizerProps, TableBodyProps, TableRowProps, TableCellProps, TableCellSlotProps, TableDragHandleProps, TableDropIndicatorProps, TableFooterProps, TableLoadMoreProps, TableLoadMoreContentProps, TableSelectionCheckboxProps, TableSortableColumnHeaderProps, TableColumnSlotProps, TableRowSlotProps, TableSortDescriptor, TableSortDirection, } from "./table.types.js";
+export type { TableColumnSize } from "./use-table-column-layout.js";
 export { tableVariants } from "@ropav/styles";
 export type { TableVariants } from "@ropav/styles";

package/dist/components/table/table-body.js

@@ -19,6 +19,11 @@ var table_body_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PUR
 		const { collection, dropState } = useTableGridContext();
 		const virtualizer = useTableVirtualizerContext();
 		/**
+		* The rows are keyed by the slot the virtualizer hands them rather than by their own key, so a
+		* window that moved keeps its elements and changes what they show. Everything a row derives from
+		* its item — its key, its registrations, its drag target — has to follow the item for that to
+		* hold, which is the row's side of the bargain.
+		*
 		* A row node's datum, back as the item type it came in as.
 		*
 		* `VirtualizerNode.content` is `unknown` on purpose — the virtualizer carries data it never looks
@@ -58,9 +63,9 @@ var table_body_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PUR
 		* A windowed body renders its own drop indicators; a plain one leaves them to the caller.
 		*
 		* Not a second way of doing the same thing — it is the only way. An indicator is positioned
-		* against the row wrappers it sits between, which makes it their **sibling**, and this is the
-		* level that produces them. Markup written in the row slot lands *inside* one wrapper, where an
-		* absolute offset would be measured from the wrong origin and clipped by its overflow.
+		* against the rows it sits between, which makes it their **sibling**, and this is the level that
+		* produces them. Markup written in the row slot lands *inside* a row, where an absolute offset
+		* would be measured from the wrong origin.
 		*/
 		const rendersDropIndicators = computed(() => virtualizer != null && dropState != null);
 		/** The gap after the last row, which no row's own "before" indicator covers. */
@@ -81,16 +86,11 @@ var table_body_vue_vue_type_script_setup_true_vapor_true_lang_default = /*@__PUR
 									key: _for_item0.value.key,
 									type: "item"
 								}) });
-							}, null, 10), createComponent(table_virtualizer_item_default, {
-								"layout-info": () => _for_item0.value.layoutInfo,
-								"parent-layout-info": () => layoutInfo.value
-							}, extend(() => {
-								return createSlot("default", {
-									index: () => _for_item0.value.node?.index,
-									item: () => itemOf(_for_item0.value.node)
-								}, null, 36);
-							}, { _: 8 }))];
-						}, (view) => view.key, 32), createIf(() => rendersDropIndicators.value && lastRowKey.value != null, () => {
+							}, null, 138), createSlot("default", {
+								index: () => _for_item0.value.node?.index,
+								item: () => itemOf(_for_item0.value.node)
+							}, null, 20)];
+						}, (view) => view.slot, 32), createIf(() => rendersDropIndicators.value && lastRowKey.value != null, () => {
 							return createComponent(table_drop_indicator_default, { target: () => ({
 								dropPosition: "after",
 								key: lastRowKey.value,