atomic-fns 0.3.5 → 0.4.2

package/tests/collections.spec.ts

@@ -1,288 +0,0 @@
-import assert from 'assert'
-import {
-  clone,
-  compact,
-  count,
-  difference,
-  filter,
-  find,
-  findRight,
-  flatten,
-  forEach,
-  groupBy,
-  intersection,
-  merge,
-  omit,
-  pick,
-  remove,
-  sortedUniq,
-  union,
-  uniq
-} from '../core/collections/index.js'
-
-describe('collections', () => {
-  it('compact', () => {
-    let filtered = compact([0, 1, false, 2, '', 3])
-    assert.deepEqual(filtered, [1, 2, 3])
-    assert.deepEqual(compact({ a: 1, b: undefined, c: false, d: [] }), { a: 1 })
-  })
-
-  it('count', () => {
-    let counters = count([0, 1, false, 2, '', 3], (x) => !!x)
-    assert(counters['true'] === 3)
-    assert(counters['false'] === 3)
-  })
-
-  it('clone array', () => {
-    let arr = [4, 7, 1, 9]
-    assert.deepEqual(clone(arr), arr)
-    let target = { user: 'fred', age: 40, active: false }
-    assert.deepEqual(clone(target), target)
-  })
-
-  it('clone object', () => {
-    let target = { user: 'fred', age: 40, active: false }
-    assert.deepEqual(clone(target), target)
-  })
-
-  it('difference', () => {
-    let a = [1, 2, 5]
-    let b = [3, 4, 5]
-    assert.deepEqual(sortedUniq(difference(a, b)), [1, 2, 3, 4])
-  })
-
-  it('intersection', () => {
-    let a = [1, 2, 5]
-    let b = [3, 4, 5]
-    assert.deepEqual([...intersection(a, b)], [5])
-  })
-
-  it('union', () => {
-    let a = [1, 2, 5]
-    let b = [3, 4, 5]
-    assert.deepEqual(sortedUniq(union(a, b)), [1, 2, 3, 4, 5])
-  })
-
-  it('filter', () => {
-    assert(filter(null) == undefined)
-    let users = [
-      { user: 'barney', age: 36, active: true },
-      { user: 'fred', age: 40, active: false }
-    ]
-    assert.deepEqual(
-      filter(users, (o) => o.active),
-      [users[0]]
-    )
-  })
-
-  it('filter matches', () => {
-    assert(filter(null) == undefined)
-    let users = [
-      { user: 'barney', age: 36, active: true },
-      { user: 'fred', age: 40, active: false }
-    ]
-    assert.deepEqual(filter(users, { age: 36 }), [users[0]])
-  })
-
-  it('filter property', () => {
-    assert(filter(null) == undefined)
-    let users = [
-      { user: 'barney', age: 36, active: true },
-      { user: 'fred', age: 40, active: false }
-    ]
-    assert.deepEqual(filter(users, 'active'), [users[0]])
-  })
-
-  it('find', () => {
-    let users = [
-      { user: 'barney', age: 36, active: true },
-      { user: 'fred', age: 40, active: false }
-    ]
-    assert(find(users, (o) => o.active) === users[0])
-  })
-
-  it('find matches', () => {
-    let users = [
-      { user: 'barney', age: 36, active: true },
-      { user: 'fred', age: 40, active: false }
-    ]
-    assert(find(users, { age: 36 }) === users[0])
-  })
-
-  it('find property', () => {
-    let users = [
-      { user: 'barney', age: 36, active: true },
-      { user: 'fred', age: 40, active: false }
-    ]
-    assert(find(users, 'active') === users[0])
-  })
-
-  it('findRight', () => {
-    let users = [
-      { user: 'barney', age: 36, active: true },
-      { user: 'fred', age: 40, active: false },
-      { user: 'barney', age: 36, active: true }
-    ]
-    assert(findRight(users, { age: 36 }) === users[2])
-  })
-
-  it('findRight matches', () => {
-    let users = [
-      { user: 'barney', age: 36, active: true },
-      { user: 'fred', age: 40, active: false },
-      { user: 'barney', age: 36, active: true }
-    ]
-    assert(findRight(users, { age: 36 }) === users[2])
-  })
-
-  it('findRight property', () => {
-    let users = [
-      { user: 'barney', age: 36, active: true },
-      { user: 'fred', age: 40, active: false },
-      { user: 'barney', age: 36, active: true }
-    ]
-    assert(findRight(users, 'active') === users[2])
-  })
-
-  it('forEach', () => {
-    let users = [
-      { user: 'barney', age: 36, active: true },
-      { user: 'fred', age: 40, active: false }
-    ]
-    let result = [] as any
-    forEach(users, (value, key) => result.push([key, value]))
-    assert.deepEqual(
-      result,
-      users.map((x, i) => [i, x])
-    )
-  })
-
-  it('forEach object key', () => {
-    let target = { user: 'fred', age: 40, active: false }
-    let objs = []
-    // @ts-expect-error
-    forEach(target, (value, key) => objs.push([key, value]))
-    assert.deepEqual(objs, Object.entries(target))
-  })
-
-  it('flatten Array', () => {
-    let data = flatten([1, 2, [3, 4], 5])
-    assert.deepEqual(data, [1, 2, 3, 4, 5])
-  })
-
-  it('flatten Array deep', () => {
-    let data = flatten([1, 2, [3, [4]], [5]], true)
-    assert.deepEqual(data, [1, 2, 3, 4, 5])
-  })
-
-  it('flatten Object', () => {
-    const data = {
-      dates: {
-        expiry_date: '30 sep 2018',
-        available: '30 sep 2017',
-        min_contract_period: [
-          {
-            id: 1,
-            name: '1 month'
-          }
-        ]
-      },
-      price: {
-        currency: 'RM',
-        value: 1500
-      }
-    }
-    assert.deepEqual(flatten(data), {
-      'dates.expiry_date': '30 sep 2018',
-      'dates.available': '30 sep 2017',
-      'dates.min_contract_period[0].id': 1,
-      'dates.min_contract_period[0].name': '1 month',
-      'price.currency': 'RM',
-      'price.value': 1500
-    })
-  })
-
-  it('groupBy', () => {
-    assert.deepEqual(groupBy([6.1, 4.2, 6.3], Math.floor), { '4': [4.2], '6': [6.1, 6.3] })
-  })
-
-  it('merge', () => {
-    let object = {
-      a: [{ b: 2 }, { d: 4 }]
-    }
-    let other = {
-      a: [{ c: 3 }, { e: 5 }],
-      foo: null,
-      bar: true,
-      noop: undefined
-    }
-    assert.deepEqual(merge(object, other), {
-      a: [
-        { b: 2, c: 3 },
-        { d: 4, e: 5 }
-      ],
-      foo: null,
-      bar: true
-    })
-  })
-
-  it('pick', () => {
-    let target = { user: 'fred', age: 40, active: false }
-    assert.deepEqual(pick(target, ['user']), { user: 'fred' })
-    assert.deepEqual(
-      pick(target, (x) => x >= 40),
-      { age: 40 }
-    )
-  })
-
-  it('pickBy', () => {
-    let target = { user: 'fred', age: 40, active: false }
-    assert.deepEqual(
-      pick(target, (x) => x >= 40),
-      { age: 40 }
-    )
-  })
-
-  it('omit', () => {
-    let target = { user: 'fred', age: 40, active: false }
-    assert.deepEqual(omit(target, ['age', 'active']), { user: 'fred' })
-  })
-
-  it('omitBy', () => {
-    let target = { user: 'fred', age: 40, active: false }
-    assert.deepEqual(
-      omit(target, (x) => !x),
-      { user: 'fred', age: 40 }
-    )
-  })
-
-  it('remove', () => {
-    assert.deepEqual(remove([1, 2, 3, 4], 1), [2, 3, 4])
-    assert.deepEqual(remove([1, 2, 3, 4], [3, 4]), [1, 2])
-  })
-
-  it('removeBy', () => {
-    assert.deepEqual(
-      remove([1, 2, 3, 4], (x) => x % 2 === 0),
-      [1, 3]
-    )
-  })
-
-  it('sortedUniq', () => {
-    let arr = [4, 7, 1, 9, 1, 7, 4]
-    let sort = sortedUniq(arr)
-    assert.deepEqual(sort, [1, 4, 7, 9])
-  })
-
-  it('uniq', () => {
-    let arr = [4, 7, 1, 1, 9, 4, 7]
-    let distinct = uniq(arr)
-    assert.deepEqual(distinct, [4, 7, 1, 9])
-  })
-
-  it('uniqBy', () => {
-    let arr = [4, 7, 1, 1, 9, 4, 7]
-    let distinct = uniq(arr, (x) => x * 2)
-    assert.deepEqual(distinct, [8, 14, 2, 18])
-  })
-})

