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

package/README.md

@@ -0,0 +1,6 @@
+# Dito.js Utility Functions
+
+Dito.js is a declarative and modern web framework with a focus on API driven
+development, based on Koa.js, Objection.js and Vue.js
+
+Released in 2018 under the MIT license, with support by https://lineto.com/

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@radio-garden/ditojs-utils",
+  "version": "2.85.0-0.5067ad799",
+  "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",
+  "author": "Jürg Lehni <juerg@scratchdisk.com> (http://scratchdisk.com)",
+  "license": "MIT",
+  "main": "./src/index.js",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./src/index.js",
+      "require": "./src/index.js"
+    }
+  },
+  "files": [
+    "src/",
+    "types/"
+  ],
+  "scripts": {
+    "types": "tsc --noEmit types/index.d.ts"
+  },
+  "engines": {
+    "node": ">= 20.0.0"
+  },
+  "browserslist": [
+    "node >= 18",
+    "> 1%",
+    "last 2 versions",
+    "ie >= 11",
+    "ie_mob >= 11"
+  ],
+  "dependencies": {
+    "punycode": "^2.3.1"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "gitHead": "5067ad799",
+  "gitBranch": "chore/improve-ts-types"
+}

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

@@ -0,0 +1,88 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`index > exports all symbols 1`] = `
+{
+  "asArray": [Function],
+  "asFunction": [Function],
+  "asObject": [Function],
+  "assignDeeply": [Function],
+  "camelize": [Function],
+  "capitalize": [Function],
+  "clone": [Function],
+  "debounce": [Function],
+  "debounceAsync": [Function],
+  "decamelize": [Function],
+  "defaultFormats": {
+    "date": {
+      "day": "numeric",
+      "month": "long",
+      "year": "numeric",
+    },
+    "number": {
+      "style": "decimal",
+    },
+    "time": {
+      "hour": "2-digit",
+      "minute": "2-digit",
+      "second": "2-digit",
+    },
+  },
+  "deindent": [Function],
+  "deprecate": [Function],
+  "equals": [Function],
+  "escapeHtml": [Function],
+  "escapeRegexp": [Function],
+  "flatten": [Function],
+  "format": [Function],
+  "formatDate": [Function],
+  "getCommonOffset": [Function],
+  "getCommonPrefix": [Function],
+  "getEntriesAtDataPath": [Function],
+  "getValueAtDataPath": [Function],
+  "groupBy": [Function],
+  "hyphenate": [Function],
+  "is": [Function],
+  "isAbsoluteUrl": [Function],
+  "isArray": [Function],
+  "isArrayLike": [Function],
+  "isAsync": [Function],
+  "isBoolean": [Function],
+  "isCreditCard": [Function],
+  "isDate": [Function],
+  "isDomain": [Function],
+  "isEmail": [Function],
+  "isEmpty": [Function],
+  "isFunction": [Function],
+  "isHostname": [Function],
+  "isInteger": [Function],
+  "isModule": [Function],
+  "isNumber": [Function],
+  "isObject": [Function],
+  "isPlainArray": [Function],
+  "isPlainObject": [Function],
+  "isPromise": [Function],
+  "isRegExp": [Function],
+  "isString": [Function],
+  "isUrl": [Function],
+  "labelize": [Function],
+  "mapConcurrently": [Function],
+  "mapKeys": [Function],
+  "mapSequentially": [Function],
+  "mapValues": [Function],
+  "mergeDeeply": [Function],
+  "mixin": [Function],
+  "normalizeDataPath": [Function],
+  "parseDataPath": [Function],
+  "pick": [Function],
+  "pickBy": [Function],
+  "setDataPathEntries": [Function],
+  "setValueAtDataPath": [Function],
+  "shuffle": [Function],
+  "stripHtml": [Function],
+  "stripTags": [Function],
+  "toAsync": [Function],
+  "toCallback": [Function],
+  "toPromiseCallback": [Function],
+  "underscore": [Function],
+}
+`;

package/src/array/flatten.js

@@ -0,0 +1,14 @@
+import { isArray } from '../base/index.js'
+
+export function flatten(array, maxDepth = Infinity, _depth = 0) {
+  const res = []
+  for (let i = 0, l = array.length; i < l; i++) {
+    const value = array[i]
+    if (_depth < maxDepth && isArray(value)) {
+      res.push(...flatten(value, maxDepth, _depth + 1))
+    } else {
+      res.push(value)
+    }
+  }
+  return res
+}

package/src/array/flattten.test.js

@@ -0,0 +1,29 @@
+import { flatten } from './flatten.js'
+
+describe('flatten()', () => {
+  it('should support flattening of nested arrays', () => {
+    const array = [1, [2, [3, [4]], 5]]
+    expect(flatten(array)).toStrictEqual([1, 2, 3, 4, 5])
+    expect(flatten(array, 1)).toStrictEqual([1, 2, [3, [4]], 5])
+    expect(flatten(array, 2)).toStrictEqual([1, 2, 3, [4], 5])
+  })
+
+  it('should work with empty arrays', () => {
+    const array = [[], [[]], [[], [[[]]]]]
+
+    expect(flatten(array)).toStrictEqual([])
+    expect(flatten(array, 1)).toStrictEqual([[], [], [[[]]]])
+    expect(flatten(array, 2)).toStrictEqual([[[]]])
+  })
+
+  it('should treat sparse arrays as dense', () => {
+    const array = [[1, 2, 3], Array(3)]
+    const expected = [1, 2, 3]
+    expected.push(undefined, undefined, undefined)
+    expect(flatten(array)).toStrictEqual(expected)
+  })
+
+  it('should return an empty array for non array-like objects', () => {
+    expect(flatten({ 0: 'a' })).toStrictEqual([])
+  })
+})

