@vizejs/ui 0.386.0 → 0.388.0

package/dist/motion.d.mts

@@ -0,0 +1,2 @@
+import { S as ViewTransitionHandle, _ as MotionRecipe, a as motionTokenVar, b as MotionTokenOverrides, c as startViewTransition, d as supportsViewTransitions, f as useReducedMotion, g as MotionEnterExitRecipe, h as MotionEasingToken, i as motionTokenProperty, l as supportsScrollDrivenAnimations, m as MotionDurationToken, n as motionDurations, o as setMotionTokens, p as MotionDelayToken, r as motionEasings, s as prefersReducedMotion, t as motionDelays, u as supportsStartingStyle, v as MotionRecipeHook, x as StartViewTransitionOptions, y as MotionTokenName } from "./motion-iUSBdWaI.mjs";
+export { type MotionDelayToken, type MotionDurationToken, type MotionEasingToken, type MotionEnterExitRecipe, type MotionRecipe, type MotionRecipeHook, type MotionTokenName, type MotionTokenOverrides, type StartViewTransitionOptions, type ViewTransitionHandle, motionDelays, motionDurations, motionEasings, motionTokenProperty, motionTokenVar, prefersReducedMotion, setMotionTokens, startViewTransition, supportsScrollDrivenAnimations, supportsStartingStyle, supportsViewTransitions, useReducedMotion };

package/dist/motion.mjs

@@ -0,0 +1,2 @@
+import { a as motionTokenVar, c as startViewTransition, d as supportsViewTransitions, f as useReducedMotion, i as motionTokenProperty, l as supportsScrollDrivenAnimations, n as motionDurations, o as setMotionTokens, r as motionEasings, s as prefersReducedMotion, t as motionDelays, u as supportsStartingStyle } from "./motion-OdERKfZR.mjs";
+export { motionDelays, motionDurations, motionEasings, motionTokenProperty, motionTokenVar, prefersReducedMotion, setMotionTokens, startViewTransition, supportsScrollDrivenAnimations, supportsStartingStyle, supportsViewTransitions, useReducedMotion };

package/dist/{move-BOmXDYbh.d.mts → move-BJGaV7Y9.d.mts}

@@ -1,6 +1,6 @@
 import { MaybeRefOrGetter, ShallowRef } from "vue";
 
-//#region src/move-types.d.ts
+//#region src/families/interaction/move/move-types.d.ts
 /** Input families normalized by the move interaction. */
 type MovePointerType = "keyboard" | "mouse" | "pen" | "pointer" | "touch";
 /** Lifecycle phases emitted by a move controller. */
@@ -94,7 +94,7 @@ interface MoveController {
   readonly dispose: () => void;
 }
 //#endregion
-//#region src/move.d.ts
+//#region src/families/interaction/move/move.d.ts
 /** Create an SSR-safe mouse, pen, touch, and keyboard move normalizer. */
 declare function createMove(options?: MoveOptions): MoveController;
 /** Create a move normalizer disposed with the current Vue effect scope. */

package/dist/move-internal-BM_7g70h.mjs

