@ls-stack/utils 3.65.0 → 3.66.0

package/dist/hash.mjs

@@ -0,0 +1,28 @@
+//#region src/hash.ts
+/**
+* @param str - The string to hash.
+* @returns The hash of the string.
+*/
+function murmur2(str) {
+	let h = 0;
+	let k, i = 0, len = str.length;
+	for (; len >= 4; ++i, len -= 4) {
+		k = str.charCodeAt(i) & 255 | (str.charCodeAt(++i) & 255) << 8 | (str.charCodeAt(++i) & 255) << 16 | (str.charCodeAt(++i) & 255) << 24;
+		k = (k & 65535) * 1540483477 + ((k >>> 16) * 59797 << 16);
+		k ^= k >>> 24;
+		h = (k & 65535) * 1540483477 + ((k >>> 16) * 59797 << 16) ^ (h & 65535) * 1540483477 + ((h >>> 16) * 59797 << 16);
+	}
+	switch (len) {
+		case 3: h ^= (str.charCodeAt(i + 2) & 255) << 16;
+		case 2: h ^= (str.charCodeAt(i + 1) & 255) << 8;
+		case 1:
+			h ^= str.charCodeAt(i) & 255;
+			h = (h & 65535) * 1540483477 + ((h >>> 16) * 59797 << 16);
+	}
+	h ^= h >>> 13;
+	h = (h & 65535) * 1540483477 + ((h >>> 16) * 59797 << 16);
+	return ((h ^ h >>> 15) >>> 0).toString(36);
+}
+
+//#endregion
+export { murmur2 };

package/dist/interpolate.d.mts

@@ -0,0 +1,17 @@
+//#region src/interpolate.d.ts
+type Interval = [number, number];
+declare function cyclicLerp(input: number, [inStart, inEnd]: Interval, [outStart, outEnd]: Interval): number;
+type InterpolateArgs = {
+  input: number;
+  in: number[];
+  out: number[];
+  clamp?: boolean | 'start' | 'end';
+};
+declare function interpolate({
+  input,
+  in: inputRange,
+  out,
+  clamp
+}: InterpolateArgs): number;
+//#endregion
+export { cyclicLerp, interpolate };

package/dist/interpolate.mjs

@@ -0,0 +1,28 @@
+import { i as invariant } from "./assertions-qMxfVhSu.mjs";
+import { a as clampRange, i as clampMin, r as clampMax } from "./mathUtils-BDP1lM_z.mjs";
+
+//#region src/interpolate.ts
+function mod(n, m) {
+	return (n % m + m) % m;
+}
+function cyclicLerp(input, [inStart, inEnd], [outStart, outEnd]) {
+	return mod((input - inStart) / (inEnd - inStart), 1) * (outEnd - outStart) + outStart;
+}
+function findRange(input, inputRange) {
+	for (let i = 1; i < inputRange.length - 1; i++) if (inputRange[i] >= input) return i - 1;
+	return inputRange.length - 2;
+}
+function interpolate({ input, in: inputRange, out, clamp = true }) {
+	invariant(inputRange.length === out.length, "Ranges must have the same length");
+	const range = findRange(input, inputRange);
+	const inStart = inputRange[range];
+	const inEnd = inputRange[range + 1];
+	const outStart = out[range];
+	const outEnd = out[range + 1];
+	const interpolatedValue = (input - inStart) / (inEnd - inStart) * (outEnd - outStart) + outStart;
+	const outputIsAscending = outStart < outEnd;
+	return clamp === "start" ? outputIsAscending ? clampMin(interpolatedValue, outStart) : clampMax(interpolatedValue, outStart) : clamp === "end" ? outputIsAscending ? clampMax(interpolatedValue, outEnd) : clampMin(interpolatedValue, outEnd) : clamp ? clampRange(interpolatedValue, outStart, outEnd) : interpolatedValue;
+}
+
+//#endregion
+export { cyclicLerp, interpolate };

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

@@ -1,10 +1,11 @@
+//#region src/iteratorUtils.d.ts
 declare function enumerate<T>(iter: Iterable<T>, start?: number): Generator<[number, T]>;
 declare function withIsLast<T>(array: T[]): Generator<[isLast: boolean, item: T, index: number]>;
 declare function withPrevious<T>(iter: Iterable<T>): Generator<{
-    prev: T | undefined;
-    current: T;
+  prev: T | undefined;
+  current: T;
 }>;
 declare function range(start: number, end: number, step?: number): Generator<number>;
 declare function rangeArray(start: number, end: number, step?: number): number[];
