@vizejs/composable 0.345.0 → 0.350.2

package/dist/catalog-CYHr82Jz.mjs

@@ -0,0 +1,529 @@
+//#region src/catalog-entries.ts
+/** Canonical runtime target ordering used by the catalog. */
+const allTargets = [
+	"web",
+	"server",
+	"worker",
+	"native",
+	"desktop",
+	"terminal"
+];
+/** Aggregate entry policy, including intentionally isolated subpaths. */
+const rootEntry = {
+	subpath: ".",
+	source: "src/index.ts",
+	gzipBudget: "sum-of-reexported-entry-budgets",
+	reexportedEntries: [
+		"./abort-signal",
+		"./async-resource",
+		"./capability",
+		"./catalog",
+		"./disposal-scope",
+		"./event-listener",
+		"./locale",
+		"./media-query",
+		"./retry-async",
+		"./retry-delay",
+		"./scope",
+		"./timeout-scheduler",
+		"./use-counter",
+		"./use-debounced",
+		"./use-history",
+		"./use-previous",
+		"./use-throttled",
+		"./use-toggle"
+	],
+	isolatedEntries: ["./temporal"]
+};
+/** Independently importable entries in package export-map order. */
+const entries = [
+	{
+		subpath: "./abort-signal",
+		source: "src/abort-signal.ts",
+		gzipBudgetBytes: 3 * 1024,
+		runtimeExports: [
+			"anyAbortSignal",
+			"timeoutAbortSignal",
+			"deadlineAbortSignal"
+		],
+		utilities: [
+			"anyAbortSignal",
+			"timeoutAbortSignal",
+			"deadlineAbortSignal"
+		]
+	},
+	{
+		subpath: "./async-resource",
+		source: "src/async-resource.ts",
+		gzipBudgetBytes: 2 * 1024,
+		runtimeExports: ["useAsyncResource"],
+		utilities: ["useAsyncResource"]
+	},
+	{
+		subpath: "./capability",
+		source: "src/capability.ts",
+		gzipBudgetBytes: 1024,
+		runtimeExports: [
+			"availableCapability",
+			"unavailableCapability",
+			"isCapabilityAvailable",
+			"isCapabilityUnavailable"
+		],
+		utilities: [
+			"availableCapability",
+			"unavailableCapability",
+			"isCapabilityAvailable",
+			"isCapabilityUnavailable"
+		]
+	},
+	{
+		subpath: "./catalog",
+		source: "src/catalog.ts",
+		gzipBudgetBytes: 4 * 1024,
+		runtimeExports: ["COMPOSABLE_CATALOG"],
+		utilities: []
+	},
+	{
+		subpath: "./disposal-scope",
+		source: "src/disposal-scope.ts",
+		gzipBudgetBytes: 2 * 1024,
+		runtimeExports: [
+			"DISPOSAL_ERROR_CODE",
+			"DisposalError",
+			"createDisposalScope"
+		],
+		utilities: ["createDisposalScope"]
+	},
+	{
+		subpath: "./event-listener",
+		source: "src/event-listener.ts",
+		gzipBudgetBytes: 2 * 1024,
+		runtimeExports: ["useEventListener"],
+		utilities: ["useEventListener"]
+	},
+	{
+		subpath: "./locale",
+		source: "src/locale.ts",
+		gzipBudgetBytes: 2 * 1024,
+		runtimeExports: ["useLocale"],
+		utilities: ["useLocale"]
+	},
+	{
+		subpath: "./media-query",
+		source: "src/media-query.ts",
+		gzipBudgetBytes: 1024,
+		runtimeExports: ["useMediaQuery", "useReducedMotion"],
+		utilities: ["useMediaQuery", "useReducedMotion"]
+	},
+	{
+		subpath: "./retry-async",
+		source: "src/retry-async.ts",
+		gzipBudgetBytes: 5.5 * 1024,
+		runtimeExports: ["retryAsync"],
+		utilities: ["retryAsync"]
+	},
+	{
+		subpath: "./retry-delay",
+		source: "src/retry-delay.ts",
+		gzipBudgetBytes: 1.5 * 1024,
+		runtimeExports: ["calculateRetryDelay"],
+		utilities: ["calculateRetryDelay"]
+	},
+	{
+		subpath: "./scope",
+		source: "src/scope.ts",
+		gzipBudgetBytes: .5 * 1024,
+		runtimeExports: ["tryOnScopeDispose"],
+		utilities: ["tryOnScopeDispose"]
+	},
+	{
+		subpath: "./temporal",
+		source: "src/temporal.ts",
+		gzipBudgetBytes: 2 * 1024,
+		runtimeExports: [
+			"Temporal",
+			"TemporalIntl",
+			"useTemporalNow",
+			"useTemporalZonedDateTime"
+		],
+		utilities: ["useTemporalNow", "useTemporalZonedDateTime"]
+	},
+	{
+		subpath: "./timeout-scheduler",
+		source: "src/timeout-scheduler.ts",
+		gzipBudgetBytes: .25 * 1024,
+		runtimeExports: [],
+		utilities: []
+	},
+	{
+		subpath: "./use-counter",
+		source: "src/use-counter.ts",
+		gzipBudgetBytes: 1.5 * 1024,
+		runtimeExports: ["useCounter"],
+		utilities: ["useCounter"]
+	},
+	{
+		subpath: "./use-debounced",
+		source: "src/use-debounced.ts",
+		gzipBudgetBytes: 2 * 1024,
+		runtimeExports: ["useDebounced"],
+		utilities: ["useDebounced"]
+	},
+	{
+		subpath: "./use-history",
+		source: "src/use-history.ts",
+		gzipBudgetBytes: 2.5 * 1024,
+		runtimeExports: ["useHistory"],
+		utilities: ["useHistory"]
+	},
+	{
+		subpath: "./use-previous",
+		source: "src/use-previous.ts",
+		gzipBudgetBytes: 1024,
+		runtimeExports: ["usePrevious"],
+		utilities: ["usePrevious"]
+	},
+	{
+		subpath: "./use-throttled",
+		source: "src/use-throttled.ts",
+		gzipBudgetBytes: 2.5 * 1024,
+		runtimeExports: ["useThrottled"],
+		utilities: ["useThrottled"]
+	},
+	{
+		subpath: "./use-toggle",
+		source: "src/use-toggle.ts",
+		gzipBudgetBytes: .5 * 1024,
+		runtimeExports: ["useToggle"],
+		utilities: ["useToggle"]
+	}
+];
+//#endregion
+//#region src/catalog-utilities.ts
+const reactiveTargets = allTargets;
+const browserTargets = ["web", "desktop"];
+//#endregion
+//#region src/catalog.ts
+/**
+* Complete, serializable catalog of the package's public runtime surface.
+*
+* This value is the source of truth for export-map conformance and compressed
+* size gates. It intentionally contains data only: importing the module reads
+* no host globals, creates no subscriptions, and starts no work. Utilities
+* remain marked experimental while the package is pre-1.0. Source-copy
+* installation is reported as unavailable until a deterministic installer
+* with update provenance exists.
+*/
+const COMPOSABLE_CATALOG = {
+	schemaVersion: 1,
+	catalogStability: "stable",
+	packageName: "@vizejs/composable",
+	targets: allTargets,
+	packageInstallation: {
+		status: "available",
+		specifier: "@vizejs/composable"
+	},
+	sourceInstallation: {
+		status: "unavailable",
+		reason: "A provenance-preserving source-copy installer is not implemented."
+	},
+	rootEntry,
+	entries,
+	utilities: [
+		{
+			name: "anyAbortSignal",
+			entry: "./abort-signal",
+			category: "async",
+			stability: "experimental",
+			targets: allTargets,
+			ssr: "safe",
+			hydration: "not-applicable",
+			cleanupOwners: ["returned-value"],
+			runtimeGlobals: ["AbortController", "AbortSignal"],
+			dependencies: []
+		},
+		{
+			name: "timeoutAbortSignal",
+			entry: "./abort-signal",
+			category: "timing",
+			stability: "experimental",
+			targets: allTargets,
+			ssr: "safe",
+			hydration: "not-applicable",
+			cleanupOwners: ["returned-value"],
+			runtimeGlobals: [
+				"AbortController",
+				"AbortSignal",
+				"DOMException",
+				"globalThis"
+			],
+			dependencies: ["anyAbortSignal"]
+		},
+		{
+			name: "deadlineAbortSignal",
+			entry: "./abort-signal",
+			category: "timing",
+			stability: "experimental",
+			targets: allTargets,
+			ssr: "safe",
+			hydration: "not-applicable",
+			cleanupOwners: ["returned-value"],
+			runtimeGlobals: [],
+			dependencies: ["timeoutAbortSignal"]
+		},
+		{
+			name: "useAsyncResource",
+			entry: "./async-resource",
+			category: "async",
+			stability: "experimental",
+			targets: reactiveTargets,
+			ssr: "safe",
+			hydration: "stable",
+			cleanupOwners: ["caller", "reactive-scope"],
+			runtimeGlobals: ["AbortController", "DOMException"],
+			dependencies: ["tryOnScopeDispose"]
+		},
+		{
+			name: "availableCapability",
+			entry: "./capability",
+			category: "capability",
+			stability: "experimental",
+			targets: allTargets,
+			ssr: "safe",
+			hydration: "not-applicable",
+			cleanupOwners: ["none"],
+			runtimeGlobals: [],
+			dependencies: []
+		},
+		{
+			name: "unavailableCapability",
+			entry: "./capability",
+			category: "capability",
+			stability: "experimental",
+			targets: allTargets,
+			ssr: "safe",
+			hydration: "not-applicable",
+			cleanupOwners: ["none"],
+			runtimeGlobals: [],
+			dependencies: []
+		},
+		{
+			name: "isCapabilityAvailable",
+			entry: "./capability",
+			category: "capability",
+			stability: "experimental",
+			targets: allTargets,
+			ssr: "safe",
+			hydration: "not-applicable",
+			cleanupOwners: ["none"],
+			runtimeGlobals: [],
+			dependencies: []
+		},
+		{
+			name: "isCapabilityUnavailable",
+			entry: "./capability",
+			category: "capability",
+			stability: "experimental",
+			targets: allTargets,
+			ssr: "safe",
+			hydration: "not-applicable",
+			cleanupOwners: ["none"],
+			runtimeGlobals: [],
+			dependencies: []
+		},
+		{
+			name: "createDisposalScope",
+			entry: "./disposal-scope",
+			category: "lifecycle",
+			stability: "experimental",
+			targets: reactiveTargets,
+			ssr: "safe",
+			hydration: "not-applicable",
+			cleanupOwners: ["caller", "reactive-scope"],
+			runtimeGlobals: [],
+			dependencies: ["tryOnScopeDispose"]
+		},
+		{
+			name: "useEventListener",
+			entry: "./event-listener",
+			category: "events",
+			stability: "experimental",
+			targets: reactiveTargets,
+			ssr: "safe",
+			hydration: "stable",
+			cleanupOwners: ["caller", "reactive-scope"],
+			runtimeGlobals: [],
+			dependencies: ["tryOnScopeDispose"]
+		},
+		{
+			name: "useLocale",
+			entry: "./locale",
+			category: "i18n",
+			stability: "experimental",
+			targets: reactiveTargets,
+			ssr: "deterministic-fallback",
+			hydration: "caller-managed",
+			cleanupOwners: ["none"],
+			runtimeGlobals: ["Intl", "navigator"],
+			dependencies: []
+		},
+		{
+			name: "useMediaQuery",
+			entry: "./media-query",
+			category: "media",
+			stability: "experimental",
+			targets: browserTargets,
+			ssr: "deterministic-fallback",
+			hydration: "caller-managed",
+			cleanupOwners: ["reactive-scope"],
+			runtimeGlobals: ["window"],
+			dependencies: []
+		},
+		{
+			name: "useReducedMotion",
+			entry: "./media-query",
+			category: "media",
+			stability: "experimental",
+			targets: browserTargets,
+			ssr: "deterministic-fallback",
+			hydration: "caller-managed",
+			cleanupOwners: ["reactive-scope"],
+			runtimeGlobals: ["window"],
+			dependencies: ["useMediaQuery"]
+		},
+		{
+			name: "retryAsync",
+			entry: "./retry-async",
+			category: "async",
+			stability: "experimental",
+			targets: allTargets,
+			ssr: "safe",
+			hydration: "not-applicable",
+			cleanupOwners: ["returned-value"],
+			runtimeGlobals: ["AbortController"],
+			dependencies: ["timeoutAbortSignal", "calculateRetryDelay"]
+		},
+		{
+			name: "calculateRetryDelay",
+			entry: "./retry-delay",
+			category: "timing",
+			stability: "experimental",
+			targets: allTargets,
+			ssr: "safe",
+			hydration: "not-applicable",
+			cleanupOwners: ["none"],
+			runtimeGlobals: [],
+			dependencies: []
+		},
+		{
+			name: "tryOnScopeDispose",
+			entry: "./scope",
+			category: "lifecycle",
+			stability: "experimental",
+			targets: reactiveTargets,
+			ssr: "safe",
+			hydration: "not-applicable",
+			cleanupOwners: ["reactive-scope"],
+			runtimeGlobals: [],
+			dependencies: []
+		},
+		{
+			name: "useTemporalNow",
+			entry: "./temporal",
+			category: "timing",
+			stability: "experimental",
+			targets: reactiveTargets,
+			ssr: "deterministic-fallback",
+			hydration: "caller-managed",
+			cleanupOwners: ["reactive-scope"],
+			runtimeGlobals: ["globalThis", "window"],
+			dependencies: []
+		},
+		{
+			name: "useTemporalZonedDateTime",
+			entry: "./temporal",
+			category: "timing",
+			stability: "experimental",
+			targets: reactiveTargets,
+			ssr: "deterministic-fallback",
+			hydration: "caller-managed",
+			cleanupOwners: ["reactive-scope"],
+			runtimeGlobals: ["globalThis", "window"],
+			dependencies: ["useTemporalNow"]
+		},
+		{
+			name: "useCounter",
+			entry: "./use-counter",
+			category: "state",
+			stability: "experimental",
+			targets: reactiveTargets,
+			ssr: "safe",
+			hydration: "stable",
+			cleanupOwners: ["none"],
+			runtimeGlobals: [],
+			dependencies: []
+		},
+		{
+			name: "useDebounced",
+			entry: "./use-debounced",
+			category: "timing",
+			stability: "experimental",
+			targets: reactiveTargets,
+			ssr: "deterministic-fallback",
+			hydration: "stable",
+			cleanupOwners: ["caller", "reactive-scope"],
+			runtimeGlobals: ["globalThis", "window"],
+			dependencies: ["tryOnScopeDispose"]
+		},
+		{
+			name: "useHistory",
+			entry: "./use-history",
+			category: "state",
+			stability: "experimental",
+			targets: reactiveTargets,
+			ssr: "safe",
+			hydration: "stable",
+			cleanupOwners: ["reactive-scope"],
+			runtimeGlobals: [],
+			dependencies: ["tryOnScopeDispose"]
+		},
+		{
+			name: "usePrevious",
+			entry: "./use-previous",
+			category: "state",
+			stability: "experimental",
+			targets: reactiveTargets,
+			ssr: "safe",
+			hydration: "stable",
+			cleanupOwners: ["none"],
+			runtimeGlobals: [],
+			dependencies: []
+		},
+		{
+			name: "useThrottled",
+			entry: "./use-throttled",
+			category: "timing",
+			stability: "experimental",
+			targets: reactiveTargets,
+			ssr: "deterministic-fallback",
+			hydration: "stable",
+			cleanupOwners: ["caller", "reactive-scope"],
+			runtimeGlobals: ["globalThis", "window"],
+			dependencies: ["tryOnScopeDispose"]
+		},
+		{
+			name: "useToggle",
+			entry: "./use-toggle",
+			category: "state",
+			stability: "experimental",
+			targets: reactiveTargets,
+			ssr: "safe",
+			hydration: "stable",
+			cleanupOwners: ["none"],
+			runtimeGlobals: [],
+			dependencies: []
+		}
+	]
+};
+//#endregion
+export { COMPOSABLE_CATALOG as t };

