@orioro/util 0.1.0 → 0.3.0

package/src/promise/resolveNestedPromises.spec.ts

@@ -1,205 +0,0 @@
-import { deepFreeze, wait } from '../debug'
-import { resolveNestedPromises } from './resolveNestedPromises'
-
-async function asyncDo(delay, fn) {
-  await wait(delay)
-
-  const result = fn()
-  // console.log('asyncDo', result)
-
-  return result
-}
-
-describe('resolveNestedPromises', () => {
-  test('basic', async () => {
-    const obj = {
-      a: asyncDo(100, () => 'A'),
-      b: asyncDo(300, () => 'B'),
-      c: asyncDo(200, () => ({
-        c: 'C',
-        d: asyncDo(200, () => 'D'),
-        e: {
-          f: {
-            g: asyncDo(200, () => 'G'),
-          },
-        },
-      })),
-    }
-
-    const startTime = performance.now()
-    const resolved = await resolveNestedPromises(obj)
-    const endTime = performance.now()
-
-    expect(resolved).toEqual({
-      a: 'A',
-      b: 'B',
-      c: {
-        c: 'C',
-        d: 'D',
-        e: {
-          f: {
-            g: 'G',
-          },
-        },
-      },
-    })
-    const executionTime = endTime - startTime
-
-    //
-    // Parallel promise resolution
-    //
-    expect(executionTime).toBeGreaterThan(400)
-    expect(executionTime).toBeLessThan(450)
-  })
-
-  test('deep nesting', async () => {
-    const obj = {
-      a: asyncDo(100, () => ({
-        a1: asyncDo(100, () => ({
-          a2: asyncDo(100, () => ({
-            a3: asyncDo(100, () => ({
-              a4: asyncDo(100, () => ({
-                a5: asyncDo(100, () => ({
-                  a6: asyncDo(100, () => ({
-                    a7: asyncDo(100, () => ({
-                      a8: 'a8',
-                    })),
-                  })),
-                })),
-              })),
-            })),
-          })),
-        })),
-      })),
-      b: asyncDo(200, () => ({
-        c: 'C',
-        d: asyncDo(200, () => 'D'),
-        e: {
-          f: {
-            g: asyncDo(200, () => 'G'),
-          },
-        },
-      })),
-    }
-
-    const startTime = performance.now()
-    const resolved = await resolveNestedPromises(obj)
-    const endTime = performance.now()
-
-    expect(resolved).toEqual({
-      a: { a1: { a2: { a3: { a4: { a5: { a6: { a7: { a8: 'a8' } } } } } } } },
-      b: { c: 'C', d: 'D', e: { f: { g: 'G' } } },
-    })
-    const executionTime = endTime - startTime
-
-    //
-    // Parallel promise resolution
-    //
-    expect(executionTime).toBeGreaterThan(800)
-    expect(executionTime).toBeLessThan(850)
-  })
-
-  test('immutability', async () => {
-    const obj = deepFreeze({
-      a: asyncDo(100, () => 'A'),
-      b: asyncDo(100, () => 'B'),
-      c: asyncDo(200, () => ({
-        c: 'C',
-        d: asyncDo(200, () => 'D'),
-        e: {
-          f: {
-            g: asyncDo(200, () => 'G'),
-          },
-        },
-      })),
-    })
-
-    expect(await resolveNestedPromises(obj)).toEqual({
-      a: 'A',
-      b: 'B',
-      c: {
-        c: 'C',
-        d: 'D',
-        e: {
-          f: {
-            g: 'G',
-          },
-        },
-      },
-    })
-  })
-
-  test('maxDepth', async () => {
-    const obj = {
-      a: asyncDo(100, () => 'A'),
-      b: asyncDo(300, () => 'B'),
-      c: asyncDo(200, () => ({
-        c: 'C',
-        d: asyncDo(200, () => 'D'),
-        e: {
-          f: {
-            g: asyncDo(200, () => 'G'),
-          },
-        },
-      })),
-    }
-
-    expect(
-      await resolveNestedPromises(obj, {
-        maxDepth: 4,
-      }),
-    ).toEqual({
-      a: 'A',
-      b: 'B',
-      c: {
-        c: 'C',
-        d: 'D',
-        e: {
-          f: {
-            g: 'G',
-          },
-        },
-      },
-    })
-
-    await expect(() =>
-      resolveNestedPromises(obj, {
-        maxDepth: 3,
-      }),
-    ).rejects.toThrow('Max depth exceeded: { depth: 4, maxDepth: 3 }')
-  })
-
-  test('lazy mode', async () => {
-    const obj = {
-      a: asyncDo(100, () => 'A'),
-      b: asyncDo(300, () => 'B'),
-      c: asyncDo(200, () => ({
-        c: 'C',
-        d: asyncDo(200, () => 'D'),
-        e: {
-          f: {
-            g: asyncDo(200, () => 'G'),
-          },
-        },
-      })),
-    }
-
-    expect(
-      await resolveNestedPromises(obj, {
-        mode: 'lazy',
-      }),
-    ).toEqual({
-      a: 'A',
-      b: 'B',
-      c: {
-        c: 'C',
-        d: expect.any(Promise),
-        e: {
-          f: {
-            g: expect.any(Promise),
-          },
-        },
-      },
-    })
-  })
-})

