cnhis-design-vue 3.1.11 → 3.1.12-beta.2

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

@@ -0,0 +1,55 @@
+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 AMPMParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 80);
+
+    _defineProperty(this, "incompatibleTokens", ['b', 'B', 'H', 'k', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'a':
+      case 'aa':
+      case 'aaa':
+        return match.dayPeriod(dateString, {
+          width: 'abbreviated',
+          context: 'formatting'
+        }) || match.dayPeriod(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+
+      case 'aaaaa':
+        return match.dayPeriod(dateString, {
+          width: 'narrow',
+          context: 'formatting'
+        });
+
+      case 'aaaa':
+      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 { AMPMParser };

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

@@ -0,0 +1,55 @@
+import { parseNDigits, parseNumericPattern, isLeapYearIndex } from '../utils.js';
+import { Parser } from '../Parser.js';
+import { numericPatterns } from '../constants.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; }
+var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var DAYS_IN_MONTH_LEAP_YEAR = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]; // Day of the month
+
+class DateParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 90);
+
+    _defineProperty(this, "subPriority", 1);
+
+    _defineProperty(this, "incompatibleTokens", ['Y', 'R', 'q', 'Q', 'w', 'I', 'D', 'i', 'e', 'c', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'd':
+        return parseNumericPattern(numericPatterns.date, dateString);
+
+      case 'do':
+        return match.ordinalNumber(dateString, {
+          unit: 'date'
+        });
+
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(date, value) {
+    var year = date.getUTCFullYear();
+    var isLeapYear = isLeapYearIndex(year);
+    var month = date.getUTCMonth();
+
+    if (isLeapYear) {
+      return value >= 1 && value <= DAYS_IN_MONTH_LEAP_YEAR[month];
+    } else {
+      return value >= 1 && value <= DAYS_IN_MONTH[month];
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setUTCDate(value);
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { DateParser };

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

@@ -0,0 +1,52 @@
+import { Parser } from '../Parser.js';
+import { numericPatterns } from '../constants.js';
+import { parseNDigits, parseNumericPattern, isLeapYearIndex } 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 DayOfYearParser extends Parser {
+  constructor() {
+    super(...arguments);
+
+    _defineProperty(this, "priority", 90);
+
+    _defineProperty(this, "subpriority", 1);
+
+    _defineProperty(this, "incompatibleTokens", ['Y', 'R', 'q', 'Q', 'M', 'L', 'w', 'I', 'd', 'E', 'i', 'e', 'c', 't', 'T']);
+  }
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case 'D':
+      case 'DD':
+        return parseNumericPattern(numericPatterns.dayOfYear, dateString);
+
+      case 'Do':
+        return match.ordinalNumber(dateString, {
+          unit: 'date'
+        });
+
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(date, value) {
+    var year = date.getUTCFullYear();
+    var isLeapYear = isLeapYearIndex(year);
+
+    if (isLeapYear) {
+      return value >= 1 && value <= 366;
+    } else {
+      return value >= 1 && value <= 365;
+    }
+  }
+
+  set(date, _flags, value) {
+    date.setUTCMonth(0, value);
+    date.setUTCHours(0, 0, 0, 0);
+    return date;
+  }
+
+}
+
+export { DayOfYearParser };

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 };