@ls-stack/utils 3.65.0 → 3.67.0

package/dist/testUtils.mjs

@@ -0,0 +1,310 @@
+import { a as isPlainObject } from "./typeGuards-B1mzA-Rz.mjs";
+import { o as isObject } from "./assertions-qMxfVhSu.mjs";
+import { arrayWithPrevAndIndex, filterAndMap } from "./arrayUtils.mjs";
+import { defer } from "./promiseUtils.mjs";
+import { i as clampMin } from "./mathUtils-BDP1lM_z.mjs";
+import { t as deepEqual } from "./deepEqual-C7EZEixx.mjs";
+import { deepReplaceValues } from "./deepReplaceValues.mjs";
+import { filterObjectOrArrayKeys } from "./filterObjectOrArrayKeys.mjs";
+import { omit, pick } from "./objUtils.mjs";
+import { yamlStringify } from "./yamlStringify.mjs";
+
+//#region src/testUtils.ts
+function createLoggerStore({ filterKeys: defaultFilterKeys, rejectKeys: defaultRejectKeys, splitLongLines: defaultSplitLongLines = true, maxLineLengthBeforeSplit: defaultMaxLineLengthBeforeSplit = 80, fromLastSnapshot: defaultFromLastSnapshot = false, arrays: defaultArrays = { firstNItems: 1 }, changesOnly: defaultChangesOnly = false, useEmojiForBooleans: defaultUseEmojiForBooleans = true } = {}) {
+	let logs = [];
+	let logsTime = [];
+	let startTime = Date.now();
+	let onNextLog = () => {};
+	function reset(keepLastRender = false) {
+		logs = keepLastRender ? [logs.at(-1)] : [];
+		logsTime = [];
+		startTime = Date.now();
+	}
+	function add(render) {
+		if (!isObject(render)) for (const [i, r] of render.entries()) {
+			logs.push({
+				i: i + 1,
+				...r
+			});
+			logsTime.push(Date.now() - startTime);
+		}
+		else {
+			logs.push(render);
+			logsTime.push(Date.now() - startTime);
+		}
+		onNextLog();
+		if (logs.length > 100) throw new Error("Too many logs");
+	}
+	function logsCount() {
+		return logs.filter((item) => !item._lastSnapshotMark).length;
+	}
+	async function waitNextLog(timeout = 50) {
+		return new Promise((resolve) => {
+			const timeoutId = setTimeout(() => {
+				throw new Error("Timeout");
+			}, timeout);
+			onNextLog = () => {
+				clearTimeout(timeoutId);
+				resolve();
+			};
+		});
+	}
+	function getSnapshot({ arrays = defaultArrays, changesOnly = defaultChangesOnly, filterKeys = defaultFilterKeys, rejectKeys = defaultRejectKeys, includeLastSnapshotEndMark = true, splitLongLines = defaultSplitLongLines, maxLineLengthBeforeSplit = defaultMaxLineLengthBeforeSplit, fromLastSnapshot = defaultFromLastSnapshot, useEmojiForBooleans = defaultUseEmojiForBooleans } = {}) {
+		let rendersToUse = logs;
+		if (changesOnly || filterKeys || rejectKeys) {
+			rendersToUse = [];
+			for (let { item, prev } of arrayWithPrevAndIndex(logs)) {
+				if (item._lastSnapshotMark || item._mark) {
+					rendersToUse.push(item);
+					continue;
+				}
+				if (filterKeys) {
+					prev = prev && pick(prev, filterKeys);
+					item = pick(item, filterKeys);
+				}
+				if (rejectKeys) {
+					prev = prev && omit(prev, rejectKeys);
+					item = omit(item, rejectKeys);
+				}
+				if (!deepEqual(prev, item)) rendersToUse.push(item);
+			}
+		}
+		if (fromLastSnapshot) {
+			const lastSnapshotMark = rendersToUse.findLastIndex((item) => item._lastSnapshotMark === true);
+			rendersToUse = rendersToUse.slice(clampMin(lastSnapshotMark, 0));
+		}
+		logs.push({ _lastSnapshotMark: true });
+		const propDivider = "⋅";
+		const snapShot = `\n${filterAndMap(rendersToUse, (render, i) => {
+			if (render._lastSnapshotMark) if (includeLastSnapshotEndMark) {
+				if (rendersToUse.length === 1) return "⋅⋅⋅";
+				if (i !== rendersToUse.length - 1) return "⋅⋅⋅";
+				return false;
+			} else return false;
+			if (render._mark) {
+				let mark = `${rendersToUse[i - 1]?._lastSnapshotMark ? "" : "\n"}>>> ${String(render._mark)}`;
+				const nextRender = rendersToUse[i + 1];
+				if (nextRender && !nextRender._mark && !nextRender._lastSnapshotMark) mark = `${mark}\n`;
+				return mark;
+			}
+			let line = "";
+			for (const [key, _value] of Object.entries(render)) {
+				let value = _value;
+				if (Array.isArray(value)) {
+					if (arrays === "length") value = `Array(${value.length})`;
+					else if (arrays === "firstAndLast" && value.length > 2) {
+						const intermediateSize = clampMin(value.length - 2, 0);
+						value = [
+							value[0],
+							`…(${intermediateSize} between)`,
+							value.at(-1)
+						];
+					} else if (typeof arrays === "object" && value.length > 2) value = [...value.slice(0, arrays.firstNItems), `…(${value.length - arrays.firstNItems} more)`];
+				}
+				if (typeof value === "boolean" && useEmojiForBooleans) value = value ? "✅" : "❌";
+				if (value === "") value = `''`;
+				if (typeof value === "object" && value !== null) value = JSON.stringify(value).replace(/:true/g, ":✅").replace(/:false/g, ":❌").replace(/:""/g, ":''").replace(/"/g, "").replace(/,/g, ", ");
+				line += `${key}: ${value} ${propDivider} `;
+			}
+			line = line.slice(0, -3);
+			if (splitLongLines && line.length > maxLineLengthBeforeSplit) {
+				const parts = line.split(` ${propDivider} `);
+				if (parts.length === 1) return line;
+				line = "";
+				const propDividerML = "⋅";
+				for (const { item, index } of arrayWithPrevAndIndex(parts)) {
+					if (index === 0) line += `┌─\n${propDividerML} `;
+					else if (index === parts.length - 1) line += `${propDividerML} `;
+					else line += `${propDividerML} `;
+					line += `${item}\n`;
+					if (index === parts.length - 1) line += "└─";
+				}
+			} else line = `-> ${line}`;
+			return line;
+		}).join("\n")}\n`;
+		return snapShot === `\n⋅⋅⋅\n` ? "⋅⋅⋅empty⋅⋅⋅" : snapShot;
+	}
+	function addMark(label) {
+		add({ _mark: label });
+	}
+	return {
+		add,
+		reset,
+		getSnapshot,
+		waitNextLog,
+		get changesSnapshot() {
+			return getSnapshot({ changesOnly: true });
+		},
+		get snapshot() {
+			return getSnapshot();
+		},
+		get snapshotFromLast() {
+			return getSnapshot({ fromLastSnapshot: true });
+		},
+		logsCount,
+		get rendersTime() {
+			return logsTime;
+		},
+		addMark
+	};
+}
+function getResultFn(fnGetter, wrapper) {
+	return ((...args) => {
+		const fn = fnGetter();
+		if (wrapper) return wrapper(fn(...args));
+		else return fn(...args);
+	});
+}
+function waitController() {
+	const { promise, resolve } = defer();
+	return {
+		wait: promise,
+		stopWaiting: () => {
+			resolve();
+		},
+		stopWaitingAfter: (ms) => {
+			setTimeout(() => {
+				resolve();
+			}, ms);
+		}
+	};
+}
+/**
+* Produces a more compact and readable snapshot of a value using yaml. By
+* default booleans are shown as `✅` and `❌`, use `showBooleansAs` to
+* disable/configure this.
+*
+* Filtering patterns in `rejectKeys` and `filterKeys`:
+*
+* - `'prop'` - Only root-level properties named 'prop'
+* - `'**prop'` - Any property named exactly 'prop' at any level (root or nested)
+* - `'*.prop'` - Any nested property named 'prop' at second level (excludes
+*   root-level matches)
+* - `'test.*.prop'` - Any property named 'prop' at second level of 'test'
+* - `'test.*.test.**prop'` - Any property named 'prop' inside of 'test.*.test'
+* - `'prop.nested'` - Exact nested property paths like `obj.prop.nested`
+* - `'prop.**nested'` - All nested properties inside root `prop` with name
+*   `nested`
+* - `'prop[0]'` - The first item of the `prop` array
+* - `'prop[*]'` - All items of the `prop` array
+* - `'prop[0].nested'` - `nested` prop of the first item of the `prop` array
+* - `'prop[*].nested'` - `nested` prop of all items of the `prop` array
+* - `'prop[*]**nested'` - all `nested` props of all items of the `prop` array
+* - `'prop[0-2]'` - The first three items of the `prop` array
+* - `'prop[4-*]'` - All items of the `prop` array from the fourth index to the
+*   end
+* - `'prop[0-2].nested.**prop'` - Combining multiple nested patterns is supported
+* - Root array:
+*
+*   - `'[0]'` - The first item of the root array
+*   - `'[*]'` - All items of the array
+*   - `'[0].nested'` - `nested` prop of the first item of the array
+*   - `'[*].nested'` - `nested` prop of all items of the array
+*   - `'[*]**nested'` - all `nested` props of all items of the array
+*   - `'[0-2]'` - The first three items of the array
+*   - `'[4-*]'` - All items of the array from the fourth index to the end
+* - Expanding the patterns with parentheses:
+*
+*   - `'prop.test.(prop1|prop2|prop3.prop4)'` - Will produce `prop.test.prop1`,
+*       `prop.test.prop2`, and `prop.test.prop3.prop4`
+* - Array filtering by value:
+*
+*   - `'users[%name="John"]'` - Filters the `users` with the `name` property equal
+*       to `John`
+*   - `'users[%name="John" | "Jane"]'` - Filters the `users` with the `name`
+*       property equal to `John` or `Jane`
+*   - `'users[%name="John" | "Jane" && %age=20]'` - AND and OR are supported by
+*       using `&&` and `||`, nesting logical operators is not supported yet
+*   - `'users[%config.name="John" | "Jane"]'` - Dot notation is supported
+*
+* Check more supported patterns in {@link filterObjectOrArrayKeys} docs.
+*
+* @param value - The value to snapshot.
+* @param options - The options for the snapshot.
+* @param options.collapseObjects - Whether to collapse objects into a single
+*   line.
+* @param options.maxLineLength - The maximum length of a line.
+* @param options.showUndefined - Whether to show undefined values.
+* @param options.showBooleansAs - Whether to show booleans as text, by default
+*   true is `✅` and false is `❌`
+* @param options.rejectKeys - The keys to reject.
+* @param options.filterKeys - The keys to filter.
+* @param options.ignoreProps - The props to ignore.
+* @param options.replaceValues - Function to replace values at specific paths.
+*   Returns `false` to keep original value or `{newValue}` to replace.
+* @param options.sortKeys - Sort all keys by a specific order (default:
+*   `simpleValuesFirst`).
+* @param options.sortPatterns - Sort specific keys by pattern. Use to control
+*   the order of specific properties. The same patterns as `filterKeys` are
+*   supported.
+* @returns The compact snapshot of the value.
+*/
+function compactSnapshot(value, { collapseObjects = true, maxLineLength = 100, showUndefined = false, showBooleansAs = true, replaceValues, rejectKeys, filterKeys, sortKeys, sortPatterns, ...options } = {}) {
+	let processedValue = value;
+	if (rejectKeys || filterKeys) {
+		if (isPlainObject(processedValue) || Array.isArray(processedValue)) processedValue = filterObjectOrArrayKeys(processedValue, {
+			rejectKeys,
+			filterKeys,
+			sortKeys,
+			sortPatterns
+		});
+	}
+	if (replaceValues) processedValue = deepReplaceValues(processedValue, replaceValues);
+	processedValue = showBooleansAs ? replaceBooleansWithEmoji(processedValue, showBooleansAs) : processedValue;
+	return `\n${yamlStringify(processedValue, {
+		collapseObjects,
+		maxLineLength,
+		showUndefined,
+		...options
+	})}`;
+}
+function replaceBooleansWithEmoji(value, showBooleansAs, visited = /* @__PURE__ */ new Set()) {
+	if (showBooleansAs === false) return value;
+	const defaultTrueText = "✅";
+	const defaultFalseText = "❌";
+	const config = typeof showBooleansAs === "boolean" ? {
+		trueText: defaultTrueText,
+		falseText: defaultFalseText
+	} : {
+		trueText: showBooleansAs.trueText ?? defaultTrueText,
+		falseText: showBooleansAs.falseText ?? defaultFalseText,
+		props: showBooleansAs.props ?? {},
+		ignoreProps: showBooleansAs.ignoreProps ?? []
+	};
+	function processValue(val, propName) {
+		if (typeof val === "boolean") {
+			if (propName && config.ignoreProps?.includes(propName)) return val;
+			if (propName && config.props?.[propName]) {
+				const propConfig = config.props[propName];
+				if (propConfig === true) return val ? config.trueText : config.falseText;
+				return val ? propConfig.trueText ?? config.trueText : propConfig.falseText ?? config.falseText;
+			}
+			return val ? config.trueText : config.falseText;
+		}
+		if (Array.isArray(val)) {
+			if (visited.has(val)) throw new Error("Circular reference detected in array");
+			visited.add(val);
+			try {
+				return val.map((item) => processValue(item));
+			} finally {
+				visited.delete(val);
+			}
+		}
+		if (isPlainObject(val)) {
+			if (visited.has(val)) throw new Error("Circular reference detected in object");
+			visited.add(val);
+			try {
+				const result = {};
+				for (const [key, itemValue] of Object.entries(val)) result[key] = processValue(itemValue, key);
+				return result;
+			} finally {
+				visited.delete(val);
+			}
+		}
+		return val;
+	}
+	return processValue(value);
+}
+
+//#endregion
+export { compactSnapshot, createLoggerStore, getResultFn, waitController };

