@astryxdesign/lab 0.0.0-bootstrap.0 → 0.1.2-canary.04e71b2

package/dist/Schedule/DayView.js

@@ -0,0 +1,105 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file DayView.tsx
+ * @input Schedule context and day view options
+ * @output Single-day time-grid schedule view factory
+ * @position Concrete schedule view; exported as createScheduleDayView
+ */
+import { DATE_FORMAT_WITH_WEEKDAY, plainDateAddDays, plainDateFormat } from '@astryxdesign/core/utils';
+import { enumerateDates, getScheduleRangeFromDates } from "./dateMath.js";
+import { useScheduleContext } from "./context.js";
+import { ScheduleMonthTitle, ScheduleFrame } from "./shared.js";
+import { TimeGridView } from "./TimeGridView.js";
+import { scheduleRangeToZonedDateTimeRange } from "./zonedDateTime.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+function ScheduleDayView({
+  options
+}) {
+  const {
+    events,
+    date,
+    focusDate,
+    timezoneID,
+    range,
+    isLoading
+  } = useScheduleContext();
+  const {
+    minHour = 0,
+    maxHour = 24,
+    hourHeight = 100
+  } = options;
+  const rangeDate = date.toPlainDate();
+  const days = enumerateDates(range.startDate, range.endDate);
+  const titleLabel = plainDateFormat(rangeDate, DATE_FORMAT_WITH_WEEKDAY);
+  return /*#__PURE__*/_jsx(ScheduleFrame, {
+    title: /*#__PURE__*/_jsx(ScheduleMonthTitle, {
+      date: rangeDate,
+      timezoneID: timezoneID
+    }),
+    titleLabel: titleLabel,
+    isLoading: isLoading,
+    children: /*#__PURE__*/_jsx(TimeGridView, {
+      days: days,
+      events: events,
+      focusDate: focusDate.toPlainDate(),
+      timezoneID: timezoneID,
+      minHour: minHour,
+      maxHour: maxHour,
+      hourHeight: hourHeight
+    })
+  });
+}
+export function createScheduleDayView({
+  minHour = 0,
+  maxHour = 24,
+  hourHeight = 100
+} = {}) {
+  return {
+    component: ScheduleDayView,
+    options: {
+      minHour,
+      maxHour,
+      hourHeight
+    },
+    getDateRange: date => {
+      const range = getDayDateRange({
+        date: date.toPlainDate(),
+        timezoneID: date.timezoneID
+      });
+      return scheduleRangeToZonedDateTimeRange(range, date.timezoneID);
+    },
+    getPreviousDateRange: date => {
+      const range = getDayDateRange({
+        date: plainDateAddDays(date.toPlainDate(), -1),
+        timezoneID: date.timezoneID
+      });
+      return {
+        label: 'Previous day',
+        range: scheduleRangeToZonedDateTimeRange(range, date.timezoneID)
+      };
+    },
+    getNextDateRange: date => {
+      const range = getDayDateRange({
+        date: plainDateAddDays(date.toPlainDate(), 1),
+        timezoneID: date.timezoneID
+      });
+      return {
+        label: 'Next day',
+        range: scheduleRangeToZonedDateTimeRange(range, date.timezoneID)
+      };
+    }
+  };
+}
+function getDayDateRange({
+  date,
+  timezoneID
+}) {
+  return getScheduleRangeFromDates({
+    startDate: date,
+    endDate: plainDateAddDays(date, 1),
+    timezoneID
+  });
+}

package/dist/Schedule/ListView.d.ts

@@ -0,0 +1,6 @@
+import type { ScheduleView } from './types';
+export interface ScheduleListViewOptions {
+    days?: number;
+}
+export declare function createScheduleListView({ days: listDays, }?: ScheduleListViewOptions): ScheduleView<ScheduleListViewOptions>;
+//# sourceMappingURL=ListView.d.ts.map

package/dist/Schedule/ListView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ListView.d.ts","sourceRoot":"","sources":["../../src/Schedule/ListView.tsx"],"names":[],"mappings":"AAwCA,OAAO,KAAK,EAGV,YAAY,EAEb,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAqID,wBAAgB,sBAAsB,CAAC,EACrC,IAAI,EAAE,QAAY,GACnB,GAAE,uBAA4B,GAAG,YAAY,CAAC,uBAAuB,CAAC,CAmCtE"}

package/dist/Schedule/ListView.js

