@ls-stack/utils 3.41.0 → 3.43.0

package/dist/partialEqual.d.ts

@@ -0,0 +1,50 @@
+type ComparisonsType = [type: 'strStartsWith', value: string] | [type: 'strEndsWith', value: string] | [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: 'jsonStringHasPartial', value: any] | [type: 'partialEqual', value: any] | [type: 'custom', value: (target: unknown) => boolean] | [type: 'not', value: ComparisonsType];
+declare class Comparisons {
+    type: ComparisonsType;
+    constructor(type: ComparisonsType);
+}
+declare const match: {
+    str: {
+        contains: (substring: string) => Comparisons;
+        startsWith: (substring: string) => Comparisons;
+        endsWith: (substring: string) => Comparisons;
+        matchesRegex: (regex: RegExp) => Comparisons;
+    };
+    num: {
+        isGreaterThan: (value: number) => Comparisons;
+        isGreaterThanOrEqual: (value: number) => Comparisons;
+        isLessThan: (value: number) => Comparisons;
+        isLessThanOrEqual: (value: number) => Comparisons;
+        isInRange: (value: [number, number]) => Comparisons;
+    };
+    jsonString: {
+        hasPartial: (value: any) => Comparisons;
+    };
+    equal: (value: any) => Comparisons;
+    partialEqual: (value: any) => Comparisons;
+    custom: (isEqual: (value: unknown) => boolean) => Comparisons;
+    not: {
+        str: {
+            contains: (substring: string) => Comparisons;
+            startsWith: (substring: string) => Comparisons;
+            endsWith: (substring: string) => Comparisons;
+            matchesRegex: (regex: RegExp) => Comparisons;
+        };
+        num: {
+            isGreaterThan: (value: number) => Comparisons;
+            isGreaterThanOrEqual: (value: number) => Comparisons;
+            isLessThan: (value: number) => Comparisons;
+            isLessThanOrEqual: (value: number) => Comparisons;
+            isInRange: (value: [number, number]) => Comparisons;
+        };
+        jsonString: {
+            hasPartial: (value: any) => Comparisons;
+        };
+        equal: (value: any) => Comparisons;
+        partialEqual: (value: any) => Comparisons;
+        custom: (value: (target: unknown) => boolean) => Comparisons;
+    };
+};
+declare function partialEqual(target: any, sub: any): boolean;
+
+export { match, partialEqual };

package/dist/partialEqual.js

