@cleverbrush/deep 1.0.0-beta.5 → 1.0.0

package/README.md

@@ -8,10 +8,6 @@ This is yet another library which provides operations over JavaScript objects, l
 
 ## Usage
 
-    const deep = require('@cleverbrush/deep');
-
-or for ES Module
-
     import deep from '@cleverbrush/deep';
     // or import functions individually
     import { deepEqual, deepExtend } from '@cleverbrush/deep';

package/dist/deepEqual.d.ts

@@ -1,2 +1,18 @@
-declare const deepEqual: (p1: any, p2: any) => boolean;
+/**
+ * Compares two objects and returns true if they
+ * have the same structure and values. Can work
+ * with arrays and objects, nested objects,
+ * recursive objects, dates, etc.
+ * @param p1 first object
+ * @param p2 second object
+ * @param options additional options
+ * @returns {boolean} `true` if the objects are equal, `false` otherwise
+ */
+declare const deepEqual: (p1: any, p2: any, options?: {
+    /**
+     * if true, the order of the elements in the array will be disregarded
+     * e.g. [1, 2] and [2, 1] will be considered equal
+     */
+    disregardArrayOrder?: boolean;
+}) => boolean;
 export default deepEqual;

package/dist/deepEqual.js

@@ -1,18 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+import { HashObject } from './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;
+/**
+ * Compares two objects and returns true if they
+ * have the same structure and values. Can work
+ * with arrays and objects, nested objects,
+ * recursive objects, dates, etc.
+ * @param p1 first object
+ * @param p2 second object
+ * @param options additional options
+ * @returns {boolean} `true` if the objects are equal, `false` otherwise
+ */
+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 = 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;
@@ -39,6 +64,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)
@@ -60,4 +90,4 @@ const deepEqual = function (p1, p2) {
     };
     return compare(p1, p2);
 };
-exports.default = deepEqual;
+export default deepEqual;

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/deepExtend.js

@@ -1,5 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 const deepExtend = function () {
     if (arguments.length === 0)
         return false;
@@ -37,4 +35,4 @@ const deepExtend = function () {
     }
     return result;
 };
-exports.default = deepExtend;
+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,44 @@
+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;

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/dist/index.js

@@ -1,14 +1,7 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deepExtend = exports.deepEqual = void 0;
-const deepEqual_1 = __importDefault(require("./deepEqual"));
-exports.deepEqual = deepEqual_1.default;
-const deepExtend_1 = __importDefault(require("./deepExtend"));
-exports.deepExtend = deepExtend_1.default;
-exports.default = {
-    deepEqual: deepEqual_1.default,
-    deepExtend: deepExtend_1.default
+import deepEqual from './deepEqual';
+import deepExtend from './deepExtend';
+export { deepEqual, deepExtend };
+export default {
+    deepEqual,
+    deepExtend
 };

package/package.json

@@ -1,26 +1,39 @@
 {
-    "name": "@cleverbrush/deep",
-    "version": "1.0.0-beta.5",
+    "author": "Andrew Zolotukhin <andrew_zol@cleverbrush.com>",
+    "bugs": {
+        "url": "https://github.com/cleverbrush/framework/issues",
+        "email": "andrew_zol@cleverbrush.com"
+    },
+    "description": "Library for deep operations on objects like deep equal, deep extend, etc.",
+    "files": [
+        "dist/**/*"
+    ],
+    "homepage": "https://docs.cleverbrush.com/v1.0.0/modules/Deep_operations_on_objects.html",
     "keywords": [
         "deep operations on objects",
         "deep equal",
-        "deep extend"
-    ],
-    "author": "Andrew Zolotukhin <andrew_zol@cleverbrush.com>",
-    "license": "BSD",
-    "files": [
-        "*",
-        "dist/*"
+        "deep extend",
+        "cleverbrush"
     ],
+    "license": "BSD 3-Clause",
     "main": "./dist/index.js",
-    "readme": "https://github.com/cleverbrush/libs/tree/master/libs/deep#readme",
+    "name": "@cleverbrush/deep",
+    "readme": "https://github.com/cleverbrush/framework/tree/master/libs/deep#readme",
+    "repository": {
+        "type": "git",
+        "url": "github:cleverbrush/framework"
+    },
     "scripts": {
         "watch": "tsc --watch",
         "build": "tsc"
     },
-    "repository": {
-        "type": "git",
-        "url": "github:cleverbrush/libs"
+    "typedoc": {
+        "entryPoint": "./src/index.ts",
+        "readmeFile": "./README.md",
+        "displayName": "Deep operations on objects",
+        "tsconfig": "./tsconfig.json"
     },
-    "types": "./dist/index.d.ts"
+    "type": "module",
+    "types": "./dist/index.d.ts",
+    "version": "1.0.0"
 }

package/src/deepEqual.ts

@@ -1,67 +0,0 @@
-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 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();
-
-            for (let i = 0; i < c1.length; i++) {
-                if (!compare(c1[i], c2[i])) return false;
-            }
-            return true;
-        };
-
-        if (arguments.length !== 2) return false;
-        if (o1 === o2) return true;
-        if (typeof o1 !== typeof o2) return false;
-        if (isBothNaN(o1, o2)) return true;
-
-        if (
-            (Array.isArray(o1) && !Array.isArray(o2)) ||
-            (!Array.isArray(o1) && Array.isArray(o2))
-        ) {
-            return false;
-        }
-        if (Array.isArray(o1) && Array.isArray(o2)) {
-            return arraysAreIdentical(o1, o2);
-        }
-
-        if (typeof o1 === 'object') {
-            if (cache.get(o1) === true) {
-                return false;
-            }
-
-            cache.set(o1, true);
-
-            const keys1 = Object.keys(o1);
-            const keys2 = Object.keys(o2);
-            if (keys1.length != keys2.length) return false;
-
-            keys1.sort();
-            keys2.sort();
-            for (let i = 0; i < keys1.length; i++) {
-                if (keys1[i] !== keys2[i]) {
-                    return false;
-                }
-
-                const v1 = o1[keys1[i]];
-                const v2 = o2[keys1[i]];
-                if (!compare(v1, v2)) return false;
-            }
-            return true;
-        }
-
-        return false;
-    };
-
-    return compare(p1, p2);
-};
-
-export default deepEqual;

