@ditojs/utils 1.4.3 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/utils",
-  "version": "1.4.3",
+  "version": "1.6.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",
@@ -27,5 +27,5 @@
   "dependencies": {
     "punycode": "^2.1.1"
   },
-  "gitHead": "f2a544aef8ab0a12c7019650cd86558f8365b007"
+  "gitHead": "a442b0e47237fef8aeb65793fa3f5bc6621442ce"
 }

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

@@ -1,7 +1,7 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
+// Vitest Snapshot v1
 
-exports[`index exports all symbols 1`] = `
-Object {
+exports[`index > exports all symbols 1`] = `
+{
   "asArray": [Function],
   "asFunction": [Function],
   "asObject": [Function],
@@ -11,16 +11,16 @@ Object {
   "debounce": [Function],
   "debounceAsync": [Function],
   "decamelize": [Function],
-  "defaultFormats": Object {
-    "date": Object {
+  "defaultFormats": {
+    "date": {
       "day": "numeric",
       "month": "long",
       "year": "numeric",
     },
-    "number": Object {
+    "number": {
       "style": "decimal",
     },
-    "time": Object {
+    "time": {
       "hour": "2-digit",
       "minute": "2-digit",
       "second": "2-digit",
@@ -29,6 +29,7 @@ Object {
   "deindent": [Function],
   "equals": [Function],
   "escapeHtml": [Function],
+  "escapeRegexp": [Function],
   "flatten": [Function],
   "format": [Function],
   "formatDate": [Function],
@@ -77,5 +78,6 @@ Object {
   "toCallback": [Function],
   "toPromiseCallback": [Function],
   "underscore": [Function],
+  Symbol(Symbol.toStringTag): "Module",
 }
 `;

package/src/array/shuffle.test.js

@@ -7,7 +7,7 @@ describe('shuffle()', () => {
     expect(shuffle(array)).not.toBe(array)
   })
 
-  it('should contain the same elements after a collection is shuffled', () => {
+  it(`should contain the same elements after a collection is shuffled and sorted again`, () => {
     expect(shuffle(array).sort()).toStrictEqual(array)
   })
 

package/src/function/toPromiseCallback.test.js

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

package/src/object/clone.test.js

@@ -1,5 +1,5 @@
 import { clone } from './clone.js'
-import { jest } from '@jest/globals'
+import { vi } from 'vitest'
 
 describe('clone()', () => {
   it('should clone objects', () => {
@@ -47,7 +47,7 @@ describe('clone()', () => {
   it('should use clone() methods if available', () => {
     const object = {
       a: 1,
-      clone: jest.fn(() => ({ b: 2 }))
+      clone: vi.fn(() => ({ b: 2 }))
     }
     const copy = clone(object)
     expect(object.clone).toBeCalledTimes(1)

package/src/object/merge.js

@@ -11,10 +11,7 @@ export function merge(target, ...sources) {
         ? clone(target)
         : target
       for (const key of Object.keys(source)) {
-        const value = _merge(target[key], source[key], true)
-        if (value !== undefined || !(key in result)) {
-          result[key] = value
-        }
+        result[key] = _merge(target[key], source[key], true)
       }
       return result
     }

package/src/object/merge.test.js

@@ -80,21 +80,20 @@ describe('merge()', () => {
     expect(actual2.a).toStrictEqual([[4, 5, 3]])
   })
 
-  it('should not overwrite existing values with `undefined` in objects', () => {
+  it('should overwrite existing values with `undefined` in objects', () => {
     const actual = merge({ a: 1 }, { a: undefined, b: undefined })
-    expect(actual).toStrictEqual({ a: 1, b: undefined })
+    expect(actual).toStrictEqual({ a: undefined, b: undefined })
   })
 
-  it('should not overwrite existing values with `undefined` in arrays', () => {
+  it('should overwrite existing values with `undefined` in arrays', () => {
     const array1 = [1]
     array1[2] = 3
     const actual1 = merge([4, 5, 6], array1)
-    const expected1 = [1, 5, 3]
-    expect(actual1).toStrictEqual(expected1)
+    expect(actual1).toStrictEqual([1, 5, 3])
 
     const array2 = [1, undefined, 3]
     const actual2 = merge([4, 5, 6], array2)
-    expect(actual2).toStrictEqual(expected1)
+    expect(actual2).toStrictEqual([1, undefined, 3])
   })
 
   it('should merge regexps', () => {

package/src/string/escapeRegexp.js

@@ -0,0 +1,3 @@
+export function escapeRegexp(string) {
+  return string.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')
+}

package/src/string/index.js

@@ -2,6 +2,7 @@ export * from './camelize.js'
 export * from './capitalize.js'
 export * from './decamelize.js'
 export * from './deindent.js'
+export * from './escapeRegexp.js'
 export * from './format.js'
 export * from './formatDate.js'
 export * from './getCommonPrefix.js'

package/src/string/isDomain.js

@@ -1,4 +1,4 @@
-// eslint-disable-next-line node/no-deprecated-api
+// eslint-disable-next-line n/no-deprecated-api
 import punycode from 'punycode'
 
 // Best effort approach, allowing Internationalized domain name (with punycode)

package/src/timer/debounce.test.js

@@ -1,100 +1,100 @@
 import { debounce } from './debounce.js'
-import { jest } from '@jest/globals'
+import { vi } from 'vitest'
 
-// Tell jest to mock all timeout functions:
-jest.useFakeTimers()
+// Tell vitest to mock all timeout functions:
+vi.useFakeTimers()
 
 describe('debounce()', () => {
   const fixture = Symbol('fixture')
 
   it('should never execute if intervals are less than wait', () => {
-    const func = jest.fn()
+    const func = vi.fn()
     const debounced = debounce(func, 1000)
     for (let i = 0; i < 10; i++) {
-      jest.advanceTimersByTime(500)
+      vi.advanceTimersByTime(500)
       debounced()
     }
     expect(func).toBeCalledTimes(0)
   })
 
   it('should execute just once if an interval is big enough', () => {
-    const func = jest.fn()
+    const func = vi.fn()
     const debounced = debounce(func, 1000)
     for (let i = 0; i < 10; i++) {
-      jest.advanceTimersByTime(500)
+      vi.advanceTimersByTime(500)
       debounced()
     }
-    jest.advanceTimersByTime(1000)
+    vi.advanceTimersByTime(1000)
     debounced()
     expect(func).toBeCalledTimes(1)
   })
 
   it('should pass through argument', async () => {
-    const func = jest.fn(value => value)
+    const func = vi.fn(value => value)
     const debounced = debounce(func, 1000)
     expect(debounced(fixture)).toBeUndefined()
-    jest.advanceTimersByTime(1000)
+    vi.advanceTimersByTime(1000)
     expect(debounced()).toBe(fixture)
     expect(func).toBeCalledTimes(1)
   })
 
   it('should pass through return value', () => {
-    const func = jest.fn().mockReturnValue(fixture)
+    const func = vi.fn().mockReturnValue(fixture)
     const debounced = debounce(func, 1000)
     expect(debounced()).toBeUndefined()
-    jest.advanceTimersByTime(1000)
+    vi.advanceTimersByTime(1000)
     expect(debounced()).toBe(fixture)
     expect(func).toBeCalledTimes(1)
   })
 
   it('should pass through `this`', () => {
-    const func = jest.fn().mockReturnThis()
+    const func = vi.fn().mockReturnThis()
     const debounced = debounce(func, 0)
     const obj = {}
     expect(debounced.call(obj)).toBeUndefined()
-    jest.advanceTimersByTime(1000)
+    vi.advanceTimersByTime(1000)
     expect(debounced.call(obj)).toBe(obj)
   })
 
   it('should allow to cancel', () => {
-    const func = jest.fn()
+    const func = vi.fn()
     const debounced = debounce(func, 1000)
     debounced()
-    jest.advanceTimersByTime(500)
+    vi.advanceTimersByTime(500)
     expect(debounced.cancel()).toBe(true)
     expect(debounced.cancel()).toBe(false)
-    jest.advanceTimersByTime(500)
+    vi.advanceTimersByTime(500)
     expect(func).toBeCalledTimes(0)
-    jest.advanceTimersByTime(1000)
+    vi.advanceTimersByTime(1000)
     expect(func).toBeCalledTimes(0)
     debounced()
-    jest.advanceTimersByTime(1000)
+    vi.advanceTimersByTime(1000)
     expect(func).toBeCalledTimes(1)
   })
 
   it('should execute once immediately if intervals are less than wait', () => {
-    const func = jest.fn()
+    const func = vi.fn()
     const debounced = debounce(func, { delay: 1000, immediate: true })
     debounced()
     expect(func).toBeCalledTimes(1)
     for (let i = 0; i < 10; i++) {
-      jest.advanceTimersByTime(500)
+      vi.advanceTimersByTime(500)
       debounced()
     }
     expect(func).toBeCalledTimes(1)
   })
 
   it(`should execute once immediately and once at the end with long enough intervals`, () => {
-    const func = jest.fn()
+    const func = vi.fn()
     const debounced = debounce(func, { delay: 1000, immediate: true })
     debounced()
     expect(func).toBeCalledTimes(1)
     for (let i = 0; i < 10; i++) {
-      jest.advanceTimersByTime(500)
+      vi.advanceTimersByTime(500)
       debounced()
     }
     expect(func).toBeCalledTimes(1)
-    jest.advanceTimersByTime(1000)
+    vi.advanceTimersByTime(1000)
     debounced()
     expect(func).toBeCalledTimes(2)
   })

package/src/timer/debounceAsync.test.js

@@ -1,51 +1,51 @@
 import { debounceAsync } from './debounceAsync.js'
-import { jest } from '@jest/globals'
+import { vi } from 'vitest'
 
-// Tell jest to mock all timeout functions:
-jest.useFakeTimers()
+// Tell vitest to mock all timeout functions:
+vi.useFakeTimers()
 
 describe('debounceAsync()', () => {
   const fixture = Symbol('fixture')
 
   it('should never execute if intervals are less than wait', () => {
-    const func = jest.fn()
+    const func = vi.fn()
     const debounced = debounceAsync(func, 1000)
     for (let i = 0; i < 10; i++) {
-      jest.advanceTimersByTime(500)
+      vi.advanceTimersByTime(500)
       debounced()
     }
     expect(func).toBeCalledTimes(0)
   })
 
   it('should execute just once if an interval is big enough', () => {
-    const func = jest.fn()
+    const func = vi.fn()
     const debounced = debounceAsync(func, 1000)
     for (let i = 0; i < 10; i++) {
-      jest.advanceTimersByTime(500)
+      vi.advanceTimersByTime(500)
       debounced()
     }
-    jest.advanceTimersByTime(1000)
+    vi.advanceTimersByTime(1000)
     debounced()
     expect(func).toBeCalledTimes(1)
   })
 
   it('should pass through argument', async () => {
     expect.assertions(2)
-    const func = jest.fn(async value => value)
+    const func = vi.fn(async value => value)
     const debounced = debounceAsync(func, 1000)
     const promise = debounced(fixture)
-    jest.advanceTimersByTime(1000)
+    vi.advanceTimersByTime(1000)
     expect(await promise).toBe(fixture)
     expect(func).toBeCalledTimes(1)
   })
 
   it('should pass through return value', async () => {
     expect.assertions(2)
-    const func = jest.fn().mockResolvedValueOnce(fixture)
+    const func = vi.fn().mockResolvedValueOnce(fixture)
     const debounced = debounceAsync(func, 1000)
     const promises = []
     promises.push(debounced())
-    jest.advanceTimersByTime(1000)
+    vi.advanceTimersByTime(1000)
     promises.push(debounced())
     expect(await Promise.all(promises)).toStrictEqual([fixture, fixture])
     expect(func).toBeCalledTimes(1)
@@ -53,12 +53,12 @@ describe('debounceAsync()', () => {
 
   it('should pass through `this`', async () => {
     expect.assertions(2)
-    const func = jest.fn(async function() { return this })
+    const func = vi.fn(async function() { return this })
     const debounced = debounceAsync(func, 1000)
     const obj = {}
     const promises = []
     promises.push(debounced.call(obj))
-    jest.advanceTimersByTime(1000)
+    vi.advanceTimersByTime(1000)
     promises.push(debounced.call(obj))
     expect(await Promise.all(promises)).toStrictEqual([obj, obj])
     expect(func).toBeCalledTimes(1)
@@ -66,19 +66,19 @@ describe('debounceAsync()', () => {
 
   it('should allow to cancel', async () => {
     expect.assertions(6)
-    const func = jest.fn()
+    const func = vi.fn()
     const debounced = debounceAsync(func, 1000)
     const promise = debounced()
-    jest.advanceTimersByTime(500)
+    vi.advanceTimersByTime(500)
     expect(debounced.cancel()).toBe(true)
     expect(debounced.cancel()).toBe(false)
-    jest.advanceTimersByTime(500)
+    vi.advanceTimersByTime(500)
     expect(func).toBeCalledTimes(0)
     expect(await promise).toBeUndefined()
-    jest.advanceTimersByTime(1000)
+    vi.advanceTimersByTime(1000)
     expect(func).toBeCalledTimes(0)
     await debounced()
-    jest.advanceTimersByTime(1000)
+    vi.advanceTimersByTime(1000)
     expect(func).toBeCalledTimes(1)
   })
 
@@ -86,13 +86,13 @@ describe('debounceAsync()', () => {
     'should execute once immediately if intervals are less than wait',
     async () => {
       expect.assertions(2)
-      const func = jest.fn()
+      const func = vi.fn()
       const debounced = debounceAsync(func, { delay: 1000, immediate: true })
       const promises = []
       promises.push(debounced())
       expect(func).toBeCalledTimes(1)
       for (let i = 0; i < 10; i++) {
-        jest.advanceTimersByTime(500)
+        vi.advanceTimersByTime(500)
         promises.push(debounced())
       }
       await Promise.all(promises)
@@ -104,17 +104,17 @@ describe('debounceAsync()', () => {
     'should execute twice immediately with long enough intervals',
     async () => {
       expect.assertions(3)
-      const func = jest.fn()
+      const func = vi.fn()
       const debounced = debounceAsync(func, { delay: 1000, immediate: true })
       const promises = []
       promises.push(debounced())
       expect(func).toBeCalledTimes(1)
       for (let i = 0; i < 10; i++) {
-        jest.advanceTimersByTime(500)
+        vi.advanceTimersByTime(500)
         promises.push(debounced())
       }
       expect(func).toBeCalledTimes(1)
-      jest.advanceTimersByTime(1000)
+      vi.advanceTimersByTime(1000)
       promises.push(debounced())
       await Promise.all(promises)
       expect(func).toBeCalledTimes(2)
@@ -126,7 +126,7 @@ describe('debounceAsync()', () => {
     async () => {
       expect.assertions(5)
       let count = 0
-      const func = jest.fn(() => {
+      const func = vi.fn(() => {
         if (++count > 1) {
           throw new Error('boom')
         }
@@ -136,11 +136,11 @@ describe('debounceAsync()', () => {
       promises.push(debounced())
       expect(func).toBeCalledTimes(1)
       for (let i = 0; i < 10; i++) {
-        jest.advanceTimersByTime(500)
+        vi.advanceTimersByTime(500)
         promises.push(debounced())
       }
       expect(func).toBeCalledTimes(1)
-      jest.advanceTimersByTime(1000)
+      vi.advanceTimersByTime(1000)
       await expect(debounced()).rejects.toThrow('boom')
       const results = await Promise.all(promises)
       expect(results).toStrictEqual(new Array(11).fill(undefined))