yummies 7.19.4 → 7.20.1

package/async.d.ts

@@ -1,83 +1,74 @@
+import { MaybeFn, Primitive, MaybePromise } from 'yummies/types';
+
 /**
- * Represents all primitive types in TypeScript.
- *
- * @returns Union of all primitive types
- */
-type Primitive = null | undefined | string | number | boolean | symbol | bigint;
-type Fn<T, TArgs extends any[] = any[]> = (...args: TArgs) => T;
-/**
- * Represents a type that can be either the specified type or a function returning that type.
- *
- * @template T - The type to make possibly a function
- * @template TArgs - Arguments type for the function
- * @returns T or a function that returns T
- */
-type MaybeFn<T, TArgs extends any[] = any[]> = T | Fn<T, TArgs>;
-/**
- * Represents a type that can be either the specified type or a Promise resolving to that type.
+ * A single interpolated segment in {@link asyncTemplate}.
  *
- * @template T - The type to make possibly a promise
- * @returns T or Promise<T>
+ * - **Primitives** use `String(value)` for output, except that values matching
+ *   `value === null || value === undefined || value === false` yield no text (early return in `processTemplatePiece`).
+ *   Other falsy values such as `0` or `''` are still stringified.
+ * - **Arrays** are flattened recursively in order.
+ * - **Promises** are awaited; the resolved value is processed the same way.
+ * - **Async iterables of primitives** are streamed in order; each yielded value uses the same rules
+ *   as a standalone primitive (`String(...)`, with `null` / `undefined` / `false` omitted).
+ * - **Functions** (thunks): if the piece is a function, it is invoked with **no arguments** (`piece()`), and the return
+ *   value is processed recursively—so you can defer work or return any other {@link AsyncTemplatePiece} shape
+ *   (see {@link MaybeFn}). At runtime a thunk may also return a `Promise` of a piece; that is covered by
+ *   {@link MaybePromise} on each template interpolation.
  */
-type MaybePromise<T> = T | Promise<T>;
+type AsyncTemplatePiece = MaybeFn<Primitive | void | AsyncIterable<Primitive> | Promise<Primitive> | AsyncTemplatePiece[]>;
 
 /**
- * ---header-docs-section---
- * # yummies/async
+ * Tagged template that builds an async iterable of string chunks (like a streaming template engine).
  *
- * ## Description
+ * Static template parts are yielded as-is. Each interpolated “piece” can be a primitive, a nested array of pieces,
+ * a `Promise` of a piece (including a resolved primitive), an async iterable of primitives, or a
+ * **zero-arg function** whose result is processed the same way (see {@link AsyncTemplatePiece} / `MaybeFn`).
  *
- * Helpers for asynchronous control flow: delays, cancellable waits, scheduling on the next frame,
- * and small utilities around `requestAnimationFrame` and `queueMicrotask`. They complement native
- * `Promise`/`AbortSignal` patterns and keep timing logic easy to test and tree-shake per call site.
- * Import only what you need from `yummies/async` so bundlers can drop unused helpers.
+ * Interpolation handling matches `processTemplatePiece`: `null`, `undefined`, and `false` add nothing; any other value
+ * becomes text via `String(...)`; functions are called once with no arguments before further processing. Collect chunks
+ * with `for await...of` or utilities like `Array.fromAsync` where available.
  *
- * ## Usage
+ * @param strings - Cooked template segments from the tag (`strings[0]`, `strings[1]`, …).
+ * @param pieces - Values between segments (`pieces[i]` sits between `strings[i]` and `strings[i + 1]`).
+ * @returns An async generator yielding string fragments in document order.
  *
+ * @example
+ * Plain values and promises:
  * ```ts
- * import { sleep } from "yummies/async";
+ * const gen = asyncTemplate`Hello, ${'world'}! Status: ${Promise.resolve(200)}`;
+ * let out = '';
+ * for await (const chunk of gen) out += chunk;
+ * // out === 'Hello, world! Status: 200'
  * ```
- */
-
-/**
- * Returns a promise that resolves after `time` milliseconds.
- *
- * When `signal` is passed and becomes aborted before the delay elapses, the promise
- * rejects with `signal.reason` (same as native `fetch` / `AbortController` usage).
- * The timeout is cleared on abort so no resolve happens after cancellation.
- *
- * @param time - Delay in milliseconds. Defaults to `0` (next macrotask tick, same idea as `setTimeout(0)`).
- * @param signal - Optional `AbortSignal` to cancel the wait early.
- * @returns A promise that resolves with `void` when the delay completes, or rejects if aborted.
  *
  * @example
- * Basic pause in an async function:
+ * Falsy pieces are omitted (`null`, `undefined`, `false`); arrays flatten recursively:
  * ```ts
- * await sleep(250);
- * console.log('after 250ms');
+ * const gen = asyncTemplate`${null}${false}A${['B', ['C']]}`;
+ * const out = await Array.fromAsync(gen).then((parts) => parts.join(''));
+ * // out === 'ABC'
  * ```
  *
  * @example
- * Cancellable delay tied to component unmount or user action:
+ * Stream from an async iterable (e.g. chunked upstream text):
  * ```ts
- * const ac = new AbortController();
- * try {
- *   await sleep(5000, ac.signal);
- * } catch (e) {
- *   // aborted — e is signal.reason
+ * async function* lines() {
+ *   yield 'line1\n';
+ *   yield 'line2\n';
  * }
- * ac.abort('user cancelled');
+ * const gen = asyncTemplate`Header\n${lines()}Footer`;
  * ```
- */
-declare const sleep: (time?: number, signal?: AbortSignal) => Promise<void>;
-/**
- * Creates a promise that resolves after the specified number of milliseconds.
  *
- * @deprecated Use `sleep` instead.
- * @param ms Delay in milliseconds.
- * @returns Promise
+ * @example
+ * Lazy piece via a thunk (invoked as `piece()`):
+ * ```ts
+ * let n = 0;
+ * const gen = asyncTemplate`count=${() => ++n}`;
+ * // first consumption yields "count=1", etc.
+ * ```
  */
