atomic-fns 1.2.0 → 2.0.0

package/dist/i18n/date/index.js

@@ -1,552 +0,0 @@
-import { isObject, ValueError } from '../../globals/index.js';
-import { Duration, UNITS_PLURAL } from '../duration.js';
-import { asDate, formatDate, fromFields, strftime } from '../format.js';
-import { asNumber, dayOfYear, daysInMonth, daysInYear, isLeapYear, maxDate, minDate, weekOfYear, weeksInYear } from './utils.js';
-// Export date functions
-export { asDate, daysInMonth, daysInYear, formatDate, isLeapYear, maxDate, minDate, strftime, weeksInYear };
-const INVALID_DATE_STRING = 'Invalid Date';
-/**
- * Creates a date tied to a given locale (default system locale) which can be formatted in that locale's language using the native {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl Intl Apis} directly or using a formatting string.
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl Intl Apis}
- */
-export class IntlDate {
-    _date;
-    locale;
-    intlRelativeFormat;
-    /** Parses the provided value as UTC date or returns the current UTC date. */
-    static UTC(value, locale) {
-        return new IntlDate(value, { utc: true, locale });
-    }
-    /** Returns the current local date and time. */
-    static now() {
-        return new IntlDate();
-    }
-    /** Creates a new date from a Unix timestamp (seconds since the unix epoch) */
-    static unix(seconds) {
-        return new IntlDate(seconds * 1000);
-    }
-    /**
-     * Creates a new `IntlDate` in local time and specified locale (default is system locale).
-     * **Note:** The allowed values for `month` start at 1, which is different from legacy `Date`
-     * @param {DateLike} obj The date value (default is current local time)
-     * @param {Object} opts The options for this date
-     * @param {boolean?} opts.utc Converts input or current time to UTC
-     * @param {string?} opts.locale A locale string to use for this date
-     * @returns
-     */
-    constructor(obj, { locale, utc } = {}) {
-        this.locale = locale;
-        if (obj instanceof IntlDate) {
-            obj = obj._date;
-        }
-        if (typeof obj === 'string' || typeof obj === 'number' || obj instanceof Date) {
-            this._date = asDate(obj, utc);
-        }
-        else if (isObject(obj)) {
-            let { year, month, day, hour, minute, second, millisecond } = obj;
-            // NOTE month is from 1-12, not from 0-11
-            month = (month ?? 1) - 1;
-            this._date = fromFields(utc, Number(year), month, day || 1, hour || 0, minute || 0, second || 0, millisecond || 0);
-        }
-        else {
-            this._date = asDate(obj, utc);
-        }
-        return this;
-    }
-    /** Get the date's year. */
-    get year() {
-        return this._date.getFullYear();
-    }
-    /** Get the this date's month as a number from 1 to 12, inclusive. */
-    get month() {
-        return this._date.getMonth() + 1;
-    }
-    /** Returns the weekday as a number between 1 and 7, inclusive, where Monday is 1 and Sunday is 7. */
-    get dayOfWeek() {
-        if (this._date.getDay() === 0)
-            return 7;
-        return this._date.getDay();
-    }
-    /** Get the this date's current day of the month. */
-    get day() {
-        return this._date.getDate();
-    }
-    /** Get the this date's current hour. */
-    get hour() {
-        return this._date.getHours();
-    }
-    /** Get the this date's current minute. */
-    get minute() {
-        return this._date.getMinutes();
-    }
-    /** Get the this date's current second. */
-    get second() {
-        return this._date.getSeconds();
-    }
-    /** Get the this date's current millisecond. */
-    get millisecond() {
-        return this._date.getMilliseconds();
-    }
-    isValid() {
-        return this._date.toString() !== INVALID_DATE_STRING;
-    }
-    /** Get the number of days in this date's month. */
-    daysInMonth() {
-        return daysInMonth(this._date);
-    }
-    /** Get the number of days in this date's year. */
-    daysInYear() {
-        return daysInYear(this.year);
-    }
-    dayOfYear() {
-        return dayOfYear(this._date);
-    }
-    /** Returns `true` if this date's year is a leap year. */
-    isLeapYear() {
-        return isLeapYear(this.year);
-    }
-    /** Gets the number of Monday-first weeks in the current year, where week 1 is the first full week. */
-    weeksInYear() {
-        return weeksInYear(this.year);
-    }
-    /** Gets the number of weeks in the current year, according to ISO weeks. */
-    isoWeeksInYear() {
-        return weeksInYear(this.year, 1, 4);
-    }
-    /** Returns the current week of the year. */
-    week() {
-        return weekOfYear(this._date).week;
-    }
-    /** Returns the ISO week of the year. */
-    isoWeek() {
-        return weekOfYear(this._date, 1, 4).week;
-    }
-    /**
-     * Returns a localized string representation of this date.
-     * @param {Intl.DateTimeFormatOptions} opts The options to use for the format
-     * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat/DateTimeFormat Intl.DateTimeFormat()}
-     */
-    toString(opts) {
-        return this._date.toLocaleString(this.locale, opts);
-    }
-    /**
-     * 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
-  new IntlDate().format('MM/DD/YYYY') // '10/31/2022'
-  ```
-     */
-    format(str) {
-        return formatDate(str, this._date, this.locale);
-    }
-    /**
-     * Returns a new copy of the native `Date` object used by this instance.
-     * @returns {Date} A new `Date` object
-     */
-    toDate() {
-        return new Date(this.isValid() ? this._date : NaN);
-    }
-    /**
-     * Returns the number of seconds since the Unix Epoch (January 1, 1970 UTC).
-     * @see {@link IntlDate.timestamp}
-     * @see {@link IntlDate.unix}
-     * @example
-  ```js
-  new IntlDate().toSeconds() // 1318874398
-  ```
-     */
-    toSeconds() {
-        return Math.trunc(this.getTime() / 1000);
-    }
-    /**
-     * Returns the number of seconds since the Unix Epoch (January 1, 1970 UTC).
-     * @see {@link IntlDate.toSeconds}
-     * @see {@link IntlDate.unix}
-     * @example
-  ```js
-  new IntlDate().timestamp() // 1318874398
-  ```
-     */
-    timestamp() {
-        return this.toSeconds();
-    }
-    /**
-     * Returns the number of seconds since the Unix Epoch (January 1, 1970 UTC).
-     * @see {@link IntlDate.toSeconds}
-     * @see {@link IntlDate.timestamp}
-     * @example
-  ```js
-  new IntlDate().unix() // 1318874398
-  ```
-     */
-    unix() {
-        return this.toSeconds();
-    }
-    /** Formats a string to the ISO8601 standard.
-     * @example
-  ```js
-  new IntlDate().toISOString() // '2022-10-31T22:44:30.652Z'
-  ```
-     */
-    toISOString() {
-        return this._date.toISOString();
-    }
-    /** Returns the date part formatted as ISO8601.
-     * @example
-  ```js
-  new IntlDate().toISODate() // '2022-10-31'
-  ```
-     */
-    toISODate() {
-        return this._date.toISOString().split('T')[0];
-    }
-    /** Returns the time part formatted as ISO8601.
-     * @example
-  ```js
-  new IntlDate().toISOTime() // '22:44:30.652Z'
-  ```
-     */
-    toISOTime() {
-        return this._date.toISOString().split('T')[1];
-    }
-    /**
-     * Returns an object containing year, month, day-of-month, hours, minutes, seconds, milliseconds.
-     * @returns {Object} An object like `{year, month, day, hour, minute, second, millisecond}`
-     */
-    toObject() {
-        return {
-            year: this.year,
-            month: this.month,
-            day: this.day,
-            hour: this.hour,
-            minute: this.minute,
-            second: this.second,
-            millisecond: this.millisecond
-        };
-    }
-    /** Returns the number of milliseconds since the Unix Epoch (January 1, 1970 UTC)  */
-    getTime() {
-        return this.isValid() ? this._date.getTime() : NaN;
-    }
-    /** Alias of {@link IntlDate.getTime}  */
-    valueOf() {
-        return this.getTime();
-    }
-    /** Returns the timezone string name  */
-    zoneName() {
-        return this.format('zzz');
-    }
-    /** Returns the timezone GMT offset as a string  */
-    zone() {
-        if (!this.isValid())
-            return INVALID_DATE_STRING;
-        const zoneFormat = new Intl.DateTimeFormat(this.locale, { timeZoneName: 'longOffset' });
-        return zoneFormat.formatToParts(this._date).find((part) => part.type === 'timeZoneName').value;
-    }
-    /** Returns the difference in `minutes` between this date and UTC  */
-    utcOffset() {
-        return this._date.getTimezoneOffset();
-    }
-    /**
-     * Check if this date is before another date. The other value will be parsed as an `IntlDate` if not already so.
-     * @param {DateLike} other Another date or date like object
-     * @returns {boolean} Returns `true` if this date is before the given value
-     */
-    isBefore(other) {
-        if (other instanceof IntlDate) {
-            return this.getTime() < other.getTime();
-        }
-        return this.getTime() < new IntlDate(other).getTime();
-    }
-    /**
-     * Check if this date is strictly after the given `start` and before `stop` dates. The values will be parsed as an `IntlDate` if not already so.
-     * @param {DateLike} start The smaller date
-     * @param {DateLike} stop The larger date
-     * @returns {boolean} Returns `true` if this date is greater than `start` and less than `stop`.
-     */
-    isBetween(start, stop) {
-        return this.isAfter(start) && this.isBefore(stop);
-    }
-    /**
-     * Check if this date is after another date. The other value will be parsed as an `IntlDate` if not already so.
-     * @param {DateLike} other Another date or date like object
-     * @returns {boolean} Returns `true` if this date is after the given value
-     */
-    isAfter(other) {
-        if (other instanceof IntlDate) {
-            return this.getTime() > other.getTime();
-        }
-        return this.getTime() > new IntlDate(other).getTime();
-    }
-    /**
-     * Check if this date is the same as `other`.
-     * @param other Another date object
-     * @returns {boolean} Returns `true` if this date is the same as other
-     */
-    isSame(other) {
-        if (other instanceof IntlDate) {
-            return (this.isValid() &&
-                other.isValid() &&
-                this.getTime() === other.getTime() &&
-                this.locale === other.locale);
-        }
-        return this.getTime() === other.getTime();
-    }
-    lt(other) {
-        return this.isBefore(other);
-    }
-    eq(other) {
-        return this.isSame(other);
-    }
-    compare(other) {
-        if (!this.isValid())
-            return 1;
-        const dt = new IntlDate(other);
-        if (!dt.isValid())
-            return -1;
-        return this.getTime() - dt.getTime();
-    }
-    set(values) {
-        if (!this.isValid())
-            return this;
-        const normalized = normalizeObject(values, normalizeUnit);
-        const mixed = { ...this.toObject(), ...normalized };
-        // if we didn't set the day but we ended up on an overflow date,
-        // use the last day of the right month
-        if (normalized.day === undefined) {
-            const target = new Date(this._date);
-            target.setFullYear(mixed.year, mixed.month - 1, 1);
-            mixed.day = Math.min(daysInMonth(target), mixed.day);
-        }
-        const result = this.clone(mixed);
-        return normalized.weekday === undefined
-            ? result
-            : result.add({ days: normalized.weekday - result.dayOfWeek });
-    }
-    get relativeFormat() {
-        if (this.intlRelativeFormat)
-            return this.intlRelativeFormat;
-        this.intlRelativeFormat = new Intl.RelativeTimeFormat(this.locale);
-        return new Intl.RelativeTimeFormat(this.locale);
-    }
-    relativeTime(n, unit = 'seconds') {
-        return Number.isNaN(n) ? INVALID_DATE_STRING : this.relativeFormat.format(n, unit);
-    }
-    fromNow(unit = 'seconds') {
-        const diff = this.diff(new Date(), unit);
-        return this.relativeTime(diff, unit);
-    }
-    from(other, unit = 'seconds') {
-        const diff = this.diff(other, unit);
-        return this.relativeTime(diff, unit);
-    }
-    toNow(unit = 'seconds') {
-        const diff = this.diff(new Date(), unit);
-        return this.relativeTime(-diff, unit);
-    }
-    to(other, unit = 'seconds') {
-        const diff = this.diff(other, unit);
-        return this.relativeTime(-diff, unit);
-    }
-    diff(other, unit = 'milliseconds', exact = false) {
-        const dt = new IntlDate(other);
-        const normalizedUnit = UNITS_PLURAL[unit.toLowerCase()];
-        const monthsInUnit = MONTHS_IN_UNIT[normalizedUnit];
-        if (monthsInUnit && !exact) {
-            // whole months are the ones `add` can take from `other` without passing this date
-            let months = (this.year - dt.year) * 12 + this.month - dt.month;
-            const sign = Math.sign(this.getTime() - dt.getTime());
-            if (sign * (dt.add({ months }).getTime() - this.getTime()) > 0)
-                months -= sign;
-            return Math.trunc(months / monthsInUnit);
-        }
-        let elapsed = this.getTime() - dt.getTime();
-        if (normalizedUnit === 'days' || normalizedUnit === 'weeks') {
-            // a calendar day can last 23 or 25 hours, so measure it on the wall clock
-            elapsed += (dt._date.getTimezoneOffset() - this._date.getTimezoneOffset()) * 6e4;
-        }
-        const dur = new Duration(elapsed, exact);
-        let total = dur.total(unit);
-        if (!exact)
-            total = Math.trunc(total);
-        return total;
-    }
-    add(duration, exact = false) {
-        return this.clone(addDuration(this._date, duration, exact));
-    }
-    subtract(duration, exact = false) {
-        return this.clone(subDuration(this._date, duration, exact));
-    }
-    startOf(unit) {
-        if (!this.isValid())
-            return this;
-        const obj = {};
-        const normalizedUnit = UNITS_PLURAL[unit.toLowerCase()];
-        switch (normalizedUnit) {
-            case 'years':
-                obj.month = 1;
-            // falls through
-            case 'quarters':
-            case 'months':
-                obj.day = 1;
-            // falls through
-            case 'weeks':
-            case 'days':
-                obj.hour = 0;
-            // falls through
-            case 'hours':
-                obj.minute = 0;
-            // falls through
-            case 'minutes':
-                obj.second = 0;
-            // falls through
-            case 'seconds':
-                obj.millisecond = 0;
-                break;
-            case 'milliseconds':
-                break;
-            // no default, an unknown unit changes nothing
-        }
-        if (normalizedUnit === 'weeks') {
-            return this.subtract({ days: this.dayOfWeek - 1 }).startOf('days');
-        }
-        if (normalizedUnit === 'quarters') {
-            const q = Math.ceil(this.month / 3);
-            obj.month = (q - 1) * 3 + 1;
-        }
-        const start = this.set(obj);
-        if (obj.hour !== undefined)
-            return start;
-        // Date reads a repeated wall clock as its first pass, this date may be on the second
-        const offset = this._date.getTimezoneOffset();
-        const kept = new Date(start.getTime() + (offset - start._date.getTimezoneOffset()) * 6e4);
-        return kept.getTimezoneOffset() === offset ? this.clone(kept) : start;
-    }
-    endOf(unit) {
-        return this.isValid()
-            ? this.add({ [unit]: 1 })
-                .startOf(unit)
-                .subtract({ milliseconds: 1 })
-            : this;
-    }
-    clone(date) {
-        return new IntlDate(date ?? this, { locale: this.locale });
-    }
-    static max(...args) {
-        return maxDate.apply(undefined, args);
-    }
-    static min(...args) {
-        return minDate.apply(undefined, args);
-    }
-    inspect() {
-        return this.isValid() ? `new IntlDate("${this.toISOString()}")` : 'new IntlDate(NaN)';
-    }
-}
-/**
- * Add the specified years, months, weeks, days, hours, minutes and seconds to the given date
- * @param date
- * @param duration
- * @param exact Kept for callers that pass it, it no longer changes the result.
- * @returns
- */
-export function addDuration(date, duration, exact = false) {
-    const newDate = asDate(date);
-    const { values } = new Duration(duration, exact);
-    const { years = 0, quarters = 0, months = 0, weeks = 0, days = 0 } = values;
-    // largest unit first and all the months in one step, so a clamped day cannot carry over
-    setDateUnit(newDate, 'months', Math.trunc(years * 12 + quarters * 3 + Number(months)));
-    setDateUnit(newDate, 'days', Math.trunc(weeks * 7 + Number(days)));
-    for (const unit of ['hours', 'minutes', 'seconds', 'milliseconds']) {
-        setDateUnit(newDate, unit, Number(values[unit] ?? 0));
-    }
-    return newDate;
-}
-function addMonths(date, months) {
-    const target = new Date(date);
-    target.setFullYear(date.getFullYear(), date.getMonth() + months, 1);
-    const day = Math.min(date.getDate(), daysInMonth(target));
-    date.setFullYear(target.getFullYear(), target.getMonth(), day);
-}
-function setDateUnit(date, unit, value) {
-    // writing a date field again would move a repeated hour to its first pass
-    if (value === 0)
-        return date;
-    switch (unit) {
-        case 'months':
-            addMonths(date, value);
-            break;
-        case 'days':
-            date.setDate(date.getDate() + value);
-            break;
-        case 'hours':
-            date.setTime(date.getTime() + value * 36e5);
-            break;
-        case 'minutes':
-            date.setTime(date.getTime() + value * 6e4);
-            break;
-        case 'seconds':
-            date.setTime(date.getTime() + value * 1e3);
-            break;
-        case 'milliseconds':
-            date.setTime(date.getTime() + value);
-            break;
-        default:
-            break;
-    }
-    return date;
-}
-/**
- * Subtract the specified years, months, weeks, days, hours, minutes and seconds from the given date.
- * @param date
- * @param duration
- * @param exact Kept for callers that pass it, it no longer changes the result.
- * @returns
- */
-export function subDuration(date, duration, exact = false) {
-    return addDuration(date, new Duration(duration, exact).negated(), exact);
-}
-const MONTHS_IN_UNIT = { years: 12, quarters: 3, months: 1 };
-const UNITS_SINGULAR = {
-    year: 'year',
-    years: 'year',
-    month: 'month',
-    months: 'month',
-    day: 'day',
-    days: 'day',
-    hour: 'hour',
-    hours: 'hour',
-    minute: 'minute',
-    minutes: 'minute',
-    quarter: 'quarter',
-    quarters: 'quarter',
-    second: 'second',
-    seconds: 'second',
-    millisecond: 'millisecond',
-    milliseconds: 'millisecond',
-    weekday: 'weekday',
-    weekdays: 'weekday',
-    weeknumber: 'weekNumber',
-    weeksnumber: 'weekNumber',
-    weeknumbers: 'weekNumber',
-    weekyear: 'weekYear',
-    weekyears: 'weekYear',
-    ordinal: 'ordinal'
-};
-function normalizeUnit(unit) {
-    const normalized = UNITS_SINGULAR[unit.toLowerCase()];
-    if (!normalized)
-        throw new ValueError(`Invalid unit ${unit}`);
-    return normalized;
-}
-function normalizeObject(obj, normalizer) {
-    const normalized = {};
-    for (const key of Object.keys(obj)) {
-        const value = obj[key];
-        if (value == null)
-            continue;
-        normalized[normalizer(key)] = asNumber(value);
-    }
-    return normalized;
-}

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