@@ -0,0 +1,172 @@
+import { toValue } from "vue";
+//#region src/families/interaction/move/move-internal.ts
+const invalidOptionDiagnostic = "VIZE_UI_MOVE_OPTION";
+function readBoolean(value) {
+	const resolved = toValue(value);
+	if (resolved === void 0) return false;
+	if (typeof resolved !== "boolean") throw new TypeError(`${invalidOptionDiagnostic}: isDisabled must resolve to a boolean`);
+	return resolved;
+}
+function readKeyboardStep(value) {
+	const resolved = toValue(value) ?? 1;
+	if (typeof resolved !== "number" || !Number.isFinite(resolved) || resolved <= 0) throw new TypeError(`${invalidOptionDiagnostic}: keyboardStep must resolve to a finite number > 0`);
+	return resolved;
+}
+function modifier(event, key) {
+	return event && key in event ? Boolean(event[key]) : false;
+}
+function positionOf(event, touchId = null) {
+	if ("pageX" in event && "pageY" in event) {
+		const x = Number(event.pageX);
+		const y = Number(event.pageY);
+		if (Number.isFinite(x) && Number.isFinite(y)) return {
+			x,
+			y
+		};
+	}
+	if ("clientX" in event && "clientY" in event) {
+		const x = Number(event.clientX);
+		const y = Number(event.clientY);
+		if (Number.isFinite(x) && Number.isFinite(y)) return {
+			x,
+			y
+		};
+	}
+	if ("changedTouches" in event) {
+		const touch = Array.from(event.changedTouches).find(({ identifier }) => touchId === null || identifier === touchId);
+		if (touch) return {
+			x: touch.pageX,
+			y: touch.pageY
+		};
+	}
+	return null;
+}
+function pointerTypeOf(event) {
+	if (event.pointerType === "mouse" || event.pointerType === "pen") return event.pointerType;
+	if (event.pointerType === "touch") return "touch";
+	return "pointer";
+}
+function createMoveEvent(type, target, pointerType, originalEvent, deltaX = 0, deltaY = 0, isCanceled = false, touchId = null) {
+	const position = originalEvent ? positionOf(originalEvent, touchId) : null;
+	return Object.freeze({
+		type,
+		pointerType,
+		target,
+		originalEvent,
+		x: position?.x ?? null,
+		y: position?.y ?? null,
+		deltaX,
+		deltaY,
+		altKey: modifier(originalEvent, "altKey"),
+		ctrlKey: modifier(originalEvent, "ctrlKey"),
+		metaKey: modifier(originalEvent, "metaKey"),
+		shiftKey: modifier(originalEvent, "shiftKey"),
+		isCanceled
+	});
+}
+function surfaceErrors(errors, message) {
+	if (errors.length === 1) throw errors[0];
+	if (errors.length < 2) return;
+	const Aggregate = globalThis.AggregateError;
+	if (typeof Aggregate === "function") throw new Aggregate(errors, message);
+	const fallback = Object.assign(new Error(message), { errors: [...errors] });
+	fallback.name = "AggregateError";
+	throw fallback;
+}
+function capture(errors, callback) {
+	try {
+		callback();
+	} catch (error) {
+		errors.push(error);
+	}
+}
+function validateOptions(options) {
+	for (const name of [
+		"onMove",
+		"onMoveEnd",
+		"onMoveStart"
+	]) {
+		const callback = options[name];
+		if (callback !== void 0 && typeof callback !== "function") throw new TypeError(`${invalidOptionDiagnostic}: ${name} must be a function`);
+	}
+	if (typeof options.keyboardStep !== "function") readKeyboardStep(options.keyboardStep);
+}
+/** Install and exhaustively clean up the document listeners for one pointer family. */
+function installMoveListeners(document, source, context) {
+	const removals = [];
+	const listen = (owner, type, callback, capture = true) => {
+		owner.addEventListener(type, callback, capture);
+		removals.push(() => owner.removeEventListener(type, callback, capture));
+	};
+	const matches = (family, id) => {
+		const current = context.getActive();
+		return current?.source === family && current.id === id ? current : null;
+	};
+	const pointerMove = (event) => {
+		const current = matches("pointer", event.pointerId);
+		const position = positionOf(event);
+		if (current && position) context.emitDelta(current, event, position);
+	};
+	const pointerEnd = (event, canceled) => {
+		const current = matches("pointer", event.pointerId);
+		if (!current) return;
+		const disabled = context.readDisabled(event);
+		context.finish(event, canceled || disabled || !current.target.isConnected);
+	};
+	const mouseMove = (event) => {
+		const current = matches("mouse", null);
+		const position = positionOf(event);
+		if (current && position) context.emitDelta(current, event, position);
+	};
+	const mouseUp = (event) => {
+		const current = matches("mouse", null);
+		if (event.button === 0 && current) context.finish(event, context.readDisabled(event) || !current.target.isConnected);
+	};
+	const touchMove = (event) => {
+		const candidate = context.getActive();
+		const current = candidate?.source === "touch" ? candidate : null;
+		const position = current ? positionOf(event, current.id) : null;
+		if (current && position) context.emitDelta(current, event, position);
+	};
+	const touchEnd = (event, canceled) => {
+		const candidate = context.getActive();
+		const current = candidate?.source === "touch" ? candidate : null;
+		if (!current || !positionOf(event, current.id)) return;
+		context.rememberTouch(event.timeStamp);
+		context.finish(event, canceled || context.readDisabled(event) || !current.target.isConnected);
+	};
+	try {
+		if (source === "pointer") {
+			listen(document, "pointermove", pointerMove);
+			listen(document, "pointerup", ((event) => pointerEnd(event, false)));
+			listen(document, "pointercancel", ((event) => pointerEnd(event, true)));
+		} else if (source === "mouse") {
+			listen(document, "mousemove", mouseMove);
+			listen(document, "mouseup", mouseUp);
+		} else {
+			listen(document, "touchmove", touchMove);
+			listen(document, "touchend", ((event) => touchEnd(event, false)));
+			listen(document, "touchcancel", ((event) => touchEnd(event, true)));
+		}
+		listen(document, "dragstart", (event) => context.finish(event, true));
+		listen(document, "visibilitychange", (() => {
+			if (document.visibilityState === "hidden") context.finish(null, true);
+		}));
+		if (document.defaultView) listen(document.defaultView, "blur", (event) => context.finish(event, true), false);
+	} catch (error) {
+		const errors = [error];
+		for (const remove of removals.reverse()) capture(errors, remove);
+		surfaceErrors(errors, "Move listener setup failed");
+		throw error;
+	}
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		const errors = [];
+		for (const remove of removals) capture(errors, remove);
+		surfaceErrors(errors, "Move listener cleanup failed");
+	};
+}
+//#endregion
+export { positionOf as a, surfaceErrors as c, pointerTypeOf as i, validateOptions as l, createMoveEvent as n, readBoolean as o, installMoveListeners as r, readKeyboardStep as s, capture as t };

