@metamask-previews/analytics-controller 2.0.0-preview-fe4b3be11 → 2.1.0-preview-2f57247

package/dist/AnalyticsController.mjs

@@ -9,7 +9,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _AnalyticsController_instances, _AnalyticsController_platformAdapter, _AnalyticsController_isAnonymousEventsFeatureEnabled, _AnalyticsController_isEventQueuePersistenceEnabled, _AnalyticsController_isPreConsentQueueEnabled, _AnalyticsController_isGeolocationEnabled, _AnalyticsController_initPromise, _AnalyticsController_locationResolvePromise, _AnalyticsController_locationContext, _AnalyticsController_performInit, _AnalyticsController_maybeResolveLocation, _AnalyticsController_resolveLocationContext, _AnalyticsController_withLocationContext, _AnalyticsController_sendOrQueueTrackEvent, _AnalyticsController_sendOrQueueIdentifyEvent, _AnalyticsController_sendOrQueueViewEvent, _AnalyticsController_enqueueEvent, _AnalyticsController_sendQueuedEvent, _AnalyticsController_replayQueuedEvents, _AnalyticsController_removeQueuedEvent, _AnalyticsController_clearQueuedEvents, _AnalyticsController_enqueuePreConsentEvent, _AnalyticsController_replayPreConsentEvents, _AnalyticsController_enrichPreConsentEvent, _AnalyticsController_clearPreConsentEvents, _AnalyticsController_reconcilePreConsentEvents;
+var _AnalyticsController_instances, _AnalyticsController_platformAdapter, _AnalyticsController_isAnonymousEventsFeatureEnabled, _AnalyticsController_isEventQueuePersistenceEnabled, _AnalyticsController_isPreConsentQueueEnabled, _AnalyticsController_isGeolocationEnabled, _AnalyticsController_isEventFragmentsEnabled, _AnalyticsController_initPromise, _AnalyticsController_locationResolvePromise, _AnalyticsController_locationContext, _AnalyticsController_performInit, _AnalyticsController_maybeResolveLocation, _AnalyticsController_resolveLocationContext, _AnalyticsController_withLocationContext, _AnalyticsController_sendOrQueueTrackEvent, _AnalyticsController_sendOrQueueIdentifyEvent, _AnalyticsController_sendOrQueueViewEvent, _AnalyticsController_enqueueEvent, _AnalyticsController_sendQueuedEvent, _AnalyticsController_replayQueuedEvents, _AnalyticsController_removeQueuedEvent, _AnalyticsController_clearQueuedEvents, _AnalyticsController_enqueuePreConsentEvent, _AnalyticsController_replayPreConsentEvents, _AnalyticsController_enrichPreConsentEvent, _AnalyticsController_clearPreConsentEvents, _AnalyticsController_reconcilePreConsentEvents, _AnalyticsController_reconcileEventFragments, _AnalyticsController_purgeStaleEventFragments, _AnalyticsController_getEventFragment, _AnalyticsController_setEventFragment, _AnalyticsController_removeEventFragment, _AnalyticsController_clearEventFragments, _AnalyticsController_shouldIgnoreEventFragmentCall, _AnalyticsController_emitEventFragment, _AnalyticsController_isAnalyticsCaptureAllowed;
 import { BaseController } from "@metamask/base-controller";
 import $lodash from "lodash";
 const { cloneDeep } = $lodash;
@@ -24,6 +24,16 @@ import { analyticsControllerSelectors } from "./selectors.mjs";
  * when composed with other controllers.
  */
 export const controllerName = 'AnalyticsController';