-
-export { enumerate, range, rangeArray, withIsLast, withPrevious };
+//#endregion
+export { enumerate, range, rangeArray, withIsLast, withPrevious };

package/dist/iteratorUtils.mjs

@@ -0,0 +1,39 @@
+//#region src/iteratorUtils.ts
+function* enumerate(iter, start = 0) {
+	let index = start;
+	for (const item of iter) {
+		yield [index, item];
+		index++;
+	}
+}
+function* withIsLast(array) {
+	let index = 0;
+	for (const item of array) {
+		yield [
+			index === array.length - 1,
+			item,
+			index
+		];
+		index++;
+	}
+}
+function* withPrevious(iter) {
+	let prev = void 0;
+	for (const current of iter) {
+		yield {
+			prev,
+			current
+		};
+		prev = current;
+	}
+}
+function* range(start, end, step = 1) {
+	if (start > end) for (let i = start; i >= end; i -= step) yield i;
+	else for (let i = start; i <= end; i += step) yield i;
+}
+function rangeArray(start, end, step = 1) {
+	return [...range(start, end, step)];
+}
+
+//#endregion
+export { enumerate, range, rangeArray, withIsLast, withPrevious };

package/dist/keepPrevIfUnchanged.d.mts

@@ -0,0 +1,12 @@
+//#region src/keepPrevIfUnchanged.d.ts
+declare function keepPrevIfUnchanged<T>({
+  prev,
+  newValue,
+  equalityFn
+}: {
+  prev: T;
+  newValue: T;
+  equalityFn?: (foo: any, bar: any) => boolean;
+}): T;
+//#endregion
+export { keepPrevIfUnchanged };

package/dist/keepPrevIfUnchanged.mjs

@@ -0,0 +1,9 @@
+import { t as deepEqual } from "./deepEqual-C7EZEixx.mjs";
+
+//#region src/keepPrevIfUnchanged.ts
+function keepPrevIfUnchanged({ prev, newValue, equalityFn = deepEqual }) {
+	return equalityFn(prev, newValue) ? prev : newValue;
+}
+
+//#endregion
+export { keepPrevIfUnchanged };

package/dist/keyedMap.d.mts

@@ -0,0 +1,76 @@
+//#region src/keyedMap.d.ts
+/**
+ * A Map implementation that uses a custom key function to determine key equality.
+ * Keys with the same computed internal key are considered equal.
+ *
+ * @example
+ *   const map = new KeyedMap<{ x: number; y: number }, string, string>(
+ *     (key) => `${key.x},${key.y}`,
+ *   );
+ *   map.set({ x: 1, y: 2 }, 'point A');
+ *   map.get({ x: 1, y: 2 }); // 'point A' (different object, same computed key)
+ *
+ * @template K - The type of the external key
+ * @template V - The type of the value
+ * @template InternalKey - The type of the internal key used for comparison
+ */
+declare class KeyedMap<K, V, InternalKey = string> {
+  private map;
+  private getKey;
+  /**
+   * @param getKey - Function to compute an internal key from the external key
+   * @param entries - Optional initial entries to add to the map
+   */
+  constructor(getKey: (key: K) => InternalKey, entries?: Iterable<[K, V]>);
+  /** The number of entries in the map */
+  get size(): number;
+  /** Sets a value for the given key. If the key exists, replaces both key and value. */
+  set(key: K, value: V): this;
+  /** Sets multiple entries at once. */
+  setMultiple(entries: Iterable<[K, V]>): this;
+  /** Gets the value for the given key, or undefined if not found. */
+  get(key: K): V | undefined;
+  /** Checks if the map contains the given key. */
+  has(key: K): boolean;
+  /** Removes the entry for the given key. Returns true if the entry was removed. */
+  delete(key: K): boolean;
+  /** Removes multiple entries. Returns the number of entries removed. */
+  deleteMultiple(keys: Iterable<K>): number;
+  /** Removes all entries from the map. */
+  clear(): void;
+  /** Executes a callback for each entry in the map. */
+  forEach(callback: (value: V, key: K, map: KeyedMap<K, V, InternalKey>) => void, thisArg?: unknown): void;
+  /** Finds the first entry matching the predicate. */
+  find(predicate: (value: V, key: K) => boolean): {
+    key: K;
+    value: V;
+  } | undefined;
+  /** Gets the value for the given key, or throws if not found. */
+  getOrThrow(key: K): V;
+  /** Gets the value for the given key, or inserts and returns the fallback value. */
+  getOrInsert(key: K, fallback: () => V): V;
+  /** Returns values that match the predicate. */
+  toFilteredValues(predicate: (value: V, key: K) => boolean): V[];
+  /** Returns all values as an array. */
+  toValues(): V[];
+  /** Returns all keys as an array. */
+  toKeys(): K[];
+  keys(): IterableIterator<K>;
+  values(): IterableIterator<V>;
+  entries(): IterableIterator<[K, V]>;
+  [Symbol.iterator](): IterableIterator<[K, V]>;
+}
+/**
+ * A Map that compares keys by value instead of reference.
+ * Uses `getCompositeKey` to generate a stable string key for any value.
+ *
+ * @example
+ *   const map = new CompositeKeyMap<{ x: number; y: number }, string>();
+ *   map.set({ x: 1, y: 2 }, 'point A');
+ *   map.get({ x: 1, y: 2 }); // 'point A' (different object, same value)
+ */
+declare class CompositeKeyMap<K, V> extends KeyedMap<K, V, string> {
+  constructor(entries?: Iterable<[K, V]>);
+}
+//#endregion
+export { CompositeKeyMap, KeyedMap };

