bunshin-clone 1.2.0 → 1.2.2

package/README.md

@@ -2,14 +2,6 @@
 
 High-performance deep clone utility with descriptor support. Handles circular ref and complex built-in types.
 
-* Fast (no unnecessary overhead)
-* Deep clone (no structural sharing)
-* Supports circular ref
-* Handles Map, Set, Array, TypedArray, Date, RegExp, etc.
-* Optional descriptor preservation
-
----
-
 ## Install
 
 ```bash
@@ -28,7 +20,7 @@ import bunshinClone from 'https://cdn.jsdelivr.net/npm/bunshin-clone/+esm';
 import bunshinClone from 'https://unpkg.com/bunshin-clone/dist/index.js';
 ```
 
-## Usage
+## 📦 APIs
 
 ```ts
 bunshinClone(source, options);
@@ -38,7 +30,7 @@ bunshinClone(source, options);
 // options (optional): BunshinCloneOptions
 ```
 
-### 🪄 Options
+## 🪄 Options
 
 ```ts
 interface BunshinCloneOptions {
@@ -47,47 +39,20 @@ interface BunshinCloneOptions {
 }
 ```
 
-**preserveDescriptors**
+### `preserveDescriptors`
 
-* `false`: use standard merge (faster, ignores property descriptors)
-* `true`: preserve property descriptors (getters/setters, etc.)
+If `true`, preserves property descriptors (getters/setters, etc.).
 
-<details>
-<summary>Example</summary>
+### `strictDescriptors`
 
-```ts
-const source = {};
-Object.defineProperty(source, 'x', {
-  get: () => 42,
-  enumerable: true,
-});
+If `true`, throws if descriptor cannot be merged (e.g. non-configurable or non-writable)
 
-const result = bunshinClone(source, { preserveDescriptors: true });
-
-Object.getOwnPropertyDescriptor(result, 'x')?.get;
-// => function
-```
-</details>
-
-**strictDescriptors**
-
-* `false`: skip incompatible descriptors
-* `true`: throw if descriptor cannot be merged (e.g. non-configurable or non-writable)
+## 📖 Details
 
 <details>
-<summary>Example</summary>
+<summary>Read more</summary>
 
-```ts
-Object.freeze(obj);
-
-bunshinClone(obj, { strictDescriptors: true });
-// => may throw TypeError
-```
-</details>
-
----
-
-## Example
+### Example
 
 ```ts
 const source = { foo: 1, nested: { x: 1 } };
@@ -101,7 +66,7 @@ console.log(result === source); // false
 console.log(result.nested === source.nested); // false
 ```
 
-## Supported Types
+### Supported Types
 
 bunshin-clone correctly handles:
 
@@ -120,7 +85,7 @@ bunshin-clone correctly handles:
 * URL
 * URLSearchParams
 
-## Circular ref
+### Circular ref
 
 ```ts
 const a: any = { x: 1 };
@@ -131,9 +96,9 @@ const result = bunshinClone(a);
 result.self === result; // true
 ```
 
-## Descriptor Behavior
+### Descriptor Behavior
 
-### Default (fast path)
+#### Default (fast path)
 
 ```ts
 const source = {
@@ -148,7 +113,7 @@ result.x; // 42
 // getter is NOT preserved
 ```
 
-### preserveDescriptors: true
+#### preserveDescriptors: true
 
 ```ts
 const source = {};
@@ -165,7 +130,7 @@ Object.getOwnPropertyDescriptor(result, 'x')?.get;
 // => preserved
 ```
 
-### Unsupported / Pass-through Types
+#### Unsupported / Pass-through Types
 
 Some values are returned as-is:
 
@@ -180,9 +145,9 @@ const fn = () => {};
 bunshinClone(fn) === fn; // true
 ```
 
-## Design Notes
+### Design Notes
 
-### Deep clone (no structural sharing)
+#### Deep clone (no structural sharing)
 
 Unlike merge utilities, bunshin-clone always produces a new structure:
 
@@ -195,12 +160,12 @@ result !== source; // true
 result.a !== source.a; // true
 ```
 
-### Getter / Setter behavior
+#### Getter / Setter behavior
 
 * Default: evaluated and converted to value
 * preserveDescriptors: preserved as-is
 
-### Descriptor safety
+#### Descriptor safety
 
 When `preserveDescriptors` is enabled:
 
