atomic-fns 1.1.7 → 2.0.0

package/dist/math/index.d.ts

@@ -1,96 +0,0 @@
-/**
- * Math and algebraic operations.
- *
- * @module math
- */
-import { Predicate } from '../types.js';
-/**
- * Returns the absolute value of a number. The argument may be a number or an object implementing the `abs()`.
- * @param x The value.
- * @returns The absolute value.
- */
-export declare function abs(x: any): number;
-/**
- * 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]
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round Math.round()}
- */
-export declare function round(x: number, digits?: number): number;
-/**
- * Rounds down and returns the largest integer less than or equal to a given number.
- * @param x A number.
- * @returns Nearest integer less than or equal to number.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor Math.floor()}
- */
-export declare function floor(x: number): number;
-/**
- * Rounds up and returns the largest integer greater than or equal to a given number.
- * @param x A number.
- * @returns Nearest integer greater than or equal to number.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil Math.ceil()}
- */
-export declare function ceil(x: number): number;
-/**
- * Returns a tuple like `[x / y, x % y]`.
- *
- * @param x
- * @param y
- * @returns
- */
-export declare function divmod(x: number, y: number): [number, number];
-export declare function log2(x: number): number;
-export declare function logBase(x: number, y: number): number;
-/**
- * Returns the smallest element in an iterable. The optional `key` argument specifies a transform on the elements before comparing them. If the elements in the iterable are objects that implement a custom `lt` method, this will be called to compare.
- * @param iterable The iterable to inspect.
- * @param key Optional key function to transform the elements (default `id`).
- * @returns The smallest element in the iterable.
- */
-export declare function min(iterable: number[]): number;
-export declare function min<T>(iterable: Iterable<T>, key?: Predicate<T>): T;
-/**
- * Returns the largest element in an iterable. The optional `key` argument specifies a transform on the elements before comparing them. If the elements in the iterable are objects that implement a custom `gt` method, this will be called to compare.
- * @param iterable The iterable to inspect.
- * @param key Optional key function to transform the elements (default `id`).
- * @returns The largest element in the iterable.
- */
-export declare function max(iterable: number[]): number;
-export declare function max<T>(iterable: Iterable<T>, key?: Predicate<T>): T;
-/**
- * Computes the mean of the values in `iterable` and accepts an optional `key` function which is invoked for each element to generate the values to be averaged.
- * @param {Array<number>|Iterable<T>} iterable
- * @param {Function} [key] Optional iteratee invoked per element.
- * @returns Returns the mean value or `NaN` if no elements.
- * @template T
- * @example
-```js
-let objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }]
-
-mean(objects, o => o.n)
-// 5
-```
- */
-export declare function mean(iterable: number[]): number;
-export declare function mean<T>(iterable: Iterable<T>, key?: Predicate<T>): number;
-/**
- * Sums `initial` and the items of an iterable and returns the total.
- * @param args The elements to add to `initial`.
- * @param initial The initial value to add to (default `0`).
- * @returns The total sum of initial and iterable elements.
- * @example
-```js
-sum([1, 2, 3, 4])
-// 10
-
-sum([1, 2, 3, 4], 5)
-// 15
-```
- */
-export declare function sum(args: number[]): number;
-export declare function sum<T>(args: Iterable<T>, key?: Predicate<T>): number;

package/dist/math/index.js

@@ -1,98 +0,0 @@
-/**
- * Math and algebraic operations.
- *
- * @module math
- */
-import { call } from '../globals/index.js';
-import { reduce } from '../itertools/index.js';
-import { gt, id, lt } from '../operators/index.js';
-/**
- * Returns the absolute value of a number. The argument may be a number or an object implementing the `abs()`.
- * @param x The value.
- * @returns The absolute value.
- */
-export function abs(x) {
-    const op = call(x, 'abs');
-    if (op != null)
-        return op;
-    return Math.abs(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]
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round Math.round()}
- */
-export function round(x, digits = 0) {
-    const base = 10 ** digits;
-    return Math.round(x * base) / base;
-}
-/**
- * Rounds down and returns the largest integer less than or equal to a given number.
- * @param x A number.
- * @returns Nearest integer less than or equal to number.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor Math.floor()}
- */
-export function floor(x) {
-    return Math.floor(x);
-}
-/**
- * Rounds up and returns the largest integer greater than or equal to a given number.
- * @param x A number.
- * @returns Nearest integer greater than or equal to number.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil Math.ceil()}
- */
-export function ceil(x) {
-    return Math.ceil(x);
-}
-/**
- * Returns a tuple like `[x / y, x % y]`.
- *
- * @param x
- * @param y
- * @returns
- */
-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;
-}
-export function min(iterable, key = id) {
-    return reduce(iterable, (x, y) => (lt(key(x), key(y)) ? x : y));
-}
-export function max(iterable, key = id) {
-    return reduce(iterable, (x, y) => (gt(key(x), key(y)) ? x : y));
-}
-export function mean(iterable, key = id) {
-    let total = 0;
-    let count = 0;
-    for (const value of iterable) {
-        total += key(value);
-        count++;
-    }
-    if (count !== 0)
-        return total / count;
-    return Number.NaN;
-}
-export function sum(args, key = id) {
-    let initial = 0;
-    for (const x of args) {
-        initial += key(x);
-    }
-    return initial;
-}