package/src/deepExtend.ts

@@ -1,70 +0,0 @@
-export type CommonProps<T1, T2> = {
-    [k in keyof T1 & keyof T2]: T1[k] extends never
-        ? never
-        : T2[k] extends never
-        ? never
-        : T2[k];
-};
-
-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 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;
-
-const deepExtend: <T extends unknown[]>(...args: T) => Merge<T> = function () {
-    if (arguments.length === 0) return false;
-    if (arguments.length === 1) return arguments[0];
-    if (typeof arguments[0] !== 'object') return false;
-
-    const result = {};
-
-    const extendObject = function (o1, o2) {
-        if (o2 == null) return;
-        const keys = Object.keys(o2);
-
-        for (let i = 0; i < keys.length; i++) {
-            if (o2.hasOwnProperty(keys[i])) {
-                if (
-                    !o1.hasOwnProperty(keys[i]) ||
-                    !(
-                        typeof o1[keys[i]] === 'object' &&
-                        typeof o2[keys[i]] === 'object'
-                    )
-                ) {
-                    o1[keys[i]] = o2[keys[i]];
-                } else {
-                    if (o1[keys[i]] == null) {
-                        o1[keys[i]] = o2[keys[i]];
-                    } else {
-                        extendObject(o1[keys[i]], o2[keys[i]]);
-                    }
-                }
-            }
-        }
-    };
-
-    for (let i = 0; i < arguments.length; i++) {
-        if (typeof arguments[i] === 'object' && arguments[i]) {
-            extendObject(result, arguments[i]);
-        }
-    }
-
-    return result;
-};
-export default deepExtend;

package/src/index.ts

@@ -1,9 +0,0 @@
-import deepEqual from './deepEqual';
-import deepExtend, { Merge } from './deepExtend';
-
-export { deepEqual, deepExtend, Merge };
-
-export default {
-    deepEqual,
-    deepExtend
-};

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-    "compilerOptions": {
-        "rootDir": "./src",
-        "outDir": "./dist",
-        "declaration": true,
-        "target": "esnext",
-        "module": "CommonJS",
-        "esModuleInterop": true,
-        "moduleResolution": "Node",
-        "allowSyntheticDefaultImports": true
-    },
-    "files": ["./src/index.ts"],
-    "watchOptions": {
-        "excludeDirectories": ["./dist"]
-    }
-}