@fr0st/datetime 5.0.0

package/src/prototype/utility.js

@@ -0,0 +1,346 @@
+import DateTime from './../date-time.js';
+import { getRelativeFormatter } from './../factory.js';
+import { compensateDiff, getBiggestDiff } from './../helpers.js';
+import { formatDay, formatDayPeriod, formatEra, formatMonth, formatOffset, formatTimeZoneName } from './../formatter/format.js';
+import { minimumDays } from './../formatter/utility.js';
+import { daysInMonth as _daysInMonth, daysInYear as _daysInYear, isLeapYear as _isLeapYear } from './../static/utility.js';
+
+/**
+ * DateTime Utility
+ */
+
+/**
+ * Get the name of the day of the week in current timeZone.
+ * @param {string} [type=long] The type of day name to return.
+ * @return {string} The name of the day of the week.
+ */
+export function dayName(type = 'long') {
+    return formatDay(this.getLocale(), this.getDay(), type);
+};
+
+/**
+ * Get the day period in current timeZone.
+ * @param {string} [type=long] The type of day period to return.
+ * @return {string} The day period.
+ */
+export function dayPeriod(type = 'long') {
+    return formatDayPeriod(
+        this.getLocale(),
+        this.getHours() < 12 ?
+            0 :
+            1,
+        type,
+    );
+};
+
+/**
+ * Get the number of days in the current month.
+ * @return {number} The number of days in the current month.
+ */
+export function daysInMonth() {
+    return _daysInMonth(
+        this.getYear(),
+        this.getMonth(),
+    );
+};
+
+/**
+ * Get the number of days in the current year.
+ * @return {number} The number of days in the current year.
+ */
+export function daysInYear() {
+    return _daysInYear(
+        this.getYear(),
+    );
+};
+
+/**
+ * Get the difference between this and another Date.
+ * @param {DateTime} [other] The date to compare to.
+ * @param {string} [timeUnit] The unit of time.
+ * @param {Boolean} [relative=true] Whether to use the relative difference.
+ * @return {number} The difference.
+ */
+export function diff(other, timeUnit, relative = true) {
+    if (!other) {
+        other = new this.constructor;
+    }
+
+    if (!timeUnit) {
+        return this - other;
+    }
+
+    if (timeUnit) {
+        timeUnit = timeUnit.toLowerCase();
+    }
+
+    other = other.setTimeZone(this.getTimeZone());
+
+    switch (timeUnit) {
+        case 'year':
+        case 'years':
+            const yearDiff = this.getYear() - other.getYear();
+            return compensateDiff(
+                this,
+                other.setYear(
+                    this.getYear(),
+                ),
+                yearDiff,
+                !relative,
+                -1,
+            );
+        case 'month':
+        case 'months':
+            const monthDiff = (this.getYear() - other.getYear()) *
+                12 +
+                this.getMonth() -
+                other.getMonth();
+            return compensateDiff(
+                this,
+                other.setYear(
+                    this.getYear(),
+                    this.getMonth(),
+                ),
+                monthDiff,
+                !relative,
+                -1,
+            );
+        case 'week':
+        case 'weeks':
+            const weekDiff = (this - other) / 604800000;
+            return compensateDiff(
+                this,
+                other.setWeekYear(
+                    this.getWeekYear(),
+                    this.getWeek(),
+                ),
+                weekDiff,
+                relative,
+            );
+        case 'day':
+        case 'days':
+            const dayDiff = (this - other) / 86400000;
+            return compensateDiff(
+                this,
+                other.setYear(
+                    this.getYear(),
+                    this.getMonth(),
+                    this.getDate(),
+                ),
+                dayDiff,
+                relative,
+            );
+        case 'hour':
+        case 'hours':
+            const hourDiff = (this - other) / 3600000;
+            return compensateDiff(
+                this,
+                other.setYear(
+                    this.getYear(),
+                    this.getMonth(),
+                    this.getDate(),
+                ).setHours(
+                    this.getHours(),
+                ),
+                hourDiff,
+                relative,
+            );
+        case 'minute':
+        case 'minutes':
+            const minuteDiff = (this - other) / 60000;
+            return compensateDiff(
+                this,
+                other.setYear(
+                    this.getYear(),
+                    this.getMonth(),
+                    this.getDate(),
+                ).setHours(
+                    this.getHours(),
+                    this.getMinutes(),
+                ),
+                minuteDiff,
+                relative,
+            );
+        case 'second':
+        case 'seconds':
+            const secondDiff = (this - other) / 1000;
+            return compensateDiff(
+                this,
+                other.setYear(
+                    this.getYear(),
+                    this.getMonth(),
+                    this.getDate(),
+                ).setHours(
+                    this.getHours(),
+                    this.getMinutes(),
+                    this.getSeconds(),
+                ),
+                secondDiff,
+                relative,
+            );
+        default:
+            throw new Error('Invalid time unit supplied');
+    }
+};
+
+/**
+ * Get the era in current timeZone.
+ * @param {string} [type=long] The type of era to return.
+ * @return {string} The era.
+ */
+export function era(type = 'long') {
+    return formatEra(
+        this.getLocale(),
+        this.getYear() < 0 ?
+            0 :
+            1,
+        type,
+    );
+};
+
+/**
+ * Get the difference between this and another Date in human readable form.
+ * @param {DateTime} [other] The date to compare to.
+ * @param {string} [timeUnit] The unit of time.
+ * @return {string} The difference in human readable form.
+ */
+export function humanDiff(other, timeUnit) {
+    const relativeFormatter = getRelativeFormatter(this.getLocale());
+
+    if (!relativeFormatter) {
+        throw new Error('RelativeTimeFormat not supported');
+    }
+
+    if (!other) {
+        other = new this.constructor;
+    }
+
+    let amount;
+    if (timeUnit) {
+        amount = this.diff(other, timeUnit);
+    } else {
+        [amount, timeUnit] = getBiggestDiff(this, other);
+    }
+
+    return relativeFormatter.format(amount, timeUnit);
+};
+
+/**
+ * Determine whether this DateTime is after another date (optionally to a granularity).
+ * @param {DateTime} [other] The date to compare to.
+ * @param {string} [granularity] The level of granularity to use for comparison.
+ * @return {Boolean} TRUE if this DateTime is after the other date, otherwise FALSE.
+ */
+export function isAfter(other, granularity) {
+    return this.diff(other, granularity) > 0;
+};
+
+/**
+ * Determine whether this DateTime is before another date (optionally to a granularity).
+ * @param {DateTime} [other] The date to compare to.
+ * @param {string} [granularity] The level of granularity to use for comparison.
+ * @return {Boolean} TRUE if this DateTime is before the other date, otherwise FALSE.
+ */
+export function isBefore(other, granularity) {
+    return this.diff(other, granularity) < 0;
+};
+
+/**
+ * Determine whether this DateTime is between two other dates (optionally to a granularity).
+ * @param {DateTime} [start] The first date to compare to.
+ * @param {DateTime} [end] The second date to compare to.
+ * @param {string} [granularity] The level of granularity to use for comparison.
+ * @return {Boolean} TRUE if this DateTime is between the other dates, otherwise FALSE.
+ */
+export function isBetween(start, end, granularity) {
+    return this.diff(start, granularity) > 0 && this.diff(end, granularity) < 0;
+};
+
+/**
+ * Return true if the DateTime is in daylight savings.
+ * @return {Boolean} TRUE if the current time is in daylight savings, otherwise FALSE.
+ */
+export function isDST() {
+    if (!this.isDynamicTimeZone()) {
+        return false;
+    }
+
+    const year = this.getYear();
+    const dateA = DateTime.fromArray([year, 1, 1], {
+        timeZone: this.getTimeZone(),
+    });
+    const dateB = DateTime.fromArray([year, 6, 1], {
+        timeZone: this.getTimeZone(),
+    });
+
+    return this.getTimeZoneOffset() < Math.max(dateA.getTimeZoneOffset(), dateB.getTimeZoneOffset());
+};
+
+/**
+ * Return true if the year is a leap year.
+ * @return {Boolean} TRUE if the current year is a leap year, otherwise FALSE.
+ */
+export function isLeapYear() {
+    return _isLeapYear(
+        this.getYear(),
+    );
+};
+
+/**
+ * Determine whether this DateTime is the same as another date (optionally to a granularity).
+ * @param {DateTime} [other] The date to compare to.
+ * @param {string} [granularity] The level of granularity to use for comparison.
+ * @return {Boolean} TRUE if this DateTime is the same as the other date, otherwise FALSE.
+ */
+export function isSame(other, granularity) {
+    return this.diff(other, granularity) === 0;
+};
+
+/**
+ * Determine whether this DateTime is the same or after another date (optionally to a granularity).
+ * @param {DateTime} [other] The date to compare to.
+ * @param {string} [granularity] The level of granularity to use for comparison.
+ * @return {Boolean} TRUE if this DateTime is the same or after the other date, otherwise FALSE.
+ */
+export function isSameOrAfter(other, granularity) {
+    return this.diff(other, granularity) >= 0;
+};
+
+/**
+ * Determine whether this DateTime is the same or before another date.
+ * @param {DateTime} other The date to compare to.
+ * @param {string} [granularity] The level of granularity to use for comparison.
+ * @return {Boolean} TRUE if this DateTime is the same or before the other date, otherwise FALSE.
+ */
+export function isSameOrBefore(other, granularity) {
+    return this.diff(other, granularity) <= 0;
+};
+
+/**
+ * Get the name of the month in current timeZone.
+ * @param {string} [type=long] The type of month name to return.
+ * @return {string} The name of the month.
+ */
+export function monthName(type = 'long') {
+    return formatMonth(this.getLocale(), this.getMonth(), type);
+};
+
+/**
+ * Get the name of the current timeZone.
+ * @param {string} [type=long] The formatting type.
+ * @return {string} The name of the time zone.
+ */
+export function timeZoneName(type = 'long') {
+    return this.isDynamicTimeZone() ?
+        formatTimeZoneName(this.getLocale(), this.getTime(), this.getTimeZone(), type) :
+        'GMT' + formatOffset(this.getTimeZoneOffset(), true, type === 'short');
+};
+
+/**
+ * Get the number of weeks in the current year.
+ * @return {number} The number of weeks in the current year.
+ */
+export function weeksInYear() {
+    const minDays = minimumDays(this.getLocale());
+    return this.setMonth(12, 24 + minDays).getWeek();
+};

