atomic-fns 0.1.1 → 0.2.2

package/src/math.js

@@ -0,0 +1,70 @@
+/**
+ * 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)
+}
+/**
+ * Returns a tuple like (x / y, x % y)
+ *
+ * @param {number} x
+ * @param {number} y
+ * @return {number[]}
+ */
+export function divmod(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
+}
+export function logBase(x, y) {
+  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()
+  }
+  let res = args[0]
+  for (const x of args) {
+    if (cmp(x, res) === -1) {
+      res = x
+    }
+  }
+  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
+    }
+  }
+  return res
+}
+export function sum(args) {
+  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'
 
@@ -9,7 +13,7 @@ export function abs(x: number) {
 
 /**
  * Returns a tuple like (x / y, x % y)
- * @export
+ *
  * @param {number} x
  * @param {number} y
  * @return {number[]}

package/src/objects.js

@@ -0,0 +1 @@
+'use strict'

package/{build → src}/operators.d.ts

@@ -21,7 +21,7 @@ export declare function mod(x: any, y: any): any;
 /**
  * Calculates `x` to the power of `y`. If `x` implements a custom `pow` operator
  * it will return `x.pow(y)`.
- * @export
+ *
  * @param {*} x
  * @param {*} y
  * @return `x` raised to the power `y`

package/src/operators.js

@@ -0,0 +1,109 @@
+/**
+ * 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
+}
+export function eq(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 (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
+  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
+}

package/src/operators.ts

@@ -1,3 +1,7 @@
+/**
+ * Operators
+ * @module
+ */
 import { call, isNumber, isObject } from './globals.js'
 
 export const id = (x) => x
@@ -114,7 +118,7 @@ export function mod(x, y) {
 /**
  * Calculates `x` to the power of `y`. If `x` implements a custom `pow` operator
  * it will return `x.pow(y)`.
- * @export
+ *
  * @param {*} x
  * @param {*} y
  * @return `x` raised to the power `y`

package/src/random.d.ts

@@ -0,0 +1,22 @@
+/** Returns a random float between a [min, max) value (max exclusive). */
+export declare const random: (min?: number, max?: number) => number;
+/** Returns a random integer between a [min, max] value (inclusive). */
+export declare const randomInt: (min?: number, max?: number) => number;
+/** Returns the item at some random index in a sequence. */
+export declare const choice: (arr: any[]) => any;
+/**
+ * Returns a random sample of size k from a list of items.
+ *
+ * @export
+ * @param {any[]} arr
+ * @param {number} k
+ * @return
+ */
+export declare function sample(arr: any[], k: number): any[] | undefined;
+/**
+ * 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 {*} arr
+ * @return
+ */
+export declare function shuffle(arr: any): any;

package/src/random.js

@@ -0,0 +1,48 @@
+/**
+ * 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
+/** Returns a random integer between a [min, max] value (inclusive). */
+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)]
+}
+/**
+ * Returns a random sample of size k from a list of items.
+ *
+ * @export
+ * @param {any[]} arr
+ * @param {number} k
+ * @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
+}
+/**
+ * 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 {*} arr
+ * @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
+}

package/src/random.ts

@@ -1,23 +1,46 @@
-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
 
-export const randomInt = (min = 0, max = 1) => round(random(min, max), 0)
+/** Returns a random integer between a [min, max] value (inclusive). */
+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: any[]) => {
-  if (!arr?.length) return
-  const index = randomInt(0, arr.length - 1)
-  return arr[index]
+  if (!arr || !arr.length) return
+  return arr[randomInt(0, arr.length - 1)]
 }
 
