@vizejs/ui 0.387.0 → 0.388.0

package/dist/meter-B3m17_8g.d.mts

@@ -0,0 +1,174 @@
+import { ComputedRef } from "vue";
+
+//#region src/families/feedback/meter/meter-types.d.ts
+/** Native-friendly Meter range token derived from low/high thresholds. */
+type MeterRange = "high" | "low" | "medium";
+/** Stable state token exposed by the Meter primitive. */
+type MeterState = "empty" | "full" | "high" | "low" | "medium" | "optimum";
+/** State exposed to the default Meter slot and component instance. */
+interface MeterSlotState {
+  /** Current finite value clamped to the normalized min/max range. */
+  readonly value: number;
+  /** Finite lower bound. */
+  readonly min: number;
+  /** Finite upper bound, always greater than `min`. */
+  readonly max: number;
+  /** Optional low threshold clamped to the normalized range. */
+  readonly low: number | null;
+  /** Optional high threshold clamped to the normalized range. */
+  readonly high: number | null;
+  /** Optional optimum threshold clamped to the normalized range. */
+  readonly optimum: number | null;
+  /** Completion percentage from 0 to 100. */
+  readonly percent: number;
+  /** Current threshold range. */
+  readonly range: MeterRange;
+  /** Whether the current range contains the optimum threshold. */
+  readonly optimal: boolean;
+  /** Whether raw inputs had to be repaired before reaching the native element. */
+  readonly invalid: boolean;
+  /** Stable state token for styling and tests. */
+  readonly state: MeterState;
+}
+/** Public component instance exposed by the Meter primitive. */
+interface MeterExpose extends MeterSlotState {
+  /** Rendered native meter element. */
+  readonly element: HTMLMeterElement | null;
+}
+//#endregion
+//#region src/families/feedback/meter/meter.vue.d.ts
+type __VLS_Props = {
+  /**
+   * Consumer-owned meter id. `null` and `undefined` select a deterministic fallback.
+   *
+   * @default undefined
+   */
+  readonly id?: string | null;
+  /**
+   * Current value. Non-finite values are repaired to the normalized minimum.
+   *
+   * @default 0
+   */
+  readonly value?: number | null;
+  /**
+   * Lower bound.
+   *
+   * @default 0
+   */
+  readonly min?: number;
+  /**
+   * Upper bound. Values less than or equal to `min` are repaired to `min + 1`.
+   *
+   * @default 1
+   */
+  readonly max?: number;
+  /**
+   * Optional low threshold.
+   *
+   * @default null
+   */
+  readonly low?: number | null;
+  /**
+   * Optional high threshold.
+   *
+   * @default null
+   */
+  readonly high?: number | null;
+  /**
+   * Optional optimum threshold.
+   *
+   * @default null
+   */
+  readonly optimum?: number | null;
+  /**
+   * Accessible name when no visible label or `aria-labelledby` supplies one.
+   *
+   * @default undefined
+   */
+  readonly ariaLabel?: string;
+  /**
+   * Space-separated ids that label the meter.
+   *
+   * @default undefined
+   */
+  readonly ariaLabelledby?: string;
+  /**
+   * Space-separated ids that describe the meter.
+   *
+   * @default undefined
+   */
+  readonly ariaDescribedby?: string;
+};
+type __VLS_Slots = {
+  /** Optional fallback contents. Receives normalized Meter state for composition. */default(props: MeterSlotState): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+  element: Readonly<import("vue").ShallowRef<HTMLMeterElement | null>>;
+  value: ComputedRef<number>;
+  min: ComputedRef<number>;
+  max: ComputedRef<number>;
+  low: ComputedRef<number | null>;
+  high: ComputedRef<number | null>;
+  optimum: ComputedRef<number | null>;
+  percent: ComputedRef<number>;
+  range: ComputedRef<MeterRange>;
+  optimal: ComputedRef<boolean>;
+  invalid: ComputedRef<boolean>;
+  state: ComputedRef<MeterState>;
+}, {}, {}, {}, 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 & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/families/feedback/meter/meter-state.d.ts
+/** Native default lower bound for Meter. */
+declare const METER_DEFAULT_MIN = 0;
+/** Native default upper bound for Meter. */
+declare const METER_DEFAULT_MAX = 1;
+/** Raw values accepted by the Meter normalizer. */
+interface MeterStateOptions {
+  /**
+   * Raw value. Non-finite values fall back to the normalized minimum.
+   *
+   * @default METER_DEFAULT_MIN
+   */
+  readonly value?: number | null;
+  /**
+   * Raw minimum.
+   *
+   * @default METER_DEFAULT_MIN
+   */
+  readonly min?: number | null;
+  /**
+   * Raw maximum. Values less than or equal to `min` are repaired to `min + 1`.
+   *
+   * @default METER_DEFAULT_MAX
+   */
+  readonly max?: number | null;
+  /**
+   * Optional low threshold.
+   *
+   * @default null
+   */
+  readonly low?: number | null;
+  /**
+   * Optional high threshold.
+   *
+   * @default null
+   */
+  readonly high?: number | null;
+  /**
+   * Optional optimum threshold.
+   *
+   * @default null
+   */
+  readonly optimum?: number | null;
+}
+/** Normalize raw Meter props into the public native-safe state contract. */
+declare function getMeterState(options?: MeterStateOptions): MeterSlotState;
+//#endregion
+export { MeterExpose as a, MeterState as c, _default as i, METER_DEFAULT_MIN as n, MeterRange as o, getMeterState as r, MeterSlotState as s, METER_DEFAULT_MAX as t };

