@ls-stack/utils 3.65.0 → 3.66.0

package/dist/debounce.d.mts

@@ -0,0 +1,47 @@
+//#region src/debounce.d.ts
+type DebounceOptions = {
+  /** @see _.leading */
+  leading?: boolean;
+  /** @see _.maxWait */
+  maxWait?: number;
+  /** @see _.trailing */
+  trailing?: boolean;
+};
+interface DebouncedFunc<T extends (...args: any[]) => void> {
+  /**
+   * Call the original function, but applying the debounce rules.
+   *
+   * If the debounced function can be run immediately, this calls it and returns
+   * its return value.
+   *
+   * Otherwise, it returns the return value of the last invocation, or undefined
+   * if the debounced function was not invoked yet.
+   */
+  (...args: Parameters<T>): ReturnType<T> | undefined;
+  /** Throw away any pending invocation of the debounced function. */
+  cancel: () => void;
+  /**
+   * If there is a pending invocation of the debounced function, invoke it
+   * immediately and return its return value.
+   *
+   * Otherwise, return the value from the last invocation, or undefined if the
+   * debounced function was never invoked.
+   */
+  flush: () => ReturnType<T> | undefined;
+  /** Return true if the debounced function still has a scheduled run. */
+  pending: () => boolean;
+  /** Update the debounced function with a new callback. */
+  updateCb: (callback: T) => void;
+  /** Update the debounce wait and options while keeping scheduled runs. */
+  updateParams: (wait: number, options?: DebounceOptions) => void;
+}
+declare function debounce<T extends (...args: any[]) => void>(func: T, wait: number, options?: DebounceOptions): DebouncedFunc<T>;
+declare function isDebouncedFn<T extends (...args: any[]) => void>(fn: T): fn is T & {
+  cancel: () => void;
+  flush: () => ReturnType<T> | undefined;
+  pending: () => boolean;
+  updateCb: (callback: T) => void;
+  updateParams: (wait: number, options?: DebounceOptions) => void;
+};
+//#endregion
+export { DebounceOptions, DebouncedFunc, debounce, isDebouncedFn };

package/dist/debounce.mjs

