@easyops-cn/a2ui-react 0.0.1 → 0.0.3

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

@@ -0,0 +1,42 @@
+import { Parser as t } from "../Parser.js";
+import { dayPeriodEnumToHours as i } from "../utils.js";
+class s extends t {
+  priority = 80;
+  parse(r, e, o) {
+    switch (e) {
+      case "B":
+      case "BB":
+      case "BBB":
+        return o.dayPeriod(r, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || o.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+      case "BBBBB":
+        return o.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return o.dayPeriod(r, {
+          width: "wide",
+          context: "formatting"
+        }) || o.dayPeriod(r, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || o.dayPeriod(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  set(r, e, o) {
+    return r.setHours(i(o), 0, 0, 0), r;
+  }
+  incompatibleTokens = ["a", "b", "t", "T"];
+}
+export {
+  s as DayPeriodParser
+};

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

@@ -0,0 +1,25 @@
+import { Parser as G } from "../Parser.js";
+class i extends G {
+  priority = 140;
+  parse(r, s, e) {
+    switch (s) {
+      // AD, BC
+      case "G":
+      case "GG":
+      case "GGG":
+        return e.era(r, { width: "abbreviated" }) || e.era(r, { width: "narrow" });
+      // A, B
+      case "GGGGG":
+        return e.era(r, { width: "narrow" });
+      default:
+        return e.era(r, { width: "wide" }) || e.era(r, { width: "abbreviated" }) || e.era(r, { width: "narrow" });
+    }
+  }
+  set(r, s, e) {
+    return s.era = e, r.setFullYear(e, 0, 1), r.setHours(0, 0, 0, 0), r;
+  }
+  incompatibleTokens = ["R", "u", "t", "T"];
+}
+export {
+  i as EraParser
+};

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

@@ -0,0 +1,15 @@
+import { Parser as i } from "../Parser.js";
+import { parseNDigitsSigned as s } from "../utils.js";
+class a extends i {
+  priority = 130;
+  parse(r, e) {
+    return e === "u" ? s(4, r) : s(e.length, r);
+  }
+  set(r, e, t) {
+    return r.setFullYear(t, 0, 1), r.setHours(0, 0, 0, 0), r;
+  }
+  incompatibleTokens = ["G", "y", "Y", "R", "w", "I", "i", "e", "c", "t", "T"];
+}
+export {
+  a as ExtendedYearParser
+};

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

@@ -0,0 +1,16 @@
+import { Parser as a } from "../Parser.js";
+import { mapValue as o, parseNDigits as i } from "../utils.js";
+class c extends a {
+  priority = 30;
+  parse(r, e) {
+    const t = (s) => Math.trunc(s * Math.pow(10, -e.length + 3));
+    return o(i(e.length, r), t);
+  }
+  set(r, e, t) {
+    return r.setMilliseconds(t), r;
+  }
+  incompatibleTokens = ["t", "T"];
+}
+export {
+  c as FractionOfSecondParser
+};

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

@@ -0,0 +1,26 @@
+import { numericPatterns as t } from "../constants.js";
+import { Parser as o } from "../Parser.js";
+import { parseNDigits as i, parseNumericPattern as u } from "../utils.js";
+class f extends o {
+  priority = 70;
+  parse(r, s, e) {
+    switch (s) {
+      case "K":
+        return u(t.hour11h, r);
+      case "Ko":
+        return e.ordinalNumber(r, { unit: "hour" });
+      default:
+        return i(s.length, r);
+    }
+  }
+  validate(r, s) {
+    return s >= 0 && s <= 11;
+  }
+  set(r, s, e) {
+    return r.getHours() >= 12 && e < 12 ? r.setHours(e + 12, 0, 0, 0) : r.setHours(e, 0, 0, 0), r;
+  }
+  incompatibleTokens = ["h", "H", "k", "t", "T"];
+}
+export {
+  f as Hour0To11Parser
+};

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

@@ -0,0 +1,26 @@
+import { numericPatterns as s } from "../constants.js";
+import { Parser as o } from "../Parser.js";
+import { parseNDigits as a, parseNumericPattern as i } from "../utils.js";
+class c extends o {
+  priority = 70;
+  parse(r, e, t) {
+    switch (e) {
+      case "H":
+        return i(s.hour23h, r);
+      case "Ho":
+        return t.ordinalNumber(r, { unit: "hour" });
+      default:
+        return a(e.length, r);
+    }
+  }
+  validate(r, e) {
+    return e >= 0 && e <= 23;
+  }
+  set(r, e, t) {
+    return r.setHours(t, 0, 0, 0), r;
+  }
+  incompatibleTokens = ["a", "b", "h", "K", "k", "t", "T"];
+}
+export {
+  c as Hour0to23Parser
+};

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

@@ -0,0 +1,27 @@
+import { numericPatterns as o } from "../constants.js";
+import { Parser as i } from "../Parser.js";
+import { parseNDigits as a, parseNumericPattern as n } from "../utils.js";
+class h extends i {
+  priority = 70;
+  parse(r, e, t) {
+    switch (e) {
+      case "k":
+        return n(o.hour24h, r);
+      case "ko":
+        return t.ordinalNumber(r, { unit: "hour" });
+      default:
+        return a(e.length, r);
+    }
+  }
+  validate(r, e) {
+    return e >= 1 && e <= 24;
+  }
+  set(r, e, t) {
+    const s = t <= 24 ? t % 24 : t;
+    return r.setHours(s, 0, 0, 0), r;
+  }
+  incompatibleTokens = ["a", "b", "h", "H", "K", "t", "T"];
+}
+export {
+  h as Hour1To24Parser
+};

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

@@ -0,0 +1,27 @@
+import { numericPatterns as o } from "../constants.js";
+import { Parser as i } from "../Parser.js";
+import { parseNDigits as u, parseNumericPattern as n } from "../utils.js";
+class f extends i {
+  priority = 70;
+  parse(r, s, e) {
+    switch (s) {
+      case "h":
+        return n(o.hour12h, r);
+      case "ho":
+        return e.ordinalNumber(r, { unit: "hour" });
+      default:
+        return u(s.length, r);
+    }
+  }
+  validate(r, s) {
+    return s >= 1 && s <= 12;
+  }
+  set(r, s, e) {
+    const t = r.getHours() >= 12;
+    return t && e < 12 ? r.setHours(e + 12, 0, 0, 0) : !t && e === 12 ? r.setHours(0, 0, 0, 0) : r.setHours(e, 0, 0, 0), r;
+  }
+  incompatibleTokens = ["H", "K", "k", "t", "T"];
+}
+export {
+  f as Hour1to12Parser
+};

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

@@ -0,0 +1,97 @@
+import { setISODay as n } from "../../../setISODay.js";
+import { Parser as s } from "../Parser.js";
+import { mapValue as e, parseNDigits as w } from "../utils.js";
+class c extends s {
+  priority = 90;
+  parse(r, t, i) {
+    const o = (a) => a === 0 ? 7 : a;
+    switch (t) {
+      // 2
+      case "i":
+      case "ii":
+        return w(t.length, r);
+      // 2nd
+      case "io":
+        return i.ordinalNumber(r, { unit: "day" });
+      // Tue
+      case "iii":
+        return e(
+          i.day(r, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || i.day(r, {
+            width: "short",
+            context: "formatting"
+          }) || i.day(r, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          o
+        );
+      // T
+      case "iiiii":
+        return e(
+          i.day(r, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          o
+        );
+      // Tu
+      case "iiiiii":
+        return e(
+          i.day(r, {
+            width: "short",
+            context: "formatting"
+          }) || i.day(r, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          o
+        );
+      default:
+        return e(
+          i.day(r, {
+            width: "wide",
+            context: "formatting"
+          }) || i.day(r, {
+            width: "abbreviated",
+            context: "formatting"
+          }) || i.day(r, {
+            width: "short",
+            context: "formatting"
+          }) || i.day(r, {
+            width: "narrow",
+            context: "formatting"
+          }),
+          o
+        );
+    }
+  }
+  validate(r, t) {
+    return t >= 1 && t <= 7;
+  }
+  set(r, t, i) {
+    return r = n(r, i), r.setHours(0, 0, 0, 0), r;
+  }
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "E",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+export {
+  c as ISODayParser
+};

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

@@ -0,0 +1,41 @@
+import { constructFrom as n } from "../../../constructFrom.js";
+import { getTimezoneOffsetInMilliseconds as i } from "../../../_lib/getTimezoneOffsetInMilliseconds.js";
+import { timezonePatterns as r } from "../constants.js";
+import { Parser as m } from "../Parser.js";
+import { parseTimezonePattern as s } from "../utils.js";
+class l extends m {
+  priority = 10;
+  parse(e, t) {
+    switch (t) {
+      case "x":
+        return s(
+          r.basicOptionalMinutes,
+          e
+        );
+      case "xx":
+        return s(r.basic, e);
+      case "xxxx":
+        return s(
+          r.basicOptionalSeconds,
+          e
+        );
+      case "xxxxx":
+        return s(
+          r.extendedOptionalSeconds,
+          e
+        );
+      default:
+        return s(r.extended, e);
+    }
+  }
+  set(e, t, o) {
+    return t.timestampIsSet ? e : n(
+      e,
+      e.getTime() - i(e) - o
+    );
+  }
+  incompatibleTokens = ["t", "T", "X"];
+}
+export {
+  l as ISOTimezoneParser
+};

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

@@ -0,0 +1,41 @@
+import { constructFrom as i } from "../../../constructFrom.js";
+import { getTimezoneOffsetInMilliseconds as n } from "../../../_lib/getTimezoneOffsetInMilliseconds.js";
+import { timezonePatterns as r } from "../constants.js";
+import { Parser as m } from "../Parser.js";
+import { parseTimezonePattern as t } from "../utils.js";
+class l extends m {
+  priority = 10;
+  parse(e, s) {
+    switch (s) {
+      case "X":
+        return t(
+          r.basicOptionalMinutes,
+          e
+        );
+      case "XX":
+        return t(r.basic, e);
+      case "XXXX":
+        return t(
+          r.basicOptionalSeconds,
+          e
+        );
+      case "XXXXX":
+        return t(
+          r.extendedOptionalSeconds,
+          e
+        );
+      default:
+        return t(r.extended, e);
+    }
+  }
+  set(e, s, o) {
+    return s.timestampIsSet ? e : i(
+      e,
+      e.getTime() - n(e) - o
+    );
+  }
+  incompatibleTokens = ["t", "T", "x"];
+}
+export {
+  l as ISOTimezoneWithZParser
+};

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

@@ -0,0 +1,43 @@
+import { setISOWeek as s } from "../../../setISOWeek.js";
+import { startOfISOWeek as a } from "../../../startOfISOWeek.js";
+import { numericPatterns as i } from "../constants.js";
+import { Parser as o } from "../Parser.js";
+import { parseNDigits as m, parseNumericPattern as n } from "../utils.js";
+class I extends o {
+  priority = 100;
+  parse(e, r, t) {
+    switch (r) {
+      case "I":
+        return n(i.week, e);
+      case "Io":
+        return t.ordinalNumber(e, { unit: "week" });
+      default:
+        return m(r.length, e);
+    }
+  }
+  validate(e, r) {
+    return r >= 1 && r <= 53;
+  }
+  set(e, r, t) {
+    return a(s(e, t));
+  }
+  incompatibleTokens = [
+    "y",
+    "Y",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+export {
+  I as ISOWeekParser
+};

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

@@ -0,0 +1,34 @@
+import { startOfISOWeek as i } from "../../../startOfISOWeek.js";
+import { constructFrom as a } from "../../../constructFrom.js";
+import { Parser as m } from "../Parser.js";
+import { parseNDigitsSigned as s } from "../utils.js";
+class l extends m {
+  priority = 130;
+  parse(r, e) {
+    return e === "R" ? s(4, r) : s(e.length, r);
+  }
+  set(r, e, o) {
+    const t = a(r, 0);
+    return t.setFullYear(o, 0, 4), t.setHours(0, 0, 0, 0), i(t);
+  }
+  incompatibleTokens = [
+    "G",
+    "y",
+    "Y",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "w",
+    "d",
+    "D",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+export {
+  l as ISOWeekYearParser
+};

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

@@ -0,0 +1,72 @@
+import { setDay as w } from "../../../setDay.js";
+import { Parser as d } from "../Parser.js";
+import { mapValue as s, parseNDigits as f } from "../utils.js";
+class x extends d {
+  priority = 90;
+  parse(e, r, t, o) {
+    const a = (n) => {
+      const i = Math.floor((n - 1) / 7) * 7;
+      return (n + o.weekStartsOn + 6) % 7 + i;
+    };
+    switch (r) {
+      // 3
+      case "e":
+      case "ee":
+        return s(f(r.length, e), a);
+      // 3rd
+      case "eo":
+        return s(
+          t.ordinalNumber(e, {
+            unit: "day"
+          }),
+          a
+        );
+      // Tue
+      case "eee":
+        return t.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.day(e, { width: "short", context: "formatting" }) || t.day(e, { width: "narrow", context: "formatting" });
+      // T
+      case "eeeee":
+        return t.day(e, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // Tu
+      case "eeeeee":
+        return t.day(e, { width: "short", context: "formatting" }) || t.day(e, { width: "narrow", context: "formatting" });
+      default:
+        return t.day(e, { width: "wide", context: "formatting" }) || t.day(e, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.day(e, { width: "short", context: "formatting" }) || t.day(e, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(e, r) {
+    return r >= 0 && r <= 6;
+  }
+  set(e, r, t, o) {
+    return e = w(e, t, o), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "E",
+    "i",
+    "c",
+    "t",
+    "T"
+  ];
+}
+export {
+  x as LocalDayParser
+};

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

@@ -0,0 +1,42 @@
+import { setWeek as a } from "../../../setWeek.js";
+import { startOfWeek as i } from "../../../startOfWeek.js";
+import { numericPatterns as m } from "../constants.js";
+import { Parser as o } from "../Parser.js";
+import { parseNDigits as n, parseNumericPattern as p } from "../utils.js";
+class d extends o {
+  priority = 100;
+  parse(r, e, t) {
+    switch (e) {
+      case "w":
+        return p(m.week, r);
+      case "wo":
+        return t.ordinalNumber(r, { unit: "week" });
+      default:
+        return n(e.length, r);
+    }
+  }
+  validate(r, e) {
+    return e >= 1 && e <= 53;
+  }
+  set(r, e, t, s) {
+    return i(a(r, t, s), s);
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "q",
+    "Q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T"
+  ];
+}
+export {
+  d as LocalWeekParser
+};

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

@@ -0,0 +1,63 @@
+import { getWeekYear as u } from "../../../getWeekYear.js";
+import { startOfWeek as o } from "../../../startOfWeek.js";
+import { Parser as c } from "../Parser.js";
+import { mapValue as s, parseNDigits as n, normalizeTwoDigitYear as l } from "../utils.js";
+class w extends c {
+  priority = 130;
+  parse(r, e, i) {
+    const a = (t) => ({
+      year: t,
+      isTwoDigitYear: e === "YY"
+    });
+    switch (e) {
+      case "Y":
+        return s(n(4, r), a);
+      case "Yo":
+        return s(
+          i.ordinalNumber(r, {
+            unit: "year"
+          }),
+          a
+        );
+      default:
+        return s(n(e.length, r), a);
+    }
+  }
+  validate(r, e) {
+    return e.isTwoDigitYear || e.year > 0;
+  }
+  set(r, e, i, a) {
+    const t = u(r, a);
+    if (i.isTwoDigitYear) {
+      const m = l(
+        i.year,
+        t
+      );
+      return r.setFullYear(
+        m,
+        0,
+        a.firstWeekContainsDate
+      ), r.setHours(0, 0, 0, 0), o(r, a);
+    }
+    const Y = !("era" in e) || e.era === 1 ? i.year : 1 - i.year;
+    return r.setFullYear(Y, 0, a.firstWeekContainsDate), r.setHours(0, 0, 0, 0), o(r, a);
+  }
+  incompatibleTokens = [
+    "y",
+    "R",
+    "u",
+    "Q",
+    "q",
+    "M",
+    "L",
+    "I",
+    "d",
+    "D",
+    "i",
+    "t",
+    "T"
+  ];
+}
+export {
+  w as LocalWeekYearParser
+};

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

@@ -0,0 +1,26 @@
+import { numericPatterns as s } from "../constants.js";
+import { Parser as i } from "../Parser.js";
+import { parseNDigits as n, parseNumericPattern as m } from "../utils.js";
+class c extends i {
+  priority = 60;
+  parse(r, e, t) {
+    switch (e) {
+      case "m":
+        return m(s.minute, r);
+      case "mo":
+        return t.ordinalNumber(r, { unit: "minute" });
+      default:
+        return n(e.length, r);
+    }
+  }
+  validate(r, e) {
+    return e >= 0 && e <= 59;
+  }
+  set(r, e, t) {
+    return r.setMinutes(t, 0, 0), r;
+  }
+  incompatibleTokens = ["t", "T"];
+}
+export {
+  c as MinuteParser
+};