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((a2) => a2, 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, " "))
)
);
}
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;
}
var Store = class {
constructor() {
this.handlers = [];
}
set(value) {
this.currentValue = value;
for (let handler of this.handlers) {
handler(value);
}
}
subscribe(handler) {
this.handlers.push(handler);
if (this.currentValue !== void 0) {
handler(this.currentValue);
}
}
};
var CustomRenderingStore = class extends Store {
constructor() {
super(...arguments);
this.map = /* @__PURE__ */ new Map();
}
// for consistent order
handle(customRendering) {
const { map } = this;
let updated = false;
if (customRendering.isActive) {
map.set(customRendering.id, customRendering);
updated = true;
} else if (map.has(customRendering.id)) {
map.delete(customRendering.id);
updated = true;
}
if (updated) {
this.set(map);
}
}
};
// node_modules/.pnpm/@fullcalendar+core@6.1.14/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 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":
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
};
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, clippedFramingRange, dateEnv);
}
return [];
}
};
var simpleRecurringEventsPlugin = createPlugin({
name: "simple-recurring-event",
recurringTypes: [recurring],
eventRefiners: SIMPLE_RECURRING_REFINERS
});
function expandRanges(daysOfWeek, startTime, framingRange, dateEnv) {
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 = dateEnv.add(dayMarker, startTime);
} else {
instanceStart = dayMarker;
}
instanceStarts.push(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 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.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();
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 currentDate = getInitialDate(optionsData.calendarOptions, optionsData.dateEnv);
let dateProfile = currentViewData.dateProfileGenerator.build(currentDate);
if (!rangeContainsMarker(dateProfile.activeRange, currentDate)) {
currentDate = dateProfile.currentRange.start;
}
let calendarContext = {
dateEnv: optionsData.dateEnv,
options: optionsData.calendarOptions,
pluginHooks: optionsData.pluginHooks,
calendarApi: props.calendarApi,
dispatch: this.dispatch,
emitter: this.emitter,
getCurrentData: this.getCurrentData
};
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 = {
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({ 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);
let dateProfileGenerator = this.buildDateProfileGenerator({
dateProfileGeneratorClass: viewSpec.optionDefaults.dateProfileGeneratorClass,
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,
nowInput: refinedOptions.now,
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 toolbarProps = this.buildToolbarProps(
props.viewSpec,
props.dateProfile,
props.dateProfileGenerator,
props.currentDate,
getNow(props.options.now, props.dateEnv),
// TODO: use NowTimer????
props.viewTitle
);
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.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 },
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);
}
};
function formatDate(dateInput, options = {}) {
let dateEnv = buildDateEnv(options);
let formatter = createFormatter(options);
let dateMeta = dateEnv.createMarkerMeta(dateInput);
if (!dateMeta) {
return "";
}
return dateEnv.format(dateMeta.marker, formatter, {
forcedTzo: dateMeta.forcedTzo
});
}
function formatRange(startInput, endInput, options) {
let dateEnv = buildDateEnv(typeof options === "object" && options ? options : {});
let formatter = createFormatter(options);
let startMeta = dateEnv.createMarkerMeta(startInput);
let endMeta = dateEnv.createMarkerMeta(endInput);
if (!startMeta || !endMeta) {
return "";
}
return dateEnv.formatRange(startMeta.marker, endMeta.marker, formatter, {
forcedStartTzo: startMeta.forcedTzo,
forcedEndTzo: endMeta.forcedTzo,
isEndExclusive: options.isEndExclusive,
defaultSeparator: BASE_OPTION_DEFAULTS.defaultRangeSeparator
});
}
function buildDateEnv(settings) {
let locale = buildLocale(settings.locale || "en", organizeRawLocales([]).map);
return new DateEnv(Object.assign(Object.assign({ timeZone: BASE_OPTION_DEFAULTS.timeZone, calendarSystem: "gregory" }, settings), { locale }));
}
function sliceEvents(props, allDay) {
return sliceEventStore(props.eventStore, props.eventUiBases, props.dateProfile.activeRange, allDay ? props.nextDayThreshold : null).fg;
}
var version = "6.1.14";
export {
injectStyles,
removeElement,
elementClosest,
elementMatches,
applyStyle,
getEventTargetViaRoot,
getUniqueDomId,
whenTransitionDone,
disableCursor,
enableCursor,
preventSelection,
allowSelection,
preventContextMenu,
allowContextMenu,
compareNumbers,
createDuration,
addDurations,
multiplyDuration,
asRoughMs,
wholeDivideDurations,
addWeeks,
addDays,
addMs,
diffWeeks,
diffDays,
startOfDay,
buildIsoString,
formatDayString,
formatIsoMonthStr,
formatIsoTimeString,
memoize,
createFormatter,
BASE_OPTION_DEFAULTS,
identity,
mapHash,
isPropsEqual,
ViewContextType,
BaseComponent,
setRef,
ContentContainer,
ViewContainer,
intersectRanges,
rangeContainsRange,
rangeContainsMarker,
diffDates,
DateProfileGenerator,
createEventInstance,
refineEventDef,
parseEventDef,
eventTupleToStore,
getRelevantEvents,
createEmptyEventStore,
Emitter,
triggerDateSelect,
getDefaultEventEnd,
applyMutationToEventStore,
EventImpl,
buildEventApis,
hasBgRendering,
getElSeg,
sortEventSegs,
buildSegTimeText,
getSegMeta,
buildEventRangeKey,
getSegAnchorAttrs,
isDateSpansEqual,
JsonRequestError,
Interaction,
interactionSettingsToStore,
interactionSettingsStore,
pointInsideRect,
intersectRects,
constrainPoint,
getRectCenter,
diffPoints,
Splitter,
buildNavLinkAttrs,
computeInnerRect,
computeRect,
getClippingParents,
PositionCache,
ScrollController,
ElementScrollController,
WindowScrollController,
DateComponent,
SegHierarchy,
getEntrySpanEnd,
buildEntryKey,
groupIntersectingEntries,
intersectSpans,
binarySearch,
ElementDragging,
config,
parseDragMeta,
NowTimer,
DayHeader,
DaySeriesModel,
DayTableModel,
Slicer,
isInteractionValid,
isDateSelectionValid,
RefMap,
renderScrollShim,
getStickyHeaderDates,
getStickyFooterScrollbar,
SimpleScrollGrid,
EventContainer,
StandardEvent,
NowIndicatorContainer,
DayCellContainer,
hasCustomDayCellContent,
BgEvent,
renderFill,
WeekNumberContainer,
MoreLinkContainer,
computeEarliestSegStart,
CustomRenderingStore,
globalLocales,
createPlugin,
globalPlugins,
Calendar,
formatDate,
formatRange,
sliceEvents,
version
};
//# sourceMappingURL=chunk-QH2VTIUN.js.map