@cleverbrush/deep 1.1.0 → 1.1.1

package/README.md

@@ -8,9 +8,11 @@ This is yet another library which provides operations over JavaScript objects, l
 
 ## Usage
 
-    import deep from '@cleverbrush/deep';
-    // or import functions individually
-    import { deepEqual, deepExtend } from '@cleverbrush/deep';
+```typescript
+import deep from '@cleverbrush/deep';
+// or import functions individually
+import { deepEqual, deepExtend } from '@cleverbrush/deep';
+```
 
 ## Functions
 
@@ -18,36 +20,45 @@ This is yet another library which provides operations over JavaScript objects, l
 
 Takes two objects as parameters, compares it recursively and returns `true` if they are equal or `false` in other case.
 
-    import { deepEqual } from '@cleverbrush/deep';
+```typescript
+import { deepEqual } from '@cleverbrush/deep';
 
-    const equal1 = deepEqual({ a: {b : 1} }, { a: {b: 1} });
-    // equal1 === true
+const equal1 = deepEqual({ a: { b: 1 } }, { a: { b: 1 } });
+// equal1 === true
 
-    const equal2 = deepEqual({ a: {b : 1} }, { a: {b: 20} });
-    // equal2 === false
+const equal2 = deepEqual({ a: { b: 1 } }, { a: { b: 20 } });
+// equal2 === false
 
-    const equal3 = deepEqual({ a: {b : 1, c: 2} }, { a: {b: 20} });
-    // equal3 === false
+const equal3 = deepEqual({ a: { b: 1, c: 2 } }, { a: { b: 20 } });
+// equal3 === false
+```
 
 ### deepExtend
 
 Works similary to `Object.extend`, but respects the deep structure of objects.
 
-    import { deepExtend } from '@cleverbrush/deep';
+```typescript
+import { deepExtend } from '@cleverbrush/deep';
 
-    deepExtend({}, {
-            a: 'something,
-            name: {
-                first: 'Ivan'
-            }
-        }, {
-            name: {
-                last: 'Ivanov'
-            }
-        });
+deepExtend(
+    {},
+    {
+        a: 'something',
+        name: {
+            first: 'Ivan'
+        }
+    },
+    {
+        name: {
+            last: 'Ivanov'
+        }
+    }
+);
+```
 
 will return the following object:
 
+```typescript
     {
         a: 'something',
         name: {
@@ -55,3 +66,42 @@ will return the following object:
             last: 'Ivanov'
         }
     }
+```
+
+### deepFlatten
+
+Flattens an object to a single level. Accepts an optional separator as a second parameter.
+If no separator is provided, the default separator is `.`.
+Supports only objects with string keys. Supports nested objects of any depth.
+Throws an error if the object contains circular references.
+
+```typescript
+import { deepFlatten } from '@cleverbrush/deep';
+
+deepFlatten({
+    a: {
+        b: 1,
+        c: 2
+    },
+    d: 3
+});
+
+// => { 'a.b': 1, 'a.c': 2, d: 3 }
+
+deepFlatten(
+    {
+        a: {
+            b: 1,
+            c: 2
+        },
+        d: {
+            e: {
+                f: 3
+            }
+        }
+    },
+    '-'
+);
+
+// => { 'a-b': 1, 'a-c': 2, 'd-e-f': 3 }
+```

package/dist/deepEqual.d.ts

@@ -8,11 +8,10 @@
  * @param options additional options
  * @returns {boolean} `true` if the objects are equal, `false` otherwise
  */
