@easyops-cn/a2ui-react 0.0.1 → 0.0.3

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

@@ -0,0 +1,69 @@
+import { numericPatterns as i } from "../constants.js";
+import { Parser as a } from "../Parser.js";
+import { mapValue as n, parseNDigits as m, parseNumericPattern as M } from "../utils.js";
+class h extends a {
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "L",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+  priority = 110;
+  parse(t, o, r) {
+    const e = (s) => s - 1;
+    switch (o) {
+      // 1, 2, ..., 12
+      case "M":
+        return n(
+          M(i.month, t),
+          e
+        );
+      // 01, 02, ..., 12
+      case "MM":
+        return n(m(2, t), e);
+      // 1st, 2nd, ..., 12th
+      case "Mo":
+        return n(
+          r.ordinalNumber(t, {
+            unit: "month"
+          }),
+          e
+        );
+      // Jan, Feb, ..., Dec
+      case "MMM":
+        return r.month(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.month(t, { width: "narrow", context: "formatting" });
+      // J, F, ..., D
+      case "MMMMM":
+        return r.month(t, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return r.month(t, { width: "wide", context: "formatting" }) || r.month(t, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || r.month(t, { width: "narrow", context: "formatting" });
+    }
+  }
+  validate(t, o) {
+    return o >= 0 && o <= 11;
+  }
+  set(t, o, r) {
+    return t.setMonth(r, 1), t.setHours(0, 0, 0, 0), t;
+  }
+}
+export {
+  h as MonthParser
+};

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

@@ -0,0 +1,67 @@
+import { Parser as o } from "../Parser.js";
+import { parseNDigits as a } from "../utils.js";
+class u extends o {
+  priority = 120;
+  parse(r, e, t) {
+    switch (e) {
+      // 1, 2, 3, 4
+      case "Q":
+      case "QQ":
+        return a(e.length, r);
+      // 1st, 2nd, 3rd, 4th
+      case "Qo":
+        return t.ordinalNumber(r, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "QQQ":
+        return t.quarter(r, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.quarter(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "QQQQQ":
+        return t.quarter(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+      default:
+        return t.quarter(r, {
+          width: "wide",
+          context: "formatting"
+        }) || t.quarter(r, {
+          width: "abbreviated",
+          context: "formatting"
+        }) || t.quarter(r, {
+          width: "narrow",
+          context: "formatting"
+        });
+    }
+  }
+  validate(r, e) {
+    return e >= 1 && e <= 4;
+  }
+  set(r, e, t) {
+    return r.setMonth((t - 1) * 3, 1), r.setHours(0, 0, 0, 0), r;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+export {
+  u as QuarterParser
+};

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

@@ -0,0 +1,26 @@
+import { numericPatterns as t } from "../constants.js";
+import { Parser as n } from "../Parser.js";
+import { parseNDigits as o, parseNumericPattern as a } from "../utils.js";
+class u extends n {
+  priority = 50;
+  parse(r, e, s) {
+    switch (e) {
+      case "s":
+        return a(t.second, r);
+      case "so":
+        return s.ordinalNumber(r, { unit: "second" });
+      default:
+        return o(e.length, r);
+    }
+  }
+  validate(r, e) {
+    return e >= 0 && e <= 59;
+  }
+  set(r, e, s) {
+    return r.setSeconds(s, 0), r;
+  }
+  incompatibleTokens = ["t", "T"];
+}
+export {
+  u as SecondParser
+};

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

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

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

@@ -0,0 +1,69 @@
+import { numericPatterns as a } from "../constants.js";
+import { Parser as i } from "../Parser.js";
+import { mapValue as r, parseNDigits as l, parseNumericPattern as L } from "../utils.js";
+class d extends i {
+  priority = 110;
+  parse(e, n, t) {
+    const o = (s) => s - 1;
+    switch (n) {
+      // 1, 2, ..., 12
+      case "L":
+        return r(
+          L(a.month, e),
+          o
+        );
+      // 01, 02, ..., 12
+      case "LL":
+        return r(l(2, e), o);
+      // 1st, 2nd, ..., 12th
+      case "Lo":
+        return r(
+          t.ordinalNumber(e, {
+            unit: "month"
+          }),
+          o
+        );
+      // Jan, Feb, ..., Dec
+      case "LLL":
+        return t.month(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || t.month(e, { width: "narrow", context: "standalone" });
+      // J, F, ..., D
+      case "LLLLL":
+        return t.month(e, {
+          width: "narrow",
+          context: "standalone"
+        });
+      default:
+        return t.month(e, { width: "wide", context: "standalone" }) || t.month(e, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || t.month(e, { width: "narrow", context: "standalone" });
+    }
+  }
+  validate(e, n) {
+    return n >= 0 && n <= 11;
+  }
+  set(e, n, t) {
+    return e.setMonth(t, 1), e.setHours(0, 0, 0, 0), e;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "q",
+    "Q",
+    "M",
+    "w",
+    "I",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+export {
+  d as StandAloneMonthParser
+};

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

@@ -0,0 +1,67 @@
+import { Parser as a } from "../Parser.js";
+import { parseNDigits as n } from "../utils.js";
+class u extends a {
+  priority = 120;
+  parse(r, t, e) {
+    switch (t) {
+      // 1, 2, 3, 4
+      case "q":
+      case "qq":
+        return n(t.length, r);
+      // 1st, 2nd, 3rd, 4th
+      case "qo":
+        return e.ordinalNumber(r, { unit: "quarter" });
+      // Q1, Q2, Q3, Q4
+      case "qqq":
+        return e.quarter(r, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || e.quarter(r, {
+          width: "narrow",
+          context: "standalone"
+        });
+      // 1, 2, 3, 4 (narrow quarter; could be not numerical)
+      case "qqqqq":
+        return e.quarter(r, {
+          width: "narrow",
+          context: "standalone"
+        });
+      default:
+        return e.quarter(r, {
+          width: "wide",
+          context: "standalone"
+        }) || e.quarter(r, {
+          width: "abbreviated",
+          context: "standalone"
+        }) || e.quarter(r, {
+          width: "narrow",
+          context: "standalone"
+        });
+    }
+  }
+  validate(r, t) {
+    return t >= 1 && t <= 4;
+  }
+  set(r, t, e) {
+    return r.setMonth((e - 1) * 3, 1), r.setHours(0, 0, 0, 0), r;
+  }
+  incompatibleTokens = [
+    "Y",
+    "R",
+    "Q",
+    "M",
+    "L",
+    "w",
+    "I",
+    "d",
+    "D",
+    "i",
+    "e",
+    "c",
+    "t",
+    "T"
+  ];
+}
+export {
+  u as StandAloneQuarterParser
+};

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

@@ -0,0 +1,16 @@
+import { constructFrom as t } from "../../../constructFrom.js";
+import { Parser as s } from "../Parser.js";
+import { parseAnyDigitsSigned as i } from "../utils.js";
+class c extends s {
+  priority = 20;
+  parse(r) {
+    return i(r);
+  }
+  set(r, m, e) {
+    return [t(r, e), { timestampIsSet: !0 }];
+  }
+  incompatibleTokens = "*";
+}
+export {
+  c as TimestampMillisecondsParser
+};

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

@@ -0,0 +1,16 @@
+import { constructFrom as t } from "../../../constructFrom.js";
+import { Parser as s } from "../Parser.js";
+import { parseAnyDigitsSigned as o } from "../utils.js";
+class c extends s {
+  priority = 40;
+  parse(r) {
+    return o(r);
+  }
+  set(r, m, e) {
+    return [t(r, e * 1e3), { timestampIsSet: !0 }];
+  }
+  incompatibleTokens = "*";
+}
+export {
+  c as TimestampSecondsParser
+};

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

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

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

@@ -0,0 +1,67 @@
+import { EraParser as r } from "./parsers/EraParser.js";
+import { YearParser as e } from "./parsers/YearParser.js";
+import { LocalWeekYearParser as o } from "./parsers/LocalWeekYearParser.js";
+import { ISOWeekYearParser as m } from "./parsers/ISOWeekYearParser.js";
+import { ExtendedYearParser as a } from "./parsers/ExtendedYearParser.js";
+import { QuarterParser as t } from "./parsers/QuarterParser.js";
+import { StandAloneQuarterParser as n } from "./parsers/StandAloneQuarterParser.js";
+import { MonthParser as i } from "./parsers/MonthParser.js";
+import { StandAloneMonthParser as s } from "./parsers/StandAloneMonthParser.js";
+import { LocalWeekParser as p } from "./parsers/LocalWeekParser.js";
+import { ISOWeekParser as P } from "./parsers/ISOWeekParser.js";
+import { DateParser as f } from "./parsers/DateParser.js";
+import { DayOfYearParser as w } from "./parsers/DayOfYearParser.js";
+import { DayParser as d } from "./parsers/DayParser.js";
+import { LocalDayParser as S } from "./parsers/LocalDayParser.js";
+import { StandAloneLocalDayParser as c } from "./parsers/StandAloneLocalDayParser.js";
+import { ISODayParser as M } from "./parsers/ISODayParser.js";
+import { AMPMParser as l } from "./parsers/AMPMParser.js";
+import { AMPMMidnightParser as u } from "./parsers/AMPMMidnightParser.js";
+import { DayPeriodParser as D } from "./parsers/DayPeriodParser.js";
+import { Hour1to12Parser as y } from "./parsers/Hour1to12Parser.js";
+import { Hour0to23Parser as O } from "./parsers/Hour0to23Parser.js";
+import { Hour0To11Parser as T } from "./parsers/Hour0To11Parser.js";
+import { Hour1To24Parser as I } from "./parsers/Hour1To24Parser.js";
+import { MinuteParser as Y } from "./parsers/MinuteParser.js";
+import { SecondParser as h } from "./parsers/SecondParser.js";
+import { FractionOfSecondParser as k } from "./parsers/FractionOfSecondParser.js";
+import { ISOTimezoneWithZParser as A } from "./parsers/ISOTimezoneWithZParser.js";
+import { ISOTimezoneParser as H } from "./parsers/ISOTimezoneParser.js";
+import { TimestampSecondsParser as L } from "./parsers/TimestampSecondsParser.js";
+import { TimestampMillisecondsParser as W } from "./parsers/TimestampMillisecondsParser.js";
+const sr = {
+  G: new r(),
+  y: new e(),
+  Y: new o(),
+  R: new m(),
+  u: new a(),
+  Q: new t(),
+  q: new n(),
+  M: new i(),
+  L: new s(),
+  w: new p(),
+  I: new P(),
+  d: new f(),
+  D: new w(),
+  E: new d(),
+  e: new S(),
+  c: new c(),
+  i: new M(),
+  a: new l(),
+  b: new u(),
+  B: new D(),
+  h: new y(),
+  H: new O(),
+  K: new T(),
+  k: new I(),
+  m: new Y(),
+  s: new h(),
+  S: new k(),
+  X: new A(),
+  x: new H(),
+  t: new L(),
+  T: new W()
+};
+export {
+  sr as parsers
+};

package/dist/node_modules/date-fns/parse/_lib/utils.js

@@ -0,0 +1,100 @@
+import { millisecondsInHour as l, millisecondsInMinute as m, millisecondsInSecond as f } from "../../constants.js";
+import { numericPatterns as r } from "./constants.js";
+function p(e, n) {
+  return e && {
+    value: n(e.value),
+    rest: e.rest
+  };
+}
+function t(e, n) {
+  const s = n.match(e);
+  return s ? {
+    value: parseInt(s[0], 10),
+    rest: n.slice(s[0].length)
+  } : null;
+}
+function d(e, n) {
+  const s = n.match(e);
+  if (!s)
+    return null;
+  if (s[0] === "Z")
+    return {
+      value: 0,
+      rest: n.slice(1)
+    };
+  const u = s[1] === "+" ? 1 : -1, i = s[2] ? parseInt(s[2], 10) : 0, c = s[3] ? parseInt(s[3], 10) : 0, o = s[5] ? parseInt(s[5], 10) : 0;
+  return {
+    value: u * (i * l + c * m + o * f),
+    rest: n.slice(s[0].length)
+  };
+}
+function D(e) {
+  return t(r.anyDigitsSigned, e);
+}
+function I(e, n) {
+  switch (e) {
+    case 1:
+      return t(r.singleDigit, n);
+    case 2:
+      return t(r.twoDigits, n);
+    case 3:
+      return t(r.threeDigits, n);
+    case 4:
+      return t(r.fourDigits, n);
+    default:
+      return t(new RegExp("^\\d{1," + e + "}"), n);
+  }
+}
+function v(e, n) {
+  switch (e) {
+    case 1:
+      return t(r.singleDigitSigned, n);
+    case 2:
+      return t(r.twoDigitsSigned, n);
+    case 3:
+      return t(r.threeDigitsSigned, n);
+    case 4:
+      return t(r.fourDigitsSigned, n);
+    default:
+      return t(new RegExp("^-?\\d{1," + e + "}"), n);
+  }
+}
+function w(e) {
+  switch (e) {
+    case "morning":
+      return 4;
+    case "evening":
+      return 17;
+    case "pm":
+    case "noon":
+    case "afternoon":
+      return 12;
+    default:
+      return 0;
+  }
+}
+function E(e, n) {
+  const s = n > 0, u = s ? n : 1 - n;
+  let i;
+  if (u <= 50)
+    i = e || 100;
+  else {
+    const c = u + 50, o = Math.trunc(c / 100) * 100, a = e >= c % 100;
+    i = e + o - (a ? 100 : 0);
+  }
+  return s ? i : 1 - i;
+}
+function P(e) {
+  return e % 400 === 0 || e % 4 === 0 && e % 100 !== 0;
+}
+export {
+  w as dayPeriodEnumToHours,
+  P as isLeapYearIndex,
+  p as mapValue,
+  E as normalizeTwoDigitYear,
+  D as parseAnyDigitsSigned,
+  I as parseNDigits,
+  v as parseNDigitsSigned,
+  t as parseNumericPattern,
+  d as parseTimezonePattern
+};