@angular/fire 7.6.0 → 16.0.0-canary.596e208

package/esm2022/compat/database/database.mjs

@@ -0,0 +1,119 @@
+import { Inject, Injectable, InjectionToken, NgZone, Optional, PLATFORM_ID } from '@angular/core';
+import { getRef } from './utils';
+import { createListReference } from './list/create-reference';
+import { createObjectReference } from './object/create-reference';
+import { ɵAngularFireSchedulers } from '@angular/fire';
+import { ɵfirebaseAppFactory, FIREBASE_APP_NAME, FIREBASE_OPTIONS, ɵcacheInstance } from '@angular/fire/compat';
+import 'firebase/compat/auth';
+import 'firebase/compat/database';
+import { AngularFireAuth, USE_EMULATOR as USE_AUTH_EMULATOR, SETTINGS as AUTH_SETTINGS, TENANT_ID, LANGUAGE_CODE, USE_DEVICE_LANGUAGE, PERSISTENCE, ɵauthFactory, } from '@angular/fire/compat/auth';
+import { AppCheckInstances } from '@angular/fire/app-check';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/fire";
+import * as i2 from "@angular/fire/compat/auth";
+import * as i3 from "@angular/fire/app-check";
+export const URL = new InjectionToken('angularfire2.realtimeDatabaseURL');
+export const USE_EMULATOR = new InjectionToken('angularfire2.database.use-emulator');
+export class AngularFireDatabase {
+    schedulers;
+    database;
+    constructor(options, name, databaseURL, 
+    // tslint:disable-next-line:ban-types
+    platformId, zone, schedulers, _useEmulator, // tuple isn't working here
+    auth, useAuthEmulator, authSettings, // can't use firebase.auth.AuthSettings here
+    tenantId, languageCode, useDeviceLanguage, persistence, _appCheckInstances) {
+        this.schedulers = schedulers;
+        const useEmulator = _useEmulator;
+        const app = ɵfirebaseAppFactory(options, zone, name);
+        if (auth) {
+            ɵauthFactory(app, zone, useAuthEmulator, tenantId, languageCode, useDeviceLanguage, authSettings, persistence);
+        }
+        this.database = ɵcacheInstance(`${app.name}.database.${databaseURL}`, 'AngularFireDatabase', app.name, () => {
+            const database = zone.runOutsideAngular(() => app.database(databaseURL || undefined));
+            if (useEmulator) {
+                database.useEmulator(...useEmulator);
+            }
+            return database;
+        }, [useEmulator]);
+    }
+    list(pathOrRef, queryFn) {
+        const ref = this.schedulers.ngZone.runOutsideAngular(() => getRef(this.database, pathOrRef));
+        let query = ref;
+        if (queryFn) {
+            query = queryFn(ref);
+        }
+        return createListReference(query, this);
+    }
+    object(pathOrRef) {
+        const ref = this.schedulers.ngZone.runOutsideAngular(() => getRef(this.database, pathOrRef));
+        return createObjectReference(ref, this);
+    }
+    createPushId() {
+        const ref = this.schedulers.ngZone.runOutsideAngular(() => this.database.ref());
+        return ref.push().key;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireDatabase, deps: [{ token: FIREBASE_OPTIONS }, { token: FIREBASE_APP_NAME, optional: true }, { token: URL, optional: true }, { token: PLATFORM_ID }, { token: i0.NgZone }, { token: i1.ɵAngularFireSchedulers }, { token: USE_EMULATOR, optional: true }, { token: i2.AngularFireAuth, optional: true }, { token: USE_AUTH_EMULATOR, optional: true }, { token: AUTH_SETTINGS, optional: true }, { token: TENANT_ID, optional: true }, { token: LANGUAGE_CODE, optional: true }, { token: USE_DEVICE_LANGUAGE, optional: true }, { token: PERSISTENCE, optional: true }, { token: i3.AppCheckInstances, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireDatabase, providedIn: 'any' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireDatabase, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'any'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [FIREBASE_OPTIONS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FIREBASE_APP_NAME]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [URL]
+                }] }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i0.NgZone }, { type: i1.ɵAngularFireSchedulers }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [USE_EMULATOR]
+                }] }, { type: i2.AngularFireAuth, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [USE_AUTH_EMULATOR]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AUTH_SETTINGS]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TENANT_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [LANGUAGE_CODE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [USE_DEVICE_LANGUAGE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [PERSISTENCE]
+                }] }, { type: i3.AppCheckInstances, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"database.js","sourceRoot":"","sources":["../../../../../src/compat/database/database.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, InjectionToken, NgZone, Optional, PLATFORM_ID } from '@angular/core';\nimport { AngularFireList, AngularFireObject, DatabaseQuery, PathReference, QueryFn } from './interfaces';\nimport { getRef } from './utils';\nimport { createListReference } from './list/create-reference';\nimport { createObjectReference } from './object/create-reference';\nimport { ɵAngularFireSchedulers } from '@angular/fire';\nimport { FirebaseOptions } from 'firebase/app';\nimport { ɵfirebaseAppFactory, FIREBASE_APP_NAME, FIREBASE_OPTIONS, ɵcacheInstance } from '@angular/fire/compat';\nimport 'firebase/compat/auth';\nimport 'firebase/compat/database';\nimport {\n  AngularFireAuth,\n  USE_EMULATOR as USE_AUTH_EMULATOR,\n  SETTINGS as AUTH_SETTINGS,\n  TENANT_ID,\n  LANGUAGE_CODE,\n  USE_DEVICE_LANGUAGE,\n  PERSISTENCE,\n  ɵauthFactory,\n} from '@angular/fire/compat/auth';\nimport firebase from 'firebase/compat/app';\nimport { AppCheckInstances } from '@angular/fire/app-check';\n\nexport const URL = new InjectionToken<string>('angularfire2.realtimeDatabaseURL');\n\ntype UseEmulatorArguments = Parameters<firebase.database.Database['useEmulator']>;\nexport const USE_EMULATOR = new InjectionToken<UseEmulatorArguments>('angularfire2.database.use-emulator');\n\n@Injectable({\n  providedIn: 'any'\n})\nexport class AngularFireDatabase {\n  public readonly database: firebase.database.Database;\n\n  constructor(\n    @Inject(FIREBASE_OPTIONS) options: FirebaseOptions,\n    @Optional() @Inject(FIREBASE_APP_NAME) name: string | null | undefined,\n    @Optional() @Inject(URL) databaseURL: string | null,\n    // tslint:disable-next-line:ban-types\n    @Inject(PLATFORM_ID) platformId: Object,\n    zone: NgZone,\n    public schedulers: ɵAngularFireSchedulers,\n    @Optional() @Inject(USE_EMULATOR) _useEmulator: any, // tuple isn't working here\n    @Optional() auth: AngularFireAuth,\n    @Optional() @Inject(USE_AUTH_EMULATOR) useAuthEmulator: any,\n    @Optional() @Inject(AUTH_SETTINGS) authSettings: any, // can't use firebase.auth.AuthSettings here\n    @Optional() @Inject(TENANT_ID) tenantId: string | null,\n    @Optional() @Inject(LANGUAGE_CODE) languageCode: string | null,\n    @Optional() @Inject(USE_DEVICE_LANGUAGE) useDeviceLanguage: boolean | null,\n    @Optional() @Inject(PERSISTENCE) persistence: string | null,\n    @Optional() _appCheckInstances: AppCheckInstances,\n  ) {\n\n    const useEmulator: UseEmulatorArguments | null = _useEmulator;\n    const app = ɵfirebaseAppFactory(options, zone, name);\n\n    if (auth) {\n      ɵauthFactory(app, zone, useAuthEmulator, tenantId, languageCode, useDeviceLanguage, authSettings, persistence);\n    }\n\n    this.database = ɵcacheInstance(`${app.name}.database.${databaseURL}`, 'AngularFireDatabase', app.name, () => {\n      const database = zone.runOutsideAngular(() => app.database(databaseURL || undefined));\n      if (useEmulator) {\n        database.useEmulator(...useEmulator);\n      }\n      return database;\n    }, [useEmulator]);\n  }\n\n  list<T>(pathOrRef: PathReference, queryFn?: QueryFn): AngularFireList<T> {\n    const ref = this.schedulers.ngZone.runOutsideAngular(() => getRef(this.database, pathOrRef));\n    let query: DatabaseQuery = ref;\n    if (queryFn) {\n      query = queryFn(ref);\n    }\n    return createListReference<T>(query, this);\n  }\n\n  object<T>(pathOrRef: PathReference): AngularFireObject<T> {\n    const ref = this.schedulers.ngZone.runOutsideAngular(() => getRef(this.database, pathOrRef));\n    return createObjectReference<T>(ref, this);\n  }\n\n  createPushId() {\n    const ref = this.schedulers.ngZone.runOutsideAngular(() => this.database.ref());\n    return ref.push().key;\n  }\n\n}\n\nexport {\n  PathReference,\n  DatabaseSnapshot,\n  ChildEvent,\n  ListenEvent,\n  QueryFn,\n  AngularFireList,\n  AngularFireObject,\n  AngularFireAction,\n  Action,\n  SnapshotAction\n} from './interfaces';\n"]}

