@superhero/deep 4.1.0 → 4.2.0

package/README.md

@@ -145,63 +145,66 @@ npm test
 
 ```
 ▶ @superhero/deep/assign
-  ✔ Assigns arrays correctly (1.993351ms)
-  ✔ Assigns objects correctly (0.797187ms)
-  ✔ Overwrites non-object properties correctly (0.311862ms)
-  ✔ Handles undefined values correctly (0.67959ms)
+  ✔ Assigns arrays correctly (3.167398ms)
+  ✔ Assigns objects correctly (0.763768ms)
+  ✔ Overwrites non-object properties correctly (0.347727ms)
+  ✔ Handles undefined values correctly (0.521744ms)
+
   ▶ Descriptor properties
     ▶ Retains
-      ✔ non-writable, non-configurable and non-enumarable (0.365558ms)
-      ✔ writable but non-configurable and non-enumarable (0.384859ms)
-      ✔ writable and configurable but non-enumarable (0.24546ms)
-    ✔ Retains (1.395563ms)
+      ✔ non-writable, non-configurable and non-enumarable (0.474666ms)
+      ✔ writable but non-configurable and non-enumarable (0.649244ms)
+      ✔ writable and configurable but non-enumarable (0.298073ms)
+    ✔ Retains (1.918778ms)
+
     ▶ Assigns
-      ✔ non-writable, non-configurable and non-enumarable (0.246451ms)
-    ✔ Assigns (0.528402ms)
-  ✔ Descriptor properties (2.438803ms)
-  ✔ Merges nested arrays correctly (1.67104ms)
-  ✔ Merges nested objects correctly (0.649403ms)
-  ✔ Does not alter objects with no conflicts (0.219023ms)
-✔ @superhero/deep/assign (10.784739ms)
+      ✔ non-writable, non-configurable and non-enumarable (0.485428ms)
+    ✔ Assigns (0.889839ms)
+  ✔ Descriptor properties (3.74915ms)
+  
+  ✔ Merges nested arrays correctly (1.898073ms)
+  ✔ Merges nested objects correctly (0.761838ms)
+  ✔ Does not alter objects with no conflicts (0.277694ms)
+✔ @superhero/deep/assign (14.053485ms)
 
 ▶ @superhero/deep/clone
-  ✔ Clones simple objects (3.898407ms)
-  ✔ Clones nested objects (0.358366ms)
-  ✔ Clones arrays (0.347023ms)
-  ✔ Handles circular references (0.190668ms)
-  ✔ Clones objects with null prototype (0.302189ms)
-✔ @superhero/deep/clone (6.720191ms)
+  ✔ Clones simple objects (7.235299ms)
+  ✔ Clones nested objects (0.634553ms)
+  ✔ Clones arrays (0.650244ms)
+  ✔ Handles circular references (0.382144ms)
+  ✔ Clones objects with null prototype (0.375334ms)
+✔ @superhero/deep/clone (11.89498ms)
 
 ▶ @superhero/deep/freeze
-  ✔ Freezes a simple object (2.561531ms)
-  ✔ Freezes nested objects recursively (0.357866ms)
-  ✔ Handles circular references gracefully (0.308297ms)
-  ✔ Freezes objects with symbols (0.210516ms)
-  ✔ Handles already frozen objects without error (0.157051ms)
-  ✔ Freezes objects with non-enumerable properties (0.214033ms)
-  ✔ Freezes arrays (0.244445ms)
-  ✔ Handles objects with null prototype (0.337528ms)
-  ✔ Freezes objects with multiple property types (0.525787ms)
-✔ @superhero/deep/freeze (7.261487ms)
+  ✔ Freezes a simple object (3.683567ms)
+  ✔ Freezes nested objects recursively (0.406919ms)
+  ✔ Handles circular references gracefully (0.309979ms)
+  ✔ Freezes objects with symbols (0.405137ms)
+  ✔ Handles already frozen objects without error (0.337038ms)
+  ✔ Freezes objects with non-enumerable properties (0.354681ms)
+  ✔ Freezes arrays (0.662049ms)
+  ✔ Handles objects with null prototype (0.387428ms)
+  ✔ Freezes objects with multiple property types (0.626902ms)
+✔ @superhero/deep/freeze (10.607326ms)
 
 ▶ @superhero/deep
-  ✔ All functions are accessible as a member to the default import object (1.250244ms)
-  ✔ All functions are accessible to import from the default import object (0.23689ms)
-✔ @superhero/deep (3.080305ms)
+  ✔ All functions are accessible as a member to the default import object (1.734551ms)
+  ✔ All functions are accessible to import from the default import object (0.255022ms)
+✔ @superhero/deep (5.188429ms)
 
 ▶ @superhero/deep/merge
-  ✔ Merges arrays with unique values (3.122153ms)
-  ✔ Merges arrays with order preserved (0.298964ms)
-  ✔ Handles empty arrays correctly (0.275066ms)
-  ✔ Handles arrays with duplicate values (0.492229ms)
-  ✔ Merges objects and prioritizes restrictive descriptors (0.623443ms)
-  ✔ Merges objects with non-enumerable properties (0.342317ms)
-  ✔ Handles nested object merging (0.43726ms)
-  ✔ Stops at circular references (0.827394ms)
-  ✔ Stops when nested and with circular references (0.720571ms)
-  ✔ Returns second value for non-object types (0.925228ms)
-  ✔ Handles multiple merges sequentially (0.359582ms)
-✔ @superhero/deep/merge (12.298476ms)
+  ✔ Merges arrays with unique values (3.271451ms)
+  ✔ Merges arrays with order preserved (0.455376ms)
+  ✔ Handles empty arrays correctly (0.283857ms)
+  ✔ Handles arrays with duplicate values (0.538911ms)
+  ✔ Merges objects and prioritizes restrictive descriptors (0.592729ms)
+  ✔ Merges objects with non-enumerable properties (0.343159ms)
+  ✔ Handles nested object merging (0.359878ms)
+  ✔ Stops at circular references (0.554345ms)
+  ✔ Stops when nested and with circular references (0.667265ms)
+  ✔ Returns second value for non-object types (0.744991ms)
+  ✔ Handles multiple merges sequentially (0.327608ms)
+✔ @superhero/deep/merge (11.803686ms)
 
 tests 38
 suites 8
@@ -212,8 +215,8 @@ file             | line % | branch % | funcs % | uncovered lines
 -----------------------------------------------------------------
 assign.js        | 100.00 |   100.00 |  100.00 | 
 assign.test.js   | 100.00 |   100.00 |  100.00 | 
-clone.js         | 100.00 |   100.00 |  100.00 | 
-clone.test.js    |  96.34 |    87.50 |  100.00 | 56-58
+clone.js         |  95.83 |    92.86 |  100.00 | 22-23
+clone.test.js    | 100.00 |   100.00 |  100.00 | 
 freeze.js        | 100.00 |   100.00 |  100.00 | 
 freeze.test.js   | 100.00 |   100.00 |  100.00 | 
 index.js         | 100.00 |   100.00 |  100.00 | 
@@ -221,7 +224,7 @@ index.test.js    | 100.00 |   100.00 |  100.00 |
 merge.js         | 100.00 |   100.00 |  100.00 | 
 merge.test.js    | 100.00 |   100.00 |  100.00 | 
 -----------------------------------------------------------------
-all files        |  99.66 |    99.19 |  100.00 | 
+all files        |  99.78 |    99.25 |  100.00 | 
 -----------------------------------------------------------------
 ```
 

