@ls-stack/utils 3.42.0 → 3.44.0

package/dist/partialEqual.js

@@ -0,0 +1,201 @@
+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 = {
+  hasType: {
+    string: new Comparisons(["hasType", "string"]),
+    number: new Comparisons(["hasType", "number"]),
+    boolean: new Comparisons(["hasType", "boolean"]),
+    object: new Comparisons(["hasType", "object"]),
+    array: new Comparisons(["hasType", "array"]),
+    function: new Comparisons(["hasType", "function"])
+  },
+  isInstanceOf: (constructor) => new Comparisons(["isInstanceOf", constructor]),
+  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: {
+    hasType: {
+      string: new Comparisons(["not", ["hasType", "string"]]),
+      number: new Comparisons(["not", ["hasType", "number"]]),
+      boolean: new Comparisons(["not", ["hasType", "boolean"]]),
+      object: new Comparisons(["not", ["hasType", "object"]]),
+      array: new Comparisons(["not", ["hasType", "array"]]),
+      function: new Comparisons(["not", ["hasType", "function"]])
+    },
+    isInstanceOf: (constructor) => new Comparisons(["not", ["isInstanceOf", constructor]]),
+    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 "hasType":
+      switch (value) {
+        case "string":
+          return typeof target === "string";
+        case "number":
+          return typeof target === "number";
+        case "boolean":
+          return typeof target === "boolean";
+        case "function":
+          return typeof target === "function";
+        case "array":
+          return Array.isArray(target);
+        case "object":
+          return typeof target === "object" && target !== null && !Array.isArray(target);
+        default:
+          return false;
+      }
+    case "isInstanceOf":
+      return target instanceof value;
+    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/typingFnUtils.d.cts

@@ -86,6 +86,13 @@ type NonEmptyArray<T> = [T, ...T[]];
  * @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;
 };

package/dist/typingFnUtils.d.ts

@@ -86,6 +86,13 @@ type NonEmptyArray<T> = [T, ...T[]];
  * @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;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Universal TypeScript utilities for browser and Node.js",
-  "version": "3.42.0",
+  "version": "3.44.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"