@cleverbrush/deep 1.0.0-beta.5 → 1.0.0-beta.6

package/dist/deepEqual.d.ts

@@ -1,2 +1,4 @@
-declare const deepEqual: (p1: any, p2: any) => boolean;
+declare const deepEqual: (p1: any, p2: any, options?: {
+    disregardArrayOrder?: boolean;
+}) => boolean;
 export default deepEqual;

package/dist/deepEqual.js

@@ -1,18 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const hashObject_js_1 = require("./hashObject.js");
 const isBothNaN = function (v1, v2) {
     return Number.isNaN(v1) && Number.isNaN(v2);
 };
-const deepEqual = function (p1, p2) {
-    if (arguments.length !== 2)
-        return false;
+const deepEqual = function (p1, p2, options) {
     const cache = new Map();
     const compare = function (o1, o2) {
         const arraysAreIdentical = function (a1, a2) {
             if (a1.length !== a2.length)
                 return false;
-            const c1 = a1.map((t) => t).sort();
-            const c2 = a2.map((t) => t).sort();
+            if (a1.length === 0 && a2.length === 0)
+                return true;
+            const c1 = options?.disregardArrayOrder
+                ? a1
+                    .map((t) => t)
+                    .sort((l, r) => {
+                    const hash1 = (0, hashObject_js_1.HashObject)(l);
+                    const hash2 = (0, hashObject_js_1.HashObject)(r);
+                    return hash1 < hash2 ? 1 : -1;
+                })
+                : a1.map((t) => t);
+            const c2 = options?.disregardArrayOrder
+                ? a2
+                    .map((t) => t)
+                    .sort((l, r) => {
+                    const hash1 = (0, hashObject_js_1.HashObject)(l);
+                    const hash2 = (0, hashObject_js_1.HashObject)(r);
+                    return hash1 < hash2 ? 1 : -1;
+                })
+                : a2.map((t) => t);
             for (let i = 0; i < c1.length; i++) {
                 if (!compare(c1[i], c2[i]))
                     return false;
@@ -39,6 +56,11 @@ const deepEqual = function (p1, p2) {
                 return false;
             }
             cache.set(o1, true);
+            if (o1 instanceof Date && o2 instanceof Date) {
+                return (!isNaN(o1) &&
+                    !isNaN(o2) &&
+                    o1.getTime() === o2.getTime());
+            }
             const keys1 = Object.keys(o1);
             const keys2 = Object.keys(o2);
             if (keys1.length != keys2.length)

package/dist/deepExtend.d.ts

@@ -1,10 +1,10 @@
-export declare type CommonProps<T1, T2> = {
+export type CommonProps<T1, T2> = {
     [k in keyof T1 & keyof T2]: T1[k] extends never ? never : T2[k] extends never ? never : T2[k];
 };
-export declare type PropsInFirstOnly<T1, T2> = Omit<T1, keyof T2>;
-export declare type MergeTwo<T1, T2> = PropsInFirstOnly<T1, T2> & PropsInFirstOnly<T2, T1> & {
+export type PropsInFirstOnly<T1, T2> = Omit<T1, keyof T2>;
+export type MergeTwo<T1, T2> = PropsInFirstOnly<T1, T2> & PropsInFirstOnly<T2, T1> & {
     [k in keyof CommonProps<T1, T2>]: T1[k] extends Record<string, unknown> ? T2[k] extends Record<string, unknown> ? MergeTwo<T1[k], T2[k]> : T2[k] : T2[k];
 };
-export declare type Merge<T extends unknown[]> = T['length'] extends 3 ? MergeTwo<T[0], MergeTwo<T[1], T[2]>> : T['length'] extends 2 ? MergeTwo<T[0], T[1]> : T['length'] extends 1 ? T[0] : T extends [...infer K, infer PL, infer L] ? Merge<[Merge<[...K]>, MergeTwo<PL, L>]> : never;
+export type Merge<T extends unknown[]> = T['length'] extends 3 ? MergeTwo<T[0], MergeTwo<T[1], T[2]>> : T['length'] extends 2 ? MergeTwo<T[0], T[1]> : T['length'] extends 1 ? T[0] : T extends [...infer K, infer PL, infer L] ? Merge<[Merge<[...K]>, MergeTwo<PL, L>]> : never;
 declare const deepExtend: <T extends unknown[]>(...args: T) => Merge<T>;
 export default deepExtend;

package/dist/hashObject.d.ts

@@ -0,0 +1 @@
+export declare function HashObject(unkType: any, exclude?: any): any;

package/dist/hashObject.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashObject = void 0;
+const stringHash = (string, noType) => {
+    let hashString = string;
+    if (!noType) {
+        hashString = `string${string}`;
+    }
+    let hash = 0;
+    for (let i = 0; i < hashString.length; i++) {
+        const character = hashString.charCodeAt(i);
+        hash = (hash << 5) - hash + character;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return hash;
+};
+function objectHash(obj, exclude) {
+    if (exclude.indexOf(obj) > -1) {
+        return undefined;
+    }
+    let hash = '';
+    const keys = Object.keys(obj).sort();
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        const keyHash = hashFunc(key);
+        const attrHash = hashFunc(obj[key], exclude);
+        exclude.push(obj[key]);
+        hash += stringHash(`object${keyHash}${attrHash}`, true);
+    }
+    return stringHash(hash, true);
+}
+function HashObject(unkType, exclude) {
+    let ex = exclude;
+    if (ex === undefined) {
+        ex = [];
+    }
+    if (!isNaN(unkType) && typeof unkType !== 'string') {
+        return unkType;
+    }
+    switch (typeof unkType) {
+        case 'object':
+            return objectHash(unkType, ex);
+        default:
+            return stringHash(String(unkType));
+    }
+}
+exports.HashObject = HashObject;
+const hashFunc = HashObject;

package/dist/index.d.ts

@@ -2,7 +2,9 @@ import deepEqual from './deepEqual';
 import deepExtend, { Merge } from './deepExtend';
 export { deepEqual, deepExtend, Merge };
 declare const _default: {
-    deepEqual: (p1: any, p2: any) => boolean;
+    deepEqual: (p1: any, p2: any, options?: {
+        disregardArrayOrder?: boolean;
+    }) => boolean;
     deepExtend: <T extends unknown[]>(...args: T) => Merge<T>;
 };
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cleverbrush/deep",
-    "version": "1.0.0-beta.5",
+    "version": "1.0.0-beta.6",
     "keywords": [
         "deep operations on objects",
         "deep equal",

package/src/deepEqual.test.ts

@@ -0,0 +1,69 @@
+import deepEqual from './deepEqual.js';
+
+test('deepEqual - 1', () => {
+    expect(deepEqual('a', 'a')).toEqual(true);
+});
+
+test('deepEqual - 2', () => {
+    expect(deepEqual('a', 'b')).toEqual(false);
+});
+
+test('deepEqual - 3', () => {
+    expect(deepEqual({}, 'a')).toEqual(false);
+});
+
+test('deepEqual - 4', () => {
+    expect(deepEqual({ a: 10 }, { a: 10 })).toEqual(true);
+});
+
+test('deepEqual - 5', () => {
+    expect(deepEqual([], [])).toEqual(true);
+});
+
+test('deepEqual - 6', () => {
+    expect(deepEqual([10], [])).toEqual(false);
+});
+
+test('deepEqual - 7', () => {
+    expect(deepEqual([10], [10])).toEqual(true);
+});
+
+test('deepEqual - 8', () => {
+    expect(deepEqual([10], [10, { b: 20 }])).toEqual(false);
+});
+
+test('deepEqual - 9', () => {
+    expect(deepEqual([{ b: 20 }, 10], [10, { b: 20 }])).toEqual(false);
+});
+
+test('deepEqual - 10', () => {
+    expect(
+        deepEqual([{ b: 20 }, 10], [10, { b: 20 }], {
+            disregardArrayOrder: true
+        })
+    ).toEqual(true);
+});
+
+test('deepEqual - 11', () => {
+    expect(
+        deepEqual(
+            [{ b: 20, c: { d: 'a', e: new Date(2022, 10, 1) } }, 10],
+            [10, { b: 20 }],
+            {
+                disregardArrayOrder: true
+            }
+        )
+    ).toEqual(false);
+});
+
+test('deepEqual - 12', () => {
+    expect(
+        deepEqual(
+            [{ b: 20, c: { d: 'a', e: new Date(2022, 10, 1) } }, 10],
+            [10, { b: 20, c: { e: new Date(2022, 10, 1), d: 'a' } }],
+            {
+                disregardArrayOrder: true
+            }
+        )
+    ).toEqual(true);
+});

package/src/deepEqual.ts

@@ -1,16 +1,39 @@
+import { HashObject } from './hashObject.js';
+
 const isBothNaN = function (v1, v2) {
     return Number.isNaN(v1) && Number.isNaN(v2);
 };
 
-const deepEqual = function (p1, p2): boolean {
-    if (arguments.length !== 2) return false;
+const deepEqual = function (
+    p1,
+    p2,
+    options?: { disregardArrayOrder?: boolean }
+): boolean {
     const cache = new Map();
 
     const compare = function (o1, o2) {
         const arraysAreIdentical = function (a1, a2) {
             if (a1.length !== a2.length) return false;
-            const c1 = a1.map((t) => t).sort();
-            const c2 = a2.map((t) => t).sort();
+            if (a1.length === 0 && a2.length === 0) return true;
+
+            const c1 = options?.disregardArrayOrder
+                ? a1
+                      .map((t) => t)
+                      .sort((l, r) => {
+                          const hash1 = HashObject(l);
+                          const hash2 = HashObject(r);
+                          return hash1 < hash2 ? 1 : -1;
+                      })
+                : a1.map((t) => t);
+            const c2 = options?.disregardArrayOrder
+                ? a2
+                      .map((t) => t)
+                      .sort((l, r) => {
+                          const hash1 = HashObject(l);
+                          const hash2 = HashObject(r);
+                          return hash1 < hash2 ? 1 : -1;
+                      })
+                : a2.map((t) => t);
 
             for (let i = 0; i < c1.length; i++) {
                 if (!compare(c1[i], c2[i])) return false;
@@ -40,6 +63,14 @@ const deepEqual = function (p1, p2): boolean {
 
             cache.set(o1, true);
 
+            if (o1 instanceof Date && o2 instanceof Date) {
+                return (
+                    !isNaN(o1 as any) &&
+                    !isNaN(o2 as any) &&
+                    o1.getTime() === o2.getTime()
+                );
+            }
+
             const keys1 = Object.keys(o1);
             const keys2 = Object.keys(o2);
             if (keys1.length != keys2.length) return false;

package/src/hashObject.ts

@@ -0,0 +1,47 @@
+const stringHash = (string, noType?) => {
+    let hashString = string;
+    if (!noType) {
+        hashString = `string${string}`;
+    }
+    let hash = 0;
+    for (let i = 0; i < hashString.length; i++) {
+        const character = hashString.charCodeAt(i);
+        hash = (hash << 5) - hash + character;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return hash;
+};
+
+function objectHash(obj, exclude) {
+    if (exclude.indexOf(obj) > -1) {
+        return undefined;
+    }
+    let hash = '';
+    const keys = Object.keys(obj).sort();
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        const keyHash = hashFunc(key);
+        const attrHash = hashFunc(obj[key], exclude);
+        exclude.push(obj[key]);
+        hash += stringHash(`object${keyHash}${attrHash}`, true);
+    }
+    return stringHash(hash, true);
+}
+
+export function HashObject(unkType, exclude?) {
+    let ex = exclude;
+    if (ex === undefined) {
+        ex = [];
+    }
+    if (!isNaN(unkType) && typeof unkType !== 'string') {
+        return unkType;
+    }
+    switch (typeof unkType) {
+        case 'object':
+            return objectHash(unkType, ex);
+        default:
+            return stringHash(String(unkType));
+    }
+}
+
+const hashFunc = HashObject;