@sequencemedia/dupe 0.0.1 → 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,48 +1,54 @@
 {
   "name": "@sequencemedia/dupe",
-  "version": "0.0.1",
-  "main": "./index.mjs",
-  "type": "module",
-  "types": "./index.d.mts",
-  "author": {
-    "name": "Jonathan Perry for Sequence Media Limited",
-    "email": "sequencemedia@sequencemedia.net",
-    "url": "https://sequencemedia.net"
-  },
+  "version": "0.0.3",
   "keywords": [
     "dupe",
     "duplicate",
     "clone",
     "deep clone",
-    "deep"
+    "deep",
+    "structured clone"
   ],
+  "main": "./src/index.mjs",
+  "type": "module",
+  "types": "./src/index.d.mts",
+  "author": {
+    "name": "Jonathan Perry for Sequence Media Limited",
+    "email": "sequencemedia@sequencemedia.net",
+    "url": "https://sequencemedia.net"
+  },
   "license": "ISC",
   "scripts": {
     "lint": "eslint .",
     "lint:fix": "npm run lint -- --fix",
-    "test": "cross-env NODE_ENV=test mocha test --recursive",
-    "prepare": "husky"
+    "prepare": "husky",
+    "test": "cross-env NODE_ENV=test mocha test --recursive"
   },
   "dependencies": {
-    "-": "^0.0.1",
-    "chai": "^5.1.2",
-    "D": "^1.0.0",
-    "debug": "^4.4.0",
-    "mocha": "^11.0.1"
+    "debug": "^4.4.0"
   },
   "devDependencies": {
+    "chai": "^5.1.2",
+    "mocha": "^11.0.1",
     "@babel/core": "^7.26.0",
     "@babel/preset-env": "^7.26.0",
     "@sequencemedia/eslint-config-standard": "^0.2.2",
     "@sequencemedia/eslint-config-typescript": "^0.1.2",
     "@types/debug": "^4.1.12",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^22.10.1",
     "core-js": "^3.39.0",
     "cross-env": "^7.0.3",
     "eslint": "^9.16.0",
     "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/{index.mjs → src/index.mjs}

@@ -12,7 +12,7 @@
  * @param {ValueType | ValueType[]} v
  * @returns {boolean}
  */
-function isArray (v) {
+export function isArray (v) {
   return Array.isArray(v)
 }
 
@@ -20,7 +20,7 @@ function isArray (v) {
  * @param {ValueType | ValueType[]} v
  * @returns {boolean}
  */
-function isObject (v) {
+export function isObject (v) {
   return (v || false) instanceof Object && !Array.isArray(v)
 }
 
@@ -28,16 +28,19 @@ function isObject (v) {
  * @param {ValueType | ValueType[]} v
  * @returns {boolean}
  */
-function isFunction (v) {
+export function isFunction (v) {
   return v instanceof Function
 }
-
 /**
  * @param {ValueType | ValueType[]} v
  * @returns {boolean}
  */
 function isPrimitive (v) {
-  return !isObject(v) && !isArray(v) && !isFunction(v)
+  return !(
+    isObject(v) ||
+    isArray(v) ||
+    isFunction(v)
+  )
 }
 
 /**

package/src/node/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 | Buffer | null | undefined
+
+export default function dupe (v: ValueType | ValueType[]): ValueType | ValueType[]

package/src/node/index.mjs

@@ -0,0 +1,188 @@
+/**
+ * @typedef {unknown[] | never[]} ArrayLiteralType
+ *
+ * @typedef {Record<PropertyKey, unknown> | Record<PropertyKey, never>} ObjectLiteralType
+ *
+ * @typedef {string | number | ArrayLiteralType | ObjectLiteralType | Buffer | null | undefined} ValueType
+ *
+ * @typedef {WeakMap<WeakKey, ArrayLiteralType | ObjectLiteralType>} WeakMapType
+ */
+
+/**
+ * @param {ValueType | ValueType[]} v
+ * @returns {boolean}
+ */
+function isArray (v) {
+  return Array.isArray(v)
+}
+
+/**
+ * @param {ValueType | ValueType[]} v
+ * @returns {boolean}
+ */
+function isObject (v) {
+  return (v || false) instanceof Object && !Array.isArray(v) && !Buffer.isBuffer(v)
+}
+
+/**
+ * @param {ValueType | ValueType[]} v
+ * @returns {boolean}
+ */
+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}
+ */
+function isPrimitive (v) {
+  return !(
+    isObject(v) ||
+    isArray(v) ||
+    isFunction(v) ||
+    isBuffer(v)
+  )
+}
+
+/**
+ *  function isArrayBuffer (v) {
+ *    return v instanceof ArrayBuffer
+ *  }
+ */
+
+/**
+ * @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 {Buffer} v
+ * @param {WeakMapType} weakMap
+ * @returns {Buffer}
+ */
+function getBuffer (v, weakMap) {
+  const b = Buffer.from(v)
+
+  weakMap.set(v, b)
+  return b
+}
+
+/**
+ * @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
+    }
+
+    if (isBuffer(v)) {
+      a.push(getBuffer(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)]
+    }
+
+    if (isBuffer(v)) {
+      return [k, getBuffer(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())
+  }
+
+  if (isBuffer(v)) {
+    return getBuffer(v, new WeakMap())
+  }
+}