FIN INIT

node_modules/@fullcalendar/list/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2021 Adam Shaw
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@fullcalendar/list/README.md

@@ -0,0 +1,32 @@
+
+# FullCalendar List View Plugin
+
+Display events on a calendar view that looks like a bulleted list
+
+## Installation
+
+Install the necessary packages:
+
+```sh
+npm install @fullcalendar/core @fullcalendar/list
+```
+
+## Usage
+
+Instantiate a Calendar with the necessary plugin:
+
+```js
+import { Calendar } from '@fullcalendar/core'
+import listPlugin from '@fullcalendar/list'
+
+const calendarEl = document.getElementById('calendar')
+const calendar = new Calendar(calendarEl, {
+  plugins: [listPlugin],
+  initialView: 'listWeek',
+  events: [
+    { title: 'Meeting', start: new Date() }
+  ]
+})
+
+calendar.render()
+```

node_modules/@fullcalendar/list/index.cjs

@@ -0,0 +1,56 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index_cjs = require('@fullcalendar/core/index.cjs');
+var internalCommon = require('./internal.cjs');
+var internal_cjs = require('@fullcalendar/core/internal.cjs');
+require('@fullcalendar/core/preact.cjs');
+
+const OPTION_REFINERS = {
+    listDayFormat: createFalsableFormatter,
+    listDaySideFormat: createFalsableFormatter,
+    noEventsClassNames: internal_cjs.identity,
+    noEventsContent: internal_cjs.identity,
+    noEventsDidMount: internal_cjs.identity,
+    noEventsWillUnmount: internal_cjs.identity,
+    // noEventsText is defined in base options
+};
+function createFalsableFormatter(input) {
+    return input === false ? null : internal_cjs.createFormatter(input);
+}
+
+var index = index_cjs.createPlugin({
+    name: '@fullcalendar/list',
+    optionRefiners: OPTION_REFINERS,
+    views: {
+        list: {
+            component: internalCommon.ListView,
+            buttonTextKey: 'list',
+            listDayFormat: { month: 'long', day: 'numeric', year: 'numeric' }, // like "January 1, 2016"
+        },
+        listDay: {
+            type: 'list',
+            duration: { days: 1 },
+            listDayFormat: { weekday: 'long' }, // day-of-week is all we need. full date is probably in headerToolbar
+        },
+        listWeek: {
+            type: 'list',
+            duration: { weeks: 1 },
+            listDayFormat: { weekday: 'long' },
+            listDaySideFormat: { month: 'long', day: 'numeric', year: 'numeric' },
+        },
+        listMonth: {
+            type: 'list',
+            duration: { month: 1 },
+            listDaySideFormat: { weekday: 'long' }, // day-of-week is nice-to-have
+        },
+        listYear: {
+            type: 'list',
+            duration: { year: 1 },
+            listDaySideFormat: { weekday: 'long' }, // day-of-week is nice-to-have
+        },
+    },
+});
+
+exports["default"] = index;

node_modules/@fullcalendar/list/index.d.ts

@@ -0,0 +1,27 @@
+import { ClassNamesGenerator, FormatterInput, PluginDef } from '@fullcalendar/core';
+import { Identity, CustomContentGenerator, DidMountHandler, WillUnmountHandler, DateFormatter } from '@fullcalendar/core/internal';
+import { N as NoEventsContentArg, a as NoEventsMountArg } from './internal-common.js';
+export { N as NoEventsContentArg, a as NoEventsMountArg } from './internal-common.js';
+import '@fullcalendar/core/preact';
+
+declare const OPTION_REFINERS: {
+    listDayFormat: typeof createFalsableFormatter;
+    listDaySideFormat: typeof createFalsableFormatter;
+    noEventsClassNames: Identity<ClassNamesGenerator<NoEventsContentArg>>;
+    noEventsContent: Identity<CustomContentGenerator<NoEventsContentArg>>;
+    noEventsDidMount: Identity<DidMountHandler<NoEventsMountArg>>;
+    noEventsWillUnmount: Identity<WillUnmountHandler<NoEventsMountArg>>;
+};
+declare function createFalsableFormatter(input: FormatterInput | false): DateFormatter;
+
+type ExtraOptionRefiners = typeof OPTION_REFINERS;
+declare module '@fullcalendar/core/internal' {
+    interface BaseOptionRefiners extends ExtraOptionRefiners {
+    }
+}
+//# sourceMappingURL=ambient.d.ts.map
+
+declare const _default: PluginDef;
+//# sourceMappingURL=index.d.ts.map
+
+export { _default as default };

node_modules/@fullcalendar/list/index.global.js

