@stokr/components-library 3.0.66 → 3.0.67

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

@@ -0,0 +1,44 @@
+import { Parser } from "../Parser.js";
+import { dayPeriodEnumToHours } from "../utils.js";
+class AMPMMidnightParser extends Parser {
+  priority = 80;
+  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.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date;
+  }
+  incompatibleTokens = ["a", "B", "H", "k", "t", "T"];
+}
+export {
+  AMPMMidnightParser
+};

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

@@ -0,0 +1,44 @@
+import { Parser } from "../Parser.js";
+import { dayPeriodEnumToHours } from "../utils.js";
+class AMPMParser extends Parser {
+  priority = 80;
+  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.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date;
+  }
+  incompatibleTokens = ["b", "B", "H", "k", "t", "T"];
+}
+export {
+  AMPMParser
+};

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

@@ -0,0 +1,64 @@
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+import { parseNDigits, parseNumericPattern, isLeapYearIndex } from "../utils.js";
+const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+const DAYS_IN_MONTH_LEAP_YEAR = [
+  31,
+  29,
+  31,
+  30,
+  31,
+  30,
+  31,
+  31,
+  30,
+  31,
+  30,
+  31
+];
+class DateParser extends Parser {
+  priority = 90;
+  subPriority = 1;
+  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) {
+    const year = date.getFullYear();
+    const isLeapYear = isLeapYearIndex(year);
+    const month = date.getMonth();
+    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.setDate(value);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+export {
+  DateParser
+};

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

@@ -0,0 +1,52 @@
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+import { parseNDigits, parseNumericPattern, isLeapYearIndex } from "../utils.js";
+class DayOfYearParser extends Parser {
+  priority = 90;
+  subpriority = 1;
+  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) {
+    const year = date.getFullYear();
+    const isLeapYear = isLeapYearIndex(year);
+    if (isLeapYear) {
+      return value >= 1 && value <= 366;
+    } else {
+      return value >= 1 && value <= 365;
+    }
+  }
+  set(date, _flags, value) {
+    date.setMonth(0, value);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "E",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+export {
+  DayOfYearParser
+};

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

@@ -0,0 +1,45 @@
+import { setDay } from "../../../setDay.js";
+import { Parser } from "../Parser.js";
+class DayParser extends Parser {
+  priority = 90;
+  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 = setDay(date, value, options);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+  incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
+}
+export {
+  DayParser
+};

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

@@ -0,0 +1,44 @@
+import { Parser } from "../Parser.js";
+import { dayPeriodEnumToHours } from "../utils.js";
+class DayPeriodParser extends Parser {
+  priority = 80;
+  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.setHours(dayPeriodEnumToHours(value), 0, 0, 0);
+    return date;
+  }
+  incompatibleTokens = ["a", "b", "t", "T"];
+}
+export {
+  DayPeriodParser
+};

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

@@ -0,0 +1,30 @@
+import { Parser } from "../Parser.js";
+class EraParser extends Parser {
+  priority = 140;
+  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.setFullYear(value, 0, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+  incompatibleTokens = ["R", "u", "t", "T"];
+}
+export {
+  EraParser
+};

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

@@ -0,0 +1,20 @@
+import { Parser } from "../Parser.js";
+import { parseNDigitsSigned } from "../utils.js";
+class ExtendedYearParser extends Parser {
+  priority = 130;
+  parse(dateString, token) {
+    if (token === "u") {
+      return parseNDigitsSigned(4, dateString);
+    }
+    return parseNDigitsSigned(token.length, dateString);
+  }
+  set(date, _flags, value) {
+    date.setFullYear(value, 0, 1);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+  incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
+}
+export {
+  ExtendedYearParser
+};

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

@@ -0,0 +1,17 @@
+import { Parser } from "../Parser.js";
+import { mapValue, parseNDigits } from "../utils.js";
+class FractionOfSecondParser extends Parser {
+  priority = 30;
+  parse(dateString, token) {
+    const valueCallback = (value) => Math.trunc(value * Math.pow(10, -token.length + 3));
+    return mapValue(parseNDigits(token.length, dateString), valueCallback);
+  }
+  set(date, _flags, value) {
+    date.setMilliseconds(value);
+    return date;
+  }
+  incompatibleTokens = ["t", "T"];
+}
+export {
+  FractionOfSecondParser
+};

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

@@ -0,0 +1,32 @@
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+import { parseNDigits, parseNumericPattern } from "../utils.js";
+class Hour0To11Parser extends Parser {
+  priority = 70;
+  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) {
+    const isPM = date.getHours() >= 12;
+    if (isPM && value < 12) {
+      date.setHours(value + 12, 0, 0, 0);
+    } else {
+      date.setHours(value, 0, 0, 0);
+    }
+    return date;
+  }
+  incompatibleTokens = ["h", "H", "k", "t", "T"];
+}
+export {
+  Hour0To11Parser
+};

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

@@ -0,0 +1,27 @@
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+import { parseNDigits, parseNumericPattern } from "../utils.js";
+class Hour0to23Parser extends Parser {
+  priority = 70;
+  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.setHours(value, 0, 0, 0);
+    return date;
+  }
+  incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
+}
+export {
+  Hour0to23Parser
+};

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

@@ -0,0 +1,28 @@
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+import { parseNDigits, parseNumericPattern } from "../utils.js";
+class Hour1To24Parser extends Parser {
+  priority = 70;
+  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) {
+    const hours = value <= 24 ? value % 24 : value;
+    date.setHours(hours, 0, 0, 0);
+    return date;
+  }
+  incompatibleTokens = ["a", "b", "h", "H", "K", "t", "T"];
+}
+export {
+  Hour1To24Parser
+};

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

