@metamask-previews/analytics-controller 2.0.0-preview-3866c0ff1 → 2.0.0-preview-e3275932a

package/dist/AnalyticsController.cjs

@@ -0,0 +1,641 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsController = exports.getDefaultAnalyticsControllerState = exports.controllerName = void 0;
+const base_controller_1 = require("@metamask/base-controller");
+const lodash_1 = require("lodash");
+const uuid_1 = require("uuid");
+const analyticsControllerStateValidator_js_1 = require("./analyticsControllerStateValidator.cjs");
+const AnalyticsLogger_js_1 = require("./AnalyticsLogger.cjs");
+const selectors_js_1 = require("./selectors.cjs");
+// === GENERAL ===
+/**
+ * The name of the {@link AnalyticsController}, used to namespace the
+ * controller's actions and events and to namespace the controller's state data
+ * when composed with other controllers.
+ */
+exports.controllerName = 'AnalyticsController';
+/**
+ * Returns default values for AnalyticsController state.
+ *
+ * Note: analyticsId is NOT included - it's an identity that must be
+ * provided by the platform (generated once on first run, then persisted).
+ *
+ * @returns Default state without analyticsId
+ */
+function getDefaultAnalyticsControllerState() {
+    return {
+        optedIn: false,
+        consentDecisionMade: false,
+    };
+}
+exports.getDefaultAnalyticsControllerState = getDefaultAnalyticsControllerState;
+/**
+ * The metadata for each property in {@link AnalyticsControllerState}.
+ *
+ * Both `optedIn` and `analyticsId` are persisted (`persist: true`).
+ * The platform must supply a valid UUIDv4 `analyticsId` on first run.
+ */
+const analyticsControllerMetadata = {
+    optedIn: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: true,
+        usedInUi: true,
+    },
+    analyticsId: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: true,
+        usedInUi: false,
+    },
+    eventQueue: {
+        includeInStateLogs: false,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: false,
+    },
+    consentDecisionMade: {
+        includeInStateLogs: true,
+        persist: true,
+        includeInDebugSnapshot: true,
+        usedInUi: true,
+    },
+    preConsentEventQueue: {
+        includeInStateLogs: false,
+        persist: true,
+        includeInDebugSnapshot: false,
+        usedInUi: false,
+    },
+};
+// === MESSENGER ===
+const MESSENGER_EXPOSED_METHODS = [
+    'trackEvent',
+    'identify',
+    'trackView',
+    'optIn',
+    'optOut',
+    'resetConsentDecision',
+];
+/**
+ * Returns whether a value is a non-array object.
+ *
+ * @param value - The value to check.
+ * @returns True if the value is a record.
+ */
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Returns whether a JSON value is a non-array object.
+ *
+ * @param value - The value to check.
+ * @returns True if the value is a JSON record.
+ */
+function isJsonRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/**
+ * Builds the analytics location context from geolocation data, keeping only
+ * the fields the geolocation API was able to determine.
+ *
+ * @param geolocation - The geolocation data to convert.
+ * @returns The location context, or `undefined` when no field is known.
+ */
+function buildLocationContext(geolocation) {
+    const locationContext = {
+        ...(geolocation.country === null
+            ? {}
+            : { country_code: geolocation.country }),
+        ...(geolocation.region === null ? {} : { region: geolocation.region }),
+        ...(geolocation.timezone === null
+            ? {}
+            : { timezone: geolocation.timezone }),
+    };
+    return Object.keys(locationContext).length === 0
+        ? undefined
+        : locationContext;
+}
+/**
+ * Returns whether a value is a valid persisted analytics event.
+ *
+ * @param value - The value to check.
+ * @returns True if the value is a queued analytics event.
+ */
+function isAnalyticsQueuedEvent(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (typeof value.messageId !== 'string' ||
+        typeof value.timestamp !== 'string') {
+        return false;
+    }
+    if (value.type === 'track') {
+        return (typeof value.eventName === 'string' &&
+            (value.properties === undefined || isRecord(value.properties)) &&
+            (value.context === undefined || isRecord(value.context)));
+    }
+    if (value.type === 'identify') {
+        return (typeof value.userId === 'string' &&
+            (value.traits === undefined || isRecord(value.traits)) &&
+            (value.context === undefined || isRecord(value.context)));
+    }
+    if (value.type === 'view') {
+        return (typeof value.name === 'string' &&
+            (value.properties === undefined || isRecord(value.properties)) &&
+            (value.context === undefined || isRecord(value.context)));
+    }
+    return false;
+}
+/**
+ * The AnalyticsController manages analytics tracking across platforms (Mobile/Extension).
+ * It provides a unified interface for tracking events, identifying users, and managing
+ * analytics preferences while delegating platform-specific implementation to an
+ * {@link AnalyticsPlatformAdapter}.
+ *
+ * This controller follows the MetaMask controller pattern and integrates with the
+ * messenger system to allow other controllers and components to track analytics events.
+ * It delegates platform-specific implementation to an {@link AnalyticsPlatformAdapter}.
+ *
+ * The controller persists `optedIn` and `analyticsId` when composed with a persisted
+ * store. The platform must supply a valid `analyticsId` on first launch.
+ */
+class AnalyticsController extends base_controller_1.BaseController {
+    /**
+     * Constructs an AnalyticsController instance.
+     *
+     * @param options - Controller options
+     * @param options.state - Initial controller state. Must include a valid UUIDv4 `analyticsId`.
+     * Use `getDefaultAnalyticsControllerState()` for default opt-in preferences.
+     * @param options.messenger - Messenger used to communicate with BaseController
+     * @param options.platformAdapter - Platform adapter implementation for tracking
+     * @param options.isAnonymousEventsFeatureEnabled - Whether the anonymous events feature is enabled
+     * @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
+     * @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, }) {
+        const initialState = {
+            ...getDefaultAnalyticsControllerState(),
+            ...state,
+        };
+        (0, analyticsControllerStateValidator_js_1.validateAnalyticsControllerState)(initialState, platformAdapter.skipUUIDv4Check === true);
+        super({
+            name: exports.controllerName,
+            metadata: analyticsControllerMetadata,
+            state: initialState,
+            messenger,
+        });
+        _AnalyticsController_instances.add(this);
+        _AnalyticsController_platformAdapter.set(this, void 0);
+        _AnalyticsController_isAnonymousEventsFeatureEnabled.set(this, void 0);
+        _AnalyticsController_isEventQueuePersistenceEnabled.set(this, void 0);
+        _AnalyticsController_isPreConsentQueueEnabled.set(this, void 0);
+        _AnalyticsController_isGeolocationEnabled.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
+         * await the same work rather than observing a premature completion.
+         */
+        _AnalyticsController_initPromise.set(this, void 0);
+        /**
+         * The in-flight (or settled) geolocation resolution, if any. Its presence
+         * marks that resolution has been started, so it runs at most once.
+         */
+        _AnalyticsController_locationResolvePromise.set(this, void 0);
+        _AnalyticsController_locationContext.set(this, void 0);
+        __classPrivateFieldSet(this, _AnalyticsController_isAnonymousEventsFeatureEnabled, isAnonymousEventsFeatureEnabled, "f");
+        __classPrivateFieldSet(this, _AnalyticsController_isEventQueuePersistenceEnabled, isEventQueuePersistenceEnabled, "f");
+        __classPrivateFieldSet(this, _AnalyticsController_isPreConsentQueueEnabled, isPreConsentQueueEnabled, "f");
+        __classPrivateFieldSet(this, _AnalyticsController_isGeolocationEnabled, isGeolocationEnabled, "f");
+        __classPrivateFieldSet(this, _AnalyticsController_platformAdapter, platformAdapter, "f");
+        __classPrivateFieldSet(this, _AnalyticsController_initPromise, undefined, "f");
+        __classPrivateFieldSet(this, _AnalyticsController_locationResolvePromise, undefined, "f");
+        this.messenger.registerMethodActionHandlers(this, MESSENGER_EXPOSED_METHODS);
+        (0, AnalyticsLogger_js_1.projectLogger)('AnalyticsController initialized and ready', {
+            enabled: selectors_js_1.analyticsControllerSelectors.selectEnabled(this.state),
+            optedIn: this.state.optedIn,
+            consentDecisionMade: this.state.consentDecisionMade,
+            analyticsId: this.state.analyticsId,
+            eventQueuePersistenceEnabled: __classPrivateFieldGet(this, _AnalyticsController_isEventQueuePersistenceEnabled, "f"),
+            preConsentQueueEnabled: __classPrivateFieldGet(this, _AnalyticsController_isPreConsentQueueEnabled, "f"),
+            geolocationEnabled: __classPrivateFieldGet(this, _AnalyticsController_isGeolocationEnabled, "f"),
+        });
+    }
+    /**
+     * Initialize the controller by calling the platform adapter's
+     * onSetupCompleted lifecycle hook and replaying any queued events. This
+     * method must be called after construction to complete the setup process.
+     *
+     * When geolocation enrichment is enabled (`isGeolocationEnabled`), geolocation
+     * is resolved only for a user who is already opted in; for undecided or
+     * opted-out users it is deferred until they opt in (see {@link optIn}), so a
+     * user's location is never requested before they consent to analytics. In
+     * either case the `GeolocationController` and its
+     * `GeolocationController:getGeolocationData` action must be registered before
+     * resolution occurs, or enrichment is skipped for the session (a message is
+     * logged, see {@link #resolveLocationContext}).
+     *
+     * Safe to call more than once: the first call performs initialization and
+     * subsequent calls return the same in-flight (or settled) promise.
+     *
+     * @returns A promise that resolves once initialization has completed.
+     */
+    init() {
+        // Cache the in-flight promise so repeated or overlapping calls share a
+        // single initialization and all await the same completion (rather than an
+        // early call observing a finished init while work is still pending).
+        __classPrivateFieldSet(this, _AnalyticsController_initPromise, __classPrivateFieldGet(this, _AnalyticsController_initPromise, "f") ?? __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_performInit).call(this), "f");
+        return __classPrivateFieldGet(this, _AnalyticsController_initPromise, "f");
+    }
+    /**
+     * Track an analytics event.
+     *
+     * Events are only tracked if analytics is enabled.
+     *
+     * @param event - Analytics event with properties and sensitive properties
+     * @param context - Optional platform-specific context forwarded to the platform adapter.
+     */
+    trackEvent(event, context) {
+        if (!selectors_js_1.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;
+            }
+        }
+        // if event does not have properties, send event without properties
+        // and return to prevent any additional processing
+        if (!event.hasProperties) {
+            __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_sendOrQueueTrackEvent).call(this, event.name, undefined, __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_withLocationContext).call(this, context));
+            return;
+        }
+        // Track regular properties first if anonymous events feature is enabled
+        if (__classPrivateFieldGet(this, _AnalyticsController_isAnonymousEventsFeatureEnabled, "f")) {
+            // Note: Even if regular properties object is empty, we still send it to ensure
+            // an event with user ID is tracked.
+            __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_sendOrQueueTrackEvent).call(this, event.name, {
+                ...event.properties,
+            }, __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_withLocationContext).call(this, context));
+        }
+        const hasSensitiveProperties = Object.keys(event.sensitiveProperties).length > 0;
+        if (!__classPrivateFieldGet(this, _AnalyticsController_isAnonymousEventsFeatureEnabled, "f") || hasSensitiveProperties) {
+            __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_sendOrQueueTrackEvent).call(this, event.name, {
+                ...event.properties,
+                ...event.sensitiveProperties,
+                ...(hasSensitiveProperties && { anonymous: true }),
+            }, 
+            // When the anonymous events feature is enabled, this payload is the
+            // anonymous one and must carry no geolocation. When the feature is
+            // disabled, this is the single identified payload, so it is enriched.
+            __classPrivateFieldGet(this, _AnalyticsController_isAnonymousEventsFeatureEnabled, "f")
+                ? context
+                : __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_withLocationContext).call(this, context));
+        }
+    }
+    /**
+     * Identify a user for analytics.
+     *
+     * @param traits - User traits/properties
+     * @param context - Optional platform-specific context forwarded to the platform adapter.
+     */
+    identify(traits, context) {
+        if (!selectors_js_1.analyticsControllerSelectors.selectEnabled(this.state)) {
+            return;
+        }
+        // Delegate to platform adapter using the current analytics ID
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_sendOrQueueIdentifyEvent).call(this, this.state.analyticsId, traits, __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_withLocationContext).call(this, context));
+    }
+    /**
+     * Track a page or screen view.
+     *
+     * @param name - The identifier/name of the page or screen being viewed (e.g., "home", "settings", "wallet")
+     * @param properties - Optional properties associated with the view
+     * @param context - Optional platform-specific context forwarded to the platform adapter.
+     */
+    trackView(name, properties, context) {
+        if (!selectors_js_1.analyticsControllerSelectors.selectEnabled(this.state)) {
+            return;
+        }
+        // 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));
+    }
+    /**
+     * Opt in to analytics.
+     *
+     * Records that a consent decision has been made and replays any events that
+     * were queued while the user was undecided.
+     *
+     * When geolocation enrichment is enabled, geolocation is resolved here (once
+     * the user has consented) and awaited before the queued events are replayed,
+     * so those events are enriched with the resolved location as they are sent.
+     *
+     * @returns A promise that resolves once opt-in processing has completed.
+     */
+    async optIn() {
+        this.update((state) => {
+            state.optedIn = true;
+            state.consentDecisionMade = true;
+        });
+        // Now that the user has consented, resolve geolocation (once) and wait for
+        // it so the queued pre-consent events can be enriched as they replay.
+        await __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_maybeResolveLocation).call(this);
+        // Reconcile against the current state rather than replaying blindly: the
+        // consent decision may have changed while geolocation was resolving (e.g.
+        // resetConsentDecision ran during the await), and preserved pre-consent
+        // events must not be delivered once the user is no longer opted in.
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_reconcilePreConsentEvents).call(this);
+    }
+    /**
+     * 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.
+     */
+    optOut() {
+        this.update((state) => {
+            state.optedIn = false;
+            state.consentDecisionMade = true;
+        });
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearQueuedEvents).call(this);
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearPreConsentEvents).call(this);
+    }
+    /**
+     * Reset the consent decision back to undecided.
+     *
+     * Intended for client flows that restart onboarding. Clears the opt-in
+     * 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.
+     */
+    resetConsentDecision() {
+        this.update((state) => {
+            state.optedIn = false;
+            state.consentDecisionMade = false;
+        });
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearQueuedEvents).call(this);
+    }
+}
+exports.AnalyticsController = AnalyticsController;
+_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 = 
+/**
+ * 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() {
+    // 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.
+    await __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_maybeResolveLocation).call(this);
+    // Call onSetupCompleted lifecycle hook after initialization
+    // State is already validated, so analyticsId is guaranteed to be a valid UUIDv4
+    try {
+        __classPrivateFieldGet(this, _AnalyticsController_platformAdapter, "f").onSetupCompleted(this.state.analyticsId);
+    }
+    catch (error) {
+        // Log error but don't throw - adapter setup failure shouldn't break controller
+        (0, AnalyticsLogger_js_1.projectLogger)('Error calling platformAdapter.onSetupCompleted', error);
+    }
+    __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_replayQueuedEvents).call(this);
+    __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_reconcilePreConsentEvents).call(this);
+}, _AnalyticsController_maybeResolveLocation = function _AnalyticsController_maybeResolveLocation() {
+    if (__classPrivateFieldGet(this, _AnalyticsController_isGeolocationEnabled, "f") &&
+        __classPrivateFieldGet(this, _AnalyticsController_locationResolvePromise, "f") === undefined &&
+        selectors_js_1.analyticsControllerSelectors.selectEnabled(this.state)) {
+        __classPrivateFieldSet(this, _AnalyticsController_locationResolvePromise, __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_resolveLocationContext).call(this), "f");
+    }
+    return __classPrivateFieldGet(this, _AnalyticsController_locationResolvePromise, "f");
+}, _AnalyticsController_resolveLocationContext = async function _AnalyticsController_resolveLocationContext() {
+    try {
+        const geolocation = await this.messenger.call('GeolocationController:getGeolocationData');
+        __classPrivateFieldSet(this, _AnalyticsController_locationContext, buildLocationContext(geolocation), "f");
+    }
+    catch (error) {
+        // A common cause is the GeolocationController not being registered before
+        // resolution runs (at init for an opted-in user, otherwise at opt-in).
+        // Name it here so the failure is diagnosable, since enrichment is
+        // otherwise skipped silently for the session.
+        (0, AnalyticsLogger_js_1.projectLogger)('Failed to resolve geolocation for analytics enrichment; events will be sent without location. Ensure the GeolocationController is registered and initialized before the user opts in when geolocation is enabled.', error);
+    }
+}, _AnalyticsController_withLocationContext = function _AnalyticsController_withLocationContext(context) {
+    if (!__classPrivateFieldGet(this, _AnalyticsController_locationContext, "f")) {
+        return context;
+    }
+    const callerLocation = context?.location;
+    return {
+        ...context,
+        location: {
+            ...(isJsonRecord(callerLocation) ? callerLocation : {}),
+            ...__classPrivateFieldGet(this, _AnalyticsController_locationContext, "f"),
+        },
+    };
+}, _AnalyticsController_sendOrQueueTrackEvent = function _AnalyticsController_sendOrQueueTrackEvent(eventName, properties, context) {
+    // Direct delivery: enabled and not persisting.
+    if (selectors_js_1.analyticsControllerSelectors.selectEnabled(this.state) &&
+        !__classPrivateFieldGet(this, _AnalyticsController_isEventQueuePersistenceEnabled, "f")) {
+        __classPrivateFieldGet(this, _AnalyticsController_platformAdapter, "f").track(eventName, properties, context);
+        return;
+    }
+    const queuedEvent = {
+        type: 'track',
+        eventName,
+        messageId: (0, uuid_1.v4)(),
+        timestamp: new Date().toISOString(),
+        ...(properties === undefined ? {} : { properties }),
+        ...(context === undefined ? {} : { context }),
+    };
+    // Not yet enabled (reached only while undecided with the pre-consent queue
+    // enabled): hold the event until the user opts in.
+    if (!selectors_js_1.analyticsControllerSelectors.selectEnabled(this.state)) {
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_enqueuePreConsentEvent).call(this, queuedEvent);
+        return;
+    }
+    __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_enqueueEvent).call(this, queuedEvent);
+}, _AnalyticsController_sendOrQueueIdentifyEvent = function _AnalyticsController_sendOrQueueIdentifyEvent(userId, traits, context) {
+    if (!__classPrivateFieldGet(this, _AnalyticsController_isEventQueuePersistenceEnabled, "f")) {
+        __classPrivateFieldGet(this, _AnalyticsController_platformAdapter, "f").identify(userId, traits, context);
+        return;
+    }
+    const queuedEvent = {
+        type: 'identify',
+        userId,
+        messageId: (0, uuid_1.v4)(),
+        timestamp: new Date().toISOString(),
+        ...(traits === undefined ? {} : { traits }),
+        ...(context === undefined ? {} : { context }),
+    };
+    __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_enqueueEvent).call(this, queuedEvent);
+}, _AnalyticsController_sendOrQueueViewEvent = function _AnalyticsController_sendOrQueueViewEvent(name, properties, context) {
+    if (!__classPrivateFieldGet(this, _AnalyticsController_isEventQueuePersistenceEnabled, "f")) {
+        __classPrivateFieldGet(this, _AnalyticsController_platformAdapter, "f").view(name, properties, context);
+        return;
+    }
+    const queuedEvent = {
+        type: 'view',
+        name,
+        messageId: (0, uuid_1.v4)(),
+        timestamp: new Date().toISOString(),
+        ...(properties === undefined ? {} : { properties }),
+        ...(context === undefined ? {} : { context }),
+    };
+    __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_enqueueEvent).call(this, queuedEvent);
+}, _AnalyticsController_enqueueEvent = function _AnalyticsController_enqueueEvent(queuedEvent) {
+    const eventQueue = {
+        ...(this.state.eventQueue ?? {}),
+        [queuedEvent.messageId]: queuedEvent,
+    };
+    this.update((state) => {
+        state.eventQueue = eventQueue;
+    });
+    __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_sendQueuedEvent).call(this, queuedEvent);
+}, _AnalyticsController_sendQueuedEvent = function _AnalyticsController_sendQueuedEvent(queuedEvent) {
+    const timestamp = new Date(queuedEvent.timestamp);
+    if (Number.isNaN(timestamp.getTime())) {
+        (0, AnalyticsLogger_js_1.projectLogger)('Dropping queued analytics event with invalid timestamp', {
+            messageId: queuedEvent.messageId,
+        });
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_removeQueuedEvent).call(this, queuedEvent.messageId);
+        return;
+    }
+    const options = {
+        messageId: queuedEvent.messageId,
+        timestamp,
+        callback: (error) => {
+            if (error) {
+                (0, AnalyticsLogger_js_1.projectLogger)('Queued analytics event delivery failed', {
+                    messageId: queuedEvent.messageId,
+                    error,
+                });
+            }
+            __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_removeQueuedEvent).call(this, queuedEvent.messageId);
+        },
+    };
+    try {
+        if (queuedEvent.type === 'track') {
+            __classPrivateFieldGet(this, _AnalyticsController_platformAdapter, "f").track(queuedEvent.eventName, (0, lodash_1.cloneDeep)(queuedEvent.properties), (0, lodash_1.cloneDeep)(queuedEvent.context), options);
+        }
+        else if (queuedEvent.type === 'identify') {
+            __classPrivateFieldGet(this, _AnalyticsController_platformAdapter, "f").identify(queuedEvent.userId, (0, lodash_1.cloneDeep)(queuedEvent.traits), (0, lodash_1.cloneDeep)(queuedEvent.context), options);
+        }
+        else {
+            __classPrivateFieldGet(this, _AnalyticsController_platformAdapter, "f").view(queuedEvent.name, (0, lodash_1.cloneDeep)(queuedEvent.properties), (0, lodash_1.cloneDeep)(queuedEvent.context), options);
+        }
+    }
+    catch (error) {
+        (0, AnalyticsLogger_js_1.projectLogger)('Error sending queued analytics event', {
+            messageId: queuedEvent.messageId,
+            error,
+        });
+    }
+}, _AnalyticsController_replayQueuedEvents = function _AnalyticsController_replayQueuedEvents() {
+    if (!__classPrivateFieldGet(this, _AnalyticsController_isEventQueuePersistenceEnabled, "f") || !this.state.eventQueue) {
+        return;
+    }
+    if (!selectors_js_1.analyticsControllerSelectors.selectEnabled(this.state)) {
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearQueuedEvents).call(this);
+        return;
+    }
+    for (const [messageId, queuedEvent] of Object.entries(this.state.eventQueue)) {
+        if (!isAnalyticsQueuedEvent(queuedEvent) ||
+            queuedEvent.messageId !== messageId) {
+            (0, AnalyticsLogger_js_1.projectLogger)('Dropping invalid queued analytics event', { messageId });
+            __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_removeQueuedEvent).call(this, messageId);
+            continue;
+        }
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_sendQueuedEvent).call(this, queuedEvent);
+    }
+}, _AnalyticsController_removeQueuedEvent = function _AnalyticsController_removeQueuedEvent(messageId) {
+    const currentEventQueue = this.state.eventQueue;
+    if (!currentEventQueue ||
+        !Object.prototype.hasOwnProperty.call(currentEventQueue, messageId)) {
+        return;
+    }
+    const { [messageId]: _deletedEvent, ...eventQueue } = currentEventQueue;
+    this.update((state) => {
+        state.eventQueue = eventQueue;
+    });
+}, _AnalyticsController_clearQueuedEvents = function _AnalyticsController_clearQueuedEvents() {
+    if (!this.state.eventQueue ||
+        Object.keys(this.state.eventQueue).length === 0) {
+        return;
+    }
+    this.update((state) => {
+        state.eventQueue = {};
+    });
+}, _AnalyticsController_enqueuePreConsentEvent = function _AnalyticsController_enqueuePreConsentEvent(queuedEvent) {
+    const preConsentEventQueue = {
+        ...(this.state.preConsentEventQueue ?? {}),
+        [queuedEvent.messageId]: queuedEvent,
+    };
+    this.update((state) => {
+        state.preConsentEventQueue = preConsentEventQueue;
+    });
+}, _AnalyticsController_replayPreConsentEvents = function _AnalyticsController_replayPreConsentEvents(queue) {
+    __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearPreConsentEvents).call(this);
+    for (const [messageId, queuedEvent] of Object.entries(queue)) {
+        if (!isAnalyticsQueuedEvent(queuedEvent) ||
+            queuedEvent.messageId !== messageId) {
+            (0, AnalyticsLogger_js_1.projectLogger)('Dropping invalid queued pre-consent analytics event', {
+                messageId,
+            });
+            continue;
+        }
+        const eventToReplay = __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_enrichPreConsentEvent).call(this, queuedEvent);
+        if (__classPrivateFieldGet(this, _AnalyticsController_isEventQueuePersistenceEnabled, "f")) {
+            __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_enqueueEvent).call(this, eventToReplay);
+        }
+        else {
+            __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_sendQueuedEvent).call(this, eventToReplay);
+        }
+    }
+}, _AnalyticsController_enrichPreConsentEvent = function _AnalyticsController_enrichPreConsentEvent(queuedEvent) {
+    if (queuedEvent.type === 'track' &&
+        queuedEvent.properties?.anonymous === true) {
+        return queuedEvent;
+    }
+    const context = __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_withLocationContext).call(this, queuedEvent.context);
+    return {
+        ...queuedEvent,
+        ...(context === undefined ? {} : { context }),
+    };
+}, _AnalyticsController_clearPreConsentEvents = function _AnalyticsController_clearPreConsentEvents() {
+    if (!this.state.preConsentEventQueue) {
+        return;
+    }
+    this.update((state) => {
+        state.preConsentEventQueue = {};
+    });
+}, _AnalyticsController_reconcilePreConsentEvents = function _AnalyticsController_reconcilePreConsentEvents() {
+    const queue = this.state.preConsentEventQueue;
+    if (!queue) {
+        return;
+    }
+    if (!__classPrivateFieldGet(this, _AnalyticsController_isPreConsentQueueEnabled, "f")) {
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearPreConsentEvents).call(this);
+        return;
+    }
+    if (this.state.optedIn) {
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_replayPreConsentEvents).call(this, queue);
+    }
+    else if (this.state.consentDecisionMade) {
+        __classPrivateFieldGet(this, _AnalyticsController_instances, "m", _AnalyticsController_clearPreConsentEvents).call(this);
+    }
+};
+//# sourceMappingURL=AnalyticsController.cjs.map