@posthog/browser-common 0.9.5 → 0.9.6

package/dist/survey-event-receiver-base.js

@@ -0,0 +1,354 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    EventReceiver: ()=>EventReceiver
+});
+const external_survey_constants_js_namespaceObject = require("./survey-constants.js");
+const external_survey_action_matcher_js_namespaceObject = require("./survey-action-matcher.js");
+const surveys_namespaceObject = require("@posthog/core/surveys");
+const core_namespaceObject = require("@posthog/core");
+class EventReceiver {
+    constructor(host, _onActivationChanged){
+        this._onActivationChanged = _onActivationChanged;
+        this._pendingActivatedItems = [];
+        this._host = host;
+        this._eventToItems = new Map();
+        this._cancelEventToItems = new Map();
+        this._actionToItems = new Map();
+    }
+    _subscribeSession() {
+        this._sessionIdUnsubscribe = this._host.subscribeSession?.((sessionId)=>this._onSessionIdChanged(sessionId));
+    }
+    _shouldPersistArmedActivation(_itemId) {
+        return false;
+    }
+    _getActivationTimestampsKey() {
+        return null;
+    }
+    _writeActivationTimestamps(_timestamps) {}
+    _clearActivationTimestampsStore() {}
+    _doesEventMatchFilter(eventConfig, eventPayload) {
+        if (!eventConfig) return false;
+        return (0, surveys_namespaceObject.matchPropertyFilters)(eventConfig.propertyFilters, eventPayload?.properties);
+    }
+    _buildEventToItemMap(items, conditionField) {
+        const map = new Map();
+        items.forEach((item)=>{
+            item.conditions?.[conditionField]?.values?.forEach((event)=>{
+                if (event?.name) {
+                    const existing = map.get(event.name) || [];
+                    existing.push(item.id);
+                    map.set(event.name, existing);
+                }
+            });
+        });
+        return map;
+    }
+    _getMatchingItems(eventName, eventPayload, conditionField) {
+        const itemIdMap = conditionField === external_survey_constants_js_namespaceObject.SurveyEventType.Activation ? this._eventToItems : this._cancelEventToItems;
+        const itemIds = itemIdMap.get(eventName);
+        let items = [];
+        this._getItems((allItems)=>{
+            items = allItems.filter((item)=>itemIds?.includes(item.id));
+        });
+        return items.filter((item)=>{
+            const eventConfig = item.conditions?.[conditionField]?.values?.find((e)=>e.name === eventName);
+            return this._doesEventMatchFilter(eventConfig, eventPayload);
+        });
+    }
+    register(items) {
+        this._register(items, false);
+    }
+    replace(items) {
+        this._register(items, true);
+    }
+    _register(items, replace) {
+        if ((0, core_namespaceObject.isUndefined)(this._host.subscribeCapture)) return;
+        this._setupEventBasedItems(items, replace);
+        this._setupActionBasedItems(items, replace);
+    }
+    _setupActionBasedItems(items, replace) {
+        const actionBasedItems = items.filter((item)=>item.conditions?.actions?.values?.length);
+        if (replace) this._actionToItems.clear();
+        if (0 === actionBasedItems.length) {
+            if (replace) this._actionMatcher?.replace([]);
+            return;
+        }
+        if (!this._actionMatcher) {
+            this._actionMatcher = new external_survey_action_matcher_js_namespaceObject.ActionMatcher(this._host);
+            this._actionMatcher.init();
+            this._actionMatcher._addActionHook((actionName)=>this.onAction(actionName));
+        }
+        const actions = [];
+        actionBasedItems.forEach((item)=>{
+            item.conditions?.actions?.values.forEach((action)=>{
+                actions.push(action);
+                if (action.name) {
+                    const matchingItems = this._actionToItems.get(action.name) ?? [];
+                    if (!matchingItems.includes(item.id)) matchingItems.push(item.id);
+                    this._actionToItems.set(action.name, matchingItems);
+                }
+            });
+        });
+        if (replace) this._actionMatcher.replace(actions);
+        else this._actionMatcher.register(actions);
+    }
+    _mergeItemMaps(target, source) {
+        source.forEach((itemIds, eventName)=>{
+            const matchingItems = target.get(eventName) ?? [];
+            itemIds.forEach((itemId)=>{
+                if (!matchingItems.includes(itemId)) matchingItems.push(itemId);
+            });
+            target.set(eventName, matchingItems);
+        });
+    }
+    _setupEventBasedItems(items, replace) {
+        const eventBasedItems = items.filter((item)=>item.conditions?.events && item.conditions?.events?.values?.length > 0);
+        const itemsWithCancelEvents = items.filter((item)=>item.conditions?.cancelEvents && item.conditions?.cancelEvents?.values?.length > 0);
+        const eventToItems = this._buildEventToItemMap(items, external_survey_constants_js_namespaceObject.SurveyEventType.Activation);
+        const cancelEventToItems = this._buildEventToItemMap(items, external_survey_constants_js_namespaceObject.SurveyEventType.Cancellation);
+        if (replace) {
+            this._eventToItems = eventToItems;
+            this._cancelEventToItems = cancelEventToItems;
+        } else {
+            this._mergeItemMaps(this._eventToItems, eventToItems);
+            this._mergeItemMaps(this._cancelEventToItems, cancelEventToItems);
+        }
+        if (0 === eventBasedItems.length && 0 === itemsWithCancelEvents.length && !items.some((item)=>item.conditions?.actions?.values?.length)) return;
+        const matchEventToItem = (eventName, eventPayload)=>{
+            this.onEvent(eventName, eventPayload);
+        };
+        this._captureHookUnsubscribe ??= this._host.subscribeCapture?.(matchEventToItem);
+    }
+    onEvent(event, eventPayload) {
+        const logger = this._getLogger();
+        const itemId = eventPayload?.properties?.$survey_id || eventPayload?.properties?.$product_tour_id;
+        if (itemId && this.getActivatedIds().includes(itemId)) {
+            const outcome = this._activationOutcome(event, itemId, eventPayload);
+            if ('consume' === outcome) {
+                logger.info('event consumed activated item, removing it', {
+                    event,
+                    itemId
+                });
+                this._deactivateItems([
+                    itemId
+                ]);
+                return;
+            }
+            if ('persist' === outcome) {
+                logger.info('shown item promoted to persisted activation', {
+                    event,
+                    itemId
+                });
+                this._persistActivation(itemId);
+                this._clearActivationTimestamps([
+                    itemId
+                ]);
+                return;
+            }
+        }
+        if (this._cancelEventToItems.has(event)) {
+            const itemsToCancel = this._getMatchingItems(event, eventPayload, external_survey_constants_js_namespaceObject.SurveyEventType.Cancellation);
+            if (itemsToCancel.length > 0) {
+                logger.info('cancel event matched, cancelling items', {
+                    event,
+                    itemsToCancel: itemsToCancel.map((s)=>s.id)
+                });
+                this._deactivateItems(itemsToCancel.map((item)=>item.id));
+                itemsToCancel.forEach((item)=>this._cancelPendingItem(item.id));
+            }
+        }
+        if (!this._eventToItems.has(event)) return;
+        logger.info('event name matched', {
+            event,
+            eventPayload,
+            items: this._eventToItems.get(event)
+        });
+        const matchedItems = this._getMatchingItems(event, eventPayload, external_survey_constants_js_namespaceObject.SurveyEventType.Activation);
+        this._activateItems(matchedItems.map((item)=>item.id));
+    }
+    onAction(actionName) {
+        if (this._actionToItems.has(actionName)) this._activateItems(this._actionToItems.get(actionName) || []);
+    }
+    _activateItems(itemIds) {
+        if (0 === itemIds.length) return;
+        const canPersist = !!this._host.getSessionId();
+        const armedInMemory = [];
+        for (const itemId of itemIds)if (canPersist && this._shouldPersistArmedActivation(itemId)) {
+            if (this._persistActivation(itemId)) this._recordActivationTimestamp(itemId);
+        } else armedInMemory.push(itemId);
+        if (armedInMemory.length > 0) this._pendingActivatedItems = [
+            ...new Set([
+                ...this._pendingActivatedItems,
+                ...armedInMemory
+            ])
+        ];
+        this._getLogger().info('updating activated items', {
+            activatedItems: this.getActivatedIds()
+        });
+        this._notifyActivationChanged();
+    }
+    _persistActivation(itemId) {
+        this._pendingActivatedItems = this._pendingActivatedItems.filter((id)=>id !== itemId);
+        const persisted = this._getPersistedActivatedIds();
+        if (persisted.includes(itemId)) return false;
+        this._setActivatedItems([
+            ...persisted,
+            itemId
+        ]);
+        this._stampActivationSession();
+        return true;
+    }
+    _deactivateItems(itemIds) {
+        const remove = new Set(itemIds);
+        this._pendingActivatedItems = this._pendingActivatedItems.filter((id)=>!remove.has(id));
+        const persisted = this._getRawPersistedActivatedIds();
+        const nextPersisted = persisted.filter((id)=>!remove.has(id));
+        if (nextPersisted.length !== persisted.length) {
+            this._setActivatedItems(nextPersisted);
+            if (0 === nextPersisted.length) this._clearActivationSession();
+        }
+        this._clearActivationTimestamps(itemIds);
+        this._notifyActivationChanged();
+    }
+    _notifyActivationChanged() {
+        try {
+            this._onActivationChanged?.();
+        } catch (error) {
+            this._getLogger().error('Error while handling activated items change', error);
+        }
+    }
+    _getRawActivationTimestamps() {
+        const key = this._getActivationTimestampsKey();
+        if (!key) return {};
+        const stored = this._host.getProperty(key);
+        return stored && 'object' == typeof stored ? stored : {};
+    }
+    _recordActivationTimestamp(itemId) {
+        const key = this._getActivationTimestampsKey();
+        if (!key) return;
+        const timestamps = this._getRawActivationTimestamps();
+        this._writeActivationTimestamps({
+            ...timestamps,
+            [itemId]: Date.now()
+        });
+    }
+    _clearActivationTimestamps(itemIds) {
+        const key = this._getActivationTimestampsKey();
+        if (!key) return;
+        const timestamps = this._getRawActivationTimestamps();
+        const next = {};
+        let changed = false;
+        for (const [id, ts] of Object.entries(timestamps))if (itemIds.includes(id)) changed = true;
+        else next[id] = ts;
+        if (!changed) return;
+        if ((0, core_namespaceObject.isEmptyObject)(next)) return void this._clearActivationTimestampsStore();
+        this._writeActivationTimestamps(next);
+    }
+    _clearAllActivationTimestamps() {
+        if (this._getActivationTimestampsKey()) this._clearActivationTimestampsStore();
+    }
+    getActivationTimestamp(itemId) {
+        if (!this._getPersistedActivatedIds().includes(itemId)) return;
+        const ts = this._getRawActivationTimestamps()[itemId];
+        return (0, core_namespaceObject.isNumber)(ts) ? ts : void 0;
+    }
+    _getRawPersistedActivatedIds() {
+        const activatedKey = this._getActivatedKey();
+        const existingActivatedItems = this._host.getProperty(activatedKey);
+        return existingActivatedItems ? existingActivatedItems : [];
+    }
+    _getPersistedActivatedIds() {
+        const ids = this._getRawPersistedActivatedIds();
+        if (0 === ids.length) return [];
+        const stampedSessionId = this._host.getProperty(this._getActivatedSessionKey());
+        const currentSessionId = this._host.getSessionId();
+        if (!currentSessionId || stampedSessionId !== currentSessionId) return [];
+        return ids;
+    }
+    _stampActivationSession() {
+        const currentSessionId = this._host.getSessionId();
+        if (currentSessionId) this._setActivatedSession(currentSessionId);
+    }
+    _clearActivationSession() {
+        this._clearActivatedSession();
+    }
+    _onSessionIdChanged(sessionId) {
+        const stampedSessionId = this._host.getProperty(this._getActivatedSessionKey());
+        if (stampedSessionId && stampedSessionId !== sessionId) {
+            const activatedItemIds = this._getRawPersistedActivatedIds();
+            const activationTimestamps = this._getRawActivationTimestamps();
+            if (activatedItemIds.length > 0) {
+                this._setActivatedItems([]);
+                activatedItemIds.filter((itemId)=>(0, core_namespaceObject.isNumber)(activationTimestamps[itemId])).forEach((itemId)=>this._cancelPendingItem(itemId));
+            }
+            this._clearActivationSession();
+            this._clearAllActivationTimestamps();
+            if (activatedItemIds.length > 0) this._notifyActivationChanged();
+        }
+    }
+    getActivatedIds() {
+        const all = [
+            ...new Set([
+                ...this._getPersistedActivatedIds(),
+                ...this._pendingActivatedItems
+            ])
+        ];
+        return all.filter((itemId)=>!this._isItemPermanentlyIneligible(itemId));
+    }
+    dispose() {
+        this._sessionIdUnsubscribe?.();
+        this._sessionIdUnsubscribe = void 0;
+        this._captureHookUnsubscribe?.();
+        this._captureHookUnsubscribe = void 0;
+        this._actionMatcher?.dispose();
+        this._actionMatcher = void 0;
+    }
+    reset() {
+        this._pendingActivatedItems = [];
+        if (this._getRawPersistedActivatedIds().length > 0) this._setActivatedItems([]);
+        this._clearActivationSession();
+        this._clearAllActivationTimestamps();
+        this._notifyActivationChanged();
+    }
+    getEventToItemsMap() {
+        return this._eventToItems;
+    }
+    _getActionMatcher() {
+        return this._actionMatcher;
+    }
+}
+exports.EventReceiver = __webpack_exports__.EventReceiver;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "EventReceiver"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/survey-event-receiver-base.mjs

