@fullcalendar/core 6.0.0 → 6.0.2

package/internal-common.cjs

@@ -200,6 +200,16 @@ function isPropsEqual(obj0, obj1) {
     }
     return true;
 }
+const HANDLER_RE = /^on[A-Z]/;
+function isNonHandlerPropsEqual(obj0, obj1) {
+    const keys = getUnequalProps(obj0, obj1);
+    for (let key of keys) {
+        if (!HANDLER_RE.test(key)) {
+            return false;
+        }
+    }
+    return true;
+}
 function getUnequalProps(obj0, obj1) {
     let keys = [];
     for (let key in obj0) {
@@ -262,8 +272,6 @@ function collectFromHash(hash, startIndex = 0, endIndex, step = 1) {
     return res;
 }
 
-const globalLocales = [];
-
 // TODO: new util arrayify?
 function removeExact(array, exactVal) {
     let removeCnt = 0;
@@ -700,165 +708,6 @@ function computeSmallestCellWidth(cellEl) {
         contentWidthEl.getBoundingClientRect().width;
 }
 
-// TODO: easier way to add new hooks? need to update a million things
-function createPlugin(input) {
-    return {
-        id: guid(),
-        name: input.name,
-        premiumReleaseDate: input.premiumReleaseDate ? new Date(input.premiumReleaseDate) : undefined,
-        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: undefined,
-        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 === undefined) {
-                currentPluginIds[pluginName] = def.id;
-                addDefs(def.deps);
-                hooks = combineHooks(hooks, def);
-            }
-            else if (currentId !== def.id) {
-                // different ID than the one already added
-                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 === undefined) {
-        return date1;
-    }
-    if (date1 === undefined) {
-        return date0;
-    }
-    return new Date(Math.max(date0.valueOf(), date1.valueOf()));
-}
-
 const DAY_IDS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
 // Adding
 function addWeeks(m, n) {
@@ -2555,7 +2404,7 @@ class ContentInjector extends BaseComponent {
 ContentInjector.addPropsEquality({
     elClasses: isArraysEqual,
     elStyle: isPropsEqual,
-    elAttrs: isPropsEqual,
+    elAttrs: isNonHandlerPropsEqual,
     renderProps: isPropsEqual,
 });
 // Util
@@ -3558,170 +3407,6 @@ function buildEventSourceMeta(raw, context) {
     return null;
 }
 
-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; // need this check?
-    switch (action.type) {
-        case 'ADD_EVENT_SOURCES': // already parsed
-            return addSources(eventSources, action.sources, activeRange, context);
-        case 'REMOVE_EVENT_SOURCE':
-            return removeSource(eventSources, action.sourceId);
-        case 'PREV': // TODO: how do we track all actions that affect dateProfile :(
-        case 'NEXT':
-        case 'CHANGE_DATE':
-        case 'CHANGE_VIEW_TYPE':
-            if (dateProfile) {
-                return fetchDirtySources(eventSources, activeRange, context);
-            }
-            return eventSources;
-        case 'FETCH_EVENT_SOURCES':
-            return fetchSourcesByIds(eventSources, action.sourceIds ? // why no type?
-                arrayToHash(action.sourceIds) :
-                excludeStaticSources(eventSources, context), activeRange, action.isRefetch || false, context);
-        case 'RECEIVE_EVENTS':
-        case 'RECEIVE_EVENT_ERROR':
-            return receiveResponse(eventSources, action.sourceId, action.fetchId, action.fetchRange);
-        case 'REMOVE_ALL_EVENT_SOURCES':
-            return {};
-        default:
-            return eventSources;
-    }
-}
-function reduceEventSourcesNewTimeZone(eventSources, dateProfile, context) {
-    let activeRange = dateProfile ? dateProfile.activeRange : null; // need this check?
-    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 = []; // parsed
-    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 reduceEventStore(eventStore, action, eventSources, dateProfile, context) {
     switch (action.type) {
         case 'RECEIVE_EVENTS': // raw
@@ -3905,25 +3590,6 @@ function refineInputs(input) {
     return rawDefs;
 }
 
-let eventSourceDef$2 = {
-    ignoreRange: true,
-    parseMeta(refined) {
-        if (Array.isArray(refined.events)) {
-            return refined.events;
-        }
-        return null;
-    },
-    fetch(arg, successCallback) {
-        successCallback({
-            rawEvents: arg.eventSource.meta,
-        });
-    },
-};
-const arrayEventSourcePlugin = createPlugin({
-    name: 'array-event-source',
-    eventSourceDefs: [eventSourceDef$2],
-});
-
 function triggerDateSelect(selection, pev, context) {
     context.emitter.trigger('select', Object.assign(Object.assign({}, buildDateSpanApiWithContext(selection, context)), { jsEvent: pev ? pev.origEvent : null, view: context.viewApi || context.calendarApi.view }));
 }
@@ -4809,24 +4475,6 @@ function unpromisify(func, normalizedSuccessCallback, normalizedFailureCallback)
     }
 }
 
-let 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);
-    },
-};
-const funcEventSourcePlugin = createPlugin({
-    name: 'func-event-source',
-    eventSourceDefs: [eventSourceDef$1],
-});
-
 class JsonRequestError extends Error {
     constructor(message, response) {
         super(message);
@@ -4862,220 +4510,6 @@ function requestJson(method, url, params) {
     });
 }
 
-const JSON_FEED_EVENT_SOURCE_REFINERS = {
-    method: String,
-    extraParams: identity,
-    startParam: String,
-    endParam: String,
-    timeZoneParam: String,
-};
-
-let 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);
-    },
-};
-const 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;
-    }
-    // retrieve any outbound GET/POST data from the options
-    if (typeof meta.extraParams === 'function') {
-        // supplied as a function that returns a key/value object
-        customRequestParams = meta.extraParams();
-    }
-    else {
-        // probably supplied as a straight key/value object
-        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;
-}
-
-const SIMPLE_RECURRING_REFINERS = {
-    daysOfWeek: identity,
-    startTime: createDuration,
-    endTime: createDuration,
-    duration: createDuration,
-    startRecur: identity,
-    endRecur: identity,
-};
-
-let 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 [];
-    },
-};
-const 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 everyday, or this particular day-of-week
-        if (!dowHash || dowHash[dayMarker.getUTCDay()]) {
-            if (startTime) {
-                instanceStart = dateEnv.add(dayMarker, startTime);
-            }
-            else {
-                instanceStart = dayMarker;
-            }
-            instanceStarts.push(instanceStart);
-        }
-        dayMarker = addDays(dayMarker, 1);
-    }
-    return instanceStarts;
-}
-
-const changeHandlerPlugin = createPlugin({
-    name: 'change-handler',
-    optionChangeHandlers: {
-        events(events, context) {
-            handleEventSources([events], context);
-        },
-        eventSources: handleEventSources,
-    },
-});
-/*
-BUG: if `event` was supplied, all previously-given `eventSources` will be wiped out
-*/
-function handleEventSources(inputs, context) {
-    let unfoundSources = hashValuesToArray(context.getCurrentData().eventSources);
-    let newInputs = [];
-    for (let input of inputs) {
-        let inputFound = false;
-        for (let i = 0; i < unfoundSources.length; i += 1) {
-            if (unfoundSources[i]._raw === input) {
-                unfoundSources.splice(i, 1); // delete
-                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));
-    }
-}
-
-/*
-this array is exposed on the root namespace so that UMD plugins can add to it.
-see the rollup-bundles script.
-*/
-const globalPlugins = [
-    arrayEventSourcePlugin,
-    funcEventSourcePlugin,
-    jsonFeedEventSourcePlugin,
-    simpleRecurringEventsPlugin,
-    changeHandlerPlugin,
-    createPlugin({
-        name: 'misc',
-        isLoadingFuncs: [
-            (state) => computeEventSourcesLoading(state.eventSources),
-        ],
-        propSetHandlers: {
-            dateProfile: handleDateProfile,
-            eventStore: handleEventStore,
-        },
-    }),
-];
-
 let canVGrowWithinCell;
 function getCanVGrowWithinCell() {
     if (canVGrowWithinCell == null) {
@@ -7439,10 +6873,10 @@ class EventContainer extends BaseComponent {
     constructor() {
         super(...arguments);
         this.handleEl = (el) => {
+            this.el = el;
             if (el) {
                 setElSeg(el, this.props.seg);
             }
-            // TODO: when null, should unset to avoid memory leaks?
         };
     }
     render() {
@@ -7477,6 +6911,11 @@ class EventContainer extends BaseComponent {
                 ...(props.elClasses || []),
             ], renderProps: renderProps, generatorName: "eventContent", generator: options.eventContent || 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);
+        }
+    }
 }
 
 // should not be a purecomponent
