@ditojs/utils 1.24.0 → 1.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/utils",
-  "version": "1.24.0",
+  "version": "1.26.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",
@@ -32,7 +32,7 @@
     "typescript": "^4.9.5"
   },
   "types": "types",
-  "gitHead": "0ca96ce0335509daa9ebbac278ae2d346015baad",
+  "gitHead": "198c9832c863003c8c8fcd147bf61a5f99a39c91",
   "scripts": {
     "types": "tsc --noEmit types/index.d.ts"
   },

package/src/__snapshots__/index.test.js.snap

@@ -1,4 +1,4 @@
-// Vitest Snapshot v1
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
 
 exports[`index > exports all symbols 1`] = `
 {
@@ -62,7 +62,9 @@ exports[`index > exports all symbols 1`] = `
   "isString": [Function],
   "isUrl": [Function],
   "labelize": [Function],
+  "mapConcurrently": [Function],
   "mapKeys": [Function],
+  "mapSequentially": [Function],
   "mapValues": [Function],
   "merge": [Function],
   "mixin": [Function],

package/src/dataPath/getEntriesAtDataPath.js

@@ -1,12 +1,31 @@
 import { parseDataPath } from './parseDataPath.js'
 import { normalizeDataPath } from './normalizeDataPath.js'
 
+const NOT_FOUND = Symbol('NOT_FOUND')
+
 export function getEntriesAtDataPath(
   obj,
   path,
   handleError = () => { throw new Error(`Invalid path: ${path}`) }
 ) {
   const parsedPath = parseDataPath(path)
+
+  const prefixEntries = (obj, index, getEntries) => {
+    const prefix = normalizeDataPath(parsedPath.slice(0, index))
+    return Object.entries(obj).reduce(
+      (map, [key, value]) => {
+        const pathKey = prefix ? `${prefix}/${key}` : key
+        for (const [path, val] of Object.entries(getEntries(value))) {
+          if (val !== NOT_FOUND) {
+            map[`${pathKey}/${path}`] = val
+          }
+        }
+        return map
+      },
+      {}
+    )
+  }
+
   let index = 0
   for (const part of parsedPath) {
     if (obj && typeof obj === 'object') {
@@ -16,18 +35,23 @@ export function getEntriesAtDataPath(
         continue
       } else if (part === '*') {
         // Support wildcards on arrays and objects
-        const pathStart = normalizeDataPath(parsedPath.slice(0, index))
-        const pathEnd = parsedPath.slice(index + 1)
-        return Object.entries(obj).reduce(
-          (map, [key, value]) => {
-            const entries = getEntriesAtDataPath(value, pathEnd, handleError)
-            const pathToKey = pathStart ? `${pathStart}/${key}` : key
-            for (const [subPath, subVal] of Object.entries(entries)) {
-              map[`${pathToKey}/${subPath}`] = subVal
-            }
-            return map
-          },
-          {}
+        const pathNested = parsedPath.slice(index + 1)
+        return prefixEntries(
+          obj,
+          index,
+          value => getEntriesAtDataPath(value, pathNested, handleError)
+        )
+      } else if (part === '**') {
+        // Support wildcards on arrays and objects
+        const pathNested = parsedPath.slice(index + 1)
+        const pathSelf = parsedPath.slice(index)
+        return prefixEntries(
+          obj,
+          index,
+          value => ({
+            ...getEntriesAtDataPath(value, pathNested, () => NOT_FOUND),
+            ...getEntriesAtDataPath(value, pathSelf, () => NOT_FOUND)
+          })
         )
       }
     }

package/src/dataPath/getEntriesAtDataPath.test.js

@@ -52,7 +52,7 @@ describe('getEntriesAtDataPath()', () => {
       .toStrictEqual({})
   })
 
-  it('should return wildcard matches', () => {
+  it('should return shallow wildcard matches', () => {
     const data = {
       object1: {
         array: [
@@ -141,4 +141,64 @@ describe('getEntriesAtDataPath()', () => {
         'object3/array/1/two/name': 'two.two'
       })
   })
+
+  it('should return deep wildcard matches', () => {
+    const data = {
+      object: {
+        array: [
+          { name: 'one' },
+          { name: 'two' },
+          {
+            object: {
+              one: { name: 'three' },
+              two: { name: 'four' }
+            },
+            array: [
+              { name: 'five' },
+              { name: 'six' },
+              {
+                object: {
+                  one: { name: 'seven' },
+                  two: { name: 'eight' }
+                }
+              }
+            ]
+          }
+        ]
+      }
+    }
+
+    const expected = {
+      'object/array/0/name': 'one',
+      'object/array/1/name': 'two',
+      'object/array/2/object/one/name': 'three',
+      'object/array/2/object/two/name': 'four',
+      'object/array/2/array/0/name': 'five',
+      'object/array/2/array/1/name': 'six',
+      'object/array/2/array/2/object/one/name': 'seven',
+      'object/array/2/array/2/object/two/name': 'eight'
+    }
+
+    let result = getEntriesAtDataPath(data, '**/name')
+    expect(result).toEqual(expected)
+    expect(Object.values(result)).toEqual(Object.values(expected))
+
+    result = getEntriesAtDataPath(data, 'object/**/name')
+    expect(result).toEqual(expected)
+    expect(Object.values(result)).toEqual(Object.values(expected))
+
+    expect(getEntriesAtDataPath(data, 'object/**/array/**/name')).toEqual({
+      'object/array/2/array/0/name': 'five',
+      'object/array/2/array/1/name': 'six',
+      'object/array/2/array/2/object/one/name': 'seven',
+      'object/array/2/array/2/object/two/name': 'eight'
+    })
+
+    expect(getEntriesAtDataPath(data, 'object/**/object/**/name')).toEqual({
+      'object/array/2/object/one/name': 'three',
+      'object/array/2/object/two/name': 'four',
+      'object/array/2/array/2/object/one/name': 'seven',
+      'object/array/2/array/2/object/two/name': 'eight'
+    })
+  })
 })

package/src/dataPath/getValueAtDataPath.js

@@ -1,6 +1,8 @@
-import { isArray } from '../base/index.js'
+import { isArray, asArray } from '../base/index.js'
 import { parseDataPath } from './parseDataPath.js'
 
+const NOT_FOUND = Symbol('NOT_FOUND')
+
 export function getValueAtDataPath(
   obj,
   path,
@@ -16,13 +18,20 @@ export function getValueAtDataPath(
         continue
       } else if (part === '*') {
         // Support wildcards on arrays and objects
-        const subPath = parsedPath.slice(index + 1)
+        const pathNested = parsedPath.slice(index + 1)
+        const values = isArray(obj) ? obj : Object.values(obj)
+        return values.map(
+          value => getValueAtDataPath(value, pathNested, handleError)
+        ).flat(1)
+      } else if (part === '**') {
+        // Support deep wildcards on arrays and objects
+        const pathNested = parsedPath.slice(index + 1)
+        const pathSelf = parsedPath.slice(index)
         const values = isArray(obj) ? obj : Object.values(obj)
-        const results = values.map(
-          value => getValueAtDataPath(value, subPath, handleError)
-        )
-        const flat = subPath.filter(part => part === '*').length
-        return flat > 0 ? results.flat(flat) : results
+        return values.map(value => [
+          ...asArray(getValueAtDataPath(value, pathNested, () => NOT_FOUND)),
+          ...asArray(getValueAtDataPath(value, pathSelf, () => NOT_FOUND))
+        ]).flat(1).filter(value => value !== NOT_FOUND)
       }
     }
     return handleError?.(obj, part, index)

package/src/dataPath/getValueAtDataPath.test.js

@@ -40,7 +40,7 @@ describe('getValueAtDataPath()', () => {
       .toBe('Error: unknown, 1')
   })
 
-  it('should return wildcard matches', () => {
+  it('should return shallow wildcard matches', () => {
     const data = {
       object1: {
         array: [
@@ -73,5 +73,52 @@ describe('getValueAtDataPath()', () => {
       ])
     expect(getValueAtDataPath(data, '*/*/*/name'))
       .toEqual(['one', 'two', 'one', 'two'])
+
+    expect(getValueAtDataPath(data, '**/name'))
+      .toEqual(['one', 'two', 'one', 'two'])
+  })
+
+  it('should return deep wildcard matches', () => {
+    const data = {
+      object: {
+        object: {
+          array: [
+            { name: 'one' },
+            { name: 'two' },
+            {
+              object: {
+                one: { name: 'three' },
+                two: { name: 'four' }
+              },
+              array: [
+                { name: 'five' },
+                { name: 'six' },
+                {
+                  object: {
+                    one: { name: 'seven' },
+                    two: { name: 'eight' }
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      }
+    }
+
+    expect(getValueAtDataPath(data, 'object/**/name'))
+      .toEqual(['one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight'])
+
+    expect(getValueAtDataPath(data, 'object/**/object/one/name'))
+      .toEqual(['three', 'seven'])
+
+    expect(getValueAtDataPath(data, 'object/**/object/two/name'))
+      .toEqual(['four', 'eight'])
+
+    expect(getValueAtDataPath(data, 'object/**/array/0/name'))
+      .toEqual(['one', 'five'])
+
+    expect(getValueAtDataPath(data, 'object/**/array/1/name'))
+      .toEqual(['two', 'six'])
   })
 })

package/src/dataPath/parseDataPath.test.js

@@ -31,7 +31,7 @@ describe('parseDataPath()', () => {
       .toStrictEqual(['..', 'object', 'value'])
     expect(parseDataPath('./object/value'))
       .toStrictEqual(['.', 'object', 'value'])
-    // This happens when concanating a data path with another absolute one, an
+    // This happens when concatenating a data path with another absolute one, an
     // empty space will be interpreted as "start from scratch" when normalizing.
     expect(parseDataPath('//object/value'))
       .toStrictEqual(['', 'object', 'value'])

package/src/index.js

@@ -4,6 +4,7 @@ export * from './array/index.js'
 export * from './object/index.js'
 export * from './string/index.js'
 export * from './timer/index.js'
+export * from './promise/index.js'
 export * from './function/index.js'
 export * from './dataPath/index.js'
 export * from './html/index.js'

package/src/promise/index.js

@@ -0,0 +1,2 @@
+export * from './mapConcurrently.js'
+export * from './mapSequentially.js'

package/src/promise/mapConcurrently.js

@@ -0,0 +1,33 @@
+export async function mapConcurrently(
+  input,
+  callback,
+  { concurrency = 0 } = {}
+) {
+  const array = await input
+  if (!concurrency) {
+    return Promise.all(array.map(callback))
+  }
+
+  const promises = []
+  const results = []
+  let index = 0
+
+  function next() {
+    if (index < array.length) {
+      const i = index++
+      return Promise.resolve(callback(array[i], i, array)).then(result => {
+        results[i] = result
+        return next()
+      })
+    }
+    return null
+  }
+
+  while (concurrency-- > 0) {
+    const promise = next()
+    if (!promise) break
+    promises.push(promise)
+  }
+
+  return Promise.all(promises).then(() => results)
+}

package/src/promise/mapSequentially.js

@@ -0,0 +1,9 @@
+export async function mapSequentially(input, callback) {
+  const array = await input
+  const results = []
+  let index = 0
+  for (const item of array) {
+    results.push(await callback(item, index++))
+  }
+  return results
+}

package/src/string/format.test.js

@@ -19,7 +19,7 @@ describe('format()', () => {
   it('should use the en-US locale by default', () => {
     expect(format(integer)).toBe('123,456,789')
     expect(format(float)).toBe('123,456.789')
-    expect(format(date)).toBe('June 9, 2012 at 10:45:30 PM')
+    expect(format(date)).toBe('June 9, 2012 at 10:45:30 PM')
   })
 
   it('should format numbers with different locale and default options', () => {
@@ -188,7 +188,7 @@ describe('format()', () => {
     ).toBe('May 24, 2016')
     expect(
       format('2016-05-24T15:54:14.876Z', { date: true, time: true })
-    ).toBe('May 24, 2016 at 05:54:14 PM')
+    ).toBe('May 24, 2016 at 05:54:14 PM')
     expect(format('123456789', { number: true })).toBe('123,456,789')
     expect(format('123456.789', { number: true })).toBe('123,456.789')
     expect(format('Hello World')).toBe('Hello World')

package/src/string/formatDate.test.js

@@ -8,8 +8,8 @@ describe('formatDate()', () => {
   })
 
   it('should use the en-US locale by default', () => {
-    expect(formatDate(date)).toBe('June 9, 2012 at 10:45:30 PM')
-    expect(formatDate(date, {})).toBe('June 9, 2012 at 10:45:30 PM')
+    expect(formatDate(date)).toBe('June 9, 2012 at 10:45:30 PM')
+    expect(formatDate(date, {})).toBe('June 9, 2012 at 10:45:30 PM')
   })
 
   it('should format dates with different locale and default options', () => {