@ls-stack/utils 3.46.0 → 3.48.0

package/dist/partialEqual.d.ts

@@ -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 };

package/dist/partialEqual.js

@@ -3,6 +3,7 @@ import {
 } from "./chunk-JQFUKJU5.js";
 
 // src/partialEqual.ts
+import { err, ok } from "t-result";
 var has = Object.prototype.hasOwnProperty;
 function createComparison(type) {
   return { "~sc": type };
@@ -302,7 +303,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 = !!find(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 = find(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 (has.call(sub, key)) {
+          const subValue = sub[key];
+          context.path.push(key);
+          if (subValue && typeof subValue === "object" && "~sc" in subValue && subValue["~sc"][0] === "keyNotBePresent") {
+            if (has.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 = has.call(target, key);
+            const targetValue = targetHasKey ? target[key] : void 0;
+            executeComparisonWithKeyContextAndErrorCollection(
+              targetValue,
+              subValue["~sc"],
+              targetHasKey,
+              context
+            );
+          } else {
+            if (!has.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 ok(void 0);
+    } else {
+      return err(context.errors);
+    }
+  }
   if (sub === target) return true;
   if (sub && typeof sub === "object" && "~sc" in sub) {
     return executeComparison(target, sub["~sc"]);

package/dist/testUtils.cjs

@@ -155,6 +155,51 @@ function deepEqual(foo, bar, maxDepth = 20) {
   return foo !== foo && bar !== bar;
 }
 
+// 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(), "");
+}
+
 // src/filterObjectOrArrayKeys.ts
 var ID_PROP_REGEXP = /^(id_|key_|id-|key-)|(_id|_key|-id|-key)$/i;
 function filterObjectOrArrayKeys(objOrArray, {
@@ -1368,7 +1413,7 @@ function compactSnapshot(value, {
     }
   }
   if (replaceValues) {
-    processedValue = applyValueReplacements(processedValue, replaceValues);
+    processedValue = deepReplaceValues(processedValue, replaceValues);
   }
   processedValue = showBooleansAs ? replaceBooleansWithEmoji(processedValue, showBooleansAs) : processedValue;
   return `
@@ -1379,46 +1424,6 @@ ${yamlStringify(processedValue, {
     ...options
   })}`;
 }
-function applyValueReplacements(value, replaceValues, visited = /* @__PURE__ */ new Set(), 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 replaceBooleansWithEmoji(value, showBooleansAs, visited = /* @__PURE__ */ new Set()) {
   if (showBooleansAs === false) {
     return value;

package/dist/testUtils.js

@@ -6,13 +6,16 @@ import {
   pick
 } from "./chunk-Y45CE75W.js";
 import "./chunk-GMJTLFM6.js";
+import {
+  filterObjectOrArrayKeys
+} from "./chunk-6CG6JZKB.js";
 import "./chunk-IATIXMCE.js";
 import {
   deepEqual
 } from "./chunk-JQFUKJU5.js";
 import {
-  filterObjectOrArrayKeys
-} from "./chunk-6CG6JZKB.js";
+  deepReplaceValues
+} from "./chunk-PUKVXYYL.js";
 import {
   defer
 } from "./chunk-DFXNVEH6.js";
@@ -281,7 +284,7 @@ function compactSnapshot(value, {
     }
   }
   if (replaceValues) {
-    processedValue = applyValueReplacements(processedValue, replaceValues);
+    processedValue = deepReplaceValues(processedValue, replaceValues);
   }
   processedValue = showBooleansAs ? replaceBooleansWithEmoji(processedValue, showBooleansAs) : processedValue;
   return `
@@ -292,46 +295,6 @@ ${yamlStringify(processedValue, {
     ...options
   })}`;
 }
-function applyValueReplacements(value, replaceValues, visited = /* @__PURE__ */ new Set(), 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 replaceBooleansWithEmoji(value, showBooleansAs, visited = /* @__PURE__ */ new Set()) {
   if (showBooleansAs === false) {
     return value;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Universal TypeScript utilities for browser and Node.js",
-  "version": "3.46.0",
+  "version": "3.48.0",
   "license": "MIT",
   "files": [
     "dist",
@@ -76,6 +76,10 @@
       "import": "./dist/deepEqual.js",
       "require": "./dist/deepEqual.cjs"
     },
+    "./deepReplaceValues": {
+      "import": "./dist/deepReplaceValues.js",
+      "require": "./dist/deepReplaceValues.cjs"
+    },
     "./enhancedMap": {
       "import": "./dist/enhancedMap.js",
       "require": "./dist/enhancedMap.cjs"