@ditojs/utils 1.20.0 → 1.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/utils",
-  "version": "1.20.0",
+  "version": "1.22.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",
@@ -29,11 +29,11 @@
     "ie_mob >= 11"
   ],
   "dependencies": {
-    "punycode": "^2.1.1"
+    "punycode": "^2.3.0"
   },
   "devDependencies": {
-    "typescript": "^4.9.3"
+    "typescript": "^4.9.4"
   },
   "types": "types",
-  "gitHead": "049aa3611927f3f096bc6230f0ce93e1419303e4"
+  "gitHead": "e1693edb8bf18e074606a842f2f2bacc1d2856cb"
 }

package/src/object/clone.js

@@ -1,9 +1,9 @@
 import {
   isArray, isObject, isDate, isRegExp, isFunction, isPromise
 } from '../base/index.js'
-import { pick } from '../object/index.js'
+import { pick } from './pick.js'
 
-export function clone(arg, options) {
+export function clone(value, options) {
   const {
     shallow = false,
     enumerable = true,
@@ -14,44 +14,58 @@ export function clone(arg, options) {
     ? { processValue: options } // TODO: `callback` deprecated in December 2022.
     : options || {}
 
-  const handleValue = value => shallow || transferables?.includes(value)
-    ? value
-    : clone(value, options)
+  const clones = new Map()
 
-  let copy = arg
-  if (isDate(arg)) {
-    copy = new arg.constructor(+arg)
-  } else if (isRegExp(arg)) {
-    copy = new arg.constructor(arg)
-  } else if (isArray(arg)) {
-    copy = new arg.constructor(arg.length)
-    for (let i = 0, l = arg.length; i < l; i++) {
-      copy[i] = handleValue(arg[i])
-    }
-  } else if (isObject(arg)) {
+  const storeClone = (value, copy) => {
+    clones.set(value, copy)
+    return copy
+  }
+
+  const handleValue = value => {
+    return shallow || transferables?.includes(value) ? value
+      : clones.has(value) ? clones.get(value)
+      : cloneValue(value)
+  }
+
+  const cloneValue = value => {
+    let copy = value
+    if (isDate(value)) {
+      copy = storeClone(value, new value.constructor(+value))
+    } else if (isRegExp(value)) {
+      copy = storeClone(value, new value.constructor(value))
+    } else if (isArray(value)) {
+      copy = storeClone(value, new value.constructor(value.length))
+      for (let i = 0, l = value.length; i < l; i++) {
+        copy[i] = handleValue(value[i])
+      }
+    } else if (isObject(value)) {
     // Rely on arg.clone() if it exists and assume it creates an actual clone.
-    if (isFunction(arg.clone)) {
-      copy = arg.clone(options)
-    } else if (isPromise(arg)) {
+      if (isFunction(value.clone)) {
+        copy = storeClone(value, value.clone(options))
+      } else if (isPromise(value)) {
       // https://stackoverflow.com/questions/37063293/can-i-clone-a-promise
-      copy = arg.then()
-    } else {
+        copy = storeClone(value, value.then())
+      } else {
       // 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))
-      const keys = enumerable ? Object.keys(arg) : Reflect.ownKeys(arg)
-      for (const key of keys) {
-        if (descriptors) {
-          const desc = Reflect.getOwnPropertyDescriptor(arg, key)
-          if (desc.value != null) {
-            desc.value = handleValue(desc.value)
+        copy = storeClone(value, Object.create(Object.getPrototypeOf(value)))
+        clones.set(value, copy)
+        const keys = enumerable ? Object.keys(value) : Reflect.ownKeys(value)
+        for (const key of keys) {
+          if (descriptors) {
+            const desc = Reflect.getOwnPropertyDescriptor(value, key)
+            if (desc.value != null) {
+              desc.value = handleValue(desc.value)
+            }
+            Reflect.defineProperty(copy, key, desc)
+          } else {
+            copy[key] = handleValue(value[key])
           }
-          Reflect.defineProperty(copy, key, desc)
-        } else {
-          copy[key] = handleValue(arg[key])
         }
       }
     }
+    return pick(processValue?.(copy), copy)
   }
-  return pick(processValue?.(copy), copy)
+
+  return cloneValue(value)
 }

package/src/object/clone.test.js

@@ -60,6 +60,22 @@ describe('clone()', () => {
     expect(copy).toStrictEqual({ b: 2 })
   })
 
+  it('should preserve identity', async () => {
+    const object = { a: { b: 1 } }
+    object.c = object.a
+    const copy = clone(object)
+    expect(copy).toEqual(object)
+    expect(copy.c).toBe(copy.a)
+  })
+
+  it('should handle circular references', async () => {
+    const object = { a: { b: 1 } }
+    object.c = object
+    const copy = clone(object)
+    expect(copy).toEqual(object)
+    expect(copy.c).toBe(copy)
+  })
+
   it('should handle non-enumerable properties', async () => {
     const object = { a: 1 }
     Object.defineProperty(object, 'b', { value: 2, enumerable: false })

package/types/index.d.ts

@@ -108,9 +108,32 @@ export function asFunction<T>(
 /* --------------------------------- object --------------------------------- */
 
 /**
- * Performs a deep (recursive) clone on the supplied value.
+ * Clones the supplied value.
  */
-export function clone<T>(arg: T, iteratee?: (arg: any) => void): T
+export function clone<T>(arg: T, options?: {
+  /**
+   * Wether to clone the value shallowly.
+   *
+   * @default false
+   */
+  shallow?: boolean,
+  /**
+   * Wether to clone all object properties, or only those that are defined
+   * directly on that object, and are not inherited from the object's prototype.
+   *
+   * @default true
+   */
+  enumerable?: boolean,
+  /**
+   * @default `true` if `options.enumerable` is true, `false` otherwise
+   */
+  descriptors?: boolean,
+  transferables?: any[],
+  /**
+   * Optional callback to process the cloned value.
+   */
+  processValue?: <S>(arg: T) => S,
+}): T
 
 /**
  * Determines whether the supplied values can be considered equal through