prep for 17.1.0 release

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/fire",
-  "version": "17.0.0",
+  "version": "17.1.0",
   "description": "Angular + Firebase = ❤️",
   "private": true,
   "scripts": {
@@ -55,7 +55,7 @@
     "@angular/platform-browser-dynamic": "^17.0.0",
     "@angular/router": "^17.0.0",
     "@schematics/angular": "^17.0.0",
-    "firebase": "^10.7.0",
+    "firebase": "^10.12.0",
     "firebase-admin": "^9.11.1",
     "firebase-functions": "^3.6.0",
     "firebase-tools": "^13.0.0",

src/package.json

@@ -34,7 +34,7 @@
     "firebase-tools": { "optional": true }
   },
   "dependencies": {
-    "firebase": "^10.7.0",
+    "firebase": "^10.12.0",
     "rxfire": "^6.0.5",
     "@angular-devkit/schematics": "^17.0.0",
     "@schematics/angular": "^17.0.0",

src/schematics/interfaces.ts

@@ -12,10 +12,11 @@ export const enum FEATURES {
   Firestore,
   Storage,
   RemoteConfig,
+  VertexAI,
 }
 
 export const featureOptions = [
-  { name: 'ng deploy -- hosting', value: FEATURES.Hosting },
+  { name: 'ng deploy -- Hosting', value: FEATURES.Hosting },
   { name: 'Authentication', value: FEATURES.Authentication },
   { name: 'Google Analytics', value: FEATURES.Analytics },
   { name: 'App Check', value: FEATURES.AppCheck },
@@ -26,6 +27,7 @@ export const featureOptions = [
   { name: 'Performance Monitoring', value: FEATURES.Performance },
   { name: 'Cloud Storage', value: FEATURES.Storage },
   { name: 'Remote Config', value: FEATURES.RemoteConfig },
+  { name: 'VertexAI (preview)', value: FEATURES.VertexAI },
 ];
 
 export const enum PROJECT_TYPE { Static, CloudFunctions, CloudRun, WebFrameworks }

src/schematics/setup/prompts.ts

@@ -118,7 +118,7 @@ export const featuresPrompt = async (): Promise<FEATURES[]> => {
     name: 'features',
     choices: featureOptions,
     message: 'What features would you like to setup?',
-    default: [FEATURES.Hosting],
+    default: [],
   }) as { features: FEATURES[] };
   return features;
 };

src/schematics/utils.ts

@@ -253,6 +253,11 @@ export function featureToRules(features: FEATURES[], projectName: string) {
             external('getRemoteConfig', '@angular/fire/remote-config');
             return code`${external('provideRemoteConfig', '@angular/fire/remote-config')}(() => getRemoteConfig())`;
           });
+        case FEATURES.VertexAI:
+          return addRootProvider(projectName, ({code, external}) => {
+            external('getVertexAI', '@angular/fire/vertexai-preview');
+            return code`${external('provideVertexAI', '@angular/fire/vertexai-preview')}(() => getVertexAI())`;
+          });
         default:
           return undefined;
       }

src/vertexai-preview/ng-package.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "lib": {
+    "entryFile": "public_api.ts"
+  }
+}

src/vertexai-preview/package.json

@@ -0,0 +1,3 @@
+{
+  "$schema": "../../node_modules/ng-packagr/package.schema.json"
+}

src/vertexai-preview/public_api.ts

@@ -0,0 +1,3 @@
+export { VertexAI, VertexAIInstances, vertexAIInstance$ } from './vertexai';
+export { provideVertexAI, VertexAIModule } from './vertexai.module';
+export * from './firebase';

src/vertexai-preview/vertexai.module.ts

