@ls-stack/utils 3.45.0 → 3.47.0

package/dist/chunk-PUKVXYYL.js

@@ -0,0 +1,52 @@
+import {
+  isPlainObject
+} from "./chunk-JF2MDHOJ.js";
+
+// 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) => {
+          const itemPath = path ? `${path}[${index}]` : `[${index}]`;
+          return processValue(item, itemPath);
+        });
+      } 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)) {
+          const itemPath = path ? `${path}.${key}` : key;
+          result[key] = processValue(itemValue, itemPath);
+        }
+        return result;
+      } finally {
+        visited.delete(val);
+      }
+    }
+    return val;
+  }
+  return processValue(value, currentPath);
+}
+function deepReplaceValues(value, replaceValues) {
+  return applyValueReplacements(value, replaceValues, /* @__PURE__ */ new Set(), "");
+}
+
+export {
+  deepReplaceValues
+};

package/dist/deepReplaceValues.cjs

@@ -0,0 +1,87 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/deepReplaceValues.ts
+var deepReplaceValues_exports = {};
+__export(deepReplaceValues_exports, {
+  deepReplaceValues: () => deepReplaceValues
+});
+module.exports = __toCommonJS(deepReplaceValues_exports);
+
+// src/typeGuards.ts
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object) return true;
+  const objectCtorString = Object.prototype.constructor.toString();
+  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+}
+
+// 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) => {
+          const itemPath = path ? `${path}[${index}]` : `[${index}]`;
+          return processValue(item, itemPath);
+        });
+      } 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)) {
+          const itemPath = path ? `${path}.${key}` : key;
+          result[key] = processValue(itemValue, itemPath);
+        }
+        return result;
+      } finally {
+        visited.delete(val);
+      }
+    }
+    return val;
+  }
+  return processValue(value, currentPath);
+}
+function deepReplaceValues(value, replaceValues) {
+  return applyValueReplacements(value, replaceValues, /* @__PURE__ */ new Set(), "");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  deepReplaceValues
+});

package/dist/deepReplaceValues.d.cts

@@ -0,0 +1,27 @@
+/**
+ * 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] }
+ */
+declare function deepReplaceValues<T, R = T>(value: T, replaceValues: (value: unknown, path: string) => false | {
+    newValue: unknown;
+}): R;
+
+export { deepReplaceValues };

package/dist/deepReplaceValues.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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] }
+ */
+declare function deepReplaceValues<T, R = T>(value: T, replaceValues: (value: unknown, path: string) => false | {
+    newValue: unknown;
+}): R;
+
+export { deepReplaceValues };

package/dist/deepReplaceValues.js

@@ -0,0 +1,7 @@
+import {
+  deepReplaceValues
+} from "./chunk-PUKVXYYL.js";
+import "./chunk-JF2MDHOJ.js";
+export {
+  deepReplaceValues
+};

package/dist/matchPath.cjs

@@ -39,12 +39,18 @@ function fastCache({ maxCacheSize = 1e3 } = {}) {
   }
   function getOrInsert(cacheKey, val) {
     if (!cache2.has(cacheKey)) {
-      cache2.set(cacheKey, val());
+      const value = val();
+      cache2.set(cacheKey, value);
       trimCache();
+      return cache2.get(cacheKey) ?? value;
     }
     return cache2.get(cacheKey);
   }
-  return { getOrInsert, clear: () => cache2.clear() };
+  return {
+    getOrInsert,
+    /** Clears all cached values */
+    clear: () => cache2.clear()
+  };
 }
 
 // src/matchPath.ts

package/dist/matchPath.js

@@ -1,6 +1,6 @@
 import {
   fastCache
-} from "./chunk-OIAGLRII.js";
+} from "./chunk-AULH7VMS.js";
 import "./chunk-5MNYPLZI.js";
 import "./chunk-HTCYUMDR.js";
 import "./chunk-II4R3VVX.js";

package/dist/partialEqual.cjs

