@ditojs/utils 1.14.0 → 1.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/utils",
-  "version": "1.14.0",
+  "version": "1.16.0",
   "type": "module",
   "description": "Dito.js Utility Functions – Dito.js is a declarative and modern web framework, based on Objection.js, Koa.js and Vue.js",
   "repository": "https://github.com/ditojs/dito/tree/master/packages/utils",
@@ -35,5 +35,5 @@
     "typescript": "^4.9.3"
   },
   "types": "types",
-  "gitHead": "ba197ae5254deb657b2c3b5dab7a851f488e022a"
+  "gitHead": "e7e7ddb88965dbffc29c0968054015a647844803"
 }

package/src/object/clone.js

@@ -3,7 +3,17 @@ import {
 } from '../base/index.js'
 import { pick } from '../object/index.js'
 
-export function clone(arg, callback = null) {
+export function clone(arg, options) {
+  const {
+    shallow = false,
+    enumerable = true,
+    processValue = null
+  } = isFunction(options)
+    ? { processValue: options } // TODO: `callback` deprecated in December 2022.
+    : options || {}
+
+  const handleValue = value => shallow ? value : clone(value, options)
+
   let copy = arg
   if (isDate(arg)) {
     copy = new arg.constructor(+arg)
@@ -12,12 +22,12 @@ export function clone(arg, callback = null) {
   } else if (isArray(arg)) {
     copy = new arg.constructor(arg.length)
     for (let i = 0, l = arg.length; i < l; i++) {
-      copy[i] = clone(arg[i], callback)
+      copy[i] = handleValue(arg[i])
     }
   } else if (isObject(arg)) {
     // Rely on arg.clone() if it exists and assume it creates an actual clone.
     if (isFunction(arg.clone)) {
-      copy = arg.clone()
+      copy = arg.clone(options)
     } else if (isPromise(arg)) {
       // https://stackoverflow.com/questions/37063293/can-i-clone-a-promise
       copy = arg.then()
@@ -25,10 +35,15 @@ export function clone(arg, callback = null) {
       // Prevent calling the actual constructor since it is not guaranteed to
       // work as intended here, and only clone the non-inherited own properties.
       copy = Object.create(Object.getPrototypeOf(arg))
-      for (const key of Object.keys(arg)) {
-        copy[key] = clone(arg[key], callback)
+      const keys = enumerable ? Object.keys(arg) : Reflect.ownKeys(arg)
+      for (const key of keys) {
+        const desc = Reflect.getOwnPropertyDescriptor(arg, key)
+        if (desc.value != null) {
+          desc.value = handleValue(desc.value)
+        }
+        Reflect.defineProperty(copy, key, desc)
       }
     }
   }
-  return pick(callback?.(copy), copy)
+  return pick(processValue?.(copy), copy)
 }

package/src/object/clone.test.js

@@ -44,6 +44,12 @@ describe('clone()', () => {
     expect(copy.b).not.toBe(object.b)
   })
 
+  it('should support shallow-cloning', () => {
+    const object = { a: [1, 2, 3] }
+    const copy = clone(object, { shallow: true })
+    expect(object.a).toBe(copy.a)
+  })
+
   it('should use clone() methods if available', () => {
     const object = {
       a: 1,
@@ -54,14 +60,24 @@ describe('clone()', () => {
     expect(copy).toStrictEqual({ b: 2 })
   })
 
-  it('should transform cloned values by `callback`', () => {
+  it('should handle non-enumerable properties', async () => {
+    const object = { a: 1 }
+    Object.defineProperty(object, 'b', { value: 2, enumerable: false })
+    const copy = clone(object, { enumerable: false })
+    expect(copy.a).toEqual(1)
+    expect(copy.b).toEqual(2)
+  })
+
+  it('should transform cloned values by `processValue`', () => {
     const object = {
       a: { b: 1, c: 2 },
       d: { e: 3, f: 4 }
     }
-    const copy = clone(object, value => {
-      if (typeof value === 'object') {
-        value.g = 5
+    const copy = clone(object, {
+      processValue: value => {
+        if (typeof value === 'object') {
+          value.g = 5
+        }
       }
     })
     const expected = {
@@ -72,14 +88,16 @@ describe('clone()', () => {
     expect(copy).toStrictEqual(expected)
   })
 
-  it('should call `callback` after cloning all children', () => {
+  it('should call `processValue` after cloning all children', () => {
     const array = [
       { a: 1, b: 2 },
       { a: 3, b: 4 }
     ]
-    const copy = clone(array, value => {
-      if (typeof value === 'object') {
-        delete value.b
+    const copy = clone(array, {
+      processValue: value => {
+        if (typeof value === 'object') {
+          delete value.b
+        }
       }
     })
     const expected = [