@vizejs/ui 0.345.0 → 0.350.2

package/dist/press-types-CNqStzJf.d.mts

@@ -0,0 +1,112 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/press-types.d.ts
+/** Stable input family reported by a press interaction. */
+type PressPointerType = "keyboard" | "mouse" | "pen" | "pointer" | "touch" | "virtual";
+/** Lifecycle notification emitted by a press controller. */
+type PressEventType = "press" | "pressend" | "pressstart" | "pressup";
+/** Keyboard semantics applied when the host is not natively activatable. */
+type PressKeyboardBehavior = "button" | "link" | "none";
+/** Immutable, renderer-independent snapshot of one press lifecycle event. */
+interface PressEvent {
+  /** Press lifecycle phase represented by this snapshot. */
+  readonly type: PressEventType;
+  /** Input family that initiated the interaction. */
+  readonly pointerType: PressPointerType;
+  /** Element whose bound press props own the interaction. */
+  readonly target: Element;
+  /** Native event responsible for this phase, or `null` for manual cancellation. */
+  readonly originalEvent: Event | null;
+  /** Viewport coordinate when supplied by pointing hardware. */
+  readonly x: number | null;
+  /** Viewport coordinate when supplied by pointing hardware. */
+  readonly y: number | null;
+  /** Modifier-key snapshots captured from the native event. */
+  readonly altKey: boolean;
+  readonly ctrlKey: boolean;
+  readonly metaKey: boolean;
+  readonly shiftKey: boolean;
+  /** Whether the lifecycle ended without an activation. */
+  readonly isCanceled: boolean;
+}
+/** Options shared by {@link createPress} and {@link usePress}. */
+interface PressOptions {
+  /**
+   * Suppress every activation while retaining the bound props.
+   *
+   * Reactive values are read for every event, so disabling an interaction
+   * between pointer-down and pointer-up cancels it deterministically.
+   *
+   * @default false
+   */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Keyboard contract for hosts without native activation behavior.
+   * Native buttons, links, inputs, and summaries always keep browser timing.
+   *
+   * @default "button"
+   */
+  readonly keyboardBehavior?: MaybeRefOrGetter<PressKeyboardBehavior | undefined>;
+  /**
+   * End the interaction permanently on its first pointer exit.
+   * When false, leaving pauses pressed state and re-entering resumes it.
+   *
+   * @default false
+   */
+  readonly shouldCancelOnPointerExit?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Prevent the compatibility mousedown default that normally moves focus.
+   * Keyboard and virtual activation never lose focus.
+   *
+   * @default false
+   */
+  readonly preventFocusOnPress?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Preserve selectable text during an active pointer press. When false, the
+   * host's exact inline user-select declarations are restored at press end.
+   *
+   * @default false
+   */
+  readonly allowTextSelectionOnPress?: MaybeRefOrGetter<boolean | undefined>;
+  /** Called after pressed state becomes active. */
+  readonly onPressStart?: (event: PressEvent) => void;
+  /** Called after pressed state ends or pauses at the pointer boundary. */
+  readonly onPressEnd?: (event: PressEvent) => void;
+  /** Called for every distinct pressed-state transition. */
+  readonly onPressChange?: (isPressed: boolean) => void;
+  /** Called when keyboard or pointing hardware is released over the host. */
+  readonly onPressUp?: (event: PressEvent) => void;
+  /** Called exactly once for a completed activation. */
+  readonly onPress?: (event: PressEvent) => void;
+}
+/** Framework props to spread onto the element that owns a press interaction. */
+interface PressProps {
+  readonly onClick: (event: MouseEvent) => void;
+  readonly onDragstart: (event: DragEvent) => void;
+  readonly onKeydown: (event: KeyboardEvent) => void;
+  readonly onKeyup: (event: KeyboardEvent) => void;
+  readonly onMousedown: (event: MouseEvent) => void;
+  readonly onMousemove: (event: MouseEvent) => void;
+  readonly onMouseup: (event: MouseEvent) => void;
+  readonly onPointercancel: (event: PointerEvent) => void;
+  readonly onPointerdown: (event: PointerEvent) => void;
+  readonly onPointermove: (event: PointerEvent) => void;
+  readonly onPointerup: (event: PointerEvent) => void;
+  readonly onTouchcancel: (event: TouchEvent) => void;
+  readonly onTouchend: (event: TouchEvent) => void;
+  readonly onTouchmove: (event: TouchEvent) => void;
+  readonly onTouchstart: (event: TouchEvent) => void;
+}
+/** Stateful press normalizer with explicit lifecycle ownership. */
+interface PressController {
+  /** Whether the active input is currently within the pressed region. */
+  readonly isPressed: Readonly<ShallowRef<boolean>>;
+  /** Stable handlers to merge or spread onto exactly one host element. */
+  readonly pressProps: Readonly<PressProps>;
+  /** Cancel the current interaction without producing an activation. */
+  readonly cancel: () => boolean;
+  /** Release document listeners, timers, and transient selection changes. */
+  readonly dispose: () => void;
+}
+//#endregion
+export { PressOptions as a, PressKeyboardBehavior as i, PressEvent as n, PressPointerType as o, PressEventType as r, PressProps as s, PressController as t };

