@vielzeug/toolkit 1.1.3 → 2.1.0

package/dist/async/retry.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"retry.cjs","sources":["../../src/async/retry.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport { sleep } from './sleep';\n\n/**\n * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.\n *\n * @example\n * ```ts\n * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })\n *   .then(result => console.log(result))\n *   .catch(error => console.error(error));\n * ```\n *\n * @param fn - The asynchronous function to retry.\n * @param options - (optional) Options for retrying the function.\n * @param [options.times=3] - The number of retry attempts.\n * @param [options.delay=250] - The delay in milliseconds between retries.\n * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff).\n * @param [options.signal] - `AbortSignal` to allow canceling retries.\n *\n * @returns The result of the asynchronous function.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  {\n    times = 3,\n    delay = 250,\n    backoff = 1,\n    signal,\n  }: {\n    times?: number;\n    delay?: number;\n    backoff?: number | ((attempt: number, delay: number) => number);\n    signal?: AbortSignal;\n  } = {},\n): Promise<T> {\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= times; attempt++) {\n    if (signal?.aborted) {\n      Logit.warn(`retry() -> Aborted after ${attempt - 1} attempts`);\n      throw new Error('Retry aborted');\n    }\n\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt === times) throw err;\n\n      Logit.warn(`retry() -> ${err}, attempt ${attempt}/${times}, retrying in ${currentDelay}ms`);\n      if (currentDelay > 0) await sleep(currentDelay);\n\n      currentDelay = typeof backoff === 'function' ? backoff(attempt, currentDelay) : currentDelay * backoff;\n    }\n  }\n\n  throw new Error('Retry failed unexpectedly');\n}\n"],"names":["retry","fn","times","delay","backoff","signal","currentDelay","attempt","Logit","err","sleep"],"mappings":"oJAsBA,eAAsBA,EACpBC,EACA,CACE,MAAAC,EAAQ,EACR,MAAAC,EAAQ,IACR,QAAAC,EAAU,EACV,OAAAC,CACF,EAKI,GACQ,CACZ,IAAIC,EAAeH,EAEnB,QAASI,EAAU,EAAGA,GAAWL,EAAOK,IAAW,CACjD,GAAIF,GAAQ,QACVG,MAAAA,EAAAA,MAAM,KAAK,4BAA4BD,EAAU,CAAC,WAAW,EACvD,IAAI,MAAM,eAAe,EAGjC,GAAI,CACF,OAAO,MAAMN,EAAA,CACf,OAASQ,EAAK,CACZ,GAAIF,IAAYL,EAAO,MAAMO,EAE7BD,EAAAA,MAAM,KAAK,cAAcC,CAAG,aAAaF,CAAO,IAAIL,CAAK,iBAAiBI,CAAY,IAAI,EACtFA,EAAe,GAAG,MAAMI,EAAAA,MAAMJ,CAAY,EAE9CA,EAAe,OAAOF,GAAY,WAAaA,EAAQG,EAASD,CAAY,EAAIA,EAAeF,CACjG,CACF,CAEA,MAAM,IAAI,MAAM,2BAA2B,CAC7C"}
+{"version":3,"file":"retry.cjs","names":[],"sources":["../../src/async/retry.ts"],"sourcesContent":["import { sleep } from './sleep';\n\n/**\n * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.\n *\n * @example\n * ```ts\n * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })\n *   .then(result => console.log(result))\n *   .catch(error => console.error(error));\n * ```\n *\n * @param fn - The asynchronous function to retry.\n * @param options - (optional) Options for retrying the function.\n * @param [options.times=3] - Total number of attempts (including the first).\n * @param [options.delay=250] - The delay in milliseconds between retries. Ignored when `retryDelay` is provided.\n * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff). Ignored when `retryDelay` is provided.\n * @param [options.retryDelay] - Per-attempt delay function. `attempt` is 0-based (0 = waiting before the 2nd try). Supersedes `delay` and `backoff`.\n * @param [options.signal] - `AbortSignal` to cancel retries; throws the signal's `reason` on abort.\n * @param [options.shouldRetry] - Return `false` to stop retrying immediately for a specific error. `attempt` is 0-based failure count.\n *\n * @returns The result of the asynchronous function.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  {\n    backoff = 1,\n    delay = 250,\n    retryDelay,\n    shouldRetry,\n    signal,\n    times = 3,\n  }: {\n    backoff?: number | ((attempt: number, currentDelay: number) => number);\n    delay?: number;\n    /** Per-attempt delay override. `attempt` is 0-based (0 = before the 2nd try). Supersedes `delay` and `backoff`. */\n    retryDelay?: (attempt: number) => number;\n    /** Return `false` to stop retrying for a specific error. `attempt` is 0-based failure count. */\n    shouldRetry?: (error: unknown, attempt: number) => boolean;\n    signal?: AbortSignal;\n    times?: number;\n  } = {},\n): Promise<T> {\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= times; attempt++) {\n    if (signal?.aborted) throw signal.reason ?? new DOMException('Retry aborted', 'AbortError');\n\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt === times) throw err;\n\n      if (shouldRetry && !shouldRetry(err, attempt - 1)) throw err;\n\n      const ms = retryDelay ? retryDelay(attempt - 1) : currentDelay;\n\n      if (ms > 0) await sleep(ms);\n\n      if (!retryDelay) {\n        currentDelay = typeof backoff === 'function' ? backoff(attempt, currentDelay) : currentDelay * backoff;\n      }\n    }\n  }\n\n  throw new Error('Retry failed unexpectedly');\n}\n"],"mappings":"+BAuBA,eAAsB,EACpB,EACA,CACE,UAAU,EACV,QAAQ,IACR,aACA,cACA,SACA,QAAQ,GAUN,EAAE,CACM,CACZ,IAAI,EAAe,EAEnB,IAAK,IAAI,EAAU,EAAG,GAAW,EAAO,IAAW,CACjD,GAAI,GAAQ,QAAS,MAAM,EAAO,QAAU,IAAI,aAAa,gBAAiB,aAAa,CAE3F,GAAI,CACF,OAAO,MAAM,GAAI,OACV,EAAK,CAGZ,GAFI,IAAY,GAEZ,GAAe,CAAC,EAAY,EAAK,EAAU,EAAE,CAAE,MAAM,EAEzD,IAAM,EAAK,EAAa,EAAW,EAAU,EAAE,CAAG,EAE9C,EAAK,GAAG,MAAM,EAAA,MAAM,EAAG,CAEtB,IACH,EAAe,OAAO,GAAY,WAAa,EAAQ,EAAS,EAAa,CAAG,EAAe,IAKrG,MAAU,MAAM,4BAA4B"}

package/dist/async/retry.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.
+ *
+ * @example
+ * ```ts
+ * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })
+ *   .then(result => console.log(result))
+ *   .catch(error => console.error(error));
+ * ```
+ *
+ * @param fn - The asynchronous function to retry.
+ * @param options - (optional) Options for retrying the function.
+ * @param [options.times=3] - Total number of attempts (including the first).
+ * @param [options.delay=250] - The delay in milliseconds between retries. Ignored when `retryDelay` is provided.
+ * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff). Ignored when `retryDelay` is provided.
+ * @param [options.retryDelay] - Per-attempt delay function. `attempt` is 0-based (0 = waiting before the 2nd try). Supersedes `delay` and `backoff`.
+ * @param [options.signal] - `AbortSignal` to cancel retries; throws the signal's `reason` on abort.
+ * @param [options.shouldRetry] - Return `false` to stop retrying immediately for a specific error. `attempt` is 0-based failure count.
+ *
+ * @returns The result of the asynchronous function.
+ */
+export declare function retry<T>(fn: () => Promise<T>, { backoff, delay, retryDelay, shouldRetry, signal, times, }?: {
+    backoff?: number | ((attempt: number, currentDelay: number) => number);
+    delay?: number;
+    /** Per-attempt delay override. `attempt` is 0-based (0 = before the 2nd try). Supersedes `delay` and `backoff`. */
+    retryDelay?: (attempt: number) => number;
+    /** Return `false` to stop retrying for a specific error. `attempt` is 0-based failure count. */
+    shouldRetry?: (error: unknown, attempt: number) => boolean;
+    signal?: AbortSignal;
+    times?: number;
+}): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/async/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/async/retry.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,KAAK,CAAC,CAAC,EAC3B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,EACE,OAAW,EACX,KAAW,EACX,UAAU,EACV,WAAW,EACX,MAAM,EACN,KAAS,GACV,GAAE;IACD,OAAO,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IACvE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mHAAmH;IACnH,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,CAAC;IACzC,gGAAgG;IAChG,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAC3D,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CACX,GACL,OAAO,CAAC,CAAC,CAAC,CAwBZ"}

package/dist/async/retry.js

