Convert moment.js to ES6 modules.

lib/create/check-overflow.js

@@ -0,0 +1,27 @@
+import { daysInMonth } from "../units/month";
+import { YEAR, MONTH, DATE, HOUR, MINUTE, SECOND, MILLISECOND } from "../units/constants";
+
+export default function checkOverflow (m) {
+    var overflow;
+    var a = m._a;
+
+    if (a && m._pf.overflow === -2) {
+        overflow =
+            a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
+            a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
+            a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :
+            a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :
+            a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :
+            a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
+            -1;
+
+        if (m._pf._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
+            overflow = DATE;
+        }
+
+        m._pf.overflow = overflow;
+    }
+
+    return m;
+}
+

lib/create/date-from-array.js

@@ -0,0 +1,19 @@
+export function createDate (y, m, d, h, M, s, ms) {
+    //can't just apply() to create a date:
+    //http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
+    var date = new Date(y, m, d, h, M, s, ms);
+
+    //the date constructor doesn't accept years < 1970
+    if (y < 1970) {
+        date.setFullYear(y);
+    }
+    return date;
+}
+
+export function createUTCDate (y) {
+    var date = new Date(Date.UTC.apply(null, arguments));
+    if (y < 1970) {
+        date.setUTCFullYear(y);
+    }
+    return date;
+}

lib/create/default-parsing-flags.js

@@ -0,0 +1,15 @@
+export default function defaultParsingFlags() {
+    // We need to deep clone this object.
+    return {
+        empty           : false,
+        unusedTokens    : [],
+        unusedInput     : [],
+        overflow        : -2,
+        charsLeftOver   : 0,
+        nullInput       : false,
+        invalidMonth    : null,
+        invalidFormat   : false,
+        userInvalidated : false,
+        iso             : false
+    };
+}

lib/create/from-anything.js

@@ -0,0 +1,93 @@
+import defaultParsingFlags from "./default-parsing-flags";
+import isArray from "../utils/is-array";
+import isDate from "../utils/is-date";
+import map from "../utils/map";
+import { createInvalid } from "./valid";
+import { Moment, isMoment } from "../moment/constructor";
+import { getLocale } from "../locale/locales";
+import { hooks } from "../utils/hooks";
+import checkOverflow from "./check-overflow";
+
+import { configFromStringAndArray }  from "./from-string-and-array";
+import { configFromStringAndFormat } from "./from-string-and-format";
+import { configFromString }          from "./from-string";
+import { configFromArray }           from "./from-array";
+import { configFromObject }          from "./from-object";
+
+function createFromConfig (config) {
+    var input = config._i,
+        format = config._f,
+        res;
+
+    config._locale = config._locale || getLocale(config._l);
+
+    if (input === null || (format === undefined && input === '')) {
+        return createInvalid({nullInput: true});
+    }
+
+    if (typeof input === 'string') {
+        config._i = input = config._locale.preparse(input);
+    }
+
+    if (isMoment(input)) {
+        return new Moment(checkOverflow(input));
+    } else if (isArray(format)) {
+        configFromStringAndArray(config);
+    } else if (format) {
+        configFromStringAndFormat(config);
+    } else {
+        configFromInput(config);
+    }
+
+    res = new Moment(checkOverflow(config));
+    if (res._nextDay) {
+        // Adding is smart enough around DST
+        res.add(1, 'd');
+        res._nextDay = undefined;
+    }
+
+    return res;
+}
+
+function configFromInput(config) {
+    var input = config._i;
+    if (input === undefined) {
+        config._d = new Date();
+    } else if (isDate(input)) {
+        config._d = new Date(+input);
+    } else if (typeof input === 'string') {
+        configFromString(config);
+    } else if (isArray(input)) {
+        config._a = map(input.slice(0), function (obj) {
+            return parseInt(obj, 10);
+        });
+        configFromArray(config);
+    } else if (typeof(input) === 'object') {
+        configFromObject(config);
+    } else if (typeof(input) === 'number') {
+        // from milliseconds
+        config._d = new Date(input);
+    } else {
+        hooks.createFromInputFallback(config);
+    }
+}
+
+export function createLocalOrUTC (input, format, locale, strict, isUTC) {
+    var c = {};
+
+    if (typeof(locale) === 'boolean') {
+        strict = locale;
+        locale = undefined;
+    }
+    // object construction must be done this way.
+    // https://github.com/moment/moment/issues/1423
+    c._isAMomentObject = true;
+    c._useUTC = c._isUTC = isUTC;
+    c._l = locale;
+    c._i = input;
+    c._f = format;
+    c._strict = strict;
+    c._pf = defaultParsingFlags();
+
+    return createFromConfig(c);
+}

lib/create/from-array.js