package/dist/meter-BwOXVWH8.mjs

@@ -0,0 +1,243 @@
+import { a as useDeterministicId } from "./deterministic-id-yMq4HfmS.mjs";
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { computed, createElementBlock, defineComponent, openBlock, renderSlot, unref, useTemplateRef } from "vue";
+//#region src/families/feedback/meter/meter-state.ts
+/** Native default lower bound for Meter. */
+const METER_DEFAULT_MIN = 0;
+/** Native default upper bound for Meter. */
+const METER_DEFAULT_MAX = 1;
+function finite(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function readThreshold(value, min, max) {
+	if (value == null) return {
+		invalid: false,
+		value: null
+	};
+	if (!finite(value)) return {
+		invalid: true,
+		value: null
+	};
+	return {
+		invalid: value < min || value > max,
+		value: clamp(value, min, max)
+	};
+}
+function rangeFor(value, low, high) {
+	if (low !== null && value < low) return "low";
+	if (high !== null && value > high) return "high";
+	return "medium";
+}
+function stateFor(value, min, max, range, optimal) {
+	if (value <= min) return "empty";
+	if (value >= max) return "full";
+	return optimal ? "optimum" : range;
+}
+/** Normalize raw Meter props into the public native-safe state contract. */
+function getMeterState(options = {}) {
+	const min = finite(options.min) ? options.min : 0;
+	let invalid = options.min != null && !finite(options.min);
+	let max = 1;
+	if (finite(options.max) && options.max > min) max = options.max;
+	else {
+		invalid = invalid || options.max != null;
+		max = min + 1;
+	}
+	const value = finite(options.value) ? clamp(options.value, min, max) : min;
+	invalid = invalid || options.value != null && (!finite(options.value) || options.value !== value);
+	const lowResult = readThreshold(options.low, min, max);
+	const highResult = readThreshold(options.high, min, max);
+	const optimumResult = readThreshold(options.optimum, min, max);
+	let low = lowResult.value;
+	let high = highResult.value;
+	invalid = invalid || lowResult.invalid || highResult.invalid || optimumResult.invalid;
+	if (low !== null && high !== null && low > high) {
+		invalid = true;
+		[low, high] = [high, low];
+	}
+	const percent = (value - min) / (max - min) * 100;
+	const range = rangeFor(value, low, high);
+	const optimumRange = optimumResult.value === null ? null : rangeFor(optimumResult.value, low, high);
+	const optimal = optimumRange !== null && range === optimumRange;
+	return Object.freeze({
+		value,
+		min,
+		max,
+		low,
+		high,
+		optimum: optimumResult.value,
+		percent,
+		range,
+		optimal,
+		invalid,
+		state: stateFor(value, min, max, range, optimal)
+	});
+}
+//#endregion
+//#region src/families/feedback/meter/meter.vue?vue&type=script&setup=true&lang.ts
+const _hoisted_1 = [
+	"id",
+	"min",
+	"max",
+	"value",
+	"low",
+	"high",
+	"optimum",
+	"aria-label",
+	"aria-labelledby",
+	"aria-describedby",
+	"data-state",
+	"data-range",
+	"data-optimal",
+	"data-invalid",
+	"data-value",
+	"data-min",
+	"data-max",
+	"data-low",
+	"data-high",
+	"data-optimum",
+	"data-percent"
+];
+//#endregion
+//#region src/families/feedback/meter/meter.vue
+var meter_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "meter",
+	props: {
+		id: {
+			type: [String, null],
+			required: false,
+			default: () => void 0
+		},
+		value: {
+			type: [Number, null],
+			required: false,
+			default: () => 0
+		},
+		min: {
+			type: Number,
+			required: false,
+			default: () => 0
+		},
+		max: {
+			type: Number,
+			required: false,
+			default: () => 1
+		},
+		low: {
+			type: [Number, null],
+			required: false,
+			default: null
+		},
+		high: {
+			type: [Number, null],
+			required: false,
+			default: null
+		},
+		optimum: {
+			type: [Number, null],
+			required: false,
+			default: null
+		},
+		ariaLabel: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaLabelledby: {
+			type: String,
+			required: false,
+			default: () => void 0
+		},
+		ariaDescribedby: {
+			type: String,
+			required: false,
+			default: () => void 0
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const element = useTemplateRef("element");
+		const controlId = useDeterministicId({
+			id: () => __props.id,
+			hint: "meter"
+		});
+		const meter = computed(() => getMeterState({
+			value: __props.value,
+			min: __props.min,
+			max: __props.max,
+			low: __props.low,
+			high: __props.high,
+			optimum: __props.optimum
+		}));
+		const currentValue = computed(() => meter.value.value);
+		const currentMin = computed(() => meter.value.min);
+		const currentMax = computed(() => meter.value.max);
+		const currentLow = computed(() => meter.value.low);
+		const currentHigh = computed(() => meter.value.high);
+		const currentOptimum = computed(() => meter.value.optimum);
+		const percent = computed(() => meter.value.percent);
+		const range = computed(() => meter.value.range);
+		const optimal = computed(() => meter.value.optimal);
+		const invalid = computed(() => meter.value.invalid);
+		const state = computed(() => meter.value.state);
+		__expose({
+			element,
+			value: currentValue,
+			min: currentMin,
+			max: currentMax,
+			low: currentLow,
+			high: currentHigh,
+			optimum: currentOptimum,
+			percent,
+			range,
+			optimal,
+			invalid,
+			state
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createElementBlock("meter", {
+				id: unref(controlId),
+				ref_key: "element",
+				ref: element,
+				min: currentMin.value,
+				max: currentMax.value,
+				value: currentValue.value,
+				low: currentLow.value ?? void 0,
+				high: currentHigh.value ?? void 0,
+				optimum: currentOptimum.value ?? void 0,
+				"aria-label": __props.ariaLabel,
+				"aria-labelledby": __props.ariaLabelledby,
+				"aria-describedby": __props.ariaDescribedby,
+				"data-vize-ui": "meter",
+				part: "root",
+				"data-state": state.value,
+				"data-range": range.value,
+				"data-optimal": optimal.value ? "true" : "false",
+				"data-invalid": invalid.value ? "true" : void 0,
+				"data-value": currentValue.value,
+				"data-min": currentMin.value,
+				"data-max": currentMax.value,
+				"data-low": currentLow.value ?? void 0,
+				"data-high": currentHigh.value ?? void 0,
+				"data-optimum": currentOptimum.value ?? void 0,
+				"data-percent": percent.value
+			}, [renderSlot(_ctx.$slots, "default", {
+				value: currentValue.value,
+				min: currentMin.value,
+				max: currentMax.value,
+				low: currentLow.value,
+				high: currentHigh.value,
+				optimum: currentOptimum.value,
+				percent: percent.value,
+				range: range.value,
+				optimal: optimal.value,
+				invalid: invalid.value,
+				state: state.value
+			}, void 0, true)], 8, _hoisted_1);
+		};
+	}
+}), [["__scopeId", "data-v-fdc70309"]]);
+//#endregion
+export { getMeterState as i, METER_DEFAULT_MAX as n, METER_DEFAULT_MIN as r, meter_default as t };

