@fluixi/utils 1.0.0-alpha.100

package/dist/lib/compare/comparators.cjs

@@ -0,0 +1,171 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/compare/comparators.ts
+var comparators_exports = {};
+__export(comparators_exports, {
+  deepEqual: () => deepEqual,
+  hasLength: () => hasLength,
+  isDeepEqual: () => isDeepEqual,
+  isEqual: () => isEqual
+});
+module.exports = __toCommonJS(comparators_exports);
+
+// src/lib/helpers.ts
+var import_primitive = require("@fluixi/utils/primitive");
+var import_object = require("@fluixi/utils/object");
+var import_array = require("@fluixi/utils/array");
+var import_functions = require("@fluixi/utils/functions");
+var isUndefinedOrNull = (element) => {
+  if (typeof element === "undefined" || element === null) return true;
+  return false;
+};
+function isPrimitive(v) {
+  const type = typeof v;
+  return v === null || type === "string" || type === "number" || type === "boolean" || type === "symbol" || type === "bigint" || type === "undefined" || (0, import_primitive.isDate)(v);
+}
+
+// src/lib/compare/comparators.ts
+var import_object2 = require("@fluixi/utils/object");
+var hasLength = (data) => {
+  const type = typeof data;
+  let hasValue = false;
+  if (isUndefinedOrNull(data)) {
+    return false;
+  }
+  switch (type) {
+    case "string":
+      hasValue = data.length > 0;
+      break;
+    case "number":
+      hasValue = true;
+      break;
+    case "object":
+      if (Array.isArray(data)) {
+        hasValue = data.length > 0;
+      } else {
+        hasValue = Object.keys(data).length > 0;
+      }
+      break;
+    case "boolean":
+      hasValue = data;
+  }
+  return hasValue;
+};
+var isDeepEqual = (compare1, compare2, keys) => {
+  if (compare1 === void 0 || compare2 === void 0) return false;
+  if (compare1 === null || compare2 === null) return compare1 === compare2;
+  if (Array.isArray(compare1) && Array.isArray(compare2)) {
+    if (compare1.length !== compare2.length) return false;
+    return compare1.every((v, i) => isDeepEqual(v, compare2[i]));
+  }
+  if (keys && keys.length > 0) {
+    if (isPrimitive(compare1) && isPrimitive(compare2))
+      return compare1 === compare2;
+    if ((0, import_object2.isObject)(compare1) && (0, import_object2.isObject)(compare2))
+      return keys.every(
+        (k) => isDeepEqual(compare1[k], compare2[k])
+      );
+    return false;
+  }
+  if ((0, import_object2.isObject)(compare1) && (0, import_object2.isObject)(compare2)) {
+    const obj1Keys = Object.keys(compare1).sort();
+    const obj2Keys = Object.keys(compare2).sort();
+    if (obj1Keys.length !== obj2Keys.length) return false;
+    return obj1Keys.every(
+      (key) => isDeepEqual(compare1[key], compare2[key])
+    );
+  }
+  return compare1 === compare2;
+};
+function unorderedArrayEqual(a, b, opts) {
+  const used = new Uint8Array(b.length);
+  outer: for (let i = 0; i < a.length; i++) {
+    for (let j = 0; j < b.length; j++) {
+      if (!used[j] && deepEqual(a[i], b[j], opts)) {
+        used[j] = 1;
+        continue outer;
+      }
+    }
+    return false;
+  }
+  return true;
+}
+var deepEqual = (obj1, obj2, options = {}) => {
+  if (obj1 === obj2) return true;
+  if (obj1 == null || obj2 == null) return false;
+  if (typeof obj1 !== typeof obj2) return false;
+  const isArr1 = Array.isArray(obj1);
+  const isArr2 = Array.isArray(obj2);
+  if (isArr1 !== isArr2) return false;
+  if (isArr1 && isArr2) {
+    if (obj1.length !== obj2.length) return false;
+    return options.unordered ? unorderedArrayEqual(obj1, obj2, options) : obj1.every((item, i) => deepEqual(item, obj2[i], options));
+  }
+  if (typeof obj1 !== "object") return obj1 === obj2;
+  const isDate1 = obj1 instanceof Date;
+  const isDate2 = obj2 instanceof Date;
+  if (isDate1 !== isDate2) return false;
+  if (isDate1) return obj1.getTime() === obj2.getTime();
+  const isRE1 = obj1 instanceof RegExp;
+  const isRE2 = obj2 instanceof RegExp;
+  if (isRE1 !== isRE2) return false;
+  if (isRE1) return obj1.toString() === obj2.toString();
+  const isMap1 = obj1 instanceof Map;
+  const isMap2 = obj2 instanceof Map;
+  if (isMap1 !== isMap2) return false;
+  if (isMap1) {
+    if (obj1.size !== obj2.size) return false;
+    for (const [k, v] of obj1) {
+      if (!obj2.has(k)) return false;
+      if (!deepEqual(v, obj2.get(k), options)) return false;
+    }
+    return true;
+  }
+  const isSet1 = obj1 instanceof Set;
+  const isSet2 = obj2 instanceof Set;
+  if (isSet1 !== isSet2) return false;
+  if (isSet1) {
+    if (obj1.size !== obj2.size) return false;
+    const bArr = [...obj2];
+    const used = new Uint8Array(bArr.length);
+    outer: for (const v of obj1) {
+      for (let j = 0; j < bArr.length; j++) {
+        if (!used[j] && deepEqual(v, bArr[j], options)) {
+          used[j] = 1;
+          continue outer;
+        }
+      }
+      return false;
+    }
+    return true;
+  }
+  if (!(0, import_object2.isObject)(obj1) || !(0, import_object2.isObject)(obj2)) return false;
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  for (const key of keys1) {
+    if (!Object.prototype.hasOwnProperty.call(obj2, key)) return false;
+    if (!deepEqual(obj1[key], obj2[key], options)) return false;
+  }
+  return true;
+};
+function isEqual(a, b) {
+  return Object.is(a, b);
+}