package/src/promise/resolveNestedPromises.ts

@@ -1,83 +0,0 @@
-import traverse from 'traverse'
-import copy from 'fast-copy'
-import { AnyArray, AnyObject } from './types'
-
-type ResolveCtx = {
-  root: AnyArray | AnyObject
-  depth: number
-}
-
-type ResolveOptions = {
-  mode: 'eager' | 'lazy'
-  maxDepth: number
-  clone: false | (<T = { [key: string]: any } | any[]>(obj: T) => T)
-}
-
-const DEFAULT_OPTIONS: ResolveOptions = {
-  mode: 'eager',
-  maxDepth: 30,
-  clone: copy,
-}
-
-function _echo<T = any>(input: T): T {
-  return input
-}
-
-export async function resolveNestedPromises(
-  node: AnyArray | AnyObject,
-  options: Partial<ResolveOptions> = {},
-  ctx: ResolveCtx = { root: node, depth: 0 },
-): Promise<AnyArray | AnyObject> {
-  const opts: ResolveOptions = {
-    ...DEFAULT_OPTIONS,
-    ...options,
-  }
-  let promises: Promise<void>[] = []
-
-  //
-  // Allow consumers to provide a clone function.
-  // There are multiple nuances regarding cloning. Here are some
-  // we've faced:
-  // - clone-deep (https://www.npmjs.com/package/clone-deep) does
-  //   creates new versions of symbols
-  // - fast-copy (default export) does not clone array custom properties
-  //   (but allows for creating a copier function that does)
-  //
-  // It would be incorrect to use copyStrict (from fast-copy) by default, thus
-  // we allow consumers to provide their copy functions
-  //
-  // If opts.clone is set to false, use the _echo function
-  //
-  const _cloneFn = opts.clone || _echo
-  const clonedNode = _cloneFn(node)
-
-  const resolved = traverse(clonedNode).forEach(function (value) {
-    const depth = ctx.depth + this.path.length
-
-    if (depth > opts.maxDepth) {
-      throw new Error(
-        `Max depth exceeded: { depth: ${depth}, maxDepth: ${opts.maxDepth} }`,
-      )
-    }
-
-    if (value instanceof Promise) {
-      const updatePromise = value.then(async (resolvedValue) => {
-        // Arrow function;
-        // this refers to outside this ctx
-        this.update(
-          opts.mode === 'eager'
-            ? await resolveNestedPromises(resolvedValue, opts, {
-                ...ctx,
-                // pass the base depth of the current value
-                depth,
-              })
-            : resolvedValue,
-        )
-      })
-
-      promises = [...promises, updatePromise]
-    }
-  })
-
-  return Promise.all(promises).then(() => resolved)
-}

package/src/promise/types.ts

@@ -1,2 +0,0 @@
-export type AnyArray = unknown[]
-export type AnyObject = Record<string, unknown>

package/src/switchValue.spec.ts

@@ -1,30 +0,0 @@
-import { switchValue } from './switchValue'
-
-describe('switchValue', () => {
-  test('basic', () => {
-    const cases = {
-      string: 'String value',
-      number: 'Number value',
-      regexp: 'RegExp value',
-    }
-
-    expect(switchValue(typeof 'string input', cases)).toEqual('String value')
-    expect(switchValue(typeof 8, cases)).toEqual('Number value')
-  })
-
-  test('function criteria', () => {
-    const cases = [
-      [
-        (input) => typeof input === 'string' || typeof input === 'number',
-        'Number or String',
-      ],
-      [(input) => Array.isArray(input), 'Array value'],
-      ['Default value']
-    ]
-
-    expect(switchValue('str', cases)).toEqual('Number or String')
-    expect(switchValue(8, cases)).toEqual('Number or String')
-    expect(switchValue([], cases)).toEqual('Array value')
-    expect(switchValue({}, cases)).toEqual('Default value')
-  })
-})

package/src/switchValue.ts

@@ -1,59 +0,0 @@
-type Criteria = string | symbol | RegExp | ((input: any) => boolean)
-
-type ObjectSwitchCases<ValueType = any> = {
-  [key: string | symbol]: ValueType
-}
-
-type TupleSwitchCases<ValueType = any> = ([Criteria, ValueType] | [ValueType])[]
-
-export type SwitchCases<ValueType = any> =
-  | ObjectSwitchCases<ValueType>
-  | TupleSwitchCases<ValueType>
-
-function testCriteria(criteria: Criteria, input: any) {
-  switch (typeof criteria) {
-    case 'function': {
-      return criteria(input)
-    }
-    case 'object': {
-      if (criteria instanceof RegExp) {
-        return criteria.test(input)
-      } else {
-        throw new Error('Unsupported criteria')
-      }
-    }
-    case 'string':
-    case 'symbol': {
-      return criteria === input
-    }
-  }
-}
-
-export function switchValue<ValueType = any>(
-  input: any,
-  cases: SwitchCases,
-): ValueType | undefined {
-  if (Array.isArray(cases)) {
-    const matching = cases.find((case_) => {
-      return case_.length === 1 || testCriteria(case_[0], input)
-    })
-
-    return matching
-      ? matching.length === 1
-        ? matching[0]
-        : matching[1]
-      : undefined
-  } else {
-    return cases[input] || cases.default
-  }
-}
-
-export function switchExec<ArgsType extends any[] = any[]>(
-  input: any,
-  cases: SwitchCases<(...args: any[]) => any>,
-  ...args: ArgsType
-) {
-  const fn = switchValue(input, cases)
-
-  return fn(...args)
-}

