@angular/fire 17.1.0 → 18.0.0-canary.c866d08

package/fesm2022/angular-fire-analytics.mjs

@@ -1,323 +1,436 @@
-import { ɵgetAllInstancesOf, ɵisSupportedError, ɵzoneWrap, VERSION, ɵgetDefaultInstanceOf, ɵAngularFireSchedulers } from '@angular/fire';
-import { from, timer, of } from 'rxjs';
-import { concatMap, distinct, filter, switchMap, map, groupBy, distinctUntilChanged, startWith, pairwise, mergeMap } from 'rxjs/operators';
-import * as i0 from '@angular/core';
-import { Injectable, Optional, InjectionToken, APP_INITIALIZER, NgModule, NgZone, Injector, makeEnvironmentProviders } from '@angular/core';
-import { FirebaseApp, FirebaseApps } from '@angular/fire/app';
-import { registerVersion } from 'firebase/app';
-import { isSupported as isSupported$1, getAnalytics as getAnalytics$1, getGoogleAnalyticsClientId as getGoogleAnalyticsClientId$1, initializeAnalytics as initializeAnalytics$1, logEvent as logEvent$1, setAnalyticsCollectionEnabled as setAnalyticsCollectionEnabled$1, setConsent as setConsent$1, setCurrentScreen as setCurrentScreen$1, setDefaultEventParameters as setDefaultEventParameters$1, settings as settings$1, setUserId as setUserId$1, setUserProperties as setUserProperties$1 } from 'firebase/analytics';
-export * from 'firebase/analytics';
-import * as i2 from '@angular/platform-browser';
-import * as i1$1 from '@angular/router';
-import { ActivationEnd, ɵEmptyOutletComponent } from '@angular/router';
-import * as i1 from '@angular/fire/auth';
-import { authState } from '@angular/fire/auth';
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 
-class Analytics {
-    constructor(analytics) {
-        return analytics;
-    }
-}
-const ANALYTICS_PROVIDER_NAME = 'analytics';
-class AnalyticsInstances {
-    constructor() {
-        return ɵgetAllInstancesOf(ANALYTICS_PROVIDER_NAME);
-    }
-}
-const analyticInstance$ = timer(0, 300).pipe(concatMap(() => from(ɵgetAllInstancesOf(ANALYTICS_PROVIDER_NAME))), distinct());
+// angular-fire-analytics.mjs
+var angular_fire_analytics_exports = {};
+__export(angular_fire_analytics_exports, {
+  Analytics: () => Analytics,
+  AnalyticsInstances: () => AnalyticsInstances,
+  AnalyticsModule: () => AnalyticsModule,
+  ScreenTrackingService: () => ScreenTrackingService,
+  UserTrackingService: () => UserTrackingService,
+  analyticInstance$: () => analyticInstance$,
+  getAnalytics: () => getAnalytics,
+  getGoogleAnalyticsClientId: () => getGoogleAnalyticsClientId,
+  initializeAnalytics: () => initializeAnalytics,
+  isSupported: () => isSupported2,
+  logEvent: () => logEvent,
+  provideAnalytics: () => provideAnalytics,
+  setAnalyticsCollectionEnabled: () => setAnalyticsCollectionEnabled,
+  setConsent: () => setConsent,
+  setCurrentScreen: () => setCurrentScreen,
+  setDefaultEventParameters: () => setDefaultEventParameters,
+  setUserId: () => setUserId,
+  setUserProperties: () => setUserProperties,
+  settings: () => settings,
+  ɵscreenViewEvent: () => ɵscreenViewEvent
+});
 
