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

package/src/string/format.test.js

@@ -0,0 +1,196 @@
+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’456’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’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.js

@@ -0,0 +1,13 @@
+import { isDate } from '../base/index.js'
+import { format } from './format.js'
+
+export function formatDate(value, {
+  locale = 'en-US',
+  date = true,
+  time = true
+} = {}) {
+  return format(
+    isDate(value) || value == null ? value : new Date(value),
+    { locale, date, time }
+  )
+}

package/src/string/formatDate.test.js

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

@@ -0,0 +1,35 @@
+/**
+ * Computes the index of the end of the longest common prefix from an array of
+ * strings.
+ * @param {string[]} strings
+ * @returns {number}
+ */
+export function getCommonOffset(...strings) {
+  if (strings.length === 0) return 0
+  let offset = 0
+  const string1 = strings[0]
+  const length1 = string1.length
+  for (let i = 0; i < length1; i++) {
+    const char = string1.charCodeAt(i)
+    for (let j = 1; j < strings.length; j++) {
+      const string2 = strings[j]
+      if (i >= string2.length || char !== string2.charCodeAt(i)) {
+        return offset
+      }
+    }
+    offset++
+  }
+  return offset
+}
+
+/**
+ * Computes the longest common prefix from an array of strings.
+ *
+ * @param {string[]} strings
+ * @returns {string}
+ */
+export function getCommonPrefix(...strings) {
+  return strings.length === 0
+    ? ''
+    : strings[0].slice(0, getCommonOffset(...strings))
+}

package/src/string/getCommonPrefix.test.js

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

@@ -0,0 +1,15 @@
+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'
+export * from './isAbsoluteUrl.js'
+export * from './isCreditCard.js'
+export * from './isDomain.js'
+export * from './isEmail.js'
+export * from './isHostname.js'
+export * from './isUrl.js'
+export * from './labelize.js'

package/src/string/isAbsoluteUrl.js

@@ -0,0 +1,7 @@
+export function isAbsoluteUrl(str) {
+  // A URL is considered absolute if it begins with "<scheme>:" or "//"
+  // (protocol-relative URL).  RFC 3986 defines scheme name as a sequence of
+  // characters beginning with a letter and followed by any combination of
+  // letters, digits, plus, period, or hyphen.
+  return !!(str && /^([a-z][a-z\d+-.]*:)|^\/\//i.test(str))
+}

package/src/string/isAbsoluteUrl.test.js

@@ -0,0 +1,15 @@
+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)
+  })
+})

package/src/string/isCreditCard.js

@@ -0,0 +1,21 @@
+const creditCardRegExp =
+  /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|(222[1-9]|22[3-9][0-9]|2[3-6][0-9]{2}|27[01][0-9]|2720)[0-9]{12}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11})|62[0-9]{14}$/
+
+export function isCreditCard(str) {
+  str = str && str.replace(/[\s-]+/g, '')
+  if (!str || str.length > 16 || !creditCardRegExp.test(str)) {
+    return false
+  }
+  // The Luhn-Algorithm:
+  let check = 0
+  let even = false
+  for (let i = str.length - 1; i >= 0; i--) {
+    let digit = +str[i]
+    if (even && (digit *= 2) > 9) {
+      digit -= 9
+    }
+    check += digit
+    even = !even
+  }
+  return (check % 10) === 0
+}

package/src/string/isCreditCard.test.js

@@ -0,0 +1,50 @@
+import { isCreditCard } from './isCreditCard.js'
+
+describe('isCreditCard()', () => {
+  describe.each([
+    '375556917985515',
+    '36050234196908',
+    '4716461583322103',
+    '4716-2210-5188-5662',
+    '4929 7226 5379 7141',
+    '5398228707871527',
+    '6283875070985593',
+    '6263892624162870',
+    '6234917882863855',
+    '6234698580215388',
+    '6226050967750613',
+    '6246281879460688',
+    '2222155765072228',
+    '2225855203075256',
+    '2720428011723762',
+    '2718760626256570'
+  ])(
+    'isCreditCard(%o)',
+    str => {
+      it('returns true', () => {
+        expect(isCreditCard(str)).toBe(true)
+      })
+    }
+  )
+  describe.each([
+    false,
+    'foo',
+    'foo',
+    '5398228707871528',
+    '2718760626256571',
+    '2721465526338453',
+    '2220175103860763',
+    '375556917985515999999993',
+    '899999996234917882863855',
+    'prefix6234917882863855',
+    '623491788middle2863855',
+    '6234917882863855suffix'
+  ])(
+    'isCreditCard(%o)',
+    str => {
+      it('returns false', () => {
+        expect(isCreditCard(str)).toBe(false)
+      })
+    }
+  )
+})

package/src/string/isDomain.js

