@superhero/deep 4.3.0 → 4.4.0

package/clone.js

@@ -1,21 +1,26 @@
-export default function clone(input) 
+export default function clone(input, options = {}) 
 {
   const seen = new WeakSet()
-  return deepClone(input, seen)
+
+  options.preservesImutable   = options.preservesImutable   ?? false
+  options.preservesEnumerable = options.preservesEnumerable ?? true
+  options.fallback            = options.fallback            ?? cloneFallback.bind(null, options, seen)
+
+  return deepClone(input, options, seen)
 }
 
-function deepClone(value, seen) 
+function deepClone(value, options, seen) 
 {
   switch(Object.prototype.toString.call(value))
   {
-    case '[object Array]'  : return cloneArray(value, seen)
-    case '[object Object]' : return cloneObject(value, seen)
+    case '[object Array]'  : return cloneArray(value, options, seen)
+    case '[object Object]' : return cloneObject(value, options, seen)
   }
 
-  return structuredClone(value)
+  return options.fallback(value)
 }
 
-function cloneArray(array, seen) 
+function cloneArray(array, options, seen) 
 {
   if(seen.has(array)) 
   {
@@ -23,10 +28,10 @@ function cloneArray(array, seen)
   }
 
   seen.add(array)
-  return array.map((item) => deepClone(item, seen))
+  return array.map((item) => deepClone(item, options, seen))
 }
 
-function cloneObject(obj, seen) 
+function cloneObject(obj, options, seen) 
 {
   if(seen.has(obj)) 
   {
@@ -39,10 +44,52 @@ function cloneObject(obj, seen)
 
   for(const key of Object.getOwnPropertyNames(obj)) 
   {
-    const descriptor = Object.getOwnPropertyDescriptor(obj, key)
-    Object.defineProperty(output, key, 
-      { ...descriptor, value : deepClone(descriptor.value, seen) })
+    if(options.preservesImutable)
+    {
+      const descriptor = Object.getOwnPropertyDescriptor(obj, key)
+      Object.defineProperty(output, key, 
+      { 
+        enumerable    : options.preservesEnumerable ? descriptor.enumerable : true,
+        writable      : descriptor.writable, 
+        configurable  : descriptor.configurable, 
+        value         : deepClone(descriptor.value, options, seen) 
+      })
+      continue
+    }
+    else if(options.preservesEnumerable)
+    {
+      const descriptor = Object.getOwnPropertyDescriptor(obj, key)
+      Object.defineProperty(output, key, 
+      { 
+        enumerable    : descriptor.enumerable, 
+        writable      : true, 
+        configurable  : true, 
+        value         : deepClone(descriptor.value, options, seen) 
+      })
+      continue
+    }
+    else
+    {
+      output[key] = deepClone(obj[key], options, seen)
+    }
   }
 
   return output
+}
+
+function cloneFallback(options, seen, value)
+{
+  if(typeof value !== 'object'
+  || value === null) 
+  {
+    return value
+  }
+
+  const clone = Object.create(Object.getPrototypeOf(value))
+  for(const key in value) 
+  {
+    clone[key] = deepClone(value[key], options, seen)
+  }
+
+  return clone
 }

package/clone.test.js

@@ -24,6 +24,32 @@ suite('@superhero/deep/clone', () =>
     assert.notStrictEqual(cloned.foo, obj.foo, 'Not the same reference as the original')
   })
 
+  test('Do not preserves descriptors', () =>
+  {
+    const origin = {}
+
+    Object.defineProperty(origin, 'foo', { value: {}, enumerable: true,  writable: true,  configurable: true  })
+    Object.defineProperty(origin, 'bar', { value: {}, enumerable: false, writable: true,  configurable: true  })
+    Object.defineProperty(origin, 'baz', { value: {}, enumerable: false, writable: false, configurable: true  })
+    Object.defineProperty(origin, 'qux', { value: {}, enumerable: false, writable: false, configurable: false })
+
+    const cloned = deepclone(origin, { preservesImutable: false, preservesEnumerable: false })
+
+    assert.notStrictEqual(cloned,     origin,     'Not the same reference as the original')
+    assert.notStrictEqual(cloned.foo, origin.foo, 'Cloned nested object should not share reference with the original')
+
+    const
+      clonedDescriptors = Object.getOwnPropertyDescriptors(cloned),
+      originDescriptors = Object.getOwnPropertyDescriptors(origin)
+
+    for(const key in originDescriptors)
+    {
+      assert.equal(clonedDescriptors[key].enumerable,    true)
+      assert.equal(clonedDescriptors[key].writable,      true)
+      assert.equal(clonedDescriptors[key].configurable,  true)
+    }
+  })
+
   test('Preserves descriptors', () =>
   {
     const origin = {}
@@ -33,7 +59,7 @@ suite('@superhero/deep/clone', () =>
     Object.defineProperty(origin, 'baz', { value: {}, enumerable: false, writable: false, configurable: true  })
     Object.defineProperty(origin, 'qux', { value: {}, enumerable: false, writable: false, configurable: false })
 
-    const cloned = deepclone(origin)
+    const cloned = deepclone(origin, { preservesImutable: true, preservesEnumerable: true })
 
     assert.deepStrictEqual(cloned,    origin,     'Cloned nested object should be equal to the original')
     assert.notStrictEqual(cloned,     origin,     'Not the same reference as the original')
@@ -51,6 +77,21 @@ suite('@superhero/deep/clone', () =>
     }
   })
 
+  test('Does not preserve frozen object state', () =>
+  {
+    const origin = { foo:'bar', baz: 42, qux: true }
+
+    Object.freeze(origin)
+
+    assert.ok(Object.isFrozen(origin), 'Origin object should be frozen')
+
+    const cloned = deepclone(origin)
+
+    assert.deepStrictEqual(cloned, origin, 'Cloned nested object should be equal to the original')
+    assert.notStrictEqual(cloned,  origin, 'Not the same reference as the original')
+    assert.ok(false === Object.isFrozen(cloned), 'Cloned object should not be frozen')
+  })
+
   test('Clones arrays', () =>
   {
     const 

package/merge.js

@@ -66,7 +66,7 @@ export default function merge(a, b, ...c)
 
   return c.length
   ? merge(output, ...c)
-  : deepclone(output)
+  : deepclone(output, { preservesImutable: true })
 }
 
 function mergeAandB(a, b, seen)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superhero/deep",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "A collection of deep structure operations",
   "keywords": ["deep", "assign", "clone", "freeze", "intersect", "merge"],
   "main": "index.js",