package/dist/meter.d.mts

@@ -0,0 +1,2 @@
+import { a as MeterExpose, c as MeterState, i as _default, n as METER_DEFAULT_MIN, o as MeterRange, r as getMeterState, s as MeterSlotState, t as METER_DEFAULT_MAX } from "./meter-B3m17_8g.mjs";
+export { METER_DEFAULT_MAX, METER_DEFAULT_MIN, _default as Meter, type MeterExpose, type MeterRange, type MeterSlotState, type MeterState, getMeterState };

package/dist/meter.mjs

@@ -0,0 +1,2 @@
+import { i as getMeterState, n as METER_DEFAULT_MAX, r as METER_DEFAULT_MIN, t as meter_default } from "./meter-BwOXVWH8.mjs";
+export { METER_DEFAULT_MAX, METER_DEFAULT_MIN, meter_default as Meter, getMeterState };

package/dist/motion-OdERKfZR.mjs

@@ -0,0 +1,174 @@
+import './style.css';
+import { getCurrentScope, onScopeDispose, shallowReadonly, shallowRef } from "vue";
+//#region src/families/overlays/motion/motion-adapters.ts
+const invalidOptionDiagnostic = "VIZE_UI_MOTION_OPTION";
+const setupDiagnostic = "VIZE_UI_MOTION_SETUP";
+const reducedMotionQuery = "(prefers-reduced-motion: reduce)";
+/** Whether the current environment matches `prefers-reduced-motion: reduce`. */
+function prefersReducedMotion() {
+	if (typeof globalThis.matchMedia !== "function") return false;
+	return globalThis.matchMedia(reducedMotionQuery).matches;
+}
+/** Whether this environment can run native document view transitions. */
+function supportsViewTransitions() {
+	if (typeof document === "undefined") return false;
+	return typeof document.startViewTransition === "function";
+}
+/** Whether this environment supports `@starting-style` first-render transitions. */
+function supportsStartingStyle() {
+	return "CSSStartingStyleRule" in globalThis;
+}
+/** Whether this environment supports scroll-driven animation timelines. */
+function supportsScrollDrivenAnimations() {
+	if (typeof CSS === "undefined" || typeof CSS.supports !== "function") return false;
+	return CSS.supports("animation-timeline: scroll()");
+}
+function readBoolean(value, fallback) {
+	if (value === void 0) return fallback;
+	if (typeof value !== "boolean") throw new TypeError(`${invalidOptionDiagnostic}: respectReducedMotion must be a boolean`);
+	return value;
+}
+function toHandledVoid(promise) {
+	const result = promise.then(() => void 0);
+	result.catch(() => void 0);
+	return result;
+}
+/**
+* Run a DOM update through the View Transitions API when available.
+*
+* SSR-safe: without a document, without native support, or under reduced
+* motion (unless opted out) the update runs directly and the handle resolves
+* once it completes, so callers write one code path for every platform.
+*/
+function startViewTransition(update, options = {}) {
+	if (typeof update !== "function") throw new TypeError(`${invalidOptionDiagnostic}: update must be a function`);
+	const respectReducedMotion = readBoolean(options.respectReducedMotion, true);
+	if (!supportsViewTransitions() || respectReducedMotion && prefersReducedMotion()) {
+		const updateCallbackDone = toHandledVoid(Promise.resolve().then(update));
+		return Object.freeze({
+			native: false,
+			finished: updateCallbackDone,
+			ready: updateCallbackDone,
+			updateCallbackDone,
+			skipTransition: () => void 0
+		});
+	}
+	const transition = document.startViewTransition?.(() => Promise.resolve(update()).then(() => void 0));
+	if (transition === void 0) throw new Error(`${invalidOptionDiagnostic}: the platform revoked view transition support`);
+	return Object.freeze({
+		native: true,
+		finished: toHandledVoid(transition.finished),
+		ready: toHandledVoid(transition.ready),
+		updateCallbackDone: toHandledVoid(transition.updateCallbackDone),
+		skipTransition: () => {
+			transition.skipTransition();
+		}
+	});
+}
+/**
+* Reactive `prefers-reduced-motion` state for motion policy decisions.
+*
+* SSR-safe: without `matchMedia` the ref stays `false`. The media listener is
+* released with the current Vue effect scope.
+*/
+function useReducedMotion() {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const reduced = shallowRef(false);
+	if (typeof globalThis.matchMedia === "function") {
+		const query = globalThis.matchMedia(reducedMotionQuery);
+		reduced.value = query.matches;
+		const onChange = (event) => {
+			reduced.value = event.matches;
+		};
+		query.addEventListener("change", onChange);
+		onScopeDispose(() => {
+			query.removeEventListener("change", onChange);
+		});
+	}
+	return shallowReadonly(reduced);
+}
+//#endregion
+//#region src/families/overlays/motion/motion-tokens.ts
+const invalidTokenDiagnostic = "VIZE_UI_MOTION_TOKEN";
+/**
+* Duration tokens mirrored from `motion.css`.
+*
+* The packaged stylesheet is the source of truth; these mirrors exist so
+* JavaScript consumers can read the same scale the CSS ships with.
+*/
+const motionDurations = Object.freeze({
+	instant: "0ms",
+	fast: "120ms",
+	base: "200ms",
+	slow: "320ms",
+	deliberate: "480ms"
+});
+/** Delay tokens mirrored from `motion.css`. */
+const motionDelays = Object.freeze({
+	none: "0ms",
+	hint: "40ms",
+	stagger: "24ms"
+});
+/** Named easing curves mirrored from `motion.css`. */
+const motionEasings = Object.freeze({
+	standard: "cubic-bezier(0.2, 0, 0, 1)",
+	decelerate: "cubic-bezier(0.1, 0, 0, 1)",
+	accelerate: "cubic-bezier(0.45, 0, 1, 1)",
+	emphasized: "cubic-bezier(0.34, 1.3, 0.32, 1)",
+	linear: "linear"
+});
+const recipeHooks = [
+	"enter-duration",
+	"enter-easing",
+	"exit-duration",
+	"exit-easing",
+	"move-duration",
+	"move-easing",
+	"emphasis-duration",
+	"emphasis-easing",
+	"slide-distance",
+	"scale-from"
+];
+const tokenNames = new Set([
+	...Object.keys(motionDurations).map((token) => `duration-${token}`),
+	...Object.keys(motionDelays).map((token) => `delay-${token}`),
+	...Object.keys(motionEasings).map((token) => `ease-${token}`),
+	...recipeHooks
+]);
+function assertTokenName(name) {
+	if (!tokenNames.has(name)) throw new TypeError(`${invalidTokenDiagnostic}: unknown motion token "${name}"`);
+}
+/** Custom-property name (`--vize-ui-motion-*`) for one motion token. */
+function motionTokenProperty(name) {
+	assertTokenName(name);
+	return `--vize-ui-motion-${name}`;
+}
+/** `var()` reference to one motion token for imperative style composition. */
+function motionTokenVar(name) {
+	return `var(${motionTokenProperty(name)})`;
+}
+/**
+* Override motion tokens on one element's subtree.
+*
+* Custom properties inherit, so scoping an override to an element retunes
+* every recipe below it — replacing a curve without forking a component.
+* Returns a restore function that reinstates the element's previous values.
+*/
+function setMotionTokens(element, overrides) {
+	if (typeof element?.style?.setProperty !== "function") throw new TypeError(`${invalidTokenDiagnostic}: overrides need an element with inline style`);
+	const previous = /* @__PURE__ */ new Map();
+	for (const [name, value] of Object.entries(overrides)) {
+		if (value === void 0) continue;
+		if (typeof value !== "string" || value.trim().length === 0) throw new TypeError(`${invalidTokenDiagnostic}: token "${name}" needs a non-empty string`);
+		const property = motionTokenProperty(name);
+		if (!previous.has(property)) previous.set(property, element.style.getPropertyValue(property));
+		element.style.setProperty(property, value);
+	}
+	return () => {
+		for (const [property, value] of previous) if (value === "") element.style.removeProperty(property);
+		else element.style.setProperty(property, value);
+		previous.clear();
+	};
+}
+//#endregion
+export { motionTokenVar as a, startViewTransition as c, supportsViewTransitions as d, useReducedMotion as f, motionTokenProperty as i, supportsScrollDrivenAnimations as l, motionDurations as n, setMotionTokens as o, motionEasings as r, prefersReducedMotion as s, motionDelays as t, supportsStartingStyle as u };