+/**
+ * Maximum age of a persisted event fragment, measured from
+ * {@link AnalyticsEventFragment.lastUpdated}.
+ *
+ * Fragments older than this are discarded during {@link AnalyticsController.init}
+ * without emitting a success or failure event. Confirmation journeys that span a
+ * restart are expected to resume within this window; abandoned ones must not keep
+ * `properties` or `sensitiveProperties` in storage indefinitely.
+ */
+export const EVENT_FRAGMENT_MAX_AGE = 24 * 60 * 60 * 1000;
 /**
  * Returns default values for AnalyticsController state.
  *
@@ -75,6 +85,12 @@ const analyticsControllerMetadata = {
         includeInDebugSnapshot: false,
         usedInUi: false,
     },
+    eventFragments: {
+        includeInStateLogs: false,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: false,
+    },
 };
 // === MESSENGER ===
 const MESSENGER_EXPOSED_METHODS = [
@@ -84,6 +100,12 @@ const MESSENGER_EXPOSED_METHODS = [
     'optIn',
     'optOut',
     'resetConsentDecision',
+    'createEventFragment',
+    'upsertEventFragment',
+    'updateEventFragment',
+    'getEventFragmentById',
+    'deleteEventFragment',
+    'finalizeEventFragment',
 ];
 /**
  * Returns whether a value is a non-array object.
@@ -155,6 +177,69 @@ function isAnalyticsQueuedEvent(value) {
     }
     return false;
 }
+/**
+ * Returns whether a value is a valid persisted event fragment.
+ *
+ * @param value - The value to check.
+ * @returns True if the value is an event fragment.
+ */
+function isAnalyticsEventFragment(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return (typeof value.id === 'string' &&
+        typeof value.createdAt === 'number' &&
+        typeof value.lastUpdated === 'number' &&
+        isRecord(value.properties) &&
+        isRecord(value.sensitiveProperties) &&
+        (value.initialEvent === undefined ||
+            typeof value.initialEvent === 'string') &&
+        (value.successEvent === undefined ||
+            typeof value.successEvent === 'string') &&
+        (value.failureEvent === undefined ||
+            typeof value.failureEvent === 'string') &&
+        (value.context === undefined || isRecord(value.context)) &&
+        (value.persist === undefined || typeof value.persist === 'boolean'));
+}
+/**
+ * Merges a payload into an event fragment.
+ *
+ * `properties`, `sensitiveProperties` and `context` are merged one level deep,
+ * so a key written twice is replaced rather than combined. This keeps array
+ * values predictable: writing a shorter array replaces the longer one instead
+ * of leaving stale trailing entries behind.
+ *
+ * @param fragment - The fragment to merge into.
+ * @param payload - The payload to merge.
+ * @returns A new fragment with the payload applied.
+ */
+function mergeEventFragment(fragment, payload) {
+    const context = mergeEventFragmentContext(fragment.context, payload.context);
+    return {
+        ...fragment,
+        properties: { ...fragment.properties, ...(payload.properties ?? {}) },
+        sensitiveProperties: {
+            ...fragment.sensitiveProperties,
+            ...(payload.sensitiveProperties ?? {}),
+        },
+        ...(context === undefined ? {} : { context }),
+        lastUpdated: Date.now(),
+    };
+}
+/**
+ * Merges two optional analytics contexts, preserving `undefined` when neither
+ * side has one so an empty context is never sent.
+ *
+ * @param base - The context to merge into.
+ * @param override - The context whose fields win.
+ * @returns The merged context, or `undefined` when both sides are unset.
+ */
+function mergeEventFragmentContext(base, override) {
+    if (base === undefined && override === undefined) {
+        return undefined;
+    }
+    return { ...(base ?? {}), ...(override ?? {}) };
+}
 /**
  * The AnalyticsController manages analytics tracking across platforms (Mobile/Extension).
  * It provides a unified interface for tracking events, identifying users, and managing
@@ -181,10 +266,11 @@ export class AnalyticsController extends BaseController {
      * @param options.isEventQueuePersistenceEnabled - Whether analytics event queue persistence is enabled
      * @param options.isPreConsentQueueEnabled - Whether the pre-consent event queue is enabled
      * @param options.isGeolocationEnabled - Whether geolocation enrichment is enabled
+     * @param options.isEventFragmentsEnabled - Whether the event fragments feature is enabled
      * @throws Error if state.analyticsId is missing or not a valid UUIDv4
      * @remarks After construction, call {@link AnalyticsController.init} to complete initialization.
      */
