atomic-fns 0.2.0 → 0.2.3

package/src/globals.ts

@@ -1,373 +0,0 @@
-export type Comp = (x, y) => number
-
-export type Function = (...args) => any
-
-export type Iteratee = (value, key?, arr?) => any
-
-export const True = () => true
-
-export const False = () => false
-
-/**
- * A custom error class that inherits from the Error object.
- *
- *
- * @class CustomError
- * @extends {Error}
- */
-export class CustomError extends Error {
-  /**
-   * Returns a new CustomError with the specified message.
-   * @param message
-   * @constructor
-   */
-  constructor(message?) {
-    super(message)
-    this.name = this.constructor.name
-    if (typeof Error.captureStackTrace === 'function') {
-      Error.captureStackTrace(this, this.constructor)
-    } else {
-      this.stack = new Error(message).stack
-    }
-  }
-}
-
-/**
- * Custom error to signal an invalid index access.
- * @extends {CustomError}
- */
-export class IndexError extends CustomError {}
-
-/**
- * Raised when a system function returns an I/O failure such as "file not found"
- * or "disk full".
- * @extends {CustomError}
- */
-export class IOError extends CustomError {}
-
-/**
- * Custom error to signal an invalid key access.
- * @extends {CustomError}
- */
-export class KeyError extends CustomError {}
-
-/**
- * Custom error to signal an invalid operation.
- * @extends {CustomError}
- */
-export class NotImplementedError extends CustomError {}
-
-/**
- * Custom error to signal an invalid value.
- * @extends {CustomError}
- */
-export class ValueError extends CustomError {}
-
-/**
- * Raised when the second argument of a division or modulo operation is zero.
- * @extends {CustomError}
- */
-export class ZeroDivisionError extends CustomError {}
-
-/**
- * Returns the true type of any value with correct detection for null, Array,
- * Object, Promise, Symbol, and NaN.
- *
- *
- * @param {*} value
- * @return
- */
-export function type(value) {
-  const result = typeof value
-  if (result === 'object') {
-    if (value) {
-      if (value instanceof String) return 'string'
-      if (value instanceof Boolean) return 'boolean'
-      if (value instanceof Function) return 'function'
-      // IE improperly marshals typeof across execution contexts, but a
-      // cross-context object will still return false for "instanceof Object".
-      if (value instanceof Array) return 'array'
-
-      const className = str(value)
-      // In Firefox 3.6, attempting to access iframe window objects' length
-      // property throws an NS_ERROR_FAILURE, so we need to special-case it
-      // here.
-      if (className === '[object Window]') return 'object'
-
-      // We cannot always use constructor === Array or instanceof Array because
-      // different frames have different Array objects.
-      // Mark Miller noticed that Object.prototype.toString
-      // allows access to the unforgeable [[Class]] property.
-      //  15.2.4.2 Object.prototype.toString ( )
-      //  When the toString method is called, the following steps are taken:
-      //      1. Get the [[Class]] property of this object.
-      //      2. Compute a string value by concatenating the three strings
-      //         "[object ", Result(1), and "]".
-      //      3. Return Result(2).
-      // and this behavior survives the destruction of the execution context.
-      if (className.endsWith('Array]') || Array.isArray(value)) {
-        return 'array'
-      }
-      // HACK: There is still an array case that fails.
-      //     function ArrayImpostor() {}
-      //     ArrayImpostor.prototype = [];
-      //     var impostor = new ArrayImpostor;
-      // this can be fixed by getting rid of the fast path
-      // (value instanceof Array) and solely relying on
-      // (value && Object.prototype.toString.vall(value) === '[object Array]')
-      // but that would require many more function calls and is not warranted
-      // unless closure code is receiving objects from untrusted sources.
-
-      // IE in cross-window calls does not correctly marshal the function type
-      // (it appears just as an object) so we cannot use just typeof val ==
-      // 'function'. However, if the object has a call property, it is a
-      // function.
-      if (className.endsWith('Function]') || typeof value.call === 'function') {
-        return 'function'
-      }
-      if (className === '[object Promise]' || value instanceof Promise) {
-        return 'promise'
-      }
-      if (className === '[object Symbol]') {
-        return 'symbol'
-      }
-    } else {
-      return 'null'
-    }
-  } else if (result === 'function' && typeof value.call === 'undefined') {
-    // In Safari typeof nodeList returns 'function', and on Firefox typeof
-    // behaves similarly for HTML{Applet,Embed,Object}, Elements and RegExps. We
-    // would like to return object for those and we can detect an invalid
-    // function by making sure that the function object has a call method.
-    return 'object'
-  } else if (Number.isNaN(value)) return 'NaN'
-  return result
-}
-
-/** Same as `x.toString()`. Returns `''` when x is null or undefined */
-export const str = (x) => (x != null ? x.toString() : '')
-
-/** Check if value is a boolean type */
-export const isBool = (x) => type(x) === 'boolean'
-
-/** Check if value is an object type */
-export const isObject = (x) => typeof x === 'object' && type(x) === 'object'
-
-/** Check if value is a string type */
-export const isString = (x) => type(x) === 'string'
-
-/** Check if value is an Array type */
-export const isArray = (x) => type(x) === 'array'
-
-/** Check if value is Array-like type.
- * A value is considered array-like if it's not a function and has a
- * `.length` number property.
- */
-export const isArrayLike = (x) => {
-  const T = type(x)
-  return T === 'array' || (T === 'object' && isNumber(x.length))
-}
-
-/** Check if value is a function type */
-export const isFunc = (x) => type(x) === 'function'
-
-/** Check if value is a number type */
-export const isNumber = (x) => type(x) === 'number'
-
-/** Check if value is a Bigint type */
-export const isBigint = (x) => type(x) === 'bigint'
-
-/** Check if value is NaN based on `Number.isNaN` */
-export const isNaN = (x) => Number.isNaN(x)
-
-/** Check if value is a Promise type */
-export const isPromise = (x) => type(x) === 'promise'
-
-/** Check if value is an async function type */
-export const isAsync = (x) => get(x, 'constructor.name') === 'AsyncFunction'
-
-/** Check if value is a generator function type */
-export const isGenerator = (x) => {
-  return get(x, 'constructor.constructor.name') === 'GeneratorFunction'
-}
-
-/** Check if value is null or undefined */
-export const isNull = (x) => x == null
-
-/** Check if value is not null or undefined */
-export const notNull = (x) => x != null
-
-export function len(x) {
-  if (x == null) return
-  if (x.length !== undefined) {
-    return x.length
-  }
-  if (isFunc(x.size)) {
-    return x.size()
-  }
-  if (isObject(x)) {
-    return Object.keys(x).length
-  }
-}
-
-/** Returns true for objects without length or falsey values. */
-export const isEmpty = (x) => (len(x) === 0 ? true : !x)
-
-/** Check if value is a Symbol type */
-export const isSymbol = (x) => type(x) === 'symbol'
-
-/**
- * Generates a unique ID using random numbers.
- * If prefix is given, the ID is appended to it
- */
-export const uniqueId = (pre: string = '') =>
-  // @ts-expect-error
-  (pre || 0) + ((Math.random() * 1e10) >>> 0)
-
-/**
- * Checks if `obj.key` is a function, and calls it with any `args`.
- *
- *
- * @param {*} obj
- * @param {PropertyKey} key
- * @param {...any[]} args
- * @return `obj.key(...args)`
- */
-export function call(obj: any, key: PropertyKey, ...args: any[]) {
-  if (isFunc(get(obj, key))) {
-    return obj[key](...args)
-  }
-}
-
-/** Convert number to unicode character */
-export const chr = (x: number) => String.fromCodePoint(x)
-
-/** Convert character to Unicode code point */
-export const ord = (x: string) => x.charCodeAt(0)
-
-/** `Object.keys(x)` */
-export const keys = (x) => Object.keys(x)
-
-/** `Object.values(x)` */
-export const values = (x) => Object.values(x)
-
-/**
- * Round `x` to the number of digits after the decimal point. If `digits` is
- * omitted, it returns the nearest integer to x.
- *
- * @param {number} x
- * @param {number} [digits=0]
- */
-export function round(x: number, digits = 0) {
-  const base = 10 ** digits
-  return Math.round(x * base) / base
-}
-
-export const floor = (x: number) => Math.floor(x)
-
-export const ceil = (x: number) => Math.ceil(x)
-
-/**
- * Yields elements like [index, item] from an iterable.
- *
- *
- * @template T
- * @param {Iterable<T>} iterable
- */
-export function* enumerate<T = unknown>(iterable: Iterable<T>) {
-  let i = 0
-  for (const item of iterable) {
-    yield [i++, item]
-  }
-}
-
-export const has = (obj, attr: PropertyKey) => obj && attr in obj
-
-/**
- * Check if the attribute is present in the object, or return optional default.
- *
- *
- * @param {*} obj
- * @param {PropertyKey} key
- * @param {*} [value=undefined]
- * @return The property value or default value
- */
-export function get(obj: any, key: PropertyKey | PropertyKey[], value: any = undefined) {
-  if (obj == null) return value
-
-  let paths = Array.isArray(key) ? key : [key]
-  if (typeof key === 'string') {
-    paths = key.split('.')
-  }
-
-  try {
-    let result = obj
-    for (const k of paths) {
-      result = result[k]
-    }
-    return result === undefined ? value : result
-  } catch (error) {
-    return value
-  }
-}
-
-export function del(x, attr) {
-  if (x != null) delete x[attr]
-  return x
-}
-
-export function set(self: any, attr: PropertyKey, value, writable = false, enumerable = false) {
-  return Object.defineProperty(self, attr, {
-    value,
-    enumerable,
-    writable
-  })
-}
-
-export const HASH_KEY = Symbol.for('HASH_KEY')
-
-export function hash(obj) {
-  if (typeof obj === 'string') {
-    return hashCode(obj)
-  }
-
-  if (typeof obj === 'object') {
-    if (obj[HASH_KEY] == null) {
-      set(obj, HASH_KEY, uniqueId())
-    }
-    return obj[HASH_KEY]
-  }
-
-  return obj
-}
-
-/**
- * A hash value generator for strings
- *
- * @param {string} str
- * @return {number}
- * @see http://isthe.com/chongo/tech/comp/fnv/
- */
-export function hashCode(str: string) {
-  const FNV1_32A_INIT = 0x811c9dc5
-  let hval = FNV1_32A_INIT
-  for (let i = 0; i < str.length; ++i) {
-    hval ^= str.charCodeAt(i)
-    hval += (hval << 1) + (hval << 4) + (hval << 7) + (hval << 8) + (hval << 24)
-  }
-  return hval >>> 0
-}
-
-export const bin = (n: number) => n.toString(2)
-
-export const hex = (n: number) => n.toString(16)
-
-export const oct = (n: number) => n.toString(8)
-
-export const float = (x) => parseFloat(x)
-
-export const int = (x, base = 10) => parseInt(x, base)
-
-export const list = (arr?) => (arr ? Array.from(arr) : [])
-
-export const next = (iter: Iterator<unknown>) => iter.next().value