package/src/static/create.js

@@ -0,0 +1,222 @@
+import DateTime from './../date-time.js';
+import { parseCompare, parseFactory } from './../helpers.js';
+import { config, formats, formatTokenRegExp, parseOrderKeys } from './../vars.js';
+import tokens from './../formatter/tokens.js';
+
+/**
+ * DateTime (Static) Creation
+ */
+
+/**
+ * Create a new DateTime from an array.
+ * @param {number[]} dateArray The date to parse.
+ * @param {object} [options] Options for the new DateTime.
+ * @param {string} [options.timeZone] The timeZone to use.
+ * @param {string} [options.locale] The locale to use.
+ * @return {DateTime} A new DateTime object.
+ */
+export function fromArray(dateArray, options = {}) {
+    const dateValues = dateArray.slice(0, 3);
+    const timeValues = dateArray.slice(3);
+
+    if (dateValues.length < 3) {
+        dateValues.push(...new Array(3 - dateValues.length).fill(1));
+    }
+
+    if (timeValues.length < 4) {
+        timeValues.push(...new Array(4 - timeValues.length).fill(0));
+    }
+
+    return new DateTime(null, options)
+        .setTimestamp(0)
+        .setYear(...dateValues)
+        .setHours(...timeValues);
+};
+
+/**
+ * Create a new DateTime from a Date.
+ * @param {Date} date The date.
+ * @param {object} [options] Options for the new DateTime.
+ * @param {string} [options.timeZone] The timeZone to use.
+ * @param {string} [options.locale] The locale to use.
+ * @return {DateTime} A new DateTime object.
+ */
+export function fromDate(date, options = {}) {
+    return new DateTime(date.getTime(), options);
+};
+
+/**
+ * Create a new DateTime from a format string.
+ * @param {string} formatString The format string.
+ * @param {string} dateString The date string.
+ * @param {object} [options] Options for the new DateTime.
+ * @param {string} [options.timeZone] The timeZone to use.
+ * @param {string} [options.locale] The locale to use.
+ * @return {DateTime} A new DateTime object.
+ */
+export function fromFormat(formatString, dateString, options = {}) {
+    if (!('locale' in options)) {
+        options.locale = config.defaultLocale;
+    }
+
+    const values = [];
+
+    let match;
+    while (formatString && (match = formatString.match(formatTokenRegExp))) {
+        const token = match[1];
+        const position = match.index;
+        const length = match[0].length;
+
+        if (position) {
+            const formatTest = formatString.substring(0, position);
+            parseCompare(formatTest, dateString);
+        }
+
+        formatString = formatString.substring(position + length);
+        dateString = dateString.substring(position);
+
+        if (!token) {
+            const literal = match[0].slice(1, -1);
+            parseCompare(literal || `'`, dateString);
+            dateString = dateString.substring(literal.length);
+            continue;
+        }
+
+        if (!(token in tokens)) {
+            throw new Error(`Invalid token in DateTime format: ${token}`);
+        }
+
+        const regExp = tokens[token].regex(options.locale, length);
+        const matchedValue = dateString.match(new RegExp(`^${regExp}`));
+
+        if (!matchedValue) {
+            throw new Error(`Unmatched token in DateTime string: ${token}`);
+        }
+
+        const literal = matchedValue[0];
+        const value = tokens[token].input(options.locale, literal, length);
+
+        if (value !== null) {
+            const key = tokens[token].key;
+            values.push({ key, value, literal, token, length });
+        }
+
+        dateString = dateString.substring(literal.length);
+    }
+
+    if (formatString) {
+        parseCompare(formatString, dateString);
+    }
+
+    if (!('timeZone' in options)) {
+        options.timeZone = config.defaultTimeZone;
+    }
+
+    let timeZone = options.timeZone;
+    for (const { key, value } of values) {
+        if (key !== 'timeZone') {
+            continue;
+        }
+
+        timeZone = value;
+    }
+
+    let datetime = this.fromTimestamp(0, {
+        locale: options.locale,
+    }).setYear(1).setTimeZone(timeZone);
+
+    const methods = parseFactory();
+
+    const testValues = [];
+
+    for (const subKeys of parseOrderKeys) {
+        for (const subKey of subKeys) {
+            if (subKey === 'era' && !values.find((data) => data.key === 'year')) {
+                continue;
+            }
+
+            for (const data of values) {
+                const { key, value, literal, token, length } = data;
+
+                if (key !== subKey) {
+                    continue;
+                }
+
+                // skip narrow month and day names if output already matches
+                if (length === 5 && ['M', 'L', 'E', 'e', 'c'].includes(token)) {
+                    const fullToken = token.repeat(length);
+                    if (datetime.format(fullToken) === literal) {
+                        continue;
+                    }
+                }
+
+                datetime = methods[key].set(datetime, value);
+                testValues.push(data);
+            }
+        }
+    }
+
+    let isValid = true;
+    for (const { key, value } of testValues) {
+        if (key in methods && methods[key].get(datetime) !== value) {
+            isValid = false;
+            break;
+        }
+    }
+
+    if (options.timeZone !== timeZone) {
+        datetime = datetime.setTimeZone(options.timeZone);
+    }
+
+    datetime.isValid = isValid;
+
+    return datetime;
+};
+
+/**
+ * Create a new DateTime from an ISO format string.
+ * @param {string} dateString The date string.
+ * @param {object} [options] Options for the new DateTime.
+ * @param {string} [options.timeZone] The timeZone to use.
+ * @param {string} [options.locale] The locale to use.
+ * @return {DateTime} A new DateTime object.
+ */
+export function fromISOString(dateString, options = {}) {
+    let date = this.fromFormat(formats.rfc3339_extended, dateString, {
+        locale: 'en',
+    });
+
+    if ('timeZone' in options) {
+        date = date.setTimeZone(options.timeZone);
+    }
+
+    if ('locale' in options) {
+        date = date.setLocale(options.locale);
+    }
+
+    return date;
+};
+
+/**
+ * Create a new DateTime from a timestamp.
+ * @param {number} timestamp The timestamp.
+ * @param {object} [options] Options for the new DateTime.
+ * @param {string} [options.timeZone] The timeZone to use.
+ * @param {string} [options.locale] The locale to use.
+ * @return {DateTime} A new DateTime object.
+ */
+export function fromTimestamp(timestamp, options = {}) {
+    return new DateTime(null, options)
+        .setTimestamp(timestamp);
+};
+
+/**
+ * Create a new DateTime for the current time.
+ * @param {object} [options] Options for the new DateTime.
+ * @param {string} [options.timeZone] The timeZone to use.
+ * @param {string} [options.locale] The locale to use.
+ * @return {DateTime} A new DateTime object.
+ */
+export function now(options = {}) {
+    return new DateTime(null, options);
+};

