@a-ui/react 7.13.0-beta.6 → 7.13.0-beta.7

package/es/index191.mjs

@@ -1,64 +1,6 @@
-import { Parser as a } from "./index221.mjs";
-import { parseNDigits as n } from "./index222.mjs";
-class u extends a {
-  priority = 120;
-  parse(r, t, e) {
-    switch (t) {
-      case "q":
-      case "qq":
-        return n(t.length, r);
-      case "qo":
-        return e.ordinalNumber(r, { unit: "quarter" });
-      case "qqq":
-        return e.quarter(r, {
-          width: "abbreviated",
-          context: "standalone"
-        }) || e.quarter(r, {
-          width: "narrow",
-          context: "standalone"
-        });
-      case "qqqqq":
-        return e.quarter(r, {
-          width: "narrow",
-          context: "standalone"
-        });
-      case "qqqq":
-      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"
-  ];
-}
+import { getAugmentedNamespace as e } from "./index171.mjs";
+import * as t from "./index221.mjs";
+const a = /* @__PURE__ */ e(t);
 export {
-  u as StandAloneQuarterParser
+  a as default
 };

package/es/index192.mjs

@@ -1,65 +1,4 @@
-import { numericPatterns as i } from "./index223.mjs";
-import { Parser as a } from "./index221.mjs";
-import { mapValue as n, parseNDigits as m, parseNumericPattern as M } from "./index222.mjs";
-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) {
-      case "M":
-        return n(
-          M(i.month, t),
-          e
-        );
-      case "MM":
-        return n(m(2, t), e);
-      case "Mo":
-        return n(
-          r.ordinalNumber(t, {
-            unit: "month"
-          }),
-          e
-        );
-      case "MMM":
-        return r.month(t, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || r.month(t, { width: "narrow", context: "formatting" });
-      case "MMMMM":
-        return r.month(t, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "MMMM":
-      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;
-  }
-}
+var e = {};
 export {
-  h as MonthParser
+  e as __exports
 };

package/es/index193.mjs

@@ -1,65 +1,4 @@
-import { numericPatterns as a } from "./index223.mjs";
-import { Parser as i } from "./index221.mjs";
-import { mapValue as r, parseNDigits as l, parseNumericPattern as L } from "./index222.mjs";
-class d extends i {
-  priority = 110;
-  parse(e, n, t) {
-    const o = (s) => s - 1;
-    switch (n) {
-      case "L":
-        return r(
-          L(a.month, e),
-          o
-        );
-      case "LL":
-        return r(l(2, e), o);
-      case "Lo":
-        return r(
-          t.ordinalNumber(e, {
-            unit: "month"
-          }),
-          o
-        );
-      case "LLL":
-        return t.month(e, {
-          width: "abbreviated",
-          context: "standalone"
-        }) || t.month(e, { width: "narrow", context: "standalone" });
-      case "LLLLL":
-        return t.month(e, {
-          width: "narrow",
-          context: "standalone"
-        });
-      case "LLLL":
-      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"
-  ];
-}
+var r = {};
 export {
-  d as StandAloneMonthParser
+  r as __exports
 };

package/es/index194.mjs

@@ -1,42 +1,61 @@
-import { setWeek as a } from "./index179.mjs";
-import { startOfWeek as i } from "./index131.mjs";
-import { numericPatterns as m } from "./index223.mjs";
-import { Parser as o } from "./index221.mjs";
-import { parseNDigits as n, parseNumericPattern as p } from "./index222.mjs";
-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"
-  ];
+import { tzName as r } from "./index195.mjs";
+import { TZDateMini as s } from "./index90.mjs";
+class o extends s {
+  //#region static
+  static tz(t, ...e) {
+    return e.length ? new o(...e, t) : new o(Date.now(), t);
+  }
+  //#endregion
+  //#region representation
+  toISOString() {
+    const [t, e, n] = this.tzComponents(), i = `${t}${e}:${n}`;
+    return this.internal.toISOString().slice(0, -1) + i;
+  }
+  toString() {
+    return `${this.toDateString()} ${this.toTimeString()}`;
+  }
+  toDateString() {
+    const [t, e, n, i] = this.internal.toUTCString().split(" ");
+    return `${t?.slice(0, -1)} ${n} ${e} ${i}`;
+  }
+  toTimeString() {
+    const t = this.internal.toUTCString().split(" ")[4], [e, n, i] = this.tzComponents();
+    return `${t} GMT${e}${n}${i} (${r(this.timeZone, this)})`;
+  }
+  toLocaleString(t, e) {
+    return Date.prototype.toLocaleString.call(this, t, {
+      ...e,
+      timeZone: e?.timeZone || this.timeZone
+    });
+  }
+  toLocaleDateString(t, e) {
+    return Date.prototype.toLocaleDateString.call(this, t, {
+      ...e,
+      timeZone: e?.timeZone || this.timeZone
+    });
+  }
+  toLocaleTimeString(t, e) {
+    return Date.prototype.toLocaleTimeString.call(this, t, {
+      ...e,
+      timeZone: e?.timeZone || this.timeZone
+    });
+  }
+  //#endregion
+  //#region private
+  tzComponents() {
+    const t = this.getTimezoneOffset(), e = t > 0 ? "-" : "+", n = String(Math.floor(Math.abs(t) / 60)).padStart(2, "0"), i = String(Math.abs(t) % 60).padStart(2, "0");
+    return [e, n, i];
+  }
+  //#endregion
+  withTimeZone(t) {
+    return new o(+this, t);
+  }
+  //#region date-fns integration
+  [Symbol.for("constructDateFrom")](t) {
+    return new o(+new Date(t), this.timeZone);
+  }
+  //#endregion
 }
 export {
-  d as LocalWeekParser
+  o as TZDate
 };

package/es/index195.mjs

@@ -1,43 +1,11 @@
-import { setISOWeek as s } from "./index178.mjs";
-import { startOfISOWeek as a } from "./index167.mjs";
-import { numericPatterns as i } from "./index223.mjs";
-import { Parser as o } from "./index221.mjs";
-import { parseNDigits as m, parseNumericPattern as n } from "./index222.mjs";
-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"
-  ];
+function o(e, n, t = "long") {
+  return new Intl.DateTimeFormat("en-US", {
+    // Enforces engine to render the time. Without the option JavaScriptCore omits it.
+    hour: "numeric",
+    timeZone: e,
+    timeZoneName: t
+  }).format(n).split(/\s/g).slice(2).join(" ");
 }
 export {
-  I as ISOWeekParser
+  o as tzName
 };

