@fr0st/datetime 5.0.0

package/src/formatter/utility.js

@@ -0,0 +1,96 @@
+import { minDaysInFirstWeek, weekStart } from './locales.js';
+import { getData } from './../factory.js';
+
+/**
+ * Get the formatting type from the component token length.
+ * @param {number} length The component token length.
+ * @return {string} The formatting type.
+ */
+export function getType(length) {
+    switch (length) {
+        case 5:
+            return 'narrow';
+        case 4:
+            return 'long';
+        default:
+            return 'short';
+    }
+};
+
+/**
+ * Get the minimum days.
+ * @param {string} locale The locale.
+ * @return {number} The minimum days.
+ */
+export function minimumDays(locale) {
+    return getData(
+        `minimumDays.${locale}`,
+        (_) => {
+            let minDays = 1;
+            const localeTest = locale.toLowerCase().split('-');
+            while (minDays === 1 && localeTest.length) {
+                for (const days in minDaysInFirstWeek) {
+                    if (!{}.hasOwnProperty.call(minDaysInFirstWeek, days)) {
+                        continue;
+                    }
+
+                    const locales = minDaysInFirstWeek[days];
+
+                    if (locales.includes(localeTest.join('-'))) {
+                        minDays = parseInt(days);
+                        break;
+                    }
+                }
+
+                localeTest.pop();
+            }
+
+            return minDays;
+        },
+    );
+};
+
+/**
+ * Get the week start offset for a locale.
+ * @param {string} [locale] The locale to load.
+ * @return {number} The week start offset.
+ */
+function weekStartOffset(locale) {
+    return getData(
+        `weekStartOffset.${locale}`,
+        (_) => {
+            let weekStarted;
+            const localeTest = locale.toLowerCase().split('-');
+            while (!weekStarted && localeTest.length) {
+                for (const start in weekStart) {
+                    if (!{}.hasOwnProperty.call(weekStart, start)) {
+                        continue;
+                    }
+
+                    const locales = weekStart[start];
+
+                    if (locales.includes(localeTest.join('-'))) {
+                        weekStarted = parseInt(start);
+                        break;
+                    }
+                }
+
+                localeTest.pop();
+            }
+
+            return weekStarted ?
+                weekStarted - 2 :
+                0;
+        },
+    );
+};
+
+/**
+ * Convert a day of the week to a local format.
+ * @param {string} locale The locale.
+ * @param {number} day The day of the week.
+ * @return {number} The local day of the week.
+ */
+export function weekDay(locale, day) {
+    return (7 + parseInt(day) - weekStartOffset(locale)) % 7 || 7;
+};

package/src/formatter/values.js

