atomic-fns 0.3.4 → 0.4.2

package/dist/i18n/format.js

@@ -0,0 +1,495 @@
+const NATIVE_DATE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/;
+const REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/;
+const REGEX_FORMAT = /\[([^\]]+)]|Y{1,4}|M{1,4}|Q|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|z{1,4}|N{1,4}|LTS?|L{1,4}|l{1,4}|x|X|SSS/g;
+const FORMAT_DEFAULT = 'YYYY-MM-DDTHH:mm:ssZ';
+const padStart = (string, length, pad) => String(string).padStart(length, pad);
+const padZoneStr = (instance) => {
+    const negMinutes = -instance.getTimezoneOffset();
+    const minutes = Math.abs(negMinutes);
+    const hourOffset = Math.floor(minutes / 60);
+    const minuteOffset = minutes % 60;
+    return `${negMinutes <= 0 ? '+' : '-'}${padStart(hourOffset, 2, '0')}:${padStart(minuteOffset, 2, '0')}`;
+};
+/**
+ * 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 asDate(date, utc = false) {
+    if (date === null) {
+        return new Date(NaN);
+    }
+    if (date === undefined) {
+        date = Date.now();
+    }
+    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);
+        }
+    }
+    const fromDate = new Date(date);
+    if (utc) {
+        fromDate.setFullYear(fromDate.getUTCFullYear());
+        fromDate.setMonth(fromDate.getUTCMonth());
+        fromDate.setDate(fromDate.getUTCDate());
+        fromDate.setHours(fromDate.getUTCHours());
+        fromDate.setMinutes(fromDate.getUTCMinutes());
+        fromDate.setSeconds(fromDate.getUTCSeconds());
+        fromDate.setMilliseconds(fromDate.getUTCMilliseconds());
+    }
+    return fromDate;
+}
+const n = 'numeric';
+const s = 'short';
+const l = 'long';
+const dd = '2-digit';
+const STRFTIME = {
+    // 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 },
+    '%Z': { timeZoneName: l, year: dd },
+    '%-Z': { timeZoneName: s, year: dd }
+};
+const TOKENS = {
+    // weekday
+    dddd: { weekday: l },
+    ddd: { weekday: s },
+    E: { weekday: n },
+    // day
+    DD: { day: dd },
+    D: { day: n },
+    // month
+    MM: { month: dd },
+    M: { month: n },
+    MMMM: { month: l },
+    MMM: { month: s },
+    // year
+    YYYY: { year: n },
+    YY: { year: dd },
+    // hour
+    hh: { hourCycle: 'h12', hour: dd },
+    h: { hourCycle: 'h12', hour: n },
+    HH: { hourCycle: 'h23', hour: dd },
+    H: { hourCycle: 'h23', hour: n },
+    kk: { hourCycle: 'h11', hour: dd },
+    k: { hourCycle: 'h24', hour: n },
+    // minutes
+    mm: { minute: dd },
+    m: { minute: n },
+    // seconds
+    ss: { second: dd },
+    s: { second: n },
+    // day period
+    A: { dayPeriod: l },
+    a: { dayPeriod: s },
+    // era
+    N: { era: s, year: dd },
+    NN: { era: s, year: dd },
+    NNN: { era: s, year: dd },
+    NNNN: { era: l, year: dd },
+    // timeZoneName
+    ZZ: { timeZoneName: 'longOffset', year: dd },
+    Z: { timeZoneName: 'shortOffset', year: dd },
+    zzz: { timeZoneName: l, year: dd },
+    z: { 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);
+const formatHour = (h, maxLength) => String(h % 12 || 12).padStart(maxLength, '0');
+const formatMeridiem = (hour, isLowercase) => {
+    const m = hour < 12 ? 'AM' : 'PM';
+    return isLowercase ? m.toLowerCase() : m;
+};
+const formatPart = (locale, t, date) => {
+    const value = formatter(locale, TOKENS[t]).format(date);
+    return value.split(/\s+/g).slice(1).join(' ');
+};
+/**
+ * Returns a localized string representation of this date, according to the given format string. Format codes use the same specification as {@link https://momentjs.com/docs/#/displaying/format/ moment}.
+ * @param {string} str The format string to use
+ * @see {@link https://momentjs.com/docs/#/displaying/format/ List of formats}
+ * @example
+```js
+formatDate(new Date(), 'MM/DD/YYYY') // '10/31/2022'
+```
+  */
+export function formatDate(formatStr, date, locale) {
+    const str = formatStr || FORMAT_DEFAULT;
+    const zoneStr = padZoneStr(date);
+    const time = {
+        H: date.getHours(),
+        HH: padStart(date.getHours(), 2, '0'),
+        h: formatHour(date.getHours(), 1),
+        hh: formatHour(date.getHours(), 2),
+        a: formatMeridiem(date.getHours(), true),
+        A: formatMeridiem(date.getHours()),
+        m: date.getMinutes(),
+        mm: padStart(date.getMinutes(), 2, '0'),
+        s: date.getSeconds(),
+        ss: padStart(date.getSeconds(), 2, '0'),
+        SSS: padStart(date.getMilliseconds(), 3, '0'),
+        X: Math.floor(date.getTime() / 1000),
+        x: date.getTime()
+    };
+    const matches = {
+        ...time,
+        N: formatPart(locale, 'N', date),
+        NN: formatPart(locale, 'NN', date),
+        NNN: formatPart(locale, 'NNN', date),
+        NNNN: formatPart(locale, 'NNNN', date),
+        YY: String(date.getFullYear()).slice(-2),
+        YYYY: date.getFullYear(),
+        M: date.getMonth() + 1,
+        MM: padStart(date.getMonth() + 1, 2, '0'),
+        MMM: formatter(locale, TOKENS.MMM).format(date),
+        MMMM: formatter(locale, TOKENS.MMMM).format(date),
+        Q: Math.ceil((date.getMonth() + 1) / 3),
+        D: date.getDate(),
+        DD: padStart(date.getDate(), 2, '0'),
+        d: date.getDay(),
+        ddd: formatter(locale, TOKENS.ddd).format(date),
+        dddd: formatter(locale, TOKENS.dddd).format(date),
+        Z: formatPart(locale, 'Z', date),
+        ZZ: formatPart(locale, 'ZZ', date),
+        z: formatPart(locale, 'z', date),
+        zzz: formatPart(locale, 'zzz', date),
+        LT: `${time.h}:${time.mm} ${time.A}`,
+        LTS: `${time.h}:${time.mm}:${time.ss} ${time.A}`,
+        L: formatter(locale, DATE_SHORT_DD).format(date),
+        LL: formatter(locale, DATE_FULL).format(date),
+        LLL: formatter(locale, DATE_LONG_TIME).format(date),
+        LLLL: formatter(locale, DATE_HUGE).format(date),
+        l: formatter(locale, DATE_SHORT).format(date),
+        ll: formatter(locale, DATE_MED).format(date),
+        lll: formatter(locale, DATE_MED_TIME).format(date),
+        llll: formatter(locale, DATE_MED_WITH_WEEKDAY).format(date)
+    };
+    return str.replace(REGEX_FORMAT, (match, $1) => $1 || matches[match] || zoneStr.replace(':', '')); // 'ZZ'
+}
+/**
+ * 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 strftime(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, STRFTIME[part]).format(date).split(/\s+/g);
+                // 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;
+                if (part === '%p' && dayPeriod) {
+                    dayPeriod = dayPeriod.toLowerCase();
+                }
+                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, STRFTIME[part]).format(date).split(/\s+/g);
+                results.push(res.slice(1).join(' '));
+                continue;
+            }
+            // format any other parts
+            let res = formatter(locale, STRFTIME[part]).format(date);
+            // fix bugs in time formatter
+            if ((part === '%S' || part === '%M') && 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('').trim();
+}
+const DATETIME_DEFAULT = {};
+/** L: 09/04/1983 */
+const DATE_SHORT_DD = {
+    year: n,
+    month: dd,
+    day: dd
+};
+/** l: 9/4/1983 */
+const DATE_SHORT = {
+    year: n,
+    month: n,
+    day: n
+};
+/** ll: Oct 14, 1983 */
+const DATE_MED = {
+    year: n,
+    month: s,
+    day: n
+};
+/** LL: October 14, 1983 */
+const DATE_FULL = {
+    year: n,
+    month: l,
+    day: n
+};
+/** lll: Oct 14, 1983 8:30 PM */
+const DATE_MED_TIME = {
+    year: n,
+    month: s,
+    day: n,
+    hour: n,
+    minute: n,
+    hourCycle: 'h12'
+};
+/** LLL: October 14, 1983 8:30 PM */
+const DATE_LONG_TIME = {
+    year: n,
+    month: l,
+    day: n,
+    hour: n,
+    minute: n,
+    hourCycle: 'h12'
+};
+/** llll: Fri, Oct 14, 1983, 8:30 PM */
+const DATE_MED_WITH_WEEKDAY = {
+    year: n,
+    month: s,
+    day: n,
+    weekday: s,
+    hour: n,
+    minute: n,
+    hourCycle: 'h12'
+};
+/** LLLL: Tuesday, October 14, 1983, 8:30 PM */
+const DATE_HUGE = {
+    year: n,
+    month: l,
+    day: n,
+    weekday: l,
+    hour: n,
+    minute: n,
+    hourCycle: 'h12'
+};
+/** LT: 09:30 AM */
+const TIME_SIMPLE = {
+    hour: n,
+    minute: n,
+    hourCycle: 'h12'
+};
+/** LTS: 09:30:23 AM */
+const TIME_WITH_SECONDS = {
+    hour: n,
+    minute: n,
+    second: n,
+    hourCycle: 'h12'
+};
+/** 09:30:23 AM EDT */
+const TIME_WITH_SHORT_OFFSET = {
+    hour: n,
+    minute: n,
+    second: n,
+    timeZoneName: s,
+    hourCycle: 'h12'
+};
+/** 09:30:23 AM Eastern Daylight Time */
+const TIME_WITH_LONG_OFFSET = {
+    hour: n,
+    minute: n,
+    second: n,
+    timeZoneName: l,
+    hourCycle: 'h12'
+};
+/** 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,
+    hourCycle: 'h12'
+};
+/** 10/14/1983, 9:30:33 AM */
+const DATETIME_SHORT_WITH_SECONDS = {
+    year: n,
+    month: n,
+    day: n,
+    hour: n,
+    minute: n,
+    second: n,
+    hourCycle: 'h12'
+};
+/** Oct 14, 1983, 9:30 AM */
+const DATETIME_MED = {
+    year: n,
+    month: s,
+    day: n,
+    hour: n,
+    minute: n,
+    hourCycle: 'h12'
+};
+/** Oct 14, 1983, 9:30:33 AM */
+const DATETIME_MED_WITH_SECONDS = {
+    year: n,
+    month: s,
+    day: n,
+    hour: n,
+    minute: n,
+    second: n,
+    hourCycle: 'h12'
+};
+/** Fri, 14 Oct 1983, 9:30 AM */
+const DATETIME_MED_WITH_WEEKDAY = {
+    year: n,
+    month: s,
+    day: n,
+    weekday: s,
+    hour: n,
+    minute: n,
+    hourCycle: 'h12'
+};
+/** October 14, 1983, 9:30 AM EDT */
+const DATETIME_FULL = {
+    year: n,
+    month: l,
+    day: n,
+    hour: n,
+    minute: n,
+    timeZoneName: s,
+    hourCycle: 'h12'
+};
+/** 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,
+    hourCycle: 'h12'
+};
+/** 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,
+    hourCycle: 'h12'
+};
+/** 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,
+    hourCycle: 'h12'
+};

package/{core → dist}/i18n/index.d.ts

@@ -4,4 +4,4 @@
  * @module i18n
  */
 export * from './date/index.js';
