atomic-fns 1.2.0 → 2.0.0

package/dist/operators/index.d.ts

@@ -1,148 +0,0 @@
-/**
- * Generic operations for both values and objects.
- *
- * @module operators
- */
-/** 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 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,325 +0,0 @@
-/**
- * Generic operations for both values and objects.
- *
- * @module operators
- */
-import { call, isObject } from '../globals/index.js';
-/** 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 instanceof Date && y instanceof Date)
-        return Math.sign(x.getTime() - y.getTime()) || 0;
-    if (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 x === y || Object.is(x, y) || !!call(x, 'eq', y);
-}
-/**
- * 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) {
-    const op = call(x, 'lt', y);
-    return op != null ? !!op : x < y;
-}
-/**
- * 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) {
-    const op = call(x, 'lte', y);
-    if (op != null)
-        return !!op;
-    const less = call(x, 'lt', y);
-    if (less != null)
-        return !!less || eq(x, y) || (call(y, 'lt', x) === false && x <= y);
-    return x <= y || eq(x, y);
-}
-/**
- * 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) {
-    const op = call(x, 'gt', y);
-    return op != null ? !!op : x > 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) {
-    const op = call(x, 'gte', y);
-    if (op != null)
-        return !!op;
-    const greater = call(x, 'gt', y);
-    if (greater != null)
-        return !!greater || eq(x, y) || (call(y, 'gt', x) === false && x >= y);
-    return x >= y || eq(x, y);
-}
-/**
- * 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;
-}
-/** Class names tell kinds apart across realms, where prototypes differ. */
-function sameKind(x, y) {
-    if (!x || !y || typeof x !== 'object' || typeof y !== 'object')
-        return false;
-    const tag = Object.prototype.toString;
-    if (tag.call(x) !== tag.call(y))
-        return false;
-    return (x.constructor?.name ?? 'Object') === (y.constructor?.name ?? 'Object');
-}
-function isList(x) {
-    return Array.isArray(x) || (ArrayBuffer.isView(x) && !(x instanceof DataView));
-}
-function isDateOrRegExp(x) {
-    return x instanceof Date || x instanceof RegExp;
-}
-function sameDateOrRegExp(x, y) {
-    if (x instanceof Date)
-        return Object.is(x.getTime(), y.getTime());
-    return String(x) === String(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 (!sameKind(obj, other))
-        return false;
-    if (isDateOrRegExp(obj))
-        return sameDateOrRegExp(obj, other);
-    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.hasOwn(other, key) || obj[key] !== other[key]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    return false;
-}
-export function deepEqual(obj, other, checker = eq, seen = new WeakMap()) {
-    if (!(seen instanceof WeakMap))
-        seen = new WeakMap();
-    if (checker(obj, other))
-        return true;
-    if (!sameKind(obj, other))
-        return false;
-    if (isDateOrRegExp(obj))
-        return sameDateOrRegExp(obj, other);
-    // A pair that was compared before needs no second walk: it either held, or the call has returned.
-    const partners = seen.get(obj) ?? new WeakSet();
-    if (partners.has(other))
-        return true;
-    seen.set(obj, partners.add(other));
-    if (isList(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, seen)) {
-                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;
-        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;
-        for (const key of objKeys) {
-            if (!Object.hasOwn(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 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 type Iteratee<T = any, K = any, TResult = any> = (value: T, key?: K, arr?: any) => TResult;
-export type Predicate<T = any, TReturn = any> = (value: T) => TReturn;

package/dist/types.js

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