@@ -0,0 +1,117 @@
+//#region src/debounce.ts
+function debounce(func, wait, options) {
+	let currentCallback = func;
+	let waitMs = wait;
+	let currentOptions = options;
+	let lastArgs;
+	let lastThis;
+	let maxWait;
+	let result;
+	let timerId;
+	let lastCallTime;
+	let lastInvokeTime = 0;
+	let leading = false;
+	let maxing = false;
+	let trailing = true;
+	function applyOptions() {
+		const opts = currentOptions;
+		leading = !!opts?.leading;
+		trailing = opts && "trailing" in opts ? !!opts.trailing : true;
+		maxing = !!(opts && "maxWait" in opts);
+		maxWait = maxing ? Math.max(opts?.maxWait ?? 0, waitMs) : void 0;
+	}
+	applyOptions();
+	function invokeFunc(time) {
+		const args = lastArgs;
+		const thisArg = lastThis;
+		lastArgs = lastThis = void 0;
+		lastInvokeTime = time;
+		result = currentCallback.apply(thisArg, args);
+		return result;
+	}
+	function leadingEdge(time) {
+		lastInvokeTime = time;
+		timerId = setTimeout(timerExpired, waitMs);
+		return leading ? invokeFunc(time) : result;
+	}
+	function remainingWait(time) {
+		const timeSinceLastCall = time - (lastCallTime ?? 0);
+		const timeSinceLastInvoke = time - lastInvokeTime;
+		const timeWaiting = waitMs - timeSinceLastCall;
+		return maxing ? Math.min(timeWaiting, (maxWait ?? 0) - timeSinceLastInvoke) : timeWaiting;
+	}
+	function shouldInvoke(time) {
+		const timeSinceLastCall = time - (lastCallTime ?? 0);
+		const timeSinceLastInvoke = time - lastInvokeTime;
+		return lastCallTime === void 0 || timeSinceLastCall >= waitMs || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= (maxWait ?? 0);
+	}
+	function timerExpired() {
+		const time = Date.now();
+		if (shouldInvoke(time)) return trailingEdge(time);
+		timerId = setTimeout(timerExpired, remainingWait(time));
+	}
+	function trailingEdge(time) {
+		timerId = void 0;
+		if (trailing && lastArgs) return invokeFunc(time);
+		lastArgs = lastThis = void 0;
+		return result;
+	}
+	function cancel() {
+		if (timerId !== void 0) clearTimeout(timerId);
+		lastInvokeTime = 0;
+		lastArgs = lastCallTime = lastThis = timerId = void 0;
+	}
+	function flush() {
+		return timerId === void 0 ? result : trailingEdge(Date.now());
+	}
+	function pending() {
+		return timerId !== void 0;
+	}
+	function updateCb(callback) {
+		currentCallback = callback;
+	}
+	function updateParams(newWait, newOptions) {
+		waitMs = newWait;
+		if (newOptions !== void 0) currentOptions = newOptions;
+		applyOptions();
+		if (timerId !== void 0) {
+			const time = Date.now();
+			const shouldRun = shouldInvoke(time);
+			clearTimeout(timerId);
+			if (shouldRun) timerId = setTimeout(timerExpired, 0);
+			else {
+				const delay = remainingWait(time);
+				timerId = setTimeout(timerExpired, delay > 0 ? delay : 0);
+			}
+		}
+	}
+	function debounced() {
+		const time = Date.now();
+		const isInvoking = shouldInvoke(time);
+		lastArgs = arguments;
+		lastThis = this;
+		lastCallTime = time;
+		if (isInvoking) {
+			if (timerId === void 0) return leadingEdge(lastCallTime);
+			if (maxing) {
+				clearTimeout(timerId);
+				timerId = setTimeout(timerExpired, waitMs);
+				return invokeFunc(lastCallTime);
+			}
+		}
+		if (timerId === void 0) timerId = setTimeout(timerExpired, waitMs);
+		return result;
+	}
+	debounced.cancel = cancel;
+	debounced.flush = flush;
+	debounced.pending = pending;
+	debounced.updateCb = updateCb;
+	debounced.updateParams = updateParams;
+	return debounced;
+}
+function isDebouncedFn(fn) {
+	return typeof fn === "function" && "cancel" in fn && typeof fn.cancel === "function" && "flush" in fn && typeof fn.flush === "function" && "pending" in fn && typeof fn.pending === "function" && "updateCb" in fn && typeof fn.updateCb === "function" && "updateParams" in fn && typeof fn.updateParams === "function";
+}
+
+//#endregion
+export { debounce, isDebouncedFn };

package/dist/dedent.d.mts

@@ -0,0 +1,74 @@
+//#region src/dedent.d.ts
+/** Configuration options for the dedent function behavior */
+interface DedentOptions {
+  /**
+   * Whether to process escape sequences like \n, `, $, and { When true, allows
+   * using escaped characters in template literals
+   *
+   * @default true for template literals, false for plain strings
+   */
+  escapeSpecialCharacters?: boolean;
+  /**
+   * Whether to trim leading and trailing whitespace from the final result
+   *
+   * @default true
+   */
+  trimWhitespace?: boolean;
+  /**
+   * Whether to preserve relative indentation of interpolated multi-line values
+   * When true, multi-line interpolations are re-indented to match the
+   * surrounding context
+   *
+   * @default true
+   */
+  identInterpolations?: boolean;
+  /**
+   * Whether to display nullish or false values (false, null, undefined) in
+   * interpolations When false, nullish or false values are skipped entirely
+   *
+   * @default false
+   */
+  showNullishOrFalseValues?: boolean;
+}
+type InterpolationValue = string | number | boolean | null | undefined;
+/**
+ * Dedent function interface that can be used both as a template tag and a
+ * regular function
+ */
+interface Dedent {
+  /** Process a plain string to remove common indentation */
+  (literals: string): string;
+  /**
+   * Process a template literal to remove common indentation while handling
+   * interpolations
+   */
+  (strings: TemplateStringsArray, ...values: InterpolationValue[]): string;
+  /** Create a new dedent function with custom options */
+  withOptions: CreateDedent;
+}
+/** Factory function type for creating dedent functions with custom options */
+type CreateDedent = (options: DedentOptions) => Dedent;
+/**
+ * Remove common leading indentation from multi-line strings while preserving
+ * relative indentation. Can be used as a tagged template literal or called with
+ * a plain string.
+ *
+ * By default, it will dedent interpolated multi-line strings to match the
+ * surrounding context. And it will not show falsy values.
+ *
+ * @example
+ *   ```typescript
+ *   const text = dedent`;
+ *   function hello() {
+ *     console.log('world');
+ *   }
+ *   `;
+ *   // Result:
+ *   "function hello() {
+ *     console.log('world');
+ *   }"
+ *   ```;
+ */
+declare const dedent: Dedent;
+//#endregion
+export { CreateDedent, Dedent, DedentOptions, dedent };