package/tests/deque.spec.ts

@@ -1,107 +0,0 @@
-import assert from 'assert'
-import { Deque } from '../core/collections/deque.js'
-
-describe('deque', () => {
-  const print = (x) => console.log(x.toArray())
-
-  it('empty', () => {
-    let deque = new Deque()
-    assert(deque.size === 0)
-  })
-
-  it('iterable', () => {
-    let values = [1, 2, 3, 4]
-    let deque = new Deque(values)
-    let elements = [] as any[]
-    for (const value of deque.values()) {
-      elements.push(value)
-    }
-    assert.deepEqual(values, elements)
-  })
-
-  it('append', () => {
-    let values = [1, 2, 3, 4]
-    let deque = new Deque(values)
-    assert(deque.size === values.length)
-    assert.deepEqual(deque.toArray(), values)
-    deque.append(5)
-    assert(deque.size === 5)
-    assert.deepEqual(deque.toArray(), [1, 2, 3, 4, 5])
-  })
-
-  it('appendleft', () => {
-    let values = [1, 2, 3, 4]
-    let deque = new Deque(values)
-    deque.appendleft(0)
-    deque.appendleft(1)
-    deque.appendleft(1)
-    deque.appendleft(0)
-    assert.deepEqual(deque.toArray(), [0, 1, 1, 0, 1, 2, 3, 4])
-    assert(deque.size === 8)
-  })
-
-  it('pop', () => {
-    let values = [1, 2, 3, 4]
-    let deque = new Deque(values)
-    assert(deque.pop() === 4)
-    assert(deque.pop() === 3)
-    assert(deque.pop() === 2)
-    assert(deque.pop() === 1)
-    assert(deque.size === 0)
-    assert.deepEqual(deque.toArray(), [])
-    // assert.throws(() => deque.pop())
-  })
-
-  it('popleft', () => {
-    let values = [1, 2, 3, 4]
-    let deque = new Deque(values)
-    assert(deque.popleft() === 1)
-    assert(deque.popleft() === 2)
-    assert(deque.popleft() === 3)
-    assert(deque.popleft() === 4)
-    assert(deque.size === 0)
-    assert.deepEqual(deque.toArray(), [])
-    // assert.throws(() => deque.popleft())
-  })
-
-  it('contains', () => {
-    let values = [1, 2, 3, 4]
-    let deque = new Deque(values)
-    for (const val of values) {
-      assert(deque.contains(val))
-    }
-  })
-
-  it('get', () => {
-    let values = [1, 2, 3, 4]
-    let deque = new Deque(values)
-    for (let i = 0; i < values.length; i++) {
-      assert(deque.get(i) === values[i])
-    }
-    assert(deque.get(-1) === 4)
-    assert(deque.get(-2) === 3)
-  })
-
-  it('clear', () => {
-    let values = [1, 2, 3, 4]
-    let deque = new Deque(values)
-    deque.clear()
-    assert(deque.size === 0)
-    assert.deepEqual(deque.toArray(), [])
-  })
-
-  it('reversed', () => {
-    let values = [4, 3, 2, 0, 1]
-    let deque = new Deque(values)
-    values.reverse()
-    let arr = deque.reversed()
-    assert.deepEqual(arr, values)
-  })
-
-  it('toArray', () => {
-    let values = [1, 2, 3, 4]
-    let deque = new Deque(values)
-    assert(deque.size === values.length)
-    assert.deepEqual(deque.toArray(), values)
-  })
-})