@@ -0,0 +1,332 @@
+/*!
+FullCalendar List View Plugin v6.1.17
+Docs & License: https://fullcalendar.io/docs/list-view
+(c) 2024 Adam Shaw
+*/
+FullCalendar.List = (function (exports, core, internal$1, preact) {
+    'use strict';
+
+    class ListViewHeaderRow extends internal$1.BaseComponent {
+        constructor() {
+            super(...arguments);
+            this.state = {
+                textId: internal$1.getUniqueDomId(),
+            };
+        }
+        render() {
+            let { theme, dateEnv, options, viewApi } = this.context;
+            let { cellId, dayDate, todayRange } = this.props;
+            let { textId } = this.state;
+            let dayMeta = internal$1.getDateMeta(dayDate, todayRange);
+            // will ever be falsy?
+            let text = options.listDayFormat ? dateEnv.format(dayDate, options.listDayFormat) : '';
+            // will ever be falsy? also, BAD NAME "alt"
+            let sideText = options.listDaySideFormat ? dateEnv.format(dayDate, options.listDaySideFormat) : '';
+            let renderProps = Object.assign({ date: dateEnv.toDate(dayDate), view: viewApi, textId,
+                text,
+                sideText, navLinkAttrs: internal$1.buildNavLinkAttrs(this.context, dayDate), sideNavLinkAttrs: internal$1.buildNavLinkAttrs(this.context, dayDate, 'day', false) }, dayMeta);
+            // TODO: make a reusable HOC for dayHeader (used in daygrid/timegrid too)
+            return (preact.createElement(internal$1.ContentContainer, { elTag: "tr", elClasses: [
+                    'fc-list-day',
+                    ...internal$1.getDayClassNames(dayMeta, theme),
+                ], elAttrs: {
+                    'data-date': internal$1.formatDayString(dayDate),
+                }, renderProps: renderProps, generatorName: "dayHeaderContent", customGenerator: options.dayHeaderContent, defaultGenerator: renderInnerContent, classNameGenerator: options.dayHeaderClassNames, didMount: options.dayHeaderDidMount, willUnmount: options.dayHeaderWillUnmount }, (InnerContent) => ( // TODO: force-hide top border based on :first-child
+            preact.createElement("th", { scope: "colgroup", colSpan: 3, id: cellId, "aria-labelledby": textId },
+                preact.createElement(InnerContent, { elTag: "div", elClasses: [
+                        'fc-list-day-cushion',
+                        theme.getClass('tableCellShaded'),
+                    ] })))));
+        }
+    }
+    function renderInnerContent(props) {
+        return (preact.createElement(preact.Fragment, null,
+            props.text && (preact.createElement("a", Object.assign({ id: props.textId, className: "fc-list-day-text" }, props.navLinkAttrs), props.text)),
+            props.sideText && ( /* not keyboard tabbable */preact.createElement("a", Object.assign({ "aria-hidden": true, className: "fc-list-day-side-text" }, props.sideNavLinkAttrs), props.sideText))));
+    }
+
+    const DEFAULT_TIME_FORMAT = internal$1.createFormatter({
+        hour: 'numeric',
+        minute: '2-digit',
+        meridiem: 'short',
+    });
+    class ListViewEventRow extends internal$1.BaseComponent {
+        render() {
+            let { props, context } = this;
+            let { options } = context;
+            let { seg, timeHeaderId, eventHeaderId, dateHeaderId } = props;
+            let timeFormat = options.eventTimeFormat || DEFAULT_TIME_FORMAT;
+            return (preact.createElement(internal$1.EventContainer, Object.assign({}, props, { elTag: "tr", elClasses: [
+                    'fc-list-event',
+                    seg.eventRange.def.url && 'fc-event-forced-url',
+                ], defaultGenerator: () => renderEventInnerContent(seg, context) /* weird */, seg: seg, timeText: "", disableDragging: true, disableResizing: true }), (InnerContent, eventContentArg) => (preact.createElement(preact.Fragment, null,
+                buildTimeContent(seg, timeFormat, context, timeHeaderId, dateHeaderId),
+                preact.createElement("td", { "aria-hidden": true, className: "fc-list-event-graphic" },
+                    preact.createElement("span", { className: "fc-list-event-dot", style: {
+                            borderColor: eventContentArg.borderColor || eventContentArg.backgroundColor,
+                        } })),
+                preact.createElement(InnerContent, { elTag: "td", elClasses: ['fc-list-event-title'], elAttrs: { headers: `${eventHeaderId} ${dateHeaderId}` } })))));
+        }
+    }
+    function renderEventInnerContent(seg, context) {
+        let interactiveAttrs = internal$1.getSegAnchorAttrs(seg, context);
+        return (preact.createElement("a", Object.assign({}, interactiveAttrs), seg.eventRange.def.title));
+    }
+    function buildTimeContent(seg, timeFormat, context, timeHeaderId, dateHeaderId) {
+        let { options } = context;
+        if (options.displayEventTime !== false) {
+            let eventDef = seg.eventRange.def;
+            let eventInstance = seg.eventRange.instance;
+            let doAllDay = false;
+            let timeText;
+            if (eventDef.allDay) {
+                doAllDay = true;
+            }
+            else if (internal$1.isMultiDayRange(seg.eventRange.range)) { // TODO: use (!isStart || !isEnd) instead?
+                if (seg.isStart) {
+                    timeText = internal$1.buildSegTimeText(seg, timeFormat, context, null, null, eventInstance.range.start, seg.end);
+                }
+                else if (seg.isEnd) {
+                    timeText = internal$1.buildSegTimeText(seg, timeFormat, context, null, null, seg.start, eventInstance.range.end);
+                }
+                else {
+                    doAllDay = true;
+                }
+            }
+            else {
+                timeText = internal$1.buildSegTimeText(seg, timeFormat, context);
+            }
+            if (doAllDay) {
+                let renderProps = {
+                    text: context.options.allDayText,
+                    view: context.viewApi,
+                };
+                return (preact.createElement(internal$1.ContentContainer, { elTag: "td", elClasses: ['fc-list-event-time'], elAttrs: {
+                        headers: `${timeHeaderId} ${dateHeaderId}`,
+                    }, renderProps: renderProps, generatorName: "allDayContent", customGenerator: options.allDayContent, defaultGenerator: renderAllDayInner, classNameGenerator: options.allDayClassNames, didMount: options.allDayDidMount, willUnmount: options.allDayWillUnmount }));
+            }
+            return (preact.createElement("td", { className: "fc-list-event-time" }, timeText));
+        }
+        return null;
+    }
+    function renderAllDayInner(renderProps) {
+        return renderProps.text;
+    }
+
+    /*
+    Responsible for the scroller, and forwarding event-related actions into the "grid".
+    */
+    class ListView extends internal$1.DateComponent {
+        constructor() {
+            super(...arguments);
+            this.computeDateVars = internal$1.memoize(computeDateVars);
+            this.eventStoreToSegs = internal$1.memoize(this._eventStoreToSegs);
+            this.state = {
+                timeHeaderId: internal$1.getUniqueDomId(),
+                eventHeaderId: internal$1.getUniqueDomId(),
+                dateHeaderIdRoot: internal$1.getUniqueDomId(),
+            };
+            this.setRootEl = (rootEl) => {
+                if (rootEl) {
+                    this.context.registerInteractiveComponent(this, {
+                        el: rootEl,
+                    });
+                }
+                else {
+                    this.context.unregisterInteractiveComponent(this);
+                }
+            };
+        }
+        render() {
+            let { props, context } = this;
+            let { dayDates, dayRanges } = this.computeDateVars(props.dateProfile);
+            let eventSegs = this.eventStoreToSegs(props.eventStore, props.eventUiBases, dayRanges);
+            return (preact.createElement(internal$1.ViewContainer, { elRef: this.setRootEl, elClasses: [
+                    'fc-list',
+                    context.theme.getClass('table'),
+                    context.options.stickyHeaderDates !== false ?
+                        'fc-list-sticky' :
+                        '',
+                ], viewSpec: context.viewSpec },
+                preact.createElement(internal$1.Scroller, { liquid: !props.isHeightAuto, overflowX: props.isHeightAuto ? 'visible' : 'hidden', overflowY: props.isHeightAuto ? 'visible' : 'auto' }, eventSegs.length > 0 ?
+                    this.renderSegList(eventSegs, dayDates) :
+                    this.renderEmptyMessage())));
+        }
+        renderEmptyMessage() {
+            let { options, viewApi } = this.context;
+            let renderProps = {
+                text: options.noEventsText,
+                view: viewApi,
+            };
+            return (preact.createElement(internal$1.ContentContainer, { elTag: "div", elClasses: ['fc-list-empty'], renderProps: renderProps, generatorName: "noEventsContent", customGenerator: options.noEventsContent, defaultGenerator: renderNoEventsInner, classNameGenerator: options.noEventsClassNames, didMount: options.noEventsDidMount, willUnmount: options.noEventsWillUnmount }, (InnerContent) => (preact.createElement(InnerContent, { elTag: "div", elClasses: ['fc-list-empty-cushion'] }))));
+        }
+        renderSegList(allSegs, dayDates) {
+            let { theme, options } = this.context;
+            let { timeHeaderId, eventHeaderId, dateHeaderIdRoot } = this.state;
+            let segsByDay = groupSegsByDay(allSegs); // sparse array
+            return (preact.createElement(internal$1.NowTimer, { unit: "day" }, (nowDate, todayRange) => {
+                let innerNodes = [];
+                for (let dayIndex = 0; dayIndex < segsByDay.length; dayIndex += 1) {
+                    let daySegs = segsByDay[dayIndex];
+                    if (daySegs) { // sparse array, so might be undefined
+                        let dayStr = internal$1.formatDayString(dayDates[dayIndex]);
+                        let dateHeaderId = dateHeaderIdRoot + '-' + dayStr;
+                        // append a day header
+                        innerNodes.push(preact.createElement(ListViewHeaderRow, { key: dayStr, cellId: dateHeaderId, dayDate: dayDates[dayIndex], todayRange: todayRange }));
+                        daySegs = internal$1.sortEventSegs(daySegs, options.eventOrder);
+                        for (let seg of daySegs) {
+                            innerNodes.push(preact.createElement(ListViewEventRow, Object.assign({ key: dayStr + ':' + seg.eventRange.instance.instanceId /* are multiple segs for an instanceId */, seg: seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: false, timeHeaderId: timeHeaderId, eventHeaderId: eventHeaderId, dateHeaderId: dateHeaderId }, internal$1.getSegMeta(seg, todayRange, nowDate))));
+                        }
+                    }
+                }
+                return (preact.createElement("table", { className: 'fc-list-table ' + theme.getClass('table') },
+                    preact.createElement("thead", null,
+                        preact.createElement("tr", null,
+                            preact.createElement("th", { scope: "col", id: timeHeaderId }, options.timeHint),
+                            preact.createElement("th", { scope: "col", "aria-hidden": true }),
+                            preact.createElement("th", { scope: "col", id: eventHeaderId }, options.eventHint))),
+                    preact.createElement("tbody", null, innerNodes)));
+            }));
+        }
+        _eventStoreToSegs(eventStore, eventUiBases, dayRanges) {
+            return this.eventRangesToSegs(internal$1.sliceEventStore(eventStore, eventUiBases, this.props.dateProfile.activeRange, this.context.options.nextDayThreshold).fg, dayRanges);
+        }
+        eventRangesToSegs(eventRanges, dayRanges) {
+            let segs = [];
+            for (let eventRange of eventRanges) {
+                segs.push(...this.eventRangeToSegs(eventRange, dayRanges));
+            }
+            return segs;
+        }
+        eventRangeToSegs(eventRange, dayRanges) {
+            let { dateEnv } = this.context;
+            let { nextDayThreshold } = this.context.options;
+            let range = eventRange.range;
+            let allDay = eventRange.def.allDay;
+            let dayIndex;
+            let segRange;
+            let seg;
+            let segs = [];
+            for (dayIndex = 0; dayIndex < dayRanges.length; dayIndex += 1) {
+                segRange = internal$1.intersectRanges(range, dayRanges[dayIndex]);
+                if (segRange) {
+                    seg = {
+                        component: this,
+                        eventRange,
+                        start: segRange.start,
+                        end: segRange.end,
+                        isStart: eventRange.isStart && segRange.start.valueOf() === range.start.valueOf(),
+                        isEnd: eventRange.isEnd && segRange.end.valueOf() === range.end.valueOf(),
+                        dayIndex,
+                    };
+                    segs.push(seg);
+                    // detect when range won't go fully into the next day,
+                    // and mutate the latest seg to the be the end.
+                    if (!seg.isEnd && !allDay &&
+                        dayIndex + 1 < dayRanges.length &&
+                        range.end <
+                            dateEnv.add(dayRanges[dayIndex + 1].start, nextDayThreshold)) {
+                        seg.end = range.end;
+                        seg.isEnd = true;
+                        break;
+                    }
+                }
+            }
+            return segs;
+        }
+    }
+    function renderNoEventsInner(renderProps) {
+        return renderProps.text;
+    }
+    function computeDateVars(dateProfile) {
+        let dayStart = internal$1.startOfDay(dateProfile.renderRange.start);
+        let viewEnd = dateProfile.renderRange.end;
+        let dayDates = [];
+        let dayRanges = [];
+        while (dayStart < viewEnd) {
+            dayDates.push(dayStart);
+            dayRanges.push({
+                start: dayStart,
+                end: internal$1.addDays(dayStart, 1),
+            });
+            dayStart = internal$1.addDays(dayStart, 1);
+        }
+        return { dayDates, dayRanges };
+    }
+    // Returns a sparse array of arrays, segs grouped by their dayIndex
+    function groupSegsByDay(segs) {
+        let segsByDay = []; // sparse array
+        let i;
+        let seg;
+        for (i = 0; i < segs.length; i += 1) {
+            seg = segs[i];
+            (segsByDay[seg.dayIndex] || (segsByDay[seg.dayIndex] = []))
+                .push(seg);
+        }
+        return segsByDay;
+    }
+
+    const OPTION_REFINERS = {
+        listDayFormat: createFalsableFormatter,
+        listDaySideFormat: createFalsableFormatter,
+        noEventsClassNames: internal$1.identity,
+        noEventsContent: internal$1.identity,
+        noEventsDidMount: internal$1.identity,
+        noEventsWillUnmount: internal$1.identity,
+        // noEventsText is defined in base options
+    };
+    function createFalsableFormatter(input) {
+        return input === false ? null : internal$1.createFormatter(input);
+    }
+
+    var css_248z = ":root{--fc-list-event-dot-width:10px;--fc-list-event-hover-bg-color:#f5f5f5}.fc-theme-standard .fc-list{border:1px solid var(--fc-border-color)}.fc .fc-list-empty{align-items:center;background-color:var(--fc-neutral-bg-color);display:flex;height:100%;justify-content:center}.fc .fc-list-empty-cushion{margin:5em 0}.fc .fc-list-table{border-style:hidden;width:100%}.fc .fc-list-table tr>*{border-left:0;border-right:0}.fc .fc-list-sticky .fc-list-day>*{background:var(--fc-page-bg-color);position:sticky;top:0}.fc .fc-list-table thead{left:-10000px;position:absolute}.fc .fc-list-table tbody>tr:first-child th{border-top:0}.fc .fc-list-table th{padding:0}.fc .fc-list-day-cushion,.fc .fc-list-table td{padding:8px 14px}.fc .fc-list-day-cushion:after{clear:both;content:\"\";display:table}.fc-theme-standard .fc-list-day-cushion{background-color:var(--fc-neutral-bg-color)}.fc-direction-ltr .fc-list-day-text,.fc-direction-rtl .fc-list-day-side-text{float:left}.fc-direction-ltr .fc-list-day-side-text,.fc-direction-rtl .fc-list-day-text{float:right}.fc-direction-ltr .fc-list-table .fc-list-event-graphic{padding-right:0}.fc-direction-rtl .fc-list-table .fc-list-event-graphic{padding-left:0}.fc .fc-list-event.fc-event-forced-url{cursor:pointer}.fc .fc-list-event:hover td{background-color:var(--fc-list-event-hover-bg-color)}.fc .fc-list-event-graphic,.fc .fc-list-event-time{white-space:nowrap;width:1px}.fc .fc-list-event-dot{border:calc(var(--fc-list-event-dot-width)/2) solid var(--fc-event-border-color);border-radius:calc(var(--fc-list-event-dot-width)/2);box-sizing:content-box;display:inline-block;height:0;width:0}.fc .fc-list-event-title a{color:inherit;text-decoration:none}.fc .fc-list-event.fc-event-forced-url:hover a{text-decoration:underline}";
+    internal$1.injectStyles(css_248z);
+
+    var plugin = core.createPlugin({
+        name: '@fullcalendar/list',
+        optionRefiners: OPTION_REFINERS,
+        views: {
+            list: {
+                component: ListView,
+                buttonTextKey: 'list',
+                listDayFormat: { month: 'long', day: 'numeric', year: 'numeric' }, // like "January 1, 2016"
+            },
+            listDay: {
+                type: 'list',
+                duration: { days: 1 },
+                listDayFormat: { weekday: 'long' }, // day-of-week is all we need. full date is probably in headerToolbar
+            },
+            listWeek: {
+                type: 'list',
+                duration: { weeks: 1 },
+                listDayFormat: { weekday: 'long' },
+                listDaySideFormat: { month: 'long', day: 'numeric', year: 'numeric' },
+            },
+            listMonth: {
+                type: 'list',
+                duration: { month: 1 },
+                listDaySideFormat: { weekday: 'long' }, // day-of-week is nice-to-have
+            },
+            listYear: {
+                type: 'list',
+                duration: { year: 1 },
+                listDaySideFormat: { weekday: 'long' }, // day-of-week is nice-to-have
+            },
+        },
+    });
+
+    var internal = {
+        __proto__: null,
+        ListView: ListView
+    };
+
+    core.globalPlugins.push(plugin);
+
+    exports.Internal = internal;
+    exports["default"] = plugin;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+    return exports;
+
+})({}, FullCalendar, FullCalendar.Internal, FullCalendar.Preact);