package/src/static/utility.js

@@ -0,0 +1,103 @@
+import { config, monthDays } from './../vars.js';
+
+/**
+ * DateTime (Static) Utility
+ */
+
+/**
+ * Get the day of the year for a year, month and date.
+ * @param {number} year The year.
+ * @param {number} month The month. (1, 12)
+ * @param {number} date The date.
+ * @return {number} The day of the year. (1, 366)
+ */
+export function dayOfYear(year, month, date) {
+    return new Array(month - 1)
+        .fill()
+        .reduce(
+            (d, _, i) =>
+                d + daysInMonth(year, i + 1),
+            date,
+        );
+};
+
+/**
+ * Get the number of days in a month, from a year and month.
+ * @param {number} year The year.
+ * @param {number} month The month. (1, 12)
+ * @return {number} The number of days in the month.
+ */
+export function daysInMonth(year, month) {
+    const date = new Date(Date.UTC(year, month - 1));
+    month = date.getUTCMonth();
+
+    return monthDays[month] +
+        (
+            month == 1 && isLeapYear(
+                date.getUTCFullYear(),
+            ) ?
+                1 :
+                0
+        );
+};
+
+/**
+ * Get the number of days in a year.
+ * @param {number} year The year.
+ * @return {number} The number of days in the year.
+ */
+export function daysInYear(year) {
+    return !isLeapYear(year) ?
+        365 :
+        366;
+};
+
+/**
+ * Get the default locale.
+ * @return {string} The locale.
+ */
+export function getDefaultLocale() {
+    return config.defaultLocale;
+};
+
+/**
+ * Get the default timeZone.
+ * @return {string} The name of the timeZone.
+ */
+export function getDefaultTimeZone() {
+    return config.defaultTimeZone;
+};
+
+/**
+ * Return true if a year is a leap year.
+ * @param {number} year The year.
+ * @return {Boolean} TRUE if the year is a leap year, otherwise FALSE.
+ */
+export function isLeapYear(year) {
+    return new Date(year, 1, 29)
+        .getDate() === 29;
+};
+
+/**
+ * Set whether dates will be clamped when changing months.
+ * @param {Boolean} clampDates Whether to clamp dates.
+ */
+export function setDateClamping(clampDates) {
+    config.clampDates = clampDates;
+};
+
+/**
+ * Set the default locale.
+ * @param {string} locale The locale.
+ */
+export function setDefaultLocale(locale) {
+    config.defaultLocale = locale;
+};
+
+/**
+ * Set the default timeZone.
+ * @param {string} timeZone The name of the timeZone.
+ */
+export function setDefaultTimeZone(timeZone) {
+    config.defaultTimeZone = timeZone;
+};

