@dereekb/dbx-firebase 8.5.2 → 8.6.1

package/esm2020/lib/index.mjs

@@ -3,5 +3,6 @@ export * from './firebase';
 export * from './firestore';
 export * from './function';
 export * from './model';
+export * from './router';
 export * from './module';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLFVBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXV0aCc7XG5leHBvcnQgKiBmcm9tICcuL2ZpcmViYXNlJztcbmV4cG9ydCAqIGZyb20gJy4vZmlyZXN0b3JlJztcbmV4cG9ydCAqIGZyb20gJy4vZnVuY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL21vZHVsZSc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLFVBQVUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXV0aCc7XG5leHBvcnQgKiBmcm9tICcuL2ZpcmViYXNlJztcbmV4cG9ydCAqIGZyb20gJy4vZmlyZXN0b3JlJztcbmV4cG9ydCAqIGZyb20gJy4vZnVuY3Rpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL3JvdXRlcic7XG5leHBvcnQgKiBmcm9tICcuL21vZHVsZSc7XG4iXX0=

package/esm2020/lib/model/loader/collection.change.trigger.mjs

@@ -0,0 +1,81 @@
+import { SubscriptionObject, asObservable } from '@dereekb/rxjs';
+import { BehaviorSubject, filter, switchMap, exhaustMap, EMPTY } from 'rxjs';
+import { dbxFirebaseCollectionChangeWatcher } from './collection.change.watcher';
+/**
+ * Restarts the store.
+ *
+ * @param instance
+ * @returns
+ */
+export const DEFAULT_FIREBASE_COLLECTION_CHANGE_TRIGGER_FUNCTION = (instance) => instance.watcher.store.restart();
+export class DbxFirebaseCollectionChangeTriggerInstance {
+    constructor(config) {
+        this.config = config;
+        this._triggerFunction = new BehaviorSubject(undefined);
+        this._sub = new SubscriptionObject();
+        this.watcher = config.watcher;
+        this.triggerFunction = config.triggerFunction ?? DEFAULT_FIREBASE_COLLECTION_CHANGE_TRIGGER_FUNCTION;
+    }
+    init() {
+        this._sub.subscription = this._triggerFunction
+            .pipe(switchMap((triggerFunction) => {
+            if (triggerFunction) {
+                return this.watcher.triggered$.pipe(filter((triggered) => triggered), exhaustMap(() => asObservable(triggerFunction(this))));
+            }
+            else {
+                return EMPTY;
+            }
+        }))
+            .subscribe();
+    }
+    destroy() {
+        this._triggerFunction.complete();
+        if (this.config.destroyWatcherOnDestroy === true) {
+            this.watcher?.destroy();
+        }
+    }
+    get triggerFunction() {
+        return this._triggerFunction.value;
+    }
+    set triggerFunction(triggerFunction) {
+        this._triggerFunction.next(triggerFunction);
+    }
+}
+/**
+ * Creates a new DbxFirebaseCollectionChangeWatcher, set the modes to "auto", and creates a new DbxFirebaseCollectionChangeTriggerInstance.
+ *
+ * @param store
+ * @param triggerFunction
+ * @returns
+ */
+export function dbxFirebaseCollectionChangeTriggerForStore(store, triggerFunction) {
+    return dbxFirebaseCollectionChangeTrigger({
+        watcher: dbxFirebaseCollectionChangeWatcher(store, 'auto'),
+        destroyWatcherOnDestroy: true,
+        triggerFunction
+    });
+}
+export function dbxFirebaseCollectionChangeTriggerForWatcher(watcher, triggerFunction) {
+    return dbxFirebaseCollectionChangeTrigger({
+        watcher,
+        destroyWatcherOnDestroy: false,
+        triggerFunction
+    });
+}
+export function dbxFirebaseCollectionChangeTrigger(config) {
+    return new DbxFirebaseCollectionChangeTriggerInstance(config);
+}
+// MARK: Compat
+/**
+ * @deprecated
+ */
+export const dbxFirebaseCollectionChangeTriggerInstance = dbxFirebaseCollectionChangeTrigger;
+/**
+ * @deprecated
+ */
+export const dbxFirebaseCollectionChangeTriggerInstanceForStore = dbxFirebaseCollectionChangeTriggerForStore;
+/**
+ * @deprecated
+ */
+export const dbxFirebaseCollectionChangeTriggerInstanceForWatcher = dbxFirebaseCollectionChangeTriggerForWatcher;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection.change.trigger.js","sourceRoot":"","sources":["../../../../../../../packages/dbx-firebase/src/lib/model/loader/collection.change.trigger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAqB,YAAY,EAAE,MAAM,eAAe,CAAC;AACpF,OAAO,EAAE,eAAe,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAE7E,OAAO,EAAsC,kCAAkC,EAAE,MAAM,6BAA6B,CAAC;AAKrH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mDAAmD,GAAoD,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;AAuBnK,MAAM,OAAO,0CAA0C;IAMrD,YAAqB,MAA2D;QAA3D,WAAM,GAAN,MAAM,CAAqD;QAHxE,qBAAgB,GAAG,IAAI,eAAe,CAAuD,SAAS,CAAC,CAAC;QACxG,SAAI,GAAG,IAAI,kBAAkB,EAAE,CAAC;QAGtC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC;QAC9B,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,IAAI,mDAAmD,CAAC;IACvG,CAAC;IAED,IAAI;QACF,IAAI,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,gBAAgB;aAC3C,IAAI,CACH,SAAS,CAAC,CAAC,eAAe,EAAE,EAAE;YAC5B,IAAI,eAAe,EAAE;gBACnB,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CACjC,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,EAChC,UAAU,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CACtD,CAAC;aACH;iBAAM;gBACL,OAAO,KAAK,CAAC;aACd;QACH,CAAC,CAAC,CACH;aACA,SAAS,EAAE,CAAC;IACjB,CAAC;IAED,OAAO;QACL,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC;QAEjC,IAAI,IAAI,CAAC,MAAM,CAAC,uBAAuB,KAAK,IAAI,EAAE;YAC/C,IAAI,CAAC,OAAkC,EAAE,OAAO,EAAE,CAAC;SACrD;IACH,CAAC;IAED,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC;IACrC,CAAC;IAED,IAAI,eAAe,CAAC,eAAqE;QACvF,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC9C,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,UAAU,0CAA0C,CAAqD,KAAQ,EAAE,eAAsE;IAC7L,OAAO,kCAAkC,CAAI;QAC3C,OAAO,EAAE,kCAAkC,CAAI,KAAK,EAAE,MAAM,CAAC;QAC7D,uBAAuB,EAAE,IAAI;QAC7B,eAAe;KAChB,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,4CAA4C,CAAqD,OAA8C,EAAE,eAAsE;IACrO,OAAO,kCAAkC,CAAI;QAC3C,OAAO;QACP,uBAAuB,EAAE,KAAK;QAC9B,eAAe;KAChB,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,kCAAkC,CAAqD,MAA2D;IAChK,OAAO,IAAI,0CAA0C,CAAC,MAAM,CAAC,CAAC;AAChE,CAAC;AAED,eAAe;AACf;;GAEG;AACH,MAAM,CAAC,MAAM,0CAA0C,GAAG,kCAAkC,CAAC;AAE7F;;GAEG;AACH,MAAM,CAAC,MAAM,kDAAkD,GAAG,0CAA0C,CAAC;AAE7G;;GAEG;AACH,MAAM,CAAC,MAAM,oDAAoD,GAAG,4CAA4C,CAAC","sourcesContent":["import { SubscriptionObject, ObservableOrValue, asObservable } from '@dereekb/rxjs';\nimport { BehaviorSubject, filter, switchMap, exhaustMap, EMPTY } from 'rxjs';\nimport { Destroyable, Maybe, Initialized } from '@dereekb/util';\nimport { DbxFirebaseCollectionChangeWatcher, dbxFirebaseCollectionChangeWatcher } from './collection.change.watcher';\nimport { DbxFirebaseCollectionLoaderAccessor } from './collection.loader';\n\nexport type DbxFirebaseCollectionChangeTriggerFunction<S extends DbxFirebaseCollectionLoaderAccessor<any>> = (instance: DbxFirebaseCollectionChangeTriggerInstance<S>) => ObservableOrValue<void>;\n\n/**\n * Restarts the store.\n *\n * @param instance\n * @returns\n */\nexport const DEFAULT_FIREBASE_COLLECTION_CHANGE_TRIGGER_FUNCTION: DbxFirebaseCollectionChangeTriggerFunction<any> = (instance) => instance.watcher.store.restart();\n\nexport interface DbxFirebaseCollectionChangeTriggerInstanceConfig<S extends DbxFirebaseCollectionLoaderAccessor<any>> {\n  readonly watcher: DbxFirebaseCollectionChangeWatcher<S> & Partial<Destroyable>;\n  /**\n   * Whether or not to also destroy the watcher when the trigger instance is destroyed.\n   *\n   * Defaults to false.\n   */\n  readonly destroyWatcherOnDestroy?: boolean;\n  /**\n   * Initial trigger function to use.\n   *\n   * By default restarts the store.\n   */\n  readonly triggerFunction?: Maybe<DbxFirebaseCollectionChangeTriggerFunction<S>>;\n}\n\nexport interface DbxFirebaseCollectionChangeTrigger<S extends DbxFirebaseCollectionLoaderAccessor<any>> {\n  readonly watcher: DbxFirebaseCollectionChangeWatcher<S>;\n  triggerFunction?: Maybe<DbxFirebaseCollectionChangeTriggerFunction<S>>;\n}\n\nexport class DbxFirebaseCollectionChangeTriggerInstance<S extends DbxFirebaseCollectionLoaderAccessor<any>> implements DbxFirebaseCollectionChangeTrigger<S>, Initialized, Destroyable {\n  readonly watcher: DbxFirebaseCollectionChangeWatcher<S>;\n\n  private _triggerFunction = new BehaviorSubject<Maybe<DbxFirebaseCollectionChangeTriggerFunction<S>>>(undefined);\n  private _sub = new SubscriptionObject();\n\n  constructor(readonly config: DbxFirebaseCollectionChangeTriggerInstanceConfig<S>) {\n    this.watcher = config.watcher;\n    this.triggerFunction = config.triggerFunction ?? DEFAULT_FIREBASE_COLLECTION_CHANGE_TRIGGER_FUNCTION;\n  }\n\n  init(): void {\n    this._sub.subscription = this._triggerFunction\n      .pipe(\n        switchMap((triggerFunction) => {\n          if (triggerFunction) {\n            return this.watcher.triggered$.pipe(\n              filter((triggered) => triggered),\n              exhaustMap(() => asObservable(triggerFunction(this)))\n            );\n          } else {\n            return EMPTY;\n          }\n        })\n      )\n      .subscribe();\n  }\n\n  destroy(): void {\n    this._triggerFunction.complete();\n\n    if (this.config.destroyWatcherOnDestroy === true) {\n      (this.watcher as unknown as Destroyable)?.destroy();\n    }\n  }\n\n  get triggerFunction(): Maybe<DbxFirebaseCollectionChangeTriggerFunction<S>> {\n    return this._triggerFunction.value;\n  }\n\n  set triggerFunction(triggerFunction: Maybe<DbxFirebaseCollectionChangeTriggerFunction<S>>) {\n    this._triggerFunction.next(triggerFunction);\n  }\n}\n\n/**\n * Creates a new DbxFirebaseCollectionChangeWatcher, set the modes to \"auto\", and creates a new DbxFirebaseCollectionChangeTriggerInstance.\n *\n * @param store\n * @param triggerFunction\n * @returns\n */\nexport function dbxFirebaseCollectionChangeTriggerForStore<S extends DbxFirebaseCollectionLoaderAccessor<any>>(store: S, triggerFunction?: Maybe<DbxFirebaseCollectionChangeTriggerFunction<S>>): DbxFirebaseCollectionChangeTriggerInstance<S> {\n  return dbxFirebaseCollectionChangeTrigger<S>({\n    watcher: dbxFirebaseCollectionChangeWatcher<S>(store, 'auto'),\n    destroyWatcherOnDestroy: true,\n    triggerFunction\n  });\n}\n\nexport function dbxFirebaseCollectionChangeTriggerForWatcher<S extends DbxFirebaseCollectionLoaderAccessor<any>>(watcher: DbxFirebaseCollectionChangeWatcher<S>, triggerFunction?: Maybe<DbxFirebaseCollectionChangeTriggerFunction<S>>): DbxFirebaseCollectionChangeTriggerInstance<S> {\n  return dbxFirebaseCollectionChangeTrigger<S>({\n    watcher,\n    destroyWatcherOnDestroy: false,\n    triggerFunction\n  });\n}\n\nexport function dbxFirebaseCollectionChangeTrigger<S extends DbxFirebaseCollectionLoaderAccessor<any>>(config: DbxFirebaseCollectionChangeTriggerInstanceConfig<S>): DbxFirebaseCollectionChangeTriggerInstance<S> {\n  return new DbxFirebaseCollectionChangeTriggerInstance(config);\n}\n\n// MARK: Compat\n/**\n * @deprecated\n */\nexport const dbxFirebaseCollectionChangeTriggerInstance = dbxFirebaseCollectionChangeTrigger;\n\n/**\n * @deprecated\n */\nexport const dbxFirebaseCollectionChangeTriggerInstanceForStore = dbxFirebaseCollectionChangeTriggerForStore;\n\n/**\n * @deprecated\n */\nexport const dbxFirebaseCollectionChangeTriggerInstanceForWatcher = dbxFirebaseCollectionChangeTriggerForWatcher;\n"]}

