npm - yummies - Versions diffs - 7.17.0 → 7.19.0 - Mend

yummies 7.17.0 → 7.19.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/async.cjs CHANGED Viewed

@@ -1,23 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/async.ts
 /**
-* ---header-docs-section---
-* # yummies/async
-*
-* ## Description
-*
-* 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.
-*
-* ## Usage
-*
-* ```ts
-* import { sleep } from "yummies/async";
-* ```
-*/
-/**
 * Returns a promise that resolves after `time` milliseconds.
 *
 * When `signal` is passed and becomes aborted before the delay elapses, the promise
@@ -181,7 +164,79 @@ function setAbortableInterval(callback, delayInMs, signal) {
 	signal?.addEventListener("abort", handleAbort, { once: true });
 	timer = setInterval(callback, delayInMs);
 }
+/**
+* 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, or an async iterable of strings (e.g. another template or a line-by-line source).
+*
+* Interpolation handling matches `processTemplatePiece`: `null`, `undefined`, and `false` add nothing; any other value
+* becomes text via `String(...)`. 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
+* 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'
+* ```
+*
+* @example
+* Falsy pieces are omitted (`null`, `undefined`, `false`); arrays flatten recursively:
+* ```ts
+* 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';
+* }
+* const gen = asyncTemplate`Header\n${lines()}Footer`;
+* ```
+*/
+async function* asyncTemplate(strings, ...pieces) {
+	for (let i = 0; i < strings.length; i++) {
+		yield strings[i];
+		if (i < pieces.length) {
+			const value = pieces[i];
+			yield* processTemplatePiece(value);
+		}
+	}
+}
+/**
+* Resolves a template piece into yielded string chunks.
+*
+* Skips output when `value === null || value === undefined || value === false`.
+* Otherwise awaits promises, flattens arrays, streams async iterables, and uses `String(value)` for primitives.
+*/
+async function* processTemplatePiece(value) {
+	if (value === null || value === void 0 || value === false) return;
+	if (value instanceof Promise) {
+		yield* processTemplatePiece(await value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const item of value) yield* processTemplatePiece(item);
+		return;
+	}
+	if (typeof value === "object" && typeof value[Symbol.asyncIterator] === "function") {
+		yield* value;
+		return;
+	}
+	yield String(value);
+}
 //#endregion
+exports.asyncTemplate = asyncTemplate;
 exports.endlessRAF = endlessRAF;
 exports.setAbortableInterval = setAbortableInterval;
 exports.setAbortableTimeout = setAbortableTimeout;