package/dist/dedent.mjs

@@ -0,0 +1,80 @@
+//#region src/dedent.ts
+/**
+* Remove common leading indentation from multi-line strings while preserving
+* relative indentation. Can be used as a tagged template literal or called with
+* a plain string.
+*
+* By default, it will dedent interpolated multi-line strings to match the
+* surrounding context. And it will not show falsy values.
+*
+* @example
+*   ```typescript
+*   const text = dedent`;
+*   function hello() {
+*     console.log('world');
+*   }
+*   `;
+*   // Result:
+*   "function hello() {
+*     console.log('world');
+*   }"
+*   ```;
+*/
+const dedent = createDedent({ identInterpolations: true });
+function createDedent(options) {
+	d.withOptions = (newOptions) => createDedent({
+		...options,
+		...newOptions
+	});
+	return d;
+	function d(strings, ...values) {
+		const raw = typeof strings === "string" ? [strings] : strings.raw;
+		const { escapeSpecialCharacters = Array.isArray(strings), trimWhitespace = true, identInterpolations = true, showNullishOrFalseValues = false } = options;
+		let result = "";
+		for (let i = 0; i < raw.length; i++) {
+			let next = raw[i];
+			if (escapeSpecialCharacters) next = next.replace(/\\\n[ \t]*/g, "").replace(/\\`/g, "`").replace(/\\\$/g, "$").replace(/\\\{/g, "{");
+			result += next;
+			if (i < values.length) {
+				let val = values[i];
+				if (!showNullishOrFalseValues && (val === false || val === null || val === void 0)) continue;
+				val = String(val);
+				if (identInterpolations && val.includes("\n")) {
+					let withIdent = val;
+					const currentIndent = getCurrentIndent(result);
+					if (currentIndent && withIdent) withIdent = withIdent.split("\n").map((line, index) => {
+						return index === 0 || line === "" ? line : currentIndent + line;
+					}).join("\n");
+					result += withIdent;
+				} else result += val;
+			}
+		}
+		const lines = result.split("\n");
+		let mindent = null;
+		for (const l of lines) {
+			const m = l.match(/^(\s+)\S+/);
+			if (m) {
+				const indent = m[1].length;
+				if (!mindent) mindent = indent;
+				else mindent = Math.min(mindent, indent);
+			}
+		}
+		if (mindent !== null) {
+			const m = mindent;
+			result = lines.map((l) => l[0] === " " || l[0] === "	" ? l.slice(m) : l).join("\n");
+		}
+		if (trimWhitespace) result = result.trim();
+		if (escapeSpecialCharacters) result = result.replace(/\\n/g, "\n");
+		return result;
+	}
+}
+function getCurrentIndent(str) {
+	const lines = str.split("\n");
+	const lastLine = lines[lines.length - 1];
+	if (!lastLine) return "";
+	const match = lastLine.match(/^(\s*)/);
+	return match ? match[1] : "";
+}
+
+//#endregion
+export { dedent };

package/dist/deepEqual-C7EZEixx.mjs

@@ -0,0 +1,78 @@
+//#region src/deepEqual.ts
+/**
+* Forked from https://github.com/lukeed/dequal to consider invalid dates as
+* equal
+*/
+const has = Object.prototype.hasOwnProperty;
+function find(iter, tar, maxDepth) {
+	for (const key of iter.keys()) if (deepEqual(key, tar, maxDepth)) return key;
+}
+/**
+* Deep equality comparison between two values
+*
+* @example
+*   ```ts
+*   deepEqual({a: 1}, {a: 1}) // true
+*   deepEqual({a: 1}, {a: 2}) // false
+*   deepEqual([1, {b: 2}], [1, {b: 2}]) // true
+*   deepEqual(new Map([['a', 1]]), new Map([['a', 1]])) // true
+*   deepEqual(new Set([1, 2]), new Set([1, 2])) // true
+*   ```;
+*
+* @param foo First value to compare
+* @param bar Second value to compare
+* @param maxDepth Maximum comparison depth (default: 20)
+* @returns True if values are deeply equal, false otherwise
+*/
+function deepEqual(foo, bar, maxDepth = 20) {
+	let ctor, len, tmp;
+	if (foo === bar) return true;
+	if (maxDepth && maxDepth <= 0) return false;
+	if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+		if (ctor === Date) return deepEqual(foo.getTime(), bar.getTime(), maxDepth - 1);
+		if (ctor === RegExp) return foo.toString() === bar.toString();
+		if (ctor === Array) {
+			if ((len = foo.length) === bar.length) while (len-- && deepEqual(foo[len], bar[len], maxDepth - 1));
+			return len === -1;
+		}
+		if (ctor === Set) {
+			if (foo.size !== bar.size) return false;
+			for (len of foo) {
+				tmp = len;
+				if (tmp && typeof tmp === "object") {
+					tmp = find(bar, tmp, maxDepth - 1);
+					if (!tmp) return false;
+				}
+				if (!bar.has(tmp)) return false;
+			}
+			return true;
+		}
+		if (ctor === Map) {
+			if (foo.size !== bar.size) return false;
+			for (len of foo) {
+				tmp = len[0];
+				if (tmp && typeof tmp === "object") {
+					tmp = find(bar, tmp, maxDepth - 1);
+					if (!tmp) return false;
+				}
+				if (!deepEqual(len[1], bar.get(tmp), maxDepth - 1)) return false;
+			}
+			return true;
+		}
+		if (!ctor || typeof foo === "object") {
+			len = 0;
+			for (ctor in foo) {
+				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+				if (!(ctor in bar) || !deepEqual(foo[ctor], bar[ctor], maxDepth - 1)) return false;
+			}
+			return Object.keys(bar).length === len;
+		}
+	}
+	return foo !== foo && bar !== bar;
+}
+function deepEqualWithMaxDepth(maxDepth) {
+	return (foo, bar) => deepEqual(foo, bar, maxDepth);
+}
+
+//#endregion
+export { deepEqualWithMaxDepth as n, deepEqual as t };

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

@@ -1,3 +1,4 @@
+//#region src/deepEqual.d.ts
 /**
  * Deep equality comparison between two values
  *
@@ -17,5 +18,5 @@
  */
 declare function deepEqual(foo: any, bar: any, maxDepth?: number): boolean;
 declare function deepEqualWithMaxDepth(maxDepth: number): (foo: any, bar: any) => boolean;
-
-export { deepEqual, deepEqualWithMaxDepth };
+//#endregion
+export { deepEqual, deepEqualWithMaxDepth };

package/dist/deepEqual.mjs

@@ -0,0 +1,3 @@
+import { n as deepEqualWithMaxDepth, t as deepEqual } from "./deepEqual-C7EZEixx.mjs";
+
+export { deepEqual, deepEqualWithMaxDepth };

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

@@ -1,3 +1,4 @@
+//#region src/deepReplaceValues.d.ts
 /**
  * Recursively traverses an object or array and allows conditional replacement of values
  * based on a provided callback function. The callback receives each value and its path
@@ -21,7 +22,7 @@
  * // Result: { user: { id: 2, name: "Alice" }, scores: [170, 184] }
  */
 declare function deepReplaceValues<T, R = T>(value: T, replaceValues: (value: unknown, path: string) => false | {
-    newValue: unknown;
+  newValue: unknown;
 }): R;
-
-export { deepReplaceValues };
+//#endregion
+export { deepReplaceValues };

package/dist/deepReplaceValues.mjs

@@ -0,0 +1,61 @@
+import { a as isPlainObject } from "./typeGuards-B1mzA-Rz.mjs";
+
+//#region src/deepReplaceValues.ts
+function applyValueReplacements(value, replaceValues, visited, currentPath) {
+	function processValue(val, path) {
+		const replacement = replaceValues(val, path);
+		if (replacement !== false) return replacement.newValue;
+		if (Array.isArray(val)) {
+			if (visited.has(val)) throw new Error("Circular reference detected in array");
+			visited.add(val);
+			try {
+				return val.map((item, index) => {
+					return processValue(item, path ? `${path}[${index}]` : `[${index}]`);
+				});
+			} 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, path ? `${path}.${key}` : key);
+				return result;
+			} finally {
+				visited.delete(val);
+			}
+		}
+		return val;
+	}
+	return processValue(value, currentPath);
+}
+/**
+* Recursively traverses an object or array and allows conditional replacement of values
+* based on a provided callback function. The callback receives each value and its path
+* within the data structure.
+*
+* @param value - The input value to process (object, array, or primitive)
+* @param replaceValues - Callback function that receives each value and its path.
+*   Return `false` to keep the original value, or `{ newValue: unknown }` to replace it.
+*   The path uses dot notation for objects (e.g., "user.name") and bracket notation for arrays (e.g., "items[0]")
+* @returns A new structure with replaced values. The original structure is not modified.
+* @throws Error if circular references are detected
+*
+* @example
+* const data = { user: { id: 1, name: "Alice" }, scores: [85, 92] };
+* const result = deepReplaceValues(data, (value, path) => {
+*   if (typeof value === "number") {
+*     return { newValue: value * 2 };
+*   }
+*   return false;
+* });
+* // Result: { user: { id: 2, name: "Alice" }, scores: [170, 184] }
+*/
+function deepReplaceValues(value, replaceValues) {
+	return applyValueReplacements(value, replaceValues, /* @__PURE__ */ new Set(), "");
+}
+
+//#endregion
+export { deepReplaceValues };