package/esm2020/lib/model/loader/collection.change.watcher.mjs

@@ -4,9 +4,10 @@ import { filter, take, map, BehaviorSubject, distinctUntilChanged, switchMap, st
  * DbxFirebaseCollectionChangeWatcher instance
  */
 export class DbxFirebaseCollectionChangeWatcherInstance {
-    constructor(store) {
+    constructor(store, _initialMode = 'off') {
         this.store = store;
-        this._mode = new BehaviorSubject('off');
+        this._initialMode = _initialMode;
+        this._mode = new BehaviorSubject(this._initialMode);
         this._sub = new SubscriptionObject();
         this.mode$ = this._mode.pipe(distinctUntilChanged());
         this.event$ = this.store.queryChangeWatcher$.pipe(switchMap((x) => x.event$.pipe(filter((x) => x.type !== 'none'), // do not share 'none' events.
@@ -30,7 +31,7 @@ export class DbxFirebaseCollectionChangeWatcherInstance {
         this._mode.next(mode);
     }
 }
-export function dbxFirebaseCollectionChangeWatcher(store) {
-    return new DbxFirebaseCollectionChangeWatcherInstance(store);
+export function dbxFirebaseCollectionChangeWatcher(store, mode) {
+    return new DbxFirebaseCollectionChangeWatcherInstance(store, mode);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/loader/collection.loader.instance.mjs

@@ -97,4 +97,4 @@ export function dbxFirebaseCollectionLoaderInstance(config) {
 export function dbxFirebaseCollectionLoaderInstanceWithCollection(collection) {
     return new DbxFirebaseCollectionLoaderInstance({ collection });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection.loader.instance.js","sourceRoot":"","sources":["../../../../../../../packages/dbx-firebase/src/lib/model/loader/collection.loader.instance.ts"],"names":[],"mappings":"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","sourcesContent":["import { PageListLoadingState, cleanupDestroyable, filterMaybe, useFirst, SubscriptionObject, accumulatorFlattenPageListLoadingState } from '@dereekb/rxjs';\nimport { BehaviorSubject, combineLatest, map, shareReplay, distinctUntilChanged, Subject, throttleTime, switchMap, Observable, tap, startWith, NEVER } from 'rxjs';\nimport { DocumentDataWithId, FirebaseQueryItemAccumulator, firebaseQueryItemAccumulator, FirestoreCollectionLike, FirestoreDocument, FirestoreItemPageIterationInstance, FirestoreItemPageIteratorFilter, FirestoreQueryConstraint, IterationQueryDocChangeWatcher, iterationQueryDocChangeWatcher } from '@dereekb/firebase';\nimport { ArrayOrValue, Destroyable, Initialized, Maybe } from '@dereekb/util';\nimport { DbxFirebaseCollectionLoader } from './collection.loader';\n\nexport interface DbxFirebaseCollectionLoaderInstanceInitConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {\n  collection?: Maybe<FirestoreCollectionLike<T, D>>;\n  maxPages?: Maybe<number>;\n  itemsPerPage?: Maybe<number>;\n  constraints?: Maybe<ArrayOrValue<FirestoreQueryConstraint>>;\n}\n\nexport interface DbxFirebaseCollectionLoaderInstanceData<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {\n  readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>>;\n  readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>>;\n  readonly pageLoadingState$: Observable<PageListLoadingState<T>>;\n}\n\n/**\n * DbxFirebaseModelLoader implementation within an instance.\n */\nexport class DbxFirebaseCollectionLoaderInstance<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>> implements DbxFirebaseCollectionLoader<T>, DbxFirebaseCollectionLoaderInstanceData<T, D>, Initialized, Destroyable {\n  protected readonly _collection = new BehaviorSubject<Maybe<FirestoreCollectionLike<T, D>>>(this._initConfig?.collection);\n\n  protected readonly _maxPages = new BehaviorSubject<Maybe<number>>(this._initConfig?.maxPages);\n  protected readonly _itemsPerPage = new BehaviorSubject<Maybe<number>>(this._initConfig?.itemsPerPage);\n  protected readonly _constraints = new BehaviorSubject<Maybe<ArrayOrValue<FirestoreQueryConstraint>>>(this._initConfig?.constraints);\n  protected readonly _restart = new Subject<void>();\n\n  private readonly _maxPagesSub = new SubscriptionObject();\n\n  readonly collection$ = this._collection.pipe(distinctUntilChanged());\n  readonly constraints$ = this._constraints.pipe(distinctUntilChanged());\n\n  readonly iteratorFilter$: Observable<FirestoreItemPageIteratorFilter> = combineLatest([this._itemsPerPage.pipe(distinctUntilChanged()), this.constraints$]).pipe(\n    map(([limit, constraints]) => ({ limit, constraints, maxPageLoadLimit: this.maxPages } as FirestoreItemPageIteratorFilter)),\n    shareReplay(1)\n  );\n\n  readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>> = this.collection$.pipe(\n    switchMap((collection) => {\n      if (collection) {\n        return combineLatest([this.iteratorFilter$, this._restart.pipe(startWith(undefined))]).pipe(\n          throttleTime(100, undefined, { trailing: true }), // prevent rapid changes and executing filters too quickly.\n          map(([iteratorFilter]) => collection.firestoreIteration(iteratorFilter)),\n          cleanupDestroyable(), // cleanup the iteration\n          shareReplay(1)\n        );\n      } else {\n        return NEVER; // don't emit anything until collection is provided.\n      }\n    }),\n    cleanupDestroyable(), // cleanup the iteration\n    shareReplay(1)\n  );\n\n  readonly queryChangeWatcher$: Observable<IterationQueryDocChangeWatcher<T>> = this.firestoreIteration$.pipe(\n    map((instance) => iterationQueryDocChangeWatcher({ instance })),\n    shareReplay(1)\n  );\n\n  readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>> = this.firestoreIteration$.pipe(\n    map((x) => firebaseQueryItemAccumulator<T>(x)),\n    cleanupDestroyable(),\n    shareReplay(1)\n  );\n\n  readonly pageLoadingState$: Observable<PageListLoadingState<DocumentDataWithId<T>>> = this.accumulator$.pipe(\n    switchMap((x) => accumulatorFlattenPageListLoadingState(x)),\n    shareReplay(1)\n  );\n\n  constructor(private readonly _initConfig?: DbxFirebaseCollectionLoaderInstanceInitConfig<T, D>) {}\n\n  init(): void {\n    // When max pages changes, update the iteration's max page limit.\n    this._maxPagesSub.subscription = this._maxPages\n      .pipe(\n        distinctUntilChanged(),\n        filterMaybe(), // do not pass null/undefined values\n        switchMap((maxPageLoadLimit) =>\n          this.firestoreIteration$.pipe(\n            tap((iteration) => {\n              iteration.maxPageLoadLimit = maxPageLoadLimit;\n            })\n          )\n        )\n      )\n      .subscribe();\n  }\n\n  destroy(): void {\n    this._maxPages.complete();\n    this._collection.complete();\n    this._constraints.complete();\n    this._itemsPerPage.complete();\n    this._restart.complete();\n    this._maxPagesSub.destroy();\n  }\n\n  // MARK: Inputs\n  get maxPages(): Maybe<number> {\n    return this._maxPages.value;\n  }\n\n  set maxPages(maxPages: Maybe<number>) {\n    if (this.maxPages != maxPages) {\n      this._maxPages.next(maxPages);\n    }\n  }\n\n  get itemsPerPage(): Maybe<number> {\n    return this._itemsPerPage.value;\n  }\n\n  set itemsPerPage(itemsPerPage: Maybe<number>) {\n    if (this.itemsPerPage != itemsPerPage) {\n      this._itemsPerPage.next(itemsPerPage);\n    }\n  }\n\n  get constraints(): Maybe<ArrayOrValue<FirestoreQueryConstraint>> {\n    return this._constraints.value;\n  }\n\n  set constraints(constraints: Maybe<ArrayOrValue<FirestoreQueryConstraint>>) {\n    this._constraints.next(constraints);\n  }\n\n  get collection(): Maybe<FirestoreCollectionLike<T, D>> {\n    return this._collection.value;\n  }\n\n  set collection(collection: Maybe<FirestoreCollectionLike<T, D>>) {\n    this._collection.next(collection);\n  }\n\n  // MARK: DbxFirebaseCollectionLoader\n  next() {\n    useFirst(this.firestoreIteration$, (x) => x.next());\n  }\n\n  restart() {\n    this._restart.next();\n  }\n\n  setConstraints(constraints: Maybe<ArrayOrValue<FirestoreQueryConstraint>>) {\n    this.constraints = constraints;\n  }\n\n  setCollection(firestoreCollection: Maybe<FirestoreCollectionLike<T, D>>) {\n    this.collection = firestoreCollection;\n  }\n}\n\nexport function dbxFirebaseCollectionLoaderInstance<T, D extends FirestoreDocument<T> = FirestoreDocument<T>>(config: DbxFirebaseCollectionLoaderInstanceInitConfig<T, D>): DbxFirebaseCollectionLoaderInstance<T, D> {\n  return new DbxFirebaseCollectionLoaderInstance<T, D>(config);\n}\n\nexport function dbxFirebaseCollectionLoaderInstanceWithCollection<T, D extends FirestoreDocument<T> = FirestoreDocument<T>>(collection: Maybe<FirestoreCollectionLike<T, D>>): DbxFirebaseCollectionLoaderInstance<T, D> {\n  return new DbxFirebaseCollectionLoaderInstance<T, D>({ collection });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection.loader.instance.js","sourceRoot":"","sources":["../../../../../../../packages/dbx-firebase/src/lib/model/loader/collection.loader.instance.ts"],"names":[],"mappings":"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","sourcesContent":["import { PageListLoadingState, cleanupDestroyable, filterMaybe, useFirst, SubscriptionObject, accumulatorFlattenPageListLoadingState } from '@dereekb/rxjs';\nimport { BehaviorSubject, combineLatest, map, shareReplay, distinctUntilChanged, Subject, throttleTime, switchMap, Observable, tap, startWith, NEVER } from 'rxjs';\nimport { DocumentDataWithId, FirebaseQueryItemAccumulator, firebaseQueryItemAccumulator, FirestoreCollectionLike, FirestoreDocument, FirestoreItemPageIterationInstance, FirestoreItemPageIteratorFilter, FirestoreQueryConstraint, IterationQueryDocChangeWatcher, iterationQueryDocChangeWatcher } from '@dereekb/firebase';\nimport { ArrayOrValue, Destroyable, Initialized, Maybe } from '@dereekb/util';\nimport { DbxFirebaseCollectionLoader, DbxFirebaseCollectionLoaderAccessor } from './collection.loader';\n\nexport interface DbxFirebaseCollectionLoaderInstanceInitConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {\n  collection?: Maybe<FirestoreCollectionLike<T, D>>;\n  maxPages?: Maybe<number>;\n  itemsPerPage?: Maybe<number>;\n  constraints?: Maybe<ArrayOrValue<FirestoreQueryConstraint>>;\n}\n\nexport type DbxFirebaseCollectionLoaderInstanceData<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> = DbxFirebaseCollectionLoaderAccessor<T>;\n\n/**\n * DbxFirebaseModelLoader implementation within an instance.\n */\nexport class DbxFirebaseCollectionLoaderInstance<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>> implements DbxFirebaseCollectionLoader<T>, DbxFirebaseCollectionLoaderInstanceData<T, D>, Initialized, Destroyable {\n  protected readonly _collection = new BehaviorSubject<Maybe<FirestoreCollectionLike<T, D>>>(this._initConfig?.collection);\n\n  protected readonly _maxPages = new BehaviorSubject<Maybe<number>>(this._initConfig?.maxPages);\n  protected readonly _itemsPerPage = new BehaviorSubject<Maybe<number>>(this._initConfig?.itemsPerPage);\n  protected readonly _constraints = new BehaviorSubject<Maybe<ArrayOrValue<FirestoreQueryConstraint>>>(this._initConfig?.constraints);\n  protected readonly _restart = new Subject<void>();\n\n  private readonly _maxPagesSub = new SubscriptionObject();\n\n  readonly collection$ = this._collection.pipe(distinctUntilChanged());\n  readonly constraints$ = this._constraints.pipe(distinctUntilChanged());\n\n  readonly iteratorFilter$: Observable<FirestoreItemPageIteratorFilter> = combineLatest([this._itemsPerPage.pipe(distinctUntilChanged()), this.constraints$]).pipe(\n    map(([limit, constraints]) => ({ limit, constraints, maxPageLoadLimit: this.maxPages } as FirestoreItemPageIteratorFilter)),\n    shareReplay(1)\n  );\n\n  readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>> = this.collection$.pipe(\n    switchMap((collection) => {\n      if (collection) {\n        return combineLatest([this.iteratorFilter$, this._restart.pipe(startWith(undefined))]).pipe(\n          throttleTime(100, undefined, { trailing: true }), // prevent rapid changes and executing filters too quickly.\n          map(([iteratorFilter]) => collection.firestoreIteration(iteratorFilter)),\n          cleanupDestroyable(), // cleanup the iteration\n          shareReplay(1)\n        );\n      } else {\n        return NEVER; // don't emit anything until collection is provided.\n      }\n    }),\n    cleanupDestroyable(), // cleanup the iteration\n    shareReplay(1)\n  );\n\n  readonly queryChangeWatcher$: Observable<IterationQueryDocChangeWatcher<T>> = this.firestoreIteration$.pipe(\n    map((instance) => iterationQueryDocChangeWatcher({ instance })),\n    shareReplay(1)\n  );\n\n  readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>> = this.firestoreIteration$.pipe(\n    map((x) => firebaseQueryItemAccumulator<T>(x)),\n    cleanupDestroyable(),\n    shareReplay(1)\n  );\n\n  readonly pageLoadingState$: Observable<PageListLoadingState<DocumentDataWithId<T>>> = this.accumulator$.pipe(\n    switchMap((x) => accumulatorFlattenPageListLoadingState(x)),\n    shareReplay(1)\n  );\n\n  constructor(private readonly _initConfig?: DbxFirebaseCollectionLoaderInstanceInitConfig<T, D>) {}\n\n  init(): void {\n    // When max pages changes, update the iteration's max page limit.\n    this._maxPagesSub.subscription = this._maxPages\n      .pipe(\n        distinctUntilChanged(),\n        filterMaybe(), // do not pass null/undefined values\n        switchMap((maxPageLoadLimit) =>\n          this.firestoreIteration$.pipe(\n            tap((iteration) => {\n              iteration.maxPageLoadLimit = maxPageLoadLimit;\n            })\n          )\n        )\n      )\n      .subscribe();\n  }\n\n  destroy(): void {\n    this._maxPages.complete();\n    this._collection.complete();\n    this._constraints.complete();\n    this._itemsPerPage.complete();\n    this._restart.complete();\n    this._maxPagesSub.destroy();\n  }\n\n  // MARK: Inputs\n  get maxPages(): Maybe<number> {\n    return this._maxPages.value;\n  }\n\n  set maxPages(maxPages: Maybe<number>) {\n    if (this.maxPages != maxPages) {\n      this._maxPages.next(maxPages);\n    }\n  }\n\n  get itemsPerPage(): Maybe<number> {\n    return this._itemsPerPage.value;\n  }\n\n  set itemsPerPage(itemsPerPage: Maybe<number>) {\n    if (this.itemsPerPage != itemsPerPage) {\n      this._itemsPerPage.next(itemsPerPage);\n    }\n  }\n\n  get constraints(): Maybe<ArrayOrValue<FirestoreQueryConstraint>> {\n    return this._constraints.value;\n  }\n\n  set constraints(constraints: Maybe<ArrayOrValue<FirestoreQueryConstraint>>) {\n    this._constraints.next(constraints);\n  }\n\n  get collection(): Maybe<FirestoreCollectionLike<T, D>> {\n    return this._collection.value;\n  }\n\n  set collection(collection: Maybe<FirestoreCollectionLike<T, D>>) {\n    this._collection.next(collection);\n  }\n\n  // MARK: DbxFirebaseCollectionLoader\n  next() {\n    useFirst(this.firestoreIteration$, (x) => x.next());\n  }\n\n  restart() {\n    this._restart.next();\n  }\n\n  setConstraints(constraints: Maybe<ArrayOrValue<FirestoreQueryConstraint>>) {\n    this.constraints = constraints;\n  }\n\n  setCollection(firestoreCollection: Maybe<FirestoreCollectionLike<T, D>>) {\n    this.collection = firestoreCollection;\n  }\n}\n\nexport function dbxFirebaseCollectionLoaderInstance<T, D extends FirestoreDocument<T> = FirestoreDocument<T>>(config: DbxFirebaseCollectionLoaderInstanceInitConfig<T, D>): DbxFirebaseCollectionLoaderInstance<T, D> {\n  return new DbxFirebaseCollectionLoaderInstance<T, D>(config);\n}\n\nexport function dbxFirebaseCollectionLoaderInstanceWithCollection<T, D extends FirestoreDocument<T> = FirestoreDocument<T>>(collection: Maybe<FirestoreCollectionLike<T, D>>): DbxFirebaseCollectionLoaderInstance<T, D> {\n  return new DbxFirebaseCollectionLoaderInstance<T, D>({ collection });\n}\n"]}

package/esm2020/lib/model/loader/collection.loader.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sbGVjdGlvbi5sb2FkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9tb2RlbC9sb2FkZXIvY29sbGVjdGlvbi5sb2FkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERvY3VtZW50RGF0YVdpdGhJZCwgRmlyZXN0b3JlSXRlbVBhZ2VJdGVyYXRpb25JbnN0YW5jZSwgRmlyZXN0b3JlUXVlcnlDb25zdHJhaW50IH0gZnJvbSAnQGRlcmVla2IvZmlyZWJhc2UnO1xuaW1wb3J0IHsgUGFnZUxpc3RMb2FkaW5nU3RhdGUgfSBmcm9tICdAZGVyZWVrYi9yeGpzJztcbmltcG9ydCB7IE1heWJlLCBBcnJheU9yVmFsdWUgfSBmcm9tICdAZGVyZWVrYi91dGlsJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcblxuLyoqXG4gKiBBYnN0cmFjdCB0eXBlIHRoYXQgbG9hZHMgbW9kZWxzIGZyb20gYSBjb25maWd1cmVkIGNvbGxlY3Rpb24uXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRGJ4RmlyZWJhc2VDb2xsZWN0aW9uTG9hZGVyPFQgPSB1bmtub3duPiB7XG4gIHJlYWRvbmx5IGNvbnN0cmFpbnRzJDogT2JzZXJ2YWJsZTxNYXliZTxBcnJheU9yVmFsdWU8RmlyZXN0b3JlUXVlcnlDb25zdHJhaW50Pj4+O1xuICByZWFkb25seSBmaXJlc3RvcmVJdGVyYXRpb24kOiBPYnNlcnZhYmxlPEZpcmVzdG9yZUl0ZW1QYWdlSXRlcmF0aW9uSW5zdGFuY2U8VD4+O1xuICByZWFkb25seSBwYWdlTG9hZGluZ1N0YXRlJDogT2JzZXJ2YWJsZTxQYWdlTGlzdExvYWRpbmdTdGF0ZTxEb2N1bWVudERhdGFXaXRoSWQ8VD4+PjtcblxuICAvKipcbiAgICogTWF4aW11bSBudW1iZXIgb2YgcGFnZXMgdG8gbG9hZCBmcm9tIHRoZSBpbnRlcmF0aW9uLlxuICAgKlxuICAgKiBDaGFuZ2luZyB0aGlzIHVwZGF0ZXMgdGhlIGl0ZXJhdGlvbiwgYnV0IGRvZXMgbm90IHJlc2V0IGl0LlxuICAgKi9cbiAgbWF4UGFnZXM6IE1heWJlPG51bWJlcj47XG5cbiAgLyoqXG4gICAqIE51bWJlciBvZiBpdGVtcyB0byBsb2FkIHBlciBwYWdlLlxuICAgKlxuICAgKiBDaGFuZ2luZyB0aGlzIHdpbGwgcmVzZXQgdGhlIGl0ZXJhdGlvbi5cbiAgICovXG4gIGl0ZW1zUGVyUGFnZTogTWF5YmU8bnVtYmVyPjtcblxuICAvKipcbiAgICogU2V0cyB0aGUgY29uc3RyYWludHMgb24gdGhlIG1vZGVsIGxvYWRlci5cbiAgICpcbiAgICogQHBhcmFtIGNvbnN0cmFpbnRzXG4gICAqL1xuICBzZXRDb25zdHJhaW50cyhjb25zdHJhaW50czogTWF5YmU8QXJyYXlPclZhbHVlPEZpcmVzdG9yZVF1ZXJ5Q29uc3RyYWludD4+KTogdm9pZDtcblxuICAvKipcbiAgICogTG9hZHMgbW9yZSBpdGVtcy5cbiAgICovXG4gIG5leHQoKTogdm9pZDtcblxuICAvKipcbiAgICogUmVzZXRzL3Jlc3RhcnRzIHRoZSBsaXN0LlxuICAgKi9cbiAgcmVzdGFydCgpOiB2b2lkO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/loader/index.mjs

@@ -1,6 +1,7 @@
 export * from './collection.change.watcher';
+export * from './collection.change.trigger';
 export * from './collection.loader.instance';
 export * from './collection.loader';
 export * from './document.loader.instance';
 export * from './document.loader';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9tb2RlbC9sb2FkZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb2xsZWN0aW9uLmNoYW5nZS53YXRjaGVyJztcbmV4cG9ydCAqIGZyb20gJy4vY29sbGVjdGlvbi5sb2FkZXIuaW5zdGFuY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9jb2xsZWN0aW9uLmxvYWRlcic7XG5leHBvcnQgKiBmcm9tICcuL2RvY3VtZW50LmxvYWRlci5pbnN0YW5jZSc7XG5leHBvcnQgKiBmcm9tICcuL2RvY3VtZW50LmxvYWRlcic7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9tb2RlbC9sb2FkZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbGxlY3Rpb24uY2hhbmdlLndhdGNoZXInO1xuZXhwb3J0ICogZnJvbSAnLi9jb2xsZWN0aW9uLmNoYW5nZS50cmlnZ2VyJztcbmV4cG9ydCAqIGZyb20gJy4vY29sbGVjdGlvbi5sb2FkZXIuaW5zdGFuY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9jb2xsZWN0aW9uLmxvYWRlcic7XG5leHBvcnQgKiBmcm9tICcuL2RvY3VtZW50LmxvYWRlci5pbnN0YW5jZSc7XG5leHBvcnQgKiBmcm9tICcuL2RvY3VtZW50LmxvYWRlcic7XG4iXX0=

package/esm2020/lib/model/store/store.collection.change.directive.mjs

@@ -1,31 +1,32 @@
 import { Directive, Input } from '@angular/core';
 import { DbxFirebaseCollectionStoreDirective } from './store.collection.directive';
-import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
 import { dbxFirebaseCollectionChangeWatcher } from '../loader/collection.change.watcher';
+import { dbxFirebaseCollectionChangeTriggerForWatcher } from '../loader/collection.change.trigger';
 import * as i0 from "@angular/core";
 import * as i1 from "./store.collection.directive";
 /**
  * Used to watch query doc changes and respond to them accordingly.
  */
-export class DbxFirebaseCollectionChangeDirective extends AbstractSubscriptionDirective {
+export class DbxFirebaseCollectionChangeDirective {
     constructor(dbxFirebaseCollectionStoreDirective) {
-        super();
         this.dbxFirebaseCollectionStoreDirective = dbxFirebaseCollectionStoreDirective;
         this._watcher = dbxFirebaseCollectionChangeWatcher(this.dbxFirebaseCollectionStoreDirective.store);
+        this._trigger = dbxFirebaseCollectionChangeTriggerForWatcher(this._watcher, () => this.restart());
         this.mode$ = this._watcher.mode$;
         this.event$ = this._watcher.event$;
         this.hasChangeAvailable$ = this._watcher.hasChangeAvailable$;
         this.triggered$ = this._watcher.triggered$;
         this.trigger$ = this._watcher.trigger$;
     }
+    get store() {
+        return this._watcher.store;
+    }
     ngOnInit() {
-        this.sub = this._watcher.trigger$.subscribe(() => {
-            this.restart();
-        });
+        this._trigger.init();
     }
     ngOnDestroy() {
-        super.ngOnDestroy();
         this._watcher.destroy();
+        this._trigger.destroy();
     }
     get mode() {
         return this._watcher.mode;
@@ -38,7 +39,7 @@ export class DbxFirebaseCollectionChangeDirective extends AbstractSubscriptionDi
     }
 }
 DbxFirebaseCollectionChangeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFirebaseCollectionChangeDirective, deps: [{ token: i1.DbxFirebaseCollectionStoreDirective }], target: i0.ɵɵFactoryTarget.Directive });
-DbxFirebaseCollectionChangeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.2", type: DbxFirebaseCollectionChangeDirective, selector: "[dbxFirebaseCollectionChange]", inputs: { mode: ["dbxFirebaseCollectionChange", "mode"] }, usesInheritance: true, ngImport: i0 });
+DbxFirebaseCollectionChangeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.2", type: DbxFirebaseCollectionChangeDirective, selector: "[dbxFirebaseCollectionChange]", inputs: { mode: ["dbxFirebaseCollectionChange", "mode"] }, ngImport: i0 });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFirebaseCollectionChangeDirective, decorators: [{
             type: Directive,
             args: [{
@@ -48,4 +49,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImpor
                 type: Input,
                 args: ['dbxFirebaseCollectionChange']
             }] } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmUuY29sbGVjdGlvbi5jaGFuZ2UuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZGJ4LWZpcmViYXNlL3NyYy9saWIvbW9kZWwvc3RvcmUvc3RvcmUuY29sbGVjdGlvbi5jaGFuZ2UuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFxQixNQUFNLGVBQWUsQ0FBQztBQUlwRSxPQUFPLEVBQUUsbUNBQW1DLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUNuRixPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNsRSxPQUFPLEVBQXNDLGtDQUFrQyxFQUEwRixNQUFNLHFDQUFxQyxDQUFDOzs7QUFHck47O0dBRUc7QUFJSCxNQUFNLE9BQU8sb0NBQXdMLFNBQVEsNkJBQTZCO0lBU3hPLFlBQXFCLG1DQUFpRjtRQUNwRyxLQUFLLEVBQUUsQ0FBQztRQURXLHdDQUFtQyxHQUFuQyxtQ0FBbUMsQ0FBOEM7UUFSOUYsYUFBUSxHQUFHLGtDQUFrQyxDQUFVLElBQUksQ0FBQyxtQ0FBbUMsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUV0RyxVQUFLLEdBQThELElBQUksQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDO1FBQ3ZGLFdBQU0sR0FBd0QsSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUM7UUFDbkYsd0JBQW1CLEdBQXdCLElBQUksQ0FBQyxRQUFRLENBQUMsbUJBQW1CLENBQUM7UUFDN0UsZUFBVSxHQUF3QixJQUFJLENBQUMsUUFBUSxDQUFDLFVBQVUsQ0FBQztRQUMzRCxhQUFRLEdBQXFCLElBQUksQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDO0lBSTdELENBQUM7SUFDRCxRQUFRO1FBQ04sSUFBSSxDQUFDLEdBQUcsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFO1lBQy9DLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUNqQixDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFUSxXQUFXO1FBQ2xCLEtBQUssQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUNwQixJQUFJLENBQUMsUUFBUSxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQzFCLENBQUM7SUFFRCxJQUNJLElBQUk7UUFDTixPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDO0lBQzVCLENBQUM7SUFFRCxJQUFJLElBQUksQ0FBQyxJQUErRDtRQUN0RSxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksR0FBRyxJQUFJLElBQUksS0FBSyxDQUFDO0lBQ3JDLENBQUM7SUFFRCxPQUFPO1FBQ0wsSUFBSSxDQUFDLG1DQUFtQyxDQUFDLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUMzRCxDQUFDOztpSUFsQ1Usb0NBQW9DO3FIQUFwQyxvQ0FBb0M7MkZBQXBDLG9DQUFvQztrQkFIaEQsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsK0JBQStCO2lCQUMxQzswSEF5QkssSUFBSTtzQkFEUCxLQUFLO3VCQUFDLDZCQUE2QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSW5wdXQsIE9uRGVzdHJveSwgT25Jbml0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBGaXJlc3RvcmVEb2N1bWVudCB9IGZyb20gJ0BkZXJlZWtiL2ZpcmViYXNlJztcbmltcG9ydCB7IE1heWJlIH0gZnJvbSAnQGRlcmVla2IvdXRpbCc7XG5pbXBvcnQgeyBEYnhGaXJlYmFzZUNvbGxlY3Rpb25TdG9yZSB9IGZyb20gJy4vc3RvcmUuY29sbGVjdGlvbic7XG5pbXBvcnQgeyBEYnhGaXJlYmFzZUNvbGxlY3Rpb25TdG9yZURpcmVjdGl2ZSB9IGZyb20gJy4vc3RvcmUuY29sbGVjdGlvbi5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgQWJzdHJhY3RTdWJzY3JpcHRpb25EaXJlY3RpdmUgfSBmcm9tICdAZGVyZWVrYi9kYngtY29yZSc7XG5pbXBvcnQgeyBEYnhGaXJlYmFzZUNvbGxlY3Rpb25DaGFuZ2VXYXRjaGVyLCBkYnhGaXJlYmFzZUNvbGxlY3Rpb25DaGFuZ2VXYXRjaGVyLCBEYnhGaXJlYmFzZUNvbGxlY3Rpb25DaGFuZ2VXYXRjaGVyRXZlbnQsIERieEZpcmViYXNlQ29sbGVjdGlvbkNoYW5nZVdhdGNoZXJUcmlnZ2VyTW9kZSB9IGZyb20gJy4uL2xvYWRlci9jb2xsZWN0aW9uLmNoYW5nZS53YXRjaGVyJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcblxuLyoqXG4gKiBVc2VkIHRvIHdhdGNoIHF1ZXJ5IGRvYyBjaGFuZ2VzIGFuZCByZXNwb25kIHRvIHRoZW0gYWNjb3JkaW5nbHkuXG4gKi9cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tkYnhGaXJlYmFzZUNvbGxlY3Rpb25DaGFuZ2VdJ1xufSlcbmV4cG9ydCBjbGFzcyBEYnhGaXJlYmFzZUNvbGxlY3Rpb25DaGFuZ2VEaXJlY3RpdmU8VCA9IHVua25vd24sIEQgZXh0ZW5kcyBGaXJlc3RvcmVEb2N1bWVudDxUPiA9IEZpcmVzdG9yZURvY3VtZW50PFQ+LCBTIGV4dGVuZHMgRGJ4RmlyZWJhc2VDb2xsZWN0aW9uU3RvcmU8VCwgRD4gPSBEYnhGaXJlYmFzZUNvbGxlY3Rpb25TdG9yZTxULCBEPj4gZXh0ZW5kcyBBYnN0cmFjdFN1YnNjcmlwdGlvbkRpcmVjdGl2ZSBpbXBsZW1lbnRzIERieEZpcmViYXNlQ29sbGVjdGlvbkNoYW5nZVdhdGNoZXIsIE9uSW5pdCwgT25EZXN0cm95IHtcbiAgcHJpdmF0ZSBfd2F0Y2hlciA9IGRieEZpcmViYXNlQ29sbGVjdGlvbkNoYW5nZVdhdGNoZXI8VCwgRCwgUz4odGhpcy5kYnhGaXJlYmFzZUNvbGxlY3Rpb25TdG9yZURpcmVjdGl2ZS5zdG9yZSk7XG5cbiAgcmVhZG9ubHkgbW9kZSQ6IE9ic2VydmFibGU8RGJ4RmlyZWJhc2VDb2xsZWN0aW9uQ2hhbmdlV2F0Y2hlclRyaWdnZXJNb2RlPiA9IHRoaXMuX3dhdGNoZXIubW9kZSQ7XG4gIHJlYWRvbmx5IGV2ZW50JDogT2JzZXJ2YWJsZTxEYnhGaXJlYmFzZUNvbGxlY3Rpb25DaGFuZ2VXYXRjaGVyRXZlbnQ+ID0gdGhpcy5fd2F0Y2hlci5ldmVudCQ7XG4gIHJlYWRvbmx5IGhhc0NoYW5nZUF2YWlsYWJsZSQ6IE9ic2VydmFibGU8Ym9vbGVhbj4gPSB0aGlzLl93YXRjaGVyLmhhc0NoYW5nZUF2YWlsYWJsZSQ7XG4gIHJlYWRvbmx5IHRyaWdnZXJlZCQ6IE9ic2VydmFibGU8Ym9vbGVhbj4gPSB0aGlzLl93YXRjaGVyLnRyaWdnZXJlZCQ7XG4gIHJlYWRvbmx5IHRyaWdnZXIkOiBPYnNlcnZhYmxlPHZvaWQ+ID0gdGhpcy5fd2F0Y2hlci50cmlnZ2VyJDtcblxuICBjb25zdHJ1Y3RvcihyZWFkb25seSBkYnhGaXJlYmFzZUNvbGxlY3Rpb25TdG9yZURpcmVjdGl2ZTogRGJ4RmlyZWJhc2VDb2xsZWN0aW9uU3RvcmVEaXJlY3RpdmU8VCwgRCwgUz4pIHtcbiAgICBzdXBlcigpO1xuICB9XG4gIG5nT25Jbml0KCk6IHZvaWQge1xuICAgIHRoaXMuc3ViID0gdGhpcy5fd2F0Y2hlci50cmlnZ2VyJC5zdWJzY3JpYmUoKCkgPT4ge1xuICAgICAgdGhpcy5yZXN0YXJ0KCk7XG4gICAgfSk7XG4gIH1cblxuICBvdmVycmlkZSBuZ09uRGVzdHJveSgpOiB2b2lkIHtcbiAgICBzdXBlci5uZ09uRGVzdHJveSgpO1xuICAgIHRoaXMuX3dhdGNoZXIuZGVzdHJveSgpO1xuICB9XG5cbiAgQElucHV0KCdkYnhGaXJlYmFzZUNvbGxlY3Rpb25DaGFuZ2UnKVxuICBnZXQgbW9kZSgpOiBEYnhGaXJlYmFzZUNvbGxlY3Rpb25DaGFuZ2VXYXRjaGVyVHJpZ2dlck1vZGUge1xuICAgIHJldHVybiB0aGlzLl93YXRjaGVyLm1vZGU7XG4gIH1cblxuICBzZXQgbW9kZShtb2RlOiBNYXliZTxEYnhGaXJlYmFzZUNvbGxlY3Rpb25DaGFuZ2VXYXRjaGVyVHJpZ2dlck1vZGUgfCAnJz4pIHtcbiAgICB0aGlzLl93YXRjaGVyLm1vZGUgPSBtb2RlIHx8ICdvZmYnO1xuICB9XG5cbiAgcmVzdGFydCgpIHtcbiAgICB0aGlzLmRieEZpcmViYXNlQ29sbGVjdGlvblN0b3JlRGlyZWN0aXZlLnN0b3JlLnJlc3RhcnQoKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/store/store.collection.mjs

@@ -35,6 +35,7 @@ export class AbstractDbxFirebaseCollectionStore extends LockSetComponentStore {
             itemsPerPage: x.itemsPerPage,
             constraints: x.constraints
         })))), cleanupDestroyable(), distinctUntilChanged(), shareReplay(1));
+        this.constraints$ = this.loader$.pipe(switchMap((x) => x.constraints$));
         this.firestoreIteration$ = this.loader$.pipe(switchMap((x) => x.firestoreIteration$));
         this.queryChangeWatcher$ = this.loader$.pipe(switchMap((x) => x.queryChangeWatcher$));
         this.accumulator$ = this.loader$.pipe(switchMap((x) => x.accumulator$));
@@ -47,4 +48,4 @@ AbstractDbxFirebaseCollectionStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVers
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AbstractDbxFirebaseCollectionStore, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.collection.js","sourceRoot":"","sources":["../../../../../../../packages/dbx-firebase/src/lib/model/store/store.collection.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, shareReplay, distinctUntilChanged, Subscription, exhaustMap, first, map, switchMap, tap } from 'rxjs';\nimport { FirebaseQueryItemAccumulator, FirestoreCollectionLike, FirestoreDocument, FirestoreItemPageIterationInstance, FirestoreQueryConstraint, IterationQueryDocChangeWatcher, DocumentDataWithId } from '@dereekb/firebase';\nimport { ObservableOrValue, cleanupDestroyable, PageListLoadingState, filterMaybe } from '@dereekb/rxjs';\nimport { ArrayOrValue, Maybe } from '@dereekb/util';\nimport { LockSetComponentStore } from '@dereekb/dbx-core';\nimport { DbxFirebaseCollectionLoaderInstance, dbxFirebaseCollectionLoaderInstance, DbxFirebaseCollectionLoaderInstanceData } from '../loader/collection.loader.instance';\n\nexport interface DbxFirebaseCollectionStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends DbxFirebaseCollectionLoaderInstanceData<T, D> {\n  readonly firestoreCollection$: Observable<Maybe<FirestoreCollectionLike<T, D>>>;\n  readonly loader$: Observable<DbxFirebaseCollectionLoaderInstance<T, D>>;\n\n  readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>>;\n  readonly queryChangeWatcher$: Observable<IterationQueryDocChangeWatcher<T>>;\n  readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>>;\n  readonly pageLoadingState$: Observable<PageListLoadingState<DocumentDataWithId<T>>>;\n\n  setMaxPages(observableOrValue: ObservableOrValue<Maybe<number>>): Subscription;\n  setItemsPerPage(observableOrValue: ObservableOrValue<Maybe<number>>): Subscription;\n  setConstraints(observableOrValue: ObservableOrValue<Maybe<ArrayOrValue<FirestoreQueryConstraint>>>): Subscription;\n  next(observableOrValue: ObservableOrValue<void>): void;\n  restart(observableOrValue: ObservableOrValue<void>): void;\n\n  readonly setFirestoreCollection: (() => void) | ((observableOrValue: ObservableOrValue<Maybe<FirestoreCollectionLike<T, D>>>) => Subscription);\n}\n\nexport interface DbxFirebaseCollectionStoreContextState<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {\n  readonly firestoreCollection?: Maybe<FirestoreCollectionLike<T, D>>;\n  readonly maxPages?: Maybe<number>;\n  readonly itemsPerPage?: Maybe<number>;\n  readonly constraints?: Maybe<ArrayOrValue<FirestoreQueryConstraint>>;\n}\n\n/**\n * Used for storing the state of a Person and related email threads.\n */\n@Injectable()\nexport class AbstractDbxFirebaseCollectionStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, C extends DbxFirebaseCollectionStoreContextState<T, D> = DbxFirebaseCollectionStoreContextState<T, D>> extends LockSetComponentStore<C> implements DbxFirebaseCollectionStore<T, D> {\n  // MARK: Effects\n  readonly setMaxPages = this.effect((input: Observable<Maybe<number>>) => {\n    return input.pipe(switchMap((maxPages) => this.loader$.pipe(tap((x) => (x.maxPages = maxPages)))));\n  });\n\n  readonly setItemsPerPage = this.effect((input: Observable<Maybe<number>>) => {\n    return input.pipe(switchMap((itemsPerPage) => this.loader$.pipe(tap((x) => (x.itemsPerPage = itemsPerPage)))));\n  });\n\n  readonly setConstraints = this.effect((input: Observable<Maybe<ArrayOrValue<FirestoreQueryConstraint>>>) => {\n    return input.pipe(switchMap((constraints) => this.loader$.pipe(tap((x) => x.setConstraints(constraints)))));\n  });\n\n  readonly next = this.effect((input: Observable<void>) => {\n    return input.pipe(\n      exhaustMap(() =>\n        this.loader$.pipe(\n          first(),\n          tap((x) => x.next())\n        )\n      )\n    );\n  });\n\n  readonly restart = this.effect((input: Observable<void>) => {\n    return input.pipe(\n      exhaustMap(() =>\n        this.loader$.pipe(\n          first(),\n          tap((x) => x.restart())\n        )\n      )\n    );\n  });\n\n  // MARK: Accessors\n  readonly currentFirestoreCollection$: Observable<Maybe<FirestoreCollectionLike<T, D>>> = this.state$.pipe(\n    map((x) => x.firestoreCollection),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly firestoreCollection$: Observable<FirestoreCollectionLike<T, D>> = this.currentFirestoreCollection$.pipe(filterMaybe());\n\n  readonly loader$: Observable<DbxFirebaseCollectionLoaderInstance<T, D>> = this.currentFirestoreCollection$.pipe(\n    switchMap((collection) =>\n      this.state$.pipe(\n        first(),\n        map((x) =>\n          dbxFirebaseCollectionLoaderInstance({\n            collection,\n            maxPages: x.maxPages,\n            itemsPerPage: x.itemsPerPage,\n            constraints: x.constraints\n          })\n        )\n      )\n    ),\n    cleanupDestroyable(),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>> = this.loader$.pipe(switchMap((x) => x.firestoreIteration$));\n  readonly queryChangeWatcher$: Observable<IterationQueryDocChangeWatcher<T>> = this.loader$.pipe(switchMap((x) => x.queryChangeWatcher$));\n  readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>> = this.loader$.pipe(switchMap((x) => x.accumulator$));\n  readonly pageLoadingState$: Observable<PageListLoadingState<DocumentDataWithId<T>>> = this.loader$.pipe(switchMap((x) => x.pageLoadingState$));\n\n  readonly setFirestoreCollection = this.updater((state, firestoreCollection: FirestoreCollectionLike<T, D> | null | undefined) => ({ ...state, firestoreCollection }));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.collection.js","sourceRoot":"","sources":["../../../../../../../packages/dbx-firebase/src/lib/model/store/store.collection.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, shareReplay, distinctUntilChanged, Subscription, exhaustMap, first, map, switchMap, tap } from 'rxjs';\nimport { FirebaseQueryItemAccumulator, FirestoreCollectionLike, FirestoreDocument, FirestoreItemPageIterationInstance, FirestoreQueryConstraint, IterationQueryDocChangeWatcher, DocumentDataWithId } from '@dereekb/firebase';\nimport { ObservableOrValue, cleanupDestroyable, PageListLoadingState, filterMaybe } from '@dereekb/rxjs';\nimport { ArrayOrValue, Maybe } from '@dereekb/util';\nimport { LockSetComponentStore } from '@dereekb/dbx-core';\nimport { DbxFirebaseCollectionLoaderInstance, dbxFirebaseCollectionLoaderInstance, DbxFirebaseCollectionLoaderInstanceData } from '../loader/collection.loader.instance';\nimport { DbxFirebaseCollectionLoaderAccessor } from '../loader/collection.loader';\n\nexport interface DbxFirebaseCollectionStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends DbxFirebaseCollectionLoaderAccessor<T>, DbxFirebaseCollectionLoaderInstanceData<T, D> {\n  readonly firestoreCollection$: Observable<Maybe<FirestoreCollectionLike<T, D>>>;\n  readonly loader$: Observable<DbxFirebaseCollectionLoaderInstance<T, D>>;\n\n  readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>>;\n  readonly queryChangeWatcher$: Observable<IterationQueryDocChangeWatcher<T>>;\n  readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>>;\n  readonly pageLoadingState$: Observable<PageListLoadingState<DocumentDataWithId<T>>>;\n\n  setMaxPages(observableOrValue: ObservableOrValue<Maybe<number>>): Subscription;\n  setItemsPerPage(observableOrValue: ObservableOrValue<Maybe<number>>): Subscription;\n  setConstraints(observableOrValue: ObservableOrValue<Maybe<ArrayOrValue<FirestoreQueryConstraint>>>): Subscription;\n  next(observableOrValue: ObservableOrValue<void>): void;\n  restart(observableOrValue: ObservableOrValue<void>): void;\n\n  readonly setFirestoreCollection: (() => void) | ((observableOrValue: ObservableOrValue<Maybe<FirestoreCollectionLike<T, D>>>) => Subscription);\n}\n\nexport interface DbxFirebaseCollectionStoreContextState<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {\n  readonly firestoreCollection?: Maybe<FirestoreCollectionLike<T, D>>;\n  readonly maxPages?: Maybe<number>;\n  readonly itemsPerPage?: Maybe<number>;\n  readonly constraints?: Maybe<ArrayOrValue<FirestoreQueryConstraint>>;\n}\n\n/**\n * Used for storing the state of a Person and related email threads.\n */\n@Injectable()\nexport class AbstractDbxFirebaseCollectionStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, C extends DbxFirebaseCollectionStoreContextState<T, D> = DbxFirebaseCollectionStoreContextState<T, D>> extends LockSetComponentStore<C> implements DbxFirebaseCollectionStore<T, D> {\n  // MARK: Effects\n  readonly setMaxPages = this.effect((input: Observable<Maybe<number>>) => {\n    return input.pipe(switchMap((maxPages) => this.loader$.pipe(tap((x) => (x.maxPages = maxPages)))));\n  });\n\n  readonly setItemsPerPage = this.effect((input: Observable<Maybe<number>>) => {\n    return input.pipe(switchMap((itemsPerPage) => this.loader$.pipe(tap((x) => (x.itemsPerPage = itemsPerPage)))));\n  });\n\n  readonly setConstraints = this.effect((input: Observable<Maybe<ArrayOrValue<FirestoreQueryConstraint>>>) => {\n    return input.pipe(switchMap((constraints) => this.loader$.pipe(tap((x) => x.setConstraints(constraints)))));\n  });\n\n  readonly next = this.effect((input: Observable<void>) => {\n    return input.pipe(\n      exhaustMap(() =>\n        this.loader$.pipe(\n          first(),\n          tap((x) => x.next())\n        )\n      )\n    );\n  });\n\n  readonly restart = this.effect((input: Observable<void>) => {\n    return input.pipe(\n      exhaustMap(() =>\n        this.loader$.pipe(\n          first(),\n          tap((x) => x.restart())\n        )\n      )\n    );\n  });\n\n  // MARK: Accessors\n  readonly currentFirestoreCollection$: Observable<Maybe<FirestoreCollectionLike<T, D>>> = this.state$.pipe(\n    map((x) => x.firestoreCollection),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly firestoreCollection$: Observable<FirestoreCollectionLike<T, D>> = this.currentFirestoreCollection$.pipe(filterMaybe());\n\n  readonly loader$: Observable<DbxFirebaseCollectionLoaderInstance<T, D>> = this.currentFirestoreCollection$.pipe(\n    switchMap((collection) =>\n      this.state$.pipe(\n        first(),\n        map((x) =>\n          dbxFirebaseCollectionLoaderInstance({\n            collection,\n            maxPages: x.maxPages,\n            itemsPerPage: x.itemsPerPage,\n            constraints: x.constraints\n          })\n        )\n      )\n    ),\n    cleanupDestroyable(),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly constraints$: Observable<Maybe<ArrayOrValue<FirestoreQueryConstraint>>> = this.loader$.pipe(switchMap((x) => x.constraints$));\n  readonly firestoreIteration$: Observable<FirestoreItemPageIterationInstance<T>> = this.loader$.pipe(switchMap((x) => x.firestoreIteration$));\n  readonly queryChangeWatcher$: Observable<IterationQueryDocChangeWatcher<T>> = this.loader$.pipe(switchMap((x) => x.queryChangeWatcher$));\n  readonly accumulator$: Observable<FirebaseQueryItemAccumulator<T>> = this.loader$.pipe(switchMap((x) => x.accumulator$));\n  readonly pageLoadingState$: Observable<PageListLoadingState<DocumentDataWithId<T>>> = this.loader$.pipe(switchMap((x) => x.pageLoadingState$));\n\n  readonly setFirestoreCollection = this.updater((state, firestoreCollection: FirestoreCollectionLike<T, D> | null | undefined) => ({ ...state, firestoreCollection }));\n}\n"]}

package/esm2020/lib/model/store/store.document.mjs

@@ -1,6 +1,6 @@
 import { Injectable } from '@angular/core';
 import { shareReplay, distinctUntilChanged, map, switchMap, combineLatest, of } from 'rxjs';
-import { documentDataWithId } from '@dereekb/firebase';
+import { documentDataWithId, firestoreModelIdsFromKey, firestoreModelKeyPartPairs, firestoreModelKeyPairObject } from '@dereekb/firebase';
 import { filterMaybe, beginLoading, successResult, loadingStateFromObs, errorResult } from '@dereekb/rxjs';
 import { isMaybeSo } from '@dereekb/util';
 import { LockSetComponentStore } from '@dereekb/dbx-core';
@@ -42,9 +42,12 @@ export class AbstractDbxFirebaseDocumentStore extends LockSetComponentStore {
         }), distinctUntilChanged(), shareReplay(1));
         this.document$ = this.currentDocument$.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));
         this.documentLoadingState$ = this.currentDocument$.pipe(map((x) => (x ? successResult(x) : beginLoading())), shareReplay(1));
-        this.id$ = this.document$.pipe(map((x) => x.id), shareReplay());
-        this.key$ = this.document$.pipe(map((x) => x.key), shareReplay());
-        this.ref$ = this.document$.pipe(map((x) => x.documentRef), shareReplay());
+        this.id$ = this.document$.pipe(map((x) => x.id), shareReplay(1));
+        this.key$ = this.document$.pipe(map((x) => x.key), shareReplay(1));
+        this.keyModelIds$ = this.key$.pipe(map(firestoreModelIdsFromKey), shareReplay(1));
+        this.keyPairs$ = this.key$.pipe(map(firestoreModelKeyPartPairs), filterMaybe(), shareReplay(1));
+        this.keyPairObject$ = this.key$.pipe(map(firestoreModelKeyPairObject), filterMaybe(), shareReplay(1));
+        this.ref$ = this.document$.pipe(map((x) => x.documentRef), shareReplay(1));
         this.snapshot$ = this.document$.pipe(switchMap((x) => x.accessor.stream()), shareReplay(1));
         this.snapshotLoadingState$ = this.currentDocument$.pipe(switchMap(() => loadingStateFromObs(this.snapshot$)), shareReplay(1));
         this.currentData$ = this.document$.pipe(switchMap((x) => x.accessor.stream().pipe(map((y) => documentDataWithId(y)))), shareReplay(1));
@@ -75,15 +78,15 @@ export class AbstractDbxFirebaseDocumentStore extends LockSetComponentStore {
         /**
          * Sets the id of the document to load.
          */
-        this.setId = this.updater((state, id) => (id ? { ...state, id, ref: undefined } : { ...state, id }));
+        this.setId = this.updater((state, id) => (id ? { ...state, id, key: undefined, ref: undefined } : { ...state, id }));
         /**
          * Sets the key of the document to load.
          */
-        this.setKey = this.updater((state, key) => (key ? { ...state, key, ref: undefined } : { ...state, key }));
+        this.setKey = this.updater((state, key) => (key ? { ...state, key, id: undefined, ref: undefined } : { ...state, key }));
         /**
          * Sets the ref of the document to load.
          */
-        this.setRef = this.updater((state, ref) => (ref ? { ...state, id: undefined, ref } : { ...state, ref }));
+        this.setRef = this.updater((state, ref) => (ref ? { ...state, key: undefined, id: undefined, ref } : { ...state, ref }));
         this.clearRefs = this.updater((state) => ({ ...state, id: undefined, key: undefined, ref: undefined }));
         this.setFirestoreCollection = this.updater((state, firestoreCollection) => ({ ...state, firestoreCollection }));
         this.setFirestoreCollectionLike = this.updater((state, firestoreCollectionLike) => ({ ...state, firestoreCollectionLike }));
@@ -94,4 +97,4 @@ AbstractDbxFirebaseDocumentStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersio
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: AbstractDbxFirebaseDocumentStore, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.document.js","sourceRoot":"","sources":["../../../../../../../packages/dbx-firebase/src/lib/model/store/store.document.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, shareReplay, distinctUntilChanged, map, switchMap, combineLatest, Subscription, of } from 'rxjs';\nimport { DocumentSnapshot, DocumentReference, FirestoreCollection, FirestoreDocument, documentDataWithId, DocumentDataWithId, FirestoreModelId, FirestoreModelKey, FirestoreCollectionLike, FirestoreModelIdentity } from '@dereekb/firebase';\nimport { filterMaybe, LoadingState, beginLoading, successResult, loadingStateFromObs, errorResult, ObservableOrValue } from '@dereekb/rxjs';\nimport { Maybe, isMaybeSo } from '@dereekb/util';\nimport { LockSetComponent, LockSetComponentStore } from '@dereekb/dbx-core';\nimport { modelDoesNotExistError } from '../error';\n\nexport interface DbxFirebaseDocumentStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends LockSetComponent {\n  readonly firestoreCollectionLike$: Observable<FirestoreCollectionLike<T, D>>;\n  readonly firestoreCollection$: Observable<FirestoreCollection<T, D>>;\n\n  readonly currentInputId$: Observable<Maybe<FirestoreModelId>>;\n  readonly inputId$: Observable<FirestoreModelId>;\n  readonly currentInputKey$: Observable<Maybe<FirestoreModelKey>>;\n  readonly inputKey$: Observable<FirestoreModelKey>;\n  readonly currentInputRef$: Observable<Maybe<DocumentReference<T>>>;\n  readonly inputRef$: Observable<DocumentReference<T>>;\n\n  readonly currentDocument$: Observable<Maybe<D>>;\n  readonly document$: Observable<D>;\n  readonly id$: Observable<FirestoreModelId>;\n  readonly key$: Observable<FirestoreModelKey>;\n  readonly ref$: Observable<DocumentReference<T>>;\n  readonly documentLoadingState$: Observable<LoadingState<D>>;\n  readonly snapshot$: Observable<DocumentSnapshot<T>>;\n  readonly snapshotLoadingState$: Observable<LoadingState<DocumentSnapshot<T>>>;\n  readonly currentData$: Observable<Maybe<DocumentDataWithId<T>>>;\n  readonly data$: Observable<DocumentDataWithId<T>>;\n  readonly dataLoadingState$: Observable<LoadingState<DocumentDataWithId<T>>>;\n  readonly exists$: Observable<boolean>;\n  readonly modelIdentity$: Observable<FirestoreModelIdentity>;\n\n  setId: (observableOrValue: ObservableOrValue<Maybe<FirestoreModelId>>) => Subscription;\n  setKey: (observableOrValue: ObservableOrValue<Maybe<FirestoreModelKey>>) => Subscription;\n  setRef: (observableOrValue: ObservableOrValue<Maybe<DocumentReference<T>>>) => Subscription;\n\n  /**\n   * Clears the key/id/ref and current document from the store.\n   */\n  clearRefs: () => void;\n\n  /**\n   * Sets the FirestoreCollection to retrieve documents from.\n   */\n  readonly setFirestoreCollection: (() => void) | ((observableOrValue: ObservableOrValue<Maybe<FirestoreCollection<T, D>>>) => Subscription);\n\n  /**\n   * Sets the FirestoreCollectionLike to retrieve documents from.\n   */\n  readonly setFirestoreCollectionLike: (() => void) | ((observableOrValue: ObservableOrValue<Maybe<FirestoreCollectionLike<T, D>>>) => Subscription);\n}\n\nexport interface DbxFirebaseDocumentStoreContextState<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {\n  readonly firestoreCollectionLike?: Maybe<FirestoreCollectionLike<T, D>>;\n  readonly firestoreCollection?: Maybe<FirestoreCollection<T, D>>;\n  readonly id?: Maybe<FirestoreModelId>;\n  readonly key?: Maybe<FirestoreModelKey>;\n  readonly ref?: Maybe<DocumentReference<T>>;\n}\n\n/**\n * Used for storing the state of a Person and related email threads.\n */\n@Injectable()\nexport class AbstractDbxFirebaseDocumentStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, C extends DbxFirebaseDocumentStoreContextState<T, D> = DbxFirebaseDocumentStoreContextState<T, D>> extends LockSetComponentStore<C> implements DbxFirebaseDocumentStore<T, D> {\n  // MARK: Effects\n\n  // MARK: Accessors\n  readonly currentFirestoreCollectionLike$: Observable<Maybe<FirestoreCollectionLike<T, D>>> = this.state$.pipe(\n    map((x) => x.firestoreCollection ?? x.firestoreCollectionLike),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly currentFirestoreCollection$: Observable<Maybe<FirestoreCollection<T, D>>> = this.state$.pipe(\n    map((x) => x.firestoreCollection),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly firestoreCollectionLike$: Observable<FirestoreCollectionLike<T, D>> = this.currentFirestoreCollectionLike$.pipe(filterMaybe());\n  readonly firestoreCollection$: Observable<FirestoreCollection<T, D>> = this.currentFirestoreCollection$.pipe(filterMaybe());\n\n  readonly currentInputId$: Observable<Maybe<FirestoreModelId>> = this.state$.pipe(\n    map((x) => x.id),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly inputId$: Observable<FirestoreModelId> = this.currentInputId$.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));\n\n  readonly currentInputKey$: Observable<Maybe<FirestoreModelKey>> = this.state$.pipe(\n    map((x) => x.key),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly inputKey$: Observable<FirestoreModelKey> = this.currentInputKey$.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));\n\n  readonly currentInputRef$: Observable<Maybe<DocumentReference<T>>> = this.state$.pipe(\n    map((x) => x.ref),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly inputRef$: Observable<DocumentReference<T>> = this.currentInputRef$.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));\n\n  readonly currentDocument$: Observable<Maybe<D>> = combineLatest([this.currentInputId$, this.currentInputKey$, this.currentInputRef$]).pipe(\n    switchMap(([id, key, ref]) => {\n      let document: Observable<Maybe<D>>;\n\n      if (ref) {\n        document = this.firestoreCollectionLike$.pipe(map((x) => x.documentAccessor().loadDocument(ref)));\n      } else if (key) {\n        document = this.firestoreCollectionLike$.pipe(map((x) => x.documentAccessor().loadDocumentForKey(key)));\n      } else if (id) {\n        document = this.firestoreCollection$.pipe(map((x) => x.documentAccessor().loadDocumentForId(id)));\n      } else {\n        document = of(undefined);\n      }\n\n      return document;\n    }),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly document$: Observable<D> = this.currentDocument$.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));\n\n  readonly documentLoadingState$: Observable<LoadingState<D>> = this.currentDocument$.pipe(\n    map((x) => (x ? successResult(x) : beginLoading<D>())),\n    shareReplay(1)\n  );\n\n  readonly id$: Observable<FirestoreModelId> = this.document$.pipe(\n    map((x) => x.id),\n    shareReplay()\n  );\n\n  readonly key$: Observable<FirestoreModelKey> = this.document$.pipe(\n    map((x) => x.key),\n    shareReplay()\n  );\n\n  readonly ref$: Observable<DocumentReference<T>> = this.document$.pipe(\n    map((x) => x.documentRef),\n    shareReplay()\n  );\n\n  readonly snapshot$: Observable<DocumentSnapshot<T>> = this.document$.pipe(\n    switchMap((x) => x.accessor.stream()),\n    shareReplay(1)\n  );\n\n  readonly snapshotLoadingState$: Observable<LoadingState<DocumentSnapshot<T>>> = this.currentDocument$.pipe(\n    switchMap(() => loadingStateFromObs(this.snapshot$)),\n    shareReplay(1)\n  );\n\n  readonly currentData$: Observable<Maybe<DocumentDataWithId<T>>> = this.document$.pipe(\n    switchMap((x) => x.accessor.stream().pipe(map((y) => documentDataWithId(y)))),\n    shareReplay(1)\n  );\n\n  readonly data$: Observable<DocumentDataWithId<T>> = this.currentDocument$.pipe(\n    switchMap(() => this.currentData$.pipe(filterMaybe())),\n    shareReplay(1)\n  );\n\n  readonly dataLoadingState$: Observable<LoadingState<DocumentDataWithId<T>>> = this.snapshotLoadingState$.pipe(\n    map((x) => {\n      let result: LoadingState<DocumentDataWithId<T>>;\n\n      if (x.value) {\n        const data = documentDataWithId(x.value);\n\n        if (data) {\n          result = successResult(data);\n        } else {\n          result = errorResult(modelDoesNotExistError());\n        }\n      } else {\n        result = {\n          ...x,\n          value: undefined\n        };\n      }\n\n      return result;\n    }),\n    shareReplay(1)\n  );\n\n  readonly exists$: Observable<boolean> = this.currentData$.pipe(\n    map((x) => isMaybeSo(x)),\n    shareReplay(1)\n  );\n\n  readonly doesNotExist$: Observable<boolean> = this.exists$.pipe(\n    map((x) => !x),\n    shareReplay(1)\n  );\n\n  readonly modelIdentity$: Observable<FirestoreModelIdentity> = this.document$.pipe(\n    map((x) => x.modelIdentity),\n    shareReplay(1)\n  );\n\n  // MARK: State Changes\n  /**\n   * Sets the id of the document to load.\n   */\n  readonly setId = this.updater((state, id: Maybe<FirestoreModelId>) => (id ? { ...state, id, ref: undefined } : { ...state, id })) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\n\n  /**\n   * Sets the key of the document to load.\n   */\n  readonly setKey = this.updater((state, key: Maybe<FirestoreModelKey>) => (key ? { ...state, key, ref: undefined } : { ...state, key })) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\n\n  /**\n   * Sets the ref of the document to load.\n   */\n  readonly setRef = this.updater((state, ref: Maybe<DocumentReference<T>>) => (ref ? { ...state, id: undefined, ref } : { ...state, ref })) as (observableOrValue: Maybe<DocumentReference<T>> | Observable<Maybe<DocumentReference<T>>>) => Subscription;\n\n  readonly clearRefs = this.updater((state) => ({ ...state, id: undefined, key: undefined, ref: undefined }));\n\n  readonly setFirestoreCollection = this.updater((state, firestoreCollection: Maybe<FirestoreCollection<T, D>>) => ({ ...state, firestoreCollection }));\n  readonly setFirestoreCollectionLike = this.updater((state, firestoreCollectionLike: Maybe<FirestoreCollectionLike<T, D>>) => ({ ...state, firestoreCollectionLike }));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.document.js","sourceRoot":"","sources":["../../../../../../../packages/dbx-firebase/src/lib/model/store/store.document.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, shareReplay, distinctUntilChanged, map, switchMap, combineLatest, Subscription, of } from 'rxjs';\nimport { DocumentSnapshot, DocumentReference, FirestoreCollection, FirestoreDocument, documentDataWithId, DocumentDataWithId, FirestoreModelId, FirestoreModelKey, FirestoreCollectionLike, FirestoreModelIdentity, firestoreModelIdsFromKey, firestoreModelKeyPartPairs, FirestoreModelCollectionAndIdPair, firestoreModelKeyPairObject, FirestoreModelKeyPairObject } from '@dereekb/firebase';\nimport { filterMaybe, LoadingState, beginLoading, successResult, loadingStateFromObs, errorResult, ObservableOrValue } from '@dereekb/rxjs';\nimport { Maybe, isMaybeSo } from '@dereekb/util';\nimport { LockSetComponent, LockSetComponentStore } from '@dereekb/dbx-core';\nimport { modelDoesNotExistError } from '../error';\n\nexport interface DbxFirebaseDocumentStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> extends LockSetComponent {\n  readonly firestoreCollectionLike$: Observable<FirestoreCollectionLike<T, D>>;\n  readonly firestoreCollection$: Observable<FirestoreCollection<T, D>>;\n\n  readonly currentInputId$: Observable<Maybe<FirestoreModelId>>;\n  readonly inputId$: Observable<FirestoreModelId>;\n  readonly currentInputKey$: Observable<Maybe<FirestoreModelKey>>;\n  readonly inputKey$: Observable<FirestoreModelKey>;\n  readonly currentInputRef$: Observable<Maybe<DocumentReference<T>>>;\n  readonly inputRef$: Observable<DocumentReference<T>>;\n\n  readonly currentDocument$: Observable<Maybe<D>>;\n  readonly document$: Observable<D>;\n  readonly id$: Observable<FirestoreModelId>;\n  readonly key$: Observable<FirestoreModelKey>;\n  readonly ref$: Observable<DocumentReference<T>>;\n\n  readonly keyModelIds$: Observable<FirestoreModelId[]>;\n  readonly keyPairs$: Observable<FirestoreModelCollectionAndIdPair[]>;\n  readonly keyPairObject$: Observable<FirestoreModelKeyPairObject>;\n\n  readonly documentLoadingState$: Observable<LoadingState<D>>;\n  readonly snapshot$: Observable<DocumentSnapshot<T>>;\n  readonly snapshotLoadingState$: Observable<LoadingState<DocumentSnapshot<T>>>;\n  readonly currentData$: Observable<Maybe<DocumentDataWithId<T>>>;\n  readonly data$: Observable<DocumentDataWithId<T>>;\n  readonly dataLoadingState$: Observable<LoadingState<DocumentDataWithId<T>>>;\n  readonly exists$: Observable<boolean>;\n  readonly modelIdentity$: Observable<FirestoreModelIdentity>;\n\n  setId: (observableOrValue: ObservableOrValue<Maybe<FirestoreModelId>>) => Subscription;\n  setKey: (observableOrValue: ObservableOrValue<Maybe<FirestoreModelKey>>) => Subscription;\n  setRef: (observableOrValue: ObservableOrValue<Maybe<DocumentReference<T>>>) => Subscription;\n\n  /**\n   * Clears the key/id/ref and current document from the store.\n   */\n  clearRefs: () => void;\n\n  /**\n   * Sets the FirestoreCollection to retrieve documents from.\n   */\n  readonly setFirestoreCollection: (() => void) | ((observableOrValue: ObservableOrValue<Maybe<FirestoreCollection<T, D>>>) => Subscription);\n\n  /**\n   * Sets the FirestoreCollectionLike to retrieve documents from.\n   */\n  readonly setFirestoreCollectionLike: (() => void) | ((observableOrValue: ObservableOrValue<Maybe<FirestoreCollectionLike<T, D>>>) => Subscription);\n}\n\nexport interface DbxFirebaseDocumentStoreContextState<T, D extends FirestoreDocument<T> = FirestoreDocument<T>> {\n  readonly firestoreCollectionLike?: Maybe<FirestoreCollectionLike<T, D>>;\n  readonly firestoreCollection?: Maybe<FirestoreCollection<T, D>>;\n  readonly id?: Maybe<FirestoreModelId>;\n  readonly key?: Maybe<FirestoreModelKey>;\n  readonly ref?: Maybe<DocumentReference<T>>;\n}\n\n/**\n * Used for storing the state of a Person and related email threads.\n */\n@Injectable()\nexport class AbstractDbxFirebaseDocumentStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, C extends DbxFirebaseDocumentStoreContextState<T, D> = DbxFirebaseDocumentStoreContextState<T, D>> extends LockSetComponentStore<C> implements DbxFirebaseDocumentStore<T, D> {\n  // MARK: Effects\n\n  // MARK: Accessors\n  readonly currentFirestoreCollectionLike$: Observable<Maybe<FirestoreCollectionLike<T, D>>> = this.state$.pipe(\n    map((x) => x.firestoreCollection ?? x.firestoreCollectionLike),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly currentFirestoreCollection$: Observable<Maybe<FirestoreCollection<T, D>>> = this.state$.pipe(\n    map((x) => x.firestoreCollection),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly firestoreCollectionLike$: Observable<FirestoreCollectionLike<T, D>> = this.currentFirestoreCollectionLike$.pipe(filterMaybe());\n  readonly firestoreCollection$: Observable<FirestoreCollection<T, D>> = this.currentFirestoreCollection$.pipe(filterMaybe());\n\n  readonly currentInputId$: Observable<Maybe<FirestoreModelId>> = this.state$.pipe(\n    map((x) => x.id),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly inputId$: Observable<FirestoreModelId> = this.currentInputId$.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));\n\n  readonly currentInputKey$: Observable<Maybe<FirestoreModelKey>> = this.state$.pipe(\n    map((x) => x.key),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly inputKey$: Observable<FirestoreModelKey> = this.currentInputKey$.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));\n\n  readonly currentInputRef$: Observable<Maybe<DocumentReference<T>>> = this.state$.pipe(\n    map((x) => x.ref),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly inputRef$: Observable<DocumentReference<T>> = this.currentInputRef$.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));\n\n  readonly currentDocument$: Observable<Maybe<D>> = combineLatest([this.currentInputId$, this.currentInputKey$, this.currentInputRef$]).pipe(\n    switchMap(([id, key, ref]) => {\n      let document: Observable<Maybe<D>>;\n\n      if (ref) {\n        document = this.firestoreCollectionLike$.pipe(map((x) => x.documentAccessor().loadDocument(ref)));\n      } else if (key) {\n        document = this.firestoreCollectionLike$.pipe(map((x) => x.documentAccessor().loadDocumentForKey(key)));\n      } else if (id) {\n        document = this.firestoreCollection$.pipe(map((x) => x.documentAccessor().loadDocumentForId(id)));\n      } else {\n        document = of(undefined);\n      }\n\n      return document;\n    }),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly document$: Observable<D> = this.currentDocument$.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));\n\n  readonly documentLoadingState$: Observable<LoadingState<D>> = this.currentDocument$.pipe(\n    map((x) => (x ? successResult(x) : beginLoading<D>())),\n    shareReplay(1)\n  );\n\n  readonly id$: Observable<FirestoreModelId> = this.document$.pipe(\n    map((x) => x.id),\n    shareReplay(1)\n  );\n\n  readonly key$: Observable<FirestoreModelKey> = this.document$.pipe(\n    map((x) => x.key),\n    shareReplay(1)\n  );\n\n  readonly keyModelIds$: Observable<FirestoreModelId[]> = this.key$.pipe(map(firestoreModelIdsFromKey), shareReplay(1));\n  readonly keyPairs$: Observable<FirestoreModelCollectionAndIdPair[]> = this.key$.pipe(map(firestoreModelKeyPartPairs), filterMaybe(), shareReplay(1));\n  readonly keyPairObject$: Observable<FirestoreModelKeyPairObject> = this.key$.pipe(map(firestoreModelKeyPairObject), filterMaybe(), shareReplay(1));\n\n  readonly ref$: Observable<DocumentReference<T>> = this.document$.pipe(\n    map((x) => x.documentRef),\n    shareReplay(1)\n  );\n\n  readonly snapshot$: Observable<DocumentSnapshot<T>> = this.document$.pipe(\n    switchMap((x) => x.accessor.stream()),\n    shareReplay(1)\n  );\n\n  readonly snapshotLoadingState$: Observable<LoadingState<DocumentSnapshot<T>>> = this.currentDocument$.pipe(\n    switchMap(() => loadingStateFromObs(this.snapshot$)),\n    shareReplay(1)\n  );\n\n  readonly currentData$: Observable<Maybe<DocumentDataWithId<T>>> = this.document$.pipe(\n    switchMap((x) => x.accessor.stream().pipe(map((y) => documentDataWithId(y)))),\n    shareReplay(1)\n  );\n\n  readonly data$: Observable<DocumentDataWithId<T>> = this.currentDocument$.pipe(\n    switchMap(() => this.currentData$.pipe(filterMaybe())),\n    shareReplay(1)\n  );\n\n  readonly dataLoadingState$: Observable<LoadingState<DocumentDataWithId<T>>> = this.snapshotLoadingState$.pipe(\n    map((x) => {\n      let result: LoadingState<DocumentDataWithId<T>>;\n\n      if (x.value) {\n        const data = documentDataWithId(x.value);\n\n        if (data) {\n          result = successResult(data);\n        } else {\n          result = errorResult(modelDoesNotExistError());\n        }\n      } else {\n        result = {\n          ...x,\n          value: undefined\n        };\n      }\n\n      return result;\n    }),\n    shareReplay(1)\n  );\n\n  readonly exists$: Observable<boolean> = this.currentData$.pipe(\n    map((x) => isMaybeSo(x)),\n    shareReplay(1)\n  );\n\n  readonly doesNotExist$: Observable<boolean> = this.exists$.pipe(\n    map((x) => !x),\n    shareReplay(1)\n  );\n\n  readonly modelIdentity$: Observable<FirestoreModelIdentity> = this.document$.pipe(\n    map((x) => x.modelIdentity),\n    shareReplay(1)\n  );\n\n  // MARK: State Changes\n  /**\n   * Sets the id of the document to load.\n   */\n  readonly setId = this.updater((state, id: Maybe<FirestoreModelId>) => (id ? { ...state, id, key: undefined, ref: undefined } : { ...state, id })) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\n\n  /**\n   * Sets the key of the document to load.\n   */\n  readonly setKey = this.updater((state, key: Maybe<FirestoreModelKey>) => (key ? { ...state, key, id: undefined, ref: undefined } : { ...state, key })) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\n\n  /**\n   * Sets the ref of the document to load.\n   */\n  readonly setRef = this.updater((state, ref: Maybe<DocumentReference<T>>) => (ref ? { ...state, key: undefined, id: undefined, ref } : { ...state, ref })) as (observableOrValue: Maybe<DocumentReference<T>> | Observable<Maybe<DocumentReference<T>>>) => Subscription;\n\n  readonly clearRefs = this.updater((state) => ({ ...state, id: undefined, key: undefined, ref: undefined }));\n\n  readonly setFirestoreCollection = this.updater((state, firestoreCollection: Maybe<FirestoreCollection<T, D>>) => ({ ...state, firestoreCollection }));\n  readonly setFirestoreCollectionLike = this.updater((state, firestoreCollectionLike: Maybe<FirestoreCollectionLike<T, D>>) => ({ ...state, firestoreCollectionLike }));\n}\n"]}