package/dist/catalog.d.mts

@@ -0,0 +1,2 @@
+import { a as ComposableEntryMetadata, c as ComposableRootEntryMetadata, d as ComposableUtilityMetadata, i as ComposableCleanupOwner, l as ComposableSsrBehavior, n as ComposableCatalog, o as ComposableHydrationBehavior, r as ComposableCategory, s as ComposableInstallationAvailability, t as COMPOSABLE_CATALOG, u as ComposableStability } from "./catalog-BQMC1CcY.mjs";
+export { COMPOSABLE_CATALOG, type ComposableCatalog, type ComposableCategory, type ComposableCleanupOwner, type ComposableEntryMetadata, type ComposableHydrationBehavior, type ComposableInstallationAvailability, type ComposableRootEntryMetadata, type ComposableSsrBehavior, type ComposableStability, type ComposableUtilityMetadata };

package/dist/catalog.mjs

@@ -0,0 +1,2 @@
+import { t as COMPOSABLE_CATALOG } from "./catalog-CYHr82Jz.mjs";
+export { COMPOSABLE_CATALOG };

package/dist/disposal-scope.d.mts

@@ -0,0 +1,93 @@
+//#region src/disposal-scope.d.ts
+/** Stable error code reported when one or more owned cleanups fail. */
+declare const DISPOSAL_ERROR_CODE: "VIZE_COMPOSE_DISPOSAL_FAILED";
+/** Aggregate failure produced after every owned cleanup has been attempted. */
+declare class DisposalError extends AggregateError {
+  /** Stable machine-readable error code. */
+  readonly code: "VIZE_COMPOSE_DISPOSAL_FAILED";
+  /**
+   * Create an aggregate disposal failure.
+   *
+   * Nested {@link DisposalError} instances are flattened by the scope before
+   * construction, so `errors` contains the original cleanup failures in
+   * execution order.
+   *
+   * @param errors Cleanup failures in deterministic execution order.
+   */
+  constructor(errors: readonly unknown[]);
+}
+/** Handle for removing one cleanup from its owner before disposal. */
+interface CleanupRegistration {
+  /** Whether this registration is still retained by its owner. */
+  readonly active: boolean;
+  /**
+   * Release the cleanup without running it.
+   *
+   * @returns Whether an active registration was removed.
+   */
+  readonly unregister: () => boolean;
+}
+/** Options for {@link createDisposalScope}. */
+interface CreateDisposalScopeOptions {
+  /**
+   * Dispose the owner with the active Vue reactive scope when one exists.
+   * Outside a reactive scope, ownership remains entirely with the caller.
+   *
+   * @default true
+   */
+  readonly scope?: boolean;
+}
+/** Explicit owner for a deterministic group of cleanup operations. */
+interface DisposalScope {
+  /** Whether disposal has started or completed. */
+  readonly disposed: boolean;
+  /** Number of active cleanup registrations currently retained. */
+  readonly size: number;
+  /**
+   * Register one cleanup.
+   *
+   * Active registrations run in last-in, first-out order. After disposal,
+   * registration runs the cleanup immediately and returns an inactive handle;
+   * a late failure is wrapped in {@link DisposalError}.
+   *
+   * @param cleanup Synchronous, idempotent resource cleanup.
+   * @returns A handle that can release the cleanup without running it.
+   * @throws {DisposalError} A late cleanup failed after the owner was disposed.
+   */
+  readonly add: <Cleanup extends () => unknown>(cleanup: [ReturnType<Cleanup>] extends [never] ? Cleanup : ReturnType<Cleanup> extends PromiseLike<unknown> ? never : Cleanup) => CleanupRegistration;
+  /**
+   * Create a child whose lifetime cannot outlive this owner.
+   *
+   * Disposing the child early unregisters it from the parent. Disposing the
+   * parent disposes the child in normal LIFO order.
+   *
+   * @returns A new child disposal scope.
+   */
+  readonly child: () => DisposalScope;
+  /**
+   * Run every active cleanup in last-in, first-out order exactly once.
+   *
+   * Reentrant and late registrations run immediately. All cleanups are
+   * attempted even when some fail. Repeated calls after successful or failed
+   * disposal do nothing.
+   *
+   * @throws {DisposalError} One or more cleanup operations failed.
+   */
+  readonly dispose: () => void;
+}
+/**
+ * Create an explicit, deterministic cleanup owner.
+ *
+ * The owner is runtime-neutral and performs no browser-global access. By
+ * default it joins an active Vue reactive scope; when no scope exists, or
+ * `scope` is disabled, the caller must invoke `dispose()`. Cleanups are
+ * synchronous by contract so disposal completes before the owner releases
+ * its records.
+ *
+ * @param options Reactive-scope ownership behavior.
+ * @default options {}
+ * @returns A disposal owner with child-lifetime support.
+ */
+declare function createDisposalScope(options?: CreateDisposalScopeOptions): DisposalScope;
+//#endregion
+export { CleanupRegistration, CreateDisposalScopeOptions, DISPOSAL_ERROR_CODE, DisposalError, DisposalScope, createDisposalScope };