@cleverbrush/deep 1.1.11 → 3.0.0

package/README.md

@@ -1,46 +1,66 @@
-# Deep operations on objects
+# @cleverbrush/deep
 
-This is yet another library which provides operations over JavaScript objects, like deep compare and deep merge.
+[![CI](https://github.com/cleverbrush/framework/actions/workflows/ci.yml/badge.svg)](https://github.com/cleverbrush/framework/actions/workflows/ci.yml)
+[![License: BSD-3-Clause](https://img.shields.io/badge/license-BSD--3--Clause-blue.svg)](../../LICENSE)
+<!-- coverage-badge-start -->
+![Coverage](https://img.shields.io/badge/coverage-95.6%25-brightgreen)
+<!-- coverage-badge-end -->
+
+A library for deep operations on JavaScript objects — deep equality, deep merge, and flattening.
 
 ## Installation
 
-    npm install @cleverbrush/deep
+```bash
+npm install @cleverbrush/deep
+```
 
 ## Usage
 
 ```typescript
-import deep from '@cleverbrush/deep';
-// or import functions individually
-import { deepEqual, deepExtend } from '@cleverbrush/deep';
+import { deepEqual, deepExtend, deepFlatten } from '@cleverbrush/deep';
 ```
 
-## Functions
+## API
+
+### `deepEqual(a, b, options?)`
+
+Recursively compares two values and returns `true` if they are deeply equal. Supports nested objects, arrays, `Date` instances, and handles circular references.
 
-### deepEqual
+**Parameters:**
 
-Takes two objects as parameters, compares it recursively and returns `true` if they are equal or `false` in other case.
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| `a` | `any` | — | First value |
+| `b` | `any` | — | Second value |
+| `options.disregardArrayOrder` | `boolean` | `false` | When `true`, arrays are treated as equal regardless of element order |
 
 ```typescript
 import { deepEqual } from '@cleverbrush/deep';
 
-const equal1 = deepEqual({ a: { b: 1 } }, { a: { b: 1 } });
-// equal1 === true
+deepEqual({ a: { b: 1 } }, { a: { b: 1 } });
+// => true
 
-const equal2 = deepEqual({ a: { b: 1 } }, { a: { b: 20 } });
-// equal2 === false
+deepEqual({ a: { b: 1 } }, { a: { b: 20 } });
+// => false
 
-const equal3 = deepEqual({ a: { b: 1, c: 2 } }, { a: { b: 20 } });
-// equal3 === false
+deepEqual({ a: { b: 1, c: 2 } }, { a: { b: 1 } });
+// => false
+
+// Array order can be ignored
+deepEqual([1, 2, 3], [3, 1, 2], { disregardArrayOrder: true });
+// => true
 ```
 
-### deepExtend
+### `deepExtend(...objects)`
+
+Deeply merges multiple objects. Works like `Object.assign`, but recursively merges nested objects instead of overwriting them. All arguments must be non-null objects.
 
-Works similary to `Object.extend`, but respects the deep structure of objects.
+Returns a new object that is the deep merge of all provided objects.
 
 ```typescript
 import { deepExtend } from '@cleverbrush/deep';
 
-deepExtend(
+const result = deepExtend(
     {},
     {
         a: 'something',
@@ -54,25 +74,30 @@ deepExtend(
         }
     }
 );
+
+// result:
+// {
+//     a: 'something',
+//     name: {
+//         first: 'Ivan',
+//         last: 'Ivanov'
+//     }
+// }
 ```
 
-will return the following object:
+The result type is inferred from the input types using the `Merge<T>` utility type, which is also exported from the library.
 
-```typescript
-    {
-        a: 'something',
-        name: {
-            first: 'Ivan',
-            last: 'Ivanov'
-        }
-    }
-```
+### `deepFlatten(obj, delimiter?)`
+
+Flattens a nested object to a single level, concatenating keys with the specified delimiter.
 
-### deepFlatten
+**Parameters:**
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| `obj` | `Record<string, any>` | — | Object to flatten |
+| `delimiter` | `string` | `'.'` | Separator used to join nested keys |
 
-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
@@ -85,7 +110,6 @@ deepFlatten({
     },
     d: 3
 });
-
 // => { 'a.b': 1, 'a.c': 2, d: 3 }
 
 deepFlatten(
@@ -102,6 +126,34 @@ deepFlatten(
     },
     '-'
 );
-
 // => { 'a-b': 1, 'a-c': 2, 'd-e-f': 3 }
 ```
+
+### `HashObject(obj, exclude?)`
+
+Generates a hash representation for an object. Useful for comparing objects by value.
+
+**Parameters:**
+
+| Name | Type | Description |
+| --- | --- | --- |
+| `obj` | `any` | The value to hash |
+| `exclude` | `any[]` | Optional list of values to exclude from hashing |
+
+```typescript
+import { HashObject } from '@cleverbrush/deep';
+
+const hash = HashObject({ name: 'John', age: 30 });
+```
+
+## Code Quality
+
+- **Linting:** [Biome](https://biomejs.dev/) — enforced on every PR via CI
+- **Type checking:** TypeScript strict mode
+- **Unit tests:** [Vitest](https://vitest.dev/) — covering deep equality edge cases (circular references, `Date` instances, array order), deep merge, flattening, and hashing
+- **CI:** Every pull request must pass lint + build + test before merge — see [`.github/workflows/ci.yml`](../../.github/workflows/ci.yml)
+
+## License
+
+BSD-3-Clause
+

package/dist/deepExtend.d.ts

@@ -1,9 +1,29 @@
+/** Properties that exist in both `T1` and `T2`, typed as `T2`'s version. */
 export type CommonProps<T1, T2> = {
     [k in keyof T1 & keyof T2]: T1[k] extends never ? never : T2[k] extends never ? never : T2[k];
 };
+/** Properties present in `T1` but not in `T2`. */
 export type PropsInFirstOnly<T1, T2> = Omit<T1, keyof T2>;
+/** Recursively merges two object types. Matching keys are merged; unique keys are kept. */
 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];
 };
+/** Recursively merges a tuple of object types from left to right. */
 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;
+/**
+ * Deep-merges multiple objects into one. Later values override earlier ones;
+ * nested objects are merged recursively rather than replaced.
+ *
+ * @example
+ * ```ts
+ * const a = { x: 1, nested: { a: true } };
+ * const b = { y: 2, nested: { b: false } };
+ * const result = deepExtend(a, b);
+ * // { x: 1, y: 2, nested: { a: true, b: false } }
+ * ```
+ *
+ * @param args - Two or more non-null objects to merge.
+ * @returns A new object containing the deep-merged result.
+ * @throws If no arguments are provided or any argument is not a non-null object.
+ */
 export declare const deepExtend: <T extends unknown[]>(...args: T) => Merge<T>;

package/dist/hashObject.d.ts

@@ -1 +1,11 @@
-export declare function HashObject(unkType: any, exclude?: any): any;
+/**
+ * Computes a 32-bit numeric hash for any value.
+ *
+ * Objects are hashed by recursively hashing their sorted keys and values;
+ * circular references are detected via an internal exclusion list.
+ *
+ * @param unkType - The value to hash (object, string, number, etc.).
+ * @param exclude - Internal array used for circular-reference detection.
+ * @returns A 32-bit integer hash code.
+ */
+export declare function HashObject(unkType: any, exclude?: any[]): number;

package/dist/index.d.ts

@@ -1,12 +1,4 @@
 import { deepEqual } from './deepEqual.js';
-import { deepExtend, type Merge } from './deepExtend.js';
+import { deepExtend, type Merge, type MergeTwo } 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;
+export { deepEqual, deepExtend, deepFlatten, type Merge, type MergeTwo };

package/dist/index.js

@@ -1,9 +1,2 @@
-import { deepEqual } from './deepEqual.js';
-import { deepExtend } from './deepExtend.js';
-import { deepFlatten } from './deepFlatten.js';
-export { deepEqual, deepExtend, deepFlatten };
-export default {
-    deepEqual,
-    deepExtend,
-    deepFlatten
-};
+var m=(e,f)=>{let i=e;f||(i=`string${e}`);let t=0;for(let a=0;a<i.length;a++){let n=i.charCodeAt(a);t=(t<<5)-t+n,t=t&t}return t};function k(e,f){if(f.indexOf(e)>-1)return;let i="",t=Object.keys(e).sort();for(let a=0;a<t.length;a+=1){let n=t[a],r=w(n),o=w(e[n],f);f.push(e[n]),i+=m(`object${r}${o}`,!0)}return m(i,!0)}function h(e,f){let i=f;return i===void 0&&(i=[]),!isNaN(e)&&typeof e!="string"?e:typeof e==="object"?k(e,i):m(String(e))}var w=h;var x=(e,f)=>Number.isNaN(e)&&Number.isNaN(f),b=(e,f,i)=>{let t=new Map,a=(...n)=>{let r=(l,u)=>{if(l.length!==u.length)return!1;if(l.length===0&&u.length===0)return!0;let y=i?.disregardArrayOrder?l.map(c=>c).sort((c,p)=>{let d=h(c),T=h(p);return d<T?1:-1}):l.map(c=>c),g=i?.disregardArrayOrder?u.map(c=>c).sort((c,p)=>{let d=h(c),T=h(p);return d<T?1:-1}):u.map(c=>c);for(let c=0;c<y.length;c++)if(!a(y[c],g[c]))return!1;return!0};if(n.length!==2)return!1;let[o,s]=n;if(o===s)return!0;if(typeof o!=typeof s)return!1;if(x(o,s))return!0;if(Array.isArray(o)&&!Array.isArray(s)||!Array.isArray(o)&&Array.isArray(s))return!1;if(Array.isArray(o)&&Array.isArray(s))return r(o,s);if(typeof o=="object"&&o!==null){if(t.get(o)===!0)return!1;if(t.set(o,!0),o instanceof Date&&s instanceof Date)return!isNaN(o)&&!isNaN(s)&&o.getTime()===s.getTime();let l=Object.keys(o),u=Object.keys(s);if(l.length!==u.length)return!1;l.sort(),u.sort();for(let y=0;y<l.length;y++){if(l[y]!==u[y])return!1;let g=o[l[y]],c=s[l[y]];if(!a(g,c))return!1}return!0}return!1};return a(e,f)};var A=((...e)=>{if(e.length===0)throw new Error("no arguments");if(typeof e[0]!="object"||e[0]===null)throw new Error("not a non-null object");if(e.length===1)return e[0];let f={},i=(t,a)=>{let n=Object.keys(a);for(let r=0;r<n.length;r++)!Reflect.has(t,n[r])||!(typeof t[n[r]]=="object"&&t[n[r]]!==null&&typeof a[n[r]]=="object")||t[n[r]]==null||a[n[r]]==null?t[n[r]]=a[n[r]]:i(t[n[r]],a[n[r]])};for(let t=0;t<e.length;t++)if(typeof e[t]=="object"&&e[t]!==null&&e[t])i(f,e[t]);else throw new Error("not a non-null object");return f});function O(e,f="."){let i=r=>typeof r=="object"&&r!==null&&!Array.isArray(r)&&Object.getPrototypeOf(r)===Object.prototype;if(!i(e))throw new Error("cannot flatten this object");let t=[],a={},n=(r,o="")=>{if(t.find(s=>s===r))throw new Error("circular reference detected");t.push(r),Object.keys(r).forEach(s=>{if(!i(r[s])){a[o?`${o}${f}${s}`:s]=r[s];return}n(r[s],o?`${o}${f}${s}`:s)}),t.pop()};return n(e),a}export{b as deepEqual,A as deepExtend,O as deepFlatten};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hashObject.ts","../src/deepEqual.ts","../src/deepExtend.ts","../src/deepFlatten.ts"],"sourcesContent":["const stringHash = (string: string, noType?: boolean) => {\n    let hashString = string;\n    if (!noType) {\n        hashString = `string${string}`;\n    }\n    let hash = 0;\n    for (let i = 0; i < hashString.length; i++) {\n        const character = hashString.charCodeAt(i);\n        hash = (hash << 5) - hash + character;\n        hash = hash & hash; // Convert to 32bit integer\n    }\n    return hash;\n};\n\nfunction objectHash(\n    obj: Record<string, any>,\n    exclude: any[]\n): number | undefined {\n    if (exclude.indexOf(obj) > -1) {\n        return undefined;\n    }\n    let hash = '';\n    const keys = Object.keys(obj).sort();\n    for (let index = 0; index < keys.length; index += 1) {\n        const key = keys[index];\n        const keyHash = hashFunc(key);\n        const attrHash = hashFunc(obj[key], exclude);\n        exclude.push(obj[key]);\n        hash += stringHash(`object${keyHash}${attrHash}`, true);\n    }\n    return stringHash(hash, true);\n}\n\n/**\n * Computes a 32-bit numeric hash for any value.\n *\n * Objects are hashed by recursively hashing their sorted keys and values;\n * circular references are detected via an internal exclusion list.\n *\n * @param unkType - The value to hash (object, string, number, etc.).\n * @param exclude - Internal array used for circular-reference detection.\n * @returns A 32-bit integer hash code.\n */\nexport function HashObject(unkType: any, exclude?: any[]): number {\n    let ex = exclude;\n    if (ex === undefined) {\n        ex = [];\n    }\n    // biome-ignore lint/suspicious/noGlobalIsNan: intentional coercion — isNaN returns true for non-numeric types like objects\n    if (!isNaN(unkType) && typeof unkType !== 'string') {\n        return unkType;\n    }\n    switch (typeof unkType) {\n        case 'object':\n            return objectHash(unkType, ex) as number;\n        default:\n            return stringHash(String(unkType)) as number;\n    }\n}\n\nconst hashFunc = HashObject;\n","import { HashObject } from './hashObject.js';\n\nconst isBothNaN = (v1: any, v2: any) => Number.isNaN(v1) && Number.isNaN(v2);\n\n/**\n * Compares two objects and returns true if they\n * have the same structure and values. Can work\n * with arrays and objects, nested objects,\n * recursive objects, dates, etc.\n * @param p1 first object\n * @param p2 second object\n * @param options additional options\n * @returns {boolean} `true` if the objects are equal, `false` otherwise\n */\nexport const deepEqual = (\n    p1: any,\n    p2: any,\n    options?: {\n        /**\n         * if true, the order of the elements in the array will be disregarded\n         * e.g. [1, 2] and [2, 1] will be considered equal\n         */\n        disregardArrayOrder?: boolean;\n    }\n): boolean => {\n    const cache = new Map();\n\n    const compare = (...args: any[]) => {\n        const arraysAreIdentical = (a1: any, a2: any) => {\n            if (a1.length !== a2.length) return false;\n            if (a1.length === 0 && a2.length === 0) return true;\n\n            const c1 = options?.disregardArrayOrder\n                ? a1\n                      .map((t: any) => t)\n                      .sort((l: any, r: any) => {\n                          const hash1 = HashObject(l);\n                          const hash2 = HashObject(r);\n                          return hash1 < hash2 ? 1 : -1;\n                      })\n                : a1.map((t: any) => t);\n            const c2 = options?.disregardArrayOrder\n                ? a2\n                      .map((t: any) => t)\n                      .sort((l: any, r: any) => {\n                          const hash1 = HashObject(l);\n                          const hash2 = HashObject(r);\n                          return hash1 < hash2 ? 1 : -1;\n                      })\n                : a2.map((t: any) => t);\n\n            for (let i = 0; i < c1.length; i++) {\n                if (!compare(c1[i], c2[i])) return false;\n            }\n            return true;\n        };\n\n        if (args.length !== 2) return false;\n        const [o1, o2] = args;\n        if (o1 === o2) return true;\n        if (typeof o1 !== typeof o2) return false;\n        if (isBothNaN(o1, o2)) return true;\n\n        if (\n            (Array.isArray(o1) && !Array.isArray(o2)) ||\n            (!Array.isArray(o1) && Array.isArray(o2))\n        ) {\n            return false;\n        }\n        if (Array.isArray(o1) && Array.isArray(o2)) {\n            return arraysAreIdentical(o1, o2);\n        }\n\n        if (typeof o1 === 'object' && o1 !== null) {\n            if (cache.get(o1) === true) {\n                return false;\n            }\n\n            cache.set(o1, true);\n\n            if (o1 instanceof Date && o2 instanceof Date) {\n                return (\n                    // biome-ignore lint/suspicious/noGlobalIsNan: isNaN coerces Date to number, which is the intended behavior here\n                    !isNaN(o1 as any) &&\n                    // biome-ignore lint/suspicious/noGlobalIsNan: isNaN coerces Date to number, which is the intended behavior here\n                    !isNaN(o2 as any) &&\n                    o1.getTime() === o2.getTime()\n                );\n            }\n\n            const keys1 = Object.keys(o1);\n            const keys2 = Object.keys(o2);\n            if (keys1.length !== keys2.length) return false;\n\n            keys1.sort();\n            keys2.sort();\n            for (let i = 0; i < keys1.length; i++) {\n                if (keys1[i] !== keys2[i]) {\n                    return false;\n                }\n\n                const v1 = o1[keys1[i]];\n                const v2 = o2[keys1[i]];\n                if (!compare(v1, v2)) return false;\n            }\n            return true;\n        }\n\n        return false;\n    };\n\n    return compare(p1, p2);\n};\n","/** Properties that exist in both `T1` and `T2`, typed as `T2`'s version. */\nexport type CommonProps<T1, T2> = {\n    [k in keyof T1 & keyof T2]: T1[k] extends never\n        ? never\n        : T2[k] extends never\n          ? never\n          : T2[k];\n};\n\n/** Properties present in `T1` but not in `T2`. */\nexport type PropsInFirstOnly<T1, T2> = Omit<T1, keyof T2>;\n\n/** Recursively merges two object types. Matching keys are merged; unique keys are kept. */\nexport type MergeTwo<T1, T2> = PropsInFirstOnly<T1, T2> &\n    PropsInFirstOnly<T2, T1> & {\n        [k in keyof CommonProps<T1, T2>]: T1[k] extends Record<string, unknown>\n            ? T2[k] extends Record<string, unknown>\n                ? MergeTwo<T1[k], T2[k]>\n                : T2[k]\n            : T2[k];\n    };\n\n/** Recursively merges a tuple of object types from left to right. */\nexport type Merge<T extends unknown[]> = T['length'] extends 3\n    ? MergeTwo<T[0], MergeTwo<T[1], T[2]>>\n    : T['length'] extends 2\n      ? MergeTwo<T[0], T[1]>\n      : T['length'] extends 1\n        ? T[0]\n        : T extends [...infer K, infer PL, infer L]\n          ? Merge<[Merge<[...K]>, MergeTwo<PL, L>]>\n          : never;\n\n/**\n * Deep-merges multiple objects into one. Later values override earlier ones;\n * nested objects are merged recursively rather than replaced.\n *\n * @example\n * ```ts\n * const a = { x: 1, nested: { a: true } };\n * const b = { y: 2, nested: { b: false } };\n * const result = deepExtend(a, b);\n * // { x: 1, y: 2, nested: { a: true, b: false } }\n * ```\n *\n * @param args - Two or more non-null objects to merge.\n * @returns A new object containing the deep-merged result.\n * @throws If no arguments are provided or any argument is not a non-null object.\n */\nexport const deepExtend = ((...rest) => {\n    if (rest.length === 0) throw new Error('no arguments');\n    if (typeof rest[0] !== 'object' || rest[0] === null)\n        throw new Error('not a non-null object');\n    if (rest.length === 1) return rest[0];\n\n    const result = {};\n\n    const extendObject = (o1: any, o2: any) => {\n        const keys = Object.keys(o2);\n\n        for (let i = 0; i < keys.length; i++) {\n            if (\n                !Reflect.has(o1, keys[i]) ||\n                !(\n                    typeof o1[keys[i]] === 'object' &&\n                    o1[keys[i]] !== null &&\n                    typeof o2[keys[i]] === 'object'\n                )\n            ) {\n                o1[keys[i]] = o2[keys[i]];\n            } else {\n                if (o1[keys[i]] == null || o2[keys[i]] == null) {\n                    o1[keys[i]] = o2[keys[i]];\n                } else {\n                    extendObject(o1[keys[i]], o2[keys[i]]);\n                }\n            }\n        }\n    };\n\n    for (let i = 0; i < rest.length; i++) {\n        if (typeof rest[i] === 'object' && rest[i] !== null && rest[i]) {\n            extendObject(result, rest[i]);\n        } else {\n            throw new Error('not a non-null object');\n        }\n    }\n\n    return result;\n}) as <T extends unknown[]>(...args: T) => Merge<T>;\n","/**\n * Flattens an object to a single level, with the nested keys separated by a `delimiter`.\n * @example\n * ```ts\n * deepFlatten({ a: { b: 1, c: 2 } });\n * // => { 'a.b': 1, 'a.c': 2 }\n *\n * deepFlatten({ a: { b: 1, c: 2 } }, '/');\n * // => { 'a/b': 1, 'a/c': 2 }\n *\n * deepFlatten({ a: { b: 1, c: { d: 'some val' } }, d: 3 });\n * // => { 'a.b': 1, 'a.c.d': 'some val', d: 3 }\n *\n * ```\n * @param {string} [delimiter]\n */\nexport function deepFlatten(\n    obj: Record<string, any>,\n    delimiter = '.'\n): Record<string, any> {\n    const shouldFlatten = (obj: any) =>\n        typeof obj === 'object' &&\n        obj !== null &&\n        !Array.isArray(obj) &&\n        Object.getPrototypeOf(obj) === Object.prototype;\n\n    if (!shouldFlatten(obj)) throw new Error('cannot flatten this object');\n\n    const stack: any[] = [];\n\n    const result: Record<string, any> = {};\n\n    const deepFlattenHelper = (obj: any, prefix = '') => {\n        if (stack.find(o => o === obj))\n            throw new Error('circular reference detected');\n\n        stack.push(obj);\n\n        Object.keys(obj).forEach(key => {\n            if (!shouldFlatten(obj[key])) {\n                result[prefix ? `${prefix}${delimiter}${key}` : key] = obj[key];\n                return;\n            }\n            deepFlattenHelper(\n                obj[key],\n                prefix ? `${prefix}${delimiter}${key}` : key\n            );\n        });\n\n        stack.pop();\n    };\n\n    deepFlattenHelper(obj);\n\n    return result;\n}\n"],"mappings":"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","names":["stringHash","string","noType","hashString","hash","i","character","objectHash","obj","exclude","keys","index","key","keyHash","hashFunc","attrHash","HashObject","unkType","ex","isBothNaN","v1","v2","deepEqual","p1","p2","options","cache","compare","args","arraysAreIdentical","a1","a2","c1","t","l","r","hash1","HashObject","hash2","c2","i","o1","o2","keys1","keys2","deepExtend","rest","result","extendObject","o1","o2","keys","i","deepFlatten","obj","delimiter","shouldFlatten","stack","result","deepFlattenHelper","prefix","o","key"]}

package/package.json

@@ -8,7 +8,7 @@
     "files": [
         "dist"
     ],
-    "homepage": "https://docs.cleverbrush.com/modules/_cleverbrush_deep.html",
+    "homepage": "https://docs.cleverbrush.com/",
     "keywords": [
         "deep operations on objects",
         "deep equal",
@@ -17,6 +17,13 @@
     ],
     "license": "BSD 3-Clause",
     "main": "./dist/index.js",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "sideEffects": false,
     "name": "@cleverbrush/deep",
     "readme": "https://github.com/cleverbrush/framework/tree/master/libs/deep#readme",
     "repository": {
@@ -24,10 +31,11 @@
         "url": "github:cleverbrush/framework"
     },
     "scripts": {
-        "watch": "tsc --watch",
-        "build": "tsc"
+        "watch": "tsc --build --watch",
+        "build": "tsup && rm -f tsconfig.build.tsbuildinfo && tsc --project tsconfig.build.json --emitDeclarationOnly",
+        "clean": "rm -rf dist tsconfig.tsbuildinfo"
     },
     "type": "module",
     "types": "./dist/index.d.ts",
-    "version": "1.1.11"
+    "version": "3.0.0"
 }

package/dist/deepEqual.js

@@ -1,90 +0,0 @@
-import { HashObject } from './hashObject.js';
-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
- * 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
- */
-export 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;
-            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' && o1 !== null) {
-            if (cache.get(o1) === true) {
-                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)
-                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);
-};

package/dist/deepExtend.js

@@ -1,37 +0,0 @@
-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) {
-        const keys = Object.keys(o2);
-        for (let i = 0; i < keys.length; i++) {
-            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 {
-                    extendObject(o1[keys[i]], o2[keys[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;
-});

package/dist/deepFlatten.js

@@ -1,41 +0,0 @@
-/**
- * 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/hashObject.js

@@ -1,44 +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;