@@ -0,0 +1,142 @@
+import { getData, makeFormatter } from './../factory.js';
+
+/**
+ * DateFormatter Values
+ */
+
+/**
+ * Get cached day period values.
+ * @param {string} locale The locale.
+ * @param {string} [type=long] The formatting type.
+ * @return {array} The cached values.
+ */
+export function getDayPeriods(locale, type = 'long') {
+    return getData(
+        `periods.${locale}.${type}`,
+        (_) => {
+            const dayPeriodFormatter = makeFormatter(locale, { hour: 'numeric', hourCycle: 'h11' });
+            return new Array(2)
+                .fill()
+                .map((_, index) =>
+                    dayPeriodFormatter.formatToParts(Date.UTC(2018, 0, 1, index * 12))
+                        .find((part) => part.type === 'dayPeriod')
+                        .value,
+                );
+        },
+    );
+};
+
+/**
+ * Get cached day values.
+ * @param {string} locale The locale.
+ * @param {string} [type=long] The formatting type.
+ * @param {Boolean} [standalone=true] Whether the values are standalone.
+ * @return {array} The cached values.
+ */
+export function getDays(locale, type = 'long', standalone = true) {
+    return getData(
+        `days.${locale}.${type}.${standalone}`,
+        (_) => {
+            if (standalone) {
+                const dayFormatter = makeFormatter(locale, { weekday: type });
+                return new Array(7)
+                    .fill()
+                    .map((_, index) =>
+                        dayFormatter.format(Date.UTC(2018, 0, index)),
+                    );
+            }
+
+            const dayFormatter = makeFormatter(locale, { year: 'numeric', month: 'numeric', day: 'numeric', weekday: type });
+            return new Array(7)
+                .fill()
+                .map((_, index) =>
+                    dayFormatter.formatToParts(Date.UTC(2018, 0, index))
+                        .find((part) => part.type === 'weekday')
+                        .value,
+                );
+        },
+    );
+};
+
+/**
+ * Get cached era values.
+ * @param {string} locale The locale.
+ * @param {string} [type=long] The formatting type.
+ * @return {array} The cached values.
+ */
+export function getEras(locale, type = 'long') {
+    return getData(
+        `eras.${locale}.${type}`,
+        (_) => {
+            const eraFormatter = makeFormatter(locale, { era: type });
+            return new Array(2)
+                .fill()
+                .map((_, index) =>
+                    eraFormatter.formatToParts(Date.UTC(index - 1, 0, 1))
+                        .find((part) => part.type === 'era')
+                        .value,
+                );
+        },
+    );
+};
+
+/**
+ * Get cached month values.
+ * @param {string} locale The locale.
+ * @param {string} [type=long] The formatting type.
+ * @param {Boolean} [standalone=true] Whether the values are standalone.
+ * @return {array} The cached values.
+ */
+export function getMonths(locale, type = 'long', standalone = true) {
+    return getData(
+        `months.${locale}.${type}.${standalone}`,
+        (_) => {
+            if (standalone) {
+                const monthFormatter = makeFormatter(locale, { month: type });
+                return new Array(12)
+                    .fill()
+                    .map((_, index) =>
+                        monthFormatter.format(Date.UTC(2018, index, 1)),
+                    );
+            }
+
+            const monthFormatter = makeFormatter(locale, { year: 'numeric', month: type, day: 'numeric' });
+            return new Array(12)
+                .fill()
+                .map((_, index) =>
+                    monthFormatter.formatToParts(Date.UTC(2018, index, 1))
+                        .find((part) => part.type === 'month')
+                        .value,
+                );
+        },
+    );
+};
+
+/**
+ * Get cached number values.
+ * @param {string} locale The locale.
+ * @return {array} The cached values.
+ */
+export function getNumbers(locale) {
+    return getData(
+        `numbers.${locale}`,
+        (_) => {
+            const numberFormatter = makeFormatter(locale, { minute: 'numeric' });
+            return new Array(10)
+                .fill()
+                .map((_, index) =>
+                    numberFormatter.format(Date.UTC(2018, 0, 1, 0, index)),
+                );
+        },
+    );
+};
+
+/**
+ * Get the RegExp for the number values.
+ * @param {string} locale The locale.
+ * @return {string} The number values RegExp.
+ */
+export function numberRegExp(locale) {
+    const numbers = getNumbers(locale).join('|');
+    return `(?:${numbers})+`;
+};

package/src/helpers.js