node_modules/@fullcalendar/list/index.js

@@ -0,0 +1,52 @@
+import { createPlugin } from '@fullcalendar/core/index.js';
+import { ListView } from './internal.js';
+import { identity, createFormatter } from '@fullcalendar/core/internal.js';
+import '@fullcalendar/core/preact.js';
+
+const OPTION_REFINERS = {
+    listDayFormat: createFalsableFormatter,
+    listDaySideFormat: createFalsableFormatter,
+    noEventsClassNames: identity,
+    noEventsContent: identity,
+    noEventsDidMount: identity,
+    noEventsWillUnmount: identity,
+    // noEventsText is defined in base options
+};
+function createFalsableFormatter(input) {
+    return input === false ? null : createFormatter(input);
+}
+
+var index = createPlugin({
+    name: '@fullcalendar/list',
+    optionRefiners: OPTION_REFINERS,
+    views: {
+        list: {
+            component: ListView,
+            buttonTextKey: 'list',
+            listDayFormat: { month: 'long', day: 'numeric', year: 'numeric' }, // like "January 1, 2016"
+        },
+        listDay: {
+            type: 'list',
+            duration: { days: 1 },
+            listDayFormat: { weekday: 'long' }, // day-of-week is all we need. full date is probably in headerToolbar
+        },
+        listWeek: {
+            type: 'list',
+            duration: { weeks: 1 },
+            listDayFormat: { weekday: 'long' },
+            listDaySideFormat: { month: 'long', day: 'numeric', year: 'numeric' },
+        },
+        listMonth: {
+            type: 'list',
+            duration: { month: 1 },
+            listDaySideFormat: { weekday: 'long' }, // day-of-week is nice-to-have
+        },
+        listYear: {
+            type: 'list',
+            duration: { year: 1 },
+            listDaySideFormat: { weekday: 'long' }, // day-of-week is nice-to-have
+        },
+    },
+});
+
+export { index as default };

