atomic-fns 0.4.2 → 1.1.1

package/dist/globals/index.d.ts

@@ -3,27 +3,12 @@
  *
  * @module Globals
  */
-/** 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;
-/**
- * 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> = (value: T, key?: K, arr?: any) => any;
-export declare type Predicate<T = any> = (value: T) => any;
+export declare type Function<TReturn = any> = (...args: any) => TReturn;
+/** This is just a noop function. */
+export declare const noop: () => void;
 /** A function that always returns `true`. */
 export declare const True: () => boolean;
 /** A function that always returns `false`. */
@@ -79,12 +64,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 +138,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 +152,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.
@@ -196,7 +181,7 @@ export declare const ord: (x: string) => number;
  * @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 declare const keys: (object: Object) => string[];
+export declare const keys: <T>(object: T) => (keyof T)[];
 /**
  * Returns an array of the own enumerable property values of `object`.
  * @param object The given object.
@@ -218,14 +203,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 +228,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 +261,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;

package/dist/globals/index.js

@@ -69,8 +69,8 @@ export class ValueError 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. 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.
  */
@@ -198,12 +198,12 @@ export function len(value) {
     if (isNumber(value.length)) {
         return value.length;
     }
-    if (isFunction(value.size)) {
-        return value.size();
-    }
     if (isNumber(value.size)) {
         return value.size;
     }
+    if (isFunction(value.size)) {
+        return value.size();
+    }
     if (isObject(value)) {
         return Object.keys(value).length;
     }
@@ -274,14 +274,7 @@ export const values = (object) => Object.values(object);
  * @returns `true` if the object has the property name.
  */
 export const has = (obj, attr) => obj && attr in obj;
-/**
- * Check if the attribute is present in the object or return a default value instead.
- * @param {PropertyKey} key
- * @param {*} obj
- * @param {*} [value=undefined]
- * @return The property value or default value.
- */
-export function get(key, obj, value = undefined) {
+export function get(key, obj, value) {
     if (obj == null)
         return value;
     let paths = Array.isArray(key) ? key : [key];
@@ -327,11 +320,6 @@ export function set(attr, obj, value, writable = false, enumerable = false) {
     });
 }
 export const HASH_KEY = Symbol.for('HASH_KEY');
-/**
- * Return a hash value for a given object. The hash will be the same for subsequent invocations.
- * @param obj The given object.
- * @returns The hash value.
- */
 export function hash(obj) {
     if (typeof obj === 'string') {
         return hashCode(obj);
@@ -399,9 +387,6 @@ export const int = (x, base = 10) => parseInt(x, base);
  * @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) : []);
-/**
- * Retrieve the next item from the iterator by calling its `next()` method.
- * @param iter The iterator.
- * @returns The next value from the iterator.
- */
-export const next = (iter) => iter.next().value;
+export function next(iter) {
+    return iter.next().value;
+}

package/dist/i18n/currency.d.ts

@@ -0,0 +1,24 @@
+import { Decimal } from '../decimal/index.js';
+/**
+ * Currency represents a local currency amount that can be formatted using the `Intl` apis.
+ */
+export declare class Currency extends Decimal {
+    private readonly locale;
+    private readonly currency;
+    private readonly numberFormat;
+    private readonly options;
+    constructor(amount: any, currency: string, locale?: string, opts?: Intl.NumberFormatOptions);
+    clone(n: any): Currency;
+    negated(): Currency;
+    add(x: any): Currency;
+    sub(x: any): Currency;
+    div(x: any): Currency;
+    mul(x: any): Currency;
+    toDecimal(): any;
+    toString(): string;
+    format(opts?: Intl.NumberFormatOptions, locale?: string): string;
+    displayName(): string;
+    accounting(): string;
+    precision(digits?: number): string;
+    eq(x: any): any;
+}

package/dist/i18n/currency.js

@@ -0,0 +1,85 @@
+import { defaults } from '../collections/index.js';
+import { isObject } from '../globals/index.js';
+import { Decimal } from '../decimal/index.js';
+/**
+ * Currency represents a local currency amount that can be formatted using the `Intl` apis.
+ */
+export class Currency extends Decimal {
+    locale;
+    currency;
+    numberFormat;
+    options = {
+        style: 'currency',
+        currencyDisplay: 'symbol',
+        maximumFractionDigits: 20
+    };
+    constructor(amount, currency, locale, opts = {}) {
+        super(amount);
+        if (isObject(locale)) {
+            opts = locale;
+            locale = undefined;
+        }
+        const systemLocale = new Intl.NumberFormat(locale, defaults(opts, { currency }, this.options));
+        const resolved = systemLocale.resolvedOptions();
+        this.numberFormat = systemLocale;
+        this.options.currency = currency;
+        this.currency = resolved.currency;
+        this.locale = resolved.locale;
+    }
+    // @ts-expect-error overrides
+    clone(n) {
+        return new Currency(n, this.currency, this.locale, this.options);
+    }
+    // @ts-expect-error overrides
+    negated() {
+        const n = super.negated.call(this);
+        return this.clone(n);
+    }
+    // @ts-expect-error overrides
+    add(x) {
+        const n = super.add.call(this.toDecimal(), x);
+        return this.clone(n);
+    }
+    // @ts-expect-error overrides
+    sub(x) {
+        const n = super.sub.call(this.toDecimal(), x);
+        return this.clone(n);
+    }
+    // @ts-expect-error overrides
+    div(x) {
+        const n = super.div.call(this.toDecimal(), x);
+        return this.clone(n);
+    }
+    // @ts-expect-error overrides
+    mul(x) {
+        const n = super.mul.call(this.toDecimal(), x);
+        return this.clone(n);
+    }
+    toDecimal() {
+        return super.clone.call(this);
+    }
+    toString() {
+        const number = this.toNumber();
+        return this.numberFormat.format(number);
+    }
+    format(opts = {}, locale) {
+        const number = this.toNumber();
+        opts = defaults(opts, this.options);
+        return new Intl.NumberFormat(locale ?? this.locale, opts).format(number);
+    }
+    displayName() {
+        return this.format({ currencyDisplay: 'name' });
+    }
+    accounting() {
+        return this.format({ currencySign: 'accounting' });
+    }
+    precision(digits) {
+        return this.format({ maximumFractionDigits: digits });
+    }
+    eq(x) {
+        if (x?.currency && x.currency !== this.currency) {
+            return false;
+        }
+        return super.eq.call(this, x);
+    }
+}

package/dist/i18n/date/format.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Returns a new Date from the given arguments.
+ * @param {string | number | Date} date The date value
+ * @param {?boolean} [utc=false] Interprets the given value as a UTC date
+ * @returns {Date} The new date object
+ */
+export declare function getDate(date: string | number | Date, utc?: boolean): Date;
+/**
+ * Formats a date using a formatting string in the {@link https://strftime.org/ strftime} format, in any given locale.
+ * @param {string} fmt The format string to apply
+ * @param {number | Date} date The date value
+ * @param {?string} locale The locale to use when formatting (default is system locale).
+ * @returns {string} The string representation of date
+ * @see {@link https://strftime.org/ strftime format}
+ */
+export declare function format(fmt: string, date: number | Date, locale?: any): string;

package/dist/i18n/date/format.js

@@ -0,0 +1,313 @@
+const NATIVE_DATE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/;
+/**
+ * Returns a new Date from the given arguments.
+ * @param {string | number | Date} date The date value
+ * @param {?boolean} [utc=false] Interprets the given value as a UTC date
+ * @returns {Date} The new date object
+ */
+export function getDate(date, utc = false) {
+    if (date === null)
+        return new Date(NaN);
+    if (!date)
+        return new Date();
+    if (date instanceof Date)
+        return new Date(date);
+    if (typeof date === 'string' && !/Z$/i.test(date)) {
+        const d = date.match(NATIVE_DATE);
+        if (d) {
+            const m = d[2] - 1 || 0;
+            const ms = (d[7] || '0').slice(0, 3);
+            if (utc) {
+                return new Date(Date.UTC(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms));
+            }
+            return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);
+        }
+    }
+    return new Date(date);
+}
+const n = 'numeric';
+const s = 'short';
+const l = 'long';
+const dd = '2-digit';
+const TOKEN_MAP = {
+    // weekday
+    '%A': { weekday: l },
+    '%a': { weekday: s },
+    '%aa': { weekday: n },
+    // day
+    '%d': { day: dd },
+    '%-d': { day: n },
+    // month
+    '%m': { month: dd },
+    '%-m': { month: n },
+    '%B': { month: l },
+    '%b': { month: s },
+    '%bb': { month: n },
+    // year
+    '%y': { year: n },
+    '%Y': { year: dd },
+    // hour
+    '%K': { hourCycle: 'h11', hour: dd },
+    '%I': { hourCycle: 'h12', hour: dd },
+    '%-I': { hourCycle: 'h12', hour: n },
+    '%H': { hourCycle: 'h23', hour: dd },
+    '%-H': { hourCycle: 'h23', hour: n },
+    '%k': { hourCycle: 'h24', hour: n },
+    // minutes
+    '%M': { minute: dd },
+    '%-M': { minute: n },
+    // seconds
+    '%S': { second: dd },
+    '%-S': { second: n },
+    // day period
+    '%P': { dayPeriod: l },
+    '%p': { dayPeriod: s },
+    '%pp': { dayPeriod: 'narrow' },
+    // era
+    '%N': { era: l, year: dd },
+    '%n': { era: s, year: dd },
+    '%nn': { era: n, year: 'narrow' },
+    // timeZoneName
+    '%Z': { timeZoneName: 'longGeneric', year: dd },
+    '%-Z': { timeZoneName: 'shortGeneric', year: dd },
+    '%z': { timeZoneName: 'longOffset', year: dd },
+    '%-z': { timeZoneName: 'shortOffset', year: dd },
+    '%ZZ': { timeZoneName: l, year: dd },
+    '%-ZZ': { timeZoneName: s, year: dd }
+};
+const HOUR_PARTS = { '%I': 1, '%-I': 1, '%K': 1, '%k': 1 };
+const ERA_PARTS = { '%n': 1, '%N': 1, '%nn': 1 };
+const TZ_PARTS = { '%ZZ': 1, '%-ZZ': 1, '%-z': 1, '%z': 1, '%-Z': 1, '%Z': 1 };
+const formatter = (locale, opts) => new Intl.DateTimeFormat(locale, opts);
+/**
+ * Formats a date using a formatting string in the {@link https://strftime.org/ strftime} format, in any given locale.
+ * @param {string} fmt The format string to apply
+ * @param {number | Date} date The date value
+ * @param {?string} locale The locale to use when formatting (default is system locale).
+ * @returns {string} The string representation of date
+ * @see {@link https://strftime.org/ strftime format}
+ */
+export function format(fmt, date, locale) {
+    const results = [];
+    let dayPeriod = '';
+    let dayPeriodIndex = -1;
+    for (let i = 0; i < fmt.length; i++) {
+        let part = fmt[i];
+        if (part === '%') {
+            // check for escaped '%'
+            if (fmt[++i] === '%') {
+                results.push('%');
+                continue;
+            }
+            if (fmt[i] === '-') {
+                part += fmt[i++];
+            }
+            part += fmt[i];
+            // add any repeated characters that come after
+            while (i < fmt.length - 1 && fmt[i + 1] === fmt[i])
+                part += fmt[++i];
+            if (HOUR_PARTS[part]) {
+                const res = formatter(locale, TOKEN_MAP[part]).format(date).split(' ');
+                // save the AM/PM for the correct spot
+                results.push(res[0]);
+                dayPeriod = res[1];
+                continue;
+            }
+            if (part === '%P' || part === '%p') {
+                // leave this flag in place for later
+                dayPeriodIndex = results.length;
+                results.push(part);
+                continue;
+            }
+            if (ERA_PARTS[part] || TZ_PARTS[part]) {
+                // the formatting includes the date/year so we take what comes after
+                const res = formatter(locale, TOKEN_MAP[part]).format(date).split(' ');
+                results.push(res.slice(1).join(' '));
+                continue;
+            }
+            // format any other parts
+            let res = formatter(locale, TOKEN_MAP[part]).format(date);
+            if (part === '%S' && res.length === 1)
+                res = '0' + res;
+            results.push(res);
+        }
+        else {
+            // output as literal
+            results.push(part);
+        }
+    }
+    // insert the AM/PM at the correct spot
+    if (dayPeriodIndex >= 0)
+        results[dayPeriodIndex] = dayPeriod || '';
+    return results.join('');
+}
+const DATETIME_DEFAULT = {};
+/** 10/14/1983 */
+const DATE_SHORT = {
+    year: n,
+    month: n,
+    day: n
+};
+/** Oct 14, 1983 */
+const DATE_MED = {
+    year: n,
+    month: s,
+    day: n
+};
+/** Fri, Oct 14, 1983 */
+const DATE_MED_WITH_WEEKDAY = {
+    year: n,
+    month: s,
+    day: n,
+    weekday: s
+};
+/** October 14, 1983 */
+const DATE_FULL = {
+    year: n,
+    month: l,
+    day: n
+};
+/** Tuesday, October 14, 1983 */
+const DATE_HUGE = {
+    year: n,
+    month: l,
+    day: n,
+    weekday: l
+};
+/** 09:30 AM */
+const TIME_SIMPLE = {
+    hour: n,
+    minute: n
+};
+/** 09:30:23 AM */
+const TIME_WITH_SECONDS = {
+    hour: n,
+    minute: n,
+    second: n
+};
+/** 09:30:23 AM EDT */
+const TIME_WITH_SHORT_OFFSET = {
+    hour: n,
+    minute: n,
+    second: n,
+    timeZoneName: s
+};
+/** 09:30:23 AM Eastern Daylight Time */
+const TIME_WITH_LONG_OFFSET = {
+    hour: n,
+    minute: n,
+    second: n,
+    timeZoneName: l
+};
+/** 09:30 */
+const TIME_24_SIMPLE = {
+    hour: n,
+    minute: n,
+    hourCycle: 'h23'
+};
+/** 09:30:23 */
+const TIME_24_WITH_SECONDS = {
+    hour: n,
+    minute: n,
+    second: n,
+    hourCycle: 'h23'
+};
+/** 09:30:23 EDT */
+const TIME_24_WITH_SHORT_OFFSET = {
+    hour: n,
+    minute: n,
+    second: n,
+    hourCycle: 'h23',
+    timeZoneName: s
+};
+/** 09:30:23 Eastern Daylight Time */
+const TIME_24_WITH_LONG_OFFSET = {
+    hour: n,
+    minute: n,
+    second: n,
+    hourCycle: 'h23',
+    timeZoneName: l
+};
+/** 10/14/1983, 9:30 AM */
+const DATETIME_SHORT = {
+    year: n,
+    month: n,
+    day: n,
+    hour: n,
+    minute: n
+};
+/** 10/14/1983, 9:30:33 AM */
+const DATETIME_SHORT_WITH_SECONDS = {
+    year: n,
+    month: n,
+    day: n,
+    hour: n,
+    minute: n,
+    second: n
+};
+/** Oct 14, 1983, 9:30 AM */
+const DATETIME_MED = {
+    year: n,
+    month: s,
+    day: n,
+    hour: n,
+    minute: n
+};
+/** Oct 14, 1983, 9:30:33 AM */
+const DATETIME_MED_WITH_SECONDS = {
+    year: n,
+    month: s,
+    day: n,
+    hour: n,
+    minute: n,
+    second: n
+};
+/** Fri, 14 Oct 1983, 9:30 AM */
+const DATETIME_MED_WITH_WEEKDAY = {
+    year: n,
+    month: s,
+    day: n,
+    weekday: s,
+    hour: n,
+    minute: n
+};
+/** October 14, 1983, 9:30 AM EDT */
+const DATETIME_FULL = {
+    year: n,
+    month: l,
+    day: n,
+    hour: n,
+    minute: n,
+    timeZoneName: s
+};
+/** October 14, 1983, 9:30:33 AM EDT */
+const DATETIME_FULL_WITH_SECONDS = {
+    year: n,
+    month: l,
+    day: n,
+    hour: n,
+    minute: n,
+    second: n,
+    timeZoneName: s
+};
+/** Friday, October 14, 1983, 9:30 AM Eastern Daylight Time */
+const DATETIME_HUGE = {
+    year: n,
+    month: l,
+    day: n,
+    weekday: l,
+    hour: n,
+    minute: n,
+    timeZoneName: l
+};
+/** Friday, October 14, 1983, 9:30:33 AM Eastern Daylight Time */
+const DATETIME_HUGE_WITH_SECONDS = {
+    year: n,
+    month: l,
+    day: n,
+    weekday: l,
+    hour: n,
+    minute: n,
+    second: n,
+    timeZoneName: l
+};