@cleverbrush/deep 0.0.1

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,62 @@
+"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);
+            let keys1 = Object.keys(o1);
+            let 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;
+                }
+                let v1 = o1[keys1[i]];
+                let 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,2 @@
+declare const deepExtend: (...args: any) => any;
+export default deepExtend;

package/dist/deepExtend.js

@@ -0,0 +1,38 @@
+"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,3 @@
+import deepEqual from './deepEqual';
+import deepExtend from './deepExtend';
+export { deepEqual, deepExtend };

package/dist/index.js

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

package/package.json

@@ -0,0 +1,22 @@
+{
+    "name": "@cleverbrush/deep",
+    "version": "0.0.1",
+    "type": "module",
+    "keywords": [
+        "deep operations on objects",
+        "deep equal",
+        "deep extend"
+    ],
+    "author": "Andrew Zolotukhin <andrew_zol@cleverbrush.com>",
+    "license": "BSD",
+    "main": "./dist/index.js",
+    "scripts": {
+        "watch": "tsc --watch",
+        "build": "tsc"
+    },
+    "repository": {
+        "type": "git",
+        "url": "github:cleverbrush/libs"
+    },
+    "types": "./dist/index.d.ts"
+}

package/src/deepEqual.ts

@@ -0,0 +1,67 @@
+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);
+
+            let keys1 = Object.keys(o1);
+            let 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;
+                }
+
+                let v1 = o1[keys1[i]];
+                let 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

@@ -0,0 +1,41 @@
+const deepExtend: (...args: any) => any = 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

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

package/tsconfig.json

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