-const isAnalyticsSupportedValueSymbol = '__angularfire_symbol__analyticsIsSupportedValue';
-const isAnalyticsSupportedPromiseSymbol = '__angularfire_symbol__analyticsIsSupported';
-globalThis[isAnalyticsSupportedPromiseSymbol] ||= isSupported$1().then(it => globalThis[isAnalyticsSupportedValueSymbol] = it).catch(() => globalThis[isAnalyticsSupportedValueSymbol] = false);
-const isAnalyticsSupportedFactory = {
-    async: () => globalThis[isAnalyticsSupportedPromiseSymbol],
-    sync: () => {
-        const ret = globalThis[isAnalyticsSupportedValueSymbol];
-        if (ret === undefined) {
-            throw new Error(ɵisSupportedError('Analytics'));
-        }
-        return ret;
+// public_api.mjs
+var public_api_exports = {};
+__export(public_api_exports, {
+  Analytics: () => Analytics,
+  AnalyticsInstances: () => AnalyticsInstances,
+  AnalyticsModule: () => AnalyticsModule,
+  ScreenTrackingService: () => ScreenTrackingService,
+  UserTrackingService: () => UserTrackingService,
+  analyticInstance$: () => analyticInstance$,
+  getAnalytics: () => getAnalytics,
+  getGoogleAnalyticsClientId: () => getGoogleAnalyticsClientId,
+  initializeAnalytics: () => initializeAnalytics,
+  isSupported: () => isSupported2,
+  logEvent: () => logEvent,
+  provideAnalytics: () => provideAnalytics,
+  setAnalyticsCollectionEnabled: () => setAnalyticsCollectionEnabled,
+  setConsent: () => setConsent,
+  setCurrentScreen: () => setCurrentScreen,
+  setDefaultEventParameters: () => setDefaultEventParameters,
+  setUserId: () => setUserId,
+  setUserProperties: () => setUserProperties,
+  settings: () => settings,
+  ɵscreenViewEvent: () => ɵscreenViewEvent
+});
+
+// analytics.mjs
+import { ɵgetAllInstancesOf } from "@angular/fire";
+import { from, timer } from "rxjs";
+import { concatMap, distinct } from "rxjs/operators";
+var Analytics = class {
+  constructor(analytics) {
+    return analytics;
+  }
+};
+var ANALYTICS_PROVIDER_NAME = "analytics";
+var AnalyticsInstances = class {
+  constructor() {
+    return ɵgetAllInstancesOf(ANALYTICS_PROVIDER_NAME);
+  }
+};
+var analyticInstance$ = timer(0, 300).pipe(concatMap(() => from(ɵgetAllInstancesOf(ANALYTICS_PROVIDER_NAME))), distinct());
+
+// is-analytics-supported-factory.mjs
+import { ɵisSupportedError } from "@angular/fire";
+import { isSupported } from "firebase/analytics";
+var isAnalyticsSupportedValueSymbol = "__angularfire_symbol__analyticsIsSupportedValue";
+var isAnalyticsSupportedPromiseSymbol = "__angularfire_symbol__analyticsIsSupported";
+globalThis[isAnalyticsSupportedPromiseSymbol] ||= isSupported().then((it) => globalThis[isAnalyticsSupportedValueSymbol] = it).catch(() => globalThis[isAnalyticsSupportedValueSymbol] = false);
+var isAnalyticsSupportedFactory = {
+  async: () => globalThis[isAnalyticsSupportedPromiseSymbol],
+  sync: () => {
+    const ret = globalThis[isAnalyticsSupportedValueSymbol];
+    if (ret === void 0) {
+      throw new Error(ɵisSupportedError("Analytics"));
     }
+    return ret;
+  }
 };
 
-const isSupported = isAnalyticsSupportedFactory.async;
+// firebase.mjs
+var firebase_exports = {};
+__export(firebase_exports, {
+  getAnalytics: () => getAnalytics,
+  getGoogleAnalyticsClientId: () => getGoogleAnalyticsClientId,
+  initializeAnalytics: () => initializeAnalytics,
+  isSupported: () => isSupported2,
+  logEvent: () => logEvent,
+  setAnalyticsCollectionEnabled: () => setAnalyticsCollectionEnabled,
+  setConsent: () => setConsent,
+  setCurrentScreen: () => setCurrentScreen,
+  setDefaultEventParameters: () => setDefaultEventParameters,
+  setUserId: () => setUserId,
+  setUserProperties: () => setUserProperties,
+  settings: () => settings
+});
 
-// DO NOT MODIFY, this file is autogenerated by tools/build.ts
-const getAnalytics = ɵzoneWrap(getAnalytics$1, true);
-const getGoogleAnalyticsClientId = ɵzoneWrap(getGoogleAnalyticsClientId$1, true);
-const initializeAnalytics = ɵzoneWrap(initializeAnalytics$1, true);
-const logEvent = ɵzoneWrap(logEvent$1, true);
-const setAnalyticsCollectionEnabled = ɵzoneWrap(setAnalyticsCollectionEnabled$1, true);
-const setConsent = ɵzoneWrap(setConsent$1, true);
-const setCurrentScreen = ɵzoneWrap(setCurrentScreen$1, true);
-const setDefaultEventParameters = ɵzoneWrap(setDefaultEventParameters$1, true);
-const settings = ɵzoneWrap(settings$1, true);
-const setUserId = ɵzoneWrap(setUserId$1, true);
-const setUserProperties = ɵzoneWrap(setUserProperties$1, true);
+// overrides.mjs
+var isSupported2 = isAnalyticsSupportedFactory.async;
 
-class UserTrackingService {
-    initialized;
-    disposables = [];
-    constructor(auth, zone, injector) {
-        registerVersion('angularfire', VERSION.full, 'user-tracking');
-        let resolveInitialized;
-        this.initialized = zone.runOutsideAngular(() => new Promise(resolve => { resolveInitialized = resolve; }));
-        // The APP_INITIALIZER that is making isSupported() sync for the sake of convenient DI
-        // may not be done when services are initialized. Guard the functionality by first ensuring
-        // that the (global) promise has resolved, then get Analytics from the injector.
-        isSupported().then(() => {
-            const analytics = injector.get(Analytics);
-            if (analytics) {
-                this.disposables = [
-                    // TODO add credential tracking back in
-                    authState(auth).subscribe(user => {
-                        setUserId(analytics, user?.uid);
-                        resolveInitialized();
-                    }),
-                ];
-            }
-            else {
-                resolveInitialized();
-            }
-        });
-    }
-    ngOnDestroy() {
-        this.disposables.forEach(it => it.unsubscribe());
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: UserTrackingService, deps: [{ token: i1.Auth }, { token: i0.NgZone }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: UserTrackingService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: UserTrackingService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.Auth }, { type: i0.NgZone }, { type: i0.Injector }] });
+// firebase.mjs
+__reExport(firebase_exports, analytics_star);
+import * as analytics_star from "firebase/analytics";
+import { ɵzoneWrap } from "@angular/fire";
+import { getAnalytics as _getAnalytics, getGoogleAnalyticsClientId as _getGoogleAnalyticsClientId, initializeAnalytics as _initializeAnalytics, logEvent as _logEvent, setAnalyticsCollectionEnabled as _setAnalyticsCollectionEnabled, setConsent as _setConsent, setCurrentScreen as _setCurrentScreen, setDefaultEventParameters as _setDefaultEventParameters, settings as _settings, setUserId as _setUserId, setUserProperties as _setUserProperties } from "firebase/analytics";
+var getAnalytics = ɵzoneWrap(_getAnalytics, true);
+var getGoogleAnalyticsClientId = ɵzoneWrap(_getGoogleAnalyticsClientId, true);
+var initializeAnalytics = ɵzoneWrap(_initializeAnalytics, true);
+var logEvent = ɵzoneWrap(_logEvent, true);
+var setAnalyticsCollectionEnabled = ɵzoneWrap(_setAnalyticsCollectionEnabled, true);
+var setConsent = ɵzoneWrap(_setConsent, true);
+var setCurrentScreen = ɵzoneWrap(_setCurrentScreen, true);
+var setDefaultEventParameters = ɵzoneWrap(_setDefaultEventParameters, true);
+var settings = ɵzoneWrap(_settings, true);
+var setUserId = ɵzoneWrap(_setUserId, true);
+var setUserProperties = ɵzoneWrap(_setUserProperties, true);
 
-const FIREBASE_EVENT_ORIGIN_KEY = 'firebase_event_origin';
-const FIREBASE_PREVIOUS_SCREEN_CLASS_KEY = 'firebase_previous_class';
-const FIREBASE_PREVIOUS_SCREEN_INSTANCE_ID_KEY = 'firebase_previous_id';
-const FIREBASE_PREVIOUS_SCREEN_NAME_KEY = 'firebase_previous_screen';
-const FIREBASE_SCREEN_CLASS_KEY = 'firebase_screen_class';
-const FIREBASE_SCREEN_INSTANCE_ID_KEY = 'firebase_screen_id';
-const FIREBASE_SCREEN_NAME_KEY = 'firebase_screen';
-const OUTLET_KEY = 'outlet';
-const PAGE_PATH_KEY = 'page_path';
-const PAGE_TITLE_KEY = 'page_title';
-const SCREEN_CLASS_KEY = 'screen_class';
-const SCREEN_NAME_KEY = 'screen_name';
-const SCREEN_VIEW_EVENT = 'screen_view';
-const EVENT_ORIGIN_AUTO = 'auto';
-const SCREEN_INSTANCE_DELIMITER = '#';
-// this is an INT64 in iOS/Android but use INT32 cause javascript
-let nextScreenInstanceID = Math.floor(Math.random() * (2 ** 32 - 1)) - 2 ** 31;
-const knownScreenInstanceIDs = {};
-const getScreenInstanceID = (params) => {
-    // unique the screen class against the outlet name
-    const screenInstanceKey = [
-        params[SCREEN_CLASS_KEY],
-        params[OUTLET_KEY]
-    ].join(SCREEN_INSTANCE_DELIMITER);
-    // eslint-disable-next-line no-prototype-builtins
-    if (knownScreenInstanceIDs.hasOwnProperty(screenInstanceKey)) {
-        return knownScreenInstanceIDs[screenInstanceKey];
-    }
-    else {
-        const ret = nextScreenInstanceID++;
-        knownScreenInstanceIDs[screenInstanceKey] = ret;
-        return ret;
-    }
+// user-tracking.service.mjs
+import { Injectable, Injector, NgZone } from "@angular/core";
+import { VERSION } from "@angular/fire";
+import { Auth, authState } from "@angular/fire/auth";
+import { registerVersion } from "firebase/app";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/fire/auth";
+var UserTrackingService = class _UserTrackingService {
+  initialized;
+  disposables = [];
+  constructor(auth, zone, injector) {
+    registerVersion("angularfire", VERSION.full, "user-tracking");
+    let resolveInitialized;
+    this.initialized = zone.runOutsideAngular(() => new Promise((resolve) => {
+      resolveInitialized = resolve;
+    }));
+    isSupported2().then(() => {
+      const analytics = injector.get(Analytics);
+      if (analytics) {
+        this.disposables = [
+          // TODO add credential tracking back in
+          authState(auth).subscribe((user) => {
+            setUserId(analytics, user?.uid);
+            resolveInitialized();
+          })
+        ];
+      } else {
+        resolveInitialized();
+      }
+    });
+  }
+  ngOnDestroy() {
+    this.disposables.forEach((it) => it.unsubscribe());
+  }
+  static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0-rc.3", ngImport: i0, type: _UserTrackingService, deps: [{ token: i1.Auth }, { token: i0.NgZone }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+  static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0-rc.3", ngImport: i0, type: _UserTrackingService });
 };
