@ls-stack/utils 3.53.0 → 3.55.0

package/dist/{chunk-7L4KCZJJ.js → chunk-B6DNOZCP.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-IATIXMCE.js";
 import {
   truncateString
-} from "./chunk-B3KFV2MH.js";
+} from "./chunk-BM4PYVOX.js";
 import {
   isObject,
   isPlainObject

package/dist/{chunk-B3KFV2MH.js → chunk-BM4PYVOX.js}

@@ -22,6 +22,33 @@ function formatNum(num, maxDecimalsOrOptions = 2) {
 function isSnakeCase(str) {
   return /^[a-z0-9_]+$/.test(str);
 }
+function isKebabCase(str) {
+  return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(str);
+}
+function isPascalCase(str) {
+  return /^[A-Z][a-zA-Z0-9]*$/.test(str);
+}
+function isCamelCase(str) {
+  return /^[a-z][a-zA-Z0-9]*$/.test(str);
+}
+function isTitleCase(str) {
+  return /^[A-Z][a-z0-9]*( ([A-Z][a-z0-9]*|[0-9]+))*$/.test(str);
+}
+function isSentenceCase(str) {
+  return /^[A-Z][a-z0-9]*( [a-z0-9]+)*$/.test(str);
+}
+function isConstantCase(str) {
+  return /^[A-Z_][A-Z0-9_]*$/.test(str);
+}
+function isDotCase(str) {
+  return /^[a-z0-9]+(\.[a-z0-9]+)*$/.test(str);
+}
+function isPathCase(str) {
+  return /^[a-z0-9]+(\/[a-z0-9]+)*$/.test(str);
+}
+function convertToKebabCase(str) {
+  return convertToSnakeCase(str).replace(/_/g, "-");
+}
 function convertToSnakeCase(str) {
   return str.replace(/[\s\-.]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9_]/g, "").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
 }
@@ -38,6 +65,15 @@ function convertToSentenceCase(str) {
 function convertToTitleCase(str) {
   return str.replace(/[\s\-.]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
 }
+function convertToConstantCase(str) {
+  return convertToSnakeCase(str).toUpperCase();
+}
+function convertToDotCase(str) {
+  return convertToSnakeCase(str).replace(/_/g, ".");
+}
+function convertToPathCase(str) {
+  return convertToSnakeCase(str).replace(/_/g, "/");
+}
 function truncateString(str, length, ellipsis = "\u2026") {
   if (str.length <= length) return str;
   return str.slice(0, length - 1) + ellipsis;
@@ -51,11 +87,23 @@ export {
   joinStrings,
   formatNum,
   isSnakeCase,
+  isKebabCase,
+  isPascalCase,
+  isCamelCase,
+  isTitleCase,
+  isSentenceCase,
+  isConstantCase,
+  isDotCase,
+  isPathCase,
+  convertToKebabCase,
   convertToSnakeCase,
   convertToPascalCase,
   convertToCamelCase,
   convertToSentenceCase,
   convertToTitleCase,
+  convertToConstantCase,
+  convertToDotCase,
+  convertToPathCase,
   truncateString,
   removeANSIColors
 };

package/dist/concurrentCalls.js

@@ -3,7 +3,7 @@ import {
 } from "./chunk-VAAMRG4K.js";
 import {
   truncateString
-} from "./chunk-B3KFV2MH.js";
+} from "./chunk-BM4PYVOX.js";
 import {
   sleep
 } from "./chunk-5DZT3Z5Z.js";

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/dist/stringUtils.cjs

@@ -22,12 +22,24 @@ var stringUtils_exports = {};
 __export(stringUtils_exports, {
   concatStrings: () => concatStrings,
   convertToCamelCase: () => convertToCamelCase,
+  convertToConstantCase: () => convertToConstantCase,
+  convertToDotCase: () => convertToDotCase,
+  convertToKebabCase: () => convertToKebabCase,
   convertToPascalCase: () => convertToPascalCase,
+  convertToPathCase: () => convertToPathCase,
   convertToSentenceCase: () => convertToSentenceCase,
   convertToSnakeCase: () => convertToSnakeCase,
   convertToTitleCase: () => convertToTitleCase,
   formatNum: () => formatNum,
+  isCamelCase: () => isCamelCase,
+  isConstantCase: () => isConstantCase,
+  isDotCase: () => isDotCase,
+  isKebabCase: () => isKebabCase,
+  isPascalCase: () => isPascalCase,
+  isPathCase: () => isPathCase,
+  isSentenceCase: () => isSentenceCase,
   isSnakeCase: () => isSnakeCase,
+  isTitleCase: () => isTitleCase,
   joinStrings: () => joinStrings,
   removeANSIColors: () => removeANSIColors,
   truncateString: () => truncateString
@@ -56,6 +68,33 @@ function formatNum(num, maxDecimalsOrOptions = 2) {
 function isSnakeCase(str) {
   return /^[a-z0-9_]+$/.test(str);
 }
+function isKebabCase(str) {
+  return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(str);
+}
+function isPascalCase(str) {
+  return /^[A-Z][a-zA-Z0-9]*$/.test(str);
+}
+function isCamelCase(str) {
+  return /^[a-z][a-zA-Z0-9]*$/.test(str);
+}
+function isTitleCase(str) {
+  return /^[A-Z][a-z0-9]*( ([A-Z][a-z0-9]*|[0-9]+))*$/.test(str);
+}
+function isSentenceCase(str) {
+  return /^[A-Z][a-z0-9]*( [a-z0-9]+)*$/.test(str);
+}
+function isConstantCase(str) {
+  return /^[A-Z_][A-Z0-9_]*$/.test(str);
+}
+function isDotCase(str) {
+  return /^[a-z0-9]+(\.[a-z0-9]+)*$/.test(str);
+}
+function isPathCase(str) {
+  return /^[a-z0-9]+(\/[a-z0-9]+)*$/.test(str);
+}
+function convertToKebabCase(str) {
+  return convertToSnakeCase(str).replace(/_/g, "-");
+}
 function convertToSnakeCase(str) {
   return str.replace(/[\s\-.]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z])([A-Z][a-z])/g, "$1_$2").toLowerCase().replace(/[^a-z0-9_]/g, "").replace(/^_+|_+$/g, "").replace(/_+/g, "_");
 }
@@ -72,6 +111,15 @@ function convertToSentenceCase(str) {
 function convertToTitleCase(str) {
   return str.replace(/[\s\-.]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z])([A-Z][a-z])/g, "$1 $2").split(/[\s_-]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
 }
+function convertToConstantCase(str) {
+  return convertToSnakeCase(str).toUpperCase();
+}
+function convertToDotCase(str) {
+  return convertToSnakeCase(str).replace(/_/g, ".");
+}
+function convertToPathCase(str) {
+  return convertToSnakeCase(str).replace(/_/g, "/");
+}
 function truncateString(str, length, ellipsis = "\u2026") {
   if (str.length <= length) return str;
   return str.slice(0, length - 1) + ellipsis;
@@ -83,12 +131,24 @@ function removeANSIColors(str) {
 0 && (module.exports = {
   concatStrings,
   convertToCamelCase,
+  convertToConstantCase,
+  convertToDotCase,
+  convertToKebabCase,
   convertToPascalCase,
+  convertToPathCase,
   convertToSentenceCase,
   convertToSnakeCase,
   convertToTitleCase,
   formatNum,
+  isCamelCase,
+  isConstantCase,
+  isDotCase,
+  isKebabCase,
+  isPascalCase,
+  isPathCase,
+  isSentenceCase,
   isSnakeCase,
+  isTitleCase,
   joinStrings,
   removeANSIColors,
   truncateString

package/dist/stringUtils.d.cts

@@ -14,12 +14,24 @@ declare function concatStrings(...args: (Arg | Arg[])[]): string;
 declare const joinStrings: typeof concatStrings;
 declare function formatNum(num: number, maxDecimalsOrOptions?: number | Intl.NumberFormatOptions): string;
 declare function isSnakeCase(str: string): boolean;
+declare function isKebabCase(str: string): boolean;
+declare function isPascalCase(str: string): boolean;
+declare function isCamelCase(str: string): boolean;
+declare function isTitleCase(str: string): boolean;
+declare function isSentenceCase(str: string): boolean;
+declare function isConstantCase(str: string): boolean;
+declare function isDotCase(str: string): boolean;
+declare function isPathCase(str: string): boolean;
+declare function convertToKebabCase(str: string): string;
 declare function convertToSnakeCase(str: string): string;
 declare function convertToPascalCase(str: string): string;
 declare function convertToCamelCase(str: string): string;
 declare function convertToSentenceCase(str: string): string;
 declare function convertToTitleCase(str: string): string;
+declare function convertToConstantCase(str: string): string;
+declare function convertToDotCase(str: string): string;
+declare function convertToPathCase(str: string): string;
 declare function truncateString(str: string, length: number, ellipsis?: string): string;
 declare function removeANSIColors(str: string): string;
 
-export { concatStrings, convertToCamelCase, convertToPascalCase, convertToSentenceCase, convertToSnakeCase, convertToTitleCase, formatNum, isSnakeCase, joinStrings, removeANSIColors, truncateString };
+export { concatStrings, convertToCamelCase, convertToConstantCase, convertToDotCase, convertToKebabCase, convertToPascalCase, convertToPathCase, convertToSentenceCase, convertToSnakeCase, convertToTitleCase, formatNum, isCamelCase, isConstantCase, isDotCase, isKebabCase, isPascalCase, isPathCase, isSentenceCase, isSnakeCase, isTitleCase, joinStrings, removeANSIColors, truncateString };

package/dist/stringUtils.d.ts

@@ -14,12 +14,24 @@ declare function concatStrings(...args: (Arg | Arg[])[]): string;
 declare const joinStrings: typeof concatStrings;
 declare function formatNum(num: number, maxDecimalsOrOptions?: number | Intl.NumberFormatOptions): string;
 declare function isSnakeCase(str: string): boolean;
+declare function isKebabCase(str: string): boolean;
+declare function isPascalCase(str: string): boolean;
+declare function isCamelCase(str: string): boolean;
+declare function isTitleCase(str: string): boolean;
+declare function isSentenceCase(str: string): boolean;
+declare function isConstantCase(str: string): boolean;
+declare function isDotCase(str: string): boolean;
+declare function isPathCase(str: string): boolean;
+declare function convertToKebabCase(str: string): string;
 declare function convertToSnakeCase(str: string): string;
 declare function convertToPascalCase(str: string): string;
 declare function convertToCamelCase(str: string): string;
 declare function convertToSentenceCase(str: string): string;
 declare function convertToTitleCase(str: string): string;
+declare function convertToConstantCase(str: string): string;
+declare function convertToDotCase(str: string): string;
+declare function convertToPathCase(str: string): string;
 declare function truncateString(str: string, length: number, ellipsis?: string): string;
 declare function removeANSIColors(str: string): string;
 
-export { concatStrings, convertToCamelCase, convertToPascalCase, convertToSentenceCase, convertToSnakeCase, convertToTitleCase, formatNum, isSnakeCase, joinStrings, removeANSIColors, truncateString };
+export { concatStrings, convertToCamelCase, convertToConstantCase, convertToDotCase, convertToKebabCase, convertToPascalCase, convertToPathCase, convertToSentenceCase, convertToSnakeCase, convertToTitleCase, formatNum, isCamelCase, isConstantCase, isDotCase, isKebabCase, isPascalCase, isPathCase, isSentenceCase, isSnakeCase, isTitleCase, joinStrings, removeANSIColors, truncateString };

package/dist/stringUtils.js

@@ -1,25 +1,49 @@
 import {
   concatStrings,
   convertToCamelCase,
+  convertToConstantCase,
+  convertToDotCase,
+  convertToKebabCase,
   convertToPascalCase,
+  convertToPathCase,
   convertToSentenceCase,
   convertToSnakeCase,
   convertToTitleCase,
   formatNum,
+  isCamelCase,
+  isConstantCase,
+  isDotCase,
+  isKebabCase,
+  isPascalCase,
+  isPathCase,
+  isSentenceCase,
   isSnakeCase,
+  isTitleCase,
   joinStrings,
   removeANSIColors,
   truncateString
-} from "./chunk-B3KFV2MH.js";
+} from "./chunk-BM4PYVOX.js";
 export {
   concatStrings,
   convertToCamelCase,
+  convertToConstantCase,
+  convertToDotCase,
+  convertToKebabCase,
   convertToPascalCase,
+  convertToPathCase,
   convertToSentenceCase,
   convertToSnakeCase,
   convertToTitleCase,
   formatNum,
+  isCamelCase,
+  isConstantCase,
+  isDotCase,
+  isKebabCase,
+  isPascalCase,
+  isPathCase,
+  isSentenceCase,
   isSnakeCase,
+  isTitleCase,
   joinStrings,
   removeANSIColors,
   truncateString

package/dist/testUtils.js

@@ -1,6 +1,6 @@
 import {
   yamlStringify
-} from "./chunk-7L4KCZJJ.js";
+} from "./chunk-B6DNOZCP.js";
 import {
   omit,
   pick
@@ -22,7 +22,7 @@ import {
 import {
   clampMin
 } from "./chunk-HTCYUMDR.js";
-import "./chunk-B3KFV2MH.js";
+import "./chunk-BM4PYVOX.js";
 import {
   arrayWithPrevAndIndex,
   filterAndMap

package/dist/yamlStringify.js

@@ -1,8 +1,8 @@
 import {
   yamlStringify
-} from "./chunk-7L4KCZJJ.js";
+} from "./chunk-B6DNOZCP.js";
 import "./chunk-IATIXMCE.js";
-import "./chunk-B3KFV2MH.js";
+import "./chunk-BM4PYVOX.js";
 import "./chunk-JF2MDHOJ.js";
 export {
   yamlStringify

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.55.0",
   "license": "MIT",
   "files": [
     "dist",