package/src/vars.js

@@ -0,0 +1,46 @@
+/**
+ * DateTime Variables
+ */
+
+const resolvedOptions = (new Intl.DateTimeFormat).resolvedOptions();
+
+export const config = {
+    clampDates: true,
+    defaultLocale: resolvedOptions.locale,
+    defaultTimeZone: resolvedOptions.timeZone,
+};
+
+export const dateStringTimeZoneRegExp = /\s(?:UTC|GMT|Z|[\+\-]\d)|\d{4}\-\d{2}\-\d{2}T\d{2}\:\d{2}\:\d{2}\.\d{3}[\+\-]\d{2}\:\d{2}/i;
+
+export const formats = {
+    date: 'eee MMM dd yyyy',
+    rfc3339_extended: `yyyy-MM-dd'T'HH:mm:ss.SSSxxx`,
+    string: 'eee MMM dd yyyy HH:mm:ss xx (VV)',
+    time: 'HH:mm:ss xx (VV)',
+};
+
+export const formatTokenRegExp = /([a-z])\1*|'[^']*'/i;
+
+export const monthDays = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+
+export const offsetRegExp = /(?:GMT)?([\+\-])(\d{2})(\:?)(\d{2})?/;
+
+export const parseOrderKeys = [
+    ['year', 'weekYear'],
+    ['era'],
+    ['quarter', 'month', 'week', 'dayOfYear'],
+    ['weekOfMonth'],
+    ['date', 'weekDay'],
+    ['weekDayInMonth'],
+    ['hours24', 'hours12', 'dayPeriod'],
+    ['minutes', 'seconds', 'milliseconds'],
+];
+
+export const thresholds = {
+    month: 12,
+    week: null,
+    day: 7,
+    hour: 24,
+    minute: 60,
+    second: 60,
+};