package/dist/move.d.mts

@@ -1,2 +1,2 @@
-import { a as MoveEvent, c as MovePointerType, d as MoveUpdateEvent, i as MoveEndEvent, l as MoveProps, n as useMove, o as MoveEventType, r as MoveController, s as MoveOptions, t as createMove, u as MoveStartEvent } from "./move-BOmXDYbh.mjs";
+import { a as MoveEvent, c as MovePointerType, d as MoveUpdateEvent, i as MoveEndEvent, l as MoveProps, n as useMove, o as MoveEventType, r as MoveController, s as MoveOptions, t as createMove, u as MoveStartEvent } from "./move-BJGaV7Y9.mjs";
 export { type MoveController, type MoveEndEvent, type MoveEvent, type MoveEventType, type MoveOptions, type MovePointerType, type MoveProps, type MoveStartEvent, type MoveUpdateEvent, createMove, useMove };

package/dist/move.mjs

@@ -1,2 +1,217 @@
-import { n as useMove, t as createMove } from "./move-BVvMHzxr.mjs";
+import { a as positionOf, c as surfaceErrors, i as pointerTypeOf, l as validateOptions, n as createMoveEvent, o as readBoolean, r as installMoveListeners, s as readKeyboardStep, t as capture } from "./move-internal-BM_7g70h.mjs";
+import { a as isPrimaryPointer, n as disableTextSelection, r as eventElement } from "./press-event-xlWYF9py.mjs";
+import { getCurrentScope, onScopeDispose, shallowReadonly, shallowRef } from "vue";
+//#region src/families/interaction/move/move.ts
+const disposedDiagnostic = "VIZE_UI_MOVE_DISPOSED";
+const setupDiagnostic = "VIZE_UI_MOVE_SETUP";
+/** Create an SSR-safe mouse, pen, touch, and keyboard move normalizer. */
+function createMove(options = {}) {
+	validateOptions(options);
+	const moving = shallowRef(false);
+	let active = null;
+	let keyboard = null;
+	let disposed = false;
+	let lastTouchTime = Number.NEGATIVE_INFINITY;
+	const finish = (originalEvent, isCanceled) => {
+		const current = active;
+		if (!current) return false;
+		active = null;
+		moving.value = false;
+		const errors = [];
+		capture(errors, current.releaseListeners);
+		capture(errors, current.restoreSelection);
+		if (current.didMove) capture(errors, () => options.onMoveEnd?.(createMoveEvent("moveend", current.target, current.pointerType, originalEvent, 0, 0, isCanceled, current.source === "touch" ? current.id : null)));
+		surfaceErrors(errors, "Move completion failed");
+		return true;
+	};
+	const readDisabledDuringActive = (event) => {
+		try {
+			return readBoolean(options.isDisabled);
+		} catch (error) {
+			const errors = [error];
+			capture(errors, () => finish(event, true));
+			surfaceErrors(errors, "Move option validation failed during teardown");
+			throw error;
+		}
+	};
+	const finishKeyboard = (originalEvent, isCanceled) => {
+		const current = keyboard;
+		if (!current) return false;
+		keyboard = null;
+		moving.value = false;
+		options.onMoveEnd?.(createMoveEvent("moveend", current.target, "keyboard", originalEvent, 0, 0, isCanceled));
+		return true;
+	};
+	const emitDelta = (current, event, position) => {
+		if (active !== current) return;
+		current.lastEvent = event;
+		if (readDisabledDuringActive(event) || !current.target.isConnected) {
+			finish(event, true);
+			return;
+		}
+		const deltaX = position.x - current.position.x;
+		const deltaY = position.y - current.position.y;
+		current.position = position;
+		if (deltaX === 0 && deltaY === 0) return;
+		event.preventDefault();
+		const errors = [];
+		if (!current.didMove) {
+			current.didMove = true;
+			moving.value = true;
+			capture(errors, () => options.onMoveStart?.(createMoveEvent("movestart", current.target, current.pointerType, event, 0, 0, false, current.source === "touch" ? current.id : null)));
+		}
+		if (active === current && !disposed) capture(errors, () => options.onMove?.(createMoveEvent("move", current.target, current.pointerType, event, deltaX, deltaY, false, current.source === "touch" ? current.id : null)));
+		surfaceErrors(errors, "Move callbacks failed");
+	};
+	const matches = (source, id) => {
+		const current = active;
+		return current?.source === source && current.id === id ? current : null;
+	};
+	const start = (event, source, pointerType, id, position) => {
+		if (disposed || active || readBoolean(options.isDisabled)) return;
+		const target = eventElement(event);
+		if (!target) return;
+		event.preventDefault();
+		event.stopPropagation();
+		let releaseListeners = () => void 0;
+		let restoreSelection = () => void 0;
+		try {
+			releaseListeners = installMoveListeners(target.ownerDocument, source, {
+				emitDelta,
+				finish,
+				getActive: () => active,
+				readDisabled: readDisabledDuringActive,
+				rememberTouch: (timeStamp) => {
+					lastTouchTime = timeStamp;
+				}
+			});
+			restoreSelection = disableTextSelection(target);
+		} catch (error) {
+			const errors = [error];
+			capture(errors, releaseListeners);
+			capture(errors, restoreSelection);
+			surfaceErrors(errors, "Move start cleanup failed");
+			throw error;
+		}
+		active = {
+			id,
+			pointerType,
+			releaseListeners,
+			restoreSelection,
+			source,
+			target,
+			didMove: false,
+			lastEvent: event,
+			position
+		};
+	};
+	const keyboardMove = (event, deltaX, deltaY) => {
+		if (disposed || active || keyboard || readBoolean(options.isDisabled)) return;
+		const target = eventElement(event);
+		if (!target || event.target !== target) return;
+		event.preventDefault();
+		event.stopPropagation();
+		const step = readKeyboardStep(options.keyboardStep);
+		const errors = [];
+		const current = { target };
+		keyboard = current;
+		moving.value = true;
+		capture(errors, () => options.onMoveStart?.(createMoveEvent("movestart", target, "keyboard", event)));
+		if (keyboard === current && !disposed) capture(errors, () => options.onMove?.(createMoveEvent("move", target, "keyboard", event, deltaX * step, deltaY * step)));
+		if (keyboard === current && !disposed) capture(errors, () => finishKeyboard(event, false));
+		surfaceErrors(errors, "Keyboard move callbacks failed");
+	};
+	const moveProps = Object.freeze({
+		onDragstart(event) {
+			if (active?.target === eventElement(event)) finish(event, true);
+		},
+		onKeydown(event) {
+			if (event.isComposing || event.altKey || event.ctrlKey || event.metaKey) return;
+			switch (event.key) {
+				case "Left":
+				case "ArrowLeft":
+					keyboardMove(event, -1, 0);
+					break;
+				case "Right":
+				case "ArrowRight":
+					keyboardMove(event, 1, 0);
+					break;
+				case "Up":
+				case "ArrowUp":
+					keyboardMove(event, 0, -1);
+					break;
+				case "Down":
+				case "ArrowDown":
+					keyboardMove(event, 0, 1);
+					break;
+			}
+		},
+		onMousedown(event) {
+			if (event.button !== 0 || active || event.view && "PointerEvent" in event.view) return;
+			const elapsed = event.timeStamp - lastTouchTime;
+			if (elapsed >= 0 && elapsed < 800) return;
+			const position = positionOf(event);
+			if (position) start(event, "mouse", "mouse", null, position);
+		},
+		onPointercancel(event) {
+			if (matches("pointer", event.pointerId)) finish(event, true);
+		},
+		onPointerdown(event) {
+			if (!isPrimaryPointer(event)) return;
+			const position = positionOf(event);
+			if (position) start(event, "pointer", pointerTypeOf(event), event.pointerId, position);
+		},
+		onTouchcancel(event) {
+			const current = active?.source === "touch" ? active : null;
+			if (current && positionOf(event, current.id)) finish(event, true);
+		},
+		onTouchend(event) {
+			const current = active?.source === "touch" ? active : null;
+			if (current && positionOf(event, current.id)) finish(event, false);
+		},
+		onTouchmove(event) {
+			const current = active?.source === "touch" ? active : null;
+			const position = current ? positionOf(event, current.id) : null;
+			if (current && position) emitDelta(current, event, position);
+		},
+		onTouchstart(event) {
+			lastTouchTime = event.timeStamp;
+			if (event.view && "PointerEvent" in event.view || active || event.changedTouches.length !== 1) return;
+			const touch = event.changedTouches.item(0);
+			if (touch) start(event, "touch", "touch", touch.identifier, {
+				x: touch.pageX,
+				y: touch.pageY
+			});
+		}
+	});
+	return Object.freeze({
+		isMoving: shallowReadonly(moving),
+		moveProps,
+		cancel: () => {
+			if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+			return finish(null, true) || finishKeyboard(null, true);
+		},
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			const current = active;
+			active = null;
+			keyboard = null;
+			moving.value = false;
+			if (!current) return;
+			const errors = [];
+			capture(errors, current.releaseListeners);
+			capture(errors, current.restoreSelection);
+			surfaceErrors(errors, "Move disposal failed");
+		}
+	});
+}
+/** Create a move normalizer disposed with the current Vue effect scope. */
+function useMove(options = {}) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createMove(options);
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
 export { createMove, useMove };