serves as a min-height
}
}, arg.tableColGroupNode, y(isHeader ? "thead" : "tbody", {
role: "presentation"
}, typeof chunkConfig.rowContent === "function" ? chunkConfig.rowContent(arg) : chunkConfig.rowContent));
return content;
}
function isColPropsEqual(cols0, cols1) {
return isArraysEqual(cols0, cols1, isPropsEqual);
}
function renderMicroColGroup(cols, shrinkWidth) {
let colNodes = [];
for (let colProps of cols) {
let span = colProps.span || 1;
for (let i3 = 0; i3 < span; i3 += 1) {
colNodes.push(y("col", { style: {
width: colProps.width === "shrink" ? sanitizeShrinkWidth(shrinkWidth) : colProps.width || "",
minWidth: colProps.minWidth || ""
} }));
}
}
return y("colgroup", {}, ...colNodes);
}
function sanitizeShrinkWidth(shrinkWidth) {
return shrinkWidth == null ? 4 : shrinkWidth;
}
function hasShrinkWidth(cols) {
for (let col of cols) {
if (col.width === "shrink") {
return true;
}
}
return false;
}
function getScrollGridClassNames(liquid, context) {
let classNames = [
"fc-scrollgrid",
context.theme.getClass("table")
];
if (liquid) {
classNames.push("fc-scrollgrid-liquid");
}
return classNames;
}
function getSectionClassNames(sectionConfig, wholeTableVGrow) {
let classNames = [
"fc-scrollgrid-section",
`fc-scrollgrid-section-${sectionConfig.type}`,
sectionConfig.className
// used?
];
if (wholeTableVGrow && sectionConfig.liquid && sectionConfig.maxHeight == null) {
classNames.push("fc-scrollgrid-section-liquid");
}
if (sectionConfig.isSticky) {
classNames.push("fc-scrollgrid-section-sticky");
}
return classNames;
}
function renderScrollShim(arg) {
return y("div", { className: "fc-scrollgrid-sticky-shim", style: {
width: arg.clientWidth,
minWidth: arg.tableMinWidth
} });
}
function getStickyHeaderDates(options) {
let { stickyHeaderDates } = options;
if (stickyHeaderDates == null || stickyHeaderDates === "auto") {
stickyHeaderDates = options.height === "auto" || options.viewHeight === "auto";
}
return stickyHeaderDates;
}
function getStickyFooterScrollbar(options) {
let { stickyFooterScrollbar } = options;
if (stickyFooterScrollbar == null || stickyFooterScrollbar === "auto") {
stickyFooterScrollbar = options.height === "auto" || options.viewHeight === "auto";
}
return stickyFooterScrollbar;
}
var SimpleScrollGrid = class extends BaseComponent {
constructor() {
super(...arguments);
this.processCols = memoize((a3) => a3, isColPropsEqual);
this.renderMicroColGroup = memoize(renderMicroColGroup);
this.scrollerRefs = new RefMap();
this.scrollerElRefs = new RefMap(this._handleScrollerEl.bind(this));
this.state = {
shrinkWidth: null,
forceYScrollbars: false,
scrollerClientWidths: {},
scrollerClientHeights: {}
};
this.handleSizing = () => {
this.safeSetState(Object.assign({ shrinkWidth: this.computeShrinkWidth() }, this.computeScrollerDims()));
};
}
render() {
let { props, state, context } = this;
let sectionConfigs = props.sections || [];
let cols = this.processCols(props.cols);
let microColGroupNode = this.renderMicroColGroup(cols, state.shrinkWidth);
let classNames = getScrollGridClassNames(props.liquid, context);
if (props.collapsibleWidth) {
classNames.push("fc-scrollgrid-collapsible");
}
let configCnt = sectionConfigs.length;
let configI = 0;
let currentConfig;
let headSectionNodes = [];
let bodySectionNodes = [];
let footSectionNodes = [];
while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === "header") {
headSectionNodes.push(this.renderSection(currentConfig, microColGroupNode, true));
configI += 1;
}
while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === "body") {
bodySectionNodes.push(this.renderSection(currentConfig, microColGroupNode, false));
configI += 1;
}
while (configI < configCnt && (currentConfig = sectionConfigs[configI]).type === "footer") {
footSectionNodes.push(this.renderSection(currentConfig, microColGroupNode, true));
configI += 1;
}
let isBuggy = !getCanVGrowWithinCell();
const roleAttrs = { role: "rowgroup" };
return y("table", {
role: "grid",
className: classNames.join(" "),
style: { height: props.height }
}, Boolean(!isBuggy && headSectionNodes.length) && y("thead", roleAttrs, ...headSectionNodes), Boolean(!isBuggy && bodySectionNodes.length) && y("tbody", roleAttrs, ...bodySectionNodes), Boolean(!isBuggy && footSectionNodes.length) && y("tfoot", roleAttrs, ...footSectionNodes), isBuggy && y("tbody", roleAttrs, ...headSectionNodes, ...bodySectionNodes, ...footSectionNodes));
}
renderSection(sectionConfig, microColGroupNode, isHeader) {
if ("outerContent" in sectionConfig) {
return y(_, { key: sectionConfig.key }, sectionConfig.outerContent);
}
return y("tr", { key: sectionConfig.key, role: "presentation", className: getSectionClassNames(sectionConfig, this.props.liquid).join(" ") }, this.renderChunkTd(sectionConfig, microColGroupNode, sectionConfig.chunk, isHeader));
}
renderChunkTd(sectionConfig, microColGroupNode, chunkConfig, isHeader) {
if ("outerContent" in chunkConfig) {
return chunkConfig.outerContent;
}
let { props } = this;
let { forceYScrollbars, scrollerClientWidths, scrollerClientHeights } = this.state;
let needsYScrolling = getAllowYScrolling(props, sectionConfig);
let isLiquid = getSectionHasLiquidHeight(props, sectionConfig);
let overflowY = !props.liquid ? "visible" : forceYScrollbars ? "scroll" : !needsYScrolling ? "hidden" : "auto";
let sectionKey = sectionConfig.key;
let content = renderChunkContent(sectionConfig, chunkConfig, {
tableColGroupNode: microColGroupNode,
tableMinWidth: "",
clientWidth: !props.collapsibleWidth && scrollerClientWidths[sectionKey] !== void 0 ? scrollerClientWidths[sectionKey] : null,
clientHeight: scrollerClientHeights[sectionKey] !== void 0 ? scrollerClientHeights[sectionKey] : null,
expandRows: sectionConfig.expandRows,
syncRowHeights: false,
rowSyncHeights: [],
reportRowHeightChange: () => {
}
}, isHeader);
return y(isHeader ? "th" : "td", {
ref: chunkConfig.elRef,
role: "presentation"
}, y(
"div",
{ className: `fc-scroller-harness${isLiquid ? " fc-scroller-harness-liquid" : ""}` },
y(Scroller, { ref: this.scrollerRefs.createRef(sectionKey), elRef: this.scrollerElRefs.createRef(sectionKey), overflowY, overflowX: !props.liquid ? "visible" : "hidden", maxHeight: sectionConfig.maxHeight, liquid: isLiquid, liquidIsAbsolute: true }, content)
));
}
_handleScrollerEl(scrollerEl, key) {
let section = getSectionByKey(this.props.sections, key);
if (section) {
setRef(section.chunk.scrollerElRef, scrollerEl);
}
}
componentDidMount() {
this.handleSizing();
this.context.addResizeHandler(this.handleSizing);
}
componentDidUpdate() {
this.handleSizing();
}
componentWillUnmount() {
this.context.removeResizeHandler(this.handleSizing);
}
computeShrinkWidth() {
return hasShrinkWidth(this.props.cols) ? computeShrinkWidth(this.scrollerElRefs.getAll()) : 0;
}
computeScrollerDims() {
let scrollbarWidth = getScrollbarWidths();
let { scrollerRefs, scrollerElRefs } = this;
let forceYScrollbars = false;
let scrollerClientWidths = {};
let scrollerClientHeights = {};
for (let sectionKey in scrollerRefs.currentMap) {
let scroller = scrollerRefs.currentMap[sectionKey];
if (scroller && scroller.needsYScrolling()) {
forceYScrollbars = true;
break;
}
}
for (let section of this.props.sections) {
let sectionKey = section.key;
let scrollerEl = scrollerElRefs.currentMap[sectionKey];
if (scrollerEl) {
let harnessEl = scrollerEl.parentNode;
scrollerClientWidths[sectionKey] = Math.floor(harnessEl.getBoundingClientRect().width - (forceYScrollbars ? scrollbarWidth.y : 0));
scrollerClientHeights[sectionKey] = Math.floor(harnessEl.getBoundingClientRect().height);
}
}
return { forceYScrollbars, scrollerClientWidths, scrollerClientHeights };
}
};
SimpleScrollGrid.addStateEquality({
scrollerClientWidths: isPropsEqual,
scrollerClientHeights: isPropsEqual
});
function getSectionByKey(sections, key) {
for (let section of sections) {
if (section.key === key) {
return section;
}
}
return null;
}
var EventContainer = class extends BaseComponent {
constructor() {
super(...arguments);
this.handleEl = (el) => {
this.el = el;
if (el) {
setElSeg(el, this.props.seg);
}
};
}
render() {
const { props, context } = this;
const { options } = context;
const { seg } = props;
const { eventRange } = seg;
const { ui } = eventRange;
const renderProps = {
event: new EventImpl(context, eventRange.def, eventRange.instance),
view: context.viewApi,
timeText: props.timeText,
textColor: ui.textColor,
backgroundColor: ui.backgroundColor,
borderColor: ui.borderColor,
isDraggable: !props.disableDragging && computeSegDraggable(seg, context),
isStartResizable: !props.disableResizing && computeSegStartResizable(seg, context),
isEndResizable: !props.disableResizing && computeSegEndResizable(seg),
isMirror: Boolean(props.isDragging || props.isResizing || props.isDateSelecting),
isStart: Boolean(seg.isStart),
isEnd: Boolean(seg.isEnd),
isPast: Boolean(props.isPast),
isFuture: Boolean(props.isFuture),
isToday: Boolean(props.isToday),
isSelected: Boolean(props.isSelected),
isDragging: Boolean(props.isDragging),
isResizing: Boolean(props.isResizing)
};
return y(ContentContainer, Object.assign({}, props, { elRef: this.handleEl, elClasses: [
...getEventClassNames(renderProps),
...seg.eventRange.ui.classNames,
...props.elClasses || []
], renderProps, generatorName: "eventContent", customGenerator: options.eventContent, defaultGenerator: props.defaultGenerator, classNameGenerator: options.eventClassNames, didMount: options.eventDidMount, willUnmount: options.eventWillUnmount }));
}
componentDidUpdate(prevProps) {
if (this.el && this.props.seg !== prevProps.seg) {
setElSeg(this.el, this.props.seg);
}
}
};
var StandardEvent = class extends BaseComponent {
render() {
let { props, context } = this;
let { options } = context;
let { seg } = props;
let { ui } = seg.eventRange;
let timeFormat = options.eventTimeFormat || props.defaultTimeFormat;
let timeText = buildSegTimeText(seg, timeFormat, context, props.defaultDisplayEventTime, props.defaultDisplayEventEnd);
return y(EventContainer, Object.assign({}, props, { elTag: "a", elStyle: {
borderColor: ui.borderColor,
backgroundColor: ui.backgroundColor
}, elAttrs: getSegAnchorAttrs(seg, context), defaultGenerator: renderInnerContent$1, timeText }), (InnerContent, eventContentArg) => y(
_,
null,
y(InnerContent, { elTag: "div", elClasses: ["fc-event-main"], elStyle: { color: eventContentArg.textColor } }),
Boolean(eventContentArg.isStartResizable) && y("div", { className: "fc-event-resizer fc-event-resizer-start" }),
Boolean(eventContentArg.isEndResizable) && y("div", { className: "fc-event-resizer fc-event-resizer-end" })
));
}
};
function renderInnerContent$1(innerProps) {
return y(
"div",
{ className: "fc-event-main-frame" },
innerProps.timeText && y("div", { className: "fc-event-time" }, innerProps.timeText),
y(
"div",
{ className: "fc-event-title-container" },
y("div", { className: "fc-event-title fc-sticky" }, innerProps.event.title || y(_, null, "\xA0"))
)
);
}
var NowIndicatorContainer = (props) => y(ViewContextType.Consumer, null, (context) => {
let { options } = context;
let renderProps = {
isAxis: props.isAxis,
date: context.dateEnv.toDate(props.date),
view: context.viewApi
};
return y(ContentContainer, Object.assign({}, props, { elTag: props.elTag || "div", renderProps, generatorName: "nowIndicatorContent", customGenerator: options.nowIndicatorContent, classNameGenerator: options.nowIndicatorClassNames, didMount: options.nowIndicatorDidMount, willUnmount: options.nowIndicatorWillUnmount }));
});
var DAY_NUM_FORMAT = createFormatter({ day: "numeric" });
var DayCellContainer = class extends BaseComponent {
constructor() {
super(...arguments);
this.refineRenderProps = memoizeObjArg(refineRenderProps);
}
render() {
let { props, context } = this;
let { options } = context;
let renderProps = this.refineRenderProps({
date: props.date,
dateProfile: props.dateProfile,
todayRange: props.todayRange,
isMonthStart: props.isMonthStart || false,
showDayNumber: props.showDayNumber,
extraRenderProps: props.extraRenderProps,
viewApi: context.viewApi,
dateEnv: context.dateEnv,
monthStartFormat: options.monthStartFormat
});
return y(ContentContainer, Object.assign({}, props, { elClasses: [
...getDayClassNames(renderProps, context.theme),
...props.elClasses || []
], elAttrs: Object.assign(Object.assign({}, props.elAttrs), renderProps.isDisabled ? {} : { "data-date": formatDayString(props.date) }), renderProps, generatorName: "dayCellContent", customGenerator: options.dayCellContent, defaultGenerator: props.defaultGenerator, classNameGenerator: (
// don't use custom classNames if disabled
renderProps.isDisabled ? void 0 : options.dayCellClassNames
), didMount: options.dayCellDidMount, willUnmount: options.dayCellWillUnmount }));
}
};
function hasCustomDayCellContent(options) {
return Boolean(options.dayCellContent || hasCustomRenderingHandler("dayCellContent", options));
}
function refineRenderProps(raw) {
let { date, dateEnv, dateProfile, isMonthStart } = raw;
let dayMeta = getDateMeta(date, raw.todayRange, null, dateProfile);
let dayNumberText = raw.showDayNumber ? dateEnv.format(date, isMonthStart ? raw.monthStartFormat : DAY_NUM_FORMAT) : "";
return Object.assign(Object.assign(Object.assign({ date: dateEnv.toDate(date), view: raw.viewApi }, dayMeta), {
isMonthStart,
dayNumberText
}), raw.extraRenderProps);
}
var BgEvent = class extends BaseComponent {
render() {
let { props } = this;
let { seg } = props;
return y(EventContainer, { elTag: "div", elClasses: ["fc-bg-event"], elStyle: { backgroundColor: seg.eventRange.ui.backgroundColor }, defaultGenerator: renderInnerContent, seg, timeText: "", isDragging: false, isResizing: false, isDateSelecting: false, isSelected: false, isPast: props.isPast, isFuture: props.isFuture, isToday: props.isToday, disableDragging: true, disableResizing: true });
}
};
function renderInnerContent(props) {
let { title } = props.event;
return title && y("div", { className: "fc-event-title" }, props.event.title);
}
function renderFill(fillType) {
return y("div", { className: `fc-${fillType}` });
}
var WeekNumberContainer = (props) => y(ViewContextType.Consumer, null, (context) => {
let { dateEnv, options } = context;
let { date } = props;
let format = options.weekNumberFormat || props.defaultFormat;
let num = dateEnv.computeWeekNumber(date);
let text = dateEnv.format(date, format);
let renderProps = { num, text, date };
return y(
ContentContainer,
Object.assign({}, props, { renderProps, generatorName: "weekNumberContent", customGenerator: options.weekNumberContent, defaultGenerator: renderInner, classNameGenerator: options.weekNumberClassNames, didMount: options.weekNumberDidMount, willUnmount: options.weekNumberWillUnmount })
);
});
function renderInner(innerProps) {
return innerProps.text;
}
var PADDING_FROM_VIEWPORT = 10;
var Popover = class extends BaseComponent {
constructor() {
super(...arguments);
this.state = {
titleId: getUniqueDomId()
};
this.handleRootEl = (el) => {
this.rootEl = el;
if (this.props.elRef) {
setRef(this.props.elRef, el);
}
};
this.handleDocumentMouseDown = (ev) => {
const target = getEventTargetViaRoot(ev);
if (!this.rootEl.contains(target)) {
this.handleCloseClick();
}
};
this.handleDocumentKeyDown = (ev) => {
if (ev.key === "Escape") {
this.handleCloseClick();
}
};
this.handleCloseClick = () => {
let { onClose } = this.props;
if (onClose) {
onClose();
}
};
}
render() {
let { theme, options } = this.context;
let { props, state } = this;
let classNames = [
"fc-popover",
theme.getClass("popover")
].concat(props.extraClassNames || []);
return j3(y(
"div",
Object.assign({}, props.extraAttrs, { id: props.id, className: classNames.join(" "), "aria-labelledby": state.titleId, ref: this.handleRootEl }),
y(
"div",
{ className: "fc-popover-header " + theme.getClass("popoverHeader") },
y("span", { className: "fc-popover-title", id: state.titleId }, props.title),
y("span", { className: "fc-popover-close " + theme.getIconClass("close"), title: options.closeHint, onClick: this.handleCloseClick })
),
y("div", { className: "fc-popover-body " + theme.getClass("popoverContent") }, props.children)
), props.parentEl);
}
componentDidMount() {
document.addEventListener("mousedown", this.handleDocumentMouseDown);
document.addEventListener("keydown", this.handleDocumentKeyDown);
this.updateSize();
}
componentWillUnmount() {
document.removeEventListener("mousedown", this.handleDocumentMouseDown);
document.removeEventListener("keydown", this.handleDocumentKeyDown);
}
updateSize() {
let { isRtl } = this.context;
let { alignmentEl, alignGridTop } = this.props;
let { rootEl } = this;
let alignmentRect = computeClippedClientRect(alignmentEl);
if (alignmentRect) {
let popoverDims = rootEl.getBoundingClientRect();
let popoverTop = alignGridTop ? elementClosest(alignmentEl, ".fc-scrollgrid").getBoundingClientRect().top : alignmentRect.top;
let popoverLeft = isRtl ? alignmentRect.right - popoverDims.width : alignmentRect.left;
popoverTop = Math.max(popoverTop, PADDING_FROM_VIEWPORT);
popoverLeft = Math.min(popoverLeft, document.documentElement.clientWidth - PADDING_FROM_VIEWPORT - popoverDims.width);
popoverLeft = Math.max(popoverLeft, PADDING_FROM_VIEWPORT);
let origin = rootEl.offsetParent.getBoundingClientRect();
applyStyle(rootEl, {
top: popoverTop - origin.top,
left: popoverLeft - origin.left
});
}
}
};
var MorePopover = class extends DateComponent {
constructor() {
super(...arguments);
this.handleRootEl = (rootEl) => {
this.rootEl = rootEl;
if (rootEl) {
this.context.registerInteractiveComponent(this, {
el: rootEl,
useEventCenter: false
});
} else {
this.context.unregisterInteractiveComponent(this);
}
};
}
render() {
let { options, dateEnv } = this.context;
let { props } = this;
let { startDate, todayRange, dateProfile } = props;
let title = dateEnv.format(startDate, options.dayPopoverFormat);
return y(DayCellContainer, { elRef: this.handleRootEl, date: startDate, dateProfile, todayRange }, (InnerContent, renderProps, elAttrs) => y(
Popover,
{ elRef: elAttrs.ref, id: props.id, title, extraClassNames: ["fc-more-popover"].concat(elAttrs.className || []), extraAttrs: elAttrs, parentEl: props.parentEl, alignmentEl: props.alignmentEl, alignGridTop: props.alignGridTop, onClose: props.onClose },
hasCustomDayCellContent(options) && y(InnerContent, { elTag: "div", elClasses: ["fc-more-popover-misc"] }),
props.children
));
}
queryHit(positionLeft, positionTop, elWidth, elHeight) {
let { rootEl, props } = this;
if (positionLeft >= 0 && positionLeft < elWidth && positionTop >= 0 && positionTop < elHeight) {
return {
dateProfile: props.dateProfile,
dateSpan: Object.assign({ allDay: !props.forceTimed, range: {
start: props.startDate,
end: props.endDate
} }, props.extraDateSpan),
dayEl: rootEl,
rect: {
left: 0,
top: 0,
right: elWidth,
bottom: elHeight
},
layer: 1
// important when comparing with hits from other components
};
}
return null;
}
};
var MoreLinkContainer = class extends BaseComponent {
constructor() {
super(...arguments);
this.state = {
isPopoverOpen: false,
popoverId: getUniqueDomId()
};
this.handleLinkEl = (linkEl) => {
this.linkEl = linkEl;
if (this.props.elRef) {
setRef(this.props.elRef, linkEl);
}
};
this.handleClick = (ev) => {
let { props, context } = this;
let { moreLinkClick } = context.options;
let date = computeRange(props).start;
function buildPublicSeg(seg) {
let { def, instance, range } = seg.eventRange;
return {
event: new EventImpl(context, def, instance),
start: context.dateEnv.toDate(range.start),
end: context.dateEnv.toDate(range.end),
isStart: seg.isStart,
isEnd: seg.isEnd
};
}
if (typeof moreLinkClick === "function") {
moreLinkClick = moreLinkClick({
date,
allDay: Boolean(props.allDayDate),
allSegs: props.allSegs.map(buildPublicSeg),
hiddenSegs: props.hiddenSegs.map(buildPublicSeg),
jsEvent: ev,
view: context.viewApi
});
}
if (!moreLinkClick || moreLinkClick === "popover") {
this.setState({ isPopoverOpen: true });
} else if (typeof moreLinkClick === "string") {
context.calendarApi.zoomTo(date, moreLinkClick);
}
};
this.handlePopoverClose = () => {
this.setState({ isPopoverOpen: false });
};
}
render() {
let { props, state } = this;
return y(ViewContextType.Consumer, null, (context) => {
let { viewApi, options, calendarApi } = context;
let { moreLinkText } = options;
let { moreCnt } = props;
let range = computeRange(props);
let text = typeof moreLinkText === "function" ? moreLinkText.call(calendarApi, moreCnt) : `+${moreCnt} ${moreLinkText}`;
let hint = formatWithOrdinals(options.moreLinkHint, [moreCnt], text);
let renderProps = {
num: moreCnt,
shortText: `+${moreCnt}`,
text,
view: viewApi
};
return y(
_,
null,
Boolean(props.moreCnt) && y(ContentContainer, { elTag: props.elTag || "a", elRef: this.handleLinkEl, elClasses: [
...props.elClasses || [],
"fc-more-link"
], elStyle: props.elStyle, elAttrs: Object.assign(Object.assign(Object.assign({}, props.elAttrs), createAriaClickAttrs(this.handleClick)), { title: hint, "aria-expanded": state.isPopoverOpen, "aria-controls": state.isPopoverOpen ? state.popoverId : "" }), renderProps, generatorName: "moreLinkContent", customGenerator: options.moreLinkContent, defaultGenerator: props.defaultGenerator || renderMoreLinkInner, classNameGenerator: options.moreLinkClassNames, didMount: options.moreLinkDidMount, willUnmount: options.moreLinkWillUnmount }, props.children),
state.isPopoverOpen && y(MorePopover, { id: state.popoverId, startDate: range.start, endDate: range.end, dateProfile: props.dateProfile, todayRange: props.todayRange, extraDateSpan: props.extraDateSpan, parentEl: this.parentEl, alignmentEl: props.alignmentElRef ? props.alignmentElRef.current : this.linkEl, alignGridTop: props.alignGridTop, forceTimed: props.forceTimed, onClose: this.handlePopoverClose }, props.popoverContent())
);
});
}
componentDidMount() {
this.updateParentEl();
}
componentDidUpdate() {
this.updateParentEl();
}
updateParentEl() {
if (this.linkEl) {
this.parentEl = elementClosest(this.linkEl, ".fc-view-harness");
}
}
};
function renderMoreLinkInner(props) {
return props.text;
}
function computeRange(props) {
if (props.allDayDate) {
return {
start: props.allDayDate,
end: addDays(props.allDayDate, 1)
};
}
let { hiddenSegs } = props;
return {
start: computeEarliestSegStart(hiddenSegs),
end: computeLatestSegEnd(hiddenSegs)
};
}
function computeEarliestSegStart(segs) {
return segs.reduce(pickEarliestStart).eventRange.range.start;
}
function pickEarliestStart(seg0, seg1) {
return seg0.eventRange.range.start < seg1.eventRange.range.start ? seg0 : seg1;
}
function computeLatestSegEnd(segs) {
return segs.reduce(pickLatestEnd).eventRange.range.end;
}
function pickLatestEnd(seg0, seg1) {
return seg0.eventRange.range.end > seg1.eventRange.range.end ? seg0 : seg1;
}
// node_modules/.pnpm/@fullcalendar+core@6.1.17/node_modules/@fullcalendar/core/index.js
var globalLocales = [];
var MINIMAL_RAW_EN_LOCALE = {
code: "en",
week: {
dow: 0,
doy: 4
// 4 days need to be within the year to be considered the first week
},
direction: "ltr",
buttonText: {
prev: "prev",
next: "next",
prevYear: "prev year",
nextYear: "next year",
year: "year",
today: "today",
month: "month",
week: "week",
day: "day",
list: "list"
},
weekText: "W",
weekTextLong: "Week",
closeHint: "Close",
timeHint: "Time",
eventHint: "Event",
allDayText: "all-day",
moreLinkText: "more",
noEventsText: "No events to display"
};
var RAW_EN_LOCALE = Object.assign(Object.assign({}, MINIMAL_RAW_EN_LOCALE), {
// Includes things we don't want other locales to inherit,
// things that derive from other translatable strings.
buttonHints: {
prev: "Previous $0",
next: "Next $0",
today(buttonText, unit) {
return unit === "day" ? "Today" : `This ${buttonText}`;
}
},
viewHint: "$0 view",
navLinkHint: "Go to $0",
moreLinkHint(eventCnt) {
return `Show ${eventCnt} more event${eventCnt === 1 ? "" : "s"}`;
}
});
function organizeRawLocales(explicitRawLocales) {
let defaultCode = explicitRawLocales.length > 0 ? explicitRawLocales[0].code : "en";
let allRawLocales = globalLocales.concat(explicitRawLocales);
let rawLocaleMap = {
en: RAW_EN_LOCALE
};
for (let rawLocale of allRawLocales) {
rawLocaleMap[rawLocale.code] = rawLocale;
}
return {
map: rawLocaleMap,
defaultCode
};
}
function buildLocale(inputSingular, available) {
if (typeof inputSingular === "object" && !Array.isArray(inputSingular)) {
return parseLocale(inputSingular.code, [inputSingular.code], inputSingular);
}
return queryLocale(inputSingular, available);
}
function queryLocale(codeArg, available) {
let codes = [].concat(codeArg || []);
let raw = queryRawLocale(codes, available) || RAW_EN_LOCALE;
return parseLocale(codeArg, codes, raw);
}
function queryRawLocale(codes, available) {
for (let i3 = 0; i3 < codes.length; i3 += 1) {
let parts = codes[i3].toLocaleLowerCase().split("-");
for (let j4 = parts.length; j4 > 0; j4 -= 1) {
let simpleId = parts.slice(0, j4).join("-");
if (available[simpleId]) {
return available[simpleId];
}
}
}
return null;
}
function parseLocale(codeArg, codes, raw) {
let merged = mergeProps([MINIMAL_RAW_EN_LOCALE, raw], ["buttonText"]);
delete merged.code;
let { week } = merged;
delete merged.week;
return {
codeArg,
codes,
week,
simpleNumberFormat: new Intl.NumberFormat(codeArg),
options: merged
};
}
function createPlugin(input) {
return {
id: guid(),
name: input.name,
premiumReleaseDate: input.premiumReleaseDate ? new Date(input.premiumReleaseDate) : void 0,
deps: input.deps || [],
reducers: input.reducers || [],
isLoadingFuncs: input.isLoadingFuncs || [],
contextInit: [].concat(input.contextInit || []),
eventRefiners: input.eventRefiners || {},
eventDefMemberAdders: input.eventDefMemberAdders || [],
eventSourceRefiners: input.eventSourceRefiners || {},
isDraggableTransformers: input.isDraggableTransformers || [],
eventDragMutationMassagers: input.eventDragMutationMassagers || [],
eventDefMutationAppliers: input.eventDefMutationAppliers || [],
dateSelectionTransformers: input.dateSelectionTransformers || [],
datePointTransforms: input.datePointTransforms || [],
dateSpanTransforms: input.dateSpanTransforms || [],
views: input.views || {},
viewPropsTransformers: input.viewPropsTransformers || [],
isPropsValid: input.isPropsValid || null,
externalDefTransforms: input.externalDefTransforms || [],
viewContainerAppends: input.viewContainerAppends || [],
eventDropTransformers: input.eventDropTransformers || [],
componentInteractions: input.componentInteractions || [],
calendarInteractions: input.calendarInteractions || [],
themeClasses: input.themeClasses || {},
eventSourceDefs: input.eventSourceDefs || [],
cmdFormatter: input.cmdFormatter,
recurringTypes: input.recurringTypes || [],
namedTimeZonedImpl: input.namedTimeZonedImpl,
initialView: input.initialView || "",
elementDraggingImpl: input.elementDraggingImpl,
optionChangeHandlers: input.optionChangeHandlers || {},
scrollGridImpl: input.scrollGridImpl || null,
listenerRefiners: input.listenerRefiners || {},
optionRefiners: input.optionRefiners || {},
propSetHandlers: input.propSetHandlers || {}
};
}
function buildPluginHooks(pluginDefs, globalDefs) {
let currentPluginIds = {};
let hooks = {
premiumReleaseDate: void 0,
reducers: [],
isLoadingFuncs: [],
contextInit: [],
eventRefiners: {},
eventDefMemberAdders: [],
eventSourceRefiners: {},
isDraggableTransformers: [],
eventDragMutationMassagers: [],
eventDefMutationAppliers: [],
dateSelectionTransformers: [],
datePointTransforms: [],
dateSpanTransforms: [],
views: {},
viewPropsTransformers: [],
isPropsValid: null,
externalDefTransforms: [],
viewContainerAppends: [],
eventDropTransformers: [],
componentInteractions: [],
calendarInteractions: [],
themeClasses: {},
eventSourceDefs: [],
cmdFormatter: null,
recurringTypes: [],
namedTimeZonedImpl: null,
initialView: "",
elementDraggingImpl: null,
optionChangeHandlers: {},
scrollGridImpl: null,
listenerRefiners: {},
optionRefiners: {},
propSetHandlers: {}
};
function addDefs(defs) {
for (let def of defs) {
const pluginName = def.name;
const currentId = currentPluginIds[pluginName];
if (currentId === void 0) {
currentPluginIds[pluginName] = def.id;
addDefs(def.deps);
hooks = combineHooks(hooks, def);
} else if (currentId !== def.id) {
console.warn(`Duplicate plugin '${pluginName}'`);
}
}
}
if (pluginDefs) {
addDefs(pluginDefs);
}
addDefs(globalDefs);
return hooks;
}
function buildBuildPluginHooks() {
let currentOverrideDefs = [];
let currentGlobalDefs = [];
let currentHooks;
return (overrideDefs, globalDefs) => {
if (!currentHooks || !isArraysEqual(overrideDefs, currentOverrideDefs) || !isArraysEqual(globalDefs, currentGlobalDefs)) {
currentHooks = buildPluginHooks(overrideDefs, globalDefs);
}
currentOverrideDefs = overrideDefs;
currentGlobalDefs = globalDefs;
return currentHooks;
};
}
function combineHooks(hooks0, hooks1) {
return {
premiumReleaseDate: compareOptionalDates(hooks0.premiumReleaseDate, hooks1.premiumReleaseDate),
reducers: hooks0.reducers.concat(hooks1.reducers),
isLoadingFuncs: hooks0.isLoadingFuncs.concat(hooks1.isLoadingFuncs),
contextInit: hooks0.contextInit.concat(hooks1.contextInit),
eventRefiners: Object.assign(Object.assign({}, hooks0.eventRefiners), hooks1.eventRefiners),
eventDefMemberAdders: hooks0.eventDefMemberAdders.concat(hooks1.eventDefMemberAdders),
eventSourceRefiners: Object.assign(Object.assign({}, hooks0.eventSourceRefiners), hooks1.eventSourceRefiners),
isDraggableTransformers: hooks0.isDraggableTransformers.concat(hooks1.isDraggableTransformers),
eventDragMutationMassagers: hooks0.eventDragMutationMassagers.concat(hooks1.eventDragMutationMassagers),
eventDefMutationAppliers: hooks0.eventDefMutationAppliers.concat(hooks1.eventDefMutationAppliers),
dateSelectionTransformers: hooks0.dateSelectionTransformers.concat(hooks1.dateSelectionTransformers),
datePointTransforms: hooks0.datePointTransforms.concat(hooks1.datePointTransforms),
dateSpanTransforms: hooks0.dateSpanTransforms.concat(hooks1.dateSpanTransforms),
views: Object.assign(Object.assign({}, hooks0.views), hooks1.views),
viewPropsTransformers: hooks0.viewPropsTransformers.concat(hooks1.viewPropsTransformers),
isPropsValid: hooks1.isPropsValid || hooks0.isPropsValid,
externalDefTransforms: hooks0.externalDefTransforms.concat(hooks1.externalDefTransforms),
viewContainerAppends: hooks0.viewContainerAppends.concat(hooks1.viewContainerAppends),
eventDropTransformers: hooks0.eventDropTransformers.concat(hooks1.eventDropTransformers),
calendarInteractions: hooks0.calendarInteractions.concat(hooks1.calendarInteractions),
componentInteractions: hooks0.componentInteractions.concat(hooks1.componentInteractions),
themeClasses: Object.assign(Object.assign({}, hooks0.themeClasses), hooks1.themeClasses),
eventSourceDefs: hooks0.eventSourceDefs.concat(hooks1.eventSourceDefs),
cmdFormatter: hooks1.cmdFormatter || hooks0.cmdFormatter,
recurringTypes: hooks0.recurringTypes.concat(hooks1.recurringTypes),
namedTimeZonedImpl: hooks1.namedTimeZonedImpl || hooks0.namedTimeZonedImpl,
initialView: hooks0.initialView || hooks1.initialView,
elementDraggingImpl: hooks0.elementDraggingImpl || hooks1.elementDraggingImpl,
optionChangeHandlers: Object.assign(Object.assign({}, hooks0.optionChangeHandlers), hooks1.optionChangeHandlers),
scrollGridImpl: hooks1.scrollGridImpl || hooks0.scrollGridImpl,
listenerRefiners: Object.assign(Object.assign({}, hooks0.listenerRefiners), hooks1.listenerRefiners),
optionRefiners: Object.assign(Object.assign({}, hooks0.optionRefiners), hooks1.optionRefiners),
propSetHandlers: Object.assign(Object.assign({}, hooks0.propSetHandlers), hooks1.propSetHandlers)
};
}
function compareOptionalDates(date0, date1) {
if (date0 === void 0) {
return date1;
}
if (date1 === void 0) {
return date0;
}
return new Date(Math.max(date0.valueOf(), date1.valueOf()));
}
var StandardTheme = class extends Theme {
};
StandardTheme.prototype.classes = {
root: "fc-theme-standard",
tableCellShaded: "fc-cell-shaded",
buttonGroup: "fc-button-group",
button: "fc-button fc-button-primary",
buttonActive: "fc-button-active"
};
StandardTheme.prototype.baseIconClass = "fc-icon";
StandardTheme.prototype.iconClasses = {
close: "fc-icon-x",
prev: "fc-icon-chevron-left",
next: "fc-icon-chevron-right",
prevYear: "fc-icon-chevrons-left",
nextYear: "fc-icon-chevrons-right"
};
StandardTheme.prototype.rtlIconClasses = {
prev: "fc-icon-chevron-right",
next: "fc-icon-chevron-left",
prevYear: "fc-icon-chevrons-right",
nextYear: "fc-icon-chevrons-left"
};
StandardTheme.prototype.iconOverrideOption = "buttonIcons";
StandardTheme.prototype.iconOverrideCustomButtonOption = "icon";
StandardTheme.prototype.iconOverridePrefix = "fc-icon-";
function compileViewDefs(defaultConfigs, overrideConfigs) {
let hash = {};
let viewType;
for (viewType in defaultConfigs) {
ensureViewDef(viewType, hash, defaultConfigs, overrideConfigs);
}
for (viewType in overrideConfigs) {
ensureViewDef(viewType, hash, defaultConfigs, overrideConfigs);
}
return hash;
}
function ensureViewDef(viewType, hash, defaultConfigs, overrideConfigs) {
if (hash[viewType]) {
return hash[viewType];
}
let viewDef = buildViewDef(viewType, hash, defaultConfigs, overrideConfigs);
if (viewDef) {
hash[viewType] = viewDef;
}
return viewDef;
}
function buildViewDef(viewType, hash, defaultConfigs, overrideConfigs) {
let defaultConfig = defaultConfigs[viewType];
let overrideConfig = overrideConfigs[viewType];
let queryProp = (name) => defaultConfig && defaultConfig[name] !== null ? defaultConfig[name] : overrideConfig && overrideConfig[name] !== null ? overrideConfig[name] : null;
let theComponent = queryProp("component");
let superType = queryProp("superType");
let superDef = null;
if (superType) {
if (superType === viewType) {
throw new Error("Can't have a custom view type that references itself");
}
superDef = ensureViewDef(superType, hash, defaultConfigs, overrideConfigs);
}
if (!theComponent && superDef) {
theComponent = superDef.component;
}
if (!theComponent) {
return null;
}
return {
type: viewType,
component: theComponent,
defaults: Object.assign(Object.assign({}, superDef ? superDef.defaults : {}), defaultConfig ? defaultConfig.rawOptions : {}),
overrides: Object.assign(Object.assign({}, superDef ? superDef.overrides : {}), overrideConfig ? overrideConfig.rawOptions : {})
};
}
function parseViewConfigs(inputs) {
return mapHash(inputs, parseViewConfig);
}
function parseViewConfig(input) {
let rawOptions = typeof input === "function" ? { component: input } : input;
let { component } = rawOptions;
if (rawOptions.content) {
component = createViewHookComponent(rawOptions);
} else if (component && !(component.prototype instanceof BaseComponent)) {
component = createViewHookComponent(Object.assign(Object.assign({}, rawOptions), { content: component }));
}
return {
superType: rawOptions.type,
component,
rawOptions
// includes type and component too :(
};
}
function createViewHookComponent(options) {
return (viewProps) => y(ViewContextType.Consumer, null, (context) => y(ContentContainer, { elTag: "div", elClasses: buildViewClassNames(context.viewSpec), renderProps: Object.assign(Object.assign({}, viewProps), { nextDayThreshold: context.options.nextDayThreshold }), generatorName: void 0, customGenerator: options.content, classNameGenerator: options.classNames, didMount: options.didMount, willUnmount: options.willUnmount }));
}
function buildViewSpecs(defaultInputs, optionOverrides, dynamicOptionOverrides, localeDefaults) {
let defaultConfigs = parseViewConfigs(defaultInputs);
let overrideConfigs = parseViewConfigs(optionOverrides.views);
let viewDefs = compileViewDefs(defaultConfigs, overrideConfigs);
return mapHash(viewDefs, (viewDef) => buildViewSpec(viewDef, overrideConfigs, optionOverrides, dynamicOptionOverrides, localeDefaults));
}
function buildViewSpec(viewDef, overrideConfigs, optionOverrides, dynamicOptionOverrides, localeDefaults) {
let durationInput = viewDef.overrides.duration || viewDef.defaults.duration || dynamicOptionOverrides.duration || optionOverrides.duration;
let duration = null;
let durationUnit = "";
let singleUnit = "";
let singleUnitOverrides = {};
if (durationInput) {
duration = createDurationCached(durationInput);
if (duration) {
let denom = greatestDurationDenominator(duration);
durationUnit = denom.unit;
if (denom.value === 1) {
singleUnit = durationUnit;
singleUnitOverrides = overrideConfigs[durationUnit] ? overrideConfigs[durationUnit].rawOptions : {};
}
}
}
let queryButtonText = (optionsSubset) => {
let buttonTextMap = optionsSubset.buttonText || {};
let buttonTextKey = viewDef.defaults.buttonTextKey;
if (buttonTextKey != null && buttonTextMap[buttonTextKey] != null) {
return buttonTextMap[buttonTextKey];
}
if (buttonTextMap[viewDef.type] != null) {
return buttonTextMap[viewDef.type];
}
if (buttonTextMap[singleUnit] != null) {
return buttonTextMap[singleUnit];
}
return null;
};
let queryButtonTitle = (optionsSubset) => {
let buttonHints = optionsSubset.buttonHints || {};
let buttonKey = viewDef.defaults.buttonTextKey;
if (buttonKey != null && buttonHints[buttonKey] != null) {
return buttonHints[buttonKey];
}
if (buttonHints[viewDef.type] != null) {
return buttonHints[viewDef.type];
}
if (buttonHints[singleUnit] != null) {
return buttonHints[singleUnit];
}
return null;
};
return {
type: viewDef.type,
component: viewDef.component,
duration,
durationUnit,
singleUnit,
optionDefaults: viewDef.defaults,
optionOverrides: Object.assign(Object.assign({}, singleUnitOverrides), viewDef.overrides),
buttonTextOverride: queryButtonText(dynamicOptionOverrides) || queryButtonText(optionOverrides) || // constructor-specified buttonText lookup hash takes precedence
viewDef.overrides.buttonText,
buttonTextDefault: queryButtonText(localeDefaults) || viewDef.defaults.buttonText || queryButtonText(BASE_OPTION_DEFAULTS) || viewDef.type,
// not DRY
buttonTitleOverride: queryButtonTitle(dynamicOptionOverrides) || queryButtonTitle(optionOverrides) || viewDef.overrides.buttonHint,
buttonTitleDefault: queryButtonTitle(localeDefaults) || viewDef.defaults.buttonHint || queryButtonTitle(BASE_OPTION_DEFAULTS)
// will eventually fall back to buttonText
};
}
var durationInputMap = {};
function createDurationCached(durationInput) {
let json = JSON.stringify(durationInput);
let res = durationInputMap[json];
if (res === void 0) {
res = createDuration(durationInput);
durationInputMap[json] = res;
}
return res;
}
function reduceViewType(viewType, action) {
switch (action.type) {
case "CHANGE_VIEW_TYPE":
viewType = action.viewType;
}
return viewType;
}
function reduceCurrentDate(currentDate, action) {
switch (action.type) {
case "CHANGE_DATE":
return action.dateMarker;
default:
return currentDate;
}
}
function getInitialDate(options, dateEnv, nowManager) {
let initialDateInput = options.initialDate;
if (initialDateInput != null) {
return dateEnv.createMarker(initialDateInput);
}
return nowManager.getDateMarker();
}
function reduceDynamicOptionOverrides(dynamicOptionOverrides, action) {
switch (action.type) {
case "SET_OPTION":
return Object.assign(Object.assign({}, dynamicOptionOverrides), { [action.optionName]: action.rawOptionValue });
default:
return dynamicOptionOverrides;
}
}
function reduceDateProfile(currentDateProfile, action, currentDate, dateProfileGenerator) {
let dp;
switch (action.type) {
case "CHANGE_VIEW_TYPE":
return dateProfileGenerator.build(action.dateMarker || currentDate);
case "CHANGE_DATE":
return dateProfileGenerator.build(action.dateMarker);
case "PREV":
dp = dateProfileGenerator.buildPrev(currentDateProfile, currentDate);
if (dp.isValid) {
return dp;
}
break;
case "NEXT":
dp = dateProfileGenerator.buildNext(currentDateProfile, currentDate);
if (dp.isValid) {
return dp;
}
break;
}
return currentDateProfile;
}
function initEventSources(calendarOptions, dateProfile, context) {
let activeRange = dateProfile ? dateProfile.activeRange : null;
return addSources({}, parseInitialSources(calendarOptions, context), activeRange, context);
}
function reduceEventSources(eventSources, action, dateProfile, context) {
let activeRange = dateProfile ? dateProfile.activeRange : null;
switch (action.type) {
case "ADD_EVENT_SOURCES":
return addSources(eventSources, action.sources, activeRange, context);
case "REMOVE_EVENT_SOURCE":
return removeSource(eventSources, action.sourceId);
case "PREV":
// TODO: how do we track all actions that affect dateProfile :(
case "NEXT":
case "CHANGE_DATE":
case "CHANGE_VIEW_TYPE":
if (dateProfile) {
return fetchDirtySources(eventSources, activeRange, context);
}
return eventSources;
case "FETCH_EVENT_SOURCES":
return fetchSourcesByIds(eventSources, action.sourceIds ? (
// why no type?
arrayToHash(action.sourceIds)
) : excludeStaticSources(eventSources, context), activeRange, action.isRefetch || false, context);
case "RECEIVE_EVENTS":
case "RECEIVE_EVENT_ERROR":
return receiveResponse(eventSources, action.sourceId, action.fetchId, action.fetchRange);
case "REMOVE_ALL_EVENT_SOURCES":
return {};
default:
return eventSources;
}
}
function reduceEventSourcesNewTimeZone(eventSources, dateProfile, context) {
let activeRange = dateProfile ? dateProfile.activeRange : null;
return fetchSourcesByIds(eventSources, excludeStaticSources(eventSources, context), activeRange, true, context);
}
function computeEventSourcesLoading(eventSources) {
for (let sourceId in eventSources) {
if (eventSources[sourceId].isFetching) {
return true;
}
}
return false;
}
function addSources(eventSourceHash, sources, fetchRange, context) {
let hash = {};
for (let source of sources) {
hash[source.sourceId] = source;
}
if (fetchRange) {
hash = fetchDirtySources(hash, fetchRange, context);
}
return Object.assign(Object.assign({}, eventSourceHash), hash);
}
function removeSource(eventSourceHash, sourceId) {
return filterHash(eventSourceHash, (eventSource) => eventSource.sourceId !== sourceId);
}
function fetchDirtySources(sourceHash, fetchRange, context) {
return fetchSourcesByIds(sourceHash, filterHash(sourceHash, (eventSource) => isSourceDirty(eventSource, fetchRange, context)), fetchRange, false, context);
}
function isSourceDirty(eventSource, fetchRange, context) {
if (!doesSourceNeedRange(eventSource, context)) {
return !eventSource.latestFetchId;
}
return !context.options.lazyFetching || !eventSource.fetchRange || eventSource.isFetching || // always cancel outdated in-progress fetches
fetchRange.start < eventSource.fetchRange.start || fetchRange.end > eventSource.fetchRange.end;
}
function fetchSourcesByIds(prevSources, sourceIdHash, fetchRange, isRefetch, context) {
let nextSources = {};
for (let sourceId in prevSources) {
let source = prevSources[sourceId];
if (sourceIdHash[sourceId]) {
nextSources[sourceId] = fetchSource(source, fetchRange, isRefetch, context);
} else {
nextSources[sourceId] = source;
}
}
return nextSources;
}
function fetchSource(eventSource, fetchRange, isRefetch, context) {
let { options, calendarApi } = context;
let sourceDef = context.pluginHooks.eventSourceDefs[eventSource.sourceDefId];
let fetchId = guid();
sourceDef.fetch({
eventSource,
range: fetchRange,
isRefetch,
context
}, (res) => {
let { rawEvents } = res;
if (options.eventSourceSuccess) {
rawEvents = options.eventSourceSuccess.call(calendarApi, rawEvents, res.response) || rawEvents;
}
if (eventSource.success) {
rawEvents = eventSource.success.call(calendarApi, rawEvents, res.response) || rawEvents;
}
context.dispatch({
type: "RECEIVE_EVENTS",
sourceId: eventSource.sourceId,
fetchId,
fetchRange,
rawEvents
});
}, (error) => {
let errorHandled = false;
if (options.eventSourceFailure) {
options.eventSourceFailure.call(calendarApi, error);
errorHandled = true;
}
if (eventSource.failure) {
eventSource.failure(error);
errorHandled = true;
}
if (!errorHandled) {
console.warn(error.message, error);
}
context.dispatch({
type: "RECEIVE_EVENT_ERROR",
sourceId: eventSource.sourceId,
fetchId,
fetchRange,
error
});
});
return Object.assign(Object.assign({}, eventSource), { isFetching: true, latestFetchId: fetchId });
}
function receiveResponse(sourceHash, sourceId, fetchId, fetchRange) {
let eventSource = sourceHash[sourceId];
if (eventSource && // not already removed
fetchId === eventSource.latestFetchId) {
return Object.assign(Object.assign({}, sourceHash), { [sourceId]: Object.assign(Object.assign({}, eventSource), { isFetching: false, fetchRange }) });
}
return sourceHash;
}
function excludeStaticSources(eventSources, context) {
return filterHash(eventSources, (eventSource) => doesSourceNeedRange(eventSource, context));
}
function parseInitialSources(rawOptions, context) {
let refiners = buildEventSourceRefiners(context);
let rawSources = [].concat(rawOptions.eventSources || []);
let sources = [];
if (rawOptions.initialEvents) {
rawSources.unshift(rawOptions.initialEvents);
}
if (rawOptions.events) {
rawSources.unshift(rawOptions.events);
}
for (let rawSource of rawSources) {
let source = parseEventSource(rawSource, context, refiners);
if (source) {
sources.push(source);
}
}
return sources;
}
function doesSourceNeedRange(eventSource, context) {
let defs = context.pluginHooks.eventSourceDefs;
return !defs[eventSource.sourceDefId].ignoreRange;
}
function reduceDateSelection(currentSelection, action) {
switch (action.type) {
case "UNSELECT_DATES":
return null;
case "SELECT_DATES":
return action.selection;
default:
return currentSelection;
}
}
function reduceSelectedEvent(currentInstanceId, action) {
switch (action.type) {
case "UNSELECT_EVENT":
return "";
case "SELECT_EVENT":
return action.eventInstanceId;
default:
return currentInstanceId;
}
}
function reduceEventDrag(currentDrag, action) {
let newDrag;
switch (action.type) {
case "UNSET_EVENT_DRAG":
return null;
case "SET_EVENT_DRAG":
newDrag = action.state;
return {
affectedEvents: newDrag.affectedEvents,
mutatedEvents: newDrag.mutatedEvents,
isEvent: newDrag.isEvent
};
default:
return currentDrag;
}
}
function reduceEventResize(currentResize, action) {
let newResize;
switch (action.type) {
case "UNSET_EVENT_RESIZE":
return null;
case "SET_EVENT_RESIZE":
newResize = action.state;
return {
affectedEvents: newResize.affectedEvents,
mutatedEvents: newResize.mutatedEvents,
isEvent: newResize.isEvent
};
default:
return currentResize;
}
}
function parseToolbars(calendarOptions, calendarOptionOverrides, theme, viewSpecs, calendarApi) {
let header = calendarOptions.headerToolbar ? parseToolbar(calendarOptions.headerToolbar, calendarOptions, calendarOptionOverrides, theme, viewSpecs, calendarApi) : null;
let footer = calendarOptions.footerToolbar ? parseToolbar(calendarOptions.footerToolbar, calendarOptions, calendarOptionOverrides, theme, viewSpecs, calendarApi) : null;
return { header, footer };
}
function parseToolbar(sectionStrHash, calendarOptions, calendarOptionOverrides, theme, viewSpecs, calendarApi) {
let sectionWidgets = {};
let viewsWithButtons = [];
let hasTitle = false;
for (let sectionName in sectionStrHash) {
let sectionStr = sectionStrHash[sectionName];
let sectionRes = parseSection(sectionStr, calendarOptions, calendarOptionOverrides, theme, viewSpecs, calendarApi);
sectionWidgets[sectionName] = sectionRes.widgets;
viewsWithButtons.push(...sectionRes.viewsWithButtons);
hasTitle = hasTitle || sectionRes.hasTitle;
}
return { sectionWidgets, viewsWithButtons, hasTitle };
}
function parseSection(sectionStr, calendarOptions, calendarOptionOverrides, theme, viewSpecs, calendarApi) {
let isRtl = calendarOptions.direction === "rtl";
let calendarCustomButtons = calendarOptions.customButtons || {};
let calendarButtonTextOverrides = calendarOptionOverrides.buttonText || {};
let calendarButtonText = calendarOptions.buttonText || {};
let calendarButtonHintOverrides = calendarOptionOverrides.buttonHints || {};
let calendarButtonHints = calendarOptions.buttonHints || {};
let sectionSubstrs = sectionStr ? sectionStr.split(" ") : [];
let viewsWithButtons = [];
let hasTitle = false;
let widgets = sectionSubstrs.map((buttonGroupStr) => buttonGroupStr.split(",").map((buttonName) => {
if (buttonName === "title") {
hasTitle = true;
return { buttonName };
}
let customButtonProps;
let viewSpec;
let buttonClick;
let buttonIcon;
let buttonText;
let buttonHint;
if (customButtonProps = calendarCustomButtons[buttonName]) {
buttonClick = (ev) => {
if (customButtonProps.click) {
customButtonProps.click.call(ev.target, ev, ev.target);
}
};
(buttonIcon = theme.getCustomButtonIconClass(customButtonProps)) || (buttonIcon = theme.getIconClass(buttonName, isRtl)) || (buttonText = customButtonProps.text);
buttonHint = customButtonProps.hint || customButtonProps.text;
} else if (viewSpec = viewSpecs[buttonName]) {
viewsWithButtons.push(buttonName);
buttonClick = () => {
calendarApi.changeView(buttonName);
};
(buttonText = viewSpec.buttonTextOverride) || (buttonIcon = theme.getIconClass(buttonName, isRtl)) || (buttonText = viewSpec.buttonTextDefault);
let textFallback = viewSpec.buttonTextOverride || viewSpec.buttonTextDefault;
buttonHint = formatWithOrdinals(
viewSpec.buttonTitleOverride || viewSpec.buttonTitleDefault || calendarOptions.viewHint,
[textFallback, buttonName],
// view-name = buttonName
textFallback
);
} else if (calendarApi[buttonName]) {
buttonClick = () => {
calendarApi[buttonName]();
};
(buttonText = calendarButtonTextOverrides[buttonName]) || (buttonIcon = theme.getIconClass(buttonName, isRtl)) || (buttonText = calendarButtonText[buttonName]);
if (buttonName === "prevYear" || buttonName === "nextYear") {
let prevOrNext = buttonName === "prevYear" ? "prev" : "next";
buttonHint = formatWithOrdinals(calendarButtonHintOverrides[prevOrNext] || calendarButtonHints[prevOrNext], [
calendarButtonText.year || "year",
"year"
], calendarButtonText[buttonName]);
} else {
buttonHint = (navUnit) => formatWithOrdinals(calendarButtonHintOverrides[buttonName] || calendarButtonHints[buttonName], [
calendarButtonText[navUnit] || navUnit,
navUnit
], calendarButtonText[buttonName]);
}
}
return { buttonName, buttonClick, buttonIcon, buttonText, buttonHint };
}));
return { widgets, viewsWithButtons, hasTitle };
}
var ViewImpl = class {
constructor(type, getCurrentData, dateEnv) {
this.type = type;
this.getCurrentData = getCurrentData;
this.dateEnv = dateEnv;
}
get calendar() {
return this.getCurrentData().calendarApi;
}
get title() {
return this.getCurrentData().viewTitle;
}
get activeStart() {
return this.dateEnv.toDate(this.getCurrentData().dateProfile.activeRange.start);
}
get activeEnd() {
return this.dateEnv.toDate(this.getCurrentData().dateProfile.activeRange.end);
}
get currentStart() {
return this.dateEnv.toDate(this.getCurrentData().dateProfile.currentRange.start);
}
get currentEnd() {
return this.dateEnv.toDate(this.getCurrentData().dateProfile.currentRange.end);
}
getOption(name) {
return this.getCurrentData().options[name];
}
};
var eventSourceDef$2 = {
ignoreRange: true,
parseMeta(refined) {
if (Array.isArray(refined.events)) {
return refined.events;
}
return null;
},
fetch(arg, successCallback) {
successCallback({
rawEvents: arg.eventSource.meta
});
}
};
var arrayEventSourcePlugin = createPlugin({
name: "array-event-source",
eventSourceDefs: [eventSourceDef$2]
});
var eventSourceDef$1 = {
parseMeta(refined) {
if (typeof refined.events === "function") {
return refined.events;
}
return null;
},
fetch(arg, successCallback, errorCallback) {
const { dateEnv } = arg.context;
const func = arg.eventSource.meta;
unpromisify(func.bind(null, buildRangeApiWithTimeZone(arg.range, dateEnv)), (rawEvents) => successCallback({ rawEvents }), errorCallback);
}
};
var funcEventSourcePlugin = createPlugin({
name: "func-event-source",
eventSourceDefs: [eventSourceDef$1]
});
var JSON_FEED_EVENT_SOURCE_REFINERS = {
method: String,
extraParams: identity,
startParam: String,
endParam: String,
timeZoneParam: String
};
var eventSourceDef = {
parseMeta(refined) {
if (refined.url && (refined.format === "json" || !refined.format)) {
return {
url: refined.url,
format: "json",
method: (refined.method || "GET").toUpperCase(),
extraParams: refined.extraParams,
startParam: refined.startParam,
endParam: refined.endParam,
timeZoneParam: refined.timeZoneParam
};
}
return null;
},
fetch(arg, successCallback, errorCallback) {
const { meta } = arg.eventSource;
const requestParams = buildRequestParams(meta, arg.range, arg.context);
requestJson(meta.method, meta.url, requestParams).then(([rawEvents, response]) => {
successCallback({ rawEvents, response });
}, errorCallback);
}
};
var jsonFeedEventSourcePlugin = createPlugin({
name: "json-event-source",
eventSourceRefiners: JSON_FEED_EVENT_SOURCE_REFINERS,
eventSourceDefs: [eventSourceDef]
});
function buildRequestParams(meta, range, context) {
let { dateEnv, options } = context;
let startParam;
let endParam;
let timeZoneParam;
let customRequestParams;
let params = {};
startParam = meta.startParam;
if (startParam == null) {
startParam = options.startParam;
}
endParam = meta.endParam;
if (endParam == null) {
endParam = options.endParam;
}
timeZoneParam = meta.timeZoneParam;
if (timeZoneParam == null) {
timeZoneParam = options.timeZoneParam;
}
if (typeof meta.extraParams === "function") {
customRequestParams = meta.extraParams();
} else {
customRequestParams = meta.extraParams || {};
}
Object.assign(params, customRequestParams);
params[startParam] = dateEnv.formatIso(range.start);
params[endParam] = dateEnv.formatIso(range.end);
if (dateEnv.timeZone !== "local") {
params[timeZoneParam] = dateEnv.timeZone;
}
return params;
}
var SIMPLE_RECURRING_REFINERS = {
daysOfWeek: identity,
startTime: createDuration,
endTime: createDuration,
duration: createDuration,
startRecur: identity,
endRecur: identity
};
var recurring = {
parse(refined, dateEnv) {
if (refined.daysOfWeek || refined.startTime || refined.endTime || refined.startRecur || refined.endRecur) {
let recurringData = {
daysOfWeek: refined.daysOfWeek || null,
startTime: refined.startTime || null,
endTime: refined.endTime || null,
startRecur: refined.startRecur ? dateEnv.createMarker(refined.startRecur) : null,
endRecur: refined.endRecur ? dateEnv.createMarker(refined.endRecur) : null,
dateEnv
};
let duration;
if (refined.duration) {
duration = refined.duration;
}
if (!duration && refined.startTime && refined.endTime) {
duration = subtractDurations(refined.endTime, refined.startTime);
}
return {
allDayGuess: Boolean(!refined.startTime && !refined.endTime),
duration,
typeData: recurringData
// doesn't need endTime anymore but oh well
};
}
return null;
},
expand(typeData, framingRange, dateEnv) {
let clippedFramingRange = intersectRanges(framingRange, { start: typeData.startRecur, end: typeData.endRecur });
if (clippedFramingRange) {
return expandRanges(typeData.daysOfWeek, typeData.startTime, typeData.dateEnv, dateEnv, clippedFramingRange);
}
return [];
}
};
var simpleRecurringEventsPlugin = createPlugin({
name: "simple-recurring-event",
recurringTypes: [recurring],
eventRefiners: SIMPLE_RECURRING_REFINERS
});
function expandRanges(daysOfWeek, startTime, eventDateEnv, calendarDateEnv, framingRange) {
let dowHash = daysOfWeek ? arrayToHash(daysOfWeek) : null;
let dayMarker = startOfDay(framingRange.start);
let endMarker = framingRange.end;
let instanceStarts = [];
while (dayMarker < endMarker) {
let instanceStart;
if (!dowHash || dowHash[dayMarker.getUTCDay()]) {
if (startTime) {
instanceStart = calendarDateEnv.add(dayMarker, startTime);
} else {
instanceStart = dayMarker;
}
instanceStarts.push(calendarDateEnv.createMarker(eventDateEnv.toDate(instanceStart)));
}
dayMarker = addDays(dayMarker, 1);
}
return instanceStarts;
}
var changeHandlerPlugin = createPlugin({
name: "change-handler",
optionChangeHandlers: {
events(events, context) {
handleEventSources([events], context);
},
eventSources: handleEventSources
}
});
function handleEventSources(inputs, context) {
let unfoundSources = hashValuesToArray(context.getCurrentData().eventSources);
if (unfoundSources.length === 1 && inputs.length === 1 && Array.isArray(unfoundSources[0]._raw) && Array.isArray(inputs[0])) {
context.dispatch({
type: "RESET_RAW_EVENTS",
sourceId: unfoundSources[0].sourceId,
rawEvents: inputs[0]
});
return;
}
let newInputs = [];
for (let input of inputs) {
let inputFound = false;
for (let i3 = 0; i3 < unfoundSources.length; i3 += 1) {
if (unfoundSources[i3]._raw === input) {
unfoundSources.splice(i3, 1);
inputFound = true;
break;
}
}
if (!inputFound) {
newInputs.push(input);
}
}
for (let unfoundSource of unfoundSources) {
context.dispatch({
type: "REMOVE_EVENT_SOURCE",
sourceId: unfoundSource.sourceId
});
}
for (let newInput of newInputs) {
context.calendarApi.addEventSource(newInput);
}
}
function handleDateProfile(dateProfile, context) {
context.emitter.trigger("datesSet", Object.assign(Object.assign({}, buildRangeApiWithTimeZone(dateProfile.activeRange, context.dateEnv)), { view: context.viewApi }));
}
function handleEventStore(eventStore, context) {
let { emitter } = context;
if (emitter.hasHandlers("eventsSet")) {
emitter.trigger("eventsSet", buildEventApis(eventStore, context));
}
}
var globalPlugins = [
arrayEventSourcePlugin,
funcEventSourcePlugin,
jsonFeedEventSourcePlugin,
simpleRecurringEventsPlugin,
changeHandlerPlugin,
createPlugin({
name: "misc",
isLoadingFuncs: [
(state) => computeEventSourcesLoading(state.eventSources)
],
propSetHandlers: {
dateProfile: handleDateProfile,
eventStore: handleEventStore
}
})
];
var TaskRunner = class {
constructor(runTaskOption, drainedOption) {
this.runTaskOption = runTaskOption;
this.drainedOption = drainedOption;
this.queue = [];
this.delayedRunner = new DelayedRunner(this.drain.bind(this));
}
request(task, delay) {
this.queue.push(task);
this.delayedRunner.request(delay);
}
pause(scope) {
this.delayedRunner.pause(scope);
}
resume(scope, force) {
this.delayedRunner.resume(scope, force);
}
drain() {
let { queue } = this;
while (queue.length) {
let completedTasks = [];
let task;
while (task = queue.shift()) {
this.runTask(task);
completedTasks.push(task);
}
this.drained(completedTasks);
}
}
runTask(task) {
if (this.runTaskOption) {
this.runTaskOption(task);
}
}
drained(completedTasks) {
if (this.drainedOption) {
this.drainedOption(completedTasks);
}
}
};
function buildTitle(dateProfile, viewOptions, dateEnv) {
let range;
if (/^(year|month)$/.test(dateProfile.currentRangeUnit)) {
range = dateProfile.currentRange;
} else {
range = dateProfile.activeRange;
}
return dateEnv.formatRange(range.start, range.end, createFormatter(viewOptions.titleFormat || buildTitleFormat(dateProfile)), {
isEndExclusive: dateProfile.isRangeAllDay,
defaultSeparator: viewOptions.titleRangeSeparator
});
}
function buildTitleFormat(dateProfile) {
let { currentRangeUnit } = dateProfile;
if (currentRangeUnit === "year") {
return { year: "numeric" };
}
if (currentRangeUnit === "month") {
return { year: "numeric", month: "long" };
}
let days = diffWholeDays(dateProfile.currentRange.start, dateProfile.currentRange.end);
if (days !== null && days > 1) {
return { year: "numeric", month: "short", day: "numeric" };
}
return { year: "numeric", month: "long", day: "numeric" };
}
var CalendarNowManager = class {
constructor() {
this.resetListeners = /* @__PURE__ */ new Set();
}
handleInput(dateEnv, nowInput) {
const oldDateEnv = this.dateEnv;
if (dateEnv !== oldDateEnv) {
if (typeof nowInput === "function") {
this.nowFn = nowInput;
} else if (!oldDateEnv) {
this.nowAnchorDate = dateEnv.toDate(nowInput ? dateEnv.createMarker(nowInput) : dateEnv.createNowMarker());
this.nowAnchorQueried = Date.now();
}
this.dateEnv = dateEnv;
if (oldDateEnv) {
for (const resetListener of this.resetListeners.values()) {
resetListener();
}
}
}
}
getDateMarker() {
return this.nowAnchorDate ? this.dateEnv.timestampToMarker(this.nowAnchorDate.valueOf() + (Date.now() - this.nowAnchorQueried)) : this.dateEnv.createMarker(this.nowFn());
}
addResetListener(handler) {
this.resetListeners.add(handler);
}
removeResetListener(handler) {
this.resetListeners.delete(handler);
}
};
var CalendarDataManager = class {
constructor(props) {
this.computeCurrentViewData = memoize(this._computeCurrentViewData);
this.organizeRawLocales = memoize(organizeRawLocales);
this.buildLocale = memoize(buildLocale);
this.buildPluginHooks = buildBuildPluginHooks();
this.buildDateEnv = memoize(buildDateEnv$1);
this.buildTheme = memoize(buildTheme);
this.parseToolbars = memoize(parseToolbars);
this.buildViewSpecs = memoize(buildViewSpecs);
this.buildDateProfileGenerator = memoizeObjArg(buildDateProfileGenerator);
this.buildViewApi = memoize(buildViewApi);
this.buildViewUiProps = memoizeObjArg(buildViewUiProps);
this.buildEventUiBySource = memoize(buildEventUiBySource, isPropsEqual);
this.buildEventUiBases = memoize(buildEventUiBases);
this.parseContextBusinessHours = memoizeObjArg(parseContextBusinessHours);
this.buildTitle = memoize(buildTitle);
this.nowManager = new CalendarNowManager();
this.emitter = new Emitter();
this.actionRunner = new TaskRunner(this._handleAction.bind(this), this.updateData.bind(this));
this.currentCalendarOptionsInput = {};
this.currentCalendarOptionsRefined = {};
this.currentViewOptionsInput = {};
this.currentViewOptionsRefined = {};
this.currentCalendarOptionsRefiners = {};
this.optionsForRefining = [];
this.optionsForHandling = [];
this.getCurrentData = () => this.data;
this.dispatch = (action) => {
this.actionRunner.request(action);
};
this.props = props;
this.actionRunner.pause();
this.nowManager = new CalendarNowManager();
let dynamicOptionOverrides = {};
let optionsData = this.computeOptionsData(props.optionOverrides, dynamicOptionOverrides, props.calendarApi);
let currentViewType = optionsData.calendarOptions.initialView || optionsData.pluginHooks.initialView;
let currentViewData = this.computeCurrentViewData(currentViewType, optionsData, props.optionOverrides, dynamicOptionOverrides);
props.calendarApi.currentDataManager = this;
this.emitter.setThisContext(props.calendarApi);
this.emitter.setOptions(currentViewData.options);
let calendarContext = {
nowManager: this.nowManager,
dateEnv: optionsData.dateEnv,
options: optionsData.calendarOptions,
pluginHooks: optionsData.pluginHooks,
calendarApi: props.calendarApi,
dispatch: this.dispatch,
emitter: this.emitter,
getCurrentData: this.getCurrentData
};
let currentDate = getInitialDate(optionsData.calendarOptions, optionsData.dateEnv, this.nowManager);
let dateProfile = currentViewData.dateProfileGenerator.build(currentDate);
if (!rangeContainsMarker(dateProfile.activeRange, currentDate)) {
currentDate = dateProfile.currentRange.start;
}
for (let callback of optionsData.pluginHooks.contextInit) {
callback(calendarContext);
}
let eventSources = initEventSources(optionsData.calendarOptions, dateProfile, calendarContext);
let initialState = {
dynamicOptionOverrides,
currentViewType,
currentDate,
dateProfile,
businessHours: this.parseContextBusinessHours(calendarContext),
eventSources,
eventUiBases: {},
eventStore: createEmptyEventStore(),
renderableEventStore: createEmptyEventStore(),
dateSelection: null,
eventSelection: "",
eventDrag: null,
eventResize: null,
selectionConfig: this.buildViewUiProps(calendarContext).selectionConfig
};
let contextAndState = Object.assign(Object.assign({}, calendarContext), initialState);
for (let reducer of optionsData.pluginHooks.reducers) {
Object.assign(initialState, reducer(null, null, contextAndState));
}
if (computeIsLoading(initialState, calendarContext)) {
this.emitter.trigger("loading", true);
}
this.state = initialState;
this.updateData();
this.actionRunner.resume();
}
resetOptions(optionOverrides, changedOptionNames) {
let { props } = this;
if (changedOptionNames === void 0) {
props.optionOverrides = optionOverrides;
} else {
props.optionOverrides = Object.assign(Object.assign({}, props.optionOverrides || {}), optionOverrides);
this.optionsForRefining.push(...changedOptionNames);
}
if (changedOptionNames === void 0 || changedOptionNames.length) {
this.actionRunner.request({
type: "NOTHING"
});
}
}
_handleAction(action) {
let { props, state, emitter } = this;
let dynamicOptionOverrides = reduceDynamicOptionOverrides(state.dynamicOptionOverrides, action);
let optionsData = this.computeOptionsData(props.optionOverrides, dynamicOptionOverrides, props.calendarApi);
let currentViewType = reduceViewType(state.currentViewType, action);
let currentViewData = this.computeCurrentViewData(currentViewType, optionsData, props.optionOverrides, dynamicOptionOverrides);
props.calendarApi.currentDataManager = this;
emitter.setThisContext(props.calendarApi);
emitter.setOptions(currentViewData.options);
let calendarContext = {
nowManager: this.nowManager,
dateEnv: optionsData.dateEnv,
options: optionsData.calendarOptions,
pluginHooks: optionsData.pluginHooks,
calendarApi: props.calendarApi,
dispatch: this.dispatch,
emitter,
getCurrentData: this.getCurrentData
};
let { currentDate, dateProfile } = state;
if (this.data && this.data.dateProfileGenerator !== currentViewData.dateProfileGenerator) {
dateProfile = currentViewData.dateProfileGenerator.build(currentDate);
}
currentDate = reduceCurrentDate(currentDate, action);
dateProfile = reduceDateProfile(dateProfile, action, currentDate, currentViewData.dateProfileGenerator);
if (action.type === "PREV" || // TODO: move this logic into DateProfileGenerator
action.type === "NEXT" || // "
!rangeContainsMarker(dateProfile.currentRange, currentDate)) {
currentDate = dateProfile.currentRange.start;
}
let eventSources = reduceEventSources(state.eventSources, action, dateProfile, calendarContext);
let eventStore = reduceEventStore(state.eventStore, action, eventSources, dateProfile, calendarContext);
let isEventsLoading = computeEventSourcesLoading(eventSources);
let renderableEventStore = isEventsLoading && !currentViewData.options.progressiveEventRendering ? state.renderableEventStore || eventStore : (
// try from previous state
eventStore
);
let { eventUiSingleBase, selectionConfig } = this.buildViewUiProps(calendarContext);
let eventUiBySource = this.buildEventUiBySource(eventSources);
let eventUiBases = this.buildEventUiBases(renderableEventStore.defs, eventUiSingleBase, eventUiBySource);
let newState = {
dynamicOptionOverrides,
currentViewType,
currentDate,
dateProfile,
eventSources,
eventStore,
renderableEventStore,
selectionConfig,
eventUiBases,
businessHours: this.parseContextBusinessHours(calendarContext),
dateSelection: reduceDateSelection(state.dateSelection, action),
eventSelection: reduceSelectedEvent(state.eventSelection, action),
eventDrag: reduceEventDrag(state.eventDrag, action),
eventResize: reduceEventResize(state.eventResize, action)
};
let contextAndState = Object.assign(Object.assign({}, calendarContext), newState);
for (let reducer of optionsData.pluginHooks.reducers) {
Object.assign(newState, reducer(state, action, contextAndState));
}
let wasLoading = computeIsLoading(state, calendarContext);
let isLoading = computeIsLoading(newState, calendarContext);
if (!wasLoading && isLoading) {
emitter.trigger("loading", true);
} else if (wasLoading && !isLoading) {
emitter.trigger("loading", false);
}
this.state = newState;
if (props.onAction) {
props.onAction(action);
}
}
updateData() {
let { props, state } = this;
let oldData = this.data;
let optionsData = this.computeOptionsData(props.optionOverrides, state.dynamicOptionOverrides, props.calendarApi);
let currentViewData = this.computeCurrentViewData(state.currentViewType, optionsData, props.optionOverrides, state.dynamicOptionOverrides);
let data = this.data = Object.assign(Object.assign(Object.assign({ nowManager: this.nowManager, viewTitle: this.buildTitle(state.dateProfile, currentViewData.options, optionsData.dateEnv), calendarApi: props.calendarApi, dispatch: this.dispatch, emitter: this.emitter, getCurrentData: this.getCurrentData }, optionsData), currentViewData), state);
let changeHandlers = optionsData.pluginHooks.optionChangeHandlers;
let oldCalendarOptions = oldData && oldData.calendarOptions;
let newCalendarOptions = optionsData.calendarOptions;
if (oldCalendarOptions && oldCalendarOptions !== newCalendarOptions) {
if (oldCalendarOptions.timeZone !== newCalendarOptions.timeZone) {
state.eventSources = data.eventSources = reduceEventSourcesNewTimeZone(data.eventSources, state.dateProfile, data);
state.eventStore = data.eventStore = rezoneEventStoreDates(data.eventStore, oldData.dateEnv, data.dateEnv);
state.renderableEventStore = data.renderableEventStore = rezoneEventStoreDates(data.renderableEventStore, oldData.dateEnv, data.dateEnv);
}
for (let optionName in changeHandlers) {
if (this.optionsForHandling.indexOf(optionName) !== -1 || oldCalendarOptions[optionName] !== newCalendarOptions[optionName]) {
changeHandlers[optionName](newCalendarOptions[optionName], data);
}
}
}
this.optionsForHandling = [];
if (props.onData) {
props.onData(data);
}
}
computeOptionsData(optionOverrides, dynamicOptionOverrides, calendarApi) {
if (!this.optionsForRefining.length && optionOverrides === this.stableOptionOverrides && dynamicOptionOverrides === this.stableDynamicOptionOverrides) {
return this.stableCalendarOptionsData;
}
let { refinedOptions, pluginHooks, localeDefaults, availableLocaleData, extra } = this.processRawCalendarOptions(optionOverrides, dynamicOptionOverrides);
warnUnknownOptions(extra);
let dateEnv = this.buildDateEnv(refinedOptions.timeZone, refinedOptions.locale, refinedOptions.weekNumberCalculation, refinedOptions.firstDay, refinedOptions.weekText, pluginHooks, availableLocaleData, refinedOptions.defaultRangeSeparator);
let viewSpecs = this.buildViewSpecs(pluginHooks.views, this.stableOptionOverrides, this.stableDynamicOptionOverrides, localeDefaults);
let theme = this.buildTheme(refinedOptions, pluginHooks);
let toolbarConfig = this.parseToolbars(refinedOptions, this.stableOptionOverrides, theme, viewSpecs, calendarApi);
return this.stableCalendarOptionsData = {
calendarOptions: refinedOptions,
pluginHooks,
dateEnv,
viewSpecs,
theme,
toolbarConfig,
localeDefaults,
availableRawLocales: availableLocaleData.map
};
}
// always called from behind a memoizer
processRawCalendarOptions(optionOverrides, dynamicOptionOverrides) {
let { locales, locale } = mergeRawOptions([
BASE_OPTION_DEFAULTS,
optionOverrides,
dynamicOptionOverrides
]);
let availableLocaleData = this.organizeRawLocales(locales);
let availableRawLocales = availableLocaleData.map;
let localeDefaults = this.buildLocale(locale || availableLocaleData.defaultCode, availableRawLocales).options;
let pluginHooks = this.buildPluginHooks(optionOverrides.plugins || [], globalPlugins);
let refiners = this.currentCalendarOptionsRefiners = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, BASE_OPTION_REFINERS), CALENDAR_LISTENER_REFINERS), CALENDAR_OPTION_REFINERS), pluginHooks.listenerRefiners), pluginHooks.optionRefiners);
let extra = {};
let raw = mergeRawOptions([
BASE_OPTION_DEFAULTS,
localeDefaults,
optionOverrides,
dynamicOptionOverrides
]);
let refined = {};
let currentRaw = this.currentCalendarOptionsInput;
let currentRefined = this.currentCalendarOptionsRefined;
let anyChanges = false;
for (let optionName in raw) {
if (this.optionsForRefining.indexOf(optionName) === -1 && (raw[optionName] === currentRaw[optionName] || COMPLEX_OPTION_COMPARATORS[optionName] && optionName in currentRaw && COMPLEX_OPTION_COMPARATORS[optionName](currentRaw[optionName], raw[optionName]))) {
refined[optionName] = currentRefined[optionName];
} else if (refiners[optionName]) {
refined[optionName] = refiners[optionName](raw[optionName]);
anyChanges = true;
} else {
extra[optionName] = currentRaw[optionName];
}
}
if (anyChanges) {
this.currentCalendarOptionsInput = raw;
this.currentCalendarOptionsRefined = refined;
this.stableOptionOverrides = optionOverrides;
this.stableDynamicOptionOverrides = dynamicOptionOverrides;
}
this.optionsForHandling.push(...this.optionsForRefining);
this.optionsForRefining = [];
return {
rawOptions: this.currentCalendarOptionsInput,
refinedOptions: this.currentCalendarOptionsRefined,
pluginHooks,
availableLocaleData,
localeDefaults,
extra
};
}
_computeCurrentViewData(viewType, optionsData, optionOverrides, dynamicOptionOverrides) {
let viewSpec = optionsData.viewSpecs[viewType];
if (!viewSpec) {
throw new Error(`viewType "${viewType}" is not available. Please make sure you've loaded all neccessary plugins`);
}
let { refinedOptions, extra } = this.processRawViewOptions(viewSpec, optionsData.pluginHooks, optionsData.localeDefaults, optionOverrides, dynamicOptionOverrides);
warnUnknownOptions(extra);
this.nowManager.handleInput(optionsData.dateEnv, refinedOptions.now);
let dateProfileGenerator = this.buildDateProfileGenerator({
dateProfileGeneratorClass: viewSpec.optionDefaults.dateProfileGeneratorClass,
nowManager: this.nowManager,
duration: viewSpec.duration,
durationUnit: viewSpec.durationUnit,
usesMinMaxTime: viewSpec.optionDefaults.usesMinMaxTime,
dateEnv: optionsData.dateEnv,
calendarApi: this.props.calendarApi,
slotMinTime: refinedOptions.slotMinTime,
slotMaxTime: refinedOptions.slotMaxTime,
showNonCurrentDates: refinedOptions.showNonCurrentDates,
dayCount: refinedOptions.dayCount,
dateAlignment: refinedOptions.dateAlignment,
dateIncrement: refinedOptions.dateIncrement,
hiddenDays: refinedOptions.hiddenDays,
weekends: refinedOptions.weekends,
validRangeInput: refinedOptions.validRange,
visibleRangeInput: refinedOptions.visibleRange,
fixedWeekCount: refinedOptions.fixedWeekCount
});
let viewApi = this.buildViewApi(viewType, this.getCurrentData, optionsData.dateEnv);
return { viewSpec, options: refinedOptions, dateProfileGenerator, viewApi };
}
processRawViewOptions(viewSpec, pluginHooks, localeDefaults, optionOverrides, dynamicOptionOverrides) {
let raw = mergeRawOptions([
BASE_OPTION_DEFAULTS,
viewSpec.optionDefaults,
localeDefaults,
optionOverrides,
viewSpec.optionOverrides,
dynamicOptionOverrides
]);
let refiners = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, BASE_OPTION_REFINERS), CALENDAR_LISTENER_REFINERS), CALENDAR_OPTION_REFINERS), VIEW_OPTION_REFINERS), pluginHooks.listenerRefiners), pluginHooks.optionRefiners);
let refined = {};
let currentRaw = this.currentViewOptionsInput;
let currentRefined = this.currentViewOptionsRefined;
let anyChanges = false;
let extra = {};
for (let optionName in raw) {
if (raw[optionName] === currentRaw[optionName] || COMPLEX_OPTION_COMPARATORS[optionName] && COMPLEX_OPTION_COMPARATORS[optionName](raw[optionName], currentRaw[optionName])) {
refined[optionName] = currentRefined[optionName];
} else {
if (raw[optionName] === this.currentCalendarOptionsInput[optionName] || COMPLEX_OPTION_COMPARATORS[optionName] && COMPLEX_OPTION_COMPARATORS[optionName](raw[optionName], this.currentCalendarOptionsInput[optionName])) {
if (optionName in this.currentCalendarOptionsRefined) {
refined[optionName] = this.currentCalendarOptionsRefined[optionName];
}
} else if (refiners[optionName]) {
refined[optionName] = refiners[optionName](raw[optionName]);
} else {
extra[optionName] = raw[optionName];
}
anyChanges = true;
}
}
if (anyChanges) {
this.currentViewOptionsInput = raw;
this.currentViewOptionsRefined = refined;
}
return {
rawOptions: this.currentViewOptionsInput,
refinedOptions: this.currentViewOptionsRefined,
extra
};
}
};
function buildDateEnv$1(timeZone, explicitLocale, weekNumberCalculation, firstDay, weekText, pluginHooks, availableLocaleData, defaultSeparator) {
let locale = buildLocale(explicitLocale || availableLocaleData.defaultCode, availableLocaleData.map);
return new DateEnv({
calendarSystem: "gregory",
timeZone,
namedTimeZoneImpl: pluginHooks.namedTimeZonedImpl,
locale,
weekNumberCalculation,
firstDay,
weekText,
cmdFormatter: pluginHooks.cmdFormatter,
defaultSeparator
});
}
function buildTheme(options, pluginHooks) {
let ThemeClass = pluginHooks.themeClasses[options.themeSystem] || StandardTheme;
return new ThemeClass(options);
}
function buildDateProfileGenerator(props) {
let DateProfileGeneratorClass = props.dateProfileGeneratorClass || DateProfileGenerator;
return new DateProfileGeneratorClass(props);
}
function buildViewApi(type, getCurrentData, dateEnv) {
return new ViewImpl(type, getCurrentData, dateEnv);
}
function buildEventUiBySource(eventSources) {
return mapHash(eventSources, (eventSource) => eventSource.ui);
}
function buildEventUiBases(eventDefs, eventUiSingleBase, eventUiBySource) {
let eventUiBases = { "": eventUiSingleBase };
for (let defId in eventDefs) {
let def = eventDefs[defId];
if (def.sourceId && eventUiBySource[def.sourceId]) {
eventUiBases[defId] = eventUiBySource[def.sourceId];
}
}
return eventUiBases;
}
function buildViewUiProps(calendarContext) {
let { options } = calendarContext;
return {
eventUiSingleBase: createEventUi({
display: options.eventDisplay,
editable: options.editable,
startEditable: options.eventStartEditable,
durationEditable: options.eventDurationEditable,
constraint: options.eventConstraint,
overlap: typeof options.eventOverlap === "boolean" ? options.eventOverlap : void 0,
allow: options.eventAllow,
backgroundColor: options.eventBackgroundColor,
borderColor: options.eventBorderColor,
textColor: options.eventTextColor,
color: options.eventColor
// classNames: options.eventClassNames // render hook will handle this
}, calendarContext),
selectionConfig: createEventUi({
constraint: options.selectConstraint,
overlap: typeof options.selectOverlap === "boolean" ? options.selectOverlap : void 0,
allow: options.selectAllow
}, calendarContext)
};
}
function computeIsLoading(state, context) {
for (let isLoadingFunc of context.pluginHooks.isLoadingFuncs) {
if (isLoadingFunc(state)) {
return true;
}
}
return false;
}
function parseContextBusinessHours(calendarContext) {
return parseBusinessHours(calendarContext.options.businessHours, calendarContext);
}
function warnUnknownOptions(options, viewName) {
for (let optionName in options) {
console.warn(`Unknown option '${optionName}'` + (viewName ? ` for view '${viewName}'` : ""));
}
}
var ToolbarSection = class extends BaseComponent {
render() {
let children = this.props.widgetGroups.map((widgetGroup) => this.renderWidgetGroup(widgetGroup));
return y("div", { className: "fc-toolbar-chunk" }, ...children);
}
renderWidgetGroup(widgetGroup) {
let { props } = this;
let { theme } = this.context;
let children = [];
let isOnlyButtons = true;
for (let widget of widgetGroup) {
let { buttonName, buttonClick, buttonText, buttonIcon, buttonHint } = widget;
if (buttonName === "title") {
isOnlyButtons = false;
children.push(y("h2", { className: "fc-toolbar-title", id: props.titleId }, props.title));
} else {
let isPressed = buttonName === props.activeButton;
let isDisabled = !props.isTodayEnabled && buttonName === "today" || !props.isPrevEnabled && buttonName === "prev" || !props.isNextEnabled && buttonName === "next";
let buttonClasses = [`fc-${buttonName}-button`, theme.getClass("button")];
if (isPressed) {
buttonClasses.push(theme.getClass("buttonActive"));
}
children.push(y("button", { type: "button", title: typeof buttonHint === "function" ? buttonHint(props.navUnit) : buttonHint, disabled: isDisabled, "aria-pressed": isPressed, className: buttonClasses.join(" "), onClick: buttonClick }, buttonText || (buttonIcon ? y("span", { className: buttonIcon, role: "img" }) : "")));
}
}
if (children.length > 1) {
let groupClassName = isOnlyButtons && theme.getClass("buttonGroup") || "";
return y("div", { className: groupClassName }, ...children);
}
return children[0];
}
};
var Toolbar = class extends BaseComponent {
render() {
let { model, extraClassName } = this.props;
let forceLtr = false;
let startContent;
let endContent;
let sectionWidgets = model.sectionWidgets;
let centerContent = sectionWidgets.center;
if (sectionWidgets.left) {
forceLtr = true;
startContent = sectionWidgets.left;
} else {
startContent = sectionWidgets.start;
}
if (sectionWidgets.right) {
forceLtr = true;
endContent = sectionWidgets.right;
} else {
endContent = sectionWidgets.end;
}
let classNames = [
extraClassName || "",
"fc-toolbar",
forceLtr ? "fc-toolbar-ltr" : ""
];
return y(
"div",
{ className: classNames.join(" ") },
this.renderSection("start", startContent || []),
this.renderSection("center", centerContent || []),
this.renderSection("end", endContent || [])
);
}
renderSection(key, widgetGroups) {
let { props } = this;
return y(ToolbarSection, { key, widgetGroups, title: props.title, navUnit: props.navUnit, activeButton: props.activeButton, isTodayEnabled: props.isTodayEnabled, isPrevEnabled: props.isPrevEnabled, isNextEnabled: props.isNextEnabled, titleId: props.titleId });
}
};
var ViewHarness = class extends BaseComponent {
constructor() {
super(...arguments);
this.state = {
availableWidth: null
};
this.handleEl = (el) => {
this.el = el;
setRef(this.props.elRef, el);
this.updateAvailableWidth();
};
this.handleResize = () => {
this.updateAvailableWidth();
};
}
render() {
let { props, state } = this;
let { aspectRatio } = props;
let classNames = [
"fc-view-harness",
aspectRatio || props.liquid || props.height ? "fc-view-harness-active" : "fc-view-harness-passive"
// let the view do the height
];
let height = "";
let paddingBottom = "";
if (aspectRatio) {
if (state.availableWidth !== null) {
height = state.availableWidth / aspectRatio;
} else {
paddingBottom = `${1 / aspectRatio * 100}%`;
}
} else {
height = props.height || "";
}
return y("div", { "aria-labelledby": props.labeledById, ref: this.handleEl, className: classNames.join(" "), style: { height, paddingBottom } }, props.children);
}
componentDidMount() {
this.context.addResizeHandler(this.handleResize);
}
componentWillUnmount() {
this.context.removeResizeHandler(this.handleResize);
}
updateAvailableWidth() {
if (this.el && // needed. but why?
this.props.aspectRatio) {
this.setState({ availableWidth: this.el.offsetWidth });
}
}
};
var EventClicking = class extends Interaction {
constructor(settings) {
super(settings);
this.handleSegClick = (ev, segEl) => {
let { component } = this;
let { context } = component;
let seg = getElSeg(segEl);
if (seg && // might be the surrounding the more link
component.isValidSegDownEl(ev.target)) {
let hasUrlContainer = elementClosest(ev.target, ".fc-event-forced-url");
let url = hasUrlContainer ? hasUrlContainer.querySelector("a[href]").href : "";
context.emitter.trigger("eventClick", {
el: segEl,
event: new EventImpl(component.context, seg.eventRange.def, seg.eventRange.instance),
jsEvent: ev,
view: context.viewApi
});
if (url && !ev.defaultPrevented) {
window.location.href = url;
}
}
};
this.destroy = listenBySelector(
settings.el,
"click",
".fc-event",
// on both fg and bg events
this.handleSegClick
);
}
};
var EventHovering = class extends Interaction {
constructor(settings) {
super(settings);
this.handleEventElRemove = (el) => {
if (el === this.currentSegEl) {
this.handleSegLeave(null, this.currentSegEl);
}
};
this.handleSegEnter = (ev, segEl) => {
if (getElSeg(segEl)) {
this.currentSegEl = segEl;
this.triggerEvent("eventMouseEnter", ev, segEl);
}
};
this.handleSegLeave = (ev, segEl) => {
if (this.currentSegEl) {
this.currentSegEl = null;
this.triggerEvent("eventMouseLeave", ev, segEl);
}
};
this.removeHoverListeners = listenToHoverBySelector(
settings.el,
".fc-event",
// on both fg and bg events
this.handleSegEnter,
this.handleSegLeave
);
}
destroy() {
this.removeHoverListeners();
}
triggerEvent(publicEvName, ev, segEl) {
let { component } = this;
let { context } = component;
let seg = getElSeg(segEl);
if (!ev || component.isValidSegDownEl(ev.target)) {
context.emitter.trigger(publicEvName, {
el: segEl,
event: new EventImpl(context, seg.eventRange.def, seg.eventRange.instance),
jsEvent: ev,
view: context.viewApi
});
}
}
};
var CalendarContent = class extends PureComponent {
constructor() {
super(...arguments);
this.buildViewContext = memoize(buildViewContext);
this.buildViewPropTransformers = memoize(buildViewPropTransformers);
this.buildToolbarProps = memoize(buildToolbarProps);
this.headerRef = d();
this.footerRef = d();
this.interactionsStore = {};
this.state = {
viewLabelId: getUniqueDomId()
};
this.registerInteractiveComponent = (component, settingsInput) => {
let settings = parseInteractionSettings(component, settingsInput);
let DEFAULT_INTERACTIONS = [
EventClicking,
EventHovering
];
let interactionClasses = DEFAULT_INTERACTIONS.concat(this.props.pluginHooks.componentInteractions);
let interactions = interactionClasses.map((TheInteractionClass) => new TheInteractionClass(settings));
this.interactionsStore[component.uid] = interactions;
interactionSettingsStore[component.uid] = settings;
};
this.unregisterInteractiveComponent = (component) => {
let listeners = this.interactionsStore[component.uid];
if (listeners) {
for (let listener of listeners) {
listener.destroy();
}
delete this.interactionsStore[component.uid];
}
delete interactionSettingsStore[component.uid];
};
this.resizeRunner = new DelayedRunner(() => {
this.props.emitter.trigger("_resize", true);
this.props.emitter.trigger("windowResize", { view: this.props.viewApi });
});
this.handleWindowResize = (ev) => {
let { options } = this.props;
if (options.handleWindowResize && ev.target === window) {
this.resizeRunner.request(options.windowResizeDelay);
}
};
}
/*
renders INSIDE of an outer div
*/
render() {
let { props } = this;
let { toolbarConfig, options } = props;
let viewVGrow = false;
let viewHeight = "";
let viewAspectRatio;
if (props.isHeightAuto || props.forPrint) {
viewHeight = "";
} else if (options.height != null) {
viewVGrow = true;
} else if (options.contentHeight != null) {
viewHeight = options.contentHeight;
} else {
viewAspectRatio = Math.max(options.aspectRatio, 0.5);
}
let viewContext = this.buildViewContext(props.viewSpec, props.viewApi, props.options, props.dateProfileGenerator, props.dateEnv, props.nowManager, props.theme, props.pluginHooks, props.dispatch, props.getCurrentData, props.emitter, props.calendarApi, this.registerInteractiveComponent, this.unregisterInteractiveComponent);
let viewLabelId = toolbarConfig.header && toolbarConfig.header.hasTitle ? this.state.viewLabelId : void 0;
return y(
ViewContextType.Provider,
{ value: viewContext },
y(NowTimer, { unit: "day" }, (nowDate) => {
let toolbarProps = this.buildToolbarProps(props.viewSpec, props.dateProfile, props.dateProfileGenerator, props.currentDate, nowDate, props.viewTitle);
return y(
_,
null,
toolbarConfig.header && y(Toolbar, Object.assign({ ref: this.headerRef, extraClassName: "fc-header-toolbar", model: toolbarConfig.header, titleId: viewLabelId }, toolbarProps)),
y(
ViewHarness,
{ liquid: viewVGrow, height: viewHeight, aspectRatio: viewAspectRatio, labeledById: viewLabelId },
this.renderView(props),
this.buildAppendContent()
),
toolbarConfig.footer && y(Toolbar, Object.assign({ ref: this.footerRef, extraClassName: "fc-footer-toolbar", model: toolbarConfig.footer, titleId: "" }, toolbarProps))
);
})
);
}
componentDidMount() {
let { props } = this;
this.calendarInteractions = props.pluginHooks.calendarInteractions.map((CalendarInteractionClass) => new CalendarInteractionClass(props));
window.addEventListener("resize", this.handleWindowResize);
let { propSetHandlers } = props.pluginHooks;
for (let propName in propSetHandlers) {
propSetHandlers[propName](props[propName], props);
}
}
componentDidUpdate(prevProps) {
let { props } = this;
let { propSetHandlers } = props.pluginHooks;
for (let propName in propSetHandlers) {
if (props[propName] !== prevProps[propName]) {
propSetHandlers[propName](props[propName], props);
}
}
}
componentWillUnmount() {
window.removeEventListener("resize", this.handleWindowResize);
this.resizeRunner.clear();
for (let interaction of this.calendarInteractions) {
interaction.destroy();
}
this.props.emitter.trigger("_unmount");
}
buildAppendContent() {
let { props } = this;
let children = props.pluginHooks.viewContainerAppends.map((buildAppendContent) => buildAppendContent(props));
return y(_, {}, ...children);
}
renderView(props) {
let { pluginHooks } = props;
let { viewSpec } = props;
let viewProps = {
dateProfile: props.dateProfile,
businessHours: props.businessHours,
eventStore: props.renderableEventStore,
eventUiBases: props.eventUiBases,
dateSelection: props.dateSelection,
eventSelection: props.eventSelection,
eventDrag: props.eventDrag,
eventResize: props.eventResize,
isHeightAuto: props.isHeightAuto,
forPrint: props.forPrint
};
let transformers = this.buildViewPropTransformers(pluginHooks.viewPropsTransformers);
for (let transformer of transformers) {
Object.assign(viewProps, transformer.transform(viewProps, props));
}
let ViewComponent = viewSpec.component;
return y(ViewComponent, Object.assign({}, viewProps));
}
};
function buildToolbarProps(viewSpec, dateProfile, dateProfileGenerator, currentDate, now, title) {
let todayInfo = dateProfileGenerator.build(now, void 0, false);
let prevInfo = dateProfileGenerator.buildPrev(dateProfile, currentDate, false);
let nextInfo = dateProfileGenerator.buildNext(dateProfile, currentDate, false);
return {
title,
activeButton: viewSpec.type,
navUnit: viewSpec.singleUnit,
isTodayEnabled: todayInfo.isValid && !rangeContainsMarker(dateProfile.currentRange, now),
isPrevEnabled: prevInfo.isValid,
isNextEnabled: nextInfo.isValid
};
}
function buildViewPropTransformers(theClasses) {
return theClasses.map((TheClass) => new TheClass());
}
var Calendar = class extends CalendarImpl {
constructor(el, optionOverrides = {}) {
super();
this.isRendering = false;
this.isRendered = false;
this.currentClassNames = [];
this.customContentRenderId = 0;
this.handleAction = (action) => {
switch (action.type) {
case "SET_EVENT_DRAG":
case "SET_EVENT_RESIZE":
this.renderRunner.tryDrain();
}
};
this.handleData = (data) => {
this.currentData = data;
this.renderRunner.request(data.calendarOptions.rerenderDelay);
};
this.handleRenderRequest = () => {
if (this.isRendering) {
this.isRendered = true;
let { currentData } = this;
flushSync(() => {
D(y(CalendarRoot, { options: currentData.calendarOptions, theme: currentData.theme, emitter: currentData.emitter }, (classNames, height, isHeightAuto, forPrint) => {
this.setClassNames(classNames);
this.setHeight(height);
return y(
RenderId.Provider,
{ value: this.customContentRenderId },
y(CalendarContent, Object.assign({ isHeightAuto, forPrint }, currentData))
);
}), this.el);
});
} else if (this.isRendered) {
this.isRendered = false;
D(null, this.el);
this.setClassNames([]);
this.setHeight("");
}
};
ensureElHasStyles(el);
this.el = el;
this.renderRunner = new DelayedRunner(this.handleRenderRequest);
new CalendarDataManager({
optionOverrides,
calendarApi: this,
onAction: this.handleAction,
onData: this.handleData
});
}
render() {
let wasRendering = this.isRendering;
if (!wasRendering) {
this.isRendering = true;
} else {
this.customContentRenderId += 1;
}
this.renderRunner.request();
if (wasRendering) {
this.updateSize();
}
}
destroy() {
if (this.isRendering) {
this.isRendering = false;
this.renderRunner.request();
}
}
updateSize() {
flushSync(() => {
super.updateSize();
});
}
batchRendering(func) {
this.renderRunner.pause("batchRendering");
func();
this.renderRunner.resume("batchRendering");
}
pauseRendering() {
this.renderRunner.pause("pauseRendering");
}
resumeRendering() {
this.renderRunner.resume("pauseRendering", true);
}
resetOptions(optionOverrides, changedOptionNames) {
this.currentDataManager.resetOptions(optionOverrides, changedOptionNames);
}
setClassNames(classNames) {
if (!isArraysEqual(classNames, this.currentClassNames)) {
let { classList } = this.el;
for (let className of this.currentClassNames) {
classList.remove(className);
}
for (let className of classNames) {
classList.add(className);
}
this.currentClassNames = classNames;
}
}
setHeight(height) {
applyStyleProp(this.el, "height", height);
}
};
// node_modules/.pnpm/@fullcalendar+daygrid@6.1.17_@fullcalendar+core@6.1.17/node_modules/@fullcalendar/daygrid/internal.js
var TableView = class extends DateComponent {
constructor() {
super(...arguments);
this.headerElRef = d();
}
renderSimpleLayout(headerRowContent, bodyContent) {
let { props, context } = this;
let sections = [];
let stickyHeaderDates = getStickyHeaderDates(context.options);
if (headerRowContent) {
sections.push({
type: "header",
key: "header",
isSticky: stickyHeaderDates,
chunk: {
elRef: this.headerElRef,
tableClassName: "fc-col-header",
rowContent: headerRowContent
}
});
}
sections.push({
type: "body",
key: "body",
liquid: true,
chunk: { content: bodyContent }
});
return y(
ViewContainer,
{ elClasses: ["fc-daygrid"], viewSpec: context.viewSpec },
y(SimpleScrollGrid, { liquid: !props.isHeightAuto && !props.forPrint, collapsibleWidth: props.forPrint, cols: [], sections })
);
}
renderHScrollLayout(headerRowContent, bodyContent, colCnt, dayMinWidth) {
let ScrollGrid = this.context.pluginHooks.scrollGridImpl;
if (!ScrollGrid) {
throw new Error("No ScrollGrid implementation");
}
let { props, context } = this;
let stickyHeaderDates = !props.forPrint && getStickyHeaderDates(context.options);
let stickyFooterScrollbar = !props.forPrint && getStickyFooterScrollbar(context.options);
let sections = [];
if (headerRowContent) {
sections.push({
type: "header",
key: "header",
isSticky: stickyHeaderDates,
chunks: [{
key: "main",
elRef: this.headerElRef,
tableClassName: "fc-col-header",
rowContent: headerRowContent
}]
});
}
sections.push({
type: "body",
key: "body",
liquid: true,
chunks: [{
key: "main",
content: bodyContent
}]
});
if (stickyFooterScrollbar) {
sections.push({
type: "footer",
key: "footer",
isSticky: true,
chunks: [{
key: "main",
content: renderScrollShim
}]
});
}
return y(
ViewContainer,
{ elClasses: ["fc-daygrid"], viewSpec: context.viewSpec },
y(ScrollGrid, { liquid: !props.isHeightAuto && !props.forPrint, forPrint: props.forPrint, collapsibleWidth: props.forPrint, colGroups: [{ cols: [{ span: colCnt, minWidth: dayMinWidth }] }], sections })
);
}
};
function splitSegsByRow(segs, rowCnt) {
let byRow = [];
for (let i3 = 0; i3 < rowCnt; i3 += 1) {
byRow[i3] = [];
}
for (let seg of segs) {
byRow[seg.row].push(seg);
}
return byRow;
}
function splitSegsByFirstCol(segs, colCnt) {
let byCol = [];
for (let i3 = 0; i3 < colCnt; i3 += 1) {
byCol[i3] = [];
}
for (let seg of segs) {
byCol[seg.firstCol].push(seg);
}
return byCol;
}
function splitInteractionByRow(ui, rowCnt) {
let byRow = [];
if (!ui) {
for (let i3 = 0; i3 < rowCnt; i3 += 1) {
byRow[i3] = null;
}
} else {
for (let i3 = 0; i3 < rowCnt; i3 += 1) {
byRow[i3] = {
affectedInstances: ui.affectedInstances,
isEvent: ui.isEvent,
segs: []
};
}
for (let seg of ui.segs) {
byRow[seg.row].segs.push(seg);
}
}
return byRow;
}
var DEFAULT_TABLE_EVENT_TIME_FORMAT = createFormatter({
hour: "numeric",
minute: "2-digit",
omitZeroMinute: true,
meridiem: "narrow"
});
function hasListItemDisplay(seg) {
let { display } = seg.eventRange.ui;
return display === "list-item" || display === "auto" && !seg.eventRange.def.allDay && seg.firstCol === seg.lastCol && // can't be multi-day
seg.isStart && // "
seg.isEnd;
}
var TableBlockEvent = class extends BaseComponent {
render() {
let { props } = this;
return y(StandardEvent, Object.assign({}, props, { elClasses: ["fc-daygrid-event", "fc-daygrid-block-event", "fc-h-event"], defaultTimeFormat: DEFAULT_TABLE_EVENT_TIME_FORMAT, defaultDisplayEventEnd: props.defaultDisplayEventEnd, disableResizing: !props.seg.eventRange.def.allDay }));
}
};
var TableListItemEvent = class extends BaseComponent {
render() {
let { props, context } = this;
let { options } = context;
let { seg } = props;
let timeFormat = options.eventTimeFormat || DEFAULT_TABLE_EVENT_TIME_FORMAT;
let timeText = buildSegTimeText(seg, timeFormat, context, true, props.defaultDisplayEventEnd);
return y(EventContainer, Object.assign({}, props, { elTag: "a", elClasses: ["fc-daygrid-event", "fc-daygrid-dot-event"], elAttrs: getSegAnchorAttrs(props.seg, context), defaultGenerator: renderInnerContent2, timeText, isResizing: false, isDateSelecting: false }));
}
};
function renderInnerContent2(renderProps) {
return y(
_,
null,
y("div", { className: "fc-daygrid-event-dot", style: { borderColor: renderProps.borderColor || renderProps.backgroundColor } }),
renderProps.timeText && y("div", { className: "fc-event-time" }, renderProps.timeText),
y("div", { className: "fc-event-title" }, renderProps.event.title || y(_, null, "\xA0"))
);
}
var TableCellMoreLink = class extends BaseComponent {
constructor() {
super(...arguments);
this.compileSegs = memoize(compileSegs);
}
render() {
let { props } = this;
let { allSegs, invisibleSegs } = this.compileSegs(props.singlePlacements);
return y(MoreLinkContainer, { elClasses: ["fc-daygrid-more-link"], dateProfile: props.dateProfile, todayRange: props.todayRange, allDayDate: props.allDayDate, moreCnt: props.moreCnt, allSegs, hiddenSegs: invisibleSegs, alignmentElRef: props.alignmentElRef, alignGridTop: props.alignGridTop, extraDateSpan: props.extraDateSpan, popoverContent: () => {
let isForcedInvisible = (props.eventDrag ? props.eventDrag.affectedInstances : null) || (props.eventResize ? props.eventResize.affectedInstances : null) || {};
return y(_, null, allSegs.map((seg) => {
let instanceId = seg.eventRange.instance.instanceId;
return y("div", { className: "fc-daygrid-event-harness", key: instanceId, style: {
visibility: isForcedInvisible[instanceId] ? "hidden" : ""
} }, hasListItemDisplay(seg) ? y(TableListItemEvent, Object.assign({ seg, isDragging: false, isSelected: instanceId === props.eventSelection, defaultDisplayEventEnd: false }, getSegMeta(seg, props.todayRange))) : y(TableBlockEvent, Object.assign({ seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: instanceId === props.eventSelection, defaultDisplayEventEnd: false }, getSegMeta(seg, props.todayRange))));
}));
} });
}
};
function compileSegs(singlePlacements) {
let allSegs = [];
let invisibleSegs = [];
for (let placement of singlePlacements) {
allSegs.push(placement.seg);
if (!placement.isVisible) {
invisibleSegs.push(placement.seg);
}
}
return { allSegs, invisibleSegs };
}
var DEFAULT_WEEK_NUM_FORMAT = createFormatter({ week: "narrow" });
var TableCell = class extends DateComponent {
constructor() {
super(...arguments);
this.rootElRef = d();
this.state = {
dayNumberId: getUniqueDomId()
};
this.handleRootEl = (el) => {
setRef(this.rootElRef, el);
setRef(this.props.elRef, el);
};
}
render() {
let { context, props, state, rootElRef } = this;
let { options, dateEnv } = context;
let { date, dateProfile } = props;
const isMonthStart = props.showDayNumber && shouldDisplayMonthStart(date, dateProfile.currentRange, dateEnv);
return y(DayCellContainer, { elTag: "td", elRef: this.handleRootEl, elClasses: [
"fc-daygrid-day",
...props.extraClassNames || []
], elAttrs: Object.assign(Object.assign(Object.assign({}, props.extraDataAttrs), props.showDayNumber ? { "aria-labelledby": state.dayNumberId } : {}), { role: "gridcell" }), defaultGenerator: renderTopInner, date, dateProfile, todayRange: props.todayRange, showDayNumber: props.showDayNumber, isMonthStart, extraRenderProps: props.extraRenderProps }, (InnerContent, renderProps) => y(
"div",
{ ref: props.innerElRef, className: "fc-daygrid-day-frame fc-scrollgrid-sync-inner", style: { minHeight: props.minHeight } },
props.showWeekNumber && y(WeekNumberContainer, { elTag: "a", elClasses: ["fc-daygrid-week-number"], elAttrs: buildNavLinkAttrs(context, date, "week"), date, defaultFormat: DEFAULT_WEEK_NUM_FORMAT }),
!renderProps.isDisabled && (props.showDayNumber || hasCustomDayCellContent(options) || props.forceDayTop) ? y(
"div",
{ className: "fc-daygrid-day-top" },
y(InnerContent, { elTag: "a", elClasses: [
"fc-daygrid-day-number",
isMonthStart && "fc-daygrid-month-start"
], elAttrs: Object.assign(Object.assign({}, buildNavLinkAttrs(context, date)), { id: state.dayNumberId }) })
) : props.showDayNumber ? (
// for creating correct amount of space (see issue #7162)
y(
"div",
{ className: "fc-daygrid-day-top", style: { visibility: "hidden" } },
y("a", { className: "fc-daygrid-day-number" }, "\xA0")
)
) : void 0,
y(
"div",
{ className: "fc-daygrid-day-events", ref: props.fgContentElRef },
props.fgContent,
y(
"div",
{ className: "fc-daygrid-day-bottom", style: { marginTop: props.moreMarginTop } },
y(TableCellMoreLink, { allDayDate: date, singlePlacements: props.singlePlacements, moreCnt: props.moreCnt, alignmentElRef: rootElRef, alignGridTop: !props.showDayNumber, extraDateSpan: props.extraDateSpan, dateProfile: props.dateProfile, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, todayRange: props.todayRange })
)
),
y("div", { className: "fc-daygrid-day-bg" }, props.bgContent)
));
}
};
function renderTopInner(props) {
return props.dayNumberText || y(_, null, "\xA0");
}
function shouldDisplayMonthStart(date, currentRange, dateEnv) {
const { start: currentStart, end: currentEnd } = currentRange;
const currentEndIncl = addMs(currentEnd, -1);
const currentFirstYear = dateEnv.getYear(currentStart);
const currentFirstMonth = dateEnv.getMonth(currentStart);
const currentLastYear = dateEnv.getYear(currentEndIncl);
const currentLastMonth = dateEnv.getMonth(currentEndIncl);
return !(currentFirstYear === currentLastYear && currentFirstMonth === currentLastMonth) && Boolean(
// first date in current view?
date.valueOf() === currentStart.valueOf() || // a month-start that's within the current range?
dateEnv.getDay(date) === 1 && date.valueOf() < currentEnd.valueOf()
);
}
function generateSegKey(seg) {
return seg.eventRange.instance.instanceId + ":" + seg.firstCol;
}
function generateSegUid(seg) {
return generateSegKey(seg) + ":" + seg.lastCol;
}
function computeFgSegPlacement(segs, dayMaxEvents, dayMaxEventRows, strictOrder, segHeights, maxContentHeight, cells) {
let hierarchy = new DayGridSegHierarchy((segEntry) => {
let segUid = segs[segEntry.index].eventRange.instance.instanceId + ":" + segEntry.span.start + ":" + (segEntry.span.end - 1);
return segHeights[segUid] || 1;
});
hierarchy.allowReslicing = true;
hierarchy.strictOrder = strictOrder;
if (dayMaxEvents === true || dayMaxEventRows === true) {
hierarchy.maxCoord = maxContentHeight;
hierarchy.hiddenConsumes = true;
} else if (typeof dayMaxEvents === "number") {
hierarchy.maxStackCnt = dayMaxEvents;
} else if (typeof dayMaxEventRows === "number") {
hierarchy.maxStackCnt = dayMaxEventRows;
hierarchy.hiddenConsumes = true;
}
let segInputs = [];
let unknownHeightSegs = [];
for (let i3 = 0; i3 < segs.length; i3 += 1) {
let seg = segs[i3];
let segUid = generateSegUid(seg);
let eventHeight = segHeights[segUid];
if (eventHeight != null) {
segInputs.push({
index: i3,
span: {
start: seg.firstCol,
end: seg.lastCol + 1
}
});
} else {
unknownHeightSegs.push(seg);
}
}
let hiddenEntries = hierarchy.addSegs(segInputs);
let segRects = hierarchy.toRects();
let { singleColPlacements, multiColPlacements, leftoverMargins } = placeRects(segRects, segs, cells);
let moreCnts = [];
let moreMarginTops = [];
for (let seg of unknownHeightSegs) {
multiColPlacements[seg.firstCol].push({
seg,
isVisible: false,
isAbsolute: true,
absoluteTop: 0,
marginTop: 0
});
for (let col = seg.firstCol; col <= seg.lastCol; col += 1) {
singleColPlacements[col].push({
seg: resliceSeg(seg, col, col + 1, cells),
isVisible: false,
isAbsolute: false,
absoluteTop: 0,
marginTop: 0
});
}
}
for (let col = 0; col < cells.length; col += 1) {
moreCnts.push(0);
}
for (let hiddenEntry of hiddenEntries) {
let seg = segs[hiddenEntry.index];
let hiddenSpan = hiddenEntry.span;
multiColPlacements[hiddenSpan.start].push({
seg: resliceSeg(seg, hiddenSpan.start, hiddenSpan.end, cells),
isVisible: false,
isAbsolute: true,
absoluteTop: 0,
marginTop: 0
});
for (let col = hiddenSpan.start; col < hiddenSpan.end; col += 1) {
moreCnts[col] += 1;
singleColPlacements[col].push({
seg: resliceSeg(seg, col, col + 1, cells),
isVisible: false,
isAbsolute: false,
absoluteTop: 0,
marginTop: 0
});
}
}
for (let col = 0; col < cells.length; col += 1) {
moreMarginTops.push(leftoverMargins[col]);
}
return { singleColPlacements, multiColPlacements, moreCnts, moreMarginTops };
}
function placeRects(allRects, segs, cells) {
let rectsByEachCol = groupRectsByEachCol(allRects, cells.length);
let singleColPlacements = [];
let multiColPlacements = [];
let leftoverMargins = [];
for (let col = 0; col < cells.length; col += 1) {
let rects = rectsByEachCol[col];
let singlePlacements = [];
let currentHeight = 0;
let currentMarginTop = 0;
for (let rect of rects) {
let seg = segs[rect.index];
singlePlacements.push({
seg: resliceSeg(seg, col, col + 1, cells),
isVisible: true,
isAbsolute: false,
absoluteTop: rect.levelCoord,
marginTop: rect.levelCoord - currentHeight
});
currentHeight = rect.levelCoord + rect.thickness;
}
let multiPlacements = [];
currentHeight = 0;
currentMarginTop = 0;
for (let rect of rects) {
let seg = segs[rect.index];
let isAbsolute = rect.span.end - rect.span.start > 1;
let isFirstCol = rect.span.start === col;
currentMarginTop += rect.levelCoord - currentHeight;
currentHeight = rect.levelCoord + rect.thickness;
if (isAbsolute) {
currentMarginTop += rect.thickness;
if (isFirstCol) {
multiPlacements.push({
seg: resliceSeg(seg, rect.span.start, rect.span.end, cells),
isVisible: true,
isAbsolute: true,
absoluteTop: rect.levelCoord,
marginTop: 0
});
}
} else if (isFirstCol) {
multiPlacements.push({
seg: resliceSeg(seg, rect.span.start, rect.span.end, cells),
isVisible: true,
isAbsolute: false,
absoluteTop: rect.levelCoord,
marginTop: currentMarginTop
// claim the margin
});
currentMarginTop = 0;
}
}
singleColPlacements.push(singlePlacements);
multiColPlacements.push(multiPlacements);
leftoverMargins.push(currentMarginTop);
}
return { singleColPlacements, multiColPlacements, leftoverMargins };
}
function groupRectsByEachCol(rects, colCnt) {
let rectsByEachCol = [];
for (let col = 0; col < colCnt; col += 1) {
rectsByEachCol.push([]);
}
for (let rect of rects) {
for (let col = rect.span.start; col < rect.span.end; col += 1) {
rectsByEachCol[col].push(rect);
}
}
return rectsByEachCol;
}
function resliceSeg(seg, spanStart, spanEnd, cells) {
if (seg.firstCol === spanStart && seg.lastCol === spanEnd - 1) {
return seg;
}
let eventRange = seg.eventRange;
let origRange = eventRange.range;
let slicedRange = intersectRanges(origRange, {
start: cells[spanStart].date,
end: addDays(cells[spanEnd - 1].date, 1)
});
return Object.assign(Object.assign({}, seg), { firstCol: spanStart, lastCol: spanEnd - 1, eventRange: {
def: eventRange.def,
ui: Object.assign(Object.assign({}, eventRange.ui), { durationEditable: false }),
instance: eventRange.instance,
range: slicedRange
}, isStart: seg.isStart && slicedRange.start.valueOf() === origRange.start.valueOf(), isEnd: seg.isEnd && slicedRange.end.valueOf() === origRange.end.valueOf() });
}
var DayGridSegHierarchy = class extends SegHierarchy {
constructor() {
super(...arguments);
this.hiddenConsumes = false;
this.forceHidden = {};
}
addSegs(segInputs) {
const hiddenSegs = super.addSegs(segInputs);
const { entriesByLevel } = this;
const excludeHidden = (entry) => !this.forceHidden[buildEntryKey(entry)];
for (let level = 0; level < entriesByLevel.length; level += 1) {
entriesByLevel[level] = entriesByLevel[level].filter(excludeHidden);
}
return hiddenSegs;
}
handleInvalidInsertion(insertion, entry, hiddenEntries) {
const { entriesByLevel, forceHidden } = this;
const { touchingEntry, touchingLevel, touchingLateral } = insertion;
if (this.hiddenConsumes && touchingEntry) {
const touchingEntryId = buildEntryKey(touchingEntry);
if (!forceHidden[touchingEntryId]) {
if (this.allowReslicing) {
const hiddenEntry = Object.assign(Object.assign({}, touchingEntry), { span: intersectSpans(touchingEntry.span, entry.span) });
const hiddenEntryId = buildEntryKey(hiddenEntry);
forceHidden[hiddenEntryId] = true;
entriesByLevel[touchingLevel][touchingLateral] = hiddenEntry;
hiddenEntries.push(hiddenEntry);
this.splitEntry(touchingEntry, entry, hiddenEntries);
} else {
forceHidden[touchingEntryId] = true;
hiddenEntries.push(touchingEntry);
}
}
}
super.handleInvalidInsertion(insertion, entry, hiddenEntries);
}
};
var TableRow = class extends DateComponent {
constructor() {
super(...arguments);
this.cellElRefs = new RefMap();
this.frameElRefs = new RefMap();
this.fgElRefs = new RefMap();
this.segHarnessRefs = new RefMap();
this.rootElRef = d();
this.state = {
framePositions: null,
maxContentHeight: null,
segHeights: {}
};
this.handleResize = (isForced) => {
if (isForced) {
this.updateSizing(true);
}
};
}
render() {
let { props, state, context } = this;
let { options } = context;
let colCnt = props.cells.length;
let businessHoursByCol = splitSegsByFirstCol(props.businessHourSegs, colCnt);
let bgEventSegsByCol = splitSegsByFirstCol(props.bgEventSegs, colCnt);
let highlightSegsByCol = splitSegsByFirstCol(this.getHighlightSegs(), colCnt);
let mirrorSegsByCol = splitSegsByFirstCol(this.getMirrorSegs(), colCnt);
let { singleColPlacements, multiColPlacements, moreCnts, moreMarginTops } = computeFgSegPlacement(sortEventSegs(props.fgEventSegs, options.eventOrder), props.dayMaxEvents, props.dayMaxEventRows, options.eventOrderStrict, state.segHeights, state.maxContentHeight, props.cells);
let isForcedInvisible = (
// TODO: messy way to compute this
props.eventDrag && props.eventDrag.affectedInstances || props.eventResize && props.eventResize.affectedInstances || {}
);
return y(
"tr",
{ ref: this.rootElRef, role: "row" },
props.renderIntro && props.renderIntro(),
props.cells.map((cell, col) => {
let normalFgNodes = this.renderFgSegs(col, props.forPrint ? singleColPlacements[col] : multiColPlacements[col], props.todayRange, isForcedInvisible);
let mirrorFgNodes = this.renderFgSegs(col, buildMirrorPlacements(mirrorSegsByCol[col], multiColPlacements), props.todayRange, {}, Boolean(props.eventDrag), Boolean(props.eventResize), false);
return y(TableCell, { key: cell.key, elRef: this.cellElRefs.createRef(cell.key), innerElRef: this.frameElRefs.createRef(cell.key), dateProfile: props.dateProfile, date: cell.date, showDayNumber: props.showDayNumbers, showWeekNumber: props.showWeekNumbers && col === 0, forceDayTop: props.showWeekNumbers, todayRange: props.todayRange, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, extraRenderProps: cell.extraRenderProps, extraDataAttrs: cell.extraDataAttrs, extraClassNames: cell.extraClassNames, extraDateSpan: cell.extraDateSpan, moreCnt: moreCnts[col], moreMarginTop: moreMarginTops[col], singlePlacements: singleColPlacements[col], fgContentElRef: this.fgElRefs.createRef(cell.key), fgContent: (
// Fragment scopes the keys
y(
_,
null,
y(_, null, normalFgNodes),
y(_, null, mirrorFgNodes)
)
), bgContent: (
// Fragment scopes the keys
y(
_,
null,
this.renderFillSegs(highlightSegsByCol[col], "highlight"),
this.renderFillSegs(businessHoursByCol[col], "non-business"),
this.renderFillSegs(bgEventSegsByCol[col], "bg-event")
)
), minHeight: props.cellMinHeight });
})
);
}
componentDidMount() {
this.updateSizing(true);
this.context.addResizeHandler(this.handleResize);
}
componentDidUpdate(prevProps, prevState) {
let currentProps = this.props;
this.updateSizing(!isPropsEqual(prevProps, currentProps));
}
componentWillUnmount() {
this.context.removeResizeHandler(this.handleResize);
}
getHighlightSegs() {
let { props } = this;
if (props.eventDrag && props.eventDrag.segs.length) {
return props.eventDrag.segs;
}
if (props.eventResize && props.eventResize.segs.length) {
return props.eventResize.segs;
}
return props.dateSelectionSegs;
}
getMirrorSegs() {
let { props } = this;
if (props.eventResize && props.eventResize.segs.length) {
return props.eventResize.segs;
}
return [];
}
renderFgSegs(col, segPlacements, todayRange, isForcedInvisible, isDragging, isResizing, isDateSelecting) {
let { context } = this;
let { eventSelection } = this.props;
let { framePositions } = this.state;
let defaultDisplayEventEnd = this.props.cells.length === 1;
let isMirror = isDragging || isResizing || isDateSelecting;
let nodes = [];
if (framePositions) {
for (let placement of segPlacements) {
let { seg } = placement;
let { instanceId } = seg.eventRange.instance;
let isVisible = placement.isVisible && !isForcedInvisible[instanceId];
let isAbsolute = placement.isAbsolute;
let left = "";
let right = "";
if (isAbsolute) {
if (context.isRtl) {
right = 0;
left = framePositions.lefts[seg.lastCol] - framePositions.lefts[seg.firstCol];
} else {
left = 0;
right = framePositions.rights[seg.firstCol] - framePositions.rights[seg.lastCol];
}
}
nodes.push(y("div", { className: "fc-daygrid-event-harness" + (isAbsolute ? " fc-daygrid-event-harness-abs" : ""), key: generateSegKey(seg), ref: isMirror ? null : this.segHarnessRefs.createRef(generateSegUid(seg)), style: {
visibility: isVisible ? "" : "hidden",
marginTop: isAbsolute ? "" : placement.marginTop,
top: isAbsolute ? placement.absoluteTop : "",
left,
right
} }, hasListItemDisplay(seg) ? y(TableListItemEvent, Object.assign({ seg, isDragging, isSelected: instanceId === eventSelection, defaultDisplayEventEnd }, getSegMeta(seg, todayRange))) : y(TableBlockEvent, Object.assign({ seg, isDragging, isResizing, isDateSelecting, isSelected: instanceId === eventSelection, defaultDisplayEventEnd }, getSegMeta(seg, todayRange)))));
}
}
return nodes;
}
renderFillSegs(segs, fillType) {
let { isRtl } = this.context;
let { todayRange } = this.props;
let { framePositions } = this.state;
let nodes = [];
if (framePositions) {
for (let seg of segs) {
let leftRightCss = isRtl ? {
right: 0,
left: framePositions.lefts[seg.lastCol] - framePositions.lefts[seg.firstCol]
} : {
left: 0,
right: framePositions.rights[seg.firstCol] - framePositions.rights[seg.lastCol]
};
nodes.push(y("div", { key: buildEventRangeKey(seg.eventRange), className: "fc-daygrid-bg-harness", style: leftRightCss }, fillType === "bg-event" ? y(BgEvent, Object.assign({ seg }, getSegMeta(seg, todayRange))) : renderFill(fillType)));
}
}
return y(_, {}, ...nodes);
}
updateSizing(isExternalSizingChange) {
let { props, state, frameElRefs } = this;
if (!props.forPrint && props.clientWidth !== null) {
if (isExternalSizingChange) {
let frameEls = props.cells.map((cell) => frameElRefs.currentMap[cell.key]);
if (frameEls.length) {
let originEl = this.rootElRef.current;
let newPositionCache = new PositionCache(
originEl,
frameEls,
true,
// isHorizontal
false
);
if (!state.framePositions || !state.framePositions.similarTo(newPositionCache)) {
this.setState({
framePositions: new PositionCache(
originEl,
frameEls,
true,
// isHorizontal
false
)
});
}
}
}
const oldSegHeights = this.state.segHeights;
const newSegHeights = this.querySegHeights();
const limitByContentHeight = props.dayMaxEvents === true || props.dayMaxEventRows === true;
this.safeSetState({
// HACK to prevent oscillations of events being shown/hidden from max-event-rows
// Essentially, once you compute an element's height, never null-out.
// TODO: always display all events, as visibility:hidden?
segHeights: Object.assign(Object.assign({}, oldSegHeights), newSegHeights),
maxContentHeight: limitByContentHeight ? this.computeMaxContentHeight() : null
});
}
}
querySegHeights() {
let segElMap = this.segHarnessRefs.currentMap;
let segHeights = {};
for (let segUid in segElMap) {
let height = Math.round(segElMap[segUid].getBoundingClientRect().height);
segHeights[segUid] = Math.max(segHeights[segUid] || 0, height);
}
return segHeights;
}
computeMaxContentHeight() {
let firstKey = this.props.cells[0].key;
let cellEl = this.cellElRefs.currentMap[firstKey];
let fcContainerEl = this.fgElRefs.currentMap[firstKey];
return cellEl.getBoundingClientRect().bottom - fcContainerEl.getBoundingClientRect().top;
}
getCellEls() {
let elMap = this.cellElRefs.currentMap;
return this.props.cells.map((cell) => elMap[cell.key]);
}
};
TableRow.addStateEquality({
segHeights: isPropsEqual
});
function buildMirrorPlacements(mirrorSegs, colPlacements) {
if (!mirrorSegs.length) {
return [];
}
let topsByInstanceId = buildAbsoluteTopHash(colPlacements);
return mirrorSegs.map((seg) => ({
seg,
isVisible: true,
isAbsolute: true,
absoluteTop: topsByInstanceId[seg.eventRange.instance.instanceId],
marginTop: 0
}));
}
function buildAbsoluteTopHash(colPlacements) {
let topsByInstanceId = {};
for (let placements of colPlacements) {
for (let placement of placements) {
topsByInstanceId[placement.seg.eventRange.instance.instanceId] = placement.absoluteTop;
}
}
return topsByInstanceId;
}
var TableRows = class extends DateComponent {
constructor() {
super(...arguments);
this.splitBusinessHourSegs = memoize(splitSegsByRow);
this.splitBgEventSegs = memoize(splitSegsByRow);
this.splitFgEventSegs = memoize(splitSegsByRow);
this.splitDateSelectionSegs = memoize(splitSegsByRow);
this.splitEventDrag = memoize(splitInteractionByRow);
this.splitEventResize = memoize(splitInteractionByRow);
this.rowRefs = new RefMap();
}
render() {
let { props, context } = this;
let rowCnt = props.cells.length;
let businessHourSegsByRow = this.splitBusinessHourSegs(props.businessHourSegs, rowCnt);
let bgEventSegsByRow = this.splitBgEventSegs(props.bgEventSegs, rowCnt);
let fgEventSegsByRow = this.splitFgEventSegs(props.fgEventSegs, rowCnt);
let dateSelectionSegsByRow = this.splitDateSelectionSegs(props.dateSelectionSegs, rowCnt);
let eventDragByRow = this.splitEventDrag(props.eventDrag, rowCnt);
let eventResizeByRow = this.splitEventResize(props.eventResize, rowCnt);
let cellMinHeight = rowCnt >= 7 && props.clientWidth ? props.clientWidth / context.options.aspectRatio / 6 : null;
return y(NowTimer, { unit: "day" }, (nowDate, todayRange) => y(_, null, props.cells.map((cells, row) => y(TableRow, {
ref: this.rowRefs.createRef(row),
key: cells.length ? cells[0].date.toISOString() : row,
showDayNumbers: rowCnt > 1,
showWeekNumbers: props.showWeekNumbers,
todayRange,
dateProfile: props.dateProfile,
cells,
renderIntro: props.renderRowIntro,
businessHourSegs: businessHourSegsByRow[row],
eventSelection: props.eventSelection,
bgEventSegs: bgEventSegsByRow[row].filter(isSegAllDay),
fgEventSegs: fgEventSegsByRow[row],
dateSelectionSegs: dateSelectionSegsByRow[row],
eventDrag: eventDragByRow[row],
eventResize: eventResizeByRow[row],
dayMaxEvents: props.dayMaxEvents,
dayMaxEventRows: props.dayMaxEventRows,
clientWidth: props.clientWidth,
clientHeight: props.clientHeight,
cellMinHeight,
forPrint: props.forPrint
}))));
}
componentDidMount() {
this.registerInteractiveComponent();
}
componentDidUpdate() {
this.registerInteractiveComponent();
}
registerInteractiveComponent() {
if (!this.rootEl) {
const firstCellEl = this.rowRefs.currentMap[0].getCellEls()[0];
const rootEl = firstCellEl ? firstCellEl.closest(".fc-daygrid-body") : null;
if (rootEl) {
this.rootEl = rootEl;
this.context.registerInteractiveComponent(this, {
el: rootEl,
isHitComboAllowed: this.props.isHitComboAllowed
});
}
}
}
componentWillUnmount() {
if (this.rootEl) {
this.context.unregisterInteractiveComponent(this);
this.rootEl = null;
}
}
// Hit System
// ----------------------------------------------------------------------------------------------------
prepareHits() {
this.rowPositions = new PositionCache(
this.rootEl,
this.rowRefs.collect().map((rowObj) => rowObj.getCellEls()[0]),
// first cell el in each row. TODO: not optimal
false,
true
);
this.colPositions = new PositionCache(
this.rootEl,
this.rowRefs.currentMap[0].getCellEls(),
// cell els in first row
true,
// horizontal
false
);
}
queryHit(positionLeft, positionTop) {
let { colPositions, rowPositions } = this;
let col = colPositions.leftToIndex(positionLeft);
let row = rowPositions.topToIndex(positionTop);
if (row != null && col != null) {
let cell = this.props.cells[row][col];
return {
dateProfile: this.props.dateProfile,
dateSpan: Object.assign({ range: this.getCellRange(row, col), allDay: true }, cell.extraDateSpan),
dayEl: this.getCellEl(row, col),
rect: {
left: colPositions.lefts[col],
right: colPositions.rights[col],
top: rowPositions.tops[row],
bottom: rowPositions.bottoms[row]
},
layer: 0
};
}
return null;
}
getCellEl(row, col) {
return this.rowRefs.currentMap[row].getCellEls()[col];
}
getCellRange(row, col) {
let start = this.props.cells[row][col].date;
let end = addDays(start, 1);
return { start, end };
}
};
function isSegAllDay(seg) {
return seg.eventRange.def.allDay;
}
var Table = class extends DateComponent {
constructor() {
super(...arguments);
this.elRef = d();
this.needsScrollReset = false;
}
render() {
let { props } = this;
let { dayMaxEventRows, dayMaxEvents, expandRows } = props;
let limitViaBalanced = dayMaxEvents === true || dayMaxEventRows === true;
if (limitViaBalanced && !expandRows) {
limitViaBalanced = false;
dayMaxEventRows = null;
dayMaxEvents = null;
}
let classNames = [
"fc-daygrid-body",
limitViaBalanced ? "fc-daygrid-body-balanced" : "fc-daygrid-body-unbalanced",
expandRows ? "" : "fc-daygrid-body-natural"
// will height of one row depend on the others?
];
return y(
"div",
{ ref: this.elRef, className: classNames.join(" "), style: {
// these props are important to give this wrapper correct dimensions for interactions
// TODO: if we set it here, can we avoid giving to inner tables?
width: props.clientWidth,
minWidth: props.tableMinWidth
} },
y(
"table",
{ role: "presentation", className: "fc-scrollgrid-sync-table", style: {
width: props.clientWidth,
minWidth: props.tableMinWidth,
height: expandRows ? props.clientHeight : ""
} },
props.colGroupNode,
y(
"tbody",
{ role: "presentation" },
y(TableRows, { dateProfile: props.dateProfile, cells: props.cells, renderRowIntro: props.renderRowIntro, showWeekNumbers: props.showWeekNumbers, clientWidth: props.clientWidth, clientHeight: props.clientHeight, businessHourSegs: props.businessHourSegs, bgEventSegs: props.bgEventSegs, fgEventSegs: props.fgEventSegs, dateSelectionSegs: props.dateSelectionSegs, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, dayMaxEvents, dayMaxEventRows, forPrint: props.forPrint, isHitComboAllowed: props.isHitComboAllowed })
)
)
);
}
componentDidMount() {
this.requestScrollReset();
}
componentDidUpdate(prevProps) {
if (prevProps.dateProfile !== this.props.dateProfile) {
this.requestScrollReset();
} else {
this.flushScrollReset();
}
}
requestScrollReset() {
this.needsScrollReset = true;
this.flushScrollReset();
}
flushScrollReset() {
if (this.needsScrollReset && this.props.clientWidth) {
const subjectEl = getScrollSubjectEl(this.elRef.current, this.props.dateProfile);
if (subjectEl) {
const originEl = subjectEl.closest(".fc-daygrid-body");
const scrollEl = originEl.closest(".fc-scroller");
const scrollTop = subjectEl.getBoundingClientRect().top - originEl.getBoundingClientRect().top;
scrollEl.scrollTop = scrollTop ? scrollTop + 1 : 0;
}
this.needsScrollReset = false;
}
}
};
function getScrollSubjectEl(containerEl, dateProfile) {
let el;
if (dateProfile.currentRangeUnit.match(/year|month/)) {
el = containerEl.querySelector(`[data-date="${formatIsoMonthStr(dateProfile.currentDate)}-01"]`);
}
if (!el) {
el = containerEl.querySelector(`[data-date="${formatDayString(dateProfile.currentDate)}"]`);
}
return el;
}
var DayTableSlicer = class extends Slicer {
constructor() {
super(...arguments);
this.forceDayIfListItem = true;
}
sliceRange(dateRange, dayTableModel) {
return dayTableModel.sliceRange(dateRange);
}
};
var DayTable = class extends DateComponent {
constructor() {
super(...arguments);
this.slicer = new DayTableSlicer();
this.tableRef = d();
}
render() {
let { props, context } = this;
return y(Table, Object.assign({ ref: this.tableRef }, this.slicer.sliceProps(props, props.dateProfile, props.nextDayThreshold, context, props.dayTableModel), { dateProfile: props.dateProfile, cells: props.dayTableModel.cells, colGroupNode: props.colGroupNode, tableMinWidth: props.tableMinWidth, renderRowIntro: props.renderRowIntro, dayMaxEvents: props.dayMaxEvents, dayMaxEventRows: props.dayMaxEventRows, showWeekNumbers: props.showWeekNumbers, expandRows: props.expandRows, headerAlignElRef: props.headerAlignElRef, clientWidth: props.clientWidth, clientHeight: props.clientHeight, forPrint: props.forPrint }));
}
};
var DayTableView = class extends TableView {
constructor() {
super(...arguments);
this.buildDayTableModel = memoize(buildDayTableModel);
this.headerRef = d();
this.tableRef = d();
}
render() {
let { options, dateProfileGenerator } = this.context;
let { props } = this;
let dayTableModel = this.buildDayTableModel(props.dateProfile, dateProfileGenerator);
let headerContent = options.dayHeaders && y(DayHeader, { ref: this.headerRef, dateProfile: props.dateProfile, dates: dayTableModel.headerDates, datesRepDistinctDays: dayTableModel.rowCnt === 1 });
let bodyContent = (contentArg) => y(DayTable, { ref: this.tableRef, dateProfile: props.dateProfile, dayTableModel, businessHours: props.businessHours, dateSelection: props.dateSelection, eventStore: props.eventStore, eventUiBases: props.eventUiBases, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, nextDayThreshold: options.nextDayThreshold, colGroupNode: contentArg.tableColGroupNode, tableMinWidth: contentArg.tableMinWidth, dayMaxEvents: options.dayMaxEvents, dayMaxEventRows: options.dayMaxEventRows, showWeekNumbers: options.weekNumbers, expandRows: !props.isHeightAuto, headerAlignElRef: this.headerElRef, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, forPrint: props.forPrint });
return options.dayMinWidth ? this.renderHScrollLayout(headerContent, bodyContent, dayTableModel.colCnt, options.dayMinWidth) : this.renderSimpleLayout(headerContent, bodyContent);
}
};
function buildDayTableModel(dateProfile, dateProfileGenerator) {
let daySeries = new DaySeriesModel(dateProfile.renderRange, dateProfileGenerator);
return new DayTableModel(daySeries, /year|month|week/.test(dateProfile.currentRangeUnit));
}
var TableDateProfileGenerator = class extends DateProfileGenerator {
// Computes the date range that will be rendered
buildRenderRange(currentRange, currentRangeUnit, isRangeAllDay) {
let renderRange = super.buildRenderRange(currentRange, currentRangeUnit, isRangeAllDay);
let { props } = this;
return buildDayTableRenderRange({
currentRange: renderRange,
snapToWeek: /^(year|month)$/.test(currentRangeUnit),
fixedWeekCount: props.fixedWeekCount,
dateEnv: props.dateEnv
});
}
};
function buildDayTableRenderRange(props) {
let { dateEnv, currentRange } = props;
let { start, end } = currentRange;
let endOfWeek;
if (props.snapToWeek) {
start = dateEnv.startOfWeek(start);
endOfWeek = dateEnv.startOfWeek(end);
if (endOfWeek.valueOf() !== end.valueOf()) {
end = addWeeks(endOfWeek, 1);
}
}
if (props.fixedWeekCount) {
let lastMonthRenderStart = dateEnv.startOfWeek(dateEnv.startOfMonth(addDays(currentRange.end, -1)));
let rowCnt = Math.ceil(
// could be partial weeks due to hiddenDays
diffWeeks(lastMonthRenderStart, end)
);
end = addWeeks(end, 6 - rowCnt);
}
return { start, end };
}
var css_248z2 = ':root{--fc-daygrid-event-dot-width:8px}.fc-daygrid-day-events:after,.fc-daygrid-day-events:before,.fc-daygrid-day-frame:after,.fc-daygrid-day-frame:before,.fc-daygrid-event-harness:after,.fc-daygrid-event-harness:before{clear:both;content:"";display:table}.fc .fc-daygrid-body{position:relative;z-index:1}.fc .fc-daygrid-day.fc-day-today{background-color:var(--fc-today-bg-color)}.fc .fc-daygrid-day-frame{min-height:100%;position:relative}.fc .fc-daygrid-day-top{display:flex;flex-direction:row-reverse}.fc .fc-day-other .fc-daygrid-day-top{opacity:.3}.fc .fc-daygrid-day-number{padding:4px;position:relative;z-index:4}.fc .fc-daygrid-month-start{font-size:1.1em;font-weight:700}.fc .fc-daygrid-day-events{margin-top:1px}.fc .fc-daygrid-body-balanced .fc-daygrid-day-events{left:0;position:absolute;right:0}.fc .fc-daygrid-body-unbalanced .fc-daygrid-day-events{min-height:2em;position:relative}.fc .fc-daygrid-body-natural .fc-daygrid-day-events{margin-bottom:1em}.fc .fc-daygrid-event-harness{position:relative}.fc .fc-daygrid-event-harness-abs{left:0;position:absolute;right:0;top:0}.fc .fc-daygrid-bg-harness{bottom:0;position:absolute;top:0}.fc .fc-daygrid-day-bg .fc-non-business{z-index:1}.fc .fc-daygrid-day-bg .fc-bg-event{z-index:2}.fc .fc-daygrid-day-bg .fc-highlight{z-index:3}.fc .fc-daygrid-event{margin-top:1px;z-index:6}.fc .fc-daygrid-event.fc-event-mirror{z-index:7}.fc .fc-daygrid-day-bottom{font-size:.85em;margin:0 2px}.fc .fc-daygrid-day-bottom:after,.fc .fc-daygrid-day-bottom:before{clear:both;content:"";display:table}.fc .fc-daygrid-more-link{border-radius:3px;cursor:pointer;line-height:1;margin-top:1px;max-width:100%;overflow:hidden;padding:2px;position:relative;white-space:nowrap;z-index:4}.fc .fc-daygrid-more-link:hover{background-color:rgba(0,0,0,.1)}.fc .fc-daygrid-week-number{background-color:var(--fc-neutral-bg-color);color:var(--fc-neutral-text-color);min-width:1.5em;padding:2px;position:absolute;text-align:center;top:0;z-index:5}.fc .fc-more-popover .fc-popover-body{min-width:220px;padding:10px}.fc-direction-ltr .fc-daygrid-event.fc-event-start,.fc-direction-rtl .fc-daygrid-event.fc-event-end{margin-left:2px}.fc-direction-ltr .fc-daygrid-event.fc-event-end,.fc-direction-rtl .fc-daygrid-event.fc-event-start{margin-right:2px}.fc-direction-ltr .fc-daygrid-more-link{float:left}.fc-direction-ltr .fc-daygrid-week-number{border-radius:0 0 3px 0;left:0}.fc-direction-rtl .fc-daygrid-more-link{float:right}.fc-direction-rtl .fc-daygrid-week-number{border-radius:0 0 0 3px;right:0}.fc-liquid-hack .fc-daygrid-day-frame{position:static}.fc-daygrid-event{border-radius:3px;font-size:var(--fc-small-font-size);position:relative;white-space:nowrap}.fc-daygrid-block-event .fc-event-time{font-weight:700}.fc-daygrid-block-event .fc-event-time,.fc-daygrid-block-event .fc-event-title{padding:1px}.fc-daygrid-dot-event{align-items:center;display:flex;padding:2px 0}.fc-daygrid-dot-event .fc-event-title{flex-grow:1;flex-shrink:1;font-weight:700;min-width:0;overflow:hidden}.fc-daygrid-dot-event.fc-event-mirror,.fc-daygrid-dot-event:hover{background:rgba(0,0,0,.1)}.fc-daygrid-dot-event.fc-event-selected:before{bottom:-10px;top:-10px}.fc-daygrid-event-dot{border:calc(var(--fc-daygrid-event-dot-width)/2) solid var(--fc-event-border-color);border-radius:calc(var(--fc-daygrid-event-dot-width)/2);box-sizing:content-box;height:0;margin:0 4px;width:0}.fc-direction-ltr .fc-daygrid-event .fc-event-time{margin-right:3px}.fc-direction-rtl .fc-daygrid-event .fc-event-time{margin-left:3px}';
injectStyles(css_248z2);
// node_modules/.pnpm/@fullcalendar+daygrid@6.1.17_@fullcalendar+core@6.1.17/node_modules/@fullcalendar/daygrid/index.js
var index = createPlugin({
name: "@fullcalendar/daygrid",
initialView: "dayGridMonth",
views: {
dayGrid: {
component: DayTableView,
dateProfileGeneratorClass: TableDateProfileGenerator
},
dayGridDay: {
type: "dayGrid",
duration: { days: 1 }
},
dayGridWeek: {
type: "dayGrid",
duration: { weeks: 1 }
},
dayGridMonth: {
type: "dayGrid",
duration: { months: 1 },
fixedWeekCount: true
},
dayGridYear: {
type: "dayGrid",
duration: { years: 1 }
}
}
});
// node_modules/.pnpm/@fullcalendar+list@6.1.17_@fullcalendar+core@6.1.17/node_modules/@fullcalendar/list/internal.js
var ListViewHeaderRow = class 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);
let text = options.listDayFormat ? dateEnv.format(dayDate, options.listDayFormat) : "";
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);
return y(ContentContainer, { elTag: "tr", elClasses: [
"fc-list-day",
...getDayClassNames(dayMeta, theme)
], elAttrs: {
"data-date": formatDayString(dayDate)
}, renderProps, generatorName: "dayHeaderContent", customGenerator: options.dayHeaderContent, defaultGenerator: renderInnerContent3, classNameGenerator: options.dayHeaderClassNames, didMount: options.dayHeaderDidMount, willUnmount: options.dayHeaderWillUnmount }, (InnerContent) => (
// TODO: force-hide top border based on :first-child
y(
"th",
{ scope: "colgroup", colSpan: 3, id: cellId, "aria-labelledby": textId },
y(InnerContent, { elTag: "div", elClasses: [
"fc-list-day-cushion",
theme.getClass("tableCellShaded")
] })
)
));
}
};
function renderInnerContent3(props) {
return y(
_,
null,
props.text && y("a", Object.assign({ id: props.textId, className: "fc-list-day-text" }, props.navLinkAttrs), props.text),
props.sideText && /* not keyboard tabbable */
y("a", Object.assign({ "aria-hidden": true, className: "fc-list-day-side-text" }, props.sideNavLinkAttrs), props.sideText)
);
}
var DEFAULT_TIME_FORMAT = createFormatter({
hour: "numeric",
minute: "2-digit",
meridiem: "short"
});
var ListViewEventRow = class extends BaseComponent {
render() {
let { props, context } = this;
let { options } = context;
let { seg, timeHeaderId, eventHeaderId, dateHeaderId } = props;
let timeFormat = options.eventTimeFormat || DEFAULT_TIME_FORMAT;
return y(EventContainer, Object.assign({}, props, { elTag: "tr", elClasses: [
"fc-list-event",
seg.eventRange.def.url && "fc-event-forced-url"
], defaultGenerator: () => renderEventInnerContent(seg, context), seg, timeText: "", disableDragging: true, disableResizing: true }), (InnerContent, eventContentArg) => y(
_,
null,
buildTimeContent(seg, timeFormat, context, timeHeaderId, dateHeaderId),
y(
"td",
{ "aria-hidden": true, className: "fc-list-event-graphic" },
y("span", { className: "fc-list-event-dot", style: {
borderColor: eventContentArg.borderColor || eventContentArg.backgroundColor
} })
),
y(InnerContent, { elTag: "td", elClasses: ["fc-list-event-title"], elAttrs: { headers: `${eventHeaderId} ${dateHeaderId}` } })
));
}
};
function renderEventInnerContent(seg, context) {
let interactiveAttrs = getSegAnchorAttrs(seg, context);
return y("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)) {
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 y(ContentContainer, { elTag: "td", elClasses: ["fc-list-event-time"], elAttrs: {
headers: `${timeHeaderId} ${dateHeaderId}`
}, renderProps, generatorName: "allDayContent", customGenerator: options.allDayContent, defaultGenerator: renderAllDayInner, classNameGenerator: options.allDayClassNames, didMount: options.allDayDidMount, willUnmount: options.allDayWillUnmount });
}
return y("td", { className: "fc-list-event-time" }, timeText);
}
return null;
}
function renderAllDayInner(renderProps) {
return renderProps.text;
}
var ListView = class 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 y(
ViewContainer,
{ elRef: this.setRootEl, elClasses: [
"fc-list",
context.theme.getClass("table"),
context.options.stickyHeaderDates !== false ? "fc-list-sticky" : ""
], viewSpec: context.viewSpec },
y(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 y(ContentContainer, { elTag: "div", elClasses: ["fc-list-empty"], renderProps, generatorName: "noEventsContent", customGenerator: options.noEventsContent, defaultGenerator: renderNoEventsInner, classNameGenerator: options.noEventsClassNames, didMount: options.noEventsDidMount, willUnmount: options.noEventsWillUnmount }, (InnerContent) => y(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);
return y(NowTimer, { unit: "day" }, (nowDate, todayRange) => {
let innerNodes = [];
for (let dayIndex = 0; dayIndex < segsByDay.length; dayIndex += 1) {
let daySegs = segsByDay[dayIndex];
if (daySegs) {
let dayStr = formatDayString(dayDates[dayIndex]);
let dateHeaderId = dateHeaderIdRoot + "-" + dayStr;
innerNodes.push(y(ListViewHeaderRow, { key: dayStr, cellId: dateHeaderId, dayDate: dayDates[dayIndex], todayRange }));
daySegs = sortEventSegs(daySegs, options.eventOrder);
for (let seg of daySegs) {
innerNodes.push(y(ListViewEventRow, Object.assign({ key: dayStr + ":" + seg.eventRange.instance.instanceId, seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: false, timeHeaderId, eventHeaderId, dateHeaderId }, getSegMeta(seg, todayRange, nowDate))));
}
}
}
return y(
"table",
{ className: "fc-list-table " + theme.getClass("table") },
y(
"thead",
null,
y(
"tr",
null,
y("th", { scope: "col", id: timeHeaderId }, options.timeHint),
y("th", { scope: "col", "aria-hidden": true }),
y("th", { scope: "col", id: eventHeaderId }, options.eventHint)
)
),
y("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);
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 };
}
function groupSegsByDay(segs) {
let segsByDay = [];
let i3;
let seg;
for (i3 = 0; i3 < segs.length; i3 += 1) {
seg = segs[i3];
(segsByDay[seg.dayIndex] || (segsByDay[seg.dayIndex] = [])).push(seg);
}
return segsByDay;
}
var css_248z3 = ':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_248z3);
// node_modules/.pnpm/@fullcalendar+list@6.1.17_@fullcalendar+core@6.1.17/node_modules/@fullcalendar/list/index.js
var 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 index2 = 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
}
}
});
// node_modules/.pnpm/@fullcalendar+timegrid@6.1.17_@fullcalendar+core@6.1.17/node_modules/@fullcalendar/timegrid/internal.js
var AllDaySplitter = class extends Splitter {
getKeyInfo() {
return {
allDay: {},
timed: {}
};
}
getKeysForDateSpan(dateSpan) {
if (dateSpan.allDay) {
return ["allDay"];
}
return ["timed"];
}
getKeysForEventDef(eventDef) {
if (!eventDef.allDay) {
return ["timed"];
}
if (hasBgRendering(eventDef)) {
return ["timed", "allDay"];
}
return ["allDay"];
}
};
var DEFAULT_SLAT_LABEL_FORMAT = createFormatter({
hour: "numeric",
minute: "2-digit",
omitZeroMinute: true,
meridiem: "short"
});
function TimeColsAxisCell(props) {
let classNames = [
"fc-timegrid-slot",
"fc-timegrid-slot-label",
props.isLabeled ? "fc-scrollgrid-shrink" : "fc-timegrid-slot-minor"
];
return y(ViewContextType.Consumer, null, (context) => {
if (!props.isLabeled) {
return y("td", { className: classNames.join(" "), "data-time": props.isoTimeStr });
}
let { dateEnv, options, viewApi } = context;
let labelFormat = (
// TODO: fully pre-parse
options.slotLabelFormat == null ? DEFAULT_SLAT_LABEL_FORMAT : Array.isArray(options.slotLabelFormat) ? createFormatter(options.slotLabelFormat[0]) : createFormatter(options.slotLabelFormat)
);
let renderProps = {
level: 0,
time: props.time,
date: dateEnv.toDate(props.date),
view: viewApi,
text: dateEnv.format(props.date, labelFormat)
};
return y(ContentContainer, { elTag: "td", elClasses: classNames, elAttrs: {
"data-time": props.isoTimeStr
}, renderProps, generatorName: "slotLabelContent", customGenerator: options.slotLabelContent, defaultGenerator: renderInnerContent4, classNameGenerator: options.slotLabelClassNames, didMount: options.slotLabelDidMount, willUnmount: options.slotLabelWillUnmount }, (InnerContent) => y(
"div",
{ className: "fc-timegrid-slot-label-frame fc-scrollgrid-shrink-frame" },
y(InnerContent, { elTag: "div", elClasses: [
"fc-timegrid-slot-label-cushion",
"fc-scrollgrid-shrink-cushion"
] })
));
});
}
function renderInnerContent4(props) {
return props.text;
}
var TimeBodyAxis = class extends BaseComponent {
render() {
return this.props.slatMetas.map((slatMeta) => y(
"tr",
{ key: slatMeta.key },
y(TimeColsAxisCell, Object.assign({}, slatMeta))
));
}
};
var DEFAULT_WEEK_NUM_FORMAT2 = createFormatter({ week: "short" });
var AUTO_ALL_DAY_MAX_EVENT_ROWS = 5;
var TimeColsView = class extends DateComponent {
constructor() {
super(...arguments);
this.allDaySplitter = new AllDaySplitter();
this.headerElRef = d();
this.rootElRef = d();
this.scrollerElRef = d();
this.state = {
slatCoords: null
};
this.handleScrollTopRequest = (scrollTop) => {
let scrollerEl = this.scrollerElRef.current;
if (scrollerEl) {
scrollerEl.scrollTop = scrollTop;
}
};
this.renderHeadAxis = (rowKey, frameHeight = "") => {
let { options } = this.context;
let { dateProfile } = this.props;
let range = dateProfile.renderRange;
let dayCnt = diffDays(range.start, range.end);
let navLinkAttrs = dayCnt === 1 ? buildNavLinkAttrs(this.context, range.start, "week") : {};
if (options.weekNumbers && rowKey === "day") {
return y(WeekNumberContainer, { elTag: "th", elClasses: [
"fc-timegrid-axis",
"fc-scrollgrid-shrink"
], elAttrs: {
"aria-hidden": true
}, date: range.start, defaultFormat: DEFAULT_WEEK_NUM_FORMAT2 }, (InnerContent) => y(
"div",
{ className: [
"fc-timegrid-axis-frame",
"fc-scrollgrid-shrink-frame",
"fc-timegrid-axis-frame-liquid"
].join(" "), style: { height: frameHeight } },
y(InnerContent, { elTag: "a", elClasses: [
"fc-timegrid-axis-cushion",
"fc-scrollgrid-shrink-cushion",
"fc-scrollgrid-sync-inner"
], elAttrs: navLinkAttrs })
));
}
return y(
"th",
{ "aria-hidden": true, className: "fc-timegrid-axis" },
y("div", { className: "fc-timegrid-axis-frame", style: { height: frameHeight } })
);
};
this.renderTableRowAxis = (rowHeight) => {
let { options, viewApi } = this.context;
let renderProps = {
text: options.allDayText,
view: viewApi
};
return (
// TODO: make reusable hook. used in list view too
y(ContentContainer, { elTag: "td", elClasses: [
"fc-timegrid-axis",
"fc-scrollgrid-shrink"
], elAttrs: {
"aria-hidden": true
}, renderProps, generatorName: "allDayContent", customGenerator: options.allDayContent, defaultGenerator: renderAllDayInner2, classNameGenerator: options.allDayClassNames, didMount: options.allDayDidMount, willUnmount: options.allDayWillUnmount }, (InnerContent) => y(
"div",
{ className: [
"fc-timegrid-axis-frame",
"fc-scrollgrid-shrink-frame",
rowHeight == null ? " fc-timegrid-axis-frame-liquid" : ""
].join(" "), style: { height: rowHeight } },
y(InnerContent, { elTag: "span", elClasses: [
"fc-timegrid-axis-cushion",
"fc-scrollgrid-shrink-cushion",
"fc-scrollgrid-sync-inner"
] })
))
);
};
this.handleSlatCoords = (slatCoords) => {
this.setState({ slatCoords });
};
}
// rendering
// ----------------------------------------------------------------------------------------------------
renderSimpleLayout(headerRowContent, allDayContent, timeContent) {
let { context, props } = this;
let sections = [];
let stickyHeaderDates = getStickyHeaderDates(context.options);
if (headerRowContent) {
sections.push({
type: "header",
key: "header",
isSticky: stickyHeaderDates,
chunk: {
elRef: this.headerElRef,
tableClassName: "fc-col-header",
rowContent: headerRowContent
}
});
}
if (allDayContent) {
sections.push({
type: "body",
key: "all-day",
chunk: { content: allDayContent }
});
sections.push({
type: "body",
key: "all-day-divider",
outerContent: (
// TODO: rename to cellContent so don't need to define
?
y(
"tr",
{ role: "presentation", className: "fc-scrollgrid-section" },
y("td", { className: "fc-timegrid-divider " + context.theme.getClass("tableCellShaded") })
)
)
});
}
sections.push({
type: "body",
key: "body",
liquid: true,
expandRows: Boolean(context.options.expandRows),
chunk: {
scrollerElRef: this.scrollerElRef,
content: timeContent
}
});
return y(
ViewContainer,
{ elRef: this.rootElRef, elClasses: ["fc-timegrid"], viewSpec: context.viewSpec },
y(SimpleScrollGrid, { liquid: !props.isHeightAuto && !props.forPrint, collapsibleWidth: props.forPrint, cols: [{ width: "shrink" }], sections })
);
}
renderHScrollLayout(headerRowContent, allDayContent, timeContent, colCnt, dayMinWidth, slatMetas, slatCoords) {
let ScrollGrid = this.context.pluginHooks.scrollGridImpl;
if (!ScrollGrid) {
throw new Error("No ScrollGrid implementation");
}
let { context, props } = this;
let stickyHeaderDates = !props.forPrint && getStickyHeaderDates(context.options);
let stickyFooterScrollbar = !props.forPrint && getStickyFooterScrollbar(context.options);
let sections = [];
if (headerRowContent) {
sections.push({
type: "header",
key: "header",
isSticky: stickyHeaderDates,
syncRowHeights: true,
chunks: [
{
key: "axis",
rowContent: (arg) => y("tr", { role: "presentation" }, this.renderHeadAxis("day", arg.rowSyncHeights[0]))
},
{
key: "cols",
elRef: this.headerElRef,
tableClassName: "fc-col-header",
rowContent: headerRowContent
}
]
});
}
if (allDayContent) {
sections.push({
type: "body",
key: "all-day",
syncRowHeights: true,
chunks: [
{
key: "axis",
rowContent: (contentArg) => y("tr", { role: "presentation" }, this.renderTableRowAxis(contentArg.rowSyncHeights[0]))
},
{
key: "cols",
content: allDayContent
}
]
});
sections.push({
key: "all-day-divider",
type: "body",
outerContent: (
// TODO: rename to cellContent so don't need to define
?
y(
"tr",
{ role: "presentation", className: "fc-scrollgrid-section" },
y("td", { colSpan: 2, className: "fc-timegrid-divider " + context.theme.getClass("tableCellShaded") })
)
)
});
}
let isNowIndicator = context.options.nowIndicator;
sections.push({
type: "body",
key: "body",
liquid: true,
expandRows: Boolean(context.options.expandRows),
chunks: [
{
key: "axis",
content: (arg) => (
// TODO: make this now-indicator arrow more DRY with TimeColsContent
y(
"div",
{ className: "fc-timegrid-axis-chunk" },
y(
"table",
{ "aria-hidden": true, style: { height: arg.expandRows ? arg.clientHeight : "" } },
arg.tableColGroupNode,
y(
"tbody",
null,
y(TimeBodyAxis, { slatMetas })
)
),
y(
"div",
{ className: "fc-timegrid-now-indicator-container" },
y(NowTimer, {
unit: isNowIndicator ? "minute" : "day"
/* hacky */
}, (nowDate) => {
let nowIndicatorTop = isNowIndicator && slatCoords && slatCoords.safeComputeTop(nowDate);
if (typeof nowIndicatorTop === "number") {
return y(NowIndicatorContainer, { elClasses: ["fc-timegrid-now-indicator-arrow"], elStyle: { top: nowIndicatorTop }, isAxis: true, date: nowDate });
}
return null;
})
)
)
)
},
{
key: "cols",
scrollerElRef: this.scrollerElRef,
content: timeContent
}
]
});
if (stickyFooterScrollbar) {
sections.push({
key: "footer",
type: "footer",
isSticky: true,
chunks: [
{
key: "axis",
content: renderScrollShim
},
{
key: "cols",
content: renderScrollShim
}
]
});
}
return y(
ViewContainer,
{ elRef: this.rootElRef, elClasses: ["fc-timegrid"], viewSpec: context.viewSpec },
y(ScrollGrid, { liquid: !props.isHeightAuto && !props.forPrint, forPrint: props.forPrint, collapsibleWidth: false, colGroups: [
{ width: "shrink", cols: [{ width: "shrink" }] },
{ cols: [{ span: colCnt, minWidth: dayMinWidth }] }
], sections })
);
}
/* Dimensions
------------------------------------------------------------------------------------------------------------------*/
getAllDayMaxEventProps() {
let { dayMaxEvents, dayMaxEventRows } = this.context.options;
if (dayMaxEvents === true || dayMaxEventRows === true) {
dayMaxEvents = void 0;
dayMaxEventRows = AUTO_ALL_DAY_MAX_EVENT_ROWS;
}
return { dayMaxEvents, dayMaxEventRows };
}
};
function renderAllDayInner2(renderProps) {
return renderProps.text;
}
var TimeColsSlatsCoords = class {
constructor(positions, dateProfile, slotDuration) {
this.positions = positions;
this.dateProfile = dateProfile;
this.slotDuration = slotDuration;
}
safeComputeTop(date) {
let { dateProfile } = this;
if (rangeContainsMarker(dateProfile.currentRange, date)) {
let startOfDayDate = startOfDay(date);
let timeMs = date.valueOf() - startOfDayDate.valueOf();
if (timeMs >= asRoughMs(dateProfile.slotMinTime) && timeMs < asRoughMs(dateProfile.slotMaxTime)) {
return this.computeTimeTop(createDuration(timeMs));
}
}
return null;
}
// Computes the top coordinate, relative to the bounds of the grid, of the given date.
// A `startOfDayDate` must be given for avoiding ambiguity over how to treat midnight.
computeDateTop(when, startOfDayDate) {
if (!startOfDayDate) {
startOfDayDate = startOfDay(when);
}
return this.computeTimeTop(createDuration(when.valueOf() - startOfDayDate.valueOf()));
}
// Computes the top coordinate, relative to the bounds of the grid, of the given time (a Duration).
// This is a makeshify way to compute the time-top. Assumes all slatMetas dates are uniform.
// Eventually allow computation with arbirary slat dates.
computeTimeTop(duration) {
let { positions, dateProfile } = this;
let len = positions.els.length;
let slatCoverage = (duration.milliseconds - asRoughMs(dateProfile.slotMinTime)) / asRoughMs(this.slotDuration);
let slatIndex;
let slatRemainder;
slatCoverage = Math.max(0, slatCoverage);
slatCoverage = Math.min(len, slatCoverage);
slatIndex = Math.floor(slatCoverage);
slatIndex = Math.min(slatIndex, len - 1);
slatRemainder = slatCoverage - slatIndex;
return positions.tops[slatIndex] + positions.getHeight(slatIndex) * slatRemainder;
}
};
var TimeColsSlatsBody = class extends BaseComponent {
render() {
let { props, context } = this;
let { options } = context;
let { slatElRefs } = props;
return y("tbody", null, props.slatMetas.map((slatMeta, i3) => {
let renderProps = {
time: slatMeta.time,
date: context.dateEnv.toDate(slatMeta.date),
view: context.viewApi
};
return y(
"tr",
{ key: slatMeta.key, ref: slatElRefs.createRef(slatMeta.key) },
props.axis && y(TimeColsAxisCell, Object.assign({}, slatMeta)),
y(ContentContainer, { elTag: "td", elClasses: [
"fc-timegrid-slot",
"fc-timegrid-slot-lane",
!slatMeta.isLabeled && "fc-timegrid-slot-minor"
], elAttrs: {
"data-time": slatMeta.isoTimeStr
}, renderProps, generatorName: "slotLaneContent", customGenerator: options.slotLaneContent, classNameGenerator: options.slotLaneClassNames, didMount: options.slotLaneDidMount, willUnmount: options.slotLaneWillUnmount })
);
}));
}
};
var TimeColsSlats = class extends BaseComponent {
constructor() {
super(...arguments);
this.rootElRef = d();
this.slatElRefs = new RefMap();
}
render() {
let { props, context } = this;
return y(
"div",
{ ref: this.rootElRef, className: "fc-timegrid-slots" },
y(
"table",
{ "aria-hidden": true, className: context.theme.getClass("table"), style: {
minWidth: props.tableMinWidth,
width: props.clientWidth,
height: props.minHeight
} },
props.tableColGroupNode,
y(TimeColsSlatsBody, { slatElRefs: this.slatElRefs, axis: props.axis, slatMetas: props.slatMetas })
)
);
}
componentDidMount() {
this.updateSizing();
}
componentDidUpdate() {
this.updateSizing();
}
componentWillUnmount() {
if (this.props.onCoords) {
this.props.onCoords(null);
}
}
updateSizing() {
let { context, props } = this;
if (props.onCoords && props.clientWidth !== null) {
let rootEl = this.rootElRef.current;
if (rootEl.offsetHeight) {
props.onCoords(new TimeColsSlatsCoords(new PositionCache(this.rootElRef.current, collectSlatEls(this.slatElRefs.currentMap, props.slatMetas), false, true), this.props.dateProfile, context.options.slotDuration));
}
}
}
};
function collectSlatEls(elMap, slatMetas) {
return slatMetas.map((slatMeta) => elMap[slatMeta.key]);
}
function splitSegsByCol(segs, colCnt) {
let segsByCol = [];
let i3;
for (i3 = 0; i3 < colCnt; i3 += 1) {
segsByCol.push([]);
}
if (segs) {
for (i3 = 0; i3 < segs.length; i3 += 1) {
segsByCol[segs[i3].col].push(segs[i3]);
}
}
return segsByCol;
}
function splitInteractionByCol(ui, colCnt) {
let byRow = [];
if (!ui) {
for (let i3 = 0; i3 < colCnt; i3 += 1) {
byRow[i3] = null;
}
} else {
for (let i3 = 0; i3 < colCnt; i3 += 1) {
byRow[i3] = {
affectedInstances: ui.affectedInstances,
isEvent: ui.isEvent,
segs: []
};
}
for (let seg of ui.segs) {
byRow[seg.col].segs.push(seg);
}
}
return byRow;
}
var TimeColMoreLink = class extends BaseComponent {
render() {
let { props } = this;
return y(MoreLinkContainer, { elClasses: ["fc-timegrid-more-link"], elStyle: {
top: props.top,
bottom: props.bottom
}, allDayDate: null, moreCnt: props.hiddenSegs.length, allSegs: props.hiddenSegs, hiddenSegs: props.hiddenSegs, extraDateSpan: props.extraDateSpan, dateProfile: props.dateProfile, todayRange: props.todayRange, popoverContent: () => renderPlainFgSegs(props.hiddenSegs, props), defaultGenerator: renderMoreLinkInner2, forceTimed: true }, (InnerContent) => y(InnerContent, { elTag: "div", elClasses: ["fc-timegrid-more-link-inner", "fc-sticky"] }));
}
};
function renderMoreLinkInner2(props) {
return props.shortText;
}
function buildPositioning(segInputs, strictOrder, maxStackCnt) {
let hierarchy = new SegHierarchy();
if (strictOrder != null) {
hierarchy.strictOrder = strictOrder;
}
if (maxStackCnt != null) {
hierarchy.maxStackCnt = maxStackCnt;
}
let hiddenEntries = hierarchy.addSegs(segInputs);
let hiddenGroups = groupIntersectingEntries(hiddenEntries);
let web = buildWeb(hierarchy);
web = stretchWeb(web, 1);
let segRects = webToRects(web);
return { segRects, hiddenGroups };
}
function buildWeb(hierarchy) {
const { entriesByLevel } = hierarchy;
const buildNode = cacheable((level, lateral) => level + ":" + lateral, (level, lateral) => {
let siblingRange = findNextLevelSegs(hierarchy, level, lateral);
let nextLevelRes = buildNodes(siblingRange, buildNode);
let entry = entriesByLevel[level][lateral];
return [
Object.assign(Object.assign({}, entry), { nextLevelNodes: nextLevelRes[0] }),
entry.thickness + nextLevelRes[1]
// the pressure builds
];
});
return buildNodes(entriesByLevel.length ? { level: 0, lateralStart: 0, lateralEnd: entriesByLevel[0].length } : null, buildNode)[0];
}
function buildNodes(siblingRange, buildNode) {
if (!siblingRange) {
return [[], 0];
}
let { level, lateralStart, lateralEnd } = siblingRange;
let lateral = lateralStart;
let pairs = [];
while (lateral < lateralEnd) {
pairs.push(buildNode(level, lateral));
lateral += 1;
}
pairs.sort(cmpDescPressures);
return [
pairs.map(extractNode),
pairs[0][1]
// first item's pressure
];
}
function cmpDescPressures(a3, b3) {
return b3[1] - a3[1];
}
function extractNode(a3) {
return a3[0];
}
function findNextLevelSegs(hierarchy, subjectLevel, subjectLateral) {
let { levelCoords, entriesByLevel } = hierarchy;
let subjectEntry = entriesByLevel[subjectLevel][subjectLateral];
let afterSubject = levelCoords[subjectLevel] + subjectEntry.thickness;
let levelCnt = levelCoords.length;
let level = subjectLevel;
for (; level < levelCnt && levelCoords[level] < afterSubject; level += 1)
;
for (; level < levelCnt; level += 1) {
let entries = entriesByLevel[level];
let entry;
let searchIndex = binarySearch(entries, subjectEntry.span.start, getEntrySpanEnd);
let lateralStart = searchIndex[0] + searchIndex[1];
let lateralEnd = lateralStart;
while (
// loop through entries that horizontally intersect
(entry = entries[lateralEnd]) && // but not past the whole seg list
entry.span.start < subjectEntry.span.end
) {
lateralEnd += 1;
}
if (lateralStart < lateralEnd) {
return { level, lateralStart, lateralEnd };
}
}
return null;
}
function stretchWeb(topLevelNodes, totalThickness) {
const stretchNode = cacheable((node, startCoord, prevThickness) => buildEntryKey(node), (node, startCoord, prevThickness) => {
let { nextLevelNodes, thickness } = node;
let allThickness = thickness + prevThickness;
let thicknessFraction = thickness / allThickness;
let endCoord;
let newChildren = [];
if (!nextLevelNodes.length) {
endCoord = totalThickness;
} else {
for (let childNode of nextLevelNodes) {
if (endCoord === void 0) {
let res = stretchNode(childNode, startCoord, allThickness);
endCoord = res[0];
newChildren.push(res[1]);
} else {
let res = stretchNode(childNode, endCoord, 0);
newChildren.push(res[1]);
}
}
}
let newThickness = (endCoord - startCoord) * thicknessFraction;
return [endCoord - newThickness, Object.assign(Object.assign({}, node), { thickness: newThickness, nextLevelNodes: newChildren })];
});
return topLevelNodes.map((node) => stretchNode(node, 0, 0)[1]);
}
function webToRects(topLevelNodes) {
let rects = [];
const processNode = cacheable((node, levelCoord, stackDepth) => buildEntryKey(node), (node, levelCoord, stackDepth) => {
let rect = Object.assign(Object.assign({}, node), {
levelCoord,
stackDepth,
stackForward: 0
});
rects.push(rect);
return rect.stackForward = processNodes(node.nextLevelNodes, levelCoord + node.thickness, stackDepth + 1) + 1;
});
function processNodes(nodes, levelCoord, stackDepth) {
let stackForward = 0;
for (let node of nodes) {
stackForward = Math.max(processNode(node, levelCoord, stackDepth), stackForward);
}
return stackForward;
}
processNodes(topLevelNodes, 0, 0);
return rects;
}
function cacheable(keyFunc, workFunc) {
const cache = {};
return (...args) => {
let key = keyFunc(...args);
return key in cache ? cache[key] : cache[key] = workFunc(...args);
};
}
function computeSegVCoords(segs, colDate, slatCoords = null, eventMinHeight = 0) {
let vcoords = [];
if (slatCoords) {
for (let i3 = 0; i3 < segs.length; i3 += 1) {
let seg = segs[i3];
let spanStart = slatCoords.computeDateTop(seg.start, colDate);
let spanEnd = Math.max(
spanStart + (eventMinHeight || 0),
// :(
slatCoords.computeDateTop(seg.end, colDate)
);
vcoords.push({
start: Math.round(spanStart),
end: Math.round(spanEnd)
//
});
}
}
return vcoords;
}
function computeFgSegPlacements(segs, segVCoords, eventOrderStrict, eventMaxStack) {
let segInputs = [];
let dumbSegs = [];
for (let i3 = 0; i3 < segs.length; i3 += 1) {
let vcoords = segVCoords[i3];
if (vcoords) {
segInputs.push({
index: i3,
thickness: 1,
span: vcoords
});
} else {
dumbSegs.push(segs[i3]);
}
}
let { segRects, hiddenGroups } = buildPositioning(segInputs, eventOrderStrict, eventMaxStack);
let segPlacements = [];
for (let segRect of segRects) {
segPlacements.push({
seg: segs[segRect.index],
rect: segRect
});
}
for (let dumbSeg of dumbSegs) {
segPlacements.push({ seg: dumbSeg, rect: null });
}
return { segPlacements, hiddenGroups };
}
var DEFAULT_TIME_FORMAT2 = createFormatter({
hour: "numeric",
minute: "2-digit",
meridiem: false
});
var TimeColEvent = class extends BaseComponent {
render() {
return y(StandardEvent, Object.assign({}, this.props, { elClasses: [
"fc-timegrid-event",
"fc-v-event",
this.props.isShort && "fc-timegrid-event-short"
], defaultTimeFormat: DEFAULT_TIME_FORMAT2 }));
}
};
var TimeCol = class extends BaseComponent {
constructor() {
super(...arguments);
this.sortEventSegs = memoize(sortEventSegs);
}
// TODO: memoize event-placement?
render() {
let { props, context } = this;
let { options } = context;
let isSelectMirror = options.selectMirror;
let mirrorSegs = (
// yuck
props.eventDrag && props.eventDrag.segs || props.eventResize && props.eventResize.segs || isSelectMirror && props.dateSelectionSegs || []
);
let interactionAffectedInstances = (
// TODO: messy way to compute this
props.eventDrag && props.eventDrag.affectedInstances || props.eventResize && props.eventResize.affectedInstances || {}
);
let sortedFgSegs = this.sortEventSegs(props.fgEventSegs, options.eventOrder);
return y(DayCellContainer, { elTag: "td", elRef: props.elRef, elClasses: [
"fc-timegrid-col",
...props.extraClassNames || []
], elAttrs: Object.assign({ role: "gridcell" }, props.extraDataAttrs), date: props.date, dateProfile: props.dateProfile, todayRange: props.todayRange, extraRenderProps: props.extraRenderProps }, (InnerContent) => y(
"div",
{ className: "fc-timegrid-col-frame" },
y(
"div",
{ className: "fc-timegrid-col-bg" },
this.renderFillSegs(props.businessHourSegs, "non-business"),
this.renderFillSegs(props.bgEventSegs, "bg-event"),
this.renderFillSegs(props.dateSelectionSegs, "highlight")
),
y("div", { className: "fc-timegrid-col-events" }, this.renderFgSegs(sortedFgSegs, interactionAffectedInstances, false, false, false)),
y("div", { className: "fc-timegrid-col-events" }, this.renderFgSegs(mirrorSegs, {}, Boolean(props.eventDrag), Boolean(props.eventResize), Boolean(isSelectMirror), "mirror")),
y("div", { className: "fc-timegrid-now-indicator-container" }, this.renderNowIndicator(props.nowIndicatorSegs)),
hasCustomDayCellContent(options) && y(InnerContent, { elTag: "div", elClasses: ["fc-timegrid-col-misc"] })
));
}
renderFgSegs(sortedFgSegs, segIsInvisible, isDragging, isResizing, isDateSelecting, forcedKey) {
let { props } = this;
if (props.forPrint) {
return renderPlainFgSegs(sortedFgSegs, props);
}
return this.renderPositionedFgSegs(sortedFgSegs, segIsInvisible, isDragging, isResizing, isDateSelecting, forcedKey);
}
renderPositionedFgSegs(segs, segIsInvisible, isDragging, isResizing, isDateSelecting, forcedKey) {
let { eventMaxStack, eventShortHeight, eventOrderStrict, eventMinHeight } = this.context.options;
let { date, slatCoords, eventSelection, todayRange, nowDate } = this.props;
let isMirror = isDragging || isResizing || isDateSelecting;
let segVCoords = computeSegVCoords(segs, date, slatCoords, eventMinHeight);
let { segPlacements, hiddenGroups } = computeFgSegPlacements(segs, segVCoords, eventOrderStrict, eventMaxStack);
return y(
_,
null,
this.renderHiddenGroups(hiddenGroups, segs),
segPlacements.map((segPlacement) => {
let { seg, rect } = segPlacement;
let instanceId = seg.eventRange.instance.instanceId;
let isVisible = isMirror || Boolean(!segIsInvisible[instanceId] && rect);
let vStyle = computeSegVStyle(rect && rect.span);
let hStyle = !isMirror && rect ? this.computeSegHStyle(rect) : { left: 0, right: 0 };
let isInset = Boolean(rect) && rect.stackForward > 0;
let isShort = Boolean(rect) && rect.span.end - rect.span.start < eventShortHeight;
return y(
"div",
{ className: "fc-timegrid-event-harness" + (isInset ? " fc-timegrid-event-harness-inset" : ""), key: forcedKey || instanceId, style: Object.assign(Object.assign({ visibility: isVisible ? "" : "hidden" }, vStyle), hStyle) },
y(TimeColEvent, Object.assign({ seg, isDragging, isResizing, isDateSelecting, isSelected: instanceId === eventSelection, isShort }, getSegMeta(seg, todayRange, nowDate)))
);
})
);
}
// will already have eventMinHeight applied because segInputs already had it
renderHiddenGroups(hiddenGroups, segs) {
let { extraDateSpan, dateProfile, todayRange, nowDate, eventSelection, eventDrag, eventResize } = this.props;
return y(_, null, hiddenGroups.map((hiddenGroup) => {
let positionCss = computeSegVStyle(hiddenGroup.span);
let hiddenSegs = compileSegsFromEntries(hiddenGroup.entries, segs);
return y(TimeColMoreLink, { key: buildIsoString(computeEarliestSegStart(hiddenSegs)), hiddenSegs, top: positionCss.top, bottom: positionCss.bottom, extraDateSpan, dateProfile, todayRange, nowDate, eventSelection, eventDrag, eventResize });
}));
}
renderFillSegs(segs, fillType) {
let { props, context } = this;
let segVCoords = computeSegVCoords(segs, props.date, props.slatCoords, context.options.eventMinHeight);
let children = segVCoords.map((vcoords, i3) => {
let seg = segs[i3];
return y("div", { key: buildEventRangeKey(seg.eventRange), className: "fc-timegrid-bg-harness", style: computeSegVStyle(vcoords) }, fillType === "bg-event" ? y(BgEvent, Object.assign({ seg }, getSegMeta(seg, props.todayRange, props.nowDate))) : renderFill(fillType));
});
return y(_, null, children);
}
renderNowIndicator(segs) {
let { slatCoords, date } = this.props;
if (!slatCoords) {
return null;
}
return segs.map((seg, i3) => y(
NowIndicatorContainer,
{
// key doesn't matter. will only ever be one
key: i3,
elClasses: ["fc-timegrid-now-indicator-line"],
elStyle: {
top: slatCoords.computeDateTop(seg.start, date)
},
isAxis: false,
date
}
));
}
computeSegHStyle(segHCoords) {
let { isRtl, options } = this.context;
let shouldOverlap = options.slotEventOverlap;
let nearCoord = segHCoords.levelCoord;
let farCoord = segHCoords.levelCoord + segHCoords.thickness;
let left;
let right;
if (shouldOverlap) {
farCoord = Math.min(1, nearCoord + (farCoord - nearCoord) * 2);
}
if (isRtl) {
left = 1 - farCoord;
right = nearCoord;
} else {
left = nearCoord;
right = 1 - farCoord;
}
let props = {
zIndex: segHCoords.stackDepth + 1,
left: left * 100 + "%",
right: right * 100 + "%"
};
if (shouldOverlap && !segHCoords.stackForward) {
props[isRtl ? "marginLeft" : "marginRight"] = 10 * 2;
}
return props;
}
};
function renderPlainFgSegs(sortedFgSegs, { todayRange, nowDate, eventSelection, eventDrag, eventResize }) {
let hiddenInstances = (eventDrag ? eventDrag.affectedInstances : null) || (eventResize ? eventResize.affectedInstances : null) || {};
return y(_, null, sortedFgSegs.map((seg) => {
let instanceId = seg.eventRange.instance.instanceId;
return y(
"div",
{ key: instanceId, style: { visibility: hiddenInstances[instanceId] ? "hidden" : "" } },
y(TimeColEvent, Object.assign({ seg, isDragging: false, isResizing: false, isDateSelecting: false, isSelected: instanceId === eventSelection, isShort: false }, getSegMeta(seg, todayRange, nowDate)))
);
}));
}
function computeSegVStyle(segVCoords) {
if (!segVCoords) {
return { top: "", bottom: "" };
}
return {
top: segVCoords.start,
bottom: -segVCoords.end
};
}
function compileSegsFromEntries(segEntries, allSegs) {
return segEntries.map((segEntry) => allSegs[segEntry.index]);
}
var TimeColsContent = class extends BaseComponent {
constructor() {
super(...arguments);
this.splitFgEventSegs = memoize(splitSegsByCol);
this.splitBgEventSegs = memoize(splitSegsByCol);
this.splitBusinessHourSegs = memoize(splitSegsByCol);
this.splitNowIndicatorSegs = memoize(splitSegsByCol);
this.splitDateSelectionSegs = memoize(splitSegsByCol);
this.splitEventDrag = memoize(splitInteractionByCol);
this.splitEventResize = memoize(splitInteractionByCol);
this.rootElRef = d();
this.cellElRefs = new RefMap();
}
render() {
let { props, context } = this;
let nowIndicatorTop = context.options.nowIndicator && props.slatCoords && props.slatCoords.safeComputeTop(props.nowDate);
let colCnt = props.cells.length;
let fgEventSegsByRow = this.splitFgEventSegs(props.fgEventSegs, colCnt);
let bgEventSegsByRow = this.splitBgEventSegs(props.bgEventSegs, colCnt);
let businessHourSegsByRow = this.splitBusinessHourSegs(props.businessHourSegs, colCnt);
let nowIndicatorSegsByRow = this.splitNowIndicatorSegs(props.nowIndicatorSegs, colCnt);
let dateSelectionSegsByRow = this.splitDateSelectionSegs(props.dateSelectionSegs, colCnt);
let eventDragByRow = this.splitEventDrag(props.eventDrag, colCnt);
let eventResizeByRow = this.splitEventResize(props.eventResize, colCnt);
return y(
"div",
{ className: "fc-timegrid-cols", ref: this.rootElRef },
y(
"table",
{ role: "presentation", style: {
minWidth: props.tableMinWidth,
width: props.clientWidth
} },
props.tableColGroupNode,
y(
"tbody",
{ role: "presentation" },
y(
"tr",
{ role: "row" },
props.axis && y(
"td",
{ "aria-hidden": true, className: "fc-timegrid-col fc-timegrid-axis" },
y(
"div",
{ className: "fc-timegrid-col-frame" },
y("div", { className: "fc-timegrid-now-indicator-container" }, typeof nowIndicatorTop === "number" && y(NowIndicatorContainer, { elClasses: ["fc-timegrid-now-indicator-arrow"], elStyle: { top: nowIndicatorTop }, isAxis: true, date: props.nowDate }))
)
),
props.cells.map((cell, i3) => y(TimeCol, { key: cell.key, elRef: this.cellElRefs.createRef(cell.key), dateProfile: props.dateProfile, date: cell.date, nowDate: props.nowDate, todayRange: props.todayRange, extraRenderProps: cell.extraRenderProps, extraDataAttrs: cell.extraDataAttrs, extraClassNames: cell.extraClassNames, extraDateSpan: cell.extraDateSpan, fgEventSegs: fgEventSegsByRow[i3], bgEventSegs: bgEventSegsByRow[i3], businessHourSegs: businessHourSegsByRow[i3], nowIndicatorSegs: nowIndicatorSegsByRow[i3], dateSelectionSegs: dateSelectionSegsByRow[i3], eventDrag: eventDragByRow[i3], eventResize: eventResizeByRow[i3], slatCoords: props.slatCoords, eventSelection: props.eventSelection, forPrint: props.forPrint }))
)
)
)
);
}
componentDidMount() {
this.updateCoords();
}
componentDidUpdate() {
this.updateCoords();
}
updateCoords() {
let { props } = this;
if (props.onColCoords && props.clientWidth !== null) {
props.onColCoords(new PositionCache(
this.rootElRef.current,
collectCellEls(this.cellElRefs.currentMap, props.cells),
true,
// horizontal
false
));
}
}
};
function collectCellEls(elMap, cells) {
return cells.map((cell) => elMap[cell.key]);
}
var TimeCols = class extends DateComponent {
constructor() {
super(...arguments);
this.processSlotOptions = memoize(processSlotOptions);
this.state = {
slatCoords: null
};
this.handleRootEl = (el) => {
if (el) {
this.context.registerInteractiveComponent(this, {
el,
isHitComboAllowed: this.props.isHitComboAllowed
});
} else {
this.context.unregisterInteractiveComponent(this);
}
};
this.handleScrollRequest = (request) => {
let { onScrollTopRequest } = this.props;
let { slatCoords } = this.state;
if (onScrollTopRequest && slatCoords) {
if (request.time) {
let top = slatCoords.computeTimeTop(request.time);
top = Math.ceil(top);
if (top) {
top += 1;
}
onScrollTopRequest(top);
}
return true;
}
return false;
};
this.handleColCoords = (colCoords) => {
this.colCoords = colCoords;
};
this.handleSlatCoords = (slatCoords) => {
this.setState({ slatCoords });
if (this.props.onSlatCoords) {
this.props.onSlatCoords(slatCoords);
}
};
}
render() {
let { props, state } = this;
return y(
"div",
{ className: "fc-timegrid-body", ref: this.handleRootEl, style: {
// these props are important to give this wrapper correct dimensions for interactions
// TODO: if we set it here, can we avoid giving to inner tables?
width: props.clientWidth,
minWidth: props.tableMinWidth
} },
y(TimeColsSlats, { axis: props.axis, dateProfile: props.dateProfile, slatMetas: props.slatMetas, clientWidth: props.clientWidth, minHeight: props.expandRows ? props.clientHeight : "", tableMinWidth: props.tableMinWidth, tableColGroupNode: props.axis ? props.tableColGroupNode : null, onCoords: this.handleSlatCoords }),
y(TimeColsContent, { cells: props.cells, axis: props.axis, dateProfile: props.dateProfile, businessHourSegs: props.businessHourSegs, bgEventSegs: props.bgEventSegs, fgEventSegs: props.fgEventSegs, dateSelectionSegs: props.dateSelectionSegs, eventSelection: props.eventSelection, eventDrag: props.eventDrag, eventResize: props.eventResize, todayRange: props.todayRange, nowDate: props.nowDate, nowIndicatorSegs: props.nowIndicatorSegs, clientWidth: props.clientWidth, tableMinWidth: props.tableMinWidth, tableColGroupNode: props.tableColGroupNode, slatCoords: state.slatCoords, onColCoords: this.handleColCoords, forPrint: props.forPrint })
);
}
componentDidMount() {
this.scrollResponder = this.context.createScrollResponder(this.handleScrollRequest);
}
componentDidUpdate(prevProps) {
this.scrollResponder.update(prevProps.dateProfile !== this.props.dateProfile);
}
componentWillUnmount() {
this.scrollResponder.detach();
}
queryHit(positionLeft, positionTop) {
let { dateEnv, options } = this.context;
let { colCoords } = this;
let { dateProfile } = this.props;
let { slatCoords } = this.state;
let { snapDuration, snapsPerSlot } = this.processSlotOptions(this.props.slotDuration, options.snapDuration);
let colIndex = colCoords.leftToIndex(positionLeft);
let slatIndex = slatCoords.positions.topToIndex(positionTop);
if (colIndex != null && slatIndex != null) {
let cell = this.props.cells[colIndex];
let slatTop = slatCoords.positions.tops[slatIndex];
let slatHeight = slatCoords.positions.getHeight(slatIndex);
let partial = (positionTop - slatTop) / slatHeight;
let localSnapIndex = Math.floor(partial * snapsPerSlot);
let snapIndex = slatIndex * snapsPerSlot + localSnapIndex;
let dayDate = this.props.cells[colIndex].date;
let time = addDurations(dateProfile.slotMinTime, multiplyDuration(snapDuration, snapIndex));
let start = dateEnv.add(dayDate, time);
let end = dateEnv.add(start, snapDuration);
return {
dateProfile,
dateSpan: Object.assign({ range: { start, end }, allDay: false }, cell.extraDateSpan),
dayEl: colCoords.els[colIndex],
rect: {
left: colCoords.lefts[colIndex],
right: colCoords.rights[colIndex],
top: slatTop,
bottom: slatTop + slatHeight
},
layer: 0
};
}
return null;
}
};
function processSlotOptions(slotDuration, snapDurationOverride) {
let snapDuration = snapDurationOverride || slotDuration;
let snapsPerSlot = wholeDivideDurations(slotDuration, snapDuration);
if (snapsPerSlot === null) {
snapDuration = slotDuration;
snapsPerSlot = 1;
}
return { snapDuration, snapsPerSlot };
}
var DayTimeColsSlicer = class extends Slicer {
sliceRange(range, dayRanges) {
let segs = [];
for (let col = 0; col < dayRanges.length; col += 1) {
let segRange = intersectRanges(range, dayRanges[col]);
if (segRange) {
segs.push({
start: segRange.start,
end: segRange.end,
isStart: segRange.start.valueOf() === range.start.valueOf(),
isEnd: segRange.end.valueOf() === range.end.valueOf(),
col
});
}
}
return segs;
}
};
var DayTimeCols = class extends DateComponent {
constructor() {
super(...arguments);
this.buildDayRanges = memoize(buildDayRanges);
this.slicer = new DayTimeColsSlicer();
this.timeColsRef = d();
}
render() {
let { props, context } = this;
let { dateProfile, dayTableModel } = props;
let { nowIndicator, nextDayThreshold } = context.options;
let dayRanges = this.buildDayRanges(dayTableModel, dateProfile, context.dateEnv);
return y(NowTimer, { unit: nowIndicator ? "minute" : "day" }, (nowDate, todayRange) => y(TimeCols, Object.assign({ ref: this.timeColsRef }, this.slicer.sliceProps(props, dateProfile, null, context, dayRanges), { forPrint: props.forPrint, axis: props.axis, dateProfile, slatMetas: props.slatMetas, slotDuration: props.slotDuration, cells: dayTableModel.cells[0], tableColGroupNode: props.tableColGroupNode, tableMinWidth: props.tableMinWidth, clientWidth: props.clientWidth, clientHeight: props.clientHeight, expandRows: props.expandRows, nowDate, nowIndicatorSegs: nowIndicator && this.slicer.sliceNowDate(nowDate, dateProfile, nextDayThreshold, context, dayRanges), todayRange, onScrollTopRequest: props.onScrollTopRequest, onSlatCoords: props.onSlatCoords })));
}
};
function buildDayRanges(dayTableModel, dateProfile, dateEnv) {
let ranges = [];
for (let date of dayTableModel.headerDates) {
ranges.push({
start: dateEnv.add(date, dateProfile.slotMinTime),
end: dateEnv.add(date, dateProfile.slotMaxTime)
});
}
return ranges;
}
var STOCK_SUB_DURATIONS = [
{ hours: 1 },
{ minutes: 30 },
{ minutes: 15 },
{ seconds: 30 },
{ seconds: 15 }
];
function buildSlatMetas(slotMinTime, slotMaxTime, explicitLabelInterval, slotDuration, dateEnv) {
let dayStart = /* @__PURE__ */ new Date(0);
let slatTime = slotMinTime;
let slatIterator = createDuration(0);
let labelInterval = explicitLabelInterval || computeLabelInterval(slotDuration);
let metas = [];
while (asRoughMs(slatTime) < asRoughMs(slotMaxTime)) {
let date = dateEnv.add(dayStart, slatTime);
let isLabeled = wholeDivideDurations(slatIterator, labelInterval) !== null;
metas.push({
date,
time: slatTime,
key: date.toISOString(),
isoTimeStr: formatIsoTimeString(date),
isLabeled
});
slatTime = addDurations(slatTime, slotDuration);
slatIterator = addDurations(slatIterator, slotDuration);
}
return metas;
}
function computeLabelInterval(slotDuration) {
let i3;
let labelInterval;
let slotsPerLabel;
for (i3 = STOCK_SUB_DURATIONS.length - 1; i3 >= 0; i3 -= 1) {
labelInterval = createDuration(STOCK_SUB_DURATIONS[i3]);
slotsPerLabel = wholeDivideDurations(labelInterval, slotDuration);
if (slotsPerLabel !== null && slotsPerLabel > 1) {
return labelInterval;
}
}
return slotDuration;
}
var DayTimeColsView = class extends TimeColsView {
constructor() {
super(...arguments);
this.buildTimeColsModel = memoize(buildTimeColsModel);
this.buildSlatMetas = memoize(buildSlatMetas);
}
render() {
let { options, dateEnv, dateProfileGenerator } = this.context;
let { props } = this;
let { dateProfile } = props;
let dayTableModel = this.buildTimeColsModel(dateProfile, dateProfileGenerator);
let splitProps = this.allDaySplitter.splitProps(props);
let slatMetas = this.buildSlatMetas(dateProfile.slotMinTime, dateProfile.slotMaxTime, options.slotLabelInterval, options.slotDuration, dateEnv);
let { dayMinWidth } = options;
let hasAttachedAxis = !dayMinWidth;
let hasDetachedAxis = dayMinWidth;
let headerContent = options.dayHeaders && y(DayHeader, { dates: dayTableModel.headerDates, dateProfile, datesRepDistinctDays: true, renderIntro: hasAttachedAxis ? this.renderHeadAxis : null });
let allDayContent = options.allDaySlot !== false && ((contentArg) => y(DayTable, Object.assign({}, splitProps.allDay, { dateProfile, dayTableModel, nextDayThreshold: options.nextDayThreshold, tableMinWidth: contentArg.tableMinWidth, colGroupNode: contentArg.tableColGroupNode, renderRowIntro: hasAttachedAxis ? this.renderTableRowAxis : null, showWeekNumbers: false, expandRows: false, headerAlignElRef: this.headerElRef, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, forPrint: props.forPrint }, this.getAllDayMaxEventProps())));
let timeGridContent = (contentArg) => y(DayTimeCols, Object.assign({}, splitProps.timed, { dayTableModel, dateProfile, axis: hasAttachedAxis, slotDuration: options.slotDuration, slatMetas, forPrint: props.forPrint, tableColGroupNode: contentArg.tableColGroupNode, tableMinWidth: contentArg.tableMinWidth, clientWidth: contentArg.clientWidth, clientHeight: contentArg.clientHeight, onSlatCoords: this.handleSlatCoords, expandRows: contentArg.expandRows, onScrollTopRequest: this.handleScrollTopRequest }));
return hasDetachedAxis ? this.renderHScrollLayout(headerContent, allDayContent, timeGridContent, dayTableModel.colCnt, dayMinWidth, slatMetas, this.state.slatCoords) : this.renderSimpleLayout(headerContent, allDayContent, timeGridContent);
}
};
function buildTimeColsModel(dateProfile, dateProfileGenerator) {
let daySeries = new DaySeriesModel(dateProfile.renderRange, dateProfileGenerator);
return new DayTableModel(daySeries, false);
}
var css_248z4 = '.fc-v-event{background-color:var(--fc-event-bg-color);border:1px solid var(--fc-event-border-color);display:block}.fc-v-event .fc-event-main{color:var(--fc-event-text-color);height:100%}.fc-v-event .fc-event-main-frame{display:flex;flex-direction:column;height:100%}.fc-v-event .fc-event-time{flex-grow:0;flex-shrink:0;max-height:100%;overflow:hidden}.fc-v-event .fc-event-title-container{flex-grow:1;flex-shrink:1;min-height:0}.fc-v-event .fc-event-title{bottom:0;max-height:100%;overflow:hidden;top:0}.fc-v-event:not(.fc-event-start){border-top-left-radius:0;border-top-right-radius:0;border-top-width:0}.fc-v-event:not(.fc-event-end){border-bottom-left-radius:0;border-bottom-right-radius:0;border-bottom-width:0}.fc-v-event.fc-event-selected:before{left:-10px;right:-10px}.fc-v-event .fc-event-resizer-start{cursor:n-resize}.fc-v-event .fc-event-resizer-end{cursor:s-resize}.fc-v-event:not(.fc-event-selected) .fc-event-resizer{height:var(--fc-event-resizer-thickness);left:0;right:0}.fc-v-event:not(.fc-event-selected) .fc-event-resizer-start{top:calc(var(--fc-event-resizer-thickness)/-2)}.fc-v-event:not(.fc-event-selected) .fc-event-resizer-end{bottom:calc(var(--fc-event-resizer-thickness)/-2)}.fc-v-event.fc-event-selected .fc-event-resizer{left:50%;margin-left:calc(var(--fc-event-resizer-dot-total-width)/-2)}.fc-v-event.fc-event-selected .fc-event-resizer-start{top:calc(var(--fc-event-resizer-dot-total-width)/-2)}.fc-v-event.fc-event-selected .fc-event-resizer-end{bottom:calc(var(--fc-event-resizer-dot-total-width)/-2)}.fc .fc-timegrid .fc-daygrid-body{z-index:2}.fc .fc-timegrid-divider{padding:0 0 2px}.fc .fc-timegrid-body{min-height:100%;position:relative;z-index:1}.fc .fc-timegrid-axis-chunk{position:relative}.fc .fc-timegrid-axis-chunk>table,.fc .fc-timegrid-slots{position:relative;z-index:1}.fc .fc-timegrid-slot{border-bottom:0;height:1.5em}.fc .fc-timegrid-slot:empty:before{content:"\\00a0"}.fc .fc-timegrid-slot-minor{border-top-style:dotted}.fc .fc-timegrid-slot-label-cushion{display:inline-block;white-space:nowrap}.fc .fc-timegrid-slot-label{vertical-align:middle}.fc .fc-timegrid-axis-cushion,.fc .fc-timegrid-slot-label-cushion{padding:0 4px}.fc .fc-timegrid-axis-frame-liquid{height:100%}.fc .fc-timegrid-axis-frame{align-items:center;display:flex;justify-content:flex-end;overflow:hidden}.fc .fc-timegrid-axis-cushion{flex-shrink:0;max-width:60px}.fc-direction-ltr .fc-timegrid-slot-label-frame{text-align:right}.fc-direction-rtl .fc-timegrid-slot-label-frame{text-align:left}.fc-liquid-hack .fc-timegrid-axis-frame-liquid{bottom:0;height:auto;left:0;position:absolute;right:0;top:0}.fc .fc-timegrid-col.fc-day-today{background-color:var(--fc-today-bg-color)}.fc .fc-timegrid-col-frame{min-height:100%;position:relative}.fc-media-screen.fc-liquid-hack .fc-timegrid-col-frame{bottom:0;height:auto;left:0;position:absolute;right:0;top:0}.fc-media-screen .fc-timegrid-cols{bottom:0;left:0;position:absolute;right:0;top:0}.fc-media-screen .fc-timegrid-cols>table{height:100%}.fc-media-screen .fc-timegrid-col-bg,.fc-media-screen .fc-timegrid-col-events,.fc-media-screen .fc-timegrid-now-indicator-container{left:0;position:absolute;right:0;top:0}.fc .fc-timegrid-col-bg{z-index:2}.fc .fc-timegrid-col-bg .fc-non-business{z-index:1}.fc .fc-timegrid-col-bg .fc-bg-event{z-index:2}.fc .fc-timegrid-col-bg .fc-highlight{z-index:3}.fc .fc-timegrid-bg-harness{left:0;position:absolute;right:0}.fc .fc-timegrid-col-events{z-index:3}.fc .fc-timegrid-now-indicator-container{bottom:0;overflow:hidden}.fc-direction-ltr .fc-timegrid-col-events{margin:0 2.5% 0 2px}.fc-direction-rtl .fc-timegrid-col-events{margin:0 2px 0 2.5%}.fc-timegrid-event-harness{position:absolute}.fc-timegrid-event-harness>.fc-timegrid-event{bottom:0;left:0;position:absolute;right:0;top:0}.fc-timegrid-event-harness-inset .fc-timegrid-event,.fc-timegrid-event.fc-event-mirror,.fc-timegrid-more-link{box-shadow:0 0 0 1px var(--fc-page-bg-color)}.fc-timegrid-event,.fc-timegrid-more-link{border-radius:3px;font-size:var(--fc-small-font-size)}.fc-timegrid-event{margin-bottom:1px}.fc-timegrid-event .fc-event-main{padding:1px 1px 0}.fc-timegrid-event .fc-event-time{font-size:var(--fc-small-font-size);margin-bottom:1px;white-space:nowrap}.fc-timegrid-event-short .fc-event-main-frame{flex-direction:row;overflow:hidden}.fc-timegrid-event-short .fc-event-time:after{content:"\\00a0-\\00a0"}.fc-timegrid-event-short .fc-event-title{font-size:var(--fc-small-font-size)}.fc-timegrid-more-link{background:var(--fc-more-link-bg-color);color:var(--fc-more-link-text-color);cursor:pointer;margin-bottom:1px;position:absolute;z-index:9999}.fc-timegrid-more-link-inner{padding:3px 2px;top:0}.fc-direction-ltr .fc-timegrid-more-link{right:0}.fc-direction-rtl .fc-timegrid-more-link{left:0}.fc .fc-timegrid-now-indicator-arrow,.fc .fc-timegrid-now-indicator-line{pointer-events:none}.fc .fc-timegrid-now-indicator-line{border-color:var(--fc-now-indicator-color);border-style:solid;border-width:1px 0 0;left:0;position:absolute;right:0;z-index:4}.fc .fc-timegrid-now-indicator-arrow{border-color:var(--fc-now-indicator-color);border-style:solid;margin-top:-5px;position:absolute;z-index:4}.fc-direction-ltr .fc-timegrid-now-indicator-arrow{border-bottom-color:transparent;border-top-color:transparent;border-width:5px 0 5px 6px;left:0}.fc-direction-rtl .fc-timegrid-now-indicator-arrow{border-bottom-color:transparent;border-top-color:transparent;border-width:5px 6px 5px 0;right:0}';
injectStyles(css_248z4);
// node_modules/.pnpm/@fullcalendar+timegrid@6.1.17_@fullcalendar+core@6.1.17/node_modules/@fullcalendar/timegrid/index.js
var OPTION_REFINERS2 = {
allDaySlot: Boolean
};
var index3 = createPlugin({
name: "@fullcalendar/timegrid",
initialView: "timeGridWeek",
optionRefiners: OPTION_REFINERS2,
views: {
timeGrid: {
component: DayTimeColsView,
usesMinMaxTime: true,
allDaySlot: true,
slotDuration: "00:30:00",
slotEventOverlap: true
// a bad name. confused with overlap/constraint system
},
timeGridDay: {
type: "timeGrid",
duration: { days: 1 }
},
timeGridWeek: {
type: "timeGrid",
duration: { weeks: 1 }
}
}
});
// src/index.ts
var allEvents = [];
window.Webflow ||= [];
window.Webflow.push(() => {
const calendarElement = document.querySelector('[data-element="calendar"]');
if (!calendarElement) return;
allEvents = getEvents();
console.log({ allEvents });
const calendar = new Calendar(calendarElement, {
plugins: [index, index3, index2],
initialView: window.innerWidth < 900 ? "listMonth" : "dayGridMonth",
headerToolbar: {
left: "prev,next today",
center: "title",
right: "dayGridMonth,listMonth"
},
buttonIcons: {
prev: "phosphor-left",
next: "phosphor-right",
dayGridMonth: "phosphor-calendar-blank",
listMonth: "phosphor-list-star"
},
eventDisplay: "block",
events: allEvents,
eventClick(data) {
const { event } = data;
const { type, slug } = event.extendedProps;
if (type && slug) {
window.location.href = `/${type}/${slug}`;
} else {
alert(`Missing type or slug for event: ${event.title}`);
}
},
eventDidMount: function(info) {
const tooltip = document.createElement("div");
tooltip.className = "fc-tooltip";
tooltip.style.position = "absolute";
tooltip.style.padding = "8px";
tooltip.style.background = "white";
tooltip.style.border = "1px solid #ccc";
tooltip.style.borderRadius = "4px";
tooltip.style.boxShadow = "0 2px 10px rgba(0,0,0,0.1)";
tooltip.style.zIndex = "9999";
tooltip.style.display = "none";
const { start, end } = info.event;
const dateOptions = { year: "numeric", month: "short", day: "numeric" };
const timeOptions = { hour: "2-digit", minute: "2-digit" };
let dateRange = "";
if (start && (!end || isNaN(end.getTime()))) {
dateRange = `${start.toLocaleDateString(void 0, dateOptions)} ${start.toLocaleTimeString(void 0, timeOptions)}`;
} else if (start && end) {
const sameDay = start.toDateString() === end.toDateString();
if (sameDay) {
dateRange = `${start.toLocaleDateString(void 0, dateOptions)} ${start.toLocaleTimeString(void 0, timeOptions)} \u2013 ${end.toLocaleTimeString(void 0, timeOptions)}`;
} else {
dateRange = `${start.toLocaleDateString(void 0, dateOptions)} \u2013 ${end.toLocaleDateString(void 0, dateOptions)}`;
}
}
tooltip.innerHTML = `
${info.event.title}
${dateRange}
${info.event.extendedProps.location || ""}
`;
document.body.appendChild(tooltip);
info.el.addEventListener("mouseenter", (e3) => {
tooltip.style.display = "block";
tooltip.style.top = `${e3.pageY + 10}px`;
tooltip.style.left = `${e3.pageX + 10}px`;
});
info.el.addEventListener("mousemove", (e3) => {
tooltip.style.top = `${e3.pageY + 10}px`;
tooltip.style.left = `${e3.pageX + 10}px`;
});
info.el.addEventListener("mouseleave", () => {
tooltip.style.display = "none";
});
}
});
calendar.render();
const filters = document.querySelectorAll("[data-filter]");
filters.forEach((filterBtn) => {
filterBtn.addEventListener("click", () => {
const type = filterBtn.getAttribute("data-filter");
const filtered = type === "all" ? allEvents : allEvents.filter((event) => event.type === type);
calendar.removeAllEvents();
calendar.addEventSource(filtered);
filters.forEach((btn) => btn.classList.remove("is-active"));
filterBtn.classList.add("is-active");
});
});
});
var getEvents = () => {
const scripts = document.querySelectorAll('[data-element="event-data"]');
const events = [...scripts].map((script) => {
const event = JSON.parse(script.textContent);
event.start = new Date(event.start);
if (event.end) {
const endDate = new Date(event.end);
if (isNaN(endDate.getTime())) {
delete event.end;
} else {
event.end = endDate;
}
} else {
delete event.end;
}
return event;
});
return events;
};
})();
//# sourceMappingURL=index.js.map