node_modules/@fullcalendar/list/internal-common.d.ts

@@ -0,0 +1,27 @@
+import { ViewApi, EventRenderRange } from '@fullcalendar/core';
+import { MountArg, DateComponent, ViewProps, Seg, DateMarker, EventStore, EventUiHash, DateRange } from '@fullcalendar/core/internal';
+import { createElement } from '@fullcalendar/core/preact';
+
+interface NoEventsContentArg {
+    text: string;
+    view: ViewApi;
+}
+type NoEventsMountArg = MountArg<NoEventsContentArg>;
+declare class ListView extends DateComponent<ViewProps> {
+    private computeDateVars;
+    private eventStoreToSegs;
+    state: {
+        timeHeaderId: string;
+        eventHeaderId: string;
+        dateHeaderIdRoot: string;
+    };
+    render(): createElement.JSX.Element;
+    setRootEl: (rootEl: HTMLElement | null) => void;
+    renderEmptyMessage(): createElement.JSX.Element;
+    renderSegList(allSegs: Seg[], dayDates: DateMarker[]): createElement.JSX.Element;
+    _eventStoreToSegs(eventStore: EventStore, eventUiBases: EventUiHash, dayRanges: DateRange[]): Seg[];
+    eventRangesToSegs(eventRanges: EventRenderRange[], dayRanges: DateRange[]): any[];
+    eventRangeToSegs(eventRange: EventRenderRange, dayRanges: DateRange[]): any[];
+}
+
+export { ListView as L, NoEventsContentArg as N, NoEventsMountArg as a };

node_modules/@fullcalendar/list/internal.cjs

