@ditojs/utils 3.0.0 → 3.1.1

package/src/object/pickBy.test.js

@@ -1,48 +0,0 @@
-import { pickBy } from './pickBy.js'
-
-describe('pickBy()', () => {
-  it('should work with a callback argument', () => {
-    const object = { a: 1, b: 2, c: 3, d: 4 }
-    const actual = pickBy(object, n => n === 1 || n === 3)
-    expect(actual).toStrictEqual({ a: 1, c: 3 })
-  })
-
-  it('should support string property accessor for truthy values', () => {
-    const users = {
-      user1: { name: 'Alice', active: true },
-      user2: { name: 'Bob', active: false },
-      user3: { name: 'Charlie', active: true }
-    }
-    const actual = pickBy(users, 'active')
-    expect(actual).toStrictEqual({
-      user1: { name: 'Alice', active: true },
-      user3: { name: 'Charlie', active: true }
-    })
-  })
-
-  it('should filter by numeric property with string accessor', () => {
-    const items = {
-      a: { score: 0 },
-      b: { score: 5 },
-      c: { score: 10 }
-    }
-    const actual = pickBy(items, 'score')
-    expect(actual).toStrictEqual({
-      b: { score: 5 },
-      c: { score: 10 }
-    })
-  })
-
-  it('should filter by string property with string accessor', () => {
-    const data = {
-      a: { label: '' },
-      b: { label: 'test' },
-      c: { label: 'value' }
-    }
-    const actual = pickBy(data, 'label')
-    expect(actual).toStrictEqual({
-      b: { label: 'test' },
-      c: { label: 'value' }
-    })
-  })
-})

package/src/string/camelize.test.js

@@ -1,37 +0,0 @@
-import { camelize } from './camelize.js'
-
-const strings = [
-  'foo bar', 'Foo bar', 'foo Bar', 'Foo Bar', 'FOO BAR', 'FooBar', 'fooBar'
-]
-
-describe('camelize()', () => {
-  describe.each([
-    [undefined, 'fooBar'],
-    [false, 'fooBar'],
-    [true, 'FooBar']
-  ])(
-    'camelize(value, %o)',
-    (pascalCase, expected) => {
-      describe.each([
-        ...strings,
-        'foo-bar',
-        'foo_bar',
-        '--foo-bar--',
-        '__foo_bar__'
-      ])(
-        `camelize(%o, ${pascalCase})`,
-        value => {
-          it(`returns ${expected}`, () => {
-            expect(camelize(value, pascalCase)).toBe(expected)
-          })
-        }
-      )
-    }
-  )
-
-  it('should return an empty string if nothing can be processed', () => {
-    expect(camelize()).toBe('')
-    expect(camelize(null)).toBe('')
-    expect(camelize('')).toBe('')
-  })
-})

package/src/string/capitalize.test.js

@@ -1,33 +0,0 @@
-import { capitalize } from './capitalize.js'
-
-describe('capitalize()', () => {
-  it('should capitalize hyphenated text', () => {
-    expect(capitalize('some-hyphenated-text')).toBe('Some-Hyphenated-Text')
-  })
-
-  it('should capitalize underscored text', () => {
-    expect(capitalize('some_underscored_text')).toBe('Some_Underscored_Text')
-  })
-
-  it('should capitalize a camel-cased text', () => {
-    expect(capitalize('someCamelCasedText')).toBe('SomeCamelCasedText')
-  })
-
-  it('should capitalize normal text', () => {
-    expect(capitalize('some normal text')).toBe('Some Normal Text')
-  })
-
-  it('should consider numbers as word-breaks', () => {
-    expect(capitalize('one234five')).toBe('One234Five')
-  })
-
-  it('should support umlauts', () => {
-    expect(capitalize('mäuse häuschen')).toBe('Mäuse Häuschen')
-  })
-
-  it('should return an empty string if nothing can be processed', () => {
-    expect(capitalize()).toBe('')
-    expect(capitalize(null)).toBe('')
-    expect(capitalize('')).toBe('')
-  })
-})

