date_picker 0.0.8 → 0.0.9

data/test/dummy/vendor/assets/components/moment/src/lib/units/day-of-year.js

@@ -1,5 +1,6 @@
 import { addFormatToken } from '../format/format';
 import { addUnitAlias } from './aliases';
+import { addUnitPriority } from './priorities';
 import { addRegexToken, match3, match1to3 } from '../parse/regex';
 import { daysInYear } from './year';
 import { createUTCDate } from '../create/date-from-array';
@@ -14,6 +15,9 @@ addFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');
 
 addUnitAlias('dayOfYear', 'DDD');
 
+// PRIORITY
+addUnitPriority('dayOfYear', 4);
+
 // PARSING
 
 addRegexToken('DDD',  match1to3);
@@ -24,23 +28,6 @@ addParseToken(['DDD', 'DDDD'], function (input, array, config) {
 
 // HELPERS
 
-//http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
-export function dayOfYearFromWeeks(year, week, weekday, firstDayOfWeekOfYear, firstDayOfWeek) {
-    var week1Jan = 6 + firstDayOfWeek - firstDayOfWeekOfYear, janX = createUTCDate(year, 0, 1 + week1Jan), d = janX.getUTCDay(), dayOfYear;
-    if (d < firstDayOfWeek) {
-        d += 7;
-    }
-
-    weekday = weekday != null ? 1 * weekday : firstDayOfWeek;
-
-    dayOfYear = 1 + week1Jan + 7 * (week - 1) - d + weekday;
-
-    return {
-        year: dayOfYear > 0 ? year : year - 1,
-        dayOfYear: dayOfYear > 0 ?  dayOfYear : daysInYear(year - 1) + dayOfYear
-    };
-}
-
 // MOMENTS
 
 export function getSetDayOfYear (input) {

data/test/dummy/vendor/assets/components/moment/src/lib/units/hour.js

@@ -1,17 +1,44 @@
 import { makeGetSet } from '../moment/get-set';
 import { addFormatToken } from '../format/format';
 import { addUnitAlias } from './aliases';
-import { addRegexToken, match1to2, match2 } from '../parse/regex';
+import { addUnitPriority } from './priorities';
+import { addRegexToken, match1to2, match2, match3to4, match5to6 } from '../parse/regex';
 import { addParseToken } from '../parse/token';
-import { HOUR } from './constants';
+import { HOUR, MINUTE, SECOND } from './constants';
 import toInt from '../utils/to-int';
+import zeroFill from '../utils/zero-fill';
 import getParsingFlags from '../create/parsing-flags';
 
 // FORMATTING
 
-addFormatToken('H', ['HH', 2], 0, 'hour');
-addFormatToken('h', ['hh', 2], 0, function () {
+function hFormat() {
     return this.hours() % 12 || 12;
+}
+
+function kFormat() {
+    return this.hours() || 24;
+}
+
+addFormatToken('H', ['HH', 2], 0, 'hour');
+addFormatToken('h', ['hh', 2], 0, hFormat);
+addFormatToken('k', ['kk', 2], 0, kFormat);
+
+addFormatToken('hmm', 0, 0, function () {
+    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);
+});
+
+addFormatToken('hmmss', 0, 0, function () {
+    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +
+        zeroFill(this.seconds(), 2);
+});
+
+addFormatToken('Hmm', 0, 0, function () {
+    return '' + this.hours() + zeroFill(this.minutes(), 2);
+});
+
+addFormatToken('Hmmss', 0, 0, function () {
+    return '' + this.hours() + zeroFill(this.minutes(), 2) +
+        zeroFill(this.seconds(), 2);
 });
 
 function meridiem (token, lowercase) {
@@ -27,6 +54,9 @@ meridiem('A', false);
 
 addUnitAlias('hour', 'h');
 
+// PRIORITY
+addUnitPriority('hour', 13);
+
 // PARSING
 
 function matchMeridiem (isStrict, locale) {
@@ -40,6 +70,11 @@ addRegexToken('h',  match1to2);
 addRegexToken('HH', match1to2, match2);
 addRegexToken('hh', match1to2, match2);
 
+addRegexToken('hmm', match3to4);
+addRegexToken('hmmss', match5to6);
+addRegexToken('Hmm', match3to4);
+addRegexToken('Hmmss', match5to6);
+
 addParseToken(['H', 'HH'], HOUR);
 addParseToken(['a', 'A'], function (input, array, config) {
     config._isPm = config._locale.isPM(input);
@@ -49,6 +84,32 @@ addParseToken(['h', 'hh'], function (input, array, config) {
     array[HOUR] = toInt(input);
     getParsingFlags(config).bigHour = true;
 });
+addParseToken('hmm', function (input, array, config) {
+    var pos = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos));
+    array[MINUTE] = toInt(input.substr(pos));
+    getParsingFlags(config).bigHour = true;
+});
+addParseToken('hmmss', function (input, array, config) {
+    var pos1 = input.length - 4;
+    var pos2 = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos1));
+    array[MINUTE] = toInt(input.substr(pos1, 2));
+    array[SECOND] = toInt(input.substr(pos2));
+    getParsingFlags(config).bigHour = true;
+});
+addParseToken('Hmm', function (input, array, config) {
+    var pos = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos));
+    array[MINUTE] = toInt(input.substr(pos));
+});
+addParseToken('Hmmss', function (input, array, config) {
+    var pos1 = input.length - 4;
+    var pos2 = input.length - 2;
+    array[HOUR] = toInt(input.substr(0, pos1));
+    array[MINUTE] = toInt(input.substr(pos1, 2));
+    array[SECOND] = toInt(input.substr(pos2));
+});
 
 // LOCALES
 

data/test/dummy/vendor/assets/components/moment/src/lib/units/millisecond.js

@@ -1,6 +1,7 @@
 import { makeGetSet } from '../moment/get-set';
 import { addFormatToken } from '../format/format';
 import { addUnitAlias } from './aliases';
+import { addUnitPriority } from './priorities';
 import { addRegexToken, match1, match2, match3, match1to3, matchUnsigned } from '../parse/regex';
 import { addParseToken } from '../parse/token';
 import { MILLISECOND } from './constants';
@@ -41,6 +42,10 @@ addFormatToken(0, ['SSSSSSSSS', 9], 0, function () {
 
 addUnitAlias('millisecond', 'ms');
 
+// PRIORITY
+
+addUnitPriority('millisecond', 16);
+
 // PARSING
 
 addRegexToken('S',    match1to3, match1);

data/test/dummy/vendor/assets/components/moment/src/lib/units/minute.js

@@ -1,6 +1,7 @@
 import { makeGetSet } from '../moment/get-set';
 import { addFormatToken } from '../format/format';
 import { addUnitAlias } from './aliases';
+import { addUnitPriority } from './priorities';
 import { addRegexToken, match1to2, match2 } from '../parse/regex';
 import { addParseToken } from '../parse/token';
 import { MINUTE } from './constants';
@@ -13,6 +14,10 @@ addFormatToken('m', ['mm', 2], 0, 'minute');
 
 addUnitAlias('minute', 'm');
 
+// PRIORITY
+
+addUnitPriority('minute', 14);
+
 // PARSING
 
 addRegexToken('m',  match1to2);

data/test/dummy/vendor/assets/components/moment/src/lib/units/month.js

@@ -1,11 +1,15 @@
 import { get } from '../moment/get-set';
+import hasOwnProp from '../utils/has-own-prop';
 import { addFormatToken } from '../format/format';
 import { addUnitAlias } from './aliases';
-import { addRegexToken, match1to2, match2, matchWord } from '../parse/regex';
+import { addUnitPriority } from './priorities';
+import { addRegexToken, match1to2, match2, matchWord, regexEscape } from '../parse/regex';
 import { addParseToken } from '../parse/token';
 import { hooks } from '../utils/hooks';
 import { MONTH } from './constants';
 import toInt from '../utils/to-int';
+import isArray from '../utils/is-array';
+import indexOf from '../utils/index-of';
 import { createUTC } from '../create/utc';
 import getParsingFlags from '../create/parsing-flags';
 
@@ -31,12 +35,20 @@ addFormatToken('MMMM', 0, 0, function (format) {
 
 addUnitAlias('month', 'M');
 
+// PRIORITY
+
+addUnitPriority('month', 8);
+
 // PARSING
 
 addRegexToken('M',    match1to2);
 addRegexToken('MM',   match1to2, match2);
-addRegexToken('MMM',  matchWord);
-addRegexToken('MMMM', matchWord);
+addRegexToken('MMM',  function (isStrict, locale) {
+    return locale.monthsShortRegex(isStrict);
+});
+addRegexToken('MMMM', function (isStrict, locale) {
+    return locale.monthsRegex(isStrict);
+});
 
 addParseToken(['M', 'MM'], function (input, array) {
     array[MONTH] = toInt(input) - 1;
@@ -54,25 +66,82 @@ addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
 
 // LOCALES
 
+var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s)+MMMM?/;
 export var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
-export function localeMonths (m) {
-    return this._months[m.month()];
+export function localeMonths (m, format) {
+    if (!m) {
+        return this._months;
+    }
+    return isArray(this._months) ? this._months[m.month()] :
+        this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];
 }
 
 export var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
-export function localeMonthsShort (m) {
-    return this._monthsShort[m.month()];
+export function localeMonthsShort (m, format) {
+    if (!m) {
+        return this._monthsShort;
+    }
+    return isArray(this._monthsShort) ? this._monthsShort[m.month()] :
+        this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];
+}
+
+function handleStrictParse(monthName, format, strict) {
+    var i, ii, mom, llc = monthName.toLocaleLowerCase();
+    if (!this._monthsParse) {
+        // this is not used
+        this._monthsParse = [];
+        this._longMonthsParse = [];
+        this._shortMonthsParse = [];
+        for (i = 0; i < 12; ++i) {
+            mom = createUTC([2000, i]);
+            this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();
+            this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();
+        }
+    }
+
+    if (strict) {
+        if (format === 'MMM') {
+            ii = indexOf.call(this._shortMonthsParse, llc);
+            return ii !== -1 ? ii : null;
+        } else {
+            ii = indexOf.call(this._longMonthsParse, llc);
+            return ii !== -1 ? ii : null;
+        }
+    } else {
+        if (format === 'MMM') {
+            ii = indexOf.call(this._shortMonthsParse, llc);
+            if (ii !== -1) {
+                return ii;
+            }
+            ii = indexOf.call(this._longMonthsParse, llc);
+            return ii !== -1 ? ii : null;
+        } else {
+            ii = indexOf.call(this._longMonthsParse, llc);
+            if (ii !== -1) {
+                return ii;
+            }
+            ii = indexOf.call(this._shortMonthsParse, llc);
+            return ii !== -1 ? ii : null;
+        }
+    }
 }
 
 export function localeMonthsParse (monthName, format, strict) {
     var i, mom, regex;
 
+    if (this._monthsParseExact) {
+        return handleStrictParse.call(this, monthName, format, strict);
+    }
+
     if (!this._monthsParse) {
         this._monthsParse = [];
         this._longMonthsParse = [];
         this._shortMonthsParse = [];
     }
 
+    // TODO: add sorting
+    // Sorting makes sure if one month (or abbr) is a prefix of another
+    // see sorting in computeMonthsParse
     for (i = 0; i < 12; i++) {
         // make the regex if we don't have it already
         mom = createUTC([2000, i]);
@@ -100,12 +169,20 @@ export function localeMonthsParse (monthName, format, strict) {
 export function setMonth (mom, value) {
     var dayOfMonth;
 
-    // TODO: Move this out of here!
+    if (!mom.isValid()) {
+        // No op
+        return mom;
+    }
+
     if (typeof value === 'string') {
-        value = mom.localeData().monthsParse(value);
-        // TODO: Another silent failure?
-        if (typeof value !== 'number') {
-            return mom;
+        if (/^\d+$/.test(value)) {
+            value = toInt(value);
+        } else {
+            value = mom.localeData().monthsParse(value);
+            // TODO: Another silent failure?
+            if (typeof value !== 'number') {
+                return mom;
+            }
         }
     }
 
@@ -127,3 +204,77 @@ export function getSetMonth (value) {
 export function getDaysInMonth () {
     return daysInMonth(this.year(), this.month());
 }
+
+var defaultMonthsShortRegex = matchWord;
+export function monthsShortRegex (isStrict) {
+    if (this._monthsParseExact) {
+        if (!hasOwnProp(this, '_monthsRegex')) {
+            computeMonthsParse.call(this);
+        }
+        if (isStrict) {
+            return this._monthsShortStrictRegex;
+        } else {
+            return this._monthsShortRegex;
+        }
+    } else {
+        if (!hasOwnProp(this, '_monthsShortRegex')) {
+            this._monthsShortRegex = defaultMonthsShortRegex;
+        }
+        return this._monthsShortStrictRegex && isStrict ?
+            this._monthsShortStrictRegex : this._monthsShortRegex;
+    }
+}
+
+var defaultMonthsRegex = matchWord;
+export function monthsRegex (isStrict) {
+    if (this._monthsParseExact) {
+        if (!hasOwnProp(this, '_monthsRegex')) {
+            computeMonthsParse.call(this);
+        }
+        if (isStrict) {
+            return this._monthsStrictRegex;
+        } else {
+            return this._monthsRegex;
+        }
+    } else {
+        if (!hasOwnProp(this, '_monthsRegex')) {
+            this._monthsRegex = defaultMonthsRegex;
+        }
+        return this._monthsStrictRegex && isStrict ?
+            this._monthsStrictRegex : this._monthsRegex;
+    }
+}
+
+function computeMonthsParse () {
+    function cmpLenRev(a, b) {
+        return b.length - a.length;
+    }
+
+    var shortPieces = [], longPieces = [], mixedPieces = [],
+        i, mom;
+    for (i = 0; i < 12; i++) {
+        // make the regex if we don't have it already
+        mom = createUTC([2000, i]);
+        shortPieces.push(this.monthsShort(mom, ''));
+        longPieces.push(this.months(mom, ''));
+        mixedPieces.push(this.months(mom, ''));
+        mixedPieces.push(this.monthsShort(mom, ''));
+    }
+    // Sorting makes sure if one month (or abbr) is a prefix of another it
+    // will match the longer piece.
+    shortPieces.sort(cmpLenRev);
+    longPieces.sort(cmpLenRev);
+    mixedPieces.sort(cmpLenRev);
+    for (i = 0; i < 12; i++) {
+        shortPieces[i] = regexEscape(shortPieces[i]);
+        longPieces[i] = regexEscape(longPieces[i]);
+    }
+    for (i = 0; i < 24; i++) {
+        mixedPieces[i] = regexEscape(mixedPieces[i]);
+    }
+
+    this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
+    this._monthsShortRegex = this._monthsRegex;
+    this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');
+    this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');
+}

data/test/dummy/vendor/assets/components/moment/src/lib/units/offset.js

@@ -3,13 +3,14 @@ import { createDuration } from '../duration/create';
 import { addSubtract } from '../moment/add-subtract';
 import { isMoment, copyConfig } from '../moment/constructor';
 import { addFormatToken } from '../format/format';
-import { addRegexToken, matchOffset } from '../parse/regex';
+import { addRegexToken, matchOffset, matchShortOffset } from '../parse/regex';
 import { addParseToken } from '../parse/token';
 import { createLocal } from '../create/local';
 import { prepareConfig } from '../create/from-anything';
 import { createUTC } from '../create/utc';
 import isDate from '../utils/is-date';
 import toInt from '../utils/to-int';
+import isUndefined from '../utils/is-undefined';
 import compareArrays from '../utils/compare-arrays';
 import { hooks } from '../utils/hooks';
 
@@ -32,11 +33,11 @@ offset('ZZ', '');
 
 // PARSING
 
-addRegexToken('Z',  matchOffset);
-addRegexToken('ZZ', matchOffset);
+addRegexToken('Z',  matchShortOffset);
+addRegexToken('ZZ', matchShortOffset);
 addParseToken(['Z', 'ZZ'], function (input, array, config) {
     config._useUTC = true;
-    config._tzm = offsetFromString(input);
+    config._tzm = offsetFromString(matchShortOffset, input);
 });
 
 // HELPERS
@@ -46,8 +47,8 @@ addParseToken(['Z', 'ZZ'], function (input, array, config) {
 // '-1530'  > ['-15', '30']
 var chunkOffset = /([\+\-]|\d\d)/gi;
 
-function offsetFromString(string) {
-    var matches = ((string || '').match(matchOffset) || []);
+function offsetFromString(matcher, string) {
+    var matches = ((string || '').match(matcher) || []);
     var chunk   = matches[matches.length - 1] || [];
     var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];
     var minutes = +(parts[1] * 60) + toInt(parts[2]);
@@ -60,9 +61,9 @@ export function cloneWithOffset(input, model) {
     var res, diff;
     if (model._isUTC) {
         res = model.clone();
-        diff = (isMoment(input) || isDate(input) ? +input : +createLocal(input)) - (+res);
+        diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();
         // Use low-level api, because this fn is low-level api.
-        res._d.setTime(+res._d + diff);
+        res._d.setTime(res._d.valueOf() + diff);
         hooks.updateOffset(res, false);
         return res;
     } else {
@@ -97,11 +98,13 @@ hooks.updateOffset = function () {};
 export function getSetOffset (input, keepLocalTime) {
     var offset = this._offset || 0,
         localAdjust;
+    if (!this.isValid()) {
+        return input != null ? this : NaN;
+    }
     if (input != null) {
         if (typeof input === 'string') {
-            input = offsetFromString(input);
-        }
-        if (Math.abs(input) < 16) {
+            input = offsetFromString(matchShortOffset, input);
+        } else if (Math.abs(input) < 16) {
             input = input * 60;
         }
         if (!this._isUTC && keepLocalTime) {
@@ -161,12 +164,21 @@ export function setOffsetToParsedOffset () {
     if (this._tzm) {
         this.utcOffset(this._tzm);
     } else if (typeof this._i === 'string') {
-        this.utcOffset(offsetFromString(this._i));
+        var tZone = offsetFromString(matchOffset, this._i);
+
+        if (tZone === 0) {
+            this.utcOffset(0, true);
+        } else {
+            this.utcOffset(offsetFromString(matchOffset, this._i));
+        }
     }
     return this;
 }
 
 export function hasAlignedHourOffset (input) {
+    if (!this.isValid()) {
+        return false;
+    }
     input = input ? createLocal(input).utcOffset() : 0;
 
     return (this.utcOffset() - input) % 60 === 0;
@@ -180,7 +192,7 @@ export function isDaylightSavingTime () {
 }
 
 export function isDaylightSavingTimeShifted () {
-    if (typeof this._isDSTShifted !== 'undefined') {
+    if (!isUndefined(this._isDSTShifted)) {
         return this._isDSTShifted;
     }
 
@@ -201,13 +213,13 @@ export function isDaylightSavingTimeShifted () {
 }
 
 export function isLocal () {
-    return !this._isUTC;
+    return this.isValid() ? !this._isUTC : false;
 }
 
 export function isUtcOffset () {
-    return this._isUTC;
+    return this.isValid() ? this._isUTC : false;
 }
 
 export function isUtc () {
-    return this._isUTC && this._offset === 0;
+    return this.isValid() ? this._isUTC && this._offset === 0 : false;
 }