@@ -0,0 +1,271 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var internal_cjs = require('@fullcalendar/core/internal.cjs');
+var preact_cjs = require('@fullcalendar/core/preact.cjs');
+
+class ListViewHeaderRow extends internal_cjs.BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.state = {
+            textId: internal_cjs.getUniqueDomId(),
+        };
+    }
+    render() {
+        let { theme, dateEnv, options, viewApi } = this.context;
+        let { cellId, dayDate, todayRange } = this.props;
+        let { textId } = this.state;
+        let dayMeta = internal_cjs.getDateMeta(dayDate, todayRange);
+        // will ever be falsy?
+        let text = options.listDayFormat ? dateEnv.format(dayDate, options.listDayFormat) : '';
+        // will ever be falsy? also, BAD NAME "alt"
+        let sideText = options.listDaySideFormat ? dateEnv.format(dayDate, options.listDaySideFormat) : '';
+        let renderProps = Object.assign({ date: dateEnv.toDate(dayDate), view: viewApi, textId,
+            text,
+            sideText, navLinkAttrs: internal_cjs.buildNavLinkAttrs(this.context, dayDate), sideNavLinkAttrs: internal_cjs.buildNavLinkAttrs(this.context, dayDate, 'day', false) }, dayMeta);
+        // TODO: make a reusable HOC for dayHeader (used in daygrid/timegrid too)
+        return (preact_cjs.createElement(internal_cjs.ContentContainer, { elTag: "tr", elClasses: [
+                'fc-list-day',
+                ...internal_cjs.getDayClassNames(dayMeta, theme),
+            ], elAttrs: {
+                'data-date': internal_cjs.formatDayString(dayDate),
+            }, renderProps: renderProps, generatorName: "dayHeaderContent", customGenerator: options.dayHeaderContent, defaultGenerator: renderInnerContent, classNameGenerator: options.dayHeaderClassNames, didMount: options.dayHeaderDidMount, willUnmount: options.dayHeaderWillUnmount }, (InnerContent) => ( // TODO: force-hide top border based on :first-child
+        preact_cjs.createElement("th", { scope: "colgroup", colSpan: 3, id: cellId, "aria-labelledby": textId },
+            preact_cjs.createElement(InnerContent, { elTag: "div", elClasses: [
+                    'fc-list-day-cushion',
+                    theme.getClass('tableCellShaded'),
+                ] })))));
+    }
+}
+function renderInnerContent(props) {
+    return (preact_cjs.createElement(preact_cjs.Fragment, null,
+        props.text && (preact_cjs.createElement("a", Object.assign({ id: props.textId, className: "fc-list-day-text" }, props.navLinkAttrs), props.text)),
+        props.sideText && ( /* not keyboard tabbable */preact_cjs.createElement("a", Object.assign({ "aria-hidden": true, className: "fc-list-day-side-text" }, props.sideNavLinkAttrs), props.sideText))));
+}
+
+const DEFAULT_TIME_FORMAT = internal_cjs.createFormatter({
+    hour: 'numeric',
+    minute: '2-digit',
+    meridiem: 'short',
+});
+class ListViewEventRow extends internal_cjs.BaseComponent {
+    render() {
+        let { props, context } = this;
+        let { options } = context;
+        let { seg, timeHeaderId, eventHeaderId, dateHeaderId } = props;
+        let timeFormat = options.eventTimeFormat || DEFAULT_TIME_FORMAT;
+        return (preact_cjs.createElement(internal_cjs.EventContainer, Object.assign({}, props, { elTag: "tr", elClasses: [
+                'fc-list-event',
+                seg.eventRange.def.url && 'fc-event-forced-url',
+            ], defaultGenerator: () => renderEventInnerContent(seg, context) /* weird */, seg: seg, timeText: "", disableDragging: true, disableResizing: true }), (InnerContent, eventContentArg) => (preact_cjs.createElement(preact_cjs.Fragment, null,
+            buildTimeContent(seg, timeFormat, context, timeHeaderId, dateHeaderId),
+            preact_cjs.createElement("td", { "aria-hidden": true, className: "fc-list-event-graphic" },
+                preact_cjs.createElement("span", { className: "fc-list-event-dot", style: {
+                        borderColor: eventContentArg.borderColor || eventContentArg.backgroundColor,
+                    } })),
+            preact_cjs.createElement(InnerContent, { elTag: "td", elClasses: ['fc-list-event-title'], elAttrs: { headers: `${eventHeaderId} ${dateHeaderId}` } })))));
+    }
+}
+function renderEventInnerContent(seg, context) {
+    let interactiveAttrs = internal_cjs.getSegAnchorAttrs(seg, context);
+    return (preact_cjs.createElement("a", Object.assign({}, interactiveAttrs), seg.eventRange.def.title));
+}
+function buildTimeContent(seg, timeFormat, context, timeHeaderId, dateHeaderId) {
+    let { options } = context;
+    if (options.displayEventTime !== false) {
+        let eventDef = seg.eventRange.def;
+        let eventInstance = seg.eventRange.instance;
+        let doAllDay = false;
+        let timeText;
+        if (eventDef.allDay) {
+            doAllDay = true;
+        }
+        else if (internal_cjs.isMultiDayRange(seg.eventRange.range)) { // TODO: use (!isStart || !isEnd) instead?
+            if (seg.isStart) {
+                timeText = internal_cjs.buildSegTimeText(seg, timeFormat, context, null, null, eventInstance.range.start, seg.end);
+            }
+            else if (seg.isEnd) {
+                timeText = internal_cjs.buildSegTimeText(seg, timeFormat, context, null, null, seg.start, eventInstance.range.end);
+            }
+            else {
+                doAllDay = true;
+            }
+        }
+        else {
+            timeText = internal_cjs.buildSegTimeText(seg, timeFormat, context);
+        }
+        if (doAllDay) {
+            let renderProps = {
+                text: context.options.allDayText,
+                view: context.viewApi,
+            };
+            return (preact_cjs.createElement(internal_cjs.ContentContainer, { elTag: "td", elClasses: ['fc-list-event-time'], elAttrs: {
+                    headers: `${timeHeaderId} ${dateHeaderId}`,
+                }, renderProps: renderProps, generatorName: "allDayContent", customGenerator: options.allDayContent, defaultGenerator: renderAllDayInner, classNameGenerator: options.allDayClassNames, didMount: options.allDayDidMount, willUnmount: options.allDayWillUnmount }));
+        }
+        return (preact_cjs.createElement("td", { className: "fc-list-event-time" }, timeText));
+    }
+    return null;
+}
+function renderAllDayInner(renderProps) {
+    return renderProps.text;
+}
+
+/*
+Responsible for the scroller, and forwarding event-related actions into the "grid".
+*/
+class ListView extends internal_cjs.DateComponent {
+    constructor() {
+        super(...arguments);
+        this.computeDateVars = internal_cjs.memoize(computeDateVars);
+        this.eventStoreToSegs = internal_cjs.memoize(this._eventStoreToSegs);
+        this.state = {
+            timeHeaderId: internal_cjs.getUniqueDomId(),
+            eventHeaderId: internal_cjs.getUniqueDomId(),
+            dateHeaderIdRoot: internal_cjs.getUniqueDomId(),
+        };
+        this.setRootEl = (rootEl) => {
+            if (rootEl) {
+                this.context.registerInteractiveComponent(this, {
+                    el: rootEl,
+                });
+            }
+            else {
+                this.context.unregisterInteractiveComponent(this);
+            }
+        };
+    }
+    render() {
+        let { props, context } = this;
+        let { dayDates, dayRanges } = this.computeDateVars(props.dateProfile);
+        let eventSegs = this.eventStoreToSegs(props.eventStore, props.eventUiBases, dayRanges);
+        return (preact_cjs.createElement(internal_cjs.ViewContainer, { elRef: this.setRootEl, elClasses: [
+                'fc-list',
+                context.theme.getClass('table'),
+                context.options.stickyHeaderDates !== false ?
+                    'fc-list-sticky' :
+                    '',
+            ], viewSpec: context.viewSpec },
+            preact_cjs.createElement(internal_cjs.Scroller, { liquid: !props.isHeightAuto, overflowX: props.isHeightAuto ? 'visible' : 'hidden', overflowY: props.isHeightAuto ? 'visible' : 'auto' }, eventSegs.length > 0 ?
+                this.renderSegList(eventSegs, dayDates) :
+                this.renderEmptyMessage())));
+    }
+    renderEmptyMessage() {
+        let { options, viewApi } = this.context;
+        let renderProps = {
+            text: options.noEventsText,
+            view: viewApi,
+        };
+        return (preact_cjs.createElement(internal_cjs.ContentContainer, { elTag: "div", elClasses: ['fc-list-empty'], renderProps: renderProps, generatorName: "noEventsContent", customGenerator: options.noEventsContent, defaultGenerator: renderNoEventsInner, classNameGenerator: options.noEventsClassNames, didMount: options.noEventsDidMount, willUnmount: options.noEventsWillUnmount }, (InnerContent) => (preact_cjs.createElement(InnerContent, { elTag: "div", elClasses: ['fc-list-empty-cushion'] }))));
+    }
+    renderSegList(allSegs, dayDates) {
+        let { theme, options } = this.context;
+        let { timeHeaderId, eventHeaderId, dateHeaderIdRoot } = this.state;
+        let segsByDay = groupSegsByDay(allSegs); // sparse array
+        return (preact_cjs.createElement(internal_cjs.NowTimer, { unit: "day" }, (nowDate, todayRange) => {
+            let innerNodes = [];
+            for (let dayIndex = 0; dayIndex < segsByDay.length; dayIndex += 1) {
+                let daySegs = segsByDay[dayIndex];
+                if (daySegs) { // sparse array, so might be undefined
+                    let dayStr = internal_cjs.formatDayString(dayDates[dayIndex]);
+                    let dateHeaderId = dateHeaderIdRoot + '-' + dayStr;
+                    // append a day header
+                    innerNodes.push(preact_cjs.createElement(ListViewHeaderRow, { key: dayStr, cellId: dateHeaderId, dayDate: dayDates[dayIndex], todayRange: todayRange }));
+                    daySegs = internal_cjs.sortEventSegs(daySegs, options.eventOrder);
+                    for (let seg of daySegs) {
+                        innerNodes.push(preact_cjs.createElement(ListViewEventRow, Object.assign({ key: dayStr + ':' + seg.eventRange.instance.instanceId /* are multiple segs for an instanceId */, seg: seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: false, timeHeaderId: timeHeaderId, eventHeaderId: eventHeaderId, dateHeaderId: dateHeaderId }, internal_cjs.getSegMeta(seg, todayRange, nowDate))));
+                    }
+                }
+            }
+            return (preact_cjs.createElement("table", { className: 'fc-list-table ' + theme.getClass('table') },
+                preact_cjs.createElement("thead", null,
+                    preact_cjs.createElement("tr", null,
+                        preact_cjs.createElement("th", { scope: "col", id: timeHeaderId }, options.timeHint),
+                        preact_cjs.createElement("th", { scope: "col", "aria-hidden": true }),
+                        preact_cjs.createElement("th", { scope: "col", id: eventHeaderId }, options.eventHint))),
+                preact_cjs.createElement("tbody", null, innerNodes)));
+        }));
+    }
+    _eventStoreToSegs(eventStore, eventUiBases, dayRanges) {
+        return this.eventRangesToSegs(internal_cjs.sliceEventStore(eventStore, eventUiBases, this.props.dateProfile.activeRange, this.context.options.nextDayThreshold).fg, dayRanges);
+    }
+    eventRangesToSegs(eventRanges, dayRanges) {
+        let segs = [];
+        for (let eventRange of eventRanges) {
+            segs.push(...this.eventRangeToSegs(eventRange, dayRanges));
+        }
+        return segs;
+    }
+    eventRangeToSegs(eventRange, dayRanges) {
+        let { dateEnv } = this.context;
+        let { nextDayThreshold } = this.context.options;
+        let range = eventRange.range;
+        let allDay = eventRange.def.allDay;
+        let dayIndex;
+        let segRange;
+        let seg;
+        let segs = [];
+        for (dayIndex = 0; dayIndex < dayRanges.length; dayIndex += 1) {
+            segRange = internal_cjs.intersectRanges(range, dayRanges[dayIndex]);
+            if (segRange) {
+                seg = {
+                    component: this,
+                    eventRange,
+                    start: segRange.start,
+                    end: segRange.end,
+                    isStart: eventRange.isStart && segRange.start.valueOf() === range.start.valueOf(),
+                    isEnd: eventRange.isEnd && segRange.end.valueOf() === range.end.valueOf(),
+                    dayIndex,
+                };
+                segs.push(seg);
+                // detect when range won't go fully into the next day,
+                // and mutate the latest seg to the be the end.
+                if (!seg.isEnd && !allDay &&
+                    dayIndex + 1 < dayRanges.length &&
+                    range.end <
+                        dateEnv.add(dayRanges[dayIndex + 1].start, nextDayThreshold)) {
+                    seg.end = range.end;
+                    seg.isEnd = true;
+                    break;
+                }
+            }
+        }
+        return segs;
+    }
+}
+function renderNoEventsInner(renderProps) {
+    return renderProps.text;
+}
+function computeDateVars(dateProfile) {
+    let dayStart = internal_cjs.startOfDay(dateProfile.renderRange.start);
+    let viewEnd = dateProfile.renderRange.end;
+    let dayDates = [];
+    let dayRanges = [];
+    while (dayStart < viewEnd) {
+        dayDates.push(dayStart);
+        dayRanges.push({
+            start: dayStart,
+            end: internal_cjs.addDays(dayStart, 1),
+        });
+        dayStart = internal_cjs.addDays(dayStart, 1);
+    }
+    return { dayDates, dayRanges };
+}
+// Returns a sparse array of arrays, segs grouped by their dayIndex
+function groupSegsByDay(segs) {
+    let segsByDay = []; // sparse array
+    let i;
+    let seg;
+    for (i = 0; i < segs.length; i += 1) {
+        seg = segs[i];
+        (segsByDay[seg.dayIndex] || (segsByDay[seg.dayIndex] = []))
+            .push(seg);
+    }
+    return segsByDay;
+}
+
+var css_248z = ":root{--fc-list-event-dot-width:10px;--fc-list-event-hover-bg-color:#f5f5f5}.fc-theme-standard .fc-list{border:1px solid var(--fc-border-color)}.fc .fc-list-empty{align-items:center;background-color:var(--fc-neutral-bg-color);display:flex;height:100%;justify-content:center}.fc .fc-list-empty-cushion{margin:5em 0}.fc .fc-list-table{border-style:hidden;width:100%}.fc .fc-list-table tr>*{border-left:0;border-right:0}.fc .fc-list-sticky .fc-list-day>*{background:var(--fc-page-bg-color);position:sticky;top:0}.fc .fc-list-table thead{left:-10000px;position:absolute}.fc .fc-list-table tbody>tr:first-child th{border-top:0}.fc .fc-list-table th{padding:0}.fc .fc-list-day-cushion,.fc .fc-list-table td{padding:8px 14px}.fc .fc-list-day-cushion:after{clear:both;content:\"\";display:table}.fc-theme-standard .fc-list-day-cushion{background-color:var(--fc-neutral-bg-color)}.fc-direction-ltr .fc-list-day-text,.fc-direction-rtl .fc-list-day-side-text{float:left}.fc-direction-ltr .fc-list-day-side-text,.fc-direction-rtl .fc-list-day-text{float:right}.fc-direction-ltr .fc-list-table .fc-list-event-graphic{padding-right:0}.fc-direction-rtl .fc-list-table .fc-list-event-graphic{padding-left:0}.fc .fc-list-event.fc-event-forced-url{cursor:pointer}.fc .fc-list-event:hover td{background-color:var(--fc-list-event-hover-bg-color)}.fc .fc-list-event-graphic,.fc .fc-list-event-time{white-space:nowrap;width:1px}.fc .fc-list-event-dot{border:calc(var(--fc-list-event-dot-width)/2) solid var(--fc-event-border-color);border-radius:calc(var(--fc-list-event-dot-width)/2);box-sizing:content-box;display:inline-block;height:0;width:0}.fc .fc-list-event-title a{color:inherit;text-decoration:none}.fc .fc-list-event.fc-event-forced-url:hover a{text-decoration:underline}";
+internal_cjs.injectStyles(css_248z);
+
+exports.ListView = ListView;