package/clone.js

@@ -1,6 +1,48 @@
-export default function clone(a, legacy = false)
+export default function clone(input) 
 {
-  return structuredClone && false === legacy
-        ? structuredClone(a)
-        : JSON.parse(JSON.stringify(a))
+  const seen = new WeakSet()
+  return deepClone(input, seen)
+}
+
+function deepClone(value, seen) 
+{
+  switch(Object.prototype.toString.call(value))
+  {
+    case '[object Array]'  : return cloneArray(value, seen)
+    case '[object Object]' : return cloneObject(value, seen)
+  }
+
+  return structuredClone(value)
+}
+
+function cloneArray(array, seen) 
+{
+  if(seen.has(array)) 
+  {
+    return array
+  }
+
+  seen.add(array)
+  return array.map((item) => deepClone(item, seen))
+}
+
+function cloneObject(obj, seen) 
+{
+  if(seen.has(obj)) 
+  {
+    return obj
+  }
+
+  seen.add(obj)
+
+  const output = {}
+
+  for(const key of Object.getOwnPropertyNames(obj)) 
+  {
+    const descriptor = Object.getOwnPropertyDescriptor(obj, key)
+    Object.defineProperty(output, key, 
+      { ...descriptor, value : deepClone(descriptor.value, seen) })
+  }
+
+  return output
 }

package/clone.test.js

