@ls-stack/utils 3.63.0 → 3.66.0

package/dist/filterObjectOrArrayKeys.mjs

@@ -0,0 +1,497 @@
+import { a as isPlainObject } from "./typeGuards-B1mzA-Rz.mjs";
+import { sortBy } from "./arrayUtils.mjs";
+
+//#region src/filterObjectOrArrayKeys.ts
+const ID_PROP_REGEXP = /^(id_|key_|id-|key-)|(_id|_key|-id|-key)$/i;
+/**
+* Filters the keys of an object based on the provided patterns.
+*
+* 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
+* - Pattern expansion with parentheses:
+*
+*   - `'prop.test.(prop1|prop2|prop3)'` - Expands to `prop.test.prop1`,
+*       `prop.test.prop2`, and `prop.test.prop3`
+*   - `'components[*].(table_id|columns|filters[*].value)'` - Expands to
+*       `components[*].table_id`, `components[*].columns`, and
+*       `components[*].filters[*].value`
+*   - `'(users|admins)[*].name'` - Expands to `users[*].name` and `admins[*].name`
+* - Array filtering by value:
+*
+*   - `'users[%name="John"]'` - Filters the `users` with the `name` property equal
+*       to `John`
+*   - `'users[%name="John" | "Jane"]'` - Value-level OR using `|` for multiple
+*       values of same property
+*   - `'users[%name="Alice" || %age=35]'` - Property-level OR using `||` for
+*       different properties
+*   - `'users[%age=30 && %role="admin"]'` - Property-level AND using `&&` for
+*       different properties
+*   - Note: Mixing `&&` and `||` in the same filter is not supported - use separate
+*       filter patterns instead
+*   - `'users[%config.name="John" | "Jane"]'` - Dot notation is supported
+*   - `'users[%name*="oh"]'` - Contains operator (*=) - filters users where name
+*       contains "oh"
+*   - `'users[%name^="Jo"]'` - Starts with operator (^=) - filters users where name
+*       starts with "Jo"
+*   - `'users[%name$="hn"]'` - Ends with operator ($=) - filters users where name
+*       ends with "hn"
+*   - `'users[%name!="John"]'` - Not equal operator (!=) - filters users where name
+*       is not "John"
+*   - `'users[%name!*="admin"]'` - Not contains operator (!*=) - filters users
+*       where name doesn't contain "admin"
+*   - `'users[i%name="john"]'` - Case-insensitive matching (i% prefix) - matches
+*       "John", "JOHN", "john", etc.
+*
+* @param objOrArray - The object or array to filter.
+* @param options - The options for the filter.
+* @param options.filterKeys - The keys to filter.
+* @param options.rejectKeys - The keys to reject.
+* @param options.rejectEmptyObjectsInArray - Whether to reject empty objects in
+*   arrays (default: true).
+* @param options.sortKeys - Sort all keys by a specific order (optional,
+*   preserves original order when not specified).
+* @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 filtered object or array.
+*/
+function filterObjectOrArrayKeys(objOrArray, { filterKeys, rejectKeys, rejectEmptyObjectsInArray = true, sortKeys = "simpleValuesFirst", sortPatterns }) {
+	function getNestedValue(obj, path) {
+		const parts = path.split(".");
+		let current = obj;
+		for (const part of parts) {
+			if (current == null || typeof current !== "object") return;
+			current = current[part];
+		}
+		return current;
+	}
+	function evaluateCondition(item, condition) {
+		const value = getNestedValue(item, condition.property);
+		let valueStr = String(value);
+		if (condition.caseInsensitive) valueStr = valueStr.toLowerCase();
+		const processValue = (v) => condition.caseInsensitive ? v.toLowerCase() : v;
+		switch (condition.operator) {
+			case "=": return condition.values.some((v) => valueStr === processValue(v));
+			case "!=": return condition.values.every((v) => valueStr !== processValue(v));
+			case "*=": return condition.values.some((v) => valueStr.includes(processValue(v)));
+			case "!*=": return condition.values.every((v) => !valueStr.includes(processValue(v)));
+			case "^=": return condition.values.some((v) => valueStr.startsWith(processValue(v)));
+			case "!^=": return condition.values.every((v) => !valueStr.startsWith(processValue(v)));
+			case "$=": return condition.values.some((v) => valueStr.endsWith(processValue(v)));
+			case "!$=": return condition.values.every((v) => !valueStr.endsWith(processValue(v)));
+			default: return false;
+		}
+	}
+	const toArray = (v) => v === void 0 ? [] : Array.isArray(v) ? v : [v];
+	const filterPatternsRaw = toArray(filterKeys);
+	const rejectPatternsRaw = toArray(rejectKeys);
+	const hasFilters = filterPatternsRaw.length > 0;
+	const hasRejects = rejectPatternsRaw.length > 0;
+	const expandedFilterPatterns = filterPatternsRaw.flatMap(expandPatterns);
+	const expandedRejectPatterns = rejectPatternsRaw.flatMap(expandPatterns);
+	const { filterOnlyPatterns, combinedPatterns } = separateFilterPatterns(expandedFilterPatterns);
+	const filterPatterns = filterOnlyPatterns.map(parsePattern);
+	const rejectPatterns = expandedRejectPatterns.map(parsePattern);
+	const sortPatternsParsed = toArray(sortPatterns).flatMap(expandPatterns).map(parsePattern);
+	let dataToProcess = objOrArray;
+	if (combinedPatterns.length > 0) {
+		const groupedByFilter = /* @__PURE__ */ new Map();
+		for (const { filterPart, fieldPart } of combinedPatterns) {
+			if (!groupedByFilter.has(filterPart)) groupedByFilter.set(filterPart, []);
+			groupedByFilter.get(filterPart).push(fieldPart);
+		}
+		const combinedResult = Array.isArray(objOrArray) ? [] : {};
+		for (const [filterPart, fieldParts] of groupedByFilter) {
+			const fieldSelectedResult = filterObjectOrArrayKeys(filterObjectOrArrayKeys(objOrArray, {
+				filterKeys: [filterPart],
+				rejectKeys,
+				rejectEmptyObjectsInArray
+			}), {
+				filterKeys: fieldParts,
+				rejectEmptyObjectsInArray
+			});
+			if (Array.isArray(combinedResult) && Array.isArray(fieldSelectedResult)) combinedResult.push(...fieldSelectedResult);
+			else if (!Array.isArray(combinedResult) && !Array.isArray(fieldSelectedResult)) Object.assign(combinedResult, fieldSelectedResult);
+		}
+		if (filterOnlyPatterns.length === 0) return combinedResult;
+		dataToProcess = combinedResult;
+	}
+	function matchPath(path, pattern, value) {
+		function rec(pi, pti) {
+			if (pti >= pattern.length) return pi === path.length;
+			const pt = pattern[pti];
+			if (pt.type === "WILDCARD_ANY") {
+				if (rec(pi, pti + 1)) return true;
+				if (pi < path.length) return rec(pi + 1, pti);
+				return false;
+			}
+			if (pt.type === "WILDCARD_ONE") {
+				let j = pi;
+				let sawKey = false;
+				while (j < path.length) {
+					if (path[j].type === "KEY") sawKey = true;
+					if (sawKey && rec(j, pti + 1)) return true;
+					j += 1;
+				}
+				return false;
+			}
+			if (pi >= path.length) return false;
+			const ct = path[pi];
+			switch (pt.type) {
+				case "KEY":
+					if (ct.type === "KEY" && ct.name === pt.name) return rec(pi + 1, pti + 1);
+					if (ct.type === "INDEX") return rec(pi + 1, pti);
+					return false;
+				case "INDEX":
+					if (ct.type === "INDEX" && ct.index === pt.index) return rec(pi + 1, pti + 1);
+					return false;
+				case "INDEX_ANY":
+					if (ct.type === "INDEX") return rec(pi + 1, pti + 1);
+					return false;
+				case "INDEX_RANGE":
+					if (ct.type === "INDEX") {
+						const okLower = ct.index >= pt.start;
+						const okUpper = pt.end === null ? true : ct.index <= pt.end;
+						if (okLower && okUpper) return rec(pi + 1, pti + 1);
+					}
+					return false;
+				case "INDEX_FILTER":
+					if (ct.type === "INDEX" && value !== void 0) {
+						const results = pt.conditions.map((cond) => evaluateCondition(value, cond));
+						if (pt.logic === "AND" ? results.every((r) => r) : results.some((r) => r)) return rec(pi + 1, pti + 1);
+					}
+					return false;
+			}
+		}
+		return rec(0, 0);
+	}
+	const matchesAnyFilter = (path, value) => filterPatterns.some((p) => matchPath(path, p, value));
+	const matchesAnyReject = (path, value) => rejectPatterns.some((p) => matchPath(path, p, value));
+	function getSortPriority(path) {
+		for (let i = 0; i < sortPatternsParsed.length; i++) if (matchPath(path, sortPatternsParsed[i])) return i;
+		return sortPatternsParsed.length;
+	}
+	function applySortKeys(keys, obj, sortOrder) {
+		if (sortOrder === "asc") return [...keys].sort();
+		if (sortOrder === "desc") return [...keys].sort().reverse();
+		return sortBy(sortBy(keys, (k) => k), (key) => {
+			const value = obj[key];
+			if (value !== void 0 && value !== null) {
+				if (Array.isArray(value) && value.length === 0) return 0;
+				if (isPlainObject(value)) return 1.99 + Object.keys(value).length * -.001;
+				if (Array.isArray(value)) if (value.every((item) => typeof item === "string" || typeof item === "number" || typeof item === "boolean" || item === null || item === void 0)) return 1.9 + value.length * -.001;
+				else return 1.5 + value.length * -.01;
+				if (key === "id" || key === "key") return 5;
+				if (ID_PROP_REGEXP.test(key)) return 4.5;
+				if (typeof value === "boolean") return 4;
+				if (typeof value === "number") return 3.5;
+				if (typeof value === "string" && value.length < 20) return 3;
+				return 2;
+			}
+			return 0;
+		}, "desc");
+	}
+	function sortKeysWithPatterns(keys_, obj, currentPath) {
+		if (!sortKeys && sortPatternsParsed.length === 0) return keys_;
+		let keysToSort = keys_;
+		if (sortKeys) keysToSort = applySortKeys(keysToSort, obj, sortKeys);
+		return [...keysToSort].sort((a, b) => {
+			const pathA = currentPath.concat({
+				type: "KEY",
+				name: a
+			});
+			const pathB = currentPath.concat({
+				type: "KEY",
+				name: b
+			});
+			const priorityA = getSortPriority(pathA);
+			const priorityB = getSortPriority(pathB);
+			if (priorityA !== priorityB) return priorityA - priorityB;
+			if (sortKeys === "desc") return b.localeCompare(a);
+			if (sortKeys === "asc") return a.localeCompare(b);
+			return 0;
+		});
+	}
+	const build = (value, path, allowedByFilter, stack, isRoot, parentIsArray) => {
+		if (Array.isArray(value)) {
+			if (stack.has(value)) throw new TypeError("Circular references are not supported");
+			stack.add(value);
+			const out = [];
+			const includeAllChildren = allowedByFilter || !hasFilters;
+			for (let index = 0; index < value.length; index += 1) {
+				const childPath = path.concat({
+					type: "INDEX",
+					index
+				});
+				const child = value[index];
+				if (hasRejects && matchesAnyReject(childPath, child)) continue;
+				const directInclude = hasFilters ? matchesAnyFilter(childPath, child) : true;
+				const childAllowed = includeAllChildren || directInclude;
+				if (isPlainObject(child) || Array.isArray(child)) {
+					const builtChild = build(child, childPath, childAllowed, stack, false, true);
+					if (builtChild !== void 0) out.push(builtChild);
+				} else if (childAllowed) out.push(child);
+			}
+			stack.delete(value);
+			const filteredOut = rejectEmptyObjectsInArray ? out.filter((item) => !(isPlainObject(item) && Object.keys(item).length === 0)) : out;
+			if (filteredOut.length === 0 && !allowedByFilter && !isRoot) return void 0;
+			return filteredOut;
+		}
+		if (isPlainObject(value)) {
+			if (stack.has(value)) throw new TypeError("Circular references are not supported");
+			stack.add(value);
+			const result = {};
+			const includeAllChildren = allowedByFilter || !hasFilters;
+			const sortedKeys = sortKeysWithPatterns(Object.keys(value), value, path);
+			for (const key of sortedKeys) {
+				const childPath = path.concat({
+					type: "KEY",
+					name: key
+				});
+				if (hasRejects && matchesAnyReject(childPath)) continue;
+				const val = value[key];
+				const directInclude = hasFilters ? matchesAnyFilter(childPath) : true;
+				const childAllowed = includeAllChildren || directInclude;
+				if (isPlainObject(val) || Array.isArray(val)) {
+					const builtChild = build(val, childPath, childAllowed, stack, false, false);
+					if (builtChild === void 0) continue;
+					if (Array.isArray(builtChild) && builtChild.length === 0 && !childAllowed) continue;
+					if (isPlainObject(builtChild) && Object.keys(builtChild).length === 0 && !childAllowed) continue;
+					result[key] = builtChild;
+				} else if (childAllowed) result[key] = val;
+			}
+			stack.delete(value);
+			if (Object.keys(result).length === 0 && !allowedByFilter && !isRoot) {
+				if (parentIsArray && !rejectEmptyObjectsInArray) return {};
+				return;
+			}
+			return result;
+		}
+		return allowedByFilter || !hasFilters ? value : void 0;
+	};
+	const built = build(dataToProcess, [], !hasFilters, /* @__PURE__ */ new WeakSet(), true, false);
+	if (built === void 0) return Array.isArray(dataToProcess) ? [] : {};
+	return built;
+}
+function parseFilterConditions(filterContent) {
+	const conditions = [];
+	let logic = "AND";
+	const caseInsensitive = filterContent.startsWith("i");
+	const content = caseInsensitive ? filterContent.slice(1) : filterContent;
+	const hasAnd = content.includes("&&");
+	const hasOr = content.includes(" || ");
+	if (hasAnd && hasOr) throw new Error("Mixing && and || operators in the same filter is not supported. Use separate filter patterns instead.");
+	const andGroups = content.split("&&").map((s) => s.trim());
+	for (const andGroup of andGroups) if (andGroup.includes(" || ")) {
+		logic = "OR";
+		const orConditions = andGroup.split(" || ").map((s) => s.trim());
+		for (const orCondition of orConditions) {
+			const parsed = parseSingleCondition(orCondition, caseInsensitive);
+			if (parsed) conditions.push(parsed);
+		}
+	} else {
+		const parsed = parseSingleCondition(andGroup, caseInsensitive);
+		if (parsed) conditions.push(parsed);
+	}
+	if (conditions.length === 0) return null;
+	return {
+		type: "INDEX_FILTER",
+		conditions,
+		logic
+	};
+}
+function parseSingleCondition(condition, caseInsensitive = false) {
+	const cleanCondition = condition.startsWith("%") ? condition.slice(1) : condition;
+	let operator = null;
+	let operatorIndex = -1;
+	let operatorLength = 0;
+	for (const [op, opType] of [
+		["!*=", "!*="],
+		["!^=", "!^="],
+		["!$=", "!$="],
+		["!=", "!="],
+		["*=", "*="],
+		["^=", "^="],
+		["$=", "$="],
+		["=", "="]
+	]) {
+		const index = cleanCondition.indexOf(op);
+		if (index !== -1) {
+			operator = opType;
+			operatorIndex = index;
+			operatorLength = op.length;
+			break;
+		}
+	}
+	if (operator === null || operatorIndex === -1) return null;
+	const property = cleanCondition.slice(0, operatorIndex).trim();
+	const valueStr = cleanCondition.slice(operatorIndex + operatorLength).trim();
+	const values = [];
+	if (valueStr.includes(" | ")) {
+		const parts = valueStr.split(" | ");
+		for (const part of parts) {
+			const trimmed = part.trim();
+			const value = trimmed.startsWith("\"") && trimmed.endsWith("\"") ? trimmed.slice(1, -1) : trimmed;
+			values.push(value);
+		}
+	} else {
+		const trimmed = valueStr.trim();
+		const value = trimmed.startsWith("\"") && trimmed.endsWith("\"") ? trimmed.slice(1, -1) : trimmed;
+		values.push(value);
+	}
+	return {
+		property,
+		operator,
+		values,
+		caseInsensitive
+	};
+}
+function separateFilterPatterns(patterns) {
+	const filterOnlyPatterns = [];
+	const combinedPatterns = [];
+	for (const pattern of patterns) {
+		const filterMatch = pattern.match(/^(.+\[[i%][^[\]]*\])\.(.+)$/);
+		if (filterMatch?.[1] && filterMatch[2]) {
+			const filterPart = filterMatch[1];
+			const fieldPart = filterMatch[2];
+			const baseArrayPath = filterPart.replace(/\[[i%][^[\]]*\]/, "[*]");
+			combinedPatterns.push({
+				filterPart,
+				fieldPart: `${baseArrayPath}.${fieldPart}`
+			});
+		} else filterOnlyPatterns.push(pattern);
+	}
+	return {
+		filterOnlyPatterns,
+		combinedPatterns
+	};
+}
+function expandPatterns(pattern) {
+	function expandSingle(str) {
+		const start = str.indexOf("(");
+		if (start === -1) return [str];
+		const end = str.indexOf(")", start);
+		if (end === -1) return [str];
+		const before = str.slice(0, start);
+		const inside = str.slice(start + 1, end);
+		const after = str.slice(end + 1);
+		if (!inside.includes("|")) return expandSingle(before + inside + after);
+		const options = inside.split("|").filter((option) => option.trim().length > 0);
+		const results = [];
+		for (const option of options) {
+			const newStr = before + option + after;
+			results.push(...expandSingle(newStr));
+		}
+		return results;
+	}
+	return expandSingle(pattern);
+}
+function parsePattern(pattern) {
+	const tokens = [];
+	let i = 0;
+	const n = pattern.length;
+	const pushKey = (name) => {
+		if (name.length === 0) return;
+		tokens.push({
+			type: "KEY",
+			name
+		});
+	};
+	while (i < n) {
+		const ch = pattern[i];
+		if (ch === ".") {
+			i += 1;
+			continue;
+		}
+		if (ch === "[") {
+			const end = pattern.indexOf("]", i + 1);
+			const inside = end === -1 ? pattern.slice(i + 1) : pattern.slice(i + 1, end);
+			if (inside.startsWith("%") || inside.startsWith("i%")) {
+				let filterContent;
+				if (inside.startsWith("i%")) filterContent = `i${inside.slice(2)}`;
+				else if (inside.startsWith("%")) filterContent = inside.slice(1);
+				else filterContent = inside;
+				const filterToken = parseFilterConditions(filterContent);
+				if (filterToken) tokens.push(filterToken);
+			} else if (inside === "*") tokens.push({ type: "INDEX_ANY" });
+			else if (inside.includes("-")) {
+				const parts = inside.split("-");
+				const startStr = parts[0] ?? "";
+				const endStr = parts[1] ?? "";
+				const start = parseInt(startStr, 10);
+				const endNum = endStr === "*" ? null : parseInt(endStr, 10);
+				tokens.push({
+					type: "INDEX_RANGE",
+					start,
+					end: endNum === null || Number.isFinite(endNum) ? endNum : null
+				});
+			} else if (inside.length > 0) {
+				const idx = parseInt(inside, 10);
+				tokens.push({
+					type: "INDEX",
+					index: idx
+				});
+			}
+			i = end === -1 ? n : end + 1;
+			continue;
+		}
+		if (ch === "*") if (pattern[i + 1] === "*") {
+			tokens.push({ type: "WILDCARD_ANY" });
+			i += 2;
+			let j$1 = i;
+			while (j$1 < n) {
+				const c = pattern[j$1];
+				if (c === "." || c === "[") break;
+				j$1 += 1;
+			}
+			if (j$1 > i) {
+				pushKey(pattern.slice(i, j$1));
+				i = j$1;
+			}
+			continue;
+		} else {
+			tokens.push({ type: "WILDCARD_ONE" });
+			i += 1;
+			continue;
+		}
+		let j = i;
+		while (j < n) {
+			const c = pattern[j];
+			if (c === "." || c === "[") break;
+			j += 1;
+		}
+		pushKey(pattern.slice(i, j));
+		i = j;
+	}
+	return tokens;
+}
+
+//#endregion
+export { filterObjectOrArrayKeys };

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

