@angular/fire 18.0.0 → 18.0.1-canary.3639e41

package/fesm2022/angular-fire-compat-database.mjs

@@ -1,446 +1,449 @@
-// observable/fromRef.mjs
-import { Observable, asyncScheduler } from "rxjs";
-import { map, share } from "rxjs/operators";
-function fromRef(ref, event, listenType = "on", scheduler = asyncScheduler) {
-  return new Observable((subscriber) => {
-    let fn = null;
-    fn = ref[listenType](event, (snapshot, prevKey) => {
-      scheduler.schedule(() => {
-        subscriber.next({ snapshot, prevKey });
-      });
-      if (listenType === "once") {
-        scheduler.schedule(() => subscriber.complete());
-      }
-    }, (err) => {
-      scheduler.schedule(() => subscriber.error(err));
-    });
-    if (listenType === "on") {
-      return {
-        unsubscribe() {
-          if (fn != null) {
-            ref.off(event, fn);
-          }
+import * as i0 from '@angular/core';
+import { InjectionToken, PLATFORM_ID, Injectable, Inject, Optional, NgModule } from '@angular/core';
+import * as i1 from '@angular/fire';
+import { keepUnstableUntilFirst, VERSION } from '@angular/fire';
+import * as i3 from '@angular/fire/app-check';
+import { ɵfirebaseAppFactory as _firebaseAppFactory, ɵcacheInstance as _cacheInstance, FIREBASE_OPTIONS, FIREBASE_APP_NAME } from '@angular/fire/compat';
+import * as i2 from '@angular/fire/compat/auth';
+import { ɵauthFactory as _authFactory, USE_EMULATOR as USE_EMULATOR$1, SETTINGS, TENANT_ID, LANGUAGE_CODE, USE_DEVICE_LANGUAGE, PERSISTENCE } from '@angular/fire/compat/auth';
+import { map, share, scan, withLatestFrom, skipWhile, switchMap, distinctUntilChanged } from 'rxjs/operators';
+import { Observable, asyncScheduler, merge, of } from 'rxjs';
+import 'firebase/compat/auth';
+import 'firebase/compat/database';
+import firebase from 'firebase/compat/app';
+
+/**
+ * Create an observable from a Database Reference or Database Query.
+ * @param ref Database Reference
+ * @param event Listen event type ('value', 'added', 'changed', 'removed', 'moved')
+ * @param listenType 'on' or 'once'
+ * @param scheduler - Rxjs scheduler
+ */
+function fromRef(ref, event, listenType = 'on', scheduler = asyncScheduler) {
+    return new Observable(subscriber => {
+        let fn = null;
+        fn = ref[listenType](event, (snapshot, prevKey) => {
+            scheduler.schedule(() => {
+                subscriber.next({ snapshot, prevKey });
+            });
+            if (listenType === 'once') {
+                scheduler.schedule(() => subscriber.complete());
+            }
+        }, err => {
+            scheduler.schedule(() => subscriber.error(err));
+        });
+        if (listenType === 'on') {
+            return {
+                unsubscribe() {
+                    if (fn != null) {
+                        ref.off(event, fn);
+                    }
+                }
+            };
         }
-      };
-    } else {
-      return {
-        // eslint-disable-next-line @typescript-eslint/no-empty-function
-        unsubscribe() {
+        else {
+            return {
+                // eslint-disable-next-line @typescript-eslint/no-empty-function
+                unsubscribe() {
+                }
+            };
         }
-      };
-    }
-  }).pipe(map((payload) => {
-    const { snapshot, prevKey } = payload;
-    let key = null;
-    if (snapshot.exists()) {
-      key = snapshot.key;
-    }
-    return { type: event, payload: snapshot, prevKey, key };
-  }), share());
+    }).pipe(map(payload => {
+        const { snapshot, prevKey } = payload;
+        let key = null;
+        if (snapshot.exists()) {
+            key = snapshot.key;
+        }
+        return { type: event, payload: snapshot, prevKey, key };
+    }), share());
 }
 
-// utils.mjs
 function isString(value) {
-  return typeof value === "string";
+    return typeof value === 'string';
 }
 function isFirebaseDataSnapshot(value) {
-  return typeof value.exportVal === "function";
+    return typeof value.exportVal === 'function';
 }
 function isNil(obj) {
-  return obj === void 0 || obj === null;
+    return obj === undefined || obj === null;
 }
 function isFirebaseRef(value) {
-  return typeof value.set === "function";
+    return typeof value.set === 'function';
 }
+/**
+ * Returns a database reference given a Firebase App and an
+ * absolute or relative path.
+ * @param database - Firebase Database
+ * @param pathRef - Database path, relative or absolute
+ */
 function getRef(database, pathRef) {
-  return isFirebaseRef(pathRef) ? pathRef : database.ref(pathRef);
+    // if a db ref was passed in, just return it
+    return isFirebaseRef(pathRef) ? pathRef
+        : database.ref(pathRef);
 }
 function checkOperationCases(item, cases) {
-  if (isString(item)) {
-    return cases.stringCase();
-  } else if (isFirebaseRef(item)) {
-    return cases.firebaseCase();
-  } else if (isFirebaseDataSnapshot(item)) {
-    return cases.snapshotCase();
-  }
-  throw new Error(`Expects a string, snapshot, or reference. Got: ${typeof item}`);
+    if (isString(item)) {
+        return cases.stringCase();
+    }
+    else if (isFirebaseRef(item)) {
+        return cases.firebaseCase();
+    }
+    else if (isFirebaseDataSnapshot(item)) {
+        return cases.snapshotCase();
+    }
+    throw new Error(`Expects a string, snapshot, or reference. Got: ${typeof item}`);
 }
 
-// list/utils.mjs
 function validateEventsArray(events) {
-  if (isNil(events) || events.length === 0) {
-    events = ["child_added", "child_removed", "child_changed", "child_moved"];
-  }
-  return events;
+    if (isNil(events) || events.length === 0) {
+        events = ['child_added', 'child_removed', 'child_changed', 'child_moved'];
+    }
+    return events;
 }
 
-// list/state-changes.mjs
-import { merge } from "rxjs";
 function stateChanges(query, events, scheduler) {
-  events = validateEventsArray(events);
-  const childEvent$ = events.map((event) => fromRef(query, event, "on", scheduler));
-  return merge(...childEvent$);
+    events = validateEventsArray(events);
+    const childEvent$ = events.map(event => fromRef(query, event, 'on', scheduler));
+    return merge(...childEvent$);
 }
 
-// list/audit-trail.mjs
-import { map as map2, scan, skipWhile, withLatestFrom } from "rxjs/operators";
 function auditTrail(query, events, scheduler) {
-  const auditTrail$ = stateChanges(query, events).pipe(scan((current, action) => [...current, action], []));
-  return waitForLoaded(query, auditTrail$, scheduler);
+    const auditTrail$ = stateChanges(query, events)
+        .pipe(scan((current, action) => [...current, action], []));
+    return waitForLoaded(query, auditTrail$, scheduler);
 }
 function loadedData(query, scheduler) {
-  return fromRef(query, "value", "on", scheduler).pipe(map2((data) => {
-    let lastKeyToLoad;
-    data.payload.forEach((child) => {
-      lastKeyToLoad = child.key;
-      return false;
-    });
-    return { data, lastKeyToLoad };
-  }));
+    // Create an observable of loaded values to retrieve the
+    // known dataset. This will allow us to know what key to
+    // emit the "whole" array at when listening for child events.
+    return fromRef(query, 'value', 'on', scheduler)
+        .pipe(map(data => {
+        // Store the last key in the data set
+        let lastKeyToLoad;
+        // Loop through loaded dataset to find the last key
+        data.payload.forEach(child => {
+            lastKeyToLoad = child.key;
+            return false;
+        });
+        // return data set and the current last key loaded
+        return { data, lastKeyToLoad };
+    }));
 }
 function waitForLoaded(query, action$, scheduler) {
-  const loaded$ = loadedData(query, scheduler);
-  return loaded$.pipe(
-    withLatestFrom(action$),
+    const loaded$ = loadedData(query, scheduler);
+    return loaded$
+        .pipe(withLatestFrom(action$), 
     // Get the latest values from the "loaded" and "child" datasets
     // We can use both datasets to form an array of the latest values.
-    map2(([loaded, actions]) => {
-      const lastKeyToLoad = loaded.lastKeyToLoad;
-      const loadedKeys = actions.map((snap) => snap.key);
-      return { actions, lastKeyToLoad, loadedKeys };
-    }),
+    map(([loaded, actions]) => {
+        // Store the last key in the data set
+        const lastKeyToLoad = loaded.lastKeyToLoad;
+        // Store all child keys loaded at this point
+        const loadedKeys = actions.map(snap => snap.key);
+        return { actions, lastKeyToLoad, loadedKeys };
+    }), 
     // This is the magical part, only emit when the last load key
     // in the dataset has been loaded by a child event. At this point
     // we can assume the dataset is "whole".
-    skipWhile((meta) => meta.loadedKeys.indexOf(meta.lastKeyToLoad) === -1),
+    skipWhile(meta => meta.loadedKeys.indexOf(meta.lastKeyToLoad) === -1), 
     // Pluck off the meta data because the user only cares
     // to iterate through the snapshots
-    map2((meta) => meta.actions)
-  );
+    map(meta => meta.actions));
 }
 
-// list/data-operation.mjs
 function createDataOperationMethod(ref, operation) {
-  return function dataOperation(item, value) {
-    return checkOperationCases(item, {
-      stringCase: () => ref.child(item)[operation](value),
-      firebaseCase: () => item[operation](value),
-      snapshotCase: () => item.ref[operation](value)
-    });
-  };
+    return function dataOperation(item, value) {
+        return checkOperationCases(item, {
+            stringCase: () => ref.child(item)[operation](value),
+            firebaseCase: () => item[operation](value),
+            snapshotCase: () => item.ref[operation](value)
+        });
+    };
 }
 
-// list/remove.mjs
+// TODO(davideast): Find out why TS thinks this returns firebase.Primise
+// instead of Promise.
 function createRemoveMethod(ref) {
-  return function remove(item) {
-    if (!item) {
-      return ref.remove();
-    }
-    return checkOperationCases(item, {
-      stringCase: () => ref.child(item).remove(),
-      firebaseCase: () => item.remove(),
-      snapshotCase: () => item.ref.remove()
-    });
-  };
+    return function remove(item) {
+        if (!item) {
+            return ref.remove();
+        }
+        return checkOperationCases(item, {
+            stringCase: () => ref.child(item).remove(),
+            firebaseCase: () => item.remove(),
+            snapshotCase: () => item.ref.remove()
+        });
+    };
 }
 
-// list/changes.mjs
-import { merge as merge2, of } from "rxjs";
-import { distinctUntilChanged, scan as scan2, switchMap } from "rxjs/operators";
 function listChanges(ref, events, scheduler) {
-  return fromRef(ref, "value", "once", scheduler).pipe(switchMap((snapshotAction) => {
-    const childEvent$ = [of(snapshotAction)];
-    events.forEach((event) => childEvent$.push(fromRef(ref, event, "on", scheduler)));
-    return merge2(...childEvent$).pipe(scan2(buildView, []));
-  }), distinctUntilChanged());
+    return fromRef(ref, 'value', 'once', scheduler).pipe(switchMap(snapshotAction => {
+        const childEvent$ = [of(snapshotAction)];
+        events.forEach(event => childEvent$.push(fromRef(ref, event, 'on', scheduler)));
+        return merge(...childEvent$).pipe(scan(buildView, []));
+    }), distinctUntilChanged());
 }
 function positionFor(changes, key) {
-  const len = changes.length;
-  for (let i = 0; i < len; i++) {
-    if (changes[i].payload.key === key) {
-      return i;
+    const len = changes.length;
+    for (let i = 0; i < len; i++) {
+        if (changes[i].payload.key === key) {
+            return i;
+        }
     }
-  }
-  return -1;
+    return -1;
 }
 function positionAfter(changes, prevKey) {
-  if (isNil(prevKey)) {
-    return 0;
-  } else {
-    const i = positionFor(changes, prevKey);
-    if (i === -1) {
-      return changes.length;
-    } else {
-      return i + 1;
+    if (isNil(prevKey)) {
+        return 0;
+    }
+    else {
+        const i = positionFor(changes, prevKey);
+        if (i === -1) {
+            return changes.length;
+        }
+        else {
+            return i + 1;
+        }
     }
-  }
 }
 function buildView(current, action) {
-  const { payload, prevKey, key } = action;
-  const currentKeyPosition = positionFor(current, key);
-  const afterPreviousKeyPosition = positionAfter(current, prevKey);
-  switch (action.type) {
-    case "value":
-      if (action.payload?.exists()) {
-        let prevKey2 = null;
-        action.payload.forEach((payload2) => {
-          const action2 = { payload: payload2, type: "value", prevKey: prevKey2, key: payload2.key };
-          prevKey2 = payload2.key;
-          current = [...current, action2];
-          return false;
-        });
-      }
-      return current;
-    case "child_added":
-      if (currentKeyPosition > -1) {
-        const previous = current[currentKeyPosition - 1];
-        if ((previous?.key || null) !== prevKey) {
-          current = current.filter((x) => x.payload.key !== payload.key);
-          current.splice(afterPreviousKeyPosition, 0, action);
-        }
-      } else if (prevKey == null) {
-        return [action, ...current];
-      } else {
-        current = current.slice();
-        current.splice(afterPreviousKeyPosition, 0, action);
-      }
-      return current;
-    case "child_removed":
-      return current.filter((x) => x.payload.key !== payload.key);
-    case "child_changed":
-      return current.map((x) => x.payload.key === key ? action : x);
-    case "child_moved":
-      if (currentKeyPosition > -1) {
-        const data = current.splice(currentKeyPosition, 1)[0];
-        current = current.slice();
-        current.splice(afterPreviousKeyPosition, 0, data);
-        return current;
-      }
-      return current;
-    default:
-      return current;
-  }
+    const { payload, prevKey, key } = action;
+    const currentKeyPosition = positionFor(current, key);
+    const afterPreviousKeyPosition = positionAfter(current, prevKey);
+    switch (action.type) {
+        case 'value':
+            if (action.payload?.exists()) {
+                let prevKey = null;
+                action.payload.forEach(payload => {
+                    const action = { payload, type: 'value', prevKey, key: payload.key };
+                    prevKey = payload.key;
+                    current = [...current, action];
+                    return false;
+                });
+            }
+            return current;
+        case 'child_added':
+            if (currentKeyPosition > -1) {
+                // check that the previouskey is what we expect, else reorder
+                const previous = current[currentKeyPosition - 1];
+                if ((previous?.key || null) !== prevKey) {
+                    current = current.filter(x => x.payload.key !== payload.key);
+                    current.splice(afterPreviousKeyPosition, 0, action);
+                }
+            }
+            else if (prevKey == null) {
+                return [action, ...current];
+            }
+            else {
+                current = current.slice();
+                current.splice(afterPreviousKeyPosition, 0, action);
+            }
+            return current;
+        case 'child_removed':
+            return current.filter(x => x.payload.key !== payload.key);
+        case 'child_changed':
+            return current.map(x => x.payload.key === key ? action : x);
+        case 'child_moved':
+            if (currentKeyPosition > -1) {
+                const data = current.splice(currentKeyPosition, 1)[0];
+                current = current.slice();
+                current.splice(afterPreviousKeyPosition, 0, data);
+                return current;
+            }
+            return current;
+        // default will also remove null results
+        default:
+            return current;
+    }
 }
 
-// list/snapshot-changes.mjs
 function snapshotChanges(query, events, scheduler) {
-  events = validateEventsArray(events);
-  return listChanges(query, events, scheduler);
+    events = validateEventsArray(events);
+    return listChanges(query, events, scheduler);
 }
 
-// list/create-reference.mjs
-import { keepUnstableUntilFirst } from "@angular/fire";
-import { map as map3 } from "rxjs/operators";
 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(map3((actions) => actions.map((a) => {
-        if (options && options.idField) {
-          return {
-            ...a.payload.val(),
-            ...{
-              [options.idField]: a.key
-            }
-          };
-        } else {
-          return a.payload.val();
+    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);
         }
-      })), keepUnstableUntilFirst);
-    }
-  };
+    };
 }
 
