atomic-fns 0.1.0

package/src/random.ts

@@ -0,0 +1,29 @@
+import { isObject, round } from './globals'
+
+export const random = (min = 0, max = 1) => Math.random() * (max - min) + min
+
+export const randomInt = (min = 0, max = 1) => round(random(min, max), 0)
+
+export const choice = (arr: any[]) => {
+  if (!arr?.length) return
+  const index = randomInt(0, arr.length - 1)
+  return arr[index]
+}
+
+export function sample(arr: any[], k: number) {
+  if (!arr?.length) return
+  const result: any[] = []
+  while (k--) result.push(choice(arr))
+  return result
+}
+
+export function shuffle(arr) {
+  if (isObject(arr)) arr = Object.values(arr)
+  const n = arr.length - 1
+  for (let i = n; i > 0; i--) {
+    const j = randomInt(0, i)
+    const temp = arr[j]
+    arr[j] = arr[i]
+    arr[i] = temp
+  }
+}

package/tests/collections.spec.ts

@@ -0,0 +1,199 @@
+import assert from 'assert'
+import {
+  filter,
+  find,
+  forEach,
+  findRight,
+  flatten,
+  map,
+  contains,
+  flattenObj,
+  clone,
+  pick,
+  omit,
+  uniq,
+  sortedUniq,
+  merge,
+  difference,
+  intersection,
+  union
+} from '../src/collections.js'
+
+describe('collections', () => {
+  it('contains', () => {
+    assert(contains([4, 7, 1, 9], 1))
+    assert(!contains([4, 7, 1, 9], NaN))
+  })
+
+  it('clone', () => {
+    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('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, { age: 36 }), [users[0]])
+    assert.deepEqual(
+      filter(users, (o) => o.active),
+      [users[0]]
+    )
+    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, { age: 36 }) === users[0])
+    assert(find(users, (o) => o.active) === users[0])
+    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])
+    assert(findRight(users, (o) => o.active) === users[2])
+    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 = [] as any[]
+    forEach(target, (value, key) => objs.push([key, value]))
+    assert.deepEqual(objs, Object.entries(target))
+  })
+
+  it('flattenArray', () => {
+    let data = flatten([1, 2, [3, 4], 5])
+    assert.deepEqual(data, [1, 2, 3, 4, 5])
+    data = flatten([1, 2, [3, [4]], [5]], true)
+    assert.deepEqual(data, [1, 2, 3, 4, 5])
+  })
+
+  it('flattenObj', () => {
+    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(flattenObj(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('map', () => {
+    let target = { user: 'fred', age: 40, active: false }
+    let getEntries = (value, key) => [key, value]
+    assert.deepEqual(map(target, getEntries), Object.entries(target))
+  })
+
+  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('omit', () => {
+    let target = { user: 'fred', age: 40, active: false }
+    assert.deepEqual(omit(target, ['age', 'active']), { user: 'fred' })
+    assert.deepEqual(
+      omit(target, (x) => !x),
+      { user: 'fred', age: 40 }
+    )
+  })
+
+  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])
+    distinct = uniq(arr, (x) => x * 2)
+    assert.deepEqual(distinct, [8, 14, 2, 18])
+  })
+})

package/tests/globals.spec.ts

