@vizejs/composable 0.426.2 → 0.427.0

package/dist/use-request-idle-callback.d.mts

@@ -0,0 +1,122 @@
+import { t as TimeoutScheduler } from "./timeout-scheduler-CI8RVLZs.mjs";
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/use-request-idle-callback.d.ts
+/** Deadline handed to idle callbacks. */
+interface IdleDeadlineLike {
+  /** Whether the callback runs because its `timeout` elapsed. */
+  readonly didTimeout: boolean;
+  /** Milliseconds left in the current idle period. */
+  timeRemaining(): number;
+}
+/** Minimal `requestIdleCallback` capability. */
+interface IdleCallbackHost {
+  /** Schedule `callback` for the next idle period. */
+  requestIdleCallback(callback: (deadline: IdleDeadlineLike) => void, options?: {
+    readonly timeout?: number;
+  }): number;
+  /** Cancel a scheduled callback. */
+  cancelIdleCallback(handle: number): void;
+}
+/** Scheduling options shared by {@link useRequestIdleCallback} and {@link idle}. */
+interface IdleSchedulingOptions {
+  /**
+   * `requestIdleCallback` capability for alternate runtimes and tests.
+   *
+   * @default window when it implements requestIdleCallback
+   */
+  readonly host?: MaybeRefOrGetter<IdleCallbackHost | null | undefined>;
+  /**
+   * Timers used by the fallback when `host` is missing. Without timers
+   * (server rendering) nothing is scheduled.
+   *
+   * @default window.setTimeout and window.clearTimeout when a window exists
+   */
+  readonly timers?: MaybeRefOrGetter<TimeoutScheduler | null | undefined>;
+  /**
+   * Run the callback after this many milliseconds even when the browser is
+   * never idle (`deadline.didTimeout` is then true).
+   *
+   * @default undefined (no timeout)
+   */
+  readonly timeout?: number;
+  /**
+   * Clock used by the fallback deadline, in milliseconds.
+   *
+   * @default Date.now
+   */
+  readonly now?: () => number;
+}
+/** Options for {@link useRequestIdleCallback}. */
+interface UseRequestIdleCallbackOptions extends IdleSchedulingOptions {
+  /**
+   * Schedule the callback as soon as the composable is created.
+   *
+   * @default true
+   */
+  readonly immediate?: boolean;
+}
+/** Options for {@link idle}. */
+interface IdleOptions extends IdleSchedulingOptions {
+  /**
+   * Cancels the wait; the promise rejects with `signal.reason`.
+   *
+   * @default undefined
+   */
+  readonly signal?: AbortSignal;
+}
+/** Reactive state and actions returned by {@link useRequestIdleCallback}. */
+interface RequestIdleCallbackControls {
+  /** Whether the native `requestIdleCallback` API is available. */
+  readonly supported: ComputedRef<boolean>;
+  /** Whether a callback is scheduled and has not run yet. */
+  readonly isPending: Readonly<ShallowRef<boolean>>;
+  /** Schedule the callback, replacing a pending one. No-op on the server. */
+  readonly start: () => void;
+  /** Cancel the pending callback. Repeated calls are safe. */
+  readonly cancel: () => void;
+}
+/**
+ * Run a callback in the next idle period with `requestIdleCallback`.
+ *
+ * When the API is missing, a `setTimeout` fallback fabricates a deadline
+ * with a 50 ms budget and `didTimeout: false`. The pending callback is
+ * cancelled when the owning reactive scope stops; outside a scope the
+ * caller owns `cancel()`.
+ *
+ * Server rendering: nothing is scheduled, `isPending` and `supported` are
+ * false. Inside a component the first callback is scheduled after mounting,
+ * so hydration renders the server state first.
+ *
+ * @example
+ * ```ts
+ * const { start } = useRequestIdleCallback((deadline) => {
+ *   while (deadline.timeRemaining() > 1 && queue.length) queue.shift()?.();
+ * }, { timeout: 2000, immediate: false });
+ * ```
+ *
+ * @param callback Receives the idle deadline.
+ * @param options Hosts, timeout and start policy.
+ * @default options {}
+ * @returns Scheduling state and actions.
+ */
+declare function useRequestIdleCallback(callback: (deadline: IdleDeadlineLike) => void, options?: UseRequestIdleCallbackOptions): RequestIdleCallbackControls;
+/**
+ * Resolve in the next idle period (or after `timeout`).
+ *
+ * Uses the same hosts and fallback as {@link useRequestIdleCallback}. When
+ * neither an idle host nor timers resolve (server rendering) it resolves on
+ * the next microtask with an exhausted deadline instead of hanging.
+ *
+ * @example
+ * ```ts
+ * await idle({ timeout: 1000 });
+ * ```
+ *
+ * @param options Hosts, timeout and abort signal.
+ * @default options {}
+ * @returns The idle deadline; rejects with `signal.reason` when aborted.
+ */
+declare function idle(options?: IdleOptions): Promise<IdleDeadlineLike>;
+//#endregion
+export { IdleCallbackHost, IdleDeadlineLike, IdleOptions, IdleSchedulingOptions, RequestIdleCallbackControls, UseRequestIdleCallbackOptions, idle, useRequestIdleCallback };