@@ -0,0 +1,34 @@
+import { numericPatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+import { parseNDigits, parseNumericPattern } from "../utils.js";
+class Hour1to12Parser extends Parser {
+  priority = 70;
+  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) {
+    const isPM = date.getHours() >= 12;
+    if (isPM && value < 12) {
+      date.setHours(value + 12, 0, 0, 0);
+    } else if (!isPM && value === 12) {
+      date.setHours(0, 0, 0, 0);
+    } else {
+      date.setHours(value, 0, 0, 0);
+    }
+    return date;
+  }
+  incompatibleTokens = ["H", "K", "k", "t", "T"];
+}
+export {
+  Hour1to12Parser
+};

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

@@ -0,0 +1,106 @@
+import { setISODay } from "../../../setISODay.js";
+import { Parser } from "../Parser.js";
+import { mapValue, parseNDigits } from "../utils.js";
+class ISODayParser extends Parser {
+  priority = 90;
+  parse(dateString, token, match) {
+    const valueCallback = (value) => {
+      if (value === 0) {
+        return 7;
+      }
+      return value;
+    };
+    switch (token) {
+      // 2
+      case "i":
+      case "ii":
+        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 = setISODay(date, value);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "E",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+export {
+  ISODayParser
+};

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

@@ -0,0 +1,43 @@
+import { constructFrom } from "../../../constructFrom.js";
+import { getTimezoneOffsetInMilliseconds } from "../../../_lib/getTimezoneOffsetInMilliseconds.js";
+import { timezonePatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+import { parseTimezonePattern } from "../utils.js";
+class ISOTimezoneParser extends Parser {
+  priority = 10;
+  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 constructFrom(
+      date,
+      date.getTime() - getTimezoneOffsetInMilliseconds(date) - value
+    );
+  }
+  incompatibleTokens = ["t", "T", "X"];
+}
+export {
+  ISOTimezoneParser
+};

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

@@ -0,0 +1,43 @@
+import { constructFrom } from "../../../constructFrom.js";
+import { getTimezoneOffsetInMilliseconds } from "../../../_lib/getTimezoneOffsetInMilliseconds.js";
+import { timezonePatterns } from "../constants.js";
+import { Parser } from "../Parser.js";
+import { parseTimezonePattern } from "../utils.js";
+class ISOTimezoneWithZParser extends Parser {
+  priority = 10;
+  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 constructFrom(
+      date,
+      date.getTime() - getTimezoneOffsetInMilliseconds(date) - value
+    );
+  }
+  incompatibleTokens = ["t", "T", "x"];
+}
+export {
+  ISOTimezoneWithZParser
+};