atomic-fns 0.3.5 → 0.4.3

package/core/operators/index.ts

@@ -1,310 +0,0 @@
-/**
- * Generic operations for both values and objects.
- *
- * @module Operators
- */
-
-import { call, isObject } from '../globals/index.js'
-
-/** This is the identity function. It always returns the same value that was passed in */
-export const id = (x) => x
-
-/**
- * Called to implement truth value testing.
- * @param x
- * @returns {boolean} `x.bool()` if exists or `!!x`.
- */
-export const bool = (x) => {
-  const r = call(x, 'bool')
-  if (r != null) return r
-  return !!x
-}
-
-/**
- * Returns `true` if `x` is a falsy value.
- * @see {@link bool}
- */
-export const not = (x) => !bool(x)
-
-/**
- * Returns `true` if `x` is an instance of class `y`
- * @param x The instance object
- * @param y The parent class
- * @returns {boolean}
- */
-export const isinstance = (x, y) => x instanceof y
-
-/** Describes a function used to compare two values.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#parameters Array.sort()}
- */
-export type Comparer<T = any> = (x: T, y: T) => number
-
-/**
- * Checks whether `x` is a comparable type and returns the result of `x.compare(y)`.
- * Otherwise the return value of the compare function is equivalent to `obj === other ? 0 : obj < other ? -1 : 1`
- * @param {*} x An initial value
- * @param {*} y Other value to compare
- * @returns {number} The comparison result
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#parameters Array.sort()}
- * @see {@link eq}
- * @see {@link lt}
- */
-export function compare(x, y): number {
-  if (x === y || eq(x, y)) return 0
-  const op = call(x, 'compare', y)
-  if (typeof op === 'number') return op
-  if (x < y || lt(x, y)) return -1
-  return 1
-}
-
-/**
- * Compares two values to check if they are the same. If `x` is an object with an `eq` method, it returns `x.eq(y)`.
- * Otherwise it returns the result of `x === y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` and `y` are equal or `false` otherwise.
- */
-export function eq(x, y) {
-  return Object.is(x, y) || call(x, 'eq', y) != null
-}
-
-/**
- * Compares two values to check if `x` is strictly less than `y`. If `x` is an object with a `lt` method, it returns `x.lt(y)`.
- * Otherwise it returns the result of `x < y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` is strictly less than `y` or `false` otherwise.
- */
-export function lt(x, y) {
-  return x < y || call(x, 'lt', y) != null
-}
-
-/**
- * Compares two values to check if `x <= y`. If `x` is an object with a `lte` method, it returns `x.lte(y)`, also checks `x.eq(y)` and `x.lt(y)`.
- * Otherwise it returns the result of `x <= y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` is less than or equal to `y` or `false` otherwise.
- * @see {@link eq}
- * @see {@link lt}
- */
-export function lte(x, y) {
-  if (x <= y || call(x, 'lte', y)) return true
-  if (x === y || eq(x, y)) return true
-  if (x < y || lt(x, y)) return true
-  return false
-}
-
-/**
- * Compares two values to check if `x` is strictly greater than `y`. If `x` is an object with a `gt` method, it returns `x.gt(y)`.
- * Otherwise it returns the result of `x > y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` is strictly greater than `y` or `false` otherwise.
- */
-export function gt(x, y) {
-  return x > y || call(x, 'gt', y)
-}
-
-/**
- * Compares two values to check if `x >= y`. If `x` is an object with a `gte` method, it returns `x.gte(y)`, also checks `x.eq(y)` and `x.gt(y)`.
- * Otherwise it returns the result of `x >= y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` is less greater than or equal to `y` or `false` otherwise.
- * @see {@link eq}
- * @see {@link gt}
- */
-export function gte(x, y) {
-  if (x <= y || call(x, 'gte', y)) return true
-  if (x === y || eq(x, y)) return true
-  if (x > y || gt(x, y)) return true
-  return false
-}
-
-/**
- * The addition (+) operator. If `x` is an object with an `add` method, it returns `x.add(y)`.
- * Otherwise it returns the result of `x + y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x + y
- */
-export function add(x, y) {
-  const op = call(x, 'add', y)
-  if (op != null) return op
-  return x + y
-}
-
-/**
- * The subtraction (-) operator. If `x` is an object with a `sub` method, it returns `x.sub(y)`.
- * Otherwise it returns the result of `x - y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x - y
- */
-export function sub(x, y) {
-  const op = call(x, 'sub', y)
-  if (op != null) return op
-  return x - y
-}
-
-/**
- * The multiplication (*) operator. If `x` is an object with an `mul` method, it returns `x.mul(y)`.
- * Otherwise it returns the result of `x * y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x * y
- */
-export function mul(x, y) {
-  const op = call(x, 'mul', y)
-  if (op != null) return op
-  return x * y
-}
-/**
- * The division (/) operator. If `x` is an object with a `div` method, it returns `x.div(y)`.
- * Otherwise it returns the result of `x / y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x / y
- */
-export function div(x, y) {
-  const op = call(x, 'div', y)
-  if (op != null) return op
-  return x / y
-}
-/**
- * The modulo (%) operator. If `x` is an object with a `mod` method, it returns `x.mod(y)`.
- * Otherwise it returns the result of `x % y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x % y
- */
-export function mod(x, y) {
-  const op = call(x, 'mod', y)
-  if (op != null) return op
-  return x % y
-}
-
-/**
- * The power (**) operator. If `x` is an object with a `pow` method, it returns `x.pow(y)`.
- * Otherwise it returns the result of `x ** y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x ** y
- */
-export function pow(x, y) {
-  const op = call(x, 'pow', y)
-  if (op != null) return op
-  return x ** y
-}
-
-/**
- * Performs a shallow comparison of two objects or arrays to check if they have the same keys, length and values.
- * @param obj
- * @param other
- * @returns `true` if the objects are considered equal.
- * @see {@link deepEqual}
- */
-export function shallowEqual(obj, other) {
-  if (obj === other) return true
-
-  if (!obj || !other) return false
-
-  if (Array.isArray(obj)) {
-    // compare the arrays
-    if (obj.length !== other.length) return false
-
-    for (let i = 0; i < obj.length; i++) {
-      if (obj[i] !== other[i]) {
-        return false
-      }
-    }
-    return true
-  } else if (isObject(obj)) {
-    // compare the object keys
-    const objKeys = Object.keys(obj)
-    const otherKeys = Object.keys(other)
-
-    if (objKeys.length !== otherKeys.length) return false
-
-    for (const key of objKeys) {
-      if (!Object.prototype.hasOwnProperty.call(other, key) || obj[key] !== other[key]) {
-        return false
-      }
-    }
-    return true
-  }
-
-  return false
-}
-
-/**
- * Performs a recursive comparison of two objects or arrays to check if they have the same keys, length and values. Unlike {@link shallowEqual} this method compares nested values also.
- * @param obj
- * @param other
- * @returns `true` if the objects are considered equal.
- */
-export function deepEqual(obj, other, checker = eq, seen = new WeakSet()) {
-  if (checker(obj, other)) return true
-  if (!obj || !other) return false
-  if (obj.prototype !== other.prototype) return false
-  if (seen.has(obj) && seen.has(other)) return false
-
-  if (Array.isArray(obj)) {
-    // compare the arrays
-    if (obj.length !== other.length) return false
-
-    for (let i = 0; i < obj.length; i++) {
-      if (!deepEqual(obj[i], other[i], checker)) {
-        return false
-      }
-    }
-
-    return true
-  }
-
-  if (obj instanceof Set) {
-    if (obj.size !== other.size) return false
-    for (const value of obj.values()) {
-      if (!other.has(value)) return false
-    }
-    return true
-  }
-
-  if (obj instanceof Map) {
-    // compare keys and values
-    if (obj.size !== other.size) return false
-    seen.add(obj)
-    seen.add(other)
-    for (const key of obj.keys()) {
-      if (!other.has(key)) return false
-      if (!deepEqual(obj.get(key), other.get(key), checker, seen)) {
-        return false
-      }
-    }
-    return true
-  }
-
-  if (isObject(obj)) {
-    // compare the object own enumerable keys
-    const objKeys = Object.keys(obj)
-    const otherKeys = Object.keys(other)
-
-    if (objKeys.length !== otherKeys.length) return false
-
-    seen.add(obj)
-    seen.add(other)
-    for (const key of objKeys) {
-      if (
-        !Object.prototype.hasOwnProperty.call(other, key) ||
-        !deepEqual(obj[key], other[key], checker, seen)
-      ) {
-        return false
-      }
-    }
-    return true
-  }
-
-  return false
-}