package/dist/use-request-idle-callback.mjs

@@ -0,0 +1,147 @@
+import { tryOnScopeDispose } from "./scope.mjs";
+import { computed, hasInjectionContext, readonly, shallowRef, toValue, watch, watchPostEffect } from "vue";
+//#region src/use-request-idle-callback.ts
+/** Idle period length fabricated by the fallback, in milliseconds (the spec maximum). */
+const FALLBACK_IDLE_PERIOD = 50;
+function browserIdleHost() {
+	return typeof window !== "undefined" && typeof window.requestIdleCallback === "function" ? window : void 0;
+}
+function browserTimers() {
+	if (typeof window === "undefined") return void 0;
+	const target = window;
+	return {
+		setTimeout: (callback, delayMs) => target.setTimeout(callback, delayMs),
+		clearTimeout: (handle) => {
+			if (typeof handle === "number") target.clearTimeout(handle);
+		}
+	};
+}
+function validateTimeout(timeout) {
+	if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) throw new RangeError(`[VIZE_COMPOSE_IDLE_CALLBACK_INVALID_TIMEOUT] timeout must be a finite, non-negative number, received ${String(timeout)}`);
+}
+/** Schedule once; returns a canceller, or undefined when nothing could be scheduled. */
+function scheduleIdle(options, callback) {
+	const host = options.host === void 0 ? browserIdleHost() : toValue(options.host);
+	if (host) {
+		const handle = host.requestIdleCallback(callback, options.timeout === void 0 ? void 0 : { timeout: options.timeout });
+		return () => host.cancelIdleCallback(handle);
+	}
+	const timers = options.timers === void 0 ? browserTimers() : toValue(options.timers);
+	if (!timers) return void 0;
+	const now = options.now ?? Date.now;
+	const handle = timers.setTimeout(() => {
+		const start = now();
+		callback({
+			didTimeout: false,
+			timeRemaining: () => Math.max(0, FALLBACK_IDLE_PERIOD - (now() - start))
+		});
+	}, 1);
+	return () => timers.clearTimeout(handle);
+}
+/**
+* Run a callback in the next idle period with `requestIdleCallback`.
+*
+* When the API is missing, a `setTimeout` fallback fabricates a deadline
+* with a 50 ms budget and `didTimeout: false`. The pending callback is
+* cancelled when the owning reactive scope stops; outside a scope the
+* caller owns `cancel()`.
+*
+* Server rendering: nothing is scheduled, `isPending` and `supported` are
+* false. Inside a component the first callback is scheduled after mounting,
+* so hydration renders the server state first.
+*
+* @example
+* ```ts
+* const { start } = useRequestIdleCallback((deadline) => {
+*   while (deadline.timeRemaining() > 1 && queue.length) queue.shift()?.();
+* }, { timeout: 2000, immediate: false });
+* ```
+*
+* @param callback Receives the idle deadline.
+* @param options Hosts, timeout and start policy.
+* @default options {}
+* @returns Scheduling state and actions.
+*/
+function useRequestIdleCallback(callback, options = {}) {
+	validateTimeout(options.timeout);
+	const isPending = shallowRef(false);
+	let cancelPending;
+	const cancel = () => {
+		cancelPending?.();
+		cancelPending = void 0;
+		isPending.value = false;
+	};
+	const start = () => {
+		cancel();
+		cancelPending = scheduleIdle(options, (deadline) => {
+			cancelPending = void 0;
+			isPending.value = false;
+			callback(deadline);
+		});
+		isPending.value = cancelPending !== void 0;
+	};
+	const hydrated = shallowRef(!hasInjectionContext());
+	if (hydrated.value) {
+		if (options.immediate ?? true) start();
+	} else {
+		const stopReady = watch(hydrated, (ready) => {
+			if (!ready) return;
+			stopReady();
+			if (options.immediate ?? true) start();
+		}, { flush: "sync" });
+		watchPostEffect(() => {
+			hydrated.value = true;
+		});
+	}
+	tryOnScopeDispose(cancel);
+	return {
+		supported: computed(() => hydrated.value && (options.host === void 0 ? browserIdleHost() !== void 0 : Boolean(toValue(options.host)))),
+		isPending: readonly(isPending),
+		start,
+		cancel
+	};
+}
+/**
+* Resolve in the next idle period (or after `timeout`).
+*
+* Uses the same hosts and fallback as {@link useRequestIdleCallback}. When
+* neither an idle host nor timers resolve (server rendering) it resolves on
+* the next microtask with an exhausted deadline instead of hanging.
+*
+* @example
+* ```ts
+* await idle({ timeout: 1000 });
+* ```
+*
+* @param options Hosts, timeout and abort signal.
+* @default options {}
+* @returns The idle deadline; rejects with `signal.reason` when aborted.
+*/
+function idle(options = {}) {
+	validateTimeout(options.timeout);
+	const { signal } = options;
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(signal.reason);
+			return;
+		}
+		const onAbort = () => {
+			cancel?.();
+			reject(signal?.reason);
+		};
+		const cancel = scheduleIdle(options, (deadline) => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve(deadline);
+		});
+		if (!cancel) {
+			resolve({
+				didTimeout: false,
+				timeRemaining: () => 0
+			});
+			return;
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
+export { idle, useRequestIdleCallback };

package/dist/use-route-query.d.mts

@@ -0,0 +1,149 @@
+import { ComputedRef, MaybeRefOrGetter, WritableComputedRef } from "vue";
+
+//#region src/use-route-query.d.ts
+/** Raw query value: repeated keys become arrays, absent keys are `undefined`. */
+type RawQueryValue = string | readonly string[] | undefined;
+/** Query record as produced by `@vizejs/router` (`RouteMatch["query"]`). */
+type RouteQueryRecord = Readonly<Record<string, string | readonly string[]>>;
+/**
+ * Structural subset of a matched route. `@vizejs/router`'s `RouteMatch`
+ * satisfies it, so its inferred `params` type flows through without this
+ * package depending on the router.
+ */
+interface RouteLocationLike {
+  /** Decoded path params. */
+  readonly params: object;
+  /** Parsed query. */
+  readonly query: RouteQueryRecord;
+}
+/** Converts a raw query value; `undefined` selects the default. */
+type QueryParser<Value> = (raw: RawQueryValue) => Value | undefined;
+/** Converts a value back to a raw query value; `undefined` removes the key. */
+type QuerySerializer<Value> = (value: Value) => string | readonly string[] | undefined;
+/** Built-in {@link QueryParser}s. */
+declare const queryParsers: {
+  /** First value as a string. */readonly string: (raw: RawQueryValue) => string | undefined; /** First value as a finite number. */
+  readonly number: (raw: RawQueryValue) => number | undefined; /** First value as a safe integer. */
+  readonly integer: (raw: RawQueryValue) => number | undefined; /** `"true"`/`"1"`/`""` (present flag) → `true`, `"false"`/`"0"` → `false`. */
+  readonly boolean: (raw: RawQueryValue) => boolean | undefined; /** Every value as a string array. */
+  readonly array: (raw: RawQueryValue) => string[] | undefined;
+};
+/**
+ * Parser accepting only the given literal values.
+ *
+ * @example
+ * ```ts
+ * useRouteQuery(route, "sort", { parse: oneOf(["new", "top"]), default: "new" });
+ * ```
+ *
+ * @param values Allowed values.
+ * @returns A parser narrowing to the literal union.
+ */
+declare function oneOf<const Values extends readonly string[]>(values: Values): QueryParser<Values[number]>;
+/** Options for {@link useRouteQuery}. */
+interface UseRouteQueryOptions<Value> {
+  /**
+   * Converts the raw value.
+   *
+   * @default queryParsers.string
+   */
+  readonly parse?: QueryParser<Value>;
+  /**
+   * Converts a written value back into the query.
+   *
+   * @default strings and string arrays unchanged, other values via `String`
+   */
+  readonly serialize?: QuerySerializer<Value>;
+  /**
+   * Performs the navigation for a write, receiving the complete next query.
+   * Without it the returned ref is read-only.
+   *
+   * @default undefined
+   */
+  readonly navigate?: (query: RouteQueryRecord) => void;
+  /**
+   * Remove the key instead of writing it when the value equals the default.
+   *
+   * @default true
+   */
+  readonly omitDefault?: boolean;
+}
+/** Options of a string query parameter (no parser). */
+type StringQueryOptions = Omit<UseRouteQueryOptions<string>, "parse"> & {
+  /** Must be omitted: string parameters use {@link queryParsers.string}. */readonly parse?: undefined;
+};
+/**
+ * Typed, optionally writable view of one query parameter.
+ *
+ * The value type is inferred from `parse` and `default`: with a default the
+ * ref never holds `undefined`. Pass `navigate` to make the ref writable;
+ * writes build the next query (keeping every other key), drop the key when
+ * the value equals the default, and hand it to `navigate`, which is where
+ * the router integration pushes or replaces the URL. Works with any route
+ * object exposing `query`, including `@vizejs/router`'s `RouteMatch`.
+ * Pure derived state: SSR-safe and hydration-stable (it reads the matched
+ * route only).
+ *
+ * @example
+ * ```ts
+ * const page = useRouteQuery(match, "page", {
+ *   parse: queryParsers.integer,
+ *   default: 1,
+ *   navigate: (query) => navigateTo(router.resolve(match.value.name, match.value.params, { query })),
+ * });
+ * page.value += 1;
+ * ```
+ *
+ * @param route Reactive matched route.
+ * @param key Query key.
+ * @param options Parser, default, serializer, and navigation.
+ * @default options {}
+ * @returns A computed ref (writable when `navigate` is given).
+ */
+declare function useRouteQuery(route: MaybeRefOrGetter<RouteLocationLike>, key: string, options: StringQueryOptions & {
+  readonly default: string;
+  readonly navigate: (query: RouteQueryRecord) => void;
+}): WritableComputedRef<string>;
+declare function useRouteQuery(route: MaybeRefOrGetter<RouteLocationLike>, key: string, options: StringQueryOptions & {
+  readonly navigate: (query: RouteQueryRecord) => void;
+}): WritableComputedRef<string | undefined, string | undefined>;
+declare function useRouteQuery(route: MaybeRefOrGetter<RouteLocationLike>, key: string, options: StringQueryOptions & {
+  readonly default: string;
+}): ComputedRef<string>;
+declare function useRouteQuery(route: MaybeRefOrGetter<RouteLocationLike>, key: string, options?: StringQueryOptions): ComputedRef<string | undefined>;
+declare function useRouteQuery<Value>(route: MaybeRefOrGetter<RouteLocationLike>, key: string, options: UseRouteQueryOptions<Value> & {
+  readonly default: NoInfer<Value>;
+  readonly navigate: (query: RouteQueryRecord) => void;
+}): WritableComputedRef<Value>;
+declare function useRouteQuery<Value>(route: MaybeRefOrGetter<RouteLocationLike>, key: string, options: UseRouteQueryOptions<Value> & {
+  readonly navigate: (query: RouteQueryRecord) => void;
+}): WritableComputedRef<Value | undefined, Value | undefined>;
+declare function useRouteQuery<Value>(route: MaybeRefOrGetter<RouteLocationLike>, key: string, options: UseRouteQueryOptions<Value> & {
+  readonly default: NoInfer<Value>;
+}): ComputedRef<Value>;
+declare function useRouteQuery<Value>(route: MaybeRefOrGetter<RouteLocationLike>, key: string, options: UseRouteQueryOptions<Value>): ComputedRef<Value | undefined>;
+/** Params object of a route location. */
+type RouteParamsOf<Route extends RouteLocationLike> = Route["params"];
+/**
+ * Typed view of the matched route's path params.
+ *
+ * Without a key, returns all params (typed from the route table when the
+ * route comes from `@vizejs/router`). With a key, returns that param; with
+ * a parser, the parsed value. Pure derived state: SSR-safe.
+ *
+ * @example
+ * ```ts
+ * const params = useRouteParams(match); // ComputedRef<{ readonly id: string }>
+ * const id = useRouteParams(match, "id", Number); // ComputedRef<number>
+ * ```
+ *
+ * @param route Reactive matched route.
+ * @param key Param name.
+ * @param parse Converts the raw param.
+ * @returns Computed params, param, or parsed param.
+ */
+declare function useRouteParams<Route extends RouteLocationLike>(route: MaybeRefOrGetter<Route>): ComputedRef<RouteParamsOf<Route>>;
+declare function useRouteParams<Route extends RouteLocationLike, Key extends keyof Route["params"]>(route: MaybeRefOrGetter<Route>, key: Key): ComputedRef<Route["params"][Key]>;
+declare function useRouteParams<Route extends RouteLocationLike, Key extends keyof Route["params"], Value>(route: MaybeRefOrGetter<Route>, key: Key, parse: (raw: Route["params"][Key]) => Value): ComputedRef<Value>;
+//#endregion
+export { QueryParser, QuerySerializer, RawQueryValue, RouteLocationLike, RouteParamsOf, RouteQueryRecord, StringQueryOptions, UseRouteQueryOptions, oneOf, queryParsers, useRouteParams, useRouteQuery };

package/dist/use-route-query.mjs

@@ -0,0 +1,86 @@
+import { computed, toValue } from "vue";
+//#region src/use-route-query.ts
+/** Built-in {@link QueryParser}s. */
+const queryParsers = {
+	/** First value as a string. */
+	string: (raw) => typeof raw === "string" ? raw : raw?.[0],
+	/** First value as a finite number. */
+	number: (raw) => {
+		const text = typeof raw === "string" ? raw : raw?.[0];
+		if (text === void 0 || text.trim() === "") return void 0;
+		const value = Number(text);
+		return Number.isFinite(value) ? value : void 0;
+	},
+	/** First value as a safe integer. */
+	integer: (raw) => {
+		const text = typeof raw === "string" ? raw : raw?.[0];
+		return text !== void 0 && /^-?\d+$/.test(text) && Number.isSafeInteger(Number(text)) ? Number(text) : void 0;
+	},
+	/** `"true"`/`"1"`/`""` (present flag) → `true`, `"false"`/`"0"` → `false`. */
+	boolean: (raw) => {
+		const text = typeof raw === "string" ? raw : raw?.[0];
+		if (text === void 0) return void 0;
+		if (text === "true" || text === "1" || text === "") return true;
+		if (text === "false" || text === "0") return false;
+	},
+	/** Every value as a string array. */
+	array: (raw) => raw === void 0 ? void 0 : typeof raw === "string" ? [raw] : [...raw]
+};
+/**
+* Parser accepting only the given literal values.
+*
+* @example
+* ```ts
+* useRouteQuery(route, "sort", { parse: oneOf(["new", "top"]), default: "new" });
+* ```
+*
+* @param values Allowed values.
+* @returns A parser narrowing to the literal union.
+*/
+function oneOf(values) {
+	const allowed = new Set(values);
+	const isAllowed = (text) => allowed.has(text);
+	return (raw) => {
+		const text = typeof raw === "string" ? raw : raw?.[0];
+		return text !== void 0 && isAllowed(text) ? text : void 0;
+	};
+}
+function defaultSerialize(value) {
+	if (value === void 0 || value === null) return void 0;
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) return value.map((item) => typeof item === "string" ? item : JSON.stringify(item));
+	return typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" ? value.toString() : JSON.stringify(value);
+}
+function sameRaw(left, right) {
+	if (typeof left === "string" || typeof right === "string" || !left || !right) return left === right;
+	return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+function useRouteQuery(route, key, options = {}) {
+	const parse = options.parse ?? queryParsers.string;
+	const read = () => parse(toValue(route).query[key]) ?? options.default;
+	const navigate = options.navigate;
+	if (navigate === void 0) return computed(read);
+	const serialize = (value) => options.serialize === void 0 ? defaultSerialize(value) : options.serialize(value);
+	return computed({
+		get: read,
+		set: (value) => {
+			const current = toValue(route).query;
+			const raw = (options.omitDefault ?? true) && "default" in options && sameRaw(serialize(value), serialize(options.default)) ? void 0 : serialize(value);
+			if (sameRaw(raw, current[key])) return;
+			const next = { ...current };
+			if (raw === void 0) Reflect.deleteProperty(next, key);
+			else next[key] = raw;
+			navigate(next);
+		}
+	});
+}
+function useRouteParams(route, ...args) {
+	return computed(() => {
+		const { params } = toValue(route);
+		if (args.length === 0) return params;
+		const raw = Reflect.get(params, args[0]);
+		return args.length === 2 ? args[1](raw) : raw;
+	});
+}
+//#endregion
+export { oneOf, queryParsers, useRouteParams, useRouteQuery };

package/dist/use-scheduler-post-task.d.mts

@@ -0,0 +1,156 @@
+import { t as TimeoutScheduler } from "./timeout-scheduler-CI8RVLZs.mjs";
+import { ComputedRef, MaybeRef, MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/use-scheduler-post-task.d.ts
+/** Priorities defined by the Prioritized Task Scheduling API. */
+type SchedulerTaskPriority = "user-blocking" | "user-visible" | "background";
+/** Options passed to {@link SchedulerHost.postTask}. */
+interface SchedulerPostTaskInit {
+  /** Fixed task priority; overrides the signal's priority. */
+  readonly priority?: SchedulerTaskPriority;
+  /** Delay before the task is queued, in milliseconds. */
+  readonly delay?: number;
+  /** Aborts the task (a `TaskSignal` also carries a mutable priority). */
+  readonly signal?: AbortSignal;
+}
+/** Minimal `scheduler` global. */
+interface SchedulerHost {
+  /** Queue `callback`; resolves with its result, rejects with the abort reason. */
+  postTask<Result>(callback: () => Result | PromiseLike<Result>, options?: SchedulerPostTaskInit): Promise<Result>;
+  /** Yield to the event loop, continuing with inherited priority. */
+  yield?(): Promise<void>;
+}
+/** Minimal `TaskController` instance. */
+interface TaskControllerLike {
+  /** Signal handed to `postTask`. */
+  readonly signal: AbortSignal;
+  /** Abort every task using this controller's signal. */
+  abort(reason?: unknown): void;
+  /** Change the priority of every task using this controller's signal. */
+  setPriority(priority: SchedulerTaskPriority): void;
+}
+/** Minimal `TaskController` constructor. */
+type TaskControllerHost = new (init?: {
+  readonly priority?: SchedulerTaskPriority;
+}) => TaskControllerLike;
+/** Options for {@link useSchedulerPostTask}. */
+interface UseSchedulerPostTaskOptions {
+  /**
+   * Prioritized Task Scheduling capability for alternate runtimes and tests.
+   *
+   * @default window.scheduler when it implements postTask
+   */
+  readonly scheduler?: MaybeRefOrGetter<SchedulerHost | null | undefined>;
+  /**
+   * `TaskController` constructor. A ref (not a getter) because the host is a
+   * constructor function. Without it tasks use a plain `AbortController`
+   * and receive the priority explicitly, so `setPriority` cannot re-prioritize
+   * them.
+   *
+   * @default window.TaskController when it exists
+   */
+  readonly TaskController?: MaybeRef<TaskControllerHost | null | undefined>;
+  /**
+   * Timers used when `scheduler` is missing. Without timers (server
+   * rendering) `postTask` rejects.
+   *
+   * @default window.setTimeout and window.clearTimeout when a window exists
+   */
+  readonly timers?: MaybeRefOrGetter<TimeoutScheduler | null | undefined>;
+  /**
+   * Initial priority of tasks posted without an explicit priority.
+   *
+   * @default "user-visible"
+   */
+  readonly priority?: SchedulerTaskPriority;
+}
+/** Per-call options of {@link SchedulerPostTaskControls.postTask}. */
+interface PostTaskCallOptions {
+  /**
+   * Fixed priority for this task; `setPriority` no longer affects it.
+   *
+   * @default the composable priority
+   */
+  readonly priority?: SchedulerTaskPriority;
+  /**
+   * Delay before the task is queued, in milliseconds.
+   *
+   * @default 0
+   */
+  readonly delay?: number;
+  /**
+   * Aborts this task only.
+   *
+   * @default undefined
+   */
+  readonly signal?: AbortSignal;
+}
+/** Reactive state and actions returned by {@link useSchedulerPostTask}. */
+interface SchedulerPostTaskControls {
+  /** Whether the native `scheduler.postTask` API is available. */
+  readonly supported: ComputedRef<boolean>;
+  /** Priority applied to tasks posted without an explicit priority. */
+  readonly priority: Readonly<ShallowRef<SchedulerTaskPriority>>;
+  /** Number of posted tasks that have not settled. */
+  readonly pending: Readonly<ShallowRef<number>>;
+  /**
+   * Post a task.
+   *
+   * @param callback Task body; may return a value or a promise.
+   * @param options Priority, delay and abort signal.
+   * @default options {}
+   * @returns The callback result; rejects with the abort reason when
+   * aborted, or with `[VIZE_COMPOSE_POST_TASK_UNAVAILABLE]` when neither the
+   * scheduler nor timers exist (server rendering).
+   */
+  readonly postTask: <Result>(callback: () => Result | PromiseLike<Result>, options?: PostTaskCallOptions) => Promise<Result>;
+  /**
+   * Re-prioritize the composable and every pending task without a fixed priority.
+   *
+   * @param priority New priority.
+   */
+  readonly setPriority: (priority: SchedulerTaskPriority) => void;
+  /**
+   * Abort every pending task of this composable.
+   *
+   * @param reason Rejection reason (an AbortError by default).
+   */
+  readonly abort: (reason?: unknown) => void;
+  /**
+   * Yield to the event loop: `scheduler.yield()`, else a zero-delay timer,
+   * else a resolved promise.
+   *
+   * @returns Resolves when the continuation may run.
+   */
+  readonly yield: () => Promise<void>;
+}
+/**
+ * Post prioritized tasks with the Prioritized Task Scheduling API.
+ *
+ * Every task gets its own controller (a `TaskController` when available),
+ * so `setPriority` re-prioritizes pending tasks and `abort` rejects them;
+ * pending tasks are aborted when the owning reactive scope stops (their
+ * promises reject with an AbortError; outside a scope the caller owns
+ * `abort()`).
+ *
+ * Fallback without `scheduler`: tasks run from `setTimeout(delay)` in
+ * timer (FIFO) order. Priorities are ignored, so a later "user-blocking"
+ * task does not overtake an earlier "background" one, and tasks do not
+ * yield to rendering or input the way native tasks do.
+ *
+ * Server rendering: nothing is scheduled, `supported` is false and
+ * `postTask` rejects.
+ *
+ * @example
+ * ```ts
+ * const { postTask } = useSchedulerPostTask();
+ * const total = await postTask(() => expensiveSum(rows), { priority: "background" });
+ * ```
+ *
+ * @param options Hosts and the initial priority.
+ * @default options {}
+ * @returns Task state and actions.
+ */
+declare function useSchedulerPostTask(options?: UseSchedulerPostTaskOptions): SchedulerPostTaskControls;
+//#endregion
+export { PostTaskCallOptions, SchedulerHost, SchedulerPostTaskControls, SchedulerPostTaskInit, SchedulerTaskPriority, TaskControllerHost, TaskControllerLike, UseSchedulerPostTaskOptions, useSchedulerPostTask };