atomic-fns 1.1.2 → 1.1.3

package/dist/globals/index.js

@@ -4,7 +4,7 @@
  * @module globals
  */
 /** This is just a noop function. */
-export const noop = () => { };
+export function noop() { }
 /** A function that always returns `true`. */
 export const True = () => true;
 /** A function that always returns `false`. */
@@ -121,69 +121,115 @@ export function type(value) {
  * @returns `obj.toString()` or `''` if `obj` is `null` or `undefined`.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString | Object.toString }
  */
-export const str = (obj) => (obj != null ? obj.toString() : '');
+export function str(obj) {
+    return obj?.toString() ?? '';
+}
 /** Check if value is a boolean type. */
-export const isBool = (x) => type(x) === 'boolean';
+export function isBool(x) {
+    return type(x) === 'boolean';
+}
 /** Check if value is an `Error` type. */
-export const isError = (x) => x instanceof Error;
+export function isError(x) {
+    return x instanceof Error;
+}
 /** Check if value is an iterable type. */
-export const isIterable = (x) => {
+export function isIterable(x) {
     if (x == null)
         return false;
     return typeof x[Symbol.iterator] === 'function';
-};
+}
 /** Check if value is a native `Date` type. */
-export const isDate = (x) => x instanceof Date;
+export function isDate(x) {
+    return x instanceof Date;
+}
 /** Check if value is an object type. */
-export const isObject = (x) => type(x) === 'object';
+export function isObject(x) {
+    return type(x) === 'object';
+}
 /** Check if value is a string type. */
-export const isString = (x) => type(x) === 'string';
+export function isString(x) {
+    return type(x) === 'string';
+}
 /** Check if value is an Array type. */
-export const isArray = (x) => Array.isArray(x);
+export function isArray(x) {
+    return Array.isArray(x);
+}
 /**
  * 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) => {
+export function isArrayLike(x) {
     const T = type(x);
     return T === 'array' || (T === 'object' && isNumber(x.length));
-};
+}
 /** Check if value is a number type. */
-export const isNumber = (x) => type(x) === 'number';
+export function isNumber(x) {
+    return type(x) === 'number';
+}
 /** Check if value is an integer number type. */
-export const isInteger = (x) => type(x) === 'number' && Math.trunc(x) === x;
+export function isInteger(x) {
+    return type(x) === 'number' && Math.trunc(x) === x;
+}
 /** Check if value is a bigint type. */
-export const isBigint = (x) => type(x) === 'bigint';
+export function isBigint(x) {
+    return type(x) === 'bigint';
+}
 /** Check if value is a Promise type. */
-export const isPromise = (x) => type(x) === 'Promise';
+export function isPromise(x) {
+    return type(x) === 'Promise';
+}
 /** Check if value is a function type. */
-export const isFunction = (x) => x?.constructor === Function;
+export function isFunction(x) {
+    return x?.constructor === Function;
+}
 /** Check if value is an async function type. */
-export const isAsyncFunction = (x) => x?.constructor.name === 'AsyncFunction';
+export function isAsyncFunction(x) {
+    return x?.constructor.name === 'AsyncFunction';
+}
 /** Check if value is a generator function type. */
-export const isGenerator = (x) => {
+export function isGenerator(x) {
     return x?.constructor.constructor?.name === 'GeneratorFunction';
-};
+}
 /** Check if value is `null` or `undefined`. */
-export const isNull = (x) => x == null;
+export function isNull(x) {
+    return x == null;
+}
 /** Check if value === `undefined`. */
-export const isUndefined = (x) => x === undefined;
+export function isUndefined(x) {
+    return x === undefined;
+}
 /** Check if value is not `null` or `undefined`. */
-export const notNull = (x) => x != null;
+export function notNull(x) {
+    return x != null;
+}
 /** Returns `true` for objects without length or falsy values. */
-export const isEmpty = (x) => (len(x) === 0 ? true : !x);
+export function isEmpty(x) {
+    return len(x) === 0 ? true : !x;
+}
 /** Check if value is a `RegExp` type */