-const ɵscreenViewEvent = (router, title, componentFactoryResolver) => {
-    const activationEndEvents = router.events.pipe(filter(e => e instanceof ActivationEnd));
-    return activationEndEvents.pipe(switchMap(activationEnd => {
-        // router parseUrl is having trouble with outlets when they're empty
-        // e.g, /asdf/1(bob://sally:asdf), so put another slash in when empty
-        const urlTree = router.parseUrl(router.url.replace(/(?:\().+(?:\))/g, a => a.replace('://', ':///')));
-        const pagePath = urlTree.root.children[activationEnd.snapshot.outlet]?.toString() || '';
-        const actualSnapshot = router.routerState.root.children.map(it => it).find(it => it.outlet === activationEnd.snapshot.outlet);
-        if (!actualSnapshot) {
-            return of(null);
-        }
-        let actualDeep = actualSnapshot;
-        while (actualDeep.firstChild) {
-            actualDeep = actualDeep.firstChild;
-        }
-        const screenName = actualDeep.pathFromRoot.map(s => s.routeConfig?.path).filter(it => it).join('/') || '/';
-        const params = {
-            [SCREEN_NAME_KEY]: screenName,
-            [PAGE_PATH_KEY]: `/${pagePath}`,
-            [FIREBASE_EVENT_ORIGIN_KEY]: EVENT_ORIGIN_AUTO,
-            [FIREBASE_SCREEN_NAME_KEY]: screenName,
-            [OUTLET_KEY]: activationEnd.snapshot.outlet
-        };
-        if (title) {
-            params[PAGE_TITLE_KEY] = title.getTitle();
-        }
-        let component = actualSnapshot.component;
-        if (component) {
-            if (component === ɵEmptyOutletComponent) {
-                let deepSnapshot = activationEnd.snapshot;
-                // TODO when might there be mutple children, different outlets? explore
-                while (deepSnapshot.firstChild) {
-                    deepSnapshot = deepSnapshot.firstChild;
-                }
-                component = deepSnapshot.component;
-            }
-        }
-        else {
-            component = activationEnd.snapshot.component;
-        }
-        if (typeof component === 'string') {
-            return of({ ...params, [SCREEN_CLASS_KEY]: component });
-        }
-        else if (component) {
-            const componentFactory = componentFactoryResolver.resolveComponentFactory(component);
-            return of({ ...params, [SCREEN_CLASS_KEY]: componentFactory.selector });
-        }
-        // lazy loads cause extra activations, ignore
-        return of(null);
-    }), filter(it => !!it), map(params => ({
-        [FIREBASE_SCREEN_CLASS_KEY]: params[SCREEN_CLASS_KEY],
-        [FIREBASE_SCREEN_INSTANCE_ID_KEY]: getScreenInstanceID(params),
-        ...params
-    })), groupBy(it => it[OUTLET_KEY]), mergeMap(it => it.pipe(distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)), startWith(undefined), pairwise(), map(([prior, current]) => prior ? {
-        [FIREBASE_PREVIOUS_SCREEN_CLASS_KEY]: prior[SCREEN_CLASS_KEY],
-        [FIREBASE_PREVIOUS_SCREEN_NAME_KEY]: prior[SCREEN_NAME_KEY],
-        [FIREBASE_PREVIOUS_SCREEN_INSTANCE_ID_KEY]: prior[FIREBASE_SCREEN_INSTANCE_ID_KEY],
-        ...current
-    } : current))));
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0-rc.3", ngImport: i0, type: UserTrackingService, decorators: [{
+  type: Injectable
+}], ctorParameters: () => [{ type: i1.Auth }, { type: i0.NgZone }, { type: i0.Injector }] });
+
+// screen-tracking.service.mjs
+import { ComponentFactoryResolver, Injectable as Injectable2, Injector as Injector3, NgZone as NgZone3, Optional } from "@angular/core";
+import { VERSION as VERSION2 } from "@angular/fire";
+import { Title } from "@angular/platform-browser";
+import { ActivationEnd, Router, ɵEmptyOutletComponent } from "@angular/router";
+import { registerVersion as registerVersion2 } from "firebase/app";
+import { of } from "rxjs";
+import { distinctUntilChanged, filter, groupBy, map, mergeMap, pairwise, startWith, switchMap } from "rxjs/operators";
+import * as i02 from "@angular/core";
+import * as i12 from "@angular/router";
+import * as i2 from "@angular/platform-browser";
+var FIREBASE_EVENT_ORIGIN_KEY = "firebase_event_origin";
+var FIREBASE_PREVIOUS_SCREEN_CLASS_KEY = "firebase_previous_class";
+var FIREBASE_PREVIOUS_SCREEN_INSTANCE_ID_KEY = "firebase_previous_id";
+var FIREBASE_PREVIOUS_SCREEN_NAME_KEY = "firebase_previous_screen";
+var FIREBASE_SCREEN_CLASS_KEY = "firebase_screen_class";
+var FIREBASE_SCREEN_INSTANCE_ID_KEY = "firebase_screen_id";
+var FIREBASE_SCREEN_NAME_KEY = "firebase_screen";
+var OUTLET_KEY = "outlet";
+var PAGE_PATH_KEY = "page_path";
+var PAGE_TITLE_KEY = "page_title";
+var SCREEN_CLASS_KEY = "screen_class";
+var SCREEN_NAME_KEY = "screen_name";
+var SCREEN_VIEW_EVENT = "screen_view";
+var EVENT_ORIGIN_AUTO = "auto";
+var SCREEN_INSTANCE_DELIMITER = "#";
+var nextScreenInstanceID = Math.floor(Math.random() * (2 ** 32 - 1)) - 2 ** 31;
+var knownScreenInstanceIDs = {};
+var getScreenInstanceID = (params) => {
+  const screenInstanceKey = [
+    params[SCREEN_CLASS_KEY],
+    params[OUTLET_KEY]
+  ].join(SCREEN_INSTANCE_DELIMITER);
+  if (knownScreenInstanceIDs.hasOwnProperty(screenInstanceKey)) {
+    return knownScreenInstanceIDs[screenInstanceKey];
+  } else {
+    const ret = nextScreenInstanceID++;
+    knownScreenInstanceIDs[screenInstanceKey] = ret;
+    return ret;
+  }
 };
