yummies 7.10.0 → 7.12.0

package/async.js.map

@@ -1 +1 @@
-{"version":3,"file":"async.js","sources":["../src/async.ts"],"sourcesContent":["/**\n * Создает промис, который будет ждать указанное количество ms, чтобы выполниться\n *\n * @param ms значение в миллисекундах\n * @returns Promise\n */\nexport const sleep = (time: number = 0, signal?: AbortSignal) =>\n  new Promise((resolve, reject) => {\n    const timerId = setTimeout(resolve, time);\n    if (signal) {\n      signal.addEventListener(\n        'abort',\n        () => {\n          clearTimeout(timerId);\n          reject(signal.reason);\n        },\n        {\n          once: true,\n        },\n      );\n    }\n  });\n\n/**\n * Создает промис, который будет ждать указанное количество ms, чтобы выполниться\n *\n * @deprecated используй {sleep}\n * @param ms значение в миллисекундах\n * @returns Promise\n */\nexport const waitAsync = async (ms = 1000) =>\n  new Promise((resolve) => setTimeout(resolve, ms));\n\n/**\n * Создает вызов requestAnimationFrame, посылая туда фукнцию {quitFn}, если она возвращает true,\n * тогда повторно не будет создан вызов requestAnimationFrame, иначе будут создаваться повторно\n * вызовы requestAnimationFrame до тем пор, пока эта функция не вернёт true\n *\n * @param quitFn - сама фукнция которая исполнится в requestAnimationFrame\n * @param asMicrotask - дополнительно оборачивает RAF в queueMicrotask\n * @returns void\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\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\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"],"names":[],"mappings":"AAMO,MAAM,QAAQ,CAAC,OAAe,GAAG,WACtC,IAAI,QAAQ,CAAC,SAAS,WAAW;AAC/B,QAAM,UAAU,WAAW,SAAS,IAAI;AACxC,MAAI,QAAQ;AACV,WAAO;AAAA,MACL;AAAA,MACA,MAAM;AACJ,qBAAa,OAAO;AACpB,eAAO,OAAO,MAAM;AAAA,MACtB;AAAA,MACA;AAAA,QACE,MAAM;AAAA,MAAA;AAAA,IACR;AAAA,EAEJ;AACF,CAAC;AASI,MAAM,YAAY,OAAO,KAAK,QACnC,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,EAAE,CAAC;AAW3C,MAAM,aAAa,CACxB,cACA,gBACG;AACH,MAAI,eAAgB;AAEpB,QAAM,MAAM,MACV,sBAAsB,MAAM,WAAW,cAAc,WAAW,CAAC;AAEnE,MAAI,aAAa;AACf,mBAAe,GAAG;AAAA,EACpB,OAAO;AACL,QAAA;AAAA,EACF;AACF;AAEO,SAAS,oBACd,UACA,WACA,QACA;AACA,MAAI,gBAA+B;AAEnC,QAAM,cAAc,MAAM;AACxB,QAAI,iBAAiB,MAAM;AACzB;AAAA,IACF;AACA,iBAAa,aAAa;AAC1B,oBAAgB;AAAA,EAClB;AAEA,UAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,MAAM;AAE7D,kBAAgB,WAAW,MAAM;AAC/B,YAAQ,oBAAoB,SAAS,WAAW;AAChD,aAAA;AAAA,EACF,GAAG,SAAS;AACd;AAEO,SAAS,qBACd,UACA,WACA,QACA;AACA,MAAI,QAAuB;AAE3B,QAAM,cAAc,MAAM;AACxB,QAAI,SAAS,MAAM;AACjB;AAAA,IACF;AACA,kBAAc,KAAK;AACnB,YAAQ;AAAA,EACV;AAEA,UAAQ,iBAAiB,SAAS,aAAa,EAAE,MAAM,MAAM;AAE7D,UAAQ,YAAY,UAAU,SAAS;AACzC;"}
+{"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"}

package/chunk-CVq3Gv4J.cjs

