perf(parsing flags): lazily initialize parsing flags

diff --git a/src/lib/create/check-overflow.js b/src/lib/create/check-overflow.js
index 7ee7556f83e6724a26f84bda4aacebf3b7a06183..88a62ae5479a38c813f39526f00a42b9aa49e908 100644 (file)
--- a/src/lib/create/check-overflow.js
+++ b/src/lib/create/check-overflow.js
@@ -1,11 +1,12 @@
 import { daysInMonth } from '../units/month';
 import { YEAR, MONTH, DATE, HOUR, MINUTE, SECOND, MILLISECOND } from '../units/constants';
+import getParsingFlags from '../create/parsing-flags';
 
 export default function checkOverflow (m) {
     var overflow;
     var a = m._a;
 
-    if (a && m._pf.overflow === -2) {
+    if (a && getParsingFlags(m).overflow === -2) {
         overflow =
             a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :
             a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :
@@ -15,11 +16,11 @@ export default function checkOverflow (m) {
             a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :
             -1;
 
-        if (m._pf._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
+        if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
             overflow = DATE;
         }
 
-        m._pf.overflow = overflow;
+        getParsingFlags(m).overflow = overflow;
     }
 
     return m;

diff --git a/src/lib/create/from-anything.js b/src/lib/create/from-anything.js
index a5a59f3594e9f3e95db72f754df12cb387e516b7..30bc1eaeb7b57e3c28bed580eaceb7ba96a7db59 100644 (file)
--- a/src/lib/create/from-anything.js
+++ b/src/lib/create/from-anything.js
@@ -1,4 +1,3 @@
-import defaultParsingFlags from './default-parsing-flags';
 import isArray from '../utils/is-array';
 import isDate from '../utils/is-date';
 import map from '../utils/map';
@@ -87,7 +86,6 @@ export function createLocalOrUTC (input, format, locale, strict, isUTC) {
     c._i = input;
     c._f = format;
     c._strict = strict;
-    c._pf = defaultParsingFlags();
 
     return createFromConfig(c);
 }

diff --git a/src/lib/create/from-array.js b/src/lib/create/from-array.js
index dea1e85150e6c84804cb73921a6c58fbbf23d187..c4239cb720d123d743edbf1ca930a655c595cb4c 100644 (file)
--- a/src/lib/create/from-array.js
+++ b/src/lib/create/from-array.js
@@ -5,6 +5,7 @@ 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';
+import getParsingFlags from './parsing-flags';
 
 function currentDateArray(config) {
     var now = new Date();
@@ -37,7 +38,7 @@ export function configFromArray (config) {
         yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
 
         if (config._dayOfYear > daysInYear(yearToUse)) {
-            config._pf._overflowDayOfYear = true;
+            getParsingFlags(config)._overflowDayOfYear = true;
         }
 
         date = createUTCDate(yearToUse, 0, config._dayOfYear);

diff --git a/src/lib/create/from-string-and-array.js b/src/lib/create/from-string-and-array.js
index e44af67fbf1f62769a46ac2449487e18b4a8036b..1d8a7a806cda2fee37170e4b5615b7acabb555e2 100644 (file)
--- a/src/lib/create/from-string-and-array.js
+++ b/src/lib/create/from-string-and-array.js
@@ -1,6 +1,6 @@
 import { copyConfig } from '../moment/constructor';
 import { configFromStringAndFormat } from './from-string-and-format';
-import defaultParsingFlags from './default-parsing-flags';
+import getParsingFlags from './parsing-flags';
 import { isValid } from './valid';
 import extend from '../utils/extend';
 
@@ -14,7 +14,7 @@ export function configFromStringAndArray(config) {
         currentScore;
 
     if (config._f.length === 0) {
-        config._pf.invalidFormat = true;
+        getParsingFlags(config).invalidFormat = true;
         config._d = new Date(NaN);
         return;
     }
@@ -25,7 +25,6 @@ export function configFromStringAndArray(config) {
         if (config._useUTC != null) {
             tempConfig._useUTC = config._useUTC;
         }
-        tempConfig._pf = defaultParsingFlags();
         tempConfig._f = config._f[i];
         configFromStringAndFormat(tempConfig);
 
@@ -34,12 +33,12 @@ export function configFromStringAndArray(config) {
         }
 
         // if there is any input that was not parsed add a penalty for that format
-        currentScore += tempConfig._pf.charsLeftOver;
+        currentScore += getParsingFlags(tempConfig).charsLeftOver;
 
         //or tokens
-        currentScore += tempConfig._pf.unusedTokens.length * 10;
+        currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
 
-        tempConfig._pf.score = currentScore;
+        getParsingFlags(tempConfig).score = currentScore;
 
         if (scoreToBeat == null || currentScore < scoreToBeat) {
             scoreToBeat = currentScore;

diff --git a/src/lib/create/from-string-and-format.js b/src/lib/create/from-string-and-format.js
index 8a75873a066a6e3cd955c6fa2ed5021ef9d9e7ef..ac3df6183fe871901fd7532b802eefb04f096639 100644 (file)
--- a/src/lib/create/from-string-and-format.js
+++ b/src/lib/create/from-string-and-format.js
@@ -6,6 +6,7 @@ import { expandFormat, formatTokenFunctions, formattingTokens } from '../format/
 import checkOverflow from './check-overflow';
 import { HOUR } from '../units/constants';
 import { hooks } from '../utils/hooks';
+import getParsingFlags from './parsing-flags';
 
 // constant that refers to the ISO standard
 hooks.ISO_8601 = function () {};
@@ -19,7 +20,7 @@ export function configFromStringAndFormat(config) {
     }
 
     config._a = [];
-    config._pf.empty = true;
+    getParsingFlags(config).empty = true;
 
     // This array is used to make a Date, either with `new Date` or `Date.UTC`
     var string = '' + config._i,
@@ -35,7 +36,7 @@ export function configFromStringAndFormat(config) {
         if (parsedInput) {
             skipped = string.substr(0, string.indexOf(parsedInput));
             if (skipped.length > 0) {
-                config._pf.unusedInput.push(skipped);
+                getParsingFlags(config).unusedInput.push(skipped);
             }
             string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
             totalParsedInputLength += parsedInput.length;
@@ -43,27 +44,27 @@ export function configFromStringAndFormat(config) {
         // don't parse if it's not a known token
         if (formatTokenFunctions[token]) {
             if (parsedInput) {
-                config._pf.empty = false;
+                getParsingFlags(config).empty = false;
             }
             else {
-                config._pf.unusedTokens.push(token);
+                getParsingFlags(config).unusedTokens.push(token);
             }
             addTimeToArrayFromToken(token, parsedInput, config);
         }
         else if (config._strict && !parsedInput) {
-            config._pf.unusedTokens.push(token);
+            getParsingFlags(config).unusedTokens.push(token);
         }
     }
 
     // add remaining unparsed input length to the string
-    config._pf.charsLeftOver = stringLength - totalParsedInputLength;
+    getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
     if (string.length > 0) {
-        config._pf.unusedInput.push(string);
+        getParsingFlags(config).unusedInput.push(string);
     }
 
     // clear _12h flag if hour is <= 12
-    if (config._pf.bigHour === true && config._a[HOUR] <= 12) {
-        config._pf.bigHour = undefined;
+    if (getParsingFlags(config).bigHour === true && config._a[HOUR] <= 12) {
+        getParsingFlags(config).bigHour = undefined;
     }
     // handle meridiem
     config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);

diff --git a/src/lib/create/from-string.js b/src/lib/create/from-string.js
index 052d3be389ecae8f6fcba4448140cbee3ccf8e96..4bd6d5913810014eed4f045f16c9e2d7069869b6 100644 (file)
--- a/src/lib/create/from-string.js
+++ b/src/lib/create/from-string.js
@@ -2,6 +2,7 @@ import { matchOffset } from '../parse/regex';
 import { configFromStringAndFormat } from './from-string-and-format';
 import { hooks } from '../utils/hooks';
 import { deprecate } from '../utils/deprecate';
+import getParsingFlags from './parsing-flags';
 
 // iso 8601 regex
 // 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
@@ -32,7 +33,7 @@ export function configFromISO(config) {
         match = isoRegex.exec(string);
 
     if (match) {
-        config._pf.iso = true;
+        getParsingFlags(config).iso = true;
         for (i = 0, l = isoDates.length; i < l; i++) {
             if (isoDates[i][1].exec(string)) {
                 // match[5] should be 'T' or undefined

diff --git a/src/lib/create/default-parsing-flags.js b/src/lib/create/parsing-flags.js
similarity index 69%
rename from src/lib/create/default-parsing-flags.js
rename to src/lib/create/parsing-flags.js
index 0732d5bf2cdea27c1afd7c8f041840366860d8a6..2bfbcb3414c5c2955cddc0d37a97d3168b63bfd2 100644 (file)
--- a/src/lib/create/default-parsing-flags.js
+++ b/src/lib/create/parsing-flags.js
@@ -1,4 +1,4 @@
-export default function defaultParsingFlags() {
+function defaultParsingFlags() {
     // We need to deep clone this object.
     return {
         empty           : false,
@@ -13,3 +13,10 @@ export default function defaultParsingFlags() {
         iso             : false
     };
 }
+
+export default function getParsingFlags(m) {
+    if (m._pf == null) {
+        m._pf = defaultParsingFlags();
+    }
+    return m._pf;
+}

diff --git a/src/lib/create/valid.js b/src/lib/create/valid.js
index a5aaba008b2b77d008fe2564bf2b33ec585dbf94..89204f85f1e60ef9e3e0dadad34af584ea8910bb 100644 (file)
--- a/src/lib/create/valid.js
+++ b/src/lib/create/valid.js
@@ -1,21 +1,23 @@
 import extend from '../utils/extend';
 import { createUTC } from './utc';
+import getParsingFlags from '../create/parsing-flags';
 
 export function isValid(m) {
     if (m._isValid == null) {
+        var flags = getParsingFlags(m);
         m._isValid = !isNaN(m._d.getTime()) &&
-            m._pf.overflow < 0 &&
-            !m._pf.empty &&
-            !m._pf.invalidMonth &&
-            !m._pf.nullInput &&
-            !m._pf.invalidFormat &&
-            !m._pf.userInvalidated;
+            flags.overflow < 0 &&
+            !flags.empty &&
+            !flags.invalidMonth &&
+            !flags.nullInput &&
+            !flags.invalidFormat &&
+            !flags.userInvalidated;
 
         if (m._strict) {
             m._isValid = m._isValid &&
-                m._pf.charsLeftOver === 0 &&
-                m._pf.unusedTokens.length === 0 &&
-                m._pf.bigHour === undefined;
+                flags.charsLeftOver === 0 &&
+                flags.unusedTokens.length === 0 &&
+                flags.bigHour === undefined;
         }
     }
     return m._isValid;
@@ -24,10 +26,10 @@ export function isValid(m) {
 export function createInvalid (flags) {
     var m = createUTC(NaN);
     if (flags != null) {
-        extend(m._pf, flags);
+        extend(getParsingFlags(m), flags);
     }
     else {
-        m._pf.userInvalidated = true;
+        getParsingFlags(m).userInvalidated = true;
     }
 
     return m;

diff --git a/src/lib/moment/constructor.js b/src/lib/moment/constructor.js
index 2376cae70db5d63d196bd0bf71d191c8dd7568bb..1b3425f4ab6c5dbbacdf3ba47e1e8bbc5f0e479b 100644 (file)
--- a/src/lib/moment/constructor.js
+++ b/src/lib/moment/constructor.js
@@ -1,5 +1,6 @@
 import { hooks } from '../utils/hooks';
 import hasOwnProp from '../utils/has-own-prop';
+import getParsingFlags from '../create/parsing-flags';
 
 // Plugins that add properties should also add the key here (null value),
 // so we can properly clone ourselves.
@@ -33,7 +34,7 @@ export function copyConfig(to, from) {
         to._offset = from._offset;
     }
     if (typeof from._pf !== 'undefined') {
-        to._pf = from._pf;
+        to._pf = getParsingFlags(from);
     }
     if (typeof from._locale !== 'undefined') {
         to._locale = from._locale;

diff --git a/src/lib/moment/valid.js b/src/lib/moment/valid.js
index ffd47de8e6550efa27b924bbf0e528d36c157c7b..6c00742938851f5662f4fab5fec82d3daa71824c 100644 (file)
--- a/src/lib/moment/valid.js
+++ b/src/lib/moment/valid.js
@@ -1,14 +1,15 @@
 import { isValid as _isValid } from '../create/valid';
 import extend from '../utils/extend';
+import getParsingFlags from '../create/parsing-flags';
 
 export function isValid () {
     return _isValid(this);
 }
 
 export function parsingFlags () {
-    return extend({}, this._pf);
+    return extend({}, getParsingFlags(this));
 }
 
 export function invalidAt () {
-    return this._pf.overflow;
+    return getParsingFlags(this).overflow;
 }

diff --git a/src/lib/units/day-of-week.js b/src/lib/units/day-of-week.js
index c1cf95273d2f3bca66ca5b6de97e1bf8b434d565..7af2408376bb0ea6d38975999037b5d6256e3ac2 100644 (file)
--- a/src/lib/units/day-of-week.js
+++ b/src/lib/units/day-of-week.js
@@ -4,6 +4,7 @@ import { addRegexToken, match1to2, matchWord } from '../parse/regex';
 import { addWeekParseToken } from '../parse/token';
 import toInt from '../utils/to-int';
 import { createLocal } from '../create/local';
+import getParsingFlags from '../create/parsing-flags';
 
 // FORMATTING
 
@@ -45,7 +46,7 @@ addWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config) {
     if (weekday != null) {
         week.d = weekday;
     } else {
-        config._pf.invalidWeekday = input;
+        getParsingFlags(config).invalidWeekday = input;
     }
 });
 

diff --git a/src/lib/units/hour.js b/src/lib/units/hour.js
index 2c6836ae7bceaaf6a63e37c7fd2b0da9a563bbe4..356c74d234747a6868a9b67c9245b66317d2a2c9 100644 (file)
--- a/src/lib/units/hour.js
+++ b/src/lib/units/hour.js
@@ -5,6 +5,7 @@ import { addRegexToken, match1to2, match2 } from '../parse/regex';
 import { addParseToken } from '../parse/token';
 import { HOUR } from './constants';
 import toInt from '../utils/to-int';
+import getParsingFlags from '../create/parsing-flags';
 
 // FORMATTING
 
@@ -46,7 +47,7 @@ addParseToken(['a', 'A'], function (input, array, config) {
 });
 addParseToken(['h', 'hh'], function (input, array, config) {
     array[HOUR] = toInt(input);
-    config._pf.bigHour = true;
+    getParsingFlags(config).bigHour = true;
 });
 
 // LOCALES

diff --git a/src/lib/units/month.js b/src/lib/units/month.js
index 3c32137146e9d853702cb1cfefd62fdc4be44f2c..63d18b47f2fe9e99a5c9c24a1bda5367cf50e8a7 100644 (file)
--- a/src/lib/units/month.js
+++ b/src/lib/units/month.js
@@ -7,6 +7,7 @@ import { hooks } from '../utils/hooks';
 import { MONTH } from './constants';
 import toInt from '../utils/to-int';
 import { createUTC } from '../create/utc';
+import getParsingFlags from '../create/parsing-flags';
 
 export function daysInMonth(year, month) {
     return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
@@ -47,7 +48,7 @@ addParseToken(['MMM', 'MMMM'], function (input, array, config, token) {
     if (month != null) {
         array[MONTH] = month;
     } else {
-        config._pf.invalidMonth = input;
+        getParsingFlags(config).invalidMonth = input;
     }
 });