package/dist/lib/compare/comparators.d.ts

@@ -0,0 +1,65 @@
+export declare const hasLength: (data: any) => boolean;
+/**
+ * The isEqual function compares two objects and returns true if they are equal.
+ *
+ * @param compare1: T Define the type of object that will be passed into the function
+ * @param compare2: T Compare the two objects
+ *
+ * @return A boolean value
+ *
+ * @docauthor Ibrahima Touré
+ */
+export declare const isDeepEqual: <T extends string | any>(compare1: T, compare2: T, keys?: string[]) => boolean;
+export interface DeepEqualOptions {
+    /**
+     * When `true`, arrays are compared as unordered sets: two arrays are equal
+     * if every element in the first has a deeply-equal counterpart in the second,
+     * regardless of position.
+     *
+     * The option propagates recursively, so nested arrays are also compared
+     * without order.
+     *
+     * @example
+     * deepEqual([1,2,3], [3,1,2])                        // false  (default)
+     * deepEqual([1,2,3], [3,1,2], { unordered: true })   // true
+     * deepEqual(
+     *   [{ id: 1 }, { id: 2 }],
+     *   [{ id: 2 }, { id: 1 }],
+     *   { unordered: true }
+     * ) // true
+     */
+    unordered?: boolean;
+}
+/**
+ * Structural deep equality check.
+ *
+ * Handles: primitives, null/undefined, Date, RegExp, Array, Map, Set, and
+ * plain objects. Recurses into nested structures.
+ *
+ * @param obj1 - First value
+ * @param obj2 - Second value
+ * @param options - Comparison options (see {@link DeepEqualOptions})
+ *
+ * @example
+ * deepEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } })  // true
+ * deepEqual([1, 2, 3], [3, 2, 1])                            // false
+ * deepEqual([1, 2, 3], [3, 2, 1], { unordered: true })       // true
+ * deepEqual(
+ *   [{ id: 2 }, { id: 1 }],
+ *   [{ id: 1 }, { id: 2 }],
+ *   { unordered: true }
+ * ) // true
+ */
+export declare const deepEqual: (obj1: any, obj2: any, options?: DeepEqualOptions) => boolean;
+/**
+ * Checks if two values are equal
+ * @param a - The first value to compare
+ * @param b - The second value to compare
+ * @returns True if values are equal
+ * @example
+ * isEqual(1, 1) // true
+ * isEqual(1, '1') // false
+ * isEqual(null, undefined) // false
+ */
+export declare function isEqual<T>(a: T, b: T): boolean;
+//# sourceMappingURL=comparators.d.ts.map

package/dist/lib/compare/comparators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparators.d.ts","sourceRoot":"","sources":["../../../src/lib/compare/comparators.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,SAAS,GAAI,MAAM,GAAG,YAwBlC,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,MAAM,GAAG,GAAG,EAChD,UAAU,CAAC,EACX,UAAU,CAAC,EACX,OAAO,MAAM,EAAE,KACd,OA6BF,CAAC;AAIF,MAAM,WAAW,gBAAgB;IAC/B;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AA8BD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,SAAS,GACpB,MAAM,GAAG,EACT,MAAM,GAAG,EACT,UAAS,gBAAqB,KAC7B,OAmFF,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAE9C"}