package/src/string/decamelize.test.js

@@ -1,83 +0,0 @@
-import { decamelize, hyphenate, underscore } from './decamelize.js'
-
-const strings = [
-  'foo bar', 'Foo bar', 'foo Bar', 'Foo Bar', 'FOO BAR', 'FooBar', 'fooBar'
-]
-
-describe('decamelize()', () => {
-  const expected = 'foo bar'
-  describe.each(strings)(
-    'decamelize(%o)',
-    value => {
-      it(`returns ${expected}`, () => {
-        expect(decamelize(value)).toBe(expected)
-      })
-    }
-  )
-
-  it('should return an empty string if nothing can be processed', () => {
-    expect(decamelize()).toBe('')
-    expect(decamelize(null)).toBe('')
-    expect(decamelize('')).toBe('')
-  })
-})
-
-describe('hyphenate()', () => {
-  const expected = 'foo-bar'
-  describe.each(strings)(
-    'hyphenate(%o)',
-    value => {
-      it(`returns ${expected}`, () => {
-        expect(hyphenate(value)).toBe(expected)
-      })
-    }
-  )
-
-  it('should hyphenate single space between words', () => {
-    expect(hyphenate('Foo Bar')).toBe('foo-bar')
-  })
-
-  it('should hyphenate multiple spaces', () => {
-    expect(hyphenate('Foo  Bar')).toBe('foo-bar')
-  })
-
-  it('should trim leading whitespace', () => {
-    expect(hyphenate('  Foo Bar')).toBe('foo-bar')
-  })
-
-  it('should trim trailing whitespace', () => {
-    expect(hyphenate('Foo Bar  ')).toBe('foo-bar')
-  })
-
-  it('should hyphenate special characters correctly', () => {
-    expect(hyphenate('Foo & Bar')).toBe('foo-&-bar')
-  })
-})
-
-describe('underscore()', () => {
-  const expected = 'foo_bar'
-  describe.each(strings)(
-    'underscore(%o)',
-    value => {
-      it(`returns ${expected}`, () => {
-        expect(underscore(value)).toBe(expected)
-      })
-    }
-  )
-
-  it('should underscore multiple spaces', () => {
-    expect(underscore('Foo  Bar')).toBe('foo_bar')
-  })
-
-  it('should trim leading whitespace', () => {
-    expect(underscore('  Foo Bar')).toBe('foo_bar')
-  })
-
-  it('should trim trailing whitespace', () => {
-    expect(underscore('Foo Bar  ')).toBe('foo_bar')
-  })
-
-  it('should underscore special characters correctly', () => {
-    expect(underscore('Foo & Bar')).toBe('foo_&_bar')
-  })
-})

package/src/string/deindent.test.js