@@ -92,11 +92,13 @@ function deepEqual(foo, bar, maxDepth = 20) {
 // src/partialEqual.ts
 var has2 = Object.prototype.hasOwnProperty;
 function createComparison(type) {
-  return {
-    "~sc": type
-  };
+  return { "~sc": type };
 }
 var match = {
+  noExtraKeys: (partialShape) => createComparison(["withNoExtraKeys", partialShape]),
+  deepNoExtraKeys: (partialShape) => createComparison(["withDeepNoExtraKeys", partialShape]),
+  noExtraDefinedKeys: (partialShape) => createComparison(["noExtraDefinedKeys", partialShape]),
+  deepNoExtraDefinedKeys: (partialShape) => createComparison(["deepNoExtraDefinedKeys", partialShape]),
   hasType: {
     string: createComparison(["hasType", "string"]),
     number: createComparison(["hasType", "number"]),
@@ -137,6 +139,7 @@ var match = {
       array: createComparison(["not", ["hasType", "array"]]),
       function: createComparison(["not", ["hasType", "function"]])
     },
+    keyNotBePresent: createComparison(["not", ["keyNotBePresent", null]]),
     isInstanceOf: (constructor) => createComparison(["not", ["isInstanceOf", constructor]]),
     str: {
       contains: (substring) => createComparison(["not", ["strContains", substring]]),
@@ -158,7 +161,11 @@ var match = {
     partialEqual: (value) => createComparison(["not", ["partialEqual", value]]),
     custom: (value) => createComparison(["not", ["custom", value]]),
     any: (...comparisons) => createComparison(["not", ["any", comparisons.map((c) => c["~sc"])]]),
-    all: (...comparisons) => createComparison(["not", ["all", comparisons.map((c) => c["~sc"])]])
+    all: (...comparisons) => createComparison(["not", ["all", comparisons.map((c) => c["~sc"])]]),
+    noExtraKeys: (partialShape) => createComparison(["not", ["withNoExtraKeys", partialShape]]),
+    deepNoExtraKeys: (partialShape) => createComparison(["not", ["withDeepNoExtraKeys", partialShape]]),
+    noExtraDefinedKeys: (partialShape) => createComparison(["not", ["noExtraDefinedKeys", partialShape]]),
+    deepNoExtraDefinedKeys: (partialShape) => createComparison(["not", ["deepNoExtraDefinedKeys", partialShape]])
   }
 };
 function find2(iter, tar) {
@@ -256,6 +263,128 @@ function executeComparison(target, comparison) {
       return true;
     case "not":
       return !executeComparison(target, value);
+    case "withNoExtraKeys":
+      if (typeof target !== "object" || target === null || Array.isArray(target)) {
+        return false;
+      }
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+      }
+      for (const key in target) {
+        if (has2.call(target, key) && !has2.call(value, key)) {
+          return false;
+        }
+      }
+      for (const key in value) {
+        if (has2.call(value, key)) {
+          if (!has2.call(target, key)) {
+            return false;
+          }
+          if (!partialEqual(target[key], value[key])) {
+            return false;
+          }
+        }
+      }
+      return true;
+    case "withDeepNoExtraKeys":
+      if (typeof target !== "object" || target === null || Array.isArray(target)) {
+        return false;
+      }
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+      }
+      for (const key in target) {
+        if (has2.call(target, key) && !has2.call(value, key)) {
+          return false;
+        }
+      }
+      for (const key in value) {
+        if (has2.call(value, key)) {
+          if (!has2.call(target, key)) {
+            return false;
+          }
+          const targetValue = target[key];
+          const partialValue = value[key];
+          if (partialValue && typeof partialValue === "object" && "~sc" in partialValue && partialValue["~sc"][0] === "withDeepNoExtraKeys") {
+            if (!executeComparison(targetValue, partialValue["~sc"])) {
+              return false;
+            }
+          } else if (partialValue && typeof partialValue === "object" && !Array.isArray(partialValue) && partialValue.constructor === Object && targetValue && typeof targetValue === "object" && !Array.isArray(targetValue) && targetValue.constructor === Object) {
+            if (!executeComparison(targetValue, [
+              "withDeepNoExtraKeys",
+              partialValue
+            ])) {
+              return false;
+            }
+          } else {
+            if (!partialEqual(targetValue, partialValue)) {
+              return false;
+            }
+          }
+        }
+      }
+      return true;
+    case "noExtraDefinedKeys":
+      if (typeof target !== "object" || target === null || Array.isArray(target)) {
+        return false;
+      }
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+      }
+      for (const key in target) {
+        if (has2.call(target, key) && target[key] !== void 0 && !has2.call(value, key)) {
+          return false;
+        }
+      }
+      for (const key in value) {
+        if (has2.call(value, key)) {
+          if (!has2.call(target, key)) {
+            return false;
+          }
+          if (!partialEqual(target[key], value[key])) {
+            return false;
+          }
+        }
+      }
+      return true;
+    case "deepNoExtraDefinedKeys":
+      if (typeof target !== "object" || target === null || Array.isArray(target)) {
+        return false;
+      }
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+      }
+      for (const key in target) {
+        if (has2.call(target, key) && target[key] !== void 0 && !has2.call(value, key)) {
+          return false;
+        }
+      }
+      for (const key in value) {
+        if (has2.call(value, key)) {
+          if (!has2.call(target, key)) {
+            return false;
+          }
+          const targetValue = target[key];
+          const partialValue = value[key];
+          if (partialValue && typeof partialValue === "object" && "~sc" in partialValue && partialValue["~sc"][0] === "deepNoExtraDefinedKeys") {
+            if (!executeComparison(targetValue, partialValue["~sc"])) {
+              return false;
+            }
+          } else if (partialValue && typeof partialValue === "object" && !Array.isArray(partialValue) && partialValue.constructor === Object && targetValue && typeof targetValue === "object" && !Array.isArray(targetValue) && targetValue.constructor === Object) {
+            if (!executeComparison(targetValue, [
+              "deepNoExtraDefinedKeys",
+              partialValue
+            ])) {
+              return false;
+            }
+          } else {
+            if (!partialEqual(targetValue, partialValue)) {
+              return false;
+            }
+          }
+        }
+      }
+      return true;
     default:
       return false;
   }
