@vizejs/ui 0.345.0 → 0.350.2

package/dist/move-BVvMHzxr.mjs

@@ -0,0 +1,386 @@
+import { a as isPrimaryPointer, n as disableTextSelection, r as eventElement } from "./press-event-Cd2OPpmw.mjs";
+import { getCurrentScope, onScopeDispose, shallowReadonly, shallowRef, toValue } from "vue";
+//#region src/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
+//#region src/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 { useMove as n, createMove as t };

package/dist/move.d.mts

@@ -0,0 +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";
+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

@@ -0,0 +1,2 @@
+import { n as useMove, t as createMove } from "./move-BVvMHzxr.mjs";
+export { createMove, useMove };