@@ -0,0 +1,232 @@
+import assert from 'assert'
+import {
+  True,
+  False,
+  CustomError,
+  type,
+  str,
+  isBool,
+  isObject,
+  isString,
+  isArray,
+  isArrayLike,
+  isNumber,
+  isNaN,
+  isNull,
+  isBigint,
+  isFunc,
+  isPromise,
+  isSymbol,
+  isAsync,
+  uniqueId,
+  call,
+  chr,
+  ord,
+  keys,
+  values,
+  round,
+  enumerate,
+  isGenerator,
+  hash,
+  hashCode,
+  HASH_KEY,
+  bin,
+  hex,
+  oct,
+  list,
+  next,
+  get
+} from '../build/globals.js'
+import { isEmpty } from '../src/globals.js'
+
+function cb() {}
+
+describe('globals', () => {
+  it('CustomError', () => {
+    let err = new CustomError('custom')
+    assert.equal(err.message, 'custom')
+  })
+
+  it('type', () => {
+    assert(True())
+    assert(!False())
+    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(Symbol()) === 'symbol')
+    assert(type(new Promise(cb)) === 'promise')
+    assert(isBool(true))
+    assert(isBool(Boolean()))
+    assert(!isBool(''))
+    assert(!isBool({}))
+    assert(!isBool(undefined))
+    assert(isObject({}))
+    assert(!isObject(''))
+    assert(!isObject([]))
+    assert(isString(''))
+    assert(!isString([]))
+    assert(isArray([]))
+    assert(isArrayLike([]))
+    assert(!isArray(''))
+    assert(!isArrayLike(''))
+    assert(isFunc(cb))
+    assert(!isFunc([]))
+    assert(isAsync(async function () {}))
+    assert(isAsync(async () => {}))
+    assert(!isAsync(cb))
+    assert(isNaN(NaN))
+    assert(!isNumber(NaN))
+    assert(isNumber(42))
+    assert(isNumber(Number(42)))
+    assert(isNumber(Number('42')))
+    assert(isNumber(parseFloat('42.0')))
+    assert(isBigint(42n))
+    assert(isBigint(BigInt('42')))
+    assert(isPromise(new Promise(cb)))
+    assert(isSymbol(Symbol()))
+    assert(isNull(null))
+    assert(isNull(undefined))
+    assert(!isNull(''))
+    assert(!isNull([]))
+    assert(!isNull({}))
+  })
+
+  it('str', () => {
+    assert(str(undefined) === '')
+    assert(str(null) === '')
+    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))
+    assert.match(uniqueId('contact_'), /^contact_\d+/)
+  })
+
+  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('round', () => {
+    assert(round(0.5) === 1)
+    assert(round(-0.5) === 0)
+    assert(round(1.5) === 2)
+    assert(round(1.54, 2) === 1.54)
+    assert(round(1.545, 3) === 1.545)
+  })
+
+  it('enumerate', () => {
+    let iter = enumerate(['foo', 'bar', 'baz'])
+    assert(isGenerator(iter))
+    let values = [...iter]
+    assert.deepEqual(values, [
+      [0, 'foo'],
+      [1, 'bar'],
+      [2, 'baz']
+    ])
+  })
+
+  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(arr, '2') === 3)
+    assert(get(arr, '3', false) === false)
+    assert(get(arr, '3', false) === false)
+    let obj = { foo: { bar: true } }
+    let h = hash(obj)
+    assert(get(obj, 'foo.bar'))
+    assert(get(obj, ['foo', 'bar']))
+    assert(get(obj, HASH_KEY) === h)
+    assert(get(obj, [HASH_KEY]) === h)
+  })
+
+  it('isEmpty', () => {
+    assert(isEmpty(null))
+    assert(isEmpty(undefined))
+    assert(isEmpty([]))
+    assert(isEmpty(''))
+    assert(isEmpty({}))
+    assert(isEmpty(0))
+    assert(!isEmpty(1))
+  })
+})

package/tests/itertools.spec.ts