@@ -0,0 +1,79 @@
+import {
+  EnvironmentProviders,
+  InjectionToken,
+  Injector,
+  NgModule,
+  NgZone,
+  Optional,
+  makeEnvironmentProviders,
+} from '@angular/core';
+import { VERSION, ɵAngularFireSchedulers, ɵgetDefaultInstanceOf } from '@angular/fire';
+import { ɵAppCheckInstances } from '@angular/fire';
+import { FirebaseApp, FirebaseApps } from '@angular/fire/app';
+import { registerVersion } from 'firebase/app';
+import { VertexAI as FirebaseVertexAI } from 'firebase/vertexai-preview';
+import { VERTEX_AI_PROVIDER_NAME, VertexAI, VertexAIInstances } from './vertexai';
+
+export const PROVIDED_VERTEX_AI_INSTANCES = new InjectionToken<VertexAI[]>('angularfire2.vertexai-instances');
+
+export function defaultVertexAIInstanceFactory(provided: FirebaseVertexAI[]|undefined, defaultApp: FirebaseApp) {
+  const defaultVertexAI = ɵgetDefaultInstanceOf<FirebaseVertexAI>(VERTEX_AI_PROVIDER_NAME, provided, defaultApp);
+  return defaultVertexAI && new VertexAI(defaultVertexAI);
+}
+
+export function vertexAIInstanceFactory(fn: (injector: Injector) => FirebaseVertexAI) {
+  return (zone: NgZone, injector: Injector) => {
+    const vertexAI = zone.runOutsideAngular(() => fn(injector));
+    return new VertexAI(vertexAI);
+  };
+}
+
+const VERTEX_AI_INSTANCES_PROVIDER = {
+  provide: VertexAIInstances,
+  deps: [
+    [new Optional(), PROVIDED_VERTEX_AI_INSTANCES ],
+  ]
+};
+
+const DEFAULT_VERTEX_AI_INSTANCE_PROVIDER = {
+  provide: VertexAI,
+  useFactory: defaultVertexAIInstanceFactory,
+  deps: [
+    [new Optional(), PROVIDED_VERTEX_AI_INSTANCES ],
+    FirebaseApp,
+  ]
+};
+
+@NgModule({
+  providers: [
+    DEFAULT_VERTEX_AI_INSTANCE_PROVIDER,
+    VERTEX_AI_INSTANCES_PROVIDER,
+  ]
+})
+export class VertexAIModule {
+  constructor() {
+    registerVersion('angularfire', VERSION.full, 'vertexai');
+  }
+}
+
+export function provideVertexAI(fn: (injector: Injector) => FirebaseVertexAI, ...deps: any[]): EnvironmentProviders {
+  registerVersion('angularfire', VERSION.full, 'vertexai');
+
+  return makeEnvironmentProviders([
+    DEFAULT_VERTEX_AI_INSTANCE_PROVIDER,
+    VERTEX_AI_INSTANCES_PROVIDER,
+    {
+      provide: PROVIDED_VERTEX_AI_INSTANCES,
+      useFactory: vertexAIInstanceFactory(fn),
+      multi: true,
+      deps: [
+        NgZone,
+        Injector,
+        ɵAngularFireSchedulers,
+        FirebaseApps,
+        [new Optional(), ɵAppCheckInstances ],
+        ...deps,
+      ]
+    }
+  ]);
+}

src/vertexai-preview/vertexai.spec.ts

@@ -0,0 +1,38 @@
+import { TestBed } from '@angular/core/testing';
+import { FirebaseApp, getApp, initializeApp, provideFirebaseApp } from '@angular/fire/app';
+import { VertexAI, getVertexAI, provideVertexAI } from '@angular/fire/vertexai-preview';
+import { COMMON_CONFIG } from '../test-config';
+import { rando } from '../utils';
+
+describe('VertexAI', () => {
+  let app: FirebaseApp;
+  let vertexAI: VertexAI;
+  let providedVertexAI: VertexAI;
+  let appName: string;
+
+  describe('single injection', () => {
+
+    beforeEach(() => {
+        appName = rando();
+        TestBed.configureTestingModule({
+            providers: [
+                provideFirebaseApp(() => initializeApp(COMMON_CONFIG, appName)),
+                provideVertexAI(() => {
+                    providedVertexAI = getVertexAI(getApp(appName));
+                    return providedVertexAI;
+                }),
+            ],
+        });
+        app = TestBed.inject(FirebaseApp);
+        vertexAI = TestBed.inject(VertexAI);
+    });
+
+    it('should be injectable', () => {
+        expect(providedVertexAI).toBeTruthy();
+        expect(vertexAI).toEqual(providedVertexAI);
+        expect(vertexAI.app).toEqual(app);
+    });
+
+  });
+
+});

src/vertexai-preview/vertexai.ts

@@ -0,0 +1,30 @@
+import { ɵgetAllInstancesOf } from '@angular/fire';
+import { VertexAI as FirebaseVertexAI } from 'firebase/vertexai-preview';
+import { from, timer } from 'rxjs';
+import { concatMap, distinct } from 'rxjs/operators';
+
+// see notes in core/firebase.app.module.ts for why we're building the class like this
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface VertexAI extends FirebaseVertexAI {}
+
+export class VertexAI {
+  constructor(vertexai: FirebaseVertexAI) {
+    return vertexai;
+  }
+}
+
+export const VERTEX_AI_PROVIDER_NAME = 'vertexai';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface VertexAIInstances extends Array<FirebaseVertexAI> {}
+
+export class VertexAIInstances {
+  constructor() {
+    return ɵgetAllInstancesOf<FirebaseVertexAI>(VERTEX_AI_PROVIDER_NAME);
+  }
+}
+
+export const vertexAIInstance$ = timer(0, 300).pipe(
+  concatMap(() => from(ɵgetAllInstancesOf<FirebaseVertexAI>(VERTEX_AI_PROVIDER_NAME))),
+  distinct(),
+);

tools/build.ts

@@ -119,6 +119,7 @@ ${exportedZoneWrappedFns}
       collection: { exportName: 'collectionSnapshots' },
     }),
     reexport('firestore/lite', 'firebase', 'firebase/firestore/lite', tsKeys<typeof import('firebase/firestore/lite')>()),
+    reexport('vertexai-preview', 'firebase', 'firebase/vertexai-preview', tsKeys<typeof import('firebase/vertexai-preview')>()),
   ]);
 }