package/dist/{throttle.d.ts → throttle.d.mts}

@@ -1,19 +1,20 @@
-import { DebouncedFunc } from './debounce.js';
-import { __LEGIT_ANY_FUNCTION__ } from './saferTyping.js';
+import { __LEGIT_ANY_FUNCTION__ } from "./saferTyping.mjs";
+import { DebouncedFunc } from "./debounce.mjs";
 
+//#region src/throttle.d.ts
 interface ThrottleSettings {
-    /**
-     * Specify invoking on the leading edge of the timeout.
-     *
-     * @default true
-     */
-    leading?: boolean;
-    /**
-     * Specify invoking on the trailing edge of the timeout.
-     *
-     * @default true
-     */
-    trailing?: boolean;
+  /**
+   * Specify invoking on the leading edge of the timeout.
+   *
+   * @default true
+   */
+  leading?: boolean;
+  /**
+   * Specify invoking on the trailing edge of the timeout.
+   *
+   * @default true
+   */
+  trailing?: boolean;
 }
 /**
  * Creates a throttled function that only invokes the provided function at most
@@ -92,7 +93,7 @@ declare function throttle<T extends __LEGIT_ANY_FUNCTION__>(func: T, wait: numbe
  * @returns An object with a `call` method that accepts the callback arguments
  */
 declare function createThrottledFunctionFactory<T extends string | number | null | undefined | boolean, R>(wait: number, callback: (...args: T[]) => R, options?: ThrottleSettings): {
-    call: (...args: T[]) => R | undefined;
+  call: (...args: T[]) => R | undefined;
 };