package/core/random/index.ts

@@ -1,66 +0,0 @@
-/**
- * This module implements pseudo-random generators for various distributions.
- *
- * @module Random
- */
-
-import { isObject } from '../globals/index.js'
-
-/**
- * Returns a random float between a [min, max) value (max exclusive).
- * @param {number} min
- * @param {number} max
- * @returns {number}
- */
-export const random = (min = 0, max = 1) => Math.random() * (max - min) + min
-
-/**
- * Returns a random integer between a [min, max] value (inclusive).
- * @param {number} min
- * @param {number} max
- * @returns {number}
- */
-export const randomInt = (min = 0, max = 1) => Math.round(random(min, max))
-
-/**
- * Returns the item at some random index in a sequence.
- * @returns {T}
- * @template T
- */
-export const choice = <T>(arr: T[]) => {
-  if (!arr || !arr.length) return
-  return arr[randomInt(0, arr.length - 1)]
-}
-
-/**
- * Returns a random sample of size k from a list of items.
- * @param {Array} arr
- * @param {number} size
- * @returns A new array with `size` random elements from `arr`.
- * @template T
- */
-export function sample<T>(arr: T[], size: number) {
-  if (!arr || !arr.length || arr.length < size) return []
-  return shuffle(arr.slice()).slice(-size)
-}
-
-/**
- * Shuffles a collection elements in-place. Uses the Fisher-Yates algorithm for uniform shuffling. If collection is an Object it returns shuffled `Object.values()`.
- *
- * @param {Array} arr
- * @param {number} size
- * @returns The shuffled array.
- * @template T
- */
-export function shuffle<T>(arr: T[], size?: number) {
-  if (!arr || !arr.length) return arr
-  if (isObject(arr)) arr = Object.values(arr)
-  if (size == null) size = arr.length - 1
-  for (let i = 0; i <= size; i++) {
-    const j = randomInt(i, size)
-    const temp = arr[j]
-    arr[j] = arr[i]
-    arr[i] = temp
-  }
-  return arr
-}