package/src/array/index.js

@@ -0,0 +1,2 @@
+export * from './flatten.js'
+export * from './shuffle.js'

package/src/array/shuffle.js

@@ -0,0 +1,11 @@
+export function shuffle(array) {
+  // Do the Fisher-Yates (aka Knuth) Shuffle:
+  const res = array.slice()
+  for (let i = array.length; i; ) {
+    const r = Math.floor(Math.random() * i)
+    const t = res[--i]
+    res[i] = res[r]
+    res[r] = t
+  }
+  return res
+}

package/src/array/shuffle.test.js

@@ -0,0 +1,25 @@
+import { shuffle } from './shuffle.js'
+
+describe('shuffle()', () => {
+  const array = [1, 2, 3]
+
+  it('should return a new array', () => {
+    expect(shuffle(array)).not.toBe(array)
+  })
+
+  it(`should contain the same elements after a collection is shuffled and sorted again`, () => {
+    expect(shuffle(array).sort()).toStrictEqual(array)
+  })
+
+  it('should shuffle small collections', () => {
+    const results = {}
+    for (let i = 0; i < 1000; i++) {
+      const res = shuffle([1, 2])
+      results[res] = res
+    }
+    const sorted = Object.entries(results)
+      .sort()
+      .map(([, value]) => value)
+    expect(sorted).toStrictEqual([[1, 2], [2, 1]])
+  })
+})

package/src/base/base.js

@@ -0,0 +1,118 @@
+export const { isArray } = Array
+const { toString } = Object.prototype
+
+export const is = (
+  Object.is ||
+  // SameValue algorithm:
+  // istanbul ignore next
+  ((x, y) => (x === y ? x !== 0 || 1 / x === 1 / y : x !== x && y !== y))
+)
+
+export function isPlainObject(arg) {
+  const ctor = arg?.constructor
+  // We also need to check for ctor.name === 'Object', in case this is an object
+  // from another global scope (e.g. another vm context in Node.js).
+  // When an value has no constructor, it was created with `Object.create(null)`
+  return !!(
+    arg && (
+      ctor && (ctor === Object || ctor.name === 'Object') ||
+      !ctor && !isModule(arg)
+    )
+  )
+}
+
+export function isPlainArray(arg) {
+  const ctor = arg?.constructor
+  // See `isPlainObject()` for explanation.
+  return !!(arg && ctor && (ctor === Array || ctor.name === 'Array'))
+}
+
+export function isObject(arg) {
+  return !!arg && typeof arg === 'object' && !isArray(arg)
+}
+
+export function isFunction(arg) {
+  return !!arg && typeof arg === 'function'
+}
+
+function getPrimitiveCheck(name) {
+  // Create checking function for all primitive types (number, string, boolean)
+  // that also matches their Object wrappers. We can't check `valueOf()` returns
+  // here because `new Date().valueOf()` also returns a number.
+  const typeName = name.toLowerCase()
+  const toStringName = `[object ${name}]`
+  return function (arg) {
+    const type = typeof arg
+    return (
+      type === typeName ||
+      !!arg && type === 'object' && toString.call(arg) === toStringName
+    )
+  }
+}
+
+export const isModule = getPrimitiveCheck('Module')
+
+export const isNumber = getPrimitiveCheck('Number')
+
+export const isString = getPrimitiveCheck('String')
+
+export const isBoolean = getPrimitiveCheck('Boolean')
+
+export function isDate(arg) {
+  return !!arg && toString.call(arg) === '[object Date]'
+}
+
+export function isRegExp(arg) {
+  return !!arg && toString.call(arg) === '[object RegExp]'
+}
+
+export function isPromise(arg) {
+  return !!arg && isFunction(arg.then) && isFunction(arg.catch)
+}
+
+export const isInteger = (
+  Number.isInteger ||
+  function isInteger(arg) {
+    return (
+      isNumber(arg) &&
+      isFinite(arg) &&
+      Math.floor(arg) === arg
+    )
+  }
+)
+
+export function isAsync(arg) {
+  return arg?.[Symbol.toStringTag] === 'AsyncFunction'
+}
+
+export function isArrayLike(arg) {
+  const length = arg?.length
+  return (
+    length != null &&
+    !isFunction(arg) &&
+    isNumber(length) &&
+    length >= 0 &&
+    length <= Number.MAX_SAFE_INTEGER
+  )
+}
+
+export function isEmpty(arg) {
+  return (
+    arg == null ||
+    isArrayLike(arg) && arg.length === 0 ||
+    isObject(arg) && Object.keys(arg).length === 0
+  )
+}
+
+export function asObject(arg) {
+  // http://2ality.com/2011/04/javascript-converting-any-value-to.html
+  return arg != null ? Object(arg) : arg
+}
+
+export function asArray(arg) {
+  return isArray(arg) ? arg : arg !== undefined ? [arg] : []
+}
+
+export function asFunction(arg) {
+  return isFunction(arg) ? arg : () => arg
+}