@@ -0,0 +1,9 @@
+import punycode from 'punycode/punycode.js'
+
+// Best effort approach, allowing Internationalized domain name (with punycode)
+const domainRegExp =
+  /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$/i
+
+export function isDomain(str) {
+  return !!(str && domainRegExp.test(punycode.toASCII(str)))
+}

package/src/string/isDomain.test.js

@@ -0,0 +1,15 @@
+import { isDomain } from './isDomain.js'
+
+describe('isDomain()', () => {
+  it('should return true for domains', () => {
+    expect(isDomain('lineto.com')).toBe(true)
+    expect(isDomain('www.lineto.com')).toBe(true)
+    expect(isDomain('www.lineto.ch')).toBe(true)
+    expect(isDomain('sub2.sub1.lineto.com')).toBe(true)
+    expect(isDomain('www.lineto.c')).toBe(false)
+    expect(isDomain('lineto_com')).toBe(false)
+    expect(isDomain('line-to.com')).toBe(true)
+    expect(isDomain('line_to.com')).toBe(false)
+    expect(isDomain('lünéto.com')).toBe(true)
+  })
+})

package/src/string/isEmail.js

@@ -0,0 +1,6 @@
+const emailRegExp =
+  /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/i
+
+export function isEmail(str) {
+  return !!(str && emailRegExp.test(str))
+}

package/src/string/isEmail.test.js

@@ -0,0 +1,37 @@
+import { isEmail } from './isEmail.js'
+
+describe('isEmail()', () => {
+  describe.each([
+    'foo@bar.com',
+    'x@x.au',
+    'foo@bar.com.au',
+    'foo+bar@bar.com',
+    'hans.m端ller@test.com',
+    'hans@m端ller.com',
+    'test|123@m端ller.com',
+    'test+ext@gmail.com',
+    'some.name.midd.leNa.me.+extension@GoogleMail.com'
+  ])(
+    'isEmail(%o)',
+    str => {
+      it('returns true', () => {
+        expect(isEmail(str)).toBe(true)
+      })
+    }
+  )
+  describe.each([
+    'invalidemail@',
+    'invalid.com',
+    '@invalid.com',
+    'foo@bar.com.',
+    'foo@bar.co.uk.',
+    'Name foo@bar.co.uk'
+  ])(
+    'isEmail(%o)',
+    str => {
+      it('returns false', () => {
+        expect(isEmail(str)).toBe(false)
+      })
+    }
+  )
+})

package/src/string/isHostname.js

@@ -0,0 +1,8 @@
+// https://tools.ietf.org/html/rfc1034#section-3.5
+// https://tools.ietf.org/html/rfc1123#section-2
+const hostnameRegExp =
+  /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*$/i
+
+export function isHostname(str) {
+  return !!(str && hostnameRegExp.test(str))
+}

package/src/string/isHostname.test.js

@@ -0,0 +1,12 @@
+import { isHostname } from './isHostname.js'
+
+describe('isHostname()', () => {
+  it('should return true for hostnames', () => {
+    expect(isHostname('lineto.com')).toBe(true)
+    expect(isHostname('www.lineto.com')).toBe(true)
+    expect(isHostname('lineto_com')).toBe(false)
+    expect(isHostname('line-to.com')).toBe(true)
+    expect(isHostname('line_to.com')).toBe(false)
+    expect(isHostname('linéto.com')).toBe(false)
+  })
+})

package/src/string/isUrl.js

@@ -0,0 +1,23 @@
+// TODO: There's a contradiction between isUrl() and isAbsoluteUrl(), where
+// isUrl() returns `true` for 'google.com', and isAbsoluteUrl() returns `false`!
+
+const isUrlRegExp = new RegExp(
+  '^((https?|ftps?|mailto|rtsp|mms)?://)?' + // user:pass@
+  "(([0-9a-z_!~*'().&=+$%-]+:)?[0-9a-z_!~*'().&=+$%-]*@)?" +
+  '(' +
+  '(\\d{1,3}\\.){3}\\d{1,3}' + // ip
+  '|' +
+  '([0-9a-z_-]+\\.)*' + // sub-domain: www.
+  '[0-9a-z](?:[0-9a-z_-]{0,61}[0-9a-z])?\\.' + // domain-name
+  // tld - https://tools.ietf.org/id/draft-liman-tld-names-00.html#rfc.section.2
+  '([a-z]{2,61}|xn--[0-9a-z][0-9a-z-]{0,61}[0-9a-z])' +
+  ')' + // top level domain.
+  '(:[0-9]{1,5})?' + // port
+  '((/?)|' + // allow ending in a slash
+  "([/?#][0-9a-z_!~*'().;:@&=+$,%/?#-]+)+/?)$", // path
+  'i'
+)
+
+export function isUrl(str) {
+  return !!(str && isUrlRegExp.test(str))
+}