yummies 7.11.0 → 7.13.0

package/id.js

@@ -1,26 +1,91 @@
 import { customAlphabet } from "nanoid";
-const DIGITS = "0123456789";
-const LATIN_CHARS = "abcdefghijklmnopqrstuvwxyz";
-const ALPHABET = `${LATIN_CHARS}${DIGITS}`;
-const generateId = customAlphabet(ALPHABET, 6);
-const generateShortId = customAlphabet(ALPHABET, 4);
-const generateNumericId = customAlphabet(DIGITS, 6);
-const generateNumericShortId = customAlphabet(DIGITS, 4);
-const createLinearNumericIdGenerator = (size = 9) => {
-  let lastCount = 0;
-  return () => {
-    return (lastCount++).toString().padStart(size, "0");
-  };
+//#region src/id.ts
+/**
+* ---header-docs-section---
+* # yummies/id
+*
+* ## Description
+*
+* Fast, URL-friendly identifiers based on **nanoid** with curated alphabets and lengths. Use for
+* client-generated keys, trace ids, or UI instance ids where UUID size is unnecessary. Collisions are
+* unlikely at these lengths but still assume server-side uniqueness for persisted entities.
+*
+* ## Usage
+*
+* ```ts
+* import { generateId } from "yummies/id";
+* ```
+*/
+var DIGITS = "0123456789";
+var ALPHABET = `abcdefghijklmnopqrstuvwxyz${DIGITS}`;
+/**
+* Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.
+* Length: 6.
+*/
+var generateId = customAlphabet(ALPHABET, 6);
+/**
+* Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.
+* Length: 4.
+*/
+var generateShortId = customAlphabet(ALPHABET, 4);
+/**
+* Uses the alphabet `0123456789`.
+* Length: 6.
+*/
+var generateNumericId = customAlphabet(DIGITS, 6);
+/**
+* Uses the alphabet `0123456789`.
+* Length: 4.
+*/
+var generateNumericShortId = customAlphabet(DIGITS, 4);
+/**
+* Creates a function that generates unique strings based on call order.
+*
+* @example
+* ```ts
+* generateLinearNumericId = createLinearNumericIdGenerator(6);
+* generateLinearNumericId() // '000000'
+* generateLinearNumericId() // '000001'
+* ...
+* generateLinearNumericId() // '999999'
+* generateLinearNumericId() // '1000000'
+* ...
+* generateLinearNumericId() // '9999999'
+* generateLinearNumericId() // '10000000'
+* ```
+*
+* @param size Minimum string length.
+* @returns {()=>string}
+*/
+var createLinearNumericIdGenerator = (size = 9) => {
+	let lastCount = 0;
+	return () => {
+		return (lastCount++).toString().padStart(size, "0");
+	};
 };
-const generateLinearNumericId = createLinearNumericIdGenerator();
-const generateStackBasedId = () => new Error().stack.split("\n").slice(1, 4).join("");
-export {
-  createLinearNumericIdGenerator,
-  generateId,
-  generateLinearNumericId,
-  generateNumericId,
-  generateNumericShortId,
-  generateShortId,
-  generateStackBasedId
-};
-//# sourceMappingURL=id.js.map
+/**
+*
+* @example
+* ```ts
+* generateLinearNumericId() // '000000000'
+* generateLinearNumericId() // '000000001'
+* ...
+* generateLinearNumericId() // '999999999'
+* generateLinearNumericId() // '1000000000'
+* ...
+* generateLinearNumericId() // '9999999999'
+* generateLinearNumericId() // '10000000000'
+* ```
+*
+*/
+var generateLinearNumericId = createLinearNumericIdGenerator();
+/**
+* Is not recommended to use.
+*
+* Generates execution stack based pseudo-id (just sliced string from error stack)
+*/
+var generateStackBasedId = () => (/* @__PURE__ */ new Error()).stack.split("\n").slice(1, 4).join("");
+//#endregion
+export { createLinearNumericIdGenerator, generateId, generateLinearNumericId, generateNumericId, generateNumericShortId, generateShortId, generateStackBasedId };
+
+//# sourceMappingURL=id.js.map

package/id.js.map

@@ -1 +1 @@
-{"version":3,"file":"id.js","sources":["../src/id.ts"],"sourcesContent":["import { customAlphabet } from 'nanoid';\n\nconst DIGITS = '0123456789';\nconst LATIN_CHARS = 'abcdefghijklmnopqrstuvwxyz';\n\nconst ALPHABET = `${LATIN_CHARS}${DIGITS}`;\n\n/**\n * Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.\n * Length: 6.\n */\nexport const generateId = customAlphabet(ALPHABET, 6);\n\n/**\n * Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.\n * Length: 4.\n */\nexport const generateShortId = customAlphabet(ALPHABET, 4);\n\n/**\n * Uses the alphabet `0123456789`.\n * Length: 6.\n */\nexport const generateNumericId = customAlphabet(DIGITS, 6);\n\n/**\n * Uses the alphabet `0123456789`.\n * Length: 4.\n */\nexport const generateNumericShortId = customAlphabet(DIGITS, 4);\n\n/**\n * Creates a function that generates unique strings based on call order.\n *\n * @example\n * ```ts\n * generateLinearNumericId = createLinearNumericIdGenerator(6);\n * generateLinearNumericId() // '000000'\n * generateLinearNumericId() // '000001'\n * ...\n * generateLinearNumericId() // '999999'\n * generateLinearNumericId() // '1000000'\n * ...\n * generateLinearNumericId() // '9999999'\n * generateLinearNumericId() // '10000000'\n * ```\n *\n * @param size Minimum string length.\n * @returns {()=>string}\n */\nexport const createLinearNumericIdGenerator = (size: number = 9) => {\n  let lastCount = 0;\n  return () => {\n    return (lastCount++).toString().padStart(size, '0');\n  };\n};\n\n/**\n *\n * @example\n * ```ts\n * generateLinearNumericId() // '000000000'\n * generateLinearNumericId() // '000000001'\n * ...\n * generateLinearNumericId() // '999999999'\n * generateLinearNumericId() // '1000000000'\n * ...\n * generateLinearNumericId() // '9999999999'\n * generateLinearNumericId() // '10000000000'\n * ```\n *\n */\nexport const generateLinearNumericId = createLinearNumericIdGenerator();\n\n/**\n * Is not recommended to use.\n *\n * Generates execution stack based pseudo-id (just sliced string from error stack)\n */\nexport const generateStackBasedId = () =>\n  new Error().stack!.split('\\n').slice(1, 4).join('');\n"],"names":[],"mappings":";AAEA,MAAM,SAAS;AACf,MAAM,cAAc;AAEpB,MAAM,WAAW,GAAG,WAAW,GAAG,MAAM;AAMjC,MAAM,aAAa,eAAe,UAAU,CAAC;AAM7C,MAAM,kBAAkB,eAAe,UAAU,CAAC;AAMlD,MAAM,oBAAoB,eAAe,QAAQ,CAAC;AAMlD,MAAM,yBAAyB,eAAe,QAAQ,CAAC;AAqBvD,MAAM,iCAAiC,CAAC,OAAe,MAAM;AAClE,MAAI,YAAY;AAChB,SAAO,MAAM;AACX,YAAQ,aAAa,SAAA,EAAW,SAAS,MAAM,GAAG;AAAA,EACpD;AACF;AAiBO,MAAM,0BAA0B,+BAAA;AAOhC,MAAM,uBAAuB,MAClC,IAAI,MAAA,EAAQ,MAAO,MAAM,IAAI,EAAE,MAAM,GAAG,CAAC,EAAE,KAAK,EAAE;"}
+{"version":3,"file":"id.js","names":[],"sources":["../src/id.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/id\n *\n * ## Description\n *\n * Fast, URL-friendly identifiers based on **nanoid** with curated alphabets and lengths. Use for\n * client-generated keys, trace ids, or UI instance ids where UUID size is unnecessary. Collisions are\n * unlikely at these lengths but still assume server-side uniqueness for persisted entities.\n *\n * ## Usage\n *\n * ```ts\n * import { generateId } from \"yummies/id\";\n * ```\n */\n\nimport { customAlphabet } from 'nanoid';\n\nconst DIGITS = '0123456789';\nconst LATIN_CHARS = 'abcdefghijklmnopqrstuvwxyz';\n\nconst ALPHABET = `${LATIN_CHARS}${DIGITS}`;\n\n/**\n * Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.\n * Length: 6.\n */\nexport const generateId = customAlphabet(ALPHABET, 6);\n\n/**\n * Uses the alphabet `abcdefghijklmnopqrstuvwxyz0123456789`.\n * Length: 4.\n */\nexport const generateShortId = customAlphabet(ALPHABET, 4);\n\n/**\n * Uses the alphabet `0123456789`.\n * Length: 6.\n */\nexport const generateNumericId = customAlphabet(DIGITS, 6);\n\n/**\n * Uses the alphabet `0123456789`.\n * Length: 4.\n */\nexport const generateNumericShortId = customAlphabet(DIGITS, 4);\n\n/**\n * Creates a function that generates unique strings based on call order.\n *\n * @example\n * ```ts\n * generateLinearNumericId = createLinearNumericIdGenerator(6);\n * generateLinearNumericId() // '000000'\n * generateLinearNumericId() // '000001'\n * ...\n * generateLinearNumericId() // '999999'\n * generateLinearNumericId() // '1000000'\n * ...\n * generateLinearNumericId() // '9999999'\n * generateLinearNumericId() // '10000000'\n * ```\n *\n * @param size Minimum string length.\n * @returns {()=>string}\n */\nexport const createLinearNumericIdGenerator = (size: number = 9) => {\n  let lastCount = 0;\n  return () => {\n    return (lastCount++).toString().padStart(size, '0');\n  };\n};\n\n/**\n *\n * @example\n * ```ts\n * generateLinearNumericId() // '000000000'\n * generateLinearNumericId() // '000000001'\n * ...\n * generateLinearNumericId() // '999999999'\n * generateLinearNumericId() // '1000000000'\n * ...\n * generateLinearNumericId() // '9999999999'\n * generateLinearNumericId() // '10000000000'\n * ```\n *\n */\nexport const generateLinearNumericId = createLinearNumericIdGenerator();\n\n/**\n * Is not recommended to use.\n *\n * Generates execution stack based pseudo-id (just sliced string from error stack)\n */\nexport const generateStackBasedId = () =>\n  new Error().stack!.split('\\n').slice(1, 4).join('');\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,IAAM,SAAS;AAGf,IAAM,WAAW,6BAAiB;;;;;AAMlC,IAAa,aAAa,eAAe,UAAU,EAAE;;;;;AAMrD,IAAa,kBAAkB,eAAe,UAAU,EAAE;;;;;AAM1D,IAAa,oBAAoB,eAAe,QAAQ,EAAE;;;;;AAM1D,IAAa,yBAAyB,eAAe,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;AAqB/D,IAAa,kCAAkC,OAAe,MAAM;CAClE,IAAI,YAAY;AAChB,cAAa;AACX,UAAQ,aAAa,UAAU,CAAC,SAAS,MAAM,IAAI;;;;;;;;;;;;;;;;;;AAmBvD,IAAa,0BAA0B,gCAAgC;;;;;;AAOvE,IAAa,8CACX,IAAI,OAAO,EAAC,MAAO,MAAM,KAAK,CAAC,MAAM,GAAG,EAAE,CAAC,KAAK,GAAG"}

package/imports.cjs

@@ -1,34 +1,62 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const async = require("yummies/async");
-const fetchLazyModule = async (fetchModule, attempts = 3, delay = 1e3) => {
-  const attemptsArray = Array.from({
-    length: attempts
-  }).fill(fetchModule);
-  let lastError = null;
-  for await (const attempt of attemptsArray) {
-    try {
-      if (lastError !== null) {
-        await async.sleep(delay);
-      }
-      return await attempt();
-    } catch (error) {
-      lastError = error;
-    }
-  }
-  throw lastError;
+require("./chunk-CVq3Gv4J.cjs");
+let yummies_async = require("yummies/async");
+//#region src/imports.ts
+/**
+* ---header-docs-section---
+* # yummies/imports
+*
+* ## Description
+*
+* Patterns for **dynamic `import()`**: retry with backoff, unpacking `{ default }` from mixed ESM
+* shapes, and typed helpers around lazy-loaded modules. Ideal for code-split routes, optional panels,
+* and resilient loading when the network or CDN flakes without freezing the whole app.
+*
+* ## Usage
+*
+* ```ts
+* import { fetchLazyModule } from "yummies/imports";
+* ```
+*/
+/**
+* Lazily loads a module with retry support.
+*
+* @example
+* ```ts
+* fetchLazyModule(() => import('./test.ts'), 3) // starts loading test.ts
+* // If loading test.ts fails, fetchLazyModule retries by calling fetchModule() again
+* // It retries as many times as specified by attempts (3 by default)
+* ```
+*/
+var fetchLazyModule = async (fetchModule, attempts = 3, delay = 1e3) => {
+	const attemptsArray = Array.from({ length: attempts }).fill(fetchModule);
+	let lastError = null;
+	for await (const attempt of attemptsArray) try {
+		if (lastError !== null) await (0, yummies_async.sleep)(delay);
+		return await attempt();
+	} catch (error) {
+		lastError = error;
+	}
+	throw lastError;
 };
-const unpackAsyncModule = async (maybeModule) => {
-  if (maybeModule instanceof Promise) {
-    const data = await maybeModule;
-    if (data.default) {
-      return data.default;
-    } else {
-      return data;
-    }
-  }
-  return maybeModule;
+/**
+* Resolves either a direct value or an asynchronously imported module and unwraps its `default` export.
+*
+* @example
+* ```ts
+* const component = await unpackAsyncModule(import('./Component.ts'));
+* ```
+*/
+var unpackAsyncModule = async (maybeModule) => {
+	if (maybeModule instanceof Promise) {
+		const data = await maybeModule;
+		if (data.default) return data.default;
+		else return data;
+	}
+	return maybeModule;
 };
+//#endregion
 exports.fetchLazyModule = fetchLazyModule;
 exports.unpackAsyncModule = unpackAsyncModule;
-//# sourceMappingURL=imports.cjs.map
+
+//# sourceMappingURL=imports.cjs.map

package/imports.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"imports.cjs","sources":["../src/imports.ts"],"sourcesContent":["import { sleep } from 'yummies/async';\n\n/**\n * Lazily loads a module with retry support.\n *\n * @example\n * ```ts\n * fetchLazyModule(() => import('./test.ts'), 3) // starts loading test.ts\n * // If loading test.ts fails, fetchLazyModule retries by calling fetchModule() again\n * // It retries as many times as specified by attempts (3 by default)\n * ```\n */\nexport const fetchLazyModule = async <T>(\n  fetchModule: () => Promise<T>,\n  attempts = 3,\n  delay = 1000,\n): Promise<T> => {\n  const attemptsArray = Array.from<typeof fetchModule>({\n    length: attempts,\n  }).fill(fetchModule);\n\n  let lastError: null | Error = null;\n\n  for await (const attempt of attemptsArray) {\n    try {\n      if (lastError !== null) {\n        await sleep(delay);\n      }\n      return await attempt();\n    } catch (error) {\n      lastError = error as Error;\n    }\n  }\n  throw lastError;\n};\n\nexport type PackedAsyncModule<T> = Promise<T | { default: T }>;\n\nexport const unpackAsyncModule = async <T>(\n  maybeModule: T | PackedAsyncModule<T>,\n): Promise<T> => {\n  if (maybeModule instanceof Promise) {\n    const data = (await maybeModule) as any;\n\n    if ((data as any).default) {\n      return (data as any).default;\n    } else {\n      return data;\n    }\n  }\n\n  return maybeModule;\n};\n"],"names":["sleep"],"mappings":";;;AAYO,MAAM,kBAAkB,OAC7B,aACA,WAAW,GACX,QAAQ,QACO;AACf,QAAM,gBAAgB,MAAM,KAAyB;AAAA,IACnD,QAAQ;AAAA,EAAA,CACT,EAAE,KAAK,WAAW;AAEnB,MAAI,YAA0B;AAE9B,mBAAiB,WAAW,eAAe;AACzC,QAAI;AACF,UAAI,cAAc,MAAM;AACtB,cAAMA,MAAAA,MAAM,KAAK;AAAA,MACnB;AACA,aAAO,MAAM,QAAA;AAAA,IACf,SAAS,OAAO;AACd,kBAAY;AAAA,IACd;AAAA,EACF;AACA,QAAM;AACR;AAIO,MAAM,oBAAoB,OAC/B,gBACe;AACf,MAAI,uBAAuB,SAAS;AAClC,UAAM,OAAQ,MAAM;AAEpB,QAAK,KAAa,SAAS;AACzB,aAAQ,KAAa;AAAA,IACvB,OAAO;AACL,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;;;"}
+{"version":3,"file":"imports.cjs","names":[],"sources":["../src/imports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/imports\n *\n * ## Description\n *\n * Patterns for **dynamic `import()`**: retry with backoff, unpacking `{ default }` from mixed ESM\n * shapes, and typed helpers around lazy-loaded modules. Ideal for code-split routes, optional panels,\n * and resilient loading when the network or CDN flakes without freezing the whole app.\n *\n * ## Usage\n *\n * ```ts\n * import { fetchLazyModule } from \"yummies/imports\";\n * ```\n */\n\nimport { sleep } from 'yummies/async';\n\n/**\n * Lazily loads a module with retry support.\n *\n * @example\n * ```ts\n * fetchLazyModule(() => import('./test.ts'), 3) // starts loading test.ts\n * // If loading test.ts fails, fetchLazyModule retries by calling fetchModule() again\n * // It retries as many times as specified by attempts (3 by default)\n * ```\n */\nexport const fetchLazyModule = async <T>(\n  fetchModule: () => Promise<T>,\n  attempts = 3,\n  delay = 1000,\n): Promise<T> => {\n  const attemptsArray = Array.from<typeof fetchModule>({\n    length: attempts,\n  }).fill(fetchModule);\n\n  let lastError: null | Error = null;\n\n  for await (const attempt of attemptsArray) {\n    try {\n      if (lastError !== null) {\n        await sleep(delay);\n      }\n      return await attempt();\n    } catch (error) {\n      lastError = error as Error;\n    }\n  }\n  throw lastError;\n};\n\nexport type PackedAsyncModule<T> = Promise<T | { default: T }>;\n\n/**\n * Resolves either a direct value or an asynchronously imported module and unwraps its `default` export.\n *\n * @example\n * ```ts\n * const component = await unpackAsyncModule(import('./Component.ts'));\n * ```\n */\nexport const unpackAsyncModule = async <T>(\n  maybeModule: T | PackedAsyncModule<T>,\n): Promise<T> => {\n  if (maybeModule instanceof Promise) {\n    const data = (await maybeModule) as any;\n\n    if ((data as any).default) {\n      return (data as any).default;\n    } else {\n      return data;\n    }\n  }\n\n  return maybeModule;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,kBAAkB,OAC7B,aACA,WAAW,GACX,QAAQ,QACO;CACf,MAAM,gBAAgB,MAAM,KAAyB,EACnD,QAAQ,UACT,CAAC,CAAC,KAAK,YAAY;CAEpB,IAAI,YAA0B;AAE9B,YAAW,MAAM,WAAW,cAC1B,KAAI;AACF,MAAI,cAAc,KAChB,QAAA,GAAA,cAAA,OAAY,MAAM;AAEpB,SAAO,MAAM,SAAS;UACf,OAAO;AACd,cAAY;;AAGhB,OAAM;;;;;;;;;;AAaR,IAAa,oBAAoB,OAC/B,gBACe;AACf,KAAI,uBAAuB,SAAS;EAClC,MAAM,OAAQ,MAAM;AAEpB,MAAK,KAAa,QAChB,QAAQ,KAAa;MAErB,QAAO;;AAIX,QAAO"}

package/imports.d.ts

@@ -1,3 +1,19 @@
+/**
+ * ---header-docs-section---
+ * # yummies/imports
+ *
+ * ## Description
+ *
+ * Patterns for **dynamic `import()`**: retry with backoff, unpacking `{ default }` from mixed ESM
+ * shapes, and typed helpers around lazy-loaded modules. Ideal for code-split routes, optional panels,
+ * and resilient loading when the network or CDN flakes without freezing the whole app.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { fetchLazyModule } from "yummies/imports";
+ * ```
+ */
 /**
  * Lazily loads a module with retry support.
  *
@@ -12,6 +28,14 @@ declare const fetchLazyModule: <T>(fetchModule: () => Promise<T>, attempts?: num
 type PackedAsyncModule<T> = Promise<T | {
     default: T;
 }>;
+/**
+ * Resolves either a direct value or an asynchronously imported module and unwraps its `default` export.
+ *
+ * @example
+ * ```ts
+ * const component = await unpackAsyncModule(import('./Component.ts'));
+ * ```
+ */
 declare const unpackAsyncModule: <T>(maybeModule: T | PackedAsyncModule<T>) => Promise<T>;
 
 export { fetchLazyModule, unpackAsyncModule };

package/imports.js

@@ -1,34 +1,59 @@
 import { sleep } from "yummies/async";
-const fetchLazyModule = async (fetchModule, attempts = 3, delay = 1e3) => {
-  const attemptsArray = Array.from({
-    length: attempts
-  }).fill(fetchModule);
-  let lastError = null;
-  for await (const attempt of attemptsArray) {
-    try {
-      if (lastError !== null) {
-        await sleep(delay);
-      }
-      return await attempt();
-    } catch (error) {
-      lastError = error;
-    }
-  }
-  throw lastError;
+//#region src/imports.ts
+/**
+* ---header-docs-section---
+* # yummies/imports
+*
+* ## Description
+*
+* Patterns for **dynamic `import()`**: retry with backoff, unpacking `{ default }` from mixed ESM
+* shapes, and typed helpers around lazy-loaded modules. Ideal for code-split routes, optional panels,
+* and resilient loading when the network or CDN flakes without freezing the whole app.
+*
+* ## Usage
+*
+* ```ts
+* import { fetchLazyModule } from "yummies/imports";
+* ```
+*/
+/**
+* Lazily loads a module with retry support.
+*
+* @example
+* ```ts
+* fetchLazyModule(() => import('./test.ts'), 3) // starts loading test.ts
+* // If loading test.ts fails, fetchLazyModule retries by calling fetchModule() again
+* // It retries as many times as specified by attempts (3 by default)
+* ```
+*/
+var fetchLazyModule = async (fetchModule, attempts = 3, delay = 1e3) => {
+	const attemptsArray = Array.from({ length: attempts }).fill(fetchModule);
+	let lastError = null;
+	for await (const attempt of attemptsArray) try {
+		if (lastError !== null) await sleep(delay);
+		return await attempt();
+	} catch (error) {
+		lastError = error;
+	}
+	throw lastError;
 };
-const unpackAsyncModule = async (maybeModule) => {
-  if (maybeModule instanceof Promise) {
-    const data = await maybeModule;
-    if (data.default) {
-      return data.default;
-    } else {
-      return data;
-    }
-  }
-  return maybeModule;
+/**
+* Resolves either a direct value or an asynchronously imported module and unwraps its `default` export.
+*
+* @example
+* ```ts
+* const component = await unpackAsyncModule(import('./Component.ts'));
+* ```
+*/
+var unpackAsyncModule = async (maybeModule) => {
+	if (maybeModule instanceof Promise) {
+		const data = await maybeModule;
+		if (data.default) return data.default;
+		else return data;
+	}
+	return maybeModule;
 };
-export {
-  fetchLazyModule,
-  unpackAsyncModule
-};
-//# sourceMappingURL=imports.js.map
+//#endregion
+export { fetchLazyModule, unpackAsyncModule };
+
+//# sourceMappingURL=imports.js.map

package/imports.js.map

@@ -1 +1 @@
-{"version":3,"file":"imports.js","sources":["../src/imports.ts"],"sourcesContent":["import { sleep } from 'yummies/async';\n\n/**\n * Lazily loads a module with retry support.\n *\n * @example\n * ```ts\n * fetchLazyModule(() => import('./test.ts'), 3) // starts loading test.ts\n * // If loading test.ts fails, fetchLazyModule retries by calling fetchModule() again\n * // It retries as many times as specified by attempts (3 by default)\n * ```\n */\nexport const fetchLazyModule = async <T>(\n  fetchModule: () => Promise<T>,\n  attempts = 3,\n  delay = 1000,\n): Promise<T> => {\n  const attemptsArray = Array.from<typeof fetchModule>({\n    length: attempts,\n  }).fill(fetchModule);\n\n  let lastError: null | Error = null;\n\n  for await (const attempt of attemptsArray) {\n    try {\n      if (lastError !== null) {\n        await sleep(delay);\n      }\n      return await attempt();\n    } catch (error) {\n      lastError = error as Error;\n    }\n  }\n  throw lastError;\n};\n\nexport type PackedAsyncModule<T> = Promise<T | { default: T }>;\n\nexport const unpackAsyncModule = async <T>(\n  maybeModule: T | PackedAsyncModule<T>,\n): Promise<T> => {\n  if (maybeModule instanceof Promise) {\n    const data = (await maybeModule) as any;\n\n    if ((data as any).default) {\n      return (data as any).default;\n    } else {\n      return data;\n    }\n  }\n\n  return maybeModule;\n};\n"],"names":[],"mappings":";AAYO,MAAM,kBAAkB,OAC7B,aACA,WAAW,GACX,QAAQ,QACO;AACf,QAAM,gBAAgB,MAAM,KAAyB;AAAA,IACnD,QAAQ;AAAA,EAAA,CACT,EAAE,KAAK,WAAW;AAEnB,MAAI,YAA0B;AAE9B,mBAAiB,WAAW,eAAe;AACzC,QAAI;AACF,UAAI,cAAc,MAAM;AACtB,cAAM,MAAM,KAAK;AAAA,MACnB;AACA,aAAO,MAAM,QAAA;AAAA,IACf,SAAS,OAAO;AACd,kBAAY;AAAA,IACd;AAAA,EACF;AACA,QAAM;AACR;AAIO,MAAM,oBAAoB,OAC/B,gBACe;AACf,MAAI,uBAAuB,SAAS;AAClC,UAAM,OAAQ,MAAM;AAEpB,QAAK,KAAa,SAAS;AACzB,aAAQ,KAAa;AAAA,IACvB,OAAO;AACL,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;"}
+{"version":3,"file":"imports.js","names":[],"sources":["../src/imports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/imports\n *\n * ## Description\n *\n * Patterns for **dynamic `import()`**: retry with backoff, unpacking `{ default }` from mixed ESM\n * shapes, and typed helpers around lazy-loaded modules. Ideal for code-split routes, optional panels,\n * and resilient loading when the network or CDN flakes without freezing the whole app.\n *\n * ## Usage\n *\n * ```ts\n * import { fetchLazyModule } from \"yummies/imports\";\n * ```\n */\n\nimport { sleep } from 'yummies/async';\n\n/**\n * Lazily loads a module with retry support.\n *\n * @example\n * ```ts\n * fetchLazyModule(() => import('./test.ts'), 3) // starts loading test.ts\n * // If loading test.ts fails, fetchLazyModule retries by calling fetchModule() again\n * // It retries as many times as specified by attempts (3 by default)\n * ```\n */\nexport const fetchLazyModule = async <T>(\n  fetchModule: () => Promise<T>,\n  attempts = 3,\n  delay = 1000,\n): Promise<T> => {\n  const attemptsArray = Array.from<typeof fetchModule>({\n    length: attempts,\n  }).fill(fetchModule);\n\n  let lastError: null | Error = null;\n\n  for await (const attempt of attemptsArray) {\n    try {\n      if (lastError !== null) {\n        await sleep(delay);\n      }\n      return await attempt();\n    } catch (error) {\n      lastError = error as Error;\n    }\n  }\n  throw lastError;\n};\n\nexport type PackedAsyncModule<T> = Promise<T | { default: T }>;\n\n/**\n * Resolves either a direct value or an asynchronously imported module and unwraps its `default` export.\n *\n * @example\n * ```ts\n * const component = await unpackAsyncModule(import('./Component.ts'));\n * ```\n */\nexport const unpackAsyncModule = async <T>(\n  maybeModule: T | PackedAsyncModule<T>,\n): Promise<T> => {\n  if (maybeModule instanceof Promise) {\n    const data = (await maybeModule) as any;\n\n    if ((data as any).default) {\n      return (data as any).default;\n    } else {\n      return data;\n    }\n  }\n\n  return maybeModule;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,kBAAkB,OAC7B,aACA,WAAW,GACX,QAAQ,QACO;CACf,MAAM,gBAAgB,MAAM,KAAyB,EACnD,QAAQ,UACT,CAAC,CAAC,KAAK,YAAY;CAEpB,IAAI,YAA0B;AAE9B,YAAW,MAAM,WAAW,cAC1B,KAAI;AACF,MAAI,cAAc,KAChB,OAAM,MAAM,MAAM;AAEpB,SAAO,MAAM,SAAS;UACf,OAAO;AACd,cAAY;;AAGhB,OAAM;;;;;;;;;;AAaR,IAAa,oBAAoB,OAC/B,gBACe;AACf,KAAI,uBAAuB,SAAS;EAClC,MAAM,OAAQ,MAAM;AAEpB,MAAK,KAAa,QAChB,QAAQ,KAAa;MAErB,QAAO;;AAIX,QAAO"}

package/math.cjs

@@ -1,15 +1,41 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/math.ts
+/**
+* Converts degrees to radians.
+*
+* @example
+* ```ts
+* degToRad(180); // Math.PI
+* ```
+*/
 function degToRad(deg) {
-  return deg * (Math.PI / 180);
+	return deg * (Math.PI / 180);
 }
+/**
+* Converts radians to degrees.
+*
+* @example
+* ```ts
+* radToDeg(Math.PI); // 180
+* ```
+*/
 function radToDeg(rad) {
-  return rad * (180 / Math.PI);
+	return rad * (180 / Math.PI);
 }
-const percentFrom = (value, from) => {
-  return (value ?? 0) / (from ?? 0) * 100 || 0;
+/**
+* Returns what percentage `value` is of `from`.
+* @example
+* ```ts
+* percentFrom(500, 2000) // 25
+* percentFrom(1000, 2000) // 50
+* ```
+*/
+var percentFrom = (value, from) => {
+	return (value ?? 0) / (from ?? 0) * 100 || 0;
 };
+//#endregion
 exports.degToRad = degToRad;
 exports.percentFrom = percentFrom;
 exports.radToDeg = radToDeg;
-//# sourceMappingURL=math.cjs.map
+
+//# sourceMappingURL=math.cjs.map

package/math.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"math.cjs","sources":["../src/math.ts"],"sourcesContent":["import type { Maybe } from 'yummies/types';\n\nexport function degToRad(deg: number) {\n  return deg * (Math.PI / 180);\n}\nexport function radToDeg(rad: number) {\n  return rad * (180 / Math.PI);\n}\n\n/**\n * Returns what percentage `value` is of `from`.\n * @example\n * ```ts\n * percentFrom(500, 2000) // 25\n * percentFrom(1000, 2000) // 50\n * ```\n */\nexport const percentFrom = (value: Maybe<number>, from: Maybe<number>) => {\n  return ((value ?? 0) / (from ?? 0)) * 100 || 0;\n};\n"],"names":[],"mappings":";;AAEO,SAAS,SAAS,KAAa;AACpC,SAAO,OAAO,KAAK,KAAK;AAC1B;AACO,SAAS,SAAS,KAAa;AACpC,SAAO,OAAO,MAAM,KAAK;AAC3B;AAUO,MAAM,cAAc,CAAC,OAAsB,SAAwB;AACxE,UAAS,SAAS,MAAM,QAAQ,KAAM,OAAO;AAC/C;;;;"}
+{"version":3,"file":"math.cjs","names":[],"sources":["../src/math.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/math\n *\n * ## Description\n *\n * Tiny math helpers: degree/radian conversion and nullable-safe percentage calculations. They wrap\n * common formulas so components do not repeat magic numbers or null checks when deriving layout or\n * charts from partially loaded data.\n *\n * ## Usage\n *\n * ```ts\n * import { degToRad, percentFrom } from \"yummies/math\";\n * ```\n */\n\nimport type { Maybe } from 'yummies/types';\n\n/**\n * Converts degrees to radians.\n *\n * @example\n * ```ts\n * degToRad(180); // Math.PI\n * ```\n */\nexport function degToRad(deg: number) {\n  return deg * (Math.PI / 180);\n}\n\n/**\n * Converts radians to degrees.\n *\n * @example\n * ```ts\n * radToDeg(Math.PI); // 180\n * ```\n */\nexport function radToDeg(rad: number) {\n  return rad * (180 / Math.PI);\n}\n\n/**\n * Returns what percentage `value` is of `from`.\n * @example\n * ```ts\n * percentFrom(500, 2000) // 25\n * percentFrom(1000, 2000) // 50\n * ```\n */\nexport const percentFrom = (value: Maybe<number>, from: Maybe<number>) => {\n  return ((value ?? 0) / (from ?? 0)) * 100 || 0;\n};\n"],"mappings":";;;;;;;;;;AA2BA,SAAgB,SAAS,KAAa;AACpC,QAAO,OAAO,KAAK,KAAK;;;;;;;;;;AAW1B,SAAgB,SAAS,KAAa;AACpC,QAAO,OAAO,MAAM,KAAK;;;;;;;;;;AAW3B,IAAa,eAAe,OAAsB,SAAwB;AACxE,SAAS,SAAS,MAAM,QAAQ,KAAM,OAAO"}

package/math.d.ts

@@ -1,6 +1,39 @@
 import { Maybe } from 'yummies/types';
 
+/**
+ * ---header-docs-section---
+ * # yummies/math
+ *
+ * ## Description
+ *
+ * Tiny math helpers: degree/radian conversion and nullable-safe percentage calculations. They wrap
+ * common formulas so components do not repeat magic numbers or null checks when deriving layout or
+ * charts from partially loaded data.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { degToRad, percentFrom } from "yummies/math";
+ * ```
+ */
+
+/**
+ * Converts degrees to radians.
+ *
+ * @example
+ * ```ts
+ * degToRad(180); // Math.PI
+ * ```
+ */
 declare function degToRad(deg: number): number;
+/**
+ * Converts radians to degrees.
+ *
+ * @example
+ * ```ts
+ * radToDeg(Math.PI); // 180
+ * ```
+ */
 declare function radToDeg(rad: number): number;
 /**
  * Returns what percentage `value` is of `from`.

package/math.js

@@ -1,15 +1,38 @@
+//#region src/math.ts
+/**
+* Converts degrees to radians.
+*
+* @example
+* ```ts
+* degToRad(180); // Math.PI
+* ```
+*/
 function degToRad(deg) {
-  return deg * (Math.PI / 180);
+	return deg * (Math.PI / 180);
 }
+/**
+* Converts radians to degrees.
+*
+* @example
+* ```ts
+* radToDeg(Math.PI); // 180
+* ```
+*/
 function radToDeg(rad) {
-  return rad * (180 / Math.PI);
+	return rad * (180 / Math.PI);
 }
-const percentFrom = (value, from) => {
-  return (value ?? 0) / (from ?? 0) * 100 || 0;
+/**
+* Returns what percentage `value` is of `from`.
+* @example
+* ```ts
+* percentFrom(500, 2000) // 25
+* percentFrom(1000, 2000) // 50
+* ```
+*/
+var percentFrom = (value, from) => {
+	return (value ?? 0) / (from ?? 0) * 100 || 0;
 };
-export {
-  degToRad,
-  percentFrom,
-  radToDeg
-};
-//# sourceMappingURL=math.js.map
+//#endregion
+export { degToRad, percentFrom, radToDeg };
+
+//# sourceMappingURL=math.js.map

package/math.js.map

@@ -1 +1 @@
-{"version":3,"file":"math.js","sources":["../src/math.ts"],"sourcesContent":["import type { Maybe } from 'yummies/types';\n\nexport function degToRad(deg: number) {\n  return deg * (Math.PI / 180);\n}\nexport function radToDeg(rad: number) {\n  return rad * (180 / Math.PI);\n}\n\n/**\n * Returns what percentage `value` is of `from`.\n * @example\n * ```ts\n * percentFrom(500, 2000) // 25\n * percentFrom(1000, 2000) // 50\n * ```\n */\nexport const percentFrom = (value: Maybe<number>, from: Maybe<number>) => {\n  return ((value ?? 0) / (from ?? 0)) * 100 || 0;\n};\n"],"names":[],"mappings":"AAEO,SAAS,SAAS,KAAa;AACpC,SAAO,OAAO,KAAK,KAAK;AAC1B;AACO,SAAS,SAAS,KAAa;AACpC,SAAO,OAAO,MAAM,KAAK;AAC3B;AAUO,MAAM,cAAc,CAAC,OAAsB,SAAwB;AACxE,UAAS,SAAS,MAAM,QAAQ,KAAM,OAAO;AAC/C;"}
+{"version":3,"file":"math.js","names":[],"sources":["../src/math.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/math\n *\n * ## Description\n *\n * Tiny math helpers: degree/radian conversion and nullable-safe percentage calculations. They wrap\n * common formulas so components do not repeat magic numbers or null checks when deriving layout or\n * charts from partially loaded data.\n *\n * ## Usage\n *\n * ```ts\n * import { degToRad, percentFrom } from \"yummies/math\";\n * ```\n */\n\nimport type { Maybe } from 'yummies/types';\n\n/**\n * Converts degrees to radians.\n *\n * @example\n * ```ts\n * degToRad(180); // Math.PI\n * ```\n */\nexport function degToRad(deg: number) {\n  return deg * (Math.PI / 180);\n}\n\n/**\n * Converts radians to degrees.\n *\n * @example\n * ```ts\n * radToDeg(Math.PI); // 180\n * ```\n */\nexport function radToDeg(rad: number) {\n  return rad * (180 / Math.PI);\n}\n\n/**\n * Returns what percentage `value` is of `from`.\n * @example\n * ```ts\n * percentFrom(500, 2000) // 25\n * percentFrom(1000, 2000) // 50\n * ```\n */\nexport const percentFrom = (value: Maybe<number>, from: Maybe<number>) => {\n  return ((value ?? 0) / (from ?? 0)) * 100 || 0;\n};\n"],"mappings":";;;;;;;;;AA2BA,SAAgB,SAAS,KAAa;AACpC,QAAO,OAAO,KAAK,KAAK;;;;;;;;;;AAW1B,SAAgB,SAAS,KAAa;AACpC,QAAO,OAAO,MAAM,KAAK;;;;;;;;;;AAW3B,IAAa,eAAe,OAAsB,SAAwB;AACxE,SAAS,SAAS,MAAM,QAAQ,KAAM,OAAO"}