@@ -1,25 +1,20 @@
-import { Logit as n } from "../logit/dist/logit.js";
-import { sleep as w } from "./sleep.js";
-async function m(i, {
-  times: e = 3,
-  delay: y = 250,
-  backoff: o = 1,
-  signal: p
-} = {}) {
-  let r = y;
-  for (let t = 1; t <= e; t++) {
-    if (p?.aborted)
-      throw n.warn(`retry() -> Aborted after ${t - 1} attempts`), new Error("Retry aborted");
-    try {
-      return await i();
-    } catch (a) {
-      if (t === e) throw a;
-      n.warn(`retry() -> ${a}, attempt ${t}/${e}, retrying in ${r}ms`), r > 0 && await w(r), r = typeof o == "function" ? o(t, r) : r * o;
-    }
-  }
-  throw new Error("Retry failed unexpectedly");
+import { sleep as e } from "./sleep.js";
+//#region src/async/retry.ts
+async function t(t, { backoff: n = 1, delay: r = 250, retryDelay: i, shouldRetry: a, signal: o, times: s = 3 } = {}) {
+	let c = r;
+	for (let r = 1; r <= s; r++) {
+		if (o?.aborted) throw o.reason ?? new DOMException("Retry aborted", "AbortError");
+		try {
+			return await t();
+		} catch (t) {
+			if (r === s || a && !a(t, r - 1)) throw t;
+			let o = i ? i(r - 1) : c;
+			o > 0 && await e(o), i || (c = typeof n == "function" ? n(r, c) : c * n);
+		}
+	}
+	throw Error("Retry failed unexpectedly");
 }
-export {
-  m as retry
-};
-//# sourceMappingURL=retry.js.map
+//#endregion
+export { t as retry };
+
+//# sourceMappingURL=retry.js.map

package/dist/async/retry.js.map

@@ -1 +1 @@
-{"version":3,"file":"retry.js","sources":["../../src/async/retry.ts"],"sourcesContent":["import { Logit } from '@vielzeug/logit';\nimport { sleep } from './sleep';\n\n/**\n * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.\n *\n * @example\n * ```ts\n * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })\n *   .then(result => console.log(result))\n *   .catch(error => console.error(error));\n * ```\n *\n * @param fn - The asynchronous function to retry.\n * @param options - (optional) Options for retrying the function.\n * @param [options.times=3] - The number of retry attempts.\n * @param [options.delay=250] - The delay in milliseconds between retries.\n * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff).\n * @param [options.signal] - `AbortSignal` to allow canceling retries.\n *\n * @returns The result of the asynchronous function.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  {\n    times = 3,\n    delay = 250,\n    backoff = 1,\n    signal,\n  }: {\n    times?: number;\n    delay?: number;\n    backoff?: number | ((attempt: number, delay: number) => number);\n    signal?: AbortSignal;\n  } = {},\n): Promise<T> {\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= times; attempt++) {\n    if (signal?.aborted) {\n      Logit.warn(`retry() -> Aborted after ${attempt - 1} attempts`);\n      throw new Error('Retry aborted');\n    }\n\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt === times) throw err;\n\n      Logit.warn(`retry() -> ${err}, attempt ${attempt}/${times}, retrying in ${currentDelay}ms`);\n      if (currentDelay > 0) await sleep(currentDelay);\n\n      currentDelay = typeof backoff === 'function' ? backoff(attempt, currentDelay) : currentDelay * backoff;\n    }\n  }\n\n  throw new Error('Retry failed unexpectedly');\n}\n"],"names":["retry","fn","times","delay","backoff","signal","currentDelay","attempt","Logit","err","sleep"],"mappings":";;AAsBA,eAAsBA,EACpBC,GACA;AAAA,EACE,OAAAC,IAAQ;AAAA,EACR,OAAAC,IAAQ;AAAA,EACR,SAAAC,IAAU;AAAA,EACV,QAAAC;AACF,IAKI,IACQ;AACZ,MAAIC,IAAeH;AAEnB,WAASI,IAAU,GAAGA,KAAWL,GAAOK,KAAW;AACjD,QAAIF,GAAQ;AACVG,YAAAA,EAAM,KAAK,4BAA4BD,IAAU,CAAC,WAAW,GACvD,IAAI,MAAM,eAAe;AAGjC,QAAI;AACF,aAAO,MAAMN,EAAA;AAAA,IACf,SAASQ,GAAK;AACZ,UAAIF,MAAYL,EAAO,OAAMO;AAE7BD,MAAAA,EAAM,KAAK,cAAcC,CAAG,aAAaF,CAAO,IAAIL,CAAK,iBAAiBI,CAAY,IAAI,GACtFA,IAAe,KAAG,MAAMI,EAAMJ,CAAY,GAE9CA,IAAe,OAAOF,KAAY,aAAaA,EAAQG,GAASD,CAAY,IAAIA,IAAeF;AAAA,IACjG;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,2BAA2B;AAC7C;"}
+{"version":3,"file":"retry.js","names":[],"sources":["../../src/async/retry.ts"],"sourcesContent":["import { sleep } from './sleep';\n\n/**\n * Retries an asynchronous function a specified number of times with delay and optional exponential backoff.\n *\n * @example\n * ```ts\n * retry(() => fetchData(), { times: 3, delay: 1000, backoff: 2, signal: abortSignal })\n *   .then(result => console.log(result))\n *   .catch(error => console.error(error));\n * ```\n *\n * @param fn - The asynchronous function to retry.\n * @param options - (optional) Options for retrying the function.\n * @param [options.times=3] - Total number of attempts (including the first).\n * @param [options.delay=250] - The delay in milliseconds between retries. Ignored when `retryDelay` is provided.\n * @param [options.backoff=1] - Exponential backoff factor (default: 1 → no backoff). Ignored when `retryDelay` is provided.\n * @param [options.retryDelay] - Per-attempt delay function. `attempt` is 0-based (0 = waiting before the 2nd try). Supersedes `delay` and `backoff`.\n * @param [options.signal] - `AbortSignal` to cancel retries; throws the signal's `reason` on abort.\n * @param [options.shouldRetry] - Return `false` to stop retrying immediately for a specific error. `attempt` is 0-based failure count.\n *\n * @returns The result of the asynchronous function.\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  {\n    backoff = 1,\n    delay = 250,\n    retryDelay,\n    shouldRetry,\n    signal,\n    times = 3,\n  }: {\n    backoff?: number | ((attempt: number, currentDelay: number) => number);\n    delay?: number;\n    /** Per-attempt delay override. `attempt` is 0-based (0 = before the 2nd try). Supersedes `delay` and `backoff`. */\n    retryDelay?: (attempt: number) => number;\n    /** Return `false` to stop retrying for a specific error. `attempt` is 0-based failure count. */\n    shouldRetry?: (error: unknown, attempt: number) => boolean;\n    signal?: AbortSignal;\n    times?: number;\n  } = {},\n): Promise<T> {\n  let currentDelay = delay;\n\n  for (let attempt = 1; attempt <= times; attempt++) {\n    if (signal?.aborted) throw signal.reason ?? new DOMException('Retry aborted', 'AbortError');\n\n    try {\n      return await fn();\n    } catch (err) {\n      if (attempt === times) throw err;\n\n      if (shouldRetry && !shouldRetry(err, attempt - 1)) throw err;\n\n      const ms = retryDelay ? retryDelay(attempt - 1) : currentDelay;\n\n      if (ms > 0) await sleep(ms);\n\n      if (!retryDelay) {\n        currentDelay = typeof backoff === 'function' ? backoff(attempt, currentDelay) : currentDelay * backoff;\n      }\n    }\n  }\n\n  throw new Error('Retry failed unexpectedly');\n}\n"],"mappings":";;AAuBA,eAAsB,EACpB,GACA,EACE,aAAU,GACV,WAAQ,KACR,eACA,gBACA,WACA,WAAQ,MAUN,EAAE,EACM;CACZ,IAAI,IAAe;AAEnB,MAAK,IAAI,IAAU,GAAG,KAAW,GAAO,KAAW;AACjD,MAAI,GAAQ,QAAS,OAAM,EAAO,UAAU,IAAI,aAAa,iBAAiB,aAAa;AAE3F,MAAI;AACF,UAAO,MAAM,GAAI;WACV,GAAK;AAGZ,OAFI,MAAY,KAEZ,KAAe,CAAC,EAAY,GAAK,IAAU,EAAE,CAAE,OAAM;GAEzD,IAAM,IAAK,IAAa,EAAW,IAAU,EAAE,GAAG;AAIlD,GAFI,IAAK,KAAG,MAAM,EAAM,EAAG,EAEtB,MACH,IAAe,OAAO,KAAY,aAAa,EAAQ,GAAS,EAAa,GAAG,IAAe;;;AAKrG,OAAU,MAAM,4BAA4B"}

package/dist/async/scheduler.cjs

@@ -0,0 +1,2 @@
+function e(){return{postTask:(e,t)=>{let n=t?.delay??0,r=t?.signal;return new Promise((t,i)=>{if(r?.aborted){i(r.reason);return}let a=setTimeout(()=>{r?.removeEventListener(`abort`,o);try{t(e())}catch(e){i(e)}},n),o=()=>{clearTimeout(a),i(r.reason)};r?.addEventListener(`abort`,o,{once:!0})})}}}function t(){`scheduler`in globalThis||Object.defineProperty(globalThis,`scheduler`,{configurable:!0,value:e(),writable:!0})}var n=class{#e;constructor(){globalThis.scheduler===void 0&&t(),this.#e=globalThis.scheduler}postTask(e,t){return this.#e.postTask(e,t)}};exports.Scheduler=n,exports.polyfillScheduler=t;
+//# sourceMappingURL=scheduler.cjs.map

package/dist/async/scheduler.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.cjs","names":["#scheduler"],"sources":["../../src/async/scheduler.ts"],"sourcesContent":["/**\n * Scheduler.postTask helper for environments with or without native support.\n *\n * `new Scheduler()` guarantees that `globalThis.scheduler.postTask` exists,\n * using the native API when available and installing a small fallback otherwise.\n *\n * `polyfillScheduler()` remains available when explicit installation is preferred.\n *\n * The polyfill provides:\n * - Delayed execution via the `delay` option\n * - AbortSignal support for cancellation\n * - Priority hint support (though priorities are not enforced in the polyfill)\n *\n * @example\n * ```ts\n * import { Scheduler } from '@vielzeug/toolkit';\n *\n * const scheduler = new Scheduler();\n * await scheduler.postTask(() => console.log('hello'), { delay: 100 });\n * ```\n */\n\nexport type TaskPriority = 'background' | 'user-blocking' | 'user-visible';\n\nexport type SchedulerLike = {\n  postTask<T>(\n    callback: () => T | PromiseLike<T>,\n    options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n  ): Promise<T>;\n};\n\ntype SchedulerGlobal = { scheduler?: SchedulerLike };\n\nfunction createPolyfill(): SchedulerLike {\n  return {\n    postTask: <T>(\n      callback: () => T | PromiseLike<T>,\n      options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n    ) => {\n      const delay = options?.delay ?? 0;\n      const signal = options?.signal;\n\n      return new Promise<T>((resolve, reject) => {\n        if (signal?.aborted) {\n          reject(signal.reason);\n\n          return;\n        }\n\n        const id = setTimeout(() => {\n          signal?.removeEventListener('abort', onAbort);\n\n          try {\n            resolve(callback());\n          } catch (error) {\n            reject(error);\n          }\n        }, delay);\n\n        const onAbort = () => {\n          clearTimeout(id);\n          reject(signal!.reason);\n        };\n\n        signal?.addEventListener('abort', onAbort, { once: true });\n      });\n    },\n  };\n}\n\n/**\n * Install the scheduler polyfill if not natively supported.\n *\n * Safe to call multiple times - it only installs if not already present.\n */\nexport function polyfillScheduler(): void {\n  if ('scheduler' in globalThis) {\n    return;\n  }\n\n  Object.defineProperty(globalThis, 'scheduler', {\n    configurable: true,\n    value: createPolyfill(),\n    writable: true,\n  });\n}\n\n/**\n * Lightweight scheduler wrapper.\n *\n * Creating an instance guarantees that a scheduler exists (native or polyfilled)\n * and exposes a stable postTask API.\n */\nexport class Scheduler implements SchedulerLike {\n  #scheduler: SchedulerLike;\n\n  constructor() {\n    const g = globalThis as unknown as SchedulerGlobal;\n\n    if (g.scheduler === undefined) {\n      polyfillScheduler();\n    }\n\n    this.#scheduler = (globalThis as unknown as SchedulerGlobal).scheduler!;\n  }\n\n  postTask<T>(\n    callback: () => T | PromiseLike<T>,\n    options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n  ): Promise<T> {\n    return this.#scheduler.postTask(callback, options);\n  }\n}\n"],"mappings":"AAiCA,SAAS,GAAgC,CACvC,MAAO,CACL,UACE,EACA,IACG,CACH,IAAM,EAAQ,GAAS,OAAS,EAC1B,EAAS,GAAS,OAExB,OAAO,IAAI,SAAY,EAAS,IAAW,CACzC,GAAI,GAAQ,QAAS,CACnB,EAAO,EAAO,OAAO,CAErB,OAGF,IAAM,EAAK,eAAiB,CAC1B,GAAQ,oBAAoB,QAAS,EAAQ,CAE7C,GAAI,CACF,EAAQ,GAAU,CAAC,OACZ,EAAO,CACd,EAAO,EAAM,GAEd,EAAM,CAEH,MAAgB,CACpB,aAAa,EAAG,CAChB,EAAO,EAAQ,OAAO,EAGxB,GAAQ,iBAAiB,QAAS,EAAS,CAAE,KAAM,GAAM,CAAC,EAC1D,EAEL,CAQH,SAAgB,GAA0B,CACpC,cAAe,YAInB,OAAO,eAAe,WAAY,YAAa,CAC7C,aAAc,GACd,MAAO,GAAgB,CACvB,SAAU,GACX,CAAC,CASJ,IAAa,EAAb,KAAgD,CAC9C,GAEA,aAAc,CACF,WAEJ,YAAc,IAAA,IAClB,GAAmB,CAGrB,MAAA,EAAmB,WAA0C,UAG/D,SACE,EACA,EACY,CACZ,OAAO,MAAA,EAAgB,SAAS,EAAU,EAAQ"}

package/dist/async/scheduler.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Scheduler.postTask helper for environments with or without native support.
+ *
+ * `new Scheduler()` guarantees that `globalThis.scheduler.postTask` exists,
+ * using the native API when available and installing a small fallback otherwise.
+ *
+ * `polyfillScheduler()` remains available when explicit installation is preferred.
+ *
+ * The polyfill provides:
+ * - Delayed execution via the `delay` option
+ * - AbortSignal support for cancellation
+ * - Priority hint support (though priorities are not enforced in the polyfill)
+ *
+ * @example
+ * ```ts
+ * import { Scheduler } from '@vielzeug/toolkit';
+ *
+ * const scheduler = new Scheduler();
+ * await scheduler.postTask(() => console.log('hello'), { delay: 100 });
+ * ```
+ */
+export type TaskPriority = 'background' | 'user-blocking' | 'user-visible';
+export type SchedulerLike = {
+    postTask<T>(callback: () => T | PromiseLike<T>, options?: {
+        delay?: number;
+        priority?: TaskPriority;
+        signal?: AbortSignal;
+    }): Promise<T>;
+};
+/**
+ * Install the scheduler polyfill if not natively supported.
+ *
+ * Safe to call multiple times - it only installs if not already present.
+ */
+export declare function polyfillScheduler(): void;
+/**
+ * Lightweight scheduler wrapper.
+ *
+ * Creating an instance guarantees that a scheduler exists (native or polyfilled)
+ * and exposes a stable postTask API.
+ */
+export declare class Scheduler implements SchedulerLike {
+    #private;
+    constructor();
+    postTask<T>(callback: () => T | PromiseLike<T>, options?: {
+        delay?: number;
+        priority?: TaskPriority;
+        signal?: AbortSignal;
+    }): Promise<T>;
+}
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/async/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/async/scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,MAAM,YAAY,GAAG,YAAY,GAAG,eAAe,GAAG,cAAc,CAAC;AAE3E,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,CAAC,EACR,QAAQ,EAAE,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAClC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC1E,OAAO,CAAC,CAAC,CAAC,CAAC;CACf,CAAC;AAyCF;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAUxC;AAED;;;;;GAKG;AACH,qBAAa,SAAU,YAAW,aAAa;;;IAa7C,QAAQ,CAAC,CAAC,EACR,QAAQ,EAAE,MAAM,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,EAClC,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,YAAY,CAAC;QAAC,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAC1E,OAAO,CAAC,CAAC,CAAC;CAGd"}

package/dist/async/scheduler.js

@@ -0,0 +1,43 @@
+//#region src/async/scheduler.ts
+function e() {
+	return { postTask: (e, t) => {
+		let n = t?.delay ?? 0, r = t?.signal;
+		return new Promise((t, i) => {
+			if (r?.aborted) {
+				i(r.reason);
+				return;
+			}
+			let a = setTimeout(() => {
+				r?.removeEventListener("abort", o);
+				try {
+					t(e());
+				} catch (e) {
+					i(e);
+				}
+			}, n), o = () => {
+				clearTimeout(a), i(r.reason);
+			};
+			r?.addEventListener("abort", o, { once: !0 });
+		});
+	} };
+}
+function t() {
+	"scheduler" in globalThis || Object.defineProperty(globalThis, "scheduler", {
+		configurable: !0,
+		value: e(),
+		writable: !0
+	});
+}
+var n = class {
+	#e;
+	constructor() {
+		globalThis.scheduler === void 0 && t(), this.#e = globalThis.scheduler;
+	}
+	postTask(e, t) {
+		return this.#e.postTask(e, t);
+	}
+};
+//#endregion
+export { n as Scheduler, t as polyfillScheduler };
+
+//# sourceMappingURL=scheduler.js.map

package/dist/async/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","names":["#scheduler"],"sources":["../../src/async/scheduler.ts"],"sourcesContent":["/**\n * Scheduler.postTask helper for environments with or without native support.\n *\n * `new Scheduler()` guarantees that `globalThis.scheduler.postTask` exists,\n * using the native API when available and installing a small fallback otherwise.\n *\n * `polyfillScheduler()` remains available when explicit installation is preferred.\n *\n * The polyfill provides:\n * - Delayed execution via the `delay` option\n * - AbortSignal support for cancellation\n * - Priority hint support (though priorities are not enforced in the polyfill)\n *\n * @example\n * ```ts\n * import { Scheduler } from '@vielzeug/toolkit';\n *\n * const scheduler = new Scheduler();\n * await scheduler.postTask(() => console.log('hello'), { delay: 100 });\n * ```\n */\n\nexport type TaskPriority = 'background' | 'user-blocking' | 'user-visible';\n\nexport type SchedulerLike = {\n  postTask<T>(\n    callback: () => T | PromiseLike<T>,\n    options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n  ): Promise<T>;\n};\n\ntype SchedulerGlobal = { scheduler?: SchedulerLike };\n\nfunction createPolyfill(): SchedulerLike {\n  return {\n    postTask: <T>(\n      callback: () => T | PromiseLike<T>,\n      options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n    ) => {\n      const delay = options?.delay ?? 0;\n      const signal = options?.signal;\n\n      return new Promise<T>((resolve, reject) => {\n        if (signal?.aborted) {\n          reject(signal.reason);\n\n          return;\n        }\n\n        const id = setTimeout(() => {\n          signal?.removeEventListener('abort', onAbort);\n\n          try {\n            resolve(callback());\n          } catch (error) {\n            reject(error);\n          }\n        }, delay);\n\n        const onAbort = () => {\n          clearTimeout(id);\n          reject(signal!.reason);\n        };\n\n        signal?.addEventListener('abort', onAbort, { once: true });\n      });\n    },\n  };\n}\n\n/**\n * Install the scheduler polyfill if not natively supported.\n *\n * Safe to call multiple times - it only installs if not already present.\n */\nexport function polyfillScheduler(): void {\n  if ('scheduler' in globalThis) {\n    return;\n  }\n\n  Object.defineProperty(globalThis, 'scheduler', {\n    configurable: true,\n    value: createPolyfill(),\n    writable: true,\n  });\n}\n\n/**\n * Lightweight scheduler wrapper.\n *\n * Creating an instance guarantees that a scheduler exists (native or polyfilled)\n * and exposes a stable postTask API.\n */\nexport class Scheduler implements SchedulerLike {\n  #scheduler: SchedulerLike;\n\n  constructor() {\n    const g = globalThis as unknown as SchedulerGlobal;\n\n    if (g.scheduler === undefined) {\n      polyfillScheduler();\n    }\n\n    this.#scheduler = (globalThis as unknown as SchedulerGlobal).scheduler!;\n  }\n\n  postTask<T>(\n    callback: () => T | PromiseLike<T>,\n    options?: { delay?: number; priority?: TaskPriority; signal?: AbortSignal },\n  ): Promise<T> {\n    return this.#scheduler.postTask(callback, options);\n  }\n}\n"],"mappings":";AAiCA,SAAS,IAAgC;AACvC,QAAO,EACL,WACE,GACA,MACG;EACH,IAAM,IAAQ,GAAS,SAAS,GAC1B,IAAS,GAAS;AAExB,SAAO,IAAI,SAAY,GAAS,MAAW;AACzC,OAAI,GAAQ,SAAS;AACnB,MAAO,EAAO,OAAO;AAErB;;GAGF,IAAM,IAAK,iBAAiB;AAC1B,OAAQ,oBAAoB,SAAS,EAAQ;AAE7C,QAAI;AACF,OAAQ,GAAU,CAAC;aACZ,GAAO;AACd,OAAO,EAAM;;MAEd,EAAM,EAEH,UAAgB;AAEpB,IADA,aAAa,EAAG,EAChB,EAAO,EAAQ,OAAO;;AAGxB,MAAQ,iBAAiB,SAAS,GAAS,EAAE,MAAM,IAAM,CAAC;IAC1D;IAEL;;AAQH,SAAgB,IAA0B;AACpC,gBAAe,cAInB,OAAO,eAAe,YAAY,aAAa;EAC7C,cAAc;EACd,OAAO,GAAgB;EACvB,UAAU;EACX,CAAC;;AASJ,IAAa,IAAb,MAAgD;CAC9C;CAEA,cAAc;AAOZ,EANU,WAEJ,cAAc,KAAA,KAClB,GAAmB,EAGrB,MAAA,IAAmB,WAA0C;;CAG/D,SACE,GACA,GACY;AACZ,SAAO,MAAA,EAAgB,SAAS,GAAU,EAAQ"}

package/dist/async/sleep.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("../function/assert.cjs");async function s(e){return n.assert(typeof e=="number"&&e>=0&&Number.isFinite(e),"Timeout must be a non-negative finite number",{args:{timeout:e},type:TypeError}),new Promise(r=>setTimeout(r,e))}exports.sleep=s;
-//# sourceMappingURL=sleep.cjs.map
+const e=require(`../function/assert.cjs`);async function t(t){return e.assert(typeof t==`number`&&t>=0&&Number.isFinite(t),`Timeout must be a non-negative finite number`,{args:{timeout:t},type:TypeError}),new Promise(e=>setTimeout(e,t))}exports.sleep=t;
+//# sourceMappingURL=sleep.cjs.map

package/dist/async/sleep.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"sleep.cjs","sources":["../../src/async/sleep.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates a Promise that resolves after a specified amount of time.\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n *\n * @returns A Promise that resolves after the specified time.\n *\n * @throws {TypeError} If timeout is not a non-negative number.\n */\nexport async function sleep(timeout: number): Promise<void> {\n  assert(\n    typeof timeout === 'number' && timeout >= 0 && Number.isFinite(timeout),\n    'Timeout must be a non-negative finite number',\n    { args: { timeout }, type: TypeError },\n  );\n  return new Promise((resolve) => setTimeout(resolve, timeout));\n}\n"],"names":["sleep","timeout","assert","resolve"],"mappings":"0HAgBA,eAAsBA,EAAMC,EAAgC,CAC1DC,OAAAA,EAAAA,OACE,OAAOD,GAAY,UAAYA,GAAW,GAAK,OAAO,SAASA,CAAO,EACtE,+CACA,CAAE,KAAM,CAAE,QAAAA,CAAA,EAAW,KAAM,SAAA,CAAU,EAEhC,IAAI,QAASE,GAAY,WAAWA,EAASF,CAAO,CAAC,CAC9D"}
+{"version":3,"file":"sleep.cjs","names":[],"sources":["../../src/async/sleep.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates a Promise that resolves after a specified amount of time.\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n *\n * @returns A Promise that resolves after the specified time.\n *\n * @throws {TypeError} If timeout is not a non-negative number.\n */\nexport async function sleep(timeout: number): Promise<void> {\n  assert(\n    typeof timeout === 'number' && timeout >= 0 && Number.isFinite(timeout),\n    'Timeout must be a non-negative finite number',\n    { args: { timeout }, type: TypeError },\n  );\n\n  return new Promise((resolve) => setTimeout(resolve, timeout));\n}\n"],"mappings":"0CAgBA,eAAsB,EAAM,EAAgC,CAO1D,OANA,EAAA,OACE,OAAO,GAAY,UAAY,GAAW,GAAK,OAAO,SAAS,EAAQ,CACvE,+CACA,CAAE,KAAM,CAAE,UAAS,CAAE,KAAM,UAAW,CACvC,CAEM,IAAI,QAAS,GAAY,WAAW,EAAS,EAAQ,CAAC"}

package/dist/async/sleep.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Creates a Promise that resolves after a specified amount of time.
+ *
+ * @example
+ * ```ts
+ * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second
+ * ```
+ *
+ * @param timeout - The number of milliseconds to wait before resolving the Promise.
+ *
+ * @returns A Promise that resolves after the specified time.
+ *
+ * @throws {TypeError} If timeout is not a non-negative number.
+ */
+export declare function sleep(timeout: number): Promise<void>;
+//# sourceMappingURL=sleep.d.ts.map

package/dist/async/sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../src/async/sleep.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,wBAAsB,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQ1D"}

package/dist/async/sleep.js

@@ -1,12 +1,12 @@
-import { assert as n } from "../function/assert.js";
-async function i(e) {
-  return n(
-    typeof e == "number" && e >= 0 && Number.isFinite(e),
-    "Timeout must be a non-negative finite number",
-    { args: { timeout: e }, type: TypeError }
-  ), new Promise((r) => setTimeout(r, e));
+import { assert as e } from "../function/assert.js";
+//#region src/async/sleep.ts
+async function t(t) {
+	return e(typeof t == "number" && t >= 0 && Number.isFinite(t), "Timeout must be a non-negative finite number", {
+		args: { timeout: t },
+		type: TypeError
+	}), new Promise((e) => setTimeout(e, t));
 }
-export {
-  i as sleep
-};
-//# sourceMappingURL=sleep.js.map
+//#endregion
+export { t as sleep };
+
+//# sourceMappingURL=sleep.js.map

package/dist/async/sleep.js.map

@@ -1 +1 @@
-{"version":3,"file":"sleep.js","sources":["../../src/async/sleep.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates a Promise that resolves after a specified amount of time.\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n *\n * @returns A Promise that resolves after the specified time.\n *\n * @throws {TypeError} If timeout is not a non-negative number.\n */\nexport async function sleep(timeout: number): Promise<void> {\n  assert(\n    typeof timeout === 'number' && timeout >= 0 && Number.isFinite(timeout),\n    'Timeout must be a non-negative finite number',\n    { args: { timeout }, type: TypeError },\n  );\n  return new Promise((resolve) => setTimeout(resolve, timeout));\n}\n"],"names":["sleep","timeout","assert","resolve"],"mappings":";AAgBA,eAAsBA,EAAMC,GAAgC;AAC1D,SAAAC;AAAA,IACE,OAAOD,KAAY,YAAYA,KAAW,KAAK,OAAO,SAASA,CAAO;AAAA,IACtE;AAAA,IACA,EAAE,MAAM,EAAE,SAAAA,EAAA,GAAW,MAAM,UAAA;AAAA,EAAU,GAEhC,IAAI,QAAQ,CAACE,MAAY,WAAWA,GAASF,CAAO,CAAC;AAC9D;"}
+{"version":3,"file":"sleep.js","names":[],"sources":["../../src/async/sleep.ts"],"sourcesContent":["import { assert } from '../function/assert';\n\n/**\n * Creates a Promise that resolves after a specified amount of time.\n *\n * @example\n * ```ts\n * sleep(1000).then(() => console.log('Hello, world!')); // logs 'Hello, world!' after 1 second\n * ```\n *\n * @param timeout - The number of milliseconds to wait before resolving the Promise.\n *\n * @returns A Promise that resolves after the specified time.\n *\n * @throws {TypeError} If timeout is not a non-negative number.\n */\nexport async function sleep(timeout: number): Promise<void> {\n  assert(\n    typeof timeout === 'number' && timeout >= 0 && Number.isFinite(timeout),\n    'Timeout must be a non-negative finite number',\n    { args: { timeout }, type: TypeError },\n  );\n\n  return new Promise((resolve) => setTimeout(resolve, timeout));\n}\n"],"mappings":";;AAgBA,eAAsB,EAAM,GAAgC;AAO1D,QANA,EACE,OAAO,KAAY,YAAY,KAAW,KAAK,OAAO,SAAS,EAAQ,EACvE,gDACA;EAAE,MAAM,EAAE,YAAS;EAAE,MAAM;EAAW,CACvC,EAEM,IAAI,SAAS,MAAY,WAAW,GAAS,EAAQ,CAAC"}

package/dist/async/waitFor.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});async function d(u,c={}){const{timeout:n=5e3,interval:l=100,signal:t}=c;if(t?.aborted)throw new DOMException("Aborted","AbortError");return new Promise((b,e)=>{const w=Date.now();let o=null;const r=()=>{o!==null&&(clearTimeout(o),o=null),t?.removeEventListener("abort",i)},i=()=>{r(),e(new DOMException("Aborted","AbortError"))},a=async()=>{try{if(t?.aborted){r(),e(new DOMException("Aborted","AbortError"));return}if(await u()){r(),b();return}if(Date.now()-w>=n){r(),e(new Error(`waitFor timed out after ${n}ms`));return}o=setTimeout(a,l)}catch(s){r(),e(s)}};t&&t.addEventListener("abort",i,{once:!0}),a()})}exports.waitFor=d;
-//# sourceMappingURL=waitFor.cjs.map
+async function e(e,t={}){let{interval:n=100,signal:r,timeout:i=5e3}=t,a=AbortSignal.timeout(i),o=r?AbortSignal.any([r,a]):a;return o.throwIfAborted(),new Promise((t,r)=>{let i=null,a=()=>{i!==null&&(clearTimeout(i),i=null),o.removeEventListener(`abort`,s)},s=()=>{a(),r(o.reason)},c=async()=>{try{if(o.aborted){a(),r(o.reason);return}if(await e()){a(),t();return}i=setTimeout(c,n)}catch(e){a(),r(e)}};o.addEventListener(`abort`,s,{once:!0}),c()})}exports.waitFor=e;
+//# sourceMappingURL=waitFor.cjs.map

