atomic-fns 0.2.0 → 0.2.3

package/src/{operators.js → operators/index.js}

@@ -1,12 +1,13 @@
-import { call, isNumber, isObject } from './globals.js';
+/**
+ * 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 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))
@@ -25,27 +26,6 @@ export function eq(x, y) {
         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 (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)
@@ -126,3 +106,66 @@ export function pow(x, y) {
         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,4 +1,10 @@
-import { call, isNumber, isObject } from './globals.js'
+/**
+ * Generic operations for both values and objects.
+ *
+ * @module Operators
+ */
+
+import { call, isNumber, isObject } from '../globals/index.js'
 
 export const id = (x) => x
 
@@ -8,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
@@ -31,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
@@ -124,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,37 +1,50 @@
 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', () => {
+  it('clone array', () => {
     let arr = [4, 7, 1, 9]
     assert.deepEqual(clone(arr), arr)
     let target = { user: 'fred', age: 40, active: false }
     assert.deepEqual(clone(target), target)
   })
 
+  it('clone object', () => {
+    let target = { user: 'fred', age: 40, active: false }
+    assert.deepEqual(clone(target), target)
+  })
+
   it('difference', () => {
     let a = [1, 2, 5]
     let b = [3, 4, 5]
@@ -56,11 +69,27 @@ describe('collections', () => {
       { user: 'barney', age: 36, active: true },
       { user: 'fred', age: 40, active: false }
     ]
-    assert.deepEqual(filter(users, { age: 36 }), [users[0]])
     assert.deepEqual(
       filter(users, (o) => o.active),
       [users[0]]
     )
+  })
+
+  it('filter matches', () => {
+    assert(filter(null) == undefined)
+    let users = [
+      { user: 'barney', age: 36, active: true },
+      { user: 'fred', age: 40, active: false }
+    ]
+    assert.deepEqual(filter(users, { age: 36 }), [users[0]])
+  })
+
+  it('filter property', () => {
+    assert(filter(null) == undefined)
+    let users = [
+      { user: 'barney', age: 36, active: true },
+      { user: 'fred', age: 40, active: false }
+    ]
     assert.deepEqual(filter(users, 'active'), [users[0]])
   })
 
@@ -69,8 +98,22 @@ describe('collections', () => {
       { user: 'barney', age: 36, active: true },
       { user: 'fred', age: 40, active: false }
     ]
-    assert(find(users, { age: 36 }) === users[0])
     assert(find(users, (o) => o.active) === users[0])
+  })
+
+  it('find matches', () => {
+    let users = [
+      { user: 'barney', age: 36, active: true },
+      { user: 'fred', age: 40, active: false }
+    ]
+    assert(find(users, { age: 36 }) === users[0])
+  })
+
+  it('find property', () => {
+    let users = [
+      { user: 'barney', age: 36, active: true },
+      { user: 'fred', age: 40, active: false }
+    ]
     assert(find(users, 'active') === users[0])
   })
 
@@ -81,7 +124,23 @@ describe('collections', () => {
       { user: 'barney', age: 36, active: true }
     ]
     assert(findRight(users, { age: 36 }) === users[2])
-    assert(findRight(users, (o) => o.active) === users[2])
+  })
+
+  it('findRight matches', () => {
+    let users = [
+      { user: 'barney', age: 36, active: true },
+      { user: 'fred', age: 40, active: false },
+      { user: 'barney', age: 36, active: true }
+    ]
+    assert(findRight(users, { age: 36 }) === users[2])
+  })
+
+  it('findRight property', () => {
+    let users = [
+      { user: 'barney', age: 36, active: true },
+      { user: 'fred', age: 40, active: false },
+      { user: 'barney', age: 36, active: true }
+    ]
     assert(findRight(users, 'active') === users[2])
   })
 
@@ -90,7 +149,7 @@ describe('collections', () => {
       { user: 'barney', age: 36, active: true },
       { user: 'fred', age: 40, active: false }
     ]
-    let result = [] as any[]
+    let result = [] as any
     forEach(users, (value, key) => result.push([key, value]))
     assert.deepEqual(
       result,
@@ -100,19 +159,23 @@ describe('collections', () => {
 
   it('forEach object key', () => {
     let target = { user: 'fred', age: 40, active: false }
-    let objs = [] as any[]
+    let objs = []
+    // @ts-expect-error
     forEach(target, (value, key) => objs.push([key, value]))
     assert.deepEqual(objs, Object.entries(target))
   })
 
-  it('flattenArray', () => {
+  it('flatten Array', () => {
     let data = flatten([1, 2, [3, 4], 5])
     assert.deepEqual(data, [1, 2, 3, 4, 5])
-    data = flatten([1, 2, [3, [4]], [5]], true)
+  })
+
+  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',
@@ -129,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,
@@ -139,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', () => {
@@ -174,15 +235,39 @@ describe('collections', () => {
     )
   })
 
+  it('pickBy', () => {
+    let target = { user: 'fred', age: 40, active: false }
+    assert.deepEqual(
+      pick(target, (x) => x >= 40),
+      { age: 40 }
+    )
+  })
+
   it('omit', () => {
     let target = { user: 'fred', age: 40, active: false }
     assert.deepEqual(omit(target, ['age', 'active']), { user: 'fred' })
+  })
+
+  it('omitBy', () => {
+    let target = { user: 'fred', age: 40, active: false }
     assert.deepEqual(
       omit(target, (x) => !x),
       { user: 'fred', age: 40 }
     )
   })
 
+  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)
@@ -193,7 +278,11 @@ describe('collections', () => {
     let arr = [4, 7, 1, 1, 9, 4, 7]
     let distinct = uniq(arr)
     assert.deepEqual(distinct, [4, 7, 1, 9])
-    distinct = uniq(arr, (x) => x * 2)
+  })
+
+  it('uniqBy', () => {
+    let arr = [4, 7, 1, 1, 9, 4, 7]
+    let distinct = uniq(arr, (x) => x * 2)
     assert.deepEqual(distinct, [8, 14, 2, 18])
   })
 })