node_modules/@fullcalendar/list/internal.d.ts

@@ -0,0 +1,4 @@
+export { L as ListView } from './internal-common.js';
+import '@fullcalendar/core';
+import '@fullcalendar/core/internal';
+import '@fullcalendar/core/preact';

node_modules/@fullcalendar/list/internal.js

@@ -0,0 +1,267 @@
+import { BaseComponent, getUniqueDomId, getDateMeta, buildNavLinkAttrs, ContentContainer, getDayClassNames, formatDayString, createFormatter, EventContainer, getSegAnchorAttrs, isMultiDayRange, buildSegTimeText, DateComponent, memoize, ViewContainer, Scroller, NowTimer, sortEventSegs, getSegMeta, sliceEventStore, intersectRanges, startOfDay, addDays, injectStyles } from '@fullcalendar/core/internal.js';
+import { createElement, Fragment } from '@fullcalendar/core/preact.js';
+
+class ListViewHeaderRow extends BaseComponent {
+    constructor() {
+        super(...arguments);
+        this.state = {
+            textId: getUniqueDomId(),
+        };
+    }
+    render() {
+        let { theme, dateEnv, options, viewApi } = this.context;
+        let { cellId, dayDate, todayRange } = this.props;
+        let { textId } = this.state;
+        let dayMeta = getDateMeta(dayDate, todayRange);
+        // will ever be falsy?
+        let text = options.listDayFormat ? dateEnv.format(dayDate, options.listDayFormat) : '';
+        // will ever be falsy? also, BAD NAME "alt"
+        let sideText = options.listDaySideFormat ? dateEnv.format(dayDate, options.listDaySideFormat) : '';
+        let renderProps = Object.assign({ date: dateEnv.toDate(dayDate), view: viewApi, textId,
+            text,
+            sideText, navLinkAttrs: buildNavLinkAttrs(this.context, dayDate), sideNavLinkAttrs: buildNavLinkAttrs(this.context, dayDate, 'day', false) }, dayMeta);
+        // TODO: make a reusable HOC for dayHeader (used in daygrid/timegrid too)
+        return (createElement(ContentContainer, { elTag: "tr", elClasses: [
+                'fc-list-day',
+                ...getDayClassNames(dayMeta, theme),
+            ], elAttrs: {
+                'data-date': formatDayString(dayDate),
+            }, renderProps: renderProps, generatorName: "dayHeaderContent", customGenerator: options.dayHeaderContent, defaultGenerator: renderInnerContent, classNameGenerator: options.dayHeaderClassNames, didMount: options.dayHeaderDidMount, willUnmount: options.dayHeaderWillUnmount }, (InnerContent) => ( // TODO: force-hide top border based on :first-child
+        createElement("th", { scope: "colgroup", colSpan: 3, id: cellId, "aria-labelledby": textId },
+            createElement(InnerContent, { elTag: "div", elClasses: [
+                    'fc-list-day-cushion',
+                    theme.getClass('tableCellShaded'),
+                ] })))));
+    }
+}
+function renderInnerContent(props) {
+    return (createElement(Fragment, null,
+        props.text && (createElement("a", Object.assign({ id: props.textId, className: "fc-list-day-text" }, props.navLinkAttrs), props.text)),
+        props.sideText && ( /* not keyboard tabbable */createElement("a", Object.assign({ "aria-hidden": true, className: "fc-list-day-side-text" }, props.sideNavLinkAttrs), props.sideText))));
+}
+
+const DEFAULT_TIME_FORMAT = createFormatter({
+    hour: 'numeric',
+    minute: '2-digit',
+    meridiem: 'short',
+});
+class ListViewEventRow extends BaseComponent {
+    render() {
+        let { props, context } = this;
+        let { options } = context;
+        let { seg, timeHeaderId, eventHeaderId, dateHeaderId } = props;
+        let timeFormat = options.eventTimeFormat || DEFAULT_TIME_FORMAT;
+        return (createElement(EventContainer, Object.assign({}, props, { elTag: "tr", elClasses: [
+                'fc-list-event',
+                seg.eventRange.def.url && 'fc-event-forced-url',
+            ], defaultGenerator: () => renderEventInnerContent(seg, context) /* weird */, seg: seg, timeText: "", disableDragging: true, disableResizing: true }), (InnerContent, eventContentArg) => (createElement(Fragment, null,
+            buildTimeContent(seg, timeFormat, context, timeHeaderId, dateHeaderId),
+            createElement("td", { "aria-hidden": true, className: "fc-list-event-graphic" },
+                createElement("span", { className: "fc-list-event-dot", style: {
+                        borderColor: eventContentArg.borderColor || eventContentArg.backgroundColor,
+                    } })),
+            createElement(InnerContent, { elTag: "td", elClasses: ['fc-list-event-title'], elAttrs: { headers: `${eventHeaderId} ${dateHeaderId}` } })))));
+    }
+}
+function renderEventInnerContent(seg, context) {
+    let interactiveAttrs = getSegAnchorAttrs(seg, context);
+    return (createElement("a", Object.assign({}, interactiveAttrs), seg.eventRange.def.title));
+}
+function buildTimeContent(seg, timeFormat, context, timeHeaderId, dateHeaderId) {
+    let { options } = context;
+    if (options.displayEventTime !== false) {
+        let eventDef = seg.eventRange.def;
+        let eventInstance = seg.eventRange.instance;
+        let doAllDay = false;
+        let timeText;
+        if (eventDef.allDay) {
+            doAllDay = true;
+        }
+        else if (isMultiDayRange(seg.eventRange.range)) { // TODO: use (!isStart || !isEnd) instead?
+            if (seg.isStart) {
+                timeText = buildSegTimeText(seg, timeFormat, context, null, null, eventInstance.range.start, seg.end);
+            }
+            else if (seg.isEnd) {
+                timeText = buildSegTimeText(seg, timeFormat, context, null, null, seg.start, eventInstance.range.end);
+            }
+            else {
+                doAllDay = true;
+            }
+        }
+        else {
+            timeText = buildSegTimeText(seg, timeFormat, context);
+        }
+        if (doAllDay) {
+            let renderProps = {
+                text: context.options.allDayText,
+                view: context.viewApi,
+            };
+            return (createElement(ContentContainer, { elTag: "td", elClasses: ['fc-list-event-time'], elAttrs: {
+                    headers: `${timeHeaderId} ${dateHeaderId}`,
+                }, renderProps: renderProps, generatorName: "allDayContent", customGenerator: options.allDayContent, defaultGenerator: renderAllDayInner, classNameGenerator: options.allDayClassNames, didMount: options.allDayDidMount, willUnmount: options.allDayWillUnmount }));
+        }
+        return (createElement("td", { className: "fc-list-event-time" }, timeText));
+    }
+    return null;
+}
+function renderAllDayInner(renderProps) {
+    return renderProps.text;
+}
+
+/*
+Responsible for the scroller, and forwarding event-related actions into the "grid".
+*/
+class ListView extends DateComponent {
+    constructor() {
+        super(...arguments);
+        this.computeDateVars = memoize(computeDateVars);
+        this.eventStoreToSegs = memoize(this._eventStoreToSegs);
+        this.state = {
+            timeHeaderId: getUniqueDomId(),
+            eventHeaderId: getUniqueDomId(),
+            dateHeaderIdRoot: getUniqueDomId(),
+        };
+        this.setRootEl = (rootEl) => {
+            if (rootEl) {
+                this.context.registerInteractiveComponent(this, {
+                    el: rootEl,
+                });
+            }
+            else {
+                this.context.unregisterInteractiveComponent(this);
+            }
+        };
+    }
+    render() {
+        let { props, context } = this;
+        let { dayDates, dayRanges } = this.computeDateVars(props.dateProfile);
+        let eventSegs = this.eventStoreToSegs(props.eventStore, props.eventUiBases, dayRanges);
+        return (createElement(ViewContainer, { elRef: this.setRootEl, elClasses: [
+                'fc-list',
+                context.theme.getClass('table'),
+                context.options.stickyHeaderDates !== false ?
+                    'fc-list-sticky' :
+                    '',
+            ], viewSpec: context.viewSpec },
+            createElement(Scroller, { liquid: !props.isHeightAuto, overflowX: props.isHeightAuto ? 'visible' : 'hidden', overflowY: props.isHeightAuto ? 'visible' : 'auto' }, eventSegs.length > 0 ?
+                this.renderSegList(eventSegs, dayDates) :
+                this.renderEmptyMessage())));
+    }
+    renderEmptyMessage() {
+        let { options, viewApi } = this.context;
+        let renderProps = {
+            text: options.noEventsText,
+            view: viewApi,
+        };
+        return (createElement(ContentContainer, { elTag: "div", elClasses: ['fc-list-empty'], renderProps: renderProps, generatorName: "noEventsContent", customGenerator: options.noEventsContent, defaultGenerator: renderNoEventsInner, classNameGenerator: options.noEventsClassNames, didMount: options.noEventsDidMount, willUnmount: options.noEventsWillUnmount }, (InnerContent) => (createElement(InnerContent, { elTag: "div", elClasses: ['fc-list-empty-cushion'] }))));
+    }
+    renderSegList(allSegs, dayDates) {
+        let { theme, options } = this.context;
+        let { timeHeaderId, eventHeaderId, dateHeaderIdRoot } = this.state;
+        let segsByDay = groupSegsByDay(allSegs); // sparse array
+        return (createElement(NowTimer, { unit: "day" }, (nowDate, todayRange) => {
+            let innerNodes = [];
+            for (let dayIndex = 0; dayIndex < segsByDay.length; dayIndex += 1) {
+                let daySegs = segsByDay[dayIndex];
+                if (daySegs) { // sparse array, so might be undefined
+                    let dayStr = formatDayString(dayDates[dayIndex]);
+                    let dateHeaderId = dateHeaderIdRoot + '-' + dayStr;
+                    // append a day header
+                    innerNodes.push(createElement(ListViewHeaderRow, { key: dayStr, cellId: dateHeaderId, dayDate: dayDates[dayIndex], todayRange: todayRange }));
+                    daySegs = sortEventSegs(daySegs, options.eventOrder);
+                    for (let seg of daySegs) {
+                        innerNodes.push(createElement(ListViewEventRow, Object.assign({ key: dayStr + ':' + seg.eventRange.instance.instanceId /* are multiple segs for an instanceId */, seg: seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: false, timeHeaderId: timeHeaderId, eventHeaderId: eventHeaderId, dateHeaderId: dateHeaderId }, getSegMeta(seg, todayRange, nowDate))));
+                    }
+                }
+            }
+            return (createElement("table", { className: 'fc-list-table ' + theme.getClass('table') },
+                createElement("thead", null,
+                    createElement("tr", null,
+                        createElement("th", { scope: "col", id: timeHeaderId }, options.timeHint),
+                        createElement("th", { scope: "col", "aria-hidden": true }),
+                        createElement("th", { scope: "col", id: eventHeaderId }, options.eventHint))),
+                createElement("tbody", null, innerNodes)));
+        }));
+    }
+    _eventStoreToSegs(eventStore, eventUiBases, dayRanges) {
+        return this.eventRangesToSegs(sliceEventStore(eventStore, eventUiBases, this.props.dateProfile.activeRange, this.context.options.nextDayThreshold).fg, dayRanges);
+    }
+    eventRangesToSegs(eventRanges, dayRanges) {
+        let segs = [];
+        for (let eventRange of eventRanges) {
+            segs.push(...this.eventRangeToSegs(eventRange, dayRanges));
+        }
+        return segs;
+    }
+    eventRangeToSegs(eventRange, dayRanges) {
+        let { dateEnv } = this.context;
+        let { nextDayThreshold } = this.context.options;
+        let range = eventRange.range;
+        let allDay = eventRange.def.allDay;
+        let dayIndex;
+        let segRange;
+        let seg;
+        let segs = [];
+        for (dayIndex = 0; dayIndex < dayRanges.length; dayIndex += 1) {
+            segRange = intersectRanges(range, dayRanges[dayIndex]);
+            if (segRange) {
+                seg = {
+                    component: this,
+                    eventRange,
+                    start: segRange.start,
+                    end: segRange.end,
+                    isStart: eventRange.isStart && segRange.start.valueOf() === range.start.valueOf(),
+                    isEnd: eventRange.isEnd && segRange.end.valueOf() === range.end.valueOf(),
+                    dayIndex,
+                };
+                segs.push(seg);
+                // detect when range won't go fully into the next day,
+                // and mutate the latest seg to the be the end.
+                if (!seg.isEnd && !allDay &&
+                    dayIndex + 1 < dayRanges.length &&
+                    range.end <
+                        dateEnv.add(dayRanges[dayIndex + 1].start, nextDayThreshold)) {
+                    seg.end = range.end;
+                    seg.isEnd = true;
+                    break;
+                }
+            }
+        }
+        return segs;
+    }
+}
+function renderNoEventsInner(renderProps) {
+    return renderProps.text;
+}
+function computeDateVars(dateProfile) {
+    let dayStart = startOfDay(dateProfile.renderRange.start);
+    let viewEnd = dateProfile.renderRange.end;
+    let dayDates = [];
+    let dayRanges = [];
+    while (dayStart < viewEnd) {
+        dayDates.push(dayStart);
+        dayRanges.push({
+            start: dayStart,
+            end: addDays(dayStart, 1),
+        });
+        dayStart = addDays(dayStart, 1);
+    }
+    return { dayDates, dayRanges };
+}
+// Returns a sparse array of arrays, segs grouped by their dayIndex
+function groupSegsByDay(segs) {
+    let segsByDay = []; // sparse array
+    let i;
+    let seg;
+    for (i = 0; i < segs.length; i += 1) {
+        seg = segs[i];
+        (segsByDay[seg.dayIndex] || (segsByDay[seg.dayIndex] = []))
+            .push(seg);
+    }
+    return segsByDay;
+}
+
+var css_248z = ":root{--fc-list-event-dot-width:10px;--fc-list-event-hover-bg-color:#f5f5f5}.fc-theme-standard .fc-list{border:1px solid var(--fc-border-color)}.fc .fc-list-empty{align-items:center;background-color:var(--fc-neutral-bg-color);display:flex;height:100%;justify-content:center}.fc .fc-list-empty-cushion{margin:5em 0}.fc .fc-list-table{border-style:hidden;width:100%}.fc .fc-list-table tr>*{border-left:0;border-right:0}.fc .fc-list-sticky .fc-list-day>*{background:var(--fc-page-bg-color);position:sticky;top:0}.fc .fc-list-table thead{left:-10000px;position:absolute}.fc .fc-list-table tbody>tr:first-child th{border-top:0}.fc .fc-list-table th{padding:0}.fc .fc-list-day-cushion,.fc .fc-list-table td{padding:8px 14px}.fc .fc-list-day-cushion:after{clear:both;content:\"\";display:table}.fc-theme-standard .fc-list-day-cushion{background-color:var(--fc-neutral-bg-color)}.fc-direction-ltr .fc-list-day-text,.fc-direction-rtl .fc-list-day-side-text{float:left}.fc-direction-ltr .fc-list-day-side-text,.fc-direction-rtl .fc-list-day-text{float:right}.fc-direction-ltr .fc-list-table .fc-list-event-graphic{padding-right:0}.fc-direction-rtl .fc-list-table .fc-list-event-graphic{padding-left:0}.fc .fc-list-event.fc-event-forced-url{cursor:pointer}.fc .fc-list-event:hover td{background-color:var(--fc-list-event-hover-bg-color)}.fc .fc-list-event-graphic,.fc .fc-list-event-time{white-space:nowrap;width:1px}.fc .fc-list-event-dot{border:calc(var(--fc-list-event-dot-width)/2) solid var(--fc-event-border-color);border-radius:calc(var(--fc-list-event-dot-width)/2);box-sizing:content-box;display:inline-block;height:0;width:0}.fc .fc-list-event-title a{color:inherit;text-decoration:none}.fc .fc-list-event.fc-event-forced-url:hover a{text-decoration:underline}";
+injectStyles(css_248z);
+
+export { ListView };

