@adyen/adyen-platform-experience-web 0.1.2 → 1.0.0-beta.1

package/dist/es/components/internal/Calendar/clock/today.js

@@ -1,46 +1,66 @@
-import D from "../../../../utils/watchable/index.js";
-import { struct as T } from "../../../../utils/common/index.js";
-import i from "./clock.js";
-import d from "../../../../core/Localization/datetime/restamper/restamper.js";
-import { timezoneToSystem as g, systemToTimezone as z } from "../../../../core/Localization/datetime/restamper/utils.js";
-const w = (() => {
-  const u = /* @__PURE__ */ new Map(), r = d(), f = (a = i.timestamp) => {
-    const t = new Date(a), o = new Date(g(r, a)), e = t.getDate() - o.getDate();
-    if (e) {
-      const n = e > 1 ? -1 : e < -1 ? 1 : e;
-      t.setDate(t.getDate() - n);
+import clock from "./clock.js";
+import restamper from "../../../../core/Localization/datetime/restamper/restamper.js";
+import "../../../../core/Localization/datetime/restamper/constants.js";
+import { timezoneToSystem, systemToTimezone } from "../../../../core/Localization/datetime/restamper/utils.js";
+import watchable from "../../../../utils/watchable/index.js";
+import { struct } from "../../../../utils/common/index.js";
+const today = (() => {
+  const timezones = /* @__PURE__ */ new Map();
+  const restamper$1 = restamper();
+  const getTimestampWithTomorrowOffset = (withTimestamp = clock.timestamp) => {
+    const date = new Date(withTimestamp);
+    const restampedDate = new Date(timezoneToSystem(restamper$1, withTimestamp));
+    const dateDiff = date.getDate() - restampedDate.getDate();
+    if (dateDiff) {
+      const dateOffset = dateDiff > 1 ? -1 : dateDiff < -1 ? 1 : dateDiff;
+      date.setDate(date.getDate() - dateOffset);
     }
-    const s = z(r, t.setHours(0, 0, 0, 0)), m = z(r, t.setDate(t.getDate() + 1));
-    return [s, m - s];
+    const currentTimestamp = systemToTimezone(restamper$1, date.setHours(0, 0, 0, 0));
+    const nextTimestamp = systemToTimezone(restamper$1, date.setDate(date.getDate() + 1));
+    return [currentTimestamp, nextTimestamp - currentTimestamp];
   };
-  return (a) => {
-    r.tz = a;
-    const t = r.tz.current;
-    return u.get(t) ?? (() => {
-      let o = null, e = null, s = null;
-      const m = () => (r.tz = t, o ?? f()[0]), n = (l = i.timestamp) => {
-        r.tz = t, [o, e] = f(l);
-      }, c = D({ timestamp: m });
-      c.callback.resume = () => {
-        s = i.watch((l) => {
-          if (l !== D.UNWATCH) {
-            if (o === null || e === null)
-              return n();
-            i.timestamp - o < e || (n(), c.notify());
-          }
+  return (timezone) => {
+    restamper$1.tz = timezone;
+    const tz = restamper$1.tz.current;
+    return timezones.get(tz) ?? (() => {
+      let timestamp = null;
+      let tomorrowOffset = null;
+      let unwatch = null;
+      const getTimestamp = () => {
+        restamper$1.tz = tz;
+        return timestamp ?? getTimestampWithTomorrowOffset()[0];
+      };
+      const refreshTimestamps = (withTimestamp = clock.timestamp) => {
+        restamper$1.tz = tz;
+        [timestamp, tomorrowOffset] = getTimestampWithTomorrowOffset(withTimestamp);
+      };
+      const watchable$1 = watchable({ timestamp: getTimestamp });
+      watchable$1.callback.resume = () => {
+        unwatch = clock.watch((snapshotOrSignal) => {
+          if (snapshotOrSignal === watchable.UNWATCH)
+            return;
+          if (timestamp === null || tomorrowOffset === null)
+            return refreshTimestamps();
+          if (clock.timestamp - timestamp < tomorrowOffset)
+            return;
+          refreshTimestamps();
+          watchable$1.notify();
         });
-      }, c.callback.idle = () => {
-        s == null || s(), o = e = s = null;
       };
-      const p = T({
-        timestamp: { get: m },
-        timezone: { value: t },
-        watch: { value: c.watch }
+      watchable$1.callback.idle = () => {
+        unwatch == null ? void 0 : unwatch();
+        timestamp = tomorrowOffset = unwatch = null;
+      };
+      const instance = struct({
+        timestamp: { get: getTimestamp },
+        timezone: { value: tz },
+        watch: { value: watchable$1.watch }
       });
-      return u.set(t, p), p;
+      timezones.set(tz, instance);
+      return instance;
     })();
   };
-})(), $ = w;
+})();
 export {
-  $ as default
+  today as default
 };

package/dist/es/components/internal/Calendar/clock/today.test.js

@@ -0,0 +1,98 @@
+import "../../../../core/Localization/datetime/restamper/restamper.js";
+import { SYSTEM_TIMEZONE } from "../../../../core/Localization/datetime/restamper/constants.js";
+import "../../../../utils/common/index.js";
+import { initialize, TIMEZONES, DATES, startOfNextDay, startOfDay } from "./testing/fixtures.js";
+import today from "./today.js";
+import { d as describe, t as test, g as globalExpect, v as vi } from "../../../../../vendor-vi.a3ff54b1-5e924357.mjs";
+describe("today", () => {
+  const { watchFn } = initialize();
+  test("should use shared instance for same timezone", () => {
+    const testRoutine = (timezone) => {
+      const today1 = today(timezone);
+      const today2 = today(timezone);
+      globalExpect(today1).toBe(today2);
+      globalExpect(today1.timestamp).toBe(today2.timestamp);
+      globalExpect(today1.timezone).toBe(today2.timezone);
+    };
+    testRoutine();
+    testRoutine(SYSTEM_TIMEZONE);
+    testRoutine("Unknown/Invalid_TZ");
+    TIMEZONES.forEach((_, timezone) => testRoutine(timezone));
+  });
+  test("should have latest timestamp when not being watched", () => {
+    const testRoutine = (getStartDate, timezone) => {
+      const today$1 = today(timezone);
+      globalExpect(today$1.timezone).toBe(timezone ?? SYSTEM_TIMEZONE);
+      DATES.forEach((date, index) => {
+        vi.setSystemTime(date);
+        const currentTimestamp = getStartDate(index);
+        const nextTimestamp = startOfNextDay(currentTimestamp);
+        globalExpect(today$1.timestamp).toBe(currentTimestamp);
+        vi.setSystemTime(nextTimestamp - 1);
+        globalExpect(today$1.timestamp).toBe(currentTimestamp);
+        vi.setSystemTime(nextTimestamp);
+        globalExpect(today$1.timestamp).not.toBe(currentTimestamp);
+        globalExpect(today$1.timestamp).toBe(nextTimestamp);
+        vi.setSystemTime(startOfNextDay(nextTimestamp) - 1);
+        globalExpect(today$1.timestamp).toBe(nextTimestamp);
+      });
+    };
+    testRoutine(() => startOfDay(), SYSTEM_TIMEZONE);
+    TIMEZONES.forEach((startDates, timezone) => {
+      testRoutine((index) => startDates[index].getTime(), timezone);
+    });
+    testRoutine(() => startOfDay());
+  });
+  test("should use latest timestamp for new day when being watched", () => {
+    let watchFnCalls = 0;
+    const testRoutine = (getStartDate, timezone) => {
+      var _a;
+      vi.setSystemTime(0);
+      const today$1 = today(timezone);
+      const unwatch = today$1.watch(watchFn);
+      let currentDayTimestamp = (_a = watchFn.mock.lastCall[0]) == null ? void 0 : _a.timestamp;
+      globalExpect(today$1.timestamp).toBe(currentDayTimestamp);
+      globalExpect(today$1.timezone).toBe(timezone ?? SYSTEM_TIMEZONE);
+      globalExpect(watchFn).toBeCalledTimes(++watchFnCalls);
+      globalExpect(watchFn).toHaveBeenLastCalledWith({ timestamp: currentDayTimestamp });
+      DATES.forEach((date, index) => {
+        vi.runOnlyPendingTimers();
+        vi.setSystemTime(date);
+        const todayTimestamp = getStartDate(index);
+        const nextTimestamp = startOfNextDay(todayTimestamp);
+        globalExpect(today$1.timestamp).not.toBe(todayTimestamp);
+        globalExpect(today$1.timestamp).toBe(currentDayTimestamp);
+        globalExpect(watchFn).toBeCalledTimes(watchFnCalls);
+        vi.advanceTimersToNextTimer();
+        currentDayTimestamp = todayTimestamp;
+        globalExpect(today$1.timestamp).toBe(currentDayTimestamp);
+        globalExpect(watchFn).toBeCalledTimes(++watchFnCalls);
+        globalExpect(watchFn).toHaveBeenLastCalledWith({ timestamp: currentDayTimestamp });
+        vi.setSystemTime(nextTimestamp - 1);
+        vi.advanceTimersToNextTimer();
+        globalExpect(today$1.timestamp).toBe(currentDayTimestamp);
+        globalExpect(watchFn).toBeCalledTimes(watchFnCalls);
+        vi.setSystemTime(nextTimestamp);
+        vi.advanceTimersToNextTimer();
+        globalExpect(today$1.timestamp).not.toBe(currentDayTimestamp);
+        globalExpect(today$1.timestamp).toBe(currentDayTimestamp = nextTimestamp);
+        globalExpect(watchFn).toBeCalledTimes(++watchFnCalls);
+        globalExpect(watchFn).toHaveBeenLastCalledWith({ timestamp: currentDayTimestamp });
+        vi.setSystemTime(startOfNextDay(nextTimestamp) - 1);
+        vi.advanceTimersToNextTimer();
+        globalExpect(today$1.timestamp).toBe(nextTimestamp);
+        globalExpect(watchFn).toBeCalledTimes(watchFnCalls);
+        vi.setSystemTime(currentDayTimestamp = Date.now());
+        vi.advanceTimersToNextTimer();
+        globalExpect(watchFn).toBeCalledTimes(++watchFnCalls);
+        globalExpect(watchFn).toHaveBeenLastCalledWith({ timestamp: currentDayTimestamp });
+      });
+      unwatch();
+    };
+    testRoutine(() => startOfDay(), SYSTEM_TIMEZONE);
+    TIMEZONES.forEach((startDates, timezone) => {
+      testRoutine((index) => startDates[index].getTime(), timezone);
+    });
+    testRoutine(() => startOfDay());
+  });
+});

package/dist/es/components/internal/Calendar/components/CalendarControls/CalendarControls.js

@@ -1,9 +1,14 @@
-import { jsx as a } from "../../../../../external/preact/jsx-runtime/dist/jsxRuntime.module.js";
-import { memo as s } from "../../../../../external/preact/compat/dist/compat.module.js";
-import { isFunction as l } from "../../../../../utils/common/index.js";
-import i from "../../calendar/facade/index.js";
-import { Fragment as c } from "../../../../../external/preact/dist/preact.module.js";
-const e = ({ config: r, grid: { controls: t }, renderer: o }) => r.controls === i.controls.NONE || !l(o) ? null : /* @__PURE__ */ a(c, { children: t.map(([n, m]) => o(n, m)) }), x = s(e);
+import { o } from "../../../../../../jsxRuntime.module-69493d81.mjs";
+import { x } from "../../../../../../compat.module-a4d537ff.mjs";
+import calendar from "../../calendar/facade/index.js";
+import { isFunction } from "../../../../../utils/common/index.js";
+import { k } from "../../../../../../preact.module-38e5a571.mjs";
+const CalendarControls = ({ config, grid: { controls }, renderer }) => {
+  if (config.controls === calendar.controls.NONE || !isFunction(renderer))
+    return null;
+  return /* @__PURE__ */ o(k, { children: controls.map(([control, handle]) => renderer(control, handle)) });
+};
+const CalendarControls$1 = x(CalendarControls);
 export {
-  x as default
+  CalendarControls$1 as default
 };

package/dist/es/components/internal/Calendar/components/CalendarControls/index.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "./CalendarControls.js";
+export {
+  default2 as default
+};

package/dist/es/components/internal/Calendar/components/CalendarGrid/CalendarGrid.js

@@ -1,38 +1,40 @@
-import { jsx as e } from "../../../../../external/preact/jsx-runtime/dist/jsxRuntime.module.js";
-import { memo as c, forwardRef as p } from "../../../../../external/preact/compat/dist/compat.module.js";
-import f from "./CalendarGridDate.js";
-import h from "./CalendarGridDayOfWeek.js";
-import "../../Calendar.scss.js";
-const y = p(({ cursorRootProps: t, onlyCellsWithin: i, prepare: d, grid: r }, s) => /* @__PURE__ */ e("ol", { className: "adyen-fp-calendar", role: "none", ...t, children: r.map((a) => /* @__PURE__ */ e("li", { className: "adyen-fp-calendar__month", role: "none", children: [
-  /* @__PURE__ */ e("div", { className: "adyen-fp-calendar__month-name", role: "none", children: /* @__PURE__ */ e("time", { dateTime: a.datetime, "aria-hidden": "true", children: a.label }) }),
-  /* @__PURE__ */ e(
+import '../../../../../../CalendarGrid.css';
+import { o } from "../../../../../../jsxRuntime.module-69493d81.mjs";
+import { k, x } from "../../../../../../compat.module-a4d537ff.mjs";
+import CalendarGridDate from "./CalendarGridDate.js";
+import CalendarGridDayOfWeek from "./CalendarGridDayOfWeek.js";
+const Calendar = "";
+const CalendarGrid = k(({ cursorRootProps, onlyCellsWithin, prepare, grid }, cursorElementRef) => /* @__PURE__ */ o("ol", { className: "adyen-pe-calendar", role: "none", ...cursorRootProps, children: grid.map((block) => /* @__PURE__ */ o("li", { className: "adyen-pe-calendar__month", role: "none", children: [
+  /* @__PURE__ */ o("div", { className: "adyen-pe-calendar__month-name", role: "none", children: /* @__PURE__ */ o("time", { dateTime: block.datetime, "aria-hidden": "true", children: block.label }) }),
+  /* @__PURE__ */ o(
     "table",
     {
       role: "grid",
-      "aria-multiselectable": !0,
-      "aria-label": `${a.label} calendar`,
-      className: "adyen-fp-calendar__grid",
-      style: { "--adyen-fp-calendar-rowspan": r.rowspan },
+      "aria-multiselectable": true,
+      "aria-label": `${block.label} calendar`,
+      className: "adyen-pe-calendar__grid",
+      style: { "--adyen-pe-calendar-rowspan": grid.rowspan },
       children: [
-        /* @__PURE__ */ e("thead", { children: /* @__PURE__ */ e("tr", { className: "adyen-fp-calendar__row", children: r.weekdays.map((l, n) => /* @__PURE__ */ e(h, { grid: r, block: a, prepare: d, cell: n, ...l }, l.labels.long)) }) }),
-        /* @__PURE__ */ e("tbody", { children: a.map((l, n) => /* @__PURE__ */ e("tr", { className: "adyen-fp-calendar__row", children: l.map((m, o) => /* @__PURE__ */ e(
-          f,
+        /* @__PURE__ */ o("thead", { children: /* @__PURE__ */ o("tr", { className: "adyen-pe-calendar__row", children: grid.weekdays.map((data, index) => /* @__PURE__ */ o(CalendarGridDayOfWeek, { grid, block, prepare, cell: index, ...data }, data.labels["long"])) }) }),
+        /* @__PURE__ */ o("tbody", { children: block.map((row, rowindex) => /* @__PURE__ */ o("tr", { className: "adyen-pe-calendar__row", children: row.map((data, index) => /* @__PURE__ */ o(
+          CalendarGridDate,
           {
-            ref: s,
-            grid: r,
-            block: a,
-            prepare: d,
-            cell: o,
-            onlyCellsWithin: i,
-            row: n,
-            ...m
+            ref: cursorElementRef,
+            grid,
+            block,
+            prepare,
+            cell: index,
+            onlyCellsWithin,
+            row: rowindex,
+            ...data
           },
-          `${a.month}:${m.timestamp}`
-        )) }, `${a.month}:${n}`)) })
+          `${block.month}:${data.timestamp}`
+        )) }, `${block.month}:${rowindex}`)) })
       ]
     }
   )
-] }, a.datetime)) })), C = c(y);
+] }, block.datetime)) }));
+const CalendarGrid$1 = x(CalendarGrid);
 export {
-  C as default
+  CalendarGrid$1 as default
 };

package/dist/es/components/internal/Calendar/components/CalendarGrid/CalendarGridDate.js

@@ -1,50 +1,75 @@
-import { jsx as E } from "../../../../../external/preact/jsx-runtime/dist/jsxRuntime.module.js";
-import { getClassName as N } from "../../../../../utils/class-name-utils.js";
-import { memo as u, forwardRef as w } from "../../../../../external/preact/compat/dist/compat.module.js";
-import { propsProperty as y, property as s } from "./utils.js";
-import { EMPTY_OBJECT as i } from "../../../../../utils/common/constants.js";
-import { CalendarGridRenderToken as O } from "../../types.js";
-import l from "../../../../../utils/memoComparator/memoComparator.js";
-const T = "adyen-fp-calendar__cell adyen-fp-calendar__cell--date", _ = "adyen-fp-calendar__date", P = (a = i, r) => {
-  const d = y.unwrapped(
+import { o } from "../../../../../../jsxRuntime.module-69493d81.mjs";
+import { getClassName } from "../../../../../utils/class-name-utils.js";
+import { k, x } from "../../../../../../compat.module-a4d537ff.mjs";
+import { propsProperty, property } from "./utils.js";
+import { EMPTY_OBJECT } from "../../../../../utils/common/constants.js";
+import { C as CalendarGridRenderToken } from "../../../../../../types-0027b7c2.mjs";
+import memoComparator from "../../../../../utils/memoComparator/memoComparator.js";
+const DEFAULT_DATE_CELL_CLASSNAME = "adyen-pe-calendar__cell adyen-pe-calendar__cell--date";
+const DEFAULT_DATE_TIME_CLASSNAME = "adyen-pe-calendar__date";
+const getGridDateRenderProps = (computedProps = EMPTY_OBJECT, prepare) => {
+  const renderProps = propsProperty.unwrapped(
     {
-      childClassName: s.mutable(_),
+      childClassName: property.mutable(DEFAULT_DATE_TIME_CLASSNAME),
       childProps: {
-        children: s.restricted(),
+        children: property.restricted(),
         className: ""
       },
-      className: s.mutable(T),
+      className: property.mutable(DEFAULT_DATE_CELL_CLASSNAME),
       props: {
-        ...a,
-        children: s.restricted(),
+        ...computedProps,
+        children: property.restricted(),
         className: ""
       }
     },
-    !0
+    true
   );
-  return r == null || r(O.DATE, d), d;
-}, G = w(({ grid: a, prepare: r, datetime: d, flags: e, index: m, label: p, onlyCellsWithin: C }, h) => {
-  const n = e.WITHIN_BLOCK, t = {
-    "data-cursor-position": m,
-    "data-within-month": n,
+  prepare == null ? void 0 : prepare(CalendarGridRenderToken.DATE, renderProps);
+  return renderProps;
+};
+const CalendarGridDate = k(({ grid, prepare, datetime, flags, index, label, onlyCellsWithin }, cursorElementRef) => {
+  const withinMonth = flags.WITHIN_BLOCK;
+  const props = {
+    "data-cursor-position": index,
+    "data-within-month": withinMonth,
     tabIndex: -1
   };
-  if (n) {
-    const c = e.WITHIN_RANGE;
-    t["data-today"] = e.CURRENT, t["data-first-week-day"] = e.LINE_START, t["data-last-week-day"] = e.LINE_END, t["data-weekend"] = e.WEEKEND, t["data-first-month-day"] = e.BLOCK_START, t["data-last-month-day"] = e.BLOCK_END, t["data-within-range"] = c, c && (t["data-range-end"] = e.RANGE_END, t["data-range-start"] = e.RANGE_START, t["data-selection-end"] = e.SELECTION_END, t["data-selection-start"] = e.SELECTION_START, t["data-within-selection"] = e.WITHIN_SELECTION, t["aria-selected"] = `${!!(e.SELECTION_END || e.SELECTION_START || e.WITHIN_SELECTION)}`), m === +a.cursor && (t.ref = h);
+  if (withinMonth) {
+    const withinRange = flags.WITHIN_RANGE;
+    props["data-today"] = flags.CURRENT;
+    props["data-first-week-day"] = flags.LINE_START;
+    props["data-last-week-day"] = flags.LINE_END;
+    props["data-weekend"] = flags.WEEKEND;
+    props["data-first-month-day"] = flags.BLOCK_START;
+    props["data-last-month-day"] = flags.BLOCK_END;
+    props["data-within-range"] = withinRange;
+    if (withinRange) {
+      props["data-range-end"] = flags.RANGE_END;
+      props["data-range-start"] = flags.RANGE_START;
+      props["data-selection-end"] = flags.SELECTION_END;
+      props["data-selection-start"] = flags.SELECTION_START;
+      props["data-within-selection"] = flags.WITHIN_SELECTION;
+      props["aria-selected"] = `${!!(flags.SELECTION_END || flags.SELECTION_START || flags.WITHIN_SELECTION)}`;
+    }
+    if (index === +grid.cursor)
+      props.ref = cursorElementRef;
   }
-  const o = P(t, r), { children: k, className: I, ...A } = o.props || i, L = N(o.className, T, I);
-  return /* @__PURE__ */ E("td", { ...A, ...t, className: L, children: (!C || n) && (() => {
-    const { children: c, className: S, ...D } = o.childProps || i, R = N(o.childClassName, _, S);
-    return /* @__PURE__ */ E("time", { ...D, className: R, dateTime: d, children: p });
+  const renderProps = getGridDateRenderProps(props, prepare);
+  const { children: _, className, ...extendedProps } = renderProps.props || EMPTY_OBJECT;
+  const classes = getClassName(renderProps.className, DEFAULT_DATE_CELL_CLASSNAME, className);
+  return /* @__PURE__ */ o("td", { ...extendedProps, ...props, className: classes, children: (!onlyCellsWithin || withinMonth) && (() => {
+    const { children: _2, className: className2, ...extendedProps2 } = renderProps.childProps || EMPTY_OBJECT;
+    const classes2 = getClassName(renderProps.childClassName, DEFAULT_DATE_TIME_CLASSNAME, className2);
+    return /* @__PURE__ */ o("time", { ...extendedProps2, className: classes2, dateTime: datetime, children: label });
   })() });
-}), K = u(
-  G,
-  l({
-    block: l.exclude,
-    flags: (a) => +a
+});
+const CalendarGridDate$1 = x(
+  CalendarGridDate,
+  memoComparator({
+    block: memoComparator.exclude,
+    flags: (value) => +value
   })
 );
 export {
-  K as default
+  CalendarGridDate$1 as default
 };

package/dist/es/components/internal/Calendar/components/CalendarGrid/CalendarGridDayOfWeek.js

@@ -1,44 +1,54 @@
-import { jsx as c } from "../../../../../external/preact/jsx-runtime/dist/jsxRuntime.module.js";
-import { getClassName as t } from "../../../../../utils/class-name-utils.js";
-import { memo as y } from "../../../../../external/preact/compat/dist/compat.module.js";
-import { propsProperty as k, property as o } from "./utils.js";
-import { EMPTY_OBJECT as l } from "../../../../../utils/common/constants.js";
-import { CalendarGridRenderToken as L } from "../../types.js";
-import n from "../../../../../utils/memoComparator/memoComparator.js";
-const m = "adyen-fp-calendar__cell adyen-fp-calendar__cell--day-of-week", i = "adyen-fp-calendar__day-of-week", A = (a = l, e) => {
-  const s = k.unwrapped(
+import { o } from "../../../../../../jsxRuntime.module-69493d81.mjs";
+import { getClassName } from "../../../../../utils/class-name-utils.js";
+import { x } from "../../../../../../compat.module-a4d537ff.mjs";
+import { propsProperty, property } from "./utils.js";
+import { EMPTY_OBJECT } from "../../../../../utils/common/constants.js";
+import { C as CalendarGridRenderToken } from "../../../../../../types-0027b7c2.mjs";
+import memoComparator from "../../../../../utils/memoComparator/memoComparator.js";
+const DEFAULT_CELL_CLASSNAME = "adyen-pe-calendar__cell adyen-pe-calendar__cell--day-of-week";
+const DEFAULT_CELL_ABBR_CLASSNAME = "adyen-pe-calendar__day-of-week";
+const getGridDayOfWeekRenderProps = (computedProps = EMPTY_OBJECT, prepare) => {
+  const renderProps = propsProperty.unwrapped(
     {
-      childClassName: o.mutable(i),
+      childClassName: property.mutable(DEFAULT_CELL_ABBR_CLASSNAME),
       childProps: {
-        children: o.restricted(),
+        children: property.restricted(),
         className: ""
       },
-      className: o.mutable(m),
+      className: property.mutable(DEFAULT_CELL_CLASSNAME),
       props: {
-        ...a,
-        children: o.restricted(),
+        ...computedProps,
+        children: property.restricted(),
         className: ""
       }
     },
-    !0
+    true
   );
-  return e == null || e(L.DAY_OF_WEEK, s), s;
-}, P = ({ prepare: a, flags: e, labels: { long: s, short: p } }) => {
-  const d = {
-    "aria-label": s,
-    "data-first-week-day": e.LINE_START,
-    "data-last-week-day": e.LINE_END,
-    "data-weekend": e.WEEKEND,
+  prepare == null ? void 0 : prepare(CalendarGridRenderToken.DAY_OF_WEEK, renderProps);
+  return renderProps;
+};
+const CalendarGridDayOfWeek = ({ prepare, flags, labels: { long: longLabel, short: shortLabel } }) => {
+  const props = {
+    "aria-label": longLabel,
+    "data-first-week-day": flags.LINE_START,
+    "data-last-week-day": flags.LINE_END,
+    "data-weekend": flags.WEEKEND,
     scope: "col"
-  }, r = A(d, a), { children: u, className: _, ...N } = r.props || l, f = t(r.className, m, _), { children: D, className: E, ...h } = r.childProps || l, C = t(r.childClassName, i, E);
-  return /* @__PURE__ */ c("th", { ...N, ...d, className: f, children: /* @__PURE__ */ c("abbr", { ...h, className: C, children: p }) });
-}, G = y(
-  P,
-  n({
-    block: n.exclude,
-    flags: (a) => +a
+  };
+  const renderProps = getGridDayOfWeekRenderProps(props, prepare);
+  const { children: _, className, ...extendedProps } = renderProps.props || EMPTY_OBJECT;
+  const classes = getClassName(renderProps.className, DEFAULT_CELL_CLASSNAME, className);
+  const { children: __, className: childClassName, ...extendedChildProps } = renderProps.childProps || EMPTY_OBJECT;
+  const childClasses = getClassName(renderProps.childClassName, DEFAULT_CELL_ABBR_CLASSNAME, childClassName);
+  return /* @__PURE__ */ o("th", { ...extendedProps, ...props, className: classes, children: /* @__PURE__ */ o("abbr", { ...extendedChildProps, className: childClasses, children: shortLabel }) });
+};
+const CalendarGridDayOfWeek$1 = x(
+  CalendarGridDayOfWeek,
+  memoComparator({
+    block: memoComparator.exclude,
+    flags: (value) => +value
   })
 );
 export {
-  G as default
+  CalendarGridDayOfWeek$1 as default
 };

package/dist/es/components/internal/Calendar/components/CalendarGrid/index.js

@@ -0,0 +1,4 @@
+import { default as default2 } from "./CalendarGrid.js";
+export {
+  default2 as default
+};

package/dist/es/components/internal/Calendar/components/CalendarGrid/utils.js

@@ -1,64 +1,69 @@
-import { toString as l } from "../../../../../utils/common/index.js";
-import { EMPTY_OBJECT as a } from "../../../../../utils/common/constants.js";
-const s = (() => {
-  const n = (e) => Object.freeze(
-    Object.create(a, Object.fromEntries(Object.entries(e).map(([t, r]) => [t, { value: r }])))
-  ), i = (e) => {
+import { toString } from "../../../../../utils/common/index.js";
+import { EMPTY_OBJECT } from "../../../../../utils/common/constants.js";
+const property = (() => {
+  const descriptor = (descriptor2) => Object.freeze(
+    Object.create(EMPTY_OBJECT, Object.fromEntries(Object.entries(descriptor2).map(([field, value]) => [field, { value }])))
+  );
+  const isPropDescriptor = (value) => {
     try {
-      return Object.getPrototypeOf(e) === a;
+      return Object.getPrototypeOf(value) === EMPTY_OBJECT;
     } catch {
-      return !1;
+      return false;
     }
-  }, c = (e, t) => {
-    if (!e)
-      return n({
-        enumerable: !0,
-        writable: e !== !1,
-        value: t
+  };
+  const prop = (setter, value) => {
+    if (!setter)
+      return descriptor({
+        enumerable: true,
+        writable: setter !== false,
+        value
       });
-    let r = t;
-    return n({
-      enumerable: !0,
-      get: () => r,
-      set: (o) => {
-        r = e(o);
+    let currentValue = value;
+    return descriptor({
+      enumerable: true,
+      get: () => currentValue,
+      set: (value2) => {
+        currentValue = setter(value2);
       }
     });
   };
-  return Object.defineProperties(c, {
-    is: { value: i },
-    isObject: { value: (e) => l(e).slice(8, -1) === "Object" },
-    immutable: { value: (e) => c(!1, e) },
-    mutable: { value: (e) => c(void 0, e) },
-    restricted: { value: () => c(!1) }
+  return Object.defineProperties(prop, {
+    is: { value: isPropDescriptor },
+    isObject: { value: (value) => toString(value).slice(8, -1) === "Object" },
+    immutable: { value: (value) => prop(false, value) },
+    mutable: { value: (value) => prop(void 0, value) },
+    restricted: { value: () => prop(false) }
   });
-})(), O = (() => {
-  const n = (c = {}, e = !1) => {
-    const t = /* @__PURE__ */ Object.create(null);
-    for (const [r, o] of Object.entries(c)) {
+})();
+const propsProperty = (() => {
+  const propsProperty2 = (props = {}, deepImmutable = false) => {
+    const $props = /* @__PURE__ */ Object.create(null);
+    for (const [prop, maybeDescriptor] of Object.entries(props)) {
       try {
-        const p = s.is(o), u = s.isObject(o);
-        if (p || u) {
-          Object.defineProperty(t, r, p ? o : n(o, e));
+        const isDescriptor = property.is(maybeDescriptor);
+        const isPlainObject = property.isObject(maybeDescriptor);
+        if (isDescriptor || isPlainObject) {
+          Object.defineProperty($props, prop, isDescriptor ? maybeDescriptor : propsProperty2(maybeDescriptor, deepImmutable));
           continue;
-        } else if (e) {
-          Object.defineProperty(t, r, s.immutable(o));
+        } else if (deepImmutable) {
+          Object.defineProperty($props, prop, property.immutable(maybeDescriptor));
           continue;
         }
       } catch {
       }
-      t[r] = o;
+      $props[prop] = maybeDescriptor;
     }
-    return s((r = {}) => Object.assign(t, r), t);
+    return property((props2 = {}) => Object.assign($props, props2), $props);
+  };
+  const unwrapped = (props = {}, deepImmutable = false) => {
+    const P = propsProperty2(props, deepImmutable);
+    return Object.create(null, { P }).P;
   };
-  return Object.defineProperties(n, {
-    unwrapped: { value: (c = {}, e = !1) => {
-      const t = n(c, e);
-      return Object.create(null, { P: t }).P;
-    } }
+  return Object.defineProperties(propsProperty2, {
+    unwrapped: { value: unwrapped }
   });
 })();
 export {
-  s as property,
-  O as propsProperty
+  property,
+  propsProperty
 };