-// object/snapshot-changes.mjs
 function createObjectSnapshotChanges(query, scheduler) {
-  return function snapshotChanges2() {
-    return fromRef(query, "value", "on", scheduler);
-  };
+    return function snapshotChanges() {
+        return fromRef(query, 'value', 'on', scheduler);
+    };
 }
 
-// object/create-reference.mjs
-import { keepUnstableUntilFirst as keepUnstableUntilFirst2 } from "@angular/fire";
-import { map as map4 } from "rxjs/operators";
 function createObjectReference(query, afDatabase) {
-  return {
-    query,
-    snapshotChanges() {
-      return createObjectSnapshotChanges(query, afDatabase.schedulers.outsideAngular)().pipe(keepUnstableUntilFirst2);
-    },
-    update(data) {
-      return query.ref.update(data);
-    },
-    set(data) {
-      return query.ref.set(data);
-    },
-    remove() {
-      return query.ref.remove();
-    },
-    valueChanges() {
-      const snapshotChanges$ = createObjectSnapshotChanges(query, afDatabase.schedulers.outsideAngular)();
-      return snapshotChanges$.pipe(keepUnstableUntilFirst2, map4((action) => action.payload.exists() ? action.payload.val() : null));
-    }
-  };
+    return {
+        query,
+        snapshotChanges() {
+            return createObjectSnapshotChanges(query, afDatabase.schedulers.outsideAngular)().pipe(keepUnstableUntilFirst);
+        },
+        update(data) { return query.ref.update(data); },
+        set(data) { return query.ref.set(data); },
+        remove() { return query.ref.remove(); },
+        valueChanges() {
+            const snapshotChanges$ = createObjectSnapshotChanges(query, afDatabase.schedulers.outsideAngular)();
+            return snapshotChanges$.pipe(keepUnstableUntilFirst, map(action => action.payload.exists() ? action.payload.val() : null));
+        },
+    };
 }
 
