@ls-stack/utils 3.47.0 → 3.48.0

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

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Universal TypeScript utilities for browser and Node.js",
-  "version": "3.47.0",
+  "version": "3.48.0",
   "license": "MIT",
   "files": [
     "dist",