package/firebase.json

@@ -1,10 +0,0 @@
-{
-  "hosting": {
-    "public": "docs",
-    "ignore": [
-      "firebase.json",
-      "**/.*",
-      "**/node_modules/**"
-    ]
-  }
-}

package/jasmine.json

@@ -1,14 +0,0 @@
-{
-  "reporters": [
-    {
-      "name": "jasmine-spec-reporter#SpecReporter",
-      "options": {
-        "displayStacktrace": "all"
-      }
-    }
-  ],
-  "spec_dir": "tests",
-  "spec_files": [
-    "**/*spec.ts"
-  ]
-}

package/tests/BTree.spec.ts

@@ -1,143 +0,0 @@
-import assert from 'assert'
-import { BTree } from '../core/collections/BTree.js'
-import { times } from '../core/itertools/index.js'
-
-describe('BTree', () => {
-  it('get', () => {
-    let tree = new BTree()
-
-    for (let i = 100; i > 0; i--) {
-      tree.set(i, i * 2)
-      assert(tree.get(i) == i * 2)
-    }
-  })
-
-  it('add', () => {
-    let tree = new BTree()
-
-    for (let i = 100; i > 0; i--) {
-      tree.add(i)
-      assert(tree.contains(i))
-      assert(tree.get(i) === null)
-    }
-  })
-
-  it('set', () => {
-    let tree = new BTree()
-
-    for (let i = 100; i > 0; i--) {
-      tree.set(i, i)
-      assert(tree.contains(i))
-    }
-
-    assert(tree.size === 100)
-  })
-
-  it('remove', () => {
-    let tree = new BTree()
-    for (let i = 100; i > 0; i--) {
-      tree.set(i, i)
-    }
-    assert(tree.contains(100))
-    tree.remove(100)
-    assert(tree.contains(100) === false)
-  })
-
-  it('clear', () => {
-    let tree = new BTree()
-    for (let i = 100; i > 0; i--) {
-      tree.set(i, i)
-    }
-    tree.clear()
-    assert(tree.size === 0)
-    assert(tree.contains(100) === false)
-  })
-
-  it('iterates in order', () => {
-    let tree = new BTree()
-    let entries: any[] = []
-    for (let i = 9; i >= 0; i--) {
-      tree.set(i, i * 2)
-      entries.push([i, i * 2])
-    }
-    entries.sort((x, y) => x[0] - y[0])
-    assert.deepEqual([...tree], entries)
-  })
-
-  it('minKey', () => {
-    let tree = new BTree()
-    let keys: number[] = []
-    for (let i = 10; i >= 0; i--) {
-      keys.push(i)
-      tree.set(i, i * 2)
-    }
-    keys.sort(tree._compare)
-    assert(tree.minKey() === keys[0])
-  })
-
-  it('maxKey', () => {
-    let tree = new BTree()
-    let keys: number[] = []
-    for (let i = 10; i >= 0; i--) {
-      keys.push(i)
-      tree.set(i, i * 2)
-    }
-    keys.sort(tree._compare)
-    assert(tree.maxKey() === keys[keys.length - 1])
-  })
-
-  it('clone', () => {
-    let tree = new BTree()
-    let entries: any[] = []
-    for (let i = 100; i > 0; i--) {
-      tree.set(i, i)
-      entries.push([i, i])
-    }
-    let t2 = tree.clone()
-    assert.deepEqual([...t2.reversed()], entries)
-  })
-
-  it('freeze', () => {
-    let tree = new BTree()
-    for (let i = 10; i > 0; i--) {
-      tree.set(i, i)
-    }
-    tree.freeze()
-    assert.throws(tree.clear)
-    assert.throws(() => tree.add(11))
-  })
-
-  it('reversed', () => {
-    let tree = new BTree()
-    let entries: any[] = []
-    for (let i = 100; i > 0; i--) {
-      tree.set(i, i)
-      entries.push([i, i])
-    }
-    assert.deepEqual([...tree.reversed()], entries)
-  })
-
-  it('keys', () => {
-    let tree = new BTree()
-    for (let i = 9; i >= 0; i--) {
-      tree.set(i, i)
-    }
-    assert.deepEqual([...tree.keys()], [...times(10, (i) => i)])
-  })
-
-  it('values', () => {
-    let tree = new BTree()
-    for (let i = 9; i >= 0; i--) {
-      tree.set(i, i * 2)
-    }
-    assert.deepEqual([...tree.values()], [...times(10, (i) => i * 2)])
-  })
-
-  it('entries', () => {
-    let tree = new BTree()
-    for (let i = 9; i >= 0; i--) {
-      tree.set(i, i * 2)
-    }
-    assert.deepEqual([...tree.entries()], [...times(10, (i) => [i, i * 2])])
-  })
-})