package/dist/async/waitFor.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"waitFor.cjs","sources":["../../src/async/waitFor.ts"],"sourcesContent":["/**\n * Waits for a condition to become true by polling.\n * Useful for waiting for DOM elements, API states, or other conditions.\n *\n * @example\n * ```ts\n * // Wait for an element to appear\n * await waitFor(() => document.querySelector('#myElement') !== null);\n *\n * // Wait for API to be ready\n * await waitFor(\n *   async () => {\n *     const res = await fetch('/api/health');\n *     return res.ok;\n *   },\n *   { timeout: 30000, interval: 1000 }\n * );\n * ```\n *\n * @param condition - Function that returns true when condition is met\n * @param options - Configuration options\n * @param options.timeout - Maximum time to wait in ms (default: 5000)\n * @param options.interval - Polling interval in ms (default: 100)\n * @param options.signal - AbortSignal to cancel waiting\n * @returns Promise that resolves when condition becomes true\n * @throws {Error} If timeout is reached\n * @throws {DOMException} If aborted via signal\n */\nexport async function waitFor(\n  condition: () => boolean | Promise<boolean>,\n  options: {\n    timeout?: number;\n    interval?: number;\n    signal?: AbortSignal;\n  } = {},\n): Promise<void> {\n  const { timeout: timeoutMs = 5000, interval = 100, signal } = options;\n\n  if (signal?.aborted) {\n    throw new DOMException('Aborted', 'AbortError');\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const startTime = Date.now();\n    let timeoutId: ReturnType<typeof setTimeout> | null = null;\n    let intervalId: ReturnType<typeof setTimeout> | null = null;\n\n    const cleanup = () => {\n      if (timeoutId !== null) {\n        clearTimeout(timeoutId);\n        timeoutId = null;\n      }\n      if (intervalId !== null) {\n        clearTimeout(intervalId);\n        intervalId = null;\n      }\n      signal?.removeEventListener('abort', onAbort);\n    };\n\n    const onAbort = () => {\n      cleanup();\n      reject(new DOMException('Aborted', 'AbortError'));\n    };\n\n    const check = async () => {\n      try {\n        // Check if aborted\n        if (signal?.aborted) {\n          cleanup();\n          reject(new DOMException('Aborted', 'AbortError'));\n          return;\n        }\n\n        // Check condition\n        const result = await condition();\n\n        if (result) {\n          cleanup();\n          resolve();\n          return;\n        }\n\n        // Check timeout\n        if (Date.now() - startTime >= timeoutMs) {\n          cleanup();\n          reject(new Error(`waitFor timed out after ${timeoutMs}ms`));\n          return;\n        }\n\n        // Schedule next check\n        intervalId = setTimeout(check, interval);\n      } catch (error) {\n        // If the condition throws, clean up and reject\n        cleanup();\n        reject(error);\n      }\n    };\n\n    // Set up abort listener\n    if (signal) {\n      signal.addEventListener('abort', onAbort, { once: true });\n    }\n\n    // Start checking\n    check();\n  });\n}\n"],"names":["waitFor","condition","options","timeoutMs","interval","signal","resolve","reject","startTime","intervalId","cleanup","onAbort","check","error"],"mappings":"gFA4BA,eAAsBA,EACpBC,EACAC,EAII,GACW,CACf,KAAM,CAAE,QAASC,EAAY,IAAM,SAAAC,EAAW,IAAK,OAAAC,GAAWH,EAE9D,GAAIG,GAAQ,QACV,MAAM,IAAI,aAAa,UAAW,YAAY,EAGhD,OAAO,IAAI,QAAc,CAACC,EAASC,IAAW,CAC5C,MAAMC,EAAY,KAAK,IAAA,EAEvB,IAAIC,EAAmD,KAEvD,MAAMC,EAAU,IAAM,CAKhBD,IAAe,OACjB,aAAaA,CAAU,EACvBA,EAAa,MAEfJ,GAAQ,oBAAoB,QAASM,CAAO,CAC9C,EAEMA,EAAU,IAAM,CACpBD,EAAA,EACAH,EAAO,IAAI,aAAa,UAAW,YAAY,CAAC,CAClD,EAEMK,EAAQ,SAAY,CACxB,GAAI,CAEF,GAAIP,GAAQ,QAAS,CACnBK,EAAA,EACAH,EAAO,IAAI,aAAa,UAAW,YAAY,CAAC,EAChD,MACF,CAKA,GAFe,MAAMN,EAAA,EAET,CACVS,EAAA,EACAJ,EAAA,EACA,MACF,CAGA,GAAI,KAAK,MAAQE,GAAaL,EAAW,CACvCO,EAAA,EACAH,EAAO,IAAI,MAAM,2BAA2BJ,CAAS,IAAI,CAAC,EAC1D,MACF,CAGAM,EAAa,WAAWG,EAAOR,CAAQ,CACzC,OAASS,EAAO,CAEdH,EAAA,EACAH,EAAOM,CAAK,CACd,CACF,EAGIR,GACFA,EAAO,iBAAiB,QAASM,EAAS,CAAE,KAAM,GAAM,EAI1DC,EAAA,CACF,CAAC,CACH"}
+{"version":3,"file":"waitFor.cjs","names":[],"sources":["../../src/async/waitFor.ts"],"sourcesContent":["/**\n * Waits for a condition to become true by polling.\n * Useful for waiting for DOM elements, API states, or other conditions.\n *\n * @example\n * ```ts\n * // Wait for an element to appear\n * await waitFor(() => document.querySelector('#myElement') !== null);\n *\n * // Wait for API to be ready\n * await waitFor(\n *   async () => {\n *     const res = await fetch('/api/health');\n *     return res.ok;\n *   },\n *   { timeout: 30000, interval: 1000 }\n * );\n * ```\n *\n * @param condition - Function that returns true when condition is met\n * @param options - Configuration options\n * @param options.timeout - Maximum time to wait in ms (default: 5000)\n * @param options.interval - Polling interval in ms (default: 100)\n * @param options.signal - AbortSignal to cancel waiting\n * @returns Promise that resolves when condition becomes true\n * @throws {unknown} Rejects with the merged AbortSignal reason (timeout or abort)\n */\nexport async function waitFor(\n  condition: () => boolean | Promise<boolean>,\n  options: {\n    interval?: number;\n    signal?: AbortSignal;\n    timeout?: number;\n  } = {},\n): Promise<void> {\n  const { interval = 100, signal, timeout: timeoutMs = 5000 } = options;\n  const timeoutSignal = AbortSignal.timeout(timeoutMs);\n  const mergedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;\n\n  mergedSignal.throwIfAborted();\n\n  return new Promise<void>((resolve, reject) => {\n    let intervalId: ReturnType<typeof setTimeout> | null = null;\n\n    const cleanup = () => {\n      if (intervalId !== null) {\n        clearTimeout(intervalId);\n        intervalId = null;\n      }\n\n      mergedSignal.removeEventListener('abort', onAbort);\n    };\n\n    const onAbort = () => {\n      cleanup();\n      reject(mergedSignal.reason);\n    };\n\n    const check = async () => {\n      try {\n        if (mergedSignal.aborted) {\n          cleanup();\n          reject(mergedSignal.reason);\n\n          return;\n        }\n\n        const result = await condition();\n\n        if (result) {\n          cleanup();\n          resolve();\n\n          return;\n        }\n\n        intervalId = setTimeout(check, interval);\n      } catch (error) {\n        cleanup();\n        reject(error);\n      }\n    };\n\n    mergedSignal.addEventListener('abort', onAbort, { once: true });\n\n    // Start checking\n    check();\n  });\n}\n"],"mappings":"AA2BA,eAAsB,EACpB,EACA,EAII,EAAE,CACS,CACf,GAAM,CAAE,WAAW,IAAK,SAAQ,QAAS,EAAY,KAAS,EACxD,EAAgB,YAAY,QAAQ,EAAU,CAC9C,EAAe,EAAS,YAAY,IAAI,CAAC,EAAQ,EAAc,CAAC,CAAG,EAIzE,OAFA,EAAa,gBAAgB,CAEtB,IAAI,SAAe,EAAS,IAAW,CAC5C,IAAI,EAAmD,KAEjD,MAAgB,CAChB,IAAe,OACjB,aAAa,EAAW,CACxB,EAAa,MAGf,EAAa,oBAAoB,QAAS,EAAQ,EAG9C,MAAgB,CACpB,GAAS,CACT,EAAO,EAAa,OAAO,EAGvB,EAAQ,SAAY,CACxB,GAAI,CACF,GAAI,EAAa,QAAS,CACxB,GAAS,CACT,EAAO,EAAa,OAAO,CAE3B,OAKF,GAFe,MAAM,GAAW,CAEpB,CACV,GAAS,CACT,GAAS,CAET,OAGF,EAAa,WAAW,EAAO,EAAS,OACjC,EAAO,CACd,GAAS,CACT,EAAO,EAAM,GAIjB,EAAa,iBAAiB,QAAS,EAAS,CAAE,KAAM,GAAM,CAAC,CAG/D,GAAO,EACP"}