-export const isRegExp = (x) => x instanceof RegExp;
+export function isRegExp(x) {
+    return x instanceof RegExp;
+}
 /** Check if value is a `Symbol` type */
-export const isSymbol = (x) => type(x) === 'symbol';
+export function isSymbol(x) {
+    return type(x) === 'symbol';
+}
 /** Check if value is a `Set` type. */
-export const isSet = (x) => x instanceof Set;
+export function isSet(x) {
+    return x instanceof Set;
+}
 /** Check if value is a `Map` type. */
-export const isMap = (x) => x instanceof Map;
+export function isMap(x) {
+    return x instanceof Map;
+}
 /** Check if value is a `WeakSet` type. */
-export const isWeakSet = (x) => x instanceof WeakSet;
+export function isWeakSet(x) {
+    return x instanceof WeakSet;
+}
 /** Check if value is a `WeakMap` type. */
-export const isWeakMap = (x) => x instanceof WeakMap;
+export function isWeakMap(x) {
+    return x instanceof WeakMap;
+}
 /**
  * Returns the number of elements in a collection type.
  *
@@ -221,9 +267,10 @@ uniqueId('user_')
 // 'user_1033763188'
 ```
  */
-export const uniqueId = (pre = '') => 
-// @ts-expect-error
-(pre || 0) + ((Math.random() * 1e10) >>> 0);
+export function uniqueId(pre = '') {
+    // @ts-expect-error
+    return (pre || 0) + ((Math.random() * 1e10) >>> 0);
+}
 /**
  * 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.
@@ -233,10 +280,10 @@ uuid()
 // '183f8ef3-b8f0-4000-81f5-89234c836d00'
 ```
  */
-export const uuid = () => {
+export function uuid() {
     const u = Date.now().toString(16) + Math.random().toString(16) + '0'.repeat(16);
     return [u.substr(0, 8), u.substr(8, 4), '4000-8' + u.substr(13, 3), u.substr(16, 12)].join('-');
-};
+}
 /**
  * Checks if `obj.key` is a function, and calls it with any given `args`.
  * @param {*} obj
@@ -250,30 +297,40 @@ export function call(obj, key, ...args) {
     }
 }
 /** Convert number to unicode character */
-export const chr = (x) => String.fromCodePoint(x);
+export function chr(x) {
+    return String.fromCodePoint(x);
+}
 /** Convert character to Unicode code point */
-export const ord = (x) => x.charCodeAt(0);
+export function ord(x) {
+    return x.charCodeAt(0);
+}
 /**
  * Returns an array of the own enumerable property names of `object`.
  * @param object The given object.
  * @returns The array of object keys.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys Object.keys()}
  */
-export const keys = (object) => Object.keys(object);
+export function keys(object) {
+    return Object.keys(object);
+}
 /**
  * Returns an array of the own enumerable property values of `object`.
  * @param object The given object.
  * @returns The array of object keys.
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values Object.values()}
  */
-export const values = (object) => Object.values(object);
+export function values(object) {
+    return Object.values(object);
+}
 /**
  * Check if a given property is present in a given object.
  * @param obj The object to check.
  * @param attr A property key name.
  * @returns `true` if the object has the property name.
  */
