@sequencemedia/dupe 0.0.2 → 0.0.3

package/README.md

@@ -4,6 +4,38 @@ Produces a duplicate (or deep clone) of an object or array, preserving circular
 
 Primitives are returned as-is
 
-There is no special effort to identify `Buffer` or `ArrayBuffer` or typed arrays _etc_ in this version
+```javascript
+import dupe from '@sequencemedia/dupe'
 
-For most values `structuredClone` is preferable, except where there are or may be functions involved
+const a = [1, 2, 3]
+
+a.push(a)
+
+const o = { a: 4, b: 5, c: 6, func () { } }
+
+o.o = o
+
+a.push(o)
+
+const array = dupe(a)
+```
+
+These types as well as `Buffer` instances can be duplicated using `@sequencemedia/dupe/node`
+
+```javascript
+import dupe from '@sequencemedia/dupe/node'
+
+const a = [1, 2, 3, Buffer.from('x')]
+
+a.push(a)
+
+const o = { a: 4, b: 5, c: 6, func () { }, buff: Buffer.from('y') }
+
+o.o = o
+
+a.push(o)
+
+const array = dupe(a)
+```
+
+For most values (i.e., except functions) `structuredClone` is preferable

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@sequencemedia/dupe",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "keywords": [
     "dupe",
     "duplicate",
     "clone",
     "deep clone",
-    "deep"
+    "deep",
+    "structured clone"
   ],
-  "main": "./index.mjs",
+  "main": "./src/index.mjs",
   "type": "module",
-  "types": "./index.d.mts",
+  "types": "./src/index.d.mts",
   "author": {
     "name": "Jonathan Perry for Sequence Media Limited",
     "email": "sequencemedia@sequencemedia.net",
@@ -42,7 +43,12 @@
     "globals": "^15.13.0",
     "husky": "^9.1.7"
   },
+  "imports": {
+    "#dupe": "./src/index.mjs",
+    "#dupe/node": "./src/node/index.mjs"
+  },
   "exports": {
-    ".": "./index.mjs"
+    ".": "./src/index.mjs",
+    "./node": "./src/node/index.mjs"
   }
 }

package/src/index.d.mts

@@ -0,0 +1,6 @@
+type ArrayLiteralType = unknown[] | never[]
+type ObjectLiteralType = Record<PropertyKey, unknown> | Record<PropertyKey, never>
+
+type ValueType = string | number | ArrayLiteralType | ObjectLiteralType | null | undefined
+
+export default function dupe (v: ValueType | ValueType[]): ValueType | ValueType[]

package/src/index.mjs

@@ -0,0 +1,147 @@
+/**
+ * @typedef {unknown[] | never[]} ArrayLiteralType
+ *
+ * @typedef {Record<PropertyKey, unknown> | Record<PropertyKey, never>} ObjectLiteralType
+ *
+ * @typedef {string | number | ArrayLiteralType | ObjectLiteralType | null | undefined} ValueType
+ *
+ * @typedef {WeakMap<WeakKey, ArrayLiteralType | ObjectLiteralType>} WeakMapType
+ */
+
+/**
+ * @param {ValueType | ValueType[]} v
+ * @returns {boolean}
+ */
+export function isArray (v) {
+  return Array.isArray(v)
+}
+
+/**
+ * @param {ValueType | ValueType[]} v
+ * @returns {boolean}
+ */
+export function isObject (v) {
+  return (v || false) instanceof Object && !Array.isArray(v)
+}
+
+/**
+ * @param {ValueType | ValueType[]} v
+ * @returns {boolean}
+ */
+export function isFunction (v) {
+  return v instanceof Function
+}
+/**
+ * @param {ValueType | ValueType[]} v
+ * @returns {boolean}
+ */
+function isPrimitive (v) {
+  return !(
+    isObject(v) ||
+    isArray(v) ||
+    isFunction(v)
+  )
+}
+
+/**
+ * @param {ArrayLiteralType} v
+ * @param {WeakMapType} weakMap
+ * @returns {ArrayLiteralType}
+ */
+function getArray (v, weakMap) {
+  const a = []
+
+  weakMap.set(v, a)
+
+  return v.reduce(getReduceArray(weakMap), a)
+}
+
+/**
+ * @param {ObjectLiteralType} v
+ * @param {WeakMapType} weakMap
+ * @returns {ObjectLiteralType}
+ */
+function getObject (v, weakMap) {
+  const o = {}
+
+  weakMap.set(v, o)
+
+  return Object.assign(o, Object.fromEntries(Object.entries(v).map(getMapEntries(weakMap))))
+}
+
+/**
+ * @param {WeakMapType} weakMap
+ * @returns {(a: ArrayLiteralType, v: ValueType | ValueType[]) => ArrayLiteralType}
+ */
+function getReduceArray (weakMap) {
+  /**
+   * @param {ArrayLiteralType} a
+   * @param {ValueType | ValueType[]} v
+   * @returns {ArrayLiteralType}
+   */
+  return function reduceArray (a, v) {
+    if (isPrimitive(v) || isFunction(v)) {
+      a.push(v)
+      return a
+    }
+
+    if (weakMap.has(v)) {
+      a.push(weakMap.get(v))
+      return a
+    }
+
+    if (isArray(v)) {
+      a.push(getArray(v, weakMap))
+      return a
+    }
+
+    if (isObject(v)) {
+      a.push(getObject(v, weakMap))
+      return a
+    }
+  }
+}
+
+/**
+ * @param {WeakMapType} weakMap
+ * @returns {(entry: [PropertyKey, ValueType | ValueType[]]) => [PropertyKey, ValueType | ValueType[]]}
+ */
+function getMapEntries (weakMap) {
+  /**
+   * @param {[PropertyKey, ValueType | ValueType[]]} entry
+   * @returns {[PropertyKey, ValueType | ValueType[]]}
+   */
+  return function mapEntries ([k, v]) {
+    if (isPrimitive(v) || isFunction(v)) return [k, v]
+
+    if (weakMap.has(v)) {
+      return [k, weakMap.get(v)]
+    }
+
+    if (isArray(v)) {
+      return [k, getArray(v, weakMap)]
+    }
+
+    if (isObject(v)) {
+      return [k, getObject(v, weakMap)]
+    }
+  }
+}
+
+/**
+ * Duplicate a value
+ *
+ * @param {ValueType | ValueType[]} v
+ * @returns {ValueType | ValueType[]}
+ */
+export default function toDuplicate (v) {
+  if (isPrimitive(v) || isFunction(v)) return v
+
+  if (isArray(v)) {
+    return getArray(v, new WeakMap())
+  }
+
+  if (isObject(v)) {
+    return getObject(v, new WeakMap())
+  }
+}

package/{index.mjs → src/node/index.mjs}

@@ -32,6 +32,14 @@ function isFunction (v) {
   return v instanceof Function
 }
 
+/**
+ * @param {ValueType | ValueType[]} v
+ * @returns {boolean}
+ */
+function isBuffer (v) {
+  return Buffer.isBuffer(v)
+}
+
 /**
  * @param {ValueType | ValueType[]} v
  * @returns {boolean}
@@ -45,14 +53,6 @@ function isPrimitive (v) {
   )
 }
 
-/**
- * @param {ValueType | ValueType[]} v
- * @returns {boolean}
- */
-function isBuffer (v) {
-  return Buffer.isBuffer(v)
-}
-
 /**
  *  function isArrayBuffer (v) {
  *    return v instanceof ArrayBuffer