package/dist/async/waitFor.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Waits for a condition to become true by polling.
+ * Useful for waiting for DOM elements, API states, or other conditions.
+ *
+ * @example
+ * ```ts
+ * // Wait for an element to appear
+ * await waitFor(() => document.querySelector('#myElement') !== null);
+ *
+ * // Wait for API to be ready
+ * await waitFor(
+ *   async () => {
+ *     const res = await fetch('/api/health');
+ *     return res.ok;
+ *   },
+ *   { timeout: 30000, interval: 1000 }
+ * );
+ * ```
+ *
+ * @param condition - Function that returns true when condition is met
+ * @param options - Configuration options
+ * @param options.timeout - Maximum time to wait in ms (default: 5000)
+ * @param options.interval - Polling interval in ms (default: 100)
+ * @param options.signal - AbortSignal to cancel waiting
+ * @returns Promise that resolves when condition becomes true
+ * @throws {unknown} Rejects with the merged AbortSignal reason (timeout or abort)
+ */
+export declare function waitFor(condition: () => boolean | Promise<boolean>, options?: {
+    interval?: number;
+    signal?: AbortSignal;
+    timeout?: number;
+}): Promise<void>;
+//# sourceMappingURL=waitFor.d.ts.map

package/dist/async/waitFor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"waitFor.d.ts","sourceRoot":"","sources":["../../src/async/waitFor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,OAAO,CAC3B,SAAS,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EAC3C,OAAO,GAAE;IACP,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CACb,GACL,OAAO,CAAC,IAAI,CAAC,CAsDf"}