-declare const deepEqual: (p1: any, p2: any, options?: {
+export 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,7 +1,5 @@
 import { HashObject } from './hashObject.js';
-const isBothNaN = function (v1, v2) {
-    return Number.isNaN(v1) && Number.isNaN(v2);
-};
+const isBothNaN = (v1, v2) => Number.isNaN(v1) && Number.isNaN(v2);
 /**
  * Compares two objects and returns true if they
  * have the same structure and values. Can work
@@ -12,7 +10,7 @@ const isBothNaN = function (v1, v2) {
  * @param options additional options
  * @returns {boolean} `true` if the objects are equal, `false` otherwise
  */
-const deepEqual = function (p1, p2, options) {
+export const deepEqual = function (p1, p2, options) {
     const cache = new Map();
     const compare = function (o1, o2) {
         const arraysAreIdentical = function (a1, a2) {
@@ -90,4 +88,3 @@ const deepEqual = function (p1, p2, options) {
     };
     return compare(p1, p2);
 };
-export default deepEqual;

package/dist/deepExtend.d.ts

@@ -6,5 +6,4 @@ export type MergeTwo<T1, T2> = PropsInFirstOnly<T1, T2> & PropsInFirstOnly<T2, T
     [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;
-declare const deepExtend: <T extends unknown[]>(...args: T) => Merge<T>;
-export default deepExtend;
+export declare const deepExtend: <T extends unknown[]>(...args: T) => Merge<T>;

package/dist/deepExtend.js

@@ -1,38 +1,37 @@
-const deepExtend = function () {
-    if (arguments.length === 0)
-        return false;
-    if (arguments.length === 1)
-        return arguments[0];
-    if (typeof arguments[0] !== 'object')
-        return false;
+export const deepExtend = ((...rest) => {
+    if (rest.length === 0)
+        throw new Error('no arguments');
+    if (typeof rest[0] !== 'object' || rest[0] === null)
+        throw new Error('not a non-null object');
+    if (rest.length === 1)
+        return rest[0];
     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')) {
+            if (!Reflect.has(o1, keys[i]) ||
+                !(typeof o1[keys[i]] === 'object' &&
+                    o1[keys[i]] !== null &&
+                    typeof o2[keys[i]] === 'object')) {
+                o1[keys[i]] = o2[keys[i]];
+            }
+            else {
+                if (o1[keys[i]] == null || o2[keys[i]] == null) {
                     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]]);
-                    }
+                    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]);
+    for (let i = 0; i < rest.length; i++) {
+        if (typeof rest[i] === 'object' && rest[i] !== null && rest[i]) {
+            extendObject(result, rest[i]);
+        }
+        else {
+            throw new Error('not a non-null object');
         }
     }
     return result;
-};
-export default deepExtend;
+});

package/dist/deepFlatten.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Flattens an object to a single level, with the nested keys separated by a `delimiter`.
+ * @example
+ * ```ts
+ * deepFlatten({ a: { b: 1, c: 2 } });
+ * // => { 'a.b': 1, 'a.c': 2 }
+ *
+ * deepFlatten({ a: { b: 1, c: 2 } }, '/');
+ * // => { 'a/b': 1, 'a/c': 2 }
+ *
+ * deepFlatten({ a: { b: 1, c: { d: 'some val' } }, d: 3 });
+ * // => { 'a.b': 1, 'a.c.d': 'some val', d: 3 }
+ *
+ * ```
+ * @param {string} [delimiter]
+ */
+export declare function deepFlatten(obj: Record<string, any>, delimiter?: string): Record<string, any>;

package/dist/deepFlatten.js

@@ -0,0 +1,41 @@
+/**
+ * Flattens an object to a single level, with the nested keys separated by a `delimiter`.
+ * @example
+ * ```ts
+ * deepFlatten({ a: { b: 1, c: 2 } });
+ * // => { 'a.b': 1, 'a.c': 2 }
+ *
+ * deepFlatten({ a: { b: 1, c: 2 } }, '/');
+ * // => { 'a/b': 1, 'a/c': 2 }
+ *
+ * deepFlatten({ a: { b: 1, c: { d: 'some val' } }, d: 3 });
+ * // => { 'a.b': 1, 'a.c.d': 'some val', d: 3 }
+ *
+ * ```
+ * @param {string} [delimiter]
+ */
+export function deepFlatten(obj, delimiter = '.') {
+    const shouldFlatten = (obj) => typeof obj === 'object' &&
+        obj !== null &&
+        !Array.isArray(obj) &&
+        Object.getPrototypeOf(obj) === Object.prototype;
+    if (!shouldFlatten(obj))
+        throw new Error('cannot flatten this object');
+    const stack = [];
+    const result = {};
+    const deepFlattenHelper = (obj, prefix = '') => {
+        if (stack.find((o) => o === obj))
+            throw new Error('circular reference detected');
+        stack.push(obj);
+        Object.keys(obj).forEach((key) => {
+            if (!shouldFlatten(obj[key])) {
+                result[prefix ? `${prefix}${delimiter}${key}` : key] = obj[key];
+                return;
+            }
+            deepFlattenHelper(obj[key], prefix ? `${prefix}${delimiter}${key}` : key);
+        });
+        stack.pop();
+    };
+    deepFlattenHelper(obj);
+    return result;
+}

package/dist/index.d.ts

@@ -1,10 +1,12 @@
-import deepEqual from './deepEqual';
-import deepExtend, { Merge } from './deepExtend';
-export { deepEqual, deepExtend, Merge };
+import { deepEqual } from './deepEqual.js';
+import { deepExtend, type Merge } from './deepExtend.js';
+import { deepFlatten } from './deepFlatten.js';
+export { deepEqual, deepExtend, deepFlatten, type Merge };
 declare const _default: {
     deepEqual: (p1: any, p2: any, options?: {
         disregardArrayOrder?: boolean;
     }) => boolean;
     deepExtend: <T extends unknown[]>(...args: T) => Merge<T>;
+    deepFlatten: typeof deepFlatten;
 };
 export default _default;

package/dist/index.js

@@ -1,7 +1,9 @@
-import deepEqual from './deepEqual';
-import deepExtend from './deepExtend';
-export { deepEqual, deepExtend };
+import { deepEqual } from './deepEqual.js';
+import { deepExtend } from './deepExtend.js';
+import { deepFlatten } from './deepFlatten.js';
+export { deepEqual, deepExtend, deepFlatten };
 export default {
     deepEqual,
-    deepExtend
+    deepExtend,
+    deepFlatten
 };

package/package.json

@@ -8,7 +8,7 @@
     "files": [
         "dist"
     ],
-    "homepage": "https://docs.cleverbrush.com/v1.0.0/modules/Deep_operations_on_objects.html",
+    "homepage": "https://docs.cleverbrush.com/v1.1.1/modules/Deep_operations_on_objects.html",
     "keywords": [
         "deep operations on objects",
         "deep equal",
@@ -35,5 +35,5 @@
     },
     "type": "module",
     "types": "./dist/index.d.ts",
-    "version": "1.1.0"
+    "version": "1.1.1"
 }