package/{esm2015/compat/database/database.module.js → esm2022/compat/database/database.module.mjs}

@@ -7,14 +7,14 @@ export class AngularFireDatabaseModule {
     constructor() {
         firebase.registerVersion('angularfire', VERSION.full, 'rtdb-compat');
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireDatabaseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.3", ngImport: i0, type: AngularFireDatabaseModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireDatabaseModule, providers: [AngularFireDatabase] });
 }
-AngularFireDatabaseModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFireDatabaseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-AngularFireDatabaseModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFireDatabaseModule });
-AngularFireDatabaseModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFireDatabaseModule, providers: [AngularFireDatabase] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFireDatabaseModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireDatabaseModule, decorators: [{
             type: NgModule,
             args: [{
                     providers: [AngularFireDatabase]
                 }]
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YWJhc2UubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2NvbXBhdC9kYXRhYmFzZS9kYXRhYmFzZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFDakQsT0FBTyxRQUFRLE1BQU0scUJBQXFCLENBQUM7QUFDM0MsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFLeEMsTUFBTSxPQUFPLHlCQUF5QjtJQUNwQztRQUNFLFFBQVEsQ0FBQyxlQUFlLENBQUMsYUFBYSxFQUFFLE9BQU8sQ0FBQyxJQUFJLEVBQUUsYUFBYSxDQUFDLENBQUM7SUFDdkUsQ0FBQzs7c0hBSFUseUJBQXlCO3VIQUF6Qix5QkFBeUI7dUhBQXpCLHlCQUF5QixhQUZ6QixDQUFFLG1CQUFtQixDQUFFOzJGQUV2Qix5QkFBeUI7a0JBSHJDLFFBQVE7bUJBQUM7b0JBQ1IsU0FBUyxFQUFFLENBQUUsbUJBQW1CLENBQUU7aUJBQ25DIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFuZ3VsYXJGaXJlRGF0YWJhc2UgfSBmcm9tICcuL2RhdGFiYXNlJztcbmltcG9ydCBmaXJlYmFzZSBmcm9tICdmaXJlYmFzZS9jb21wYXQvYXBwJztcbmltcG9ydCB7IFZFUlNJT04gfSBmcm9tICdAYW5ndWxhci9maXJlJztcblxuQE5nTW9kdWxlKHtcbiAgcHJvdmlkZXJzOiBbIEFuZ3VsYXJGaXJlRGF0YWJhc2UgXVxufSlcbmV4cG9ydCBjbGFzcyBBbmd1bGFyRmlyZURhdGFiYXNlTW9kdWxlIHtcbiAgY29uc3RydWN0b3IoKSB7XG4gICAgZmlyZWJhc2UucmVnaXN0ZXJWZXJzaW9uKCdhbmd1bGFyZmlyZScsIFZFUlNJT04uZnVsbCwgJ3J0ZGItY29tcGF0Jyk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YWJhc2UubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL2NvbXBhdC9kYXRhYmFzZS9kYXRhYmFzZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFDakQsT0FBTyxRQUFRLE1BQU0scUJBQXFCLENBQUM7QUFDM0MsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFLeEMsTUFBTSxPQUFPLHlCQUF5QjtJQUNwQztRQUNFLFFBQVEsQ0FBQyxlQUFlLENBQUMsYUFBYSxFQUFFLE9BQU8sQ0FBQyxJQUFJLEVBQUUsYUFBYSxDQUFDLENBQUM7SUFDdkUsQ0FBQzt1R0FIVSx5QkFBeUI7d0dBQXpCLHlCQUF5Qjt3R0FBekIseUJBQXlCLGFBRnpCLENBQUUsbUJBQW1CLENBQUU7OzJGQUV2Qix5QkFBeUI7a0JBSHJDLFFBQVE7bUJBQUM7b0JBQ1IsU0FBUyxFQUFFLENBQUUsbUJBQW1CLENBQUU7aUJBQ25DIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFuZ3VsYXJGaXJlRGF0YWJhc2UgfSBmcm9tICcuL2RhdGFiYXNlJztcbmltcG9ydCBmaXJlYmFzZSBmcm9tICdmaXJlYmFzZS9jb21wYXQvYXBwJztcbmltcG9ydCB7IFZFUlNJT04gfSBmcm9tICdAYW5ndWxhci9maXJlJztcblxuQE5nTW9kdWxlKHtcbiAgcHJvdmlkZXJzOiBbIEFuZ3VsYXJGaXJlRGF0YWJhc2UgXVxufSlcbmV4cG9ydCBjbGFzcyBBbmd1bGFyRmlyZURhdGFiYXNlTW9kdWxlIHtcbiAgY29uc3RydWN0b3IoKSB7XG4gICAgZmlyZWJhc2UucmVnaXN0ZXJWZXJzaW9uKCdhbmd1bGFyZmlyZScsIFZFUlNJT04uZnVsbCwgJ3J0ZGItY29tcGF0Jyk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/compat/database/list/create-reference.mjs

@@ -0,0 +1,44 @@
+import { snapshotChanges } from './snapshot-changes';
+import { stateChanges } from './state-changes';
+import { auditTrail } from './audit-trail';
+import { createDataOperationMethod } from './data-operation';
+import { createRemoveMethod } from './remove';
+import { map } from 'rxjs/operators';
+import { keepUnstableUntilFirst } from '@angular/fire';
+export function createListReference(query, afDatabase) {
+    const outsideAngularScheduler = afDatabase.schedulers.outsideAngular;
+    const refInZone = afDatabase.schedulers.ngZone.run(() => query.ref);
+    return {
+        query,
+        update: createDataOperationMethod(refInZone, 'update'),
+        set: createDataOperationMethod(refInZone, 'set'),
+        push: (data) => refInZone.push(data),
+        remove: createRemoveMethod(refInZone),
+        snapshotChanges(events) {
+            return snapshotChanges(query, events, outsideAngularScheduler).pipe(keepUnstableUntilFirst);
+        },
+        stateChanges(events) {
+            return stateChanges(query, events, outsideAngularScheduler).pipe(keepUnstableUntilFirst);
+        },
+        auditTrail(events) {
+            return auditTrail(query, events, outsideAngularScheduler).pipe(keepUnstableUntilFirst);
+        },
+        valueChanges(events, options) {
+            const snapshotChanges$ = snapshotChanges(query, events, outsideAngularScheduler);
+            return snapshotChanges$.pipe(map(actions => actions.map(a => {
+                if (options && options.idField) {
+                    return {
+                        ...a.payload.val(),
+                        ...{
+                            [options.idField]: a.key
+                        }
+                    };
+                }
+                else {
+                    return a.payload.val();
+                }
+            })), keepUnstableUntilFirst);
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/compat/firebase.app.module.js → esm2022/compat/firebase.app.module.mjs}

@@ -38,12 +38,6 @@ const FIREBASE_APP_PROVIDER = {
     ]
 };
 export class AngularFireModule {
-    // tslint:disable-next-line:ban-types
-    constructor(platformId) {
-        firebase.registerVersion('angularfire', VERSION.full, 'core');
-        firebase.registerVersion('angularfire', VERSION.full, 'app-compat');
-        firebase.registerVersion('angular', NG_VERSION.full, platformId.toString());
-    }
     static initializeApp(options, nameOrConfig) {
         return {
             ngModule: AngularFireModule,
@@ -53,11 +47,17 @@ export class AngularFireModule {
             ]
         };
     }
+    // tslint:disable-next-line:ban-types
+    constructor(platformId) {
+        firebase.registerVersion('angularfire', VERSION.full, 'core');
+        firebase.registerVersion('angularfire', VERSION.full, 'app-compat');
+        firebase.registerVersion('angular', NG_VERSION.full, platformId.toString());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireModule, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.1.3", ngImport: i0, type: AngularFireModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireModule, providers: [FIREBASE_APP_PROVIDER] });
 }
-AngularFireModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFireModule, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.NgModule });
-AngularFireModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFireModule });
-AngularFireModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFireModule, providers: [FIREBASE_APP_PROVIDER] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.3", ngImport: i0, type: AngularFireModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.3", ngImport: i0, type: AngularFireModule, decorators: [{
             type: NgModule,
             args: [{
                     providers: [FIREBASE_APP_PROVIDER]
@@ -66,4 +66,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.1.3", ngImpor
                     type: Inject,
                     args: [PLATFORM_ID]
                 }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/compat/firestore/collection/changes.mjs

@@ -0,0 +1,108 @@
+import { fromCollectionRef } from '../observable/fromRef';
+import { distinctUntilChanged, map, pairwise, scan, startWith } from 'rxjs/operators';
+/**
+ * Return a stream of document changes on a query. These results are not in sort order but in
+ * order of occurence.
+ */
+export function docChanges(query, scheduler) {
+    return fromCollectionRef(query, scheduler)
+        .pipe(startWith(undefined), pairwise(), map((actionTuple) => {
+        const [priorAction, action] = actionTuple;
+        const docChanges = action.payload.docChanges();
+        const actions = docChanges.map(change => ({ type: change.type, payload: change }));
+        // the metadata has changed from the prior emission
+        if (priorAction && JSON.stringify(priorAction.payload.metadata) !== JSON.stringify(action.payload.metadata)) {
+            // go through all the docs in payload and figure out which ones changed
+            action.payload.docs.forEach((currentDoc, currentIndex) => {
+                const docChange = docChanges.find(d => d.doc.ref.isEqual(currentDoc.ref));
+                const priorDoc = priorAction?.payload.docs.find(d => d.ref.isEqual(currentDoc.ref));
+                if (docChange && JSON.stringify(docChange.doc.metadata) === JSON.stringify(currentDoc.metadata) ||
+                    !docChange && priorDoc && JSON.stringify(priorDoc.metadata) === JSON.stringify(currentDoc.metadata)) {
+                    // document doesn't appear to have changed, don't log another action
+                }
+                else {
+                    // since the actions are processed in order just push onto the array
+                    actions.push({
+                        type: 'modified',
+                        payload: {
+                            oldIndex: currentIndex,
+                            newIndex: currentIndex,
+                            type: 'modified',
+                            doc: currentDoc
+                        }
+                    });
+                }
+            });
+        }
+        return actions;
+    }));
+}
+/**
+ * Return a stream of document changes on a query. These results are in sort order.
+ */
+export function sortedChanges(query, events, scheduler) {
+    return docChanges(query, scheduler)
+        .pipe(scan((current, changes) => combineChanges(current, changes.map(it => it.payload), events), []), distinctUntilChanged(), // cut down on unneed change cycles
+    map(changes => changes.map(c => ({ type: c.type, payload: c }))));
+}
+/**
+ * Combines the total result set from the current set of changes from an incoming set
+ * of changes.
+ */
+export function combineChanges(current, changes, events) {
+    changes.forEach(change => {
+        // skip unwanted change types
+        if (events.indexOf(change.type) > -1) {
+            current = combineChange(current, change);
+        }
+    });
+    return current;
+}
+/**
+ * Splice arguments on top of a sliced array, to break top-level ===
+ * this is useful for change-detection
+ */
+function sliceAndSplice(original, start, deleteCount, ...args) {
+    const returnArray = original.slice();
+    returnArray.splice(start, deleteCount, ...args);
+    return returnArray;
+}
+/**
+ * Creates a new sorted array from a new change.
+ * Build our own because we allow filtering of action types ('added', 'removed', 'modified') before scanning
+ * and so we have greater control over change detection (by breaking ===)
+ */
+export function combineChange(combined, change) {
+    switch (change.type) {
+        case 'added':
+            if (combined[change.newIndex] && combined[change.newIndex].doc.ref.isEqual(change.doc.ref)) {
+                // Not sure why the duplicates are getting fired
+            }
+            else {
+                return sliceAndSplice(combined, change.newIndex, 0, change);
+            }
+            break;
+        case 'modified':
+            if (combined[change.oldIndex] == null || combined[change.oldIndex].doc.ref.isEqual(change.doc.ref)) {
+                // When an item changes position we first remove it
+                // and then add it's new position
+                if (change.oldIndex !== change.newIndex) {
+                    const copiedArray = combined.slice();
+                    copiedArray.splice(change.oldIndex, 1);
+                    copiedArray.splice(change.newIndex, 0, change);
+                    return copiedArray;
+                }
+                else {
+                    return sliceAndSplice(combined, change.newIndex, 1, change);
+                }
+            }
+            break;
+        case 'removed':
+            if (combined[change.oldIndex] && combined[change.oldIndex].doc.ref.isEqual(change.doc.ref)) {
+                return sliceAndSplice(combined, change.oldIndex, 1);
+            }
+            break;
+    }
+    return combined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"changes.js","sourceRoot":"","sources":["../../../../../../src/compat/firestore/collection/changes.ts"],"names":[],"mappings":"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","sourcesContent":["import { fromCollectionRef } from '../observable/fromRef';\nimport { Observable, SchedulerLike } from 'rxjs';\nimport { distinctUntilChanged, map, pairwise, scan, startWith } from 'rxjs/operators';\nimport { Action, QuerySnapshot, DocumentChange, DocumentChangeAction, DocumentChangeType, Query } from '../interfaces';\nimport firebase from 'firebase/compat/app';\n\n\ntype ActionTupe = [Action<QuerySnapshot<firebase.firestore.DocumentData>>, Action<QuerySnapshot<firebase.firestore.DocumentData>>]\n/**\n * Return a stream of document changes on a query. These results are not in sort order but in\n * order of occurence.\n */\nexport function docChanges<T>(query: Query, scheduler?: SchedulerLike): Observable<DocumentChangeAction<T>[]> {\n  return fromCollectionRef(query, scheduler)\n    .pipe(\n      startWith<Action<QuerySnapshot<firebase.firestore.DocumentData>>, undefined>(undefined),\n      pairwise(),\n      map((actionTuple: ActionTupe) => {\n        const [priorAction, action] = actionTuple;\n        const docChanges = action.payload.docChanges();\n        const actions = docChanges.map(change => ({ type: change.type, payload: change }));\n        // the metadata has changed from the prior emission\n        if (priorAction && JSON.stringify(priorAction.payload.metadata) !== JSON.stringify(action.payload.metadata)) {\n          // go through all the docs in payload and figure out which ones changed\n          action.payload.docs.forEach((currentDoc, currentIndex) => {\n            const docChange = docChanges.find(d => d.doc.ref.isEqual(currentDoc.ref));\n            const priorDoc = priorAction?.payload.docs.find(d => d.ref.isEqual(currentDoc.ref));\n            if (docChange && JSON.stringify(docChange.doc.metadata) === JSON.stringify(currentDoc.metadata) ||\n              !docChange && priorDoc && JSON.stringify(priorDoc.metadata) === JSON.stringify(currentDoc.metadata)) {\n              // document doesn't appear to have changed, don't log another action\n            } else {\n              // since the actions are processed in order just push onto the array\n              actions.push({\n                type: 'modified',\n                payload: {\n                  oldIndex: currentIndex,\n                  newIndex: currentIndex,\n                  type: 'modified',\n                  doc: currentDoc\n                }\n              });\n            }\n          });\n        }\n        return actions as DocumentChangeAction<T>[];\n      }),\n  );\n}\n\n/**\n * Return a stream of document changes on a query. These results are in sort order.\n */\nexport function sortedChanges<T>(\n  query: Query,\n  events: DocumentChangeType[],\n  scheduler?: SchedulerLike): Observable<DocumentChangeAction<T>[]> {\n  return docChanges<T>(query, scheduler)\n    .pipe(\n      scan((current, changes) => combineChanges<T>(current, changes.map(it => it.payload), events), []),\n      distinctUntilChanged(), // cut down on unneed change cycles\n      map(changes => changes.map(c => ({ type: c.type, payload: c } as DocumentChangeAction<T>))));\n}\n\n/**\n * Combines the total result set from the current set of changes from an incoming set\n * of changes.\n */\nexport function combineChanges<T>(current: DocumentChange<T>[], changes: DocumentChange<T>[], events: DocumentChangeType[]) {\n  changes.forEach(change => {\n    // skip unwanted change types\n    if (events.indexOf(change.type) > -1) {\n      current = combineChange(current, change);\n    }\n  });\n  return current;\n}\n\n/**\n * Splice arguments on top of a sliced array, to break top-level ===\n * this is useful for change-detection\n */\nfunction sliceAndSplice<T>(\n  original: T[],\n  start: number,\n  deleteCount: number,\n  ...args: T[]\n): T[] {\n  const returnArray = original.slice();\n  returnArray.splice(start, deleteCount, ...args);\n  return returnArray;\n}\n\n/**\n * Creates a new sorted array from a new change.\n * Build our own because we allow filtering of action types ('added', 'removed', 'modified') before scanning\n * and so we have greater control over change detection (by breaking ===)\n */\nexport function combineChange<T>(combined: DocumentChange<T>[], change: DocumentChange<T>): DocumentChange<T>[] {\n  switch (change.type) {\n    case 'added':\n      if (combined[change.newIndex] && combined[change.newIndex].doc.ref.isEqual(change.doc.ref)) {\n        // Not sure why the duplicates are getting fired\n      } else {\n        return sliceAndSplice(combined, change.newIndex, 0, change);\n      }\n      break;\n    case 'modified':\n      if (combined[change.oldIndex] == null || combined[change.oldIndex].doc.ref.isEqual(change.doc.ref)) {\n        // When an item changes position we first remove it\n        // and then add it's new position\n        if (change.oldIndex !== change.newIndex) {\n          const copiedArray = combined.slice();\n          copiedArray.splice(change.oldIndex, 1);\n          copiedArray.splice(change.newIndex, 0, change);\n          return copiedArray;\n        } else {\n          return sliceAndSplice(combined, change.newIndex, 1, change);\n        }\n      }\n      break;\n    case 'removed':\n      if (combined[change.oldIndex] && combined[change.oldIndex].doc.ref.isEqual(change.doc.ref)) {\n        return sliceAndSplice(combined, change.oldIndex, 1);\n      }\n      break;\n  }\n  return combined;\n}\n"]}

package/esm2022/compat/firestore/collection/collection.mjs

@@ -0,0 +1,123 @@
+import { from } from 'rxjs';
+import { filter, map, pairwise, scan, startWith } from 'rxjs/operators';
+import { keepUnstableUntilFirst } from '@angular/fire';
+import { docChanges, sortedChanges } from './changes';
+import { AngularFirestoreDocument } from '../document/document';
+import { fromCollectionRef } from '../observable/fromRef';
+export function validateEventsArray(events) {
+    if (!events || events.length === 0) {
+        events = ['added', 'removed', 'modified'];
+    }
+    return events;
+}
+/**
+ * AngularFirestoreCollection service
+ *
+ * This class creates a reference to a Firestore Collection. A reference and a query are provided in
+ * in the constructor. The query can be the unqueried reference if no query is desired.The class
+ * is generic which gives you type safety for data update methods and data streaming.
+ *
+ * This class uses Symbol.observable to transform into Observable using Observable.from().
+ *
+ * This class is rarely used directly and should be created from the AngularFirestore service.
+ *
+ * Example:
+ *
+ * const collectionRef = firebase.firestore.collection('stocks');
+ * const query = collectionRef.where('price', '>', '0.01');
+ * const fakeStock = new AngularFirestoreCollection<Stock>(collectionRef, query);
+ *
+ * // NOTE!: the updates are performed on the reference not the query
+ * await fakeStock.add({ name: 'FAKE', price: 0.01 });
+ *
+ * // Subscribe to changes as snapshots. This provides you data updates as well as delta updates.
+ * fakeStock.valueChanges().subscribe(value => console.log(value));
+ */
+export class AngularFirestoreCollection {
+    ref;
+    query;
+    afs;
+    /**
+     * The constructor takes in a CollectionReference and Query to provide wrapper methods
+     * for data operations and data streaming.
+     *
+     * Note: Data operation methods are done on the reference not the query. This means
+     * when you update data it is not updating data to the window of your query unless
+     * the data fits the criteria of the query. See the AssociatedRefence type for details
+     * on this implication.
+     */
+    constructor(ref, query, afs) {
+        this.ref = ref;
+        this.query = query;
+        this.afs = afs;
+    }
+    /**
+     * Listen to the latest change in the stream. This method returns changes
+     * as they occur and they are not sorted by query order. This allows you to construct
+     * your own data structure.
+     */
+    stateChanges(events) {
+        let source = docChanges(this.query, this.afs.schedulers.outsideAngular);
+        if (events && events.length > 0) {
+            source = source.pipe(map(actions => actions.filter(change => events.indexOf(change.type) > -1)));
+        }
+        return source.pipe(
+        // We want to filter out empty arrays, but always emit at first, so the developer knows
+        // that the collection has been resolve; even if it's empty
+        startWith(undefined), pairwise(), filter(([prior, current]) => current.length > 0 || !prior), map(([prior, current]) => current), keepUnstableUntilFirst);
+    }
+    /**
+     * Create a stream of changes as they occur it time. This method is similar to stateChanges()
+     * but it collects each event in an array over time.
+     */
+    auditTrail(events) {
+        return this.stateChanges(events).pipe(scan((current, action) => [...current, ...action], []));
+    }
+    /**
+     * Create a stream of synchronized changes. This method keeps the local array in sorted
+     * query order.
+     */
+    snapshotChanges(events) {
+        const validatedEvents = validateEventsArray(events);
+        const scheduledSortedChanges$ = sortedChanges(this.query, validatedEvents, this.afs.schedulers.outsideAngular);
+        return scheduledSortedChanges$.pipe(keepUnstableUntilFirst);
+    }
+    valueChanges(options = {}) {
+        return fromCollectionRef(this.query, this.afs.schedulers.outsideAngular)
+            .pipe(map(actions => actions.payload.docs.map(a => {
+            if (options.idField) {
+                return {
+                    ...a.data(),
+                    ...{ [options.idField]: a.id }
+                };
+            }
+            else {
+                return a.data();
+            }
+        })), keepUnstableUntilFirst);
+    }
+    /**
+     * Retrieve the results of the query once.
+     */
+    get(options) {
+        return from(this.query.get(options)).pipe(keepUnstableUntilFirst);
+    }
+    /**
+     * Add data to a collection reference.
+     *
+     * Note: Data operation methods are done on the reference not the query. This means
+     * when you update data it is not updating data to the window of your query unless
+     * the data fits the criteria of the query.
+     */
+    add(data) {
+        return this.ref.add(data);
+    }
+    /**
+     * Create a reference to a single document in a collection.
+     */
+    doc(path) {
+        // TODO is there a better way to solve this type issue
+        return new AngularFirestoreDocument(this.ref.doc(path), this.afs);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection.js","sourceRoot":"","sources":["../../../../../../src/compat/firestore/collection/collection.ts"],"names":[],"mappings":"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","sourcesContent":["import { from, Observable } from 'rxjs';\nimport { filter, map, pairwise, scan, startWith } from 'rxjs/operators';\nimport firebase from 'firebase/compat/app';\nimport { keepUnstableUntilFirst } from '@angular/fire';\n\nimport { CollectionReference, DocumentChangeAction, DocumentChangeType, DocumentData, DocumentReference, Query } from '../interfaces';\nimport { docChanges, sortedChanges } from './changes';\nimport { AngularFirestoreDocument } from '../document/document';\nimport { fromCollectionRef } from '../observable/fromRef';\nimport { AngularFirestore } from '../firestore';\n\ntype DocumentChangeTuple<T> = [DocumentChangeAction<T>[], DocumentChangeAction<T>[]];\n\nexport function validateEventsArray(events?: DocumentChangeType[]) {\n  if (!events || events.length === 0) {\n    events = ['added', 'removed', 'modified'];\n  }\n  return events;\n}\n\n/**\n * AngularFirestoreCollection service\n *\n * This class creates a reference to a Firestore Collection. A reference and a query are provided in\n * in the constructor. The query can be the unqueried reference if no query is desired.The class\n * is generic which gives you type safety for data update methods and data streaming.\n *\n * This class uses Symbol.observable to transform into Observable using Observable.from().\n *\n * This class is rarely used directly and should be created from the AngularFirestore service.\n *\n * Example:\n *\n * const collectionRef = firebase.firestore.collection('stocks');\n * const query = collectionRef.where('price', '>', '0.01');\n * const fakeStock = new AngularFirestoreCollection<Stock>(collectionRef, query);\n *\n * // NOTE!: the updates are performed on the reference not the query\n * await fakeStock.add({ name: 'FAKE', price: 0.01 });\n *\n * // Subscribe to changes as snapshots. This provides you data updates as well as delta updates.\n * fakeStock.valueChanges().subscribe(value => console.log(value));\n */\nexport class AngularFirestoreCollection<T = DocumentData> {\n  /**\n   * The constructor takes in a CollectionReference and Query to provide wrapper methods\n   * for data operations and data streaming.\n   *\n   * Note: Data operation methods are done on the reference not the query. This means\n   * when you update data it is not updating data to the window of your query unless\n   * the data fits the criteria of the query. See the AssociatedRefence type for details\n   * on this implication.\n   */\n  constructor(\n    public readonly ref: CollectionReference<T>,\n    private readonly query: Query<T>,\n    private readonly afs: AngularFirestore) { }\n\n  /**\n   * Listen to the latest change in the stream. This method returns changes\n   * as they occur and they are not sorted by query order. This allows you to construct\n   * your own data structure.\n   */\n  stateChanges(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]> {\n    let source = docChanges<T>(this.query, this.afs.schedulers.outsideAngular);\n    if (events && events.length > 0) {\n      source = source.pipe(\n        map(actions => actions.filter(change => events.indexOf(change.type) > -1))\n      );\n    }\n    return source.pipe(\n      // We want to filter out empty arrays, but always emit at first, so the developer knows\n      // that the collection has been resolve; even if it's empty\n      startWith<DocumentChangeAction<T>[], undefined>(undefined),\n      pairwise(),\n      filter(([prior, current]: DocumentChangeTuple<T>) => current.length > 0 || !prior),\n      map(([prior, current]) => current),\n      keepUnstableUntilFirst\n    );\n  }\n\n  /**\n   * Create a stream of changes as they occur it time. This method is similar to stateChanges()\n   * but it collects each event in an array over time.\n   */\n  auditTrail(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]> {\n    return this.stateChanges(events).pipe(scan((current, action) => [...current, ...action], []));\n  }\n\n  /**\n   * Create a stream of synchronized changes. This method keeps the local array in sorted\n   * query order.\n   */\n  snapshotChanges(events?: DocumentChangeType[]): Observable<DocumentChangeAction<T>[]> {\n    const validatedEvents = validateEventsArray(events);\n    const scheduledSortedChanges$ = sortedChanges<T>(this.query, validatedEvents, this.afs.schedulers.outsideAngular);\n    return scheduledSortedChanges$.pipe(\n      keepUnstableUntilFirst\n    );\n  }\n\n  /**\n   * Listen to all documents in the collection and its possible query as an Observable.\n   *\n   * If the `idField` option is provided, document IDs are included and mapped to the\n   * provided `idField` property name.\n   */\n  valueChanges(): Observable<T[]>;\n  // tslint:disable-next-line:unified-signatures\n  valueChanges({}): Observable<T[]>;\n  valueChanges<K extends string>(options: {idField: K}): Observable<(T & { [T in K]: string })[]>;\n  valueChanges<K extends string>(options: {idField?: K} = {}): Observable<T[]> {\n    return fromCollectionRef<T>(this.query, this.afs.schedulers.outsideAngular)\n      .pipe(\n        map(actions => actions.payload.docs.map(a => {\n          if (options.idField) {\n            return {\n              ...a.data() as {},\n              ...{ [options.idField]: a.id }\n            } as T & { [T in K]: string };\n          } else {\n            return a.data();\n          }\n        })),\n        keepUnstableUntilFirst\n      );\n  }\n\n  /**\n   * Retrieve the results of the query once.\n   */\n  get(options?: firebase.firestore.GetOptions) {\n    return from(this.query.get(options)).pipe(\n      keepUnstableUntilFirst,\n    );\n  }\n\n  /**\n   * Add data to a collection reference.\n   *\n   * Note: Data operation methods are done on the reference not the query. This means\n   * when you update data it is not updating data to the window of your query unless\n   * the data fits the criteria of the query.\n   */\n  add(data: T): Promise<DocumentReference<T>> {\n    return this.ref.add(data);\n  }\n\n  /**\n   * Create a reference to a single document in a collection.\n   */\n  doc<T2 = T>(path?: string): AngularFirestoreDocument<T2> {\n    // TODO is there a better way to solve this type issue\n    return new AngularFirestoreDocument(this.ref.doc(path) as any, this.afs);\n  }\n}\n"]}