@@ -0,0 +1,171 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file ListView.tsx
+ * @input Schedule context and list view options
+ * @output Event-list schedule view factory
+ * @position Concrete schedule view; exported as createScheduleListView
+ */
+import * as stylex from '@stylexjs/stylex';
+import { plainDateAddDays, plainDateFromInstant, plainDateIsEqual, plainDateToISO } from '@astryxdesign/core/utils';
+import { Heading } from '@astryxdesign/core/Text';
+import { enumerateDates, eventOccursOnDate, getScheduleRangeFromDates, isDayEvent } from "./dateMath.js";
+import { useScheduleContext } from "./context.js";
+import { formatDayNumber, formatFullDate, formatWeekday, formatWeekTitle, isEventInPast, ListEventRow, ScheduleFrame, ScheduleRangeMonthTitle, styles } from "./shared.js";
+import { useCurrentTime } from "./useCurrentTime.js";
+import { scheduleRangeToZonedDateTimeRange } from "./zonedDateTime.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+function ScheduleListView(_props) {
+  const {
+    events,
+    timezoneID,
+    range,
+    isLoading
+  } = useScheduleContext();
+  const days = enumerateDates(range.startDate, range.endDate);
+  const currentTime = useCurrentTime();
+  const currentPlainDate = plainDateFromInstant(currentTime, timezoneID);
+  const endDate = plainDateAddDays(range.endDate, -1);
+  const titleLabel = formatWeekTitle(range.startDate, endDate, timezoneID);
+  const visibleDays = days.map(day => {
+    const isCurrentDay = plainDateIsEqual(day, currentPlainDate);
+    const isBaseDay = plainDateIsEqual(day, range.startDate);
+    const dayEvents = events.filter(event => eventOccursOnDate(event, day, timezoneID));
+    return {
+      day,
+      dayEvents,
+      isCurrentDay,
+      isVisible: dayEvents.length > 0 || isCurrentDay || isBaseDay
+    };
+  }).filter(dayRecord => dayRecord.isVisible);
+  return /*#__PURE__*/_jsx(ScheduleFrame, {
+    title: /*#__PURE__*/_jsx(ScheduleRangeMonthTitle, {
+      start: range.startDate,
+      end: endDate,
+      timezoneID: timezoneID
+    }),
+    titleLabel: titleLabel,
+    isLoading: isLoading,
+    children: /*#__PURE__*/_jsx("div", {
+      ...stylex.props(styles.list),
+      children: visibleDays.map(({
+        day,
+        dayEvents,
+        isCurrentDay
+      }, index) => /*#__PURE__*/_jsxs("section", {
+        ...stylex.props(styles.listDay, index === visibleDays.length - 1 && styles.listDayLast),
+        children: [/*#__PURE__*/_jsx(ListDayHeading, {
+          day: day,
+          isCurrentDay: isCurrentDay,
+          timezoneID: timezoneID
+        }), /*#__PURE__*/_jsx("div", {
+          ...stylex.props(styles.listEvents),
+          children: renderListRows({
+            events: dayEvents,
+            timezoneID,
+            showCurrentTime: isCurrentDay && !isLoading,
+            currentTime
+          })
+        })]
+      }, plainDateToISO(day)))
+    })
+  });
+}
+function ListDayHeading({
+  day,
+  isCurrentDay,
+  timezoneID
+}) {
+  return /*#__PURE__*/_jsxs(Heading, {
+    level: 4,
+    color: "secondary",
+    display: "block",
+    "aria-label": formatFullDate(day, timezoneID),
+    "aria-current": isCurrentDay ? 'date' : undefined,
+    xstyle: styles.listDayHeading,
+    children: [/*#__PURE__*/_jsx("span", {
+      ...stylex.props(styles.listDayNumber, isCurrentDay && styles.listDayNumberCurrent),
+      children: /*#__PURE__*/_jsx("span", {
+        ...stylex.props(styles.listDayNumberText),
+        children: formatDayNumber(day, timezoneID)
+      })
+    }), formatWeekday(day, timezoneID, 'short')]
+  });
+}
+function renderListRows({
+  events,
+  timezoneID,
+  showCurrentTime,
+  currentTime
+}) {
+  const rows = events.map(event => /*#__PURE__*/_jsx(ListEventRow, {
+    event: event,
+    timezoneID: timezoneID,
+    isPast: isEventInPast(event, currentTime, timezoneID)
+  }, event.id));
+  if (!showCurrentTime) {
+    return rows;
+  }
+  const marker = /*#__PURE__*/_jsx("div", {
+    "aria-hidden": true,
+    ...stylex.props(styles.listNowRow)
+  }, "current-time");
+  const insertIndex = events.findIndex(event => !isDayEvent(event) && event.start > currentTime);
+  if (insertIndex < 0) {
+    return [...rows, marker];
+  }
+  return [...rows.slice(0, insertIndex), marker, ...rows.slice(insertIndex)];
+}
+export function createScheduleListView({
+  days: listDays = 7
+} = {}) {
+  return {
+    component: ScheduleListView,
+    options: {
+      days: listDays
+    },
+    getDateRange: date => {
+      const range = getListDateRange({
+        date: date.toPlainDate(),
+        timezoneID: date.timezoneID,
+        days: listDays
+      });
+      return scheduleRangeToZonedDateTimeRange(range, date.timezoneID);
+    },
+    getPreviousDateRange: date => {
+      const range = getListDateRange({
+        date: plainDateAddDays(date.toPlainDate(), -listDays),
+        timezoneID: date.timezoneID,
+        days: listDays
+      });
+      return {
+        label: 'Previous list range',
+        range: scheduleRangeToZonedDateTimeRange(range, date.timezoneID)
+      };
+    },
+    getNextDateRange: date => {
+      const range = getListDateRange({
+        date: plainDateAddDays(date.toPlainDate(), listDays),
+        timezoneID: date.timezoneID,
+        days: listDays
+      });
+      return {
+        label: 'Next list range',
+        range: scheduleRangeToZonedDateTimeRange(range, date.timezoneID)
+      };
+    }
+  };
+}
+function getListDateRange({
+  date,
+  timezoneID,
+  days
+}) {
+  return getScheduleRangeFromDates({
+    startDate: date,
+    endDate: plainDateAddDays(date, days),
+    timezoneID
+  });
+}

