@vizejs/ui 0.343.0 → 0.347.7

package/dist/interaction-modality-tee79ZBZ.d.mts

@@ -0,0 +1,89 @@
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/interaction-modality-types.d.ts
+/**
+ * Input family that most recently expressed user intent.
+ *
+ * Pens and unknown pointing hardware intentionally map to `pointer`; consumers
+ * that need device-specific geometry should inspect the original pointer event.
+ */
+type InteractionModality = "keyboard" | "pointer" | "touch" | "virtual";
+/** Why an {@link InteractionModalityTracker} changed. */
+type InteractionModalityChangeReason = InteractionModality | "document" | "manual";
+/** Immutable notification emitted after a distinct modality change. */
+interface InteractionModalityChange {
+  /** New modality, or `null` when a consumer explicitly resets detection. */
+  readonly modality: InteractionModality | null;
+  /** Value observed immediately before this change. */
+  readonly previousModality: InteractionModality | null;
+  /** Event classification or lifecycle operation responsible for the change. */
+  readonly reason: InteractionModalityChangeReason;
+  /** Native event when the change came from document input. */
+  readonly originalEvent: Event | null;
+  /** Document whose state produced the change, if the tracker is attached. */
+  readonly document: Document | null;
+}
+/** Options for {@link createInteractionModalityTracker}. */
+interface InteractionModalityOptions {
+  /**
+   * Reactive document to observe. Pass `null` for SSR or deferred attachment.
+   *
+   * When omitted, the current global document is resolved lazily. No DOM global
+   * is read while the module is evaluated.
+   *
+   * @default globalThis.document when available
+   */
+  readonly document?: MaybeRefOrGetter<Document | null | undefined>;
+  /**
+   * Value used before the first qualifying input event.
+   *
+   * @default null
+   */
+  readonly initialModality?: InteractionModality | null;
+  /** Called synchronously after each distinct change. */
+  readonly onChange?: (change: InteractionModalityChange) => void;
+}
+/** Reactive, explicitly disposable input-modality observer. */
+interface InteractionModalityTracker {
+  /** Document currently observed by this tracker. */
+  readonly document: Readonly<ShallowRef<Document | null>>;
+  /** Most recently detected input family. */
+  readonly modality: Readonly<ShallowRef<InteractionModality | null>>;
+  /** Whether global focus treatment should currently be keyboard-visible. */
+  readonly isFocusVisible: ComputedRef<boolean>;
+  /** Attach to another document, retaining the current value until synchronized. */
+  readonly attach: (document: Document | null) => boolean;
+  /** Stop observing the current document without clearing the current value. */
+  readonly detach: () => boolean;
+  /** Explicitly set or reset modality and synchronize peers on the same document. */
+  readonly setModality: (modality: InteractionModality | null) => boolean;
+  /** Release reactive observation and native listeners. Safe to call repeatedly. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/interaction-modality.d.ts
+/**
+ * Create an SSR-safe, document-scoped interaction-modality observer.
+ *
+ * Trackers in one document share native capture listeners and state. Separate
+ * documents, including iframes, remain isolated. Call {@link InteractionModalityTracker.dispose}
+ * when using this factory outside a Vue effect scope.
+ */
+declare function createInteractionModalityTracker(options?: InteractionModalityOptions): InteractionModalityTracker;
+/**
+ * Create a tracker owned by the current Vue effect scope.
+ *
+ * The tracker is disposed automatically when its component or effect scope is
+ * destroyed, preventing document-listener leaks.
+ */
+declare function useInteractionModality(options?: InteractionModalityOptions): InteractionModalityTracker;
+/**
+ * Determine whether a focused element should expose its focus indicator.
+ *
+ * Native `:focus-visible` semantics take precedence. The modality fallback is
+ * used only when the selector is unsupported, preserving text-input and
+ * platform heuristics implemented by the browser.
+ */
+declare function isElementFocusVisible(element: Element | null | undefined, modality: InteractionModality | null): boolean;
+//#endregion
+export { InteractionModalityChange as a, InteractionModalityTracker as c, InteractionModality as i, isElementFocusVisible as n, InteractionModalityChangeReason as o, useInteractionModality as r, InteractionModalityOptions as s, createInteractionModalityTracker as t };

package/dist/interaction-modality.d.mts

@@ -0,0 +1,2 @@
+import { a as InteractionModalityChange, c as InteractionModalityTracker, i as InteractionModality, n as isElementFocusVisible, o as InteractionModalityChangeReason, r as useInteractionModality, s as InteractionModalityOptions, t as createInteractionModalityTracker } from "./interaction-modality-tee79ZBZ.mjs";
+export { InteractionModality, InteractionModalityChange, InteractionModalityChangeReason, InteractionModalityOptions, InteractionModalityTracker, createInteractionModalityTracker, isElementFocusVisible, useInteractionModality };

package/dist/interaction-modality.mjs

@@ -0,0 +1,2 @@
+import { n as isElementFocusVisible, r as useInteractionModality, t as createInteractionModalityTracker } from "./interaction-modality-CO-eQzNy.mjs";
+export { createInteractionModalityTracker, isElementFocusVisible, useInteractionModality };

package/dist/long-press-CRjjjJK2.d.mts

@@ -0,0 +1,115 @@
+import { n as PressEvent, o as PressPointerType, s as PressProps } from "./press-types-B8Ssxqg4.mjs";
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/long-press-types.d.ts
+/** Pointing-device families eligible to start a long press. */
+type LongPressPointerType = Extract<PressPointerType, "mouse" | "pen" | "pointer" | "touch">;
+/** Lifecycle notification emitted by a long-press controller. */
+type LongPressEventType = "longpress" | "longpressend" | "longpressstart";
+/** Immutable snapshot of one long-press lifecycle event. */
+interface LongPressEvent {
+  /** Long-press lifecycle phase represented by this snapshot. */
+  readonly type: LongPressEventType;
+  /** Pointing-device family that initiated the interaction. */
+  readonly pointerType: LongPressPointerType;
+  /** Element whose bound 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 attempt ended without reaching a normal release. */
+  readonly isCanceled: boolean;
+}
+/** Options shared by {@link createLongPress} and {@link useLongPress}. */
+interface LongPressOptions {
+  /**
+   * Suppress long and short activation while retaining the bound props.
+   * Reactive values are checked at start and again when the threshold elapses.
+   *
+   * @default false
+   */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Restrict long-press recognition to one pointing-device family.
+   * Keyboard and virtual activation remain available through `onPress`.
+   *
+   * @default undefined
+   */
+  readonly pointerType?: MaybeRefOrGetter<LongPressPointerType | undefined>;
+  /**
+   * Time in milliseconds that the primary pointer must remain down.
+   * The value is resolved once per attempt and must be finite and non-negative.
+   *
+   * @default 500
+   */
+  readonly threshold?: MaybeRefOrGetter<number | undefined>;
+  /**
+   * Accessible explanation of the long action, for example
+   * "Long press to open actions". Used as `aria-description` unless
+   * `accessibilityDescriptionId` is supplied.
+   */
+  readonly accessibilityDescription?: MaybeRefOrGetter<string | undefined>;
+  /**
+   * ID of consumer-rendered descriptive content. When supplied, the host uses
+   * `aria-describedby` and the inline accessibility description is omitted.
+   */
+  readonly accessibilityDescriptionId?: MaybeRefOrGetter<string | undefined>;
+  /**
+   * Preserve selectable text during the pointer attempt.
+   *
+   * @default false
+   */
+  readonly allowTextSelectionOnPress?: MaybeRefOrGetter<boolean | undefined>;
+  /**
+   * Prevent the compatibility mousedown default that normally moves focus.
+   *
+   * @default false
+   */
+  readonly preventFocusOnPress?: MaybeRefOrGetter<boolean | undefined>;
+  /** Called after a qualifying primary pointer starts. */
+  readonly onLongPressStart?: (event: LongPressEvent) => void;
+  /** Called when an attempt ends, whether before or after the threshold. */
+  readonly onLongPressEnd?: (event: LongPressEvent) => void;
+  /** Called exactly once when the configured threshold is reached. */
+  readonly onLongPress?: (event: LongPressEvent) => void;
+  /**
+   * Called for an ordinary short, keyboard, or virtual activation.
+   * Use this as the keyboard-accessible alternative to a long-only action.
+   */
+  readonly onPress?: (event: PressEvent) => void;
+}
+/** Attributes and native handlers to spread onto one long-press host. */
+interface LongPressProps extends PressProps {
+  readonly "aria-describedby": string | undefined;
+  readonly "aria-description": string | undefined;
+  readonly onContextmenu: (event: MouseEvent) => void;
+}
+/** Stateful long-press recognizer with explicit lifecycle ownership. */
+interface LongPressController {
+  /** Whether an eligible pointer attempt is currently active. */
+  readonly isPressed: Readonly<ShallowRef<boolean>>;
+  /** Whether the active attempt has crossed the configured threshold. */
+  readonly isLongPressed: Readonly<ShallowRef<boolean>>;
+  /** Stable handlers and accessibility attributes for exactly one host. */
+  readonly longPressProps: Readonly<LongPressProps>;
+  /** Cancel the current pending or triggered interaction. */
+  readonly cancel: () => boolean;
+  /** Release timers, listeners, selection guards, and reactive state. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/long-press.d.ts
+/** Create an SSR-safe long-press recognizer for one host element. */
+declare function createLongPress(options?: LongPressOptions): LongPressController;
+/** Create a long-press recognizer disposed with the current Vue effect scope. */
+declare function useLongPress(options?: LongPressOptions): LongPressController;
+//#endregion
+export { LongPressEventType as a, LongPressProps as c, LongPressEvent as i, useLongPress as n, LongPressOptions as o, LongPressController as r, LongPressPointerType as s, createLongPress as t };

package/dist/long-press.d.mts

@@ -0,0 +1,2 @@
+import { a as LongPressEventType, c as LongPressProps, i as LongPressEvent, n as useLongPress, o as LongPressOptions, r as LongPressController, s as LongPressPointerType, t as createLongPress } from "./long-press-CRjjjJK2.mjs";
+export { LongPressController, LongPressEvent, LongPressEventType, LongPressOptions, LongPressPointerType, LongPressProps, createLongPress, useLongPress };

package/dist/long-press.mjs

@@ -0,0 +1,246 @@
+import { i as disableTextSelection, r as createPressEvent, t as createPress } from "./press-Bp57IOe2.mjs";
+import { getCurrentScope, onScopeDispose, shallowReadonly, shallowRef, toValue } from "vue";
+//#region src/long-press.ts
+const defaultThreshold = 500;
+const invalidOptionDiagnostic = "VIZE_UI_LONG_PRESS_OPTION";
+const disposedDiagnostic = "VIZE_UI_LONG_PRESS_DISPOSED";
+const setupDiagnostic = "VIZE_UI_LONG_PRESS_SETUP";
+const hardwarePointers = new Set([
+	"mouse",
+	"pen",
+	"pointer",
+	"touch"
+]);
+function readBoolean(value, name) {
+	const resolved = toValue(value);
+	if (resolved === void 0) return false;
+	if (typeof resolved !== "boolean") throw new TypeError(`${invalidOptionDiagnostic}: ${name} must resolve to a boolean`);
+	return resolved;
+}
+function readPointerType(value) {
+	const resolved = toValue(value) ?? null;
+	if (resolved !== null && !hardwarePointers.has(resolved)) throw new TypeError(`${invalidOptionDiagnostic}: pointerType must resolve to mouse, pen, pointer, or touch`);
+	return resolved;
+}
+function readThreshold(value) {
+	const resolved = toValue(value) ?? defaultThreshold;
+	if (typeof resolved !== "number" || !Number.isFinite(resolved) || resolved < 0) throw new TypeError(`${invalidOptionDiagnostic}: threshold must resolve to a finite number >= 0`);
+	return resolved;
+}
+function readText(value, name) {
+	const resolved = toValue(value);
+	if (resolved === void 0 || resolved === "") return void 0;
+	if (typeof resolved !== "string") throw new TypeError(`${invalidOptionDiagnostic}: ${name} must resolve to a string`);
+	return resolved;
+}
+function toLongPressEvent(type, event, originalEvent = event.originalEvent, isCanceled = event.isCanceled) {
+	const snapshot = createPressEvent("pressend", event.target, event.pointerType, originalEvent, isCanceled);
+	return Object.freeze({
+		...snapshot,
+		type
+	});
+}
+function validateOptions(options) {
+	for (const name of [
+		"onLongPress",
+		"onLongPressEnd",
+		"onLongPressStart",
+		"onPress"
+	]) {
+		const callback = options[name];
+		if (callback !== void 0 && typeof callback !== "function") throw new TypeError(`${invalidOptionDiagnostic}: ${name} must be a function`);
+	}
+	if (typeof options.threshold !== "function") readThreshold(options.threshold);
+	if (typeof options.pointerType !== "function") readPointerType(options.pointerType);
+}
+/** Create an SSR-safe long-press recognizer for one host element. */
+function createLongPress(options = {}) {
+	validateOptions(options);
+	const isPressed = shallowRef(false);
+	const isLongPressed = shallowRef(false);
+	let attempt = null;
+	let releaseTriggered = null;
+	let restoreTriggeredSelection = null;
+	let contextMenuPointer = null;
+	let contextMenuTimer = null;
+	let endingAtThreshold = false;
+	let disposed = false;
+	const clearContextMenuTimer = () => {
+		if (contextMenuTimer !== null) clearTimeout(contextMenuTimer);
+		contextMenuTimer = null;
+	};
+	const lingerContextMenuSuppression = () => {
+		clearContextMenuTimer();
+		contextMenuTimer = setTimeout(() => {
+			contextMenuPointer = null;
+			contextMenuTimer = null;
+		}, 50);
+	};
+	const clearRelease = () => {
+		releaseTriggered?.();
+		releaseTriggered = null;
+		restoreTriggeredSelection?.();
+		restoreTriggeredSelection = null;
+	};
+	const clearAttempt = () => {
+		const timer = attempt?.timer;
+		if (timer != null) clearTimeout(timer);
+		attempt = null;
+	};
+	const finishTriggered = (originalEvent, isCanceled) => {
+		if (!isLongPressed.value || !attempt) return false;
+		const current = attempt;
+		const canceled = isCanceled || readBoolean(options.isDisabled, "isDisabled");
+		clearRelease();
+		clearAttempt();
+		isPressed.value = false;
+		isLongPressed.value = false;
+		lingerContextMenuSuppression();
+		options.onLongPressEnd?.(toLongPressEvent("longpressend", current.event, originalEvent, canceled));
+		return true;
+	};
+	const installTriggeredRelease = (current) => {
+		const removals = [];
+		const document = current.target.ownerDocument;
+		const start = current.event.originalEvent;
+		const listen = (owner, type, callback, capture = true) => {
+			owner.addEventListener(type, callback, capture);
+			removals.push(() => owner.removeEventListener(type, callback, capture));
+		};
+		const finish = (event, canceled = false) => finishTriggered(event, canceled);
+		if (start && "pointerId" in start) {
+			const id = Number(start.pointerId);
+			listen(document, "pointerup", ((event) => {
+				if (event.pointerId === id) finish(event);
+			}));
+			listen(document, "pointercancel", ((event) => {
+				if (event.pointerId === id) finish(event, true);
+			}));
+		} else if (start && "changedTouches" in start) {
+			const id = start.changedTouches.item(0)?.identifier;
+			const ownsTouch = (event) => id !== void 0 && Array.from(event.changedTouches).some((touch) => touch.identifier === id);
+			listen(document, "touchend", ((event) => {
+				if (ownsTouch(event)) finish(event);
+			}));
+			listen(document, "touchcancel", ((event) => {
+				if (ownsTouch(event)) finish(event, true);
+			}));
+		} else listen(document, "mouseup", ((event) => {
+			if (event.button === 0) finish(event);
+		}));
+		listen(document, "dragstart", (event) => finish(event, true));
+		listen(document, "visibilitychange", (() => {
+			if (document.visibilityState === "hidden") finish(null, true);
+		}));
+		if (document.defaultView) listen(document.defaultView, "blur", (event) => finish(event, true), false);
+		return () => {
+			for (const remove of removals.splice(0)) remove();
+		};
+	};
+	let press;
+	const trigger = (current) => {
+		if (disposed || attempt !== current) return;
+		current.timer = null;
+		if (readBoolean(options.isDisabled, "isDisabled")) {
+			press.cancel();
+			return;
+		}
+		isLongPressed.value = true;
+		releaseTriggered = installTriggeredRelease(current);
+		endingAtThreshold = true;
+		try {
+			press.cancel();
+		} finally {
+			endingAtThreshold = false;
+		}
+		const focusable = current.target;
+		if ((current.pointerType === "touch" || current.pointerType === "pen") && current.target.ownerDocument.activeElement !== current.target && typeof focusable.focus === "function") try {
+			focusable.focus({ preventScroll: true });
+		} catch {
+			focusable.focus();
+		}
+		if (!readBoolean(options.allowTextSelectionOnPress, "allowTextSelectionOnPress")) restoreTriggeredSelection = disableTextSelection(current.target);
+		options.onLongPress?.(toLongPressEvent("longpress", current.event));
+	};
+	press = createPress({
+		...options.isDisabled === void 0 ? {} : { isDisabled: options.isDisabled },
+		...options.allowTextSelectionOnPress === void 0 ? {} : { allowTextSelectionOnPress: options.allowTextSelectionOnPress },
+		...options.preventFocusOnPress === void 0 ? {} : { preventFocusOnPress: options.preventFocusOnPress },
+		shouldCancelOnPointerExit: true,
+		onPressStart(event) {
+			if (!hardwarePointers.has(event.pointerType)) return;
+			const pointerType = event.pointerType;
+			const filter = readPointerType(options.pointerType);
+			if (filter && filter !== pointerType) return;
+			clearAttempt();
+			contextMenuPointer = pointerType;
+			clearContextMenuTimer();
+			const start = toLongPressEvent("longpressstart", event);
+			const current = {
+				event: start,
+				pointerType,
+				target: event.target,
+				timer: null
+			};
+			attempt = current;
+			isPressed.value = true;
+			current.timer = setTimeout(() => trigger(current), readThreshold(options.threshold));
+			options.onLongPressStart?.(start);
+		},
+		onPressEnd(event) {
+			if (!attempt || endingAtThreshold) return;
+			const current = attempt;
+			clearAttempt();
+			isPressed.value = false;
+			if (current.pointerType === "touch" || current.pointerType === "pen") lingerContextMenuSuppression();
+			else contextMenuPointer = null;
+			options.onLongPressEnd?.(toLongPressEvent("longpressend", current.event, event.originalEvent, event.isCanceled));
+		},
+		...options.onPress ? { onPress: options.onPress } : {}
+	});
+	const attributes = {
+		...press.pressProps,
+		get "aria-describedby"() {
+			if (readBoolean(options.isDisabled, "isDisabled") || !options.onLongPress) return void 0;
+			return readText(options.accessibilityDescriptionId, "accessibilityDescriptionId");
+		},
+		get "aria-description"() {
+			if (readBoolean(options.isDisabled, "isDisabled") || !options.onLongPress) return void 0;
+			if (readText(options.accessibilityDescriptionId, "accessibilityDescriptionId")) return void 0;
+			return readText(options.accessibilityDescription, "accessibilityDescription");
+		},
+		onContextmenu(event) {
+			if (contextMenuPointer === "touch" || contextMenuPointer === "pen") event.preventDefault();
+		}
+	};
+	return Object.freeze({
+		isPressed: shallowReadonly(isPressed),
+		isLongPressed: shallowReadonly(isLongPressed),
+		longPressProps: Object.freeze(attributes),
+		cancel: () => {
+			if (disposed) throw new Error(`${disposedDiagnostic}: the controller has been disposed`);
+			if (finishTriggered(null, true)) return true;
+			return press.cancel();
+		},
+		dispose: () => {
+			if (disposed) return;
+			clearRelease();
+			clearAttempt();
+			clearContextMenuTimer();
+			contextMenuPointer = null;
+			isPressed.value = false;
+			isLongPressed.value = false;
+			press.dispose();
+			disposed = true;
+		}
+	});
+}
+/** Create a long-press recognizer disposed with the current Vue effect scope. */
+function useLongPress(options = {}) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const controller = createLongPress(options);
+	onScopeDispose(controller.dispose);
+	return controller;
+}
+//#endregion
+export { createLongPress, useLongPress };

package/dist/media-pdf.d.mts

@@ -1,2 +1,2 @@
-import { n as createPDFSource, t as CreatePDFSourceOptions } from "./pdf-source-COxN3A1l.mjs";
+import { n as createPDFSource, t as CreatePDFSourceOptions } from "./pdf-source-BbZKF_dS.mjs";
 export { type CreatePDFSourceOptions, createPDFSource };

package/dist/media-pdf.mjs

@@ -1,2 +1,2 @@
-import { t as createPDFSource } from "./pdf-source-C52YE8tp.mjs";
+import { t as createPDFSource } from "./pdf-source-C9zNQd9l.mjs";
 export { createPDFSource };

package/dist/media.d.mts

@@ -1,3 +1,3 @@
 import { MediaSourceKind, NormalizeMediaSourceOptions, normalizeMediaSource } from "./media-source.mjs";
-import { n as createPDFSource, t as CreatePDFSourceOptions } from "./pdf-source-COxN3A1l.mjs";
+import { n as createPDFSource, t as CreatePDFSourceOptions } from "./pdf-source-BbZKF_dS.mjs";
 export { type CreatePDFSourceOptions, type MediaSourceKind, type NormalizeMediaSourceOptions, createPDFSource, normalizeMediaSource };

package/dist/media.mjs

@@ -1,3 +1,3 @@
 import { normalizeMediaSource } from "./media-source.mjs";
-import { t as createPDFSource } from "./pdf-source-C52YE8tp.mjs";
+import { t as createPDFSource } from "./pdf-source-C9zNQd9l.mjs";
 export { createPDFSource, normalizeMediaSource };