-declare const waitAsync: (ms?: number) => Promise<unknown>;
+declare function asyncTemplate(strings: TemplateStringsArray, ...pieces: MaybePromise<AsyncTemplatePiece>[]): AsyncGenerator<string, void, unknown>;
+
 /**
  * Runs a loop driven by `requestAnimationFrame`: on each frame, `quitFunction` is called first.
  * If it returns a truthy value, the loop stops and no further frames are scheduled.
@@ -115,32 +106,7 @@ declare const waitAsync: (ms?: number) => Promise<unknown>;
  * ```
  */
 declare const endlessRAF: (quitFunction: () => boolean | void, asMicrotask?: boolean) => void;
-/**
- * Like `setTimeout`, but if `signal` aborts before the delay fires, the timer is cleared
- * and `callback` is never run. If the callback runs normally, the abort listener is removed.
- *
- * Does nothing special if `signal` is omitted — behaves like a plain timeout.
- *
- * @param callback - Function to run once after `delayInMs` (same as `setTimeout` callback).
- * @param delayInMs - Milliseconds to wait. Passed through to `setTimeout` (browser/Node semantics apply).
- * @param signal - When aborted, clears the pending timeout so `callback` is not invoked.
- *
- * @example
- * ```ts
- * const controller = new AbortController();
- * setAbortableTimeout(() => console.log('done'), 500, controller.signal);
- * // later: controller.abort(); // timeout cancelled, log never runs
- * ```
- *
- * @example
- * Zero-delay scheduling that can still be cancelled before the macrotask runs:
- * ```ts
- * const ac = new AbortController();
- * setAbortableTimeout(() => startIntro(), 0, ac.signal);
- * // e.g. on teardown: ac.abort();
- * ```
- */
-declare function setAbortableTimeout(callback: VoidFunction, delayInMs?: number, signal?: AbortSignal): void;
+
 /**
  * Like `setInterval`, but when `signal` aborts, the interval is cleared with `clearInterval`
  * and `callback` stops being called. If `signal` is omitted, behaves like a normal interval
@@ -165,73 +131,74 @@ declare function setAbortableTimeout(callback: VoidFunction, delayInMs?: number,
  * ```
  */
 declare function setAbortableInterval(callback: VoidFunction, delayInMs?: number, signal?: AbortSignal): void;
