tp-react-elements-dev 1.14.2 → 1.14.4

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

@@ -0,0 +1,48 @@
+import { setISOWeek } from '../../../setISOWeek.esm.js';
+import { startOfISOWeek } from '../../../startOfISOWeek.esm.js';
+import { numericPatterns } from '../constants.esm.js';
+import { Parser } from '../Parser.esm.js';
+import { parseNDigits, parseNumericPattern } from '../utils.esm.js';
+
+// ISO week of year
+class ISOWeekParser extends Parser {
+  priority = 100;
+
+  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 startOfISOWeek(setISOWeek(date, value));
+  }
+
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}
+
+export { ISOWeekParser };

package/dist/node_modules/date-fns/parse/_lib/parsers/ISOWeekParser.esm2.js

@@ -0,0 +1,68 @@
+import { __exports as ISOWeekParser } from '../../../../../_virtual/ISOWeekParser.esm.js';
+import { __require as requireSetISOWeek } from '../../../setISOWeek.esm2.js';
+import { __require as requireStartOfISOWeek } from '../../../startOfISOWeek.esm2.js';
+import { __require as requireConstants } from '../constants.esm2.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+import { __require as requireUtils } from '../utils.esm2.js';
+
+var hasRequiredISOWeekParser;
+
+function requireISOWeekParser () {
+	if (hasRequiredISOWeekParser) return ISOWeekParser;
+	hasRequiredISOWeekParser = 1;
+	ISOWeekParser.ISOWeekParser = void 0;
+	var _index = /*@__PURE__*/ requireSetISOWeek();
+	var _index2 = /*@__PURE__*/ requireStartOfISOWeek();
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// ISO week of year
+	let ISOWeekParser$1 = class ISOWeekParser extends _Parser.Parser {
+	  priority = 100;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "I":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.week,
+	          dateString,
+	        );
+	      case "Io":
+	        return match.ordinalNumber(dateString, { unit: "week" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 1 && value <= 53;
+	  }
+
+	  set(date, _flags, value) {
+	    return (0, _index2.startOfISOWeek)((0, _index.setISOWeek)(date, value));
+	  }
+
+	  incompatibleTokens = [
+	    "y",
+	    "Y",
+	    "u",
+	    "q",
+	    "Q",
+	    "M",
+	    "L",
+	    "w",
+	    "d",
+	    "D",
+	    "e",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+	};
+	ISOWeekParser.ISOWeekParser = ISOWeekParser$1;
+	return ISOWeekParser;
+}
+
+export { requireISOWeekParser as __require };

package/dist/node_modules/date-fns/parse/_lib/parsers/ISOWeekYearParser.esm.js

@@ -0,0 +1,44 @@
+import { startOfISOWeek } from '../../../startOfISOWeek.esm.js';
+import { constructFrom } from '../../../constructFrom.esm.js';
+import { Parser } from '../Parser.esm.js';
+import { parseNDigitsSigned } from '../utils.esm.js';
+
+// ISO week-numbering year
+class ISOWeekYearParser extends Parser {
+  priority = 130;
+
+  parse(dateString, token) {
+    if (token === "R") {
+      return parseNDigitsSigned(4, dateString);
+    }
+
+    return parseNDigitsSigned(token.length, dateString);
+  }
+
+  set(date, _flags, value) {
+    const firstWeekOfYear = constructFrom(date, 0);
+    firstWeekOfYear.setFullYear(value, 0, 4);
+    firstWeekOfYear.setHours(0, 0, 0, 0);
+    return startOfISOWeek(firstWeekOfYear);
+  }
+
+  incompatibleTokens = [
+    "G",
+    "y",
+    "Y",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T",
+  ];
+}
+
+export { ISOWeekYearParser };

package/dist/node_modules/date-fns/parse/_lib/parsers/ISOWeekYearParser.esm2.js

@@ -0,0 +1,60 @@
+import { __exports as ISOWeekYearParser } from '../../../../../_virtual/ISOWeekYearParser.esm.js';
+import { __require as requireStartOfISOWeek } from '../../../startOfISOWeek.esm2.js';
+import { __require as requireConstructFrom } from '../../../constructFrom.esm2.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+import { __require as requireUtils } from '../utils.esm2.js';
+
+var hasRequiredISOWeekYearParser;
+
+function requireISOWeekYearParser () {
+	if (hasRequiredISOWeekYearParser) return ISOWeekYearParser;
+	hasRequiredISOWeekYearParser = 1;
+	ISOWeekYearParser.ISOWeekYearParser = void 0;
+	var _index = /*@__PURE__*/ requireStartOfISOWeek();
+	var _index2 = /*@__PURE__*/ requireConstructFrom();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// ISO week-numbering year
+	let ISOWeekYearParser$1 = class ISOWeekYearParser extends _Parser.Parser {
+	  priority = 130;
+
+	  parse(dateString, token) {
+	    if (token === "R") {
+	      return (0, _utils.parseNDigitsSigned)(4, dateString);
+	    }
+
+	    return (0, _utils.parseNDigitsSigned)(token.length, dateString);
+	  }
+
+	  set(date, _flags, value) {
+	    const firstWeekOfYear = (0, _index2.constructFrom)(date, 0);
+	    firstWeekOfYear.setFullYear(value, 0, 4);
+	    firstWeekOfYear.setHours(0, 0, 0, 0);
+	    return (0, _index.startOfISOWeek)(firstWeekOfYear);
+	  }
+
+	  incompatibleTokens = [
+	    "G",
+	    "y",
+	    "Y",
+	    "u",
+	    "Q",
+	    "q",
+	    "M",
+	    "L",
+	    "w",
+	    "d",
+	    "D",
+	    "e",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+	};
+	ISOWeekYearParser.ISOWeekYearParser = ISOWeekYearParser$1;
+	return ISOWeekYearParser;
+}
+
+export { requireISOWeekYearParser as __require };

package/dist/node_modules/date-fns/parse/_lib/parsers/LocalDayParser.esm.js

@@ -0,0 +1,96 @@
+import { setDay } from '../../../setDay.esm.js';
+import { Parser } from '../Parser.esm.js';
+import { mapValue, parseNDigits } from '../utils.esm.js';
+
+// Local day of week
+class LocalDayParser extends Parser {
+  priority = 90;
+  parse(dateString, token, match, options) {
+    const valueCallback = (value) => {
+      // We want here floor instead of trunc, so we get -7 for value 0 instead of 0
+      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
+      return ((value + options.weekStartsOn + 6) % 7) + wholeWeekDays;
+    };
+
+    switch (token) {
+      // 3
+      case "e":
+      case "ee": // 03
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+      // 3rd
+      case "eo":
+        return mapValue(
+          match.ordinalNumber(dateString, {
+            unit: "day",
+          }),
+          valueCallback,
+        );
+      // Tue
+      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 = setDay(date, value, options);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "E",
+    "i",
+    "c",
+    "t",
+    "T",
+  ];
+}
+
+export { LocalDayParser };

package/dist/node_modules/date-fns/parse/_lib/parsers/LocalDayParser.esm2.js

@@ -0,0 +1,114 @@
+import { __exports as LocalDayParser } from '../../../../../_virtual/LocalDayParser.esm.js';
+import { __require as requireSetDay } from '../../../setDay.esm2.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+import { __require as requireUtils } from '../utils.esm2.js';
+
+var hasRequiredLocalDayParser;
+
+function requireLocalDayParser () {
+	if (hasRequiredLocalDayParser) return LocalDayParser;
+	hasRequiredLocalDayParser = 1;
+	LocalDayParser.LocalDayParser = void 0;
+	var _index = /*@__PURE__*/ requireSetDay();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// Local day of week
+	let LocalDayParser$1 = class LocalDayParser extends _Parser.Parser {
+	  priority = 90;
+	  parse(dateString, token, match, options) {
+	    const valueCallback = (value) => {
+	      // We want here floor instead of trunc, so we get -7 for value 0 instead of 0
+	      const wholeWeekDays = Math.floor((value - 1) / 7) * 7;
+	      return ((value + options.weekStartsOn + 6) % 7) + wholeWeekDays;
+	    };
+
+	    switch (token) {
+	      // 3
+	      case "e":
+	      case "ee": // 03
+	        return (0, _utils.mapValue)(
+	          (0, _utils.parseNDigits)(token.length, dateString),
+	          valueCallback,
+	        );
+	      // 3rd
+	      case "eo":
+	        return (0, _utils.mapValue)(
+	          match.ordinalNumber(dateString, {
+	            unit: "day",
+	          }),
+	          valueCallback,
+	        );
+	      // Tue
+	      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 = (0, _index.setDay)(date, value, options);
+	    date.setHours(0, 0, 0, 0);
+	    return date;
+	  }
+
+	  incompatibleTokens = [
+	    "y",
+	    "R",
+	    "u",
+	    "q",
+	    "Q",
+	    "M",
+	    "L",
+	    "I",
+	    "d",
+	    "D",
+	    "E",
+	    "i",
+	    "c",
+	    "t",
+	    "T",
+	  ];
+	};
+	LocalDayParser.LocalDayParser = LocalDayParser$1;
+	return LocalDayParser;
+}
+
+export { requireLocalDayParser as __require };

package/dist/node_modules/date-fns/parse/_lib/parsers/LocalWeekParser.esm.js

@@ -0,0 +1,47 @@
+import { setWeek } from '../../../setWeek.esm.js';
+import { startOfWeek } from '../../../startOfWeek.esm.js';
+import { numericPatterns } from '../constants.esm.js';
+import { Parser } from '../Parser.esm.js';
+import { parseNDigits, parseNumericPattern } from '../utils.esm.js';
+
+// Local week of year
+class LocalWeekParser extends Parser {
+  priority = 100;
+
+  parse(dateString, token, match) {
+    switch (token) {
+      case "w":
+        return parseNumericPattern(numericPatterns.week, dateString);
+      case "wo":
+        return match.ordinalNumber(dateString, { unit: "week" });
+      default:
+        return parseNDigits(token.length, dateString);
+    }
+  }
+
+  validate(_date, value) {
+    return value >= 1 && value <= 53;
+  }
+
+  set(date, _flags, value, options) {
+    return startOfWeek(setWeek(date, value, options), options);
+  }
+
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T",
+  ];
+}
+
+export { LocalWeekParser };

package/dist/node_modules/date-fns/parse/_lib/parsers/LocalWeekParser.esm2.js

@@ -0,0 +1,70 @@
+import { __exports as LocalWeekParser } from '../../../../../_virtual/LocalWeekParser.esm.js';
+import { __require as requireSetWeek } from '../../../setWeek.esm2.js';
+import { __require as requireStartOfWeek } from '../../../startOfWeek.esm2.js';
+import { __require as requireConstants } from '../constants.esm2.js';
+import { __require as requireParser } from '../Parser.esm2.js';
+import { __require as requireUtils } from '../utils.esm2.js';
+
+var hasRequiredLocalWeekParser;
+
+function requireLocalWeekParser () {
+	if (hasRequiredLocalWeekParser) return LocalWeekParser;
+	hasRequiredLocalWeekParser = 1;
+	LocalWeekParser.LocalWeekParser = void 0;
+	var _index = /*@__PURE__*/ requireSetWeek();
+	var _index2 = /*@__PURE__*/ requireStartOfWeek();
+	var _constants = /*@__PURE__*/ requireConstants();
+	var _Parser = /*@__PURE__*/ requireParser();
+
+	var _utils = /*@__PURE__*/ requireUtils();
+
+	// Local week of year
+	let LocalWeekParser$1 = class LocalWeekParser extends _Parser.Parser {
+	  priority = 100;
+
+	  parse(dateString, token, match) {
+	    switch (token) {
+	      case "w":
+	        return (0, _utils.parseNumericPattern)(
+	          _constants.numericPatterns.week,
+	          dateString,
+	        );
+	      case "wo":
+	        return match.ordinalNumber(dateString, { unit: "week" });
+	      default:
+	        return (0, _utils.parseNDigits)(token.length, dateString);
+	    }
+	  }
+
+	  validate(_date, value) {
+	    return value >= 1 && value <= 53;
+	  }
+
+	  set(date, _flags, value, options) {
+	    return (0, _index2.startOfWeek)(
+	      (0, _index.setWeek)(date, value, options),
+	      options,
+	    );
+	  }
+
+	  incompatibleTokens = [
+	    "y",
+	    "R",
+	    "u",
+	    "q",
+	    "Q",
+	    "M",
+	    "L",
+	    "I",
+	    "d",
+	    "D",
+	    "i",
+	    "t",
+	    "T",
+	  ];
+	};
+	LocalWeekParser.LocalWeekParser = LocalWeekParser$1;
+	return LocalWeekParser;
+}
+
+export { requireLocalWeekParser as __require };

package/dist/node_modules/date-fns/parse/_lib/parsers/LocalWeekYearParser.esm.js

@@ -0,0 +1,76 @@
+import { getWeekYear } from '../../../getWeekYear.esm.js';
+import { startOfWeek } from '../../../startOfWeek.esm.js';
+import { Parser } from '../Parser.esm.js';
+import { mapValue, parseNDigits, normalizeTwoDigitYear } from '../utils.esm.js';
+
+// Local week-numbering year
+class LocalWeekYearParser extends Parser {
+  priority = 130;
+
+  parse(dateString, token, match) {
+    const valueCallback = (year) => ({
+      year,
+      isTwoDigitYear: token === "YY",
+    });
+
+    switch (token) {
+      case "Y":
+        return mapValue(parseNDigits(4, dateString), valueCallback);
+      case "Yo":
+        return mapValue(
+          match.ordinalNumber(dateString, {
+            unit: "year",
+          }),
+          valueCallback,
+        );
+      default:
+        return mapValue(parseNDigits(token.length, dateString), valueCallback);
+    }
+  }
+
+  validate(_date, value) {
+    return value.isTwoDigitYear || value.year > 0;
+  }
+
+  set(date, flags, value, options) {
+    const currentYear = getWeekYear(date, options);
+
+    if (value.isTwoDigitYear) {
+      const normalizedTwoDigitYear = normalizeTwoDigitYear(
+        value.year,
+        currentYear,
+      );
+      date.setFullYear(
+        normalizedTwoDigitYear,
+        0,
+        options.firstWeekContainsDate,
+      );
+      date.setHours(0, 0, 0, 0);
+      return startOfWeek(date, options);
+    }
+
+    const year =
+      !("era" in flags) || flags.era === 1 ? value.year : 1 - value.year;
+    date.setFullYear(year, 0, options.firstWeekContainsDate);
+    date.setHours(0, 0, 0, 0);
+    return startOfWeek(date, options);
+  }
+
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T",
+  ];
+}
+
+export { LocalWeekYearParser };