@cleverbrush/deep 1.0.0-beta.6 → 1.1.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,4 +1,18 @@
+/**
+ * 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,9 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const hashObject_js_1 = require("./hashObject.js");
+import { HashObject } from './hashObject.js';
 const isBothNaN = function (v1, v2) {
     return Number.isNaN(v1) && Number.isNaN(v2);
 };
+/**
+ * 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) {
@@ -16,8 +24,8 @@ const deepEqual = function (p1, p2, options) {
                 ? a1
                     .map((t) => t)
                     .sort((l, r) => {
-                    const hash1 = (0, hashObject_js_1.HashObject)(l);
-                    const hash2 = (0, hashObject_js_1.HashObject)(r);
+                    const hash1 = HashObject(l);
+                    const hash2 = HashObject(r);
                     return hash1 < hash2 ? 1 : -1;
                 })
                 : a1.map((t) => t);
@@ -25,8 +33,8 @@ const deepEqual = function (p1, p2, options) {
                 ? a2
                     .map((t) => t)
                     .sort((l, r) => {
-                    const hash1 = (0, hashObject_js_1.HashObject)(l);
-                    const hash2 = (0, hashObject_js_1.HashObject)(r);
+                    const hash1 = HashObject(l);
+                    const hash2 = HashObject(r);
                     return hash1 < hash2 ? 1 : -1;
                 })
                 : a2.map((t) => t);
@@ -82,4 +90,4 @@ const deepEqual = function (p1, p2, options) {
     };
     return compare(p1, p2);
 };
-exports.default = deepEqual;
+export default deepEqual;

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

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashObject = void 0;
 const stringHash = (string, noType) => {
     let hashString = string;
     if (!noType) {
@@ -29,7 +26,7 @@ function objectHash(obj, exclude) {
     }
     return stringHash(hash, true);
 }
-function HashObject(unkType, exclude) {
+export function HashObject(unkType, exclude) {
     let ex = exclude;
     if (ex === undefined) {
         ex = [];
@@ -44,5 +41,4 @@ function HashObject(unkType, exclude) {
             return stringHash(String(unkType));
     }
 }
-exports.HashObject = HashObject;
 const hashFunc = HashObject;

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.6",
+    "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.1.0"
 }

package/src/deepEqual.test.ts

@@ -1,69 +0,0 @@
-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,98 +0,0 @@
-import { HashObject } from './hashObject.js';
-
-const isBothNaN = function (v1, v2) {
-    return Number.isNaN(v1) && Number.isNaN(v2);
-};
-
-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;
-            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;
-            }
-            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);
-
-            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;
-
-            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/hashObject.ts

@@ -1,47 +0,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);
-}
-
-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/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"]
-    }
-}