@cleverbrush/deep 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/deepEqual.d.ts

@@ -0,0 +1,2 @@
+declare const deepEqual: (p1: any, p2: any) => boolean;
+export default deepEqual;

package/dist/deepEqual.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isBothNaN = function (v1, v2) {
+    return Number.isNaN(v1) && Number.isNaN(v2);
+};
+const deepEqual = function (p1, p2) {
+    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);
+};
+exports.default = deepEqual;

package/dist/deepExtend.d.ts

@@ -0,0 +1,10 @@
+export declare 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> & {
+    [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;
+declare const deepExtend: <T extends unknown[]>(...args: T) => Merge<T>;
+export default deepExtend;

package/dist/deepExtend.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const deepExtend = 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;
+};
+exports.default = deepExtend;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,14 @@
+"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
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cleverbrush/deep",
-    "version": "1.0.0-beta.2",
+    "version": "1.0.0-beta.4",
     "keywords": [
         "deep operations on objects",
         "deep equal",
@@ -8,6 +8,10 @@
     ],
     "author": "Andrew Zolotukhin <andrew_zol@cleverbrush.com>",
     "license": "BSD",
+    "files": [
+        "*",
+        "dist/*"
+    ],
     "main": "./dist/index.js",
     "readme": "https://github.com/cleverbrush/libs/tree/master/libs/deep#readme",
     "scripts": {