+
 /**
- * A single interpolated segment in {@link asyncTemplate}.
- *
- * - **Primitives** use `String(value)` for output, except that values matching
- *   `value === null || value === undefined || value === false` yield no text (early return in `processTemplatePiece`).
- *   Other falsy values such as `0` or `''` are still stringified.
- * - **Arrays** are flattened recursively in order.
- * - **Promises** are awaited; the resolved value is processed the same way.
- * - **Async iterables of primitives** are streamed in order; each yielded value uses the same rules
- *   as a standalone primitive (`String(...)`, with `null` / `undefined` / `false` omitted).
- * - **Functions** (thunks): if the piece is a function, it is invoked with **no arguments** (`piece()`), and the return
- *   value is processed recursively—so you can defer work or return any other {@link AsyncTemplatePiece} shape
- *   (see {@link MaybeFn}). At runtime a thunk may also return a `Promise` of a piece; that is covered by
- *   {@link MaybePromise} on each template interpolation.
- */
-type AsyncTemplatePiece = MaybeFn<Primitive | void | AsyncIterable<Primitive> | Promise<Primitive> | AsyncTemplatePiece[]>;
-/**
- * Tagged template that builds an async iterable of string chunks (like a streaming template engine).
- *
- * Static template parts are yielded as-is. Each interpolated “piece” can be a primitive, a nested array of pieces,
- * a `Promise` of a piece (including a resolved primitive), an async iterable of primitives, or a
- * **zero-arg function** whose result is processed the same way (see {@link AsyncTemplatePiece} / `MaybeFn`).
+ * Like `setTimeout`, but if `signal` aborts before the delay fires, the timer is cleared
+ * and `callback` is never run. If the callback runs normally, the abort listener is removed.
  *
- * Interpolation handling matches `processTemplatePiece`: `null`, `undefined`, and `false` add nothing; any other value
- * becomes text via `String(...)`; functions are called once with no arguments before further processing. Collect chunks
- * with `for await...of` or utilities like `Array.fromAsync` where available.
+ * Does nothing special if `signal` is omitted — behaves like a plain timeout.
  *
- * @param strings - Cooked template segments from the tag (`strings[0]`, `strings[1]`, …).
- * @param pieces - Values between segments (`pieces[i]` sits between `strings[i]` and `strings[i + 1]`).
- * @returns An async generator yielding string fragments in document order.
+ * @param callback - Function to run once after `delayInMs` (same as `setTimeout` callback).
+ * @param delayInMs - Milliseconds to wait. Passed through to `setTimeout` (browser/Node semantics apply).
+ * @param signal - When aborted, clears the pending timeout so `callback` is not invoked.
  *
  * @example
- * Plain values and promises:
  * ```ts
- * const gen = asyncTemplate`Hello, ${'world'}! Status: ${Promise.resolve(200)}`;
- * let out = '';
- * for await (const chunk of gen) out += chunk;
- * // out === 'Hello, world! Status: 200'
+ * const controller = new AbortController();
+ * setAbortableTimeout(() => console.log('done'), 500, controller.signal);
+ * // later: controller.abort(); // timeout cancelled, log never runs
  * ```
  *
  * @example
- * Falsy pieces are omitted (`null`, `undefined`, `false`); arrays flatten recursively:
+ * Zero-delay scheduling that can still be cancelled before the macrotask runs:
  * ```ts
- * const gen = asyncTemplate`${null}${false}A${['B', ['C']]}`;
- * const out = await Array.fromAsync(gen).then((parts) => parts.join(''));
- * // out === 'ABC'
+ * const ac = new AbortController();
+ * setAbortableTimeout(() => startIntro(), 0, ac.signal);
+ * // e.g. on teardown: ac.abort();
  * ```
+ */
+declare function setAbortableTimeout(callback: VoidFunction, delayInMs?: number, signal?: AbortSignal): void;
+
+/**
+ * Returns a promise that resolves after `time` milliseconds.
+ *
+ * When `signal` is passed and becomes aborted before the delay elapses, the promise
+ * rejects with `signal.reason` (same as native `fetch` / `AbortController` usage).
+ * The timeout is cleared on abort so no resolve happens after cancellation.
+ *
+ * @param time - Delay in milliseconds. Defaults to `0` (next macrotask tick, same idea as `setTimeout(0)`).
+ * @param signal - Optional `AbortSignal` to cancel the wait early.
+ * @returns A promise that resolves with `void` when the delay completes, or rejects if aborted.
  *
  * @example
- * Stream from an async iterable (e.g. chunked upstream text):
+ * Basic pause in an async function:
  * ```ts
- * async function* lines() {
- *   yield 'line1\n';
- *   yield 'line2\n';
- * }
- * const gen = asyncTemplate`Header\n${lines()}Footer`;
+ * await sleep(250);
+ * console.log('after 250ms');
  * ```
  *
  * @example
- * Lazy piece via a thunk (invoked as `piece()`):
+ * Cancellable delay tied to component unmount or user action:
  * ```ts
- * let n = 0;
- * const gen = asyncTemplate`count=${() => ++n}`;
- * // first consumption yields "count=1", etc.
+ * const ac = new AbortController();
+ * try {
+ *   await sleep(5000, ac.signal);
+ * } catch (e) {
+ *   // aborted — e is signal.reason
+ * }
+ * ac.abort('user cancelled');
  * ```
  */