+/**
+ * Returns a random sample of size k from a list of items.
+ *
+ * @export
+ * @param {any[]} arr
+ * @param {number} k
+ * @return
+ */
 export function sample(arr: any[], k: number) {
-  if (!arr?.length) return
-  const result: any[] = []
-  while (k--) result.push(choice(arr))
+  if (!arr || !arr.length || arr.length < k) return
+  const result: typeof arr = []
+  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()`.
+ *
+ * @param {*} arr
+ * @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--) {
@@ -26,4 +49,5 @@ export function shuffle(arr) {
     arr[j] = arr[i]
     arr[i] = temp
   }
+  return arr
 }

package/src/strings.js

@@ -0,0 +1 @@
+'use strict'

package/src/util.js

@@ -0,0 +1 @@
+'use strict'

package/tests/collections.spec.ts

@@ -25,13 +25,18 @@ describe('collections', () => {
     assert(!contains([4, 7, 1, 9], NaN))
   })
 
-  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 +61,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 +90,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 +116,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 +141,8 @@ describe('collections', () => {
       { user: 'barney', age: 36, active: true },
       { user: 'fred', age: 40, active: false }
     ]
-    let result = [] as any[]
+    let result = []
+    // @ts-expect-error
     forEach(users, (value, key) => result.push([key, value]))
     assert.deepEqual(
       result,
@@ -100,15 +152,19 @@ 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', () => {
     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('flattenDeep', () => {
+    let data = flatten([1, 2, [3, [4]], [5]], true)
     assert.deepEqual(data, [1, 2, 3, 4, 5])
   })
 
@@ -174,9 +230,21 @@ 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 }
@@ -193,7 +261,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])
   })
 })

package/tests/globals.spec.ts

@@ -26,6 +26,7 @@ import {
   values,
   round,
   enumerate,
+  isEmpty,
   isGenerator,
   hash,
   hashCode,
@@ -36,8 +37,7 @@ import {
   list,
   next,
   get
-} from '../build/globals.js'
-import { isEmpty } from '../src/globals.js'
+} from '../src/globals.js'
 
 function cb() {}
 
@@ -47,9 +47,11 @@ describe('globals', () => {
     assert.equal(err.message, 'custom')
   })
 
+  it('True', () => assert(True() === true))
+
+  it('False', () => assert(False() === false))
+
   it('type', () => {
-    assert(True())
-    assert(!False())
     assert(type(null) === 'null')
     assert(type(undefined) === 'undefined')
     assert(type(true) === 'boolean')
@@ -70,35 +72,71 @@ describe('globals', () => {
     assert(type(type) === 'function')
     assert(type(Symbol()) === 'symbol')
     assert(type(new Promise(cb)) === 'promise')
+  })
+
+  it('isBool', () => {
     assert(isBool(true))
     assert(isBool(Boolean()))
     assert(!isBool(''))
     assert(!isBool({}))
     assert(!isBool(undefined))
+  })
+
+  it('isObject', () => {
     assert(isObject({}))
     assert(!isObject(''))
     assert(!isObject([]))
+  })
+
+  it('isString', () => {
     assert(isString(''))
     assert(!isString([]))
+  })
+
+  it('isArray', () => {
     assert(isArray([]))
     assert(isArrayLike([]))
     assert(!isArray(''))
     assert(!isArrayLike(''))
+  })
+
+  it('isFunc', () => {
     assert(isFunc(cb))
     assert(!isFunc([]))
+  })
+
+  it('isAsync', () => {
     assert(isAsync(async function () {}))
     assert(isAsync(async () => {}))
     assert(!isAsync(cb))
+  })
+
+  it('isNaN', () => {
     assert(isNaN(NaN))
+  })
+
+  it('isNumber', () => {
     assert(!isNumber(NaN))
     assert(isNumber(42))
     assert(isNumber(Number(42)))
     assert(isNumber(Number('42')))
     assert(isNumber(parseFloat('42.0')))
+  })
+
+  it('isBigInt', () => {
     assert(isBigint(42n))
     assert(isBigint(BigInt('42')))
+  })
+
+  it('isPromise', () => {
     assert(isPromise(new Promise(cb)))
+  })
+
+  it('isSymbol', () => {
     assert(isSymbol(Symbol()))
+  })
+
+  it('isNull', () => {
     assert(isNull(null))
     assert(isNull(undefined))
     assert(!isNull(''))
@@ -109,6 +147,8 @@ describe('globals', () => {
   it('str', () => {
     assert(str(undefined) === '')
     assert(str(null) === '')
+    assert(str(true) === 'true')
+    assert(str(false) === 'false')
     assert(str(NaN) === 'NaN')
     assert(str(42) === '42')
     assert(str([]) === '')

package/tests/itertools.spec.ts

@@ -15,17 +15,21 @@ describe('operators', () => {
   it('sort', () => {
     let arr = [3, 2, 1]
     assert.deepEqual(sort(arr), [1, 2, 3])
-    arr = [3, 1, 2]
+  })
+
+  it('sort reversed', () => {
+    let arr = [3, 1, 2]
     assert.deepEqual(sort(arr, true), [3, 2, 1])
   })
 
   it('sorted', () => {
     let arr = [3, 2, 1]
-    let sort = sorted(arr)
-    arr.sort()
-    assert.deepEqual(sort, arr)
-    // reversed order
+    assert.deepEqual(sorted(arr), arr.sort())
+    // sorted in reverse
     assert.deepEqual(sorted([3, 1, 2], true), [3, 2, 1])
+  })
+
+  it('sorted by key', () => {
     let users = [
       { user: 'fred', age: 40 },
       { user: 'barney', age: 36 }
@@ -46,7 +50,13 @@ describe('operators', () => {
         { user: 'barney', age: 36 }
       ]
     )
-    // using custom compare
+  })
+
+  it('sorted with custom compare', () => {
+    let users = [
+      { user: 'fred', age: 40 },
+      { user: 'barney', age: 36 }
+    ]
     assert.deepEqual(
       sorted(users, false, (x, y) => (x.user <= y.user ? -1 : 1)),
       [
@@ -71,10 +81,7 @@ describe('operators', () => {
       { user: 'barney', age: 36 }
     ]
 
-    let results = [] as any
-    for (const t of zip(users1, users2)) {
-      results.push(t)
-    }
+    let results = [...zip(users1, users2)]
 
     let [first1, first2] = results[0]
     assert(first1 === users1[0])