@ls-stack/utils 3.46.0 → 3.48.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

@@ -24,6 +24,7 @@ __export(partialEqual_exports, {
   partialEqual: () => partialEqual
 });
 module.exports = __toCommonJS(partialEqual_exports);
+var import_t_result = require("t-result");
 
 // src/deepEqual.ts
 var has = Object.prototype.hasOwnProperty;
@@ -389,7 +390,437 @@ function executeComparison(target, comparison) {
       return false;
   }
 }
-function partialEqual(target, sub) {
+function formatPath(path) {
+  if (path.length === 0) return "";
+  let result = path[0] || "";
+  for (let i = 1; i < path.length; i++) {
+    const segment = path[i];
+    if (segment && segment.startsWith("[") && segment.endsWith("]")) {
+      result += segment;
+    } else if (segment) {
+      result += `.${segment}`;
+    }
+  }
+  return result;
+}
+function addError(context, message, received, expected) {
+  const error = {
+    path: formatPath(context.path),
+    message,
+    received
+  };
+  if (expected !== void 0) {
+    error.expected = expected;
+  }
+  context.errors.push(error);
+}
+function executeComparisonWithErrorCollection(target, comparison, context) {
+  const [type, value] = comparison;
+  switch (type) {
+    case "hasType":
+      switch (value) {
+        case "string":
+          if (typeof target !== "string") {
+            addError(context, `Expected type string`, target);
+          }
+          break;
+        case "number":
+          if (typeof target !== "number") {
+            addError(context, `Expected type number`, target);
+          }
+          break;
+        case "boolean":
+          if (typeof target !== "boolean") {
+            addError(context, `Expected type boolean`, target);
+          }
+          break;
+        case "function":
+          if (typeof target !== "function") {
+            addError(context, `Expected type function`, target);
+          }
+          break;
+        case "array":
+          if (!Array.isArray(target)) {
+            addError(context, `Expected array`, target);
+          }
+          break;
+        case "object":
+          if (typeof target !== "object" || target === null || Array.isArray(target)) {
+            addError(context, `Expected object`, target);
+          }
+          break;
+      }
+      break;
+    case "isInstanceOf":
+      if (!(target instanceof value)) {
+        addError(
+          context,
+          `Expected instance of ${value.name}`,
+          target
+        );
+      }
+      break;
+    case "strStartsWith":
+      if (typeof target !== "string" || !target.startsWith(value)) {
+        addError(
+          context,
+          `Expected string starting with "${value}"`,
+          target
+        );
+      }
+      break;
+    case "strEndsWith":
+      if (typeof target !== "string" || !target.endsWith(value)) {
+        addError(
+          context,
+          `Expected string ending with "${value}"`,
+          target
+        );
+      }
+      break;
+    case "strContains":
+      if (typeof target !== "string" || !target.includes(value)) {
+        addError(
+          context,
+          `Expected string containing "${value}"`,
+          target
+        );
+      }
+      break;
+    case "strMatchesRegex":
+      if (typeof target !== "string" || !value.test(target)) {
+        addError(
+          context,
+          `Expected string matching regex ${value}`,
+          target
+        );
+      }
+      break;
+    case "numIsGreaterThan":
+      if (typeof target !== "number" || target <= value) {
+        addError(
+          context,
+          `Expected number greater than ${value}`,
+          target
+        );
+      }
+      break;
+    case "numIsGreaterThanOrEqual":
+      if (typeof target !== "number" || target < value) {
+        addError(
+          context,
+          `Expected number greater than or equal to ${value}`,
+          target
+        );
+      }
+      break;
+    case "numIsLessThan":
+      if (typeof target !== "number" || target >= value) {
+        addError(
+          context,
+          `Expected number less than ${value}`,
+          target
+        );
+      }
+      break;
+    case "numIsLessThanOrEqual":
+      if (typeof target !== "number" || target > value) {
+        addError(
+          context,
+          `Expected number less than or equal to ${value}`,
+          target
+        );
+      }
+      break;
+    case "numIsInRange":
+      if (typeof target !== "number" || target < value[0] || target > value[1]) {
+        addError(
+          context,
+          `Expected number in range [${value[0]}, ${value[1]}]`,
+          target
+        );
+      }
+      break;
+    case "jsonStringHasPartial":
+      if (typeof target !== "string") {
+        addError(context, `Expected JSON string`, target);
+      } else {
+        try {
+          const parsed = JSON.parse(target);
+          partialEqualWithErrorCollection(parsed, value, context);
+        } catch {
+          addError(
+            context,
+            `Expected valid JSON string`,
+            target
+          );
+        }
+      }
+      break;
+    case "deepEqual":
+      if (!deepEqual(target, value)) {
+        addError(context, `Expected deep equal`, target, value);
+      }
+      break;
+    case "partialEqual":
+      partialEqualWithErrorCollection(target, value, context);
+      break;
+    case "custom":
+      if (!value(target)) {
+        addError(context, `Custom validation failed`, target, "valid value");
+      }
+      break;
+    case "keyNotBePresent":
+      addError(context, `Key should not be present`, target);
+      break;
+    case "any": {
+      for (const comp of value) {
+        const subContext = {
+          errors: [],
+          path: [...context.path]
+        };
+        executeComparisonWithErrorCollection(target, comp, subContext);
+        if (subContext.errors.length === 0) {
+          return;
+        }
+      }
+      addError(
+        context,
+        `None of the alternative comparisons matched`,
+        target
+      );
+      break;
+    }
+    case "all":
+      for (const comp of value) {
+        executeComparisonWithErrorCollection(target, comp, context);
+      }
+      break;
+    case "not": {
+      const subContext = {
+        errors: [],
+        path: [...context.path]
+      };
+      executeComparisonWithErrorCollection(target, value, subContext);
+      if (subContext.errors.length === 0) {
+        addError(
+          context,
+          `Expected negated condition to fail`,
+          target
+        );
+      }
+      break;
+    }
+    case "withNoExtraKeys":
+    case "withDeepNoExtraKeys":
+    case "noExtraDefinedKeys":
+    case "deepNoExtraDefinedKeys":
+      addError(
+        context,
+        `Complex validation not supported in error collection mode yet`,
+        target
+      );
+      break;
+  }
+}
+function executeComparisonWithKeyContextAndErrorCollection(target, comp, keyExists, context) {
+  const [type, value] = comp;
+  if (type === "keyNotBePresent") {
+    if (keyExists) {
+      addError(context, `Key should not be present`, target);
+    }
+    return;
+  }
+  if (type === "any") {
+    for (const childComp of value) {
+      const subContext = {
+        errors: [],
+        path: [...context.path]
+      };
+      executeComparisonWithKeyContextAndErrorCollection(
+        target,
+        childComp,
+        keyExists,
+        subContext
+      );
+      if (subContext.errors.length === 0) {
+        return;
+      }
+    }
+    addError(
+      context,
+      `None of the alternative comparisons matched`,
+      target,
+      "any alternative match"
+    );
+    return;
+  }
+  if (type === "not") {
+    const subContext = {
+      errors: [],
+      path: [...context.path]
+    };
+    executeComparisonWithKeyContextAndErrorCollection(
+      target,
+      value,
+      keyExists,
+      subContext
+    );
+    if (subContext.errors.length === 0) {
+      addError(
+        context,
+        `Expected negated condition to fail`,
+        target,
+        "negated condition"
+      );
+    }
+    return;
+  }
+  executeComparisonWithErrorCollection(target, comp, context);
+}
+function partialEqualWithErrorCollection(target, sub, context) {
+  if (sub === target) return;
+  if (sub && typeof sub === "object" && "~sc" in sub) {
+    executeComparisonWithErrorCollection(target, sub["~sc"], context);
+    return;
+  }
+  if (sub && target && sub.constructor === target.constructor) {
+    const ctor = sub.constructor;
+    if (ctor === Date) {
+      if (sub.getTime() !== target.getTime()) {
+        addError(context, `Date mismatch`, target, sub);
+      }
+      return;
+    }
+    if (ctor === RegExp) {
+      if (sub.toString() !== target.toString()) {
+        addError(context, `RegExp mismatch`, target, sub);
+      }
+      return;
+    }
+    if (ctor === Array) {
+      if (sub.length > target.length) {
+        addError(
+          context,
+          `Array too short: expected at least ${sub.length} elements, got ${target.length}`,
+          target,
+          sub
+        );
+        return;
+      }
+      for (let i = 0; i < sub.length; i++) {
+        context.path.push(`[${i}]`);
+        partialEqualWithErrorCollection(target[i], sub[i], context);
+        context.path.pop();
+      }
+      return;
+    }
+    if (ctor === Set) {
+      if (sub.size > target.size) {
+        addError(
+          context,
+          `Set too small: expected at least ${sub.size} elements, got ${target.size}`,
+          target,
+          sub
+        );
+        return;
+      }
+      for (const value of sub) {
+        let found = false;
+        if (value && typeof value === "object") {
+          found = !!find2(target, value);
+        } else {
+          found = target.has(value);
+        }
+        if (!found) {
+          addError(context, `Set missing value`, target, value);
+        }
+      }
+      return;
+    }
+    if (ctor === Map) {
+      if (sub.size > target.size) {
+        addError(
+          context,
+          `Map too small: expected at least ${sub.size} entries, got ${target.size}`,
+          target,
+          sub
+        );
+        return;
+      }
+      for (const [key, value] of sub) {
+        let targetKey = key;
+        if (key && typeof key === "object") {
+          targetKey = find2(target, key);
+          if (!targetKey) {
+            addError(context, `Map missing key`, target, key);
+            continue;
+          }
+        }
+        if (!target.has(targetKey)) {
+          addError(context, `Map missing key`, target, key);
+          continue;
+        }
+        context.path.push(`[${key}]`);
+        partialEqualWithErrorCollection(target.get(targetKey), value, context);
+        context.path.pop();
+      }
+      return;
+    }
+    if (!ctor || typeof sub === "object") {
+      for (const key in sub) {
+        if (has2.call(sub, key)) {
+          const subValue = sub[key];
+          context.path.push(key);
+          if (subValue && typeof subValue === "object" && "~sc" in subValue && subValue["~sc"][0] === "keyNotBePresent") {
+            if (has2.call(target, key)) {
+              addError(
+                context,
+                `Key should not be present`,
+                target[key],
+                "key not present"
+              );
+            }
+          } 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;
+            executeComparisonWithKeyContextAndErrorCollection(
+              targetValue,
+              subValue["~sc"],
+              targetHasKey,
+              context
+            );
+          } else {
+            if (!has2.call(target, key)) {
+              addError(context, `Missing property`, void 0, subValue);
+            } else {
+              partialEqualWithErrorCollection(target[key], subValue, context);
+            }
+          }
+          context.path.pop();
+        }
+      }
+      return;
+    }
+  }
+  if (sub !== sub && target !== target) {
+    return;
+  }
+  addError(context, `Value mismatch`, target, sub);
+}
+function partialEqual(target, sub, returnErrors) {
+  if (returnErrors === true) {
+    const context = {
+      errors: [],
+      path: []
+    };
+    partialEqualWithErrorCollection(target, sub, context);
+    if (context.errors.length === 0) {
+      return (0, import_t_result.ok)(void 0);
+    } else {
+      return (0, import_t_result.err)(context.errors);
+    }
+  }
   if (sub === target) return true;
   if (sub && typeof sub === "object" && "~sc" in sub) {
     return executeComparison(target, sub["~sc"]);

package/dist/partialEqual.d.cts

@@ -1,3 +1,5 @@
+import { Result } from 't-result';
+
 type ComparisonsType = [type: 'strStartsWith', value: string] | [type: 'strEndsWith', value: string] | [
     type: 'hasType',
     value: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'function'
@@ -46,6 +48,13 @@ type Match = BaseMatch & {
     not: BaseMatch;
 };
 declare const match: Match;
+type PartialError = {
+    path: string;
+    message: string;
+    received: any;
+    expected?: any;
+};
+declare function partialEqual(target: any, sub: any, returnErrors: true): Result<void, PartialError[]>;
 declare function partialEqual(target: any, sub: any): boolean;
 
 export { match, partialEqual };