@ls-stack/utils 3.53.0 → 3.54.0

package/dist/partialEqual.cjs

@@ -100,6 +100,15 @@ var match = {
       return ["deepEqual", v];
     })
   ]),
+  key: {
+    any: "$pqkc:any$",
+    anyOther: "$pqkc:anyOther$",
+    numeric: "$pqkc:numeric$",
+    startingWith: (substring) => `$pqkc:startingWith:${substring}$`,
+    endingWith: (substring) => `$pqkc:endingWith:${substring}$`,
+    containing: (substring) => `$pqkc:contains:${substring}$`,
+    matchingRegex: (regex) => `$pqkc:matchesRegex:${regex}$`
+  },
   not: {
     hasType: {
       string: createComparison(["not", ["hasType", "string"]]),
@@ -169,12 +178,93 @@ var match = {
     noExtraKeys: (partialShape) => createComparison(["not", ["withNoExtraKeys", partialShape]]),
     deepNoExtraKeys: (partialShape) => createComparison(["not", ["withDeepNoExtraKeys", partialShape]]),
     noExtraDefinedKeys: (partialShape) => createComparison(["not", ["noExtraDefinedKeys", partialShape]]),
-    deepNoExtraDefinedKeys: (partialShape) => createComparison(["not", ["deepNoExtraDefinedKeys", partialShape]])
+    deepNoExtraDefinedKeys: (partialShape) => createComparison(["not", ["deepNoExtraDefinedKeys", partialShape]]),
+    key: {
+      any: "$pqkc-not:any$",
+      anyOther: "$pqkc-not:anyOther$",
+      numeric: "$pqkc-not:numeric$",
+      startingWith: (substring) => `$pqkc-not:startingWith:${substring}$`,
+      endingWith: (substring) => `$pqkc-not:endingWith:${substring}$`,
+      containing: (substring) => `$pqkc-not:contains:${substring}$`,
+      matchingRegex: (regex) => `$pqkc-not:matchesRegex:${regex}$`
+    }
   }
 };
 function isComparison(value) {
   return value && typeof value === "object" && "~sc" in value;
 }
+function isKeyMatcher(key) {
+  return typeof key === "string" && (key.startsWith("$pqkc:") || key.startsWith("$pqkc-not:"));
+}
+function parseKeyMatcher(key) {
+  if (!isKeyMatcher(key)) return null;
+  const negated = key.startsWith("$pqkc-not:");
+  const prefix = negated ? "$pqkc-not:" : "$pqkc:";
+  const suffix = "$";
+  if (!key.endsWith(suffix)) return null;
+  const content = key.slice(prefix.length, -suffix.length);
+  if (content === "any") {
+    return { type: "any", negated };
+  }
+  if (content === "anyOther") {
+    return { type: "anyOther", negated };
+  }
+  if (content === "numeric") {
+    return { type: "numeric", negated };
+  }
+  if (content.startsWith("startingWith:")) {
+    return { type: "startingWith", parameter: content.slice("startingWith:".length), negated };
+  }
+  if (content.startsWith("endingWith:")) {
+    return { type: "endingWith", parameter: content.slice("endingWith:".length), negated };
+  }
+  if (content.startsWith("contains:")) {
+    return { type: "contains", parameter: content.slice("contains:".length), negated };
+  }
+  if (content.startsWith("matchesRegex:")) {
+    const regexStr = content.slice("matchesRegex:".length);
+    try {
+      if (regexStr.startsWith("/") && regexStr.lastIndexOf("/") > 0) {
+        const lastSlashIndex = regexStr.lastIndexOf("/");
+        const pattern = regexStr.slice(1, lastSlashIndex);
+        const flags = regexStr.slice(lastSlashIndex + 1);
+        return { type: "matchesRegex", parameter: new RegExp(pattern, flags), negated };
+      } else {
+        return { type: "matchesRegex", parameter: new RegExp(regexStr), negated };
+      }
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function keyMatchesPattern(key, matcher) {
+  let matches = false;
+  switch (matcher.type) {
+    case "any":
+      matches = true;
+      break;
+    case "anyOther":
+      matches = true;
+      break;
+    case "numeric":
+      matches = /^\d+$/.test(key);
+      break;
+    case "startingWith":
+      matches = key.startsWith(matcher.parameter);
+      break;
+    case "endingWith":
+      matches = key.endsWith(matcher.parameter);
+      break;
+    case "contains":
+      matches = key.includes(matcher.parameter);
+      break;
+    case "matchesRegex":
+      matches = matcher.parameter.test(key);
+      break;
+  }
+  return matcher.negated ? !matches : matches;
+}
 function executeComparison(target, comparison, context) {
   const [type, value] = comparison;
   switch (type) {
@@ -871,7 +961,21 @@ function partialEqualInternal(target, sub, context) {
       return false;
     }
     let allMatch = true;
+    const regularKeys = [];
+    const keyMatchers = [];
     for (const key of Object.keys(sub)) {
+      if (isKeyMatcher(key)) {
+        const matcher = parseKeyMatcher(key);
+        if (matcher) {
+          keyMatchers.push({ key, matcher, value: sub[key] });
+        }
+      } else {
+        regularKeys.push(key);
+      }
+    }
+    const explicitlySpecifiedKeys = /* @__PURE__ */ new Set();
+    for (const key of regularKeys) {
+      explicitlySpecifiedKeys.add(key);
       if (isComparison(sub[key]) && sub[key]["~sc"][0] === "keyNotBePresent") {
         if (has.call(target, key)) {
           const oldPath2 = context.path;
@@ -915,6 +1019,72 @@ function partialEqualInternal(target, sub, context) {
       context.path = oldPath;
       if (!result) allMatch = false;
     }
+    for (const { matcher, value } of keyMatchers) {
+      let foundMatch = false;
+      const matchedKeys = [];
+      if (matcher.type === "anyOther") {
+        for (const targetKey of Object.keys(target)) {
+          if (!explicitlySpecifiedKeys.has(targetKey)) {
+            const matches = keyMatchesPattern(targetKey, matcher);
+            if (matches) {
+              foundMatch = true;
+              matchedKeys.push(targetKey);
+              const oldPath = context.path;
+              context.path = [...oldPath, targetKey];
+              const result = partialEqualInternal(target[targetKey], value, context);
+              context.path = oldPath;
+              if (!result) allMatch = false;
+            }
+          }
+        }
+      } else if (matcher.type === "any") {
+        let anyKeyMatched = false;
+        for (const targetKey of Object.keys(target)) {
+          if (keyMatchesPattern(targetKey, matcher)) {
+            foundMatch = true;
+            matchedKeys.push(targetKey);
+            explicitlySpecifiedKeys.add(targetKey);
+            const tempContext = {
+              errors: [],
+              path: [...context.path, targetKey]
+            };
+            const result = partialEqualInternal(target[targetKey], value, tempContext);
+            if (result) {
+              anyKeyMatched = true;
+              break;
+            }
+          }
+        }
+        if (foundMatch && !anyKeyMatched) {
+          addError(context, {
+            message: `No keys matching pattern had the expected value`,
+            received: { keysChecked: matchedKeys, availableKeys: Object.keys(target) }
+          });
+          allMatch = false;
+        }
+      } else {
+        for (const targetKey of Object.keys(target)) {
+          if (keyMatchesPattern(targetKey, matcher)) {
+            foundMatch = true;
+            matchedKeys.push(targetKey);
+            explicitlySpecifiedKeys.add(targetKey);
+            const oldPath = context.path;
+            context.path = [...oldPath, targetKey];
+            const result = partialEqualInternal(target[targetKey], value, context);
+            context.path = oldPath;
+            if (!result) allMatch = false;
+          }
+        }
+      }
+      if (!foundMatch) {
+        const patternDescription = matcher.type === "anyOther" ? "anyOther (keys not explicitly specified)" : `${matcher.type}${matcher.parameter ? ` (${matcher.parameter})` : ""}`;
+        addError(context, {
+          message: `No keys found matching pattern: ${patternDescription}`,
+          received: { availableKeys: Object.keys(target), explicitKeys: Array.from(explicitlySpecifiedKeys) }
+        });
+        allMatch = false;
+      }
+    }
     return allMatch;
   }
   if (target !== sub) {

package/dist/partialEqual.d.cts

@@ -6,6 +6,16 @@ type ComparisonsType = [type: 'strStartsWith', value: string] | [type: 'strEndsW
 ] | [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: 'arrayContains', value: any[]] | [type: 'arrayContainsInOrder', value: any[]] | [type: 'arrayStartsWith', value: any[]] | [type: 'arrayEndsWith', value: any[]] | [type: 'arrayLength', value: number] | [type: 'arrayMinLength', value: number] | [type: 'arrayMaxLength', value: number] | [type: 'arrayIncludes', value: any] | [type: 'arrayEvery', value: ComparisonsType] | [type: 'arraySome', value: ComparisonsType] | [type: 'jsonStringHasPartial', value: any] | [type: 'partialEqual', value: any] | [type: 'custom', value: (target: unknown) => boolean | {
     error: string;
 }] | [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 KeyComparisonPrefix = 'pqkc' | 'pqkc-not';
+type KeyComparison = {
+    any: `$${KeyComparisonPrefix}:any$`;
+    anyOther: `$${KeyComparisonPrefix}:anyOther$`;
+    numeric: `$${KeyComparisonPrefix}:numeric$`;
+    startingWith: `$${KeyComparisonPrefix}:startingWith:${string}$`;
+    endingWith: `$${KeyComparisonPrefix}:endingWith:${string}$`;
+    contains: `$${KeyComparisonPrefix}:contains:${string}$`;
+    matchesRegex: `$${KeyComparisonPrefix}:matchesRegex:${string}$`;
+};
 type Comparison = {
     '~sc': ComparisonsType;
 };
@@ -59,6 +69,15 @@ type BaseMatch = {
     keyNotBePresent: Comparison;
     any: (...values: any[]) => Comparison;
     all: (...values: any[]) => Comparison;
+    key: {
+        any: KeyComparison['any'];
+        anyOther: KeyComparison['anyOther'];
+        numeric: KeyComparison['numeric'];
+        startingWith: (substring: string) => KeyComparison['startingWith'];
+        endingWith: (substring: string) => KeyComparison['endingWith'];
+        containing: (substring: string) => KeyComparison['contains'];
+        matchingRegex: (regex: RegExp) => KeyComparison['matchesRegex'];
+    };
 };
 type Match = BaseMatch & {
     not: BaseMatch;
@@ -91,7 +110,10 @@ type PartialError = {
  *   partialEqual([1, 2, 3], match.array.endsWith([2, 3])); // true - suffix matching
  *   partialEqual([1, 2, 3], match.array.length(3)); // true - exact length
  *   partialEqual([1, 2, 3], match.array.includes(2)); // true - includes element
- *   partialEqual([10, 20, 30], match.array.every(match.num.isGreaterThan(5))); // true - all elements match
+ *   partialEqual(
+ *     [10, 20, 30],
+ *     match.array.every(match.num.isGreaterThan(5)),
+ *   ); // true - all elements match
  *   partialEqual([1, 10, 3], match.array.some(match.num.isGreaterThan(8))); // true - at least one matches
  *
  *   // Special comparisons

package/dist/partialEqual.d.ts

@@ -6,6 +6,16 @@ type ComparisonsType = [type: 'strStartsWith', value: string] | [type: 'strEndsW
 ] | [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: 'arrayContains', value: any[]] | [type: 'arrayContainsInOrder', value: any[]] | [type: 'arrayStartsWith', value: any[]] | [type: 'arrayEndsWith', value: any[]] | [type: 'arrayLength', value: number] | [type: 'arrayMinLength', value: number] | [type: 'arrayMaxLength', value: number] | [type: 'arrayIncludes', value: any] | [type: 'arrayEvery', value: ComparisonsType] | [type: 'arraySome', value: ComparisonsType] | [type: 'jsonStringHasPartial', value: any] | [type: 'partialEqual', value: any] | [type: 'custom', value: (target: unknown) => boolean | {
     error: string;
 }] | [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 KeyComparisonPrefix = 'pqkc' | 'pqkc-not';
+type KeyComparison = {
+    any: `$${KeyComparisonPrefix}:any$`;
+    anyOther: `$${KeyComparisonPrefix}:anyOther$`;
+    numeric: `$${KeyComparisonPrefix}:numeric$`;
+    startingWith: `$${KeyComparisonPrefix}:startingWith:${string}$`;
+    endingWith: `$${KeyComparisonPrefix}:endingWith:${string}$`;
+    contains: `$${KeyComparisonPrefix}:contains:${string}$`;
+    matchesRegex: `$${KeyComparisonPrefix}:matchesRegex:${string}$`;
+};
 type Comparison = {
     '~sc': ComparisonsType;
 };
@@ -59,6 +69,15 @@ type BaseMatch = {
     keyNotBePresent: Comparison;
     any: (...values: any[]) => Comparison;
     all: (...values: any[]) => Comparison;
+    key: {
+        any: KeyComparison['any'];
+        anyOther: KeyComparison['anyOther'];
+        numeric: KeyComparison['numeric'];
+        startingWith: (substring: string) => KeyComparison['startingWith'];
+        endingWith: (substring: string) => KeyComparison['endingWith'];
+        containing: (substring: string) => KeyComparison['contains'];
+        matchingRegex: (regex: RegExp) => KeyComparison['matchesRegex'];
+    };
 };
 type Match = BaseMatch & {
     not: BaseMatch;
@@ -91,7 +110,10 @@ type PartialError = {
  *   partialEqual([1, 2, 3], match.array.endsWith([2, 3])); // true - suffix matching
  *   partialEqual([1, 2, 3], match.array.length(3)); // true - exact length
  *   partialEqual([1, 2, 3], match.array.includes(2)); // true - includes element
- *   partialEqual([10, 20, 30], match.array.every(match.num.isGreaterThan(5))); // true - all elements match
+ *   partialEqual(
+ *     [10, 20, 30],
+ *     match.array.every(match.num.isGreaterThan(5)),
+ *   ); // true - all elements match
  *   partialEqual([1, 10, 3], match.array.some(match.num.isGreaterThan(8))); // true - at least one matches
  *
  *   // Special comparisons

package/dist/partialEqual.js

@@ -73,6 +73,15 @@ var match = {
       return ["deepEqual", v];
     })
   ]),
+  key: {
+    any: "$pqkc:any$",
+    anyOther: "$pqkc:anyOther$",
+    numeric: "$pqkc:numeric$",
+    startingWith: (substring) => `$pqkc:startingWith:${substring}$`,
+    endingWith: (substring) => `$pqkc:endingWith:${substring}$`,
+    containing: (substring) => `$pqkc:contains:${substring}$`,
+    matchingRegex: (regex) => `$pqkc:matchesRegex:${regex}$`
+  },
   not: {
     hasType: {
       string: createComparison(["not", ["hasType", "string"]]),
@@ -142,12 +151,93 @@ var match = {
     noExtraKeys: (partialShape) => createComparison(["not", ["withNoExtraKeys", partialShape]]),
     deepNoExtraKeys: (partialShape) => createComparison(["not", ["withDeepNoExtraKeys", partialShape]]),
     noExtraDefinedKeys: (partialShape) => createComparison(["not", ["noExtraDefinedKeys", partialShape]]),
-    deepNoExtraDefinedKeys: (partialShape) => createComparison(["not", ["deepNoExtraDefinedKeys", partialShape]])
+    deepNoExtraDefinedKeys: (partialShape) => createComparison(["not", ["deepNoExtraDefinedKeys", partialShape]]),
+    key: {
+      any: "$pqkc-not:any$",
+      anyOther: "$pqkc-not:anyOther$",
+      numeric: "$pqkc-not:numeric$",
+      startingWith: (substring) => `$pqkc-not:startingWith:${substring}$`,
+      endingWith: (substring) => `$pqkc-not:endingWith:${substring}$`,
+      containing: (substring) => `$pqkc-not:contains:${substring}$`,
+      matchingRegex: (regex) => `$pqkc-not:matchesRegex:${regex}$`
+    }
   }
 };
 function isComparison(value) {
   return value && typeof value === "object" && "~sc" in value;
 }
+function isKeyMatcher(key) {
+  return typeof key === "string" && (key.startsWith("$pqkc:") || key.startsWith("$pqkc-not:"));
+}
+function parseKeyMatcher(key) {
+  if (!isKeyMatcher(key)) return null;
+  const negated = key.startsWith("$pqkc-not:");
+  const prefix = negated ? "$pqkc-not:" : "$pqkc:";
+  const suffix = "$";
+  if (!key.endsWith(suffix)) return null;
+  const content = key.slice(prefix.length, -suffix.length);
+  if (content === "any") {
+    return { type: "any", negated };
+  }
+  if (content === "anyOther") {
+    return { type: "anyOther", negated };
+  }
+  if (content === "numeric") {
+    return { type: "numeric", negated };
+  }
+  if (content.startsWith("startingWith:")) {
+    return { type: "startingWith", parameter: content.slice("startingWith:".length), negated };
+  }
+  if (content.startsWith("endingWith:")) {
+    return { type: "endingWith", parameter: content.slice("endingWith:".length), negated };
+  }
+  if (content.startsWith("contains:")) {
+    return { type: "contains", parameter: content.slice("contains:".length), negated };
+  }
+  if (content.startsWith("matchesRegex:")) {
+    const regexStr = content.slice("matchesRegex:".length);
+    try {
+      if (regexStr.startsWith("/") && regexStr.lastIndexOf("/") > 0) {
+        const lastSlashIndex = regexStr.lastIndexOf("/");
+        const pattern = regexStr.slice(1, lastSlashIndex);
+        const flags = regexStr.slice(lastSlashIndex + 1);
+        return { type: "matchesRegex", parameter: new RegExp(pattern, flags), negated };
+      } else {
+        return { type: "matchesRegex", parameter: new RegExp(regexStr), negated };
+      }
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function keyMatchesPattern(key, matcher) {
+  let matches = false;
+  switch (matcher.type) {
+    case "any":
+      matches = true;
+      break;
+    case "anyOther":
+      matches = true;
+      break;
+    case "numeric":
+      matches = /^\d+$/.test(key);
+      break;
+    case "startingWith":
+      matches = key.startsWith(matcher.parameter);
+      break;
+    case "endingWith":
+      matches = key.endsWith(matcher.parameter);
+      break;
+    case "contains":
+      matches = key.includes(matcher.parameter);
+      break;
+    case "matchesRegex":
+      matches = matcher.parameter.test(key);
+      break;
+  }
+  return matcher.negated ? !matches : matches;
+}
 function executeComparison(target, comparison, context) {
   const [type, value] = comparison;
   switch (type) {
@@ -844,7 +934,21 @@ function partialEqualInternal(target, sub, context) {
       return false;
     }
     let allMatch = true;
+    const regularKeys = [];
+    const keyMatchers = [];
     for (const key of Object.keys(sub)) {
+      if (isKeyMatcher(key)) {
+        const matcher = parseKeyMatcher(key);
+        if (matcher) {
+          keyMatchers.push({ key, matcher, value: sub[key] });
+        }
+      } else {
+        regularKeys.push(key);
+      }
+    }
+    const explicitlySpecifiedKeys = /* @__PURE__ */ new Set();
+    for (const key of regularKeys) {
+      explicitlySpecifiedKeys.add(key);
       if (isComparison(sub[key]) && sub[key]["~sc"][0] === "keyNotBePresent") {
         if (has.call(target, key)) {
           const oldPath2 = context.path;
@@ -888,6 +992,72 @@ function partialEqualInternal(target, sub, context) {
       context.path = oldPath;
       if (!result) allMatch = false;
     }
+    for (const { matcher, value } of keyMatchers) {
+      let foundMatch = false;
+      const matchedKeys = [];
+      if (matcher.type === "anyOther") {
+        for (const targetKey of Object.keys(target)) {
+          if (!explicitlySpecifiedKeys.has(targetKey)) {
+            const matches = keyMatchesPattern(targetKey, matcher);
+            if (matches) {
+              foundMatch = true;
+              matchedKeys.push(targetKey);
+              const oldPath = context.path;
+              context.path = [...oldPath, targetKey];
+              const result = partialEqualInternal(target[targetKey], value, context);
+              context.path = oldPath;
+              if (!result) allMatch = false;
+            }
+          }
+        }
+      } else if (matcher.type === "any") {
+        let anyKeyMatched = false;
+        for (const targetKey of Object.keys(target)) {
+          if (keyMatchesPattern(targetKey, matcher)) {
+            foundMatch = true;
+            matchedKeys.push(targetKey);
+            explicitlySpecifiedKeys.add(targetKey);
+            const tempContext = {
+              errors: [],
+              path: [...context.path, targetKey]
+            };
+            const result = partialEqualInternal(target[targetKey], value, tempContext);
+            if (result) {
+              anyKeyMatched = true;
+              break;
+            }
+          }
+        }
+        if (foundMatch && !anyKeyMatched) {
+          addError(context, {
+            message: `No keys matching pattern had the expected value`,
+            received: { keysChecked: matchedKeys, availableKeys: Object.keys(target) }
+          });
+          allMatch = false;
+        }
+      } else {
+        for (const targetKey of Object.keys(target)) {
+          if (keyMatchesPattern(targetKey, matcher)) {
+            foundMatch = true;
+            matchedKeys.push(targetKey);
+            explicitlySpecifiedKeys.add(targetKey);
+            const oldPath = context.path;
+            context.path = [...oldPath, targetKey];
+            const result = partialEqualInternal(target[targetKey], value, context);
+            context.path = oldPath;
+            if (!result) allMatch = false;
+          }
+        }
+      }
+      if (!foundMatch) {
+        const patternDescription = matcher.type === "anyOther" ? "anyOther (keys not explicitly specified)" : `${matcher.type}${matcher.parameter ? ` (${matcher.parameter})` : ""}`;
+        addError(context, {
+          message: `No keys found matching pattern: ${patternDescription}`,
+          received: { availableKeys: Object.keys(target), explicitKeys: Array.from(explicitlySpecifiedKeys) }
+        });
+        allMatch = false;
+      }
+    }
     return allMatch;
   }
   if (target !== sub) {

package/package.json

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