-class ScreenTrackingService {
-    disposable;
-    constructor(router, title, componentFactoryResolver, zone, userTrackingService, injector) {
-        registerVersion('angularfire', VERSION.full, 'screen-tracking');
-        // The APP_INITIALIZER that is making isSupported() sync for the sake of convenient DI
-        // may not be done when services are initialized. Guard the functionality by first ensuring
-        // that the (global) promise has resolved, then get Analytics from the injector.
-        isSupported().then(() => {
-            const analytics = injector.get(Analytics);
-            if (!router || !analytics) {
-                return;
-            }
-            zone.runOutsideAngular(() => {
-                this.disposable = ɵscreenViewEvent(router, title, componentFactoryResolver).pipe(switchMap(async (params) => {
-                    if (userTrackingService) {
-                        await userTrackingService.initialized;
-                    }
-                    return logEvent(analytics, SCREEN_VIEW_EVENT, params);
-                })).subscribe();
-            });
-        });
+var ɵscreenViewEvent = (router, title, componentFactoryResolver) => {
+  const activationEndEvents = router.events.pipe(filter((e) => e instanceof ActivationEnd));
+  return activationEndEvents.pipe(switchMap((activationEnd) => {
+    const urlTree = router.parseUrl(router.url.replace(/(?:\().+(?:\))/g, (a) => a.replace("://", ":///")));
+    const pagePath = urlTree.root.children[activationEnd.snapshot.outlet]?.toString() || "";
+    const actualSnapshot = router.routerState.root.children.map((it) => it).find((it) => it.outlet === activationEnd.snapshot.outlet);
+    if (!actualSnapshot) {
+      return of(null);
+    }
+    let actualDeep = actualSnapshot;
+    while (actualDeep.firstChild) {
+      actualDeep = actualDeep.firstChild;
+    }
+    const screenName = actualDeep.pathFromRoot.map((s) => s.routeConfig?.path).filter((it) => it).join("/") || "/";
+    const params = {
+      [SCREEN_NAME_KEY]: screenName,
+      [PAGE_PATH_KEY]: `/${pagePath}`,
+      [FIREBASE_EVENT_ORIGIN_KEY]: EVENT_ORIGIN_AUTO,
+      [FIREBASE_SCREEN_NAME_KEY]: screenName,
+      [OUTLET_KEY]: activationEnd.snapshot.outlet
+    };
+    if (title) {
+      params[PAGE_TITLE_KEY] = title.getTitle();
     }
-    ngOnDestroy() {
-        if (this.disposable) {
-            this.disposable.unsubscribe();
+    let component = actualSnapshot.component;
+    if (component) {
+      if (component === ɵEmptyOutletComponent) {
+        let deepSnapshot = activationEnd.snapshot;
+        while (deepSnapshot.firstChild) {
+          deepSnapshot = deepSnapshot.firstChild;
         }
+        component = deepSnapshot.component;
+      }
+    } else {
+      component = activationEnd.snapshot.component;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: ScreenTrackingService, deps: [{ token: i1$1.Router, optional: true }, { token: i2.Title, optional: true }, { token: i0.ComponentFactoryResolver }, { token: i0.NgZone }, { token: UserTrackingService, optional: true }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: ScreenTrackingService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: ScreenTrackingService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1$1.Router, decorators: [{
-                    type: Optional
-                }] }, { type: i2.Title, decorators: [{
-                    type: Optional
-                }] }, { type: i0.ComponentFactoryResolver }, { type: i0.NgZone }, { type: UserTrackingService, decorators: [{
-                    type: Optional
-                }] }, { type: i0.Injector }] });
+    if (typeof component === "string") {
+      return of({ ...params, [SCREEN_CLASS_KEY]: component });
+    } else if (component) {
+      const componentFactory = componentFactoryResolver.resolveComponentFactory(component);
+      return of({ ...params, [SCREEN_CLASS_KEY]: componentFactory.selector });
+    }
+    return of(null);
+  }), filter((it) => !!it), map((params) => ({
+    [FIREBASE_SCREEN_CLASS_KEY]: params[SCREEN_CLASS_KEY],
+    [FIREBASE_SCREEN_INSTANCE_ID_KEY]: getScreenInstanceID(params),
+    ...params
+  })), groupBy((it) => it[OUTLET_KEY]), mergeMap((it) => it.pipe(distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)), startWith(void 0), pairwise(), map(([prior, current]) => prior ? {
+    [FIREBASE_PREVIOUS_SCREEN_CLASS_KEY]: prior[SCREEN_CLASS_KEY],
+    [FIREBASE_PREVIOUS_SCREEN_NAME_KEY]: prior[SCREEN_NAME_KEY],
+    [FIREBASE_PREVIOUS_SCREEN_INSTANCE_ID_KEY]: prior[FIREBASE_SCREEN_INSTANCE_ID_KEY],
+    ...current
+  } : current))));
+};
+var ScreenTrackingService = class _ScreenTrackingService {
+  disposable;
+  constructor(router, title, componentFactoryResolver, zone, userTrackingService, injector) {
+    registerVersion2("angularfire", VERSION2.full, "screen-tracking");
+    isSupported2().then(() => {
+      const analytics = injector.get(Analytics);
+      if (!router || !analytics) {
+        return;
+      }
+      zone.runOutsideAngular(() => {
+        this.disposable = ɵscreenViewEvent(router, title, componentFactoryResolver).pipe(switchMap(async (params) => {
+          if (userTrackingService) {
+            await userTrackingService.initialized;
+          }
+          return logEvent(analytics, SCREEN_VIEW_EVENT, params);
+        })).subscribe();
+      });
+    });
+  }
+  ngOnDestroy() {
+    if (this.disposable) {
+      this.disposable.unsubscribe();
+    }
+  }
+  static ɵfac = i02.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0-rc.3", ngImport: i02, type: _ScreenTrackingService, deps: [{ token: i12.Router, optional: true }, { token: i2.Title, optional: true }, { token: i02.ComponentFactoryResolver }, { token: i02.NgZone }, { token: UserTrackingService, optional: true }, { token: i02.Injector }], target: i02.ɵɵFactoryTarget.Injectable });
+  static ɵprov = i02.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.0-rc.3", ngImport: i02, type: _ScreenTrackingService });
+};
+i02.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0-rc.3", ngImport: i02, type: ScreenTrackingService, decorators: [{
+  type: Injectable2
+}], ctorParameters: () => [{ type: i12.Router, decorators: [{
+  type: Optional
+}] }, { type: i2.Title, decorators: [{
+  type: Optional
+}] }, { type: i02.ComponentFactoryResolver }, { type: i02.NgZone }, { type: UserTrackingService, decorators: [{
+  type: Optional
+}] }, { type: i02.Injector }] });
 