-export const has = (obj, attr) => obj && attr in obj;
+export function has(obj, attr) {
+    return obj && attr in obj;
+}
 export function get(key, obj, value) {
     if (obj == null)
         return value;
@@ -353,40 +410,54 @@ export function hashCode(str) {
  * @param n The given number.
  * @returns The binary string representation of `n`.
  */
-export const bin = (n) => n.toString(2);
+export function bin(n) {
+    return n.toString(2);
+}
 /**
  * Converts a number to a hexadecimal string.
  * @param n The given number.
  * @returns The hexadecimal string representation of `n`.
  */
-export const hex = (n) => n.toString(16);
+export function hex(n) {
+    return n.toString(16);
+}
 /**
  * Converts a number to an octal string.
  * @param n The given number.
  * @returns The octal string representation of `n`.
  */
-export const oct = (n) => n.toString(8);
+export function oct(n) {
+    return n.toString(8);
+}
 /**
  * Returns a floating point number constructed from a number or string `x`.
  * @param x The number or 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 const float = (x) => parseFloat(x);
+export function float(x) {
+    return parseFloat(x);
+}
 /**
  * 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 const int = (x, base = 10) => parseInt(x, base);
+export function int(x, base = 10) {
+    return parseInt(x, base);
+}
 /**
  * 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 const list = (value) => (value ? Array.from(value) : []);
+export function list(value) {
+    if (value != null)
+        return Array.from(value);
+    return [];
+}
 export function next(iter) {
     return iter.next().value;
 }

package/dist/itertools/index.d.ts

@@ -31,7 +31,7 @@ all([2, 4, 6] => (n) => n > 1)
 ```
 @see {@link any}
  */
-export declare const all: <T>(iterable: Iterable<T>, fn?: Predicate<T, any>) => boolean;
+export declare function all<T>(iterable: Iterable<T>, fn?: Predicate<T>): boolean;
 /**
  * Returns true when any of the items in iterable are truthy. An optional predicate function can be used to define what truthiness means for this specific collection.
  * @param iterable
@@ -50,7 +50,7 @@ any([1, 4, 5] => (n) => n % 2 === 0)
 ```
 @see {@link all}
  */
-export declare const any: <T>(iterable: Iterable<T>, fn?: Predicate<T, any>) => boolean;
+export declare function any<T>(iterable: Iterable<T>, fn?: Predicate<T>): boolean;
 export declare function chain<T>(...iterables: Array<Iterable<T>>): Generator<T, void, unknown>;
 /**
  * Checks if the `value` is in `collection`.

package/dist/itertools/index.js

@@ -44,13 +44,13 @@ all([2, 4, 6] => (n) => n > 1)
 ```
 @see {@link any}
  */
-export const all = (iterable, fn = bool) => {
+export function all(iterable, fn = bool) {
     for (const item of iterable) {
         if (!fn(item))
             return false;
     }
     return true;
-};
+}
 /**
  * Returns true when any of the items in iterable are truthy. An optional predicate function can be used to define what truthiness means for this specific collection.
  * @param iterable
@@ -69,13 +69,13 @@ any([1, 4, 5] => (n) => n % 2 === 0)
 ```
 @see {@link all}
  */
-export const any = (iterable, fn = bool) => {
+export function any(iterable, fn = bool) {
     for (const item of iterable) {
         if (fn(item))
             return true;
     }
     return false;
-};
+}
 export function chain(...iterables) {
     return iflatten(iterables);
 }

package/dist/math/index.d.ts

@@ -27,7 +27,7 @@ export declare function round(x: number, digits?: number): number;
  *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor Math.floor()}
  */
-export declare const floor: (x: number) => number;
+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.
@@ -35,7 +35,7 @@ export declare const floor: (x: number) => number;
  *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil Math.ceil()}
  */
-export declare const ceil: (x: number) => number;
+export declare function ceil(x: number): number;
 /**
  * Returns a tuple like `[x / y, x % y]`.
  *

package/dist/math/index.js

@@ -37,7 +37,9 @@ export function round(x, digits = 0) {
  *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor Math.floor()}
  */
-export const floor = (x) => Math.floor(x);
+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.
@@ -45,7 +47,9 @@ export const floor = (x) => Math.floor(x);
  *
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil Math.ceil()}
  */
-export const ceil = (x) => Math.ceil(x);
+export function ceil(x) {
+    return Math.ceil(x);
+}
 /**
  * Returns a tuple like `[x / y, x % y]`.
  *

package/dist/operators/index.d.ts

@@ -4,25 +4,25 @@
  * @module operators
  */
 /** This is the identity function. It always returns the same value that was passed in */