package/dist/press.d.mts

@@ -0,0 +1,14 @@
+import { a as PressOptions, i as PressKeyboardBehavior, n as PressEvent, o as PressPointerType, r as PressEventType, s as PressProps, t as PressController } from "./press-types-CNqStzJf.mjs";
+
+//#region src/press.d.ts
+/**
+ * Create an SSR-safe press normalizer for one host element.
+ *
+ * Spread the returned `pressProps` onto the host and call `dispose` when using
+ * this factory outside a Vue effect scope. No DOM global is read at setup.
+ */
+declare function createPress(options?: PressOptions): PressController;
+/** Create a press normalizer disposed with the current Vue effect scope. */
+declare function usePress(options?: PressOptions): PressController;
+//#endregion
+export { type PressController, type PressEvent, type PressEventType, type PressKeyboardBehavior, type PressOptions, type PressPointerType, type PressProps, createPress, usePress };

package/dist/press.mjs

@@ -0,0 +1,2 @@
+import { n as usePress, t as createPress } from "./press-N_mE3Mgx.mjs";
+export { createPress, usePress };

package/dist/{primitive-DJB7pOf3.mjs → primitive-BX31dogp.mjs}

@@ -1,8 +1,8 @@
-import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BVN2DL-U.mjs";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
 import { createBlock, createSlots, defineComponent, openBlock, renderList, renderSlot, resolveDynamicComponent, useSlots, useTemplateRef, withCtx } from "vue";
 //#endregion
 //#region src/PrimitiveElement.vue
