@radio-garden/ditojs-utils 2.85.0-0.5067ad799

package/src/object/pickBy.test.js

@@ -0,0 +1,48 @@
+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/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/camelize.js

@@ -0,0 +1,14 @@
+export function camelize(str, pascalCase = false) {
+  return str
+    ? str
+        // Trim beginnings and ends
+        .replace(/^[-_\s]+|[-_\s]+$/g, '')
+        .replace(
+          /(^|[-_\s]+)(\w)([A-Z]*)([a-z]*)/g,
+          (all, sep, first, upperRest, lowerRest) =>
+            `${
+              pascalCase || sep ? first.toUpperCase() : first.toLowerCase()
+            }${upperRest.toLowerCase()}${lowerRest}`
+        )
+    : ''
+}

package/src/string/camelize.test.js

@@ -0,0 +1,37 @@
+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.js

@@ -0,0 +1,7 @@
+export function capitalize(str) {
+  return str
+    ? str.replace(/(^|[^a-zA-Z\u00C0-\u017F'])([a-zA-Z\u00C0-\u017F])/g, chr =>
+        chr.toUpperCase()
+      )
+    : ''
+}

package/src/string/capitalize.test.js

@@ -0,0 +1,33 @@
+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.js

@@ -0,0 +1,27 @@
+export function decamelize(str, sep = ' ') {
+  return str
+    ? str
+        .replace(
+          // TODO: Once JavaScript supports Unicode property escapes in regexps,
+          // switch to better parsing that matches non-ASCII uppercase letters:
+          // /([\p{Ll}\d])(\p{Lu})/gu
+          // See: https://caniuse.com/?search=Unicode%20property%20escape
+          /(^\s+)|(\s+$)|([a-z\d])([A-Z])|(?<=\S)\s+(?=\S)/g,
+          (all, leading, trailing, lower, upper) =>
+            lower
+              ? `${lower}${sep}${upper}`
+              : leading || trailing
+                ? ''
+                : sep
+        )
+        .toLowerCase()
+    : ''
+}
+
+export function hyphenate(str) {
+  return decamelize(str, '-')
+}
+
+export function underscore(str) {
+  return decamelize(str, '_')
+}

package/src/string/decamelize.test.js

@@ -0,0 +1,83 @@
+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.js

@@ -0,0 +1,69 @@
+import { asArray } from '../base/index.js'
+
+// ES6 string tag that strips indentation from multi-line strings
+// Based on, and further improved from https://github.com/dmnd/dedent
+export function deindent(strings, ...values) {
+  // Small helper to determine the actual line-break used in the strings, based
+  // on the  line-breaks encountered.
+  const getLineBreak = line => line.match(/^(\n|\r\n|\r)/)?.[1] || '\n'
+
+  strings = asArray(strings)
+  // First, perform interpolation
+  let parts = []
+  for (let i = 0; i < strings.length; i++) {
+    parts.push(
+      strings[i]
+        // Join lines when there is a line-break suppressed by a preceding '\\'
+        .replace(/\\\n\s*/g, '')
+        // Handle escaped back-ticks
+        .replace(/\\`/g, '`')
+    )
+    if (i < values.length) {
+      // See if the value itself contains multiple lines, and if so, indent
+      // each of them by the whitespace that precedes it except the first.
+      const value = values[i].toString()
+      const lines = value.split(/\n|\r\n|\r/)
+      if (lines.length > 1) {
+        // Determine the indent by finding the immediately preceding white-space
+        // up to the previous line-break or the beginning of the string.
+        // (?:^[\n\r]*|[\n\r])  # Start at either the beginning or the previous
+        //                      # line break.
+        // (?:[\n\r]*)          # The line break
+        // (\s+)                # Collect the indenting white-space...
+        // (?:[^\n\r]*)$        # ...up to the end or the next word, but in last
+        //                      # line, by making sure no line breaks follow
+        //                      # until the end.
+        const str = parts.join('')
+        const match = str.match(
+          /((?:^[\n\r]*|[\n\r])(?:[\n\r]*))(\s+)(?:[^\n\r]*)$/
+        )
+        const [, lineBreaks = '', indent = ''] = match || []
+        parts = [str]
+        parts.push(lines.join(`${getLineBreak(lineBreaks)}${indent}`))
+      } else {
+        parts.push(value)
+      }
+    }
+  }
+  const str = parts.join('')
+  const lines = str.split(/\n|\r\n|\r/)
+  // Remove the first line-break at the beginning of the result, to allow this:
+  // const value = `
+  //   content...
+  //   ` // line break at the end remains
+  let offset = 0
+  if (!lines[0]) {
+    lines.shift()
+    offset++
+  }
+  let indent = Infinity
+  for (const line of lines) {
+    const match = line.match(/^(\s*)\S+/)
+    if (match) {
+      indent = Math.min(indent, match[1].length)
+    }
+  }
+  const index = lines[0].length + offset
+  const lineBreak = getLineBreak(str.slice(index, index + 2))
+  return lines.map(line => line.slice(indent)).join(lineBreak)
+}

package/src/string/deindent.test.js

@@ -0,0 +1,181 @@
+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/escapeRegexp.js

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

package/src/string/format.js

@@ -0,0 +1,109 @@
+import { isNumber, isDate, isObject } from '../base/index.js'
+
+export const defaultFormats = {
+  number: {
+    style: 'decimal'
+  },
+  date: {
+    day: 'numeric',
+    month: 'long',
+    year: 'numeric'
+  },
+  time: {
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit'
+  }
+}
+
+export function format(value, {
+  locale = 'en-US',
+  number,
+  date,
+  time,
+  defaults = defaultFormats
+} = {}) {
+  const formats = { number, date, time }
+  const defaultValue = number || date || time ? undefined : true
+  const getOptions = name => {
+    const defaultOption = defaults[name]
+    const option = formats[name] ?? defaultValue
+    return option === true
+      ? defaultOption
+      : isObject(option)
+        ? Object.entries({
+            ...defaultOption,
+            ...option
+          }).reduce((opt, [key, value]) => {
+            if (value !== false) {
+              opt[key] = value
+            }
+            return opt
+          }, {})
+        : {}
+  }
+
+  if (value != null) {
+    if (number) {
+      value = isNumber(value) ? value : parseFloat(value)
+    } else if (date || time) {
+      value = isDate(value) ? value : new Date(value)
+    }
+  }
+
+  let options
+  if (isNumber(value)) {
+    if (number === false) {
+      return ''
+    } else {
+      options = getOptions('number')
+      if (options.format) {
+        // Support custom post-formatting of number formats,
+        // e.g. to replace decimals and such:
+        const parts = new Intl.NumberFormat(locale, options)
+          .formatToParts(value)
+        return parts
+          .map(
+            ({ type, value }) => options.format(value, type, options) ?? value
+          )
+          .join('')
+      }
+    }
+  } else if (isDate(value)) {
+    if (date === false && time === false) {
+      return ''
+    } else {
+      // Flatten the separate date / time options down to one
+      const opts = {
+        date: getOptions('date'),
+        time: getOptions('time')
+      }
+      options = {
+        ...opts.date,
+        ...opts.time
+      }
+      if (options.format) {
+        // Support custom post-formatting of both time and date formats,
+        // e.g. to replace separators and such:
+        const parts = new Intl.DateTimeFormat(locale, options)
+          .formatToParts(value)
+        let modeOpts = null
+        return parts
+          .map(({ type, value }) => {
+            if (type !== 'literal') {
+              // Switch mode between date/time to pick the right format method:
+              const mode = ['weekday', 'day', 'month', 'year'].includes(type)
+                ? 'date'
+                : 'time'
+              modeOpts = opts[mode]
+            }
+            return modeOpts?.format?.(value, type, modeOpts) ?? value
+          })
+          .join('')
+      }
+    }
+  }
+  return value != null
+    ? value.toLocaleString(locale, options)
+    : value
+}