-
-export { createThrottledFunctionFactory, throttle };
+//#endregion
+export { createThrottledFunctionFactory, throttle };

package/dist/throttle.mjs

@@ -0,0 +1,102 @@
+import { EnhancedMap } from "./enhancedMap.mjs";
+import { debounce } from "./debounce.mjs";
+
+//#region src/throttle.ts
+/**
+* Creates a throttled function that only invokes the provided function at most
+* once per every `wait` milliseconds. The throttled function comes with a
+* `cancel` method to cancel delayed invocations and a `flush` method to
+* immediately invoke them.
+*
+* Throttling is useful for rate-limiting events that fire frequently, like
+* scroll or resize handlers. Unlike debouncing, throttling guarantees the
+* function is called at regular intervals.
+*
+* @example
+*   ```ts
+*   const throttledSave = throttle(saveData, 1000);
+*
+*   // Will only call saveData at most once per second
+*   throttledSave();
+*   throttledSave();
+*   throttledSave();
+*   ```;
+*
+* @example
+*   ```ts
+*   // Only invoke on trailing edge
+*   const throttledHandler = throttle(handleScroll, 100, { leading: false });
+*   ```;
+*
+* @template T - The type of the function to throttle
+* @param func - The function to throttle
+* @param wait - The number of milliseconds to throttle invocations to
+* @param options - The options object
+* @param options.leading - Specify invoking on the leading edge of the timeout
+*   (default: true)
+* @param options.trailing - Specify invoking on the trailing edge of the
+*   timeout (default: true)
+* @returns Returns the new throttled function
+*/
+function throttle(func, wait, options) {
+	let leading = true;
+	let trailing = true;
+	if (options) {
+		leading = "leading" in options ? !!options.leading : leading;
+		trailing = "trailing" in options ? !!options.trailing : trailing;
+	}
+	return debounce(func, wait, {
+		leading,
+		maxWait: wait,
+		trailing
+	});
+}
+/**
+* Creates a factory for throttled functions that caches throttled instances
+* based on function arguments. Each unique set of arguments gets its own
+* throttled function instance, allowing for fine-grained throttling control per
+* argument combination.
+*
+* This is useful when you want to throttle calls to the same function but with
+* different parameters independently. For example, throttling API calls per
+* user ID or throttling UI updates per component.
+*
+* @example
+*   ```ts
+*   const apiThrottle = createThrottledFunctionFactory(
+*     1000,
+*     (userId: string, action: string) => callAPI(userId, action)
+*   );
+*
+*   // Each user gets their own throttled instance
+*   apiThrottle.call('user1', 'update'); // Executes immediately
+*   apiThrottle.call('user2', 'update'); // Executes immediately (different user)
+*   apiThrottle.call('user1', 'update'); // Throttled (same user)
+*   ```;
+*
+* @example
+*   ```ts
+*   // Throttle UI updates per component
+*   const updateThrottle = createThrottledFunctionFactory(
+*     100,
+*     (componentId: string, data: any) => updateComponent(componentId, data)
+*   );
+*   ```;
+*
+* @template T - The type of arguments the callback function accepts
+* @template R - The return type of the callback function
+* @param wait - The number of milliseconds to throttle invocations to
+* @param callback - The function to throttle
+* @param options - The throttle options (leading/trailing behavior)
+* @returns An object with a `call` method that accepts the callback arguments
+*/
+function createThrottledFunctionFactory(wait, callback, options) {
+	const cache = new EnhancedMap();
+	return { call: (...args) => {
+		const key = args.map((arg) => arg === void 0 ? "__UNDEFINED__" : JSON.stringify(arg)).join(",");
+		return cache.getOrInsert(key, () => throttle(callback, wait, options))(...args);
+	} };
+}
+
+//#endregion
+export { createThrottledFunctionFactory, throttle };

