atomic-fns 0.2.0 → 0.2.2

package/src/itertools.js

@@ -1,29 +1,31 @@
-import { isObject, len } from './globals.js';
-import { comp, id } from './operators.js';
-const compKey = (cmp, key) => (x, y) => cmp(key(x), key(y));
+/**
+ * Iterators
+ * @module
+ */
+import { isObject, len } from './globals.js'
+import { comp, id } from './operators.js'
+const compKey = (cmp, key) => (x, y) => cmp(key(x), key(y))
 export function* range(...args) {
-    if (args.length === 1) {
-        const stop = args[0];
-        for (let i = 0; i < stop; i++) {
-            yield i;
-        }
+  if (args.length === 1) {
+    const stop = args[0]
+    for (let i = 0; i < stop; i++) {
+      yield i
     }
-    else if (args.length === 2) {
-        let [start, stop] = args;
-        for (; start < stop; start++) {
-            yield start;
-        }
+  } else if (args.length === 2) {
+    let [start, stop] = args
+    for (; start < stop; start++) {
+      yield start
     }
-    else {
-        let [start, stop, step] = args;
-        for (; start < stop; start += step) {
-            yield start;
-        }
+  } else {
+    let [start, stop, step] = args
+    for (; start < stop; start += step) {
+      yield start
     }
+  }
 }
 /** Creates a new list with the elements from the iterable in reverse order. */
 export function reversed(iterable) {
-    return Array.from(iterable).reverse();
+  return Array.from(iterable).reverse()
 }
 /**
  * Creates a new list from `args` and sorts it. This can be called many ways:
@@ -43,24 +45,21 @@ export function reversed(iterable) {
  * @return
  */
 export function sorted(args, key, reverse, compareFn) {
-    if (isObject(args))
-        args = Object.keys(args);
-    if (typeof key === 'boolean') {
-        if (typeof reverse === 'function') {
-            compareFn = reverse;
-            reverse = false;
-        }
-        else {
-            reverse = true;
-        }
-        key = id;
+  if (isObject(args)) args = Object.keys(args)
+  if (typeof key === 'boolean') {
+    if (typeof reverse === 'function') {
+      compareFn = reverse
+      reverse = false
+    } else {
+      reverse = true
     }
-    const copy = Array.from(args);
-    const _compare = compKey(compareFn || comp, key || id);
-    copy.sort(_compare);
-    if (reverse)
-        copy.reverse();
-    return copy;
+    key = id
+  }
+  const copy = Array.from(args)
+  const _compare = compKey(compareFn || comp, key || id)
+  copy.sort(_compare)
+  if (reverse) copy.reverse()
+  return copy
 }
 /**
  * Sort `args` in place. Can be called like this:
@@ -74,28 +73,26 @@ export function sorted(args, key, reverse, compareFn) {
  * @return
  */
 export function sort(args, reverse, compareFn) {
-    if (typeof reverse === 'function') {
-        compareFn = reverse;
-        reverse = false;
-    }
-    args.sort(compareFn || comp);
-    if (reverse === true)
-        args.reverse();
-    return args;
+  if (typeof reverse === 'function') {
+    compareFn = reverse
+    reverse = false
+  }
+  args.sort(compareFn || comp)
+  if (reverse === true) args.reverse()
+  return args
 }
 /** Returns a generator that calls `fn(index)` for each index < n */
 export function* times(n, fn) {
-    for (let i = 0; i < n; i++)
-        yield fn(i);
+  for (let i = 0; i < n; i++) yield fn(i)
 }
 export function* zip(...args) {
-    const size = len(args[0]);
-    for (let i = 0; i < size; i++) {
-        const tuple = [];
-        for (let k = 0; k < args.length; k++) {
-            const item = args[k][i];
-            tuple.push(item);
-        }
-        yield tuple;
+  const size = len(args[0])
+  for (let i = 0; i < size; i++) {
+    const tuple = []
+    for (let k = 0; k < args.length; k++) {
+      const item = args[k][i]
+      tuple.push(item)
     }
+    yield tuple
+  }
 }

package/src/itertools.ts

@@ -1,3 +1,7 @@
+/**
+ * Iterators
+ * @module
+ */
 import { Comp, Function, isObject, len } from './globals.js'
 import { comp, id } from './operators.js'
 

package/src/math.js

@@ -1,10 +1,13 @@
-import { call, isFunc } from './globals.js';
-import { comp } from './operators.js';
+/**
+ * Math
+ * @module
+ */
+import { call, isFunc } from './globals.js'
+import { comp } from './operators.js'
 export function abs(x) {
-    const op = call(x, 'abs');
-    if (op != null)
-        return op;
-    return Math.abs(x);
+  const op = call(x, 'abs')
+  if (op != null) return op
+  return Math.abs(x)
 }
 /**
  * Returns a tuple like (x / y, x % y)
@@ -14,54 +17,54 @@ export function abs(x) {
  * @return {number[]}
  */
 export function divmod(x, y) {
-    return [Math.floor(x / y), x % y];
+  return [Math.floor(x / y), x % y]
 }
 export function log2(x) {
-    if (x > 0) {
-        return Math.log(x) * 1.442695;
-    }
-    return Number.NaN;
+  if (x > 0) {
+    return Math.log(x) * 1.442695
+  }
+  return Number.NaN
 }
 export function logBase(x, y) {
-    if (x > 0 && y > 0) {
-        return Math.log(y) / Math.log(x);
-    }
-    return Number.NaN;
+  if (x > 0 && y > 0) {
+    return Math.log(y) / Math.log(x)
+  }
+  return Number.NaN
 }
 /** First argument can be a comparer func */
 export function min(args) {
-    // Uses `le` by default
-    let cmp = comp;
-    if (isFunc(args[0])) {
-        cmp = args.shift();
+  // Uses `le` by default
+  let cmp = comp
+  if (isFunc(args[0])) {
+    cmp = args.shift()
+  }
+  let res = args[0]
+  for (const x of args) {
+    if (cmp(x, res) === -1) {
+      res = x
     }
-    let res = args[0];
-    for (const x of args) {
-        if (cmp(x, res) === -1) {
-            res = x;
-        }
-    }
-    return res;
+  }
+  return res
 }
 /** First argument can be a comparer func */
 export function max(args) {
-    // Uses ge by default
-    let cmp = comp;
-    if (isFunc(args[0])) {
-        cmp = args.shift();
-    }
-    let res = args[0];
-    for (const x of args) {
-        if (cmp(x, res) === 1) {
-            res = x;
-        }
+  // Uses ge by default
+  let cmp = comp
+  if (isFunc(args[0])) {
+    cmp = args.shift()
+  }
+  let res = args[0]
+  for (const x of args) {
+    if (cmp(x, res) === 1) {
+      res = x
     }
-    return res;
+  }
+  return res
 }
 export function sum(args) {
-    let total = 0;
-    for (const x of args) {
-        total += x;
-    }
-    return total;
+  let total = 0
+  for (const x of args) {
+    total += x
+  }
+  return total
 }

package/src/math.ts

@@ -1,3 +1,7 @@
+/**
+ * Math
+ * @module
+ */
 import { call, isFunc } from './globals.js'
 import { comp } from './operators.js'
 

package/src/objects.js

@@ -1 +1 @@
-"use strict";
+'use strict'

package/src/operators.js

@@ -1,116 +1,98 @@
-import { call, isNumber, isObject } from './globals.js';
-export const id = (x) => x;
-export const bool = (x) => !!x;
-export const not = (x) => !x;
-export const isinstance = (x, y) => x instanceof y;
-export const all = (arr, fn = bool) => arr.every(fn);
-export const any = (arr, fn = bool) => arr.some(fn);
-export const and = all;
-export const or = any;
+/**
+ * Operators
+ * @module
+ */
+import { call, isNumber, isObject } from './globals.js'
+export const id = (x) => x
+export const bool = (x) => !!x
+export const not = (x) => !x
+export const isinstance = (x, y) => x instanceof y
+export const all = (arr, fn = bool) => arr.every(fn)
+export const any = (arr, fn = bool) => arr.some(fn)
+export const and = all
+export const or = any
 export function comp(x, y) {
-    const op = call(x, 'compare', y);
-    if (isNumber(op))
-        return op;
-    if (eq(x, y))
-        return 0;
-    if (le(x, y))
-        return -1;
-    if (ge(x, y))
-        return 1;
-    return 0;
+  const op = call(x, 'compare', y)
+  if (isNumber(op)) return op
+  if (eq(x, y)) return 0
+  if (le(x, y)) return -1
+  if (ge(x, y)) return 1
+  return 0
 }
 export function eq(x, y) {
-    const op = call(x, 'eq', y);
-    if (op != null)
-        return op;
-    return x === y;
+  const op = call(x, 'eq', y)
+  if (op != null) return op
+  return x === y
 }
 export function shallowEqual(x, y) {
-    if (!x || !y)
-        return x === y;
-    if (Array.isArray(x)) {
-        for (let i = 0; i < x.length; i++) {
-            if (!eq(x[i], y[i]))
-                return false;
-        }
-        return true;
+  if (!x || !y) return x === y
+  if (Array.isArray(x)) {
+    for (let i = 0; i < x.length; i++) {
+      if (!eq(x[i], y[i])) return false
     }
-    if (isObject(x)) {
-        if (eq(x, y))
-            return true;
-        for (const key in x) {
-            if (!eq(x[key], y[key]))
-                return false;
-        }
-        return true;
+    return true
+  }
+  if (isObject(x)) {
+    if (eq(x, y)) return true
+    for (const key in x) {
+      if (!eq(x[key], y[key])) return false
     }
-    return eq(x, y);
+    return true
+  }
+  return eq(x, y)
 }
 export function lt(x, y) {
-    const op = call(x, 'lt', y);
-    if (op != null)
-        return op;
-    return x < y;
+  const op = call(x, 'lt', y)
+  if (op != null) return op
+  return x < y
 }
 export function le(x, y) {
-    let op = call(x, 'le', y);
-    if (op != null)
-        return op;
-    op = call(x, 'eq', y);
-    if (op === true)
-        return op;
-    op = call(x, 'lt', y);
-    if (op != null)
-        return op;
-    return x <= y;
+  let op = call(x, 'le', y)
+  if (op != null) return op
+  op = call(x, 'eq', y)
+  if (op === true) return op
+  op = call(x, 'lt', y)
+  if (op != null) return op
+  return x <= y
 }
 export function gt(x, y) {
-    const op = call(x, 'gt', y);
-    if (op != null)
-        return op;
-    return x > y;
+  const op = call(x, 'gt', y)
+  if (op != null) return op
+  return x > y
 }
 export function ge(x, y) {
-    let op = call(x, 'ge', y);
-    if (op != null)
-        return op;
-    op = call(x, 'eq', y);
-    if (op === true)
-        return op;
-    op = call(x, 'gt', y);
-    if (op != null)
-        return op;
-    return x >= y;
+  let op = call(x, 'ge', y)
+  if (op != null) return op
+  op = call(x, 'eq', y)
+  if (op === true) return op
+  op = call(x, 'gt', y)
+  if (op != null) return op
+  return x >= y
 }
 export function add(x, y) {
-    const op = call(x, 'add', y);
-    if (op != null)
-        return op;
-    return x + y;
+  const op = call(x, 'add', y)
+  if (op != null) return op
+  return x + y
 }
 export function sub(x, y) {
-    const op = call(x, 'sub', y);
-    if (op != null)
-        return op;
-    return x - y;
+  const op = call(x, 'sub', y)
+  if (op != null) return op
+  return x - y
 }
 export function mult(x, y) {
-    const op = call(x, 'mult', y);
-    if (op != null)
-        return op;
-    return x * y;
+  const op = call(x, 'mult', y)
+  if (op != null) return op
+  return x * y
 }
 export function div(x, y) {
-    const op = call(x, 'div', y);
-    if (op != null)
-        return op;
-    return x / y;
+  const op = call(x, 'div', y)
+  if (op != null) return op
+  return x / y
 }
 export function mod(x, y) {
-    const op = call(x, 'mod', y);
-    if (op != null)
-        return op;
-    return x % y;
+  const op = call(x, 'mod', y)
+  if (op != null) return op
+  return x % y
 }
 /**
  * Calculates `x` to the power of `y`. If `x` implements a custom `pow` operator
@@ -121,8 +103,7 @@ export function mod(x, y) {
  * @return `x` raised to the power `y`
  */
 export function pow(x, y) {
-    const op = call(x, 'pow', y);
-    if (op != null)
-        return op;
-    return x ** y;
+  const op = call(x, 'pow', y)
+  if (op != null) return op
+  return x ** y
 }

package/src/operators.ts

@@ -1,3 +1,7 @@
+/**
+ * Operators
+ * @module
+ */
 import { call, isNumber, isObject } from './globals.js'
 
 export const id = (x) => x

package/src/random.js

@@ -1,14 +1,17 @@
-import { isObject } from './globals';
+/**
+ * Random
+ * @module
+ */
+import { isObject } from './globals'
 /** Returns a random float between a [min, max) value (max exclusive). */
-export const random = (min = 0, max = 1) => Math.random() * (max - min) + min;
+export const random = (min = 0, max = 1) => Math.random() * (max - min) + min
 /** Returns a random integer between a [min, max] value (inclusive). */
-export const randomInt = (min = 0, max = 1) => Math.round(random(min, max));
+export const randomInt = (min = 0, max = 1) => Math.round(random(min, max))
 /** Returns the item at some random index in a sequence. */
 export const choice = (arr) => {
-    if (!arr || !arr.length)
-        return;
-    return arr[randomInt(0, arr.length - 1)];
-};
+  if (!arr || !arr.length) return
+  return arr[randomInt(0, arr.length - 1)]
+}
 /**
  * Returns a random sample of size k from a list of items.
  *
@@ -18,13 +21,12 @@ export const choice = (arr) => {
  * @return
  */
 export function sample(arr, k) {
-    if (!arr || !arr.length || arr.length < k)
-        return;
-    const result = [];
-    for (let i = 0; i < k; i++) {
-        result.push(choice(arr));
-    }
-    return result;
+  if (!arr || !arr.length || arr.length < k) return
+  const result = []
+  for (let i = 0; i < k; i++) {
+    result.push(choice(arr))
+  }
+  return result
 }
 /**
  * Shuffles a collection elements in-place. Uses the Fisher-Yates algorithm for uniform shuffling. If collection is an Object it returns shuffled `Object.values()`.
@@ -33,16 +35,14 @@ export function sample(arr, k) {
  * @return
  */
 export function shuffle(arr) {
-    if (!arr || !arr.length)
-        return;
-    if (isObject(arr))
-        arr = Object.values(arr);
-    const n = arr.length - 1;
-    for (let i = n; i > 0; i--) {
-        const j = randomInt(0, i);
-        const temp = arr[j];
-        arr[j] = arr[i];
-        arr[i] = temp;
-    }
-    return arr;
+  if (!arr || !arr.length) return
+  if (isObject(arr)) arr = Object.values(arr)
+  const n = arr.length - 1
+  for (let i = n; i > 0; i--) {
+    const j = randomInt(0, i)
+    const temp = arr[j]
+    arr[j] = arr[i]
+    arr[i] = temp
+  }
+  return arr
 }

package/src/random.ts

@@ -1,4 +1,8 @@
-import { isObject, round } from './globals'
+/**
+ * Random
+ * @module
+ */
+import { isObject } from './globals'
 
 /** Returns a random float between a [min, max) value (max exclusive). */
 export const random = (min = 0, max = 1) => Math.random() * (max - min) + min

package/src/strings.js

@@ -1 +1 @@
-"use strict";
+'use strict'

package/src/util.js

@@ -1 +1 @@
-"use strict";
+'use strict'