@@ -8,75 +8,76 @@ suite('@superhero/deep/clone', () =>
   {
     const 
       obj     = { foo: 'bar', baz: 42 },
-      result  = deepclone(obj),
-      legacy  = deepclone(obj, true)
+      cloned  = deepclone(obj)
 
-    assert.deepStrictEqual(result, obj, 'Cloned object should be equal to the original')
-    assert.deepStrictEqual(legacy, obj, 'Cloned object should be equal to the original (legacy mode)')
-
-    assert.notStrictEqual(result, obj, 'Cloned object should not be the same reference as the original')
-    assert.notStrictEqual(legacy, obj, 'Cloned object should not be the same reference as the original (legacy mode)')
+    assert.deepStrictEqual(cloned, obj, 'Cloned object should be equal to the original')
+    assert.notStrictEqual(cloned, obj, 'Not the same reference as the original')
   })
 
   test('Clones nested objects', () =>
   {
-    const obj = { foo: { bar: { baz: 'qux' } } }
-
     const 
-      result = deepclone(obj),
-      legacy = deepclone(obj, true)
+      obj     = { foo: { bar: { baz: 'qux' } } },
+      cloned  = deepclone(obj)
+
+    assert.deepStrictEqual(cloned, obj, 'Cloned nested object should be equal to the original')
+    assert.notStrictEqual(cloned.foo, obj.foo, 'Not the same reference as the original')
+  })
+
+  test('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)
+
+    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.notStrictEqual(cloned.foo, origin.foo, 'Cloned nested object should not share reference with the original')
 
-    assert.deepStrictEqual(result, obj, 'Cloned nested object should be equal to the original')
-    assert.deepStrictEqual(legacy, obj, 'Cloned nested object should be equal to the original (legacy mode)')
+    const
+      clonedDescriptors = Object.getOwnPropertyDescriptors(cloned),
+      originDescriptors = Object.getOwnPropertyDescriptors(origin)
 
-    assert.notStrictEqual(result.foo, obj.foo, 'Cloned nested object should not share reference with the original')
-    assert.notStrictEqual(legacy.foo, obj.foo, 'Cloned nested object should not share reference with the original (legacy mode)')
+    for(const key in originDescriptors)
+    {
+      assert.equal(clonedDescriptors[key].enumerable,    originDescriptors[key].enumerable)
+      assert.equal(clonedDescriptors[key].writable,      originDescriptors[key].writable)
+      assert.equal(clonedDescriptors[key].configurable,  originDescriptors[key].configurable)
+    }
   })
 
   test('Clones arrays', () =>
   {
-    const arr = [1, 2, 3, [4, 5]]
-
     const 
-      result = deepclone(arr),
-      legacy = deepclone(arr, true)
+      array   = [1, 2, 3, [4, 5]],
+      cloned  = deepclone(array)
 
-    assert.deepStrictEqual(result, arr, 'Cloned array should be equal to the original')
-    assert.deepStrictEqual(legacy, arr, 'Cloned array should be equal to the original (legacy mode)')
+    assert.deepStrictEqual(cloned, array, 'Cloned array should be equal to the original')
+    assert.notStrictEqual(cloned, array, 'Not the same reference as the original')
+    assert.notStrictEqual(cloned[3], array[3], 'Nested array in clone should not share reference with the original')
+  })
 
-    assert.notStrictEqual(result, arr, 'Cloned array should not share reference with the original')
-    assert.notStrictEqual(legacy, arr, 'Cloned array should not share reference with the original (legacy mode)')
+  test('Handles circular references', () =>
+  {
+    const obj = {}
+    obj.self = obj
 
-    assert.notStrictEqual(result[3], arr[3], 'Nested array in clone should not share reference with the original')
-    assert.notStrictEqual(legacy[3], arr[3], 'Nested array in clone should not share reference with the original (legacy mode)')
+    const cloned = deepclone(obj)
+    assert.strictEqual(cloned.self, obj, 'Circular references should be preserved in the clone')
   })
 
-  if(false === !!structuredClone)
-  {
-    test.skip('Handles circular references (structuredClone not available)')
-    test.skip('Clones objects with null prototype (structuredClone not available)')
-  }
-  else
+  test('Clones objects with null prototype', () =>
   {
-    test('Handles circular references', () =>
-    {
-      const obj = {}
-      obj.self = obj
-  
-      const result = deepclone(obj)
-  
-      assert.strictEqual(result.self, result, 'Circular references should be preserved in the clone')
-    })
-  
-    test('Clones objects with null prototype', () =>
-    {
-      const obj = Object.create(null)
-      obj.foo = 'bar'
-  
-      const result = deepclone(obj)
-  
-      assert.deepEqual(result, obj, 'Cloned object with null prototype should be equal to the original')
-      assert.notStrictEqual(result, obj, 'Cloned object with null prototype should not share reference with the original')
-    })
-  }
+    const obj = Object.create(null)
+    obj.foo = 'bar'
+
+    const cloned = deepclone(obj)
+    assert.deepEqual(cloned, obj, 'Cloned object with null prototype should be equal to the original')
+    assert.notStrictEqual(cloned, obj, 'Not the same reference as the original')
+  })
 })

package/package.json

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