-export * from './date/format.js';
+export { Duration, TDuration, DurationUnit } from './duration.js';

package/{core → dist}/i18n/index.js

@@ -4,4 +4,4 @@
  * @module i18n
  */
 export * from './date/index.js';
-export * from './date/format.js';
+export { Duration } from './duration.js';

package/{core → dist}/itertools/index.d.ts

@@ -21,13 +21,13 @@ export declare function accumulate<T>(iterable: Iterable<T>, func?: typeof add,
  * @example
 ```js
 all([0])
-// => true
+// true
 
 all([1, 2, 3])
-// => true
+// true
 
 all([2, 4, 6] => (n) => n > 1)
-// => true
+// true
 ```
 @see {@link any}
  */
@@ -40,13 +40,13 @@ export declare const all: <T>(iterable: Iterable<T>, fn?: Predicate<T>) => boole
  * @example
 ```js
 any([0])
-// => false
+// false
 
 any([0, 1, null, undefined])
-// => true
+// true
 
 any([1, 4, 5] => (n) => n % 2 === 0)
-// => true
+// true
 ```
 @see {@link all}
  */
@@ -60,16 +60,16 @@ export declare function chain<T>(...iterables: Array<Iterable<T>>): Generator<T,
  * @example
 ```js
 contains([1, 2, 3], 1)
-// => true
+// true
 
 contains([1, 2, 3], 1, 2)
-// => false
+// false
 
 contains({ 'a': 1, 'b': 2 }, 1)
-// => true
+// true
 
 contains('abcd', 'bc')
-// => true
+// true
 ```
  *
  * @see {@link Collections.find}
@@ -81,7 +81,7 @@ export declare function contains(collection: Iterable<any>, value: any): any;
  * @param predicate A function invoked per element to check if it should be dropped.
  * @returns Elements
  */
-export declare function dropWhile<T>(iterable: Iterable<T>, predicate: Predicate): Generator<unknown, any, unknown>;
+export declare function dropWhile<T>(iterable: Iterable<T>, predicate: Predicate): Generator<any, any, unknown>;
 export declare function iforEach<T>(iterable: Iterable<T>, fun: Iteratee<T>): void;
 export declare function IterableIterator<T = any>(next: any): Iterator<T, any, undefined> & Iterable<T>;
 /**
@@ -93,11 +93,11 @@ export declare function IterableIterator<T = any>(next: any): Iterator<T, any, u
  * @example
 ```js
 console.log([...enumerate(['hello', 'world'])])
-// => [[0, 'hello'], [1, 'world']]
+// [[0, 'hello'], [1, 'world']]
 
 // Start with index `1`
 console.log([...enumerate(['hello', 'world'], 1)])
-// => [[1, 'hello'], [2, 'world']]
+// [[1, 'hello'], [2, 'world']]
 ```
  */
 export declare function enumerate<T = any>(iterable: Iterable<T>, start?: number): Generator<(number | T)[], void, unknown>;
@@ -114,7 +114,7 @@ export declare function first<T>(iterable: Iterable<T>): any;
  * @example
 ```js
 compact([0, 1, false, 2, '', 3])
-// => [1, 2, 3]
+// [1, 2, 3]
 ```
  */
 export declare function icompact<T>(iterable: Iterable<T>): Generator<T, void, unknown>;
@@ -129,13 +129,13 @@ export declare function imap<T, TReturn = any>(iterable: Iterable<T>, mapFn: (x:
  * @example
 ```js
 [...iflatten([[0, 1], [2, 3]])]
-// => [0, 1, 2, 3]
+// [0, 1, 2, 3]
 ```
  */
 export declare function iflatten<T = any>(iterables: Iterable<Iterable<T>>): Generator<T, void, unknown>;
 export declare function flatMap<T>(iterable: Iterable<T>, mapFn?: (x: T) => any): Generator<T, void, unknown>;
-export declare function islice<T>(iterable: Iterable<T>, start: number, stop?: number, step?: number): Generator<number | T, number | T | undefined, unknown>;
-export declare function itake<T>(n: number, iterable: Iterable<T>): Generator<unknown, void, unknown>;
+export declare function islice<T>(iterable: Iterable<T>, start: number, stop?: number, step?: number): Generator<number | T, number | T, unknown>;
+export declare function itake<T>(n: number, iterable: Iterable<T>): Generator<any, void, unknown>;
 /**
  * Returns an Iterator from the elements of a collection or the object keys.
  * @param obj The given collection to iterate over.
@@ -151,19 +151,19 @@ export declare function partition<T>(iterable: Iterable<T>, predicate: Predicate
  * @example
 ```js
 range(5)
-// => [0, 1, 2, 3, 4]
+// [0, 1, 2, 3, 4]
 
 range(2, 5)
-// => [2, 3, 4]
+// [2, 3, 4]
 
 range(0, 5, 2)
-// => [0, 2, 4]
+// [0, 2, 4]
 
 range(5, 0, -1)
-// => [5, 4, 3, 2, 1]
+// [5, 4, 3, 2, 1]
 
 range(-3)
-// => []
+// []
 ```
  */
 export declare function range(...args: number[]): Generator<number, void, unknown>;
@@ -176,7 +176,7 @@ export declare function range(...args: number[]): Generator<number, void, unknow
  * @example
 ```js
 reduce([1, 2, 3, 4, 5], (x, y) => x + y, 0)
-// => 15
+// 15
 ```
  * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce Array.reduce()}
  */
@@ -196,7 +196,7 @@ export declare function sort(args: any[]): any[];
 export declare function sort(args: any[], reverse: boolean): any[];
 export declare function sort(args: any[], compareFn: Comparer): any[];
 export declare function sort(args: any[], reverse: boolean, compareFn: Comparer): any[];
-export declare function take<T>(n: number, iterable: Iterable<T>): unknown[];
+export declare function take<T>(n: number, iterable: Iterable<T>): any[];
 /**
  * Returns a generator that takes elements from the iterable as long as the predicate is `true`.
  * @param iterable The iterable to inspect.
@@ -219,9 +219,9 @@ export declare function times(n: number, fn: (index: number) => any): Generator<
 ```js
 for item of zip([1, 2, 3], ['sugar', 'spice', 'nice'])
   console.log(item)
-// => [1, 'sugar']
-// => [2, 'spice']
-// => [3, 'nice']
+// [1, 'sugar']
+// [2, 'spice']
+// [3, 'nice']
 ```
  */
 export declare function zip(...args: Array<Iterable<any>>): Generator<any[], void, unknown>;