package/tests/globals.spec.ts

@@ -1,270 +0,0 @@
-import assert from 'assert'
-import {
-  bin,
-  call,
-  chr,
-  CustomError,
-  False,
-  get,
-  hash,
-  hashCode,
-  HASH_KEY,
-  hex,
-  isArray,
-  isArrayLike,
-  isAsyncFunction,
-  isBigint,
-  isBool,
-  isEmpty,
-  isFunction,
-  isNaN,
-  isNull,
-  isNumber,
-  isObject,
-  isPromise,
-  isString,
-  isSymbol,
-  keys,
-  list,
-  next,
-  oct,
-  ord,
-  str,
-  True,
-  type,
-  uniqueId,
-  values,
-  noop
-} from '../core/globals/index.js'
-import { enumerate } from '../core/itertools/index.js'
-
-describe('globals', () => {
-  it('CustomError', () => {
-    let err = new CustomError('custom')
-    assert.equal(err.message, 'custom')
-  })
-
-  it('True', () => assert(True() === true))
-
-  it('False', () => assert(False() === false))
-
-  it('type', () => {
-    assert(type(null) === 'null')
-    assert(type(undefined) === 'undefined')
-    assert(type(true) === 'boolean')
-    assert(type(Boolean()) === 'boolean')
-    assert(type(True()) === 'boolean')
-    assert(type(False()) === 'boolean')
-    assert(type('') === 'string')
-    assert(type(String('')) === 'string')
-    assert(type(NaN) === 'NaN')
-    assert(type(42) === 'number')
-    assert(type(Number(42)) === 'number')
-    assert(type(Number('42')) === 'number')
-    assert(type(parseFloat('42.0')) === 'number')
-    assert(type(42n) === 'bigint')
-    assert(type(BigInt('42')) === 'bigint')
-    assert(type([]) === 'array')
-    assert(type({}) === 'object')
-    assert(type(type) === 'function')
-    assert(type(Error()) === 'error')
-    assert(type(new CustomError()) === 'error')
-    assert(type(Symbol()) === 'symbol')
-    assert(type(new Map()) === 'Map')
-    assert(type(new WeakMap()) === 'WeakMap')
-    assert(type(new Set()) === 'Set')
-    assert(type(new WeakSet()) === 'WeakSet')
-    assert(type(new Promise(noop)) === 'Promise')
-    assert(type(new Int8Array()) === 'Int8Array')
-    assert(type(new Uint8Array()) === 'Uint8Array')
-    assert(type(new Uint8ClampedArray()) === 'Uint8ClampedArray')
-    assert(type(new Int16Array()) === 'Int16Array')
-    assert(type(new Uint16Array()) === 'Uint16Array')
-    assert(type(new Int32Array()) === 'Int32Array')
-    assert(type(new Uint32Array()) === 'Uint32Array')
-    assert(type(new Float32Array()) === 'Float32Array')
-    assert(type(new Float64Array()) === 'Float64Array')
-    assert(type(new ArrayBuffer(8)) === 'ArrayBuffer')
-    assert(type(new DataView(new ArrayBuffer(8))) === 'DataView')
-  })
-
-  it('isBool', () => {
-    assert(isBool(true))
-    assert(isBool(Boolean()))
-    assert(!isBool(''))
-    assert(!isBool({}))
-    assert(!isBool(undefined))
-  })
-
-  it('isObject', () => {
-    assert(isObject({}))
-    assert(!isObject(''))
-    assert(!isObject([]))
-  })
-
-  it('isString', () => {
-    assert(isString(''))
-    assert(!isString([]))
-  })
-
-  it('isArray', () => {
-    assert(isArray([]))
-    assert(isArrayLike([]))
-    assert(!isArray(''))
-    assert(!isArrayLike(''))
-  })
-
-  it('isFunction', () => {
-    assert(isFunction(noop))
-    assert(!isFunction([]))
-  })
-
-  it('isAsyncFunction', () => {
-    assert(isAsyncFunction(async function () {}))
-    assert(isAsyncFunction(async () => {}))
-    assert(!isAsyncFunction(noop))
-  })
-
-  it('isNaN', () => {
-    assert(isNaN(NaN))
-  })
-
-  it('isNumber', () => {
-    assert(!isNumber(NaN))
-    assert(isNumber(42))
-    assert(isNumber(Number(42)))
-    assert(isNumber(Number('42')))
-    assert(isNumber(parseFloat('42.0')))
-  })
-
-  it('isBigInt', () => {
-    assert(isBigint(42n))
-    assert(isBigint(BigInt('42')))
-  })
-
-  it('isPromise', () => {
-    assert(isPromise(new Promise(noop)))
-  })
-
-  it('isSymbol', () => {
-    assert(isSymbol(Symbol()))
-  })
-
-  it('isNull', () => {
-    assert(isNull(null))
-    assert(isNull(undefined))
-    assert(!isNull(''))
-    assert(!isNull([]))
-    assert(!isNull({}))
-  })
-
-  it('str', () => {
-    assert(str(undefined) === '')
-    assert(str(null) === '')
-    assert(str(true) === 'true')
-    assert(str(false) === 'false')
-    assert(str(NaN) === 'NaN')
-    assert(str(42) === '42')
-    assert(str([]) === '')
-    assert(str([1, 2, 3]) === '1,2,3')
-    assert(str({}) === '[object Object]')
-  })
-
-  it('uniqueId', () => {
-    const uid = uniqueId()
-    assert(isNumber(uid))
-    let prefix = 'user_'
-    const userId = uniqueId('user_')
-    assert(userId.startsWith('user_'))
-  })
-
-  it('call', () => {
-    const obj = {
-      foo() {
-        return 42
-      }
-    }
-    assert(call(obj, 'foo') === 42)
-  })
-
-  it('chr', () => {
-    assert(chr(97) === 'a')
-    assert(chr(8364) === '€')
-  })
-
-  it('ord', () => {
-    assert(ord('a') === 97)
-    assert(ord('€') === 8364)
-  })
-
-  it('keys', () => {
-    let obj = { a: 1, b: 2 }
-    assert.deepEqual(keys(obj), Object.keys(obj))
-  })
-
-  it('values', () => {
-    let obj = { a: 1, b: 2 }
-    assert.deepEqual(values(obj), Object.values(obj))
-  })
-
-  it('next', () => {
-    const iter = enumerate([1, 2, 3])
-    assert.deepEqual(next(iter), [0, 1])
-    assert.deepEqual(next(iter), [1, 2])
-    assert.deepEqual(next(iter), [2, 3])
-  })
-
-  it('hash', () => {
-    let obj = { a: 1, b: 2 }
-    let h = hash(obj)
-    assert(h === hash(obj))
-    assert(obj[HASH_KEY] === h)
-  })
-
-  it('hashCode', () => {
-    let obj = '{ a: 1, b: 2 }'
-    assert(hash(obj) === hashCode(obj))
-  })
-
-  it('bin', () => {
-    assert(bin(42) === (42).toString(2))
-  })
-
-  it('hex', () => {
-    assert(hex(42) === (42).toString(16))
-  })
-
-  it('oct', () => {
-    assert(oct(42) === (42).toString(8))
-  })
-
-  it('list', () => {
-    const arr = [1, 2, 3]
-    assert.deepEqual(list(arr), arr)
-    assert.deepEqual(list(), [])
-  })
-
-  it('get', () => {
-    const arr = [1, 2, 3]
-    assert(get('2', arr) === 3)
-    assert(get('3', arr, false) === false)
-    assert(get('3', arr, false) === false)
-    let obj = { foo: { bar: true } }
-    let h = hash(obj)
-    assert(get('foo.bar', obj))
-    assert(get(['foo', 'bar'], obj))
-    assert(get(HASH_KEY, obj) === h)
-    assert(get([HASH_KEY], obj) === h)
-  })
-
-  it('isEmpty', () => {
-    assert(isEmpty(null))
-    assert(isEmpty(undefined))
-    assert(isEmpty([]))
-    assert(isEmpty(''))
-    assert(isEmpty({}))
-    assert(isEmpty(0))
-    assert(isEmpty(false))
-    assert(!isEmpty(1))
-  })
-})