package/dist/Schedule/MonthlyView.d.ts

@@ -0,0 +1,6 @@
+import type { ScheduleView } from './types';
+export interface ScheduleMonthlyViewOptions {
+    weekStartsOn?: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+}
+export declare function createScheduleMonthlyView({ weekStartsOn, }?: ScheduleMonthlyViewOptions): ScheduleView<ScheduleMonthlyViewOptions>;
+//# sourceMappingURL=MonthlyView.d.ts.map

package/dist/Schedule/MonthlyView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MonthlyView.d.ts","sourceRoot":"","sources":["../../src/Schedule/MonthlyView.tsx"],"names":[],"mappings":"AA8CA,OAAO,KAAK,EAEV,YAAY,EAEb,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,0BAA0B;IACzC,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;CAC1C;AAgSD,wBAAgB,yBAAyB,CAAC,EACxC,YAAgB,GACjB,GAAE,0BAA+B,GAAG,YAAY,CAAC,0BAA0B,CAAC,CAmC5E"}

package/dist/Schedule/MonthlyView.js

@@ -0,0 +1,270 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+'use client';
+
+/**
+ * @file MonthlyView.tsx
+ * @input Schedule context and monthly view options
+ * @output Month grid schedule view factory
+ * @position Concrete schedule view; exported as createScheduleMonthlyView
+ */
+import * as stylex from '@stylexjs/stylex';
+import { plainDateAddDays, plainDateAddMonths, plainDateFromInstant, plainDateIsAfter, plainDateIsBefore, plainDateIsEqual, plainDateSetEndOfWeekExclusive, plainDateSetFirstOfMonth, plainDateSetStartOfWeek, plainDateToISO } from '@astryxdesign/core/utils';
+import { Heading, Text } from '@astryxdesign/core/Text';
+import { enumerateDates, getScheduleRangeFromDates, isDayEvent } from "./dateMath.js";
+import { useScheduleContext } from "./context.js";
+import { formatDayNumber, formatEventAccessibilityLabel, formatFullDate, formatMonthTitle, formatWeekday, isEventInPast, MonthEventPill, ScheduleFrame, ScheduleMonthTitle, styles } from "./shared.js";
+import { useCurrentTime } from "./useCurrentTime.js";
+import { scheduleRangeToZonedDateTimeRange } from "./zonedDateTime.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+function ScheduleMonthlyView(_props) {
+  const {
+    events,
+    categories,
+    date,
+    focusDate,
+    timezoneID,
+    range,
+    isLoading
+  } = useScheduleContext();
+  const rangeDate = date.toPlainDate();
+  const highlightedDate = focusDate.toPlainDate();
+  const currentTime = useCurrentTime();
+  const days = enumerateDates(range.startDate, range.endDate);
+  const weeks = getWeeks(days);
+  const eventSegments = getMonthEventSegments(events, days, timezoneID);
+  const eventsByDay = getMonthEventsByDay(events, days, timezoneID);
+  return /*#__PURE__*/_jsx(ScheduleFrame, {
+    title: /*#__PURE__*/_jsx(ScheduleMonthTitle, {
+      date: rangeDate,
+      timezoneID: timezoneID
+    }),
+    titleLabel: formatMonthTitle(rangeDate, timezoneID),
+    isLoading: isLoading,
+    children: /*#__PURE__*/_jsxs("div", {
+      role: "grid",
+      "aria-label": formatMonthTitle(rangeDate, timezoneID),
+      "aria-readonly": true,
+      ...stylex.props(styles.monthGrid),
+      children: [/*#__PURE__*/_jsx("div", {
+        role: "row",
+        ...stylex.props(styles.weekHeader),
+        children: days.slice(0, 7).map((day, index) => /*#__PURE__*/_jsx("div", {
+          role: "columnheader",
+          "aria-label": formatWeekday(day, timezoneID, 'long'),
+          "aria-colindex": index + 1,
+          ...stylex.props(styles.weekdayLabel),
+          children: /*#__PURE__*/_jsx(Heading, {
+            level: 4,
+            color: "secondary",
+            display: "block",
+            xstyle: styles.weekdayHeading,
+            children: formatWeekday(day, timezoneID, 'short')
+          })
+        }, plainDateToISO(day)))
+      }), /*#__PURE__*/_jsxs("div", {
+        ...stylex.props(styles.monthGridSurface),
+        children: [/*#__PURE__*/_jsx("div", {
+          ...stylex.props(styles.monthCellGrid),
+          children: weeks.map((week, weekIndex) => /*#__PURE__*/_jsx("div", {
+            role: "row",
+            ...stylex.props(styles.monthGridRow),
+            children: week.map((day, dayIndex) => {
+              const index = weekIndex * 7 + dayIndex;
+              const isOutsideMonth = day.month !== rangeDate.month;
+              const dayEvents = eventsByDay.get(plainDateToISO(day)) ?? EMPTY_EVENTS;
+              return /*#__PURE__*/_jsxs("div", {
+                role: "gridcell",
+                "aria-label": formatFullDate(day, timezoneID),
+                "aria-colindex": dayIndex + 1,
+                "aria-current": plainDateIsEqual(day, highlightedDate) ? 'date' : undefined,
+                ...stylex.props(styles.monthCell, index % 7 === 6 && styles.monthCellLastColumn, index >= days.length - 7 && styles.monthCellLastRow, isOutsideMonth && styles.monthCellOutside),
+                children: [/*#__PURE__*/_jsx("div", {
+                  ...stylex.props(styles.monthDayNumber, plainDateIsEqual(day, highlightedDate) && styles.currentDayPill),
+                  children: /*#__PURE__*/_jsx(Text, {
+                    type: "supporting",
+                    color: "inherit",
+                    weight: "medium",
+                    hasTabularNumbers: true,
+                    children: formatDayNumber(day, timezoneID)
+                  })
+                }), dayEvents.length > 0 && /*#__PURE__*/_jsx("ul", {
+                  ...stylex.props(styles.visuallyHidden),
+                  children: dayEvents.map(event => /*#__PURE__*/_jsx("li", {
+                    children: formatEventAccessibilityLabel(event, day, timezoneID, categories)
+                  }, event.id))
+                })]
+              }, plainDateToISO(day));
+            })
+          }, plainDateToISO(week[0])))
+        }), /*#__PURE__*/_jsx("div", {
+          "aria-hidden": true,
+          ...stylex.props(styles.monthEventOverlay),
+          children: eventSegments.map(segment => /*#__PURE__*/_jsx("div", {
+            ...stylex.props(styles.monthEventSpan(segment.week, segment.columnStart, segment.columnEnd, segment.level)),
+            children: /*#__PURE__*/_jsx(MonthEventPill, {
+              event: segment.event,
+              timezoneID: timezoneID,
+              isPast: isEventInPast(segment.event, currentTime, timezoneID)
+            })
+          }, `${segment.event.id}:${segment.week}:${segment.columnStart}`))
+        })]
+      })]
+    })
+  });
+}
+function getWeeks(days) {
+  const weeks = [];
+  for (let index = 0; index < days.length; index += 7) {
+    weeks.push(days.slice(index, index + 7));
+  }
+  return weeks;
+}
+const EMPTY_EVENTS = [];
+function getMonthEventsByDay(events, days, timezoneID) {
+  const eventsByDay = new Map();
+  days.forEach(day => {
+    eventsByDay.set(plainDateToISO(day), []);
+  });
+  const firstDay = days[0];
+  const lastDay = days[days.length - 1];
+  if (firstDay == null || lastDay == null) {
+    return eventsByDay;
+  }
+  events.forEach(event => {
+    const [eventStart, eventEnd] = getEventDateSpan(event, timezoneID);
+    if (plainDateIsBefore(eventEnd, firstDay) || plainDateIsAfter(eventStart, lastDay)) {
+      return;
+    }
+    let current = plainDateIsBefore(eventStart, firstDay) ? firstDay : eventStart;
+    const visibleEnd = plainDateIsAfter(eventEnd, lastDay) ? lastDay : eventEnd;
+    while (!plainDateIsAfter(current, visibleEnd)) {
+      eventsByDay.get(plainDateToISO(current))?.push(event);
+      current = plainDateAddDays(current, 1);
+    }
+  });
+  return eventsByDay;
+}
+const MAX_MONTH_EVENT_LEVELS = 4;
+function getMonthEventSegments(events, days, timezoneID) {
+  const segments = [];
+  const levelsByWeek = [];
+  const monthEvents = events.map(event => {
+    const [eventStart, eventEnd] = getEventDateSpan(event, timezoneID);
+    const startIndex = days.findIndex(day => !plainDateIsBefore(day, eventStart));
+    const endIndexFromRight = [...days].reverse().findIndex(day => !plainDateIsAfter(day, eventEnd));
+    if (startIndex < 0 || endIndexFromRight < 0) {
+      return null;
+    }
+    const endIndex = days.length - 1 - endIndexFromRight;
+    return {
+      event,
+      startIndex,
+      endIndex,
+      isPriority: isDayEvent(event) || endIndex > startIndex
+    };
+  }).filter(record => record != null).sort((a, b) => {
+    if (a.startIndex !== b.startIndex) {
+      return a.startIndex - b.startIndex;
+    }
+    if (a.isPriority !== b.isPriority) {
+      return a.isPriority ? -1 : 1;
+    }
+    const aDuration = a.endIndex - a.startIndex;
+    const bDuration = b.endIndex - b.startIndex;
+    if (aDuration !== bDuration) {
+      return bDuration - aDuration;
+    }
+    return a.event.title.localeCompare(b.event.title);
+  });
+  monthEvents.forEach(({
+    event,
+    startIndex,
+    endIndex
+  }) => {
+    const [eventStart, eventEnd] = getEventDateSpan(event, timezoneID);
+    if (plainDateIsBefore(eventEnd, days[0]) || plainDateIsAfter(eventStart, days[days.length - 1])) {
+      return;
+    }
+    for (let week = Math.floor(startIndex / 7); week <= Math.floor(endIndex / 7); week += 1) {
+      const columnStart = week === Math.floor(startIndex / 7) ? startIndex % 7 : 0;
+      const columnEnd = week === Math.floor(endIndex / 7) ? endIndex % 7 : 6;
+      const weekLevels = levelsByWeek[week] ??= [];
+      const level = getAvailableLevel(weekLevels, columnStart);
+      if (level < MAX_MONTH_EVENT_LEVELS) {
+        weekLevels[level] = columnEnd;
+        segments.push({
+          event,
+          week,
+          columnStart,
+          columnEnd,
+          level
+        });
+      }
+    }
+  });
+  return segments;
+}
+function getEventDateSpan(event, timezoneID) {
+  if (isDayEvent(event)) {
+    return [event.start, event.end];
+  }
+  return [plainDateFromInstant(event.start, timezoneID), plainDateFromInstant(Math.max(event.end - 1, event.start), timezoneID)];
+}
+function getAvailableLevel(levels, columnStart) {
+  const level = levels.findIndex(columnEnd => columnStart > columnEnd);
+  return level >= 0 ? level : levels.length;
+}
+export function createScheduleMonthlyView({
+  weekStartsOn = 0
+} = {}) {
+  return {
+    component: ScheduleMonthlyView,
+    options: {
+      weekStartsOn
+    },
+    getDateRange: date => {
+      const range = getMonthDateRange({
+        date: date.toPlainDate(),
+        timezoneID: date.timezoneID,
+        weekStartsOn
+      });
+      return scheduleRangeToZonedDateTimeRange(range, date.timezoneID);
+    },
+    getPreviousDateRange: date => {
+      const range = getMonthDateRange({
+        date: plainDateAddMonths(date.toPlainDate(), -1),
+        timezoneID: date.timezoneID,
+        weekStartsOn
+      });
+      return {
+        label: 'Previous month',
+        range: scheduleRangeToZonedDateTimeRange(range, date.timezoneID)
+      };
+    },
+    getNextDateRange: date => {
+      const range = getMonthDateRange({
+        date: plainDateAddMonths(date.toPlainDate(), 1),
+        timezoneID: date.timezoneID,
+        weekStartsOn
+      });
+      return {
+        label: 'Next month',
+        range: scheduleRangeToZonedDateTimeRange(range, date.timezoneID)
+      };
+    }
+  };
+}
+function getMonthDateRange({
+  date,
+  timezoneID,
+  weekStartsOn
+}) {
+  const firstOfMonth = plainDateSetFirstOfMonth(date);
+  const nextMonth = plainDateAddMonths(firstOfMonth, 1);
+  return getScheduleRangeFromDates({
+    startDate: plainDateSetStartOfWeek(firstOfMonth, weekStartsOn),
+    endDate: plainDateSetEndOfWeekExclusive(plainDateAddDays(nextMonth, -1), weekStartsOn),
+    timezoneID
+  });
+}

