atomic-fns 0.2.2 → 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() {}
 
@@ -71,7 +70,22 @@ 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', () => {
@@ -201,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])
@@ -251,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', () => {
@@ -269,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)
@@ -66,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 },

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,
   }
 }

package/src/collections.d.ts

@@ -1,228 +0,0 @@
-/**
- * Collections
- * @module
- */
-import { Function, Iteratee } from './globals.js';
-/**
- * A container type that provides contains().
- *
- *
- * @interface Container
- */
-export interface Container {
-    contains: (x: any) => boolean;
-}
-/**
- * These are the "rich comparison" methods, inspired by Python operators.
- *
- *
- * @interface Comparable
- */
-export interface Comparable {
-    /** x < y: calls this.lt(other) reflection. */
-    lt?: (other: any) => boolean;
-    /** x ≤ y: calls this.le(other) reflection. */
-    le?: (other: any) => boolean;
-    /** x == y: calls this.eq(other) reflection. */
-    eq: (other: any) => boolean;
-    /** x != y: calls this.ne(other) reflection. */
-    ne: (other: any) => boolean;
-    /** x > y: calls this.gt(other) reflection. */
-    gt?: (other: any) => boolean;
-    /** x ≥ y: calls this.ge(other) reflection. */
-    ge?: (other: any) => boolean;
-}
-/**
- * A Collection is an iterable container type.
- * This is an abstract base class for user-defined collection types.
- *
- *
- * @abstract
- * @class Collection
- * @implements {Container}
- */
-export declare abstract class Collection implements Container {
-    /**
-     * Returns an iterator for the container items
-     * @return {Iterator}
-     */
-    [Symbol.iterator](): this;
-    /**
-     * Implements the iterator protocol and returns the next item in the iterable.
-     */
-    next(): void;
-    /**
-     * Adds a new item to the container.
-     * @param item
-     */
-    add(item: any): void;
-    /**
-     * Checks if item is present in the container.
-     * @param item
-     */
-    contains(item: any): boolean;
-    /**
-     * Returns the total number of elements in the container.
-     */
-    size(): number;
-    /**
-     * Remove the first item from the container where `item == x`
-     * @raises ValueError when x is not found
-     */
-    remove(x: any): void;
-    /**
-     * Retrieve and remove the item at index `i`.
-     * @returns the item or undefined if not found.
-     */
-    pop(i: any): void;
-    /**
-     * Remove all items from the container
-     */
-    clear(): void;
-}
-/**
- * Implements an iterable that allows backward iteration.
- * @interface Reversible
- */
-export interface Reversible<T = unknown> {
-    reversed: () => Iterator<T>;
-}
-/**
- * A sequence is an iterable type with efficient index-based access.
- *
- *
- * @abstract
- * @class Sequence
- * @extends {Collection}
- * @template T
- */
-export declare abstract class Sequence<T> extends Collection implements Reversible<T> {
-    /**
-     * Return the item at the given key or index
-     * @param {*} key
-     * @memberof Sequence
-     */
-    get(key: any): T | undefined;
-    /**
-     * Set a new value at the given key or index
-     *
-     * @param {*} key
-     * @param {T} val
-     * @memberof Sequence
-     */
-    set(key: any, val: T): void;
-    /**
-     * Deletes the given key or index, and its value.
-     * Raises ValueError if not key is found.
-     *
-     * @param {*} key
-     * @memberof Sequence
-     */
-    delete(key: any): void;
-    /**
-     * Adds a new item to the end of the sequence.
-     *
-     * @param {T} x
-     * @memberof Sequence
-     */
-    append(x: T): void;
-    /**
-     * Append all the items to the sequence.
-     *
-     * @param {Iterable<T>} iter
-     * @memberof Sequence
-     */
-    extend(iter: Iterable<T>): void;
-    /**
-     * Return the index of x in the sequence, or undefined if not found.
-     *
-     * @param {T} item
-     * @return {(number | undefined)}
-     * @memberof Sequence
-     */
-    indexOf(item: T): number | undefined;
-    size(): number;
-    reversed(): Iterator<T>;
-}
-/**
- * Returns a new immutable Set object with elements from `iterable`. Its contents cannot be altered after it's created.
- *
- *
- * @class FrozenSet
- * @extends {Set<T>}
- * @template T
- */
-export declare class FrozenSet<T = any> extends Set<T> {
-    constructor(iterable: Iterable<T>);
-    add(): this;
-    delete(): boolean;
-    clear(): this;
-    freeze(): Readonly<this>;
-}
-export declare const compact: (...arr: any[]) => any[];
-/**
- * Creates a function that can be used to create named tuple-like objects.
- * @example
- * ```
- * let Point = namedtuple('x', 'y', 'z')
- * let userObj = User(0, 0, 0)
- * // -> {x: 0, y: 0, z: 0}
- * ```
- *
- *
- * @param {...string[]} fields
- * @return
- */
-export declare function namedtuple(...fields: string[]): (...args: any[]) => {};
-export declare function filter(arr: any, fn?: Iteratee | PropertyKey | Object): any[] | undefined;
-export declare function find(arr: any, fn: Iteratee | PropertyKey | Object): any;
-export declare function findRight(arr: any, fn: Iteratee | PropertyKey | Object): any;
-export declare const matches: (o: any) => (x: any) => boolean;
-export declare function forEach(arr: any[], fn: Iteratee): any;
-export declare function forEach(arr: Object, fn: Iteratee): any;
-export declare function flatten(arr: any, depth?: boolean | number): any;
-export declare function flattenArray(arr: any[], depth?: boolean | number, result?: any[]): any[];
-export declare function flattenObj(o: any, prefix?: string, result?: {}, keepNull?: boolean): {};
-export declare const map: (arr: any, fn: Function | string) => any[] | undefined;
-export declare function pick(obj: any, paths: Iteratee | string[]): {};
-export declare function omit(obj: any, paths: Iteratee | string[]): {};
-export declare function contains(arr: any, y: any): any;
-export declare function indexOf(obj: any, x: any, start?: number): any;
-export declare function lastIndexOf(obj: any, x: any, start?: any): any;
-/**
- * Creates a clone of the given `obj`. If `deep` is `true` it will clone it recursively.
- *
- *
- * @param {*} obj
- * @param {boolean} [deep=false]
- * @return The clone value
- */
-export declare function clone(obj: any, deep?: boolean): any;
-export declare function cloneArray(arr: any, deep?: boolean): any;
-export declare function cloneArrayBuffer(arrayBuffer: any): any;
-export declare function cloneTypedArray(typedArray: any, isDeep: any): any;
-export declare function uniq<T = any>(arr: T[], fn?: string | Iteratee): T[];
-export declare function sortedUniq(arr: any, fn?: string | Iteratee): any[];
-/**
- * Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object. Source properties that resolve to `undefined` are skipped if a destination value exists. Array and plain object properties are merged recursively. Other objects and value types are overridden by assignment. Source objects are applied from left to right. Subsequent sources overwrite property assignments of previous sources.
- *
- * Note: this method mutates `obj`
- *
- *
- * @param {Object} obj
- * @param {...Object} sources
- * @return {Object} The destination object.
- */
-export declare function merge(obj: any, ...sources: any[]): Object;
-export declare function difference(...args: any[]): Generator<unknown, void, unknown>;
-export declare function intersection(...args: any[]): Generator<any, void, unknown>;
-export declare function union(...args: any[]): Generator<unknown, void, unknown>;
-/**
- * Creates an object composed of keys generated from the results of running each element of `arr` thru `func`. The order of grouped values is determined by the order they occur in `arr`. The corresponding value of each key is an array of elements responsible for generating the key.
- *
- *
- * @param {(any[] | Object)} arr The collection to iterate over.
- * @param {(Iteratee | PropertyKey)} [func=id] The iteratee to transform keys.
- * @return {Object} Returns the composed aggregate object.
- */
-export declare function groupBy(arr: any[] | Object, func?: Iteratee | PropertyKey): Object;