package/dist/keyedMap.mjs

@@ -0,0 +1,139 @@
+import { getCompositeKey } from "./getCompositeKey.mjs";
+
+//#region src/keyedMap.ts
+/**
+* A Map implementation that uses a custom key function to determine key equality.
+* Keys with the same computed internal key are considered equal.
+*
+* @example
+*   const map = new KeyedMap<{ x: number; y: number }, string, string>(
+*     (key) => `${key.x},${key.y}`,
+*   );
+*   map.set({ x: 1, y: 2 }, 'point A');
+*   map.get({ x: 1, y: 2 }); // 'point A' (different object, same computed key)
+*
+* @template K - The type of the external key
+* @template V - The type of the value
+* @template InternalKey - The type of the internal key used for comparison
+*/
+var KeyedMap = class {
+	map;
+	getKey;
+	/**
+	* @param getKey - Function to compute an internal key from the external key
+	* @param entries - Optional initial entries to add to the map
+	*/
+	constructor(getKey, entries) {
+		this.getKey = getKey;
+		this.map = /* @__PURE__ */ new Map();
+		if (entries) for (const [key, value] of entries) this.set(key, value);
+	}
+	/** The number of entries in the map */
+	get size() {
+		return this.map.size;
+	}
+	/** Sets a value for the given key. If the key exists, replaces both key and value. */
+	set(key, value) {
+		const internalKey = this.getKey(key);
+		this.map.set(internalKey, {
+			key,
+			value
+		});
+		return this;
+	}
+	/** Sets multiple entries at once. */
+	setMultiple(entries) {
+		for (const [key, value] of entries) this.set(key, value);
+		return this;
+	}
+	/** Gets the value for the given key, or undefined if not found. */
+	get(key) {
+		const internalKey = this.getKey(key);
+		return this.map.get(internalKey)?.value;
+	}
+	/** Checks if the map contains the given key. */
+	has(key) {
+		const internalKey = this.getKey(key);
+		return this.map.has(internalKey);
+	}
+	/** Removes the entry for the given key. Returns true if the entry was removed. */
+	delete(key) {
+		const internalKey = this.getKey(key);
+		return this.map.delete(internalKey);
+	}
+	/** Removes multiple entries. Returns the number of entries removed. */
+	deleteMultiple(keys) {
+		let count = 0;
+		for (const key of keys) if (this.delete(key)) count++;
+		return count;
+	}
+	/** Removes all entries from the map. */
+	clear() {
+		this.map.clear();
+	}
+	/** Executes a callback for each entry in the map. */
+	forEach(callback, thisArg) {
+		for (const { key, value } of this.map.values()) callback.call(thisArg, value, key, this);
+	}
+	/** Finds the first entry matching the predicate. */
+	find(predicate) {
+		for (const { key, value } of this.map.values()) if (predicate(value, key)) return {
+			key,
+			value
+		};
+	}
+	/** Gets the value for the given key, or throws if not found. */
+	getOrThrow(key) {
+		const value = this.get(key);
+		if (value === void 0 && !this.has(key)) throw new Error(`Key not found in KeyedMap`);
+		return value;
+	}
+	/** Gets the value for the given key, or inserts and returns the fallback value. */
+	getOrInsert(key, fallback) {
+		if (!this.has(key)) this.set(key, fallback());
+		return this.getOrThrow(key);
+	}
+	/** Returns values that match the predicate. */
+	toFilteredValues(predicate) {
+		const values = [];
+		for (const { key, value } of this.map.values()) if (predicate(value, key)) values.push(value);
+		return values;
+	}
+	/** Returns all values as an array. */
+	toValues() {
+		return [...this.values()];
+	}
+	/** Returns all keys as an array. */
+	toKeys() {
+		return [...this.keys()];
+	}
+	*keys() {
+		for (const { key } of this.map.values()) yield key;
+	}
+	*values() {
+		for (const { value } of this.map.values()) yield value;
+	}
+	*entries() {
+		for (const { key, value } of this.map.values()) yield [key, value];
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+};
+/**
+* A Map that compares keys by value instead of reference.
+* Uses `getCompositeKey` to generate a stable string key for any value.
+*
+* @example
+*   const map = new CompositeKeyMap<{ x: number; y: number }, string>();
+*   map.set({ x: 1, y: 2 }, 'point A');
+*   map.get({ x: 1, y: 2 }); // 'point A' (different object, same value)
+*/
+var CompositeKeyMap = class extends KeyedMap {
+	constructor(entries) {
+		super(getCompositeKey, entries);
+	}
+};
+
+//#endregion
+export { CompositeKeyMap, KeyedMap };

package/dist/keyedSet.d.mts

@@ -0,0 +1,77 @@
+//#region src/keyedSet.d.ts
+/**
+ * A Set implementation that uses a custom key function to determine uniqueness.
+ * Items with the same key are considered equal, and adding a duplicate replaces
+ * the existing item.
+ *
+ * @example
+ *   const set = new KeyedSet<{ id: number; name: string }, number>(
+ *     (item) => item.id,
+ *   );
+ *   set.add({ id: 1, name: 'one' });
+ *   set.add({ id: 1, name: 'replaced' }); // replaces previous item
+ *   set.getByKey(1); // { id: 1, name: 'replaced' }
+ *
+ * @template T - The type of items stored in the set
+ * @template K - The type of the key extracted from items
+ */
+declare class KeyedSet<T, K = string> {
+  private map;
+  private getKey;
+  /**
+   * @param getKey - Function to extract a unique key from each item
+   * @param iterable - Optional initial items to add to the set
+   */
+  constructor(getKey: (item: T) => K, iterable?: Iterable<T>);
+  /** The number of items in the set */
+  get size(): number;
+  /**
+   * Adds an item to the set. If an item with the same key exists, it will be
+   * replaced.
+   */
+  add(item: T): this;
+  /** Adds multiple items to the set. */
+  addMultiple(items: Iterable<T>): this;
+  /** Checks if an item with the same key exists in the set. */
+  has(item: T): boolean;
+  /** Checks if an item with the given key exists in the set. */
+  hasKey(key: K): boolean;
+  /** Gets an item by its key, or undefined if not found. */
+  getByKey(key: K): T | undefined;
+  /**
+   * Removes an item from the set by computing its key. Returns true if the item
+   * was removed.
+   */
+  delete(item: T): boolean;
+  /** Removes an item by its key. Returns true if the item was removed. */
+  deleteByKey(key: K): boolean;
+  /** Removes multiple items from the set. Returns the number of items removed. */
+  deleteMultiple(items: Iterable<T>): number;
+  /** Removes multiple items by their keys. Returns the number of items removed. */
+  deleteMultipleByKeys(keys: Iterable<K>): number;
+  /** Removes all items from the set. */
+  clear(): void;
+  /** Executes a callback for each item in the set. */
+  forEach(callback: (value: T, value2: T, set: KeyedSet<T, K>) => void, thisArg?: unknown): void;
+  values(): IterableIterator<T>;
+  keys(): IterableIterator<T>;
+  entries(): IterableIterator<[T, T]>;
+  [Symbol.iterator](): IterableIterator<T>;
+  /** Returns all items as an array. */
+  toArray(): T[];
+}
+/**
+ * A Set that compares items by value instead of reference. Uses
+ * `getCompositeKey` to generate a stable string key for any value.
+ *
+ * @example
+ *   const set = new ValueSet<{ x: number; y: number }>();
+ *   set.add({ x: 1, y: 2 });
+ *   set.add({ x: 1, y: 2 }); // ignored, same value already exists
+ *   set.size; // 1
+ */
+declare class CompositeKeySet<T> extends KeyedSet<T, string> {
+  constructor(iterable?: Iterable<T>);
+}
+//#endregion
+export { CompositeKeySet, KeyedSet };

package/dist/keyedSet.mjs

@@ -0,0 +1,129 @@
+import { getCompositeKey } from "./getCompositeKey.mjs";
+
+//#region src/keyedSet.ts
+/**
+* A Set implementation that uses a custom key function to determine uniqueness.
+* Items with the same key are considered equal, and adding a duplicate replaces
+* the existing item.
+*
+* @example
+*   const set = new KeyedSet<{ id: number; name: string }, number>(
+*     (item) => item.id,
+*   );
+*   set.add({ id: 1, name: 'one' });
+*   set.add({ id: 1, name: 'replaced' }); // replaces previous item
+*   set.getByKey(1); // { id: 1, name: 'replaced' }
+*
+* @template T - The type of items stored in the set
+* @template K - The type of the key extracted from items
+*/
+var KeyedSet = class {
+	map;
+	getKey;
+	/**
+	* @param getKey - Function to extract a unique key from each item
+	* @param iterable - Optional initial items to add to the set
+	*/
+	constructor(getKey, iterable) {
+		this.getKey = getKey;
+		this.map = /* @__PURE__ */ new Map();
+		if (iterable) for (const item of iterable) this.add(item);
+	}
+	/** The number of items in the set */
+	get size() {
+		return this.map.size;
+	}
+	/**
+	* Adds an item to the set. If an item with the same key exists, it will be
+	* replaced.
+	*/
+	add(item) {
+		const key = this.getKey(item);
+		this.map.set(key, item);
+		return this;
+	}
+	/** Adds multiple items to the set. */
+	addMultiple(items) {
+		for (const item of items) this.add(item);
+		return this;
+	}
+	/** Checks if an item with the same key exists in the set. */
+	has(item) {
+		const key = this.getKey(item);
+		return this.map.has(key);
+	}
+	/** Checks if an item with the given key exists in the set. */
+	hasKey(key) {
+		return this.map.has(key);
+	}
+	/** Gets an item by its key, or undefined if not found. */
+	getByKey(key) {
+		return this.map.get(key);
+	}
+	/**
+	* Removes an item from the set by computing its key. Returns true if the item
+	* was removed.
+	*/
+	delete(item) {
+		const key = this.getKey(item);
+		return this.map.delete(key);
+	}
+	/** Removes an item by its key. Returns true if the item was removed. */
+	deleteByKey(key) {
+		return this.map.delete(key);
+	}
+	/** Removes multiple items from the set. Returns the number of items removed. */
+	deleteMultiple(items) {
+		let count = 0;
+		for (const item of items) if (this.delete(item)) count++;
+		return count;
+	}
+	/** Removes multiple items by their keys. Returns the number of items removed. */
+	deleteMultipleByKeys(keys) {
+		let count = 0;
+		for (const key of keys) if (this.deleteByKey(key)) count++;
+		return count;
+	}
+	/** Removes all items from the set. */
+	clear() {
+		this.map.clear();
+	}
+	/** Executes a callback for each item in the set. */
+	forEach(callback, thisArg) {
+		for (const value of this.map.values()) callback.call(thisArg, value, value, this);
+	}
+	*values() {
+		yield* this.map.values();
+	}
+	*keys() {
+		yield* this.map.values();
+	}
+	*entries() {
+		for (const value of this.map.values()) yield [value, value];
+	}
+	[Symbol.iterator]() {
+		return this.values();
+	}
+	/** Returns all items as an array. */
+	toArray() {
+		return [...this.map.values()];
+	}
+};
+/**
+* A Set that compares items by value instead of reference. Uses
+* `getCompositeKey` to generate a stable string key for any value.
+*
+* @example
+*   const set = new ValueSet<{ x: number; y: number }>();
+*   set.add({ x: 1, y: 2 });
+*   set.add({ x: 1, y: 2 }); // ignored, same value already exists
+*   set.size; // 1
+*/
+var CompositeKeySet = class extends KeyedSet {
+	constructor(iterable) {
+		super(getCompositeKey, iterable);
+	}
+};
+
+//#endregion
+export { CompositeKeySet, KeyedSet };

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

@@ -1,5 +1,6 @@
+//#region src/levenshtein.d.ts
 declare function levenshteinDistance(a: string, b: string): number;
 declare function getClosestString(str: string, arr: readonly string[], maxDistance?: number): string | undefined;
 declare function getClosestStringsUpToDist(str: string, arr: readonly string[], maxDistance?: number): string[];
-
-export { getClosestString, getClosestStringsUpToDist, levenshteinDistance };
+//#endregion
+export { getClosestString, getClosestStringsUpToDist, levenshteinDistance };