@@ -0,0 +1,50 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__commonJSMin", {
+	enumerable: true,
+	get: function() {
+		return __commonJSMin;
+	}
+});
+Object.defineProperty(exports, "__exportAll", {
+	enumerable: true,
+	get: function() {
+		return __exportAll;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/chunk-YKewjYmz.js

@@ -0,0 +1,37 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+export { __toESM as i, __exportAll as n, __require as r, __commonJSMin as t };

package/common.cjs

@@ -1,12 +1,52 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const callFunction = (fn, ...args) => {
-  if (typeof fn === "function") {
-    return fn(...args);
-  }
-  return fn;
+//#region src/common.ts
+/**
+* Normalizes a {@link MaybeFn} — a value that may be either a plain `TValue` or a function
+* `(...args: TArgs) => TValue`. If `fn` is callable, it is invoked with `args` and the return
+* value is returned; otherwise `fn` is returned as-is (treated as the resolved value).
+*
+* Typical uses: config fields that accept a static value or a lazy/computed factory, theme
+* tokens, labels, or callbacks where the caller should not branch on `typeof fn` themselves.
+*
+* @template TValue - Result type when `fn` is not a function, or return type when it is.
+* @template TArgs - Tuple of argument types passed through when `fn` is invoked.
+*
+* @param fn - Either a `TValue` or a function producing `TValue` from `args`.
+* @param args - Arguments forwarded to `fn` only when `fn` is a function.
+* @returns The resolved `TValue`.
+*
+* @example
+* Plain value — returned unchanged (no call):
+* ```ts
+* const n = callFunction(42); // 42
+* const label = callFunction('Hello'); // 'Hello'
+* ```
+*
+* @example
+* Function — called with the given arguments:
+* ```ts
+* const sum = callFunction((a: number, b: number) => a + b, 2, 3); // 5
+* ```
+*
+* @example
+* Same API for “static or factory” props:
+* ```ts
+* type Title = MaybeFn<string, [locale: string]>;
+* const title: Title = (loc) => (loc === 'ru' ? 'Привет' : 'Hi');
+* const text = callFunction(title, 'ru'); // 'Привет'
+* const fixed = callFunction('Hi', 'ru'); // 'Hi' — args ignored
+* ```
+*/
+var callFunction = (fn, ...args) => {
+	if (typeof fn === "function") return fn(...args);
+	return fn;
 };
-const resolveFnValue = callFunction;
+/**
+* @deprecated use {callFunction}
+*/
+var resolveFnValue = callFunction;
+//#endregion
 exports.callFunction = callFunction;
 exports.resolveFnValue = resolveFnValue;
-//# sourceMappingURL=common.cjs.map
+
+//# sourceMappingURL=common.cjs.map

package/common.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"common.cjs","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 * Calls the provided function with the given arguments if it is a function;\n * otherwise, returns the value directly.\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"],"names":[],"mappings":";;AAWO,MAAM,eAAe,CAC1B,OACG,SACA;AACH,MAAI,OAAO,OAAO,YAAY;AAC5B,WAAQ,GAAW,GAAG,IAAI;AAAA,EAC5B;AAEA,SAAO;AACT;AAKO,MAAM,iBAAiB;;;"}
+{"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"}

package/common.d.ts

@@ -5,8 +5,41 @@ import { MaybeFn } from 'yummies/types';
  */
 type FnValue<TValue, TArgs extends any[] = []> = MaybeFn<TValue, TArgs>;
 /**
- * Calls the provided function with the given arguments if it is a function;
- * otherwise, returns the value directly.
+ * Normalizes a {@link MaybeFn} — a value that may be either a plain `TValue` or a function
+ * `(...args: TArgs) => TValue`. If `fn` is callable, it is invoked with `args` and the return
+ * value is returned; otherwise `fn` is returned as-is (treated as the resolved value).
+ *
+ * Typical uses: config fields that accept a static value or a lazy/computed factory, theme
+ * tokens, labels, or callbacks where the caller should not branch on `typeof fn` themselves.
+ *
+ * @template TValue - Result type when `fn` is not a function, or return type when it is.
+ * @template TArgs - Tuple of argument types passed through when `fn` is invoked.
+ *
+ * @param fn - Either a `TValue` or a function producing `TValue` from `args`.
+ * @param args - Arguments forwarded to `fn` only when `fn` is a function.
+ * @returns The resolved `TValue`.
+ *
+ * @example
+ * Plain value — returned unchanged (no call):
+ * ```ts
+ * const n = callFunction(42); // 42
+ * const label = callFunction('Hello'); // 'Hello'
+ * ```
+ *
+ * @example
+ * Function — called with the given arguments:
+ * ```ts
+ * const sum = callFunction((a: number, b: number) => a + b, 2, 3); // 5
+ * ```
+ *
+ * @example
+ * Same API for “static or factory” props:
+ * ```ts
+ * type Title = MaybeFn<string, [locale: string]>;
+ * const title: Title = (loc) => (loc === 'ru' ? 'Привет' : 'Hi');
+ * const text = callFunction(title, 'ru'); // 'Привет'
+ * const fixed = callFunction('Hi', 'ru'); // 'Hi' — args ignored
+ * ```
  */
 declare const callFunction: <TValue, TArgs extends any[] = []>(fn: MaybeFn<TValue, TArgs>, ...args: TArgs) => TValue;
 /**

package/common.js

@@ -1,12 +1,50 @@
-const callFunction = (fn, ...args) => {
-  if (typeof fn === "function") {
-    return fn(...args);
-  }
-  return fn;
+//#region src/common.ts
+/**
+* Normalizes a {@link MaybeFn} — a value that may be either a plain `TValue` or a function
+* `(...args: TArgs) => TValue`. If `fn` is callable, it is invoked with `args` and the return
+* value is returned; otherwise `fn` is returned as-is (treated as the resolved value).
+*
+* Typical uses: config fields that accept a static value or a lazy/computed factory, theme
+* tokens, labels, or callbacks where the caller should not branch on `typeof fn` themselves.
+*
+* @template TValue - Result type when `fn` is not a function, or return type when it is.
+* @template TArgs - Tuple of argument types passed through when `fn` is invoked.
+*
+* @param fn - Either a `TValue` or a function producing `TValue` from `args`.
+* @param args - Arguments forwarded to `fn` only when `fn` is a function.
+* @returns The resolved `TValue`.
+*
+* @example
+* Plain value — returned unchanged (no call):
+* ```ts
+* const n = callFunction(42); // 42
+* const label = callFunction('Hello'); // 'Hello'
+* ```
+*
+* @example
+* Function — called with the given arguments:
+* ```ts
+* const sum = callFunction((a: number, b: number) => a + b, 2, 3); // 5
+* ```
+*
+* @example
+* Same API for “static or factory” props:
+* ```ts
+* type Title = MaybeFn<string, [locale: string]>;
+* const title: Title = (loc) => (loc === 'ru' ? 'Привет' : 'Hi');
+* const text = callFunction(title, 'ru'); // 'Привет'
+* const fixed = callFunction('Hi', 'ru'); // 'Hi' — args ignored
+* ```
+*/
+var callFunction = (fn, ...args) => {
+	if (typeof fn === "function") return fn(...args);
+	return fn;
 };
-const resolveFnValue = callFunction;
-export {
-  callFunction,
-  resolveFnValue
-};
-//# sourceMappingURL=common.js.map
+/**
+* @deprecated use {callFunction}
+*/
+var resolveFnValue = callFunction;
+//#endregion
+export { callFunction, resolveFnValue };
+
+//# sourceMappingURL=common.js.map

package/common.js.map

@@ -1 +1 @@
-{"version":3,"file":"common.js","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 * Calls the provided function with the given arguments if it is a function;\n * otherwise, returns the value directly.\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"],"names":[],"mappings":"AAWO,MAAM,eAAe,CAC1B,OACG,SACA;AACH,MAAI,OAAO,OAAO,YAAY;AAC5B,WAAQ,GAAW,GAAG,IAAI;AAAA,EAC5B;AAEA,SAAO;AACT;AAKO,MAAM,iBAAiB;"}
+{"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"}