-declare function asyncTemplate(strings: TemplateStringsArray, ...pieces: MaybePromise<AsyncTemplatePiece>[]): AsyncGenerator<string, void, unknown>;
+declare const sleep: (time?: number, signal?: AbortSignal) => Promise<void>;
+
+/**
+ * Creates a promise that resolves after the specified number of milliseconds.
+ *
+ * @deprecated Use `sleep` instead.
+ * @param ms Delay in milliseconds.
+ * @returns Promise
+ */
+declare const waitAsync: (ms?: number) => Promise<void>;
 
 export { asyncTemplate, endlessRAF, setAbortableInterval, setAbortableTimeout, sleep, waitAsync };
 export type { AsyncTemplatePiece };

package/async.js

@@ -1,55 +1,92 @@
-//#region src/async.ts
+//#region src/async/async-template.ts
 /**
-* Returns a promise that resolves after `time` milliseconds.
+* Tagged template that builds an async iterable of string chunks (like a streaming template engine).
 *
-* When `signal` is passed and becomes aborted before the delay elapses, the promise
-* rejects with `signal.reason` (same as native `fetch` / `AbortController` usage).
-* The timeout is cleared on abort so no resolve happens after cancellation.
+* Static template parts are yielded as-is. Each interpolated “piece” can be a primitive, a nested array of pieces,
+* a `Promise` of a piece (including a resolved primitive), an async iterable of primitives, or a
+* **zero-arg function** whose result is processed the same way (see {@link AsyncTemplatePiece} / `MaybeFn`).
 *
-* @param time - Delay in milliseconds. Defaults to `0` (next macrotask tick, same idea as `setTimeout(0)`).
-* @param signal - Optional `AbortSignal` to cancel the wait early.
-* @returns A promise that resolves with `void` when the delay completes, or rejects if aborted.
+* Interpolation handling matches `processTemplatePiece`: `null`, `undefined`, and `false` add nothing; any other value
+* becomes text via `String(...)`; functions are called once with no arguments before further processing. Collect chunks
+* with `for await...of` or utilities like `Array.fromAsync` where available.
+*
+* @param strings - Cooked template segments from the tag (`strings[0]`, `strings[1]`, …).
+* @param pieces - Values between segments (`pieces[i]` sits between `strings[i]` and `strings[i + 1]`).
+* @returns An async generator yielding string fragments in document order.
 *
 * @example
-* Basic pause in an async function:
+* Plain values and promises:
 * ```ts
-* await sleep(250);
-* console.log('after 250ms');
+* const gen = asyncTemplate`Hello, ${'world'}! Status: ${Promise.resolve(200)}`;
+* let out = '';
+* for await (const chunk of gen) out += chunk;
+* // out === 'Hello, world! Status: 200'
 * ```
 *
 * @example
-* Cancellable delay tied to component unmount or user action:
+* Falsy pieces are omitted (`null`, `undefined`, `false`); arrays flatten recursively:
 * ```ts
-* const ac = new AbortController();
-* try {
-*   await sleep(5000, ac.signal);
-* } catch (e) {
-*   // aborted — e is signal.reason
+* const gen = asyncTemplate`${null}${false}A${['B', ['C']]}`;
+* const out = await Array.fromAsync(gen).then((parts) => parts.join(''));
+* // out === 'ABC'
+* ```
+*
+* @example
+* Stream from an async iterable (e.g. chunked upstream text):
+* ```ts
+* async function* lines() {
+*   yield 'line1\n';
+*   yield 'line2\n';
 * }
-* ac.abort('user cancelled');
+* const gen = asyncTemplate`Header\n${lines()}Footer`;
+* ```
+*
+* @example
+* Lazy piece via a thunk (invoked as `piece()`):
+* ```ts
+* let n = 0;
+* const gen = asyncTemplate`count=${() => ++n}`;
+* // first consumption yields "count=1", etc.
 * ```
 */