@@ -0,0 +1,272 @@
+import { getDateFormatter } from './factory.js';
+import { thresholds } from './vars.js';
+
+/**
+ * DateTime Helpers
+ */
+
+/**
+ * Compensate the difference between two dates.
+ * @param {DateTime} date The DateTime.
+ * @param {DateTime} other The DateTime to compare to.
+ * @param {number} amount The amount to compensate.
+ * @param {Boolean} [compensate=true] Whether to compensate the amount.
+ * @param {number} [compensation=1] The compensation offset.
+ * @return {number} The compensated amount.
+ */
+export function compensateDiff(date, other, amount, compensate = true, compensation = 1) {
+    if (amount > 0) {
+        amount = Math.floor(amount);
+
+        if (compensate && date < other) {
+            amount += compensation;
+        }
+    } else if (amount < 0) {
+        amount = Math.ceil(amount);
+
+        if (compensate && date > other) {
+            amount -= compensation;
+        }
+    }
+
+    return amount;
+};
+
+/**
+ * Get the biggest difference between two dates.
+ * @param {DateTime} date The DateTime.
+ * @param {DateTime} [other] The DateTime to compare to.
+ * @return {array} The biggest difference (amount and time unit).
+ */
+export function getBiggestDiff(date, other) {
+    let lastResult;
+    for (const timeUnit of ['year', 'month', 'week', 'day', 'hour', 'minute', 'second']) {
+        const relativeDiff = date.diff(other, timeUnit);
+        if (lastResult && thresholds[timeUnit] && Math.abs(relativeDiff) >= thresholds[timeUnit]) {
+            return lastResult;
+        }
+
+        const actualDiff = date.diff(other, timeUnit, false);
+        if (actualDiff) {
+            return [relativeDiff, timeUnit];
+        }
+
+        if (relativeDiff) {
+            lastResult = [relativeDiff, timeUnit];
+        } else {
+            lastResult = null;
+        }
+    }
+
+    return lastResult ?
+        lastResult :
+        [0, 'second'];
+};
+
+/**
+ * Get the offset for a DateTime.
+ * @param {DateTime} date The DateTime.
+ * @return {number} The offset.
+ */
+export function getOffset(date) {
+    const timeZone = date.getTimeZone();
+
+    if (timeZone === 'UTC') {
+        return 0;
+    }
+
+    const utcString = getDateFormatter('UTC').format(date);
+    const localString = getDateFormatter(timeZone).format(date);
+
+    return (new Date(utcString) - new Date(localString)) / 60000;
+};
+
+/**
+ * Get the number of milliseconds since the UNIX epoch (offset to timeZone).
+ * @param {DateTime} date The DateTime.
+ * @return {number} The number of milliseconds since the UNIX epoch (offset to timeZone).
+ */
+export function getOffsetTime(date) {
+    return date.getTime() - (date.getTimeZoneOffset() * 60000);
+};
+
+/**
+ * Modify a DateTime by a duration.
+ * @param {DateTime} date The DateTime.
+ * @param {number} amount The amount to modify the date by.
+ * @param {string} [timeUnit] The unit of time.
+ * @return {DateTime} The DateTime object.
+ */
+export function modify(date, amount, timeUnit) {
+    timeUnit = timeUnit.toLowerCase();
+
+    switch (timeUnit) {
+        case 'second':
+        case 'seconds':
+            return date.setSeconds(
+                date.getSeconds() + amount,
+            );
+        case 'minute':
+        case 'minutes':
+            return date.setMinutes(
+                date.getMinutes() + amount,
+            );
+        case 'hour':
+        case 'hours':
+            return date.setHours(
+                date.getHours() + amount,
+            );
+        case 'week':
+        case 'weeks':
+            return date.setDate(
+                date.getDate() + (amount * 7),
+            );
+        case 'day':
+        case 'days':
+            return date.setDate(
+                date.getDate() + amount,
+            );
+        case 'month':
+        case 'months':
+            return date.setMonth(
+                date.getMonth() + amount,
+            );
+        case 'year':
+        case 'years':
+            return date.setYear(
+                date.getYear() + amount,
+            );
+        default:
+            throw new Error('Invalid time unit supplied');
+    }
+};
+
+/**
+ * Compare a literal format string with a date string.
+ * @param {string} formatString The literal format string.
+ * @param {string} dateString The date string.
+ */
+export function parseCompare(formatString, dateString) {
+    let i = 0;
+    for (const char of formatString) {
+        if (char !== dateString[i]) {
+            throw new Error(`Unmatched character in DateTime string: ${char}`);
+        }
+
+        i++;
+    }
+};
+
+/**
+ * Generate methods for parsing a date.
+ * @return {object} An object containing date parsing methods.
+ */
+export function parseFactory() {
+    let isPM = false;
+    let lastAM = true;
+
+    return {
+        date: {
+            get: (datetime) => datetime.getDate(),
+            set: (datetime, value) => datetime.setDate(value),
+        },
+        dayPeriod: {
+            get: (datetime) => datetime.getHours() < 12 ? 0 : 1,
+            set: (datetime, value) => {
+                isPM = value;
+                let hours = value ? 12 : 0;
+                if (lastAM) {
+                    hours += datetime.getHours();
+                }
+                return datetime.setHours(hours);
+            },
+        },
+        dayOfYear: {
+            get: (datetime) => datetime.getDayOfYear(),
+            set: (datetime, value) => datetime.setDayOfYear(value),
+        },
+        era: {
+            get: (datetime) => datetime.getYear() < 1 ? 0 : 1,
+            set: (datetime, value) => {
+                const offset = value ? 1 : -1;
+                return datetime.setYear(
+                    datetime.getYear() * offset,
+                );
+            },
+        },
+        hours12: {
+            get: (datetime) => datetime.getHours() % 12,
+            set: (datetime, value) => {
+                if (isPM) {
+                    value += 12;
+                }
+                lastAM = true;
+                return datetime.setHours(value);
+            },
+        },
+        hours24: {
+            get: (datetime) => datetime.getHours(),
+            set: (datetime, value) => {
+                lastAM = false;
+                return datetime.setHours(value);
+            },
+        },
+        milliseconds: {
+            get: (datetime) => datetime.getMilliseconds(),
+            set: (datetime, value) => datetime.setMilliseconds(value),
+        },
+        minutes: {
+            get: (datetime) => datetime.getMinutes(),
+            set: (datetime, value) => datetime.setMinutes(value),
+        },
+        month: {
+            get: (datetime) => datetime.getMonth(),
+            set: (datetime, value) => datetime.setMonth(value),
+        },
+        quarter: {
+            get: (datetime) => datetime.getQuarter(),
+            set: (datetime, value) => datetime.setQuarter(value),
+        },
+        seconds: {
+            get: (datetime) => datetime.getSeconds(),
+            set: (datetime, value) => datetime.setSeconds(value),
+        },
+        week: {
+            get: (datetime) => datetime.getWeek(),
+            set: (datetime, value) => datetime.setWeek(value),
+        },
+        weekDay: {
+            get: (datetime) => datetime.getWeekDay(),
+            set: (datetime, value) => datetime.setWeekDay(value),
+        },
+        weekDayInMonth: {
+            get: (datetime) => datetime.getWeekDayInMonth(),
+            set: (datetime, value) => datetime.setWeekDayInMonth(value),
+        },
+        weekOfMonth: {
+            get: (datetime) => datetime.getWeekOfMonth(),
+            set: (datetime, value) => datetime.setWeekOfMonth(value),
+        },
+        weekYear: {
+            get: (datetime) => datetime.getWeekYear(),
+            set: (datetime, value) => datetime.setWeekYear(value),
+        },
+        year: {
+            get: (datetime) => {
+                const year = datetime.getYear();
+                return Math.abs(year);
+            },
+            set: (datetime, value) => datetime.setYear(value),
+        },
+    };
+};
+
+/**
+ * Set the number of milliseconds since the UNIX epoch (offset to timeZone).
+ * @param {DateTime} date The DateTime.
+ * @param {number} time The number of milliseconds since the UNIX epoch (offset to timeZone).
+ * @return {DateTime} The DateTime object.
+ */
+export function setOffsetTime(date, time) {
+    return date.setTime(time + (date.getTimeZoneOffset() * 60000));
+};