-const PROVIDED_ANALYTICS_INSTANCES = new InjectionToken('angularfire2.analytics-instances');
+// analytics.module.mjs
+import { APP_INITIALIZER, InjectionToken, Injector as Injector5, NgModule, NgZone as NgZone5, Optional as Optional2, makeEnvironmentProviders } from "@angular/core";
+import { VERSION as VERSION3, ɵAngularFireSchedulers, ɵgetDefaultInstanceOf } from "@angular/fire";
+import { FirebaseApp, FirebaseApps } from "@angular/fire/app";
+import { registerVersion as registerVersion3 } from "firebase/app";
+import * as i03 from "@angular/core";
+var PROVIDED_ANALYTICS_INSTANCES = new InjectionToken("angularfire2.analytics-instances");
 function defaultAnalyticsInstanceFactory(provided, defaultApp) {
-    if (!isAnalyticsSupportedFactory.sync()) {
-        return null;
-    }
-    const defaultAnalytics = ɵgetDefaultInstanceOf(ANALYTICS_PROVIDER_NAME, provided, defaultApp);
-    return defaultAnalytics && new Analytics(defaultAnalytics);
+  if (!isAnalyticsSupportedFactory.sync()) {
+    return null;
+  }
+  const defaultAnalytics = ɵgetDefaultInstanceOf(ANALYTICS_PROVIDER_NAME, provided, defaultApp);
+  return defaultAnalytics && new Analytics(defaultAnalytics);
 }
 function analyticsInstanceFactory(fn) {
-    return (zone, injector) => {
-        if (!isAnalyticsSupportedFactory.sync()) {
-            return null;
-        }
-        const analytics = zone.runOutsideAngular(() => fn(injector));
-        return new Analytics(analytics);
-    };
+  return (zone, injector) => {
+    if (!isAnalyticsSupportedFactory.sync()) {
+      return null;
+    }
+    const analytics = zone.runOutsideAngular(() => fn(injector));
+    return new Analytics(analytics);
+  };
 }
