atomic-fns 0.2.2 → 0.3.0

package/tests/collections.spec.ts

@@ -1,28 +1,36 @@
 import assert from 'assert'
 import {
+  clone,
+  compact,
+  count,
+  difference,
   filter,
   find,
-  forEach,
   findRight,
   flatten,
-  map,
-  contains,
-  flattenObj,
-  clone,
-  pick,
+  forEach,
+  groupBy,
+  intersection,
+  merge,
   omit,
-  uniq,
+  pick,
+  remove,
   sortedUniq,
-  merge,
-  difference,
-  intersection,
-  union
-} from '../src/collections.js'
+  union,
+  uniq
+} from '../src/collections/index.js'
 
 describe('collections', () => {
-  it('contains', () => {
-    assert(contains([4, 7, 1, 9], 1))
-    assert(!contains([4, 7, 1, 9], NaN))
+  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', () => {
@@ -141,8 +149,7 @@ describe('collections', () => {
       { user: 'barney', age: 36, active: true },
       { user: 'fred', age: 40, active: false }
     ]
-    let result = []
-    // @ts-expect-error
+    let result = [] as any
     forEach(users, (value, key) => result.push([key, value]))
     assert.deepEqual(
       result,
@@ -158,17 +165,17 @@ describe('collections', () => {
     assert.deepEqual(objs, Object.entries(target))
   })
 
-  it('flatten', () => {
+  it('flatten Array', () => {
     let data = flatten([1, 2, [3, 4], 5])
     assert.deepEqual(data, [1, 2, 3, 4, 5])
   })
 
-  it('flattenDeep', () => {
+  it('flatten Array deep', () => {
     let data = flatten([1, 2, [3, [4]], [5]], true)
     assert.deepEqual(data, [1, 2, 3, 4, 5])
   })
 
-  it('flattenObj', () => {
+  it('flatten Object', () => {
     const data = {
       dates: {
         expiry_date: '30 sep 2018',
@@ -185,7 +192,7 @@ describe('collections', () => {
         value: 1500
       }
     }
-    assert.deepEqual(flattenObj(data), {
+    assert.deepEqual(flatten(data), {
       'dates.expiry_date': '30 sep 2018',
       'dates.available': '30 sep 2017',
       'dates.min_contract_period[0].id': 1,
@@ -195,10 +202,8 @@ describe('collections', () => {
     })
   })
 
-  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('groupBy', () => {
+    assert.deepEqual(groupBy([6.1, 4.2, 6.3], Math.floor), { '4': [4.2], '6': [6.1, 6.3] })
   })
 
   it('merge', () => {
@@ -251,6 +256,18 @@ describe('collections', () => {
     )
   })
 
+  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)

package/tests/globals.spec.ts

@@ -1,45 +1,42 @@
 import assert from 'assert'
 import {
-  True,
-  False,
+  bin,
+  call,
+  chr,
   CustomError,
-  type,
-  str,
-  isBool,
-  isObject,
-  isString,
+  False,
+  get,
+  hash,
+  hashCode,
+  HASH_KEY,
+  hex,
   isArray,
   isArrayLike,
-  isNumber,
-  isNaN,
-  isNull,
+  isAsync,
   isBigint,
+  isBool,
+  isEmpty,
   isFunc,
+  isNaN,
+  isNull,
+  isNumber,
+  isObject,
   isPromise,
+  isString,
   isSymbol,
-  isAsync,
-  uniqueId,
-  call,
-  chr,
-  ord,
   keys,
-  values,
-  round,
-  enumerate,
-  isEmpty,
-  isGenerator,
-  hash,
-  hashCode,
-  HASH_KEY,
-  bin,
-  hex,
-  oct,
   list,
   next,
-  get
-} from '../src/globals.js'
-
-function cb() {}
+  oct,
+  ord,
+  str,
+  True,
+  type,
+  uniqueId,
+  values,
+  _
+} from '../src/globals/index.js'
+import { enumerate } from '../src/itertools/index.js'
 
 describe('globals', () => {
   it('CustomError', () => {
@@ -70,8 +67,25 @@ describe('globals', () => {
     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 Promise(cb)) === 'promise')
+    assert(type(new Map()) === 'Map')
+    assert(type(new WeakMap()) === 'WeakMap')
+    assert(type(new Set()) === 'Set')
+    assert(type(new WeakSet()) === 'WeakSet')
+    assert(type(new Promise(_)) === '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', () => {
@@ -101,14 +115,14 @@ describe('globals', () => {
   })
 
   it('isFunc', () => {
-    assert(isFunc(cb))
+    assert(isFunc(_))
     assert(!isFunc([]))
   })
 
   it('isAsync', () => {
     assert(isAsync(async function () {}))
     assert(isAsync(async () => {}))
-    assert(!isAsync(cb))
+    assert(!isAsync(_))
   })
 
   it('isNaN', () => {
@@ -129,7 +143,7 @@ describe('globals', () => {
   })
 
   it('isPromise', () => {
-    assert(isPromise(new Promise(cb)))
+    assert(isPromise(new Promise(_)))
   })
 
   it('isSymbol', () => {
@@ -193,25 +207,6 @@ describe('globals', () => {
     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])
@@ -251,15 +246,15 @@ describe('globals', () => {
 
   it('get', () => {
     const arr = [1, 2, 3]
-    assert(get(arr, '2') === 3)
-    assert(get(arr, '3', false) === false)
-    assert(get(arr, '3', false) === false)
+    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(obj, 'foo.bar'))
-    assert(get(obj, ['foo', 'bar']))
-    assert(get(obj, HASH_KEY) === h)
-    assert(get(obj, [HASH_KEY]) === h)
+    assert(get('foo.bar', obj))
+    assert(get(['foo', 'bar'], obj))
+    assert(get(HASH_KEY, obj) === h)
+    assert(get([HASH_KEY], obj) === h)
   })
 
   it('isEmpty', () => {
@@ -269,6 +264,7 @@ describe('globals', () => {
     assert(isEmpty(''))
     assert(isEmpty({}))
     assert(isEmpty(0))
+    assert(isEmpty(false))
     assert(!isEmpty(1))
   })
 })

package/tests/itertools.spec.ts

@@ -1,10 +1,175 @@
 import assert from 'assert'
-import { list } from '../src/globals.js'
-import { reversed, sort, sorted, times, zip } from '../src/itertools.js'
+import {
+  accumulate,
+  all,
+  any,
+  chain,
+  contains,
+  dropWhile,
+  enumerate,
+  first,
+  flatMap,
+  icompact,
+  ifilter,
+  iflatten,
+  imap,
+  islice,
+  itake,
+  partition,
+  range,
+  reduce,
+  reversed,
+  sort,
+  sorted,
+  take,
+  takeWhile,
+  times,
+  zip
+} from '../src/itertools/index.js'
+import { max } from '../src/math/index.js'
 
-function cb() {}
+const Falsy = (x) => !x
 
 describe('operators', () => {
+  it('accumulate', () => {
+    assert.deepEqual([...accumulate([1, 2, 3, 4])], [1, 3, 6, 10])
+    assert.deepEqual(
+      [...accumulate([3, 4, 6, 2, 1, 9, 0, 7, 5, 8], (x, y) => max([x, y]))],
+      [3, 4, 6, 6, 6, 9, 9, 9, 9, 9]
+    )
+  })
+
+  it('all', () => {
+    assert(all([1, true, [], 'test', {}]))
+    assert(!all([[], {}, '']))
+    assert(all<any>([false, 0, '', null, undefined, NaN], Falsy))
+  })
+
+  it('any', () => {
+    assert(any([1, true, [], 'test', {}]))
+    assert(!any([0, false, '']))
+    assert(any([0, false, ''], Falsy))
+  })
+
+  it('chain', () => {
+    let it = chain([1, 3, 5], [2, 4, 6])
+    assert.deepEqual([...it], [1, 3, 5, 2, 4, 6])
+  })
+
+  it('contains', () => {
+    assert(contains([4, 7, 1, 9], 1))
+    assert(!contains([4, 7, 1, 9], NaN))
+  })
+
+  it('dropWhile', () => {
+    let it = dropWhile([false, 0, '', true, '', []], Falsy)
+    assert.deepEqual([...it], [true, '', []])
+  })
+
+  it('enumerate', () => {
+    let iter = enumerate(['foo', 'bar', 'baz'])
+    let values = [...iter]
+    assert.deepEqual(values, [
+      [0, 'foo'],
+      [1, 'bar'],
+      [2, 'baz']
+    ])
+  })
+
+  it('first', () => {
+    assert(first(['foo', 'bar']) === 'foo')
+    assert(first([0, 1]) === 0)
+    assert(first([1, 1]) === 1)
+  })
+
+  it('flatMap', () => {
+    assert.deepEqual(
+      [
+        ...flatMap([
+          [1, 2],
+          [3, 4]
+        ])
+      ],
+      [1, 2, 3, 4]
+    )
+    assert.deepEqual(
+      [
+        ...flatMap(
+          [
+            [1, 2],
+            [3, 4]
+          ],
+          ([x, y]) => [x * 2, y * 2]
+        )
+      ],
+      [2, 4, 6, 8]
+    )
+  })
+
+  it('icompact', () => {
+    let it = icompact([false, 0, '', true, '', []])
+    assert.deepEqual([...it], [true])
+  })
+
+  it('ifilter', () => {
+    let users = [
+      { user: 'barney', age: 36, active: true },
+      { user: 'fred', age: 40, active: false }
+    ]
+    let it = ifilter(users, (x) => !x.active)
+    assert.deepEqual([...it], [users[1]])
+  })
+
+  it('iflatten', () => {
+    let it = iflatten([
+      [0, 1],
+      [2, 3]
+    ])
+    assert.deepEqual([...it], [0, 1, 2, 3])
+  })
+
+  it('imap', () => {
+    let it = imap([0, 1, 2, 3], (x) => 2 ** x)
+    assert.deepEqual([...it], [1, 2, 4, 8])
+  })
+
+  it('islice', () => {
+    assert.deepEqual([...islice([1, 2, 3], 1)], [2, 3])
+    assert.deepEqual([...islice([1, 2, 3, 4], 2)], [3, 4])
+    assert.deepEqual([...islice([1, 2, 3, 4], 1, 3)], [2, 3])
+    assert.deepEqual([...islice([1, 2, 3, 4, 5], 0, 4)], [1, 2, 3, 4])
+    assert.deepEqual([...islice([1, 2, 3, 4, 5], 0, 4, 2)], [1, 3])
+  })
+
+  it('itake', () => {
+    let it = itake(3, [false, 0, '', true, '', []])
+    assert.deepEqual([...it], [false, 0, ''])
+  })
+
+  it('take', () => {
+    let it = take(3, [false, 0, '', true, '', []])
+    assert.deepEqual(it, [false, 0, ''])
+  })
+
+  it('partition', () => {
+    let [A, B] = partition([false, 0, '', true, '', []], Falsy)
+    assert.deepEqual(A, [false, 0, '', ''])
+    assert.deepEqual(B, [true, []])
+  })
+
+  it('range', () => {
+    assert.deepEqual([...range(0)], [])
+    assert.deepEqual([...range(4)], [0, 1, 2, 3])
+    assert.deepEqual([...range(-4)], [0, -1, -2, -3])
+    assert.deepEqual([...range(0, -4, -1)], [0, -1, -2, -3])
+    assert.deepEqual([...range(1, 5)], [1, 2, 3, 4])
+    assert.deepEqual([...range(0, 20, 5)], [0, 5, 10, 15])
+  })
+
+  it('reduce', () => {
+    assert(reduce([1, 2, 3, 4, 5], (x, y) => x + y, 0) === 15)
+  })
+
   it('reversed', () => {
     let arr = [3, 2, 1]
     let reverse = reversed(arr)
@@ -67,10 +232,17 @@ describe('operators', () => {
   })
 
   it('times', () => {
-    let arr = list(times(5, (x) => x))
+    let arr = [...times(5, (x) => x)]
     assert.deepEqual(arr, [0, 1, 2, 3, 4])
   })
 
+  it('takeWhile', () => {
+    let arr = [...takeWhile([1, 2, 3, 4], (x) => x < 4)]
+    assert.deepEqual(arr, [1, 2, 3])
+    arr = [...takeWhile([1, 2, 3, 4, 5], (x) => x)]
+    assert.deepEqual(arr, [1, 2, 3, 4, 5])
+  })
+
   it('zip', () => {
     let users1 = [
       { user: 'barney', age: 36 },

package/tests/math.spec.ts

@@ -0,0 +1,25 @@
+import assert from 'assert'
+import { max, min, round, sum } from '../src/math/index.js'
+
+describe('math', () => {
+  it('min', () => {
+    assert(min([5, 4, 3, 1, 2]) === 1)
+  })
+
+  it('max', () => {
+    assert(max([7, 9, 3, 11]) === 11)
+  })
+
+  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('sum', () => {
+    assert(sum([]) === 0)
+    assert(sum([1, 2, 3, 4]) === 10)
+  })
+})

package/tests/operators.spec.ts

@@ -1,6 +1,5 @@
 import assert from 'assert'
-import { isEmpty } from '../src/globals.js'
-import { bool, id, isinstance, not, all, any, comp, shallowEqual } from '../src/operators.js'
+import { bool, id, isinstance, not, comp, shallowEqual } from '../src/operators/index.js'
 
 describe('operators', () => {
   it('id', () => {
@@ -11,18 +10,6 @@ describe('operators', () => {
     assert(id(Object) === Object)
   })
 
-  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))
@@ -49,17 +36,5 @@ describe('operators', () => {
     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 }
-      )
-    )
   })
 })

package/tests/random.spec.ts

@@ -0,0 +1,46 @@
+import assert from 'assert'
+import { any, times } from '../src/itertools/index.js'
+import { choice, random, randomInt, sample, shuffle } from '../src/random/index.js'
+
+const randomArr = () => [...times(10, (i) => randomInt(i, 71))]
+
+describe('random', () => {
+  it('choice', () => {
+    let arr = randomArr()
+    for (let i = 0; i < 10; i++) {
+      assert(arr.includes(choice(arr)))
+    }
+  })
+
+  it('random', () => {
+    for (let i = 1; i <= 10; i++) {
+      let r = random(0, i)
+      assert(0 <= r && r < i)
+    }
+  })
+
+  it('randomInt', () => {
+    for (let i = 1; i <= 10; i++) {
+      let r = randomInt(0, i)
+      assert(0 <= r && r <= i)
+    }
+  })
+
+  it('shuffle', () => {
+    let arr = randomArr()
+    let copy = arr.slice()
+    for (let i = 0; i < 10; i++) {
+      assert(shuffle(copy) === copy)
+      assert(copy.some((x, i) => x !== arr[i]))
+    }
+  })
+
+  it('sample', () => {
+    let arr = randomArr()
+    for (let i = 0; i < 10; i++) {
+      let s = sample(arr, 3)
+      assert(s.length === 3)
+      assert(s.some((x, i) => x !== arr[i]))
+    }
+  })
+})

package/tsconfig.json

@@ -106,12 +106,20 @@
   ],
   "typedocOptions": {
     "entryPoints": [
-      "src/index.ts"
+      "./src/globals/index.ts",
+      "./src/collections/index.ts",
+      "./src/datetime/index.ts",
+      "./src/functools/index.ts",
+      "./src/itertools/index.ts",
+      "./src/math/index.ts",
+      "./src/operators/index.ts",
+      "./src/random/index.ts",
     ],
     "out": "docs",
     "exclude": [
-      "node_modules",
-      "tests/*.spec.ts"
-    ]
+      "node_modules"
+    ],
+    "excludeExternals": true,
+    "excludePrivate": true,
   }
 }