package/es/index196.mjs

@@ -1,55 +1,22 @@
-import { numericPatterns as o } from "./index223.mjs";
-import { Parser as i } from "./index221.mjs";
-import { parseNDigits as a, parseNumericPattern as c, isLeapYearIndex as m } from "./index222.mjs";
-const p = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], u = [
-  31,
-  29,
-  31,
-  30,
-  31,
-  30,
-  31,
-  31,
-  30,
-  31,
-  30,
-  31
-];
-class f extends i {
-  priority = 90;
-  subPriority = 1;
-  parse(r, e, t) {
-    switch (e) {
-      case "d":
-        return c(o.date, r);
-      case "do":
-        return t.ordinalNumber(r, { unit: "date" });
-      default:
-        return a(e.length, r);
-    }
+const e = {}, s = {};
+function u(t, r) {
+  try {
+    const n = (e[t] ||= new Intl.DateTimeFormat("en-US", {
+      timeZone: t,
+      timeZoneName: "longOffset"
+    }).format)(r).split("GMT")[1];
+    return n in s ? s[n] : o(n, n.split(":"));
+  } catch {
+    if (t in s) return s[t];
+    const f = t?.match(a);
+    return f ? o(t, f.slice(1)) : NaN;
   }
-  validate(r, e) {
-    const t = r.getFullYear(), n = m(t), s = r.getMonth();
-    return n ? e >= 1 && e <= u[s] : e >= 1 && e <= p[s];
-  }
-  set(r, e, t) {
-    return r.setDate(t), r.setHours(0, 0, 0, 0), r;
-  }
-  incompatibleTokens = [
-    "Y",
-    "R",
-    "q",
-    "Q",
-    "w",
-    "I",
-    "D",
-    "i",
-    "e",
-    "c",
-    "t",
-    "T"
-  ];
+}
+const a = /([+-]\d\d):?(\d\d)?/;
+function o(t, r) {
+  const f = +(r[0] || 0), n = +(r[1] || 0), c = +(r[2] || 0) / 60;
+  return s[t] = f * 60 + n > 0 ? f * 60 + n + c : f * 60 - n - c;
 }
 export {
-  f as DateParser
+  u as tzOffset
 };

package/es/index197.mjs

@@ -1,45 +1,70 @@
-import { numericPatterns as t } from "./index223.mjs";
-import { Parser as a } from "./index221.mjs";
-import { parseNDigits as i, parseNumericPattern as n, isLeapYearIndex as o } from "./index222.mjs";
-class l extends a {
-  priority = 90;
-  subpriority = 1;
-  parse(r, e, s) {
-    switch (e) {
-      case "D":
-      case "DD":
-        return n(t.dayOfYear, r);
-      case "Do":
-        return s.ordinalNumber(r, { unit: "date" });
-      default:
-        return i(e.length, r);
-    }
+const a = {
+  lessThanXSeconds: {
+    one: "minder dan een seconde",
+    other: "minder dan {{count}} seconden"
+  },
+  xSeconds: {
+    one: "1 seconde",
+    other: "{{count}} seconden"
+  },
+  halfAMinute: "een halve minuut",
+  lessThanXMinutes: {
+    one: "minder dan een minuut",
+    other: "minder dan {{count}} minuten"
+  },
+  xMinutes: {
+    one: "een minuut",
+    other: "{{count}} minuten"
+  },
+  aboutXHours: {
+    one: "ongeveer 1 uur",
+    other: "ongeveer {{count}} uur"
+  },
+  xHours: {
+    one: "1 uur",
+    other: "{{count}} uur"
+  },
+  xDays: {
+    one: "1 dag",
+    other: "{{count}} dagen"
+  },
+  aboutXWeeks: {
+    one: "ongeveer 1 week",
+    other: "ongeveer {{count}} weken"
+  },
+  xWeeks: {
+    one: "1 week",
+    other: "{{count}} weken"
+  },
+  aboutXMonths: {
+    one: "ongeveer 1 maand",
+    other: "ongeveer {{count}} maanden"
+  },
+  xMonths: {
+    one: "1 maand",
+    other: "{{count}} maanden"
+  },
+  aboutXYears: {
+    one: "ongeveer 1 jaar",
+    other: "ongeveer {{count}} jaar"
+  },
+  xYears: {
+    one: "1 jaar",
+    other: "{{count}} jaar"
+  },
+  overXYears: {
+    one: "meer dan 1 jaar",
+    other: "meer dan {{count}} jaar"
+  },
+  almostXYears: {
+    one: "bijna 1 jaar",
+    other: "bijna {{count}} jaar"
   }
-  validate(r, e) {
-    const s = r.getFullYear();
-    return o(s) ? e >= 1 && e <= 366 : e >= 1 && e <= 365;
-  }
-  set(r, e, s) {
-    return r.setMonth(0, s), r.setHours(0, 0, 0, 0), r;
-  }
-  incompatibleTokens = [
-    "Y",
-    "R",
-    "q",
-    "Q",
-    "M",
-    "L",
-    "w",
-    "I",
-    "d",
-    "E",
-    "i",
-    "e",
-    "c",
-    "t",
-    "T"
-  ];
-}
+}, u = (t, r, o) => {
+  let e;
+  const n = a[t];
+  return typeof n == "string" ? e = n : r === 1 ? e = n.one : e = n.other.replace("{{count}}", String(r)), o?.addSuffix ? o.comparison && o.comparison > 0 ? "over " + e : e + " geleden" : e;
+};
 export {
-  l as DayOfYearParser
+  u as formatDistance
 };

package/es/index198.mjs

@@ -1,39 +1,33 @@
-import { setDay as a } from "./index176.mjs";
-import { Parser as n } from "./index221.mjs";
-class w extends n {
-  priority = 90;
-  parse(t, o, r) {
-    switch (o) {
-      case "E":
-      case "EE":
-      case "EEE":
-        return r.day(t, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || r.day(t, { width: "short", context: "formatting" }) || r.day(t, { width: "narrow", context: "formatting" });
-      case "EEEEE":
-        return r.day(t, {
-          width: "narrow",
-          context: "formatting"
-        });
-      case "EEEEEE":
-        return r.day(t, { width: "short", context: "formatting" }) || r.day(t, { width: "narrow", context: "formatting" });
-      case "EEEE":
-      default:
-        return r.day(t, { width: "wide", context: "formatting" }) || r.day(t, {
-          width: "abbreviated",
-          context: "formatting"
-        }) || r.day(t, { width: "short", context: "formatting" }) || r.day(t, { width: "narrow", context: "formatting" });
-    }
-  }
-  validate(t, o) {
-    return o >= 0 && o <= 6;
-  }
-  set(t, o, r, e) {
-    return t = a(t, r, e), t.setHours(0, 0, 0, 0), t;
-  }
-  incompatibleTokens = ["D", "i", "e", "c", "t", "T"];
-}
+import { buildFormatLongFn as t } from "./index202.mjs";
+const m = {
+  full: "EEEE d MMMM y",
+  long: "d MMMM y",
+  medium: "d MMM y",
+  short: "dd.MM.y"
+}, o = {
+  full: "HH:mm:ss zzzz",
+  long: "HH:mm:ss z",
+  medium: "HH:mm:ss",
+  short: "HH:mm"
+}, d = {
+  full: "{{date}} 'om' {{time}}",
+  long: "{{date}} 'om' {{time}}",
+  medium: "{{date}}, {{time}}",
+  short: "{{date}}, {{time}}"
+}, a = {
+  date: t({
+    formats: m,
+    defaultWidth: "full"
+  }),
+  time: t({
+    formats: o,
+    defaultWidth: "full"
+  }),
+  dateTime: t({
+    formats: d,
+    defaultWidth: "full"
+  })
+};
 export {
-  w as DayParser
+  a as formatLong
 };