-const ANALYTICS_INSTANCES_PROVIDER = {
-    provide: AnalyticsInstances,
-    deps: [
-        [new Optional(), PROVIDED_ANALYTICS_INSTANCES],
-    ]
+var ANALYTICS_INSTANCES_PROVIDER = {
+  provide: AnalyticsInstances,
+  deps: [
+    [new Optional2(), PROVIDED_ANALYTICS_INSTANCES]
+  ]
 };
-const DEFAULT_ANALYTICS_INSTANCE_PROVIDER = {
-    provide: Analytics,
-    useFactory: defaultAnalyticsInstanceFactory,
-    deps: [
-        [new Optional(), PROVIDED_ANALYTICS_INSTANCES],
-        FirebaseApp,
-    ]
+var DEFAULT_ANALYTICS_INSTANCE_PROVIDER = {
+  provide: Analytics,
+  useFactory: defaultAnalyticsInstanceFactory,
+  deps: [
+    [new Optional2(), PROVIDED_ANALYTICS_INSTANCES],
+    FirebaseApp
+  ]
 };
-class AnalyticsModule {
-    constructor(_screenTrackingService, _userTrackingService) {
-        registerVersion('angularfire', VERSION.full, 'analytics');
+var AnalyticsModule = class _AnalyticsModule {
+  constructor(_screenTrackingService, _userTrackingService) {
+    registerVersion3("angularfire", VERSION3.full, "analytics");
+  }
+  static ɵfac = i03.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0-rc.3", ngImport: i03, type: _AnalyticsModule, deps: [{ token: ScreenTrackingService, optional: true }, { token: UserTrackingService, optional: true }], target: i03.ɵɵFactoryTarget.NgModule });
+  static ɵmod = i03.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.0-rc.3", ngImport: i03, type: _AnalyticsModule });
+  static ɵinj = i03.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.0-rc.3", ngImport: i03, type: _AnalyticsModule, providers: [
+    DEFAULT_ANALYTICS_INSTANCE_PROVIDER,
+    ANALYTICS_INSTANCES_PROVIDER,
+    {
+      provide: APP_INITIALIZER,
+      useValue: isAnalyticsSupportedFactory.async,
+      multi: true
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: AnalyticsModule, deps: [{ token: ScreenTrackingService, optional: true }, { token: UserTrackingService, optional: true }], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.6", ngImport: i0, type: AnalyticsModule });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: AnalyticsModule, providers: [
-            DEFAULT_ANALYTICS_INSTANCE_PROVIDER,
-            ANALYTICS_INSTANCES_PROVIDER,
-            {
-                provide: APP_INITIALIZER,
-                useValue: isAnalyticsSupportedFactory.async,
-                multi: true,
-            }
-        ] });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.6", ngImport: i0, type: AnalyticsModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    providers: [
-                        DEFAULT_ANALYTICS_INSTANCE_PROVIDER,
-                        ANALYTICS_INSTANCES_PROVIDER,
-                        {
-                            provide: APP_INITIALIZER,
-                            useValue: isAnalyticsSupportedFactory.async,
-                            multi: true,
-                        }
-                    ]
-                }]
-        }], ctorParameters: () => [{ type: ScreenTrackingService, decorators: [{
-                    type: Optional
-                }] }, { type: UserTrackingService, decorators: [{
-                    type: Optional
-                }] }] });
+  ] });
+};
+i03.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0-rc.3", ngImport: i03, type: AnalyticsModule, decorators: [{
+  type: NgModule,
+  args: [{
+    providers: [
+      DEFAULT_ANALYTICS_INSTANCE_PROVIDER,
+      ANALYTICS_INSTANCES_PROVIDER,
+      {
+        provide: APP_INITIALIZER,
+        useValue: isAnalyticsSupportedFactory.async,
+        multi: true
+      }
+    ]
+  }]
+}], ctorParameters: () => [{ type: ScreenTrackingService, decorators: [{
+  type: Optional2
+}] }, { type: UserTrackingService, decorators: [{
+  type: Optional2
+}] }] });
 function provideAnalytics(fn, ...deps) {
-    registerVersion('angularfire', VERSION.full, 'analytics');
-    return makeEnvironmentProviders([
-        DEFAULT_ANALYTICS_INSTANCE_PROVIDER,
-        ANALYTICS_INSTANCES_PROVIDER,
-        {
-            provide: APP_INITIALIZER,
-            useValue: isAnalyticsSupportedFactory.async,
-            multi: true,
-        },
-        {
-            provide: PROVIDED_ANALYTICS_INSTANCES,
-            useFactory: analyticsInstanceFactory(fn),
-            multi: true,
-            deps: [
-                NgZone,
-                Injector,
-                ɵAngularFireSchedulers,
-                FirebaseApps,
-                ...deps,
-            ],
-        },
-    ]);
+  registerVersion3("angularfire", VERSION3.full, "analytics");
+  return makeEnvironmentProviders([
+    DEFAULT_ANALYTICS_INSTANCE_PROVIDER,
+    ANALYTICS_INSTANCES_PROVIDER,
+    {
+      provide: APP_INITIALIZER,
+      useValue: isAnalyticsSupportedFactory.async,
+      multi: true
+    },
+    {
+      provide: PROVIDED_ANALYTICS_INSTANCES,
+      useFactory: analyticsInstanceFactory(fn),
+      multi: true,
+      deps: [
+        NgZone5,
+        Injector5,
+        ɵAngularFireSchedulers,
+        FirebaseApps,
+        ...deps
+      ]
+    }
+  ]);
 }
 