-// database.mjs
-import { Inject, Injectable, InjectionToken, NgZone, Optional, PLATFORM_ID } from "@angular/core";
-import { ɵAngularFireSchedulers } from "@angular/fire";
-import { AppCheckInstances } from "@angular/fire/app-check";
-import { FIREBASE_APP_NAME, FIREBASE_OPTIONS, ɵcacheInstance, ɵfirebaseAppFactory } from "@angular/fire/compat";
-import { SETTINGS as AUTH_SETTINGS, AngularFireAuth, LANGUAGE_CODE, PERSISTENCE, TENANT_ID, USE_EMULATOR as USE_AUTH_EMULATOR, USE_DEVICE_LANGUAGE, ɵauthFactory } from "@angular/fire/compat/auth";
-import "firebase/compat/auth";
-import "firebase/compat/database";
-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";
-var URL = new InjectionToken("angularfire2.realtimeDatabaseURL");
-var USE_EMULATOR = new InjectionToken("angularfire2.database.use-emulator");
-var AngularFireDatabase = class _AngularFireDatabase {
-  schedulers;
-  database;
-  constructor(options, name, databaseURL, platformId, zone, schedulers, _useEmulator, auth, useAuthEmulator, authSettings, 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);
+const URL = new InjectionToken('angularfire2.realtimeDatabaseURL');
+const USE_EMULATOR = new InjectionToken('angularfire2.database.use-emulator');
+class AngularFireDatabase {
+    schedulers;
+    database;
+    constructor(options, name, databaseURL, 
+    // eslint-disable-next-line @typescript-eslint/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);
     }
-    this.database = ɵcacheInstance(`${app.name}.database.${databaseURL}`, "AngularFireDatabase", app.name, () => {
-      const database = zone.runOutsideAngular(() => app.database(databaseURL || void 0));
-      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);
+    createPushId() {
+        const ref = this.schedulers.ngZone.runOutsideAngular(() => this.database.ref());
+        return ref.push().key;
     }
-    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: "18.0.0-rc.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: "18.0.0-rc.3", ngImport: i0, type: _AngularFireDatabase, providedIn: "any" });
-};
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0-rc.3", ngImport: i0, type: AngularFireDatabase, decorators: [{
-  type: Injectable,
-  args: [{
-    providedIn: "any"
-  }]
-}], ctorParameters: () => [{ type: void 0, decorators: [{
-  type: Inject,
-  args: [FIREBASE_OPTIONS]
-}] }, { type: void 0, decorators: [{
-  type: Optional
-}, {
-  type: Inject,
-  args: [FIREBASE_APP_NAME]
-}] }, { type: void 0, decorators: [{
-  type: Optional
-}, {
-  type: Inject,
-  args: [URL]
-}] }, { type: Object, decorators: [{
-  type: Inject,
-  args: [PLATFORM_ID]
-}] }, { type: i0.NgZone }, { type: i1.ɵAngularFireSchedulers }, { type: void 0, decorators: [{
-  type: Optional
-}, {
-  type: Inject,
-  args: [USE_EMULATOR]
-}] }, { type: i2.AngularFireAuth, decorators: [{
-  type: Optional
-}] }, { type: void 0, decorators: [{
-  type: Optional
-}, {
-  type: Inject,
-  args: [USE_AUTH_EMULATOR]
-}] }, { type: void 0, decorators: [{
-  type: Optional
-}, {
-  type: Inject,
-  args: [AUTH_SETTINGS]
-}] }, { type: void 0, decorators: [{
-  type: Optional
-}, {
-  type: Inject,
-  args: [TENANT_ID]
-}] }, { type: void 0, decorators: [{
-  type: Optional
-}, {
-  type: Inject,
-  args: [LANGUAGE_CODE]
-}] }, { type: void 0, decorators: [{
-  type: Optional
-}, {
-  type: Inject,
-  args: [USE_DEVICE_LANGUAGE]
-}] }, { type: void 0, decorators: [{
-  type: Optional
-}, {
-  type: Inject,
-  args: [PERSISTENCE]
-}] }, { type: i3.AppCheckInstances, decorators: [{
-  type: Optional
-}] }] });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", 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_EMULATOR$1, optional: true }, { token: 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: "18.0.0", ngImport: i0, type: AngularFireDatabase, providedIn: 'any' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: AngularFireDatabase, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'any'
+                }]
+        }], ctorParameters: () => [{ 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_EMULATOR$1]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [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
+                }] }] });
+
+class AngularFireDatabaseModule {
+    constructor() {
+        firebase.registerVersion('angularfire', VERSION.full, 'rtdb-compat');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: AngularFireDatabaseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.0", ngImport: i0, type: AngularFireDatabaseModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: AngularFireDatabaseModule, providers: [AngularFireDatabase] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0", ngImport: i0, type: AngularFireDatabaseModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [AngularFireDatabase]
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
 
-// database.module.mjs
-import { NgModule } from "@angular/core";
-import { VERSION } from "@angular/fire";
-import firebase from "firebase/compat/app";
-import * as i02 from "@angular/core";
-var AngularFireDatabaseModule = class _AngularFireDatabaseModule {
-  constructor() {
-    firebase.registerVersion("angularfire", VERSION.full, "rtdb-compat");
-  }
-  static ɵfac = i02.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.0-rc.3", ngImport: i02, type: _AngularFireDatabaseModule, deps: [], target: i02.ɵɵFactoryTarget.NgModule });
-  static ɵmod = i02.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.0-rc.3", ngImport: i02, type: _AngularFireDatabaseModule });
-  static ɵinj = i02.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.0-rc.3", ngImport: i02, type: _AngularFireDatabaseModule, providers: [AngularFireDatabase] });
-};
-i02.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.0-rc.3", ngImport: i02, type: AngularFireDatabaseModule, decorators: [{
-  type: NgModule,
-  args: [{
-    providers: [AngularFireDatabase]
-  }]
-}], ctorParameters: () => [] });
-export {
-  AngularFireDatabase,
-  AngularFireDatabaseModule,
-  URL,
-  USE_EMULATOR,
-  auditTrail,
-  createListReference,
-  fromRef,
-  listChanges,
-  snapshotChanges,
-  stateChanges
-};
+export { AngularFireDatabase, AngularFireDatabaseModule, URL, USE_EMULATOR, auditTrail, createListReference, fromRef, listChanges, snapshotChanges, stateChanges };
 //# sourceMappingURL=angular-fire-compat-database.mjs.map