@@ -1,181 +0,0 @@
-import { deindent } from './deindent.js'
-
-describe('deindent()', () => {
-  it('should deindent indented multi-line strings', () => {
-    expect(
-      deindent`
-        some
-          indented
-            text`
-    ).toBe(
-      `some
-  indented
-    text`
-    )
-  })
-
-  it('should preserve the last line-break', () => {
-    expect(
-      deindent`
-        some
-          indented
-            text
-      `
-    ).toBe(
-      `some
-  indented
-    text
-`
-    )
-  })
-
-  it('should only swallow the first line-break, not those following', () => {
-    expect(
-      deindent`
-
-
-        some
-          indented
-            text
-      `
-    ).toBe(
-      `
-
-some
-  indented
-    text
-`
-    )
-  })
-
-  it('should not swallow the empty line-breaks at the end', () => {
-    expect(
-      deindent`
-        some
-          indented
-            text
-
-
-      `
-    ).toBe(
-      `some
-  indented
-    text
-
-
-`
-    )
-  })
-
-  it('should handle multi-line strings without first or last line', () => {
-    expect(
-      deindent`some
-  indented
-    text
-some
-  indented
-    text`
-    ).toBe(
-      `some
-  indented
-    text
-some
-  indented
-    text`
-    )
-  })
-
-  it('should handle multi-line strings without first or last line', () => {
-    expect(
-      deindent`  some
-    indented
-      text`
-    ).toBe(
-      `some
-  indented
-    text`
-    )
-  })
-
-  it('should correctly indent nested single-line string values', () => {
-    const singleLineText = 'single-line text'
-    expect(
-      deindent`
-        some
-          indented
-            ${singleLineText}
-      `
-    ).toBe(
-      `some
-  indented
-    single-line text
-`
-    )
-  })
-
-  it('should correctly indent unnested multi-line string values', () => {
-    const multiLineText = 'multi-\nline\ntext'
-    expect(
-      deindent`
-some
-indented
-${multiLineText}
-`
-    ).toBe(
-      `some
-indented
-multi-
-line
-text
-`
-    )
-  })
-
-  it('should correctly indent nested multi-line string values', () => {
-    const multiLineText = 'multi-\nline\ntext'
-    expect(
-      deindent`
-        some
-          indented
-            ${multiLineText}
-      `
-    ).toBe(
-      `some
-  indented
-    multi-
-    line
-    text
-`
-    )
-  })
-
-  it('should maintain the indent of prefixed multi-line string values', () => {
-    const multiLineText = 'multi-\nline\ntext'
-    expect(
-      deindent`
-        some
-          indented
-            content: ${multiLineText}
-      `
-    ).toBe(
-      `some
-  indented
-    content: multi-
-    line
-    text
-`
-    )
-  })
-
-  it('should not deindent if the first line starts with text', () => {
-    expect(
-      deindent`some
-        indented
-          text`
-    ).toBe(
-      `some
-        indented
-          text`
-    )
-  })
-})

package/src/string/format.test.js