package/tests/Cache.spec.ts

@@ -1,161 +0,0 @@
-import assert from 'assert'
-import { Cache, LRUCache } from '../core/collections/LRUCache.js'
-
-describe('Cache', () => {
-  it('empty', () => {
-    let cache = new Cache()
-    assert(cache.size === 0)
-  })
-
-  it('contains', () => {
-    let cache = new Cache(2)
-    assert(cache.capacity === 2)
-    assert(!cache.contains(1))
-    cache.set(1, 'foo')
-    cache.set(2, 'bar')
-    assert(cache.contains(1))
-    assert(cache.contains(2))
-  })
-
-  it('evicts LRU keys', () => {
-    let cache = new Cache(2)
-    assert(cache.capacity === 2)
-    cache.set(1, 'foo')
-    cache.set(2, 'bar')
-    assert(cache.get(1) === 'foo')
-    cache.set(3, 'other')
-    assert(cache.get(2) === undefined)
-    assert.deepEqual([...cache.keys()], [3, 1])
-  })
-
-  it('keys', () => {
-    let cache = new Cache(5)
-    for (const value of [1, 2, 3, 4, 5]) {
-      cache.set(value, value)
-    }
-    assert.deepEqual([...cache.keys()], [5, 4, 3, 2, 1])
-  })
-
-  it('values', () => {
-    let cache = new Cache(5)
-    for (const value of [1, 2, 3, 4, 5]) {
-      cache.set(value, value)
-    }
-    assert.deepEqual([...cache.keys()], [5, 4, 3, 2, 1])
-  })
-
-  it('entries', () => {
-    let cache = new Cache(3)
-    for (const value of [1, 2, 3]) {
-      cache.set(value, 0)
-    }
-    assert.deepEqual(
-      [...cache.entries()],
-      [
-        [3, 0],
-        [2, 0],
-        [1, 0]
-      ]
-    )
-  })
-
-  it('iterator', () => {
-    let cache = new Cache(3)
-    for (const value of [1, 2, 3]) {
-      cache.set(value, 0)
-    }
-    let values = [...cache]
-    assert.deepEqual(values, [...cache.entries()])
-  })
-})
-
-describe('LRUCache', () => {
-  it('empty', () => {
-    let cache = new LRUCache()
-    assert(cache.size === 0)
-  })
-
-  it('contains', () => {
-    let cache = new LRUCache(2)
-    assert(cache.capacity === 2)
-    assert(!cache.contains(1))
-    cache.set(1, 'foo')
-    cache.set(2, 'bar')
-    assert(cache.contains(1))
-    assert(cache.contains(2))
-  })
-
-  it('evicts LRU keys', () => {
-    let cache = new LRUCache(2)
-    assert(cache.capacity === 2)
-    cache.set(1, 'foo')
-    cache.set(2, 'bar')
-    assert(cache.get(1) === 'foo')
-    cache.set(3, 'other')
-    assert(cache.get(2) === undefined)
-    assert.deepEqual([...cache.keys()], [3, 1])
-  })
-
-  it('keys', () => {
-    let cache = new LRUCache(5)
-    for (const value of [1, 2, 3, 4, 5]) {
-      cache.set(value, value)
-    }
-    assert.deepEqual([...cache.keys()], [5, 4, 3, 2, 1])
-  })
-
-  it('values', () => {
-    let cache = new LRUCache(5)
-    for (const value of [1, 2, 3, 4, 5]) {
-      cache.set(value, value)
-    }
-    assert.deepEqual([...cache.keys()], [5, 4, 3, 2, 1])
-  })
-
-  it('entries', () => {
-    let cache = new LRUCache(3)
-    for (const value of [1, 2, 3]) {
-      cache.set(value, 0)
-    }
-    assert.deepEqual(
-      [...cache.entries()],
-      [
-        [3, 0],
-        [2, 0],
-        [1, 0]
-      ]
-    )
-  })
-
-  it('iterator', () => {
-    let cache = new LRUCache(3)
-    for (const value of [1, 2, 3]) {
-      cache.set(value, 0)
-    }
-    let values = [...cache]
-    assert.deepEqual(values, [...cache.entries()])
-  })
-
-  it('delete', () => {
-    let cache = new LRUCache()
-    for (const value of [1, 2, 3]) {
-      cache.set(value, 0)
-    }
-    assert(cache.contains(1))
-    assert(cache.delete(1) === true)
-    assert(!cache.contains(1))
-    // try deleting again
-    assert(cache.delete(1) === false)
-  })
-
-  it('remove', () => {
-    let cache = new LRUCache()
-    for (const value of [1, 2, 3]) {
-      cache.set(value, 0)
-    }
-    assert(cache.contains(1))
-    assert(cache.remove(1) === 0)
-    assert(!cache.contains(1))
-    assert(cache.delete(2))
-  })
-})