package/dist/mod.d.ts

@@ -1 +0,0 @@
-export * from './index.js';

package/dist/mod.js

@@ -1 +0,0 @@
-export * from './index.js';

package/dist/operators/index.d.ts

@@ -1,152 +0,0 @@
-/**
- * Generic operations for both values and objects.
- *
- * @module operators
- */
-/** @deprecated Use the `identity` function instead.
- * @see {@link identity}
- */
-export declare function id(x: any): any;
-/** This is the identity function. It always returns the same value that was passed in. */
-export declare const identity: <T>(x: T) => T;
-/**
- * Called to implement truth value testing.
- * @param x
- * @returns {boolean} `x.bool()` if exists or `!!x`.
- */
-export declare function bool(x: any): any;
-/**
- * Returns `true` if `x` is a falsy value.
- * @see {@link bool}
- */
-export declare function not(x: any): boolean;
-/**
- * Returns `true` if `x` is an instance of class `y`
- * @param x The instance object
- * @param y The parent class
- * @returns {boolean}
- */
-export declare function isinstance(x: any, y: any): boolean;
-/** Describes a function used to compare two values.
- *
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#parameters Array.sort()}
- */
-export declare type Comparer<T = any> = (x: T, y: T) => number;
-/**
- * Checks whether `x` is a comparable type and returns the result of `x.compare(y)`.
- * Otherwise the return value of the compare function is equivalent to `obj === other ? 0 : obj < other ? -1 : 1`
- * @param {*} x An initial value
- * @param {*} y Other value to compare
- * @returns {number} The comparison result
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#parameters Array.sort()}
- * @see {@link operators.eq}
- * @see {@link operators.lt}
- */
-export declare function compare(x: any, y: any): number;
-/**
- * Compares two values to check if they are the same. If `x` is an object with an `eq` method, it returns `x.eq(y)`.
- * Otherwise it returns the result of `x === y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` and `y` are equal or `false` otherwise.
- */
-export declare function eq(x: any, y: any): boolean;
-/**
- * Compares two values to check if `x` is strictly less than `y`. If `x` is an object with a `lt` method, it returns `x.lt(y)`.
- * Otherwise it returns the result of `x < y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` is strictly less than `y` or `false` otherwise.
- */
-export declare function lt(x: any, y: any): boolean;
-/**
- * Compares two values to check if `x <= y`. If `x` is an object with a `lte` method, it returns `x.lte(y)`, also checks `x.eq(y)` and `x.lt(y)`.
- * Otherwise it returns the result of `x <= y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` is less than or equal to `y` or `false` otherwise.
- * @see {@link eq}
- * @see {@link lt}
- */
-export declare function lte(x: any, y: any): boolean;
-/**
- * Compares two values to check if `x` is strictly greater than `y`. If `x` is an object with a `gt` method, it returns `x.gt(y)`.
- * Otherwise it returns the result of `x > y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` is strictly greater than `y` or `false` otherwise.
- */
-export declare function gt(x: any, y: any): boolean;
-/**
- * Compares two values to check if `x >= y`. If `x` is an object with a `gte` method, it returns `x.gte(y)`, also checks `x.eq(y)` and `x.gt(y)`.
- * Otherwise it returns the result of `x >= y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` is less greater than or equal to `y` or `false` otherwise.
- * @see {@link eq}
- * @see {@link gt}
- */
-export declare function gte(x: any, y: any): boolean;
-/**
- * The addition (+) operator. If `x` is an object with an `add` method, it returns `x.add(y)`.
- * Otherwise it returns the result of `x + y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x + y
- */
-export declare function add(x: any, y: any): any;
-/**
- * The subtraction (-) operator. If `x` is an object with a `sub` method, it returns `x.sub(y)`.
- * Otherwise it returns the result of `x - y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x - y
- */
-export declare function sub(x: any, y: any): any;
-/**
- * The multiplication (*) operator. If `x` is an object with an `mul` method, it returns `x.mul(y)`.
- * Otherwise it returns the result of `x * y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x * y
- */
-export declare function mul(x: any, y: any): any;
-/**
- * The division (/) operator. If `x` is an object with a `div` method, it returns `x.div(y)`.
- * Otherwise it returns the result of `x / y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x / y
- */
-export declare function div(x: any, y: any): any;
-/**
- * The modulo (%) operator. If `x` is an object with a `mod` method, it returns `x.mod(y)`.
- * Otherwise it returns the result of `x % y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x % y
- */
-export declare function mod(x: any, y: any): any;
-/**
- * The power (**) operator. If `x` is an object with a `pow` method, it returns `x.pow(y)`.
- * Otherwise it returns the result of `x ** y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x ** y
- */
-export declare function pow(x: any, y: any): any;
-/**
- * Performs a shallow comparison of two objects or arrays to check if they have the same keys, length and values.
- * @param obj
- * @param other
- * @returns `true` if the objects are considered equal.
- * @see {@link deepEqual}
- */
-export declare function shallowEqual(obj: any, other: any): boolean;
-/**
- * Performs a recursive comparison of two objects or arrays to check if they have the same keys, length and values. Unlike {@link shallowEqual} this method compares nested values also.
- * @param obj
- * @param other
- * @returns `true` if the objects are considered equal.
- */
-export declare function deepEqual(obj: any, other: any, checker?: Function, seen?: any): boolean;

