@ditojs/utils 2.100.0 → 3.1.0

package/src/dataPath/getEntriesAtDataPath.test.js

@@ -1,204 +0,0 @@
-import { getEntriesAtDataPath } from './getEntriesAtDataPath.js'
-
-describe('getEntriesAtDataPath()', () => {
-  const data = {
-    object: {
-      array: [
-        null,
-        {
-          prop: 'expected'
-        }
-      ]
-    }
-  }
-
-  it('should return data at a given path in property access notation', () => {
-    expect(getEntriesAtDataPath(data, 'object.array[1].prop')).toStrictEqual({
-      'object/array/1/prop': 'expected'
-    })
-  })
-
-  it('should return data at a given JSON pointer path', () => {
-    expect(getEntriesAtDataPath(data, '/object/array/1/prop')).toStrictEqual({
-      'object/array/1/prop': 'expected'
-    })
-  })
-
-  it(`should return data at a given 'relative' JSON pointer path`, () => {
-    expect(getEntriesAtDataPath(data, 'object/array/1/prop')).toStrictEqual({
-      'object/array/1/prop': 'expected'
-    })
-  })
-
-  it('should throw an error with faulty paths', () => {
-    expect(() => getEntriesAtDataPath(data, 'object/unknown/prop'))
-      .toThrow('Invalid path: object/unknown/prop')
-  })
-
-  it('should throw an error with nullish objects', () => {
-    expect(() => getEntriesAtDataPath(null, 'object'))
-      .toThrow('Invalid path: object')
-  })
-
-  it('should support custom error handler', () => {
-    const handleError = (object, part, index) => `Error: ${part}, ${index}`
-    expect(getEntriesAtDataPath(data, 'object/unknown/prop', handleError))
-      .toStrictEqual({ 'object/unknown/prop': 'Error: unknown, 1' })
-  })
-
-  it('should handle non-existing paths with custom `handleError()`', () => {
-    const handleError = () => undefined
-    expect(getEntriesAtDataPath(data, 'object/unknown/prop', handleError))
-      .toStrictEqual({})
-  })
-
-  it('should return shallow wildcard matches', () => {
-    const data = {
-      object1: {
-        array: [
-          {
-            name: 'one',
-            array: [
-              { name: 'one.one' },
-              { name: 'one.two' }
-            ]
-          },
-          {
-            name: 'two',
-            array: [
-              { name: 'two.one' },
-              { name: 'two.two' }
-            ]
-          }
-        ]
-      },
-      object2: {
-        object: {
-          one: {
-            name: 'one',
-            object: {
-              one: { name: 'one.one' },
-              two: { name: 'one.two' }
-            }
-          },
-          two: {
-            name: 'two',
-            object: {
-              one: { name: 'two.one' },
-              two: { name: 'two.two' }
-            }
-          }
-        }
-      },
-      object3: {
-        array: [
-          {
-            one: { name: 'one.one' },
-            two: { name: 'one.two' }
-          },
-          {
-            one: { name: 'two.one' },
-            two: { name: 'two.two' }
-          }
-        ]
-      }
-    }
-
-    expect(getEntriesAtDataPath(data, 'object1/array/*/name'))
-      .toStrictEqual({
-        'object1/array/0/name': 'one',
-        'object1/array/1/name': 'two'
-      })
-    expect(getEntriesAtDataPath(data, 'object1.array[*].name'))
-      .toStrictEqual({
-        'object1/array/0/name': 'one',
-        'object1/array/1/name': 'two'
-      })
-    expect(getEntriesAtDataPath(data, 'object1/array/*/array/*/name'))
-      .toStrictEqual({
-        'object1/array/0/array/0/name': 'one.one',
-        'object1/array/0/array/1/name': 'one.two',
-        'object1/array/1/array/0/name': 'two.one',
-        'object1/array/1/array/1/name': 'two.two'
-      })
-    expect(getEntriesAtDataPath(data, 'object2/object/*/name'))
-      .toStrictEqual({
-        'object2/object/one/name': 'one',
-        'object2/object/two/name': 'two'
-      })
-    expect(getEntriesAtDataPath(data, 'object2/object/*/object/*/name'))
-      .toStrictEqual({
-        'object2/object/one/object/one/name': 'one.one',
-        'object2/object/one/object/two/name': 'one.two',
-        'object2/object/two/object/one/name': 'two.one',
-        'object2/object/two/object/two/name': 'two.two'
-      })
-    expect(getEntriesAtDataPath(data, 'object3/array/*/*/name'))
-      .toStrictEqual({
-        'object3/array/0/one/name': 'one.one',
-        'object3/array/0/two/name': 'one.two',
-        'object3/array/1/one/name': 'two.one',
-        '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.test.js

@@ -1,140 +0,0 @@
-import { getValueAtDataPath } from './getValueAtDataPath.js'
-
-describe('getValueAtDataPath()', () => {
-  const data = {
-    object: {
-      array: [
-        null,
-        {
-          prop: 'expected'
-        }
-      ]
-    }
-  }
-
-  it('should return the root data for empty paths', () => {
-    expect(getValueAtDataPath(data, '')).toBe(data)
-  })
-
-  it('should return data at a given path in property access notation', () => {
-    expect(getValueAtDataPath(data, 'object.array[1].prop')).toBe('expected')
-  })
-
-  it('should return data at a given JSON pointer path', () => {
-    expect(getValueAtDataPath(data, '/object/array/1/prop')).toBe('expected')
-  })
-
-  it(`should return data at a given 'relative' JSON pointer path`, () => {
-    expect(getValueAtDataPath(data, 'object/array/1/prop')).toBe('expected')
-  })
-
-  it('should throw an error with faulty paths', () => {
-    expect(() => getValueAtDataPath(data, 'object/unknown/prop'))
-      .toThrow('Invalid path: object/unknown/prop')
-  })
-
-  it('should throw an error with nullish objects', () => {
-    expect(() => getValueAtDataPath(null, 'object'))
-      .toThrow('Invalid path: object')
-  })
-
-  it('should support custom error handler', () => {
-    const handleError = (object, part, index) => `Error: ${part}, ${index}`
-    expect(getValueAtDataPath(data, 'object/unknown/prop', handleError))
-      .toBe('Error: unknown, 1')
-  })
-
-  it('should return shallow wildcard matches', () => {
-    const data = {
-      object1: {
-        array: [
-          { name: 'one' },
-          { name: 'two' }
-        ]
-      },
-      object2: {
-        object: {
-          one: { name: 'one' },
-          two: { name: 'two' }
-        }
-      }
-    }
-
-    expect(getValueAtDataPath(data, 'object1/array/*/name'))
-      .toEqual(['one', 'two'])
-    expect(getValueAtDataPath(data, 'object1.array[*].name'))
-      .toEqual(['one', 'two'])
-    expect(getValueAtDataPath(data, 'object2/object/*/name'))
-      .toEqual(['one', 'two'])
-    expect(getValueAtDataPath(data, 'object2.object[*].name'))
-      .toEqual(['one', 'two'])
-    expect(getValueAtDataPath(data, '*/*/*'))
-      .toEqual([
-        { name: 'one' },
-        { name: 'two' },
-        { name: 'one' },
-        { name: 'two' }
-      ])
-    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'])
-
-    expect(getValueAtDataPath(data, 'object/**/object'))
-      .toEqual([
-        {
-          one: { name: 'three' },
-          two: { name: 'four' }
-        },
-        {
-          one: { name: 'seven' },
-          two: { name: 'eight' }
-        }
-      ])
-  })
-})

package/src/dataPath/normalizeDataPath.test.js

@@ -1,36 +0,0 @@
-import { normalizeDataPath } from './normalizeDataPath.js'
-
-describe('normalizeDataPath()', () => {
-  it('should normalize JSON pointers', () => {
-    expect(normalizeDataPath('/object/array/1/prop'))
-      .toStrictEqual('object/array/1/prop')
-  })
-
-  it('should normalize property access notation', () => {
-    const expected = 'object/array/1/prop'
-    expect(normalizeDataPath('.object.array[1].prop')).toStrictEqual(expected)
-    expect(normalizeDataPath('.object["array"][1].prop'))
-      .toStrictEqual(expected)
-    expect(normalizeDataPath(`['object']['array'][1]['prop']`))
-      .toStrictEqual(expected)
-  })
-
-  it('should normalize relative tokens', () => {
-    expect(normalizeDataPath('/object/property1/..'))
-      .toStrictEqual('object')
-    expect(normalizeDataPath('/object/property1/../'))
-      .toStrictEqual('object')
-    expect(normalizeDataPath('/object/property1/../value'))
-      .toStrictEqual('object/value')
-    expect(normalizeDataPath('/object/property1/../value/'))
-      .toStrictEqual('object/value')
-    expect(normalizeDataPath('/object/property1/../property2/../value'))
-      .toStrictEqual('object/value')
-    expect(normalizeDataPath('/object/property1/property2/../../value'))
-      .toStrictEqual('object/value')
-    expect(normalizeDataPath('/object/property1//object/value'))
-      .toStrictEqual('object/value')
-    expect(normalizeDataPath('/object1/object2/./object3/value'))
-      .toStrictEqual('object1/object2/object3/value')
-  })
-})

package/src/dataPath/parseDataPath.test.js

@@ -1,67 +0,0 @@
-import { parseDataPath } from './parseDataPath.js'
-
-describe('parseDataPath()', () => {
-  it('should parse JSON pointers', () => {
-    expect(parseDataPath('/object/array/1/prop'))
-      .toStrictEqual(['object', 'array', '1', 'prop'])
-  })
-
-  it('should parse property access notation', () => {
-    const expected = ['object', 'array', '1', 'prop']
-    expect(parseDataPath('.object.array[1].prop')).toStrictEqual(expected)
-    expect(parseDataPath(`.object["array"][1].prop`)).toStrictEqual(expected)
-    expect(parseDataPath(`['object']['array'][1]['prop']`))
-      .toStrictEqual(expected)
-  })
-
-  it(`should parse 'relative' JSON pointers`, () => {
-    expect(parseDataPath('object/array/1/prop'))
-      .toStrictEqual(['object', 'array', '1', 'prop'])
-  })
-
-  it(`should parse 'relative' property access notation`, () => {
-    expect(parseDataPath('object.array[1].prop'))
-      .toStrictEqual(['object', 'array', '1', 'prop'])
-  })
-
-  it('should parse relative and absolute tokens', () => {
-    expect(parseDataPath('/object/property1/../property2/../value'))
-      .toStrictEqual(['object', 'property1', '..', 'property2', '..', 'value'])
-    expect(parseDataPath('../object/value'))
-      .toStrictEqual(['..', 'object', 'value'])
-    expect(parseDataPath('./object/value'))
-      .toStrictEqual(['.', 'object', 'value'])
-    // 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'])
-  })
-
-  it('should handle white-space in JSON pointers', () => {
-    expect(parseDataPath('/object/property name'))
-      .toStrictEqual(['object', 'property name'])
-  })
-
-  it('should handle white-space in property access notation', () => {
-    const expected = ['object', 'property name']
-    expect(parseDataPath(`.object["property name"]`)).toStrictEqual(expected)
-    expect(parseDataPath(`.object['property name']`)).toStrictEqual(expected)
-  })
-
-  it('should return a clone if argument is already an array', () => {
-    const array = ['object', 'array', '1']
-    const actual = parseDataPath(array)
-    expect(actual).toStrictEqual(array)
-    expect(actual).not.toBe(array)
-  })
-
-  it('should return undefined for values other than array / string', () => {
-    expect(parseDataPath({})).toBe(undefined)
-    expect(parseDataPath(false)).toBe(undefined)
-    expect(parseDataPath(10)).toBe(undefined)
-  })
-
-  it('should parse an empty string to an empty array', () => {
-    expect(parseDataPath('')).toStrictEqual([])
-  })
-})

package/src/dataPath/setDataPathEntries.test.js

@@ -1,36 +0,0 @@
-import { setDataPathEntries } from './setDataPathEntries.js'
-
-describe('setDataPathEntries()', () => {
-  const data = {
-    object: {
-      array: [
-        {}
-      ],
-      number: 10
-    }
-  }
-
-  const add = { prop: 'new' }
-
-  it('should add data at a path to a given object and array', () => {
-    expect(() =>
-      setDataPathEntries(data, {
-        'object.array[0].added': add,
-        'object.array[1]': add
-      })
-    )
-      .not.toThrow()
-    expect(data.object.array[0].added).toStrictEqual(add)
-    expect(data.object.array[1]).toStrictEqual(add)
-  })
-
-  it('should throw an error with faulty paths', () => {
-    expect(() => setDataPathEntries(data, { 'object/unknown/prop': add }))
-      .toThrow()
-  })
-
-  it('should throw an error with invalid target', () => {
-    expect(() => setDataPathEntries(data, { 'object/number/invalid': add }))
-      .toThrow('Invalid path: object/number/invalid')
-  })
-})

package/src/dataPath/setValueAtDataPath.test.js

@@ -1,34 +0,0 @@
-import { setValueAtDataPath } from './setValueAtDataPath.js'
-
-describe('setValueAtDataPath()', () => {
-  const data = {
-    object: {
-      array: [
-        {}
-      ],
-      number: 10
-    }
-  }
-
-  const add = { prop: 'new' }
-
-  it('should add data at a path to a given object', () => {
-    expect(() => setValueAtDataPath(data, 'object.array[0].added', add))
-      .not.toThrow()
-    expect(data.object.array[0].added).toStrictEqual(add)
-  })
-
-  it('should add data at a path to a given array', () => {
-    expect(() => setValueAtDataPath(data, 'object.array[1]', add)).not.toThrow()
-    expect(data.object.array[1]).toStrictEqual(add)
-  })
-
-  it('should throw an error with faulty paths', () => {
-    expect(() => setValueAtDataPath(data, 'object/unknown/prop', add)).toThrow()
-  })
-
-  it('should throw an error with invalid target', () => {
-    expect(() => setValueAtDataPath(data, 'object/number/invalid', add))
-      .toThrow('Invalid path: object/number/invalid')
-  })
-})

package/src/function/toAsync.test.js

@@ -1,31 +0,0 @@
-import { toAsync } from './toAsync.js'
-
-describe('toAsync()', () => {
-  it('should convert callback functions to async', async () => {
-    expect.assertions(1)
-    const asyncFunc = toAsync(function (toResolve, callback) {
-      process.nextTick(() => {
-        callback(null, toResolve)
-      })
-    })
-    const expected = 10
-    const actual = await asyncFunc(expected)
-    expect(actual).toBe(expected)
-  })
-
-  it('should convert callback errors to exceptions', async () => {
-    expect.assertions(1)
-    const error = new Error('This error is intentional')
-    const throwError = toAsync(function (toReject, callback) {
-      process.nextTick(() => {
-        callback(toReject)
-      })
-    })
-
-    try {
-      await throwError(error)
-    } catch (err) {
-      expect(err).toBe(error)
-    }
-  })
-})

package/src/function/toCallback.test.js

@@ -1,29 +0,0 @@
-import { toCallback } from './toCallback.js'
-
-describe('toCallback()', () => {
-  it('should convert async functions to callbacks', async () => {
-    expect.assertions(2)
-    const callback = toCallback(async result => {
-      await Promise.resolve()
-      return result
-    })
-    const expected = 10
-    callback(expected, (err, actual) => {
-      expect(err).toBeNull()
-      expect(actual).toBe(expected)
-    })
-  })
-
-  it('should convert async exceptions to callback errors', async () => {
-    expect.assertions(2)
-    const error = new Error('This error is intentional')
-    const callback = toCallback(async error => {
-      await Promise.resolve()
-      throw error
-    })
-    callback(error, (err, actual) => {
-      expect(err).toBe(error)
-      expect(actual).toBe(undefined)
-    })
-  })
-})

package/src/function/toPromiseCallback.test.js

@@ -1,24 +0,0 @@
-import { toPromiseCallback } from './toPromiseCallback.js'
-import { vi } from 'vitest'
-
-describe('toPromiseCallback()', () => {
-  it('should call reject() when called with an error', () => {
-    const error = new Error('My Error')
-    const resolve = vi.fn()
-    const reject = vi.fn()
-    const callback = toPromiseCallback(resolve, reject)
-    callback(error)
-    expect(resolve).not.toBeCalled()
-    expect(reject).toBeCalledWith(error)
-  })
-
-  it('should call resolve() when called with a result', () => {
-    const result = 42
-    const resolve = vi.fn()
-    const reject = vi.fn()
-    const callback = toPromiseCallback(resolve, reject)
-    callback(null, result)
-    expect(reject).not.toBeCalled()
-    expect(resolve).toBeCalledWith(result)
-  })
-})

package/src/html/escapeHtml.test.js

@@ -1,19 +0,0 @@
-import { escapeHtml } from './escapeHtml.js'
-
-describe('escapeHtml()', () => {
-  it('should escape quotes, ampersands, and smaller/greater than signs', () => {
-    expect(escapeHtml('<div id="me, myself & i"/>'))
-      .toBe('&lt;div id=&quot;me, myself &amp; i&quot;/&gt;')
-  })
-
-  it('should return an empty string if nothing can be processed', () => {
-    expect(escapeHtml()).toBe('')
-    expect(escapeHtml(null)).toBe('')
-    expect(escapeHtml('')).toBe('')
-  })
-
-  it('should handle falsy values correctly', () => {
-    expect(escapeHtml(0)).toBe('0')
-    expect(escapeHtml(false)).toBe('false')
-  })
-})

package/src/html/stripHtml.test.js

@@ -1,37 +0,0 @@
-import { stripHtml } from './stripHtml.js'
-
-describe('stripHtml()', () => {
-  it('should remove html tags from strings', () => {
-    expect(stripHtml('<p><b>this</b> is a marked-up string</p>'))
-      .toBe('this is a marked-up string')
-  })
-
-  it('should return an empty string if nothing can be processed', () => {
-    expect(stripHtml()).toBe('')
-    expect(stripHtml(null)).toBe('')
-    expect(stripHtml('')).toBe('')
-  })
-
-  it('should handle falsy values correctly', () => {
-    expect(stripHtml(0)).toBe('0')
-    expect(stripHtml(false)).toBe('false')
-  })
-
-  it('should convert <br> tags to line-breaks', () => {
-    expect(stripHtml('hello<br>world')).toBe('hello\nworld')
-    expect(stripHtml('hello<br/>world')).toBe('hello\nworld')
-    expect(stripHtml('hello<br />world')).toBe('hello\nworld')
-  })
-
-  it('should convert <p> tags to line-breaks', () => {
-    expect(stripHtml('<p>First paragraph</p><p>Second paragraph</p>'))
-      .toBe('First paragraph\nSecond paragraph')
-    expect(stripHtml('<p>Only paragraph</p>'))
-      .toBe('Only paragraph')
-  })
-
-  it('should trim leading and trailing whitespace', () => {
-    expect(stripHtml('  <p>text</p>  ')).toBe('text')
-    expect(stripHtml('<p>  text  </p>')).toBe('text')
-  })
-})

package/src/index.test.js

@@ -1,7 +0,0 @@
-import * as index from './index.js'
-
-describe('index', () => {
-  it('exports all symbols', () => {
-    expect(index).toMatchSnapshot()
-  })
-})