@@ -0,0 +1,123 @@
+import { createDate, createUTCDate } from "./date-from-array";
+import { daysInYear } from "../units/year";
+import { weekOfYear } from "../units/week";
+import { dayOfYearFromWeeks } from "../units/day-of-year";
+import { YEAR, MONTH, DATE, HOUR, MINUTE, SECOND, MILLISECOND } from "../units/constants";
+import { createLocal } from "./local";
+import defaults from "../utils/defaults";
+
+function currentDateArray(config) {
+    var now = new Date();
+    if (config._useUTC) {
+        return [now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()];
+    }
+    return     [now.getFullYear(),    now.getMonth(),    now.getDate()];
+}
+
+// convert an array to a date.
+// the array should mirror the parameters below
+// note: all values past the year are optional and will default to the lowest possible value.
+// [year, month, day , hour, minute, second, millisecond]
+export function configFromArray (config) {
+    var i, date, input = [], currentDate, yearToUse;
+
+    if (config._d) {
+        return;
+    }
+
+    currentDate = currentDateArray(config);
+
+    //compute day of the year from weeks and weekdays
+    if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
+        dayOfYearFromWeekInfo(config);
+    }
+
+    //if the day of the year is set, figure out what it is
+    if (config._dayOfYear) {
+        yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
+
+        if (config._dayOfYear > daysInYear(yearToUse)) {
+            config._pf._overflowDayOfYear = true;
+        }
+
+        date = createUTCDate(yearToUse, 0, config._dayOfYear);
+        config._a[MONTH] = date.getUTCMonth();
+        config._a[DATE] = date.getUTCDate();
+    }
+
+    // Default to current date.
+    // * if no year, month, day of month are given, default to today
+    // * if day of month is given, default month and year
+    // * if month is given, default only year
+    // * if year is given, don't default anything
+    for (i = 0; i < 3 && config._a[i] == null; ++i) {
+        config._a[i] = input[i] = currentDate[i];
+    }
+
+    // Zero out whatever was not defaulted, including time
+    for (; i < 7; i++) {
+        config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];
+    }
+
+    // Check for 24:00:00.000
+    if (config._a[HOUR] === 24 &&
+            config._a[MINUTE] === 0 &&
+            config._a[SECOND] === 0 &&
+            config._a[MILLISECOND] === 0) {
+        config._nextDay = true;
+        config._a[HOUR] = 0;
+    }
+
+    config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
+    // Apply timezone offset from input. The actual utcOffset can be changed
+    // with parseZone.
+    if (config._tzm != null) {
+        config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);
+    }
+
+    if (config._nextDay) {
+        config._a[HOUR] = 24;
+    }
+}
+
+function dayOfYearFromWeekInfo(config) {
+    var w, weekYear, week, weekday, dow, doy, temp;
+
+    w = config._w;
+    if (w.GG != null || w.W != null || w.E != null) {
+        dow = 1;
+        doy = 4;
+
+        // TODO: We need to take the current isoWeekYear, but that depends on
+        // how we interpret now (local, utc, fixed offset). So create
+        // a now version of current config (take local/utc/offset flags, and
+        // create now).
+        weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);
+        week = defaults(w.W, 1);
+        weekday = defaults(w.E, 1);
+    } else {
+        dow = config._locale._week.dow;
+        doy = config._locale._week.doy;
+
+        weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(createLocal(), dow, doy).year);
+        week = defaults(w.w, 1);
+
+        if (w.d != null) {
+            // weekday -- low day numbers are considered next week
+            weekday = w.d;
+            if (weekday < dow) {
+                ++week;
+            }
+        } else if (w.e != null) {
+            // local weekday -- counting starts from begining of week
+            weekday = w.e + dow;
+        } else {
+            // default to begining of week
+            weekday = dow;
+        }
+    }
+    temp = dayOfYearFromWeeks(weekYear, week, weekday, doy, dow);
+
+    config._a[YEAR] = temp.year;
+    config._dayOfYear = temp.dayOfYear;
+}

lib/create/from-object.js

@@ -0,0 +1,13 @@
+import { normalizeObjectUnits } from "../units/aliases";
+import { configFromArray } from "./from-array";
+
+export function configFromObject(config) {
+    if (config._d) {
+        return;
+    }
+
+    var i = normalizeObjectUnits(config._i);
+    config._a = [i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond];
+
+    configFromArray(config);
+}

lib/create/from-string-and-array.js

@@ -0,0 +1,51 @@
+import { copyConfig } from "../moment/constructor";
+import { configFromStringAndFormat } from "./from-string-and-format";
+import defaultParsingFlags from "./default-parsing-flags";
+import { isValid } from "./valid";
+import extend from "../utils/extend";
+
+// date from string and array of format strings
+export function configFromStringAndArray(config) {
+    var tempConfig,
+        bestMoment,
+
+        scoreToBeat,
+        i,
+        currentScore;
+
+    if (config._f.length === 0) {
+        config._pf.invalidFormat = true;
+        config._d = new Date(NaN);
+        return;
+    }
+
+    for (i = 0; i < config._f.length; i++) {
+        currentScore = 0;
+        tempConfig = copyConfig({}, config);
+        if (config._useUTC != null) {
+            tempConfig._useUTC = config._useUTC;
+        }
+        tempConfig._pf = defaultParsingFlags();
+        tempConfig._f = config._f[i];
+        configFromStringAndFormat(tempConfig);
+
+        if (!isValid(tempConfig)) {
+            continue;
+        }
+
+        // if there is any input that was not parsed add a penalty for that format
+        currentScore += tempConfig._pf.charsLeftOver;
+
+        //or tokens
+        currentScore += tempConfig._pf.unusedTokens.length * 10;
+
+        tempConfig._pf.score = currentScore;
+
+        if (scoreToBeat == null || currentScore < scoreToBeat) {
+            scoreToBeat = currentScore;
+            bestMoment = tempConfig;
+        }
+    }
+
+    extend(config, bestMoment || tempConfig);
+}