package/dist/motion-iUSBdWaI.d.mts

@@ -0,0 +1,98 @@
+import { ShallowRef } from "vue";
+
+//#region src/families/overlays/motion/motion-types.d.ts
+/** Named steps on the motion duration scale. */
+type MotionDurationToken = "instant" | "fast" | "base" | "slow" | "deliberate";
+/** Named steps on the motion delay scale. */
+type MotionDelayToken = "none" | "hint" | "stagger";
+/** Named easing curves. */
+type MotionEasingToken = "standard" | "decelerate" | "accelerate" | "emphasized" | "linear";
+/** Enter/exit recipes understood by the presence and transition primitives. */
+type MotionEnterExitRecipe = "fade" | "scale" | "slide";
+/** Every recipe name accepted in the space-separated `data-vize-motion` attribute. */
+type MotionRecipe = MotionEnterExitRecipe | "enter" | "move" | "pulse" | "shake" | "reveal";
+/** Recipe hook properties that retune one motion phase without forking components. */
+type MotionRecipeHook = "enter-duration" | "enter-easing" | "exit-duration" | "exit-easing" | "move-duration" | "move-easing" | "emphasis-duration" | "emphasis-easing" | "slide-distance" | "scale-from";
+/** Suffix of one `--vize-ui-motion-*` custom property. */
+type MotionTokenName = `duration-${MotionDurationToken}` | `delay-${MotionDelayToken}` | `ease-${MotionEasingToken}` | MotionRecipeHook;
+/** Custom-property overrides applied by {@link setMotionTokens}. */
+type MotionTokenOverrides = { readonly [Name in MotionTokenName]?: string };
+/** Options accepted by {@link startViewTransition}. */
+interface StartViewTransitionOptions {
+  /**
+   * Skip the native crossfade and apply the update directly when
+   * `prefers-reduced-motion: reduce` matches.
+   *
+   * @default true
+   */
+  readonly respectReducedMotion?: boolean;
+}
+/** Normalized handle returned by {@link startViewTransition} on every platform. */
+interface ViewTransitionHandle {
+  /** Whether a native document view transition is driving the update. */
+  readonly native: boolean;
+  /** Resolves when the transition and its animations have finished. */
+  readonly finished: Promise<void>;
+  /**
+   * Resolves when transition animations are about to start. Rejects when the
+   * browser skips the transition; the rejection is pre-handled so ignoring
+   * `ready` never surfaces an unhandled rejection.
+   */
+  readonly ready: Promise<void>;
+  /** Resolves when the DOM update callback has run to completion. */
+  readonly updateCallbackDone: Promise<void>;
+  /** Skip remaining animations while still applying the DOM update. */
+  readonly skipTransition: () => void;
+}
+//#endregion
+//#region src/families/overlays/motion/motion-adapters.d.ts
+/** Whether the current environment matches `prefers-reduced-motion: reduce`. */
+declare function prefersReducedMotion(): boolean;
+/** Whether this environment can run native document view transitions. */
+declare function supportsViewTransitions(): boolean;
+/** Whether this environment supports `@starting-style` first-render transitions. */
+declare function supportsStartingStyle(): boolean;
+/** Whether this environment supports scroll-driven animation timelines. */
+declare function supportsScrollDrivenAnimations(): boolean;
+/**
+ * Run a DOM update through the View Transitions API when available.
+ *
+ * SSR-safe: without a document, without native support, or under reduced
+ * motion (unless opted out) the update runs directly and the handle resolves
+ * once it completes, so callers write one code path for every platform.
+ */
+declare function startViewTransition(update: () => void | Promise<void>, options?: StartViewTransitionOptions): ViewTransitionHandle;
+/**
+ * Reactive `prefers-reduced-motion` state for motion policy decisions.
+ *
+ * SSR-safe: without `matchMedia` the ref stays `false`. The media listener is
+ * released with the current Vue effect scope.
+ */
+declare function useReducedMotion(): Readonly<ShallowRef<boolean>>;
+//#endregion
+//#region src/families/overlays/motion/motion-tokens.d.ts
+/**
+ * Duration tokens mirrored from `motion.css`.
+ *
+ * The packaged stylesheet is the source of truth; these mirrors exist so
+ * JavaScript consumers can read the same scale the CSS ships with.
+ */
+declare const motionDurations: Readonly<Record<MotionDurationToken, string>>;
+/** Delay tokens mirrored from `motion.css`. */
+declare const motionDelays: Readonly<Record<MotionDelayToken, string>>;
+/** Named easing curves mirrored from `motion.css`. */
+declare const motionEasings: Readonly<Record<MotionEasingToken, string>>;
+/** Custom-property name (`--vize-ui-motion-*`) for one motion token. */
+declare function motionTokenProperty(name: MotionTokenName): string;
+/** `var()` reference to one motion token for imperative style composition. */
+declare function motionTokenVar(name: MotionTokenName): string;
+/**
+ * Override motion tokens on one element's subtree.
+ *
+ * Custom properties inherit, so scoping an override to an element retunes
+ * every recipe below it — replacing a curve without forking a component.
+ * Returns a restore function that reinstates the element's previous values.
+ */
+declare function setMotionTokens(element: ElementCSSInlineStyle, overrides: MotionTokenOverrides): () => void;
+//#endregion
+export { ViewTransitionHandle as S, MotionRecipe as _, motionTokenVar as a, MotionTokenOverrides as b, startViewTransition as c, supportsViewTransitions as d, useReducedMotion as f, MotionEnterExitRecipe as g, MotionEasingToken as h, motionTokenProperty as i, supportsScrollDrivenAnimations as l, MotionDurationToken as m, motionDurations as n, setMotionTokens as o, MotionDelayToken as p, motionEasings as r, prefersReducedMotion as s, motionDelays as t, supportsStartingStyle as u, MotionRecipeHook as v, StartViewTransitionOptions as x, MotionTokenName as y };