@@ -7921,18 +7360,20 @@ exports.allowSelection = allowSelection;
 exports.applyMutationToEventStore = applyMutationToEventStore;
 exports.applyStyle = applyStyle;
 exports.applyStyleProp = applyStyleProp;
+exports.arrayToHash = arrayToHash;
 exports.asCleanDays = asCleanDays;
 exports.asRoughMinutes = asRoughMinutes;
 exports.asRoughMs = asRoughMs;
 exports.asRoughSeconds = asRoughSeconds;
 exports.binarySearch = binarySearch;
-exports.buildBuildPluginHooks = buildBuildPluginHooks;
 exports.buildElAttrs = buildElAttrs;
 exports.buildEntryKey = buildEntryKey;
 exports.buildEventApis = buildEventApis;
 exports.buildEventRangeKey = buildEventRangeKey;
+exports.buildEventSourceRefiners = buildEventSourceRefiners;
 exports.buildIsoString = buildIsoString;
 exports.buildNavLinkAttrs = buildNavLinkAttrs;
+exports.buildRangeApiWithTimeZone = buildRangeApiWithTimeZone;
 exports.buildSegTimeText = buildSegTimeText;
 exports.buildViewClassNames = buildViewClassNames;
 exports.buildViewContext = buildViewContext;
@@ -7943,7 +7384,6 @@ exports.compareNumbers = compareNumbers;
 exports.compareObjs = compareObjs;
 exports.computeEarliestSegStart = computeEarliestSegStart;
 exports.computeEdges = computeEdges;