package/dist/async/waitFor.js

@@ -1,37 +1,30 @@
-async function d(u, c = {}) {
-  const { timeout: n = 5e3, interval: l = 100, signal: t } = c;
-  if (t?.aborted)
-    throw new DOMException("Aborted", "AbortError");
-  return new Promise((b, e) => {
-    const w = Date.now();
-    let o = null;
-    const r = () => {
-      o !== null && (clearTimeout(o), o = null), t?.removeEventListener("abort", i);
-    }, i = () => {
-      r(), e(new DOMException("Aborted", "AbortError"));
-    }, a = async () => {
-      try {
-        if (t?.aborted) {
-          r(), e(new DOMException("Aborted", "AbortError"));
-          return;
-        }
-        if (await u()) {
-          r(), b();
-          return;
-        }
-        if (Date.now() - w >= n) {
-          r(), e(new Error(`waitFor timed out after ${n}ms`));
-          return;
-        }
-        o = setTimeout(a, l);
-      } catch (s) {
-        r(), e(s);
-      }
-    };
-    t && t.addEventListener("abort", i, { once: !0 }), a();
-  });
+//#region src/async/waitFor.ts
+async function e(e, t = {}) {
+	let { interval: n = 100, signal: r, timeout: i = 5e3 } = t, a = AbortSignal.timeout(i), o = r ? AbortSignal.any([r, a]) : a;
+	return o.throwIfAborted(), new Promise((t, r) => {
+		let i = null, a = () => {
+			i !== null && (clearTimeout(i), i = null), o.removeEventListener("abort", s);
+		}, s = () => {
+			a(), r(o.reason);
+		}, c = async () => {
+			try {
+				if (o.aborted) {
+					a(), r(o.reason);
+					return;
+				}
+				if (await e()) {
+					a(), t();
+					return;
+				}
+				i = setTimeout(c, n);
+			} catch (e) {
+				a(), r(e);
+			}
+		};
+		o.addEventListener("abort", s, { once: !0 }), c();
+	});
 }
-export {
-  d as waitFor
-};
-//# sourceMappingURL=waitFor.js.map
+//#endregion
+export { e as waitFor };
+
+//# sourceMappingURL=waitFor.js.map

package/dist/async/waitFor.js.map

@@ -1 +1 @@
-{"version":3,"file":"waitFor.js","sources":["../../src/async/waitFor.ts"],"sourcesContent":["/**\n * Waits for a condition to become true by polling.\n * Useful for waiting for DOM elements, API states, or other conditions.\n *\n * @example\n * ```ts\n * // Wait for an element to appear\n * await waitFor(() => document.querySelector('#myElement') !== null);\n *\n * // Wait for API to be ready\n * await waitFor(\n *   async () => {\n *     const res = await fetch('/api/health');\n *     return res.ok;\n *   },\n *   { timeout: 30000, interval: 1000 }\n * );\n * ```\n *\n * @param condition - Function that returns true when condition is met\n * @param options - Configuration options\n * @param options.timeout - Maximum time to wait in ms (default: 5000)\n * @param options.interval - Polling interval in ms (default: 100)\n * @param options.signal - AbortSignal to cancel waiting\n * @returns Promise that resolves when condition becomes true\n * @throws {Error} If timeout is reached\n * @throws {DOMException} If aborted via signal\n */\nexport async function waitFor(\n  condition: () => boolean | Promise<boolean>,\n  options: {\n    timeout?: number;\n    interval?: number;\n    signal?: AbortSignal;\n  } = {},\n): Promise<void> {\n  const { timeout: timeoutMs = 5000, interval = 100, signal } = options;\n\n  if (signal?.aborted) {\n    throw new DOMException('Aborted', 'AbortError');\n  }\n\n  return new Promise<void>((resolve, reject) => {\n    const startTime = Date.now();\n    let timeoutId: ReturnType<typeof setTimeout> | null = null;\n    let intervalId: ReturnType<typeof setTimeout> | null = null;\n\n    const cleanup = () => {\n      if (timeoutId !== null) {\n        clearTimeout(timeoutId);\n        timeoutId = null;\n      }\n      if (intervalId !== null) {\n        clearTimeout(intervalId);\n        intervalId = null;\n      }\n      signal?.removeEventListener('abort', onAbort);\n    };\n\n    const onAbort = () => {\n      cleanup();\n      reject(new DOMException('Aborted', 'AbortError'));\n    };\n\n    const check = async () => {\n      try {\n        // Check if aborted\n        if (signal?.aborted) {\n          cleanup();\n          reject(new DOMException('Aborted', 'AbortError'));\n          return;\n        }\n\n        // Check condition\n        const result = await condition();\n\n        if (result) {\n          cleanup();\n          resolve();\n          return;\n        }\n\n        // Check timeout\n        if (Date.now() - startTime >= timeoutMs) {\n          cleanup();\n          reject(new Error(`waitFor timed out after ${timeoutMs}ms`));\n          return;\n        }\n\n        // Schedule next check\n        intervalId = setTimeout(check, interval);\n      } catch (error) {\n        // If the condition throws, clean up and reject\n        cleanup();\n        reject(error);\n      }\n    };\n\n    // Set up abort listener\n    if (signal) {\n      signal.addEventListener('abort', onAbort, { once: true });\n    }\n\n    // Start checking\n    check();\n  });\n}\n"],"names":["waitFor","condition","options","timeoutMs","interval","signal","resolve","reject","startTime","intervalId","cleanup","onAbort","check","error"],"mappings":"AA4BA,eAAsBA,EACpBC,GACAC,IAII,IACW;AACf,QAAM,EAAE,SAASC,IAAY,KAAM,UAAAC,IAAW,KAAK,QAAAC,MAAWH;AAE9D,MAAIG,GAAQ;AACV,UAAM,IAAI,aAAa,WAAW,YAAY;AAGhD,SAAO,IAAI,QAAc,CAACC,GAASC,MAAW;AAC5C,UAAMC,IAAY,KAAK,IAAA;AAEvB,QAAIC,IAAmD;AAEvD,UAAMC,IAAU,MAAM;AAKpB,MAAID,MAAe,SACjB,aAAaA,CAAU,GACvBA,IAAa,OAEfJ,GAAQ,oBAAoB,SAASM,CAAO;AAAA,IAC9C,GAEMA,IAAU,MAAM;AACpB,MAAAD,EAAA,GACAH,EAAO,IAAI,aAAa,WAAW,YAAY,CAAC;AAAA,IAClD,GAEMK,IAAQ,YAAY;AACxB,UAAI;AAEF,YAAIP,GAAQ,SAAS;AACnB,UAAAK,EAAA,GACAH,EAAO,IAAI,aAAa,WAAW,YAAY,CAAC;AAChD;AAAA,QACF;AAKA,YAFe,MAAMN,EAAA,GAET;AACV,UAAAS,EAAA,GACAJ,EAAA;AACA;AAAA,QACF;AAGA,YAAI,KAAK,QAAQE,KAAaL,GAAW;AACvC,UAAAO,EAAA,GACAH,EAAO,IAAI,MAAM,2BAA2BJ,CAAS,IAAI,CAAC;AAC1D;AAAA,QACF;AAGA,QAAAM,IAAa,WAAWG,GAAOR,CAAQ;AAAA,MACzC,SAASS,GAAO;AAEd,QAAAH,EAAA,GACAH,EAAOM,CAAK;AAAA,MACd;AAAA,IACF;AAGA,IAAIR,KACFA,EAAO,iBAAiB,SAASM,GAAS,EAAE,MAAM,IAAM,GAI1DC,EAAA;AAAA,EACF,CAAC;AACH;"}
+{"version":3,"file":"waitFor.js","names":[],"sources":["../../src/async/waitFor.ts"],"sourcesContent":["/**\n * Waits for a condition to become true by polling.\n * Useful for waiting for DOM elements, API states, or other conditions.\n *\n * @example\n * ```ts\n * // Wait for an element to appear\n * await waitFor(() => document.querySelector('#myElement') !== null);\n *\n * // Wait for API to be ready\n * await waitFor(\n *   async () => {\n *     const res = await fetch('/api/health');\n *     return res.ok;\n *   },\n *   { timeout: 30000, interval: 1000 }\n * );\n * ```\n *\n * @param condition - Function that returns true when condition is met\n * @param options - Configuration options\n * @param options.timeout - Maximum time to wait in ms (default: 5000)\n * @param options.interval - Polling interval in ms (default: 100)\n * @param options.signal - AbortSignal to cancel waiting\n * @returns Promise that resolves when condition becomes true\n * @throws {unknown} Rejects with the merged AbortSignal reason (timeout or abort)\n */\nexport async function waitFor(\n  condition: () => boolean | Promise<boolean>,\n  options: {\n    interval?: number;\n    signal?: AbortSignal;\n    timeout?: number;\n  } = {},\n): Promise<void> {\n  const { interval = 100, signal, timeout: timeoutMs = 5000 } = options;\n  const timeoutSignal = AbortSignal.timeout(timeoutMs);\n  const mergedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;\n\n  mergedSignal.throwIfAborted();\n\n  return new Promise<void>((resolve, reject) => {\n    let intervalId: ReturnType<typeof setTimeout> | null = null;\n\n    const cleanup = () => {\n      if (intervalId !== null) {\n        clearTimeout(intervalId);\n        intervalId = null;\n      }\n\n      mergedSignal.removeEventListener('abort', onAbort);\n    };\n\n    const onAbort = () => {\n      cleanup();\n      reject(mergedSignal.reason);\n    };\n\n    const check = async () => {\n      try {\n        if (mergedSignal.aborted) {\n          cleanup();\n          reject(mergedSignal.reason);\n\n          return;\n        }\n\n        const result = await condition();\n\n        if (result) {\n          cleanup();\n          resolve();\n\n          return;\n        }\n\n        intervalId = setTimeout(check, interval);\n      } catch (error) {\n        cleanup();\n        reject(error);\n      }\n    };\n\n    mergedSignal.addEventListener('abort', onAbort, { once: true });\n\n    // Start checking\n    check();\n  });\n}\n"],"mappings":";AA2BA,eAAsB,EACpB,GACA,IAII,EAAE,EACS;CACf,IAAM,EAAE,cAAW,KAAK,WAAQ,SAAS,IAAY,QAAS,GACxD,IAAgB,YAAY,QAAQ,EAAU,EAC9C,IAAe,IAAS,YAAY,IAAI,CAAC,GAAQ,EAAc,CAAC,GAAG;AAIzE,QAFA,EAAa,gBAAgB,EAEtB,IAAI,SAAe,GAAS,MAAW;EAC5C,IAAI,IAAmD,MAEjD,UAAgB;AAMpB,GALI,MAAe,SACjB,aAAa,EAAW,EACxB,IAAa,OAGf,EAAa,oBAAoB,SAAS,EAAQ;KAG9C,UAAgB;AAEpB,GADA,GAAS,EACT,EAAO,EAAa,OAAO;KAGvB,IAAQ,YAAY;AACxB,OAAI;AACF,QAAI,EAAa,SAAS;AAExB,KADA,GAAS,EACT,EAAO,EAAa,OAAO;AAE3B;;AAKF,QAFe,MAAM,GAAW,EAEpB;AAEV,KADA,GAAS,EACT,GAAS;AAET;;AAGF,QAAa,WAAW,GAAO,EAAS;YACjC,GAAO;AAEd,IADA,GAAS,EACT,EAAO,EAAM;;;AAOjB,EAHA,EAAa,iBAAiB,SAAS,GAAS,EAAE,MAAM,IAAM,CAAC,EAG/D,GAAO;GACP"}

package/dist/date/expires.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function u(e,i=7){const t=typeof e=="string"?new Date(e):e,r=t.getTime();if(Number.isNaN(r))return"UNKNOWN";if(t.getFullYear()>=9999)return"NEVER";const o=Date.now(),n=r-o;return n<=0?"EXPIRED":n<=i*24*60*60*1e3?"SOON":"LATER"}exports.expires=u;
-//# sourceMappingURL=expires.cjs.map
+function e(e,t=7){let n=typeof e==`string`?new Date(e):e,r=n.getTime();if(Number.isNaN(r))return`UNKNOWN`;if(n.getFullYear()>=9999)return`NEVER`;let i=r-Date.now();return i<=0?`EXPIRED`:i<=t*24*60*60*1e3?`SOON`:`LATER`}exports.expires=e;
+//# sourceMappingURL=expires.cjs.map

package/dist/date/expires.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"expires.cjs","sources":["../../src/date/expires.ts"],"sourcesContent":["// #region Expires\nexport type Expires = 'EXPIRED' | 'SOON' | 'LATER' | 'NEVER' | 'UNKNOWN';\n// #endregion Expires\n\n/**\n * Determines the expiry status of a given date.\n *\n * @param date - The date to check, as a string or Date object.\n * @param days - Number of days before expiry to be considered \"SOON\" (default: 7).\n * @returns\n *   - 'EXPIRED' if the date is in the past,\n *   - 'SOON' if the date is within the next `days`,\n *   - 'LATER' if the date is further in the future,\n *   - 'NEVER' if the year is >= 9999,\n *   - 'UNKNOWN' if the date is invalid.\n */\nexport function expires(date: string | Date, days = 7): Expires {\n  const target = typeof date === 'string' ? new Date(date) : date;\n  const targetTime = target.getTime();\n\n  if (Number.isNaN(targetTime)) return 'UNKNOWN';\n  if (target.getFullYear() >= 9999) return 'NEVER';\n\n  const now = Date.now();\n  const diff = targetTime - now;\n\n  if (diff <= 0) return 'EXPIRED';\n  if (diff <= days * 24 * 60 * 60 * 1000) return 'SOON';\n\n  return 'LATER';\n}\n"],"names":["expires","date","days","target","targetTime","now","diff"],"mappings":"gFAgBO,SAASA,EAAQC,EAAqBC,EAAO,EAAY,CAC9D,MAAMC,EAAS,OAAOF,GAAS,SAAW,IAAI,KAAKA,CAAI,EAAIA,EACrDG,EAAaD,EAAO,QAAA,EAE1B,GAAI,OAAO,MAAMC,CAAU,EAAG,MAAO,UACrC,GAAID,EAAO,eAAiB,KAAM,MAAO,QAEzC,MAAME,EAAM,KAAK,IAAA,EACXC,EAAOF,EAAaC,EAE1B,OAAIC,GAAQ,EAAU,UAClBA,GAAQJ,EAAO,GAAK,GAAK,GAAK,IAAa,OAExC,OACT"}
+{"version":3,"file":"expires.cjs","names":[],"sources":["../../src/date/expires.ts"],"sourcesContent":["// #region Expires\nexport type Expires = 'EXPIRED' | 'SOON' | 'LATER' | 'NEVER' | 'UNKNOWN';\n// #endregion Expires\n\n/**\n * Determines the expiry status of a given date.\n *\n * @param date - The date to check, as a string or Date object.\n * @param days - Number of days before expiry to be considered \"SOON\" (default: 7).\n * @returns\n *   - 'EXPIRED' if the date is in the past,\n *   - 'SOON' if the date is within the next `days`,\n *   - 'LATER' if the date is further in the future,\n *   - 'NEVER' if the year is >= 9999,\n *   - 'UNKNOWN' if the date is invalid.\n */\nexport function expires(date: string | Date, days = 7): Expires {\n  const target = typeof date === 'string' ? new Date(date) : date;\n  const targetTime = target.getTime();\n\n  if (Number.isNaN(targetTime)) return 'UNKNOWN';\n\n  if (target.getFullYear() >= 9999) return 'NEVER';\n\n  const now = Date.now();\n  const diff = targetTime - now;\n\n  if (diff <= 0) return 'EXPIRED';\n\n  if (diff <= days * 24 * 60 * 60 * 1000) return 'SOON';\n\n  return 'LATER';\n}\n"],"mappings":"AAgBA,SAAgB,EAAQ,EAAqB,EAAO,EAAY,CAC9D,IAAM,EAAS,OAAO,GAAS,SAAW,IAAI,KAAK,EAAK,CAAG,EACrD,EAAa,EAAO,SAAS,CAEnC,GAAI,OAAO,MAAM,EAAW,CAAE,MAAO,UAErC,GAAI,EAAO,aAAa,EAAI,KAAM,MAAO,QAGzC,IAAM,EAAO,EADD,KAAK,KAAK,CAOtB,OAJI,GAAQ,EAAU,UAElB,GAAQ,EAAO,GAAK,GAAK,GAAK,IAAa,OAExC"}