node_modules/@fullcalendar/list/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@fullcalendar/list",
+  "version": "6.1.17",
+  "title": "FullCalendar List View Plugin",
+  "description": "Display events on a calendar view that looks like a bulleted list",
+  "keywords": [
+    "calendar",
+    "event",
+    "full-sized",
+    "fullcalendar",
+    "list-view"
+  ],
+  "homepage": "https://fullcalendar.io/docs/list-view",
+  "peerDependencies": {
+    "@fullcalendar/core": "~6.1.17"
+  },
+  "type": "module",
+  "bugs": "https://fullcalendar.io/reporting-bugs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fullcalendar/fullcalendar.git",
+    "directory": "packages/list"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Adam Shaw",
+    "email": "arshaw@arshaw.com",
+    "url": "http://arshaw.com/"
+  },
+  "copyright": "2024 Adam Shaw",
+  "types": "./index.d.ts",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "unpkg": "./index.global.min.js",
+  "jsdelivr": "./index.global.min.js",
+  "exports": {
+    "./package.json": "./package.json",
+    "./index.cjs": "./index.cjs",
+    "./index.js": "./index.js",
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.cjs",
+      "import": "./index.js"
+    },
+    "./internal.cjs": "./internal.cjs",
+    "./internal.js": "./internal.js",
+    "./internal": {
+      "types": "./internal.d.ts",
+      "require": "./internal.cjs",
+      "import": "./internal.js"
+    }
+  },
+  "sideEffects": false
+}