@@ -1,64 +0,0 @@
-export interface DateObject {
-    year?: number;
-    month?: number;
-    day?: number;
-    weekday?: number;
-    hour?: number;
-    minute?: number;
-    second?: number;
-    millisecond?: number;
-}
-/**
- * Returns the minimum (most distant past) of the given date values.
- * @template T
- * @param {Array<T>} dates
- * @returns {T} The smallest date of `dates`
- */
-export declare function minDate<T>(dates: Array<T>): T;
-/**
- * Returns the maximum (most distant future) of the given date values.
- * @template T
- * @param {Array<T>} dates
- * @returns {T} The largest date of `dates`
- */
-export declare function maxDate<T>(dates: Array<T>): T;
-/**
- * Returns `true` if the year is a leap year, otherwise `false`.
- * @param year The date year
- * @returns {boolean} `true` if is a leap year
- */
-export declare function isLeapYear(year: number): boolean;
-/**
- * Get the number of days in the given year.
- * @param year The date year
- * @returns {number} Number of days in year
- */
-export declare function daysInYear(year: number): number;
-/**
- * Get the number of days in the given date's month and year.
- * @param date The specified date
- * @returns {number} Number of days in month
- */
-export declare function daysInMonth(date: string | number | Date): number;
-export declare function asNumber(value: any): number;
-export declare function parseISODuration(s: any): any;
-/**
- * Returns the number of weeks in the specified year.
- * @param year
- * @param firstDayOfWeek
- * @param firstDayOfYear
- */
-export declare function weeksInYear(year: number, firstDayOfWeek?: number, firstDayOfYear?: number): number;
-/**
- * Returns the week of the year for the specified date
- * @param date The date value
- * @param firstDayOfWeek The weekday a week starts on, where Sunday is 0
- * @param firstDayOfYear Picks week 1: the week holding January `7 + firstDayOfWeek - firstDayOfYear`, so `1, 4` gives ISO weeks
- * @returns The week and the year that week belongs to
- */
-export declare function weekOfYear(date: string | number | Date, firstDayOfWeek?: number, firstDayOfYear?: number): {
-    week: any;
-    year: any;
-};
-export declare function isoWeeksInYear(year: number): number;
-export declare function dayOfYear(input: string | number | Date): number;