package/dist/lib/compare/comparators.js

@@ -0,0 +1,210 @@
+import { isPrimitive, isUndefinedOrNull } from '../helpers.js';
+import { isObject } from '@fluixi/utils/object';
+export const hasLength = (data) => {
+    const type = typeof data;
+    let hasValue = false;
+    if (isUndefinedOrNull(data)) {
+        return false;
+    }
+    switch (type) {
+        case 'string':
+            hasValue = data.length > 0;
+            break;
+        case 'number':
+            hasValue = true;
+            break;
+        case 'object':
+            if (Array.isArray(data)) {
+                hasValue = data.length > 0;
+            }
+            else {
+                hasValue = Object.keys(data).length > 0;
+            }
+            break;
+        case 'boolean':
+            hasValue = data;
+    }
+    return hasValue;
+};
+/**
+ * The isEqual function compares two objects and returns true if they are equal.
+ *
+ * @param compare1: T Define the type of object that will be passed into the function
+ * @param compare2: T Compare the two objects
+ *
+ * @return A boolean value
+ *
+ * @docauthor Ibrahima Touré
+ */
+export const isDeepEqual = (compare1, compare2, keys) => {
+    if (compare1 === undefined || compare2 === undefined)
+        return false;
+    if (compare1 === null || compare2 === null)
+        return compare1 === compare2;
+    if (Array.isArray(compare1) && Array.isArray(compare2)) {
+        if (compare1.length !== compare2.length)
+            return false;
+        return compare1.every((v, i) => isDeepEqual(v, compare2[i]));
+    }
+    if (keys && keys.length > 0) {
+        if (isPrimitive(compare1) && isPrimitive(compare2))
+            return compare1 === compare2;
+        if (isObject(compare1) && isObject(compare2))
+            return keys.every((k) => isDeepEqual(compare1[k], compare2[k]));
+        return false;
+    }
+    if (isObject(compare1) && isObject(compare2)) {
+        const obj1Keys = Object.keys(compare1).sort();
+        const obj2Keys = Object.keys(compare2).sort();
+        if (obj1Keys.length !== obj2Keys.length)
+            return false;
+        // Fixed: use recursive isDeepEqual instead of === for nested values
+        return obj1Keys.every((key) => isDeepEqual(compare1[key], compare2[key]));
+    }
+    return compare1 === compare2;
+};
+// ─── Internal helpers ─────────────────────────────────────────────────────────
+/**
+ * O(n²) unordered array equality.
+ * Finds a unique match in `b` for every element in `a`.
+ */
+function unorderedArrayEqual(a, b, opts) {
+    // Each b-slot can only be consumed once
+    const used = new Uint8Array(b.length);
+    outer: for (let i = 0; i < a.length; i++) {
+        for (let j = 0; j < b.length; j++) {
+            if (!used[j] && deepEqual(a[i], b[j], opts)) {
+                used[j] = 1;
+                continue outer;
+            }
+        }
+        return false; // no match for a[i]
+    }
+    return true;
+}
+// ─── deepEqual ────────────────────────────────────────────────────────────────
+/**
+ * Structural deep equality check.
+ *
+ * Handles: primitives, null/undefined, Date, RegExp, Array, Map, Set, and
+ * plain objects. Recurses into nested structures.
+ *
+ * @param obj1 - First value
+ * @param obj2 - Second value
+ * @param options - Comparison options (see {@link DeepEqualOptions})
+ *
+ * @example
+ * deepEqual({ a: 1, b: { c: 2 } }, { a: 1, b: { c: 2 } })  // true
+ * deepEqual([1, 2, 3], [3, 2, 1])                            // false
+ * deepEqual([1, 2, 3], [3, 2, 1], { unordered: true })       // true
+ * deepEqual(
+ *   [{ id: 2 }, { id: 1 }],
+ *   [{ id: 1 }, { id: 2 }],
+ *   { unordered: true }
+ * ) // true
+ */
+export const deepEqual = (obj1, obj2, options = {}) => {
+    // Fast path: same reference, same primitive, or both null/undefined
+    if (obj1 === obj2)
+        return true;
+    // One side is null/undefined but not the other (=== already handled above)
+    if (obj1 == null || obj2 == null)
+        return false;
+    // Type mismatch
+    if (typeof obj1 !== typeof obj2)
+        return false;
+    // ── Arrays ──────────────────────────────────────────────────────────────
+    const isArr1 = Array.isArray(obj1);
+    const isArr2 = Array.isArray(obj2);
+    if (isArr1 !== isArr2)
+        return false;
+    if (isArr1 && isArr2) {
+        if (obj1.length !== obj2.length)
+            return false;
+        return options.unordered
+            ? unorderedArrayEqual(obj1, obj2, options)
+            : obj1.every((item, i) => deepEqual(item, obj2[i], options));
+    }
+    // ── Primitive (non-object) types ─────────────────────────────────────────
+    if (typeof obj1 !== 'object')
+        return obj1 === obj2;
+    // ── Date ─────────────────────────────────────────────────────────────────
+    const isDate1 = obj1 instanceof Date;
+    const isDate2 = obj2 instanceof Date;
+    if (isDate1 !== isDate2)
+        return false;
+    if (isDate1)
+        return obj1.getTime() === obj2.getTime();
+    // ── RegExp ───────────────────────────────────────────────────────────────
+    const isRE1 = obj1 instanceof RegExp;
+    const isRE2 = obj2 instanceof RegExp;
+    if (isRE1 !== isRE2)
+        return false;
+    if (isRE1)
+        return obj1.toString() === obj2.toString();
+    // ── Map ──────────────────────────────────────────────────────────────────
+    const isMap1 = obj1 instanceof Map;
+    const isMap2 = obj2 instanceof Map;
+    if (isMap1 !== isMap2)
+        return false;
+    if (isMap1) {
+        if (obj1.size !== obj2.size)
+            return false;
+        for (const [k, v] of obj1) {
+            if (!obj2.has(k))
+                return false;
+            if (!deepEqual(v, obj2.get(k), options))
+                return false;
+        }
+        return true;
+    }
+    // ── Set ──────────────────────────────────────────────────────────────────
+    const isSet1 = obj1 instanceof Set;
+    const isSet2 = obj2 instanceof Set;
+    if (isSet1 !== isSet2)
+        return false;
+    if (isSet1) {
+        if (obj1.size !== obj2.size)
+            return false;
+        // Sets are inherently unordered; use the unordered algorithm for deep items
+        const bArr = [...obj2];
+        const used = new Uint8Array(bArr.length);
+        outer: for (const v of obj1) {
+            for (let j = 0; j < bArr.length; j++) {
+                if (!used[j] && deepEqual(v, bArr[j], options)) {
+                    used[j] = 1;
+                    continue outer;
+                }
+            }
+            return false;
+        }
+        return true;
+    }
+    // ── Plain objects ─────────────────────────────────────────────────────────
+    if (!isObject(obj1) || !isObject(obj2))
+        return false;
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length)
+        return false;
+    for (const key of keys1) {
+        if (!Object.prototype.hasOwnProperty.call(obj2, key))
+            return false;
+        if (!deepEqual(obj1[key], obj2[key], options))
+            return false;
+    }
+    return true;
+};
+/**
+ * Checks if two values are equal
+ * @param a - The first value to compare
+ * @param b - The second value to compare
+ * @returns True if values are equal
+ * @example
+ * isEqual(1, 1) // true
+ * isEqual(1, '1') // false
+ * isEqual(null, undefined) // false
+ */
+export function isEqual(a, b) {
+    return Object.is(a, b);
+}