-var sleep = (time = 0, signal) => new Promise((resolve, reject) => {
-	if (signal) {
-		const abortListener = () => {
-			clearTimeout(timerId);
-			reject(signal?.reason);
-		};
-		const timerId = setTimeout(() => {
-			signal.removeEventListener("abort", abortListener);
-			resolve();
-		}, time);
-		signal.addEventListener("abort", abortListener, { once: true });
-	} else setTimeout(resolve, time);
-});
+async function* asyncTemplate(strings, ...pieces) {
+	for (let i = 0; i < strings.length; i++) {
+		yield strings[i];
+		if (i < pieces.length) {
+			const piece = pieces[i];
+			yield* processTemplatePiece(piece);
+		}
+	}
+}
 /**
-* Creates a promise that resolves after the specified number of milliseconds.
+* Resolves a template piece into yielded string chunks.
 *
-* @deprecated Use `sleep` instead.
-* @param ms Delay in milliseconds.
-* @returns Promise
+* Skips output when `value === null || value === undefined || value === false`.
+* Otherwise awaits promises, flattens arrays, streams async iterables, invokes **functions** with no arguments and
+* recurses on the return value, and uses `String(value)` for primitives.
 */
-var waitAsync = async (ms = 1e3) => new Promise((resolve) => setTimeout(resolve, ms));
+async function* processTemplatePiece(piece) {
+	if (piece === null || piece === void 0 || piece === false) return;
+	if (piece instanceof Promise) {
+		yield* processTemplatePiece(await piece);
+		return;
+	}
+	if (Array.isArray(piece)) {
+		for (const item of piece) yield* processTemplatePiece(item);
+		return;
+	}
+	if (typeof piece === "object" && piece !== null && typeof piece[Symbol.asyncIterator] === "function") {
+		for await (const item of piece) yield* processTemplatePiece(item);
+		return;
+	}
+	if (typeof piece === "function") {
+		yield* processTemplatePiece(piece());
+		return;
+	}
+	yield String(piece);
+}
+//#endregion
+//#region src/async/endless-raf.ts
 /**
 * Runs a loop driven by `requestAnimationFrame`: on each frame, `quitFunction` is called first.
 * If it returns a truthy value, the loop stops and no further frames are scheduled.
@@ -92,44 +129,8 @@ var endlessRAF = (quitFunction, asMicrotask) => {
 	if (asMicrotask) queueMicrotask(raf);
 	else raf();
 };
-/**
-* Like `setTimeout`, but if `signal` aborts before the delay fires, the timer is cleared
-* and `callback` is never run. If the callback runs normally, the abort listener is removed.
-*
-* Does nothing special if `signal` is omitted — behaves like a plain timeout.
-*
-* @param callback - Function to run once after `delayInMs` (same as `setTimeout` callback).
-* @param delayInMs - Milliseconds to wait. Passed through to `setTimeout` (browser/Node semantics apply).
-* @param signal - When aborted, clears the pending timeout so `callback` is not invoked.
-*
-* @example
-* ```ts
-* const controller = new AbortController();
-* setAbortableTimeout(() => console.log('done'), 500, controller.signal);
-* // later: controller.abort(); // timeout cancelled, log never runs
-* ```
-*
-* @example
-* Zero-delay scheduling that can still be cancelled before the macrotask runs:
-* ```ts
-* const ac = new AbortController();
-* setAbortableTimeout(() => startIntro(), 0, ac.signal);
-* // e.g. on teardown: ac.abort();
-* ```
-*/
-function setAbortableTimeout(callback, delayInMs, signal) {
-	let internalTimer = null;
-	const handleAbort = () => {
-		if (internalTimer == null) return;
-		clearTimeout(internalTimer);
-		internalTimer = null;
-	};
-	signal?.addEventListener("abort", handleAbort, { once: true });
-	internalTimer = setTimeout(() => {
-		signal?.removeEventListener("abort", handleAbort);
-		callback();
-	}, delayInMs);
-}
+//#endregion
+//#region src/async/set-abortable-interval.ts
 /**
 * Like `setInterval`, but when `signal` aborts, the interval is cleared with `clearInterval`
 * and `callback` stops being called. If `signal` is omitted, behaves like a normal interval
@@ -163,92 +164,101 @@ function setAbortableInterval(callback, delayInMs, signal) {
 	signal?.addEventListener("abort", handleAbort, { once: true });
 	timer = setInterval(callback, delayInMs);
 }
+//#endregion
+//#region src/async/set-abortable-timeout.ts
 /**
-* Tagged template that builds an async iterable of string chunks (like a streaming template engine).
-*
-* Static template parts are yielded as-is. Each interpolated “piece” can be a primitive, a nested array of pieces,
-* a `Promise` of a piece (including a resolved primitive), an async iterable of primitives, or a
-* **zero-arg function** whose result is processed the same way (see {@link AsyncTemplatePiece} / `MaybeFn`).
+* Like `setTimeout`, but if `signal` aborts before the delay fires, the timer is cleared
+* and `callback` is never run. If the callback runs normally, the abort listener is removed.
 *
-* Interpolation handling matches `processTemplatePiece`: `null`, `undefined`, and `false` add nothing; any other value
-* becomes text via `String(...)`; functions are called once with no arguments before further processing. Collect chunks
-* with `for await...of` or utilities like `Array.fromAsync` where available.
+* Does nothing special if `signal` is omitted — behaves like a plain timeout.
 *
-* @param strings - Cooked template segments from the tag (`strings[0]`, `strings[1]`, …).
-* @param pieces - Values between segments (`pieces[i]` sits between `strings[i]` and `strings[i + 1]`).
-* @returns An async generator yielding string fragments in document order.
+* @param callback - Function to run once after `delayInMs` (same as `setTimeout` callback).
+* @param delayInMs - Milliseconds to wait. Passed through to `setTimeout` (browser/Node semantics apply).
+* @param signal - When aborted, clears the pending timeout so `callback` is not invoked.
 *
 * @example
-* Plain values and promises:
 * ```ts
-* const gen = asyncTemplate`Hello, ${'world'}! Status: ${Promise.resolve(200)}`;
-* let out = '';
-* for await (const chunk of gen) out += chunk;
-* // out === 'Hello, world! Status: 200'
+* const controller = new AbortController();
+* setAbortableTimeout(() => console.log('done'), 500, controller.signal);
+* // later: controller.abort(); // timeout cancelled, log never runs
 * ```
 *
 * @example
-* Falsy pieces are omitted (`null`, `undefined`, `false`); arrays flatten recursively:
+* Zero-delay scheduling that can still be cancelled before the macrotask runs:
 * ```ts
-* const gen = asyncTemplate`${null}${false}A${['B', ['C']]}`;
-* const out = await Array.fromAsync(gen).then((parts) => parts.join(''));
-* // out === 'ABC'
+* const ac = new AbortController();
+* setAbortableTimeout(() => startIntro(), 0, ac.signal);
+* // e.g. on teardown: ac.abort();
 * ```
+*/
+function setAbortableTimeout(callback, delayInMs, signal) {
+	let internalTimer = null;
+	const handleAbort = () => {
+		if (internalTimer == null) return;
+		clearTimeout(internalTimer);
+		internalTimer = null;
+	};
+	signal?.addEventListener("abort", handleAbort, { once: true });
+	internalTimer = setTimeout(() => {
+		signal?.removeEventListener("abort", handleAbort);
+		callback();
+	}, delayInMs);
+}
+//#endregion
+//#region src/async/sleep.ts
+/**
+* Returns a promise that resolves after `time` milliseconds.
+*
+* When `signal` is passed and becomes aborted before the delay elapses, the promise
+* rejects with `signal.reason` (same as native `fetch` / `AbortController` usage).
+* The timeout is cleared on abort so no resolve happens after cancellation.
+*
+* @param time - Delay in milliseconds. Defaults to `0` (next macrotask tick, same idea as `setTimeout(0)`).
+* @param signal - Optional `AbortSignal` to cancel the wait early.
+* @returns A promise that resolves with `void` when the delay completes, or rejects if aborted.
 *
 * @example
-* Stream from an async iterable (e.g. chunked upstream text):
+* Basic pause in an async function:
 * ```ts
-* async function* lines() {
-*   yield 'line1\n';
-*   yield 'line2\n';
-* }
-* const gen = asyncTemplate`Header\n${lines()}Footer`;
+* await sleep(250);
+* console.log('after 250ms');
 * ```
 *
 * @example
-* Lazy piece via a thunk (invoked as `piece()`):
+* Cancellable delay tied to component unmount or user action:
 * ```ts
-* let n = 0;
-* const gen = asyncTemplate`count=${() => ++n}`;
-* // first consumption yields "count=1", etc.
+* const ac = new AbortController();
+* try {
+*   await sleep(5000, ac.signal);
+* } catch (e) {
+*   // aborted — e is signal.reason
+* }
+* ac.abort('user cancelled');
 * ```
 */