@@ -0,0 +1,164 @@
+import {
+  deepEqual
+} from "./chunk-JQFUKJU5.js";
+
+// src/partialEqual.ts
+var has = Object.prototype.hasOwnProperty;
+var Comparisons = class {
+  type;
+  constructor(type) {
+    this.type = type;
+  }
+};
+var match = {
+  str: {
+    contains: (substring) => new Comparisons(["strContains", substring]),
+    startsWith: (substring) => new Comparisons(["strStartsWith", substring]),
+    endsWith: (substring) => new Comparisons(["strEndsWith", substring]),
+    matchesRegex: (regex) => new Comparisons(["strMatchesRegex", regex])
+  },
+  num: {
+    isGreaterThan: (value) => new Comparisons(["numIsGreaterThan", value]),
+    isGreaterThanOrEqual: (value) => new Comparisons(["numIsGreaterThanOrEqual", value]),
+    isLessThan: (value) => new Comparisons(["numIsLessThan", value]),
+    isLessThanOrEqual: (value) => new Comparisons(["numIsLessThanOrEqual", value]),
+    isInRange: (value) => new Comparisons(["numIsInRange", value])
+  },
+  jsonString: {
+    hasPartial: (value) => new Comparisons(["jsonStringHasPartial", value])
+  },
+  equal: (value) => new Comparisons(["deepEqual", value]),
+  partialEqual: (value) => new Comparisons(["partialEqual", value]),
+  custom: (isEqual) => new Comparisons(["custom", isEqual]),
+  not: {
+    str: {
+      contains: (substring) => new Comparisons(["not", ["strContains", substring]]),
+      startsWith: (substring) => new Comparisons(["not", ["strStartsWith", substring]]),
+      endsWith: (substring) => new Comparisons(["not", ["strEndsWith", substring]]),
+      matchesRegex: (regex) => new Comparisons(["not", ["strMatchesRegex", regex]])
+    },
+    num: {
+      isGreaterThan: (value) => new Comparisons(["not", ["numIsGreaterThan", value]]),
+      isGreaterThanOrEqual: (value) => new Comparisons(["not", ["numIsGreaterThanOrEqual", value]]),
+      isLessThan: (value) => new Comparisons(["not", ["numIsLessThan", value]]),
+      isLessThanOrEqual: (value) => new Comparisons(["not", ["numIsLessThanOrEqual", value]]),
+      isInRange: (value) => new Comparisons(["not", ["numIsInRange", value]])
+    },
+    jsonString: {
+      hasPartial: (value) => new Comparisons(["not", ["jsonStringHasPartial", value]])
+    },
+    equal: (value) => new Comparisons(["not", ["deepEqual", value]]),
+    partialEqual: (value) => new Comparisons(["not", ["partialEqual", value]]),
+    custom: (value) => new Comparisons(["not", ["custom", value]])
+  }
+};
+function find(iter, tar) {
+  for (const key of iter.keys()) {
+    if (partialEqual(key, tar)) return key;
+  }
+}
+function executeComparison(target, comparison) {
+  const [type, value] = comparison;
+  switch (type) {
+    case "strStartsWith":
+      return typeof target === "string" && target.startsWith(value);
+    case "strEndsWith":
+      return typeof target === "string" && target.endsWith(value);
+    case "strContains":
+      return typeof target === "string" && target.includes(value);
+    case "strMatchesRegex":
+      return typeof target === "string" && value.test(target);
+    case "numIsGreaterThan":
+      return typeof target === "number" && target > value;
+    case "numIsGreaterThanOrEqual":
+      return typeof target === "number" && target >= value;
+    case "numIsLessThan":
+      return typeof target === "number" && target < value;
+    case "numIsLessThanOrEqual":
+      return typeof target === "number" && target <= value;
+    case "numIsInRange":
+      return typeof target === "number" && target >= value[0] && target <= value[1];
+    case "jsonStringHasPartial":
+      if (typeof target !== "string") return false;
+      try {
+        const parsed = JSON.parse(target);
+        return partialEqual(parsed, value);
+      } catch {
+        return false;
+      }
+    case "deepEqual":
+      return deepEqual(target, value);
+    case "partialEqual":
+      return partialEqual(target, value);
+    case "custom":
+      return value(target);
+    case "not":
+      return !executeComparison(target, value);
+    default:
+      return false;
+  }
+}
+function partialEqual(target, sub) {
+  if (sub === target) return true;
+  if (sub instanceof Comparisons) {
+    return executeComparison(target, sub.type);
+  }
+  if (sub && target && sub.constructor === target.constructor) {
+    const ctor = sub.constructor;
+    if (ctor === Date) {
+      return sub.getTime() === target.getTime();
+    }
+    if (ctor === RegExp) {
+      return sub.toString() === target.toString();
+    }
+    if (ctor === Array) {
+      if (sub.length > target.length) return false;
+      for (let i = 0; i < sub.length; i++) {
+        if (!partialEqual(target[i], sub[i])) return false;
+      }
+      return true;
+    }
+    if (ctor === Set) {
+      if (sub.size > target.size) return false;
+      for (const value of sub) {
+        let found = false;
+        if (value && typeof value === "object") {
+          found = !!find(target, value);
+        } else {
+          found = target.has(value);
+        }
+        if (!found) return false;
+      }
+      return true;
+    }
+    if (ctor === Map) {
+      if (sub.size > target.size) return false;
+      for (const [key, value] of sub) {
+        let targetKey = key;
+        if (key && typeof key === "object") {
+          targetKey = find(target, key);
+          if (!targetKey) return false;
+        }
+        if (!target.has(targetKey) || !partialEqual(target.get(targetKey), value)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    if (!ctor || typeof sub === "object") {
+      for (const key in sub) {
+        if (has.call(sub, key)) {
+          if (!has.call(target, key) || !partialEqual(target[key], sub[key])) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
+  }
+  return sub !== sub && target !== target;
+}
+export {
+  match,
+  partialEqual
+};

package/dist/testUtils.js

@@ -4,8 +4,8 @@ import {
 import {
   omit,
   pick
-} from "./chunk-23KPGKDT.js";
-import "./chunk-DTE2QMWE.js";
+} from "./chunk-Y45CE75W.js";
+import "./chunk-GMJTLFM6.js";
 import "./chunk-IATIXMCE.js";
 import {
   deepEqual

package/dist/typingFnUtils.cjs

@@ -23,9 +23,12 @@ __export(typingFnUtils_exports, {
   asNonPartial: () => asNonPartial,
   asPartialUndefinedValues: () => asPartialUndefinedValues,
   asType: () => asType,
+  isNonEmptyArray: () => isNonEmptyArray,
   isObjKey: () => isObjKey,
   isSubTypeOf: () => isSubTypeOf,
   narrowStringToUnion: () => narrowStringToUnion,
+  objectHasKey: () => objectHasKey,
+  strictTypedObjectEntries: () => strictTypedObjectEntries,
   typeOnRightExtendsLeftType: () => typeOnRightExtendsLeftType,
   typedObjectEntries: () => typedObjectEntries,
   typedObjectKeys: () => typedObjectKeys,
@@ -38,6 +41,9 @@ function asNonPartial(obj) {
 function typedObjectEntries(obj) {
   return Object.entries(obj);
 }
+function strictTypedObjectEntries(obj) {
+  return Object.entries(obj);
+}
 function typedObjectKeys(obj) {
   return Object.keys(obj);
 }
@@ -66,14 +72,23 @@ function unionsAreTheSame(_diff) {
 function asPartialUndefinedValues(value) {
   return value;
 }
+function isNonEmptyArray(array) {
+  return array.length > 0;
+}
+function objectHasKey(obj, key) {
+  return key in obj;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   asNonPartial,
   asPartialUndefinedValues,
   asType,
+  isNonEmptyArray,
   isObjKey,
   isSubTypeOf,
   narrowStringToUnion,
+  objectHasKey,
+  strictTypedObjectEntries,
   typeOnRightExtendsLeftType,
   typedObjectEntries,
   typedObjectKeys,

package/dist/typingFnUtils.d.cts

@@ -10,6 +10,15 @@ declare function asNonPartial<T extends Record<string, unknown>>(obj: T): NonPar
 declare function typedObjectEntries<T extends Record<string, unknown>>(obj: T): NonNullable<{
     [K in keyof T]: [K, T[K]];
 }[keyof T]>[];
+/**
+ * A wrapper to Object.entries with a better typing inference, but with strict
+ * typing narrowing keys to strings.
+ *
+ * @param obj
+ */
+declare function strictTypedObjectEntries<T extends Record<string, unknown>>(obj: T): NonNullable<{
+    [K in keyof T]: [K & string, T[K]];
+}[keyof T]>[];
 /**
  * A wrapper to Object.keys with a better typing inference
  *
@@ -68,5 +77,24 @@ type UnionDiff<T, U> = [
  */
 declare function unionsAreTheSame<T, U>(_diff: UnionDiff<T, U>): void;
 declare function asPartialUndefinedValues<T extends Record<string, unknown>>(value: PartialPossiblyUndefinedValues<T>): T;
+/** A type representing an array that is guaranteed to have at least one element. */
+type NonEmptyArray<T> = [T, ...T[]];
+/**
+ * Type guard to check if an array has at least one element.
+ *
+ * @param array - The array to check
+ * @returns True if the array is non-empty, false otherwise
+ */
+declare function isNonEmptyArray<T>(array: T[]): array is NonEmptyArray<T>;
+/**
+ * Type guard to check if an object has a specific key and narrow its type.
+ *
+ * @param obj - The object to check
+ * @param key - The key to check for
+ * @returns True if the object has the key, false otherwise
+ */
+declare function objectHasKey<T extends string>(obj: object, key: T): obj is object & {
+    [K in T]: unknown;
+};
 
-export { asNonPartial, asPartialUndefinedValues, asType, isObjKey, isSubTypeOf, narrowStringToUnion, typeOnRightExtendsLeftType, typedObjectEntries, typedObjectKeys, unionsAreTheSame };
+export { type NonEmptyArray, asNonPartial, asPartialUndefinedValues, asType, isNonEmptyArray, isObjKey, isSubTypeOf, narrowStringToUnion, objectHasKey, strictTypedObjectEntries, typeOnRightExtendsLeftType, typedObjectEntries, typedObjectKeys, unionsAreTheSame };

package/dist/typingFnUtils.d.ts

@@ -10,6 +10,15 @@ declare function asNonPartial<T extends Record<string, unknown>>(obj: T): NonPar
 declare function typedObjectEntries<T extends Record<string, unknown>>(obj: T): NonNullable<{
     [K in keyof T]: [K, T[K]];
 }[keyof T]>[];
+/**
+ * A wrapper to Object.entries with a better typing inference, but with strict
+ * typing narrowing keys to strings.
+ *
+ * @param obj
+ */
+declare function strictTypedObjectEntries<T extends Record<string, unknown>>(obj: T): NonNullable<{
+    [K in keyof T]: [K & string, T[K]];
+}[keyof T]>[];
 /**
  * A wrapper to Object.keys with a better typing inference
  *
@@ -68,5 +77,24 @@ type UnionDiff<T, U> = [
  */
 declare function unionsAreTheSame<T, U>(_diff: UnionDiff<T, U>): void;
 declare function asPartialUndefinedValues<T extends Record<string, unknown>>(value: PartialPossiblyUndefinedValues<T>): T;
+/** A type representing an array that is guaranteed to have at least one element. */
+type NonEmptyArray<T> = [T, ...T[]];
+/**
+ * Type guard to check if an array has at least one element.
+ *
+ * @param array - The array to check
+ * @returns True if the array is non-empty, false otherwise
+ */
+declare function isNonEmptyArray<T>(array: T[]): array is NonEmptyArray<T>;
+/**
+ * Type guard to check if an object has a specific key and narrow its type.
+ *
+ * @param obj - The object to check
+ * @param key - The key to check for
+ * @returns True if the object has the key, false otherwise
+ */
+declare function objectHasKey<T extends string>(obj: object, key: T): obj is object & {
+    [K in T]: unknown;
+};
 
-export { asNonPartial, asPartialUndefinedValues, asType, isObjKey, isSubTypeOf, narrowStringToUnion, typeOnRightExtendsLeftType, typedObjectEntries, typedObjectKeys, unionsAreTheSame };
+export { type NonEmptyArray, asNonPartial, asPartialUndefinedValues, asType, isNonEmptyArray, isObjKey, isSubTypeOf, narrowStringToUnion, objectHasKey, strictTypedObjectEntries, typeOnRightExtendsLeftType, typedObjectEntries, typedObjectKeys, unionsAreTheSame };

package/dist/typingFnUtils.js

@@ -2,21 +2,27 @@ import {
   asNonPartial,
   asPartialUndefinedValues,
   asType,
+  isNonEmptyArray,
   isObjKey,
   isSubTypeOf,
   narrowStringToUnion,
+  objectHasKey,
+  strictTypedObjectEntries,
   typeOnRightExtendsLeftType,
   typedObjectEntries,
   typedObjectKeys,
   unionsAreTheSame
-} from "./chunk-DTE2QMWE.js";
+} from "./chunk-GMJTLFM6.js";
 export {
   asNonPartial,
   asPartialUndefinedValues,
   asType,
+  isNonEmptyArray,
   isObjKey,
   isSubTypeOf,
   narrowStringToUnion,
+  objectHasKey,
+  strictTypedObjectEntries,
   typeOnRightExtendsLeftType,
   typedObjectEntries,
   typedObjectKeys,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Universal TypeScript utilities for browser and Node.js",
-  "version": "3.41.0",
+  "version": "3.43.0",
   "license": "MIT",
   "files": [
     "dist",
@@ -116,6 +116,10 @@
       "import": "./dist/levenshtein.js",
       "require": "./dist/levenshtein.cjs"
     },
+    "./matchPath": {
+      "import": "./dist/matchPath.js",
+      "require": "./dist/matchPath.cjs"
+    },
     "./mathUtils": {
       "import": "./dist/mathUtils.js",
       "require": "./dist/mathUtils.cjs"
@@ -132,6 +136,10 @@
       "import": "./dist/parallelAsyncCalls.js",
       "require": "./dist/parallelAsyncCalls.cjs"
     },
+    "./partialEqual": {
+      "import": "./dist/partialEqual.js",
+      "require": "./dist/partialEqual.cjs"
+    },
     "./promiseUtils": {
       "import": "./dist/promiseUtils.js",
       "require": "./dist/promiseUtils.cjs"