package/src/index.js

@@ -0,0 +1,89 @@
+import DateTime from './date-time.js';
+import { fromArray, fromDate, fromFormat, fromISOString, fromTimestamp, now } from './static/create.js';
+import { dayOfYear, daysInMonth as _daysInMonth, daysInYear as _daysInYear, getDefaultLocale, getDefaultTimeZone, isLeapYear as _isLeapYear, setDateClamping, setDefaultLocale, setDefaultTimeZone } from './static/utility.js';
+import { getDate, getDay, getDayOfYear, getHours, getMilliseconds, getMinutes, getMonth, getQuarter, getSeconds, getTimestamp, getWeek, getWeekDay, getWeekDayInMonth, getWeekOfMonth, getWeekYear, getYear } from './prototype/attributes-get.js';
+import { setDate, setDay, setDayOfYear, setHours, setMilliseconds, setMinutes, setMonth, setQuarter, setSeconds, setTimestamp, setWeek, setWeekDay, setWeekDayInMonth, setWeekOfMonth, setWeekYear, setYear } from './prototype/attributes-set.js';
+import { add, endOf, startOf, sub } from './prototype/manipulate.js';
+import { format, toDateString, toISOString, toString, toTimeString, toUTCString } from './prototype/output.js';
+import { dayName, dayPeriod, daysInMonth, daysInYear, diff, era, humanDiff, isAfter, isBefore, isBetween, isDST, isLeapYear, isSame, isSameOrAfter, isSameOrBefore, monthName, timeZoneName, weeksInYear } from './prototype/utility.js';
+
+DateTime.dayOfYear = dayOfYear;
+DateTime.daysInMonth = _daysInMonth;
+DateTime.daysInYear = _daysInYear;
+DateTime.fromArray = fromArray;
+DateTime.fromDate = fromDate;
+DateTime.fromFormat = fromFormat;
+DateTime.fromISOString = fromISOString;
+DateTime.fromTimestamp = fromTimestamp;
+DateTime.getDefaultLocale = getDefaultLocale;
+DateTime.getDefaultTimeZone = getDefaultTimeZone;
+DateTime.isLeapYear = _isLeapYear;
+DateTime.now = now;
+DateTime.setDateClamping = setDateClamping;
+DateTime.setDefaultLocale = setDefaultLocale;
+DateTime.setDefaultTimeZone = setDefaultTimeZone;
+
+const proto = DateTime.prototype;
+
+proto.add = add;
+proto.dayName = dayName;
+proto.dayPeriod = dayPeriod;
+proto.daysInMonth = daysInMonth;
+proto.daysInYear = daysInYear;
+proto.diff = diff;
+proto.endOf = endOf;
+proto.era = era;
+proto.format = format;
+proto.getDate = getDate;
+proto.getDay = getDay;
+proto.getDayOfYear = getDayOfYear;
+proto.getHours = getHours;
+proto.getMilliseconds = getMilliseconds;
+proto.getMinutes = getMinutes;
+proto.getMonth = getMonth;
+proto.getQuarter = getQuarter;
+proto.getSeconds = getSeconds;
+proto.getTimestamp = getTimestamp;
+proto.getWeek = getWeek;
+proto.getWeekDay = getWeekDay;
+proto.getWeekDayInMonth = getWeekDayInMonth;
+proto.getWeekOfMonth = getWeekOfMonth;
+proto.getWeekYear = getWeekYear;
+proto.getYear = getYear;
+proto.humanDiff = humanDiff;
+proto.isAfter = isAfter;
+proto.isBefore = isBefore;
+proto.isBetween = isBetween;
+proto.isDST = isDST;
+proto.isLeapYear = isLeapYear;
+proto.isSame = isSame;
+proto.isSameOrAfter = isSameOrAfter;
+proto.isSameOrBefore = isSameOrBefore;
+proto.monthName = monthName;
+proto.setDate = setDate;
+proto.setDay = setDay;
+proto.setDayOfYear = setDayOfYear;
+proto.setHours = setHours;
+proto.setMilliseconds = setMilliseconds;
+proto.setMinutes = setMinutes;
+proto.setMonth = setMonth;
+proto.setQuarter = setQuarter;
+proto.setSeconds = setSeconds;
+proto.setTimestamp = setTimestamp;
+proto.setWeek = setWeek;
+proto.setWeekDay = setWeekDay;
+proto.setWeekDayInMonth = setWeekDayInMonth;
+proto.setWeekOfMonth = setWeekOfMonth;
+proto.setWeekYear = setWeekYear;
+proto.setYear = setYear;
+proto.startOf = startOf;
+proto.sub = sub;
+proto.timeZoneName = timeZoneName;
+proto.toDateString = toDateString;
+proto.toISOString = toISOString;
+proto.toString = toString;
+proto.toTimeString = toTimeString;
+proto.toUTCString = toUTCString;
+proto.weeksInYear = weeksInYear;
+
+export default DateTime;