-/**
- * Generated bundle index. Do not edit.
- */
+// public_api.mjs
+__reExport(public_api_exports, firebase_exports);
 
-export { Analytics, AnalyticsInstances, AnalyticsModule, ScreenTrackingService, UserTrackingService, analyticInstance$, getAnalytics, getGoogleAnalyticsClientId, initializeAnalytics, isSupported, logEvent, provideAnalytics, setAnalyticsCollectionEnabled, setConsent, setCurrentScreen, setDefaultEventParameters, setUserId, setUserProperties, settings, ɵscreenViewEvent };
+// angular-fire-analytics.mjs
+__reExport(angular_fire_analytics_exports, public_api_exports);
+export {
+  Analytics,
+  AnalyticsInstances,
+  AnalyticsModule,
+  ScreenTrackingService,
+  UserTrackingService,
+  analyticInstance$,
+  getAnalytics,
+  getGoogleAnalyticsClientId,
+  initializeAnalytics,
+  isSupported2 as isSupported,
+  logEvent,
+  provideAnalytics,
+  setAnalyticsCollectionEnabled,
+  setConsent,
+  setCurrentScreen,
+  setDefaultEventParameters,
+  setUserId,
+  setUserProperties,
+  settings,
+  ɵscreenViewEvent
+};
 //# sourceMappingURL=angular-fire-analytics.mjs.map