package/dist/time-sr2lhQRw.mjs

@@ -0,0 +1,67 @@
+import { t as castToNumber } from "./castValues-DfICShCc.mjs";
+import { r as clampMax } from "./mathUtils-BDP1lM_z.mjs";
+
+//#region src/time.ts
+const MINUTE_AS_MS = 60 * 1e3;
+const HOUR_AS_MS = 60 * MINUTE_AS_MS;
+const DAY_AS_MS = 24 * HOUR_AS_MS;
+const WEEK_AS_MS = 7 * DAY_AS_MS;
+const MONTH_AS_MS = 30 * DAY_AS_MS;
+const YEAR_AS_MS = 365 * DAY_AS_MS;
+const HOUR_AS_SECS = 3600;
+const DAY_AS_SECS = 24 * HOUR_AS_SECS;
+const WEEK_AS_SECS = 7 * DAY_AS_SECS;
+const MONTH_AS_SECS = 30 * DAY_AS_SECS;
+const YEAR_AS_SECS = 365 * DAY_AS_SECS;
+function dateStringOrNullToUnixMs(isoString) {
+	if (!isoString) return null;
+	const unixMs = new Date(isoString).getTime();
+	if (isNaN(unixMs)) return null;
+	return unixMs;
+}
+function msToTimeString(ms, format, hoursMinLength = 2) {
+	const { hours, minutes, seconds, milliseconds } = msToDurationObj(ms);
+	const hoursString = padTimeVal(hours, hoursMinLength);
+	const minutesString = padTimeVal(minutes);
+	if (format === "minutes") return `${hoursString}:${minutesString}`;
+	const secondsString = padTimeVal(seconds);
+	if (format === "seconds") return `${hoursString}:${minutesString}:${secondsString}`;
+	return `${hoursString}:${minutesString}:${secondsString}:${padTimeVal(milliseconds, 3)}`;
+}
+function padTimeVal(val, maxLength = 2) {
+	return val.toString().padStart(maxLength, "0");
+}
+function parseTimeStringToMs(timeString) {
+	if (!timeString.trim()) return 0;
+	const [hours, minutes, seconds, ms] = timeString.split(":");
+	return getTimeStringPartToInt(hours) * HOUR_AS_MS + clampMax(getTimeStringPartToInt(minutes), 59) * MINUTE_AS_MS + clampMax(getTimeStringPartToInt(seconds), 59) * 1e3 + getTimeStringPartToInt(ms, 3);
+}
+function getTimeStringPartToInt(timeStringPart, length) {
+	if (!timeStringPart?.trim()) return 0;
+	let string = timeStringPart.replaceAll("_", "0");
+	string = string.replaceAll("-", "");
+	if (length) {
+		string = string.padEnd(length, "0");
+		if (string.length > length) string = string.slice(0, length);
+	}
+	const num = castToNumber(string);
+	if (!num) return 0;
+	return Math.floor(num);
+}
+function msToDurationObj(ms) {
+	return {
+		milliseconds: ms % 1e3,
+		seconds: Math.floor(ms / 1e3) % 60,
+		minutes: Math.floor(ms / 1e3 / 60) % 60,
+		hours: Math.floor(ms / 1e3 / 60 / 60)
+	};
+}
+function getUnixSeconds() {
+	return Math.floor(Date.now() / 1e3);
+}
+function durationObjToMs(durationObj) {
+	return (durationObj.hours ?? 0) * HOUR_AS_MS + (durationObj.minutes ?? 0) * MINUTE_AS_MS + (durationObj.seconds ?? 0) * 1e3 + (durationObj.ms ?? 0) + (durationObj.days ?? 0) * DAY_AS_MS;
+}
+
+//#endregion
+export { MINUTE_AS_MS as a, WEEK_AS_MS as c, YEAR_AS_SECS as d, dateStringOrNullToUnixMs as f, parseTimeStringToMs as g, msToTimeString as h, HOUR_AS_SECS as i, WEEK_AS_SECS as l, getUnixSeconds as m, DAY_AS_SECS as n, MONTH_AS_MS as o, durationObjToMs as p, HOUR_AS_MS as r, MONTH_AS_SECS as s, DAY_AS_MS as t, YEAR_AS_MS as u };