package/dist/Schedule/Schedule.d.ts

@@ -0,0 +1,22 @@
+import type { BaseProps } from '@astryxdesign/core';
+import type { Instant, ScheduleCategory, ScheduleEventSource, SchedulePlugin, ScheduleView, ScheduleViewOptions } from './types';
+export interface ScheduleProps<Options extends ScheduleViewOptions = ScheduleViewOptions> extends BaseProps<HTMLDivElement> {
+    /** View object returned by a `createSchedule*View()` factory. */
+    view: ScheduleView<Options>;
+    /** Static calendar events or an async loader called with the active Instant range. */
+    events: ScheduleEventSource;
+    /** Category definitions used to style and label events by their `category` value. */
+    categories?: ReadonlyArray<ScheduleCategory>;
+    /** Focused Instant used to choose the currently rendered range. */
+    date: Instant;
+    /** Instant highlighted as the user's focus/current date. Defaults to mount time. */
+    focusDate?: Instant;
+    /** Called by pagination plugins when the rendered range should change. */
+    onChangeDate?: (date: Instant) => void;
+    /** IANA timezone ID used for date math and localized rendering. Defaults to browser timezone. */
+    timezoneID?: string;
+    /** Header/rendering plugins. Defaults to pagination controls. */
+    plugins?: ReadonlyArray<SchedulePlugin>;
+}
+export declare function Schedule({ view, events, categories, date, focusDate: focusDateProp, onChangeDate, timezoneID: timezoneIDProp, plugins, xstyle, className, style, ...rest }: ScheduleProps): import("react").JSX.Element;
+//# sourceMappingURL=Schedule.d.ts.map