-export declare const id: (x: any) => any;
+export declare function id(x: any): any;
 /**
  * Called to implement truth value testing.
  * @param x
  * @returns {boolean} `x.bool()` if exists or `!!x`.
  */
-export declare const bool: (x: any) => any;
+export declare function bool(x: any): any;
 /**
  * Returns `true` if `x` is a falsy value.
  * @see {@link bool}
  */
-export declare const not: (x: any) => boolean;
+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 const isinstance: (x: any, y: any) => 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()}

package/dist/operators/index.js

@@ -5,30 +5,36 @@
  */
 import { call, isObject } from '../globals/index.js';
 /** This is the identity function. It always returns the same value that was passed in */
-export const id = (x) => x;
+export function id(x) {
+    return x;
+}
 /**
  * Called to implement truth value testing.
  * @param x
  * @returns {boolean} `x.bool()` if exists or `!!x`.
  */
-export const bool = (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 const not = (x) => !bool(x);
+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 const isinstance = (x, y) => x instanceof y;
+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`

package/dist/random/index.d.ts

@@ -9,14 +9,14 @@
  * @param {number} max
  * @returns {number}
  */
-export declare const random: (min?: number, max?: number) => number;
+export declare function random(min?: number, max?: number): number;
 /**
  * Returns a random integer between a [min, max] value (inclusive).
  * @param {number} min
  * @param {number} max
  * @returns {number}
  */
-export declare const randomInt: (min?: number, max?: number) => number;
+export declare function randomInt(min?: number, max?: number): number;
 /**
  * Returns the item at some random index in a sequence.
  * @returns {T}

package/dist/random/index.js

@@ -10,14 +10,18 @@ import { isObject } from '../globals/index.js';
  * @param {number} max
  * @returns {number}
  */
-export const random = (min = 0, max = 1) => Math.random() * (max - min) + min;
+export function random(min = 0, max = 1) {
+    return Math.random() * (max - min) + min;
+}
 /**
  * Returns a random integer between a [min, max] value (inclusive).
  * @param {number} min
  * @param {number} max
  * @returns {number}
  */
-export const randomInt = (min = 0, max = 1) => Math.round(random(min, max));
+export function randomInt(min = 0, max = 1) {
+    return Math.round(random(min, max));
+}
 /**
  * Returns the item at some random index in a sequence.
  * @returns {T}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "atomic-fns",
   "description": "Like Lodash, but for ESNext and with types. Stop shipping code built for browsers from 2015.",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "files": [
     "dist/*"
   ],
@@ -11,12 +11,15 @@
   "types": "dist/index.d.ts",
   "sideEffects": false,
   "scripts": {
+    "preversion": "npm test",
+    "version": "npm run build && npm run docs && git add -A dist",
+    "postversion": "git push && git push --tags",
     "prepublishOnly": "npm run build",
     "test": "NODE_OPTIONS=--loader=ts-node/esm jasmine --config=jasmine.json",
     "tsc": "tsc -p . --declaration",
     "tsc:w": "tsc -p . --declaration --watch",
     "lint": "eslint src/**/*.ts --fix",
-    "build": "npm run lint && npm test && npm run tsc",
+    "build": "npm run lint && npm test && npm run tsc && npm run docs",
     "docs": "typedoc"
   },
   "devDependencies": {
@@ -67,5 +70,5 @@
   "bugs": {
     "url": "https://github.com/adrian2x/atomic-fns/issues"
   },
-  "homepage": "https://atomic-fns.dev"
+  "homepage": "https://atomic-stack.github.io/atomic-fns/"
 }

package/dist/globals/decimal.d.ts

@@ -1,142 +0,0 @@
-/**
- * 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;
-    private i;
-    private e;
-    /**
-     * 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`
-     */
-    private _normalize;
-    /**
-     * Truncate this `Decimal` to the configured precision
-     */
-    private _truncate;
-    /**
-     * 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;
-}