@ditojs/utils 1.21.0 → 1.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/utils",
-  "version": "1.21.0",
+  "version": "1.23.0",
   "type": "module",
   "description": "Dito.js Utility Functions – Dito.js is a declarative and modern web framework, based on Objection.js, Koa.js and Vue.js",
   "repository": "https://github.com/ditojs/dito/tree/master/packages/utils",
@@ -14,9 +14,6 @@
     "src/",
     "types/"
   ],
-  "scripts": {
-    "types": "tsc --noEmit types/index.d.ts"
-  },
   "engines": {
     "node": ">= 18.0.0",
     "yarn": ">= 1.0.0"
@@ -29,11 +26,15 @@
     "ie_mob >= 11"
   ],
   "dependencies": {
-    "punycode": "^2.1.1"
+    "punycode": "^2.3.0"
   },
   "devDependencies": {
-    "typescript": "^4.9.4"
+    "typescript": "^4.9.5"
   },
   "types": "types",
-  "gitHead": "a9dd1a854dbf2928a92c0be6481d704bd579cfdc"
-}
+  "gitHead": "3258fd030226062efa6837bfc5e5a761e80cead5",
+  "scripts": {
+    "types": "tsc --noEmit types/index.d.ts"
+  },
+  "readme": "# Dito.js Utility Functions\n\nDito.js is a declarative and modern web framework with a focus on API driven\ndevelopment, based on Koa.js, Objection.js and Vue.js\n\nReleased in 2018 under the MIT license, with support by https://lineto.com/\n"
+}

package/src/object/clone.js

@@ -1,9 +1,9 @@
 import {
   isArray, isObject, isDate, isRegExp, isFunction, isPromise
 } from '../base/index.js'
-import { pick } from '../object/index.js'
+import { pick } from './pick.js'
 