-    constructor({ state, messenger, platformAdapter, isAnonymousEventsFeatureEnabled = false, isEventQueuePersistenceEnabled = false, isPreConsentQueueEnabled = false, isGeolocationEnabled = false, }) {
+    constructor({ state, messenger, platformAdapter, isAnonymousEventsFeatureEnabled = false, isEventQueuePersistenceEnabled = false, isPreConsentQueueEnabled = false, isGeolocationEnabled = false, isEventFragmentsEnabled = false, }) {
         const initialState = {
             ...getDefaultAnalyticsControllerState(),
             ...state,
@@ -202,6 +288,7 @@ export class AnalyticsController extends BaseController {
         _AnalyticsController_isEventQueuePersistenceEnabled.set(this, void 0);
         _AnalyticsController_isPreConsentQueueEnabled.set(this, void 0);
         _AnalyticsController_isGeolocationEnabled.set(this, void 0);
+        _AnalyticsController_isEventFragmentsEnabled.set(this, void 0);
         /**
          * The in-flight (or settled) initialization promise. Set on the first
          * {@link init} call and returned by subsequent calls so overlapping callers
@@ -218,6 +305,7 @@ export class AnalyticsController extends BaseController {
         __classPrivateFieldSet(this, _AnalyticsController_isEventQueuePersistenceEnabled, isEventQueuePersistenceEnabled, "f");
         __classPrivateFieldSet(this, _AnalyticsController_isPreConsentQueueEnabled, isPreConsentQueueEnabled, "f");
         __classPrivateFieldSet(this, _AnalyticsController_isGeolocationEnabled, isGeolocationEnabled, "f");
+        __classPrivateFieldSet(this, _AnalyticsController_isEventFragmentsEnabled, isEventFragmentsEnabled, "f");
         __classPrivateFieldSet(this, _AnalyticsController_platformAdapter, platformAdapter, "f");
         __classPrivateFieldSet(this, _AnalyticsController_initPromise, undefined, "f");
         __classPrivateFieldSet(this, _AnalyticsController_locationResolvePromise, undefined, "f");
@@ -230,6 +318,7 @@ export class AnalyticsController extends BaseController {
             eventQueuePersistenceEnabled: __classPrivateFieldGet(this, _AnalyticsController_isEventQueuePersistenceEnabled, "f"),
             preConsentQueueEnabled: __classPrivateFieldGet(this, _AnalyticsController_isPreConsentQueueEnabled, "f"),
             geolocationEnabled: __classPrivateFieldGet(this, _AnalyticsController_isGeolocationEnabled, "f"),
+            eventFragmentsEnabled: __classPrivateFieldGet(this, _AnalyticsController_isEventFragmentsEnabled, "f"),
         });
     }
     /**
@@ -267,15 +356,11 @@ export class AnalyticsController extends BaseController {
      * @param context - Optional platform-specific context forwarded to the platform adapter.
      */
     trackEvent(event, context) {
-        if (!analyticsControllerSelectors.selectEnabled(this.state)) {
-            // While the user is undecided, fall through so the event is processed and
-            // captured in the pre-consent queue (see #sendOrQueueTrackEvent) to be
-            // replayed if they later opt in. Otherwise (opted out, or pre-consent
-            // queue disabled) drop it.
-            const shouldQueuePreConsent = __classPrivateFieldGet(this, _AnalyticsController_isPreConsentQueueEnabled, "f") && !this.state.consentDecisionMade;
-            if (!shouldQueuePreConsent) {
-                return;
-            }
+        // An event captured while the user is still undecided is held in the
+        // pre-consent queue (see #sendOrQueueTrackEvent) instead of being
+        // delivered, and replayed if they later opt in.
+        if (!__classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_isAnalyticsCaptureAllowed).call(this)) {
+            return;
         }
         // if event does not have properties, send event without properties
         // and return to prevent any additional processing
@@ -333,6 +418,160 @@ export class AnalyticsController extends BaseController {
         // Delegate to platform adapter
         __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_sendOrQueueViewEvent).call(this, name, properties, __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_withLocationContext).call(this, context));
     }
+    /**
+     * Create an event fragment.
+     *
+     * A fragment accumulates properties across a user journey so that several
+     * parts of a client can contribute to the same set of events without
+     * re-deriving them. Declaring `successEvent` and `failureEvent` turns the
+     * fragment into a funnel that {@link finalizeEventFragment} closes. Declaring
+     * none of the event names makes it a pure property bag that the client reads
+     * back with {@link getEventFragmentById} when it emits its own events.
+     *
+     * Any existing fragment with the same ID is replaced, so a new journey never
+     * inherits properties from a stale one.
+     *
+     * Nothing is created unless the user is opted in, or undecided with the
+     * pre-consent queue enabled, so an opted-out user accumulates no fragment
+     * data.
+     *
+     * @param options - The fragment definition. An ID is generated when one is
+     * not supplied.
+     * @returns A read-only copy of the created fragment, or `undefined` when the
+     * event fragments feature is disabled or the consent state does not allow
+     * capture. Mutating the returned object does not change controller state.
+     * Use {@link updateEventFragment} or {@link upsertEventFragment} to write.
+     */
+    createEventFragment(options = {}) {
+        if (__classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_shouldIgnoreEventFragmentCall).call(this, 'createEventFragment')) {
+            return undefined;
+        }
+        const now = Date.now();
+        const fragment = {
+            id: options.id ?? uuid(),
+            properties: { ...(options.properties ?? {}) },
+            sensitiveProperties: { ...(options.sensitiveProperties ?? {}) },
+            createdAt: now,
+            lastUpdated: now,
+            ...(options.initialEvent === undefined
+                ? {}
+                : { initialEvent: options.initialEvent }),
+            ...(options.successEvent === undefined
+                ? {}
+                : { successEvent: options.successEvent }),
+            ...(options.failureEvent === undefined
+                ? {}
+                : { failureEvent: options.failureEvent }),
+            ...(options.context === undefined
+                ? {}
+                : { context: { ...options.context } }),
+            ...(options.persist === undefined ? {} : { persist: options.persist }),
+        };
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_setEventFragment).call(this, fragment);
+        if (fragment.initialEvent) {
+            __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_emitEventFragment).call(this, fragment, fragment.initialEvent, fragment.context);
+        }
+        return cloneDeep(fragment);
+    }
+    /**
+     * Write to an event fragment, creating a property bag if none exists.
+     *
+     * This is the ergonomic entry point for contributors that do not know
+     * whether the journey has been started yet, and it avoids the read then
+     * write race a caller would otherwise have to implement itself.
+     *
+     * @param id - The fragment ID.
+     * @param payload - The properties and context to merge in.
+     */
+    upsertEventFragment(id, payload = {}) {
+        if (__classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_shouldIgnoreEventFragmentCall).call(this, 'upsertEventFragment')) {
+            return;
+        }
+        const fragment = __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_getEventFragment).call(this, id);
+        if (!fragment) {
+            this.createEventFragment({ id, ...payload });
+            return;
+        }
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_setEventFragment).call(this, mergeEventFragment(fragment, payload));
+    }
+    /**
+     * Write to an existing event fragment.
+     *
+     * @param id - The fragment ID.
+     * @param payload - The properties and context to merge in.
+     * @throws Error if no fragment has that ID when the call is not ignored.
+     * Use {@link upsertEventFragment} when the fragment may not exist yet.
+     * When the event fragments feature is disabled or the consent state does not
+     * allow capture, the call is a logged no-op and does not throw.
+     */
+    updateEventFragment(id, payload = {}) {
+        if (__classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_shouldIgnoreEventFragmentCall).call(this, 'updateEventFragment')) {
+            return;
+        }
+        const fragment = __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_getEventFragment).call(this, id);
+        if (!fragment) {
+            throw new Error(`Event fragment with id ${id} does not exist.`);
+        }
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_setEventFragment).call(this, mergeEventFragment(fragment, payload));
+    }
+    /**
+     * Read an event fragment.
+     *
+     * @param id - The fragment ID.
+     * @returns A read-only copy of the fragment, or `undefined` when no fragment
+     * has that ID, the event fragments feature is disabled, or the consent state
+     * does not allow capture. Mutating the returned object does not change
+     * controller state. Use {@link updateEventFragment} or
+     * {@link upsertEventFragment} to write.
+     */
+    getEventFragmentById(id) {
+        if (__classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_shouldIgnoreEventFragmentCall).call(this, 'getEventFragmentById')) {
+            return undefined;
+        }
+        const fragment = __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_getEventFragment).call(this, id);
+        return fragment === undefined ? undefined : cloneDeep(fragment);
+    }
+    /**
+     * Discard an event fragment without emitting anything.
+     *
+     * @param id - The fragment ID.
+     */
+    deleteEventFragment(id) {
+        if (__classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_shouldIgnoreEventFragmentCall).call(this, 'deleteEventFragment')) {
+            return;
+        }
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_removeEventFragment).call(this, id);
+    }
+    /**
+     * Close an event fragment, emitting its closing event and discarding it.
+     *
+     * The event emitted is `failureEvent` when the journey was abandoned and
+     * `successEvent` otherwise. A fragment that does not declare the relevant
+     * event name is discarded silently, which is what makes a pure property bag
+     * possible.
+     *
+     * @param id - The fragment ID.
+     * @param options - Finalization options.
+     * @param options.abandoned - Whether the journey was abandoned.
+     * @param options.context - Context merged over the fragment's own context.
+     * @throws Error if no fragment has that ID when the call is not ignored.
+     * When the event fragments feature is disabled or the consent state does not
+     * allow capture, the call is a logged no-op and does not throw.
+     */
+    finalizeEventFragment(id, { abandoned = false, context } = {}) {
+        if (__classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_shouldIgnoreEventFragmentCall).call(this, 'finalizeEventFragment')) {
+            return;
+        }
+        const fragment = __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_getEventFragment).call(this, id);
+        if (!fragment) {
+            throw new Error(`Event fragment with id ${id} does not exist.`);
+        }
+        const eventName = abandoned ? fragment.failureEvent : fragment.successEvent;
+        if (eventName) {
+            __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_emitEventFragment).call(this, fragment, eventName, mergeEventFragmentContext(fragment.context, context));
+        }
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_removeEventFragment).call(this, id);
+    }
     /**
      * Opt in to analytics.
      *
@@ -363,7 +602,8 @@ export class AnalyticsController extends BaseController {
      * Opt out of analytics.
      *
      * Records that a consent decision has been made and discards any persisted
-     * events so nothing captured before the decision is ever delivered.
+     * events and in-progress event fragments so nothing captured before the
+     * decision is ever delivered.
      */
     optOut() {
         this.update((state) => {
@@ -372,6 +612,7 @@ export class AnalyticsController extends BaseController {
         });
         __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearQueuedEvents).call(this);
         __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearPreConsentEvents).call(this);
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearEventFragments).call(this);
     }
     /**
      * Reset the consent decision back to undecided.
@@ -380,6 +621,10 @@ export class AnalyticsController extends BaseController {
      * preference and discards the delivery queue, but preserves any pre-consent
      * events so they can still be replayed if the user opts in again. The user is
      * treated as undecided again.
+     *
+     * In-progress event fragments are kept only while the undecided user can
+     * still accumulate them, and discarded otherwise, so no fragment outlives the
+     * consent state that allowed it.
      */
     resetConsentDecision() {
         this.update((state) => {
@@ -387,15 +632,29 @@ export class AnalyticsController extends BaseController {
             state.consentDecisionMade = false;
         });
         __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearQueuedEvents).call(this);
+        if (!__classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_isAnalyticsCaptureAllowed).call(this)) {
+            __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearEventFragments).call(this);
+        }
     }
 }