@@ -1,3 +1,4 @@
+//#region src/getAutoIncrementId.d.ts
 /**
  * Returns a unique auto-incrementing number each time it's called. This is
  * useful for generating simple unique identifiers within a single
@@ -38,9 +39,12 @@ declare function getAutoIncrementId(): number;
  * @param options.suffix - Optional suffix to append to each generated ID
  * @returns A function that generates formatted auto-increment IDs
  */
-declare function getLocalAutoIncrementIdGenerator({ prefix, suffix, }: {
-    prefix?: string;
-    suffix?: string;
+declare function getLocalAutoIncrementIdGenerator({
+  prefix,
+  suffix
+}: {
+  prefix?: string;
+  suffix?: string;
 }): () => string;
-
-export { getAutoIncrementId, getLocalAutoIncrementIdGenerator };
+//#endregion
+export { getAutoIncrementId, getLocalAutoIncrementIdGenerator };

package/dist/getAutoIncrementId.mjs

@@ -0,0 +1,53 @@
+//#region src/getAutoIncrementId.ts
+let id = 1;
+/**
+* Returns a unique auto-incrementing number each time it's called. This is
+* useful for generating simple unique identifiers within a single
+* session/process.
+*
+* **Note:** This is not suitable for distributed systems or persistent storage.
+* For cryptographically secure or collision-resistant IDs, use `nanoid()`
+* instead.
+*
+* @example
+*   ```ts
+*   const id1 = getAutoIncrementId(); // 1
+*   const id2 = getAutoIncrementId(); // 2
+*   const id3 = getAutoIncrementId(); // 3
+*   ```;
+*
+* @returns A unique incrementing number starting from 1
+*/
+function getAutoIncrementId() {
+	return id++;
+}
+/**
+* Creates a local auto-increment ID generator with optional prefix and suffix.
+* Each generator maintains its own independent counter starting from 1. This is
+* useful when you need multiple independent ID sequences or formatted IDs.
+*
+* @example
+*   ```ts
+*   const userIdGen = getLocalAutoIncrementIdGenerator({ prefix: 'user-' });
+*   const postIdGen = getLocalAutoIncrementIdGenerator({ prefix: 'post-', suffix: '-draft' });
+*
+*   console.log(userIdGen()); // "user-1"
+*   console.log(userIdGen()); // "user-2"
+*   console.log(postIdGen()); // "post-1-draft"
+*   console.log(postIdGen()); // "post-2-draft"
+*   ```;
+*
+* @param options - Configuration object
+* @param options.prefix - Optional prefix to prepend to each generated ID
+* @param options.suffix - Optional suffix to append to each generated ID
+* @returns A function that generates formatted auto-increment IDs
+*/
+function getLocalAutoIncrementIdGenerator({ prefix, suffix }) {
+	let localId = 1;
+	return () => {
+		return `${prefix || ""}${localId++}${suffix || ""}`;
+	};
+}
+
+//#endregion
+export { getAutoIncrementId, getLocalAutoIncrementIdGenerator };

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

@@ -1,3 +1,4 @@
+//#region src/getCompositeKey.d.ts
 /**
  * Returns a stable key for the input value.
  *
@@ -7,5 +8,5 @@
  * @returns A stable key for the input value.
  */
 declare function getCompositeKey(input: unknown, maxSortingDepth?: number): string;
-
-export { getCompositeKey };
+//#endregion
+export { getCompositeKey };

package/dist/getCompositeKey.mjs

@@ -0,0 +1,50 @@
+import { o as isObject } from "./assertions-qMxfVhSu.mjs";
+
+//#region src/getCompositeKey.ts
+/**
+* Returns a stable key for the input value.
+*
+* @param input - The value to get a stable key for.
+* @param maxSortingDepth - The maximum depth to sort the input value. Default
+*   is 3.
+* @returns A stable key for the input value.
+*/
+function getCompositeKey(input, maxSortingDepth = 3) {
+	if (typeof input === "string") return `"${input}`;
+	if (!input || typeof input !== "object") return `$${input}`;
+	return stringifyCompact(input, maxSortingDepth, 0, /* @__PURE__ */ new WeakSet());
+}
+function stringifyCompact(input, maxSortingDepth, depth, refs) {
+	const isJsObj = input && typeof input === "object";
+	if (isJsObj) {
+		if (refs.has(input)) throw new Error("Circular reference detected");
+		refs.add(input);
+	}
+	let result;
+	if (Array.isArray(input)) {
+		result = "[";
+		for (const v of input) {
+			if (result.length > 1) result += ",";
+			result += stringifyCompact(v, maxSortingDepth, depth + 1, refs);
+		}
+		result += "]";
+	} else if (isObject(input)) {
+		let entries = Object.entries(input);
+		if (entries.length === 0) result = "{}";
+		else {
+			if (depth < maxSortingDepth) entries = entries.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+			result = "{";
+			for (const [k, v] of entries) {
+				if (v === void 0) continue;
+				if (result.length > 1) result += ",";
+				result += `${k}:${stringifyCompact(v, maxSortingDepth, depth + 1, refs)}`;
+			}
+			result += "}";
+		}
+	} else result = JSON.stringify(input);
+	if (isJsObj) refs.delete(input);
+	return result;
+}
+
+//#endregion
+export { getCompositeKey };

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

@@ -1,4 +1,6 @@
-import { getCompositeKey } from './getCompositeKey.cjs';
+import { getCompositeKey } from "./getCompositeKey.mjs";
+
+//#region src/getValueStableKey.d.ts
 
 /**
  * Returns a stable key for the input value.
@@ -11,5 +13,5 @@ import { getCompositeKey } from './getCompositeKey.cjs';
  * @returns A stable key for the input value.
  */
 declare const getValueStableKey: typeof getCompositeKey;
-
-export { getValueStableKey };
+//#endregion
+export { getValueStableKey };

package/dist/getValueStableKey.mjs

@@ -0,0 +1,17 @@
+import { getCompositeKey } from "./getCompositeKey.mjs";
+
+//#region src/getValueStableKey.ts
+/**
+* Returns a stable key for the input value.
+*
+* @deprecated Use `getCompositeKey` from `@ls-stack/utils/getCompositeKey`
+*   instead.
+* @param input - The value to get a stable key for.
+* @param maxSortingDepth - The maximum depth to sort the input value. Default
+*   is 3.
+* @returns A stable key for the input value.
+*/
+const getValueStableKey = getCompositeKey;
+
+//#endregion
+export { getValueStableKey };

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

@@ -1,7 +1,8 @@
+//#region src/hash.d.ts
 /**
  * @param str - The string to hash.
  * @returns The hash of the string.
  */
 declare function murmur2(str: string): string;
-
-export { murmur2 };
+//#endregion
+export { murmur2 };