yummies 7.12.0 → 7.14.0

package/async.js.map

@@ -1 +1 @@
-{"version":3,"file":"async.js","names":[],"sources":["../src/async.ts"],"sourcesContent":["/**\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,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"}
+{"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"}

package/common.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"common.cjs","names":[],"sources":["../src/common.ts"],"sourcesContent":["import type { MaybeFn } from 'yummies/types';\n\n/**\n * @deprecated use {MaybeFn} type\n */\nexport type FnValue<TValue, TArgs extends any[] = []> = MaybeFn<TValue, TArgs>;\n\n/**\n * Normalizes a {@link MaybeFn} — a value that may be either a plain `TValue` or a function\n * `(...args: TArgs) => TValue`. If `fn` is callable, it is invoked with `args` and the return\n * value is returned; otherwise `fn` is returned as-is (treated as the resolved value).\n *\n * Typical uses: config fields that accept a static value or a lazy/computed factory, theme\n * tokens, labels, or callbacks where the caller should not branch on `typeof fn` themselves.\n *\n * @template TValue - Result type when `fn` is not a function, or return type when it is.\n * @template TArgs - Tuple of argument types passed through when `fn` is invoked.\n *\n * @param fn - Either a `TValue` or a function producing `TValue` from `args`.\n * @param args - Arguments forwarded to `fn` only when `fn` is a function.\n * @returns The resolved `TValue`.\n *\n * @example\n * Plain value — returned unchanged (no call):\n * ```ts\n * const n = callFunction(42); // 42\n * const label = callFunction('Hello'); // 'Hello'\n * ```\n *\n * @example\n * Function — called with the given arguments:\n * ```ts\n * const sum = callFunction((a: number, b: number) => a + b, 2, 3); // 5\n * ```\n *\n * @example\n * Same API for “static or factory” props:\n * ```ts\n * type Title = MaybeFn<string, [locale: string]>;\n * const title: Title = (loc) => (loc === 'ru' ? 'Привет' : 'Hi');\n * const text = callFunction(title, 'ru'); // 'Привет'\n * const fixed = callFunction('Hi', 'ru'); // 'Hi' — args ignored\n * ```\n */\nexport const callFunction = <TValue, TArgs extends any[] = []>(\n  fn: MaybeFn<TValue, TArgs>,\n  ...args: TArgs\n) => {\n  if (typeof fn === 'function') {\n    return (fn as any)(...args) as TValue;\n  }\n\n  return fn;\n};\n\n/**\n * @deprecated use {callFunction}\n */\nexport const resolveFnValue = callFunction;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,IAAa,gBACX,IACA,GAAG,SACA;AACH,KAAI,OAAO,OAAO,WAChB,QAAQ,GAAW,GAAG,KAAK;AAG7B,QAAO;;;;;AAMT,IAAa,iBAAiB"}
+{"version":3,"file":"common.cjs","names":[],"sources":["../src/common.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/common\n *\n * ## Description\n *\n * Small helpers for values that may be either plain data or callables (`MaybeFn` pattern). Use them\n * when a prop or config can be a static value or a factory, without forcing callers to branch on\n * `typeof` everywhere. The module also keeps a thin compatibility layer for older `FnValue` naming.\n * Everything is typed to preserve argument tuples and return types through `callFunction`.\n *\n * ## Usage\n *\n * ```ts\n * import { callFunction } from \"yummies/common\";\n * ```\n */\n\nimport type { MaybeFn } from 'yummies/types';\n\n/**\n * @deprecated use {MaybeFn} type\n */\nexport type FnValue<TValue, TArgs extends any[] = []> = MaybeFn<TValue, TArgs>;\n\n/**\n * Normalizes a {@link MaybeFn} — a value that may be either a plain `TValue` or a function\n * `(...args: TArgs) => TValue`. If `fn` is callable, it is invoked with `args` and the return\n * value is returned; otherwise `fn` is returned as-is (treated as the resolved value).\n *\n * Typical uses: config fields that accept a static value or a lazy/computed factory, theme\n * tokens, labels, or callbacks where the caller should not branch on `typeof fn` themselves.\n *\n * @template TValue - Result type when `fn` is not a function, or return type when it is.\n * @template TArgs - Tuple of argument types passed through when `fn` is invoked.\n *\n * @param fn - Either a `TValue` or a function producing `TValue` from `args`.\n * @param args - Arguments forwarded to `fn` only when `fn` is a function.\n * @returns The resolved `TValue`.\n *\n * @example\n * Plain value — returned unchanged (no call):\n * ```ts\n * const n = callFunction(42); // 42\n * const label = callFunction('Hello'); // 'Hello'\n * ```\n *\n * @example\n * Function — called with the given arguments:\n * ```ts\n * const sum = callFunction((a: number, b: number) => a + b, 2, 3); // 5\n * ```\n *\n * @example\n * Same API for “static or factory” props:\n * ```ts\n * type Title = MaybeFn<string, [locale: string]>;\n * const title: Title = (loc) => (loc === 'ru' ? 'Привет' : 'Hi');\n * const text = callFunction(title, 'ru'); // 'Привет'\n * const fixed = callFunction('Hi', 'ru'); // 'Hi' — args ignored\n * ```\n */\nexport const callFunction = <TValue, TArgs extends any[] = []>(\n  fn: MaybeFn<TValue, TArgs>,\n  ...args: TArgs\n) => {\n  if (typeof fn === 'function') {\n    return (fn as any)(...args) as TValue;\n  }\n\n  return fn;\n};\n\n/**\n * @deprecated use {callFunction}\n */\nexport const resolveFnValue = callFunction;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,IAAa,gBACX,IACA,GAAG,SACA;AACH,KAAI,OAAO,OAAO,WAChB,QAAQ,GAAW,GAAG,KAAK;AAG7B,QAAO;;;;;AAMT,IAAa,iBAAiB"}

package/common.d.ts

@@ -1,5 +1,23 @@
 import { MaybeFn } from 'yummies/types';
 
+/**
+ * ---header-docs-section---
+ * # yummies/common
+ *
+ * ## Description
+ *
+ * Small helpers for values that may be either plain data or callables (`MaybeFn` pattern). Use them
+ * when a prop or config can be a static value or a factory, without forcing callers to branch on
+ * `typeof` everywhere. The module also keeps a thin compatibility layer for older `FnValue` naming.
+ * Everything is typed to preserve argument tuples and return types through `callFunction`.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { callFunction } from "yummies/common";
+ * ```
+ */
+
 /**
  * @deprecated use {MaybeFn} type
  */

package/common.js.map

@@ -1 +1 @@
-{"version":3,"file":"common.js","names":[],"sources":["../src/common.ts"],"sourcesContent":["import type { MaybeFn } from 'yummies/types';\n\n/**\n * @deprecated use {MaybeFn} type\n */\nexport type FnValue<TValue, TArgs extends any[] = []> = MaybeFn<TValue, TArgs>;\n\n/**\n * Normalizes a {@link MaybeFn} — a value that may be either a plain `TValue` or a function\n * `(...args: TArgs) => TValue`. If `fn` is callable, it is invoked with `args` and the return\n * value is returned; otherwise `fn` is returned as-is (treated as the resolved value).\n *\n * Typical uses: config fields that accept a static value or a lazy/computed factory, theme\n * tokens, labels, or callbacks where the caller should not branch on `typeof fn` themselves.\n *\n * @template TValue - Result type when `fn` is not a function, or return type when it is.\n * @template TArgs - Tuple of argument types passed through when `fn` is invoked.\n *\n * @param fn - Either a `TValue` or a function producing `TValue` from `args`.\n * @param args - Arguments forwarded to `fn` only when `fn` is a function.\n * @returns The resolved `TValue`.\n *\n * @example\n * Plain value — returned unchanged (no call):\n * ```ts\n * const n = callFunction(42); // 42\n * const label = callFunction('Hello'); // 'Hello'\n * ```\n *\n * @example\n * Function — called with the given arguments:\n * ```ts\n * const sum = callFunction((a: number, b: number) => a + b, 2, 3); // 5\n * ```\n *\n * @example\n * Same API for “static or factory” props:\n * ```ts\n * type Title = MaybeFn<string, [locale: string]>;\n * const title: Title = (loc) => (loc === 'ru' ? 'Привет' : 'Hi');\n * const text = callFunction(title, 'ru'); // 'Привет'\n * const fixed = callFunction('Hi', 'ru'); // 'Hi' — args ignored\n * ```\n */\nexport const callFunction = <TValue, TArgs extends any[] = []>(\n  fn: MaybeFn<TValue, TArgs>,\n  ...args: TArgs\n) => {\n  if (typeof fn === 'function') {\n    return (fn as any)(...args) as TValue;\n  }\n\n  return fn;\n};\n\n/**\n * @deprecated use {callFunction}\n */\nexport const resolveFnValue = callFunction;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,IAAa,gBACX,IACA,GAAG,SACA;AACH,KAAI,OAAO,OAAO,WAChB,QAAQ,GAAW,GAAG,KAAK;AAG7B,QAAO;;;;;AAMT,IAAa,iBAAiB"}
+{"version":3,"file":"common.js","names":[],"sources":["../src/common.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/common\n *\n * ## Description\n *\n * Small helpers for values that may be either plain data or callables (`MaybeFn` pattern). Use them\n * when a prop or config can be a static value or a factory, without forcing callers to branch on\n * `typeof` everywhere. The module also keeps a thin compatibility layer for older `FnValue` naming.\n * Everything is typed to preserve argument tuples and return types through `callFunction`.\n *\n * ## Usage\n *\n * ```ts\n * import { callFunction } from \"yummies/common\";\n * ```\n */\n\nimport type { MaybeFn } from 'yummies/types';\n\n/**\n * @deprecated use {MaybeFn} type\n */\nexport type FnValue<TValue, TArgs extends any[] = []> = MaybeFn<TValue, TArgs>;\n\n/**\n * Normalizes a {@link MaybeFn} — a value that may be either a plain `TValue` or a function\n * `(...args: TArgs) => TValue`. If `fn` is callable, it is invoked with `args` and the return\n * value is returned; otherwise `fn` is returned as-is (treated as the resolved value).\n *\n * Typical uses: config fields that accept a static value or a lazy/computed factory, theme\n * tokens, labels, or callbacks where the caller should not branch on `typeof fn` themselves.\n *\n * @template TValue - Result type when `fn` is not a function, or return type when it is.\n * @template TArgs - Tuple of argument types passed through when `fn` is invoked.\n *\n * @param fn - Either a `TValue` or a function producing `TValue` from `args`.\n * @param args - Arguments forwarded to `fn` only when `fn` is a function.\n * @returns The resolved `TValue`.\n *\n * @example\n * Plain value — returned unchanged (no call):\n * ```ts\n * const n = callFunction(42); // 42\n * const label = callFunction('Hello'); // 'Hello'\n * ```\n *\n * @example\n * Function — called with the given arguments:\n * ```ts\n * const sum = callFunction((a: number, b: number) => a + b, 2, 3); // 5\n * ```\n *\n * @example\n * Same API for “static or factory” props:\n * ```ts\n * type Title = MaybeFn<string, [locale: string]>;\n * const title: Title = (loc) => (loc === 'ru' ? 'Привет' : 'Hi');\n * const text = callFunction(title, 'ru'); // 'Привет'\n * const fixed = callFunction('Hi', 'ru'); // 'Hi' — args ignored\n * ```\n */\nexport const callFunction = <TValue, TArgs extends any[] = []>(\n  fn: MaybeFn<TValue, TArgs>,\n  ...args: TArgs\n) => {\n  if (typeof fn === 'function') {\n    return (fn as any)(...args) as TValue;\n  }\n\n  return fn;\n};\n\n/**\n * @deprecated use {callFunction}\n */\nexport const resolveFnValue = callFunction;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,IAAa,gBACX,IACA,GAAG,SACA;AACH,KAAI,OAAO,OAAO,WAChB,QAAQ,GAAW,GAAG,KAAK;AAG7B,QAAO;;;;;AAMT,IAAa,iBAAiB"}

package/complex.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"complex.cjs","names":[],"sources":["../src/complex/counter.ts","../src/complex/global-point.ts","../src/complex/global-config.ts","../src/complex/modules-factory.ts","../src/complex/pub-sub.ts"],"sourcesContent":["export interface Counter<TValue = number> {\n  (): TValue;\n  counter: number;\n  value: TValue;\n  increment(): TValue;\n  decrement(): TValue;\n  reset(): void;\n}\n\n/**\n * @deprecated use {`Counter`}. Will be removed in next major release\n */\nexport interface CounterFn<TValue = number> extends Counter<TValue> {}\n\n/**\n * Creates a callable counter object with increment, decrement and reset helpers.\n *\n * The returned function increments the internal numeric counter when called and\n * exposes both the raw counter value and an optionally transformed `value`.\n *\n * @template TValue Public value type returned by the counter.\n * @param processValue Optional mapper that transforms the numeric counter value.\n * @param initial Initial numeric counter value.\n * @returns Callable counter with state and control methods.\n *\n * @example\n * ```ts\n * const counter = createCounter();\n * counter.increment(); // 1\n * ```\n *\n * @example\n * ```ts\n * const idCounter = createCounter((value) => `id-${value}`, 10);\n * idCounter(); // 'id-11'\n * ```\n */\nexport const createCounter = <TValue = number>(\n  processValue?: (value: number) => TValue,\n  initial: number = 0,\n): Counter<TValue> => {\n  const update = (counter: number) => {\n    fn.value = processValue?.(counter) ?? (counter as TValue);\n    return fn.value;\n  };\n\n  const increment = () => update(++fn.counter);\n  const decrement = () => update(--fn.counter);\n\n  const fn: Counter<TValue> = increment as any;\n\n  fn.increment = increment;\n  fn.decrement = decrement;\n\n  fn.reset = () => {\n    fn.counter = initial;\n    fn.value = processValue?.(initial) ?? (initial as TValue);\n  };\n\n  fn.reset();\n\n  return fn as Counter<TValue>;\n};\n","import type { AnyObject } from 'yummies/types';\n\nexport interface GlobalPoint<TValue> {\n  get(): TValue;\n  set(value: TValue): TValue;\n  unset(): void;\n}\n\n/**\n * Creates a simple storage point that can live either in `globalThis` under a\n * provided key or in a local closure when no key is given.\n *\n * @template TValue Stored value type.\n * @param accessSymbol Optional global property name used for storage.\n * @returns Getter/setter API for the stored value.\n *\n * @example\n * ```ts\n * const point = createGlobalPoint<number>();\n * point.set(10);\n * ```\n *\n * @example\n * ```ts\n * const point = createGlobalPoint<string>('__token__');\n * point.get();\n * ```\n */\nexport const createGlobalPoint = <TValue>(\n  accessSymbol?: keyof any,\n): GlobalPoint<TValue> => {\n  if (accessSymbol == null) {\n    let storedValue: TValue | undefined;\n\n    return {\n      get: (): TValue => storedValue!,\n      unset: () => {\n        storedValue = undefined;\n      },\n      set: (value: TValue): TValue => {\n        storedValue = value;\n        return value;\n      },\n    };\n  }\n\n  const _globalThis = globalThis as AnyObject;\n\n  return {\n    get: (): TValue => _globalThis[accessSymbol],\n    unset: () => {\n      delete _globalThis[accessSymbol];\n    },\n    set: (value: TValue): TValue => {\n      _globalThis[accessSymbol] = value;\n      return value;\n    },\n  };\n};\n","import type { AnyObject, Maybe } from 'yummies/types';\nimport { createGlobalPoint } from './global-point.js';\n\n/**\n * Creates or reuses a globally accessible config object.\n *\n * The config is stored in a global point identified by `accessSymbol`, or in a\n * local closure when no symbol is provided.\n *\n * @template T Config object type.\n * @param defaultValue Default value used when no config has been created yet.\n * @param accessSymbol Optional global key used to store the config.\n * @returns Existing or newly initialized global config object.\n *\n * @example\n * ```ts\n * const config = createGlobalConfig({ locale: 'en' }, '__app_config__');\n * ```\n *\n * @example\n * ```ts\n * const config = createGlobalConfig({ debug: false });\n * config.debug;\n * ```\n */\nexport const createGlobalConfig = <T extends AnyObject>(\n  defaultValue: T,\n  accessSymbol?: keyof any,\n): T => {\n  const globalPoint = createGlobalPoint<T>(accessSymbol);\n  return globalPoint.get() || globalPoint.set(defaultValue);\n};\n\nexport interface GlobalDynamicConfig<TValue extends AnyObject> {\n  get(): TValue;\n  set(value: TValue): TValue;\n  unset(): void;\n  update(value: Partial<TValue>): void;\n}\n\n/**\n * Creates a mutable global config manager whose value is produced and updated\n * through a custom processor function.\n *\n * @template T Config object type.\n * @param processFn Function that builds the next config state from a partial change and current value.\n * @param accessSymbol Optional global key used to store the config.\n * @returns API for reading, replacing, resetting and partially updating the config.\n *\n * @example\n * ```ts\n * const config = createGlobalDynamicConfig(\n *   (change, current) => ({ theme: 'light', ...current, ...change }),\n *   '__theme__',\n * );\n * ```\n *\n * @example\n * ```ts\n * const config = createGlobalDynamicConfig((change, current) => ({ ...current, ...change }));\n * config.update({ locale: 'ru' });\n * ```\n */\nexport const createGlobalDynamicConfig = <T extends AnyObject>(\n  processFn: (change: Maybe<Partial<T>>, current: Maybe<T>) => T,\n  accessSymbol?: keyof any,\n): GlobalDynamicConfig<T> => {\n  const globalPoint = createGlobalPoint<T>(accessSymbol);\n\n  const getValue = () => {\n    return globalPoint.get() ?? globalPoint.set(processFn(null, null))!;\n  };\n\n  return {\n    get: getValue,\n    set: globalPoint.set,\n    unset: globalPoint.unset,\n    update: (value: Partial<T>) => {\n      const currentValue = getValue();\n      Object.assign(currentValue, processFn(value, currentValue));\n    },\n  };\n};\n","import type { AnyObject, Class, EmptyObject, IsPartial } from 'yummies/types';\n\ntype ModuleLoaderConfig<TPredefinedDeps extends AnyObject = EmptyObject> = {\n  factory<TInstance, TDeps extends TPredefinedDeps>(\n    moduleClass: Class<TInstance, [TDeps]>,\n    deps: TDeps,\n  ): TInstance;\n} & (TPredefinedDeps extends EmptyObject\n  ? { deps?: TPredefinedDeps }\n  : { deps: TPredefinedDeps });\n\n/**\n * Universal factory for creating class instances with predefined and per-call\n * dependencies.\n *\n * Works with classes whose constructor accepts a single dependency object.\n *\n * @template TPredefinedDeps Dependency shape that is always injected by the factory.\n *\n * @example\n * ```\n * const factory = new ModulesFactory({\n *   factory: (MyClass, deps) => new MyClass(deps),\n *   deps: { someDependency: new Dependency() }\n * });\n *\n * const instance = factory.create(MyClass, { extraDependency: new ExtraDependency() });\n * ```\n *\n * @example\n * ```ts\n * const factory = new ModulesFactory({\n *   factory: (Module, deps) => new Module(deps),\n * });\n * ```\n *\n * @example\n * ```ts\n * const service = factory.create(UserService, { api });\n * ```\n */\nexport class ModulesFactory<TPredefinedDeps extends AnyObject = EmptyObject> {\n  /**\n   * Creates a new module factory.\n   *\n   * @param config Factory strategy and predefined dependencies.\n   *\n   * @example\n   * ```ts\n   * const factory = new ModulesFactory({\n   *   factory: (Module, deps) => new Module(deps),\n   * });\n   * ```\n   *\n   * @example\n   * ```ts\n   * const factory = new ModulesFactory({\n   *   factory: (Module, deps) => new Module(deps),\n   *   deps: { api },\n   * });\n   * ```\n   */\n  constructor(private config: ModuleLoaderConfig<TPredefinedDeps>) {}\n\n  /**\n   * Creates an instance of the provided class by merging predefined and\n   * per-call dependencies.\n   *\n   * @template TInstance Instance type produced by the constructor.\n   * @template TDeps Full dependency object expected by the constructor.\n   * @param Constructor Class constructor receiving a single dependency object.\n   * @param args Additional dependencies merged over predefined ones.\n   * @returns Created class instance.\n   *\n   * @example\n   * ```ts\n   * const service = factory.create(UserService, { logger });\n   * ```\n   *\n   * @example\n   * ```ts\n   * const store = factory.create(UserStore);\n   * ```\n   */\n  create<TInstance, TDeps extends TPredefinedDeps = TPredefinedDeps>(\n    Constructor: Class<TInstance, [TDeps]>,\n    ...args: IsPartial<Omit<TDeps, keyof TPredefinedDeps>> extends true\n      ? [extraDeps?: Omit<TDeps, keyof TPredefinedDeps>]\n      : [extraDeps: Omit<TDeps, keyof TPredefinedDeps>]\n  ) {\n    return this.config.factory(Constructor, {\n      ...this.config.deps!,\n      ...args[0],\n    } as any);\n  }\n}\n","export type SubFn<PubArgs extends any[] = any[]> = (...args: PubArgs) => void;\n\n/**\n * The Publish-Subscribe pattern, which allows objects to interact with each other\n * through an event system. Subscribers can subscribe to events and receive notifications\n * when these events occur. The last published data can be accessed through the `data` property.\n */\nexport interface PubSub<PubArgs extends any[] = any[]> {\n  (...args: PubArgs): void;\n\n  /**\n   * Last published arguments\n   */\n  lastPub: PubArgs | undefined;\n\n  /**\n   * An array of subscriber functions (sub) that will be called\n   * when an event is published. Each subscriber must match the type SubFn,\n   * taking the arguments that will be passed to it when the publisher calls pub.\n   */\n  subs: SubFn<PubArgs>[];\n\n  /**\n   * A function to unsubscribe from events. When a subscriber function (sub) is passed,\n   * it will be removed from the `subs` array, and will no longer receive notifications.\n   */\n  unsub(sub: SubFn<PubArgs>): void;\n  /**\n   * A function to subscribe to events. When a subscriber function (sub) is passed,\n   * it will be added to the `subs` array, and will receive notifications when the publisher calls pub.\n   * Returns a function that can be used to unsubscribe from events.\n   */\n  sub(sub: SubFn<PubArgs>): VoidFunction;\n}\n\n/**\n * Creates a simple publish-subscribe dispatcher that stores the last published\n * arguments and allows subscription management.\n *\n * @template PubArgs Argument tuple delivered to subscribers.\n * @returns Callable publisher with subscribe and unsubscribe helpers.\n *\n * @example\n * ```ts\n * const pub = createPubSub<[string]>();\n * pub('ready');\n * ```\n *\n * @example\n * ```ts\n * const pub = createPubSub<[number]>();\n * const unsub = pub.sub((value) => console.log(value));\n * ```\n */\nexport const createPubSub = <PubArgs extends any[] = any[]>() => {\n  const pubSub = ((...args: PubArgs) => {\n    pubSub.lastPub = args;\n    pubSub.subs.forEach((sub) => {\n      sub(...args);\n    });\n  }) as PubSub<PubArgs>;\n  pubSub.lastPub = undefined;\n\n  pubSub.subs = [];\n\n  pubSub.unsub = (sub: SubFn<PubArgs>) => {\n    pubSub.subs = pubSub.subs.filter((it) => it !== sub);\n  };\n  pubSub.sub = (sub: SubFn<PubArgs>) => {\n    pubSub.subs.push(sub);\n    return () => pubSub.unsub(sub);\n  };\n\n  return pubSub;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,iBACX,cACA,UAAkB,MACE;CACpB,MAAM,UAAU,YAAoB;AAClC,KAAG,QAAQ,eAAe,QAAQ,IAAK;AACvC,SAAO,GAAG;;CAGZ,MAAM,kBAAkB,OAAO,EAAE,GAAG,QAAQ;CAC5C,MAAM,kBAAkB,OAAO,EAAE,GAAG,QAAQ;CAE5C,MAAM,KAAsB;AAE5B,IAAG,YAAY;AACf,IAAG,YAAY;AAEf,IAAG,cAAc;AACf,KAAG,UAAU;AACb,KAAG,QAAQ,eAAe,QAAQ,IAAK;;AAGzC,IAAG,OAAO;AAEV,QAAO;;;;;;;;;;;;;;;;;;;;;;;;ACjCT,IAAa,qBACX,iBACwB;AACxB,KAAI,gBAAgB,MAAM;EACxB,IAAI;AAEJ,SAAO;GACL,WAAmB;GACnB,aAAa;AACX,kBAAc,KAAA;;GAEhB,MAAM,UAA0B;AAC9B,kBAAc;AACd,WAAO;;GAEV;;CAGH,MAAM,cAAc;AAEpB,QAAO;EACL,WAAmB,YAAY;EAC/B,aAAa;AACX,UAAO,YAAY;;EAErB,MAAM,UAA0B;AAC9B,eAAY,gBAAgB;AAC5B,UAAO;;EAEV;;;;;;;;;;;;;;;;;;;;;;;;;;AChCH,IAAa,sBACX,cACA,iBACM;CACN,MAAM,cAAc,kBAAqB,aAAa;AACtD,QAAO,YAAY,KAAK,IAAI,YAAY,IAAI,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;AAiC3D,IAAa,6BACX,WACA,iBAC2B;CAC3B,MAAM,cAAc,kBAAqB,aAAa;CAEtD,MAAM,iBAAiB;AACrB,SAAO,YAAY,KAAK,IAAI,YAAY,IAAI,UAAU,MAAM,KAAK,CAAC;;AAGpE,QAAO;EACL,KAAK;EACL,KAAK,YAAY;EACjB,OAAO,YAAY;EACnB,SAAS,UAAsB;GAC7B,MAAM,eAAe,UAAU;AAC/B,UAAO,OAAO,cAAc,UAAU,OAAO,aAAa,CAAC;;EAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxCH,IAAa,iBAAb,MAA6E;;;;;;;;;;;;;;;;;;;;;CAqB3E,YAAY,QAAqD;AAA7C,OAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;CAsBpB,OACE,aACA,GAAG,MAGH;AACA,SAAO,KAAK,OAAO,QAAQ,aAAa;GACtC,GAAG,KAAK,OAAO;GACf,GAAG,KAAK;GACT,CAAQ;;;;;;;;;;;;;;;;;;;;;;;;ACvCb,IAAa,qBAAoD;CAC/D,MAAM,WAAW,GAAG,SAAkB;AACpC,SAAO,UAAU;AACjB,SAAO,KAAK,SAAS,QAAQ;AAC3B,OAAI,GAAG,KAAK;IACZ;;AAEJ,QAAO,UAAU,KAAA;AAEjB,QAAO,OAAO,EAAE;AAEhB,QAAO,SAAS,QAAwB;AACtC,SAAO,OAAO,OAAO,KAAK,QAAQ,OAAO,OAAO,IAAI;;AAEtD,QAAO,OAAO,QAAwB;AACpC,SAAO,KAAK,KAAK,IAAI;AACrB,eAAa,OAAO,MAAM,IAAI;;AAGhC,QAAO"}
+{"version":3,"file":"complex.cjs","names":[],"sources":["../src/complex/counter.ts","../src/complex/global-point.ts","../src/complex/global-config.ts","../src/complex/modules-factory.ts","../src/complex/pub-sub.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * Callable **counter** objects with increment, decrement, and reset for UI steppers, pagination,\n * and id generators. Values can be mapped on read so the public API stays typed while the internal\n * tick stays numeric. This file is the `counter` slice of the broader `yummies/complex` entry point.\n *\n * ## Usage\n *\n * ```ts\n * import { createCounter } from \"yummies/complex\";\n * ```\n */\n\nexport interface Counter<TValue = number> {\n  (): TValue;\n  counter: number;\n  value: TValue;\n  increment(): TValue;\n  decrement(): TValue;\n  reset(): void;\n}\n\n/**\n * @deprecated use {`Counter`}. Will be removed in next major release\n */\nexport interface CounterFn<TValue = number> extends Counter<TValue> {}\n\n/**\n * Creates a callable counter object with increment, decrement and reset helpers.\n *\n * The returned function increments the internal numeric counter when called and\n * exposes both the raw counter value and an optionally transformed `value`.\n *\n * @template TValue Public value type returned by the counter.\n * @param processValue Optional mapper that transforms the numeric counter value.\n * @param initial Initial numeric counter value.\n * @returns Callable counter with state and control methods.\n *\n * @example\n * ```ts\n * const counter = createCounter();\n * counter.increment(); // 1\n * ```\n *\n * @example\n * ```ts\n * const idCounter = createCounter((value) => `id-${value}`, 10);\n * idCounter(); // 'id-11'\n * ```\n */\nexport const createCounter = <TValue = number>(\n  processValue?: (value: number) => TValue,\n  initial: number = 0,\n): Counter<TValue> => {\n  const update = (counter: number) => {\n    fn.value = processValue?.(counter) ?? (counter as TValue);\n    return fn.value;\n  };\n\n  const increment = () => update(++fn.counter);\n  const decrement = () => update(--fn.counter);\n\n  const fn: Counter<TValue> = increment as any;\n\n  fn.increment = increment;\n  fn.decrement = decrement;\n\n  fn.reset = () => {\n    fn.counter = initial;\n    fn.value = processValue?.(initial) ?? (initial as TValue);\n  };\n\n  fn.reset();\n\n  return fn as Counter<TValue>;\n};\n","/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * Minimal **global or scoped storage** with `get` / `set` / `unset` semantics. When an access symbol\n * is provided the value lives on `globalThis`; otherwise it is isolated in a closure. Handy for\n * bridging non-React singletons, test doubles, or legacy globals without `window.foo =` sprawl.\n *\n * ## Usage\n *\n * ```ts\n * import { createGlobalPoint } from \"yummies/complex\";\n * ```\n */\n\nimport type { AnyObject } from 'yummies/types';\n\nexport interface GlobalPoint<TValue> {\n  get(): TValue;\n  set(value: TValue): TValue;\n  unset(): void;\n}\n\n/**\n * Creates a simple storage point that can live either in `globalThis` under a\n * provided key or in a local closure when no key is given.\n *\n * @template TValue Stored value type.\n * @param accessSymbol Optional global property name used for storage.\n * @returns Getter/setter API for the stored value.\n *\n * @example\n * ```ts\n * const point = createGlobalPoint<number>();\n * point.set(10);\n * ```\n *\n * @example\n * ```ts\n * const point = createGlobalPoint<string>('__token__');\n * point.get();\n * ```\n */\nexport const createGlobalPoint = <TValue>(\n  accessSymbol?: keyof any,\n): GlobalPoint<TValue> => {\n  if (accessSymbol == null) {\n    let storedValue: TValue | undefined;\n\n    return {\n      get: (): TValue => storedValue!,\n      unset: () => {\n        storedValue = undefined;\n      },\n      set: (value: TValue): TValue => {\n        storedValue = value;\n        return value;\n      },\n    };\n  }\n\n  const _globalThis = globalThis as AnyObject;\n\n  return {\n    get: (): TValue => _globalThis[accessSymbol],\n    unset: () => {\n      delete _globalThis[accessSymbol];\n    },\n    set: (value: TValue): TValue => {\n      _globalThis[accessSymbol] = value;\n      return value;\n    },\n  };\n};\n","/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * **Singleton-style config** backed by either `globalThis` (keyed by symbol) or a module closure.\n * Use for app-wide feature flags, bootstrapped locale, or SSR-safe defaults without prop-drilling.\n * Pairs with `createGlobalPoint` for other global handles in the same `yummies/complex` package.\n *\n * ## Usage\n *\n * ```ts\n * import { createGlobalConfig } from \"yummies/complex\";\n * ```\n */\n\nimport type { AnyObject, Maybe } from 'yummies/types';\nimport { createGlobalPoint } from './global-point.js';\n\n/**\n * Creates or reuses a globally accessible config object.\n *\n * The config is stored in a global point identified by `accessSymbol`, or in a\n * local closure when no symbol is provided.\n *\n * @template T Config object type.\n * @param defaultValue Default value used when no config has been created yet.\n * @param accessSymbol Optional global key used to store the config.\n * @returns Existing or newly initialized global config object.\n *\n * @example\n * ```ts\n * const config = createGlobalConfig({ locale: 'en' }, '__app_config__');\n * ```\n *\n * @example\n * ```ts\n * const config = createGlobalConfig({ debug: false });\n * config.debug;\n * ```\n */\nexport const createGlobalConfig = <T extends AnyObject>(\n  defaultValue: T,\n  accessSymbol?: keyof any,\n): T => {\n  const globalPoint = createGlobalPoint<T>(accessSymbol);\n  return globalPoint.get() || globalPoint.set(defaultValue);\n};\n\nexport interface GlobalDynamicConfig<TValue extends AnyObject> {\n  get(): TValue;\n  set(value: TValue): TValue;\n  unset(): void;\n  update(value: Partial<TValue>): void;\n}\n\n/**\n * Creates a mutable global config manager whose value is produced and updated\n * through a custom processor function.\n *\n * @template T Config object type.\n * @param processFn Function that builds the next config state from a partial change and current value.\n * @param accessSymbol Optional global key used to store the config.\n * @returns API for reading, replacing, resetting and partially updating the config.\n *\n * @example\n * ```ts\n * const config = createGlobalDynamicConfig(\n *   (change, current) => ({ theme: 'light', ...current, ...change }),\n *   '__theme__',\n * );\n * ```\n *\n * @example\n * ```ts\n * const config = createGlobalDynamicConfig((change, current) => ({ ...current, ...change }));\n * config.update({ locale: 'ru' });\n * ```\n */\nexport const createGlobalDynamicConfig = <T extends AnyObject>(\n  processFn: (change: Maybe<Partial<T>>, current: Maybe<T>) => T,\n  accessSymbol?: keyof any,\n): GlobalDynamicConfig<T> => {\n  const globalPoint = createGlobalPoint<T>(accessSymbol);\n\n  const getValue = () => {\n    return globalPoint.get() ?? globalPoint.set(processFn(null, null))!;\n  };\n\n  return {\n    get: getValue,\n    set: globalPoint.set,\n    unset: globalPoint.unset,\n    update: (value: Partial<T>) => {\n      const currentValue = getValue();\n      Object.assign(currentValue, processFn(value, currentValue));\n    },\n  };\n};\n","/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * **Dependency-injection style factory** for classes that take a single deps object in their\n * constructor. Merges predefined singletons with per-call overrides so feature modules can be\n * constructed consistently in apps that avoid heavyweight DI containers.\n *\n * ## Usage\n *\n * ```ts\n * import { ModulesFactory } from \"yummies/complex\";\n * ```\n */\n\nimport type { AnyObject, Class, EmptyObject, IsPartial } from 'yummies/types';\n\ntype ModuleLoaderConfig<TPredefinedDeps extends AnyObject = EmptyObject> = {\n  factory<TInstance, TDeps extends TPredefinedDeps>(\n    moduleClass: Class<TInstance, [TDeps]>,\n    deps: TDeps,\n  ): TInstance;\n} & (TPredefinedDeps extends EmptyObject\n  ? { deps?: TPredefinedDeps }\n  : { deps: TPredefinedDeps });\n\n/**\n * Universal factory for creating class instances with predefined and per-call\n * dependencies.\n *\n * Works with classes whose constructor accepts a single dependency object.\n *\n * @template TPredefinedDeps Dependency shape that is always injected by the factory.\n *\n * @example\n * ```\n * const factory = new ModulesFactory({\n *   factory: (MyClass, deps) => new MyClass(deps),\n *   deps: { someDependency: new Dependency() }\n * });\n *\n * const instance = factory.create(MyClass, { extraDependency: new ExtraDependency() });\n * ```\n *\n * @example\n * ```ts\n * const factory = new ModulesFactory({\n *   factory: (Module, deps) => new Module(deps),\n * });\n * ```\n *\n * @example\n * ```ts\n * const service = factory.create(UserService, { api });\n * ```\n */\nexport class ModulesFactory<TPredefinedDeps extends AnyObject = EmptyObject> {\n  /**\n   * Creates a new module factory.\n   *\n   * @param config Factory strategy and predefined dependencies.\n   *\n   * @example\n   * ```ts\n   * const factory = new ModulesFactory({\n   *   factory: (Module, deps) => new Module(deps),\n   * });\n   * ```\n   *\n   * @example\n   * ```ts\n   * const factory = new ModulesFactory({\n   *   factory: (Module, deps) => new Module(deps),\n   *   deps: { api },\n   * });\n   * ```\n   */\n  constructor(private config: ModuleLoaderConfig<TPredefinedDeps>) {}\n\n  /**\n   * Creates an instance of the provided class by merging predefined and\n   * per-call dependencies.\n   *\n   * @template TInstance Instance type produced by the constructor.\n   * @template TDeps Full dependency object expected by the constructor.\n   * @param Constructor Class constructor receiving a single dependency object.\n   * @param args Additional dependencies merged over predefined ones.\n   * @returns Created class instance.\n   *\n   * @example\n   * ```ts\n   * const service = factory.create(UserService, { logger });\n   * ```\n   *\n   * @example\n   * ```ts\n   * const store = factory.create(UserStore);\n   * ```\n   */\n  create<TInstance, TDeps extends TPredefinedDeps = TPredefinedDeps>(\n    Constructor: Class<TInstance, [TDeps]>,\n    ...args: IsPartial<Omit<TDeps, keyof TPredefinedDeps>> extends true\n      ? [extraDeps?: Omit<TDeps, keyof TPredefinedDeps>]\n      : [extraDeps: Omit<TDeps, keyof TPredefinedDeps>]\n  ) {\n    return this.config.factory(Constructor, {\n      ...this.config.deps!,\n      ...args[0],\n    } as any);\n  }\n}\n","/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * Tiny **publish–subscribe** bus: subscribers register callbacks, publishers broadcast arguments, and\n * the last payload remains readable for late subscribers. Simpler than full event emitters when you\n * only need in-memory fan-out inside a feature or view-model layer.\n *\n * ## Usage\n *\n * ```ts\n * import { createPubSub } from \"yummies/complex\";\n * ```\n */\n\nexport type SubFn<PubArgs extends any[] = any[]> = (...args: PubArgs) => void;\n\n/**\n * The Publish-Subscribe pattern, which allows objects to interact with each other\n * through an event system. Subscribers can subscribe to events and receive notifications\n * when these events occur. The last published data can be accessed through the `data` property.\n */\nexport interface PubSub<PubArgs extends any[] = any[]> {\n  (...args: PubArgs): void;\n\n  /**\n   * Last published arguments\n   */\n  lastPub: PubArgs | undefined;\n\n  /**\n   * An array of subscriber functions (sub) that will be called\n   * when an event is published. Each subscriber must match the type SubFn,\n   * taking the arguments that will be passed to it when the publisher calls pub.\n   */\n  subs: SubFn<PubArgs>[];\n\n  /**\n   * A function to unsubscribe from events. When a subscriber function (sub) is passed,\n   * it will be removed from the `subs` array, and will no longer receive notifications.\n   */\n  unsub(sub: SubFn<PubArgs>): void;\n  /**\n   * A function to subscribe to events. When a subscriber function (sub) is passed,\n   * it will be added to the `subs` array, and will receive notifications when the publisher calls pub.\n   * Returns a function that can be used to unsubscribe from events.\n   */\n  sub(sub: SubFn<PubArgs>): VoidFunction;\n}\n\n/**\n * Creates a simple publish-subscribe dispatcher that stores the last published\n * arguments and allows subscription management.\n *\n * @template PubArgs Argument tuple delivered to subscribers.\n * @returns Callable publisher with subscribe and unsubscribe helpers.\n *\n * @example\n * ```ts\n * const pub = createPubSub<[string]>();\n * pub('ready');\n * ```\n *\n * @example\n * ```ts\n * const pub = createPubSub<[number]>();\n * const unsub = pub.sub((value) => console.log(value));\n * ```\n */\nexport const createPubSub = <PubArgs extends any[] = any[]>() => {\n  const pubSub = ((...args: PubArgs) => {\n    pubSub.lastPub = args;\n    pubSub.subs.forEach((sub) => {\n      sub(...args);\n    });\n  }) as PubSub<PubArgs>;\n  pubSub.lastPub = undefined;\n\n  pubSub.subs = [];\n\n  pubSub.unsub = (sub: SubFn<PubArgs>) => {\n    pubSub.subs = pubSub.subs.filter((it) => it !== sub);\n  };\n  pubSub.sub = (sub: SubFn<PubArgs>) => {\n    pubSub.subs.push(sub);\n    return () => pubSub.unsub(sub);\n  };\n\n  return pubSub;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,IAAa,iBACX,cACA,UAAkB,MACE;CACpB,MAAM,UAAU,YAAoB;AAClC,KAAG,QAAQ,eAAe,QAAQ,IAAK;AACvC,SAAO,GAAG;;CAGZ,MAAM,kBAAkB,OAAO,EAAE,GAAG,QAAQ;CAC5C,MAAM,kBAAkB,OAAO,EAAE,GAAG,QAAQ;CAE5C,MAAM,KAAsB;AAE5B,IAAG,YAAY;AACf,IAAG,YAAY;AAEf,IAAG,cAAc;AACf,KAAG,UAAU;AACb,KAAG,QAAQ,eAAe,QAAQ,IAAK;;AAGzC,IAAG,OAAO;AAEV,QAAO;;;;;;;;;;;;;;;;;;;;;;;;ACjCT,IAAa,qBACX,iBACwB;AACxB,KAAI,gBAAgB,MAAM;EACxB,IAAI;AAEJ,SAAO;GACL,WAAmB;GACnB,aAAa;AACX,kBAAc,KAAA;;GAEhB,MAAM,UAA0B;AAC9B,kBAAc;AACd,WAAO;;GAEV;;CAGH,MAAM,cAAc;AAEpB,QAAO;EACL,WAAmB,YAAY;EAC/B,aAAa;AACX,UAAO,YAAY;;EAErB,MAAM,UAA0B;AAC9B,eAAY,gBAAgB;AAC5B,UAAO;;EAEV;;;;;;;;;;;;;;;;;;;;;;;;;;AChCH,IAAa,sBACX,cACA,iBACM;CACN,MAAM,cAAc,kBAAqB,aAAa;AACtD,QAAO,YAAY,KAAK,IAAI,YAAY,IAAI,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;AAiC3D,IAAa,6BACX,WACA,iBAC2B;CAC3B,MAAM,cAAc,kBAAqB,aAAa;CAEtD,MAAM,iBAAiB;AACrB,SAAO,YAAY,KAAK,IAAI,YAAY,IAAI,UAAU,MAAM,KAAK,CAAC;;AAGpE,QAAO;EACL,KAAK;EACL,KAAK,YAAY;EACjB,OAAO,YAAY;EACnB,SAAS,UAAsB;GAC7B,MAAM,eAAe,UAAU;AAC/B,UAAO,OAAO,cAAc,UAAU,OAAO,aAAa,CAAC;;EAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxCH,IAAa,iBAAb,MAA6E;;;;;;;;;;;;;;;;;;;;;CAqB3E,YAAY,QAAqD;AAA7C,OAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;CAsBpB,OACE,aACA,GAAG,MAGH;AACA,SAAO,KAAK,OAAO,QAAQ,aAAa;GACtC,GAAG,KAAK,OAAO;GACf,GAAG,KAAK;GACT,CAAQ;;;;;;;;;;;;;;;;;;;;;;;;ACvCb,IAAa,qBAAoD;CAC/D,MAAM,WAAW,GAAG,SAAkB;AACpC,SAAO,UAAU;AACjB,SAAO,KAAK,SAAS,QAAQ;AAC3B,OAAI,GAAG,KAAK;IACZ;;AAEJ,QAAO,UAAU,KAAA;AAEjB,QAAO,OAAO,EAAE;AAEhB,QAAO,SAAS,QAAwB;AACtC,SAAO,OAAO,OAAO,KAAK,QAAQ,OAAO,OAAO,IAAI;;AAEtD,QAAO,OAAO,QAAwB;AACpC,SAAO,KAAK,KAAK,IAAI;AACrB,eAAa,OAAO,MAAM,IAAI;;AAGhC,QAAO"}

package/complex.d.ts

@@ -1,5 +1,21 @@
 import { AnyObject, Maybe, EmptyObject, Class, IsPartial } from 'yummies/types';
 
+/**
+ * ---header-docs-section---
+ * # yummies/complex
+ *
+ * ## Description
+ *
+ * Callable **counter** objects with increment, decrement, and reset for UI steppers, pagination,
+ * and id generators. Values can be mapped on read so the public API stays typed while the internal
+ * tick stays numeric. This file is the `counter` slice of the broader `yummies/complex` entry point.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { createCounter } from "yummies/complex";
+ * ```
+ */
 interface Counter<TValue = number> {
     (): TValue;
     counter: number;
@@ -38,6 +54,23 @@ interface CounterFn<TValue = number> extends Counter<TValue> {
  */
 declare const createCounter: <TValue = number>(processValue?: (value: number) => TValue, initial?: number) => Counter<TValue>;
 
+/**
+ * ---header-docs-section---
+ * # yummies/complex
+ *
+ * ## Description
+ *
+ * **Singleton-style config** backed by either `globalThis` (keyed by symbol) or a module closure.
+ * Use for app-wide feature flags, bootstrapped locale, or SSR-safe defaults without prop-drilling.
+ * Pairs with `createGlobalPoint` for other global handles in the same `yummies/complex` package.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { createGlobalConfig } from "yummies/complex";
+ * ```
+ */
+
 /**
  * Creates or reuses a globally accessible config object.
  *
@@ -92,6 +125,23 @@ interface GlobalDynamicConfig<TValue extends AnyObject> {
  */
 declare const createGlobalDynamicConfig: <T extends AnyObject>(processFn: (change: Maybe<Partial<T>>, current: Maybe<T>) => T, accessSymbol?: keyof any) => GlobalDynamicConfig<T>;
 
+/**
+ * ---header-docs-section---
+ * # yummies/complex
+ *
+ * ## Description
+ *
+ * **Dependency-injection style factory** for classes that take a single deps object in their
+ * constructor. Merges predefined singletons with per-call overrides so feature modules can be
+ * constructed consistently in apps that avoid heavyweight DI containers.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { ModulesFactory } from "yummies/complex";
+ * ```
+ */
+
 type ModuleLoaderConfig<TPredefinedDeps extends AnyObject = EmptyObject> = {
     factory<TInstance, TDeps extends TPredefinedDeps>(moduleClass: Class<TInstance, [TDeps]>, deps: TDeps): TInstance;
 } & (TPredefinedDeps extends EmptyObject ? {
@@ -175,6 +225,22 @@ declare class ModulesFactory<TPredefinedDeps extends AnyObject = EmptyObject> {
     create<TInstance, TDeps extends TPredefinedDeps = TPredefinedDeps>(Constructor: Class<TInstance, [TDeps]>, ...args: IsPartial<Omit<TDeps, keyof TPredefinedDeps>> extends true ? [extraDeps?: Omit<TDeps, keyof TPredefinedDeps>] : [extraDeps: Omit<TDeps, keyof TPredefinedDeps>]): TInstance;
 }
 
+/**
+ * ---header-docs-section---
+ * # yummies/complex
+ *
+ * ## Description
+ *
+ * Tiny **publish–subscribe** bus: subscribers register callbacks, publishers broadcast arguments, and
+ * the last payload remains readable for late subscribers. Simpler than full event emitters when you
+ * only need in-memory fan-out inside a feature or view-model layer.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { createPubSub } from "yummies/complex";
+ * ```
+ */
 type SubFn<PubArgs extends any[] = any[]> = (...args: PubArgs) => void;
 /**
  * The Publish-Subscribe pattern, which allows objects to interact with each other

package/complex.js.map

@@ -1 +1 @@
-{"version":3,"file":"complex.js","names":[],"sources":["../src/complex/counter.ts","../src/complex/global-point.ts","../src/complex/global-config.ts","../src/complex/modules-factory.ts","../src/complex/pub-sub.ts"],"sourcesContent":["export interface Counter<TValue = number> {\n  (): TValue;\n  counter: number;\n  value: TValue;\n  increment(): TValue;\n  decrement(): TValue;\n  reset(): void;\n}\n\n/**\n * @deprecated use {`Counter`}. Will be removed in next major release\n */\nexport interface CounterFn<TValue = number> extends Counter<TValue> {}\n\n/**\n * Creates a callable counter object with increment, decrement and reset helpers.\n *\n * The returned function increments the internal numeric counter when called and\n * exposes both the raw counter value and an optionally transformed `value`.\n *\n * @template TValue Public value type returned by the counter.\n * @param processValue Optional mapper that transforms the numeric counter value.\n * @param initial Initial numeric counter value.\n * @returns Callable counter with state and control methods.\n *\n * @example\n * ```ts\n * const counter = createCounter();\n * counter.increment(); // 1\n * ```\n *\n * @example\n * ```ts\n * const idCounter = createCounter((value) => `id-${value}`, 10);\n * idCounter(); // 'id-11'\n * ```\n */\nexport const createCounter = <TValue = number>(\n  processValue?: (value: number) => TValue,\n  initial: number = 0,\n): Counter<TValue> => {\n  const update = (counter: number) => {\n    fn.value = processValue?.(counter) ?? (counter as TValue);\n    return fn.value;\n  };\n\n  const increment = () => update(++fn.counter);\n  const decrement = () => update(--fn.counter);\n\n  const fn: Counter<TValue> = increment as any;\n\n  fn.increment = increment;\n  fn.decrement = decrement;\n\n  fn.reset = () => {\n    fn.counter = initial;\n    fn.value = processValue?.(initial) ?? (initial as TValue);\n  };\n\n  fn.reset();\n\n  return fn as Counter<TValue>;\n};\n","import type { AnyObject } from 'yummies/types';\n\nexport interface GlobalPoint<TValue> {\n  get(): TValue;\n  set(value: TValue): TValue;\n  unset(): void;\n}\n\n/**\n * Creates a simple storage point that can live either in `globalThis` under a\n * provided key or in a local closure when no key is given.\n *\n * @template TValue Stored value type.\n * @param accessSymbol Optional global property name used for storage.\n * @returns Getter/setter API for the stored value.\n *\n * @example\n * ```ts\n * const point = createGlobalPoint<number>();\n * point.set(10);\n * ```\n *\n * @example\n * ```ts\n * const point = createGlobalPoint<string>('__token__');\n * point.get();\n * ```\n */\nexport const createGlobalPoint = <TValue>(\n  accessSymbol?: keyof any,\n): GlobalPoint<TValue> => {\n  if (accessSymbol == null) {\n    let storedValue: TValue | undefined;\n\n    return {\n      get: (): TValue => storedValue!,\n      unset: () => {\n        storedValue = undefined;\n      },\n      set: (value: TValue): TValue => {\n        storedValue = value;\n        return value;\n      },\n    };\n  }\n\n  const _globalThis = globalThis as AnyObject;\n\n  return {\n    get: (): TValue => _globalThis[accessSymbol],\n    unset: () => {\n      delete _globalThis[accessSymbol];\n    },\n    set: (value: TValue): TValue => {\n      _globalThis[accessSymbol] = value;\n      return value;\n    },\n  };\n};\n","import type { AnyObject, Maybe } from 'yummies/types';\nimport { createGlobalPoint } from './global-point.js';\n\n/**\n * Creates or reuses a globally accessible config object.\n *\n * The config is stored in a global point identified by `accessSymbol`, or in a\n * local closure when no symbol is provided.\n *\n * @template T Config object type.\n * @param defaultValue Default value used when no config has been created yet.\n * @param accessSymbol Optional global key used to store the config.\n * @returns Existing or newly initialized global config object.\n *\n * @example\n * ```ts\n * const config = createGlobalConfig({ locale: 'en' }, '__app_config__');\n * ```\n *\n * @example\n * ```ts\n * const config = createGlobalConfig({ debug: false });\n * config.debug;\n * ```\n */\nexport const createGlobalConfig = <T extends AnyObject>(\n  defaultValue: T,\n  accessSymbol?: keyof any,\n): T => {\n  const globalPoint = createGlobalPoint<T>(accessSymbol);\n  return globalPoint.get() || globalPoint.set(defaultValue);\n};\n\nexport interface GlobalDynamicConfig<TValue extends AnyObject> {\n  get(): TValue;\n  set(value: TValue): TValue;\n  unset(): void;\n  update(value: Partial<TValue>): void;\n}\n\n/**\n * Creates a mutable global config manager whose value is produced and updated\n * through a custom processor function.\n *\n * @template T Config object type.\n * @param processFn Function that builds the next config state from a partial change and current value.\n * @param accessSymbol Optional global key used to store the config.\n * @returns API for reading, replacing, resetting and partially updating the config.\n *\n * @example\n * ```ts\n * const config = createGlobalDynamicConfig(\n *   (change, current) => ({ theme: 'light', ...current, ...change }),\n *   '__theme__',\n * );\n * ```\n *\n * @example\n * ```ts\n * const config = createGlobalDynamicConfig((change, current) => ({ ...current, ...change }));\n * config.update({ locale: 'ru' });\n * ```\n */\nexport const createGlobalDynamicConfig = <T extends AnyObject>(\n  processFn: (change: Maybe<Partial<T>>, current: Maybe<T>) => T,\n  accessSymbol?: keyof any,\n): GlobalDynamicConfig<T> => {\n  const globalPoint = createGlobalPoint<T>(accessSymbol);\n\n  const getValue = () => {\n    return globalPoint.get() ?? globalPoint.set(processFn(null, null))!;\n  };\n\n  return {\n    get: getValue,\n    set: globalPoint.set,\n    unset: globalPoint.unset,\n    update: (value: Partial<T>) => {\n      const currentValue = getValue();\n      Object.assign(currentValue, processFn(value, currentValue));\n    },\n  };\n};\n","import type { AnyObject, Class, EmptyObject, IsPartial } from 'yummies/types';\n\ntype ModuleLoaderConfig<TPredefinedDeps extends AnyObject = EmptyObject> = {\n  factory<TInstance, TDeps extends TPredefinedDeps>(\n    moduleClass: Class<TInstance, [TDeps]>,\n    deps: TDeps,\n  ): TInstance;\n} & (TPredefinedDeps extends EmptyObject\n  ? { deps?: TPredefinedDeps }\n  : { deps: TPredefinedDeps });\n\n/**\n * Universal factory for creating class instances with predefined and per-call\n * dependencies.\n *\n * Works with classes whose constructor accepts a single dependency object.\n *\n * @template TPredefinedDeps Dependency shape that is always injected by the factory.\n *\n * @example\n * ```\n * const factory = new ModulesFactory({\n *   factory: (MyClass, deps) => new MyClass(deps),\n *   deps: { someDependency: new Dependency() }\n * });\n *\n * const instance = factory.create(MyClass, { extraDependency: new ExtraDependency() });\n * ```\n *\n * @example\n * ```ts\n * const factory = new ModulesFactory({\n *   factory: (Module, deps) => new Module(deps),\n * });\n * ```\n *\n * @example\n * ```ts\n * const service = factory.create(UserService, { api });\n * ```\n */\nexport class ModulesFactory<TPredefinedDeps extends AnyObject = EmptyObject> {\n  /**\n   * Creates a new module factory.\n   *\n   * @param config Factory strategy and predefined dependencies.\n   *\n   * @example\n   * ```ts\n   * const factory = new ModulesFactory({\n   *   factory: (Module, deps) => new Module(deps),\n   * });\n   * ```\n   *\n   * @example\n   * ```ts\n   * const factory = new ModulesFactory({\n   *   factory: (Module, deps) => new Module(deps),\n   *   deps: { api },\n   * });\n   * ```\n   */\n  constructor(private config: ModuleLoaderConfig<TPredefinedDeps>) {}\n\n  /**\n   * Creates an instance of the provided class by merging predefined and\n   * per-call dependencies.\n   *\n   * @template TInstance Instance type produced by the constructor.\n   * @template TDeps Full dependency object expected by the constructor.\n   * @param Constructor Class constructor receiving a single dependency object.\n   * @param args Additional dependencies merged over predefined ones.\n   * @returns Created class instance.\n   *\n   * @example\n   * ```ts\n   * const service = factory.create(UserService, { logger });\n   * ```\n   *\n   * @example\n   * ```ts\n   * const store = factory.create(UserStore);\n   * ```\n   */\n  create<TInstance, TDeps extends TPredefinedDeps = TPredefinedDeps>(\n    Constructor: Class<TInstance, [TDeps]>,\n    ...args: IsPartial<Omit<TDeps, keyof TPredefinedDeps>> extends true\n      ? [extraDeps?: Omit<TDeps, keyof TPredefinedDeps>]\n      : [extraDeps: Omit<TDeps, keyof TPredefinedDeps>]\n  ) {\n    return this.config.factory(Constructor, {\n      ...this.config.deps!,\n      ...args[0],\n    } as any);\n  }\n}\n","export type SubFn<PubArgs extends any[] = any[]> = (...args: PubArgs) => void;\n\n/**\n * The Publish-Subscribe pattern, which allows objects to interact with each other\n * through an event system. Subscribers can subscribe to events and receive notifications\n * when these events occur. The last published data can be accessed through the `data` property.\n */\nexport interface PubSub<PubArgs extends any[] = any[]> {\n  (...args: PubArgs): void;\n\n  /**\n   * Last published arguments\n   */\n  lastPub: PubArgs | undefined;\n\n  /**\n   * An array of subscriber functions (sub) that will be called\n   * when an event is published. Each subscriber must match the type SubFn,\n   * taking the arguments that will be passed to it when the publisher calls pub.\n   */\n  subs: SubFn<PubArgs>[];\n\n  /**\n   * A function to unsubscribe from events. When a subscriber function (sub) is passed,\n   * it will be removed from the `subs` array, and will no longer receive notifications.\n   */\n  unsub(sub: SubFn<PubArgs>): void;\n  /**\n   * A function to subscribe to events. When a subscriber function (sub) is passed,\n   * it will be added to the `subs` array, and will receive notifications when the publisher calls pub.\n   * Returns a function that can be used to unsubscribe from events.\n   */\n  sub(sub: SubFn<PubArgs>): VoidFunction;\n}\n\n/**\n * Creates a simple publish-subscribe dispatcher that stores the last published\n * arguments and allows subscription management.\n *\n * @template PubArgs Argument tuple delivered to subscribers.\n * @returns Callable publisher with subscribe and unsubscribe helpers.\n *\n * @example\n * ```ts\n * const pub = createPubSub<[string]>();\n * pub('ready');\n * ```\n *\n * @example\n * ```ts\n * const pub = createPubSub<[number]>();\n * const unsub = pub.sub((value) => console.log(value));\n * ```\n */\nexport const createPubSub = <PubArgs extends any[] = any[]>() => {\n  const pubSub = ((...args: PubArgs) => {\n    pubSub.lastPub = args;\n    pubSub.subs.forEach((sub) => {\n      sub(...args);\n    });\n  }) as PubSub<PubArgs>;\n  pubSub.lastPub = undefined;\n\n  pubSub.subs = [];\n\n  pubSub.unsub = (sub: SubFn<PubArgs>) => {\n    pubSub.subs = pubSub.subs.filter((it) => it !== sub);\n  };\n  pubSub.sub = (sub: SubFn<PubArgs>) => {\n    pubSub.subs.push(sub);\n    return () => pubSub.unsub(sub);\n  };\n\n  return pubSub;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,iBACX,cACA,UAAkB,MACE;CACpB,MAAM,UAAU,YAAoB;AAClC,KAAG,QAAQ,eAAe,QAAQ,IAAK;AACvC,SAAO,GAAG;;CAGZ,MAAM,kBAAkB,OAAO,EAAE,GAAG,QAAQ;CAC5C,MAAM,kBAAkB,OAAO,EAAE,GAAG,QAAQ;CAE5C,MAAM,KAAsB;AAE5B,IAAG,YAAY;AACf,IAAG,YAAY;AAEf,IAAG,cAAc;AACf,KAAG,UAAU;AACb,KAAG,QAAQ,eAAe,QAAQ,IAAK;;AAGzC,IAAG,OAAO;AAEV,QAAO;;;;;;;;;;;;;;;;;;;;;;;;ACjCT,IAAa,qBACX,iBACwB;AACxB,KAAI,gBAAgB,MAAM;EACxB,IAAI;AAEJ,SAAO;GACL,WAAmB;GACnB,aAAa;AACX,kBAAc,KAAA;;GAEhB,MAAM,UAA0B;AAC9B,kBAAc;AACd,WAAO;;GAEV;;CAGH,MAAM,cAAc;AAEpB,QAAO;EACL,WAAmB,YAAY;EAC/B,aAAa;AACX,UAAO,YAAY;;EAErB,MAAM,UAA0B;AAC9B,eAAY,gBAAgB;AAC5B,UAAO;;EAEV;;;;;;;;;;;;;;;;;;;;;;;;;;AChCH,IAAa,sBACX,cACA,iBACM;CACN,MAAM,cAAc,kBAAqB,aAAa;AACtD,QAAO,YAAY,KAAK,IAAI,YAAY,IAAI,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;AAiC3D,IAAa,6BACX,WACA,iBAC2B;CAC3B,MAAM,cAAc,kBAAqB,aAAa;CAEtD,MAAM,iBAAiB;AACrB,SAAO,YAAY,KAAK,IAAI,YAAY,IAAI,UAAU,MAAM,KAAK,CAAC;;AAGpE,QAAO;EACL,KAAK;EACL,KAAK,YAAY;EACjB,OAAO,YAAY;EACnB,SAAS,UAAsB;GAC7B,MAAM,eAAe,UAAU;AAC/B,UAAO,OAAO,cAAc,UAAU,OAAO,aAAa,CAAC;;EAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxCH,IAAa,iBAAb,MAA6E;;;;;;;;;;;;;;;;;;;;;CAqB3E,YAAY,QAAqD;AAA7C,OAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;CAsBpB,OACE,aACA,GAAG,MAGH;AACA,SAAO,KAAK,OAAO,QAAQ,aAAa;GACtC,GAAG,KAAK,OAAO;GACf,GAAG,KAAK;GACT,CAAQ;;;;;;;;;;;;;;;;;;;;;;;;ACvCb,IAAa,qBAAoD;CAC/D,MAAM,WAAW,GAAG,SAAkB;AACpC,SAAO,UAAU;AACjB,SAAO,KAAK,SAAS,QAAQ;AAC3B,OAAI,GAAG,KAAK;IACZ;;AAEJ,QAAO,UAAU,KAAA;AAEjB,QAAO,OAAO,EAAE;AAEhB,QAAO,SAAS,QAAwB;AACtC,SAAO,OAAO,OAAO,KAAK,QAAQ,OAAO,OAAO,IAAI;;AAEtD,QAAO,OAAO,QAAwB;AACpC,SAAO,KAAK,KAAK,IAAI;AACrB,eAAa,OAAO,MAAM,IAAI;;AAGhC,QAAO"}
+{"version":3,"file":"complex.js","names":[],"sources":["../src/complex/counter.ts","../src/complex/global-point.ts","../src/complex/global-config.ts","../src/complex/modules-factory.ts","../src/complex/pub-sub.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * Callable **counter** objects with increment, decrement, and reset for UI steppers, pagination,\n * and id generators. Values can be mapped on read so the public API stays typed while the internal\n * tick stays numeric. This file is the `counter` slice of the broader `yummies/complex` entry point.\n *\n * ## Usage\n *\n * ```ts\n * import { createCounter } from \"yummies/complex\";\n * ```\n */\n\nexport interface Counter<TValue = number> {\n  (): TValue;\n  counter: number;\n  value: TValue;\n  increment(): TValue;\n  decrement(): TValue;\n  reset(): void;\n}\n\n/**\n * @deprecated use {`Counter`}. Will be removed in next major release\n */\nexport interface CounterFn<TValue = number> extends Counter<TValue> {}\n\n/**\n * Creates a callable counter object with increment, decrement and reset helpers.\n *\n * The returned function increments the internal numeric counter when called and\n * exposes both the raw counter value and an optionally transformed `value`.\n *\n * @template TValue Public value type returned by the counter.\n * @param processValue Optional mapper that transforms the numeric counter value.\n * @param initial Initial numeric counter value.\n * @returns Callable counter with state and control methods.\n *\n * @example\n * ```ts\n * const counter = createCounter();\n * counter.increment(); // 1\n * ```\n *\n * @example\n * ```ts\n * const idCounter = createCounter((value) => `id-${value}`, 10);\n * idCounter(); // 'id-11'\n * ```\n */\nexport const createCounter = <TValue = number>(\n  processValue?: (value: number) => TValue,\n  initial: number = 0,\n): Counter<TValue> => {\n  const update = (counter: number) => {\n    fn.value = processValue?.(counter) ?? (counter as TValue);\n    return fn.value;\n  };\n\n  const increment = () => update(++fn.counter);\n  const decrement = () => update(--fn.counter);\n\n  const fn: Counter<TValue> = increment as any;\n\n  fn.increment = increment;\n  fn.decrement = decrement;\n\n  fn.reset = () => {\n    fn.counter = initial;\n    fn.value = processValue?.(initial) ?? (initial as TValue);\n  };\n\n  fn.reset();\n\n  return fn as Counter<TValue>;\n};\n","/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * Minimal **global or scoped storage** with `get` / `set` / `unset` semantics. When an access symbol\n * is provided the value lives on `globalThis`; otherwise it is isolated in a closure. Handy for\n * bridging non-React singletons, test doubles, or legacy globals without `window.foo =` sprawl.\n *\n * ## Usage\n *\n * ```ts\n * import { createGlobalPoint } from \"yummies/complex\";\n * ```\n */\n\nimport type { AnyObject } from 'yummies/types';\n\nexport interface GlobalPoint<TValue> {\n  get(): TValue;\n  set(value: TValue): TValue;\n  unset(): void;\n}\n\n/**\n * Creates a simple storage point that can live either in `globalThis` under a\n * provided key or in a local closure when no key is given.\n *\n * @template TValue Stored value type.\n * @param accessSymbol Optional global property name used for storage.\n * @returns Getter/setter API for the stored value.\n *\n * @example\n * ```ts\n * const point = createGlobalPoint<number>();\n * point.set(10);\n * ```\n *\n * @example\n * ```ts\n * const point = createGlobalPoint<string>('__token__');\n * point.get();\n * ```\n */\nexport const createGlobalPoint = <TValue>(\n  accessSymbol?: keyof any,\n): GlobalPoint<TValue> => {\n  if (accessSymbol == null) {\n    let storedValue: TValue | undefined;\n\n    return {\n      get: (): TValue => storedValue!,\n      unset: () => {\n        storedValue = undefined;\n      },\n      set: (value: TValue): TValue => {\n        storedValue = value;\n        return value;\n      },\n    };\n  }\n\n  const _globalThis = globalThis as AnyObject;\n\n  return {\n    get: (): TValue => _globalThis[accessSymbol],\n    unset: () => {\n      delete _globalThis[accessSymbol];\n    },\n    set: (value: TValue): TValue => {\n      _globalThis[accessSymbol] = value;\n      return value;\n    },\n  };\n};\n","/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * **Singleton-style config** backed by either `globalThis` (keyed by symbol) or a module closure.\n * Use for app-wide feature flags, bootstrapped locale, or SSR-safe defaults without prop-drilling.\n * Pairs with `createGlobalPoint` for other global handles in the same `yummies/complex` package.\n *\n * ## Usage\n *\n * ```ts\n * import { createGlobalConfig } from \"yummies/complex\";\n * ```\n */\n\nimport type { AnyObject, Maybe } from 'yummies/types';\nimport { createGlobalPoint } from './global-point.js';\n\n/**\n * Creates or reuses a globally accessible config object.\n *\n * The config is stored in a global point identified by `accessSymbol`, or in a\n * local closure when no symbol is provided.\n *\n * @template T Config object type.\n * @param defaultValue Default value used when no config has been created yet.\n * @param accessSymbol Optional global key used to store the config.\n * @returns Existing or newly initialized global config object.\n *\n * @example\n * ```ts\n * const config = createGlobalConfig({ locale: 'en' }, '__app_config__');\n * ```\n *\n * @example\n * ```ts\n * const config = createGlobalConfig({ debug: false });\n * config.debug;\n * ```\n */\nexport const createGlobalConfig = <T extends AnyObject>(\n  defaultValue: T,\n  accessSymbol?: keyof any,\n): T => {\n  const globalPoint = createGlobalPoint<T>(accessSymbol);\n  return globalPoint.get() || globalPoint.set(defaultValue);\n};\n\nexport interface GlobalDynamicConfig<TValue extends AnyObject> {\n  get(): TValue;\n  set(value: TValue): TValue;\n  unset(): void;\n  update(value: Partial<TValue>): void;\n}\n\n/**\n * Creates a mutable global config manager whose value is produced and updated\n * through a custom processor function.\n *\n * @template T Config object type.\n * @param processFn Function that builds the next config state from a partial change and current value.\n * @param accessSymbol Optional global key used to store the config.\n * @returns API for reading, replacing, resetting and partially updating the config.\n *\n * @example\n * ```ts\n * const config = createGlobalDynamicConfig(\n *   (change, current) => ({ theme: 'light', ...current, ...change }),\n *   '__theme__',\n * );\n * ```\n *\n * @example\n * ```ts\n * const config = createGlobalDynamicConfig((change, current) => ({ ...current, ...change }));\n * config.update({ locale: 'ru' });\n * ```\n */\nexport const createGlobalDynamicConfig = <T extends AnyObject>(\n  processFn: (change: Maybe<Partial<T>>, current: Maybe<T>) => T,\n  accessSymbol?: keyof any,\n): GlobalDynamicConfig<T> => {\n  const globalPoint = createGlobalPoint<T>(accessSymbol);\n\n  const getValue = () => {\n    return globalPoint.get() ?? globalPoint.set(processFn(null, null))!;\n  };\n\n  return {\n    get: getValue,\n    set: globalPoint.set,\n    unset: globalPoint.unset,\n    update: (value: Partial<T>) => {\n      const currentValue = getValue();\n      Object.assign(currentValue, processFn(value, currentValue));\n    },\n  };\n};\n","/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * **Dependency-injection style factory** for classes that take a single deps object in their\n * constructor. Merges predefined singletons with per-call overrides so feature modules can be\n * constructed consistently in apps that avoid heavyweight DI containers.\n *\n * ## Usage\n *\n * ```ts\n * import { ModulesFactory } from \"yummies/complex\";\n * ```\n */\n\nimport type { AnyObject, Class, EmptyObject, IsPartial } from 'yummies/types';\n\ntype ModuleLoaderConfig<TPredefinedDeps extends AnyObject = EmptyObject> = {\n  factory<TInstance, TDeps extends TPredefinedDeps>(\n    moduleClass: Class<TInstance, [TDeps]>,\n    deps: TDeps,\n  ): TInstance;\n} & (TPredefinedDeps extends EmptyObject\n  ? { deps?: TPredefinedDeps }\n  : { deps: TPredefinedDeps });\n\n/**\n * Universal factory for creating class instances with predefined and per-call\n * dependencies.\n *\n * Works with classes whose constructor accepts a single dependency object.\n *\n * @template TPredefinedDeps Dependency shape that is always injected by the factory.\n *\n * @example\n * ```\n * const factory = new ModulesFactory({\n *   factory: (MyClass, deps) => new MyClass(deps),\n *   deps: { someDependency: new Dependency() }\n * });\n *\n * const instance = factory.create(MyClass, { extraDependency: new ExtraDependency() });\n * ```\n *\n * @example\n * ```ts\n * const factory = new ModulesFactory({\n *   factory: (Module, deps) => new Module(deps),\n * });\n * ```\n *\n * @example\n * ```ts\n * const service = factory.create(UserService, { api });\n * ```\n */\nexport class ModulesFactory<TPredefinedDeps extends AnyObject = EmptyObject> {\n  /**\n   * Creates a new module factory.\n   *\n   * @param config Factory strategy and predefined dependencies.\n   *\n   * @example\n   * ```ts\n   * const factory = new ModulesFactory({\n   *   factory: (Module, deps) => new Module(deps),\n   * });\n   * ```\n   *\n   * @example\n   * ```ts\n   * const factory = new ModulesFactory({\n   *   factory: (Module, deps) => new Module(deps),\n   *   deps: { api },\n   * });\n   * ```\n   */\n  constructor(private config: ModuleLoaderConfig<TPredefinedDeps>) {}\n\n  /**\n   * Creates an instance of the provided class by merging predefined and\n   * per-call dependencies.\n   *\n   * @template TInstance Instance type produced by the constructor.\n   * @template TDeps Full dependency object expected by the constructor.\n   * @param Constructor Class constructor receiving a single dependency object.\n   * @param args Additional dependencies merged over predefined ones.\n   * @returns Created class instance.\n   *\n   * @example\n   * ```ts\n   * const service = factory.create(UserService, { logger });\n   * ```\n   *\n   * @example\n   * ```ts\n   * const store = factory.create(UserStore);\n   * ```\n   */\n  create<TInstance, TDeps extends TPredefinedDeps = TPredefinedDeps>(\n    Constructor: Class<TInstance, [TDeps]>,\n    ...args: IsPartial<Omit<TDeps, keyof TPredefinedDeps>> extends true\n      ? [extraDeps?: Omit<TDeps, keyof TPredefinedDeps>]\n      : [extraDeps: Omit<TDeps, keyof TPredefinedDeps>]\n  ) {\n    return this.config.factory(Constructor, {\n      ...this.config.deps!,\n      ...args[0],\n    } as any);\n  }\n}\n","/**\n * ---header-docs-section---\n * # yummies/complex\n *\n * ## Description\n *\n * Tiny **publish–subscribe** bus: subscribers register callbacks, publishers broadcast arguments, and\n * the last payload remains readable for late subscribers. Simpler than full event emitters when you\n * only need in-memory fan-out inside a feature or view-model layer.\n *\n * ## Usage\n *\n * ```ts\n * import { createPubSub } from \"yummies/complex\";\n * ```\n */\n\nexport type SubFn<PubArgs extends any[] = any[]> = (...args: PubArgs) => void;\n\n/**\n * The Publish-Subscribe pattern, which allows objects to interact with each other\n * through an event system. Subscribers can subscribe to events and receive notifications\n * when these events occur. The last published data can be accessed through the `data` property.\n */\nexport interface PubSub<PubArgs extends any[] = any[]> {\n  (...args: PubArgs): void;\n\n  /**\n   * Last published arguments\n   */\n  lastPub: PubArgs | undefined;\n\n  /**\n   * An array of subscriber functions (sub) that will be called\n   * when an event is published. Each subscriber must match the type SubFn,\n   * taking the arguments that will be passed to it when the publisher calls pub.\n   */\n  subs: SubFn<PubArgs>[];\n\n  /**\n   * A function to unsubscribe from events. When a subscriber function (sub) is passed,\n   * it will be removed from the `subs` array, and will no longer receive notifications.\n   */\n  unsub(sub: SubFn<PubArgs>): void;\n  /**\n   * A function to subscribe to events. When a subscriber function (sub) is passed,\n   * it will be added to the `subs` array, and will receive notifications when the publisher calls pub.\n   * Returns a function that can be used to unsubscribe from events.\n   */\n  sub(sub: SubFn<PubArgs>): VoidFunction;\n}\n\n/**\n * Creates a simple publish-subscribe dispatcher that stores the last published\n * arguments and allows subscription management.\n *\n * @template PubArgs Argument tuple delivered to subscribers.\n * @returns Callable publisher with subscribe and unsubscribe helpers.\n *\n * @example\n * ```ts\n * const pub = createPubSub<[string]>();\n * pub('ready');\n * ```\n *\n * @example\n * ```ts\n * const pub = createPubSub<[number]>();\n * const unsub = pub.sub((value) => console.log(value));\n * ```\n */\nexport const createPubSub = <PubArgs extends any[] = any[]>() => {\n  const pubSub = ((...args: PubArgs) => {\n    pubSub.lastPub = args;\n    pubSub.subs.forEach((sub) => {\n      sub(...args);\n    });\n  }) as PubSub<PubArgs>;\n  pubSub.lastPub = undefined;\n\n  pubSub.subs = [];\n\n  pubSub.unsub = (sub: SubFn<PubArgs>) => {\n    pubSub.subs = pubSub.subs.filter((it) => it !== sub);\n  };\n  pubSub.sub = (sub: SubFn<PubArgs>) => {\n    pubSub.subs.push(sub);\n    return () => pubSub.unsub(sub);\n  };\n\n  return pubSub;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAsDA,IAAa,iBACX,cACA,UAAkB,MACE;CACpB,MAAM,UAAU,YAAoB;AAClC,KAAG,QAAQ,eAAe,QAAQ,IAAK;AACvC,SAAO,GAAG;;CAGZ,MAAM,kBAAkB,OAAO,EAAE,GAAG,QAAQ;CAC5C,MAAM,kBAAkB,OAAO,EAAE,GAAG,QAAQ;CAE5C,MAAM,KAAsB;AAE5B,IAAG,YAAY;AACf,IAAG,YAAY;AAEf,IAAG,cAAc;AACf,KAAG,UAAU;AACb,KAAG,QAAQ,eAAe,QAAQ,IAAK;;AAGzC,IAAG,OAAO;AAEV,QAAO;;;;;;;;;;;;;;;;;;;;;;;;ACjCT,IAAa,qBACX,iBACwB;AACxB,KAAI,gBAAgB,MAAM;EACxB,IAAI;AAEJ,SAAO;GACL,WAAmB;GACnB,aAAa;AACX,kBAAc,KAAA;;GAEhB,MAAM,UAA0B;AAC9B,kBAAc;AACd,WAAO;;GAEV;;CAGH,MAAM,cAAc;AAEpB,QAAO;EACL,WAAmB,YAAY;EAC/B,aAAa;AACX,UAAO,YAAY;;EAErB,MAAM,UAA0B;AAC9B,eAAY,gBAAgB;AAC5B,UAAO;;EAEV;;;;;;;;;;;;;;;;;;;;;;;;;;AChCH,IAAa,sBACX,cACA,iBACM;CACN,MAAM,cAAc,kBAAqB,aAAa;AACtD,QAAO,YAAY,KAAK,IAAI,YAAY,IAAI,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;AAiC3D,IAAa,6BACX,WACA,iBAC2B;CAC3B,MAAM,cAAc,kBAAqB,aAAa;CAEtD,MAAM,iBAAiB;AACrB,SAAO,YAAY,KAAK,IAAI,YAAY,IAAI,UAAU,MAAM,KAAK,CAAC;;AAGpE,QAAO;EACL,KAAK;EACL,KAAK,YAAY;EACjB,OAAO,YAAY;EACnB,SAAS,UAAsB;GAC7B,MAAM,eAAe,UAAU;AAC/B,UAAO,OAAO,cAAc,UAAU,OAAO,aAAa,CAAC;;EAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACxCH,IAAa,iBAAb,MAA6E;;;;;;;;;;;;;;;;;;;;;CAqB3E,YAAY,QAAqD;AAA7C,OAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;CAsBpB,OACE,aACA,GAAG,MAGH;AACA,SAAO,KAAK,OAAO,QAAQ,aAAa;GACtC,GAAG,KAAK,OAAO;GACf,GAAG,KAAK;GACT,CAAQ;;;;;;;;;;;;;;;;;;;;;;;;ACvCb,IAAa,qBAAoD;CAC/D,MAAM,WAAW,GAAG,SAAkB;AACpC,SAAO,UAAU;AACjB,SAAO,KAAK,SAAS,QAAQ;AAC3B,OAAI,GAAG,KAAK;IACZ;;AAEJ,QAAO,UAAU,KAAA;AAEjB,QAAO,OAAO,EAAE;AAEhB,QAAO,SAAS,QAAwB;AACtC,SAAO,OAAO,OAAO,KAAK,QAAQ,OAAO,OAAO,IAAI;;AAEtD,QAAO,OAAO,QAAwB;AACpC,SAAO,KAAK,KAAK,IAAI;AACrB,eAAa,OAAO,MAAM,IAAI;;AAGhC,QAAO"}

package/cookie.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"cookie.cjs","names":[],"sources":["../src/cookie.ts"],"sourcesContent":["import type { AnyObject } from 'yummies/types';\n\n/**\n * Parses a cookie string into an object with cookie names as keys.\n *\n * @example\n * ```ts\n * parseCookie('theme=dark; token=abc');\n * ```\n */\nexport const parseCookie = (cookiesString = document.cookie) => {\n  return cookiesString\n    .split(';')\n    .map((cookieString) => cookieString.trim().split('='))\n    .reduce<AnyObject>((acc, current) => {\n      acc[current[0]] = current[1];\n      return acc;\n    }, {});\n};\n"],"mappings":";;;;;;;;;;AAUA,IAAa,eAAe,gBAAgB,SAAS,WAAW;AAC9D,QAAO,cACJ,MAAM,IAAI,CACV,KAAK,iBAAiB,aAAa,MAAM,CAAC,MAAM,IAAI,CAAC,CACrD,QAAmB,KAAK,YAAY;AACnC,MAAI,QAAQ,MAAM,QAAQ;AAC1B,SAAO;IACN,EAAE,CAAC"}
+{"version":3,"file":"cookie.cjs","names":[],"sources":["../src/cookie.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/cookie\n *\n * ## Description\n *\n * Minimal helpers for reading the browser `document.cookie` string as a plain key/value map. This\n * avoids hand-rolled splitting and trimming at every call site and keeps parsing consistent across\n * the app. It is intentionally small: set paths, `Secure`, `SameSite`, and expiry are still handled\n * by your server or `document.cookie` writes elsewhere.\n *\n * ## Usage\n *\n * ```ts\n * import { parseCookie } from \"yummies/cookie\";\n * ```\n */\n\nimport type { AnyObject } from 'yummies/types';\n\n/**\n * Parses a cookie string into an object with cookie names as keys.\n *\n * @example\n * ```ts\n * parseCookie('theme=dark; token=abc');\n * ```\n */\nexport const parseCookie = (cookiesString = document.cookie) => {\n  return cookiesString\n    .split(';')\n    .map((cookieString) => cookieString.trim().split('='))\n    .reduce<AnyObject>((acc, current) => {\n      acc[current[0]] = current[1];\n      return acc;\n    }, {});\n};\n"],"mappings":";;;;;;;;;;AA4BA,IAAa,eAAe,gBAAgB,SAAS,WAAW;AAC9D,QAAO,cACJ,MAAM,IAAI,CACV,KAAK,iBAAiB,aAAa,MAAM,CAAC,MAAM,IAAI,CAAC,CACrD,QAAmB,KAAK,YAAY;AACnC,MAAI,QAAQ,MAAM,QAAQ;AAC1B,SAAO;IACN,EAAE,CAAC"}

package/cookie.d.ts

@@ -1,5 +1,23 @@
 import { AnyObject } from 'yummies/types';
 
+/**
+ * ---header-docs-section---
+ * # yummies/cookie
+ *
+ * ## Description
+ *
+ * Minimal helpers for reading the browser `document.cookie` string as a plain key/value map. This
+ * avoids hand-rolled splitting and trimming at every call site and keeps parsing consistent across
+ * the app. It is intentionally small: set paths, `Secure`, `SameSite`, and expiry are still handled
+ * by your server or `document.cookie` writes elsewhere.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { parseCookie } from "yummies/cookie";
+ * ```
+ */
+
 /**
  * Parses a cookie string into an object with cookie names as keys.
  *

package/cookie.js.map

@@ -1 +1 @@
-{"version":3,"file":"cookie.js","names":[],"sources":["../src/cookie.ts"],"sourcesContent":["import type { AnyObject } from 'yummies/types';\n\n/**\n * Parses a cookie string into an object with cookie names as keys.\n *\n * @example\n * ```ts\n * parseCookie('theme=dark; token=abc');\n * ```\n */\nexport const parseCookie = (cookiesString = document.cookie) => {\n  return cookiesString\n    .split(';')\n    .map((cookieString) => cookieString.trim().split('='))\n    .reduce<AnyObject>((acc, current) => {\n      acc[current[0]] = current[1];\n      return acc;\n    }, {});\n};\n"],"mappings":";;;;;;;;;AAUA,IAAa,eAAe,gBAAgB,SAAS,WAAW;AAC9D,QAAO,cACJ,MAAM,IAAI,CACV,KAAK,iBAAiB,aAAa,MAAM,CAAC,MAAM,IAAI,CAAC,CACrD,QAAmB,KAAK,YAAY;AACnC,MAAI,QAAQ,MAAM,QAAQ;AAC1B,SAAO;IACN,EAAE,CAAC"}
+{"version":3,"file":"cookie.js","names":[],"sources":["../src/cookie.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/cookie\n *\n * ## Description\n *\n * Minimal helpers for reading the browser `document.cookie` string as a plain key/value map. This\n * avoids hand-rolled splitting and trimming at every call site and keeps parsing consistent across\n * the app. It is intentionally small: set paths, `Secure`, `SameSite`, and expiry are still handled\n * by your server or `document.cookie` writes elsewhere.\n *\n * ## Usage\n *\n * ```ts\n * import { parseCookie } from \"yummies/cookie\";\n * ```\n */\n\nimport type { AnyObject } from 'yummies/types';\n\n/**\n * Parses a cookie string into an object with cookie names as keys.\n *\n * @example\n * ```ts\n * parseCookie('theme=dark; token=abc');\n * ```\n */\nexport const parseCookie = (cookiesString = document.cookie) => {\n  return cookiesString\n    .split(';')\n    .map((cookieString) => cookieString.trim().split('='))\n    .reduce<AnyObject>((acc, current) => {\n      acc[current[0]] = current[1];\n      return acc;\n    }, {});\n};\n"],"mappings":";;;;;;;;;AA4BA,IAAa,eAAe,gBAAgB,SAAS,WAAW;AAC9D,QAAO,cACJ,MAAM,IAAI,CACV,KAAK,iBAAiB,aAAa,MAAM,CAAC,MAAM,IAAI,CAAC,CACrD,QAAmB,KAAK,YAAY;AACnC,MAAI,QAAQ,MAAM,QAAQ;AAC1B,SAAO;IACN,EAAE,CAAC"}

package/css.cjs

@@ -6,6 +6,22 @@ clsx = require_chunk.__toESM(clsx);
 let tailwind_merge = require("tailwind-merge");
 //#region src/css.ts
 /**
+* ---header-docs-section---
+* # yummies/css
+*
+* ## Description
+*
+* Styling utilities for React and plain DOM: `rem` conversion, `clsx` + `tailwind-merge` via `cx`,
+* and a `cva` bridge for variant-driven class names. The goal is predictable class strings without
+* Tailwind conflicts and with less boilerplate than concatenating strings by hand across components.
+*
+* ## Usage
+*
+* ```ts
+* import { cx, toRem } from "yummies/css";
+* ```
+*/
+/**
 * Converts a length in **pixels** to a CSS **`rem`** string (`"<number>rem"`).
 *
 * Use when authoring component styles in JS/TS where design tokens are in px but the stylesheet

package/css.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"css.cjs","names":[],"sources":["../src/css.ts"],"sourcesContent":["import { cva as cvaLib } from 'class-variance-authority';\nimport clsx, { type ClassValue } from 'clsx';\nimport { twMerge } from 'tailwind-merge';\nimport type { Maybe } from 'yummies/types';\n\ntype ClassProp = {\n  class?: ClassValue;\n  className?: ClassValue;\n};\n\ntype StringToBoolean<T> = T extends 'true' | 'false' ? boolean : T;\n\n/**\n * Converts a length in **pixels** to a CSS **`rem`** string (`\"<number>rem\"`).\n *\n * Use when authoring component styles in JS/TS where design tokens are in px but the stylesheet\n * should scale with root font size (accessibility, user zoom). `remValue` is the assumed\n * `1rem` size in px (browser default is typically `16`).\n *\n * @param px - Pixel value to convert (not rounded; stringification keeps full float).\n * @param remValue - How many pixels one `rem` equals. Defaults to `16`.\n * @returns A string like `\"1.5rem\"` suitable for `style` or CSS-in-JS.\n *\n * @example\n * ```ts\n * const width = toRem(24); // '1.5rem' with default 16px root\n * ```\n *\n * @example\n * ```ts\n * // Custom root / design system where 1rem === 10px\n * const gap = toRem(20, 10); // '2rem'\n * ```\n */\nexport const toRem = (px: number, remValue = 16) => `${px / remValue}rem`;\n\n/**\n * Composes conditional class names like {@link https://github.com/lukeed/clsx | clsx}, then runs\n * the result through {@link https://github.com/dcastil/tailwind-merge | tailwind-merge} so\n * conflicting Tailwind utilities collapse to the last/intended one (e.g. two `padding-x` classes).\n *\n * Accepts the same argument shapes as `clsx`: strings, objects, arrays, falsy values to omit.\n *\n * @param args - Same as `clsx(...args)` — `ClassValue` rest parameters.\n * @returns A single merged class string, safe for `className` on DOM/React.\n *\n * @example\n * ```ts\n * cx('px-2 py-1 text-sm', 'px-4'); // 'py-1 text-sm px-4' — padding-x merged\n * ```\n *\n * @example\n * ```ts\n * cx('btn', { 'btn--active': isActive, 'btn--disabled': disabled }, className);\n * ```\n */\nexport const cx = (...args: Parameters<typeof clsx>) => twMerge(clsx(...args));\n\ntype ConfigSchema = Record<string, Record<string, ClassValue>>;\ntype ConfigVariants<T extends ConfigSchema> = {\n  [Variant in keyof T]?: StringToBoolean<keyof T[Variant]> | null | undefined;\n};\ntype ConfigVariantsMulti<T extends ConfigSchema> = {\n  [Variant in keyof T]?:\n    | StringToBoolean<keyof T[Variant]>\n    | StringToBoolean<keyof T[Variant]>[]\n    | undefined;\n};\ntype Config<T> = T extends ConfigSchema\n  ? {\n      variants?: T;\n      defaultVariants?: ConfigVariants<T>;\n      compoundVariants?: (T extends ConfigSchema\n        ? (ConfigVariants<T> | ConfigVariantsMulti<T>) & ClassProp\n        : ClassProp)[];\n    }\n  : never;\n\ntype Props<T> = T extends ConfigSchema\n  ? ConfigVariants<T> & ClassProp\n  : ClassProp;\n\n/**\n * {@link https://cva.style/docs | Class Variance Authority (cva)} with the same **tailwind-merge**\n * pass as {@link cx}: the class string produced by the variant function is merged so Tailwind\n * conflicts resolve predictably.\n *\n * API matches `cva` from `class-variance-authority`: optional `base` classes, `config` with\n * `variants`, `defaultVariants`, and `compoundVariants`. The returned function accepts variant\n * props plus optional `class` / `className` for one-off overrides.\n *\n * Use {@link VariantProps} with `typeof buttonVariants` (or similar) to type component props.\n *\n * @param base - Base `ClassValue`(s) always applied.\n * @param config - Variant schema and defaults (same shape as upstream `cva`).\n * @returns A function `(props?) => string` that resolves variant classes, merged with tw-merge.\n *\n * @example\n * ```ts\n * const button = cva('rounded font-medium', {\n *   variants: {\n *     tone: { primary: 'bg-blue-600 text-white', ghost: 'bg-transparent' },\n *     size: { sm: 'text-sm px-2', md: 'text-base px-4' },\n *   },\n *   defaultVariants: { tone: 'primary', size: 'md' },\n * });\n * button({ tone: 'ghost', className: 'ml-2' });\n * ```\n *\n * @example\n * ```ts\n * const card = cva('border p-4', {\n *   variants: { elevated: { true: 'shadow-lg', false: 'shadow-none' } },\n *   defaultVariants: { elevated: false },\n * });\n * card({ elevated: true });\n * ```\n */\nexport const cva = ((...args: any[]) => {\n  const schema = cvaLib(...args);\n  return (...inputArgs: any[]) => twMerge(schema(...inputArgs));\n}) as any as <T>(\n  base?: ClassValue,\n  config?: Config<T>,\n) => (props?: Props<T>) => string;\n\n/**\n * Utility type from `class-variance-authority`: infers the variant prop object from a `cva` instance.\n * Use it to type React (or other) components that forward variant props.\n *\n * @example\n * ```ts\n * const input = cva('border', { variants: { size: { sm: 'h-8', lg: 'h-12' } } });\n * type InputVariants = VariantProps<typeof input>;\n * // { size?: 'sm' | 'lg' | null }\n * ```\n */\nexport type { VariantProps } from 'class-variance-authority';\n\n/**\n * Re-export from `clsx`: a class name fragment — string, number, nested arrays, object map of\n * flags, or falsy nodes to skip. Used by {@link cx}, {@link cva}, and typical `className` helpers.\n *\n * @example\n * ```ts\n * const value: ClassValue = ['btn', false && 'hidden', { active: true }];\n * ```\n */\nexport type { ClassValue } from 'clsx';\n\n/**\n * Injects a stylesheet by appending a `<link rel=\"stylesheet\">` to `document.head`.\n * Resolves when the sheet fires `load`; rejects on `error` (e.g. 404 or network failure).\n *\n * **Id replacement:** if `attrubutes.id` is set, any existing element with that `id` is removed\n * first, so repeated calls with the same `id` replace the previous link (useful for theme or\n * font URLs that change).\n *\n * If `rel` is omitted in `attrubutes`, it defaults to `stylesheet`. Other attributes (`crossorigin`,\n * `media`, `data-*`, etc.) are set via `setAttribute` from the record entries.\n *\n * @param url - Stylesheet URL (`href`).\n * @param attrubutes - Optional HTML attributes for the `<link>` element (see `id` / `rel` behavior above).\n * @returns Promise that resolves to `undefined` on load, or rejects on load error.\n *\n * @example\n * ```ts\n * await loadCssFile('https://example.com/fonts.css', {\n *   id: 'app-fonts',\n *   crossOrigin: 'anonymous',\n * });\n * ```\n *\n * @example\n * ```ts\n * // Swap theme stylesheet without duplicate link tags\n * await loadCssFile('/themes/dark.css', { id: 'theme' });\n * await loadCssFile('/themes/light.css', { id: 'theme' });\n * ```\n */\nexport const loadCssFile = (url: string, attrubutes?: Record<string, any>) =>\n  new Promise((resolve, reject) => {\n    let link: Maybe<HTMLLinkElement>;\n\n    if (attrubutes?.id) {\n      link = document.getElementById(attrubutes.id) as HTMLLinkElement | null;\n\n      if (link) {\n        link.remove();\n      }\n    }\n\n    link = document.createElement('link');\n\n    const handleLoad = () => {\n      resolve(undefined);\n      link!.removeEventListener('load', handleLoad);\n      link!.removeEventListener('error', handleError);\n    };\n\n    const handleError = () => {\n      reject(undefined);\n      link!.removeEventListener('load', handleLoad);\n      link!.removeEventListener('error', handleError);\n    };\n\n    link.addEventListener('load', handleLoad);\n    link.addEventListener('error', handleError);\n\n    link.setAttribute('href', url);\n\n    if (!attrubutes?.rel) {\n      link.setAttribute('rel', 'stylesheet');\n    }\n\n    Object.entries(attrubutes || {}).forEach(([key, value]) => {\n      link.setAttribute(key, value);\n    });\n\n    document.head.appendChild(link);\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,SAAS,IAAY,WAAW,OAAO,GAAG,KAAK,SAAS;;;;;;;;;;;;;;;;;;;;;AAsBrE,IAAa,MAAM,GAAG,UAAA,GAAA,eAAA,UAAA,GAAA,KAAA,SAA+C,GAAG,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8D9E,IAAa,QAAQ,GAAG,SAAgB;CACtC,MAAM,UAAA,GAAA,yBAAA,KAAgB,GAAG,KAAK;AAC9B,SAAQ,GAAG,eAAA,GAAA,eAAA,SAA6B,OAAO,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4D/D,IAAa,eAAe,KAAa,eACvC,IAAI,SAAS,SAAS,WAAW;CAC/B,IAAI;AAEJ,KAAI,YAAY,IAAI;AAClB,SAAO,SAAS,eAAe,WAAW,GAAG;AAE7C,MAAI,KACF,MAAK,QAAQ;;AAIjB,QAAO,SAAS,cAAc,OAAO;CAErC,MAAM,mBAAmB;AACvB,UAAQ,KAAA,EAAU;AAClB,OAAM,oBAAoB,QAAQ,WAAW;AAC7C,OAAM,oBAAoB,SAAS,YAAY;;CAGjD,MAAM,oBAAoB;AACxB,SAAO,KAAA,EAAU;AACjB,OAAM,oBAAoB,QAAQ,WAAW;AAC7C,OAAM,oBAAoB,SAAS,YAAY;;AAGjD,MAAK,iBAAiB,QAAQ,WAAW;AACzC,MAAK,iBAAiB,SAAS,YAAY;AAE3C,MAAK,aAAa,QAAQ,IAAI;AAE9B,KAAI,CAAC,YAAY,IACf,MAAK,aAAa,OAAO,aAAa;AAGxC,QAAO,QAAQ,cAAc,EAAE,CAAC,CAAC,SAAS,CAAC,KAAK,WAAW;AACzD,OAAK,aAAa,KAAK,MAAM;GAC7B;AAEF,UAAS,KAAK,YAAY,KAAK;EAC/B"}
+{"version":3,"file":"css.cjs","names":[],"sources":["../src/css.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/css\n *\n * ## Description\n *\n * Styling utilities for React and plain DOM: `rem` conversion, `clsx` + `tailwind-merge` via `cx`,\n * and a `cva` bridge for variant-driven class names. The goal is predictable class strings without\n * Tailwind conflicts and with less boilerplate than concatenating strings by hand across components.\n *\n * ## Usage\n *\n * ```ts\n * import { cx, toRem } from \"yummies/css\";\n * ```\n */\n\nimport { cva as cvaLib } from 'class-variance-authority';\nimport clsx, { type ClassValue } from 'clsx';\nimport { twMerge } from 'tailwind-merge';\nimport type { Maybe } from 'yummies/types';\n\ntype ClassProp = {\n  class?: ClassValue;\n  className?: ClassValue;\n};\n\ntype StringToBoolean<T> = T extends 'true' | 'false' ? boolean : T;\n\n/**\n * Converts a length in **pixels** to a CSS **`rem`** string (`\"<number>rem\"`).\n *\n * Use when authoring component styles in JS/TS where design tokens are in px but the stylesheet\n * should scale with root font size (accessibility, user zoom). `remValue` is the assumed\n * `1rem` size in px (browser default is typically `16`).\n *\n * @param px - Pixel value to convert (not rounded; stringification keeps full float).\n * @param remValue - How many pixels one `rem` equals. Defaults to `16`.\n * @returns A string like `\"1.5rem\"` suitable for `style` or CSS-in-JS.\n *\n * @example\n * ```ts\n * const width = toRem(24); // '1.5rem' with default 16px root\n * ```\n *\n * @example\n * ```ts\n * // Custom root / design system where 1rem === 10px\n * const gap = toRem(20, 10); // '2rem'\n * ```\n */\nexport const toRem = (px: number, remValue = 16) => `${px / remValue}rem`;\n\n/**\n * Composes conditional class names like {@link https://github.com/lukeed/clsx | clsx}, then runs\n * the result through {@link https://github.com/dcastil/tailwind-merge | tailwind-merge} so\n * conflicting Tailwind utilities collapse to the last/intended one (e.g. two `padding-x` classes).\n *\n * Accepts the same argument shapes as `clsx`: strings, objects, arrays, falsy values to omit.\n *\n * @param args - Same as `clsx(...args)` — `ClassValue` rest parameters.\n * @returns A single merged class string, safe for `className` on DOM/React.\n *\n * @example\n * ```ts\n * cx('px-2 py-1 text-sm', 'px-4'); // 'py-1 text-sm px-4' — padding-x merged\n * ```\n *\n * @example\n * ```ts\n * cx('btn', { 'btn--active': isActive, 'btn--disabled': disabled }, className);\n * ```\n */\nexport const cx = (...args: Parameters<typeof clsx>) => twMerge(clsx(...args));\n\ntype ConfigSchema = Record<string, Record<string, ClassValue>>;\ntype ConfigVariants<T extends ConfigSchema> = {\n  [Variant in keyof T]?: StringToBoolean<keyof T[Variant]> | null | undefined;\n};\ntype ConfigVariantsMulti<T extends ConfigSchema> = {\n  [Variant in keyof T]?:\n    | StringToBoolean<keyof T[Variant]>\n    | StringToBoolean<keyof T[Variant]>[]\n    | undefined;\n};\ntype Config<T> = T extends ConfigSchema\n  ? {\n      variants?: T;\n      defaultVariants?: ConfigVariants<T>;\n      compoundVariants?: (T extends ConfigSchema\n        ? (ConfigVariants<T> | ConfigVariantsMulti<T>) & ClassProp\n        : ClassProp)[];\n    }\n  : never;\n\ntype Props<T> = T extends ConfigSchema\n  ? ConfigVariants<T> & ClassProp\n  : ClassProp;\n\n/**\n * {@link https://cva.style/docs | Class Variance Authority (cva)} with the same **tailwind-merge**\n * pass as {@link cx}: the class string produced by the variant function is merged so Tailwind\n * conflicts resolve predictably.\n *\n * API matches `cva` from `class-variance-authority`: optional `base` classes, `config` with\n * `variants`, `defaultVariants`, and `compoundVariants`. The returned function accepts variant\n * props plus optional `class` / `className` for one-off overrides.\n *\n * Use {@link VariantProps} with `typeof buttonVariants` (or similar) to type component props.\n *\n * @param base - Base `ClassValue`(s) always applied.\n * @param config - Variant schema and defaults (same shape as upstream `cva`).\n * @returns A function `(props?) => string` that resolves variant classes, merged with tw-merge.\n *\n * @example\n * ```ts\n * const button = cva('rounded font-medium', {\n *   variants: {\n *     tone: { primary: 'bg-blue-600 text-white', ghost: 'bg-transparent' },\n *     size: { sm: 'text-sm px-2', md: 'text-base px-4' },\n *   },\n *   defaultVariants: { tone: 'primary', size: 'md' },\n * });\n * button({ tone: 'ghost', className: 'ml-2' });\n * ```\n *\n * @example\n * ```ts\n * const card = cva('border p-4', {\n *   variants: { elevated: { true: 'shadow-lg', false: 'shadow-none' } },\n *   defaultVariants: { elevated: false },\n * });\n * card({ elevated: true });\n * ```\n */\nexport const cva = ((...args: any[]) => {\n  const schema = cvaLib(...args);\n  return (...inputArgs: any[]) => twMerge(schema(...inputArgs));\n}) as any as <T>(\n  base?: ClassValue,\n  config?: Config<T>,\n) => (props?: Props<T>) => string;\n\n/**\n * Utility type from `class-variance-authority`: infers the variant prop object from a `cva` instance.\n * Use it to type React (or other) components that forward variant props.\n *\n * @example\n * ```ts\n * const input = cva('border', { variants: { size: { sm: 'h-8', lg: 'h-12' } } });\n * type InputVariants = VariantProps<typeof input>;\n * // { size?: 'sm' | 'lg' | null }\n * ```\n */\nexport type { VariantProps } from 'class-variance-authority';\n\n/**\n * Re-export from `clsx`: a class name fragment — string, number, nested arrays, object map of\n * flags, or falsy nodes to skip. Used by {@link cx}, {@link cva}, and typical `className` helpers.\n *\n * @example\n * ```ts\n * const value: ClassValue = ['btn', false && 'hidden', { active: true }];\n * ```\n */\nexport type { ClassValue } from 'clsx';\n\n/**\n * Injects a stylesheet by appending a `<link rel=\"stylesheet\">` to `document.head`.\n * Resolves when the sheet fires `load`; rejects on `error` (e.g. 404 or network failure).\n *\n * **Id replacement:** if `attrubutes.id` is set, any existing element with that `id` is removed\n * first, so repeated calls with the same `id` replace the previous link (useful for theme or\n * font URLs that change).\n *\n * If `rel` is omitted in `attrubutes`, it defaults to `stylesheet`. Other attributes (`crossorigin`,\n * `media`, `data-*`, etc.) are set via `setAttribute` from the record entries.\n *\n * @param url - Stylesheet URL (`href`).\n * @param attrubutes - Optional HTML attributes for the `<link>` element (see `id` / `rel` behavior above).\n * @returns Promise that resolves to `undefined` on load, or rejects on load error.\n *\n * @example\n * ```ts\n * await loadCssFile('https://example.com/fonts.css', {\n *   id: 'app-fonts',\n *   crossOrigin: 'anonymous',\n * });\n * ```\n *\n * @example\n * ```ts\n * // Swap theme stylesheet without duplicate link tags\n * await loadCssFile('/themes/dark.css', { id: 'theme' });\n * await loadCssFile('/themes/light.css', { id: 'theme' });\n * ```\n */\nexport const loadCssFile = (url: string, attrubutes?: Record<string, any>) =>\n  new Promise((resolve, reject) => {\n    let link: Maybe<HTMLLinkElement>;\n\n    if (attrubutes?.id) {\n      link = document.getElementById(attrubutes.id) as HTMLLinkElement | null;\n\n      if (link) {\n        link.remove();\n      }\n    }\n\n    link = document.createElement('link');\n\n    const handleLoad = () => {\n      resolve(undefined);\n      link!.removeEventListener('load', handleLoad);\n      link!.removeEventListener('error', handleError);\n    };\n\n    const handleError = () => {\n      reject(undefined);\n      link!.removeEventListener('load', handleLoad);\n      link!.removeEventListener('error', handleError);\n    };\n\n    link.addEventListener('load', handleLoad);\n    link.addEventListener('error', handleError);\n\n    link.setAttribute('href', url);\n\n    if (!attrubutes?.rel) {\n      link.setAttribute('rel', 'stylesheet');\n    }\n\n    Object.entries(attrubutes || {}).forEach(([key, value]) => {\n      link.setAttribute(key, value);\n    });\n\n    document.head.appendChild(link);\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,IAAa,SAAS,IAAY,WAAW,OAAO,GAAG,KAAK,SAAS;;;;;;;;;;;;;;;;;;;;;AAsBrE,IAAa,MAAM,GAAG,UAAA,GAAA,eAAA,UAAA,GAAA,KAAA,SAA+C,GAAG,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8D9E,IAAa,QAAQ,GAAG,SAAgB;CACtC,MAAM,UAAA,GAAA,yBAAA,KAAgB,GAAG,KAAK;AAC9B,SAAQ,GAAG,eAAA,GAAA,eAAA,SAA6B,OAAO,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4D/D,IAAa,eAAe,KAAa,eACvC,IAAI,SAAS,SAAS,WAAW;CAC/B,IAAI;AAEJ,KAAI,YAAY,IAAI;AAClB,SAAO,SAAS,eAAe,WAAW,GAAG;AAE7C,MAAI,KACF,MAAK,QAAQ;;AAIjB,QAAO,SAAS,cAAc,OAAO;CAErC,MAAM,mBAAmB;AACvB,UAAQ,KAAA,EAAU;AAClB,OAAM,oBAAoB,QAAQ,WAAW;AAC7C,OAAM,oBAAoB,SAAS,YAAY;;CAGjD,MAAM,oBAAoB;AACxB,SAAO,KAAA,EAAU;AACjB,OAAM,oBAAoB,QAAQ,WAAW;AAC7C,OAAM,oBAAoB,SAAS,YAAY;;AAGjD,MAAK,iBAAiB,QAAQ,WAAW;AACzC,MAAK,iBAAiB,SAAS,YAAY;AAE3C,MAAK,aAAa,QAAQ,IAAI;AAE9B,KAAI,CAAC,YAAY,IACf,MAAK,aAAa,OAAO,aAAa;AAGxC,QAAO,QAAQ,cAAc,EAAE,CAAC,CAAC,SAAS,CAAC,KAAK,WAAW;AACzD,OAAK,aAAa,KAAK,MAAM;GAC7B;AAEF,UAAS,KAAK,YAAY,KAAK;EAC/B"}

package/css.d.ts

@@ -2,6 +2,23 @@ import clsx, { ClassValue } from 'clsx';
 export { ClassValue } from 'clsx';
 export { VariantProps } from 'class-variance-authority';
 
+/**
+ * ---header-docs-section---
+ * # yummies/css
+ *
+ * ## Description
+ *
+ * Styling utilities for React and plain DOM: `rem` conversion, `clsx` + `tailwind-merge` via `cx`,
+ * and a `cva` bridge for variant-driven class names. The goal is predictable class strings without
+ * Tailwind conflicts and with less boilerplate than concatenating strings by hand across components.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { cx, toRem } from "yummies/css";
+ * ```
+ */
+
 type ClassProp = {
     class?: ClassValue;
     className?: ClassValue;

package/css.js

@@ -3,6 +3,22 @@ import clsx from "clsx";
 import { twMerge } from "tailwind-merge";
 //#region src/css.ts
 /**
+* ---header-docs-section---
+* # yummies/css
+*
+* ## Description
+*
+* Styling utilities for React and plain DOM: `rem` conversion, `clsx` + `tailwind-merge` via `cx`,
+* and a `cva` bridge for variant-driven class names. The goal is predictable class strings without
+* Tailwind conflicts and with less boilerplate than concatenating strings by hand across components.
+*
+* ## Usage
+*
+* ```ts
+* import { cx, toRem } from "yummies/css";
+* ```
+*/
+/**
 * Converts a length in **pixels** to a CSS **`rem`** string (`"<number>rem"`).
 *
 * Use when authoring component styles in JS/TS where design tokens are in px but the stylesheet

package/css.js.map

@@ -1 +1 @@
-{"version":3,"file":"css.js","names":[],"sources":["../src/css.ts"],"sourcesContent":["import { cva as cvaLib } from 'class-variance-authority';\nimport clsx, { type ClassValue } from 'clsx';\nimport { twMerge } from 'tailwind-merge';\nimport type { Maybe } from 'yummies/types';\n\ntype ClassProp = {\n  class?: ClassValue;\n  className?: ClassValue;\n};\n\ntype StringToBoolean<T> = T extends 'true' | 'false' ? boolean : T;\n\n/**\n * Converts a length in **pixels** to a CSS **`rem`** string (`\"<number>rem\"`).\n *\n * Use when authoring component styles in JS/TS where design tokens are in px but the stylesheet\n * should scale with root font size (accessibility, user zoom). `remValue` is the assumed\n * `1rem` size in px (browser default is typically `16`).\n *\n * @param px - Pixel value to convert (not rounded; stringification keeps full float).\n * @param remValue - How many pixels one `rem` equals. Defaults to `16`.\n * @returns A string like `\"1.5rem\"` suitable for `style` or CSS-in-JS.\n *\n * @example\n * ```ts\n * const width = toRem(24); // '1.5rem' with default 16px root\n * ```\n *\n * @example\n * ```ts\n * // Custom root / design system where 1rem === 10px\n * const gap = toRem(20, 10); // '2rem'\n * ```\n */\nexport const toRem = (px: number, remValue = 16) => `${px / remValue}rem`;\n\n/**\n * Composes conditional class names like {@link https://github.com/lukeed/clsx | clsx}, then runs\n * the result through {@link https://github.com/dcastil/tailwind-merge | tailwind-merge} so\n * conflicting Tailwind utilities collapse to the last/intended one (e.g. two `padding-x` classes).\n *\n * Accepts the same argument shapes as `clsx`: strings, objects, arrays, falsy values to omit.\n *\n * @param args - Same as `clsx(...args)` — `ClassValue` rest parameters.\n * @returns A single merged class string, safe for `className` on DOM/React.\n *\n * @example\n * ```ts\n * cx('px-2 py-1 text-sm', 'px-4'); // 'py-1 text-sm px-4' — padding-x merged\n * ```\n *\n * @example\n * ```ts\n * cx('btn', { 'btn--active': isActive, 'btn--disabled': disabled }, className);\n * ```\n */\nexport const cx = (...args: Parameters<typeof clsx>) => twMerge(clsx(...args));\n\ntype ConfigSchema = Record<string, Record<string, ClassValue>>;\ntype ConfigVariants<T extends ConfigSchema> = {\n  [Variant in keyof T]?: StringToBoolean<keyof T[Variant]> | null | undefined;\n};\ntype ConfigVariantsMulti<T extends ConfigSchema> = {\n  [Variant in keyof T]?:\n    | StringToBoolean<keyof T[Variant]>\n    | StringToBoolean<keyof T[Variant]>[]\n    | undefined;\n};\ntype Config<T> = T extends ConfigSchema\n  ? {\n      variants?: T;\n      defaultVariants?: ConfigVariants<T>;\n      compoundVariants?: (T extends ConfigSchema\n        ? (ConfigVariants<T> | ConfigVariantsMulti<T>) & ClassProp\n        : ClassProp)[];\n    }\n  : never;\n\ntype Props<T> = T extends ConfigSchema\n  ? ConfigVariants<T> & ClassProp\n  : ClassProp;\n\n/**\n * {@link https://cva.style/docs | Class Variance Authority (cva)} with the same **tailwind-merge**\n * pass as {@link cx}: the class string produced by the variant function is merged so Tailwind\n * conflicts resolve predictably.\n *\n * API matches `cva` from `class-variance-authority`: optional `base` classes, `config` with\n * `variants`, `defaultVariants`, and `compoundVariants`. The returned function accepts variant\n * props plus optional `class` / `className` for one-off overrides.\n *\n * Use {@link VariantProps} with `typeof buttonVariants` (or similar) to type component props.\n *\n * @param base - Base `ClassValue`(s) always applied.\n * @param config - Variant schema and defaults (same shape as upstream `cva`).\n * @returns A function `(props?) => string` that resolves variant classes, merged with tw-merge.\n *\n * @example\n * ```ts\n * const button = cva('rounded font-medium', {\n *   variants: {\n *     tone: { primary: 'bg-blue-600 text-white', ghost: 'bg-transparent' },\n *     size: { sm: 'text-sm px-2', md: 'text-base px-4' },\n *   },\n *   defaultVariants: { tone: 'primary', size: 'md' },\n * });\n * button({ tone: 'ghost', className: 'ml-2' });\n * ```\n *\n * @example\n * ```ts\n * const card = cva('border p-4', {\n *   variants: { elevated: { true: 'shadow-lg', false: 'shadow-none' } },\n *   defaultVariants: { elevated: false },\n * });\n * card({ elevated: true });\n * ```\n */\nexport const cva = ((...args: any[]) => {\n  const schema = cvaLib(...args);\n  return (...inputArgs: any[]) => twMerge(schema(...inputArgs));\n}) as any as <T>(\n  base?: ClassValue,\n  config?: Config<T>,\n) => (props?: Props<T>) => string;\n\n/**\n * Utility type from `class-variance-authority`: infers the variant prop object from a `cva` instance.\n * Use it to type React (or other) components that forward variant props.\n *\n * @example\n * ```ts\n * const input = cva('border', { variants: { size: { sm: 'h-8', lg: 'h-12' } } });\n * type InputVariants = VariantProps<typeof input>;\n * // { size?: 'sm' | 'lg' | null }\n * ```\n */\nexport type { VariantProps } from 'class-variance-authority';\n\n/**\n * Re-export from `clsx`: a class name fragment — string, number, nested arrays, object map of\n * flags, or falsy nodes to skip. Used by {@link cx}, {@link cva}, and typical `className` helpers.\n *\n * @example\n * ```ts\n * const value: ClassValue = ['btn', false && 'hidden', { active: true }];\n * ```\n */\nexport type { ClassValue } from 'clsx';\n\n/**\n * Injects a stylesheet by appending a `<link rel=\"stylesheet\">` to `document.head`.\n * Resolves when the sheet fires `load`; rejects on `error` (e.g. 404 or network failure).\n *\n * **Id replacement:** if `attrubutes.id` is set, any existing element with that `id` is removed\n * first, so repeated calls with the same `id` replace the previous link (useful for theme or\n * font URLs that change).\n *\n * If `rel` is omitted in `attrubutes`, it defaults to `stylesheet`. Other attributes (`crossorigin`,\n * `media`, `data-*`, etc.) are set via `setAttribute` from the record entries.\n *\n * @param url - Stylesheet URL (`href`).\n * @param attrubutes - Optional HTML attributes for the `<link>` element (see `id` / `rel` behavior above).\n * @returns Promise that resolves to `undefined` on load, or rejects on load error.\n *\n * @example\n * ```ts\n * await loadCssFile('https://example.com/fonts.css', {\n *   id: 'app-fonts',\n *   crossOrigin: 'anonymous',\n * });\n * ```\n *\n * @example\n * ```ts\n * // Swap theme stylesheet without duplicate link tags\n * await loadCssFile('/themes/dark.css', { id: 'theme' });\n * await loadCssFile('/themes/light.css', { id: 'theme' });\n * ```\n */\nexport const loadCssFile = (url: string, attrubutes?: Record<string, any>) =>\n  new Promise((resolve, reject) => {\n    let link: Maybe<HTMLLinkElement>;\n\n    if (attrubutes?.id) {\n      link = document.getElementById(attrubutes.id) as HTMLLinkElement | null;\n\n      if (link) {\n        link.remove();\n      }\n    }\n\n    link = document.createElement('link');\n\n    const handleLoad = () => {\n      resolve(undefined);\n      link!.removeEventListener('load', handleLoad);\n      link!.removeEventListener('error', handleError);\n    };\n\n    const handleError = () => {\n      reject(undefined);\n      link!.removeEventListener('load', handleLoad);\n      link!.removeEventListener('error', handleError);\n    };\n\n    link.addEventListener('load', handleLoad);\n    link.addEventListener('error', handleError);\n\n    link.setAttribute('href', url);\n\n    if (!attrubutes?.rel) {\n      link.setAttribute('rel', 'stylesheet');\n    }\n\n    Object.entries(attrubutes || {}).forEach(([key, value]) => {\n      link.setAttribute(key, value);\n    });\n\n    document.head.appendChild(link);\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,IAAa,SAAS,IAAY,WAAW,OAAO,GAAG,KAAK,SAAS;;;;;;;;;;;;;;;;;;;;;AAsBrE,IAAa,MAAM,GAAG,SAAkC,QAAQ,KAAK,GAAG,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8D9E,IAAa,QAAQ,GAAG,SAAgB;CACtC,MAAM,SAAS,MAAO,GAAG,KAAK;AAC9B,SAAQ,GAAG,cAAqB,QAAQ,OAAO,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4D/D,IAAa,eAAe,KAAa,eACvC,IAAI,SAAS,SAAS,WAAW;CAC/B,IAAI;AAEJ,KAAI,YAAY,IAAI;AAClB,SAAO,SAAS,eAAe,WAAW,GAAG;AAE7C,MAAI,KACF,MAAK,QAAQ;;AAIjB,QAAO,SAAS,cAAc,OAAO;CAErC,MAAM,mBAAmB;AACvB,UAAQ,KAAA,EAAU;AAClB,OAAM,oBAAoB,QAAQ,WAAW;AAC7C,OAAM,oBAAoB,SAAS,YAAY;;CAGjD,MAAM,oBAAoB;AACxB,SAAO,KAAA,EAAU;AACjB,OAAM,oBAAoB,QAAQ,WAAW;AAC7C,OAAM,oBAAoB,SAAS,YAAY;;AAGjD,MAAK,iBAAiB,QAAQ,WAAW;AACzC,MAAK,iBAAiB,SAAS,YAAY;AAE3C,MAAK,aAAa,QAAQ,IAAI;AAE9B,KAAI,CAAC,YAAY,IACf,MAAK,aAAa,OAAO,aAAa;AAGxC,QAAO,QAAQ,cAAc,EAAE,CAAC,CAAC,SAAS,CAAC,KAAK,WAAW;AACzD,OAAK,aAAa,KAAK,MAAM;GAC7B;AAEF,UAAS,KAAK,YAAY,KAAK;EAC/B"}
+{"version":3,"file":"css.js","names":[],"sources":["../src/css.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/css\n *\n * ## Description\n *\n * Styling utilities for React and plain DOM: `rem` conversion, `clsx` + `tailwind-merge` via `cx`,\n * and a `cva` bridge for variant-driven class names. The goal is predictable class strings without\n * Tailwind conflicts and with less boilerplate than concatenating strings by hand across components.\n *\n * ## Usage\n *\n * ```ts\n * import { cx, toRem } from \"yummies/css\";\n * ```\n */\n\nimport { cva as cvaLib } from 'class-variance-authority';\nimport clsx, { type ClassValue } from 'clsx';\nimport { twMerge } from 'tailwind-merge';\nimport type { Maybe } from 'yummies/types';\n\ntype ClassProp = {\n  class?: ClassValue;\n  className?: ClassValue;\n};\n\ntype StringToBoolean<T> = T extends 'true' | 'false' ? boolean : T;\n\n/**\n * Converts a length in **pixels** to a CSS **`rem`** string (`\"<number>rem\"`).\n *\n * Use when authoring component styles in JS/TS where design tokens are in px but the stylesheet\n * should scale with root font size (accessibility, user zoom). `remValue` is the assumed\n * `1rem` size in px (browser default is typically `16`).\n *\n * @param px - Pixel value to convert (not rounded; stringification keeps full float).\n * @param remValue - How many pixels one `rem` equals. Defaults to `16`.\n * @returns A string like `\"1.5rem\"` suitable for `style` or CSS-in-JS.\n *\n * @example\n * ```ts\n * const width = toRem(24); // '1.5rem' with default 16px root\n * ```\n *\n * @example\n * ```ts\n * // Custom root / design system where 1rem === 10px\n * const gap = toRem(20, 10); // '2rem'\n * ```\n */\nexport const toRem = (px: number, remValue = 16) => `${px / remValue}rem`;\n\n/**\n * Composes conditional class names like {@link https://github.com/lukeed/clsx | clsx}, then runs\n * the result through {@link https://github.com/dcastil/tailwind-merge | tailwind-merge} so\n * conflicting Tailwind utilities collapse to the last/intended one (e.g. two `padding-x` classes).\n *\n * Accepts the same argument shapes as `clsx`: strings, objects, arrays, falsy values to omit.\n *\n * @param args - Same as `clsx(...args)` — `ClassValue` rest parameters.\n * @returns A single merged class string, safe for `className` on DOM/React.\n *\n * @example\n * ```ts\n * cx('px-2 py-1 text-sm', 'px-4'); // 'py-1 text-sm px-4' — padding-x merged\n * ```\n *\n * @example\n * ```ts\n * cx('btn', { 'btn--active': isActive, 'btn--disabled': disabled }, className);\n * ```\n */\nexport const cx = (...args: Parameters<typeof clsx>) => twMerge(clsx(...args));\n\ntype ConfigSchema = Record<string, Record<string, ClassValue>>;\ntype ConfigVariants<T extends ConfigSchema> = {\n  [Variant in keyof T]?: StringToBoolean<keyof T[Variant]> | null | undefined;\n};\ntype ConfigVariantsMulti<T extends ConfigSchema> = {\n  [Variant in keyof T]?:\n    | StringToBoolean<keyof T[Variant]>\n    | StringToBoolean<keyof T[Variant]>[]\n    | undefined;\n};\ntype Config<T> = T extends ConfigSchema\n  ? {\n      variants?: T;\n      defaultVariants?: ConfigVariants<T>;\n      compoundVariants?: (T extends ConfigSchema\n        ? (ConfigVariants<T> | ConfigVariantsMulti<T>) & ClassProp\n        : ClassProp)[];\n    }\n  : never;\n\ntype Props<T> = T extends ConfigSchema\n  ? ConfigVariants<T> & ClassProp\n  : ClassProp;\n\n/**\n * {@link https://cva.style/docs | Class Variance Authority (cva)} with the same **tailwind-merge**\n * pass as {@link cx}: the class string produced by the variant function is merged so Tailwind\n * conflicts resolve predictably.\n *\n * API matches `cva` from `class-variance-authority`: optional `base` classes, `config` with\n * `variants`, `defaultVariants`, and `compoundVariants`. The returned function accepts variant\n * props plus optional `class` / `className` for one-off overrides.\n *\n * Use {@link VariantProps} with `typeof buttonVariants` (or similar) to type component props.\n *\n * @param base - Base `ClassValue`(s) always applied.\n * @param config - Variant schema and defaults (same shape as upstream `cva`).\n * @returns A function `(props?) => string` that resolves variant classes, merged with tw-merge.\n *\n * @example\n * ```ts\n * const button = cva('rounded font-medium', {\n *   variants: {\n *     tone: { primary: 'bg-blue-600 text-white', ghost: 'bg-transparent' },\n *     size: { sm: 'text-sm px-2', md: 'text-base px-4' },\n *   },\n *   defaultVariants: { tone: 'primary', size: 'md' },\n * });\n * button({ tone: 'ghost', className: 'ml-2' });\n * ```\n *\n * @example\n * ```ts\n * const card = cva('border p-4', {\n *   variants: { elevated: { true: 'shadow-lg', false: 'shadow-none' } },\n *   defaultVariants: { elevated: false },\n * });\n * card({ elevated: true });\n * ```\n */\nexport const cva = ((...args: any[]) => {\n  const schema = cvaLib(...args);\n  return (...inputArgs: any[]) => twMerge(schema(...inputArgs));\n}) as any as <T>(\n  base?: ClassValue,\n  config?: Config<T>,\n) => (props?: Props<T>) => string;\n\n/**\n * Utility type from `class-variance-authority`: infers the variant prop object from a `cva` instance.\n * Use it to type React (or other) components that forward variant props.\n *\n * @example\n * ```ts\n * const input = cva('border', { variants: { size: { sm: 'h-8', lg: 'h-12' } } });\n * type InputVariants = VariantProps<typeof input>;\n * // { size?: 'sm' | 'lg' | null }\n * ```\n */\nexport type { VariantProps } from 'class-variance-authority';\n\n/**\n * Re-export from `clsx`: a class name fragment — string, number, nested arrays, object map of\n * flags, or falsy nodes to skip. Used by {@link cx}, {@link cva}, and typical `className` helpers.\n *\n * @example\n * ```ts\n * const value: ClassValue = ['btn', false && 'hidden', { active: true }];\n * ```\n */\nexport type { ClassValue } from 'clsx';\n\n/**\n * Injects a stylesheet by appending a `<link rel=\"stylesheet\">` to `document.head`.\n * Resolves when the sheet fires `load`; rejects on `error` (e.g. 404 or network failure).\n *\n * **Id replacement:** if `attrubutes.id` is set, any existing element with that `id` is removed\n * first, so repeated calls with the same `id` replace the previous link (useful for theme or\n * font URLs that change).\n *\n * If `rel` is omitted in `attrubutes`, it defaults to `stylesheet`. Other attributes (`crossorigin`,\n * `media`, `data-*`, etc.) are set via `setAttribute` from the record entries.\n *\n * @param url - Stylesheet URL (`href`).\n * @param attrubutes - Optional HTML attributes for the `<link>` element (see `id` / `rel` behavior above).\n * @returns Promise that resolves to `undefined` on load, or rejects on load error.\n *\n * @example\n * ```ts\n * await loadCssFile('https://example.com/fonts.css', {\n *   id: 'app-fonts',\n *   crossOrigin: 'anonymous',\n * });\n * ```\n *\n * @example\n * ```ts\n * // Swap theme stylesheet without duplicate link tags\n * await loadCssFile('/themes/dark.css', { id: 'theme' });\n * await loadCssFile('/themes/light.css', { id: 'theme' });\n * ```\n */\nexport const loadCssFile = (url: string, attrubutes?: Record<string, any>) =>\n  new Promise((resolve, reject) => {\n    let link: Maybe<HTMLLinkElement>;\n\n    if (attrubutes?.id) {\n      link = document.getElementById(attrubutes.id) as HTMLLinkElement | null;\n\n      if (link) {\n        link.remove();\n      }\n    }\n\n    link = document.createElement('link');\n\n    const handleLoad = () => {\n      resolve(undefined);\n      link!.removeEventListener('load', handleLoad);\n      link!.removeEventListener('error', handleError);\n    };\n\n    const handleError = () => {\n      reject(undefined);\n      link!.removeEventListener('load', handleLoad);\n      link!.removeEventListener('error', handleError);\n    };\n\n    link.addEventListener('load', handleLoad);\n    link.addEventListener('error', handleError);\n\n    link.setAttribute('href', url);\n\n    if (!attrubutes?.rel) {\n      link.setAttribute('rel', 'stylesheet');\n    }\n\n    Object.entries(attrubutes || {}).forEach(([key, value]) => {\n      link.setAttribute(key, value);\n    });\n\n    document.head.appendChild(link);\n  });\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,IAAa,SAAS,IAAY,WAAW,OAAO,GAAG,KAAK,SAAS;;;;;;;;;;;;;;;;;;;;;AAsBrE,IAAa,MAAM,GAAG,SAAkC,QAAQ,KAAK,GAAG,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8D9E,IAAa,QAAQ,GAAG,SAAgB;CACtC,MAAM,SAAS,MAAO,GAAG,KAAK;AAC9B,SAAQ,GAAG,cAAqB,QAAQ,OAAO,GAAG,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4D/D,IAAa,eAAe,KAAa,eACvC,IAAI,SAAS,SAAS,WAAW;CAC/B,IAAI;AAEJ,KAAI,YAAY,IAAI;AAClB,SAAO,SAAS,eAAe,WAAW,GAAG;AAE7C,MAAI,KACF,MAAK,QAAQ;;AAIjB,QAAO,SAAS,cAAc,OAAO;CAErC,MAAM,mBAAmB;AACvB,UAAQ,KAAA,EAAU;AAClB,OAAM,oBAAoB,QAAQ,WAAW;AAC7C,OAAM,oBAAoB,SAAS,YAAY;;CAGjD,MAAM,oBAAoB;AACxB,SAAO,KAAA,EAAU;AACjB,OAAM,oBAAoB,QAAQ,WAAW;AAC7C,OAAM,oBAAoB,SAAS,YAAY;;AAGjD,MAAK,iBAAiB,QAAQ,WAAW;AACzC,MAAK,iBAAiB,SAAS,YAAY;AAE3C,MAAK,aAAa,QAAQ,IAAI;AAE9B,KAAI,CAAC,YAAY,IACf,MAAK,aAAa,OAAO,aAAa;AAGxC,QAAO,QAAQ,cAAc,EAAE,CAAC,CAAC,SAAS,CAAC,KAAK,WAAW;AACzD,OAAK,aAAa,KAAK,MAAM;GAC7B;AAEF,UAAS,KAAK,YAAY,KAAK;EAC/B"}

package/data.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"data.cjs","names":[],"sources":["../src/data.ts"],"sourcesContent":["import 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":";;;;;;;;;;AAUA,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"}
+{"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"}

package/data.d.ts

@@ -1,5 +1,23 @@
 import { Maybe } from 'yummies/types';
 
+/**
+ * ---header-docs-section---
+ * # yummies/data
+ *
+ * ## Description
+ *
+ * General-purpose data helpers: shallow equality, normalizing values to arrays, and recursive
+ * `flatMap`-style transforms. They complement `Array`/`Object` builtins when you need stable
+ * comparisons for memoization or small structural utilities without pulling a large lodash-style
+ * dependency into the bundle.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { isShallowEqual, toArray } from "yummies/data";
+ * ```
+ */
+
 /**
  * Performs a shallow comparison for arrays, plain objects, dates and regular expressions.
  *