@gobrand/calendar-core 0.0.3

package/dist/index.cjs

@@ -0,0 +1,706 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  buildDay: () => buildDay,
+  buildMonth: () => buildMonth,
+  buildWeek: () => buildWeek,
+  convertToTimezone: () => convertToTimezone,
+  createCalendar: () => createCalendar,
+  createCalendarAccessor: () => createCalendarAccessor,
+  createCalendarViews: () => createCalendarViews,
+  createZonedDateTime: () => createZonedDateTime,
+  formatTime: () => formatTime,
+  functionalUpdate: () => functionalUpdate,
+  getCurrentTimeZone: () => getCurrentTimeZone,
+  getDayDateRange: () => getDayDateRange,
+  getDayRange: () => getDayRange,
+  getEventPosition: () => getEventPosition,
+  getMonthDateRange: () => getMonthDateRange,
+  getMonthName: () => getMonthName,
+  getMonthRange: () => getMonthRange,
+  getTimeSlotHeight: () => getTimeSlotHeight,
+  getTimezoneOffset: () => getTimezoneOffset,
+  getWeekDateRange: () => getWeekDateRange,
+  getWeekRange: () => getWeekRange,
+  getWeekdays: () => getWeekdays,
+  goToToday: () => goToToday,
+  nextDay: () => nextDay,
+  nextMonth: () => nextMonth,
+  nextWeek: () => nextWeek,
+  previousDay: () => previousDay,
+  previousMonth: () => previousMonth,
+  previousWeek: () => previousWeek
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils.ts
+var import_polyfill = require("@js-temporal/polyfill");
+function functionalUpdate(updater, input) {
+  return typeof updater === "function" ? updater(input) : updater;
+}
+function createCalendarAccessor(accessor) {
+  return accessor;
+}
+function nextMonth(month) {
+  return month.add({ months: 1 });
+}
+function previousMonth(month) {
+  return month.subtract({ months: 1 });
+}
+function nextWeek(date) {
+  return date.add({ weeks: 1 });
+}
+function previousWeek(date) {
+  return date.subtract({ weeks: 1 });
+}
+function nextDay(date) {
+  return date.add({ days: 1 });
+}
+function previousDay(date) {
+  return date.subtract({ days: 1 });
+}
+function goToToday() {
+  const today = import_polyfill.Temporal.Now.plainDateISO();
+  return { year: today.year, month: today.month };
+}
+function getWeekdays(weekStartsOn = 1, locale = "en-US", format = "short") {
+  const referenceDate = import_polyfill.Temporal.PlainDate.from("2023-01-02");
+  const days = [];
+  for (let i = 0; i < 7; i++) {
+    const offset = (weekStartsOn - 1 + i + 7) % 7;
+    const date = referenceDate.add({ days: offset });
+    days.push(date.toLocaleString(locale, { weekday: format }));
+  }
+  return days;
+}
+function getMonthName(month, locale = "en-US") {
+  return month.toPlainDate({ day: 1 }).toLocaleString(locale, { month: "long" });
+}
+function formatTime(time, locale = "en-US") {
+  const date = import_polyfill.Temporal.PlainDate.from("2023-01-01");
+  const dateTime = date.toPlainDateTime(time);
+  return dateTime.toLocaleString(locale, { hour: "numeric", minute: "2-digit" });
+}
+function getTimeSlotHeight(slotDuration, hourHeight) {
+  return slotDuration / 60 * hourHeight;
+}
+function getEventPosition(eventStart, eventEnd, dayStart, hourHeight) {
+  const startTime = eventStart.toPlainTime();
+  const endTime = eventEnd.toPlainTime();
+  const startMinutes = startTime.hour * 60 + startTime.minute;
+  const endMinutes = endTime.hour * 60 + endTime.minute;
+  const dayStartMinutes = dayStart * 60;
+  const top = (startMinutes - dayStartMinutes) / 60 * hourHeight;
+  const height = (endMinutes - startMinutes) / 60 * hourHeight;
+  return { top, height };
+}
+function convertToTimezone(dateTime, timeZone) {
+  return dateTime.withTimeZone(timeZone);
+}
+function getTimezoneOffset(dateTime) {
+  return dateTime.offsetNanoseconds / 36e11 >= 0 ? `+${Math.floor(dateTime.offsetNanoseconds / 36e11)}` : `${Math.floor(dateTime.offsetNanoseconds / 36e11)}`;
+}
+function createZonedDateTime(date, time, timeZone) {
+  return date.toZonedDateTime({ timeZone, plainTime: time });
+}
+function getCurrentTimeZone() {
+  return import_polyfill.Temporal.Now.timeZoneId();
+}
+function getMonthRange(timeZone = getCurrentTimeZone(), weekStartsOn = 1) {
+  const today = import_polyfill.Temporal.Now.zonedDateTimeISO(timeZone).toPlainDate();
+  const firstOfMonth = today.with({ day: 1 });
+  const lastOfMonth = today.with({ day: today.daysInMonth });
+  const startDayOfWeek = firstOfMonth.dayOfWeek;
+  const daysToSubtract = (startDayOfWeek - weekStartsOn + 7) % 7;
+  const start = firstOfMonth.subtract({ days: daysToSubtract });
+  const endDayOfWeek = lastOfMonth.dayOfWeek;
+  const daysToAdd = (weekStartsOn + 6 - endDayOfWeek) % 7;
+  const end = lastOfMonth.add({ days: daysToAdd });
+  return { start, end };
+}
+function getWeekRange(timeZone = getCurrentTimeZone(), weekStartsOn = 1) {
+  const today = import_polyfill.Temporal.Now.zonedDateTimeISO(timeZone).toPlainDate();
+  const dayOfWeek = today.dayOfWeek;
+  const daysToSubtract = (dayOfWeek - weekStartsOn + 7) % 7;
+  const start = today.subtract({ days: daysToSubtract });
+  const end = start.add({ days: 6 });
+  return { start, end };
+}
+function getDayRange(timeZone = getCurrentTimeZone()) {
+  const today = import_polyfill.Temporal.Now.zonedDateTimeISO(timeZone).toPlainDate();
+  return { start: today, end: today };
+}
+
+// src/utils/buildMonth.ts
+var import_polyfill2 = require("@js-temporal/polyfill");
+function buildMonth(year, month, options) {
+  const weekStartsOn = options?.weekStartsOn ?? 1;
+  const today = options?.today ?? import_polyfill2.Temporal.Now.plainDateISO();
+  const data = options?.data ?? [];
+  const accessor = options?.accessor;
+  const yearMonth = import_polyfill2.Temporal.PlainYearMonth.from({ year, month });
+  const firstOfMonth = yearMonth.toPlainDate({ day: 1 });
+  const lastOfMonth = yearMonth.toPlainDate({ day: yearMonth.daysInMonth });
+  const itemsByDate = /* @__PURE__ */ new Map();
+  if (accessor) {
+    for (const item of data) {
+      const date = accessor.getDate(item);
+      const key = date.toString();
+      const existing = itemsByDate.get(key) ?? [];
+      itemsByDate.set(key, [...existing, item]);
+    }
+  }
+  let startDate = firstOfMonth;
+  const firstDayOfWeek = firstOfMonth.dayOfWeek;
+  const daysToSubtract = (firstDayOfWeek - weekStartsOn + 7) % 7;
+  if (daysToSubtract > 0) {
+    startDate = firstOfMonth.subtract({ days: daysToSubtract });
+  }
+  const weeks = [];
+  let currentDate = startDate;
+  while (currentDate.month !== lastOfMonth.month || currentDate.day <= lastOfMonth.day || weeks.length === 0 || weeks[weeks.length - 1].length < 7) {
+    if (weeks.length === 0 || weeks[weeks.length - 1].length === 7) {
+      weeks.push([]);
+    }
+    const dateKey = currentDate.toString();
+    weeks[weeks.length - 1].push({
+      date: currentDate,
+      isCurrentMonth: currentDate.month === month,
+      isToday: import_polyfill2.Temporal.PlainDate.compare(currentDate, today) === 0,
+      items: itemsByDate.get(dateKey) ?? []
+    });
+    currentDate = currentDate.add({ days: 1 });
+    if (weeks.length >= 6 && weeks[weeks.length - 1].length === 7) {
+      break;
+    }
+  }
+  return {
+    weeks,
+    month: yearMonth
+  };
+}
+
+// src/utils/buildWeek.ts
+var import_polyfill4 = require("@js-temporal/polyfill");
+
+// src/utils/buildDay.ts
+var import_polyfill3 = require("@js-temporal/polyfill");
+function buildDay(date, options) {
+  const startHour = options?.startHour ?? 0;
+  const endHour = options?.endHour ?? 24;
+  const slotDuration = options?.slotDuration ?? 30;
+  const today = options?.today ?? import_polyfill3.Temporal.Now.plainDateISO();
+  const data = options?.data ?? [];
+  const accessor = options?.accessor;
+  const dayItems = [];
+  if (accessor) {
+    for (const item of data) {
+      const itemDate = accessor.getDate(item);
+      if (import_polyfill3.Temporal.PlainDate.compare(itemDate, date) === 0) {
+        dayItems.push(item);
+      }
+    }
+  }
+  const timeSlots = [];
+  let currentHour = startHour;
+  let currentMinute = 0;
+  while (currentHour < endHour) {
+    const slotStart = import_polyfill3.Temporal.PlainTime.from({ hour: currentHour, minute: currentMinute });
+    let nextMinute = currentMinute + slotDuration;
+    let nextHour = currentHour;
+    if (nextMinute >= 60) {
+      nextHour += Math.floor(nextMinute / 60);
+      nextMinute = nextMinute % 60;
+    }
+    const slotItems = [];
+    if (accessor?.getStart) {
+      for (const item of dayItems) {
+        const itemStart = accessor.getStart(item);
+        const itemTime = itemStart.toPlainTime();
+        const slotEndHour = nextHour >= 24 ? 0 : nextHour;
+        const slotEndMinute = nextHour >= 24 ? 0 : nextMinute;
+        const slotEnd = import_polyfill3.Temporal.PlainTime.from({ hour: slotEndHour, minute: slotEndMinute });
+        const isAfterStart = import_polyfill3.Temporal.PlainTime.compare(itemTime, slotStart) >= 0;
+        const isBeforeEnd = nextHour >= 24 ? import_polyfill3.Temporal.PlainTime.compare(itemTime, slotEnd) > 0 : import_polyfill3.Temporal.PlainTime.compare(itemTime, slotEnd) < 0;
+        if (isAfterStart && isBeforeEnd) {
+          slotItems.push(item);
+        }
+      }
+    }
+    timeSlots.push({
+      hour: currentHour,
+      minute: currentMinute,
+      time: slotStart,
+      items: slotItems
+    });
+    currentMinute += slotDuration;
+    if (currentMinute >= 60) {
+      currentHour += Math.floor(currentMinute / 60);
+      currentMinute = currentMinute % 60;
+    }
+  }
+  return {
+    date,
+    isToday: import_polyfill3.Temporal.PlainDate.compare(date, today) === 0,
+    timeSlots,
+    items: dayItems
+  };
+}
+
+// src/utils/buildWeek.ts
+function buildWeek(date, options) {
+  const weekStartsOn = options?.weekStartsOn ?? 1;
+  const startHour = options?.startHour;
+  const endHour = options?.endHour;
+  const slotDuration = options?.slotDuration;
+  const today = options?.today ?? import_polyfill4.Temporal.Now.plainDateISO();
+  const data = options?.data ?? [];
+  const accessor = options?.accessor;
+  const hasTimeSlots = startHour !== void 0 && endHour !== void 0 && slotDuration !== void 0;
+  const itemsByDate = /* @__PURE__ */ new Map();
+  if (accessor) {
+    for (const item of data) {
+      const date2 = accessor.getDate(item);
+      const key = date2.toString();
+      const existing = itemsByDate.get(key) ?? [];
+      itemsByDate.set(key, [...existing, item]);
+    }
+  }
+  const dayOfWeek = date.dayOfWeek;
+  const daysToSubtract = (dayOfWeek - weekStartsOn + 7) % 7;
+  const weekStart = date.subtract({ days: daysToSubtract });
+  const days = [];
+  for (let i = 0; i < 7; i++) {
+    const currentDate = weekStart.add({ days: i });
+    const dateKey = currentDate.toString();
+    let timeSlots = void 0;
+    if (hasTimeSlots) {
+      const dayView = buildDay(currentDate, {
+        startHour,
+        endHour,
+        slotDuration,
+        today,
+        data,
+        accessor
+      });
+      timeSlots = dayView.timeSlots;
+    }
+    days.push({
+      date: currentDate,
+      isToday: import_polyfill4.Temporal.PlainDate.compare(currentDate, today) === 0,
+      items: itemsByDate.get(dateKey) ?? [],
+      timeSlots
+    });
+  }
+  const weekEnd = weekStart.add({ days: 6 });
+  return {
+    days,
+    weekStart,
+    weekEnd
+  };
+}
+
+// src/utils/dateRanges.ts
+var import_polyfill5 = require("@js-temporal/polyfill");
+function getMonthDateRange(date, timeZone, options) {
+  const weekStartsOn = options?.weekStartsOn ?? 1;
+  const bounds = options?.bounds ?? "calendar";
+  const firstOfMonth = date.with({ day: 1 });
+  const lastOfMonth = date.with({ day: date.daysInMonth });
+  let start;
+  let end;
+  if (bounds === "calendar") {
+    const startDayOfWeek = firstOfMonth.dayOfWeek;
+    const daysToSubtract = (startDayOfWeek - weekStartsOn + 7) % 7;
+    start = firstOfMonth.subtract({ days: daysToSubtract });
+    const endDayOfWeek = lastOfMonth.dayOfWeek;
+    const daysToAdd = (weekStartsOn + 6 - endDayOfWeek) % 7;
+    end = lastOfMonth.add({ days: daysToAdd });
+  } else {
+    start = firstOfMonth;
+    end = lastOfMonth;
+  }
+  const startZoned = start.toZonedDateTime({
+    timeZone,
+    plainTime: import_polyfill5.Temporal.PlainTime.from("00:00:00")
+  });
+  const endZoned = end.toZonedDateTime({
+    timeZone,
+    plainTime: import_polyfill5.Temporal.PlainTime.from("23:59:59.999")
+  });
+  return { start: startZoned, end: endZoned };
+}
+function getWeekDateRange(date, timeZone, options) {
+  const weekStartsOn = options?.weekStartsOn ?? 1;
+  const dayOfWeek = date.dayOfWeek;
+  const daysToSubtract = (dayOfWeek - weekStartsOn + 7) % 7;
+  const start = date.subtract({ days: daysToSubtract });
+  const end = start.add({ days: 6 });
+  const startZoned = start.toZonedDateTime({
+    timeZone,
+    plainTime: import_polyfill5.Temporal.PlainTime.from("00:00:00")
+  });
+  const endZoned = end.toZonedDateTime({
+    timeZone,
+    plainTime: import_polyfill5.Temporal.PlainTime.from("23:59:59.999")
+  });
+  return { start: startZoned, end: endZoned };
+}
+function getDayDateRange(date, timeZone) {
+  const startZoned = date.toZonedDateTime({
+    timeZone,
+    plainTime: import_polyfill5.Temporal.PlainTime.from("00:00:00")
+  });
+  const endZoned = date.toZonedDateTime({
+    timeZone,
+    plainTime: import_polyfill5.Temporal.PlainTime.from("23:59:59.999")
+  });
+  return { start: startZoned, end: endZoned };
+}
+
+// src/core/calendar.ts
+var import_polyfill6 = require("@js-temporal/polyfill");
+var import_store = require("@tanstack/store");
+function computeDateRange(view, referenceDate, timeZone, weekStartsOn = 1) {
+  let start;
+  let end;
+  if (view === "month") {
+    const firstOfMonth = referenceDate.with({ day: 1 });
+    const lastOfMonth = referenceDate.with({ day: referenceDate.daysInMonth });
+    const startDayOfWeek = firstOfMonth.dayOfWeek;
+    const daysToSubtract = (startDayOfWeek - weekStartsOn + 7) % 7;
+    start = firstOfMonth.subtract({ days: daysToSubtract });
+    const endDayOfWeek = lastOfMonth.dayOfWeek;
+    const daysToAdd = (weekStartsOn + 6 - endDayOfWeek) % 7;
+    end = lastOfMonth.add({ days: daysToAdd });
+  } else if (view === "week") {
+    const dayOfWeek = referenceDate.dayOfWeek;
+    const daysToSubtract = (dayOfWeek - weekStartsOn + 7) % 7;
+    start = referenceDate.subtract({ days: daysToSubtract });
+    end = start.add({ days: 6 });
+  } else {
+    start = referenceDate;
+    end = referenceDate;
+  }
+  const startZoned = start.toZonedDateTime({
+    timeZone,
+    plainTime: import_polyfill6.Temporal.PlainTime.from("00:00:00")
+  });
+  const endZoned = end.toZonedDateTime({
+    timeZone,
+    plainTime: import_polyfill6.Temporal.PlainTime.from("23:59:59.999")
+  });
+  return { start: startZoned, end: endZoned };
+}
+function createCalendar(options) {
+  const configuredViews = Object.keys(options.views);
+  const defaultView = configuredViews[0];
+  const timeZone = options.timeZone || import_polyfill6.Temporal.Now.timeZoneId();
+  const monthView = options.views.month;
+  const weekView = options.views.week;
+  const weekStartsOn = monthView?.weekStartsOn ?? weekView?.weekStartsOn ?? 1;
+  const initialReferenceDate = options.state?.referenceDate || import_polyfill6.Temporal.Now.plainDateISO();
+  const initialView = options.state?.currentView || defaultView;
+  const initialDateRange = computeDateRange(
+    initialView,
+    initialReferenceDate,
+    timeZone,
+    weekStartsOn
+  );
+  const resolvedOptions = {
+    state: {
+      referenceDate: initialReferenceDate,
+      currentView: initialView,
+      dateRange: initialDateRange
+    },
+    onStateChange: () => {
+    },
+    ...options
+  };
+  let _options = resolvedOptions;
+  const store = new import_store.Store({
+    referenceDate: initialReferenceDate,
+    currentView: initialView,
+    dateRange: initialDateRange,
+    ...resolvedOptions.state
+  });
+  const getMonthImpl = () => {
+    const state = store.state;
+    const { year, month } = state.referenceDate;
+    const monthView2 = _options.views.month;
+    if (!monthView2) throw new Error("Month view not configured");
+    return buildMonth(year, month, {
+      weekStartsOn: monthView2.weekStartsOn,
+      data: _options.data,
+      accessor: monthView2.accessor
+    });
+  };
+  const getWeekImpl = () => {
+    const state = store.state;
+    const weekView2 = _options.views.week;
+    if (!weekView2) throw new Error("Week view not configured");
+    return buildWeek(state.referenceDate, {
+      weekStartsOn: weekView2.weekStartsOn,
+      startHour: weekView2.startHour,
+      endHour: weekView2.endHour,
+      slotDuration: weekView2.slotDuration,
+      data: _options.data,
+      accessor: weekView2.accessor
+    });
+  };
+  const getDayImpl = () => {
+    const state = store.state;
+    const dayView = _options.views.day;
+    if (!dayView) throw new Error("Day view not configured");
+    return buildDay(state.referenceDate, {
+      startHour: dayView.startHour,
+      endHour: dayView.endHour,
+      slotDuration: dayView.slotDuration,
+      data: _options.data,
+      accessor: dayView.accessor
+    });
+  };
+  const setStateImpl = (updater) => {
+    const partialState = typeof updater === "function" ? updater(store.state) : updater;
+    const newState = {
+      ...store.state,
+      ...partialState
+    };
+    const currentView = newState.currentView || defaultView;
+    const dateRange = computeDateRange(
+      currentView,
+      newState.referenceDate,
+      timeZone,
+      weekStartsOn
+    );
+    const stateWithDateRange = {
+      ...newState,
+      dateRange
+    };
+    store.setState(() => stateWithDateRange);
+    if (_options.onStateChange) {
+      _options.onStateChange(stateWithDateRange);
+    }
+  };
+  const nextMonthImpl = () => {
+    setStateImpl((old) => {
+      const current = import_polyfill6.Temporal.PlainYearMonth.from({
+        year: old.referenceDate.year,
+        month: old.referenceDate.month
+      });
+      const next = nextMonth(current);
+      return {
+        referenceDate: next.toPlainDate({ day: 1 })
+      };
+    });
+  };
+  const previousMonthImpl = () => {
+    setStateImpl((old) => {
+      const current = import_polyfill6.Temporal.PlainYearMonth.from({
+        year: old.referenceDate.year,
+        month: old.referenceDate.month
+      });
+      const prev = previousMonth(current);
+      return {
+        referenceDate: prev.toPlainDate({ day: 1 })
+      };
+    });
+  };
+  const nextWeekImpl = () => {
+    setStateImpl((old) => ({
+      referenceDate: nextWeek(old.referenceDate)
+    }));
+  };
+  const previousWeekImpl = () => {
+    setStateImpl((old) => ({
+      referenceDate: previousWeek(old.referenceDate)
+    }));
+  };
+  const nextDayImpl = () => {
+    setStateImpl((old) => ({
+      referenceDate: nextDay(old.referenceDate)
+    }));
+  };
+  const previousDayImpl = () => {
+    setStateImpl((old) => ({
+      referenceDate: previousDay(old.referenceDate)
+    }));
+  };
+  const calendar = {
+    getMonth: getMonthImpl,
+    getWeek: getWeekImpl,
+    getDay: getDayImpl,
+    getTitle(view, locales, options2) {
+      switch (view) {
+        case "month": {
+          const month = getMonthImpl();
+          const date = month.month.toPlainDate({ day: 1 });
+          return date.toLocaleString(locales, {
+            month: "long",
+            year: "numeric",
+            ...options2
+          });
+        }
+        case "week": {
+          const week = getWeekImpl();
+          const startOptions = {
+            month: "short",
+            day: "numeric",
+            ...options2
+          };
+          const endOptions = {
+            month: "short",
+            day: "numeric",
+            year: "numeric",
+            ...options2
+          };
+          const start = week.weekStart.toLocaleString(locales, startOptions);
+          const end = week.weekEnd.toLocaleString(locales, endOptions);
+          return `${start} - ${end}`;
+        }
+        case "day": {
+          const day = getDayImpl();
+          return day.date.toLocaleString(locales, {
+            weekday: "long",
+            month: "long",
+            day: "numeric",
+            year: "numeric",
+            ...options2
+          });
+        }
+      }
+    },
+    getState() {
+      return store.state;
+    },
+    setState: setStateImpl,
+    nextMonth: nextMonthImpl,
+    previousMonth: previousMonthImpl,
+    goToMonth(year, month) {
+      setStateImpl(() => ({
+        referenceDate: import_polyfill6.Temporal.PlainDate.from({ year, month, day: 1 })
+      }));
+    },
+    nextWeek: nextWeekImpl,
+    previousWeek: previousWeekImpl,
+    nextDay: nextDayImpl,
+    previousDay: previousDayImpl,
+    goToToday() {
+      setStateImpl(() => ({
+        referenceDate: import_polyfill6.Temporal.Now.plainDateISO()
+      }));
+    },
+    goToDate(date) {
+      setStateImpl(() => ({
+        referenceDate: date
+      }));
+    },
+    next(view) {
+      switch (view) {
+        case "month":
+          nextMonthImpl();
+          break;
+        case "week":
+          nextWeekImpl();
+          break;
+        case "day":
+          nextDayImpl();
+          break;
+      }
+    },
+    previous(view) {
+      switch (view) {
+        case "month":
+          previousMonthImpl();
+          break;
+        case "week":
+          previousWeekImpl();
+          break;
+        case "day":
+          previousDayImpl();
+          break;
+      }
+    },
+    get views() {
+      return configuredViews;
+    },
+    get currentView() {
+      return store.state.currentView || defaultView;
+    },
+    setCurrentView(view) {
+      setStateImpl((old) => ({
+        ...old,
+        currentView: view
+      }));
+    },
+    get dateRange() {
+      return store.state.dateRange;
+    },
+    get options() {
+      return _options;
+    },
+    setOptions(updater) {
+      _options = functionalUpdate(updater, _options);
+    },
+    store
+  };
+  return calendar;
+}
+
+// src/createCalendarViews.ts
+function createCalendarViews() {
+  return (views) => {
+    return views;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildDay,
+  buildMonth,
+  buildWeek,
+  convertToTimezone,
+  createCalendar,
+  createCalendarAccessor,
+  createCalendarViews,
+  createZonedDateTime,
+  formatTime,
+  functionalUpdate,
+  getCurrentTimeZone,
+  getDayDateRange,
+  getDayRange,
+  getEventPosition,
+  getMonthDateRange,
+  getMonthName,
+  getMonthRange,
+  getTimeSlotHeight,
+  getTimezoneOffset,
+  getWeekDateRange,
+  getWeekRange,
+  getWeekdays,
+  goToToday,
+  nextDay,
+  nextMonth,
+  nextWeek,
+  previousDay,
+  previousMonth,
+  previousWeek
+});