package/dist/diffParser.d.mts

@@ -0,0 +1,63 @@
+//#region src/diffParser.d.ts
+interface Change {
+  type: 'normal' | 'del' | 'add';
+  normal?: boolean;
+  del?: boolean;
+  add?: boolean;
+  ln1?: number;
+  ln2?: number;
+  ln?: number;
+  content: string;
+}
+interface ParentRange {
+  start: number;
+  lines: number;
+}
+interface Chunk {
+  content: string;
+  changes: Change[];
+  oldStart: number;
+  oldLines: number;
+  newStart: number;
+  newLines: number;
+  combined?: boolean;
+  parentCount?: number;
+  oldRanges?: ParentRange[];
+}
+type DiffFileType = 'modified' | 'new' | 'deleted' | 'renamed' | 'binary' | 'combined';
+interface DiffFileBase {
+  type: DiffFileType;
+  chunks: Chunk[];
+  deletions: number;
+  additions: number;
+  from: string | undefined;
+  to: string | undefined;
+  oldMode: string | undefined;
+  newMode: string | undefined;
+  index: string[] | undefined;
+  diff: string | undefined;
+}
+interface DiffFileModified extends DiffFileBase {
+  type: 'modified';
+}
+interface DiffFileNew extends DiffFileBase {
+  type: 'new';
+}
+interface DiffFileDeleted extends DiffFileBase {
+  type: 'deleted';
+}
+interface DiffFileRenamed extends DiffFileBase {
+  type: 'renamed';
+  similarityIndex: number | undefined;
+}
+interface DiffFileBinary extends DiffFileBase {
+  type: 'binary';
+}
+interface DiffFileCombined extends DiffFileBase {
+  type: 'combined';
+  froms: string[] | undefined;
+}
+type DiffFile = DiffFileModified | DiffFileNew | DiffFileDeleted | DiffFileRenamed | DiffFileBinary | DiffFileCombined;
+declare function diffParser(input: string): DiffFile[];
+//#endregion
+export { DiffFile, diffParser };