package/dist/{time.d.ts → time.d.mts}

@@ -1,3 +1,4 @@
+//#region src/time.d.ts
 declare const MINUTE_AS_MS: number;
 declare const HOUR_AS_MS: number;
 declare const DAY_AS_MS: number;
@@ -14,12 +15,12 @@ declare function msToTimeString(ms: number, format: 'minutes' | 'seconds' | 'mil
 declare function parseTimeStringToMs(timeString: string): number;
 declare function getUnixSeconds(): number;
 type DurationObj = {
-    ms?: number;
-    seconds?: number;
-    minutes?: number;
-    hours?: number;
-    days?: number;
+  ms?: number;
+  seconds?: number;
+  minutes?: number;
+  hours?: number;
+  days?: number;
 };
 declare function durationObjToMs(durationObj: DurationObj): number;
-
-export { DAY_AS_MS, DAY_AS_SECS, type DurationObj, HOUR_AS_MS, HOUR_AS_SECS, MINUTE_AS_MS, MONTH_AS_MS, MONTH_AS_SECS, WEEK_AS_MS, WEEK_AS_SECS, YEAR_AS_MS, YEAR_AS_SECS, dateStringOrNullToUnixMs, durationObjToMs, getUnixSeconds, msToTimeString, parseTimeStringToMs };
+//#endregion
+export { DAY_AS_MS, DAY_AS_SECS, DurationObj, HOUR_AS_MS, HOUR_AS_SECS, MINUTE_AS_MS, MONTH_AS_MS, MONTH_AS_SECS, WEEK_AS_MS, WEEK_AS_SECS, YEAR_AS_MS, YEAR_AS_SECS, dateStringOrNullToUnixMs, durationObjToMs, getUnixSeconds, msToTimeString, parseTimeStringToMs };

package/dist/time.mjs

@@ -0,0 +1,3 @@
+import { a as MINUTE_AS_MS, c as WEEK_AS_MS, d as YEAR_AS_SECS, f as dateStringOrNullToUnixMs, g as parseTimeStringToMs, h as msToTimeString, i as HOUR_AS_SECS, l as WEEK_AS_SECS, m as getUnixSeconds, n as DAY_AS_SECS, o as MONTH_AS_MS, p as durationObjToMs, r as HOUR_AS_MS, s as MONTH_AS_SECS, t as DAY_AS_MS, u as YEAR_AS_MS } from "./time-sr2lhQRw.mjs";
+
+export { DAY_AS_MS, DAY_AS_SECS, HOUR_AS_MS, HOUR_AS_SECS, MINUTE_AS_MS, MONTH_AS_MS, MONTH_AS_SECS, WEEK_AS_MS, WEEK_AS_SECS, YEAR_AS_MS, YEAR_AS_SECS, dateStringOrNullToUnixMs, durationObjToMs, getUnixSeconds, msToTimeString, parseTimeStringToMs };

package/dist/{timers.d.cts → timers.d.mts}

@@ -1,5 +1,6 @@
-import { Result } from 't-result';
+import { Result } from "t-result";
 
+//#region src/timers.d.ts
 type CleanupTimer = () => void;
 /**
  * Creates a timeout with automatic cleanup capability.
@@ -70,8 +71,8 @@ declare function createInterval(ms: number, callback: () => void): CleanupTimer;
  *   it
  */
 declare function createDebouncedTimeout(ms: number, callback: () => void): {
-    call: () => void;
-    clean: CleanupTimer;
+  call: () => void;
+  clean: CleanupTimer;
 };
 /**
  * Creates a timeout that waits for a condition to become true.
@@ -107,15 +108,23 @@ declare function createDebouncedTimeout(ms: number, callback: () => void): {
  *   milliseconds (default: 20)
  * @returns A cleanup function that cancels the condition timeout
  */
-declare function createWaitUntil<T extends NonNullable<unknown>>({ condition, maxWaitMs, callback, checkIntervalMs, }: {
-    condition: () => false | T;
-    maxWaitMs: number;
-    callback: (value: T) => void;
-    checkIntervalMs?: number;
+declare function createWaitUntil<T extends NonNullable<unknown>>({
+  condition,
+  maxWaitMs,
+  callback,
+  checkIntervalMs
+}: {
+  condition: () => false | T;
+  maxWaitMs: number;
+  callback: (value: T) => void;
+  checkIntervalMs?: number;
 }): CleanupTimer;
-declare function waitFor(condition: () => boolean | Promise<boolean>, { polling, timeout }: {
-    polling: number | 'raf';
-    timeout: number;
+declare function waitFor(condition: () => boolean | Promise<boolean>, {
+  polling,
+  timeout
+}: {
+  polling: number | 'raf';
+  timeout: number;
 }): Promise<Result<void, Error>>;
-
-export { type CleanupTimer, createDebouncedTimeout, createInterval, createTimeout, createWaitUntil, waitFor };
+//#endregion
+export { CleanupTimer, createDebouncedTimeout, createInterval, createTimeout, createWaitUntil, waitFor };