-_AnalyticsController_platformAdapter = new WeakMap(), _AnalyticsController_isAnonymousEventsFeatureEnabled = new WeakMap(), _AnalyticsController_isEventQueuePersistenceEnabled = new WeakMap(), _AnalyticsController_isPreConsentQueueEnabled = new WeakMap(), _AnalyticsController_isGeolocationEnabled = new WeakMap(), _AnalyticsController_initPromise = new WeakMap(), _AnalyticsController_locationResolvePromise = new WeakMap(), _AnalyticsController_locationContext = new WeakMap(), _AnalyticsController_instances = new WeakSet(), _AnalyticsController_performInit = 
+_AnalyticsController_platformAdapter = new WeakMap(), _AnalyticsController_isAnonymousEventsFeatureEnabled = new WeakMap(), _AnalyticsController_isEventQueuePersistenceEnabled = new WeakMap(), _AnalyticsController_isPreConsentQueueEnabled = new WeakMap(), _AnalyticsController_isGeolocationEnabled = new WeakMap(), _AnalyticsController_isEventFragmentsEnabled = new WeakMap(), _AnalyticsController_initPromise = new WeakMap(), _AnalyticsController_locationResolvePromise = new WeakMap(), _AnalyticsController_locationContext = new WeakMap(), _AnalyticsController_instances = new WeakSet(), _AnalyticsController_performInit = 
 /**
  * Performs the one-time initialization work: resolve geolocation, run the
  * platform adapter's onSetupCompleted lifecycle hook, then replay any queued
  * and pre-consent events.
  */
 async function _AnalyticsController_performInit() {
+    // Snapshot fragment IDs and createdAt before any awaited init work so
+    // reconciliation can tell previous-session leftovers from fragments
+    // created or replaced while init runs.
+    const initEventFragmentSnapshot = new Map();
+    for (const [id, fragment] of Object.entries(this.state.eventFragments ?? {})) {
+        if (isAnalyticsEventFragment(fragment) &&
+            fragment.id === id &&
+            typeof fragment.createdAt === 'number') {
+            initEventFragmentSnapshot.set(id, fragment.createdAt);
+        }
+    }
     // Resolve geolocation only when the user is already opted in; for undecided
     // or opted-out users it is deferred to {@link optIn}. Awaited so that an
     // already-opted-in session has location available before events replay.
@@ -411,6 +670,7 @@ async function _AnalyticsController_performInit() {
     }
     __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_replayQueuedEvents).call(this);
     __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_reconcilePreConsentEvents).call(this);
