atomic-fns 0.2.2 → 0.2.3

package/src/operators/index.js

@@ -0,0 +1,171 @@
+/**
+ * Generic operations for both values and objects.
+ *
+ * @module Operators
+ */
+import { call, isNumber, isObject } from '../globals/index.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 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;
+}
+export function eq(x, y) {
+    const op = call(x, 'eq', y);
+    if (op != null)
+        return op;
+    return x === y;
+}
+export function lt(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;
+}
+export function gt(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;
+}
+export function add(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;
+}
+export function mult(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;
+}
+export function mod(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
+ * it will return `x.pow(y)`.
+ *
+ * @param {*} x
+ * @param {*} 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;
+}
+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;
+}
+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/src/{operators.ts → operators/index.ts}

@@ -1,8 +1,10 @@
 /**
- * Operators
- * @module
+ * Generic operations for both values and objects.
+ *
+ * @module Operators
  */
-import { call, isNumber, isObject } from './globals.js'
+
+import { call, isNumber, isObject } from '../globals/index.js'
 
 export const id = (x) => x
 
@@ -12,17 +14,9 @@ export const not = (x) => !x
 
 export const isinstance = (x, y) => x instanceof y
 
-export const all = (arr: any[], fn = bool) => arr.every(fn)
-
-export const any = (arr: any[], 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 (isNumber(op)) return op as 0 | 1 | -1
   if (eq(x, y)) return 0
   if (le(x, y)) return -1
   if (ge(x, y)) return 1
@@ -35,24 +29,6 @@ export function eq(x, y) {
   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 (isObject(x)) {
-    if (eq(x, y)) return true
-    for (const key in x) {
-      if (!eq(x[key], y[key])) return false
-    }
-    return true
-  }
-  return eq(x, y)
-}
-
 export function lt(x, y) {
   const op = call(x, 'lt', y)
   if (op != null) return op
@@ -128,3 +104,72 @@ export function pow(x, y) {
   if (op != null) return op
   return x ** y
 }
+
+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
+}
+
+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/src/random/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * This module implements pseudo-random generators for various distributions.
+ *
+ * @module Random
+ */
+/**
+ * Returns a random float between a [min, max) value (max exclusive).
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export declare const random: (min?: number, max?: number) => number;
+/**
+ * Returns a random integer between a [min, max] value (inclusive).
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export declare const randomInt: (min?: number, max?: number) => number;
+/**
+ * Returns the item at some random index in a sequence.
+ * @returns {T}
+ * @template T
+ */
+export declare const choice: <T>(arr: T[]) => T | undefined;
+/**
+ * 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 declare function sample<T>(arr: T[], size: number): T[];
+/**
+ * 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 declare function shuffle<T>(arr: T[], size?: number): T[];

package/src/random/index.js

@@ -0,0 +1,65 @@
+/**
+ * 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 = (arr) => {
+    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(arr, size) {
+    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(arr, size) {
+    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/src/random/index.ts

@@ -0,0 +1,66 @@
+/**
+ * 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/tests/collections.spec.ts

@@ -1,28 +1,36 @@
 import assert from 'assert'
 import {
+  clone,
+  compact,
+  count,
+  difference,
   filter,
   find,
-  forEach,
   findRight,
   flatten,
-  map,
-  contains,
-  flattenObj,
-  clone,
-  pick,
+  forEach,
+  groupBy,
+  intersection,
+  merge,
   omit,
-  uniq,
+  pick,
+  remove,
   sortedUniq,
-  merge,
-  difference,
-  intersection,
-  union
-} from '../src/collections.js'
+  union,
+  uniq
+} from '../src/collections/index.js'
 
 describe('collections', () => {
-  it('contains', () => {
-    assert(contains([4, 7, 1, 9], 1))
-    assert(!contains([4, 7, 1, 9], NaN))
+  it('compact', () => {
+    let filtered = compact([0, 1, false, 2, '', 3])
+    assert.deepEqual(filtered, [1, 2, 3])
+    assert.deepEqual(compact({ a: 1, b: undefined, c: false, d: [] }), { a: 1 })
+  })
+
+  it('count', () => {
+    let counters = count([0, 1, false, 2, '', 3], (x) => !!x)
+    assert(counters['true'] === 3)
+    assert(counters['false'] === 3)
   })
 
   it('clone array', () => {
@@ -141,8 +149,7 @@ describe('collections', () => {
       { user: 'barney', age: 36, active: true },
       { user: 'fred', age: 40, active: false }
     ]
-    let result = []
-    // @ts-expect-error
+    let result = [] as any
     forEach(users, (value, key) => result.push([key, value]))
     assert.deepEqual(
       result,
@@ -158,17 +165,17 @@ describe('collections', () => {
     assert.deepEqual(objs, Object.entries(target))
   })
 
-  it('flatten', () => {
+  it('flatten Array', () => {
     let data = flatten([1, 2, [3, 4], 5])
     assert.deepEqual(data, [1, 2, 3, 4, 5])
   })
 
-  it('flattenDeep', () => {
+  it('flatten Array deep', () => {
     let data = flatten([1, 2, [3, [4]], [5]], true)
     assert.deepEqual(data, [1, 2, 3, 4, 5])
   })
 
-  it('flattenObj', () => {
+  it('flatten Object', () => {
     const data = {
       dates: {
         expiry_date: '30 sep 2018',
@@ -185,7 +192,7 @@ describe('collections', () => {
         value: 1500
       }
     }
-    assert.deepEqual(flattenObj(data), {
+    assert.deepEqual(flatten(data), {
       'dates.expiry_date': '30 sep 2018',
       'dates.available': '30 sep 2017',
       'dates.min_contract_period[0].id': 1,
@@ -195,10 +202,8 @@ describe('collections', () => {
     })
   })
 
-  it('map', () => {
-    let target = { user: 'fred', age: 40, active: false }
-    let getEntries = (value, key) => [key, value]
-    assert.deepEqual(map(target, getEntries), Object.entries(target))
+  it('groupBy', () => {
+    assert.deepEqual(groupBy([6.1, 4.2, 6.3], Math.floor), { '4': [4.2], '6': [6.1, 6.3] })
   })
 
   it('merge', () => {
@@ -251,6 +256,18 @@ describe('collections', () => {
     )
   })
 
+  it('remove', () => {
+    assert.deepEqual(remove([1, 2, 3, 4], 1), [2, 3, 4])
+    assert.deepEqual(remove([1, 2, 3, 4], [3, 4]), [1, 2])
+  })
+
+  it('removeBy', () => {
+    assert.deepEqual(
+      remove([1, 2, 3, 4], (x) => x % 2 === 0),
+      [1, 3]
+    )
+  })
+
   it('sortedUniq', () => {
     let arr = [4, 7, 1, 9, 1, 7, 4]
     let sort = sortedUniq(arr)