cnhis-design-vue 3.1.14-beta.2 → 3.1.14-beta.5

package/es/node_modules/date-fns/esm/parse/_lib/parsers/DayParser.js

@@ -0,0 +1,80 @@
+import { Parser } from '../Parser.js';
+import setUTCDay from '../../../_lib/setUTCDay/index.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class DayParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 90);
+
+    _defineProperty(this, "incompatibleTokens", ['D', 'i', 'e', 'c', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      // Tue
+      case 'E':
+      case 'EE':
+      case 'EEE':
+        return match.day(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'short',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+      // T
+
+      case 'EEEEE':
+        return match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+      // Tu
+
+      case 'EEEEEE':
+        return match.day(dateString, {
+          width: 'short',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+      // Tuesday
+
+      case 'EEEE':
+      default:
+        return match.day(dateString, {
+          width: 'wide',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'short',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 6;
+  }
+
+  set(date, _flags, value, options) {
+    date = setUTCDay(date, value, options);
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { DayParser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/DayPeriodParser.js

@@ -0,0 +1,56 @@
+import { Parser } from '../Parser.js';
+import { dayPeriodEnumToHours } from '../utils.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class DayPeriodParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 80);
+
+    _defineProperty(this, "incompatibleTokens", ['a', 'b', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'B':
+      case 'BB':
+      case 'BBB':
+        return match.dayPeriod(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.dayPeriod(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+
+      case 'BBBBB':
+        return match.dayPeriod(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+
+      case 'BBBB':
+      default:
+        return match.dayPeriod(dateString, {
+          width: 'wide',
+          context: 'formatting'
+        }) || match.dayPeriod(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.dayPeriod(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setUTCHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { DayPeriodParser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/EraParser.js

@@ -0,0 +1,53 @@
+import { Parser } from '../Parser.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class EraParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 140);
+
+    _defineProperty(this, "incompatibleTokens", ['R', 'u', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      // AD, BC
+      case 'G':
+      case 'GG':
+      case 'GGG':
+        return match.era(dateString, {
+          width: 'abbreviated'
+        }) || match.era(dateString, {
+          width: 'narrow'
+        });
+      // A, B
+
+      case 'GGGGG':
+        return match.era(dateString, {
+          width: 'narrow'
+        });
+      // Anno Domini, Before Christ
+
+      case 'GGGG':
+      default:
+        return match.era(dateString, {
+          width: 'wide'
+        }) || match.era(dateString, {
+          width: 'abbreviated'
+        }) || match.era(dateString, {
+          width: 'narrow'
+        });
+    }
+  }
+
+  set(date, flags, value) {
+    flags.era = value;
+    date.setUTCFullYear(value, 0, 1);
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { EraParser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/ExtendedYearParser.js

@@ -0,0 +1,30 @@
+import { Parser } from '../Parser.js';
+import { parseNDigitsSigned } from '../utils.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class ExtendedYearParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 130);
+
+    _defineProperty(this, "incompatibleTokens", ['G', 'y', 'Y', 'R', 'w', 'I', 'i', 'e', 'c', 't', 'T']);
+  }
+
+  parse(dateString, token) {
+    if (token === 'u') {
+      return parseNDigitsSigned(4, dateString);
+    }
+
+    return parseNDigitsSigned(token.length, dateString);
+  }
+
+  set(date, _flags, value) {
+    date.setUTCFullYear(value, 0, 1);
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { ExtendedYearParser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/FractionOfSecondParser.js

@@ -0,0 +1,29 @@
+import { Parser } from '../Parser.js';
+import { mapValue, parseNDigits } from '../utils.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class FractionOfSecondParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 30);
+
+    _defineProperty(this, "incompatibleTokens", ['t', 'T']);
+  }
+
+  parse(dateString, token) {
+    var valueCallback = function (value) {
+      return Math.floor(value * Math.pow(10, -token.length + 3));
+    };
+
+    return mapValue(parseNDigits(token.length, dateString), valueCallback);
+  }
+
+  set(date, _flags, value) {
+    date.setUTCMilliseconds(value);
+    return date;
+  }
+
+}
+
+export { FractionOfSecondParser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/Hour0To11Parser.js

@@ -0,0 +1,48 @@
+import { Parser } from '../Parser.js';
+import { numericPatterns } from '../constants.js';
+import { parseNDigits, parseNumericPattern } from '../utils.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class Hour0To11Parser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 70);
+
+    _defineProperty(this, "incompatibleTokens", ['h', 'H', 'k', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'K':
+        return parseNumericPattern(numericPatterns.hour11h, dateString);
+
+      case 'Ko':
+        return match.ordinalNumber(dateString, {
+          unit: 'hour'
+        });
+
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 11;
+  }
+
+  set(date, _flags, value) {
+    var isPM = date.getUTCHours() >= 12;
+
+    if (isPM && value < 12) {
+      date.setUTCHours(value + 12, 0, 0, 0);
+    } else {
+      date.setUTCHours(value, 0, 0, 0);
+    }
+
+    return date;
+  }
+
+}
+
+export { Hour0To11Parser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/Hour0to23Parser.js

@@ -0,0 +1,41 @@
+import { Parser } from '../Parser.js';
+import { numericPatterns } from '../constants.js';
+import { parseNDigits, parseNumericPattern } from '../utils.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class Hour0to23Parser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 70);
+
+    _defineProperty(this, "incompatibleTokens", ['a', 'b', 'h', 'K', 'k', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'H':
+        return parseNumericPattern(numericPatterns.hour23h, dateString);
+
+      case 'Ho':
+        return match.ordinalNumber(dateString, {
+          unit: 'hour'
+        });
+
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 0 && value <= 23;
+  }
+
+  set(date, _flags, value) {
+    date.setUTCHours(value, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { Hour0to23Parser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/Hour1To24Parser.js

@@ -0,0 +1,42 @@
+import { Parser } from '../Parser.js';
+import { numericPatterns } from '../constants.js';
+import { parseNDigits, parseNumericPattern } from '../utils.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class Hour1To24Parser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 70);
+
+    _defineProperty(this, "incompatibleTokens", ['a', 'b', 'h', 'H', 'K', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'k':
+        return parseNumericPattern(numericPatterns.hour24h, dateString);
+
+      case 'ko':
+        return match.ordinalNumber(dateString, {
+          unit: 'hour'
+        });
+
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 24;
+  }
+
+  set(date, _flags, value) {
+    var hours = value <= 24 ? value % 24 : value;
+    date.setUTCHours(hours, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { Hour1To24Parser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/Hour1to12Parser.js

@@ -0,0 +1,50 @@
+import { Parser } from '../Parser.js';
+import { numericPatterns } from '../constants.js';
+import { parseNDigits, parseNumericPattern } from '../utils.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class Hour1to12Parser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 70);
+
+    _defineProperty(this, "incompatibleTokens", ['H', 'K', 'k', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'h':
+        return parseNumericPattern(numericPatterns.hour12h, dateString);
+
+      case 'ho':
+        return match.ordinalNumber(dateString, {
+          unit: 'hour'
+        });
+
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 12;
+  }
+
+  set(date, _flags, value) {
+    var isPM = date.getUTCHours() >= 12;
+
+    if (isPM && value < 12) {
+      date.setUTCHours(value + 12, 0, 0, 0);
+    } else if (!isPM && value === 12) {
+      date.setUTCHours(0, 0, 0, 0);
+    } else {
+      date.setUTCHours(value, 0, 0, 0);
+    }
+
+    return date;
+  }
+
+}
+
+export { Hour1to12Parser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/ISODayParser.js

@@ -0,0 +1,99 @@
+import { Parser } from '../Parser.js';
+import { mapValue, parseNDigits } from '../utils.js';
+import setUTCISODay from '../../../_lib/setUTCISODay/index.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class ISODayParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 90);
+
+    _defineProperty(this, "incompatibleTokens", ['y', 'Y', 'u', 'q', 'Q', 'M', 'L', 'w', 'd', 'D', 'E', 'e', 'c', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    var valueCallback = function (value) {
+      if (value === 0) {
+        return 7;
+      }
+
+      return value;
+    };
+
+    switch (token) {
+      // 2
+      case 'i':
+      case 'ii':
+        // 02
+        return parseNDigits(token.length, dateString);
+      // 2nd
+
+      case 'io':
+        return match.ordinalNumber(dateString, {
+          unit: 'day'
+        });
+      // Tue
+
+      case 'iii':
+        return mapValue(match.day(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'short',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        }), valueCallback);
+      // T
+
+      case 'iiiii':
+        return mapValue(match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        }), valueCallback);
+      // Tu
+
+      case 'iiiiii':
+        return mapValue(match.day(dateString, {
+          width: 'short',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        }), valueCallback);
+      // Tuesday
+
+      case 'iiii':
+      default:
+        return mapValue(match.day(dateString, {
+          width: 'wide',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'short',
+          context: 'formatting'
+        }) || match.day(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        }), valueCallback);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 7;
+  }
+
+  set(date, _flags, value) {
+    date = setUTCISODay(date, value);
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { ISODayParser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/ISOTimezoneParser.js

@@ -0,0 +1,46 @@
+import { Parser } from '../Parser.js';
+import { timezonePatterns } from '../constants.js';
+import { parseTimezonePattern } from '../utils.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class ISOTimezoneParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 10);
+
+    _defineProperty(this, "incompatibleTokens", ['t', 'T', 'X']);
+  }
+
+  parse(dateString, token) {
+    switch (token) {
+      case 'x':
+        return parseTimezonePattern(timezonePatterns.basicOptionalMinutes, dateString);
+
+      case 'xx':
+        return parseTimezonePattern(timezonePatterns.basic, dateString);
+
+      case 'xxxx':
+        return parseTimezonePattern(timezonePatterns.basicOptionalSeconds, dateString);
+
+      case 'xxxxx':
+        return parseTimezonePattern(timezonePatterns.extendedOptionalSeconds, dateString);
+
+      case 'xxx':
+      default:
+        return parseTimezonePattern(timezonePatterns.extended, dateString);
+    }
+  }
+
+  set(date, flags, value) {
+    if (flags.timestampIsSet) {
+      return date;
+    }
+
+    return new Date(date.getTime() - value);
+  }
+
+}
+
+export { ISOTimezoneParser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/ISOTimezoneWithZParser.js

@@ -0,0 +1,46 @@
+import { Parser } from '../Parser.js';
+import { timezonePatterns } from '../constants.js';
+import { parseTimezonePattern } from '../utils.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class ISOTimezoneWithZParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 10);
+
+    _defineProperty(this, "incompatibleTokens", ['t', 'T', 'x']);
+  }
+
+  parse(dateString, token) {
+    switch (token) {
+      case 'X':
+        return parseTimezonePattern(timezonePatterns.basicOptionalMinutes, dateString);
+
+      case 'XX':
+        return parseTimezonePattern(timezonePatterns.basic, dateString);
+
+      case 'XXXX':
+        return parseTimezonePattern(timezonePatterns.basicOptionalSeconds, dateString);
+
+      case 'XXXXX':
+        return parseTimezonePattern(timezonePatterns.extendedOptionalSeconds, dateString);
+
+      case 'XXX':
+      default:
+        return parseTimezonePattern(timezonePatterns.extended, dateString);
+    }
+  }
+
+  set(date, flags, value) {
+    if (flags.timestampIsSet) {
+      return date;
+    }
+
+    return new Date(date.getTime() - value);
+  }
+
+}
+
+export { ISOTimezoneWithZParser };

package/es/node_modules/date-fns/esm/parse/_lib/parsers/ISOWeekParser.js

@@ -0,0 +1,43 @@
+import { Parser } from '../Parser.js';
+import { numericPatterns } from '../constants.js';
+import { parseNDigits, parseNumericPattern } from '../utils.js';
+import setUTCISOWeek from '../../../_lib/setUTCISOWeek/index.js';
+import startOfUTCISOWeek from '../../../_lib/startOfUTCISOWeek/index.js';
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+class ISOWeekParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 100);
+
+    _defineProperty(this, "incompatibleTokens", ['y', 'Y', 'u', 'q', 'Q', 'M', 'L', 'w', 'd', 'D', 'e', 'c', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'I':
+        return parseNumericPattern(numericPatterns.week, dateString);
+
+      case 'Io':
+        return match.ordinalNumber(dateString, {
+          unit: 'week'
+        });
+
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 53;
+  }
+
+  set(date, _flags, value) {
+    return startOfUTCISOWeek(setUTCISOWeek(date, value));
+  }
+
+}
+
+export { ISOWeekParser };