@vizejs/composable 0.302.0

package/dist/index.d.mts

@@ -0,0 +1,228 @@
+import { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from "vue";
+
+//#region src/async-resource.d.ts
+/** Lifecycle state of an asynchronous resource. */
+type AsyncResourceStatus = "idle" | "pending" | "success" | "error" | "cancelled";
+/** Context supplied to an asynchronous resource loader. */
+interface AsyncResourceContext {
+  /** Signal aborted by cancellation, reset, scope disposal, or a newer execution. */
+  readonly signal: AbortSignal;
+}
+/** Explicit result of one asynchronous resource execution. */
+type AsyncResourceExecution<Data, Failure> = {
+  readonly status: "success";
+  readonly data: Data;
+} | {
+  readonly status: "error";
+  readonly error: Failure;
+} | {
+  readonly status: "cancelled";
+  readonly reason: unknown;
+} | {
+  readonly status: "superseded";
+};
+/** Options for {@link useAsyncResource}. */
+interface UseAsyncResourceOptions<Data> {
+  /**
+   * Initial data restored by {@link AsyncResource.reset}.
+   *
+   * @default undefined
+   */
+  readonly initialData?: Data;
+  /**
+   * Abort the active execution when a newer execution starts.
+   *
+   * @default true
+   */
+  readonly cancelPrevious?: boolean;
+  /**
+   * Retain the current data while a new execution is pending.
+   *
+   * @default true
+   */
+  readonly keepData?: boolean;
+  /**
+   * Cancel an active execution when the current reactive scope is disposed.
+   *
+   * @default true
+   */
+  readonly scope?: boolean;
+}
+/** Reactive state and controls for an asynchronous loader. */
+interface AsyncResource<Data, Arguments extends readonly unknown[], Failure> {
+  readonly data: Readonly<ShallowRef<Data | undefined>>;
+  readonly error: Readonly<ShallowRef<Failure | undefined>>;
+  readonly status: Readonly<Ref<AsyncResourceStatus>>;
+  readonly pending: ComputedRef<boolean>;
+  readonly execute: (...arguments_: Arguments) => Promise<AsyncResourceExecution<Data, Failure>>;
+  readonly cancel: (reason?: unknown) => boolean;
+  readonly reset: () => void;
+}
+/**
+ * Create a scoped, abortable asynchronous resource with latest-result-wins
+ * state. Every execution returns a discriminated result, so cancellation,
+ * supersession, loader failure, and successful `undefined` data stay distinct.
+ */
+declare function useAsyncResource<Data, Arguments extends readonly unknown[], Failure = unknown>(loader: (context: AsyncResourceContext, ...arguments_: Arguments) => Promise<Data>, options?: UseAsyncResourceOptions<Data>): AsyncResource<Data, Arguments, Failure>;
+//#endregion
+//#region src/event-listener.d.ts
+/** Options for {@link useEventListener}. */
+interface UseEventListenerOptions {
+  /**
+   * Invoke the listener during the capture phase.
+   *
+   * @default false
+   */
+  readonly capture?: boolean;
+  /**
+   * Stop listening after the first event.
+   *
+   * @default false
+   */
+  readonly once?: boolean;
+  /**
+   * Declare that the listener does not cancel the event's default action.
+   *
+   * @default false
+   */
+  readonly passive?: boolean;
+  /**
+   * Stop listening when this signal is aborted.
+   *
+   * @default undefined
+   */
+  readonly signal?: AbortSignal;
+  /**
+   * Start listening during composable creation.
+   *
+   * @default true
+   */
+  readonly immediate?: boolean;
+  /**
+   * Reactive target update timing.
+   *
+   * @default "pre"
+   */
+  readonly flush?: "pre" | "post" | "sync";
+}
+/** Reactive controls returned by {@link useEventListener}. */
+interface EventListenerControls {
+  /** Whether a concrete target currently owns the listener. */
+  readonly isListening: Readonly<Ref<boolean>>;
+  /**
+   * Begin listening.
+   *
+   * @returns Whether a new reactive listener was started.
+   */
+  readonly start: () => boolean;
+  /** Stop listening. Repeated calls are safe. */
+  readonly stop: () => void;
+}
+/**
+ * Attach an event listener to a reactive target and clean it up with the
+ * current reactive scope. Missing targets are valid during server rendering.
+ *
+ * @param target Reactive event target.
+ * @param event Event name.
+ * @param listener Typed event listener.
+ * @param options Listener lifecycle and scheduling options.
+ * @default options {}
+ */
+declare function useEventListener<Key extends keyof WindowEventMap>(target: MaybeRefOrGetter<Window | null | undefined>, event: Key, listener: (event: WindowEventMap[Key]) => void, options?: UseEventListenerOptions): EventListenerControls;
+declare function useEventListener<Key extends keyof DocumentEventMap>(target: MaybeRefOrGetter<Document | null | undefined>, event: Key, listener: (event: DocumentEventMap[Key]) => void, options?: UseEventListenerOptions): EventListenerControls;
+declare function useEventListener<Key extends keyof HTMLElementEventMap>(target: MaybeRefOrGetter<HTMLElement | null | undefined>, event: Key, listener: (event: HTMLElementEventMap[Key]) => void, options?: UseEventListenerOptions): EventListenerControls;
+declare function useEventListener(target: MaybeRefOrGetter<EventTarget | null | undefined>, event: string, listener: EventListener, options?: UseEventListenerOptions): EventListenerControls;
+//#endregion
+//#region src/locale.d.ts
+/** Text flow reported by the internationalization runtime. */
+type TextDirection = "ltr" | "rtl";
+/** Locale selection options for {@link useLocale}. */
+interface UseLocaleOptions {
+  /**
+   * Locale detector used when the reactive source has no value.
+   *
+   * @default navigator.language when available; otherwise undefined
+   */
+  readonly detect?: () => Intl.Locale | string | null | undefined;
+  /**
+   * Locale used when neither the source nor detector provides one.
+   *
+   * @default "en"
+   */
+  readonly fallback?: Intl.Locale | string;
+}
+/** Reactive locale metadata and cached formatter factories. */
+interface LocaleControls {
+  /** Canonical Unicode locale identifier. */
+  readonly locale: ComputedRef<string>;
+  /** Parsed locale details supplied by the internationalization runtime. */
+  readonly details: ComputedRef<Intl.Locale>;
+  /** Native writing direction for the active locale. */
+  readonly direction: ComputedRef<TextDirection>;
+  /** Return a cached number formatter for the active locale and options. */
+  readonly number: (options?: Intl.NumberFormatOptions) => Intl.NumberFormat;
+  /** Return a cached date and time formatter for the active locale and options. */
+  readonly dateTime: (options?: Intl.DateTimeFormatOptions) => Intl.DateTimeFormat;
+  /** Return a cached list formatter for the active locale and options. */
+  readonly list: (options?: Intl.ListFormatOptions) => Intl.ListFormat;
+  /** Return a cached relative-time formatter for the active locale and options. */
+  readonly relativeTime: (options?: Intl.RelativeTimeFormatOptions) => Intl.RelativeTimeFormat;
+}
+/**
+ * Create reactive locale metadata and platform-native formatter factories.
+ *
+ * Equivalent formatter options reuse instances. The bounded cache follows the
+ * active locale automatically and prevents repeated constructor overhead in
+ * reactive render paths.
+ */
+declare function useLocale(source?: MaybeRefOrGetter<Intl.Locale | string | null | undefined>, options?: UseLocaleOptions): LocaleControls;
+//#endregion
+//#region src/media-query.d.ts
+/** Capability required to evaluate media queries. */
+interface MediaQueryHost {
+  /** Create an observable result for a media query. */
+  readonly matchMedia: (query: string) => MediaQueryList;
+}
+/** Options for {@link useMediaQuery}. */
+interface UseMediaQueryOptions {
+  /**
+   * Value exposed when no media-query capability is available.
+   *
+   * @default false
+   */
+  readonly ssrValue?: boolean;
+  /**
+   * Reactive media-query capability for alternate runtimes and tests.
+   *
+   * @default globalThis.window when available
+   */
+  readonly host?: MaybeRefOrGetter<MediaQueryHost | null | undefined>;
+}
+/**
+ * Evaluate a reactive media query without requiring browser globals.
+ *
+ * @param query Reactive media-query source.
+ * @param options Runtime capability and server-rendered fallback.
+ * @default options {}
+ */
+declare function useMediaQuery(query: MaybeRefOrGetter<string>, options?: UseMediaQueryOptions): Readonly<Ref<boolean>>;
+/** User motion preference exposed by {@link useReducedMotion}. */
+type MotionPreference = "reduce" | "no-preference";
+/**
+ * Return the reactive user motion preference.
+ *
+ * @param options Runtime capability and server-rendered fallback.
+ * @default options {}
+ */
+declare function useReducedMotion(options?: UseMediaQueryOptions): ComputedRef<MotionPreference>;
+//#endregion
+//#region src/scope.d.ts
+/**
+ * Register cleanup in the active reactive scope when one exists.
+ *
+ * @param cleanup Cleanup invoked exactly once when the scope is disposed.
+ * @returns Whether the cleanup was registered.
+ */
+declare function tryOnScopeDispose(cleanup: () => void): boolean;
+//#endregion
+export { AsyncResource, AsyncResourceContext, AsyncResourceExecution, AsyncResourceStatus, EventListenerControls, LocaleControls, MediaQueryHost, MotionPreference, TextDirection, UseAsyncResourceOptions, UseEventListenerOptions, UseLocaleOptions, UseMediaQueryOptions, tryOnScopeDispose, useAsyncResource, useEventListener, useLocale, useMediaQuery, useReducedMotion };

package/dist/index.mjs

@@ -0,0 +1,244 @@
+import { computed, getCurrentScope, onScopeDispose, readonly, ref, shallowRef, toValue, watch, watchEffect } from "vue";
+//#region src/scope.ts
+/**
+* Register cleanup in the active reactive scope when one exists.
+*
+* @param cleanup Cleanup invoked exactly once when the scope is disposed.
+* @returns Whether the cleanup was registered.
+*/
+function tryOnScopeDispose(cleanup) {
+	if (!getCurrentScope()) return false;
+	onScopeDispose(cleanup);
+	return true;
+}
+//#endregion
+//#region src/async-resource.ts
+/**
+* Create a scoped, abortable asynchronous resource with latest-result-wins
+* state. Every execution returns a discriminated result, so cancellation,
+* supersession, loader failure, and successful `undefined` data stay distinct.
+*/
+function useAsyncResource(loader, options = {}) {
+	const data = shallowRef(options.initialData);
+	const error = shallowRef(void 0);
+	const status = shallowRef("idle");
+	const pending = computed(() => status.value === "pending");
+	let generation = 0;
+	let active;
+	const cancel = (reason = createAbortReason("The execution was cancelled.")) => {
+		if (active === void 0) return false;
+		generation += 1;
+		active.controller.abort(reason);
+		active = void 0;
+		status.value = "cancelled";
+		return true;
+	};
+	const execute = async (...arguments_) => {
+		if ((options.cancelPrevious ?? true) && active !== void 0) {
+			active.superseded = true;
+			active.controller.abort(createAbortReason("A newer execution started."));
+		}
+		const record = {
+			generation: ++generation,
+			controller: new AbortController(),
+			superseded: false
+		};
+		active = record;
+		error.value = void 0;
+		status.value = "pending";
+		if (!(options.keepData ?? true)) data.value = void 0;
+		try {
+			const result = await loader({ signal: record.controller.signal }, ...arguments_);
+			if (record.generation !== generation) return executionAfterInvalidation(record);
+			data.value = result;
+			status.value = "success";
+			return {
+				status: "success",
+				data: result
+			};
+		} catch (cause) {
+			if (record.generation !== generation || record.controller.signal.aborted) return executionAfterInvalidation(record);
+			error.value = cause;
+			status.value = "error";
+			return {
+				status: "error",
+				error: cause
+			};
+		} finally {
+			if (active === record) active = void 0;
+		}
+	};
+	const reset = () => {
+		cancel(createAbortReason("The resource was reset."));
+		data.value = options.initialData;
+		error.value = void 0;
+		status.value = "idle";
+	};
+	if (options.scope ?? true) tryOnScopeDispose(() => cancel(createAbortReason("The reactive scope was disposed.")));
+	return {
+		data,
+		error,
+		status,
+		pending,
+		execute,
+		cancel,
+		reset
+	};
+}
+function executionAfterInvalidation(execution) {
+	if (execution.superseded || !execution.controller.signal.aborted) return { status: "superseded" };
+	return {
+		status: "cancelled",
+		reason: execution.controller.signal.reason
+	};
+}
+function createAbortReason(message) {
+	return new DOMException(message, "AbortError");
+}
+//#endregion
+//#region src/event-listener.ts
+function useEventListener(target, event, listener, options = {}) {
+	const { capture = false, once = false, passive = false, signal, immediate = true, flush = "pre" } = options;
+	const isListening = ref(false);
+	const eventOptions = {
+		capture,
+		passive,
+		...signal ? { signal } : {}
+	};
+	let stopWatch;
+	const stop = () => {
+		stopWatch?.stop();
+		stopWatch = void 0;
+		isListening.value = false;
+	};
+	const start = () => {
+		if (stopWatch || signal?.aborted) return false;
+		stopWatch = watch(() => toValue(target), (next, _previous, onCleanup) => {
+			isListening.value = false;
+			if (!next || signal?.aborted) return;
+			const invoke = (nativeEvent) => {
+				if (once) stop();
+				listener(nativeEvent);
+			};
+			const onAbort = () => stop();
+			next.addEventListener(event, invoke, eventOptions);
+			signal?.addEventListener("abort", onAbort, { once: true });
+			isListening.value = true;
+			onCleanup(() => {
+				next.removeEventListener(event, invoke, capture);
+				signal?.removeEventListener("abort", onAbort);
+				isListening.value = false;
+			});
+		}, {
+			flush,
+			immediate: true
+		});
+		return true;
+	};
+	tryOnScopeDispose(stop);
+	if (immediate) start();
+	return {
+		isListening: readonly(isListening),
+		start,
+		stop
+	};
+}
+//#endregion
+//#region src/locale.ts
+const FORMATTER_CACHE_LIMIT = 32;
+/**
+* Create reactive locale metadata and platform-native formatter factories.
+*
+* Equivalent formatter options reuse instances. The bounded cache follows the
+* active locale automatically and prevents repeated constructor overhead in
+* reactive render paths.
+*/
+function useLocale(source, options = {}) {
+	const locale = computed(() => {
+		const candidate = (source === void 0 ? void 0 : toValue(source)) ?? (options.detect ?? detectBrowserLocale)() ?? options.fallback ?? "en";
+		return candidate instanceof Intl.Locale ? candidate.toString() : new Intl.Locale(candidate).toString();
+	});
+	const details = computed(() => new Intl.Locale(locale.value));
+	const direction = computed(() => details.value.getTextInfo().direction);
+	const number = createFormatterCache((activeLocale, formatOptions) => new Intl.NumberFormat(activeLocale, formatOptions));
+	const dateTime = createFormatterCache((activeLocale, formatOptions) => new Intl.DateTimeFormat(activeLocale, formatOptions));
+	const list = createFormatterCache((activeLocale, formatOptions) => new Intl.ListFormat(activeLocale, formatOptions));
+	const relativeTime = createFormatterCache((activeLocale, formatOptions) => new Intl.RelativeTimeFormat(activeLocale, formatOptions));
+	return {
+		locale,
+		details,
+		direction,
+		number: (formatOptions) => number(locale.value, formatOptions),
+		dateTime: (formatOptions) => dateTime(locale.value, formatOptions),
+		list: (formatOptions) => list(locale.value, formatOptions),
+		relativeTime: (formatOptions) => relativeTime(locale.value, formatOptions)
+	};
+}
+function detectBrowserLocale() {
+	return typeof navigator === "undefined" ? void 0 : navigator.language;
+}
+function createFormatterCache(create) {
+	const cache = /* @__PURE__ */ new Map();
+	return (locale, options) => {
+		const key = `${locale}\u0000${serializeOptions(options)}`;
+		const cached = cache.get(key);
+		if (cached !== void 0) {
+			cache.delete(key);
+			cache.set(key, cached);
+			return cached;
+		}
+		const formatter = create(locale, options);
+		if (cache.size >= FORMATTER_CACHE_LIMIT) {
+			const oldest = cache.keys().next().value;
+			if (oldest !== void 0) cache.delete(oldest);
+		}
+		cache.set(key, formatter);
+		return formatter;
+	};
+}
+function serializeOptions(options) {
+	if (options === void 0) return "";
+	return JSON.stringify(Object.entries(options).sort(([left], [right]) => left.localeCompare(right)));
+}
+//#endregion
+//#region src/media-query.ts
+/**
+* Evaluate a reactive media query without requiring browser globals.
+*
+* @param query Reactive media-query source.
+* @param options Runtime capability and server-rendered fallback.
+* @default options {}
+*/
+function useMediaQuery(query, options = {}) {
+	const matches = ref(options.ssrValue ?? false);
+	watchEffect((onCleanup) => {
+		const host = options.host === void 0 ? browserMediaQueryHost() : toValue(options.host);
+		if (!host) {
+			matches.value = options.ssrValue ?? false;
+			return;
+		}
+		const media = host.matchMedia(toValue(query));
+		const update = () => {
+			matches.value = media.matches;
+		};
+		update();
+		media.addEventListener("change", update);
+		onCleanup(() => media.removeEventListener("change", update));
+	});
+	return readonly(matches);
+}
+/**
+* Return the reactive user motion preference.
+*
+* @param options Runtime capability and server-rendered fallback.
+* @default options {}
+*/
+function useReducedMotion(options = {}) {
+	const reduced = useMediaQuery("(prefers-reduced-motion: reduce)", options);
+	return computed(() => reduced.value ? "reduce" : "no-preference");
+}
+function browserMediaQueryHost() {
+	return typeof window !== "undefined" && typeof window.matchMedia === "function" ? window : void 0;
+}
+//#endregion
+export { tryOnScopeDispose, useAsyncResource, useEventListener, useLocale, useMediaQuery, useReducedMotion };

package/dist/temporal.d.mts

@@ -0,0 +1,90 @@
+import { ComputedRef, MaybeRefOrGetter, Ref } from "vue";
+import { Intl as TemporalIntl, Temporal } from "temporal-polyfill-lite";
+
+//#region src/temporal.d.ts
+/**
+ * Timer host used by {@link useTemporalNow}.
+ *
+ * Implement this interface to integrate a deterministic clock, a native
+ * runtime timer, or an application-owned scheduler.
+ */
+interface TemporalScheduler {
+  /** Starts a repeating callback and returns its opaque cancellation handle. */
+  readonly setInterval: (callback: () => void, intervalMs: number) => unknown;
+  /** Cancels a handle previously returned by {@link TemporalScheduler.setInterval}. */
+  readonly clearInterval: (handle: unknown) => void;
+}
+/** Options for {@link useTemporalNow}. */
+interface UseTemporalNowOptions {
+  /**
+   * Clock update interval in milliseconds.
+   *
+   * Reactive changes replace the active timer. Values must be finite and
+   * greater than zero.
+   *
+   * @default 1000
+   */
+  readonly intervalMs?: MaybeRefOrGetter<number>;
+  /**
+   * Pauses periodic updates while preserving the current instant.
+   * Manual calls to {@link TemporalClock.refresh} continue to work.
+   *
+   * @default false
+   */
+  readonly paused?: MaybeRefOrGetter<boolean>;
+  /**
+   * Starts the timer when no browser `window` is available.
+   *
+   * Keep this disabled during server rendering. Enable it for native,
+   * desktop, worker, and test runtimes whose scheduler is lifecycle-bound.
+   *
+   * @default false
+   */
+  readonly runOnServer?: MaybeRefOrGetter<boolean>;
+  /**
+   * Produces the current instant.
+   *
+   * @default Temporal.Now.instant
+   */
+  readonly now?: () => Temporal.Instant;
+  /**
+   * Owns the repeating timer.
+   *
+   * @default globalThis timer functions
+   */
+  readonly scheduler?: TemporalScheduler;
+}
+/** Reactive controls returned by {@link useTemporalNow}. */
+interface TemporalClock {
+  /** The latest instant. This ref is readonly to consumers. */
+  readonly instant: Readonly<Ref<Temporal.Instant>>;
+  /** Reads the clock source immediately, stores the value, and returns it. */
+  readonly refresh: () => Temporal.Instant;
+}
+/** Options for {@link useTemporalZonedDateTime}. */
+interface UseTemporalZonedDateTimeOptions extends UseTemporalNowOptions {
+  /**
+   * Time-zone identifier or zoned date-time accepted by Temporal.
+   *
+   * @default Temporal.Now.timeZoneId()
+   */
+  readonly timeZone?: MaybeRefOrGetter<Temporal.TimeZoneLike>;
+}
+/**
+ * Creates a pauseable Temporal clock whose timer follows the current Vue
+ * effect scope.
+ *
+ * The timer is replaced when reactive options change and is always cancelled
+ * when the owning scope stops. During server rendering, no timer starts unless
+ * {@link UseTemporalNowOptions.runOnServer} is explicitly enabled.
+ */
+declare function useTemporalNow(options?: UseTemporalNowOptions): TemporalClock;
+/**
+ * Creates a reactive zoned date-time derived from a scoped Temporal clock.
+ *
+ * Changes to {@link UseTemporalZonedDateTimeOptions.timeZone} are reflected
+ * without replacing the underlying timer.
+ */
+declare function useTemporalZonedDateTime(options?: UseTemporalZonedDateTimeOptions): ComputedRef<Temporal.ZonedDateTime>;
+//#endregion
+export { Temporal, TemporalClock, TemporalIntl, TemporalScheduler, UseTemporalNowOptions, UseTemporalZonedDateTimeOptions, useTemporalNow, useTemporalZonedDateTime };

package/dist/temporal.mjs

@@ -0,0 +1,61 @@
+import { computed, readonly, shallowRef, toValue, watchEffect } from "vue";
+import { Intl as TemporalIntl, Temporal } from "temporal-polyfill-lite";
+//#region src/temporal.ts
+const defaultScheduler = {
+	setInterval: (callback, intervalMs) => globalThis.setInterval(callback, intervalMs),
+	clearInterval: (handle) => {
+		globalThis.clearInterval(handle);
+	}
+};
+function resolveIntervalMs(value) {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`[VIZE_COMPOSE_TEMPORAL_INVALID_INTERVAL] intervalMs must be finite and greater than zero; received ${String(value)}`);
+	return Math.max(1, Math.trunc(value));
+}
+function shouldSchedule(options) {
+	if (toValue(options.paused ?? false)) return false;
+	return typeof window !== "undefined" || toValue(options.runOnServer ?? false);
+}
+/**
+* Creates a pauseable Temporal clock whose timer follows the current Vue
+* effect scope.
+*
+* The timer is replaced when reactive options change and is always cancelled
+* when the owning scope stops. During server rendering, no timer starts unless
+* {@link UseTemporalNowOptions.runOnServer} is explicitly enabled.
+*/
+function useTemporalNow(options = {}) {
+	const readNow = options.now ?? Temporal.Now.instant;
+	const instant = shallowRef(readNow());
+	if (shouldSchedule(options)) resolveIntervalMs(toValue(options.intervalMs ?? 1e3));
+	const refresh = () => {
+		const nextInstant = readNow();
+		instant.value = nextInstant;
+		return nextInstant;
+	};
+	watchEffect((onCleanup) => {
+		if (!shouldSchedule(options)) return;
+		const intervalMs = resolveIntervalMs(toValue(options.intervalMs ?? 1e3));
+		const scheduler = options.scheduler ?? defaultScheduler;
+		const handle = scheduler.setInterval(refresh, intervalMs);
+		onCleanup(() => scheduler.clearInterval(handle));
+	});
+	return {
+		instant: readonly(instant),
+		refresh
+	};
+}
+/**
+* Creates a reactive zoned date-time derived from a scoped Temporal clock.
+*
+* Changes to {@link UseTemporalZonedDateTimeOptions.timeZone} are reflected
+* without replacing the underlying timer.
+*/
+function useTemporalZonedDateTime(options = {}) {
+	const clock = useTemporalNow(options);
+	return computed(() => {
+		const timeZone = options.timeZone === void 0 ? Temporal.Now.timeZoneId() : toValue(options.timeZone);
+		return clock.instant.value.toZonedDateTimeISO(timeZone);
+	});
+}
+//#endregion
+export { Temporal, TemporalIntl, useTemporalNow, useTemporalZonedDateTime };

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@vizejs/composable",
+  "version": "0.302.0",
+  "description": "Lifecycle-safe composable foundations for Vize applications",
+  "keywords": [
+    "composables",
+    "lifecycle",
+    "type-safe",
+    "vize",
+    "vue"
+  ],
+  "homepage": "https://github.com/ubugeeei-prod/vize",
+  "bugs": {
+    "url": "https://github.com/ubugeeei-prod/vize/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ubugeeei-prod/vize.git",
+    "directory": "npm/compose/core"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./temporal": {
+      "types": "./dist/temporal.d.mts",
+      "import": "./dist/temporal.mjs",
+      "default": "./dist/temporal.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "pretest": "vp pack && pnpm check:size",
+    "test": "vp exec node --test 'src/**/*.test.ts'",
+    "check": "vp check src scripts vite.config.ts",
+    "check:fix": "vp check --fix src scripts vite.config.ts",
+    "check:size": "node scripts/check-size.mjs",
+    "fmt": "vp fmt --write src scripts vite.config.ts"
+  },
+  "dependencies": {
+    "temporal-polyfill-lite": "0.4.2"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:typescript",
+    "typescript": "catalog:typescript",
+    "vite-plus": "catalog:vite-stack",
+    "vue": "catalog:vue-stable"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.0"
+  },
+  "engines": {
+    "node": ">=24"
+  }
+}