atomic-fns 0.2.0 → 0.2.3

package/tests/globals.spec.ts

@@ -1,43 +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'
+  oct,
+  ord,
+  round,
+  str,
+  True,
+  type,
+  uniqueId,
+  values
+} from '../src/globals/index.js'
+import { enumerate } from '../src/itertools/index.js'
 
 function cb() {}
 
@@ -47,9 +46,11 @@ describe('globals', () => {
     assert.equal(err.message, 'custom')
   })
 
+  it('True', () => assert(True() === true))
+
+  it('False', () => assert(False() === false))
+
   it('type', () => {
-    assert(True())
-    assert(!False())
     assert(type(null) === 'null')
     assert(type(undefined) === 'undefined')
     assert(type(true) === 'boolean')
@@ -69,36 +70,87 @@ describe('globals', () => {
     assert(type({}) === 'object')
     assert(type(type) === 'function')
     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(cb)) === '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('isFunc', () => {
     assert(isFunc(cb))
     assert(!isFunc([]))
+  })
+
+  it('isAsync', () => {
     assert(isAsync(async function () {}))
     assert(isAsync(async () => {}))
     assert(!isAsync(cb))
+  })
+
+  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(cb)))
+  })
+
+  it('isSymbol', () => {
     assert(isSymbol(Symbol()))
+  })
+
+  it('isNull', () => {
     assert(isNull(null))
     assert(isNull(undefined))
     assert(!isNull(''))
@@ -163,17 +215,6 @@ describe('globals', () => {
     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])
@@ -213,15 +254,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', () => {
@@ -231,6 +272,7 @@ describe('globals', () => {
     assert(isEmpty(''))
     assert(isEmpty({}))
     assert(isEmpty(0))
+    assert(isEmpty(false))
     assert(!isEmpty(1))
   })
 })

package/tests/itertools.spec.ts

@@ -1,10 +1,183 @@
 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,
+  max,
+  min,
+  partition,
+  range,
+  reduce,
+  reversed,
+  sort,
+  sorted,
+  sum,
+  take,
+  takeWhile,
+  times,
+  zip
+} from '../src/itertools/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('min', () => {
+    assert(min([5, 4, 3, 1, 2]) === 1)
+  })
+
+  it('max', () => {
+    assert(max([7, 9, 3, 11]) === 11)
+  })
+
+  it('partition', () => {
+    let [A, B] = partition([false, 0, '', true, '', []], Falsy)
+    assert.deepEqual(A, [false, 0, '', ''])
+    assert.deepEqual(B, [true, []])
+  })
+
+  it('range', () => {
+    assert.deepEqual([...range(4)], [0, 1, 2, 3])
+    assert.deepEqual([...range(5, 9)], [5, 6, 7, 8])
+    assert.deepEqual([...range(5, 0, -2)], [5, 3, 1])
+    assert.deepEqual([...range(-3)], [])
+  })
+
+  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)
@@ -15,17 +188,21 @@ describe('operators', () => {
   it('sort', () => {
     let arr = [3, 2, 1]
     assert.deepEqual(sort(arr), [1, 2, 3])
-    arr = [3, 1, 2]
+  })
+
+  it('sort reversed', () => {
+    let 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(arr), arr.sort())
+    // sorted in reverse
     assert.deepEqual(sorted([3, 1, 2], true), [3, 2, 1])
+  })
+
+  it('sorted by key', () => {
     let users = [
       { user: 'fred', age: 40 },
       { user: 'barney', age: 36 }
@@ -46,7 +223,13 @@ describe('operators', () => {
         { user: 'barney', age: 36 }
       ]
     )
-    // using custom compare
+  })
+
+  it('sorted with custom compare', () => {
+    let users = [
+      { user: 'fred', age: 40 },
+      { user: 'barney', age: 36 }
+    ]
     assert.deepEqual(
       sorted(users, false, (x, y) => (x.user <= y.user ? -1 : 1)),
       [
@@ -56,11 +239,24 @@ describe('operators', () => {
     )
   })
 
+  it('sum', () => {
+    assert(sum([]) === 0)
+    assert(sum([1, 2, 3, 4]) === 10)
+    assert(sum([1, 2, 3, 4], 5) === 15)
+  })
+
   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 },
@@ -71,10 +267,7 @@ describe('operators', () => {
       { user: 'barney', age: 36 }
     ]
 
-    let results = [] as any
-    for (const t of zip(users1, users2)) {
-      results.push(t)
-    }
+    let results = [...zip(users1, users2)]
 
     let [first1, first2] = results[0]
     assert(first1 === users1[0])

package/tests/operators.spec.ts

@@ -1,18 +1,13 @@
 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('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('id', () => {
+    assert(id(true) === true)
+    assert(id(false) === false)
+    assert(id(3.0) === 3.0)
+    assert(id('') === '')
+    assert(id(Object) === Object)
   })
 
   it('bool', () => {
@@ -29,11 +24,6 @@ describe('operators', () => {
     assert(comp(4, 3) === 1)
   })
 
-  it('id', () => {
-    let x = Math.random()
-    assert(id(x) === x)
-  })
-
   it('isinstance', () => {
     assert(isinstance([], Array))
     assert(isinstance(Array(), Array))
@@ -46,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

@@ -9,9 +9,10 @@
     // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
     // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
     /* Language and Environment */
-    "target": "ESNext", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "target": "ES2022", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
     "lib": [
       "ESNext",
+      "ES2022",
       "DOM"
     ], /* Specify a set of bundled library declaration files that describe the target runtime environment. */
     // "jsx": "preserve",                                /* Specify what JSX code is generated. */
@@ -95,6 +96,9 @@
     // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
     "skipLibCheck": true /* Skip type checking all .d.ts files. */
   },
+  "exclude": [
+    "**/*.spec.ts"
+  ],
   "references": [
     {
       "path": "./tsconfig.node.json"
@@ -102,8 +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"
     ],
-    "out": "docs"
+    "excludeExternals": true,
+    "excludePrivate": true,
   }
 }