package/dist/Schedule/Schedule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schedule.d.ts","sourceRoot":"","sources":["../../src/Schedule/Schedule.tsx"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,oBAAoB,CAAC;AAQlD,OAAO,KAAK,EAEV,OAAO,EAEP,gBAAgB,EAChB,mBAAmB,EACnB,cAAc,EACd,YAAY,EACZ,mBAAmB,EAGpB,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,aAAa,CAC5B,OAAO,SAAS,mBAAmB,GAAG,mBAAmB,CACzD,SAAQ,SAAS,CAAC,cAAc,CAAC;IACjC,iEAAiE;IACjE,IAAI,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;IAC5B,sFAAsF;IACtF,MAAM,EAAE,mBAAmB,CAAC;IAC5B,qFAAqF;IACrF,UAAU,CAAC,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;IAC7C,mEAAmE;IACnE,IAAI,EAAE,OAAO,CAAC;IACd,oFAAoF;IACpF,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,0EAA0E;IAC1E,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACvC,iGAAiG;IACjG,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iEAAiE;IACjE,OAAO,CAAC,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;CACzC;AAiJD,wBAAgB,QAAQ,CAAC,EACvB,IAAI,EACJ,MAAM,EACN,UAAe,EACf,IAAI,EACJ,SAAS,EAAE,aAAa,EACxB,YAAY,EACZ,UAAU,EAAE,cAAc,EAC1B,OAAgC,EAChC,MAAM,EACN,SAAS,EACT,KAAK,EACL,GAAG,IAAI,EACR,EAAE,aAAa,+BA0Ff"}