package/src/itertools.d.ts

@@ -1,16 +0,0 @@
-import { Comp, Function } from './globals.js';
-export declare function range(...args: number[]): Generator<number, void, unknown>;
-/** Creates a new list with the elements from the iterable in reverse order. */
-export declare function reversed(iterable: Iterable<any>): any[];
-export declare function sorted(args: any[]): any[];
-export declare function sorted(args: any[], reverse: boolean): any[];
-export declare function sorted(args: any[], reverse: boolean, comp: Comp): any[];
-export declare function sorted(args: any[], key: Function): any[];
-export declare function sorted(args: any[], key: Function, reverse: boolean): any[];
-export declare function sort(args: any[]): any[];
-export declare function sort(args: any[], reverse: boolean): any[];
-export declare function sort(args: any[], compareFn: Comp): any[];
-export declare function sort(args: any[], reverse: boolean, compareFn: Comp): any[];
-/** Returns a generator that calls `fn(index)` for each index < n */
-export declare function times(n: number, fn: (index: number) => any): Generator<any, void, unknown>;
-export declare function zip(...args: any[]): Generator<any, void, unknown>;

package/src/itertools.js

@@ -1,101 +0,0 @@
-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;
-        }
-    }
-    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;
-        }
-    }
-}
-/** Creates a new list with the elements from the iterable in reverse order. */
-export function reversed(iterable) {
-    return Array.from(iterable).reverse();
-}
-/**
- * Creates a new list from `args` and sorts it. This can be called many ways:
- *   - sorted([...], true) => reverse order
- *   - sorted([...], fn = (x) => any) => using a key fn
- *   - sorted([...], fn = (x) => any, true) => reverse order using key
- *   - sorted([...], false, (x, y) => number) => using custom compare
- *   - sorted([...], fn = (x) => any, true, (x, y) => number) => custom key, reverse and compare
- *
- * If `args` is an Object, returns the sorted keys.
- *
- *
- * @param {(Array | Object)} args
- * @param {(boolean | Function)} [key]
- * @param {(boolean | Comp)} [reverse]
- * @param {Comp} [compareFn]
- * @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;
-    }
-    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:
- *   - sort([...], true) => reverse order
- *   - sort([...], (x, y) => number) => using custom compare
- *   - sort([...], true, (x, y) => number) => reverse and using custom compare
- *
- * @param {any[]} args
- * @param {(boolean | Comp)} [reverse]
- * @param {Comp} [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;
-}
-/** 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);
-}
-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;
-    }
-}

package/src/itertools.ts

@@ -1,112 +0,0 @@
-import { Comp, Function, isObject, len } from './globals.js'
-import { comp, id } from './operators.js'
-
-const compKey = (cmp: Comp, key) => (x, y) => cmp(key(x), key(y))
-
-export function* range(...args: number[]) {
-  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 {
-    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: Iterable<any>) {
-  return Array.from(iterable).reverse()
-}
-
-export function sorted(args: any[]): any[]
-export function sorted(args: any[], reverse: boolean): any[]
-export function sorted(args: any[], reverse: boolean, comp: Comp): any[]
-export function sorted(args: any[], key: Function): any[]
-export function sorted(args: any[], key: Function, reverse: boolean): any[]
-
-/**
- * Creates a new list from `args` and sorts it. This can be called many ways:
- *   - sorted([...], true) => reverse order
- *   - sorted([...], fn = (x) => any) => using a key fn
- *   - sorted([...], fn = (x) => any, true) => reverse order using key
- *   - sorted([...], false, (x, y) => number) => using custom compare
- *   - sorted([...], fn = (x) => any, true, (x, y) => number) => custom key, reverse and compare
- *
- * If `args` is an Object, returns the sorted keys.
- *
- *
- * @param {(Array | Object)} args
- * @param {(boolean | Function)} [key]
- * @param {(boolean | Comp)} [reverse]
- * @param {Comp} [compareFn]
- * @return
- */
-export function sorted(args, key?: boolean | Function, reverse?: boolean | Comp, compareFn?: Comp) {
-  if (isObject(args)) args = Object.keys(args)
-  if (typeof key === 'boolean') {
-    if (typeof reverse === 'function') {
-      compareFn = reverse
-      reverse = false
-    } else {
-      reverse = true
-    }
-    key = id
-  }
-  const copy = Array.from(args)
-  const _compare = compKey(compareFn || comp, key || id)
-  copy.sort(_compare)
-  if (reverse) copy.reverse()
-  return copy
-}
-
-export function sort(args: any[]): any[]
-export function sort(args: any[], reverse: boolean): any[]
-export function sort(args: any[], compareFn: Comp): any[]
-export function sort(args: any[], reverse: boolean, compareFn: Comp): any[]
-
-/**
- * Sort `args` in place. Can be called like this:
- *   - sort([...], true) => reverse order
- *   - sort([...], (x, y) => number) => using custom compare
- *   - sort([...], true, (x, y) => number) => reverse and using custom compare
- *
- * @param {any[]} args
- * @param {(boolean | Comp)} [reverse]
- * @param {Comp} [compareFn]
- * @return
- */
-export function sort(args: any[], reverse?: boolean | Comp, compareFn?: Comp) {
-  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: number, fn: (index: number) => any) {
-  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 = [] as any
-    for (let k = 0; k < args.length; k++) {
-      const item = args[k][i]
-      tuple.push(item)
-    }
-    yield tuple
-  }
-}

package/src/math.d.ts

@@ -1,16 +0,0 @@
-export declare function abs(x: number): any;
-/**
- * Returns a tuple like (x / y, x % y)
- *
- * @param {number} x
- * @param {number} y
- * @return {number[]}
- */
-export declare function divmod(x: number, y: number): number[];
-export declare function log2(x: any): number;
-export declare function logBase(x: any, y: any): number;
-/** First argument can be a comparer func */
-export declare function min(args: any): any;
-/** First argument can be a comparer func */
-export declare function max(args: any): any;
-export declare function sum(args: any): number;

package/src/math.js

@@ -1,67 +0,0 @@
-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;
-}