atomic-fns 0.4.2 → 0.4.3

package/dist/functools/index.d.ts

@@ -47,7 +47,7 @@ export declare const compose: (...args: any[]) => (x: any) => any;
  * @param {Function} [resolver] The function to resolve the cache key.
  * @return {Function} Returns the new memoized function.
  */
-export declare function memoize<T>(func: Function<T>, resolver?: Function): Function<ReturnType<typeof func>>;
+export declare function memoize<T>(func: Function<T>, resolver?: Function): Function<T>;
 /**
  * Can be used as a decorator on any function or method to memoize its results.
  * **NOTE:** By default the given function is memoized using it's first argument, regardless of others.
@@ -92,7 +92,7 @@ single(3) // 1
 // `func` is invoked only once.
 ```
  */
-export declare function once<T>(func: Function<T>): (...args: any[]) => T;
+export declare function once<T>(func: Function<T>): Function<T>;
 export declare type Maybe<T> = T | undefined;
 export declare type Result<T, E = any> = [Maybe<T>, Maybe<E>];
 export declare type Optional<T> = Maybe<T>;
@@ -111,7 +111,7 @@ export declare function result<T = any, E = unknown>(fun: Function<T>, onFinally
  * @param {Function} [onFinally] Optional callback that will be invoked with `(err?, value)` on the `finally` clause.
  * @returns {Function<Promise<Result<T, E>>>} A new function that awaits the `awaitable` param and returns a {@link Result} type.
  */
-export declare function resultAsync<T = any, E = unknown>(awaitable: Promise<T> | Function<Promise<T>>, onFinally?: (err: E, res: T) => any): (...args: any[]) => Promise<Result<T, E>>;
+export declare function resultAsync<T = any, E = unknown>(awaitable: Promise<T> | Function<Promise<T>>, onFinally?: (err: E, res: T) => any): (...args: any[]) => Promise<any[]>;
 /**
  * Converts a function that expects a node-style callback argument like `(err, result)` to return a Promise instead.
  * @template T
@@ -119,4 +119,4 @@ export declare function resultAsync<T = any, E = unknown>(awaitable: Promise<T>
  * @param {*} thisArg
  * @returns {Function<Promise<T>>} A function that wraps `fun` and returns a Promise.
  */
-export declare function promisify<T = any>(fun: Function<T>, thisArg: any): (...args: any[]) => Promise<T>;
+export declare function promisify<T>(fun: Function, thisArg?: any): Function<Promise<T>>;

package/dist/functools/index.js

@@ -230,7 +230,7 @@ export function resultAsync(awaitable, onFinally) {
  * @returns {Function<Promise<T>>} A function that wraps `fun` and returns a Promise.
  */
 export function promisify(fun, thisArg) {
-    const original = fun.bind(thisArg);
+    const original = thisArg ? fun.bind(thisArg) : fun;
     return async (...args) => {
         return await new Promise((resolve, reject) => original(...args, (err, result) => {
             if (err)

package/dist/globals/decimal.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Casts the given value as a {@link Decimal}.
+ */
+export declare function decimal(x: any): Decimal;
+/**
+ * `Decimal` provides support for correct rounded floating point arithmetic, unlike the standard Number type. It also supports user-defined precision (default is 20 decimal places) which can be as large as needed.
+ */
+export declare class Decimal {
+    static PRECISION: number;
+    i: bigint;
+    e: number;
+    /**
+     * Returns a new `Decimal` instance from the value or `0`.
+     * @param {*} value
+     * @returns {Decimal}
+     */
+    constructor(value?: any);
+    /**
+     * Returns a new `Decimal` that has the opposite sign of this `Decimal`.
+     * @example
+  ```js
+  let a = decimal('5')
+  a.minus()  // -5
+  ```
+     * @returns {Decimal}
+     */
+    negated(): Decimal;
+    /**
+     * Returns a new `Decimal` that is the sum of this and `x`.
+     * @param x
+     * @example
+  ```js
+  let a = decimal('50000000000')
+  let b = decimal('0.000000005')
+  a.add(b)  // 50000000000.000000005
+  ```
+     * @returns {Decimal}
+     */
+    add(x: any): Decimal;
+    /**
+     * Returns a new `Decimal` that is the difference between this and `x`.
+     * @param x
+     * @example
+  ```js
+  let a = decimal('1')
+  let b = decimal('0.0000000000000000001')
+  a.sub(b)  // 0.9999999999999999999
+  ```
+     * @returns {Decimal}
+     */
+    sub(x: any): Decimal;
+    /**
+     * Returns a new `Decimal` that is the product of this and `x`.
+     * @param x
+     * @example
+  ```js
+  let a = decimal('0.0000000000000000000025')
+  let b = decimal('400000000000000000000')
+  a.mul(b)  // 1
+  ```
+     * @returns {Decimal}
+     */
+    mul(x: any): Decimal;
+    /**
+     * Returns a new `Decimal` that is the quotient of this and `x`
+     * @param x
+     * @example
+  ```js
+  let a = decimal('1')
+  let b = decimal('3')
+  a.div(b)  // 0.333333333333333333333333333333
+  ```
+     * @returns {Decimal}
+     */
+    div(x: any): Decimal;
+    /**
+     * Returns the square root of this `Decimal`.
+     * @returns {TDecimal}
+     */
+    sqrt(): Decimal;
+    /** Returns a new copy of this Decimal value. */
+    clone(): Decimal;
+    /**
+     * Remove zeroes in the least-significant digit of this `Decimal`
+     */
+    _normalize(): this;
+    /**
+     * Truncate this `Decimal` to the configured precision
+     */
+    _truncate(): this;
+    /**
+     * Returns a string representation of this decimal.
+     * @returns {Decimal}
+     */
+    toString(): string;
+    /**
+     * Converts this decimal to the `Number` value
+     * @returns {number}
+     */
+    toNumber(): number;
+    static get precision(): number;
+    static set precision(value: number);
+    /**
+     * Returns `true` if this value is equal to the value of `x`, otherwise `false`.
+     * @param {*} x other
+     * @returns {boolean}
+     */
+    eq(x: any): boolean;
+    /**
+     * Returns `true` if this value is less than the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    lt(x: any): boolean;
+    /**
+     * Returns a comparison value representing the ordering of this value in respect to `x`.
+     *   * `-1` if this < x
+     *   * `1` if this > x
+     *   * `0` if this == x
+     * @param {*} x
+     * @returns {number}
+     */
+    compare(x: any): 1 | -1 | 0;
+    /**
+     * Returns `true` if this value is greater than the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    gt(x: any): boolean;
+    /**
+     * Returns `true` if this value is less than or equal to the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    lte(x: any): boolean;
+    /**
+     * Returns `true` if this value is greater than or equal to the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    gte(x: any): boolean;
+}

package/dist/globals/decimal.js

@@ -0,0 +1,371 @@
+const NUMBER_REGEX = /^(-?)([0-9]+)(\.([0-9]+))?$/;
+/**
+ * Casts the given value as a {@link Decimal}.
+ */
+export function decimal(x) {
+    return new Decimal(x);
+}
+/**
+ * `Decimal` provides support for correct rounded floating point arithmetic, unlike the standard Number type. It also supports user-defined precision (default is 20 decimal places) which can be as large as needed.
+ */
+export class Decimal {
+    static PRECISION = 20;
+    i = 0n;
+    e = 0;
+    /**
+     * Returns a new `Decimal` instance from the value or `0`.
+     * @param {*} value
+     * @returns {Decimal}
+     */
+    constructor(value) {
+        if (value == null) {
+            return this;
+        }
+        // Check if value is a Decimal like
+        if (typeof value?.i === 'bigint' && typeof value.e === 'number') {
+            this.i = value.i;
+            this.e = value.e;
+            this._normalize();
+            return this;
+        }
+        const result = NUMBER_REGEX.exec(value.toString());
+        if (result) {
+            // console.log(result);
+            // Construct from string if possible
+            // this.i = parseInt(result[1] + result[2] + result[4]);
+            if (typeof result[2] === 'undefined')
+                result[2] = '';
+            if (typeof result[4] === 'undefined')
+                result[4] = '';
+            this.i = BigInt(result[1] + result[2] + result[4]);
+            this.e = result[4] ? -result[4].length : 0;
+            this._normalize();
+        }
+        else {
+            // Conversion to string failed, so construct from number
+            let m = 1n;
+            if (value < 0) {
+                value = -value;
+                m = -1n;
+            }
+            if (value === 0) {
+                this.i = 0n;
+                this.e = 0;
+            }
+            else {
+                // Multiply the number by 10 until it is an integer
+                let e = -Math.floor(Math.log10(value));
+                if (e > 0) {
+                    value *= Math.pow(10, e);
+                }
+                else {
+                    e = 0;
+                }
+                while (value !== Math.round(value)) {
+                    e++;
+                    value *= 10;
+                }
+                // Divide the number by 10 until the one's digit is non-zero
+                while (value % 10 === 0 && value > 0) {
+                    e--;
+                    value /= 10;
+                }
+                value = BigInt(value);
+                this.i = value * m;
+                this.e = -e;
+            }
+        }
+    }
+    /**
+     * Returns a new `Decimal` that has the opposite sign of this `Decimal`.
+     * @example
+  ```js
+  let a = decimal('5')
+  a.minus()  // -5
+  ```
+     * @returns {Decimal}
+     */
+    negated() {
+        const negated = new Decimal();
+        negated.i = -this.i;
+        negated.e = this.e;
+        return negated;
+    }
+    /**
+     * Returns a new `Decimal` that is the sum of this and `x`.
+     * @param x
+     * @example
+  ```js
+  let a = decimal('50000000000')
+  let b = decimal('0.000000005')
+  a.add(b)  // 50000000000.000000005
+  ```
+     * @returns {Decimal}
+     */
+    add(x) {
+        let a = new Decimal(this);
+        let b = new Decimal(x);
+        // a+b = a.i * 10^a.e + b.i * 10^b.e
+        // a+b = ( a.i * 10^(a.e-b.e) + b.i ) * 10^b.e
+        const result = new Decimal();
+        // Order arguments so that a.e >= b.e
+        if (a.e < b.e) {
+            const c = a;
+            a = b;
+            b = c;
+        }
+        const intPart = exp(a.i, a.e - b.e);
+        result.i = intPart + b.i;
+        result.e = b.e;
+        result._normalize();
+        return result;
+    }
+    /**
+     * Returns a new `Decimal` that is the difference between this and `x`.
+     * @param x
+     * @example
+  ```js
+  let a = decimal('1')
+  let b = decimal('0.0000000000000000001')
+  a.sub(b)  // 0.9999999999999999999
+  ```
+     * @returns {Decimal}
+     */
+    sub(x) {
+        return this.add(decimal(x).negated());
+    }
+    /**
+     * Returns a new `Decimal` that is the product of this and `x`.
+     * @param x
+     * @example
+  ```js
+  let a = decimal('0.0000000000000000000025')
+  let b = decimal('400000000000000000000')
+  a.mul(b)  // 1
+  ```
+     * @returns {Decimal}
+     */
+    mul(x) {
+        const a = new Decimal(this);
+        const b = new Decimal(x);
+        // a * b = (a.i * b.i) * 10^(a.e + b.e)
+        const result = new Decimal();
+        result.i = a.i * b.i;
+        result.e = a.e + b.e;
+        result._normalize();
+        return result;
+    }
+    /**
+     * Returns a new `Decimal` that is the quotient of this and `x`
+     * @param x
+     * @example
+  ```js
+  let a = decimal('1')
+  let b = decimal('3')
+  a.div(b)  // 0.333333333333333333333333333333
+  ```
+     * @returns {Decimal}
+     */
+    div(x) {
+        const a = new Decimal(this);
+        const b = new Decimal(x);
+        // We need to increase the number of digits of a and b so that a / b will have the desired precision.
+        // In order for the integer quotient to have the correct precision, a.e - b.e must be greater than that precision.
+        // So we need only to increase a.e.
+        // TODO: Revisit the value of increaseA. Is it correct in every circumstance?
+        const increaseA = Math.max(Decimal.precision - (a.e + b.e), 0);
+        const intIncrease = new Decimal();
+        intIncrease.i = exp(a.i, increaseA);
+        const quotient = new Decimal();
+        quotient.i = intIncrease.i / b.i;
+        quotient.e = a.e - b.e - increaseA;
+        // No need to truncate since we already increased the number of digits before dividing
+        quotient._normalize();
+        return quotient;
+    }
+    /**
+     * Returns the square root of this `Decimal`.
+     * @returns {TDecimal}
+     */
+    sqrt() {
+        Decimal.PRECISION++;
+        // Let the guess value be 10^(e/2), where e is this.e
+        let x = new Decimal();
+        x.i = 1n;
+        x.e = Math.floor(this.e / 2);
+        const onehalf = new Decimal('0.5');
+        let xt = x.clone();
+        xt._truncate();
+        xt._normalize();
+        let lastxt;
+        let i;
+        for (i = 0; i < 100; i++) {
+            lastxt = xt;
+            x = this.div(x).add(x).mul(onehalf);
+            xt = x.clone();
+            xt._truncate();
+            xt._normalize();
+            if (xt.i === lastxt.i && xt.e === lastxt.e)
+                break;
+        }
+        if (i >= 100) {
+            console.log('Warning: sqrt exceeded maximum iterations. (Did it enter a cycle?)');
+        }
+        Decimal.PRECISION--;
+        xt._truncate();
+        xt._normalize();
+        return xt;
+    }
+    /** Returns a new copy of this Decimal value. */
+    clone() {
+        const a = new Decimal();
+        a.i = this.i;
+        a.e = this.e;
+        return a;
+    }
+    /**
+     * Remove zeroes in the least-significant digit of this `Decimal`
+     */
+    _normalize() {
+        while (this.i % 10n === 0n && this.i !== 0n) {
+            this.i /= 10n;
+            this.e++;
+        }
+        return this;
+    }
+    /**
+     * Truncate this `Decimal` to the configured precision
+     */
+    _truncate() {
+        // TODO: Make this better
+        // TODO: Rounding
+        const trunc = -this.e - Decimal.PRECISION;
+        if (trunc > 0) {
+            this.i /= 10n ** BigInt(trunc - 1);
+            this.e += trunc;
+            const nextDigit = this.i % 10n;
+            if (nextDigit >= 5) {
+                this.i += 10n;
+            }
+            this.i /= 10n;
+        }
+        // while(-this.e > Decimal.PRECISION) {
+        //   this.i /= 10n;
+        //   this.e++;
+        // }
+        return this;
+    }
+    /**
+     * Returns a string representation of this decimal.
+     * @returns {Decimal}
+     */
+    toString() {
+        let s = this.i.toString();
+        let m = '';
+        if (s[0] === '-') {
+            s = s.substring(1, s.length);
+            m = '-';
+        }
+        if (this.e > 0) {
+            return m + s + '0'.repeat(this.e);
+        }
+        else if (this.e < 0) {
+            if (-this.e >= s.length) {
+                return m + '0.' + '0'.repeat(-this.e - s.length) + s;
+            }
+            return m + s.slice(0, s.length + this.e) + '.' + s.slice(s.length + this.e, s.length);
+        }
+        else {
+            return m + s;
+        }
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return this.toString();
+    }
+    /**
+     * Converts this decimal to the `Number` value
+     * @returns {number}
+     */
+    toNumber() {
+        return Number(Decimal.prototype.toString.call(this));
+    }
+    static get precision() {
+        return Decimal.PRECISION;
+    }
+    static set precision(value) {
+        Decimal.PRECISION = value;
+    }
+    /**
+     * Returns `true` if this value is equal to the value of `x`, otherwise `false`.
+     * @param {*} x other
+     * @returns {boolean}
+     */
+    eq(x) {
+        const other = decimal(x);
+        return this.i === other.i && this.e === other.e;
+    }
+    /**
+     * Returns `true` if this value is less than the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    lt(x) {
+        const other = decimal(x);
+        if (this.e === other.e)
+            return this.i < other.i;
+        const e = this.e - other.e;
+        if (e > 0) {
+            return exp(this.i, e) < other.i;
+        }
+        return this.i < exp(other.i, -e);
+    }
+    /**
+     * Returns a comparison value representing the ordering of this value in respect to `x`.
+     *   * `-1` if this < x
+     *   * `1` if this > x
+     *   * `0` if this == x
+     * @param {*} x
+     * @returns {number}
+     */
+    compare(x) {
+        if (this.eq(x))
+            return 0;
+        if (this.lt(x))
+            return -1;
+        return 1;
+    }
+    /**
+     * Returns `true` if this value is greater than the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    gt(x) {
+        return this.compare(x) > 0;
+    }
+    /**
+     * Returns `true` if this value is less than or equal to the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    lte(x) {
+        return this.compare(x) <= 0;
+    }
+    /**
+     * Returns `true` if this value is greater than or equal to the value of `x`, otherwise `false`.
+     * @param {*} x
+     * @returns {boolean}
+     */
+    gte(x) {
+        return this.compare(x) >= 0;
+    }
+}
+/** Returns a BigInt that is equal to `i` times `10^e` */
+function exp(i, e) {
+    // TODO: Make this better
+    // The implementation is faster than 10n ** BigInt(e). But could we make it faster still?
+    let ii = i;
+    for (let j = 0; j < e; j++) {
+        ii *= 10n;
+    }
+    return ii;
+}

package/dist/globals/index.d.ts

@@ -3,12 +3,13 @@
  *
  * @module Globals
  */
+export * from './decimal.js';
 /** This is just a noop function. */
 export declare const noop: () => void;
 /**
  * A generic function type with arbitrary arguments and return.
  */
-export declare type Function<T = any> = (...args: any) => T;
+export declare type Function<TReturn = any> = (...args: any) => TReturn;
 /**
  * An iteratee function used for collection methods.
  * @see {@link Collections.filter}
@@ -22,8 +23,8 @@ export declare type Function<T = any> = (...args: any) => T;
  * @see {@link Collections.sortedUniq}
  * @see {@link Collections.groupBy}
  */
-export declare type Iteratee<T = any, K = any> = (value: T, key?: K, arr?: any) => any;
-export declare type Predicate<T = any> = (value: T) => any;
+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;
 /** A function that always returns `true`. */
 export declare const True: () => boolean;
 /** A function that always returns `false`. */
@@ -79,12 +80,12 @@ export declare class ValueError extends CustomError {
 export declare class ZeroDivisionError extends CustomError {
 }
 /**
- * Returns the true type of any value with correct detection for null, Array,
- * Object, Promise, Symbol, and NaN. The correct values are inferred from {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag | Symbol.toStringTag} and the value's prototype.
+ * Returns the true type of any value with correct detection for `null`, `Array`,
+ * `Object`, `Promise`, `Symbol`, and `NaN`. The correct values are inferred from {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag | Symbol.toStringTag} and the value's prototype.
  * @param value
  * @returns The value type.
  */
-export declare function type(value: any): any;
+export declare function type(value: any): string;
 /**
  * Returns a string representing the object.
  * @param obj
@@ -153,7 +154,7 @@ export declare const isWeakMap: <K extends object, V>(x: any) => x is WeakMap<K,
  * @param value
  * @returns The number of elements in the collection or `undefined`.
  */
-export declare function len(value: any): any;
+export declare function len(value: any): number;
 /**
  * Generates a unique ID using random numbers. If a prefix is given, the ID is appended to it and returned as a string.
  * @param {string} [pre=''] The id prefix.
@@ -167,7 +168,7 @@ uniqueId('user_')
 // 'user_1033763188'
 ```
  */
-export declare const uniqueId: (pre?: string) => any;
+export declare const uniqueId: (pre?: string) => string;
 /**
  * Generates a monotonically increasing, pseudo-random based uuid-v4 string. These are sortable, url-friendly and are 100% unique if the IDs are generated more than 1 millisecond apart. If two IDs are generated at the same millisecond, the chance of collision is still pretty low (1 in 10^15).
  * @returns Returns a GUID formatted string.
@@ -218,14 +219,15 @@ export declare const has: (obj: any, attr: PropertyKey) => boolean;
  * @param {*} [value=undefined]
  * @return The property value or default value.
  */
-export declare function get(key: PropertyKey | PropertyKey[], obj: any, value?: any): any;
+export declare function get<T>(key: PropertyKey, obj: T, value?: any): any;
+export declare function get<T>(key: PropertyKey[], obj: T, value?: any): any;
 /**
  * Deletes a given property key from an object.
  * @param attr The property name.
  * @param x The given object.
  * @returns The modified object.
  */
-export declare function del(attr: PropertyKey, x: any): any;
+export declare function del<T>(attr: PropertyKey, x: T): T;
 /**
  * Adds a property to an object, or modifies the existing value.
  * @param attr The name or Symbol of the property to be defined or modified.
@@ -242,7 +244,8 @@ export declare const HASH_KEY: unique symbol;
  * @param obj The given object.
  * @returns The hash value.
  */
-export declare function hash(obj: any): any;
+export declare function hash(obj: string): number;
+export declare function hash<T>(obj: T): T;
 /**
  * A hash value generator for strings.
  * @param {string} str The given string.
@@ -274,24 +277,25 @@ export declare const oct: (n: number) => string;
  * @returns A floating point number parsed from the given value or `NaN`.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseFloat parseFloat}
  */
-export declare const float: (x: any) => number;
+export declare const float: (x: string) => number;
 /**
  * Returns an integer number constructed from a number or string `x`.
  * @param x The number or string.
  * @returns An integer number parsed from the given value or `NaN`.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt parseInt}
  */
-export declare const int: (x: any, base?: number) => number;
+export declare const int: (x: string, base?: number) => number;
 /**
  * Converts the value to an array using `Array.from()`.
  * @param value
  * @returns A new array value.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from Array.from()}
  */
-export declare const list: (value?: any) => unknown[];
+export declare const list: <T>(value?: any) => T[];
 /**
  * Retrieve the next item from the iterator by calling its `next()` method.
  * @param iter The iterator.
  * @returns The next value from the iterator.
  */
-export declare const next: (iter: Iterator<any> | Generator) => any;
+export declare function next<T>(iter: Iterator<T>): T | undefined;
+export declare function next<T>(iter: Generator<any, T>): T | undefined;