@jsopen/objects 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Panates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @jsopen/objects
+
+[![NPM Version][npm-image]][npm-url]
+[![NPM Downloads][downloads-image]][downloads-url]
+[![CI Tests][ci-test-image]][ci-test-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+A 'swiss army knife' solution for working with javascript objects.
+
+## Installation
+
+`$ npm install @jsopen/objects`
+
+## Node Compatibility
+
+- node `>= 16`;
+
+### License
+[MIT](LICENSE)
+
+
+[npm-image]: https://img.shields.io/npm/v/@jsopen/objects
+[npm-url]: https://npmjs.org/package/@jsopen/objects
+[ci-test-image]: https://github.com/panates/jsopen-objects/actions/workflows/test.yml/badge.svg
+[ci-test-url]: https://github.com/panates/jsopen-objects/actions/workflows/test.yml
+[coveralls-image]: https://img.shields.io/coveralls/panates/@jsopen/objects/master.svg
+[coveralls-url]: https://coveralls.io/r/panates/@jsopen/objects
+[downloads-image]: https://img.shields.io/npm/dm/@jsopen/objects.svg
+[downloads-url]: https://npmjs.org/package/@jsopen/objects
+

package/cjs/clone.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clone = clone;
+const merge_js_1 = require("./merge.js");
+function clone(obj, options) {
+    return (0, merge_js_1.merge)({}, obj, {
+        ...options,
+        deep: options?.deep ?? true,
+    });
+}

package/cjs/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./clone.js"), exports);
+tslib_1.__exportStar(require("./is-built-in.js"), exports);
+tslib_1.__exportStar(require("./is-object.js"), exports);
+tslib_1.__exportStar(require("./merge.js"), exports);
+tslib_1.__exportStar(require("./omit.js"), exports);

package/cjs/is-built-in.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBuiltIn = isBuiltIn;
+function isBuiltIn(v) {
+    return ((typeof v === 'object' &&
+        (v instanceof Date ||
+            v instanceof RegExp ||
+            v instanceof Map ||
+            v instanceof Set ||
+            v instanceof WeakMap ||
+            v instanceof WeakSet ||
+            v instanceof WeakRef ||
+            v instanceof Promise ||
+            v instanceof Error ||
+            v instanceof ArrayBuffer ||
+            v instanceof SharedArrayBuffer ||
+            v instanceof Uint8Array ||
+            v instanceof Uint8ClampedArray ||
+            v instanceof Uint16Array ||
+            v instanceof Uint32Array ||
+            v instanceof BigUint64Array ||
+            v instanceof Int8Array ||
+            v instanceof Int16Array ||
+            v instanceof Int32Array ||
+            Buffer.isBuffer(v))) ||
+        Array.isArray(v));
+}

package/cjs/is-object.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+const objCtorStr = Function.prototype.toString.call(Object);
+function isObject(v) {
+    return v && typeof v === 'object' && !Array.isArray(v);
+}
+function isPlainObject(obj) {
+    if (typeof obj === 'object' &&
+        Object.prototype.toString.call(obj) === '[object Object]') {
+        const proto = Object.getPrototypeOf(obj);
+        /* istanbul ignore next */
+        if (!proto)
+            return true;
+        const ctor = Object.prototype.hasOwnProperty.call(proto, 'constructor') &&
+            proto.constructor;
+        return (typeof ctor === 'function' &&
+            ctor instanceof ctor &&
+            Function.prototype.toString.call(ctor) === objCtorStr);
+    }
+    return false;
+}

package/cjs/merge.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = merge;
+exports.getMergeFunction = getMergeFunction;
+const is_object_js_1 = require("./is-object.js");
+function merge(target, source, options) {
+    if (!((0, is_object_js_1.isObject)(target) || typeof target === 'function')) {
+        throw new TypeError('"target" argument must be an object');
+    }
+    source = source || {};
+    if (!((0, is_object_js_1.isObject)(source) || typeof target === 'function')) {
+        throw new TypeError('"target" argument must be an object');
+    }
+    const fn = getMergeFunction(options);
+    return fn(target, source, '', options, fn, is_object_js_1.isPlainObject, is_object_js_1.isObject, arrayClone);
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const functionCache = new Map();
+function getMergeFunction(options) {
+    const cacheKey = [
+        options?.deep,
+        options?.moveArrays,
+        options?.keepExisting,
+        options?.copyDescriptors,
+        options?.ignore,
+        options?.ignoreUndefined,
+        options?.ignoreNulls,
+        options?.filter,
+    ]
+        .map(option => option == null
+        ? 'n'
+        : typeof option === 'function'
+            ? 'f'
+            : option
+                ? '1'
+                : '0')
+        .join();
+    let fn = functionCache.get(cacheKey);
+    if (!fn) {
+        fn = buildMerge(options);
+        functionCache.set(cacheKey, fn);
+    }
+    return fn;
+}
+function buildMerge(options) {
+    const args = [
+        'target',
+        'source',
+        'curPath',
+        'options',
+        'mergeFunction',
+        'isPlainObject',
+        'isObject',
+        'arrayClone',
+    ];
+    const scriptL0 = [
+        `
+const _merge = (_trgVal, _srcVal, _curPath) => 
+    mergeFunction(_trgVal, _srcVal, _curPath, options, mergeFunction, isPlainObject, isObject, arrayClone);
+const keys = Object.getOwnPropertyNames(source);
+keys.push(...Object.getOwnPropertySymbols(source));
+let key;
+let descriptor;
+let srcVal;
+let trgVal;
+`,
+    ];
+    if (options?.deep) {
+        scriptL0.push(`let subPath;`, `let _isPlain;`, `let _isArray;`);
+        if (typeof options?.deep === 'function') {
+            scriptL0.push(`const deepCallback = options.deep;`);
+        }
+    }
+    if (typeof options?.ignore === 'function') {
+        scriptL0.push('const ignoreCallback = options.ignore;');
+    }
+    if (typeof options?.filter === 'function') {
+        scriptL0.push('const filterCallback = options.filter;');
+    }
+    if (typeof options?.copyDescriptors === 'function') {
+        scriptL0.push(`const copyDescriptorsCallback = options.copyDescriptors;`);
+    }
+    if (typeof options?.moveArrays === 'function') {
+        scriptL0.push(`const moveArraysCallback = options.moveArrays;`);
+    }
+    scriptL0.push(`
+let i = 0;
+const len = keys.length;
+for (i = 0; i < len; i++) {
+  key = keys[i];
+  /** Should not overwrite __proto__ and constructor properties */
+  if (key === '__proto__' || key === 'constructor') continue;
+`);
+    const scriptL1For = [];
+    scriptL0.push(scriptL1For);
+    scriptL0.push('}');
+    /** ************* filter *****************/
+    if (options?.filter) {
+        scriptL1For.push(`
+if (!filterCallback(key, curPath, target, source)) {
+  delete target[key];
+  continue;
+}`);
+    }
+    /** ************* ignore *****************/
+    if (typeof options?.ignore === 'function') {
+        scriptL1For.push(`
+if (
+      Object.prototype.hasOwnProperty.call(target, key) && 
+      ignoreCallback(key, curPath, target, source)
+   ) continue;
+`);
+    }
+    // scriptL1For.push(
+    //   `descriptor = { ...Object.getOwnPropertyDescriptor(source, key) };`,
+    // );
+    /** ************* copyDescriptors *****************/
+    if (options?.copyDescriptors) {
+        let scriptL2Descriptors = scriptL1For;
+        if (typeof options?.copyDescriptors === 'function') {
+            scriptL1For.push('if (copyDescriptorsCallback(key, curPath, target, source)) {');
+            scriptL2Descriptors = [];
+            scriptL1For.push(scriptL2Descriptors);
+            scriptL1For.push(`} else`);
+            scriptL1For.push(`  descriptor = {enumerable: true, configurable: true, writable: true}`);
+        }
+        scriptL2Descriptors.push(`
+  descriptor = { ...Object.getOwnPropertyDescriptor(source, key) }
+  if ((descriptor.get || descriptor.set)) {
+    Object.defineProperty(target, key, descriptor);
+    continue;
+  }
+  srcVal = source[key];`);
+    }
+    else {
+        scriptL1For.push(`descriptor = {enumerable: true, configurable: true, writable: true}`, `srcVal =  source[key];`);
+    }
+    /** ************* keepExisting *****************/
+    if (options?.keepExisting) {
+        scriptL1For.push(`if (hasOwnProperty.call(target, key)) continue;`);
+    }
+    /** ************* ignoreUndefined *****************/
+    if (options?.ignoreUndefined ?? true) {
+        scriptL1For.push(`if (srcVal === undefined) continue;`);
+    }
+    /** ************* ignoreNulls *****************/
+    if (options?.ignoreNulls) {
+        scriptL1For.push(`if (srcVal === null) continue;`);
+    }
+    /** ************* deep *****************/
+    if (options?.deep) {
+        scriptL1For.push(`
+_isPlain = isPlainObject(srcVal);
+_isArray = Array.isArray(srcVal);
+if (_isPlain || _isArray) {`);
+        const scriptL2Deep = [];
+        scriptL1For.push(scriptL2Deep);
+        scriptL1For.push('}');
+        let scriptL3Deep = scriptL2Deep;
+        if (typeof options?.deep === 'function') {
+            scriptL2Deep.push(`
+subPath = curPath + (curPath ? '.' : '') + key;
+if (deepCallback(key, subPath, target, source)) {`);
+            scriptL3Deep = [];
+            scriptL2Deep.push(scriptL3Deep);
+            scriptL2Deep.push('}');
+        }
+        /** ************* _isPlain *****************/
+        scriptL3Deep.push(`
+if (_isPlain) {
+  trgVal = target[key];
+  if (!isObject(trgVal)) {
+    descriptor.value = trgVal = {};
+    Object.defineProperty(target, key, descriptor);
+  }
+  _merge(trgVal, srcVal, subPath, options);
+  continue;
+}`);
+        /** ************* moveArrays *****************/
+        if (!options?.moveArrays || typeof options?.moveArrays === 'function') {
+            scriptL3Deep.push(`if (_isArray) {`);
+            const scriptL4IsArray = [];
+            scriptL3Deep.push(scriptL4IsArray);
+            scriptL3Deep.push('}');
+            let scriptL5CloneArrays = scriptL4IsArray;
+            if (typeof options?.moveArrays === 'function') {
+                scriptL4IsArray.push(`if (!moveArraysCallback(key, subPath, target, source)) {`);
+                scriptL5CloneArrays = [];
+                scriptL4IsArray.push(scriptL5CloneArrays);
+                scriptL4IsArray.push('}');
+            }
+            scriptL5CloneArrays.push(`
+descriptor.value = arrayClone(srcVal, _merge, subPath);
+Object.defineProperty(target, key, descriptor);
+continue;
+`);
+        }
+    }
+    /** ************* finalize *****************/
+    scriptL1For.push(`
+descriptor.value = srcVal;
+Object.defineProperty(target, key, descriptor);`);
+    scriptL0.push('return target;');
+    const script = _flattenText(scriptL0);
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval,prefer-const
+    return Function(...args, script);
+}
+function arrayClone(arr, _merge, curPath) {
+    return arr.map((x) => {
+        if (Array.isArray(x))
+            return arrayClone(x, _merge, curPath);
+        if ((0, is_object_js_1.isPlainObject)(x))
+            return _merge({}, x, curPath);
+        return x;
+    });
+}
+function _flattenText(arr, level = 0) {
+    const indent = '  '.repeat(level);
+    return arr
+        .map(v => {
+        if (Array.isArray(v))
+            return _flattenText(v, level + 1);
+        return (indent +
+            String(v)
+                .trim()
+                .replace(/\n/g, '\n' + indent));
+    })
+        .join('\n');
+}

package/cjs/omit.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omitUndefined = omitUndefined;
+exports.omitNull = omitNull;
+exports.omitNullish = omitNullish;
+const is_object_js_1 = require("./is-object.js");
+function omitUndefined(obj, deep) {
+    /* istanbul ignore next */
+    if (!(obj && typeof obj === 'object'))
+        return obj;
+    let v;
+    for (const k of Object.keys(obj)) {
+        v = obj[k];
+        if (v === undefined)
+            delete obj[k];
+        else if (deep) {
+            if (Array.isArray(v))
+                v.forEach(x => omitUndefined(x, deep));
+            else if ((0, is_object_js_1.isPlainObject)(v))
+                omitUndefined(obj[k], deep);
+        }
+    }
+    return obj;
+}
+function omitNull(obj, deep) {
+    /* istanbul ignore next */
+    if (!(obj && typeof obj === 'object'))
+        return obj;
+    let v;
+    for (const k of Object.keys(obj)) {
+        v = obj[k];
+        if (v === null)
+            delete obj[k];
+        else if (deep) {
+            if (Array.isArray(v))
+                v.forEach(x => omitNull(x, deep));
+            else if ((0, is_object_js_1.isPlainObject)(v))
+                omitNull(obj[k], deep);
+        }
+    }
+    return obj;
+}
+function omitNullish(obj, deep) {
+    /* istanbul ignore next */
+    if (!(obj && typeof obj === 'object'))
+        return obj;
+    let v;
+    for (const k of Object.keys(obj)) {
+        v = obj[k];
+        if (v == null)
+            delete obj[k];
+        else if (deep) {
+            if (Array.isArray(v))
+                v.forEach(x => omitNullish(x, deep));
+            else if ((0, is_object_js_1.isPlainObject)(v))
+                omitNullish(obj[k], deep);
+        }
+    }
+    return obj;
+}

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/tsconfig-build-cjs.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../../src/clone.ts","../../src/index.ts","../../src/is-built-in.ts","../../src/is-object.ts","../../src/merge.ts","../../src/omit.ts"],"version":"5.6.3"}

package/esm/clone.js

@@ -0,0 +1,7 @@
+import { merge } from './merge.js';
+export function clone(obj, options) {
+    return merge({}, obj, {
+        ...options,
+        deep: options?.deep ?? true,
+    });
+}

package/esm/index.js

@@ -0,0 +1,5 @@
+export * from './clone.js';
+export * from './is-built-in.js';
+export * from './is-object.js';
+export * from './merge.js';
+export * from './omit.js';

package/esm/is-built-in.js

@@ -0,0 +1,24 @@
+export function isBuiltIn(v) {
+    return ((typeof v === 'object' &&
+        (v instanceof Date ||
+            v instanceof RegExp ||
+            v instanceof Map ||
+            v instanceof Set ||
+            v instanceof WeakMap ||
+            v instanceof WeakSet ||
+            v instanceof WeakRef ||
+            v instanceof Promise ||
+            v instanceof Error ||
+            v instanceof ArrayBuffer ||
+            v instanceof SharedArrayBuffer ||
+            v instanceof Uint8Array ||
+            v instanceof Uint8ClampedArray ||
+            v instanceof Uint16Array ||
+            v instanceof Uint32Array ||
+            v instanceof BigUint64Array ||
+            v instanceof Int8Array ||
+            v instanceof Int16Array ||
+            v instanceof Int32Array ||
+            Buffer.isBuffer(v))) ||
+        Array.isArray(v));
+}

package/esm/is-object.js

@@ -0,0 +1,19 @@
+const objCtorStr = Function.prototype.toString.call(Object);
+export function isObject(v) {
+    return v && typeof v === 'object' && !Array.isArray(v);
+}
+export function isPlainObject(obj) {
+    if (typeof obj === 'object' &&
+        Object.prototype.toString.call(obj) === '[object Object]') {
+        const proto = Object.getPrototypeOf(obj);
+        /* istanbul ignore next */
+        if (!proto)
+            return true;
+        const ctor = Object.prototype.hasOwnProperty.call(proto, 'constructor') &&
+            proto.constructor;
+        return (typeof ctor === 'function' &&
+            ctor instanceof ctor &&
+            Function.prototype.toString.call(ctor) === objCtorStr);
+    }
+    return false;
+}

package/esm/merge.js

@@ -0,0 +1,225 @@
+import { isObject, isPlainObject } from './is-object.js';
+export function merge(target, source, options) {
+    if (!(isObject(target) || typeof target === 'function')) {
+        throw new TypeError('"target" argument must be an object');
+    }
+    source = source || {};
+    if (!(isObject(source) || typeof target === 'function')) {
+        throw new TypeError('"target" argument must be an object');
+    }
+    const fn = getMergeFunction(options);
+    return fn(target, source, '', options, fn, isPlainObject, isObject, arrayClone);
+}
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const functionCache = new Map();
+export function getMergeFunction(options) {
+    const cacheKey = [
+        options?.deep,
+        options?.moveArrays,
+        options?.keepExisting,
+        options?.copyDescriptors,
+        options?.ignore,
+        options?.ignoreUndefined,
+        options?.ignoreNulls,
+        options?.filter,
+    ]
+        .map(option => option == null
+        ? 'n'
+        : typeof option === 'function'
+            ? 'f'
+            : option
+                ? '1'
+                : '0')
+        .join();
+    let fn = functionCache.get(cacheKey);
+    if (!fn) {
+        fn = buildMerge(options);
+        functionCache.set(cacheKey, fn);
+    }
+    return fn;
+}
+function buildMerge(options) {
+    const args = [
+        'target',
+        'source',
+        'curPath',
+        'options',
+        'mergeFunction',
+        'isPlainObject',
+        'isObject',
+        'arrayClone',
+    ];
+    const scriptL0 = [
+        `
+const _merge = (_trgVal, _srcVal, _curPath) => 
+    mergeFunction(_trgVal, _srcVal, _curPath, options, mergeFunction, isPlainObject, isObject, arrayClone);
+const keys = Object.getOwnPropertyNames(source);
+keys.push(...Object.getOwnPropertySymbols(source));
+let key;
+let descriptor;
+let srcVal;
+let trgVal;
+`,
+    ];
+    if (options?.deep) {
+        scriptL0.push(`let subPath;`, `let _isPlain;`, `let _isArray;`);
+        if (typeof options?.deep === 'function') {
+            scriptL0.push(`const deepCallback = options.deep;`);
+        }
+    }
+    if (typeof options?.ignore === 'function') {
+        scriptL0.push('const ignoreCallback = options.ignore;');
+    }
+    if (typeof options?.filter === 'function') {
+        scriptL0.push('const filterCallback = options.filter;');
+    }
+    if (typeof options?.copyDescriptors === 'function') {
+        scriptL0.push(`const copyDescriptorsCallback = options.copyDescriptors;`);
+    }
+    if (typeof options?.moveArrays === 'function') {
+        scriptL0.push(`const moveArraysCallback = options.moveArrays;`);
+    }
+    scriptL0.push(`
+let i = 0;
+const len = keys.length;
+for (i = 0; i < len; i++) {
+  key = keys[i];
+  /** Should not overwrite __proto__ and constructor properties */
+  if (key === '__proto__' || key === 'constructor') continue;
+`);
+    const scriptL1For = [];
+    scriptL0.push(scriptL1For);
+    scriptL0.push('}');
+    /** ************* filter *****************/
+    if (options?.filter) {
+        scriptL1For.push(`
+if (!filterCallback(key, curPath, target, source)) {
+  delete target[key];
+  continue;
+}`);
+    }
+    /** ************* ignore *****************/
+    if (typeof options?.ignore === 'function') {
+        scriptL1For.push(`
+if (
+      Object.prototype.hasOwnProperty.call(target, key) && 
+      ignoreCallback(key, curPath, target, source)
+   ) continue;
+`);
+    }
+    // scriptL1For.push(
+    //   `descriptor = { ...Object.getOwnPropertyDescriptor(source, key) };`,
+    // );
+    /** ************* copyDescriptors *****************/
+    if (options?.copyDescriptors) {
+        let scriptL2Descriptors = scriptL1For;
+        if (typeof options?.copyDescriptors === 'function') {
+            scriptL1For.push('if (copyDescriptorsCallback(key, curPath, target, source)) {');
+            scriptL2Descriptors = [];
+            scriptL1For.push(scriptL2Descriptors);
+            scriptL1For.push(`} else`);
+            scriptL1For.push(`  descriptor = {enumerable: true, configurable: true, writable: true}`);
+        }
+        scriptL2Descriptors.push(`
+  descriptor = { ...Object.getOwnPropertyDescriptor(source, key) }
+  if ((descriptor.get || descriptor.set)) {
+    Object.defineProperty(target, key, descriptor);
+    continue;
+  }
+  srcVal = source[key];`);
+    }
+    else {
+        scriptL1For.push(`descriptor = {enumerable: true, configurable: true, writable: true}`, `srcVal =  source[key];`);
+    }
+    /** ************* keepExisting *****************/
+    if (options?.keepExisting) {
+        scriptL1For.push(`if (hasOwnProperty.call(target, key)) continue;`);
+    }
+    /** ************* ignoreUndefined *****************/
+    if (options?.ignoreUndefined ?? true) {
+        scriptL1For.push(`if (srcVal === undefined) continue;`);
+    }
+    /** ************* ignoreNulls *****************/
+    if (options?.ignoreNulls) {
+        scriptL1For.push(`if (srcVal === null) continue;`);
+    }
+    /** ************* deep *****************/
+    if (options?.deep) {
+        scriptL1For.push(`
+_isPlain = isPlainObject(srcVal);
+_isArray = Array.isArray(srcVal);
+if (_isPlain || _isArray) {`);
+        const scriptL2Deep = [];
+        scriptL1For.push(scriptL2Deep);
+        scriptL1For.push('}');
+        let scriptL3Deep = scriptL2Deep;
+        if (typeof options?.deep === 'function') {
+            scriptL2Deep.push(`
+subPath = curPath + (curPath ? '.' : '') + key;
+if (deepCallback(key, subPath, target, source)) {`);
+            scriptL3Deep = [];
+            scriptL2Deep.push(scriptL3Deep);
+            scriptL2Deep.push('}');
+        }
+        /** ************* _isPlain *****************/
+        scriptL3Deep.push(`
+if (_isPlain) {
+  trgVal = target[key];
+  if (!isObject(trgVal)) {
+    descriptor.value = trgVal = {};
+    Object.defineProperty(target, key, descriptor);
+  }
+  _merge(trgVal, srcVal, subPath, options);
+  continue;
+}`);
+        /** ************* moveArrays *****************/
+        if (!options?.moveArrays || typeof options?.moveArrays === 'function') {
+            scriptL3Deep.push(`if (_isArray) {`);
+            const scriptL4IsArray = [];
+            scriptL3Deep.push(scriptL4IsArray);
+            scriptL3Deep.push('}');
+            let scriptL5CloneArrays = scriptL4IsArray;
+            if (typeof options?.moveArrays === 'function') {
+                scriptL4IsArray.push(`if (!moveArraysCallback(key, subPath, target, source)) {`);
+                scriptL5CloneArrays = [];
+                scriptL4IsArray.push(scriptL5CloneArrays);
+                scriptL4IsArray.push('}');
+            }
+            scriptL5CloneArrays.push(`
+descriptor.value = arrayClone(srcVal, _merge, subPath);
+Object.defineProperty(target, key, descriptor);
+continue;
+`);
+        }
+    }
+    /** ************* finalize *****************/
+    scriptL1For.push(`
+descriptor.value = srcVal;
+Object.defineProperty(target, key, descriptor);`);
+    scriptL0.push('return target;');
+    const script = _flattenText(scriptL0);
+    // eslint-disable-next-line @typescript-eslint/no-implied-eval,prefer-const
+    return Function(...args, script);
+}
+function arrayClone(arr, _merge, curPath) {
+    return arr.map((x) => {
+        if (Array.isArray(x))
+            return arrayClone(x, _merge, curPath);
+        if (isPlainObject(x))
+            return _merge({}, x, curPath);
+        return x;
+    });
+}
+function _flattenText(arr, level = 0) {
+    const indent = '  '.repeat(level);
+    return arr
+        .map(v => {
+        if (Array.isArray(v))
+            return _flattenText(v, level + 1);
+        return (indent +
+            String(v)
+                .trim()
+                .replace(/\n/g, '\n' + indent));
+    })
+        .join('\n');
+}

package/esm/omit.js

@@ -0,0 +1,55 @@
+import { isPlainObject } from './is-object.js';
+export function omitUndefined(obj, deep) {
+    /* istanbul ignore next */
+    if (!(obj && typeof obj === 'object'))
+        return obj;
+    let v;
+    for (const k of Object.keys(obj)) {
+        v = obj[k];
+        if (v === undefined)
+            delete obj[k];
+        else if (deep) {
+            if (Array.isArray(v))
+                v.forEach(x => omitUndefined(x, deep));
+            else if (isPlainObject(v))
+                omitUndefined(obj[k], deep);
+        }
+    }
+    return obj;
+}
+export function omitNull(obj, deep) {
+    /* istanbul ignore next */
+    if (!(obj && typeof obj === 'object'))
+        return obj;
+    let v;
+    for (const k of Object.keys(obj)) {
+        v = obj[k];
+        if (v === null)
+            delete obj[k];
+        else if (deep) {
+            if (Array.isArray(v))
+                v.forEach(x => omitNull(x, deep));
+            else if (isPlainObject(v))
+                omitNull(obj[k], deep);
+        }
+    }
+    return obj;
+}
+export function omitNullish(obj, deep) {
+    /* istanbul ignore next */
+    if (!(obj && typeof obj === 'object'))
+        return obj;
+    let v;
+    for (const k of Object.keys(obj)) {
+        v = obj[k];
+        if (v == null)
+            delete obj[k];
+        else if (deep) {
+            if (Array.isArray(v))
+                v.forEach(x => omitNullish(x, deep));
+            else if (isPlainObject(v))
+                omitNullish(obj[k], deep);
+        }
+    }
+    return obj;
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/tsconfig-build-esm.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../../src/clone.ts","../../src/index.ts","../../src/is-built-in.ts","../../src/is-object.ts","../../src/merge.ts","../../src/omit.ts"],"version":"5.6.3"}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@jsopen/objects",
+  "description": "Helper utilities for working with JavaScript objects and arrays",
+  "version": "1.0.0",
+  "author": "Panates",
+  "license": "MIT",
+  "dependencies": {
+    "tslib": "^2.8.1"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./types/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "require": {
+        "types": "./types/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "default": "./esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./cjs/index.js",
+  "module": "./esm/index.js",
+  "types": "./types/index.d.ts",
+  "contributors": [
+    "Eray Hanoglu <e.hanoglu@panates.com>"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/jsopen-objects.git"
+  },
+  "engines": {
+    "node": ">= 16.0"
+  },
+  "files": [
+    "cjs/",
+    "esm/",
+    "types/",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "object",
+    "util",
+    "utils",
+    "merge",
+    "clone",
+    "deep",
+    "omit",
+    "is-plain",
+    "object-utils"
+  ]
+}

package/types/clone.d.ts

@@ -0,0 +1,2 @@
+import { merge } from './merge.js';
+export declare function clone<T extends object>(obj: T, options?: merge.Options): T;

package/types/index.d.cts

@@ -0,0 +1,5 @@
+export * from './clone.js';
+export * from './is-built-in.js';
+export * from './is-object.js';
+export * from './merge.js';
+export * from './omit.js';

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './clone.js';
+export * from './is-built-in.js';
+export * from './is-object.js';
+export * from './merge.js';
+export * from './omit.js';

package/types/is-built-in.d.ts

@@ -0,0 +1 @@
+export declare function isBuiltIn(v: any): boolean;

package/types/is-object.d.ts

@@ -0,0 +1,2 @@
+export declare function isObject(v: any): boolean;
+export declare function isPlainObject(obj: any): boolean;

package/types/merge.d.ts

@@ -0,0 +1,39 @@
+export declare namespace merge {
+    type NodeCallback = (key: string | symbol, path: string, target: any, source: any) => boolean;
+    interface Options {
+        deep?: boolean | NodeCallback;
+        /**
+         */
+        moveArrays?: boolean | NodeCallback;
+        /**
+         * Do not overwrite existing properties if set true
+         * @default false
+         */
+        keepExisting?: boolean;
+        /**
+         * Copy property descriptors
+         * @default false
+         */
+        copyDescriptors?: boolean | NodeCallback;
+        /**
+         * Do not copy source field if callback returns true
+         */
+        ignore?: NodeCallback;
+        /**
+         * Ignore fields which values are "undefined"
+         * @default true
+         */
+        ignoreUndefined?: boolean;
+        /**
+         * Ignore fields which values are "null"
+         * @default false
+         */
+        ignoreNulls?: boolean;
+        /**
+         *
+         */
+        filter?: NodeCallback;
+    }
+}
+export declare function merge<A, B>(target: A, source: B, options?: merge.Options): A & B;
+export declare function getMergeFunction(options?: merge.Options): Function;

package/types/omit.d.ts

@@ -0,0 +1,4 @@
+import { DeeperOmitTypes } from 'ts-gems';
+export declare function omitUndefined<T>(obj: T, deep?: boolean): DeeperOmitTypes<T, undefined>;
+export declare function omitNull<T>(obj: T, deep?: boolean): DeeperOmitTypes<T, null>;
+export declare function omitNullish<T>(obj: T, deep?: boolean): DeeperOmitTypes<T, null | undefined>;