@ditojs/utils 3.0.0 → 3.1.1

package/src/string/labelize.test.js

@@ -1,39 +0,0 @@
-import { labelize } from './labelize.js'
-
-describe('labelize()', () => {
-  it('should labelize hyphenated text', () => {
-    expect(labelize('some-hyphenated-text')).toBe('Some Hyphenated Text')
-    expect(labelize('one-&-two', true)).toBe('One & Two')
-    expect(labelize('one-2-three', true)).toBe('One 2 Three')
-  })
-
-  it('should labelize underscored text', () => {
-    expect(labelize('some_underscored_text')).toBe('Some Underscored Text')
-  })
-
-  it('should labelize camel-cased text', () => {
-    expect(labelize('SomeCamelCasedText')).toBe('Some Camel Cased Text')
-  })
-
-  it('should labelize normal text', () => {
-    expect(labelize('some normal text')).toBe('Some Normal Text')
-  })
-
-  it('should split numbers and words', () => {
-    expect(labelize('one2')).toBe('One 2')
-  })
-
-  it('should split words and numbers both sides', () => {
-    expect(labelize('one2three')).toBe('One 2 Three')
-  })
-
-  it('should keep multiple numbers together', () => {
-    expect(labelize('one234five')).toBe('One 234 Five')
-  })
-
-  it('should return an empty string if nothing can be processed', () => {
-    expect(labelize()).toBe('')
-    expect(labelize(null)).toBe('')
-    expect(labelize('')).toBe('')
-  })
-})

package/src/string/parsePlainDate.test.js

@@ -1,20 +0,0 @@
-import { parsePlainDate } from './parsePlainDate.js'
-
-describe('parsePlainDate()', () => {
-  it('should parse plain dates as local midnight', () => {
-    expect(parsePlainDate('2026-05-14')).toEqual(new Date(2026, 4, 14))
-    expect(parsePlainDate('1850-07-01')).toEqual(new Date(1850, 6, 1))
-  })
-
-  it('should return null for other values', () => {
-    expect(parsePlainDate(null)).toBe(null)
-    expect(parsePlainDate('')).toBe(null)
-    expect(parsePlainDate('2026-05-14T00:00:00.000Z')).toBe(null)
-    expect(parsePlainDate('14.05.2026')).toBe(null)
-  })
-
-  it('should return null for invalid dates', () => {
-    expect(parsePlainDate('2026-02-30')).toBe(null)
-    expect(parsePlainDate('2026-13-01')).toBe(null)
-  })
-})

package/src/timer/debounce.test.js

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

package/src/timer/debounceAsync.test.js

@@ -1,143 +0,0 @@
-import { debounceAsync } from './debounceAsync.js'
-import { vi } from 'vitest'
-
-// 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 = vi.fn()
-    const debounced = debounceAsync(func, 1000)
-    for (let i = 0; i < 10; i++) {
-      vi.advanceTimersByTime(500)
-      debounced()
-    }
-    expect(func).toBeCalledTimes(0)
-  })
-
-  it('should execute just once if an interval is big enough', () => {
-    const func = vi.fn()
-    const debounced = debounceAsync(func, 1000)
-    for (let i = 0; i < 10; i++) {
-      vi.advanceTimersByTime(500)
-      debounced()
-    }
-    vi.advanceTimersByTime(1000)
-    debounced()
-    expect(func).toBeCalledTimes(1)
-  })
-
-  it('should pass through argument', async () => {
-    expect.assertions(2)
-    const func = vi.fn(async value => value)
-    const debounced = debounceAsync(func, 1000)
-    const promise = debounced(fixture)
-    vi.advanceTimersByTime(1000)
-    expect(await promise).toBe(fixture)
-    expect(func).toBeCalledTimes(1)
-  })
-
-  it('should pass through return value', async () => {
-    expect.assertions(2)
-    const func = vi.fn().mockResolvedValueOnce(fixture)
-    const debounced = debounceAsync(func, 1000)
-    const promises = []
-    promises.push(debounced())
-    vi.advanceTimersByTime(1000)
-    promises.push(debounced())
-    expect(await Promise.all(promises)).toStrictEqual([fixture, fixture])
-    expect(func).toBeCalledTimes(1)
-  })
-
-  it('should pass through `this`', async () => {
-    expect.assertions(2)
-    const func = vi.fn(async function () {
-      return this
-    })
-    const debounced = debounceAsync(func, 1000)
-    const obj = {}
-    const promises = []
-    promises.push(debounced.call(obj))
-    vi.advanceTimersByTime(1000)
-    promises.push(debounced.call(obj))
-    expect(await Promise.all(promises)).toStrictEqual([obj, obj])
-    expect(func).toBeCalledTimes(1)
-  })
-
-  it('should allow to cancel', async () => {
-    expect.assertions(6)
-    const func = vi.fn()
-    const debounced = debounceAsync(func, 1000)
-    const promise = debounced()
-    vi.advanceTimersByTime(500)
-    expect(debounced.cancel()).toBe(true)
-    expect(debounced.cancel()).toBe(false)
-    vi.advanceTimersByTime(500)
-    expect(func).toBeCalledTimes(0)
-    expect(await promise).toBeUndefined()
-    vi.advanceTimersByTime(1000)
-    expect(func).toBeCalledTimes(0)
-    await debounced()
-    vi.advanceTimersByTime(1000)
-    expect(func).toBeCalledTimes(1)
-  })
-
-  it('should execute once immediately if intervals are less than wait', async () => {
-    expect.assertions(2)
-    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++) {
-      vi.advanceTimersByTime(500)
-      promises.push(debounced())
-    }
-    await Promise.all(promises)
-    expect(func).toBeCalledTimes(1)
-  })
-
-  it('should execute twice immediately with long enough intervals', async () => {
-    expect.assertions(3)
-    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++) {
-      vi.advanceTimersByTime(500)
-      promises.push(debounced())
-    }
-    expect(func).toBeCalledTimes(1)
-    vi.advanceTimersByTime(1000)
-    promises.push(debounced())
-    await Promise.all(promises)
-    expect(func).toBeCalledTimes(2)
-  })
-
-  it('should only reject the last waiting promise', async () => {
-    expect.assertions(5)
-    let count = 0
-    const func = vi.fn(() => {
-      if (++count > 1) {
-        throw new Error('boom')
-      }
-    })
-    const debounced = debounceAsync(func, { delay: 1000, immediate: true })
-    const promises = []
-    promises.push(debounced())
-    expect(func).toBeCalledTimes(1)
-    for (let i = 0; i < 10; i++) {
-      vi.advanceTimersByTime(500)
-      promises.push(debounced())
-    }
-    expect(func).toBeCalledTimes(1)
-    vi.advanceTimersByTime(1000)
-    await expect(debounced()).rejects.toThrow('boom')
-    const results = await Promise.all(promises)
-    expect(results).toStrictEqual(new Array(11).fill(undefined))
-    expect(func).toBeCalledTimes(2)
-  })
-})