-exports.computeEventSourcesLoading = computeEventSourcesLoading;
 exports.computeFallbackHeaderFormat = computeFallbackHeaderFormat;
 exports.computeInnerRect = computeInnerRect;
 exports.computeRect = computeRect;
@@ -7957,7 +7397,6 @@ exports.createEmptyEventStore = createEmptyEventStore;
 exports.createEventInstance = createEventInstance;
 exports.createEventUi = createEventUi;
 exports.createFormatter = createFormatter;
-exports.createPlugin = createPlugin;
 exports.diffDates = diffDates;
 exports.diffDayAndTime = diffDayAndTime;
 exports.diffDays = diffDays;
@@ -8003,16 +7442,14 @@ exports.getSlotClassNames = getSlotClassNames;
 exports.getStickyFooterScrollbar = getStickyFooterScrollbar;
 exports.getStickyHeaderDates = getStickyHeaderDates;
 exports.getUniqueDomId = getUniqueDomId;
-exports.globalLocales = globalLocales;
-exports.globalPlugins = globalPlugins;
 exports.greatestDurationDenominator = greatestDurationDenominator;
 exports.groupIntersectingEntries = groupIntersectingEntries;
 exports.guid = guid;
 exports.hasBgRendering = hasBgRendering;
 exports.hasCustomDayCellContent = hasCustomDayCellContent;
 exports.hasShrinkWidth = hasShrinkWidth;
+exports.hashValuesToArray = hashValuesToArray;
 exports.identity = identity;
-exports.initEventSources = initEventSources;
 exports.injectStyles = injectStyles;
 exports.interactionSettingsStore = interactionSettingsStore;
 exports.interactionSettingsToStore = interactionSettingsToStore;
@@ -8046,6 +7483,7 @@ exports.parseBusinessHours = parseBusinessHours;
 exports.parseClassNames = parseClassNames;
 exports.parseDragMeta = parseDragMeta;
 exports.parseEventDef = parseEventDef;
+exports.parseEventSource = parseEventSource;
 exports.parseFieldSpecs = parseFieldSpecs;
 exports.parseInteractionSettings = parseInteractionSettings;
 exports.pointInsideRect = pointInsideRect;
@@ -8057,8 +7495,6 @@ exports.rangeContainsRange = rangeContainsRange;
 exports.rangesEqual = rangesEqual;
 exports.rangesIntersect = rangesIntersect;
 exports.reduceCurrentDate = reduceCurrentDate;
-exports.reduceEventSources = reduceEventSources;
-exports.reduceEventSourcesNewTimeZone = reduceEventSourcesNewTimeZone;
 exports.reduceEventStore = reduceEventStore;
 exports.refineEventDef = refineEventDef;
 exports.refineProps = refineProps;
@@ -8075,6 +7511,7 @@ exports.setRef = setRef;
 exports.sliceEventStore = sliceEventStore;
 exports.sortEventSegs = sortEventSegs;
 exports.startOfDay = startOfDay;
+exports.subtractDurations = subtractDurations;
 exports.translateRect = translateRect;
 exports.triggerDateSelect = triggerDateSelect;
 exports.unpromisify = unpromisify;