Drop isSupported injection, bump rxfire (#3588)

* Bump rxfire dep
* Drop isSupported inject in favor of PLATFORM_ID test
* Analytics is technically isPlatformBrowser rather than !isPlatformServer, prolly no diff

Author: jamesdaniels

package-lock.json

@@ -65,7 +65,7 @@
     "jsonc-parser": "^3.0.0",
     "open": "^7.0.3 || ^8.0.0",
     "ora": "^5.3.0",
-    "rxfire": "^6.0.5",
+    "rxfire": "^6.1.0",
     "rxjs": "~7.8.0",
     "semver": "^7.1.3",
     "triple-beam": "^1.3.0",

package.json

@@ -1,33 +1,33 @@
+import { isPlatformBrowser } from '@angular/common';
 import {
-  APP_INITIALIZER,
   EnvironmentProviders,
   InjectionToken,
   Injector,
   NgModule,
   NgZone,
   Optional,
+  PLATFORM_ID,
   makeEnvironmentProviders,
 } from '@angular/core';
 import { VERSION, ɵAngularFireSchedulers, ɵgetDefaultInstanceOf } from '@angular/fire';
 import { FirebaseApp, FirebaseApps } from '@angular/fire/app';
 import { Analytics as FirebaseAnalytics } from 'firebase/analytics';
 import { registerVersion } from 'firebase/app';
 import { ANALYTICS_PROVIDER_NAME, Analytics, AnalyticsInstances } from './analytics';
-import { isAnalyticsSupportedFactory } from './is-analytics-supported-factory';
 import { ScreenTrackingService } from './screen-tracking.service';
 import { UserTrackingService } from './user-tracking.service';
 
 export const PROVIDED_ANALYTICS_INSTANCES = new InjectionToken<Analytics[]>('angularfire2.analytics-instances');
 
-export function defaultAnalyticsInstanceFactory(provided: FirebaseAnalytics[]|undefined, defaultApp: FirebaseApp) {
-  if (!isAnalyticsSupportedFactory.sync()) { return null; }
+export function defaultAnalyticsInstanceFactory(provided: FirebaseAnalytics[]|undefined, defaultApp: FirebaseApp, platformId: object) {
+  if (!isPlatformBrowser(platformId)) { return null; }
   const defaultAnalytics = ɵgetDefaultInstanceOf<FirebaseAnalytics>(ANALYTICS_PROVIDER_NAME, provided, defaultApp);
   return defaultAnalytics && new Analytics(defaultAnalytics);
 }
 
 export function analyticsInstanceFactory(fn: (injector: Injector) => FirebaseAnalytics) {
-  return (zone: NgZone, injector: Injector) => {
-    if (!isAnalyticsSupportedFactory.sync()) { return null; }
+  return (zone: NgZone, injector: Injector, platformId: object) => {
+    if (!isPlatformBrowser(platformId)) { return null; }
     const analytics = zone.runOutsideAngular(() => fn(injector));
     return new Analytics(analytics);
   };
@@ -46,18 +46,14 @@ const DEFAULT_ANALYTICS_INSTANCE_PROVIDER = {
   deps: [
     [new Optional(), PROVIDED_ANALYTICS_INSTANCES ],
     FirebaseApp,
+    PLATFORM_ID,
   ]
 };
 
 @NgModule({
   providers: [
     DEFAULT_ANALYTICS_INSTANCE_PROVIDER,
-    ANALYTICS_INSTANCES_PROVIDER,
-    {
-      provide: APP_INITIALIZER,
-      useValue: isAnalyticsSupportedFactory.async,
-      multi: true,
-    }
+    ANALYTICS_INSTANCES_PROVIDER
   ]
 })
 export class AnalyticsModule {
@@ -75,18 +71,14 @@ export function provideAnalytics(fn: (injector: Injector) => FirebaseAnalytics,
   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,
+        PLATFORM_ID,
         ɵAngularFireSchedulers,
         FirebaseApps,
         ...deps,

src/analytics/analytics.module.ts

@@ -1,5 +1,5 @@
 import { TestBed } from '@angular/core/testing';
-import { Analytics, getAnalytics, isSupported, provideAnalytics } from '@angular/fire/analytics';
+import { Analytics, getAnalytics, provideAnalytics } from '@angular/fire/analytics';
 import { FirebaseApp, getApp, initializeApp, provideFirebaseApp } from '@angular/fire/app';
 import { COMMON_CONFIG_TOO } from '../test-config';
 import { rando } from '../utils';
@@ -10,14 +10,6 @@ describe('Analytics', () => {
   let providedAnalytics: Analytics;
   let appName: string;
 
-  beforeAll(done => {
-    // The APP_INITIALIZER that is making isSupported() sync for DI may not
-    // be done evaulating by the time we inject from the TestBed. We can
-    // ensure correct behavior by waiting for the (global) isSuppported() promise
-    // to resolve.
-    isSupported().then(() => done());
-  });
-
   describe('single injection', () => {
 
     beforeEach(() => {

src/analytics/analytics.spec.ts

@@ -19,7 +19,7 @@ describe('Auth', () => {
                 provideFirebaseApp(() => initializeApp(COMMON_CONFIG, appName)),
                 provideAuth(() => {
                     providedAuth = getAuth(getApp(appName));
-                    connectAuthEmulator(providedAuth, `http://localhost:${authEmulatorPort}`);
+                    connectAuthEmulator(providedAuth, `http://localhost:${authEmulatorPort}`, { disableWarnings: true });
                     return providedAuth;
                 }),
             ],

src/analytics/firebase.ts

@@ -1,4 +1,4 @@
-import { isPlatformServer } from '@angular/common';
+import { isPlatformBrowser } from '@angular/common';
 import { Inject, Injectable, NgZone, OnDestroy, PLATFORM_ID } from '@angular/core';
 import { VERSION } from '@angular/fire';
 import { AngularFireAuth } from '@angular/fire/compat/auth';
@@ -21,7 +21,7 @@ export class UserTrackingService implements OnDestroy {
     zone: NgZone,
   ) {
     firebase.registerVersion('angularfire', VERSION.full, 'compat-user-tracking');
-    if (!isPlatformServer(platformId)) {
+    if (isPlatformBrowser(platformId)) {
       let resolveInitialized;
       this.initialized = zone.runOutsideAngular(() => new Promise(resolve => resolveInitialized = resolve));
       this.disposables = [

src/analytics/is-analytics-supported-factory.ts

@@ -1,30 +1,31 @@
+import { isPlatformServer } from '@angular/common';
 import {
-  APP_INITIALIZER, EnvironmentProviders,
+  EnvironmentProviders,
   InjectionToken,
   Injector,
   NgModule,
   NgZone,
   Optional,
+  PLATFORM_ID,
   makeEnvironmentProviders,
 } from '@angular/core';
 import { VERSION, ɵAngularFireSchedulers, ɵgetDefaultInstanceOf } from '@angular/fire';
 import { FirebaseApp, FirebaseApps } from '@angular/fire/app';
 import { registerVersion } from 'firebase/app';
 import { Messaging as FirebaseMessaging } from 'firebase/messaging';
-import { isMessagingSupportedFactory } from './is-messaging-supported-factory';
 import { MESSAGING_PROVIDER_NAME, Messaging, MessagingInstances } from './messaging';
 
 const PROVIDED_MESSAGING_INSTANCES = new InjectionToken<Messaging[]>('angularfire2.messaging-instances');
 
-export function defaultMessagingInstanceFactory(provided: FirebaseMessaging[]|undefined, defaultApp: FirebaseApp) {
-  if (!isMessagingSupportedFactory.sync()) { return null; }
+export function defaultMessagingInstanceFactory(provided: FirebaseMessaging[]|undefined, defaultApp: FirebaseApp, platformId: object) {
+  if (isPlatformServer(platformId)) { return null; }
   const defaultMessaging = ɵgetDefaultInstanceOf<FirebaseMessaging>(MESSAGING_PROVIDER_NAME, provided, defaultApp);
   return defaultMessaging && new Messaging(defaultMessaging);
 }
 
 export function messagingInstanceFactory(fn: (injector: Injector) => FirebaseMessaging) {
-  return (zone: NgZone, injector: Injector) => {
-    if (!isMessagingSupportedFactory.sync()) { return null; }
+  return (zone: NgZone, injector: Injector, platformId: object) => {
+    if (isPlatformServer(platformId)) { return null; }
     const messaging = zone.runOutsideAngular(() => fn(injector));
     return new Messaging(messaging);
   };
@@ -43,18 +44,14 @@ const DEFAULT_MESSAGING_INSTANCE_PROVIDER = {
   deps: [
     [new Optional(), PROVIDED_MESSAGING_INSTANCES ],
     FirebaseApp,
+    PLATFORM_ID,
   ]
 };
 
 @NgModule({
   providers: [
     DEFAULT_MESSAGING_INSTANCE_PROVIDER,
     MESSAGING_INSTANCES_PROVIDER,
-    {
-      provide: APP_INITIALIZER,
-      useValue: isMessagingSupportedFactory.async,
-      multi: true,
-    },
   ]
 })
 export class MessagingModule {
@@ -69,18 +66,14 @@ export function provideMessaging(fn: (injector: Injector) => FirebaseMessaging,
   return makeEnvironmentProviders([
     DEFAULT_MESSAGING_INSTANCE_PROVIDER,
     MESSAGING_INSTANCES_PROVIDER,
-    {
-      provide: APP_INITIALIZER,
-      useValue: isMessagingSupportedFactory.async,
-      multi: true,
-    },
     {
       provide: PROVIDED_MESSAGING_INSTANCES,
       useFactory: messagingInstanceFactory(fn),
       multi: true,
       deps: [
         NgZone,
         Injector,
+        PLATFORM_ID,
         ɵAngularFireSchedulers,
         FirebaseApps,
         ...deps,

src/analytics/overrides.ts

@@ -9,14 +9,6 @@ describe('Messaging', () => {
   let providedMessaging: Messaging;
   let appName: string;
 
-  beforeAll(done => {
-    // The APP_INITIALIZER that is making isSupported() sync for DI may not
-    // be done evaulating by the time we inject from the TestBed. We can
-    // ensure correct behavior by waiting for the (global) isSuppported() promise
-    // to resolve.
-    isSupported().then(() => done());
-  });
-
   describe('single injection', () => {
 
     beforeEach(() => {
@@ -33,18 +25,15 @@ describe('Messaging', () => {
         messaging = TestBed.inject(Messaging);
     });
 
-    it('should be injectable', done => {
-      (async () => {
-        const supported = await isSupported();
-        if (supported) {
-          expect(providedMessaging).toBeTruthy();
-          expect(messaging).toEqual(providedMessaging);
-        } else {
-          expect(providedMessaging).toBeUndefined();
-          expect(messaging).toBeNull();
-        }
-        done();
-      })();
+    it('should be injectable', async () => {
+      const supported = await TestBed.runInInjectionContext(isSupported);
+      if (supported) {
+        expect(providedMessaging).toBeTruthy();
+        expect(messaging).toEqual(providedMessaging);
+      } else {
+        expect(providedMessaging).toBeUndefined();
+        expect(messaging).toBeNull();
+      }
     });
 
   });

src/auth/auth.spec.ts

@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "firebase": "^11.0.2",
-    "rxfire": "^6.0.5",
+    "rxfire": "^6.1.0",
     "@angular-devkit/schematics": "^19.0.0",
     "@schematics/angular": "^19.0.0",
     "tslib": "^2.3.0"

src/compat/analytics/user-tracking.service.ts

@@ -1,34 +1,35 @@
+import { isPlatformServer } from '@angular/common';
 import {
-  APP_INITIALIZER,
   EnvironmentProviders,
   InjectionToken,
   Injector,
   NgModule,
   NgZone,
   Optional,
+  PLATFORM_ID,
   makeEnvironmentProviders,
 } from '@angular/core';
 import { VERSION, ɵAngularFireSchedulers, ɵgetDefaultInstanceOf } from '@angular/fire';
 import { FirebaseApp, FirebaseApps } from '@angular/fire/app';
 import { registerVersion } from 'firebase/app';
 import { RemoteConfig as FirebaseRemoteConfig } from 'firebase/remote-config';
-import { isRemoteConfigSupportedFactory } from './is-remote-config-supported-factory';
 import { REMOTE_CONFIG_PROVIDER_NAME, RemoteConfig, RemoteConfigInstances } from './remote-config';
 
 export const PROVIDED_REMOTE_CONFIG_INSTANCES = new InjectionToken<RemoteConfig[]>('angularfire2.remote-config-instances');
 
 export function defaultRemoteConfigInstanceFactory(
   provided: FirebaseRemoteConfig[]|undefined,
   defaultApp: FirebaseApp,
+  platformId: object,
 ) {
-  if (!isRemoteConfigSupportedFactory.sync()) { return null; }
+  if (isPlatformServer(platformId)) { return null; }
   const defaultRemoteConfig = ɵgetDefaultInstanceOf<FirebaseRemoteConfig>(REMOTE_CONFIG_PROVIDER_NAME, provided, defaultApp);
   return defaultRemoteConfig && new RemoteConfig(defaultRemoteConfig);
 }
 
 export function remoteConfigInstanceFactory(fn: (injector: Injector) => FirebaseRemoteConfig) {
-  return (zone: NgZone, injector: Injector) => {
-    if (!isRemoteConfigSupportedFactory.sync()) { return null; }
+  return (zone: NgZone, injector: Injector, platformId: object) => {
+    if (isPlatformServer(platformId)) { return null; }
     const remoteConfig = zone.runOutsideAngular(() => fn(injector));
     return new RemoteConfig(remoteConfig);
   };
@@ -47,18 +48,14 @@ const DEFAULT_REMOTE_CONFIG_INSTANCE_PROVIDER = {
   deps: [
     [new Optional(), PROVIDED_REMOTE_CONFIG_INSTANCES ],
     FirebaseApp,
+    PLATFORM_ID,
   ]
 };
 
 @NgModule({
   providers: [
     DEFAULT_REMOTE_CONFIG_INSTANCE_PROVIDER,
     REMOTE_CONFIG_INSTANCES_PROVIDER,
-    {
-      provide: APP_INITIALIZER,
-      useValue: isRemoteConfigSupportedFactory.async,
-      multi: true,
-    },
   ]
 })
 export class RemoteConfigModule {
@@ -75,18 +72,14 @@ export function provideRemoteConfig(
   return makeEnvironmentProviders([
     DEFAULT_REMOTE_CONFIG_INSTANCE_PROVIDER,
     REMOTE_CONFIG_INSTANCES_PROVIDER,
-    {
-      provide: APP_INITIALIZER,
-      useValue: isRemoteConfigSupportedFactory.async,
-      multi: true,
-    },
     {
       provide: PROVIDED_REMOTE_CONFIG_INSTANCES,
       useFactory: remoteConfigInstanceFactory(fn),
       multi: true,
       deps: [
         NgZone,
         Injector,
+        PLATFORM_ID,
         ɵAngularFireSchedulers,
         FirebaseApps,
         ...deps,

src/messaging/firebase.ts

@@ -1,6 +1,6 @@
 import { TestBed } from '@angular/core/testing';
 import { FirebaseApp, getApp, initializeApp, provideFirebaseApp } from '@angular/fire/app';
-import { RemoteConfig, getRemoteConfig, isSupported, provideRemoteConfig } from '@angular/fire/remote-config';
+import { RemoteConfig, getRemoteConfig, provideRemoteConfig } from '@angular/fire/remote-config';
 import { COMMON_CONFIG } from '../test-config';
 import { rando } from '../utils';
 
@@ -10,14 +10,6 @@ describe('RemoteConfig', () => {
   let providedRemoteConfig: RemoteConfig;
   let appName: string;
 
-  beforeAll(done => {
-    // The APP_INITIALIZER that is making isSupported() sync for DI may not
-    // be done evaulating by the time we inject from the TestBed. We can
-    // ensure correct behavior by waiting for the (global) isSuppported() promise
-    // to resolve.
-    isSupported().then(() => done());
-  });
-
   describe('single injection', () => {
 
     beforeEach(() => {

src/messaging/is-messaging-supported-factory.ts

@@ -64,9 +64,7 @@ ${exportedZoneWrappedFns}
     await writeFile(filePath, fileOutput);
   };
   return Promise.all([
-    reexport('analytics', 'firebase', 'firebase/analytics', tsKeys<typeof import('firebase/analytics')>(), {
-      isSupported: { override: true },
-    }),
+    reexport('analytics', 'firebase', 'firebase/analytics', tsKeys<typeof import('firebase/analytics')>()),
     reexport('app', 'firebase', 'firebase/app', tsKeys<typeof import('firebase/app')>()),
     reexport('app-check', 'firebase', 'firebase/app-check', tsKeys<typeof import('firebase/app-check')>()),
     reexport('auth', 'rxfire', 'rxfire/auth', tsKeys<typeof import('rxfire/auth')>()),
@@ -91,8 +89,8 @@ ${exportedZoneWrappedFns}
     }),
     reexport('functions', 'firebase', 'firebase/functions', tsKeys<typeof import('firebase/functions')>()),
     reexport('messaging', 'firebase', 'firebase/messaging', tsKeys<typeof import('firebase/messaging')>(), {
-      onMessage: { blockUntilFirst: false },
-      isSupported: { override: true },
+      isSupported: { blockUntilFirst: false },
+      onMessage: { blockUntilFirst: false }
     }),
     reexport('remote-config', 'rxfire', 'rxfire/remote-config', tsKeys<typeof import('rxfire/remote-config')>(), {
       getValue: { exportName: 'getValueChanges' },
@@ -101,9 +99,7 @@ ${exportedZoneWrappedFns}
       getBoolean: { exportName: 'getBooleanChanges' },
       getAll: { exportName: 'getAllChanges' },
     }),
-    reexport('remote-config', 'firebase', 'firebase/remote-config', tsKeys<typeof import('firebase/remote-config')>(), {
-      isSupported: { override: true },
-    }),
+    reexport('remote-config', 'firebase', 'firebase/remote-config', tsKeys<typeof import('firebase/remote-config')>()),
     reexport('storage', 'rxfire', 'rxfire/storage', tsKeys<typeof import('rxfire/storage')>(), {
       getDownloadURL: null,
       getMetadata: null,

src/messaging/messaging.module.ts

@@ -5,7 +5,7 @@
     "compilerOptions": {
         "outDir": "tools",
         "skipLibCheck": true,
-        "lib": ["es2019"],
+        "lib": ["es2019", "dom"],
         "module": "commonjs",
         "target": "ES2020",
         "plugins": [