package/dist/operators/index.js

@@ -1,305 +0,0 @@
-/**
- * Generic operations for both values and objects.
- *
- * @module operators
- */
-import { call, isObject } from '../globals/index.js';
-/** @deprecated Use the `identity` function instead.
- * @see {@link identity}
- */
-export function id(x) {
-    return x;
-}
-/** This is the identity function. It always returns the same value that was passed in. */
-export const identity = (x) => x;
-/**
- * Called to implement truth value testing.
- * @param x
- * @returns {boolean} `x.bool()` if exists or `!!x`.
- */
-export function bool(x) {
-    const r = call(x, 'bool');
-    if (r != null)
-        return r;
-    return !!x;
-}
-/**
- * Returns `true` if `x` is a falsy value.
- * @see {@link bool}
- */
-export function not(x) {
-    return !bool(x);
-}
-/**
- * Returns `true` if `x` is an instance of class `y`
- * @param x The instance object
- * @param y The parent class
- * @returns {boolean}
- */
-export function isinstance(x, y) {
-    return x instanceof y;
-}
-/**
- * Checks whether `x` is a comparable type and returns the result of `x.compare(y)`.
- * Otherwise the return value of the compare function is equivalent to `obj === other ? 0 : obj < other ? -1 : 1`
- * @param {*} x An initial value
- * @param {*} y Other value to compare
- * @returns {number} The comparison result
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#parameters Array.sort()}
- * @see {@link operators.eq}
- * @see {@link operators.lt}
- */
-export function compare(x, y) {
-    if (x === y || eq(x, y))
-        return 0;
-    const op = call(x, 'compare', y);
-    if (typeof op === 'number')
-        return op;
-    if (x < y || lt(x, y))
-        return -1;
-    return 1;
-}
-/**
- * Compares two values to check if they are the same. If `x` is an object with an `eq` method, it returns `x.eq(y)`.
- * Otherwise it returns the result of `x === y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` and `y` are equal or `false` otherwise.
- */
-export function eq(x, y) {
-    return Object.is(x, y) || call(x, 'eq', y) != null;
-}
-/**
- * Compares two values to check if `x` is strictly less than `y`. If `x` is an object with a `lt` method, it returns `x.lt(y)`.
- * Otherwise it returns the result of `x < y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` is strictly less than `y` or `false` otherwise.
- */
-export function lt(x, y) {
-    return x < y || call(x, 'lt', y) != null;
-}
-/**
- * Compares two values to check if `x <= y`. If `x` is an object with a `lte` method, it returns `x.lte(y)`, also checks `x.eq(y)` and `x.lt(y)`.
- * Otherwise it returns the result of `x <= y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` is less than or equal to `y` or `false` otherwise.
- * @see {@link eq}
- * @see {@link lt}
- */
-export function lte(x, y) {
-    if (x <= y || call(x, 'lte', y))
-        return true;
-    if (x === y || eq(x, y))
-        return true;
-    if (x < y || lt(x, y))
-        return true;
-    return false;
-}
-/**
- * Compares two values to check if `x` is strictly greater than `y`. If `x` is an object with a `gt` method, it returns `x.gt(y)`.
- * Otherwise it returns the result of `x > y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` is strictly greater than `y` or `false` otherwise.
- */
-export function gt(x, y) {
-    return x > y || call(x, 'gt', y);
-}
-/**
- * Compares two values to check if `x >= y`. If `x` is an object with a `gte` method, it returns `x.gte(y)`, also checks `x.eq(y)` and `x.gt(y)`.
- * Otherwise it returns the result of `x >= y`.
- * @param {*} x
- * @param {*} y
- * @returns {boolean} `true` if `x` is less greater than or equal to `y` or `false` otherwise.
- * @see {@link eq}
- * @see {@link gt}
- */
-export function gte(x, y) {
-    if (x <= y || call(x, 'gte', y))
-        return true;
-    if (x === y || eq(x, y))
-        return true;
-    if (x > y || gt(x, y))
-        return true;
-    return false;
-}
-/**
- * The addition (+) operator. If `x` is an object with an `add` method, it returns `x.add(y)`.
- * Otherwise it returns the result of `x + y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x + y
- */
-export function add(x, y) {
-    const op = call(x, 'add', y);
-    if (op != null)
-        return op;
-    return x + y;
-}
-/**
- * The subtraction (-) operator. If `x` is an object with a `sub` method, it returns `x.sub(y)`.
- * Otherwise it returns the result of `x - y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x - y
- */
-export function sub(x, y) {
-    const op = call(x, 'sub', y);
-    if (op != null)
-        return op;
-    return x - y;
-}
-/**
- * The multiplication (*) operator. If `x` is an object with an `mul` method, it returns `x.mul(y)`.
- * Otherwise it returns the result of `x * y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x * y
- */
-export function mul(x, y) {
-    const op = call(x, 'mul', y);
-    if (op != null)
-        return op;
-    return x * y;
-}
-/**
- * The division (/) operator. If `x` is an object with a `div` method, it returns `x.div(y)`.
- * Otherwise it returns the result of `x / y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x / y
- */
-export function div(x, y) {
-    const op = call(x, 'div', y);
-    if (op != null)
-        return op;
-    return x / y;
-}
-/**
- * The modulo (%) operator. If `x` is an object with a `mod` method, it returns `x.mod(y)`.
- * Otherwise it returns the result of `x % y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x % y
- */
-export function mod(x, y) {
-    const op = call(x, 'mod', y);
-    if (op != null)
-        return op;
-    return x % y;
-}
-/**
- * The power (**) operator. If `x` is an object with a `pow` method, it returns `x.pow(y)`.
- * Otherwise it returns the result of `x ** y`.
- * @param {*} x
- * @param {*} y
- * @returns {*} x ** y
- */
-export function pow(x, y) {
-    const op = call(x, 'pow', y);
-    if (op != null)
-        return op;
-    return x ** y;
-}
-/**
- * Performs a shallow comparison of two objects or arrays to check if they have the same keys, length and values.
- * @param obj
- * @param other
- * @returns `true` if the objects are considered equal.
- * @see {@link deepEqual}
- */
-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, seen = new WeakSet()) {
-    if (checker(obj, other))
-        return true;
-    if (!obj || !other)
-        return false;
-    if (obj.prototype !== other.prototype)
-        return false;
-    if (seen.has(obj) && seen.has(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;
-    }
-    if (obj instanceof Set) {
-        if (obj.size !== other.size)
-            return false;
-        for (const value of obj.values()) {
-            if (!other.has(value))
-                return false;
-        }
-        return true;
-    }
-    if (obj instanceof Map) {
-        // compare keys and values
-        if (obj.size !== other.size)
-            return false;
-        seen.add(obj);
-        seen.add(other);
-        for (const key of obj.keys()) {
-            if (!other.has(key))
-                return false;
-            if (!deepEqual(obj.get(key), other.get(key), checker, seen)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    if (isObject(obj)) {
-        // compare the object own enumerable keys
-        const objKeys = Object.keys(obj);
-        const otherKeys = Object.keys(other);
-        if (objKeys.length !== otherKeys.length)
-            return false;
-        seen.add(obj);
-        seen.add(other);
-        for (const key of objKeys) {
-            if (!Object.prototype.hasOwnProperty.call(other, key) ||
-                !deepEqual(obj[key], other[key], checker, seen)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    return false;
-}

package/dist/types.d.ts

@@ -1,19 +0,0 @@
-/**
- * A generic function type with arbitrary arguments and return.
- */
-export declare type Function<TReturn = any> = (...args: any) => TReturn;
-/**
- * An iteratee function used for collection methods.
- * @see {@link collections.filter}
- * @see {@link collections.find}
- * @see {@link collections.forEach}
- * @see {@link collections.index}
- * @see {@link collections.map}
- * @see {@link collections.pick}
- * @see {@link collections.omit}
- * @see {@link collections.uniq}
- * @see {@link collections.sortedUniq}
- * @see {@link collections.groupBy}
- */
-export declare type Iteratee<T = any, K = any, TResult = any> = (value: T, key?: K, arr?: any) => TResult;
-export declare type Predicate<T = any, TReturn = any> = (value: T) => TReturn;

package/dist/types.js

@@ -1 +0,0 @@
-export {};