package/src/typeOf.spec.ts

@@ -1,47 +0,0 @@
-import { typeOf } from './typeOf'
-
-describe('test', () => {
-  test('basic', () => {
-    expect(typeOf({})).toEqual('object')
-    expect(typeOf(null)).toEqual('null')
-    expect(typeOf(undefined)).toEqual('undefined')
-    expect(typeOf(true)).toEqual('boolean')
-    expect(typeOf(1n)).toEqual('bigint')
-    expect(typeOf(Symbol())).toEqual('symbol')
-    expect(typeOf(() => {})).toEqual('function')
-    expect(typeOf('string')).toEqual('string')
-    expect(typeOf(6)).toEqual('number')
-    expect(typeOf(parseInt('('))).toEqual('nan')
-    expect(typeOf([6, 'str'])).toEqual('array')
-    expect(typeOf(new Error('Error message'))).toEqual('error')
-    expect(typeOf(new RegExp('^Hello'))).toEqual('regexp')
-    expect(typeOf(new Date())).toEqual('date')
-    expect(typeOf(new Map())).toEqual('map')
-    expect(typeOf(new WeakMap())).toEqual('weakmap')
-    expect(typeOf(new Set())).toEqual('set')
-    expect(typeOf(new WeakSet())).toEqual('weakset')
-    expect(typeOf(new Promise(() => {}))).toEqual('promise')
-  })
-
-  test('custom error', () => {
-    class ValidationError extends Error {
-      constructor(message) {
-        super(message) // (1)
-        this.name = 'ValidationError' // (2)
-      }
-    }
-
-    expect(typeOf(new ValidationError('Some error'))).toEqual('error')
-  })
-
-  test('unknown constructor', () => {
-    class Custom {
-      a: string
-      constructor(a) {
-        this.a = a
-      }
-    }
-
-    expect(typeOf(new Custom('a'))).toEqual(null)
-  })
-})

package/src/typeOf.ts

@@ -1,81 +0,0 @@
-import { isPlainObject } from 'is-plain-object'
-
-export type TypeTest = (value: any) => boolean
-
-type TypeMap = Record<string, TypeTest>
-
-//
-// The only role of this function is to let typescript
-// be aware of the available types
-//
-export function typeMap<T extends TypeMap>(typeMap: T) {
-  return typeMap
-}
-
-export function makeTypeOf<T extends TypeMap>(typeMap: T) {
-  return function typeOf(value: any): keyof T | null {
-    for (const typeName in typeMap) {
-      if (typeMap[typeName](value)) {
-        return typeName
-      }
-    }
-    return null
-  }
-}
-
-function basicType(typeName: string) {
-  return (value: any) => typeof value === typeName
-}
-
-const DEFAULT_TYPES = typeMap({
-  //
-  // Primitives
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#primitive_values
-  //
-  null: (value) => value === null,
-  undefined: basicType('undefined'),
-  boolean: basicType('boolean'),
-
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN
-  number: (value) => typeof value === 'number' && !Number.isNaN(value),
-  bigint: basicType('bigint'),
-  string: basicType('string'),
-  symbol: basicType('symbol'),
-  function: basicType('function'),
-
-  object: isPlainObject,
-  array: (value) => Array.isArray(value),
-
-  regexp: (value) => value instanceof RegExp,
-  nan: (value) => Number.isNaN(value),
-  date: (value) => value instanceof Date,
-  map: (value) => value instanceof Map,
-  weakmap: (value) => value instanceof WeakMap,
-  set: (value) => value instanceof Set,
-  weakset: (value) => value instanceof WeakSet,
-  promise: (value) => value instanceof Promise,
-  error: (value) => value instanceof Error,
-})
-
-export type DEFAULT_TYPE_NAMES =
-  | 'null'
-  | 'undefined'
-  | 'boolean'
-  | 'number'
-  | 'bigint'
-  | 'string'
-  | 'symbol'
-  | 'function'
-  | 'object'
-  | 'array'
-  | 'regexp'
-  | 'nan'
-  | 'date'
-  | 'map'
-  | 'weakmap'
-  | 'set'
-  | 'weakset'
-  | 'promise'
-  | 'error'
-
-export const typeOf = makeTypeOf(DEFAULT_TYPES)

package/src/validate/__snapshots__/index.spec.ts.snap

@@ -1,9 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`validateAPI 1`] = `
-[
-  "validate",
-  "validateAsync",
-  "ValidationError",
-]
-`;