package/dist/lib/compare/comparators.mjs

@@ -0,0 +1,150 @@
+// src/lib/helpers.ts
+import {
+  isDate
+} from "@fluixi/utils/primitive";
+import { isClass, isObject } from "@fluixi/utils/object";
+import { isArray } from "@fluixi/utils/array";
+import { isFunction } from "@fluixi/utils/functions";
+var isUndefinedOrNull = (element) => {
+  if (typeof element === "undefined" || element === null) return true;
+  return false;
+};
+function isPrimitive(v) {
+  const type = typeof v;
+  return v === null || type === "string" || type === "number" || type === "boolean" || type === "symbol" || type === "bigint" || type === "undefined" || isDate(v);
+}
+
+// src/lib/compare/comparators.ts
+import { isObject as isObject2 } from "@fluixi/utils/object";
+var hasLength = (data) => {
+  const type = typeof data;
+  let hasValue = false;
+  if (isUndefinedOrNull(data)) {
+    return false;
+  }
+  switch (type) {
+    case "string":
+      hasValue = data.length > 0;
+      break;
+    case "number":
+      hasValue = true;
+      break;
+    case "object":
+      if (Array.isArray(data)) {
+        hasValue = data.length > 0;
+      } else {
+        hasValue = Object.keys(data).length > 0;
+      }
+      break;
+    case "boolean":
+      hasValue = data;
+  }
+  return hasValue;
+};
+var isDeepEqual = (compare1, compare2, keys) => {
+  if (compare1 === void 0 || compare2 === void 0) return false;
+  if (compare1 === null || compare2 === null) return compare1 === compare2;
+  if (Array.isArray(compare1) && Array.isArray(compare2)) {
+    if (compare1.length !== compare2.length) return false;
+    return compare1.every((v, i) => isDeepEqual(v, compare2[i]));
+  }
+  if (keys && keys.length > 0) {
+    if (isPrimitive(compare1) && isPrimitive(compare2))
+      return compare1 === compare2;
+    if (isObject2(compare1) && isObject2(compare2))
+      return keys.every(
+        (k) => isDeepEqual(compare1[k], compare2[k])
+      );
+    return false;
+  }
+  if (isObject2(compare1) && isObject2(compare2)) {
+    const obj1Keys = Object.keys(compare1).sort();
+    const obj2Keys = Object.keys(compare2).sort();
+    if (obj1Keys.length !== obj2Keys.length) return false;
+    return obj1Keys.every(
+      (key) => isDeepEqual(compare1[key], compare2[key])
+    );
+  }
+  return compare1 === compare2;
+};
+function unorderedArrayEqual(a, b, opts) {
+  const used = new Uint8Array(b.length);
+  outer: for (let i = 0; i < a.length; i++) {
+    for (let j = 0; j < b.length; j++) {
+      if (!used[j] && deepEqual(a[i], b[j], opts)) {
+        used[j] = 1;
+        continue outer;
+      }
+    }
+    return false;
+  }
+  return true;
+}
+var deepEqual = (obj1, obj2, options = {}) => {
+  if (obj1 === obj2) return true;
+  if (obj1 == null || obj2 == null) return false;
+  if (typeof obj1 !== typeof obj2) return false;
+  const isArr1 = Array.isArray(obj1);
+  const isArr2 = Array.isArray(obj2);
+  if (isArr1 !== isArr2) return false;
+  if (isArr1 && isArr2) {
+    if (obj1.length !== obj2.length) return false;
+    return options.unordered ? unorderedArrayEqual(obj1, obj2, options) : obj1.every((item, i) => deepEqual(item, obj2[i], options));
+  }
+  if (typeof obj1 !== "object") return obj1 === obj2;
+  const isDate1 = obj1 instanceof Date;
+  const isDate2 = obj2 instanceof Date;
+  if (isDate1 !== isDate2) return false;
+  if (isDate1) return obj1.getTime() === obj2.getTime();
+  const isRE1 = obj1 instanceof RegExp;
+  const isRE2 = obj2 instanceof RegExp;
+  if (isRE1 !== isRE2) return false;
+  if (isRE1) return obj1.toString() === obj2.toString();
+  const isMap1 = obj1 instanceof Map;
+  const isMap2 = obj2 instanceof Map;
+  if (isMap1 !== isMap2) return false;
+  if (isMap1) {
+    if (obj1.size !== obj2.size) return false;
+    for (const [k, v] of obj1) {
+      if (!obj2.has(k)) return false;
+      if (!deepEqual(v, obj2.get(k), options)) return false;
+    }
+    return true;
+  }
+  const isSet1 = obj1 instanceof Set;
+  const isSet2 = obj2 instanceof Set;
+  if (isSet1 !== isSet2) return false;
+  if (isSet1) {
+    if (obj1.size !== obj2.size) return false;
+    const bArr = [...obj2];
+    const used = new Uint8Array(bArr.length);
+    outer: for (const v of obj1) {
+      for (let j = 0; j < bArr.length; j++) {
+        if (!used[j] && deepEqual(v, bArr[j], options)) {
+          used[j] = 1;
+          continue outer;
+        }
+      }
+      return false;
+    }
+    return true;
+  }
+  if (!isObject2(obj1) || !isObject2(obj2)) return false;
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) return false;
+  for (const key of keys1) {
+    if (!Object.prototype.hasOwnProperty.call(obj2, key)) return false;
+    if (!deepEqual(obj1[key], obj2[key], options)) return false;
+  }
+  return true;
+};
+function isEqual(a, b) {
+  return Object.is(a, b);
+}
+export {
+  deepEqual,
+  hasLength,
+  isDeepEqual,
+  isEqual
+};