@@ -1,196 +0,0 @@
-import { format } from './format.js'
-
-describe('format()', () => {
-  const integer = 123456789
-  const float = 123456.789
-  const date = new Date(2012, 5, 9, 22, 45, 30)
-
-  it('should return undefined when no value is given', () => {
-    expect(format()).toBe(undefined)
-  })
-
-  it('should return null when value is null', () => {
-    expect(format(null)).toBe(null)
-    expect(format(null, { number: true })).toBe(null)
-    expect(format(null, { date: true })).toBe(null)
-    expect(format(null, { time: true })).toBe(null)
-  })
-
-  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)).toMatch(/^June 9, 2012 at 10:45:30\sPM$/)
-  })
-
-  it('should format numbers with different locale and default options', () => {
-    expect(format(integer, { locale: 'de-DE' })).toBe('123.456.789')
-    expect(format(float, { locale: 'de-DE' })).toBe('123.456,789')
-  })
-
-  it('should format dates with different locale and default options', () => {
-    expect(format(date, { locale: 'de-DE' })).toBe('9. Juni 2012 um 22:45:30')
-  })
-
-  it('should format string as numbers if told so', () => {
-    expect(
-      format('123456789', { locale: 'de-DE', number: true })
-    ).toBe('123.456.789')
-  })
-
-  it('should format numbers as dates if told so', () => {
-    expect(
-      format(integer, { locale: 'de-DE', date: false, time: true })
-    ).toBe('11:17:36')
-    expect(
-      format(integer, { locale: 'de-DE', date: true, time: false })
-    ).toBe('2. Januar 1970')
-    expect(
-      format(integer, { locale: 'de-DE', date: true, time: true })
-    ).toBe('2. Januar 1970 um 11:17:36')
-  })
-
-  it('should omit time when `options.date = true`', () => {
-    expect(
-      format(date, { locale: 'de-DE', date: true })
-    ).toBe('9. Juni 2012')
-  })
-
-  it('should omit date when `options.time = true`', () => {
-    expect(
-      format(date, { locale: 'de-DE', time: true })
-    ).toBe('22:45:30')
-  })
-
-  it('should omit time when `options.time = false`', () => {
-    expect(
-      format(date, { locale: 'de-DE', time: false })
-    ).toBe('9. Juni 2012')
-  })
-
-  it('should omit date when `options.date = false`', () => {
-    expect(
-      format(date, { locale: 'de-DE', date: false })
-    ).toBe('22:45:30')
-  })
-
-  it(`should return an empty string when \`options.date = false\` and \`options.time = false\``, () => {
-    expect(
-      format(date, { locale: 'de-DE', date: false, time: false })
-    ).toBe('')
-  })
-
-  it('should support fine-grained control of `options.number`', () => {
-    expect(
-      format(integer, {
-        locale: 'de-DE',
-        number: {
-          style: 'currency',
-          currency: 'EUR'
-        }
-      })
-    ).toMatch(/^123\.456\.789,00\s€$/)
-    expect(
-      format(integer, {
-        locale: 'de-CH',
-        number: {
-          style: 'currency',
-          currency: 'CHF'
-        }
-      })
-    ).toMatch(/^CHF\s123['\u2019]456['\u2019]789\.00$/)
-    expect(
-      format(float, {
-        locale: 'de-DE',
-        number: {
-          style: 'currency',
-          currency: 'EUR'
-        }
-      })
-    ).toMatch(/^123\.456,79\s€$/)
-    expect(
-      format(float, {
-        locale: 'de-CH',
-        number: {
-          style: 'currency',
-          currency: 'CHF'
-        }
-      })
-    ).toMatch(/^CHF\s123['\u2019]456\.79$/)
-  })
-
-  it('should support fine-grained control of `options.date`', () => {
-    expect(
-      format(date, {
-        locale: 'de-DE',
-        date: {
-          month: 'short',
-          day: false
-        },
-        time: false
-      })
-    ).toBe('Juni 2012')
-    expect(
-      format(date, {
-        locale: 'de-DE',
-        date: {
-          year: false,
-          day: '2-digit'
-        },
-        time: false
-      })
-    ).toBe('09. Juni')
-  })
-
-  it('should support custom `options.number.format()` overrides', () => {
-    expect(
-      format(integer, {
-        locale: 'en-GB',
-        number: {
-          style: 'currency',
-          currency: 'GBP',
-          format: (value, type) =>
-            type === 'group'
-              ? `’`
-              : type === 'decimal'
-                ? ','
-                : undefined
-        }
-      })
-    ).toBe(`£123’456’789,00`)
-  })
-
-  it(`should support custom \`options.date.format()\` and \`options.time.format()\` overrides`, () => {
-    expect(
-      format(date, {
-        locale: 'en-GB',
-        date: {
-          day: 'numeric',
-          month: 'numeric',
-          year: 'numeric',
-          format: (value, type, options) =>
-            type === 'literal' && options.month === 'numeric'
-              ? value.replace(/\//, '.').replace(/,/, '')
-              : undefined
-        },
-        time: {
-          hour: '2-digit',
-          minute: '2-digit',
-          second: '2-digit',
-          format: value => value.replace(/:/, '_')
-        }
-      })
-    ).toBe('09.06.2012 22_45_30')
-  })
-
-  it('should handle string values', () => {
-    expect(
-      format('2016-05-24T15:54:14.876Z', { date: true })
-    ).toBe('May 24, 2016')
-    expect(
-      format('2016-05-24T15:54:14.876Z', { date: true, time: true })
-    ).toMatch(/^May 24, 2016 at 05:54:14\sPM$/)
-    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

@@ -1,28 +0,0 @@
-import { formatDate } from './formatDate.js'
-
-describe('formatDate()', () => {
-  const date = new Date(2012, 5, 9, 22, 45, 30)
-
-  it('should not format null', () => {
-    expect(formatDate(null, { locale: 'de-DE' })).toBe(null)
-  })
-
-  it('should use the en-US locale by default', () => {
-    expect(formatDate(date)).toMatch(/^June 9, 2012 at 10:45:30\sPM$/)
-    expect(formatDate(date, {})).toMatch(/^June 9, 2012 at 10:45:30\sPM$/)
-  })
-
-  it('should format dates with different locale and default options', () => {
-    expect(formatDate(date, { locale: 'de-DE' }))
-      .toBe('9. Juni 2012 um 22:45:30')
-  })
-
-  it('should format numbers or strings as dates', () => {
-    expect(formatDate(0, { locale: 'de-DE' }))
-      .toBe('1. Januar 1970 um 01:00:00')
-    expect(formatDate(1000000000000, { locale: 'de-DE' }))
-      .toBe('9. September 2001 um 03:46:40')
-    expect(formatDate('04 Dec 1995 00:12:00 GMT', { locale: 'de-DE' }))
-      .toBe('4. Dezember 1995 um 01:12:00')
-  })
-})

package/src/string/formatPlainDate.test.js

@@ -1,13 +0,0 @@
-import { formatPlainDate } from './formatPlainDate.js'
-
-describe('formatPlainDate()', () => {
-  it('should format the local plain date', () => {
-    expect(formatPlainDate(new Date(2026, 4, 14))).toBe('2026-05-14')
-    expect(formatPlainDate(new Date(2026, 4, 14, 23, 59))).toBe(
-      '2026-05-14'
-    )
-    expect(formatPlainDate(new Date(987, 0, 1))).toBe('0987-01-01')
-    // Local mean time, with an offset in seconds in some timezones:
-    expect(formatPlainDate(new Date(1850, 6, 1))).toBe('1850-07-01')
-  })
-})

package/src/string/getCommonPrefix.test.js

@@ -1,23 +0,0 @@
-import { getCommonPrefix, getCommonOffset } from './getCommonPrefix.js'
-
-describe('getCommonPrefix()', () => {
-  it('should return the longest common prefix', () => {
-    expect(getCommonPrefix('interstate', 'intersection')).toBe('inters')
-    expect(getCommonPrefix('intersection', 'interstate')).toBe('inters')
-  })
-  it('should compare case-sensitively', () => {
-    expect(getCommonPrefix('interstate', 'Intersection')).toBe('')
-    expect(getCommonPrefix('InterState', 'Intersection')).toBe('Inter')
-  })
-})
-
-describe('getCommonOffset()', () => {
-  it('should return the longest common prefix', () => {
-    expect(getCommonOffset('interstate', 'intersection')).toBe(6)
-    expect(getCommonOffset('intersection', 'interstate')).toBe(6)
-  })
-  it('should compare case-sensitively', () => {
-    expect(getCommonOffset('interstate', 'Intersection')).toBe(0)
-    expect(getCommonOffset('InterState', 'Intersection')).toBe(5)
-  })
-})

package/src/string/isAbsoluteUrl.test.js

@@ -1,15 +0,0 @@
-import { isAbsoluteUrl } from './isAbsoluteUrl.js'
-
-describe('isAbsoluteUrl()', () => {
-  it('should return true for absolute URLs starting with schemas', () => {
-    expect(isAbsoluteUrl('http://lineto.com')).toBe(true)
-    expect(isAbsoluteUrl('https://lineto.com')).toBe(true)
-    expect(isAbsoluteUrl('ftp://lineto.com')).toBe(true)
-    expect(isAbsoluteUrl('file:///Users/lineto')).toBe(true)
-    expect(isAbsoluteUrl('mailto:user@lineto.com')).toBe(true)
-    expect(isAbsoluteUrl('//lineto.com')).toBe(true)
-    expect(isAbsoluteUrl('/static/index.html')).toBe(false)
-    expect(isAbsoluteUrl('../index.html')).toBe(false)
-    expect(isAbsoluteUrl('../static//index.html')).toBe(false)
-  })
-})