-async function* asyncTemplate(strings, ...pieces) {
-	for (let i = 0; i < strings.length; i++) {
-		yield strings[i];
-		if (i < pieces.length) {
-			const piece = pieces[i];
-			yield* processTemplatePiece(piece);
-		}
-	}
-}
+var sleep = (time = 0, signal) => new Promise((resolve, reject) => {
+	if (signal) {
+		const abortListener = () => {
+			clearTimeout(timerId);
+			reject(signal?.reason);
+		};
+		const timerId = setTimeout(() => {
+			signal.removeEventListener("abort", abortListener);
+			resolve();
+		}, time);
+		signal.addEventListener("abort", abortListener, { once: true });
+	} else setTimeout(resolve, time);
+});
+//#endregion
+//#region src/async/wait-async.ts
 /**
-* Resolves a template piece into yielded string chunks.
+* Creates a promise that resolves after the specified number of milliseconds.
 *
-* Skips output when `value === null || value === undefined || value === false`.
-* Otherwise awaits promises, flattens arrays, streams async iterables, invokes **functions** with no arguments and
-* recurses on the return value, and uses `String(value)` for primitives.
+* @deprecated Use `sleep` instead.
+* @param ms Delay in milliseconds.
+* @returns Promise
 */
-async function* processTemplatePiece(piece) {
-	if (piece === null || piece === void 0 || piece === false) return;
-	if (piece instanceof Promise) {
-		yield* processTemplatePiece(await piece);
-		return;
-	}
-	if (Array.isArray(piece)) {
-		for (const item of piece) yield* processTemplatePiece(item);
-		return;
-	}
-	if (typeof piece === "object" && piece !== null && typeof piece[Symbol.asyncIterator] === "function") {
-		for await (const item of piece) yield* processTemplatePiece(item);
-		return;
-	}
-	if (typeof piece === "function") {
-		yield* processTemplatePiece(piece());
-		return;
-	}
-	yield String(piece);
-}
+var waitAsync = (ms = 1e3) => sleep(ms);
 //#endregion
 export { asyncTemplate, endlessRAF, setAbortableInterval, setAbortableTimeout, sleep, waitAsync };