+    __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_reconcileEventFragments).call(this, initEventFragmentSnapshot);
 }, _AnalyticsController_maybeResolveLocation = function _AnalyticsController_maybeResolveLocation() {
     if (__classPrivateFieldGet(this, _AnalyticsController_isGeolocationEnabled, "f") &&
         __classPrivateFieldGet(this, _AnalyticsController_locationResolvePromise, "f") === undefined &&
@@ -633,5 +893,95 @@ async function _AnalyticsController_performInit() {
     else if (this.state.consentDecisionMade) {
         __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearPreConsentEvents).call(this);
     }
+}, _AnalyticsController_reconcileEventFragments = function _AnalyticsController_reconcileEventFragments(initEventFragmentSnapshot) {
+    const fragments = this.state.eventFragments;
+    if (!fragments) {
+        return;
+    }
+    if (!__classPrivateFieldGet(this, _AnalyticsController_isEventFragmentsEnabled, "f") || !__classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_isAnalyticsCaptureAllowed).call(this)) {
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearEventFragments).call(this);
+        return;
+    }
+    __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_purgeStaleEventFragments).call(this, fragments, initEventFragmentSnapshot);
+}, _AnalyticsController_purgeStaleEventFragments = function _AnalyticsController_purgeStaleEventFragments(currentEventFragments, initEventFragmentSnapshot) {
+    const eventFragments = {};
+    const now = Date.now();
+    for (const [id, fragment] of Object.entries(currentEventFragments)) {
+        if (!isAnalyticsEventFragment(fragment) || fragment.id !== id) {
+            log('Dropping invalid persisted event fragment', { id });
+            continue;
+        }
+        if (now - fragment.lastUpdated > EVENT_FRAGMENT_MAX_AGE) {
+            log('Dropping expired persisted event fragment', { id });
+            continue;
+        }
+        const snapshotCreatedAt = initEventFragmentSnapshot.get(id);
+        if (fragment.persist === true ||
+            snapshotCreatedAt === undefined ||
+            fragment.createdAt !== snapshotCreatedAt) {
+            eventFragments[id] = fragment;
+        }
+    }
+    if (Object.keys(eventFragments).length ===
+        Object.keys(currentEventFragments).length) {
+        return;
+    }
+    this.update((state) => {
+        state.eventFragments = eventFragments;
+    });
+}, _AnalyticsController_getEventFragment = function _AnalyticsController_getEventFragment(id) {
+    return this.state.eventFragments?.[id];
+}, _AnalyticsController_setEventFragment = function _AnalyticsController_setEventFragment(fragment) {
+    const eventFragments = {
+        ...this.state.eventFragments,
+        [fragment.id]: fragment,
+    };
+    this.update((state) => {
+        state.eventFragments = eventFragments;
+    });
+}, _AnalyticsController_removeEventFragment = function _AnalyticsController_removeEventFragment(id) {
+    const currentEventFragments = this.state.eventFragments;
+    if (!currentEventFragments ||
+        !Object.prototype.hasOwnProperty.call(currentEventFragments, id)) {
+        return;
+    }
+    const { [id]: _deletedFragment, ...eventFragments } = currentEventFragments;
+    this.update((state) => {
+        state.eventFragments = eventFragments;
+    });
+}, _AnalyticsController_clearEventFragments = function _AnalyticsController_clearEventFragments() {
+    if (!this.state.eventFragments ||
+        Object.keys(this.state.eventFragments).length === 0) {
+        return;
+    }
+    this.update((state) => {
+        state.eventFragments = {};
+    });
+}, _AnalyticsController_shouldIgnoreEventFragmentCall = function _AnalyticsController_shouldIgnoreEventFragmentCall(method) {
+    if (!__classPrivateFieldGet(this, _AnalyticsController_isEventFragmentsEnabled, "f")) {
+        log('Ignoring event fragment call because the event fragments feature is disabled', { method });
+        return true;
+    }
+    if (!__classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_isAnalyticsCaptureAllowed).call(this)) {
+        log('Ignoring event fragment call because the consent state does not allow capturing analytics', { method });
+        return true;
+    }
+    return false;
+}, _AnalyticsController_emitEventFragment = function _AnalyticsController_emitEventFragment(fragment, name, context) {
+    const properties = { ...fragment.properties };
+    const sensitiveProperties = { ...fragment.sensitiveProperties };
+    this.trackEvent({
+        name,
+        properties,
+        sensitiveProperties,
+        saveDataRecording: false,
+        hasProperties: Object.keys(properties).length > 0 ||
+            Object.keys(sensitiveProperties).length > 0,
+    }, context);
+}, _AnalyticsController_isAnalyticsCaptureAllowed = function _AnalyticsController_isAnalyticsCaptureAllowed() {
+    if (analyticsControllerSelectors.selectEnabled(this.state)) {
+        return true;
+    }
+    return __classPrivateFieldGet(this, _AnalyticsController_isPreConsentQueueEnabled, "f") && !this.state.consentDecisionMade;
 };
 //# sourceMappingURL=AnalyticsController.mjs.map