@@ -0,0 +1,87 @@
+import assert from 'assert'
+import { list } from '../src/globals.js'
+import { reversed, sort, sorted, times, zip } from '../src/itertools.js'
+
+function cb() {}
+
+describe('operators', () => {
+  it('reversed', () => {
+    let arr = [3, 2, 1]
+    let reverse = reversed(arr)
+    arr.reverse()
+    assert.deepEqual(arr, reverse)
+  })
+
+  it('sort', () => {
+    let arr = [3, 2, 1]
+    assert.deepEqual(sort(arr), [1, 2, 3])
+    arr = [3, 1, 2]
+    assert.deepEqual(sort(arr, true), [3, 2, 1])
+  })
+
+  it('sorted', () => {
+    let arr = [3, 2, 1]
+    let sort = sorted(arr)
+    arr.sort()
+    assert.deepEqual(sort, arr)
+    // reversed order
+    assert.deepEqual(sorted([3, 1, 2], true), [3, 2, 1])
+    let users = [
+      { user: 'fred', age: 40 },
+      { user: 'barney', age: 36 }
+    ]
+    // compare by age key
+    assert.deepEqual(
+      sorted(users, (u) => u.age),
+      [
+        { user: 'barney', age: 36 },
+        { user: 'fred', age: 40 }
+      ]
+    )
+    // using key and reverse
+    assert.deepEqual(
+      sorted(users, (u) => u.age, true),
+      [
+        { user: 'fred', age: 40 },
+        { user: 'barney', age: 36 }
+      ]
+    )
+    // using custom compare
+    assert.deepEqual(
+      sorted(users, false, (x, y) => (x.user <= y.user ? -1 : 1)),
+      [
+        { user: 'barney', age: 36 },
+        { user: 'fred', age: 40 }
+      ]
+    )
+  })
+
+  it('times', () => {
+    let arr = list(times(5, (x) => x))
+    assert.deepEqual(arr, [0, 1, 2, 3, 4])
+  })
+
+  it('zip', () => {
+    let users1 = [
+      { user: 'barney', age: 36 },
+      { user: 'fred', age: 40 }
+    ]
+    let users2 = [
+      { user: 'fred', age: 40 },
+      { user: 'barney', age: 36 }
+    ]
+
+    let results = [] as any
+    for (const t of zip(users1, users2)) {
+      results.push(t)
+    }
+
+    let [first1, first2] = results[0]
+    assert(first1 === users1[0])
+    assert(first2 === users2[0])
+
+    let [second1, second2] = results[1]
+    assert(second1 === users1[1])
+    assert(second2 === users2[1])
+  })
+})

package/tests/operators.spec.ts

@@ -0,0 +1,62 @@
+import assert from 'assert'
+import { isEmpty } from '../src/globals.js'
+import { bool, id, isinstance, not, all, any, comp, shallowEqual } from '../src/operators.js'
+
+describe('operators', () => {
+  it('all', () => {
+    assert(all([1, true, [], 'test', {}]))
+    assert(!all([[], {}, '']))
+    assert(all([[], {}, ''], isEmpty))
+  })
+
+  it('any', () => {
+    assert(any([1, true, [], 'test', {}]))
+    assert(!any([0, false, '']))
+    assert(any([0, false, ''], (x) => !x))
+  })
+
+  it('bool', () => {
+    assert(bool(1))
+    assert(bool(true))
+    assert(bool(false) === false)
+    assert(not(false))
+    assert(not(''))
+  })
+
+  it('comp', () => {
+    assert(comp(1, 1) === 0)
+    assert(comp(2, 3) === -1)
+    assert(comp(4, 3) === 1)
+  })
+
+  it('id', () => {
+    let x = Math.random()
+    assert(id(x) === x)
+  })
+
+  it('isinstance', () => {
+    assert(isinstance([], Array))
+    assert(isinstance(Array(), Array))
+    assert(isinstance(Object(), Object))
+    assert(isinstance(new Set(), Set))
+    assert(isinstance(new Map(), Map))
+  })
+
+  it('shallowEqual', () => {
+    assert(shallowEqual({}, {}))
+    assert(shallowEqual([], []))
+    assert(shallowEqual({ test: true }, { test: true }))
+    assert(
+      shallowEqual(
+        {
+          value: 42,
+          // custom equals implementation will be used
+          eq(other) {
+            return this.value === other.value
+          }
+        },
+        { value: 42 }
+      )
+    )
+  })
+})