@@ -208,14 +173,14 @@ When `preserveDescriptors` is enabled:
 * original object is never mutated
 * errors are controlled via `strictDescriptors`
 
-## Performance
+### Performance
 
 * No proxy / no diffing
 * Minimal branching
 * Fast path for plain objects and arrays
 * Competitive with structuredClone in many cases
 
-## Comparison
+### Comparison
 
 | Feature              | Bunshin Clone | structuredClone | lodash.clonedeep |
 |---------------------|--------------|----------------|------------------|
@@ -227,3 +192,5 @@ When `preserveDescriptors` is enabled:
 | Prototype preserved | ✅           | ❌             | ⚠️               |
 | Custom control      | ✅           | ❌             | ❌               |
 | Performance         | ⚡ fast       | ⚡ fast         | 🐢 slower        |
+
+</details>

package/dist/index.cjs

@@ -1,34 +1,10 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 // src/index.ts
 var EMPTY_OPTIONS = {};
 var { hasOwnProperty: HAS_OWN } = Object.prototype;
-function bunshinClone(source, options) {
-  return clone(source, options ?? EMPTY_OPTIONS, /* @__PURE__ */ new WeakMap());
-}
-function cloneWithDescriptors(node, options, refs) {
-  const result = Object.create(Object.getPrototypeOf(node));
-  refs.set(node, result);
-  const descs = Object.getOwnPropertyDescriptors(node);
-  forEachOwnKey(descs, (key) => {
-    if (isUnsafeKey(key)) {
-      return;
-    }
-    const desc = { ...descs[key] };
-    if ("value" in desc) {
-      desc.value = clone(desc.value, options, refs);
-    }
-    try {
-      Object.defineProperty(result, key, desc);
-    } catch (error) {
-      if (options.strictDescriptors) {
-        throw error;
-      }
-    }
-  });
-  return result;
+function bunshinClone(source, options, refs) {
+  return clone(source, options ?? EMPTY_OPTIONS, refs ?? /* @__PURE__ */ new WeakMap());
 }
 function clone(node, options, refs) {
   if (!isObject(node)) {
@@ -184,6 +160,28 @@ function cloneError(value, options, refs) {
   }
   return result;
 }
+function cloneWithDescriptors(node, options, refs) {
+  const result = Object.create(Object.getPrototypeOf(node));
+  refs.set(node, result);
+  const descs = Object.getOwnPropertyDescriptors(node);
+  forEachOwnKey(descs, (key) => {
+    if (isUnsafeKey(key)) {
+      return;
+    }
+    const desc = { ...descs[key] };
+    if ("value" in desc) {
+      desc.value = clone(desc.value, options, refs);
+    }
+    try {
+      Object.defineProperty(result, key, desc);
+    } catch (error) {
+      if (options.strictDescriptors) {
+        throw error;
+      }
+    }
+  });
+  return result;
+}
 function forEachOwnKey(object, fn) {
   for (const key of Object.keys(object)) {
     fn(key);
@@ -211,12 +209,11 @@ function isUnsafeKey(key) {
  * High-performance deep clone utility with descriptor support.
  * Handles circular ref and complex built-in types.
  *
- * @version 1.2.0
+ * @version 1.2.2
  * @author Yusuke Kamiyamane
  * @license MIT
  * @copyright Copyright (c) Yusuke Kamiyamane
  * @see {@link https://github.com/y14e/bunshin-clone}
  */
 
-exports.cloneWithDescriptors = cloneWithDescriptors;
-exports.default = bunshinClone;
+module.exports = bunshinClone;

package/dist/index.d.cts

@@ -3,7 +3,7 @@
  * High-performance deep clone utility with descriptor support.
  * Handles circular ref and complex built-in types.
  *
- * @version 1.2.0
+ * @version 1.2.2
  * @author Yusuke Kamiyamane
  * @license MIT
  * @copyright Copyright (c) Yusuke Kamiyamane
@@ -13,9 +13,7 @@ interface BunshinCloneOptions {
     readonly preserveDescriptors?: boolean;
     readonly strictDescriptors?: boolean;
 }
-type Object$1 = Record<PropertyKey, unknown>;
 type Refs = WeakMap<object, unknown>;
-declare function bunshinClone<T>(source: T, options?: BunshinCloneOptions): T;
-declare function cloneWithDescriptors<T extends Object$1>(node: T, options: BunshinCloneOptions, refs: Refs): T;
+declare function bunshinClone<T>(source: T, options?: BunshinCloneOptions, refs?: Refs): T;
 
-export { type BunshinCloneOptions, cloneWithDescriptors, bunshinClone as default };
+export { type BunshinCloneOptions, bunshinClone as default };

package/dist/index.d.ts

@@ -3,7 +3,7 @@
  * High-performance deep clone utility with descriptor support.
  * Handles circular ref and complex built-in types.
  *
- * @version 1.2.0
+ * @version 1.2.2
  * @author Yusuke Kamiyamane
  * @license MIT
  * @copyright Copyright (c) Yusuke Kamiyamane
@@ -13,9 +13,7 @@ interface BunshinCloneOptions {
     readonly preserveDescriptors?: boolean;
     readonly strictDescriptors?: boolean;
 }
-type Object$1 = Record<PropertyKey, unknown>;
 type Refs = WeakMap<object, unknown>;
-declare function bunshinClone<T>(source: T, options?: BunshinCloneOptions): T;
-declare function cloneWithDescriptors<T extends Object$1>(node: T, options: BunshinCloneOptions, refs: Refs): T;
+declare function bunshinClone<T>(source: T, options?: BunshinCloneOptions, refs?: Refs): T;
 
-export { type BunshinCloneOptions, cloneWithDescriptors, bunshinClone as default };
+export { type BunshinCloneOptions, bunshinClone as default };

package/dist/index.js

@@ -1,30 +1,8 @@
 // src/index.ts
 var EMPTY_OPTIONS = {};
 var { hasOwnProperty: HAS_OWN } = Object.prototype;
-function bunshinClone(source, options) {
-  return clone(source, options ?? EMPTY_OPTIONS, /* @__PURE__ */ new WeakMap());
-}
-function cloneWithDescriptors(node, options, refs) {
-  const result = Object.create(Object.getPrototypeOf(node));
-  refs.set(node, result);
-  const descs = Object.getOwnPropertyDescriptors(node);
-  forEachOwnKey(descs, (key) => {
-    if (isUnsafeKey(key)) {
-      return;
-    }
-    const desc = { ...descs[key] };
-    if ("value" in desc) {
-      desc.value = clone(desc.value, options, refs);
-    }
-    try {
-      Object.defineProperty(result, key, desc);
-    } catch (error) {
-      if (options.strictDescriptors) {
-        throw error;
-      }
-    }
-  });
-  return result;
+function bunshinClone(source, options, refs) {
+  return clone(source, options ?? EMPTY_OPTIONS, refs ?? /* @__PURE__ */ new WeakMap());
 }
 function clone(node, options, refs) {
   if (!isObject(node)) {
@@ -180,6 +158,28 @@ function cloneError(value, options, refs) {
   }
   return result;
 }
+function cloneWithDescriptors(node, options, refs) {
+  const result = Object.create(Object.getPrototypeOf(node));
+  refs.set(node, result);
+  const descs = Object.getOwnPropertyDescriptors(node);
+  forEachOwnKey(descs, (key) => {
+    if (isUnsafeKey(key)) {
+      return;
+    }
+    const desc = { ...descs[key] };
+    if ("value" in desc) {
+      desc.value = clone(desc.value, options, refs);
+    }
+    try {
+      Object.defineProperty(result, key, desc);
+    } catch (error) {
+      if (options.strictDescriptors) {
+        throw error;
+      }
+    }
+  });
+  return result;
+}
 function forEachOwnKey(object, fn) {
   for (const key of Object.keys(object)) {
     fn(key);
@@ -207,11 +207,11 @@ function isUnsafeKey(key) {
  * High-performance deep clone utility with descriptor support.
  * Handles circular ref and complex built-in types.
  *
- * @version 1.2.0
+ * @version 1.2.2
  * @author Yusuke Kamiyamane
  * @license MIT
  * @copyright Copyright (c) Yusuke Kamiyamane
  * @see {@link https://github.com/y14e/bunshin-clone}
  */
 
-export { cloneWithDescriptors, bunshinClone as default };
+export { bunshinClone as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunshin-clone",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "High-performance deep clone utility with descriptor support",
   "type": "module",
   "main": "./dist/index.cjs",