-export function clone(arg, options) {
+export function clone(value, options) {
   const {
     shallow = false,
     enumerable = true,
@@ -14,44 +14,58 @@ export function clone(arg, options) {
     ? { processValue: options } // TODO: `callback` deprecated in December 2022.
     : options || {}
 
-  const handleValue = value => shallow || transferables?.includes(value)
-    ? value
-    : clone(value, options)
+  const clones = new Map()
 
-  let copy = arg
-  if (isDate(arg)) {
-    copy = new arg.constructor(+arg)
-  } else if (isRegExp(arg)) {
-    copy = new arg.constructor(arg)
-  } else if (isArray(arg)) {
-    copy = new arg.constructor(arg.length)
-    for (let i = 0, l = arg.length; i < l; i++) {
-      copy[i] = handleValue(arg[i])
-    }
-  } else if (isObject(arg)) {
+  const storeClone = (value, copy) => {
+    clones.set(value, copy)
+    return copy
+  }
+
+  const handleValue = value => {
+    return shallow || transferables?.includes(value) ? value
+      : clones.has(value) ? clones.get(value)
+      : cloneValue(value)
+  }
+
+  const cloneValue = value => {
+    let copy = value
+    if (isDate(value)) {
+      copy = storeClone(value, new value.constructor(+value))
+    } else if (isRegExp(value)) {
+      copy = storeClone(value, new value.constructor(value))
+    } else if (isArray(value)) {
+      copy = storeClone(value, new value.constructor(value.length))
+      for (let i = 0, l = value.length; i < l; i++) {
+        copy[i] = handleValue(value[i])
+      }
+    } else if (isObject(value)) {
     // Rely on arg.clone() if it exists and assume it creates an actual clone.
-    if (isFunction(arg.clone)) {
-      copy = arg.clone(options)
-    } else if (isPromise(arg)) {
+      if (isFunction(value.clone)) {
+        copy = storeClone(value, value.clone(options))
+      } else if (isPromise(value)) {
       // https://stackoverflow.com/questions/37063293/can-i-clone-a-promise
-      copy = arg.then()
-    } else {
+        copy = storeClone(value, value.then())
+      } else {
       // Prevent calling the actual constructor since it is not guaranteed to
       // work as intended here, and only clone the non-inherited own properties.
-      copy = Object.create(Object.getPrototypeOf(arg))
-      const keys = enumerable ? Object.keys(arg) : Reflect.ownKeys(arg)
-      for (const key of keys) {
-        if (descriptors) {
-          const desc = Reflect.getOwnPropertyDescriptor(arg, key)
-          if (desc.value != null) {
-            desc.value = handleValue(desc.value)
+        copy = storeClone(value, Object.create(Object.getPrototypeOf(value)))
+        clones.set(value, copy)
+        const keys = enumerable ? Object.keys(value) : Reflect.ownKeys(value)
+        for (const key of keys) {
+          if (descriptors) {
+            const desc = Reflect.getOwnPropertyDescriptor(value, key)
+            if (desc.value != null) {
+              desc.value = handleValue(desc.value)
+            }
+            Reflect.defineProperty(copy, key, desc)
+          } else {
+            copy[key] = handleValue(value[key])
           }
-          Reflect.defineProperty(copy, key, desc)
-        } else {
-          copy[key] = handleValue(arg[key])
         }
       }
     }
+    return pick(processValue?.(copy), copy)
   }
-  return pick(processValue?.(copy), copy)
+
+  return cloneValue(value)
 }

package/src/object/clone.test.js

@@ -60,6 +60,22 @@ describe('clone()', () => {
     expect(copy).toStrictEqual({ b: 2 })
   })
 
+  it('should preserve identity', async () => {
+    const object = { a: { b: 1 } }
+    object.c = object.a
+    const copy = clone(object)
+    expect(copy).toEqual(object)
+    expect(copy.c).toBe(copy.a)
+  })
+
+  it('should handle circular references', async () => {
+    const object = { a: { b: 1 } }
+    object.c = object
+    const copy = clone(object)
+    expect(copy).toEqual(object)
+    expect(copy.c).toBe(copy)
+  })
+
   it('should handle non-enumerable properties', async () => {
     const object = { a: 1 }
     Object.defineProperty(object, 'b', { value: 2, enumerable: false })

package/src/string/deindent.js

@@ -1,9 +1,12 @@
-import os from 'os'
 import { asArray } from '../base/index.js'
 
 // ES6 string tag that strips indentation from multi-line strings
 // Based on, and further improved from https://github.com/dmnd/dedent
 export function deindent(strings, ...values) {
+  // Small helper to determine the actual line-break used in the strings, based
+  // on the  line-breaks encountered.
+  const getLineBreak = line => line.match(/^(\n|\r\n|\r)/)?.[1] || '\n'
+
   strings = asArray(strings)
   // First, perform interpolation
   let parts = []
@@ -21,16 +24,18 @@ export function deindent(strings, ...values) {
       if (lines.length > 1) {
         // Determine the indent by finding the immediately preceding white-space
         // up to the previous line-break or the beginning of the string.
-        // (?:^|[\n\r])  # Start at either the beginning or the prev line break.
-        // (?:[\n\r]*)   # Skip the line break
-        // (\s+)         # Collect the indenting white-space...
-        // (?:[^\n\r]*)$ # ...up to the end or the next word, but in last line,
-        // by making sure no line breaks follow until the end.
+        // (?:^[\n\r]*|[\n\r])  # Start at either the beginning or the previous
+        //                      # line break.
+        // (?:[\n\r]*)          # The line break
+        // (\s+)                # Collect the indenting white-space...
+        // (?:[^\n\r]*)$        # ...up to the end or the next word, but in last
+        //                      # line, by making sure no line breaks follow
+        //                      # until the end.
         const str = parts.join('')
-        const match = str.match(/(?:^|[\n\r])(?:[\n\r]*)(\s+)(?:[^\n\r]*)$/)
+        const match = str.match(/((?:^[\n\r]*|[\n\r])(?:[\n\r]*))(\s+)(?:[^\n\r]*)$/)
+        const [, lineBreaks = '', indent = ''] = match || []
         parts = [str]
-        const indent = match?.[1] || ''
-        parts.push(lines.join(`${os.EOL}${indent}`))
+        parts.push(lines.join(`${getLineBreak(lineBreaks)}${indent}`))
       } else {
         parts.push(value)
       }
@@ -42,7 +47,11 @@ export function deindent(strings, ...values) {
   // const value = `
   //   content...
   //   ` // line break at the end remains
-  if (!lines[0]) lines.shift()
+  let offset = 0
+  if (!lines[0]) {
+    lines.shift()
+    offset++
+  }
   let indent = Infinity
   for (const line of lines) {
     const match = line.match(/^(\s*)\S+/)
@@ -50,5 +59,7 @@ export function deindent(strings, ...values) {
       indent = Math.min(indent, match[1].length)
     }
   }
-  return lines.map(line => line.slice(indent)).join(os.EOL)
+  const index = lines[0].length + offset
+  const lineBreak = getLineBreak(str.slice(index, index + 2))
+  return lines.map(line => line.slice(indent)).join(lineBreak)
 }

package/types/index.d.ts

@@ -108,9 +108,32 @@ export function asFunction<T>(
 /* --------------------------------- object --------------------------------- */
 
 /**
- * Performs a deep (recursive) clone on the supplied value.
+ * Clones the supplied value.
  */
-export function clone<T>(arg: T, iteratee?: (arg: any) => void): T
+export function clone<T>(arg: T, options?: {
+  /**
+   * Wether to clone the value shallowly.
+   *
+   * @default false
+   */
+  shallow?: boolean,
+  /**
+   * Wether to clone all object properties, or only those that are defined
+   * directly on that object, and are not inherited from the object's prototype.
+   *
+   * @default true
+   */
+  enumerable?: boolean,
+  /**
+   * @default `true` if `options.enumerable` is true, `false` otherwise
+   */
+  descriptors?: boolean,
+  transferables?: any[],
+  /**
+   * Optional callback to process the cloned value.
+   */
+  processValue?: <S>(arg: T) => S,
+}): T
 
 /**
  * Determines whether the supplied values can be considered equal through