package/async.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"async.cjs","names":[],"sources":["../src/async.ts"],"sourcesContent":["/*\n ---header-docs-section---\n * # yummies/async\n \n ## Description\n \n Helpers for asynchronous control flow: delays, cancellable waits, scheduling on the next frame,\n * and small utilities around `requestAnimationFrame` and `queueMicrotask`. They complement native\n * `Promise`/`AbortSignal` patterns and keep timing logic easy to test and tree-shake per call site.\n * Import only what you need from `yummies/async` so bundlers can drop unused helpers.\n \n ## Usage\n \n ```ts\n * import { sleep } from \"yummies/async\";\n * ```\n /\n\n/\n Returns a promise that resolves after `time` milliseconds.\n \n When `signal` is passed and becomes aborted before the delay elapses, the promise\n * rejects with `signal.reason` (same as native `fetch` / `AbortController` usage).\n * The timeout is cleared on abort so no resolve happens after cancellation.\n \n @param time - Delay in milliseconds. Defaults to `0` (next macrotask tick, same idea as `setTimeout(0)`).\n * @param signal - Optional `AbortSignal` to cancel the wait early.\n * @returns A promise that resolves with `void` when the delay completes, or rejects if aborted.\n \n @example\n * Basic pause in an async function:\n * ```ts\n * await sleep(250);\n * console.log('after 250ms');\n * ```\n \n @example\n * Cancellable delay tied to component unmount or user action:\n * ```ts\n * const ac = new AbortController();\n * try {\n * await sleep(5000, ac.signal);\n * } catch (e) {\n * // aborted — e is signal.reason\n * }\n * ac.abort('user cancelled');\n * ```\n /\nexport const sleep = (time: number = 0, signal?: AbortSignal) =>\n new Promise<void>((resolve, reject) => {\n if (signal) {\n const abortListener = () => {\n clearTimeout(timerId);\n reject(signal?.reason);\n };\n const timerId = setTimeout(() => {\n signal.removeEventListener('abort', abortListener);\n resolve();\n }, time);\n signal.addEventListener('abort', abortListener, { once: true });\n } else {\n setTimeout(resolve, time);\n }\n });\n\n/\n Creates a promise that resolves after the specified number of milliseconds.\n \n @deprecated Use `sleep` instead.\n * @param ms Delay in milliseconds.\n * @returns Promise\n /\nexport const waitAsync = async (ms = 1000) =>\n new Promise((resolve) => setTimeout(resolve, ms));\n\n/\n Runs a loop driven by `requestAnimationFrame`: on each frame, `quitFunction` is called first.\n * If it returns a truthy value, the loop stops and no further frames are scheduled.\n * If it returns falsy or nothing, the next frame is scheduled recursively.\n \n Use this for per-frame work (animations, layout reads after paint) without managing\n * `cancelAnimationFrame` manually — returning `true` from `quitFunction` is the exit condition.\n \n When `asMicrotask` is `true`, scheduling the next RAF is deferred with `queueMicrotask`\n * so other microtasks can run before the frame is requested (useful when you need to\n * batch DOM updates or let reactive frameworks flush first).\n \n @param quitFunction - Invoked each animation frame. Return `true` to stop the loop.\n * @param asMicrotask - If `true`, wrap the `requestAnimationFrame` call in `queueMicrotask`.\n \n @example\n * Stop after 60 frames (~1s at 60Hz):\n * ```ts\n * let frames = 0;\n * endlessRAF(() => {\n * frames++;\n * updateSomething(frames);\n * return frames >= 60;\n * });\n * ```\n \n @example\n * Run until an element is removed or a flag is set:\n * ```ts\n * let running = true;\n * endlessRAF(() => {\n * if (!running \|\| !document.body.contains(el)) return true;\n * draw(el);\n * }, true);\n * ```\n /\nexport const endlessRAF = (\n quitFunction: () => boolean \| void,\n asMicrotask?: boolean,\n) => {\n if (quitFunction()) return;\n\n const raf = () =>\n requestAnimationFrame(() => endlessRAF(quitFunction, asMicrotask));\n\n if (asMicrotask) {\n queueMicrotask(raf);\n } else {\n raf();\n }\n};\n\n/\n Like `setTimeout`, but if `signal` aborts before the delay fires, the timer is cleared\n * and `callback` is never run. If the callback runs normally, the abort listener is removed.\n \n Does nothing special if `signal` is omitted — behaves like a plain timeout.\n \n @param callback - Function to run once after `delayInMs` (same as `setTimeout` callback).\n * @param delayInMs - Milliseconds to wait. Passed through to `setTimeout` (browser/Node semantics apply).\n * @param signal - When aborted, clears the pending timeout so `callback` is not invoked.\n \n @example\n * ```ts\n * const controller = new AbortController();\n * setAbortableTimeout(() => console.log('done'), 500, controller.signal);\n * // later: controller.abort(); // timeout cancelled, log never runs\n * ```\n \n @example\n * Zero-delay scheduling that can still be cancelled before the macrotask runs:\n * ```ts\n * const ac = new AbortController();\n * setAbortableTimeout(() => startIntro(), 0, ac.signal);\n * // e.g. on teardown: ac.abort();\n * ```\n /\nexport function setAbortableTimeout(\n callback: VoidFunction,\n delayInMs?: number,\n signal?: AbortSignal,\n) {\n let internalTimer: number \| null = null;\n\n const handleAbort = () => {\n if (internalTimer == null) {\n return;\n }\n clearTimeout(internalTimer);\n internalTimer = null;\n };\n\n signal?.addEventListener('abort', handleAbort, { once: true });\n\n internalTimer = setTimeout(() => {\n signal?.removeEventListener('abort', handleAbort);\n callback();\n }, delayInMs);\n}\n\n/\n Like `setInterval`, but when `signal` aborts, the interval is cleared with `clearInterval`\n * and `callback` stops being called. If `signal` is omitted, behaves like a normal interval\n * (you must clear it yourself).\n \n @param callback - Invoked every `delayInMs` milliseconds until aborted or cleared.\n * @param delayInMs - Interval period in milliseconds (same as `setInterval`).\n * @param signal - Aborting stops the interval and removes the abort listener path from keeping work alive.\n \n @example\n * ```ts\n * const controller = new AbortController();\n * setAbortableInterval(() => console.log('tick'), 1000, controller.signal);\n * // stop: controller.abort();\n * ```\n \n @example\n * ```ts\n * const ac = new AbortController();\n * setAbortableInterval(syncStatus, 30_000, ac.signal);\n * window.addEventListener('beforeunload', () => ac.abort());\n * ```\n */\nexport function setAbortableInterval(\n callback: VoidFunction,\n delayInMs?: number,\n signal?: AbortSignal,\n) {\n let timer: number \| null = null;\n\n const handleAbort = () => {\n if (timer == null) {\n return;\n }\n clearInterval(timer);\n timer = null;\n };\n\n signal?.addEventListener('abort', handleAbort, { once: true });\n\n timer = setInterval(callback, delayInMs);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,IAAa,SAAS,OAAe,GAAG,WACtC,IAAI,SAAe,SAAS,WAAW;AACrC,KAAI,QAAQ;EACV,MAAM,sBAAsB;AAC1B,gBAAa,QAAQ;AACrB,UAAO,QAAQ,OAAO;;EAExB,MAAM,UAAU,iBAAiB;AAC/B,UAAO,oBAAoB,SAAS,cAAc;AAClD,YAAS;KACR,KAAK;AACR,SAAO,iBAAiB,SAAS,eAAe,EAAE,MAAM,MAAM,CAAC;OAE/D,YAAW,SAAS,KAAK;EAE3B;;;;;;;;AASJ,IAAa,YAAY,OAAO,KAAK,QACnC,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCnD,IAAa,cACX,cACA,gBACG;AACH,KAAI,cAAc,CAAE;CAEpB,MAAM,YACJ,4BAA4B,WAAW,cAAc,YAAY,CAAC;AAEpE,KAAI,YACF,gBAAe,IAAI;KAEnB,MAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BT,SAAgB,oBACd,UACA,WACA,QACA;CACA,IAAI,gBAA+B;CAEnC,MAAM,oBAAoB;AACxB,MAAI,iBAAiB,KACnB;AAEF,eAAa,cAAc;AAC3B,kBAAgB;;AAGlB,SAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,MAAM,CAAC;AAE9D,iBAAgB,iBAAiB;AAC/B,UAAQ,oBAAoB,SAAS,YAAY;AACjD,YAAU;IACT,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;AA0Bf,SAAgB,qBACd,UACA,WACA,QACA;CACA,IAAI,QAAuB;CAE3B,MAAM,oBAAoB;AACxB,MAAI,SAAS,KACX;AAEF,gBAAc,MAAM;AACpB,UAAQ;;AAGV,SAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,MAAM,CAAC;AAE9D,SAAQ,YAAY,UAAU,UAAU"}
1	+ {"version":3,"file":"async.cjs","names":[],"sources":["../src/async.ts"],"sourcesContent":["/*\n ---header-docs-section---\n * # yummies/async\n \n ## Description\n \n Helpers for asynchronous control flow: delays, cancellable waits, scheduling on the next frame,\n * and small utilities around `requestAnimationFrame` and `queueMicrotask`. They complement native\n * `Promise`/`AbortSignal` patterns and keep timing logic easy to test and tree-shake per call site.\n * Import only what you need from `yummies/async` so bundlers can drop unused helpers.\n \n ## Usage\n \n ```ts\n * import { sleep } from \"yummies/async\";\n * ```\n /\n\nimport type { MaybePromise, Primitive } from './types.js';\n\n/\n Returns a promise that resolves after `time` milliseconds.\n \n When `signal` is passed and becomes aborted before the delay elapses, the promise\n * rejects with `signal.reason` (same as native `fetch` / `AbortController` usage).\n * The timeout is cleared on abort so no resolve happens after cancellation.\n \n @param time - Delay in milliseconds. Defaults to `0` (next macrotask tick, same idea as `setTimeout(0)`).\n * @param signal - Optional `AbortSignal` to cancel the wait early.\n * @returns A promise that resolves with `void` when the delay completes, or rejects if aborted.\n \n @example\n * Basic pause in an async function:\n * ```ts\n * await sleep(250);\n * console.log('after 250ms');\n * ```\n \n @example\n * Cancellable delay tied to component unmount or user action:\n * ```ts\n * const ac = new AbortController();\n * try {\n * await sleep(5000, ac.signal);\n * } catch (e) {\n * // aborted — e is signal.reason\n * }\n * ac.abort('user cancelled');\n * ```\n /\nexport const sleep = (time: number = 0, signal?: AbortSignal) =>\n new Promise<void>((resolve, reject) => {\n if (signal) {\n const abortListener = () => {\n clearTimeout(timerId);\n reject(signal?.reason);\n };\n const timerId = setTimeout(() => {\n signal.removeEventListener('abort', abortListener);\n resolve();\n }, time);\n signal.addEventListener('abort', abortListener, { once: true });\n } else {\n setTimeout(resolve, time);\n }\n });\n\n/\n Creates a promise that resolves after the specified number of milliseconds.\n \n @deprecated Use `sleep` instead.\n * @param ms Delay in milliseconds.\n * @returns Promise\n /\nexport const waitAsync = async (ms = 1000) =>\n new Promise((resolve) => setTimeout(resolve, ms));\n\n/\n Runs a loop driven by `requestAnimationFrame`: on each frame, `quitFunction` is called first.\n * If it returns a truthy value, the loop stops and no further frames are scheduled.\n * If it returns falsy or nothing, the next frame is scheduled recursively.\n \n Use this for per-frame work (animations, layout reads after paint) without managing\n * `cancelAnimationFrame` manually — returning `true` from `quitFunction` is the exit condition.\n \n When `asMicrotask` is `true`, scheduling the next RAF is deferred with `queueMicrotask`\n * so other microtasks can run before the frame is requested (useful when you need to\n * batch DOM updates or let reactive frameworks flush first).\n \n @param quitFunction - Invoked each animation frame. Return `true` to stop the loop.\n * @param asMicrotask - If `true`, wrap the `requestAnimationFrame` call in `queueMicrotask`.\n \n @example\n * Stop after 60 frames (~1s at 60Hz):\n * ```ts\n * let frames = 0;\n * endlessRAF(() => {\n * frames++;\n * updateSomething(frames);\n * return frames >= 60;\n * });\n * ```\n \n @example\n * Run until an element is removed or a flag is set:\n * ```ts\n * let running = true;\n * endlessRAF(() => {\n * if (!running \|\| !document.body.contains(el)) return true;\n * draw(el);\n * }, true);\n * ```\n /\nexport const endlessRAF = (\n quitFunction: () => boolean \| void,\n asMicrotask?: boolean,\n) => {\n if (quitFunction()) return;\n\n const raf = () =>\n requestAnimationFrame(() => endlessRAF(quitFunction, asMicrotask));\n\n if (asMicrotask) {\n queueMicrotask(raf);\n } else {\n raf();\n }\n};\n\n/\n Like `setTimeout`, but if `signal` aborts before the delay fires, the timer is cleared\n * and `callback` is never run. If the callback runs normally, the abort listener is removed.\n \n Does nothing special if `signal` is omitted — behaves like a plain timeout.\n \n @param callback - Function to run once after `delayInMs` (same as `setTimeout` callback).\n * @param delayInMs - Milliseconds to wait. Passed through to `setTimeout` (browser/Node semantics apply).\n * @param signal - When aborted, clears the pending timeout so `callback` is not invoked.\n \n @example\n * ```ts\n * const controller = new AbortController();\n * setAbortableTimeout(() => console.log('done'), 500, controller.signal);\n * // later: controller.abort(); // timeout cancelled, log never runs\n * ```\n \n @example\n * Zero-delay scheduling that can still be cancelled before the macrotask runs:\n * ```ts\n * const ac = new AbortController();\n * setAbortableTimeout(() => startIntro(), 0, ac.signal);\n * // e.g. on teardown: ac.abort();\n * ```\n /\nexport function setAbortableTimeout(\n callback: VoidFunction,\n delayInMs?: number,\n signal?: AbortSignal,\n) {\n let internalTimer: number \| null = null;\n\n const handleAbort = () => {\n if (internalTimer == null) {\n return;\n }\n clearTimeout(internalTimer);\n internalTimer = null;\n };\n\n signal?.addEventListener('abort', handleAbort, { once: true });\n\n internalTimer = setTimeout(() => {\n signal?.removeEventListener('abort', handleAbort);\n callback();\n }, delayInMs);\n}\n\n/\n Like `setInterval`, but when `signal` aborts, the interval is cleared with `clearInterval`\n * and `callback` stops being called. If `signal` is omitted, behaves like a normal interval\n * (you must clear it yourself).\n \n @param callback - Invoked every `delayInMs` milliseconds until aborted or cleared.\n * @param delayInMs - Interval period in milliseconds (same as `setInterval`).\n * @param signal - Aborting stops the interval and removes the abort listener path from keeping work alive.\n \n @example\n * ```ts\n * const controller = new AbortController();\n * setAbortableInterval(() => console.log('tick'), 1000, controller.signal);\n * // stop: controller.abort();\n * ```\n \n @example\n * ```ts\n * const ac = new AbortController();\n * setAbortableInterval(syncStatus, 30_000, ac.signal);\n * window.addEventListener('beforeunload', () => ac.abort());\n * ```\n /\nexport function setAbortableInterval(\n callback: VoidFunction,\n delayInMs?: number,\n signal?: AbortSignal,\n) {\n let timer: number \| null = null;\n\n const handleAbort = () => {\n if (timer == null) {\n return;\n }\n clearInterval(timer);\n timer = null;\n };\n\n signal?.addEventListener('abort', handleAbort, { once: true });\n\n timer = setInterval(callback, delayInMs);\n}\n\n/\n A single interpolated segment in {@link asyncTemplate}.\n \n - Primitives use `String(value)` for output, except that values matching\n * `value === null \|\| value === undefined \|\| value === false` yield no text (early return in `processTemplatePiece`).\n * Other falsy values such as `0` or `''` are still stringified.\n * - Arrays are flattened recursively in order.\n * - Promises are awaited; the resolved value is processed the same way.\n * - Async iterables of strings are streamed in order (`yield`).\n /\nexport type AsyncTemplatePiece =\n \| Primitive\n \| void\n \| AsyncIterable<string>\n \| AsyncTemplatePiece[];\n\n/*\n Tagged template that builds an async iterable of string chunks (like a streaming template engine).\n \n Static template parts are yielded as-is. Each interpolated “piece” can be a primitive, a nested array of pieces,\n * a `Promise` of a piece, or an async iterable of strings (e.g. another template or a line-by-line source).\n \n Interpolation handling matches `processTemplatePiece`: `null`, `undefined`, and `false` add nothing; any other value\n * becomes text via `String(...)`. Collect chunks with `for await...of` or utilities like `Array.fromAsync` where available.\n \n @param strings - Cooked template segments from the tag (`strings[0]`, `strings[1]`, …).\n * @param pieces - Values between segments (`pieces[i]` sits between `strings[i]` and `strings[i + 1]`).\n * @returns An async generator yielding string fragments in document order.\n \n @example\n * Plain values and promises:\n * ```ts\n * const gen = asyncTemplate`Hello, ${'world'}! Status: ${Promise.resolve(200)}`;\n * let out = '';\n * for await (const chunk of gen) out += chunk;\n * // out === 'Hello, world! Status: 200'\n * ```\n \n @example\n * Falsy pieces are omitted (`null`, `undefined`, `false`); arrays flatten recursively:\n * ```ts\n * const gen = asyncTemplate`${null}${false}A${['B', ['C']]}`;\n * const out = await Array.fromAsync(gen).then((parts) => parts.join(''));\n * // out === 'ABC'\n * ```\n \n @example\n * Stream from an async iterable (e.g. chunked upstream text):\n * ```ts\n * async function* lines() {\n * yield 'line1\\n';\n * yield 'line2\\n';\n * }\n * const gen = asyncTemplate`Header\\n${lines()}Footer`;\n * ```\n /\nexport async function asyncTemplate(\n strings: TemplateStringsArray,\n ...pieces: MaybePromise<AsyncTemplatePiece>[]\n) {\n for (let i = 0; i < strings.length; i++) {\n yield strings[i];\n\n if (i < pieces.length) {\n const value = pieces[i];\n yield* processTemplatePiece(value);\n }\n }\n}\n\n/*\n Resolves a template piece into yielded string chunks.\n \n Skips output when `value === null \|\| value === undefined \|\| value === false`.\n * Otherwise awaits promises, flattens arrays, streams async iterables, and uses `String(value)` for primitives.\n /\nasync function processTemplatePiece(\n value: MaybePromise<AsyncTemplatePiece>,\n): AsyncGenerator<string, void, unknown> {\n if (value === null \|\| value === undefined \|\| value === false) {\n return;\n }\n\n if (value instanceof Promise) {\n const resolved = await value;\n yield* processTemplatePiece(resolved);\n return;\n }\n\n if (Array.isArray(value)) {\n for (const item of value) {\n yield* processTemplatePiece(item);\n }\n return;\n }\n\n if (\n typeof value === 'object' &&\n typeof value[Symbol.asyncIterator] === 'function'\n ) {\n yield* value;\n return;\n }\n\n yield String(value);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,IAAa,SAAS,OAAe,GAAG,WACtC,IAAI,SAAe,SAAS,WAAW;AACrC,KAAI,QAAQ;EACV,MAAM,sBAAsB;AAC1B,gBAAa,QAAQ;AACrB,UAAO,QAAQ,OAAO;;EAExB,MAAM,UAAU,iBAAiB;AAC/B,UAAO,oBAAoB,SAAS,cAAc;AAClD,YAAS;KACR,KAAK;AACR,SAAO,iBAAiB,SAAS,eAAe,EAAE,MAAM,MAAM,CAAC;OAE/D,YAAW,SAAS,KAAK;EAE3B;;;;;;;;AASJ,IAAa,YAAY,OAAO,KAAK,QACnC,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCnD,IAAa,cACX,cACA,gBACG;AACH,KAAI,cAAc,CAAE;CAEpB,MAAM,YACJ,4BAA4B,WAAW,cAAc,YAAY,CAAC;AAEpE,KAAI,YACF,gBAAe,IAAI;KAEnB,MAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BT,SAAgB,oBACd,UACA,WACA,QACA;CACA,IAAI,gBAA+B;CAEnC,MAAM,oBAAoB;AACxB,MAAI,iBAAiB,KACnB;AAEF,eAAa,cAAc;AAC3B,kBAAgB;;AAGlB,SAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,MAAM,CAAC;AAE9D,iBAAgB,iBAAiB;AAC/B,UAAQ,oBAAoB,SAAS,YAAY;AACjD,YAAU;IACT,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;AA0Bf,SAAgB,qBACd,UACA,WACA,QACA;CACA,IAAI,QAAuB;CAE3B,MAAM,oBAAoB;AACxB,MAAI,SAAS,KACX;AAEF,gBAAc,MAAM;AACpB,UAAQ;;AAGV,SAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,MAAM,CAAC;AAE9D,SAAQ,YAAY,UAAU,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2D1C,gBAAuB,cACrB,SACA,GAAG,QACH;AACA,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,QAAM,QAAQ;AAEd,MAAI,IAAI,OAAO,QAAQ;GACrB,MAAM,QAAQ,OAAO;AACrB,UAAO,qBAAqB,MAAM;;;;;;;;;;AAWxC,gBAAgB,qBACd,OACuC;AACvC,KAAI,UAAU,QAAQ,UAAU,KAAA,KAAa,UAAU,MACrD;AAGF,KAAI,iBAAiB,SAAS;AAE5B,SAAO,qBADU,MAAM,MACc;AACrC;;AAGF,KAAI,MAAM,QAAQ,MAAM,EAAE;AACxB,OAAK,MAAM,QAAQ,MACjB,QAAO,qBAAqB,KAAK;AAEnC;;AAGF,KACE,OAAO,UAAU,YACjB,OAAO,MAAM,OAAO,mBAAmB,YACvC;AACA,SAAO;AACP;;AAGF,OAAM,OAAO,MAAM"}

package/async.d.ts CHANGED Viewed

@@ -1,3 +1,17 @@
+/**
+ * Represents all primitive types in TypeScript.
+ *
+ * @returns Union of all primitive types
+ */
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+/**
+ * Represents a type that can be either the specified type or a Promise resolving to that type.
+ *
+ * @template T - The type to make possibly a promise
+ * @returns T or Promise<T>
+ */
+type MaybePromise<T> = T | Promise<T>;
 /**
  * ---header-docs-section---
  * # yummies/async
@@ -15,6 +29,7 @@
  * import { sleep } from "yummies/async";
  * ```
  */
 /**
  * Returns a promise that resolves after `time` milliseconds.
  *
@@ -141,5 +156,58 @@ 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 strings** are streamed in order (`yield*`).
+ */
+type AsyncTemplatePiece = Primitive | void | AsyncIterable<string> | 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, or an async iterable of strings (e.g. another template or a line-by-line source).
+ *
+ * Interpolation handling matches `processTemplatePiece`: `null`, `undefined`, and `false` add nothing; any other value
+ * becomes text via `String(...)`. 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
+ * 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'
+ * ```
+ *
+ * @example
+ * Falsy pieces are omitted (`null`, `undefined`, `false`); arrays flatten recursively:
+ * ```ts
+ * 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';
+ * }
+ * const gen = asyncTemplate`Header\n${lines()}Footer`;
+ * ```
+ */
+declare function asyncTemplate(strings: TemplateStringsArray, ...pieces: MaybePromise<AsyncTemplatePiece>[]): AsyncGenerator<string, void, unknown>;
-export { endlessRAF, setAbortableInterval, setAbortableTimeout, sleep, waitAsync };
+export { asyncTemplate, endlessRAF, setAbortableInterval, setAbortableTimeout, sleep, waitAsync };
+export type { AsyncTemplatePiece };

package/async.js CHANGED Viewed

@@ -1,22 +1,5 @@
 //#region src/async.ts
 /**
-* ---header-docs-section---
-* # yummies/async
-*
-* ## Description
-*
-* 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.
-*
-* ## Usage
-*
-* ```ts
-* import { sleep } from "yummies/async";
-* ```
-*/
-/**
 * Returns a promise that resolves after `time` milliseconds.
 *
 * When `signal` is passed and becomes aborted before the delay elapses, the promise
@@ -180,7 +163,78 @@ function setAbortableInterval(callback, delayInMs, signal) {
 	signal?.addEventListener("abort", handleAbort, { once: true });
 	timer = setInterval(callback, delayInMs);
 }
+/**
+* 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, or an async iterable of strings (e.g. another template or a line-by-line source).
+*
+* Interpolation handling matches `processTemplatePiece`: `null`, `undefined`, and `false` add nothing; any other value
+* becomes text via `String(...)`. 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
+* 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'
+* ```
+*
+* @example
+* Falsy pieces are omitted (`null`, `undefined`, `false`); arrays flatten recursively:
+* ```ts
+* 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';
+* }
+* const gen = asyncTemplate`Header\n${lines()}Footer`;
+* ```
+*/
+async function* asyncTemplate(strings, ...pieces) {
+	for (let i = 0; i < strings.length; i++) {
+		yield strings[i];
+		if (i < pieces.length) {
+			const value = pieces[i];
+			yield* processTemplatePiece(value);
+		}
+	}
+}
+/**
+* Resolves a template piece into yielded string chunks.
+*
+* Skips output when `value === null || value === undefined || value === false`.
+* Otherwise awaits promises, flattens arrays, streams async iterables, and uses `String(value)` for primitives.
+*/
+async function* processTemplatePiece(value) {
+	if (value === null || value === void 0 || value === false) return;
+	if (value instanceof Promise) {
+		yield* processTemplatePiece(await value);
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const item of value) yield* processTemplatePiece(item);
+		return;
+	}
+	if (typeof value === "object" && typeof value[Symbol.asyncIterator] === "function") {
+		yield* value;
+		return;
+	}
+	yield String(value);
+}
 //#endregion
