atomic-fns 0.3.1 → 0.3.3

package/core/operators/index.ts

@@ -0,0 +1,282 @@
+/**
+ * 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 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) {
+  if (checker(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 (!deepEqual(obj[i], other[i], checker)) {
+        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) ||
+        !deepEqual(obj[key], other[key], checker)
+      ) {
+        return false
+      }
+    }
+    return true
+  }
+
+  return false
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "atomic-fns",
   "description": "Like Lodash, but for ESNext and with types. Stop shipping code built for browsers from 2015.",
-  "version": "0.3.1",
-  "main": "src/index.js",
+  "version": "0.3.3",
+  "main": "core/index.js",
   "type": "module",
-  "types": "src/index.d.ts",
-  "module": "src/index.js",
+  "types": "core/index.d.ts",
+  "module": "core/index.js",
   "sideEffects": false,
   "devDependencies": {
     "@types/jasmine": "^4.3.0",
@@ -32,8 +32,8 @@
     "test": "NODE_OPTIONS=--loader=ts-node/esm jasmine --config=jasmine.json",
     "tsc": "tsc -p ./tsconfig.xo.json --declaration",
     "tsc:w": "tsc -p ./tsconfig.xo.json --declaration --watch",
-    "lint": "eslint src/**",
-    "lint:fix": "eslint src/** --fix",
+    "lint": "eslint core/**/*.ts",
+    "lint:fix": "eslint core/**/*.ts --fix",
     "build": "npm run lint:fix && npm run tsc && npm run docs",
     "docs": "typedoc"
   },

package/tests/BTree.spec.ts

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,161 @@
+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))
+  })
+})

package/tests/Heap.spec.ts

@@ -0,0 +1,66 @@
+import assert from 'assert'
+import { Heap } from '../core/collections/Heap.js'
+import { sorted } from '../core/itertools/index.js'
+
+describe('Heap', () => {
+  it('empty', () => {
+    let h = new Heap()
+    assert(h.empty())
+  })
+
+  it('heapifies array', () => {
+    let arr = [7, 9, 3, 5, 8, 1, 2, 6, 4]
+    let h = new Heap(arr)
+    assert.deepEqual([...h.values()], arr)
+    for (const x of sorted(arr)) {
+      assert(h.contains(x))
+      assert(h.pop() === x)
+    }
+  })
+
+  it('max heapifies', () => {
+    let arr = [7, 9, 3, 5, 8, 1, 2, 6, 4]
+    let h = new Heap(arr, (x, y) => {
+      if (x > y) return -1
+      if (x < y) return 1
+      return 0
+    })
+    assert.deepEqual([...h.values()], arr)
+    for (const x of sorted(arr, true)) {
+      assert(h.contains(x))
+      assert(h.pop() === x)
+    }
+  })
+
+  it('add', () => {
+    let h = new Heap()
+    let arr = [7, 9, 3, 5, 8, 1, 2, 6, 4]
+    for (const value of arr) {
+      h.add(value)
+      assert(h.contains(value))
+    }
+    assert(h.size === arr.length)
+  })
+
+  it('pop', () => {
+    let h = new Heap()
+    let arr = [7, 9, 3, 5, 8, 1, 2, 6, 4]
+    for (const value of arr) {
+      h.add(value)
+    }
+    assert(h.pop() === 1)
+    assert(h.size === arr.length - 1)
+    assert(h.pop() === 2)
+  })
+
+  it('remove', () => {
+    let h = new Heap()
+    let arr = [7, 9, 3, 5, 8, 1, 2, 6, 4]
+    for (const value of arr) {
+      h.add(value)
+    }
+    assert(h.pop() === 1)
+    assert(h.size === arr.length - 1)
+    assert(h.pop() === 2)
+  })
+})