elements-kit 0.19.0 → 0.21.0

package/dist/utilities/async.d.mts

@@ -1,7 +1,9 @@
-import { b as MaybeReactive } from "../infer-B7T5hi_D.mjs";
+import { D as CLAIM, b as MaybeReactive, j as SEED } from "../types-CUvFIgPa.mjs";
 import { ComputedPromise } from "./promise.mjs";
 
 //#region src/utilities/async.d.ts
+/** @internal Hydrate cleanup: execute deferred runs no claim resolved. */
+declare function flushDeferredAsyncRuns(): void;
 /** Shape of the async function driven by {@link Async} / {@link async}. */
 type Fn<TInput, TOutput> = (input: TInput) => Promise<TOutput>;
 /**
@@ -43,6 +45,19 @@ declare class Async<TInput = undefined, TOutput = unknown> {
   then<TResult1 = TOutput, TResult2 = never>(onfulfilled?: ((value: TOutput | undefined) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
   catch<TResult = never>(onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null): Promise<TOutput | undefined | TResult>;
   finally(onfinally?: (() => void) | null): Promise<TOutput | undefined>;
+  /**
+   * @internal Hydration seeding — delegates to the current operation's
+   * `ReactivePromise`. See `ReactivePromise[SEED]`.
+   */
+  [SEED](value: unknown): void;
+  /**
+   * @internal Hydrate claim protocol. A server record seeds the state and
+   * discards any deferred run — the fetcher never executes. No record means
+   * the deferred run executes now.
+   */
+  [CLAIM](record: {
+    value: unknown;
+  } | undefined): void;
   constructor(fn: MaybeReactive<Fn<TInput, TOutput>>);
   /**
    * Runs the async function once with the given input, stopping any currently active
@@ -59,6 +74,8 @@ declare class Async<TInput = undefined, TOutput = unknown> {
    */
   start(...args: TInput extends undefined ? [] : [input: TInput]): this;
 }
+/** @internal Cross-instance-safe `Async` detection. */
+declare function isAsyncLike(value: unknown): value is Async<never, unknown>;
 /**
  * Create an {@link Async} that is also callable as a signal: invoking it
  * (with no args) reads the current `result`, so it drops into any reactive
@@ -78,4 +95,4 @@ declare class Async<TInput = undefined, TOutput = unknown> {
  */
 declare function async<TInput = any, TOutput = undefined>(fn: MaybeReactive<(input: TInput) => Promise<TOutput>>): Async<TInput, TOutput> & ((...args: any[]) => TOutput | undefined);
 //#endregion
-export { Async, Fn, async };
+export { Async, Fn, async, flushDeferredAsyncRuns, isAsyncLike };

package/dist/utilities/async.mjs

@@ -1,7 +1,14 @@
-import { g as untracked, m as signal, s as effect } from "../lib-Dkc7cV5F.mjs";
+import { C as untracked, b as shouldDeferAsyncRuns, f as effectsInert, n as CLAIM, o as SEED, u as effect, x as signal } from "../lib-DYypKhxk.mjs";
 import { resolve } from "../signals/index.mjs";
 import { promise } from "./promise.mjs";
 //#region src/utilities/async.ts
+const deferredRuns = /* @__PURE__ */ new Map();
+/** @internal Hydrate cleanup: execute deferred runs no claim resolved. */
+function flushDeferredAsyncRuns() {
+	const runs = [...deferredRuns.values()];
+	deferredRuns.clear();
+	for (const run of runs) run();
+}
 /**
 * Reactive wrapper around an async function. Exposes the current run as
 * reactive signals (`state`, `value`, `reason`, `result`, `pending`) and
@@ -65,6 +72,28 @@ var Async = class {
 	finally(onfinally) {
 		return this.raw.finally(onfinally);
 	}
+	/**
+	* @internal Hydration seeding — delegates to the current operation's
+	* `ReactivePromise`. See `ReactivePromise[SEED]`.
+	*/
+	[SEED](value) {
+		const seed = this.raw[SEED];
+		seed?.(value);
+	}
+	/**
+	* @internal Hydrate claim protocol. A server record seeds the state and
+	* discards any deferred run — the fetcher never executes. No record means
+	* the deferred run executes now.
+	*/
+	[CLAIM](record) {
+		const pendingRun = deferredRuns.get(this);
+		deferredRuns.delete(this);
+		if (record) {
+			if (untracked(() => this.state) === "pending") this[SEED](record.value);
+			return;
+		}
+		pendingRun?.();
+	}
 	constructor(fn) {
 		this.#fn(resolve(fn));
 	}
@@ -79,6 +108,14 @@ var Async = class {
 	* and register cleanup effects.
 	*/
 	run(...args) {
+		if (shouldDeferAsyncRuns()) {
+			deferredRuns.set(this, () => this.run(...args));
+			return this;
+		}
+		if (effectsInert()) {
+			untracked(() => this.#execute(...args));
+			return this;
+		}
 		this.stop();
 		this.#cleanup = effect(() => {
 			untracked(() => this.#execute(...args));
@@ -107,6 +144,13 @@ var Async = class {
 		return this;
 	}
 };
+const ASYNC_BRAND = Symbol.for("elements-kit.async");
+Object.defineProperty(Async.prototype, ASYNC_BRAND, { value: true });
+/** @internal Cross-instance-safe `Async` detection. */
+function isAsyncLike(value) {
+	if (value instanceof Async) return true;
+	return value != null && (typeof value === "object" || typeof value === "function") && value[ASYNC_BRAND] === true;
+}
 const ASYNC_KEYS = new Set([
 	"then",
 	"catch",
@@ -121,6 +165,9 @@ const ASYNC_KEYS = new Set([
 	"run",
 	"fn",
 	"raw",
+	SEED,
+	CLAIM,
+	ASYNC_BRAND,
 	Symbol.dispose
 ]);
 /**
@@ -160,4 +207,4 @@ function async(fn) {
 	});
 }
 //#endregion
-export { Async, async };
+export { Async, async, flushDeferredAsyncRuns, isAsyncLike };

package/dist/utilities/context.mjs

@@ -1,4 +1,4 @@
-import { m as signal, p as onCleanup } from "../lib-Dkc7cV5F.mjs";
+import { _ as onCleanup, x as signal } from "../lib-DYypKhxk.mjs";
 import "../signals/index.mjs";
 //#region src/utilities/context.ts
 const registry = /* @__PURE__ */ new WeakMap();

package/dist/utilities/debounced.d.mts

@@ -1,4 +1,4 @@
-import { y as Computed } from "../infer-B7T5hi_D.mjs";
+import { y as Computed } from "../types-CUvFIgPa.mjs";
 
 //#region src/utilities/debounced.d.ts
 /**

package/dist/utilities/debounced.mjs

@@ -1,4 +1,4 @@
-import { m as signal, s as effect } from "../lib-Dkc7cV5F.mjs";
+import { u as effect, x as signal } from "../lib-DYypKhxk.mjs";
 import "../signals/index.mjs";
 import { createTimeout } from "./timeout.mjs";
 //#region src/utilities/debounced.ts