@@ -0,0 +1,316 @@
+import { SurveyEventType } from "./survey-constants.mjs";
+import { ActionMatcher } from "./survey-action-matcher.mjs";
+import { matchPropertyFilters } from "@posthog/core/surveys";
+import { isEmptyObject, isNumber, isUndefined } from "@posthog/core";
+class EventReceiver {
+    constructor(host, _onActivationChanged){
+        this._onActivationChanged = _onActivationChanged;
+        this._pendingActivatedItems = [];
+        this._host = host;
+        this._eventToItems = new Map();
+        this._cancelEventToItems = new Map();
+        this._actionToItems = new Map();
+    }
+    _subscribeSession() {
+        this._sessionIdUnsubscribe = this._host.subscribeSession?.((sessionId)=>this._onSessionIdChanged(sessionId));
+    }
+    _shouldPersistArmedActivation(_itemId) {
+        return false;
+    }
+    _getActivationTimestampsKey() {
+        return null;
+    }
+    _writeActivationTimestamps(_timestamps) {}
+    _clearActivationTimestampsStore() {}
+    _doesEventMatchFilter(eventConfig, eventPayload) {
+        if (!eventConfig) return false;
+        return matchPropertyFilters(eventConfig.propertyFilters, eventPayload?.properties);
+    }
+    _buildEventToItemMap(items, conditionField) {
+        const map = new Map();
+        items.forEach((item)=>{
+            item.conditions?.[conditionField]?.values?.forEach((event)=>{
+                if (event?.name) {
+                    const existing = map.get(event.name) || [];
+                    existing.push(item.id);
+                    map.set(event.name, existing);
+                }
+            });
+        });
+        return map;
+    }
+    _getMatchingItems(eventName, eventPayload, conditionField) {
+        const itemIdMap = conditionField === SurveyEventType.Activation ? this._eventToItems : this._cancelEventToItems;
+        const itemIds = itemIdMap.get(eventName);
+        let items = [];
+        this._getItems((allItems)=>{
+            items = allItems.filter((item)=>itemIds?.includes(item.id));
+        });
+        return items.filter((item)=>{
+            const eventConfig = item.conditions?.[conditionField]?.values?.find((e)=>e.name === eventName);
+            return this._doesEventMatchFilter(eventConfig, eventPayload);
+        });
+    }
+    register(items) {
+        this._register(items, false);
+    }
+    replace(items) {
+        this._register(items, true);
+    }
+    _register(items, replace) {
+        if (isUndefined(this._host.subscribeCapture)) return;
+        this._setupEventBasedItems(items, replace);
+        this._setupActionBasedItems(items, replace);
+    }
+    _setupActionBasedItems(items, replace) {
+        const actionBasedItems = items.filter((item)=>item.conditions?.actions?.values?.length);
+        if (replace) this._actionToItems.clear();
+        if (0 === actionBasedItems.length) {
+            if (replace) this._actionMatcher?.replace([]);
+            return;
+        }
+        if (!this._actionMatcher) {
+            this._actionMatcher = new ActionMatcher(this._host);
+            this._actionMatcher.init();
+            this._actionMatcher._addActionHook((actionName)=>this.onAction(actionName));
+        }
+        const actions = [];
+        actionBasedItems.forEach((item)=>{
+            item.conditions?.actions?.values.forEach((action)=>{
+                actions.push(action);
+                if (action.name) {
+                    const matchingItems = this._actionToItems.get(action.name) ?? [];
+                    if (!matchingItems.includes(item.id)) matchingItems.push(item.id);
+                    this._actionToItems.set(action.name, matchingItems);
+                }
+            });
+        });
+        if (replace) this._actionMatcher.replace(actions);
+        else this._actionMatcher.register(actions);
+    }
+    _mergeItemMaps(target, source) {
+        source.forEach((itemIds, eventName)=>{
+            const matchingItems = target.get(eventName) ?? [];
+            itemIds.forEach((itemId)=>{
+                if (!matchingItems.includes(itemId)) matchingItems.push(itemId);
+            });
+            target.set(eventName, matchingItems);
+        });
+    }
+    _setupEventBasedItems(items, replace) {
+        const eventBasedItems = items.filter((item)=>item.conditions?.events && item.conditions?.events?.values?.length > 0);
+        const itemsWithCancelEvents = items.filter((item)=>item.conditions?.cancelEvents && item.conditions?.cancelEvents?.values?.length > 0);
+        const eventToItems = this._buildEventToItemMap(items, SurveyEventType.Activation);
+        const cancelEventToItems = this._buildEventToItemMap(items, SurveyEventType.Cancellation);
+        if (replace) {
+            this._eventToItems = eventToItems;
+            this._cancelEventToItems = cancelEventToItems;
+        } else {
+            this._mergeItemMaps(this._eventToItems, eventToItems);
+            this._mergeItemMaps(this._cancelEventToItems, cancelEventToItems);
+        }
+        if (0 === eventBasedItems.length && 0 === itemsWithCancelEvents.length && !items.some((item)=>item.conditions?.actions?.values?.length)) return;
+        const matchEventToItem = (eventName, eventPayload)=>{
+            this.onEvent(eventName, eventPayload);
+        };
+        this._captureHookUnsubscribe ??= this._host.subscribeCapture?.(matchEventToItem);
+    }
+    onEvent(event, eventPayload) {
+        const logger = this._getLogger();
+        const itemId = eventPayload?.properties?.$survey_id || eventPayload?.properties?.$product_tour_id;
+        if (itemId && this.getActivatedIds().includes(itemId)) {
+            const outcome = this._activationOutcome(event, itemId, eventPayload);
+            if ('consume' === outcome) {
+                logger.info('event consumed activated item, removing it', {
+                    event,
+                    itemId
+                });
+                this._deactivateItems([
+                    itemId
+                ]);
+                return;
+            }
+            if ('persist' === outcome) {
+                logger.info('shown item promoted to persisted activation', {
+                    event,
+                    itemId
+                });
+                this._persistActivation(itemId);
+                this._clearActivationTimestamps([
+                    itemId
+                ]);
+                return;
+            }
+        }
+        if (this._cancelEventToItems.has(event)) {
+            const itemsToCancel = this._getMatchingItems(event, eventPayload, SurveyEventType.Cancellation);
+            if (itemsToCancel.length > 0) {
+                logger.info('cancel event matched, cancelling items', {
+                    event,
+                    itemsToCancel: itemsToCancel.map((s)=>s.id)
+                });
+                this._deactivateItems(itemsToCancel.map((item)=>item.id));
+                itemsToCancel.forEach((item)=>this._cancelPendingItem(item.id));
+            }
+        }
+        if (!this._eventToItems.has(event)) return;
+        logger.info('event name matched', {
+            event,
+            eventPayload,
+            items: this._eventToItems.get(event)
+        });
+        const matchedItems = this._getMatchingItems(event, eventPayload, SurveyEventType.Activation);
+        this._activateItems(matchedItems.map((item)=>item.id));
+    }
+    onAction(actionName) {
+        if (this._actionToItems.has(actionName)) this._activateItems(this._actionToItems.get(actionName) || []);
+    }
+    _activateItems(itemIds) {
+        if (0 === itemIds.length) return;
+        const canPersist = !!this._host.getSessionId();
+        const armedInMemory = [];
+        for (const itemId of itemIds)if (canPersist && this._shouldPersistArmedActivation(itemId)) {
+            if (this._persistActivation(itemId)) this._recordActivationTimestamp(itemId);
+        } else armedInMemory.push(itemId);
+        if (armedInMemory.length > 0) this._pendingActivatedItems = [
+            ...new Set([
+                ...this._pendingActivatedItems,
+                ...armedInMemory
+            ])
+        ];
+        this._getLogger().info('updating activated items', {
+            activatedItems: this.getActivatedIds()
+        });
+        this._notifyActivationChanged();
+    }
+    _persistActivation(itemId) {
+        this._pendingActivatedItems = this._pendingActivatedItems.filter((id)=>id !== itemId);
+        const persisted = this._getPersistedActivatedIds();
+        if (persisted.includes(itemId)) return false;
+        this._setActivatedItems([
+            ...persisted,
+            itemId
+        ]);
+        this._stampActivationSession();
+        return true;
+    }
+    _deactivateItems(itemIds) {
+        const remove = new Set(itemIds);
+        this._pendingActivatedItems = this._pendingActivatedItems.filter((id)=>!remove.has(id));
+        const persisted = this._getRawPersistedActivatedIds();
+        const nextPersisted = persisted.filter((id)=>!remove.has(id));
+        if (nextPersisted.length !== persisted.length) {
+            this._setActivatedItems(nextPersisted);
+            if (0 === nextPersisted.length) this._clearActivationSession();
+        }
+        this._clearActivationTimestamps(itemIds);
+        this._notifyActivationChanged();
+    }
+    _notifyActivationChanged() {
+        try {
+            this._onActivationChanged?.();
+        } catch (error) {
+            this._getLogger().error('Error while handling activated items change', error);
+        }
+    }
+    _getRawActivationTimestamps() {
+        const key = this._getActivationTimestampsKey();
+        if (!key) return {};
+        const stored = this._host.getProperty(key);
+        return stored && 'object' == typeof stored ? stored : {};
+    }
+    _recordActivationTimestamp(itemId) {
+        const key = this._getActivationTimestampsKey();
+        if (!key) return;
+        const timestamps = this._getRawActivationTimestamps();
+        this._writeActivationTimestamps({
+            ...timestamps,
+            [itemId]: Date.now()
+        });
+    }
+    _clearActivationTimestamps(itemIds) {
+        const key = this._getActivationTimestampsKey();
+        if (!key) return;
+        const timestamps = this._getRawActivationTimestamps();
+        const next = {};
+        let changed = false;
+        for (const [id, ts] of Object.entries(timestamps))if (itemIds.includes(id)) changed = true;
+        else next[id] = ts;
+        if (!changed) return;
+        if (isEmptyObject(next)) return void this._clearActivationTimestampsStore();
+        this._writeActivationTimestamps(next);
+    }
+    _clearAllActivationTimestamps() {
+        if (this._getActivationTimestampsKey()) this._clearActivationTimestampsStore();
+    }
+    getActivationTimestamp(itemId) {
+        if (!this._getPersistedActivatedIds().includes(itemId)) return;
+        const ts = this._getRawActivationTimestamps()[itemId];
+        return isNumber(ts) ? ts : void 0;
+    }
+    _getRawPersistedActivatedIds() {
+        const activatedKey = this._getActivatedKey();
+        const existingActivatedItems = this._host.getProperty(activatedKey);
+        return existingActivatedItems ? existingActivatedItems : [];
+    }
+    _getPersistedActivatedIds() {
+        const ids = this._getRawPersistedActivatedIds();
+        if (0 === ids.length) return [];
+        const stampedSessionId = this._host.getProperty(this._getActivatedSessionKey());
+        const currentSessionId = this._host.getSessionId();
+        if (!currentSessionId || stampedSessionId !== currentSessionId) return [];
+        return ids;
+    }
+    _stampActivationSession() {
+        const currentSessionId = this._host.getSessionId();
+        if (currentSessionId) this._setActivatedSession(currentSessionId);
+    }
+    _clearActivationSession() {
+        this._clearActivatedSession();
+    }
+    _onSessionIdChanged(sessionId) {
+        const stampedSessionId = this._host.getProperty(this._getActivatedSessionKey());
+        if (stampedSessionId && stampedSessionId !== sessionId) {
+            const activatedItemIds = this._getRawPersistedActivatedIds();
+            const activationTimestamps = this._getRawActivationTimestamps();
+            if (activatedItemIds.length > 0) {
+                this._setActivatedItems([]);
+                activatedItemIds.filter((itemId)=>isNumber(activationTimestamps[itemId])).forEach((itemId)=>this._cancelPendingItem(itemId));
+            }
+            this._clearActivationSession();
+            this._clearAllActivationTimestamps();
+            if (activatedItemIds.length > 0) this._notifyActivationChanged();
+        }
+    }
+    getActivatedIds() {
+        const all = [
+            ...new Set([
+                ...this._getPersistedActivatedIds(),
+                ...this._pendingActivatedItems
+            ])
+        ];
+        return all.filter((itemId)=>!this._isItemPermanentlyIneligible(itemId));
+    }
+    dispose() {
+        this._sessionIdUnsubscribe?.();
+        this._sessionIdUnsubscribe = void 0;
+        this._captureHookUnsubscribe?.();
+        this._captureHookUnsubscribe = void 0;
+        this._actionMatcher?.dispose();
+        this._actionMatcher = void 0;
+    }
+    reset() {
+        this._pendingActivatedItems = [];
+        if (this._getRawPersistedActivatedIds().length > 0) this._setActivatedItems([]);
+        this._clearActivationSession();
+        this._clearAllActivationTimestamps();
+        this._notifyActivationChanged();
+    }
+    getEventToItemsMap() {
+        return this._eventToItems;
+    }
+    _getActionMatcher() {
+        return this._actionMatcher;
+    }
+}
+export { EventReceiver };