-var PrimitiveElement_default = /* @__PURE__ */ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+var PrimitiveElement_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
 	__name: "PrimitiveElement",
 	props: { as: {
 		type: null,

package/dist/{primitive-BtvwikH1.d.mts → primitive-C8jW7DLd.d.mts}

@@ -1,4 +1,3 @@
-import * as _$vue from "vue";
 import { Component, ComponentPublicInstance } from "vue";
 
 //#region src/PrimitiveElement.vue.d.ts
@@ -12,9 +11,9 @@ type __VLS_Props = {
 };
 declare var __VLS_11: string, __VLS_12: {};
 type __VLS_Slots = {} & { [K in NonNullable<typeof __VLS_11>]?: (props: typeof __VLS_12) => any };
-declare const __VLS_base: _$vue.DefineComponent<__VLS_Props, {
-  element: Readonly<_$vue.ShallowRef<PrimitiveElement | null>>;
-}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, false, {}, any>;
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+  element: Readonly<import("vue").ShallowRef<PrimitiveElement | null>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;
 type __VLS_WithSlots<T, S> = T & {

package/dist/primitive.d.mts

@@ -1,2 +1,2 @@
-import { n as PrimitiveElement, r as _default, t as PrimitiveAs } from "./primitive-BtvwikH1.mjs";
+import { n as PrimitiveElement, r as _default, t as PrimitiveAs } from "./primitive-C8jW7DLd.mjs";
 export { _default as Primitive, PrimitiveAs, PrimitiveElement };

package/dist/primitive.mjs

@@ -1,2 +1,2 @@
-import { t as PrimitiveElement_default } from "./primitive-DJB7pOf3.mjs";
+import { t as PrimitiveElement_default } from "./primitive-BX31dogp.mjs";
 export { PrimitiveElement_default as Primitive };

package/dist/scroll-lock-BgVtX4wT.d.mts

@@ -0,0 +1,49 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/scroll-lock-types.d.ts
+/** Viewport-locking strategy selected for a document. */
+type ScrollLockStrategy = "auto" | "fixed" | "overflow";
+/** Reactive configuration for one document scroll-lock owner. */
+interface ScrollLockOptions {
+  /** Document whose layout viewport is locked. It may be `null` during SSR. */
+  readonly document: MaybeRefOrGetter<Document | null | undefined>;
+  /** Whether an activated controller currently participates in the lock stack. @default true */
+  readonly enabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Lock using root overflow or a fixed body. `auto` uses fixed positioning on iOS-like
+   * touch platforms and root overflow elsewhere.
+   * @default "auto"
+   */
+  readonly strategy?: MaybeRefOrGetter<ScrollLockStrategy | undefined>;
+  /** Reserve a classic scrollbar gutter so viewport-width content does not shift. @default true */
+  readonly preserveScrollbarGap?: MaybeRefOrGetter<boolean | undefined>;
+  /** Restore the captured layout-viewport offset when the final owner releases. @default true */
+  readonly restoreScroll?: MaybeRefOrGetter<boolean | undefined>;
+}
+/** Lifecycle and inspection interface returned by `createScrollLock`. */
+interface ScrollLockController {
+  /** Whether this controller has been activated, independently of reactive enablement. */
+  readonly isActive: Readonly<ShallowRef<boolean>>;
+  /** Whether this controller currently contributes to a document lock. */
+  readonly isLocked: Readonly<ShallowRef<boolean>>;
+  /** Classic scrollbar width measured before the current document lock. */
+  readonly scrollbarGap: Readonly<ShallowRef<number>>;
+  /** Effective strategy after platform resolution and nested-lock composition. */
+  readonly resolvedStrategy: Readonly<ShallowRef<Exclude<ScrollLockStrategy, "auto"> | null>>;
+  /** Join the document lock stack. Safe to call repeatedly. */
+  readonly activate: () => void;
+  /** Leave the lock stack and restore document state when the final owner exits. */
+  readonly deactivate: () => void;
+  /** Re-read reactive options and recover after imperative document changes. */
+  readonly refresh: () => void;
+  /** Permanently release reactive and document-level ownership. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/scroll-lock.d.ts
+/** Lock a reactive document viewport without suppressing browser zoom gestures. */
+declare function createScrollLock(options: ScrollLockOptions): ScrollLockController;
+/** Create, mount-activate, and scope-dispose a document scroll lock. */
+declare function useScrollLock(options: ScrollLockOptions): ScrollLockController;
+//#endregion
+export { ScrollLockStrategy as a, ScrollLockOptions as i, useScrollLock as n, ScrollLockController as r, createScrollLock as t };

package/dist/scroll-lock-Ckbmm0-J.mjs

@@ -0,0 +1,313 @@
+import { getCurrentInstance, getCurrentScope, onMounted, onScopeDispose, shallowReadonly, shallowRef, toValue, watch } from "vue";
+//#region src/scroll-lock-internal.ts
+const optionDiagnostic = "VIZE_UI_SCROLL_LOCK_OPTION";
+function readDocument(source) {
+	const value = toValue(source);
+	if (value === void 0 || value === null) return null;
+	const candidate = value;
+	if (candidate.nodeType !== 9 || candidate.documentElement?.nodeType !== 1) throw new TypeError(`${optionDiagnostic}: document must resolve to a Document or null`);
+	return value;
+}
+function readBoolean(source, name, fallback) {
+	const value = toValue(source);
+	if (value === void 0) return fallback;
+	if (typeof value !== "boolean") throw new TypeError(`${optionDiagnostic}: ${name} must resolve to a boolean`);
+	return value;
+}
+function readStrategy(source) {
+	const value = toValue(source) ?? "auto";
+	if (value !== "auto" && value !== "fixed" && value !== "overflow") throw new TypeError(`${optionDiagnostic}: strategy must resolve to "auto", "fixed", or "overflow"`);
+	return value;
+}
+function validateScrollLockOptions(options) {
+	if (!options || typeof options !== "object" || Array.isArray(options)) throw new TypeError(`${optionDiagnostic}: options must be an object`);
+	readDocument(options.document);
+	readBoolean(options.enabled, "enabled", true);
+	readBoolean(options.preserveScrollbarGap, "preserveScrollbarGap", true);
+	readBoolean(options.restoreScroll, "restoreScroll", true);
+	readStrategy(options.strategy);
+}
+//#endregion
+//#region src/scroll-lock-dom.ts
+const rootProperties = [
+	"--vize-scroll-lock-scrollbar-gap",
+	"overflow",
+	"overscroll-behavior",
+	"padding-inline-end",
+	"scrollbar-gutter"
+];
+const bodyProperties = [
+	"left",
+	"position",
+	"top",
+	"width"
+];
+function captureStyle(element, properties) {
+	return {
+		element,
+		properties: properties.map((name) => ({
+			name,
+			priority: element.style.getPropertyPriority(name),
+			value: element.style.getPropertyValue(name)
+		}))
+	};
+}
+function restoreStyle(snapshot) {
+	for (const { name, priority, value } of snapshot.properties) if (value) snapshot.element.style.setProperty(name, value, priority);
+	else snapshot.element.style.removeProperty(name);
+}
+function setOwnedStyle(element, name, value) {
+	element.style.setProperty(name, value, "important");
+}
+function captureDocumentLock(document) {
+	const root = document.documentElement;
+	const body = document.body;
+	if (!root || !body) return null;
+	const view = document.defaultView;
+	return {
+		attribute: root.getAttribute("data-vize-scroll-locked"),
+		body: captureStyle(body, bodyProperties),
+		root: captureStyle(root, rootProperties),
+		scrollX: view?.scrollX ?? 0,
+		scrollY: view?.scrollY ?? 0
+	};
+}
+function measureScrollbarGap(document) {
+	const view = document.defaultView;
+	const clientWidth = document.documentElement?.clientWidth ?? 0;
+	if (!view || clientWidth <= 0 || !Number.isFinite(view.innerWidth)) return 0;
+	return Math.max(0, view.innerWidth - clientWidth);
+}
+function resolveScrollLockStrategy(document, strategy) {
+	if (strategy !== "auto") return strategy;
+	const navigator = document.defaultView?.navigator;
+	const platform = navigator?.platform ?? "";
+	const userAgent = navigator?.userAgent ?? "";
+	return /^(iPad|iPhone|iPod)$/.test(platform) || /\b(iPad|iPhone|iPod)\b/.test(userAgent) || platform === "MacIntel" && (navigator?.maxTouchPoints ?? 0) > 1 ? "fixed" : "overflow";
+}
+function applyDocumentLock(snapshot, strategy, gap, preserveGap) {
+	const root = snapshot.root.element;
+	root.setAttribute("data-vize-scroll-locked", "");
+	setOwnedStyle(root, "--vize-scroll-lock-scrollbar-gap", `${gap}px`);
+	setOwnedStyle(root, "overflow", "hidden");
+	setOwnedStyle(root, "overscroll-behavior", "none");
+	if (preserveGap) {
+		if (root.ownerDocument.defaultView?.CSS?.supports?.("scrollbar-gutter", "stable")) setOwnedStyle(root, "scrollbar-gutter", "stable");
+		else if (gap > 0) {
+			const computed = root.ownerDocument.defaultView?.getComputedStyle(root).paddingInlineEnd;
+			const padding = Number.parseFloat(computed ?? "0");
+			setOwnedStyle(root, "padding-inline-end", `${(Number.isFinite(padding) ? padding : 0) + gap}px`);
+		}
+	}
+	if (strategy === "fixed") {
+		const body = snapshot.body.element;
+		setOwnedStyle(body, "position", "fixed");
+		setOwnedStyle(body, "top", `${-snapshot.scrollY}px`);
+		setOwnedStyle(body, "left", `${-snapshot.scrollX}px`);
+		setOwnedStyle(body, "width", "100%");
+	}
+}
+function restoreDocumentLock(snapshot) {
+	restoreStyle(snapshot.body);
+	restoreStyle(snapshot.root);
+	if (snapshot.attribute === null) snapshot.root.element.removeAttribute("data-vize-scroll-locked");
+	else snapshot.root.element.setAttribute("data-vize-scroll-locked", snapshot.attribute);
+}
+function restoreDocumentScroll(snapshot) {
+	const view = snapshot.root.element.ownerDocument.defaultView;
+	if (!view || typeof view.scrollTo !== "function") return;
+	try {
+		view.scrollTo({
+			behavior: "instant",
+			left: snapshot.scrollX,
+			top: snapshot.scrollY
+		});
+	} catch {}
+}
+//#endregion
+//#region src/scroll-lock-stack.ts
+const states = /* @__PURE__ */ new WeakMap();
+function stateFor(document) {
+	let state = states.get(document);
+	if (!state) {
+		state = {
+			document,
+			restoreOnRelease: true,
+			snapshot: null,
+			tokens: []
+		};
+		states.set(document, state);
+	}
+	return state;
+}
+function restoreAppliedState(state, restoreScroll) {
+	const snapshot = state.snapshot;
+	if (!snapshot) return;
+	restoreDocumentLock(snapshot);
+	if (restoreScroll) restoreDocumentScroll(snapshot);
+}
+function effectiveStrategy(document, tokens) {
+	return tokens.map((token) => resolveScrollLockStrategy(document, token.readStrategy())).includes("fixed") ? "fixed" : "overflow";
+}
+function recomputeScrollLock(state) {
+	const enabled = state.tokens.filter((token) => token.readEnabled());
+	if (enabled.length === 0) {
+		restoreAppliedState(state, state.restoreOnRelease);
+		state.snapshot = null;
+		for (const token of state.tokens) token.setState(false, 0, null);
+		return;
+	}
+	const previous = state.snapshot;
+	if (previous) restoreAppliedState(state, true);
+	const next = captureDocumentLock(state.document);
+	if (!next) {
+		state.snapshot = null;
+		for (const token of state.tokens) token.setState(false, 0, null);
+		return;
+	}
+	state.snapshot = previous ? {
+		...next,
+		scrollX: previous.scrollX,
+		scrollY: previous.scrollY
+	} : next;
+	state.restoreOnRelease = enabled[0]?.readRestoreScroll() ?? true;
+	const strategy = effectiveStrategy(state.document, enabled);
+	const gap = measureScrollbarGap(state.document);
+	const preserveGap = enabled.some((token) => token.readPreserveGap());
+	applyDocumentLock(state.snapshot, strategy, gap, preserveGap);
+	for (const token of state.tokens) {
+		const locked = enabled.includes(token);
+		token.setState(locked, locked ? gap : 0, locked ? strategy : null);
+	}
+}
+function attachScrollLock(token, document) {
+	if (token.document === document) {
+		recomputeScrollLock(stateFor(document));
+		return;
+	}
+	detachScrollLock(token);
+	token.document = document;
+	const state = stateFor(document);
+	state.tokens.push(token);
+	recomputeScrollLock(state);
+}
+function detachScrollLock(token) {
+	const document = token.document;
+	if (!document) {
+		token.setState(false, 0, null);
+		return;
+	}
+	const state = stateFor(document);
+	const index = state.tokens.indexOf(token);
+	if (index >= 0) state.tokens.splice(index, 1);
+	token.document = null;
+	token.setState(false, 0, null);
+	if (state.tokens.length === 0) {
+		restoreAppliedState(state, state.restoreOnRelease);
+		state.snapshot = null;
+		states.delete(document);
+	} else recomputeScrollLock(state);
+}
+function refreshScrollLock(token) {
+	if (token.document) recomputeScrollLock(stateFor(token.document));
+}
+//#endregion
+//#region src/scroll-lock.ts
+const disposedDiagnostic = "VIZE_UI_SCROLL_LOCK_DISPOSED";
+const setupDiagnostic = "VIZE_UI_SCROLL_LOCK_SETUP";
+/** Lock a reactive document viewport without suppressing browser zoom gestures. */
+function createScrollLock(options) {
+	validateScrollLockOptions(options);
+	const activeState = shallowRef(false);
+	const lockedState = shallowRef(false);
+	const gapState = shallowRef(0);
+	const strategyState = shallowRef(null);
+	const token = {
+		document: null,
+		readEnabled: () => readBoolean(options.enabled, "enabled", true),
+		readPreserveGap: () => readBoolean(options.preserveScrollbarGap, "preserveScrollbarGap", true),
+		readRestoreScroll: () => readBoolean(options.restoreScroll, "restoreScroll", true),
+		readStrategy: () => readStrategy(options.strategy),
+		setState: (locked, gap, strategy) => {
+			lockedState.value = locked;
+			gapState.value = gap;
+			strategyState.value = strategy;
+		}
+	};
+	let disposed = false;
+	const assertAlive = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+	};
+	const refresh = () => {
+		assertAlive();
+		if (!activeState.value) return;
+		const document = readDocument(options.document);
+		readBoolean(options.enabled, "enabled", true);
+		readBoolean(options.preserveScrollbarGap, "preserveScrollbarGap", true);
+		readBoolean(options.restoreScroll, "restoreScroll", true);
+		readStrategy(options.strategy);
+		if (document && document !== token.document) attachScrollLock(token, document);
+		else if (!document) detachScrollLock(token);
+		else refreshScrollLock(token);
+	};
+	const activate = () => {
+		assertAlive();
+		if (activeState.value) return;
+		activeState.value = true;
+		try {
+			refresh();
+		} catch (error) {
+			activeState.value = false;
+			detachScrollLock(token);
+			throw error;
+		}
+	};
+	const deactivate = () => {
+		assertAlive();
+		if (!activeState.value) return;
+		try {
+			detachScrollLock(token);
+		} finally {
+			activeState.value = false;
+		}
+	};
+	const stopWatch = watch(() => [
+		toValue(options.document),
+		toValue(options.enabled),
+		toValue(options.preserveScrollbarGap),
+		toValue(options.restoreScroll),
+		toValue(options.strategy)
+	], () => {
+		if (activeState.value) refresh();
+	}, { flush: "sync" });
+	return Object.freeze({
+		isActive: shallowReadonly(activeState),
+		isLocked: shallowReadonly(lockedState),
+		scrollbarGap: shallowReadonly(gapState),
+		resolvedStrategy: shallowReadonly(strategyState),
+		activate,
+		deactivate,
+		refresh,
+		dispose: () => {
+			if (disposed) return;
+			try {
+				detachScrollLock(token);
+			} finally {
+				activeState.value = false;
+				disposed = true;
+				stopWatch();
+			}
+		}
+	});
+}
+/** Create, mount-activate, and scope-dispose a document scroll lock. */
+function useScrollLock(options) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createScrollLock(options);
+	if (getCurrentInstance()) onMounted(controller.activate);
+	else controller.activate();
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+export { useScrollLock as n, createScrollLock as t };

package/dist/scroll-lock.d.mts

@@ -0,0 +1,2 @@
+import { a as ScrollLockStrategy, i as ScrollLockOptions, n as useScrollLock, r as ScrollLockController, t as createScrollLock } from "./scroll-lock-BgVtX4wT.mjs";
+export { type ScrollLockController, type ScrollLockOptions, type ScrollLockStrategy, createScrollLock, useScrollLock };

package/dist/scroll-lock.mjs

@@ -0,0 +1,2 @@
+import { n as useScrollLock, t as createScrollLock } from "./scroll-lock-Ckbmm0-J.mjs";
+export { createScrollLock, useScrollLock };

package/dist/spatial-navigation-CHj9mDZH.d.mts

@@ -0,0 +1,106 @@
+import { l as CollectionKey, p as CollectionRegistry, s as CollectionItem } from "./collection-B_dFZOHO.mjs";
+import { MaybeRefOrGetter } from "vue";
+
+//#region src/spatial-navigation-types.d.ts
+/** Physical direction requested by spatial navigation. */
+type SpatialNavigationDirection = "down" | "left" | "right" | "up";
+/** Candidate ranking behavior aligned with CSS Spatial Navigation Level 1. */
+type SpatialNavigationAlgorithm = "grid" | "normal";
+/** Arrow-key behavior when no candidate exists in the requested direction. */
+type SpatialNavigationBoundaryBehavior = "contain" | "exit";
+/** DOM focus policy after logical state changes. */
+type SpatialNavigationFocusBehavior = "focus" | "logical";
+/** Serializable, axis-aligned CSS pixel rectangle. */
+interface SpatialNavigationRect {
+  readonly bottom: number;
+  readonly height: number;
+  readonly left: number;
+  readonly right: number;
+  readonly top: number;
+  readonly width: number;
+}
+/** Immutable successful navigation snapshot. */
+interface SpatialNavigationChange<Key extends CollectionKey> {
+  readonly direction: SpatialNavigationDirection;
+  readonly key: Key;
+  readonly previousKey: Key | null;
+  readonly originalEvent: Event | null;
+  readonly algorithm: SpatialNavigationAlgorithm;
+  readonly score: number;
+}
+/** Immutable boundary snapshot emitted when no directional candidate exists. */
+interface SpatialNavigationBoundary<Key extends CollectionKey> {
+  readonly direction: SpatialNavigationDirection;
+  readonly key: Key | null;
+  readonly originalEvent: Event | null;
+}
+/** Spatial navigation configuration for one caller-owned collection. */
+interface SpatialNavigationOptions<Key extends CollectionKey, Value> {
+  /** Ordered logical items and active-key ownership. */
+  readonly registry: CollectionRegistry<Key, Value>;
+  /**
+   * Candidate scoring algorithm.
+   *
+   * @default "normal"
+   */
+  readonly algorithm?: MaybeRefOrGetter<SpatialNavigationAlgorithm | undefined>;
+  /**
+   * Whether a boundary arrow remains owned by the composite or exits to native behavior.
+   *
+   * @default "contain"
+   */
+  readonly boundaryBehavior?: MaybeRefOrGetter<SpatialNavigationBoundaryBehavior | undefined>;
+  /** Suppress keyboard and imperative navigation without discarding active state. */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Wrap to the opposite spatial edge when no forward candidate exists.
+   *
+   * @default false
+   */
+  readonly loop?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Whether successful navigation moves DOM focus or only logical active state.
+   *
+   * @default "focus"
+   */
+  readonly focusBehavior?: MaybeRefOrGetter<SpatialNavigationFocusBehavior | undefined>;
+  /**
+   * Avoid browser scrolling while moving DOM focus. Reveal behavior still runs.
+   *
+   * @default false
+   */
+  readonly preventScroll?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Resolve transformed viewport geometry for DOM or virtual items.
+   * The default reads `element.getBoundingClientRect()` and skips unmounted candidates.
+   */
+  readonly getRect?: (item: CollectionItem<Key, Value>) => SpatialNavigationRect | DOMRectReadOnly | null | undefined;
+  /** Custom visibility policy for virtualized or scroll-managed collections. */
+  readonly scrollIntoView?: (item: CollectionItem<Key, Value>, originalEvent: Event | null) => void;
+  /** Called after logical state, DOM focus, and reveal behavior commit. */
+  readonly onNavigate?: (change: SpatialNavigationChange<Key>) => void;
+  /** Called when a valid origin has no candidate in the requested direction. */
+  readonly onBoundary?: (boundary: SpatialNavigationBoundary<Key>) => void;
+}
+/** Stable event adapter for a spatial navigation container. */
+interface SpatialNavigationProps {
+  readonly onKeydown: (event: KeyboardEvent) => void;
+}
+/** Geometry-driven navigation controller. */
+interface SpatialNavigationController<Key extends CollectionKey> {
+  readonly spatialNavigationProps: Readonly<SpatialNavigationProps>;
+  /** Resolve the best candidate without mutating logical or DOM state. */
+  readonly findTarget: (direction: SpatialNavigationDirection, fromKey?: Key) => Key | null;
+  /** Navigate, returning the committed key or `null` at a boundary. */
+  readonly navigate: (direction: SpatialNavigationDirection, originalEvent?: Event | null) => Key | null;
+  /** Release scope ownership. The caller-owned registry is not disposed. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/spatial-navigation.d.ts
+/** Create a geometry-driven, SSR-safe arrow navigation controller. */
+declare function createSpatialNavigation<Key extends CollectionKey, Value>(options: SpatialNavigationOptions<Key, Value>): SpatialNavigationController<Key>;
+/** Create a spatial controller disposed with the current Vue effect scope. */
+declare function useSpatialNavigation<Key extends CollectionKey, Value>(options: SpatialNavigationOptions<Key, Value>): SpatialNavigationController<Key>;
+//#endregion
+export { SpatialNavigationBoundaryBehavior as a, SpatialNavigationDirection as c, SpatialNavigationProps as d, SpatialNavigationRect as f, SpatialNavigationBoundary as i, SpatialNavigationFocusBehavior as l, useSpatialNavigation as n, SpatialNavigationChange as o, SpatialNavigationAlgorithm as r, SpatialNavigationController as s, createSpatialNavigation as t, SpatialNavigationOptions as u };