package/dist/date/expires.d.ts

@@ -0,0 +1,15 @@
+export type Expires = 'EXPIRED' | 'SOON' | 'LATER' | 'NEVER' | 'UNKNOWN';
+/**
+ * Determines the expiry status of a given date.
+ *
+ * @param date - The date to check, as a string or Date object.
+ * @param days - Number of days before expiry to be considered "SOON" (default: 7).
+ * @returns
+ *   - 'EXPIRED' if the date is in the past,
+ *   - 'SOON' if the date is within the next `days`,
+ *   - 'LATER' if the date is further in the future,
+ *   - 'NEVER' if the year is >= 9999,
+ *   - 'UNKNOWN' if the date is invalid.
+ */
+export declare function expires(date: string | Date, days?: number): Expires;
+//# sourceMappingURL=expires.d.ts.map

package/dist/date/expires.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expires.d.ts","sourceRoot":"","sources":["../../src/date/expires.ts"],"names":[],"mappings":"AACA,MAAM,MAAM,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;AAGzE;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,IAAI,SAAI,GAAG,OAAO,CAgB9D"}

package/dist/date/expires.js

@@ -1,11 +1,12 @@
-function f(e, i = 7) {
-  const t = typeof e == "string" ? new Date(e) : e, r = t.getTime();
-  if (Number.isNaN(r)) return "UNKNOWN";
-  if (t.getFullYear() >= 9999) return "NEVER";
-  const o = Date.now(), n = r - o;
-  return n <= 0 ? "EXPIRED" : n <= i * 24 * 60 * 60 * 1e3 ? "SOON" : "LATER";
+//#region src/date/expires.ts
+function e(e, t = 7) {
+	let n = typeof e == "string" ? new Date(e) : e, r = n.getTime();
+	if (Number.isNaN(r)) return "UNKNOWN";
+	if (n.getFullYear() >= 9999) return "NEVER";
+	let i = r - Date.now();
+	return i <= 0 ? "EXPIRED" : i <= t * 24 * 60 * 60 * 1e3 ? "SOON" : "LATER";
 }
-export {
-  f as expires
-};
-//# sourceMappingURL=expires.js.map
+//#endregion
+export { e as expires };
+
+//# sourceMappingURL=expires.js.map

package/dist/date/expires.js.map

@@ -1 +1 @@
-{"version":3,"file":"expires.js","sources":["../../src/date/expires.ts"],"sourcesContent":["// #region Expires\nexport type Expires = 'EXPIRED' | 'SOON' | 'LATER' | 'NEVER' | 'UNKNOWN';\n// #endregion Expires\n\n/**\n * Determines the expiry status of a given date.\n *\n * @param date - The date to check, as a string or Date object.\n * @param days - Number of days before expiry to be considered \"SOON\" (default: 7).\n * @returns\n *   - 'EXPIRED' if the date is in the past,\n *   - 'SOON' if the date is within the next `days`,\n *   - 'LATER' if the date is further in the future,\n *   - 'NEVER' if the year is >= 9999,\n *   - 'UNKNOWN' if the date is invalid.\n */\nexport function expires(date: string | Date, days = 7): Expires {\n  const target = typeof date === 'string' ? new Date(date) : date;\n  const targetTime = target.getTime();\n\n  if (Number.isNaN(targetTime)) return 'UNKNOWN';\n  if (target.getFullYear() >= 9999) return 'NEVER';\n\n  const now = Date.now();\n  const diff = targetTime - now;\n\n  if (diff <= 0) return 'EXPIRED';\n  if (diff <= days * 24 * 60 * 60 * 1000) return 'SOON';\n\n  return 'LATER';\n}\n"],"names":["expires","date","days","target","targetTime","now","diff"],"mappings":"AAgBO,SAASA,EAAQC,GAAqBC,IAAO,GAAY;AAC9D,QAAMC,IAAS,OAAOF,KAAS,WAAW,IAAI,KAAKA,CAAI,IAAIA,GACrDG,IAAaD,EAAO,QAAA;AAE1B,MAAI,OAAO,MAAMC,CAAU,EAAG,QAAO;AACrC,MAAID,EAAO,iBAAiB,KAAM,QAAO;AAEzC,QAAME,IAAM,KAAK,IAAA,GACXC,IAAOF,IAAaC;AAE1B,SAAIC,KAAQ,IAAU,YAClBA,KAAQJ,IAAO,KAAK,KAAK,KAAK,MAAa,SAExC;AACT;"}
+{"version":3,"file":"expires.js","names":[],"sources":["../../src/date/expires.ts"],"sourcesContent":["// #region Expires\nexport type Expires = 'EXPIRED' | 'SOON' | 'LATER' | 'NEVER' | 'UNKNOWN';\n// #endregion Expires\n\n/**\n * Determines the expiry status of a given date.\n *\n * @param date - The date to check, as a string or Date object.\n * @param days - Number of days before expiry to be considered \"SOON\" (default: 7).\n * @returns\n *   - 'EXPIRED' if the date is in the past,\n *   - 'SOON' if the date is within the next `days`,\n *   - 'LATER' if the date is further in the future,\n *   - 'NEVER' if the year is >= 9999,\n *   - 'UNKNOWN' if the date is invalid.\n */\nexport function expires(date: string | Date, days = 7): Expires {\n  const target = typeof date === 'string' ? new Date(date) : date;\n  const targetTime = target.getTime();\n\n  if (Number.isNaN(targetTime)) return 'UNKNOWN';\n\n  if (target.getFullYear() >= 9999) return 'NEVER';\n\n  const now = Date.now();\n  const diff = targetTime - now;\n\n  if (diff <= 0) return 'EXPIRED';\n\n  if (diff <= days * 24 * 60 * 60 * 1000) return 'SOON';\n\n  return 'LATER';\n}\n"],"mappings":";AAgBA,SAAgB,EAAQ,GAAqB,IAAO,GAAY;CAC9D,IAAM,IAAS,OAAO,KAAS,WAAW,IAAI,KAAK,EAAK,GAAG,GACrD,IAAa,EAAO,SAAS;AAEnC,KAAI,OAAO,MAAM,EAAW,CAAE,QAAO;AAErC,KAAI,EAAO,aAAa,IAAI,KAAM,QAAO;CAGzC,IAAM,IAAO,IADD,KAAK,KAAK;AAOtB,QAJI,KAAQ,IAAU,YAElB,KAAQ,IAAO,KAAK,KAAK,KAAK,MAAa,SAExC"}

package/dist/date/index.d.ts

@@ -0,0 +1,4 @@
+export * from './expires';
+export * from './interval';
+export * from './timeDiff';
+//# sourceMappingURL=index.d.ts.map

package/dist/date/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/date/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC"}

package/dist/date/interval.cjs

@@ -1,2 +1,2 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const l=require("../function/assert.cjs"),i=require("../typed/isDate.cjs");function w(r,c,{interval:e="D",steps:t=1,latest:a=!1}={}){const n=new Date(r),o=new Date(c);l.assert([i.isDate(n),i.isDate(o)],"Invalid date format. Use a valid Date object or ISO string.",{args:{end:c,start:r},type:TypeError});const D=[];let u=new Date(s(n,e,0));for(;u<=o;)D.push(u),u=new Date(s(u,e,t));return a&&D.length>0&&D[D.length-1]<o&&D.push(o),D}function s(r,c,e){const t=r.getFullYear(),a=r.getMonth(),n=r.getDate();switch(c){case"D":return new Date(Date.UTC(t,a,n+e));case"W":return new Date(Date.UTC(t,a,n+7*e));case"M":return new Date(Date.UTC(t,a+e,n));case"MS":return new Date(Date.UTC(t,a+e,1));case"ME":return new Date(Date.UTC(t,a+e+1,0));case"Y":return new Date(Date.UTC(t+e,a,n));case"YS":return new Date(Date.UTC(t+e,0,1));case"YE":return new Date(Date.UTC(t+e,11,31))}}exports.interval=w;
-//# sourceMappingURL=interval.cjs.map
+const e=require(`../function/assert.cjs`),t=require(`../typed/isDate.cjs`);function n(n,i,{interval:a=`day`,latest:o=!1,steps:s=1}={}){let c=new Date(n),l=new Date(i);e.assertAll([t.isDate(c),t.isDate(l)],`Invalid date format. Use a valid Date object or ISO string.`,{args:{end:i,start:n},type:TypeError});let u=[],d=new Date(r(c,a,0));for(;d<=l;)u.push(d),d=new Date(r(d,a,s));return o&&u.length>0&&u[u.length-1]<l&&u.push(l),u}function r(e,t,n){let r=e.getFullYear(),i=e.getMonth(),a=e.getDate();switch(t){case`day`:return new Date(Date.UTC(r,i,a+n));case`month`:return new Date(Date.UTC(r,i+n,a));case`monthEnd`:return new Date(Date.UTC(r,i+n+1,0));case`monthStart`:return new Date(Date.UTC(r,i+n,1));case`week`:return new Date(Date.UTC(r,i,a+7*n));case`year`:return new Date(Date.UTC(r+n,i,a));case`yearEnd`:return new Date(Date.UTC(r+n,11,31));case`yearStart`:return new Date(Date.UTC(r+n,0,1))}}exports.interval=n;
+//# sourceMappingURL=interval.cjs.map