@@ -318,7 +447,11 @@ function partialEqual(target, sub) {
           } else if (subValue && typeof subValue === "object" && "~sc" in subValue && subValue["~sc"][0] === "any") {
             const targetHasKey = has2.call(target, key);
             const targetValue = targetHasKey ? target[key] : void 0;
-            if (!executeComparisonWithKeyContext(targetValue, subValue["~sc"], targetHasKey)) {
+            if (!executeComparisonWithKeyContext(
+              targetValue,
+              subValue["~sc"],
+              targetHasKey
+            )) {
               return false;
             }
           } else {

package/dist/partialEqual.d.cts

@@ -1,11 +1,15 @@
 type ComparisonsType = [type: 'strStartsWith', value: string] | [type: 'strEndsWith', value: string] | [
     type: 'hasType',
     value: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'function'
-] | [type: 'strContains', value: string] | [type: 'strMatchesRegex', value: RegExp] | [type: 'deepEqual', value: any] | [type: 'numIsGreaterThan', value: number] | [type: 'numIsGreaterThanOrEqual', value: number] | [type: 'numIsLessThan', value: number] | [type: 'numIsLessThanOrEqual', value: number] | [type: 'numIsInRange', value: [number, number]] | [type: 'jsonStringHasPartial', value: any] | [type: 'partialEqual', value: any] | [type: 'custom', value: (target: unknown) => boolean] | [type: 'isInstanceOf', value: new (...args: any[]) => any] | [type: 'keyNotBePresent', value: null] | [type: 'not', value: ComparisonsType] | [type: 'any', value: ComparisonsType[]] | [type: 'all', value: ComparisonsType[]];
+] | [type: 'strContains', value: string] | [type: 'strMatchesRegex', value: RegExp] | [type: 'deepEqual', value: any] | [type: 'numIsGreaterThan', value: number] | [type: 'numIsGreaterThanOrEqual', value: number] | [type: 'numIsLessThan', value: number] | [type: 'numIsLessThanOrEqual', value: number] | [type: 'numIsInRange', value: [number, number]] | [type: 'jsonStringHasPartial', value: any] | [type: 'partialEqual', value: any] | [type: 'custom', value: (target: unknown) => boolean] | [type: 'isInstanceOf', value: new (...args: any[]) => any] | [type: 'keyNotBePresent', value: null] | [type: 'not', value: ComparisonsType] | [type: 'any', value: ComparisonsType[]] | [type: 'all', value: ComparisonsType[]] | [type: 'withNoExtraKeys', partialShape: any] | [type: 'withDeepNoExtraKeys', partialShape: any] | [type: 'noExtraDefinedKeys', partialShape: any] | [type: 'deepNoExtraDefinedKeys', partialShape: any];
 type Comparison = {
     '~sc': ComparisonsType;
 };
-declare const match: {
+type BaseMatch = {
+    noExtraKeys: (partialShape: any) => Comparison;
+    deepNoExtraKeys: (partialShape: any) => Comparison;
+    noExtraDefinedKeys: (partialShape: any) => Comparison;
+    deepNoExtraDefinedKeys: (partialShape: any) => Comparison;
     hasType: {
         string: Comparison;
         number: Comparison;
@@ -37,39 +41,11 @@ declare const match: {
     keyNotBePresent: Comparison;
     any: (...comparisons: Comparison[]) => Comparison;
     all: (...comparisons: Comparison[]) => Comparison;
-    not: {
-        hasType: {
-            string: Comparison;
-            number: Comparison;
-            boolean: Comparison;
-            object: Comparison;
-            array: Comparison;
-            function: Comparison;
-        };
-        isInstanceOf: (constructor: new (...args: any[]) => any) => Comparison;
-        str: {
-            contains: (substring: string) => Comparison;
-            startsWith: (substring: string) => Comparison;
-            endsWith: (substring: string) => Comparison;
-            matchesRegex: (regex: RegExp) => Comparison;
-        };
-        num: {
-            isGreaterThan: (value: number) => Comparison;
-            isGreaterThanOrEqual: (value: number) => Comparison;
-            isLessThan: (value: number) => Comparison;
-            isLessThanOrEqual: (value: number) => Comparison;
-            isInRange: (value: [number, number]) => Comparison;
-        };
-        jsonString: {
-            hasPartial: (value: any) => Comparison;
-        };
-        equal: (value: any) => Comparison;
-        partialEqual: (value: any) => Comparison;
-        custom: (value: (target: unknown) => boolean) => Comparison;
-        any: (...comparisons: Comparison[]) => Comparison;
-        all: (...comparisons: Comparison[]) => Comparison;
-    };
 };
+type Match = BaseMatch & {
+    not: BaseMatch;
+};
+declare const match: Match;
 declare function partialEqual(target: any, sub: any): boolean;
 
 export { match, partialEqual };

package/dist/partialEqual.d.ts

@@ -1,11 +1,15 @@
 type ComparisonsType = [type: 'strStartsWith', value: string] | [type: 'strEndsWith', value: string] | [
     type: 'hasType',
     value: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'function'
-] | [type: 'strContains', value: string] | [type: 'strMatchesRegex', value: RegExp] | [type: 'deepEqual', value: any] | [type: 'numIsGreaterThan', value: number] | [type: 'numIsGreaterThanOrEqual', value: number] | [type: 'numIsLessThan', value: number] | [type: 'numIsLessThanOrEqual', value: number] | [type: 'numIsInRange', value: [number, number]] | [type: 'jsonStringHasPartial', value: any] | [type: 'partialEqual', value: any] | [type: 'custom', value: (target: unknown) => boolean] | [type: 'isInstanceOf', value: new (...args: any[]) => any] | [type: 'keyNotBePresent', value: null] | [type: 'not', value: ComparisonsType] | [type: 'any', value: ComparisonsType[]] | [type: 'all', value: ComparisonsType[]];
+] | [type: 'strContains', value: string] | [type: 'strMatchesRegex', value: RegExp] | [type: 'deepEqual', value: any] | [type: 'numIsGreaterThan', value: number] | [type: 'numIsGreaterThanOrEqual', value: number] | [type: 'numIsLessThan', value: number] | [type: 'numIsLessThanOrEqual', value: number] | [type: 'numIsInRange', value: [number, number]] | [type: 'jsonStringHasPartial', value: any] | [type: 'partialEqual', value: any] | [type: 'custom', value: (target: unknown) => boolean] | [type: 'isInstanceOf', value: new (...args: any[]) => any] | [type: 'keyNotBePresent', value: null] | [type: 'not', value: ComparisonsType] | [type: 'any', value: ComparisonsType[]] | [type: 'all', value: ComparisonsType[]] | [type: 'withNoExtraKeys', partialShape: any] | [type: 'withDeepNoExtraKeys', partialShape: any] | [type: 'noExtraDefinedKeys', partialShape: any] | [type: 'deepNoExtraDefinedKeys', partialShape: any];
 type Comparison = {
     '~sc': ComparisonsType;
 };
-declare const match: {
+type BaseMatch = {
+    noExtraKeys: (partialShape: any) => Comparison;
+    deepNoExtraKeys: (partialShape: any) => Comparison;
+    noExtraDefinedKeys: (partialShape: any) => Comparison;
+    deepNoExtraDefinedKeys: (partialShape: any) => Comparison;
     hasType: {
         string: Comparison;
         number: Comparison;
@@ -37,39 +41,11 @@ declare const match: {
     keyNotBePresent: Comparison;
     any: (...comparisons: Comparison[]) => Comparison;
     all: (...comparisons: Comparison[]) => Comparison;
-    not: {
-        hasType: {
-            string: Comparison;
-            number: Comparison;
-            boolean: Comparison;
-            object: Comparison;
-            array: Comparison;
-            function: Comparison;
-        };
-        isInstanceOf: (constructor: new (...args: any[]) => any) => Comparison;
-        str: {
-            contains: (substring: string) => Comparison;
-            startsWith: (substring: string) => Comparison;
-            endsWith: (substring: string) => Comparison;
-            matchesRegex: (regex: RegExp) => Comparison;
-        };
-        num: {
-            isGreaterThan: (value: number) => Comparison;
-            isGreaterThanOrEqual: (value: number) => Comparison;
-            isLessThan: (value: number) => Comparison;
-            isLessThanOrEqual: (value: number) => Comparison;
-            isInRange: (value: [number, number]) => Comparison;
-        };
-        jsonString: {
-            hasPartial: (value: any) => Comparison;
-        };
-        equal: (value: any) => Comparison;
-        partialEqual: (value: any) => Comparison;
-        custom: (value: (target: unknown) => boolean) => Comparison;
-        any: (...comparisons: Comparison[]) => Comparison;
-        all: (...comparisons: Comparison[]) => Comparison;
-    };
 };
+type Match = BaseMatch & {
+    not: BaseMatch;
+};
+declare const match: Match;
 declare function partialEqual(target: any, sub: any): boolean;
 
 export { match, partialEqual };