-export { endlessRAF, setAbortableInterval, setAbortableTimeout, sleep, waitAsync };
+export { asyncTemplate, endlessRAF, setAbortableInterval, setAbortableTimeout, sleep, waitAsync };
 //# sourceMappingURL=async.js.map

package/async.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"async.js","names":[],"sources":["../src/async.ts"],"sourcesContent":["/*\n ---header-docs-section---\n * # yummies/async\n \n ## Description\n \n Helpers for asynchronous control flow: delays, cancellable waits, scheduling on the next frame,\n * and small utilities around `requestAnimationFrame` and `queueMicrotask`. They complement native\n * `Promise`/`AbortSignal` patterns and keep timing logic easy to test and tree-shake per call site.\n * Import only what you need from `yummies/async` so bundlers can drop unused helpers.\n \n ## Usage\n \n ```ts\n * import { sleep } from \"yummies/async\";\n * ```\n /\n\n/\n Returns a promise that resolves after `time` milliseconds.\n \n When `signal` is passed and becomes aborted before the delay elapses, the promise\n * rejects with `signal.reason` (same as native `fetch` / `AbortController` usage).\n * The timeout is cleared on abort so no resolve happens after cancellation.\n \n @param time - Delay in milliseconds. Defaults to `0` (next macrotask tick, same idea as `setTimeout(0)`).\n * @param signal - Optional `AbortSignal` to cancel the wait early.\n * @returns A promise that resolves with `void` when the delay completes, or rejects if aborted.\n \n @example\n * Basic pause in an async function:\n * ```ts\n * await sleep(250);\n * console.log('after 250ms');\n * ```\n \n @example\n * Cancellable delay tied to component unmount or user action:\n * ```ts\n * const ac = new AbortController();\n * try {\n * await sleep(5000, ac.signal);\n * } catch (e) {\n * // aborted — e is signal.reason\n * }\n * ac.abort('user cancelled');\n * ```\n /\nexport const sleep = (time: number = 0, signal?: AbortSignal) =>\n new Promise<void>((resolve, reject) => {\n if (signal) {\n const abortListener = () => {\n clearTimeout(timerId);\n reject(signal?.reason);\n };\n const timerId = setTimeout(() => {\n signal.removeEventListener('abort', abortListener);\n resolve();\n }, time);\n signal.addEventListener('abort', abortListener, { once: true });\n } else {\n setTimeout(resolve, time);\n }\n });\n\n/\n Creates a promise that resolves after the specified number of milliseconds.\n \n @deprecated Use `sleep` instead.\n * @param ms Delay in milliseconds.\n * @returns Promise\n /\nexport const waitAsync = async (ms = 1000) =>\n new Promise((resolve) => setTimeout(resolve, ms));\n\n/\n Runs a loop driven by `requestAnimationFrame`: on each frame, `quitFunction` is called first.\n * If it returns a truthy value, the loop stops and no further frames are scheduled.\n * If it returns falsy or nothing, the next frame is scheduled recursively.\n \n Use this for per-frame work (animations, layout reads after paint) without managing\n * `cancelAnimationFrame` manually — returning `true` from `quitFunction` is the exit condition.\n \n When `asMicrotask` is `true`, scheduling the next RAF is deferred with `queueMicrotask`\n * so other microtasks can run before the frame is requested (useful when you need to\n * batch DOM updates or let reactive frameworks flush first).\n \n @param quitFunction - Invoked each animation frame. Return `true` to stop the loop.\n * @param asMicrotask - If `true`, wrap the `requestAnimationFrame` call in `queueMicrotask`.\n \n @example\n * Stop after 60 frames (~1s at 60Hz):\n * ```ts\n * let frames = 0;\n * endlessRAF(() => {\n * frames++;\n * updateSomething(frames);\n * return frames >= 60;\n * });\n * ```\n \n @example\n * Run until an element is removed or a flag is set:\n * ```ts\n * let running = true;\n * endlessRAF(() => {\n * if (!running \|\| !document.body.contains(el)) return true;\n * draw(el);\n * }, true);\n * ```\n /\nexport const endlessRAF = (\n quitFunction: () => boolean \| void,\n asMicrotask?: boolean,\n) => {\n if (quitFunction()) return;\n\n const raf = () =>\n requestAnimationFrame(() => endlessRAF(quitFunction, asMicrotask));\n\n if (asMicrotask) {\n queueMicrotask(raf);\n } else {\n raf();\n }\n};\n\n/\n Like `setTimeout`, but if `signal` aborts before the delay fires, the timer is cleared\n * and `callback` is never run. If the callback runs normally, the abort listener is removed.\n \n Does nothing special if `signal` is omitted — behaves like a plain timeout.\n \n @param callback - Function to run once after `delayInMs` (same as `setTimeout` callback).\n * @param delayInMs - Milliseconds to wait. Passed through to `setTimeout` (browser/Node semantics apply).\n * @param signal - When aborted, clears the pending timeout so `callback` is not invoked.\n \n @example\n * ```ts\n * const controller = new AbortController();\n * setAbortableTimeout(() => console.log('done'), 500, controller.signal);\n * // later: controller.abort(); // timeout cancelled, log never runs\n * ```\n \n @example\n * Zero-delay scheduling that can still be cancelled before the macrotask runs:\n * ```ts\n * const ac = new AbortController();\n * setAbortableTimeout(() => startIntro(), 0, ac.signal);\n * // e.g. on teardown: ac.abort();\n * ```\n /\nexport function setAbortableTimeout(\n callback: VoidFunction,\n delayInMs?: number,\n signal?: AbortSignal,\n) {\n let internalTimer: number \| null = null;\n\n const handleAbort = () => {\n if (internalTimer == null) {\n return;\n }\n clearTimeout(internalTimer);\n internalTimer = null;\n };\n\n signal?.addEventListener('abort', handleAbort, { once: true });\n\n internalTimer = setTimeout(() => {\n signal?.removeEventListener('abort', handleAbort);\n callback();\n }, delayInMs);\n}\n\n/\n Like `setInterval`, but when `signal` aborts, the interval is cleared with `clearInterval`\n * and `callback` stops being called. If `signal` is omitted, behaves like a normal interval\n * (you must clear it yourself).\n \n @param callback - Invoked every `delayInMs` milliseconds until aborted or cleared.\n * @param delayInMs - Interval period in milliseconds (same as `setInterval`).\n * @param signal - Aborting stops the interval and removes the abort listener path from keeping work alive.\n \n @example\n * ```ts\n * const controller = new AbortController();\n * setAbortableInterval(() => console.log('tick'), 1000, controller.signal);\n * // stop: controller.abort();\n * ```\n \n @example\n * ```ts\n * const ac = new AbortController();\n * setAbortableInterval(syncStatus, 30_000, ac.signal);\n * window.addEventListener('beforeunload', () => ac.abort());\n * ```\n */\nexport function setAbortableInterval(\n callback: VoidFunction,\n delayInMs?: number,\n signal?: AbortSignal,\n) {\n let timer: number \| null = null;\n\n const handleAbort = () => {\n if (timer == null) {\n return;\n }\n clearInterval(timer);\n timer = null;\n };\n\n signal?.addEventListener('abort', handleAbort, { once: true });\n\n timer = setInterval(callback, delayInMs);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgDA,IAAa,SAAS,OAAe,GAAG,WACtC,IAAI,SAAe,SAAS,WAAW;AACrC,KAAI,QAAQ;EACV,MAAM,sBAAsB;AAC1B,gBAAa,QAAQ;AACrB,UAAO,QAAQ,OAAO;;EAExB,MAAM,UAAU,iBAAiB;AAC/B,UAAO,oBAAoB,SAAS,cAAc;AAClD,YAAS;KACR,KAAK;AACR,SAAO,iBAAiB,SAAS,eAAe,EAAE,MAAM,MAAM,CAAC;OAE/D,YAAW,SAAS,KAAK;EAE3B;;;;;;;;AASJ,IAAa,YAAY,OAAO,KAAK,QACnC,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCnD,IAAa,cACX,cACA,gBACG;AACH,KAAI,cAAc,CAAE;CAEpB,MAAM,YACJ,4BAA4B,WAAW,cAAc,YAAY,CAAC;AAEpE,KAAI,YACF,gBAAe,IAAI;KAEnB,MAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BT,SAAgB,oBACd,UACA,WACA,QACA;CACA,IAAI,gBAA+B;CAEnC,MAAM,oBAAoB;AACxB,MAAI,iBAAiB,KACnB;AAEF,eAAa,cAAc;AAC3B,kBAAgB;;AAGlB,SAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,MAAM,CAAC;AAE9D,iBAAgB,iBAAiB;AAC/B,UAAQ,oBAAoB,SAAS,YAAY;AACjD,YAAU;IACT,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;AA0Bf,SAAgB,qBACd,UACA,WACA,QACA;CACA,IAAI,QAAuB;CAE3B,MAAM,oBAAoB;AACxB,MAAI,SAAS,KACX;AAEF,gBAAc,MAAM;AACpB,UAAQ;;AAGV,SAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,MAAM,CAAC;AAE9D,SAAQ,YAAY,UAAU,UAAU"}
1	+ {"version":3,"file":"async.js","names":[],"sources":["../src/async.ts"],"sourcesContent":["/*\n ---header-docs-section---\n * # yummies/async\n \n ## Description\n \n Helpers for asynchronous control flow: delays, cancellable waits, scheduling on the next frame,\n * and small utilities around `requestAnimationFrame` and `queueMicrotask`. They complement native\n * `Promise`/`AbortSignal` patterns and keep timing logic easy to test and tree-shake per call site.\n * Import only what you need from `yummies/async` so bundlers can drop unused helpers.\n \n ## Usage\n \n ```ts\n * import { sleep } from \"yummies/async\";\n * ```\n /\n\nimport type { MaybePromise, Primitive } from './types.js';\n\n/\n Returns a promise that resolves after `time` milliseconds.\n \n When `signal` is passed and becomes aborted before the delay elapses, the promise\n * rejects with `signal.reason` (same as native `fetch` / `AbortController` usage).\n * The timeout is cleared on abort so no resolve happens after cancellation.\n \n @param time - Delay in milliseconds. Defaults to `0` (next macrotask tick, same idea as `setTimeout(0)`).\n * @param signal - Optional `AbortSignal` to cancel the wait early.\n * @returns A promise that resolves with `void` when the delay completes, or rejects if aborted.\n \n @example\n * Basic pause in an async function:\n * ```ts\n * await sleep(250);\n * console.log('after 250ms');\n * ```\n \n @example\n * Cancellable delay tied to component unmount or user action:\n * ```ts\n * const ac = new AbortController();\n * try {\n * await sleep(5000, ac.signal);\n * } catch (e) {\n * // aborted — e is signal.reason\n * }\n * ac.abort('user cancelled');\n * ```\n /\nexport const sleep = (time: number = 0, signal?: AbortSignal) =>\n new Promise<void>((resolve, reject) => {\n if (signal) {\n const abortListener = () => {\n clearTimeout(timerId);\n reject(signal?.reason);\n };\n const timerId = setTimeout(() => {\n signal.removeEventListener('abort', abortListener);\n resolve();\n }, time);\n signal.addEventListener('abort', abortListener, { once: true });\n } else {\n setTimeout(resolve, time);\n }\n });\n\n/\n Creates a promise that resolves after the specified number of milliseconds.\n \n @deprecated Use `sleep` instead.\n * @param ms Delay in milliseconds.\n * @returns Promise\n /\nexport const waitAsync = async (ms = 1000) =>\n new Promise((resolve) => setTimeout(resolve, ms));\n\n/\n Runs a loop driven by `requestAnimationFrame`: on each frame, `quitFunction` is called first.\n * If it returns a truthy value, the loop stops and no further frames are scheduled.\n * If it returns falsy or nothing, the next frame is scheduled recursively.\n \n Use this for per-frame work (animations, layout reads after paint) without managing\n * `cancelAnimationFrame` manually — returning `true` from `quitFunction` is the exit condition.\n \n When `asMicrotask` is `true`, scheduling the next RAF is deferred with `queueMicrotask`\n * so other microtasks can run before the frame is requested (useful when you need to\n * batch DOM updates or let reactive frameworks flush first).\n \n @param quitFunction - Invoked each animation frame. Return `true` to stop the loop.\n * @param asMicrotask - If `true`, wrap the `requestAnimationFrame` call in `queueMicrotask`.\n \n @example\n * Stop after 60 frames (~1s at 60Hz):\n * ```ts\n * let frames = 0;\n * endlessRAF(() => {\n * frames++;\n * updateSomething(frames);\n * return frames >= 60;\n * });\n * ```\n \n @example\n * Run until an element is removed or a flag is set:\n * ```ts\n * let running = true;\n * endlessRAF(() => {\n * if (!running \|\| !document.body.contains(el)) return true;\n * draw(el);\n * }, true);\n * ```\n /\nexport const endlessRAF = (\n quitFunction: () => boolean \| void,\n asMicrotask?: boolean,\n) => {\n if (quitFunction()) return;\n\n const raf = () =>\n requestAnimationFrame(() => endlessRAF(quitFunction, asMicrotask));\n\n if (asMicrotask) {\n queueMicrotask(raf);\n } else {\n raf();\n }\n};\n\n/\n Like `setTimeout`, but if `signal` aborts before the delay fires, the timer is cleared\n * and `callback` is never run. If the callback runs normally, the abort listener is removed.\n \n Does nothing special if `signal` is omitted — behaves like a plain timeout.\n \n @param callback - Function to run once after `delayInMs` (same as `setTimeout` callback).\n * @param delayInMs - Milliseconds to wait. Passed through to `setTimeout` (browser/Node semantics apply).\n * @param signal - When aborted, clears the pending timeout so `callback` is not invoked.\n \n @example\n * ```ts\n * const controller = new AbortController();\n * setAbortableTimeout(() => console.log('done'), 500, controller.signal);\n * // later: controller.abort(); // timeout cancelled, log never runs\n * ```\n \n @example\n * Zero-delay scheduling that can still be cancelled before the macrotask runs:\n * ```ts\n * const ac = new AbortController();\n * setAbortableTimeout(() => startIntro(), 0, ac.signal);\n * // e.g. on teardown: ac.abort();\n * ```\n /\nexport function setAbortableTimeout(\n callback: VoidFunction,\n delayInMs?: number,\n signal?: AbortSignal,\n) {\n let internalTimer: number \| null = null;\n\n const handleAbort = () => {\n if (internalTimer == null) {\n return;\n }\n clearTimeout(internalTimer);\n internalTimer = null;\n };\n\n signal?.addEventListener('abort', handleAbort, { once: true });\n\n internalTimer = setTimeout(() => {\n signal?.removeEventListener('abort', handleAbort);\n callback();\n }, delayInMs);\n}\n\n/\n Like `setInterval`, but when `signal` aborts, the interval is cleared with `clearInterval`\n * and `callback` stops being called. If `signal` is omitted, behaves like a normal interval\n * (you must clear it yourself).\n \n @param callback - Invoked every `delayInMs` milliseconds until aborted or cleared.\n * @param delayInMs - Interval period in milliseconds (same as `setInterval`).\n * @param signal - Aborting stops the interval and removes the abort listener path from keeping work alive.\n \n @example\n * ```ts\n * const controller = new AbortController();\n * setAbortableInterval(() => console.log('tick'), 1000, controller.signal);\n * // stop: controller.abort();\n * ```\n \n @example\n * ```ts\n * const ac = new AbortController();\n * setAbortableInterval(syncStatus, 30_000, ac.signal);\n * window.addEventListener('beforeunload', () => ac.abort());\n * ```\n /\nexport function setAbortableInterval(\n callback: VoidFunction,\n delayInMs?: number,\n signal?: AbortSignal,\n) {\n let timer: number \| null = null;\n\n const handleAbort = () => {\n if (timer == null) {\n return;\n }\n clearInterval(timer);\n timer = null;\n };\n\n signal?.addEventListener('abort', handleAbort, { once: true });\n\n timer = setInterval(callback, delayInMs);\n}\n\n/\n A single interpolated segment in {@link asyncTemplate}.\n \n - Primitives use `String(value)` for output, except that values matching\n * `value === null \|\| value === undefined \|\| value === false` yield no text (early return in `processTemplatePiece`).\n * Other falsy values such as `0` or `''` are still stringified.\n * - Arrays are flattened recursively in order.\n * - Promises are awaited; the resolved value is processed the same way.\n * - Async iterables of strings are streamed in order (`yield`).\n /\nexport type AsyncTemplatePiece =\n \| Primitive\n \| void\n \| AsyncIterable<string>\n \| AsyncTemplatePiece[];\n\n/*\n Tagged template that builds an async iterable of string chunks (like a streaming template engine).\n \n Static template parts are yielded as-is. Each interpolated “piece” can be a primitive, a nested array of pieces,\n * a `Promise` of a piece, or an async iterable of strings (e.g. another template or a line-by-line source).\n \n Interpolation handling matches `processTemplatePiece`: `null`, `undefined`, and `false` add nothing; any other value\n * becomes text via `String(...)`. Collect chunks with `for await...of` or utilities like `Array.fromAsync` where available.\n \n @param strings - Cooked template segments from the tag (`strings[0]`, `strings[1]`, …).\n * @param pieces - Values between segments (`pieces[i]` sits between `strings[i]` and `strings[i + 1]`).\n * @returns An async generator yielding string fragments in document order.\n \n @example\n * Plain values and promises:\n * ```ts\n * const gen = asyncTemplate`Hello, ${'world'}! Status: ${Promise.resolve(200)}`;\n * let out = '';\n * for await (const chunk of gen) out += chunk;\n * // out === 'Hello, world! Status: 200'\n * ```\n \n @example\n * Falsy pieces are omitted (`null`, `undefined`, `false`); arrays flatten recursively:\n * ```ts\n * const gen = asyncTemplate`${null}${false}A${['B', ['C']]}`;\n * const out = await Array.fromAsync(gen).then((parts) => parts.join(''));\n * // out === 'ABC'\n * ```\n \n @example\n * Stream from an async iterable (e.g. chunked upstream text):\n * ```ts\n * async function* lines() {\n * yield 'line1\\n';\n * yield 'line2\\n';\n * }\n * const gen = asyncTemplate`Header\\n${lines()}Footer`;\n * ```\n /\nexport async function asyncTemplate(\n strings: TemplateStringsArray,\n ...pieces: MaybePromise<AsyncTemplatePiece>[]\n) {\n for (let i = 0; i < strings.length; i++) {\n yield strings[i];\n\n if (i < pieces.length) {\n const value = pieces[i];\n yield* processTemplatePiece(value);\n }\n }\n}\n\n/*\n Resolves a template piece into yielded string chunks.\n \n Skips output when `value === null \|\| value === undefined \|\| value === false`.\n * Otherwise awaits promises, flattens arrays, streams async iterables, and uses `String(value)` for primitives.\n /\nasync function processTemplatePiece(\n value: MaybePromise<AsyncTemplatePiece>,\n): AsyncGenerator<string, void, unknown> {\n if (value === null \|\| value === undefined \|\| value === false) {\n return;\n }\n\n if (value instanceof Promise) {\n const resolved = await value;\n yield* processTemplatePiece(resolved);\n return;\n }\n\n if (Array.isArray(value)) {\n for (const item of value) {\n yield* processTemplatePiece(item);\n }\n return;\n }\n\n if (\n typeof value === 'object' &&\n typeof value[Symbol.asyncIterator] === 'function'\n ) {\n yield* value;\n return;\n }\n\n yield String(value);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,IAAa,SAAS,OAAe,GAAG,WACtC,IAAI,SAAe,SAAS,WAAW;AACrC,KAAI,QAAQ;EACV,MAAM,sBAAsB;AAC1B,gBAAa,QAAQ;AACrB,UAAO,QAAQ,OAAO;;EAExB,MAAM,UAAU,iBAAiB;AAC/B,UAAO,oBAAoB,SAAS,cAAc;AAClD,YAAS;KACR,KAAK;AACR,SAAO,iBAAiB,SAAS,eAAe,EAAE,MAAM,MAAM,CAAC;OAE/D,YAAW,SAAS,KAAK;EAE3B;;;;;;;;AASJ,IAAa,YAAY,OAAO,KAAK,QACnC,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCnD,IAAa,cACX,cACA,gBACG;AACH,KAAI,cAAc,CAAE;CAEpB,MAAM,YACJ,4BAA4B,WAAW,cAAc,YAAY,CAAC;AAEpE,KAAI,YACF,gBAAe,IAAI;KAEnB,MAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BT,SAAgB,oBACd,UACA,WACA,QACA;CACA,IAAI,gBAA+B;CAEnC,MAAM,oBAAoB;AACxB,MAAI,iBAAiB,KACnB;AAEF,eAAa,cAAc;AAC3B,kBAAgB;;AAGlB,SAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,MAAM,CAAC;AAE9D,iBAAgB,iBAAiB;AAC/B,UAAQ,oBAAoB,SAAS,YAAY;AACjD,YAAU;IACT,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;AA0Bf,SAAgB,qBACd,UACA,WACA,QACA;CACA,IAAI,QAAuB;CAE3B,MAAM,oBAAoB;AACxB,MAAI,SAAS,KACX;AAEF,gBAAc,MAAM;AACpB,UAAQ;;AAGV,SAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,MAAM,CAAC;AAE9D,SAAQ,YAAY,UAAU,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2D1C,gBAAuB,cACrB,SACA,GAAG,QACH;AACA,MAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAAK;AACvC,QAAM,QAAQ;AAEd,MAAI,IAAI,OAAO,QAAQ;GACrB,MAAM,QAAQ,OAAO;AACrB,UAAO,qBAAqB,MAAM;;;;;;;;;;AAWxC,gBAAgB,qBACd,OACuC;AACvC,KAAI,UAAU,QAAQ,UAAU,KAAA,KAAa,UAAU,MACrD;AAGF,KAAI,iBAAiB,SAAS;AAE5B,SAAO,qBADU,MAAM,MACc;AACrC;;AAGF,KAAI,MAAM,QAAQ,MAAM,EAAE;AACxB,OAAK,MAAM,QAAQ,MACjB,QAAO,qBAAqB,KAAK;AAEnC;;AAGF,KACE,OAAO,UAAU,YACjB,OAAO,MAAM,OAAO,mBAAmB,YACvC;AACA,SAAO;AACP;;AAGF,OAAM,OAAO,MAAM"}

package/data.cjs CHANGED Viewed

@@ -31,6 +31,19 @@ var isShallowEqual = (a, b) => {
 	return true;
 };
 /**
+* Checks whether an object has at least one enumerable key.
+*
+* @example
+* ```ts
+* hasEnumerableKeys({ id: 1 }); // true
+* hasEnumerableKeys({}); // false
+* ```
+*/
+var hasEnumerableKeys = (input) => {
+	for (const _key in input) return true;
+	return false;
+};
+/**
 * Wraps a value in an array when it is not already an array.
 *
 * @example
@@ -92,6 +105,7 @@ var UNSAFE_PROPERTY_KEYS = new Set([
 var isUnsafeProperty = (key) => UNSAFE_PROPERTY_KEYS.has(key);
 //#endregion
 exports.flatMapDeep = flatMapDeep;
+exports.hasEnumerableKeys = hasEnumerableKeys;
 exports.isShallowEqual = isShallowEqual;
 exports.isUnsafeProperty = isUnsafeProperty;
 exports.safeJsonParse = safeJsonParse;

package/data.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"data.cjs","names":[],"sources":["../src/data.ts"],"sourcesContent":["/*\n ---header-docs-section---\n * # yummies/data\n \n ## Description\n \n General-purpose data helpers: shallow equality, normalizing values to arrays, and recursive\n * `flatMap`-style transforms. They complement `Array`/`Object` builtins when you need stable\n * comparisons for memoization or small structural utilities without pulling a large lodash-style\n * dependency into the bundle.\n \n ## Usage\n \n ```ts\n * import { isShallowEqual, toArray } from \"yummies/data\";\n * ```\n /\n\nimport type { AnyObject, Maybe } from 'yummies/types';\n\n/\n Performs a shallow comparison for arrays, plain objects, dates and regular expressions.\n \n @example\n * ```ts\n * isShallowEqual({ id: 1 }, { id: 1 }); // true\n * ```\n /\nexport const isShallowEqual = (a: unknown, b: unknown): boolean => {\n if (a === b) return true;\n\n if (\n typeof a !== 'object' \|\|\n typeof b !== 'object' \|\|\n a === null \|\|\n b === null\n ) {\n return false;\n }\n\n if (a.constructor !== b.constructor) return false;\n\n const isArrayA = Array.isArray(a);\n\n if (isArrayA !== Array.isArray(b)) return false;\n\n if (isArrayA) {\n const arrA = a as unknown[];\n const arrB = b as unknown[];\n if (arrA.length !== arrB.length) return false;\n\n for (const [i, element] of arrA.entries()) {\n if (element !== arrB[i]) return false;\n }\n return true;\n }\n\n if (a instanceof Date) return a.getTime() === (b as Date).getTime();\n\n if (a instanceof RegExp) return a.toString() === (b as RegExp).toString();\n\n const aKeys = Object.keys(a);\n const bKeys = Object.keys(b);\n\n if (aKeys.length !== bKeys.length) return false;\n\n const bObj = b as AnyObject;\n for (const key of aKeys) {\n if (!Object.hasOwn(bObj, key) \|\| (a as AnyObject)[key] !== bObj[key]) {\n return false;\n }\n }\n\n return true;\n};\n\n/\n Wraps a value in an array when it is not already an array.\n \n @example\n * ```ts\n * toArray('item'); // ['item']\n * ```\n /\nexport const toArray = <TValue>(value: TValue \| TValue[]): TValue[] => {\n return Array.isArray(value) ? value : [value];\n};\n\ntype DeepArray<TValue> = TValue \| Array<DeepArray<TValue>>;\n\n/\n Recursively flattens a nested array and maps the collected values.\n \n @example\n * ```ts\n * flatMapDeep([1, [2, [3]]], (value) => value * 2); // [2, 4, 6]\n * ```\n /\nexport const flatMapDeep = <TSource, TNewValue>(\n arr: DeepArray<TSource>,\n fn: (value: TSource, i: number, arr: TSource[]) => TNewValue,\n): TNewValue[] => {\n const source: TSource[] = [];\n\n const collect = (value: DeepArray<TSource>): void => {\n if (!Array.isArray(value)) {\n source.push(value);\n return;\n }\n\n for (const item of value) {\n collect(item);\n }\n };\n\n collect(arr);\n\n return source.map((value, i) => fn(value, i, source));\n};\n\n/\n Parses JSON safely and returns a fallback value when parsing fails.\n \n @example\n * ```ts\n * safeJsonParse('{\"enabled\":true}', {}); // { enabled: true }\n * ```\n /\nexport const safeJsonParse = <TValue = any, TFallback = null>(\n json: Maybe<string>,\n fallback: TFallback = null as TFallback,\n): TValue \| TFallback => {\n if (json == null) return fallback;\n\n try {\n return JSON.parse(json);\n } catch {\n return fallback;\n }\n};\n\nconst UNSAFE_PROPERTY_KEYS = new Set(['__proto__', 'prototype', 'constructor']);\n\n/\n Checks whether a property key is unsafe and can lead to prototype pollution.\n \n @example\n * isUnsafeProperty('__proto__'); // true\n * isUnsafeProperty('name'); // false\n */\nexport const isUnsafeProperty = (key: any) => UNSAFE_PROPERTY_KEYS.has(key);\n"],"mappings":";;;;;;;;;;AA4BA,IAAa,kBAAkB,GAAY,MAAwB;AACjE,KAAI,MAAM,EAAG,QAAO;AAEpB,KACE,OAAO,MAAM,YACb,OAAO,MAAM,YACb,MAAM,QACN,MAAM,KAEN,QAAO;AAGT,KAAI,EAAE,gBAAgB,EAAE,YAAa,QAAO;CAE5C,MAAM,WAAW,MAAM,QAAQ,EAAE;AAEjC,KAAI,aAAa,MAAM,QAAQ,EAAE,CAAE,QAAO;AAE1C,KAAI,UAAU;EACZ,MAAM,OAAO;EACb,MAAM,OAAO;AACb,MAAI,KAAK,WAAW,KAAK,OAAQ,QAAO;AAExC,OAAK,MAAM,CAAC,GAAG,YAAY,KAAK,SAAS,CACvC,KAAI,YAAY,KAAK,GAAI,QAAO;AAElC,SAAO;;AAGT,KAAI,aAAa,KAAM,QAAO,EAAE,SAAS,KAAM,EAAW,SAAS;AAEnE,KAAI,aAAa,OAAQ,QAAO,EAAE,UAAU,KAAM,EAAa,UAAU;CAEzE,MAAM,QAAQ,OAAO,KAAK,EAAE;CAC5B,MAAM,QAAQ,OAAO,KAAK,EAAE;AAE5B,KAAI,MAAM,WAAW,MAAM,OAAQ,QAAO;CAE1C,MAAM,OAAO;AACb,MAAK,MAAM,OAAO,MAChB,KAAI,CAAC,OAAO,OAAO,MAAM,IAAI,IAAK,EAAgB,SAAS,KAAK,KAC9D,QAAO;AAIX,QAAO;;;;;;;;;;AAWT,IAAa,WAAmB,UAAuC;AACrE,QAAO,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM;;;;;;;;;;AAa/C,IAAa,eACX,KACA,OACgB;CAChB,MAAM,SAAoB,EAAE;CAE5B,MAAM,WAAW,UAAoC;AACnD,MAAI,CAAC,MAAM,QAAQ,MAAM,EAAE;AACzB,UAAO,KAAK,MAAM;AAClB;;AAGF,OAAK,MAAM,QAAQ,MACjB,SAAQ,KAAK;;AAIjB,SAAQ,IAAI;AAEZ,QAAO,OAAO,KAAK,OAAO,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;;;;;;;;;;AAWvD,IAAa,iBACX,MACA,WAAsB,SACC;AACvB,KAAI,QAAQ,KAAM,QAAO;AAEzB,KAAI;AACF,SAAO,KAAK,MAAM,KAAK;SACjB;AACN,SAAO;;;AAIX,IAAM,uBAAuB,IAAI,IAAI;CAAC;CAAa;CAAa;CAAc,CAAC;;;;;;;;AAS/E,IAAa,oBAAoB,QAAa,qBAAqB,IAAI,IAAI"}
1	+ {"version":3,"file":"data.cjs","names":[],"sources":["../src/data.ts"],"sourcesContent":["/*\n ---header-docs-section---\n * # yummies/data\n \n ## Description\n \n General-purpose data helpers: shallow equality, normalizing values to arrays, and recursive\n * `flatMap`-style transforms. They complement `Array`/`Object` builtins when you need stable\n * comparisons for memoization or small structural utilities without pulling a large lodash-style\n * dependency into the bundle.\n \n ## Usage\n \n ```ts\n * import { isShallowEqual, toArray } from \"yummies/data\";\n * ```\n /\n\nimport type { AnyObject, Maybe } from 'yummies/types';\n\n/\n Performs a shallow comparison for arrays, plain objects, dates and regular expressions.\n \n @example\n * ```ts\n * isShallowEqual({ id: 1 }, { id: 1 }); // true\n * ```\n /\nexport const isShallowEqual = (a: unknown, b: unknown): boolean => {\n if (a === b) return true;\n\n if (\n typeof a !== 'object' \|\|\n typeof b !== 'object' \|\|\n a === null \|\|\n b === null\n ) {\n return false;\n }\n\n if (a.constructor !== b.constructor) return false;\n\n const isArrayA = Array.isArray(a);\n\n if (isArrayA !== Array.isArray(b)) return false;\n\n if (isArrayA) {\n const arrA = a as unknown[];\n const arrB = b as unknown[];\n if (arrA.length !== arrB.length) return false;\n\n for (const [i, element] of arrA.entries()) {\n if (element !== arrB[i]) return false;\n }\n return true;\n }\n\n if (a instanceof Date) return a.getTime() === (b as Date).getTime();\n\n if (a instanceof RegExp) return a.toString() === (b as RegExp).toString();\n\n const aKeys = Object.keys(a);\n const bKeys = Object.keys(b);\n\n if (aKeys.length !== bKeys.length) return false;\n\n const bObj = b as AnyObject;\n for (const key of aKeys) {\n if (!Object.hasOwn(bObj, key) \|\| (a as AnyObject)[key] !== bObj[key]) {\n return false;\n }\n }\n\n return true;\n};\n\n/\n Checks whether an object has at least one enumerable key.\n \n @example\n * ```ts\n * hasEnumerableKeys({ id: 1 }); // true\n * hasEnumerableKeys({}); // false\n * ```\n /\nexport const hasEnumerableKeys = (input: AnyObject): boolean => {\n for (const _key in input) {\n return true;\n }\n return false;\n};\n\n/\n Wraps a value in an array when it is not already an array.\n \n @example\n * ```ts\n * toArray('item'); // ['item']\n * ```\n /\nexport const toArray = <TValue>(value: TValue \| TValue[]): TValue[] => {\n return Array.isArray(value) ? value : [value];\n};\n\ntype DeepArray<TValue> = TValue \| Array<DeepArray<TValue>>;\n\n/\n Recursively flattens a nested array and maps the collected values.\n \n @example\n * ```ts\n * flatMapDeep([1, [2, [3]]], (value) => value * 2); // [2, 4, 6]\n * ```\n /\nexport const flatMapDeep = <TSource, TNewValue>(\n arr: DeepArray<TSource>,\n fn: (value: TSource, i: number, arr: TSource[]) => TNewValue,\n): TNewValue[] => {\n const source: TSource[] = [];\n\n const collect = (value: DeepArray<TSource>): void => {\n if (!Array.isArray(value)) {\n source.push(value);\n return;\n }\n\n for (const item of value) {\n collect(item);\n }\n };\n\n collect(arr);\n\n return source.map((value, i) => fn(value, i, source));\n};\n\n/\n Parses JSON safely and returns a fallback value when parsing fails.\n \n @example\n * ```ts\n * safeJsonParse('{\"enabled\":true}', {}); // { enabled: true }\n * ```\n /\nexport const safeJsonParse = <TValue = any, TFallback = null>(\n json: Maybe<string>,\n fallback: TFallback = null as TFallback,\n): TValue \| TFallback => {\n if (json == null) return fallback;\n\n try {\n return JSON.parse(json);\n } catch {\n return fallback;\n }\n};\n\nconst UNSAFE_PROPERTY_KEYS = new Set(['__proto__', 'prototype', 'constructor']);\n\n/\n Checks whether a property key is unsafe and can lead to prototype pollution.\n \n @example\n * isUnsafeProperty('__proto__'); // true\n * isUnsafeProperty('name'); // false\n */\nexport const isUnsafeProperty = (key: any) => UNSAFE_PROPERTY_KEYS.has(key);\n"],"mappings":";;;;;;;;;;AA4BA,IAAa,kBAAkB,GAAY,MAAwB;AACjE,KAAI,MAAM,EAAG,QAAO;AAEpB,KACE,OAAO,MAAM,YACb,OAAO,MAAM,YACb,MAAM,QACN,MAAM,KAEN,QAAO;AAGT,KAAI,EAAE,gBAAgB,EAAE,YAAa,QAAO;CAE5C,MAAM,WAAW,MAAM,QAAQ,EAAE;AAEjC,KAAI,aAAa,MAAM,QAAQ,EAAE,CAAE,QAAO;AAE1C,KAAI,UAAU;EACZ,MAAM,OAAO;EACb,MAAM,OAAO;AACb,MAAI,KAAK,WAAW,KAAK,OAAQ,QAAO;AAExC,OAAK,MAAM,CAAC,GAAG,YAAY,KAAK,SAAS,CACvC,KAAI,YAAY,KAAK,GAAI,QAAO;AAElC,SAAO;;AAGT,KAAI,aAAa,KAAM,QAAO,EAAE,SAAS,KAAM,EAAW,SAAS;AAEnE,KAAI,aAAa,OAAQ,QAAO,EAAE,UAAU,KAAM,EAAa,UAAU;CAEzE,MAAM,QAAQ,OAAO,KAAK,EAAE;CAC5B,MAAM,QAAQ,OAAO,KAAK,EAAE;AAE5B,KAAI,MAAM,WAAW,MAAM,OAAQ,QAAO;CAE1C,MAAM,OAAO;AACb,MAAK,MAAM,OAAO,MAChB,KAAI,CAAC,OAAO,OAAO,MAAM,IAAI,IAAK,EAAgB,SAAS,KAAK,KAC9D,QAAO;AAIX,QAAO;;;;;;;;;;;AAYT,IAAa,qBAAqB,UAA8B;AAC9D,MAAK,MAAM,QAAQ,MACjB,QAAO;AAET,QAAO;;;;;;;;;;AAWT,IAAa,WAAmB,UAAuC;AACrE,QAAO,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM;;;;;;;;;;AAa/C,IAAa,eACX,KACA,OACgB;CAChB,MAAM,SAAoB,EAAE;CAE5B,MAAM,WAAW,UAAoC;AACnD,MAAI,CAAC,MAAM,QAAQ,MAAM,EAAE;AACzB,UAAO,KAAK,MAAM;AAClB;;AAGF,OAAK,MAAM,QAAQ,MACjB,SAAQ,KAAK;;AAIjB,SAAQ,IAAI;AAEZ,QAAO,OAAO,KAAK,OAAO,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;;;;;;;;;;AAWvD,IAAa,iBACX,MACA,WAAsB,SACC;AACvB,KAAI,QAAQ,KAAM,QAAO;AAEzB,KAAI;AACF,SAAO,KAAK,MAAM,KAAK;SACjB;AACN,SAAO;;;AAIX,IAAM,uBAAuB,IAAI,IAAI;CAAC;CAAa;CAAa;CAAc,CAAC;;;;;;;;AAS/E,IAAa,oBAAoB,QAAa,qBAAqB,IAAI,IAAI"}

package/data.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { Maybe } from 'yummies/types';
+import { AnyObject, Maybe } from 'yummies/types';
 /**
  * ---header-docs-section---
@@ -27,6 +27,16 @@ import { Maybe } from 'yummies/types';
  * ```
  */
 declare const isShallowEqual: (a: unknown, b: unknown) => boolean;
+/**
+ * Checks whether an object has at least one enumerable key.
+ *
+ * @example
+ * ```ts
+ * hasEnumerableKeys({ id: 1 }); // true
+ * hasEnumerableKeys({}); // false
+ * ```
+ */
+declare const hasEnumerableKeys: (input: AnyObject) => boolean;
 /**
  * Wraps a value in an array when it is not already an array.
  *
@@ -64,4 +74,4 @@ declare const safeJsonParse: <TValue = any, TFallback = null>(json: Maybe<string
  */
 declare const isUnsafeProperty: (key: any) => boolean;
-export { flatMapDeep, isShallowEqual, isUnsafeProperty, safeJsonParse, toArray };
+export { flatMapDeep, hasEnumerableKeys, isShallowEqual, isUnsafeProperty, safeJsonParse, toArray };

package/data.js CHANGED Viewed

@@ -30,6 +30,19 @@ var isShallowEqual = (a, b) => {
 	return true;
 };
 /**
+* Checks whether an object has at least one enumerable key.
+*
+* @example
+* ```ts
+* hasEnumerableKeys({ id: 1 }); // true
+* hasEnumerableKeys({}); // false
+* ```
+*/
+var hasEnumerableKeys = (input) => {
+	for (const _key in input) return true;
+	return false;
+};
+/**
 * Wraps a value in an array when it is not already an array.
 *
 * @example
@@ -90,6 +103,6 @@ var UNSAFE_PROPERTY_KEYS = new Set([
 */
 var isUnsafeProperty = (key) => UNSAFE_PROPERTY_KEYS.has(key);
 //#endregion
-export { flatMapDeep, isShallowEqual, isUnsafeProperty, safeJsonParse, toArray };
+export { flatMapDeep, hasEnumerableKeys, isShallowEqual, isUnsafeProperty, safeJsonParse, toArray };
 //# sourceMappingURL=data.js.map

package/data.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"data.js","names":[],"sources":["../src/data.ts"],"sourcesContent":["/*\n ---header-docs-section---\n * # yummies/data\n \n ## Description\n \n General-purpose data helpers: shallow equality, normalizing values to arrays, and recursive\n * `flatMap`-style transforms. They complement `Array`/`Object` builtins when you need stable\n * comparisons for memoization or small structural utilities without pulling a large lodash-style\n * dependency into the bundle.\n \n ## Usage\n \n ```ts\n * import { isShallowEqual, toArray } from \"yummies/data\";\n * ```\n /\n\nimport type { AnyObject, Maybe } from 'yummies/types';\n\n/\n Performs a shallow comparison for arrays, plain objects, dates and regular expressions.\n \n @example\n * ```ts\n * isShallowEqual({ id: 1 }, { id: 1 }); // true\n * ```\n /\nexport const isShallowEqual = (a: unknown, b: unknown): boolean => {\n if (a === b) return true;\n\n if (\n typeof a !== 'object' \|\|\n typeof b !== 'object' \|\|\n a === null \|\|\n b === null\n ) {\n return false;\n }\n\n if (a.constructor !== b.constructor) return false;\n\n const isArrayA = Array.isArray(a);\n\n if (isArrayA !== Array.isArray(b)) return false;\n\n if (isArrayA) {\n const arrA = a as unknown[];\n const arrB = b as unknown[];\n if (arrA.length !== arrB.length) return false;\n\n for (const [i, element] of arrA.entries()) {\n if (element !== arrB[i]) return false;\n }\n return true;\n }\n\n if (a instanceof Date) return a.getTime() === (b as Date).getTime();\n\n if (a instanceof RegExp) return a.toString() === (b as RegExp).toString();\n\n const aKeys = Object.keys(a);\n const bKeys = Object.keys(b);\n\n if (aKeys.length !== bKeys.length) return false;\n\n const bObj = b as AnyObject;\n for (const key of aKeys) {\n if (!Object.hasOwn(bObj, key) \|\| (a as AnyObject)[key] !== bObj[key]) {\n return false;\n }\n }\n\n return true;\n};\n\n/\n Wraps a value in an array when it is not already an array.\n \n @example\n * ```ts\n * toArray('item'); // ['item']\n * ```\n /\nexport const toArray = <TValue>(value: TValue \| TValue[]): TValue[] => {\n return Array.isArray(value) ? value : [value];\n};\n\ntype DeepArray<TValue> = TValue \| Array<DeepArray<TValue>>;\n\n/\n Recursively flattens a nested array and maps the collected values.\n \n @example\n * ```ts\n * flatMapDeep([1, [2, [3]]], (value) => value * 2); // [2, 4, 6]\n * ```\n /\nexport const flatMapDeep = <TSource, TNewValue>(\n arr: DeepArray<TSource>,\n fn: (value: TSource, i: number, arr: TSource[]) => TNewValue,\n): TNewValue[] => {\n const source: TSource[] = [];\n\n const collect = (value: DeepArray<TSource>): void => {\n if (!Array.isArray(value)) {\n source.push(value);\n return;\n }\n\n for (const item of value) {\n collect(item);\n }\n };\n\n collect(arr);\n\n return source.map((value, i) => fn(value, i, source));\n};\n\n/\n Parses JSON safely and returns a fallback value when parsing fails.\n \n @example\n * ```ts\n * safeJsonParse('{\"enabled\":true}', {}); // { enabled: true }\n * ```\n /\nexport const safeJsonParse = <TValue = any, TFallback = null>(\n json: Maybe<string>,\n fallback: TFallback = null as TFallback,\n): TValue \| TFallback => {\n if (json == null) return fallback;\n\n try {\n return JSON.parse(json);\n } catch {\n return fallback;\n }\n};\n\nconst UNSAFE_PROPERTY_KEYS = new Set(['__proto__', 'prototype', 'constructor']);\n\n/\n Checks whether a property key is unsafe and can lead to prototype pollution.\n \n @example\n * isUnsafeProperty('__proto__'); // true\n * isUnsafeProperty('name'); // false\n */\nexport const isUnsafeProperty = (key: any) => UNSAFE_PROPERTY_KEYS.has(key);\n"],"mappings":";;;;;;;;;AA4BA,IAAa,kBAAkB,GAAY,MAAwB;AACjE,KAAI,MAAM,EAAG,QAAO;AAEpB,KACE,OAAO,MAAM,YACb,OAAO,MAAM,YACb,MAAM,QACN,MAAM,KAEN,QAAO;AAGT,KAAI,EAAE,gBAAgB,EAAE,YAAa,QAAO;CAE5C,MAAM,WAAW,MAAM,QAAQ,EAAE;AAEjC,KAAI,aAAa,MAAM,QAAQ,EAAE,CAAE,QAAO;AAE1C,KAAI,UAAU;EACZ,MAAM,OAAO;EACb,MAAM,OAAO;AACb,MAAI,KAAK,WAAW,KAAK,OAAQ,QAAO;AAExC,OAAK,MAAM,CAAC,GAAG,YAAY,KAAK,SAAS,CACvC,KAAI,YAAY,KAAK,GAAI,QAAO;AAElC,SAAO;;AAGT,KAAI,aAAa,KAAM,QAAO,EAAE,SAAS,KAAM,EAAW,SAAS;AAEnE,KAAI,aAAa,OAAQ,QAAO,EAAE,UAAU,KAAM,EAAa,UAAU;CAEzE,MAAM,QAAQ,OAAO,KAAK,EAAE;CAC5B,MAAM,QAAQ,OAAO,KAAK,EAAE;AAE5B,KAAI,MAAM,WAAW,MAAM,OAAQ,QAAO;CAE1C,MAAM,OAAO;AACb,MAAK,MAAM,OAAO,MAChB,KAAI,CAAC,OAAO,OAAO,MAAM,IAAI,IAAK,EAAgB,SAAS,KAAK,KAC9D,QAAO;AAIX,QAAO;;;;;;;;;;AAWT,IAAa,WAAmB,UAAuC;AACrE,QAAO,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM;;;;;;;;;;AAa/C,IAAa,eACX,KACA,OACgB;CAChB,MAAM,SAAoB,EAAE;CAE5B,MAAM,WAAW,UAAoC;AACnD,MAAI,CAAC,MAAM,QAAQ,MAAM,EAAE;AACzB,UAAO,KAAK,MAAM;AAClB;;AAGF,OAAK,MAAM,QAAQ,MACjB,SAAQ,KAAK;;AAIjB,SAAQ,IAAI;AAEZ,QAAO,OAAO,KAAK,OAAO,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;;;;;;;;;;AAWvD,IAAa,iBACX,MACA,WAAsB,SACC;AACvB,KAAI,QAAQ,KAAM,QAAO;AAEzB,KAAI;AACF,SAAO,KAAK,MAAM,KAAK;SACjB;AACN,SAAO;;;AAIX,IAAM,uBAAuB,IAAI,IAAI;CAAC;CAAa;CAAa;CAAc,CAAC;;;;;;;;AAS/E,IAAa,oBAAoB,QAAa,qBAAqB,IAAI,IAAI"}
1	+ {"version":3,"file":"data.js","names":[],"sources":["../src/data.ts"],"sourcesContent":["/*\n ---header-docs-section---\n * # yummies/data\n \n ## Description\n \n General-purpose data helpers: shallow equality, normalizing values to arrays, and recursive\n * `flatMap`-style transforms. They complement `Array`/`Object` builtins when you need stable\n * comparisons for memoization or small structural utilities without pulling a large lodash-style\n * dependency into the bundle.\n \n ## Usage\n \n ```ts\n * import { isShallowEqual, toArray } from \"yummies/data\";\n * ```\n /\n\nimport type { AnyObject, Maybe } from 'yummies/types';\n\n/\n Performs a shallow comparison for arrays, plain objects, dates and regular expressions.\n \n @example\n * ```ts\n * isShallowEqual({ id: 1 }, { id: 1 }); // true\n * ```\n /\nexport const isShallowEqual = (a: unknown, b: unknown): boolean => {\n if (a === b) return true;\n\n if (\n typeof a !== 'object' \|\|\n typeof b !== 'object' \|\|\n a === null \|\|\n b === null\n ) {\n return false;\n }\n\n if (a.constructor !== b.constructor) return false;\n\n const isArrayA = Array.isArray(a);\n\n if (isArrayA !== Array.isArray(b)) return false;\n\n if (isArrayA) {\n const arrA = a as unknown[];\n const arrB = b as unknown[];\n if (arrA.length !== arrB.length) return false;\n\n for (const [i, element] of arrA.entries()) {\n if (element !== arrB[i]) return false;\n }\n return true;\n }\n\n if (a instanceof Date) return a.getTime() === (b as Date).getTime();\n\n if (a instanceof RegExp) return a.toString() === (b as RegExp).toString();\n\n const aKeys = Object.keys(a);\n const bKeys = Object.keys(b);\n\n if (aKeys.length !== bKeys.length) return false;\n\n const bObj = b as AnyObject;\n for (const key of aKeys) {\n if (!Object.hasOwn(bObj, key) \|\| (a as AnyObject)[key] !== bObj[key]) {\n return false;\n }\n }\n\n return true;\n};\n\n/\n Checks whether an object has at least one enumerable key.\n \n @example\n * ```ts\n * hasEnumerableKeys({ id: 1 }); // true\n * hasEnumerableKeys({}); // false\n * ```\n /\nexport const hasEnumerableKeys = (input: AnyObject): boolean => {\n for (const _key in input) {\n return true;\n }\n return false;\n};\n\n/\n Wraps a value in an array when it is not already an array.\n \n @example\n * ```ts\n * toArray('item'); // ['item']\n * ```\n /\nexport const toArray = <TValue>(value: TValue \| TValue[]): TValue[] => {\n return Array.isArray(value) ? value : [value];\n};\n\ntype DeepArray<TValue> = TValue \| Array<DeepArray<TValue>>;\n\n/\n Recursively flattens a nested array and maps the collected values.\n \n @example\n * ```ts\n * flatMapDeep([1, [2, [3]]], (value) => value * 2); // [2, 4, 6]\n * ```\n /\nexport const flatMapDeep = <TSource, TNewValue>(\n arr: DeepArray<TSource>,\n fn: (value: TSource, i: number, arr: TSource[]) => TNewValue,\n): TNewValue[] => {\n const source: TSource[] = [];\n\n const collect = (value: DeepArray<TSource>): void => {\n if (!Array.isArray(value)) {\n source.push(value);\n return;\n }\n\n for (const item of value) {\n collect(item);\n }\n };\n\n collect(arr);\n\n return source.map((value, i) => fn(value, i, source));\n};\n\n/\n Parses JSON safely and returns a fallback value when parsing fails.\n \n @example\n * ```ts\n * safeJsonParse('{\"enabled\":true}', {}); // { enabled: true }\n * ```\n /\nexport const safeJsonParse = <TValue = any, TFallback = null>(\n json: Maybe<string>,\n fallback: TFallback = null as TFallback,\n): TValue \| TFallback => {\n if (json == null) return fallback;\n\n try {\n return JSON.parse(json);\n } catch {\n return fallback;\n }\n};\n\nconst UNSAFE_PROPERTY_KEYS = new Set(['__proto__', 'prototype', 'constructor']);\n\n/\n Checks whether a property key is unsafe and can lead to prototype pollution.\n \n @example\n * isUnsafeProperty('__proto__'); // true\n * isUnsafeProperty('name'); // false\n */\nexport const isUnsafeProperty = (key: any) => UNSAFE_PROPERTY_KEYS.has(key);\n"],"mappings":";;;;;;;;;AA4BA,IAAa,kBAAkB,GAAY,MAAwB;AACjE,KAAI,MAAM,EAAG,QAAO;AAEpB,KACE,OAAO,MAAM,YACb,OAAO,MAAM,YACb,MAAM,QACN,MAAM,KAEN,QAAO;AAGT,KAAI,EAAE,gBAAgB,EAAE,YAAa,QAAO;CAE5C,MAAM,WAAW,MAAM,QAAQ,EAAE;AAEjC,KAAI,aAAa,MAAM,QAAQ,EAAE,CAAE,QAAO;AAE1C,KAAI,UAAU;EACZ,MAAM,OAAO;EACb,MAAM,OAAO;AACb,MAAI,KAAK,WAAW,KAAK,OAAQ,QAAO;AAExC,OAAK,MAAM,CAAC,GAAG,YAAY,KAAK,SAAS,CACvC,KAAI,YAAY,KAAK,GAAI,QAAO;AAElC,SAAO;;AAGT,KAAI,aAAa,KAAM,QAAO,EAAE,SAAS,KAAM,EAAW,SAAS;AAEnE,KAAI,aAAa,OAAQ,QAAO,EAAE,UAAU,KAAM,EAAa,UAAU;CAEzE,MAAM,QAAQ,OAAO,KAAK,EAAE;CAC5B,MAAM,QAAQ,OAAO,KAAK,EAAE;AAE5B,KAAI,MAAM,WAAW,MAAM,OAAQ,QAAO;CAE1C,MAAM,OAAO;AACb,MAAK,MAAM,OAAO,MAChB,KAAI,CAAC,OAAO,OAAO,MAAM,IAAI,IAAK,EAAgB,SAAS,KAAK,KAC9D,QAAO;AAIX,QAAO;;;;;;;;;;;AAYT,IAAa,qBAAqB,UAA8B;AAC9D,MAAK,MAAM,QAAQ,MACjB,QAAO;AAET,QAAO;;;;;;;;;;AAWT,IAAa,WAAmB,UAAuC;AACrE,QAAO,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM;;;;;;;;;;AAa/C,IAAa,eACX,KACA,OACgB;CAChB,MAAM,SAAoB,EAAE;CAE5B,MAAM,WAAW,UAAoC;AACnD,MAAI,CAAC,MAAM,QAAQ,MAAM,EAAE;AACzB,UAAO,KAAK,MAAM;AAClB;;AAGF,OAAK,MAAM,QAAQ,MACjB,SAAQ,KAAK;;AAIjB,SAAQ,IAAI;AAEZ,QAAO,OAAO,KAAK,OAAO,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;;;;;;;;;;AAWvD,IAAa,iBACX,MACA,WAAsB,SACC;AACvB,KAAI,QAAQ,KAAM,QAAO;AAEzB,KAAI;AACF,SAAO,KAAK,MAAM,KAAK;SACjB;AACN,SAAO;;;AAIX,IAAM,uBAAuB,IAAI,IAAI;CAAC;CAAa;CAAa;CAAc,CAAC;;;;;;;;AAS/E,IAAa,oBAAoB,QAAa,qBAAqB,IAAI,IAAI"}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "yummies",
-  "version": "7.17.0",
+  "version": "7.19.0",
   "keywords": [
     "javascript",
     "typescript",