@dereekb/dbx-firebase 12.6.10 → 12.6.12

package/esm2022/lib/model/modules/store/store.document.context.store.mjs

@@ -0,0 +1,86 @@
+import { Injectable } from '@angular/core';
+import { ComponentStore } from '@ngrx/component-store';
+import { separateValues, sortByNumberFunction } from '@dereekb/util';
+import { combineLatest, distinctUntilChanged, first, map, of, shareReplay, switchMap } from 'rxjs';
+import { isSameDate } from '@dereekb/date';
+import * as i0 from "@angular/core";
+export class DbxFirebaseDocumentStoreContextStore extends ComponentStore {
+    constructor() {
+        super({
+            nextEntryNumber: 0,
+            currentEntryCount: 0,
+            stores: new Map(),
+            lastStoresChangeAt: new Date()
+        });
+    }
+    // MARK: Accessors
+    stores$ = this.select((state) => [state.stores, state.currentEntryCount, state.nextEntryNumber], {
+        debounce: true, // NOTE: The addStore/removeStore functions use the same map, so we overload the equal function to properly trigger changes to the map.
+        equal: (a, b) => a[1] === b[1] && a[2] === b[2] // only considered different if the nextEntryNumber changes
+    }).pipe(map((x) => x[0]), shareReplay(1));
+    lastStoresChangeAt$ = this.select((state) => state.lastStoresChangeAt).pipe(distinctUntilChanged(isSameDate), shareReplay(1));
+    entriesGroupedByIdentity$ = this.stores$.pipe(switchMap((stores) => {
+        let entriesObs;
+        const allEntries = Array.from(stores.values());
+        const { included: hasIdentity, excluded: noIdentity } = separateValues(allEntries, (x) => x.modelIdentity != null);
+        if (noIdentity.length > 0) {
+            entriesObs = combineLatest(noIdentity.map((entryWithoutCachedIdentity) => entryWithoutCachedIdentity.store.modelIdentity$.pipe(first(), map((z) => {
+                // set the model identity on the entry
+                entryWithoutCachedIdentity.modelIdentity = z;
+                // return the entry
+                return entryWithoutCachedIdentity;
+            })))).pipe(map(() => {
+                return allEntries; // all the entries should have an identity now
+            }));
+        }
+        else {
+            entriesObs = of(hasIdentity);
+        }
+        return entriesObs;
+    }), map((x) => {
+        // sort in ascending order by entry number
+        x.sort(sortByNumberFunction((x) => x.entryNumber));
+        return x;
+    }), shareReplay(1));
+    // MARK: State Changes
+    addStore = this.updater(addStore);
+    removeStore = this.updater(removeStore);
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseDocumentStoreContextStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseDocumentStoreContextStore });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DbxFirebaseDocumentStoreContextStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+function addStore(state, store) {
+    const { stores, nextEntryNumber } = state;
+    let nextState;
+    if (stores.has(store)) {
+        nextState = state;
+    }
+    else {
+        // add the entry
+        const entry = {
+            store,
+            entryNumber: nextEntryNumber
+        };
+        stores.set(store, entry);
+        // update the last changed date
+        nextState = { ...state, currentEntryCount: state.currentEntryCount + 1, lastStoresChangeAt: new Date(), nextEntryNumber: nextEntryNumber + 1 };
+    }
+    return nextState;
+}
+function removeStore(state, store) {
+    const { stores } = state;
+    let nextState;
+    if (!stores.has(store)) {
+        nextState = state;
+    }
+    else {
+        // remove the entry
+        stores.delete(store);
+        // update the last changed date
+        nextState = { ...state, currentEntryCount: state.currentEntryCount - 1, lastStoresChangeAt: new Date() };
+    }
+    return nextState;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.document.context.store.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/model/modules/store/store.document.context.store.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ComponentStore } from '@ngrx/component-store';\nimport { DbxFirebaseDocumentStore } from './store';\nimport { FirestoreModelIdentity } from '@dereekb/firebase';\nimport { Configurable, Maybe, separateValues, sortByNumberFunction } from '@dereekb/util';\nimport { combineLatest, distinctUntilChanged, first, map, Observable, of, shareReplay, switchMap } from 'rxjs';\nimport { isSameDate } from '@dereekb/date';\n\n/**\n * A unique number for a store entry.\n */\nexport type DbxFirebaseDocumentStoreContextStoreEntryNumber = number;\n\n/**\n * A specifiy entry in the store.\n *\n * Used for caching information about a specific store.\n */\nexport interface DbxFirebaseDocumentStoreContextStoreEntry {\n  /**\n   * The number the entry was assigned when added to the store.\n   */\n  readonly entryNumber: DbxFirebaseDocumentStoreContextStoreEntryNumber;\n  /**\n   * The referenced document store.\n   */\n  readonly store: DbxFirebaseDocumentStore<unknown>;\n\n  // Cached Values\n  readonly modelIdentity?: Maybe<FirestoreModelIdentity>;\n}\n\nexport interface DbxFirebaseDocumentStoreContextStoreEntryWithIdentity extends Omit<DbxFirebaseDocumentStoreContextStoreEntry, 'modelIdentity'> {\n  readonly modelIdentity: FirestoreModelIdentity;\n}\n\nexport interface DbxFirebaseDocumentStoreContextStoreState {\n  /**\n   * The next entry number to use for a new store.\n   */\n  readonly nextEntryNumber: DbxFirebaseDocumentStoreContextStoreEntryNumber;\n  /**\n   * The current number of entries\n   */\n  readonly currentEntryCount: number;\n  /**\n   * The map of all current stores.\n   *\n   * The map uses the store as the key for it's corresponding entry that contains additional information about the store.\n   */\n  readonly stores: Map<DbxFirebaseDocumentStore<unknown>, DbxFirebaseDocumentStoreContextStoreEntry>;\n  /**\n   * The last time the stores map was changed.\n   */\n  readonly lastStoresChangeAt: Date;\n}\n\n@Injectable()\nexport class DbxFirebaseDocumentStoreContextStore extends ComponentStore<DbxFirebaseDocumentStoreContextStoreState> {\n  constructor() {\n    super({\n      nextEntryNumber: 0,\n      currentEntryCount: 0,\n      stores: new Map(),\n      lastStoresChangeAt: new Date()\n    });\n  }\n\n  // MARK: Accessors\n  readonly stores$ = this.select((state) => [state.stores, state.currentEntryCount, state.nextEntryNumber] as const, {\n    debounce: true, // NOTE: The addStore/removeStore functions use the same map, so we overload the equal function to properly trigger changes to the map.\n    equal: (a, b) => a[1] === b[1] && a[2] === b[2] // only considered different if the nextEntryNumber changes\n  }).pipe(\n    map((x) => x[0]),\n    shareReplay(1)\n  );\n\n  readonly lastStoresChangeAt$ = this.select((state) => state.lastStoresChangeAt).pipe(distinctUntilChanged(isSameDate), shareReplay(1));\n\n  readonly entriesGroupedByIdentity$: Observable<DbxFirebaseDocumentStoreContextStoreEntryWithIdentity[]> = this.stores$.pipe(\n    switchMap((stores) => {\n      let entriesObs: Observable<DbxFirebaseDocumentStoreContextStoreEntryWithIdentity[]>;\n\n      const allEntries = Array.from(stores.values());\n\n      const { included: hasIdentity, excluded: noIdentity } = separateValues(allEntries, (x) => x.modelIdentity != null);\n\n      if (noIdentity.length > 0) {\n        entriesObs = combineLatest(\n          noIdentity.map((entryWithoutCachedIdentity) =>\n            entryWithoutCachedIdentity.store.modelIdentity$.pipe(\n              first(),\n              map((z) => {\n                // set the model identity on the entry\n                (entryWithoutCachedIdentity as Configurable<DbxFirebaseDocumentStoreContextStoreEntryWithIdentity>).modelIdentity = z;\n                // return the entry\n                return entryWithoutCachedIdentity;\n              })\n            )\n          )\n        ).pipe(\n          map(() => {\n            return allEntries as DbxFirebaseDocumentStoreContextStoreEntryWithIdentity[]; // all the entries should have an identity now\n          })\n        );\n      } else {\n        entriesObs = of(hasIdentity as DbxFirebaseDocumentStoreContextStoreEntryWithIdentity[]);\n      }\n\n      return entriesObs;\n    }),\n    map((x) => {\n      // sort in ascending order by entry number\n      x.sort(sortByNumberFunction((x) => x.entryNumber));\n\n      return x;\n    }),\n    shareReplay(1)\n  );\n\n  // MARK: State Changes\n  readonly addStore = this.updater(addStore);\n  readonly removeStore = this.updater(removeStore);\n}\n\nfunction addStore(state: DbxFirebaseDocumentStoreContextStoreState, store: DbxFirebaseDocumentStore<unknown>) {\n  const { stores, nextEntryNumber } = state;\n\n  let nextState: DbxFirebaseDocumentStoreContextStoreState;\n\n  if (stores.has(store)) {\n    nextState = state;\n  } else {\n    // add the entry\n    const entry: Configurable<DbxFirebaseDocumentStoreContextStoreEntry> = {\n      store,\n      entryNumber: nextEntryNumber\n    };\n\n    stores.set(store, entry);\n\n    // update the last changed date\n    nextState = { ...state, currentEntryCount: state.currentEntryCount + 1, lastStoresChangeAt: new Date(), nextEntryNumber: nextEntryNumber + 1 };\n  }\n\n  return nextState;\n}\n\nfunction removeStore(state: DbxFirebaseDocumentStoreContextStoreState, store: DbxFirebaseDocumentStore<unknown>) {\n  const { stores } = state;\n\n  let nextState: DbxFirebaseDocumentStoreContextStoreState;\n\n  if (!stores.has(store)) {\n    nextState = state;\n  } else {\n    // remove the entry\n    stores.delete(store);\n\n    // update the last changed date\n    nextState = { ...state, currentEntryCount: state.currentEntryCount - 1, lastStoresChangeAt: new Date() };\n  }\n\n  return nextState;\n}\n"]}

package/esm2022/lib/model/modules/store/store.document.crud.mjs

@@ -77,4 +77,4 @@ export function firebaseDocumentStoreDeleteFunction(store, fn) {
         return result;
     })), shareReplay(1)));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.document.crud.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/model/modules/store/store.document.crud.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAqB,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACjF,OAAO,EAAE,UAAU,EAAsB,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAmB,MAAM,MAAM,CAAC;AAM7E;;;;;;GAMG;AACH,MAAM,UAAU,mCAAmC,CAAiE,KAAyC,EAAE,EAAqC;IAClM,OAAO,CAAC,MAAS,EAAE,EAAE,CACnB,mBAAmB,CACjB,QAAQ,CAAC,GAAG,EAAE,CACZ,EAAE,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;QACzB,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QACnC,MAAM,QAAQ,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC;QAEvC,IAAI,QAAQ,EAAE,CAAC;YACb,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACzB,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC,CACH,CACF,CAAC;AACN,CAAC;AAID;;;;;GAKG;AACH,MAAM,UAAU,iCAAiC,CAAc,EAAmC;IAChG,OAAO,CAAC,MAAS,EAAE,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACnF,CAAC;AAcD,aAAa;AACb;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iCAAiC,CAAsD,KAAyC,EAAE,EAAmC;IACnL,OAAO,mCAAmC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;AACxD,CAAC;AAED,eAAe;AACf;;;;;;;;GAQG;AACH,MAAM,UAAU,mCAAmC,CAA6D,KAAyC,EAAE,EAAqC;IAC9L,OAAO,CAAC,MAAsD,EAAE,EAAE,CAChE,mBAAmB,CACjB,KAAK,CAAC,IAAI,CAAC,IAAI,CACb,KAAK,EAAE,EACP,UAAU,CAAC,CAAC,GAAG,EAAE,EAAE,CACjB,EAAE,CAAC;QACD,GAAG,MAAM;QACT,GAAG,CAAC,kCAAkC;KAClC,CAAC,CACR,EACD,WAAW,CAAC,CAAC,CAAC,CACf,CACF,CAAC;AACN,CAAC;AAED,eAAe;AACf;;;;;;;;GAQG;AACH,MAAM,UAAU,mCAAmC,CAA6D,KAAyC,EAAE,EAAqC;IAC9L,OAAO,CAAC,MAAsD,EAAE,EAAE,CAChE,mBAAmB,CACjB,KAAK,CAAC,IAAI,CAAC,IAAI,CACb,KAAK,EAAE,EACP,UAAU,CAAC,CAAC,GAAG,EAAE,EAAE,CACjB,EAAE,CAAC;QACD,GAAG,MAAM;QACT,GAAG,CAAC,kCAAkC;KAClC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;QACtB,KAAK,CAAC,SAAS,EAAE,CAAC;QAClB,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC,CACH,EACD,WAAW,CAAC,CAAC,CAAC,CACf,CACF,CAAC;AACN,CAAC","sourcesContent":["import { type ModelFirebaseCreateFunction, type ModelFirebaseDeleteFunction, type ModelFirebaseUpdateFunction, type OnCallCreateModelResult, type TargetModelParams, type InferredTargetModelParams, type ModelFirebaseCrudFunction, type ModelFirebaseReadFunction } from '@dereekb/firebase';\nimport { lazyFrom, type LoadingState, loadingStateFromObs } from '@dereekb/rxjs';\nimport { firstValue, type PartialOnKeys } from '@dereekb/util';\nimport { shareReplay, exhaustMap, first, from, type Observable } from 'rxjs';\nimport { type DbxFirebaseDocumentStore } from './store.document';\n\n// MARK: Create\nexport type DbxFirebaseDocumentStoreCreateFunction<I, O extends OnCallCreateModelResult = OnCallCreateModelResult> = (params: I) => Observable<LoadingState<O>>;\n\n/**\n * Creates a function for a store that DbxFirebaseDocumentStore captures the ModelFirebaseCreateFunction result and sets the key of the created value.\n *\n * @param store\n * @param fn\n * @returns\n */\nexport function firebaseDocumentStoreCreateFunction<I, O extends OnCallCreateModelResult = OnCallCreateModelResult>(store: DbxFirebaseDocumentStore<any, any>, fn: ModelFirebaseCreateFunction<I, O>): DbxFirebaseDocumentStoreCreateFunction<I, O> {\n  return (params: I) =>\n    loadingStateFromObs(\n      lazyFrom(() =>\n        fn(params).then((result) => {\n          const modelKeys = result.modelKeys;\n          const firstKey = firstValue(modelKeys);\n\n          if (firstKey) {\n            store.setKey(firstKey);\n          }\n\n          return result;\n        })\n      )\n    );\n}\n\nexport type DbxFirebaseDocumentStoreCrudFunction<I, O = void> = (input: I) => Observable<LoadingState<O>>;\n\n/**\n * Creates a DbxfirebaseDocumentStoreCrudFunction from the input ModelFirebaseCrudFunction.\n *\n * @param fn\n * @returns\n */\nexport function firebaseDocumentStoreCrudFunction<I, O = void>(fn: ModelFirebaseCrudFunction<I, O>): DbxFirebaseDocumentStoreCrudFunction<I, O> {\n  return (params: I) => loadingStateFromObs(from(fn(params)).pipe(shareReplay(1)));\n}\n\n// MARK: Targeted Functions\n/**\n * A parameter that refers to a specific key.\n */\nexport type DbxFirebaseDocumentStoreFunctionParams = TargetModelParams | InferredTargetModelParams;\n\n/**\n * Used for the input to related functions\n */\nexport type DbxFirebaseDocumentStoreFunctionParamsInput<I extends DbxFirebaseDocumentStoreFunctionParams> = PartialOnKeys<I, 'key'>;\nexport type DbxFirebaseDocumentStoreFunction<I extends DbxFirebaseDocumentStoreFunctionParams, O = void> = DbxFirebaseDocumentStoreCrudFunction<DbxFirebaseDocumentStoreFunctionParamsInput<I>, O>;\n\n// MARK: Read\n/**\n * Creates a DbxfirebaseDocumentStoreCrudFunction for read.\n *\n * The store's current key is always injected into the params of the request.\n *\n * For functions that do not require the store's current key, use firebaseDocumentStoreCrudFunction() instead.\n *\n * @param store\n * @param fn\n * @returns\n */\nexport function firebaseDocumentStoreReadFunction<I extends DbxFirebaseDocumentStoreFunctionParams, O>(store: DbxFirebaseDocumentStore<any, any>, fn: ModelFirebaseReadFunction<I, O>): DbxFirebaseDocumentStoreFunction<I, O> {\n  return firebaseDocumentStoreUpdateFunction(store, fn);\n}\n\n// MARK: Update\n/**\n * Creates a DbxFirebaseDocumentStoreFunction for update.\n *\n * The store's current key is always injected into the params of the request.\n *\n * @param store\n * @param fn\n * @returns\n */\nexport function firebaseDocumentStoreUpdateFunction<I extends DbxFirebaseDocumentStoreFunctionParams, O = void>(store: DbxFirebaseDocumentStore<any, any>, fn: ModelFirebaseUpdateFunction<I, O>): DbxFirebaseDocumentStoreFunction<I, O> {\n  return (params: DbxFirebaseDocumentStoreFunctionParamsInput<I>) =>\n    loadingStateFromObs(\n      store.key$.pipe(\n        first(),\n        exhaustMap((key) =>\n          fn({\n            ...params,\n            key // inject key into the parameters.\n          } as I)\n        ),\n        shareReplay(1)\n      )\n    );\n}\n\n// MARK: Delete\n/**\n * Creates a DbxFirebaseDocumentStoreFunction for delete.\n *\n * The store's current key is always injected into the params of the request.\n *\n * @param store\n * @param fn\n * @returns\n */\nexport function firebaseDocumentStoreDeleteFunction<I extends DbxFirebaseDocumentStoreFunctionParams, O = void>(store: DbxFirebaseDocumentStore<any, any>, fn: ModelFirebaseDeleteFunction<I, O>): DbxFirebaseDocumentStoreFunction<I, O> {\n  return (params: DbxFirebaseDocumentStoreFunctionParamsInput<I>) =>\n    loadingStateFromObs(\n      store.key$.pipe(\n        first(),\n        exhaustMap((key) =>\n          fn({\n            ...params,\n            key // inject key into the parameters.\n          } as I).then((result) => {\n            store.clearRefs();\n            return result;\n          })\n        ),\n        shareReplay(1)\n      )\n    );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.document.crud.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/model/modules/store/store.document.crud.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAqB,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACjF,OAAO,EAAE,UAAU,EAAsB,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAmB,MAAM,MAAM,CAAC;AAM7E;;;;;;GAMG;AACH,MAAM,UAAU,mCAAmC,CAAiE,KAAyC,EAAE,EAAqC;IAClM,OAAO,CAAC,MAAS,EAAE,EAAE,CACnB,mBAAmB,CACjB,QAAQ,CAAC,GAAG,EAAE,CACZ,EAAE,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;QACzB,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QACnC,MAAM,QAAQ,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC;QAEvC,IAAI,QAAQ,EAAE,CAAC;YACb,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACzB,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC,CACH,CACF,CAAC;AACN,CAAC;AAID;;;;;GAKG;AACH,MAAM,UAAU,iCAAiC,CAAc,EAAmC;IAChG,OAAO,CAAC,MAAS,EAAE,EAAE,CAAC,mBAAmB,CAAC,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACnF,CAAC;AAcD,aAAa;AACb;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iCAAiC,CAAsD,KAAyC,EAAE,EAAmC;IACnL,OAAO,mCAAmC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;AACxD,CAAC;AAED,eAAe;AACf;;;;;;;;GAQG;AACH,MAAM,UAAU,mCAAmC,CAA6D,KAAyC,EAAE,EAAqC;IAC9L,OAAO,CAAC,MAAsD,EAAE,EAAE,CAChE,mBAAmB,CACjB,KAAK,CAAC,IAAI,CAAC,IAAI,CACb,KAAK,EAAE,EACP,UAAU,CAAC,CAAC,GAAG,EAAE,EAAE,CACjB,EAAE,CAAC;QACD,GAAG,MAAM;QACT,GAAG,CAAC,kCAAkC;KAClC,CAAC,CACR,EACD,WAAW,CAAC,CAAC,CAAC,CACf,CACF,CAAC;AACN,CAAC;AAED,eAAe;AACf;;;;;;;;GAQG;AACH,MAAM,UAAU,mCAAmC,CAA6D,KAAyC,EAAE,EAAqC;IAC9L,OAAO,CAAC,MAAsD,EAAE,EAAE,CAChE,mBAAmB,CACjB,KAAK,CAAC,IAAI,CAAC,IAAI,CACb,KAAK,EAAE,EACP,UAAU,CAAC,CAAC,GAAG,EAAE,EAAE,CACjB,EAAE,CAAC;QACD,GAAG,MAAM;QACT,GAAG,CAAC,kCAAkC;KAClC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;QACtB,KAAK,CAAC,SAAS,EAAE,CAAC;QAClB,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC,CACH,EACD,WAAW,CAAC,CAAC,CAAC,CACf,CACF,CAAC;AACN,CAAC","sourcesContent":["import { type ModelFirebaseCreateFunction, type ModelFirebaseDeleteFunction, type ModelFirebaseUpdateFunction, type OnCallCreateModelResult, type TargetModelParams, type InferredTargetModelParams, type ModelFirebaseCrudFunction, type ModelFirebaseReadFunction } from '@dereekb/firebase';\nimport { lazyFrom, type LoadingState, loadingStateFromObs } from '@dereekb/rxjs';\nimport { firstValue, type PartialOnKeys } from '@dereekb/util';\nimport { shareReplay, exhaustMap, first, from, type Observable } from 'rxjs';\nimport { type DbxFirebaseDocumentStore } from './store';\n\n// MARK: Create\nexport type DbxFirebaseDocumentStoreCreateFunction<I, O extends OnCallCreateModelResult = OnCallCreateModelResult> = (params: I) => Observable<LoadingState<O>>;\n\n/**\n * Creates a function for a store that DbxFirebaseDocumentStore captures the ModelFirebaseCreateFunction result and sets the key of the created value.\n *\n * @param store\n * @param fn\n * @returns\n */\nexport function firebaseDocumentStoreCreateFunction<I, O extends OnCallCreateModelResult = OnCallCreateModelResult>(store: DbxFirebaseDocumentStore<any, any>, fn: ModelFirebaseCreateFunction<I, O>): DbxFirebaseDocumentStoreCreateFunction<I, O> {\n  return (params: I) =>\n    loadingStateFromObs(\n      lazyFrom(() =>\n        fn(params).then((result) => {\n          const modelKeys = result.modelKeys;\n          const firstKey = firstValue(modelKeys);\n\n          if (firstKey) {\n            store.setKey(firstKey);\n          }\n\n          return result;\n        })\n      )\n    );\n}\n\nexport type DbxFirebaseDocumentStoreCrudFunction<I, O = void> = (input: I) => Observable<LoadingState<O>>;\n\n/**\n * Creates a DbxfirebaseDocumentStoreCrudFunction from the input ModelFirebaseCrudFunction.\n *\n * @param fn\n * @returns\n */\nexport function firebaseDocumentStoreCrudFunction<I, O = void>(fn: ModelFirebaseCrudFunction<I, O>): DbxFirebaseDocumentStoreCrudFunction<I, O> {\n  return (params: I) => loadingStateFromObs(from(fn(params)).pipe(shareReplay(1)));\n}\n\n// MARK: Targeted Functions\n/**\n * A parameter that refers to a specific key.\n */\nexport type DbxFirebaseDocumentStoreFunctionParams = TargetModelParams | InferredTargetModelParams;\n\n/**\n * Used for the input to related functions\n */\nexport type DbxFirebaseDocumentStoreFunctionParamsInput<I extends DbxFirebaseDocumentStoreFunctionParams> = PartialOnKeys<I, 'key'>;\nexport type DbxFirebaseDocumentStoreFunction<I extends DbxFirebaseDocumentStoreFunctionParams, O = void> = DbxFirebaseDocumentStoreCrudFunction<DbxFirebaseDocumentStoreFunctionParamsInput<I>, O>;\n\n// MARK: Read\n/**\n * Creates a DbxfirebaseDocumentStoreCrudFunction for read.\n *\n * The store's current key is always injected into the params of the request.\n *\n * For functions that do not require the store's current key, use firebaseDocumentStoreCrudFunction() instead.\n *\n * @param store\n * @param fn\n * @returns\n */\nexport function firebaseDocumentStoreReadFunction<I extends DbxFirebaseDocumentStoreFunctionParams, O>(store: DbxFirebaseDocumentStore<any, any>, fn: ModelFirebaseReadFunction<I, O>): DbxFirebaseDocumentStoreFunction<I, O> {\n  return firebaseDocumentStoreUpdateFunction(store, fn);\n}\n\n// MARK: Update\n/**\n * Creates a DbxFirebaseDocumentStoreFunction for update.\n *\n * The store's current key is always injected into the params of the request.\n *\n * @param store\n * @param fn\n * @returns\n */\nexport function firebaseDocumentStoreUpdateFunction<I extends DbxFirebaseDocumentStoreFunctionParams, O = void>(store: DbxFirebaseDocumentStore<any, any>, fn: ModelFirebaseUpdateFunction<I, O>): DbxFirebaseDocumentStoreFunction<I, O> {\n  return (params: DbxFirebaseDocumentStoreFunctionParamsInput<I>) =>\n    loadingStateFromObs(\n      store.key$.pipe(\n        first(),\n        exhaustMap((key) =>\n          fn({\n            ...params,\n            key // inject key into the parameters.\n          } as I)\n        ),\n        shareReplay(1)\n      )\n    );\n}\n\n// MARK: Delete\n/**\n * Creates a DbxFirebaseDocumentStoreFunction for delete.\n *\n * The store's current key is always injected into the params of the request.\n *\n * @param store\n * @param fn\n * @returns\n */\nexport function firebaseDocumentStoreDeleteFunction<I extends DbxFirebaseDocumentStoreFunctionParams, O = void>(store: DbxFirebaseDocumentStore<any, any>, fn: ModelFirebaseDeleteFunction<I, O>): DbxFirebaseDocumentStoreFunction<I, O> {\n  return (params: DbxFirebaseDocumentStoreFunctionParamsInput<I>) =>\n    loadingStateFromObs(\n      store.key$.pipe(\n        first(),\n        exhaustMap((key) =>\n          fn({\n            ...params,\n            key // inject key into the parameters.\n          } as I).then((result) => {\n            store.clearRefs();\n            return result;\n          })\n        ),\n        shareReplay(1)\n      )\n    );\n}\n"]}

package/esm2022/lib/model/modules/store/store.document.directive.mjs

@@ -105,4 +105,4 @@ export function provideDbxFirebaseDocumentStoreDirective(sourceType, storeType)
     }
     return providers;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.document.directive.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/model/modules/store/store.document.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, forwardRef, model, OnDestroy, Provider, Type } from '@angular/core';\nimport { DocumentReference, FirestoreAccessorStreamMode, FirestoreDocument, FirestoreModelKey, FirestoreModelId, TwoWayFlatFirestoreModelKey } from '@dereekb/firebase';\nimport { ModelKey, type Maybe } from '@dereekb/util';\nimport { DbxFirebaseDocumentStore } from './store.document';\nimport { BehaviorSubject, Observable, shareReplay, Subscription, switchMap } from 'rxjs';\nimport { filterMaybe, skipInitialMaybe, SubscriptionObject } from '@dereekb/rxjs';\nimport { DbxRouteModelIdDirectiveDelegate, DbxRouteModelKeyDirectiveDelegate, provideDbxRouteModelIdDirectiveDelegate, provideDbxRouteModelKeyDirectiveDelegate } from '@dereekb/dbx-core';\nimport { DbxFirebaseDocumentStoreTwoWayKeyProvider } from './store.document.twoway.key.source';\nimport { toObservable } from '@angular/core/rxjs-interop';\n\n/**\n * Abstract directive that contains a DbxFirebaseDocumentStore and provides an interface for communicating with other directives.\n */\n@Directive()\nexport abstract class DbxFirebaseDocumentStoreDirective<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseDocumentStore<T, D> = DbxFirebaseDocumentStore<T, D>> implements DbxFirebaseDocumentStoreTwoWayKeyProvider, DbxRouteModelIdDirectiveDelegate, DbxRouteModelKeyDirectiveDelegate, OnDestroy {\n  readonly documentId = model<Maybe<FirestoreModelId>>(undefined);\n  readonly key = model<Maybe<FirestoreModelKey>>(undefined);\n  readonly flatKey = model<Maybe<TwoWayFlatFirestoreModelKey>>(undefined);\n  readonly ref = model<Maybe<DocumentReference<T>>>(undefined);\n  readonly streamMode = model<FirestoreAccessorStreamMode>(FirestoreAccessorStreamMode.STREAM);\n\n  private readonly _documentId$ = toObservable(this.documentId).pipe(skipInitialMaybe());\n  private readonly _key$ = toObservable(this.key).pipe(skipInitialMaybe());\n  private readonly _flatKey$ = toObservable(this.flatKey).pipe(skipInitialMaybe());\n  private readonly _ref$ = toObservable(this.ref).pipe(skipInitialMaybe());\n  private readonly _streamMode$ = toObservable(this.streamMode).pipe(skipInitialMaybe());\n\n  private readonly _store = new BehaviorSubject<Maybe<S>>(undefined);\n  private readonly _storeSub = new SubscriptionObject();\n\n  readonly store$ = this._store.pipe(filterMaybe(), shareReplay(1));\n\n  readonly exists$ = this.store$.pipe(switchMap((x) => x.exists$));\n  readonly document$ = this.store$.pipe(switchMap((x) => x.document$));\n  readonly documentLoadingState$ = this.store$.pipe(switchMap((x) => x.documentLoadingState$));\n\n  readonly id$ = this.store$.pipe(switchMap((x) => x.id$));\n  readonly key$ = this.store$.pipe(switchMap((x) => x.key$));\n  readonly twoWayFlatKey$ = this.store$.pipe(switchMap((x) => x.twoWayFlatKey$));\n  readonly ref$ = this.store$.pipe(switchMap((x) => x.ref$));\n\n  readonly snapshot$ = this.store$.pipe(switchMap((x) => x.snapshot$));\n  readonly snapshotLoadingState$ = this.store$.pipe(switchMap((x) => x.snapshotLoadingState$));\n\n  readonly modelIdentity$ = this.store$.pipe(switchMap((x) => x.modelIdentity$));\n  readonly data$ = this.store$.pipe(switchMap((x) => x.data$));\n  readonly loadingState$ = this.store$.pipe(switchMap((x) => x.dataLoadingState$));\n\n  constructor(store: S) {\n    this.replaceStore(store);\n\n    // sync inputs to store any time the store changes\n    this._storeSub.subscription = this._store.subscribe((x) => {\n      if (x) {\n        x.setId(this._documentId$);\n        x.setKey(this._key$);\n        x.setFlatKey(this._flatKey$);\n        x.setRef(this._ref$);\n        x.setStreamMode(this._streamMode$);\n      }\n    });\n  }\n\n  ngOnDestroy(): void {\n    this._store.complete();\n    this._storeSub.destroy();\n  }\n\n  get store() {\n    return this._store.value as S;\n  }\n\n  // MARK: Setters\n  setDocumentId(documentId: Maybe<FirestoreModelId>) {\n    this.documentId.set(documentId);\n  }\n\n  setKey(key: Maybe<FirestoreModelKey>) {\n    this.key.set(key);\n  }\n\n  setFlatKey(flatKey: Maybe<TwoWayFlatFirestoreModelKey>) {\n    this.flatKey.set(flatKey);\n  }\n\n  setRef(ref: Maybe<DocumentReference<T>>) {\n    this.ref.set(ref);\n  }\n\n  setStreamMode(streamMode: FirestoreAccessorStreamMode) {\n    this.streamMode.set(streamMode);\n  }\n\n  /**\n   * Replaces the internal store.\n   */\n  replaceStore(store: S) {\n    this._store.next(store);\n  }\n\n  // MARK: DbxRouteModelIdDirectiveDelegate\n  useRouteModelIdParamsObservable(idFromParams: Observable<Maybe<ModelKey>>): Subscription {\n    return idFromParams.subscribe((x) => this.setDocumentId(x));\n  }\n\n  // MARK: DbxRouteModelKeyDirectiveDelegate\n  useRouteModelKeyParamsObservable(keyFromParams: Observable<Maybe<TwoWayFlatFirestoreModelKey>>): Subscription {\n    // we assume that the input model key is a TwoWayFlatFirestoreModelKey, since the TwoWayFlatFirestoreModelKey is safe to encode in the url\n    return keyFromParams.subscribe((x) => this.setFlatKey(x));\n  }\n}\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n// The use of any here does not degrade the type-safety; we want to simply match that the Store type S is used in the Directive type C to provide it.\n\n/**\n * Configures providers for a DbxFirebaseDocumentStoreDirective.\n *\n * Can optionally also provide the actual store type to include in the providers array so it is instantiated by Angular.\n *\n * @param sourceType\n */\nexport function provideDbxFirebaseDocumentStoreDirective<S extends DbxFirebaseDocumentStoreDirective<any, any, any>>(sourceType: Type<S>): Provider[];\nexport function provideDbxFirebaseDocumentStoreDirective<S extends DbxFirebaseDocumentStore<any, any>, C extends DbxFirebaseDocumentStoreDirective<any, any, S> = DbxFirebaseDocumentStoreDirective<any, any, S>>(sourceType: Type<C>, storeType: Type<S>): Provider[];\nexport function provideDbxFirebaseDocumentStoreDirective<S extends DbxFirebaseDocumentStore<any, any>, C extends DbxFirebaseDocumentStoreDirective<any, any, S> = DbxFirebaseDocumentStoreDirective<any, any, S>>(sourceType: Type<C>, storeType?: Type<S>): Provider[] {\n  const providers: Provider[] = [\n    {\n      provide: DbxFirebaseDocumentStoreDirective,\n      useExisting: forwardRef(() => sourceType)\n    },\n    ...provideDbxRouteModelIdDirectiveDelegate(sourceType),\n    ...provideDbxRouteModelKeyDirectiveDelegate(sourceType)\n  ];\n\n  if (storeType != null) {\n    providers.push(storeType);\n  }\n\n  return providers;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.document.directive.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/model/modules/store/store.document.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, forwardRef, model, OnDestroy, Provider, Type } from '@angular/core';\nimport { DocumentReference, FirestoreAccessorStreamMode, FirestoreDocument, FirestoreModelKey, FirestoreModelId, TwoWayFlatFirestoreModelKey } from '@dereekb/firebase';\nimport { ModelKey, type Maybe } from '@dereekb/util';\nimport { DbxFirebaseDocumentStore } from './store';\nimport { BehaviorSubject, Observable, shareReplay, Subscription, switchMap } from 'rxjs';\nimport { filterMaybe, skipInitialMaybe, SubscriptionObject } from '@dereekb/rxjs';\nimport { DbxRouteModelIdDirectiveDelegate, DbxRouteModelKeyDirectiveDelegate, provideDbxRouteModelIdDirectiveDelegate, provideDbxRouteModelKeyDirectiveDelegate } from '@dereekb/dbx-core';\nimport { DbxFirebaseDocumentStoreTwoWayKeyProvider } from './store.document.twoway.key.source';\nimport { toObservable } from '@angular/core/rxjs-interop';\n\n/**\n * Abstract directive that contains a DbxFirebaseDocumentStore and provides an interface for communicating with other directives.\n */\n@Directive()\nexport abstract class DbxFirebaseDocumentStoreDirective<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseDocumentStore<T, D> = DbxFirebaseDocumentStore<T, D>> implements DbxFirebaseDocumentStoreTwoWayKeyProvider, DbxRouteModelIdDirectiveDelegate, DbxRouteModelKeyDirectiveDelegate, OnDestroy {\n  readonly documentId = model<Maybe<FirestoreModelId>>(undefined);\n  readonly key = model<Maybe<FirestoreModelKey>>(undefined);\n  readonly flatKey = model<Maybe<TwoWayFlatFirestoreModelKey>>(undefined);\n  readonly ref = model<Maybe<DocumentReference<T>>>(undefined);\n  readonly streamMode = model<FirestoreAccessorStreamMode>(FirestoreAccessorStreamMode.STREAM);\n\n  private readonly _documentId$ = toObservable(this.documentId).pipe(skipInitialMaybe());\n  private readonly _key$ = toObservable(this.key).pipe(skipInitialMaybe());\n  private readonly _flatKey$ = toObservable(this.flatKey).pipe(skipInitialMaybe());\n  private readonly _ref$ = toObservable(this.ref).pipe(skipInitialMaybe());\n  private readonly _streamMode$ = toObservable(this.streamMode).pipe(skipInitialMaybe());\n\n  private readonly _store = new BehaviorSubject<Maybe<S>>(undefined);\n  private readonly _storeSub = new SubscriptionObject();\n\n  readonly store$ = this._store.pipe(filterMaybe(), shareReplay(1));\n\n  readonly exists$ = this.store$.pipe(switchMap((x) => x.exists$));\n  readonly document$ = this.store$.pipe(switchMap((x) => x.document$));\n  readonly documentLoadingState$ = this.store$.pipe(switchMap((x) => x.documentLoadingState$));\n\n  readonly id$ = this.store$.pipe(switchMap((x) => x.id$));\n  readonly key$ = this.store$.pipe(switchMap((x) => x.key$));\n  readonly twoWayFlatKey$ = this.store$.pipe(switchMap((x) => x.twoWayFlatKey$));\n  readonly ref$ = this.store$.pipe(switchMap((x) => x.ref$));\n\n  readonly snapshot$ = this.store$.pipe(switchMap((x) => x.snapshot$));\n  readonly snapshotLoadingState$ = this.store$.pipe(switchMap((x) => x.snapshotLoadingState$));\n\n  readonly modelIdentity$ = this.store$.pipe(switchMap((x) => x.modelIdentity$));\n  readonly data$ = this.store$.pipe(switchMap((x) => x.data$));\n  readonly loadingState$ = this.store$.pipe(switchMap((x) => x.dataLoadingState$));\n\n  constructor(store: S) {\n    this.replaceStore(store);\n\n    // sync inputs to store any time the store changes\n    this._storeSub.subscription = this._store.subscribe((x) => {\n      if (x) {\n        x.setId(this._documentId$);\n        x.setKey(this._key$);\n        x.setFlatKey(this._flatKey$);\n        x.setRef(this._ref$);\n        x.setStreamMode(this._streamMode$);\n      }\n    });\n  }\n\n  ngOnDestroy(): void {\n    this._store.complete();\n    this._storeSub.destroy();\n  }\n\n  get store() {\n    return this._store.value as S;\n  }\n\n  // MARK: Setters\n  setDocumentId(documentId: Maybe<FirestoreModelId>) {\n    this.documentId.set(documentId);\n  }\n\n  setKey(key: Maybe<FirestoreModelKey>) {\n    this.key.set(key);\n  }\n\n  setFlatKey(flatKey: Maybe<TwoWayFlatFirestoreModelKey>) {\n    this.flatKey.set(flatKey);\n  }\n\n  setRef(ref: Maybe<DocumentReference<T>>) {\n    this.ref.set(ref);\n  }\n\n  setStreamMode(streamMode: FirestoreAccessorStreamMode) {\n    this.streamMode.set(streamMode);\n  }\n\n  /**\n   * Replaces the internal store.\n   */\n  replaceStore(store: S) {\n    this._store.next(store);\n  }\n\n  // MARK: DbxRouteModelIdDirectiveDelegate\n  useRouteModelIdParamsObservable(idFromParams: Observable<Maybe<ModelKey>>): Subscription {\n    return idFromParams.subscribe((x) => this.setDocumentId(x));\n  }\n\n  // MARK: DbxRouteModelKeyDirectiveDelegate\n  useRouteModelKeyParamsObservable(keyFromParams: Observable<Maybe<TwoWayFlatFirestoreModelKey>>): Subscription {\n    // we assume that the input model key is a TwoWayFlatFirestoreModelKey, since the TwoWayFlatFirestoreModelKey is safe to encode in the url\n    return keyFromParams.subscribe((x) => this.setFlatKey(x));\n  }\n}\n\n/* eslint-disable @typescript-eslint/no-explicit-any */\n// The use of any here does not degrade the type-safety; we want to simply match that the Store type S is used in the Directive type C to provide it.\n\n/**\n * Configures providers for a DbxFirebaseDocumentStoreDirective.\n *\n * Can optionally also provide the actual store type to include in the providers array so it is instantiated by Angular.\n *\n * @param sourceType\n */\nexport function provideDbxFirebaseDocumentStoreDirective<S extends DbxFirebaseDocumentStoreDirective<any, any, any>>(sourceType: Type<S>): Provider[];\nexport function provideDbxFirebaseDocumentStoreDirective<S extends DbxFirebaseDocumentStore<any, any>, C extends DbxFirebaseDocumentStoreDirective<any, any, S> = DbxFirebaseDocumentStoreDirective<any, any, S>>(sourceType: Type<C>, storeType: Type<S>): Provider[];\nexport function provideDbxFirebaseDocumentStoreDirective<S extends DbxFirebaseDocumentStore<any, any>, C extends DbxFirebaseDocumentStoreDirective<any, any, S> = DbxFirebaseDocumentStoreDirective<any, any, S>>(sourceType: Type<C>, storeType?: Type<S>): Provider[] {\n  const providers: Provider[] = [\n    {\n      provide: DbxFirebaseDocumentStoreDirective,\n      useExisting: forwardRef(() => sourceType)\n    },\n    ...provideDbxRouteModelIdDirectiveDelegate(sourceType),\n    ...provideDbxRouteModelKeyDirectiveDelegate(sourceType)\n  ];\n\n  if (storeType != null) {\n    providers.push(storeType);\n  }\n\n  return providers;\n}\n"]}

package/esm2022/lib/model/modules/store/store.document.mjs

@@ -6,8 +6,13 @@ import { filterMaybe, beginLoading, successResult, loadingStateFromObs, errorRes
 import { isMaybeSo } from '@dereekb/util';
 import { LockSetComponentStore } from '@dereekb/dbx-core';
 import { modelDoesNotExistError } from '../../error';
+import { linkDocumentStoreToParentContextStores } from './store.document.context.store.link';
 import * as i0 from "@angular/core";
 export class AbstractDbxFirebaseDocumentStore extends LockSetComponentStore {
+    constructor(initialState) {
+        super(initialState);
+        linkDocumentStoreToParentContextStores(this);
+    }
     // MARK: Effects
     // MARK: Accessors
     currentFirestoreCollectionLike$ = this.state$.pipe(map((x) => x.firestoreCollection ?? x.firestoreCollectionLike), distinctUntilChanged(), shareReplay(1));
@@ -43,6 +48,8 @@ export class AbstractDbxFirebaseDocumentStore extends LockSetComponentStore {
     hasRef$ = this.currentDocument$.pipe(map((x) => x?.documentRef != null), distinctUntilChanged(), shareReplay(1));
     document$ = this.currentDocument$.pipe(filterMaybe(), distinctUntilChanged(), shareReplay(1));
     documentLoadingState$ = this.currentDocument$.pipe(map((x) => (x ? successResult(x) : beginLoading())), shareReplay(1));
+    currentId$ = this.currentDocument$.pipe(map((x) => x?.id), shareReplay(1));
+    currentKey$ = this.currentDocument$.pipe(map((x) => x?.key), shareReplay(1));
     id$ = this.document$.pipe(map((x) => x.id), shareReplay(1));
     key$ = this.document$.pipe(map((x) => x.key), shareReplay(1));
     keyModelIds$ = this.key$.pipe(map(firestoreModelIdsFromKey), shareReplay(1));
@@ -101,7 +108,7 @@ export class AbstractDbxFirebaseDocumentStore extends LockSetComponentStore {
         return of(result);
     }), shareReplay(1));
     doesNotExist$ = this.exists$.pipe(map((x) => !x), shareReplay(1));
-    modelIdentity$ = this.document$.pipe(map((x) => x.modelIdentity), shareReplay(1));
+    modelIdentity$ = this.firestoreCollectionLike$.pipe(map((x) => x.modelIdentity), shareReplay(1));
     // MARK: State Changes
     setId = this.updater((state, id) => (id ? { ...state, id, key: undefined, ref: undefined } : { ...state, id }));
     setKey = this.updater((state, key) => (key ? { ...state, key, id: undefined, ref: undefined } : { ...state, key }));
@@ -111,12 +118,17 @@ export class AbstractDbxFirebaseDocumentStore extends LockSetComponentStore {
     clearRefs = this.updater((state) => ({ ...state, id: undefined, key: undefined, ref: undefined }));
     setFirestoreCollection = this.updater((state, firestoreCollection) => ({ ...state, firestoreCollection }));
     setFirestoreCollectionLike = this.updater((state, firestoreCollectionLike) => ({ ...state, firestoreCollectionLike }));
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AbstractDbxFirebaseDocumentStore, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AbstractDbxFirebaseDocumentStore, deps: [{ token: null, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AbstractDbxFirebaseDocumentStore });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AbstractDbxFirebaseDocumentStore, decorators: [{
             type: Injectable
-        }] });
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [null]
+                }, {
+                    type: Optional
+                }] }] });
 function injectSingleItemIdIntoState(state) {
     const id = state?.firestoreCollection?.singleItemIdentifier;
     if (state && id != null) {
@@ -176,4 +188,4 @@ AbstractRootSingleItemDbxFirebaseDocument = __decorate([
     __metadata("design:paramtypes", [Object])
 ], AbstractRootSingleItemDbxFirebaseDocument);
 export { AbstractRootSingleItemDbxFirebaseDocument };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.document.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/model/modules/store/store.document.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { Observable, shareReplay, distinctUntilChanged, map, switchMap, combineLatest, Subscription, of, catchError } from 'rxjs';\nimport {\n  DocumentSnapshot,\n  DocumentReference,\n  FirestoreCollection,\n  FirestoreDocument,\n  DocumentDataWithIdAndKey,\n  FirestoreModelId,\n  FirestoreModelKey,\n  FirestoreCollectionLike,\n  FirestoreModelIdentity,\n  firestoreModelIdsFromKey,\n  firestoreModelKeyPartPairs,\n  FirestoreModelCollectionAndIdPair,\n  firestoreModelKeyPairObject,\n  FirestoreModelCollectionAndIdPairObject,\n  documentDataWithIdAndKey,\n  FirestoreAccessorStreamMode,\n  TwoWayFlatFirestoreModelKey,\n  inferKeyFromTwoWayFlatFirestoreModelKey,\n  RootSingleItemFirestoreCollection,\n  FlatFirestoreModelKey,\n  flatFirestoreModelKey,\n  twoWayFlatFirestoreModelKey,\n  FIRESTORE_PERMISSION_DENIED_ERROR_CODE,\n  isClientFirebaseError\n} from '@dereekb/firebase';\nimport { filterMaybe, LoadingState, beginLoading, successResult, loadingStateFromObs, errorResult, ObservableOrValue, isLoadingStateLoading } 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 streamMode$: Observable<FirestoreAccessorStreamMode>;\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 hasRef$: Observable<boolean>;\n  readonly flatKey$: Observable<FlatFirestoreModelKey>;\n  readonly twoWayFlatKey$: Observable<TwoWayFlatFirestoreModelKey>;\n\n  readonly keyModelIds$: Observable<FirestoreModelId[]>;\n  readonly keyPairs$: Observable<FirestoreModelCollectionAndIdPair[]>;\n  readonly keyPairObject$: Observable<FirestoreModelCollectionAndIdPairObject>;\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<DocumentDataWithIdAndKey<T>>>;\n  readonly data$: Observable<DocumentDataWithIdAndKey<T>>;\n  readonly dataLoadingState$: Observable<LoadingState<DocumentDataWithIdAndKey<T>>>;\n  readonly isLoadingData$: Observable<boolean>;\n  readonly currentExists$: Observable<boolean>;\n  readonly exists$: Observable<boolean>;\n  readonly modelIdentity$: Observable<FirestoreModelIdentity>;\n\n  /**\n   * Sets the id of the document to load.\n   */\n  readonly setId: (observableOrValue: ObservableOrValue<Maybe<FirestoreModelId>>) => Subscription;\n\n  /**\n   * Sets the key of the document to load.\n   */\n  readonly setKey: (observableOrValue: ObservableOrValue<Maybe<FirestoreModelKey>>) => Subscription;\n\n  /**\n   * Sets the key of the document to load using a TwoWayFlatFirestoreModelKey.\n   */\n  readonly setFlatKey: (observableOrValue: ObservableOrValue<Maybe<TwoWayFlatFirestoreModelKey>>) => Subscription;\n\n  /**\n   * Sets the ref of the document to load.\n   */\n  readonly setRef: (observableOrValue: ObservableOrValue<Maybe<DocumentReference<T>>>) => Subscription;\n\n  /**\n   * Clears the key/id/ref and current document from the store.\n   */\n  readonly clearRefs: () => void;\n\n  /**\n   * Sets the stream mode.\n   */\n  readonly setStreamMode: (observableOrValue: ObservableOrValue<FirestoreAccessorStreamMode>) => Subscription;\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 streamMode?: FirestoreAccessorStreamMode;\n  readonly id?: Maybe<FirestoreModelId>;\n  readonly key?: Maybe<FirestoreModelKey>;\n  readonly ref?: Maybe<DocumentReference<T>>;\n}\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 streamMode$: Observable<FirestoreAccessorStreamMode> = this.state$.pipe(\n    map((x) => x.streamMode ?? FirestoreAccessorStreamMode.STREAM),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\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  /**\n   * Whether or not an id/ref/key has been input and currentDocument is not null.\n   */\n  readonly hasRef$: Observable<boolean> = this.currentDocument$.pipe(\n    map((x) => x?.documentRef != null),\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<FirestoreModelCollectionAndIdPairObject> = 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 flatKey$: Observable<FlatFirestoreModelKey> = this.key$.pipe(\n    map((x) => flatFirestoreModelKey(x)),\n    shareReplay(1)\n  );\n\n  readonly twoWayFlatKey$: Observable<FlatFirestoreModelKey> = this.key$.pipe(\n    map((x) => twoWayFlatFirestoreModelKey(x)),\n    shareReplay(1)\n  );\n\n  readonly snapshot$: Observable<DocumentSnapshot<T>> = combineLatest([this.document$, this.streamMode$]).pipe(\n    switchMap(([x, mode]) => x.snapshotStream(mode)),\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<DocumentDataWithIdAndKey<T>>> = this.snapshot$.pipe(\n    map((x) => documentDataWithIdAndKey(x)),\n    shareReplay(1)\n  );\n\n  readonly data$: Observable<DocumentDataWithIdAndKey<T>> = this.currentDocument$.pipe(\n    switchMap(() => this.currentData$.pipe(filterMaybe())),\n    shareReplay(1)\n  );\n\n  readonly dataLoadingState$: Observable<LoadingState<DocumentDataWithIdAndKey<T>>> = this.snapshotLoadingState$.pipe(\n    map((x) => {\n      let result: LoadingState<DocumentDataWithIdAndKey<T>>;\n\n      if (x.value) {\n        const data = documentDataWithIdAndKey(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 isLoadingData$ = this.dataLoadingState$.pipe(map(isLoadingStateLoading), distinctUntilChanged(), shareReplay(1));\n\n  /**\n   * Returns false while hasRef$ is false, and then returns exists$.\n   */\n  readonly currentExists$: Observable<boolean> = this.hasRef$.pipe(\n    switchMap((hasRef) => {\n      if (hasRef) {\n        return this.exists$;\n      } else {\n        return of(false);\n      }\n    }),\n    shareReplay(1)\n  );\n\n  readonly exists$: Observable<boolean> = this.currentData$.pipe(\n    map((x) => isMaybeSo(x)),\n    catchError((e) => {\n      let result: Maybe<boolean>;\n\n      if (isClientFirebaseError(e)) {\n        switch (e.code) {\n          case FIRESTORE_PERMISSION_DENIED_ERROR_CODE:\n            result = false; // does not exist if permission is denied\n            break;\n        }\n      }\n\n      if (result == null) {\n        throw e;\n      }\n\n      return of(result);\n    }),\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  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  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  readonly setFlatKey = this.updater((state, key: Maybe<TwoWayFlatFirestoreModelKey>) => (key ? { ...state, key: inferKeyFromTwoWayFlatFirestoreModelKey(key), id: undefined, ref: undefined } : { ...state, key })) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\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 setStreamMode = this.updater((state, streamMode: FirestoreAccessorStreamMode) => ({ ...state, streamMode }));\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\nfunction injectSingleItemIdIntoState<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, C extends DbxFirebaseDocumentStoreContextState<T, D> = DbxFirebaseDocumentStoreContextState<T, D>>(state?: C | undefined): C | undefined {\n  const id = (state?.firestoreCollection as RootSingleItemFirestoreCollection<T, D>)?.singleItemIdentifier;\n\n  if (state && id != null) {\n    return { ...state, id };\n  } else {\n    return state;\n  }\n}\n\n/**\n * AbstractDbxFirebaseDocumentWithParentStore extension for use with RootSingleItemFirestoreCollection.\n */\nexport class AbstractRootSingleItemDbxFirebaseDocument<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, C extends DbxFirebaseDocumentStoreContextState<T, D> = DbxFirebaseDocumentStoreContextState<T, D>> extends AbstractDbxFirebaseDocumentStore<T, D, C> {\n  protected constructor(@Inject(null) @Optional() initialState?: C) {\n    super(injectSingleItemIdIntoState<T, D, C>(initialState));\n  }\n\n  /**\n   * Sets the SingleItemFirestoreCollection to use.\n   */\n  override readonly setFirestoreCollection = this.updater((state, firestoreCollection: Maybe<FirestoreCollection<T, D>>) => {\n    if (firestoreCollection != null) {\n      const id = (firestoreCollection as RootSingleItemFirestoreCollection<T, D>).singleItemIdentifier;\n\n      if (id != null) {\n        return { ...state, firestoreCollection, id };\n      } else {\n        throw new Error('AbstractRootSingleItemDbxFirebaseDocument only accepts RootSingleItemFirestoreCollection values with a singleItemIdentifier set for setFirestoreCollection.');\n      }\n    } else {\n      return { ...state, firestoreCollection: null };\n    }\n  });\n\n  /**\n   * Does nothing on a AbstractRootSingleItemDbxFirebaseDocument.\n   *\n   * Ref is set with the FirestoreCollection\n   */\n  override readonly setId = this.updater((state, id: Maybe<FirestoreModelId>) => state) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\n\n  /**\n   * Does nothing on a AbstractRootSingleItemDbxFirebaseDocument.\n   *\n   * Ref is set with the FirestoreCollection\n   */\n  override readonly setKey = this.updater((state, key: Maybe<FirestoreModelKey>) => state) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\n\n  /**\n   * Does nothing on a AbstractRootSingleItemDbxFirebaseDocument.\n   *\n   * Ref is set with the FirestoreCollection\n   */\n  override readonly setRef = this.updater((state, ref: Maybe<DocumentReference<T>>) => state) as (observableOrValue: Maybe<DocumentReference<T>> | Observable<Maybe<DocumentReference<T>>>) => Subscription;\n\n  override readonly clearRefs = this.updater((state) => state);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.document.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/model/modules/store/store.document.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { Observable, shareReplay, distinctUntilChanged, map, switchMap, combineLatest, Subscription, of, catchError } from 'rxjs';\nimport {\n  DocumentSnapshot,\n  DocumentReference,\n  FirestoreCollection,\n  FirestoreDocument,\n  DocumentDataWithIdAndKey,\n  FirestoreModelId,\n  FirestoreModelKey,\n  FirestoreCollectionLike,\n  FirestoreModelIdentity,\n  firestoreModelIdsFromKey,\n  firestoreModelKeyPartPairs,\n  FirestoreModelCollectionAndIdPair,\n  firestoreModelKeyPairObject,\n  FirestoreModelCollectionAndIdPairObject,\n  documentDataWithIdAndKey,\n  FirestoreAccessorStreamMode,\n  TwoWayFlatFirestoreModelKey,\n  inferKeyFromTwoWayFlatFirestoreModelKey,\n  RootSingleItemFirestoreCollection,\n  FlatFirestoreModelKey,\n  flatFirestoreModelKey,\n  twoWayFlatFirestoreModelKey,\n  FIRESTORE_PERMISSION_DENIED_ERROR_CODE,\n  isClientFirebaseError\n} from '@dereekb/firebase';\nimport { filterMaybe, LoadingState, beginLoading, successResult, loadingStateFromObs, errorResult, isLoadingStateLoading } from '@dereekb/rxjs';\nimport { Maybe, isMaybeSo } from '@dereekb/util';\nimport { LockSetComponentStore } from '@dereekb/dbx-core';\nimport { modelDoesNotExistError } from '../../error';\nimport { DbxFirebaseDocumentStore } from './store';\nimport { linkDocumentStoreToParentContextStores } from './store.document.context.store.link';\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  protected constructor(@Inject(null) @Optional() initialState?: C) {\n    super(initialState);\n    linkDocumentStoreToParentContextStores(this);\n  }\n\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 streamMode$: Observable<FirestoreAccessorStreamMode> = this.state$.pipe(\n    map((x) => x.streamMode ?? FirestoreAccessorStreamMode.STREAM),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\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  /**\n   * Whether or not an id/ref/key has been input and currentDocument is not null.\n   */\n  readonly hasRef$: Observable<boolean> = this.currentDocument$.pipe(\n    map((x) => x?.documentRef != null),\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 currentId$: Observable<Maybe<FirestoreModelId>> = this.currentDocument$.pipe(\n    map((x) => x?.id),\n    shareReplay(1)\n  );\n\n  readonly currentKey$: Observable<Maybe<FirestoreModelKey>> = this.currentDocument$.pipe(\n    map((x) => x?.key),\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<FirestoreModelCollectionAndIdPairObject> = 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 flatKey$: Observable<FlatFirestoreModelKey> = this.key$.pipe(\n    map((x) => flatFirestoreModelKey(x)),\n    shareReplay(1)\n  );\n\n  readonly twoWayFlatKey$: Observable<FlatFirestoreModelKey> = this.key$.pipe(\n    map((x) => twoWayFlatFirestoreModelKey(x)),\n    shareReplay(1)\n  );\n\n  readonly snapshot$: Observable<DocumentSnapshot<T>> = combineLatest([this.document$, this.streamMode$]).pipe(\n    switchMap(([x, mode]) => x.snapshotStream(mode)),\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<DocumentDataWithIdAndKey<T>>> = this.snapshot$.pipe(\n    map((x) => documentDataWithIdAndKey(x)),\n    shareReplay(1)\n  );\n\n  readonly data$: Observable<DocumentDataWithIdAndKey<T>> = this.currentDocument$.pipe(\n    switchMap(() => this.currentData$.pipe(filterMaybe())),\n    shareReplay(1)\n  );\n\n  readonly dataLoadingState$: Observable<LoadingState<DocumentDataWithIdAndKey<T>>> = this.snapshotLoadingState$.pipe(\n    map((x) => {\n      let result: LoadingState<DocumentDataWithIdAndKey<T>>;\n\n      if (x.value) {\n        const data = documentDataWithIdAndKey(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 isLoadingData$ = this.dataLoadingState$.pipe(map(isLoadingStateLoading), distinctUntilChanged(), shareReplay(1));\n\n  /**\n   * Returns false while hasRef$ is false, and then returns exists$.\n   */\n  readonly currentExists$: Observable<boolean> = this.hasRef$.pipe(\n    switchMap((hasRef) => {\n      if (hasRef) {\n        return this.exists$;\n      } else {\n        return of(false);\n      }\n    }),\n    shareReplay(1)\n  );\n\n  readonly exists$: Observable<boolean> = this.currentData$.pipe(\n    map((x) => isMaybeSo(x)),\n    catchError((e) => {\n      let result: Maybe<boolean>;\n\n      if (isClientFirebaseError(e)) {\n        switch (e.code) {\n          case FIRESTORE_PERMISSION_DENIED_ERROR_CODE:\n            result = false; // does not exist if permission is denied\n            break;\n        }\n      }\n\n      if (result == null) {\n        throw e;\n      }\n\n      return of(result);\n    }),\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.firestoreCollectionLike$.pipe(\n    map((x) => x.modelIdentity),\n    shareReplay(1)\n  );\n\n  // MARK: State Changes\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  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  readonly setFlatKey = this.updater((state, key: Maybe<TwoWayFlatFirestoreModelKey>) => (key ? { ...state, key: inferKeyFromTwoWayFlatFirestoreModelKey(key), id: undefined, ref: undefined } : { ...state, key })) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\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 setStreamMode = this.updater((state, streamMode: FirestoreAccessorStreamMode) => ({ ...state, streamMode }));\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\nfunction injectSingleItemIdIntoState<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, C extends DbxFirebaseDocumentStoreContextState<T, D> = DbxFirebaseDocumentStoreContextState<T, D>>(state?: C | undefined): C | undefined {\n  const id = (state?.firestoreCollection as RootSingleItemFirestoreCollection<T, D>)?.singleItemIdentifier;\n\n  if (state && id != null) {\n    return { ...state, id };\n  } else {\n    return state;\n  }\n}\n\n/**\n * AbstractDbxFirebaseDocumentWithParentStore extension for use with RootSingleItemFirestoreCollection.\n */\nexport class AbstractRootSingleItemDbxFirebaseDocument<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, C extends DbxFirebaseDocumentStoreContextState<T, D> = DbxFirebaseDocumentStoreContextState<T, D>> extends AbstractDbxFirebaseDocumentStore<T, D, C> {\n  protected constructor(@Inject(null) @Optional() initialState?: C) {\n    super(injectSingleItemIdIntoState<T, D, C>(initialState));\n  }\n\n  /**\n   * Sets the SingleItemFirestoreCollection to use.\n   */\n  override readonly setFirestoreCollection = this.updater((state, firestoreCollection: Maybe<FirestoreCollection<T, D>>) => {\n    if (firestoreCollection != null) {\n      const id = (firestoreCollection as RootSingleItemFirestoreCollection<T, D>).singleItemIdentifier;\n\n      if (id != null) {\n        return { ...state, firestoreCollection, id };\n      } else {\n        throw new Error('AbstractRootSingleItemDbxFirebaseDocument only accepts RootSingleItemFirestoreCollection values with a singleItemIdentifier set for setFirestoreCollection.');\n      }\n    } else {\n      return { ...state, firestoreCollection: null };\n    }\n  });\n\n  /**\n   * Does nothing on a AbstractRootSingleItemDbxFirebaseDocument.\n   *\n   * Ref is set with the FirestoreCollection\n   */\n  override readonly setId = this.updater((state, id: Maybe<FirestoreModelId>) => state) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\n\n  /**\n   * Does nothing on a AbstractRootSingleItemDbxFirebaseDocument.\n   *\n   * Ref is set with the FirestoreCollection\n   */\n  override readonly setKey = this.updater((state, key: Maybe<FirestoreModelKey>) => state) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\n\n  /**\n   * Does nothing on a AbstractRootSingleItemDbxFirebaseDocument.\n   *\n   * Ref is set with the FirestoreCollection\n   */\n  override readonly setRef = this.updater((state, ref: Maybe<DocumentReference<T>>) => state) as (observableOrValue: Maybe<DocumentReference<T>> | Observable<Maybe<DocumentReference<T>>>) => Subscription;\n\n  override readonly clearRefs = this.updater((state) => state);\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 streamMode?: FirestoreAccessorStreamMode;\n  readonly id?: Maybe<FirestoreModelId>;\n  readonly key?: Maybe<FirestoreModelKey>;\n  readonly ref?: Maybe<DocumentReference<T>>;\n}\n"]}

package/esm2022/lib/model/modules/store/store.mjs

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

package/esm2022/lib/model/modules/store/store.subcollection.document.mjs

@@ -96,4 +96,4 @@ export class AbstractSingleItemDbxFirebaseDocument extends AbstractDbxFirebaseDo
     setRef = this.updater((state, ref) => state);
     clearRefs = this.updater((state) => state);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.subcollection.document.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/model/modules/store/store.subcollection.document.ts"],"names":[],"mappings":"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","sourcesContent":["import { filterMaybe } from '@dereekb/rxjs';\nimport { Injectable } from '@angular/core';\nimport { Observable, shareReplay, distinctUntilChanged, map, NEVER, switchMap, tap, Subscription } from 'rxjs';\nimport { FirestoreDocument, FirestoreCollectionWithParentFactory, FirestoreCollection, DocumentReference, FirestoreModelId, FirestoreModelKey, SingleItemFirestoreCollection, firestoreModelKeyParentKey } from '@dereekb/firebase';\nimport { type Maybe } from '@dereekb/util';\nimport { AbstractDbxFirebaseDocumentStore, DbxFirebaseDocumentStore, DbxFirebaseDocumentStoreContextState } from './store.document';\nimport { DbxFirebaseComponentStoreWithParentSetParentStoreEffectFunction, setParentStoreEffect, DbxFirebaseComponentStoreWithParent, DbxFirebaseComponentStoreWithParentContextState, DbxFirebaseComponentStoreWithParentSetParentEffectFunction } from './store.subcollection.rxjs';\n\nexport interface DbxFirebaseDocumentWithParentStoreContextState<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>> extends DbxFirebaseDocumentStoreContextState<T, D>, DbxFirebaseComponentStoreWithParentContextState<T, PT, D, PD> {}\n\nexport interface DbxFirebaseDocumentWithParentStore<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>> extends DbxFirebaseDocumentStore<T, D>, DbxFirebaseComponentStoreWithParent<T, PT, D, PD, FirestoreCollection<T, D>> {}\n\n/**\n * Abstract DbxFirebaseDocumentStore that has a parent document from which is derives it's FiresbaseCollection from.\n */\n@Injectable()\nexport class AbstractDbxFirebaseDocumentWithParentStore<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>, C extends DbxFirebaseDocumentWithParentStoreContextState<T, PT, D, PD> = DbxFirebaseDocumentWithParentStoreContextState<T, PT, D, PD>> extends AbstractDbxFirebaseDocumentStore<T, D, C> implements DbxFirebaseDocumentWithParentStore<T, PT, D, PD> {\n  // MARK: Effects\n  readonly setParentStore: DbxFirebaseComponentStoreWithParentSetParentStoreEffectFunction<PT, PD> = setParentStoreEffect(this);\n  readonly setParent: DbxFirebaseComponentStoreWithParentSetParentEffectFunction<PD> = this.effect((input: Observable<Maybe<PD>>) => {\n    return input.pipe(\n      switchMap((parent) => {\n        this._setParentDocument(parent);\n\n        if (parent) {\n          return this.collectionFactory$.pipe(\n            tap((collectionFactory) => {\n              const collection = collectionFactory(parent);\n              this.setFirestoreCollection(collection);\n            })\n          );\n        } else {\n          // clear the current collection\n          this.setFirestoreCollection(undefined);\n\n          // do nothing until a parent is returned.\n          return NEVER;\n        }\n      })\n    );\n  });\n\n  readonly _setParent = this.setParent;\n\n  // MARK: Accessors\n  /**\n   * Returns the parent model key given the current key value.\n   */\n  readonly keyParentKey$ = this.key$.pipe(\n    map((x) => firestoreModelKeyParentKey(x, 1)),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly currentParent$: Observable<Maybe<PD>> = this.state$.pipe(\n    map((x) => x.parent),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly currentParentKey$: Observable<Maybe<FirestoreModelKey>> = this.state$.pipe(\n    map((x) => x.parent?.key),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly parent$: Observable<PD> = this.currentParent$.pipe(filterMaybe());\n  readonly parentKey$: Observable<Maybe<FirestoreModelKey>> = this.currentParentKey$.pipe(filterMaybe());\n\n  readonly currentCollectionFactory$: Observable<Maybe<FirestoreCollectionWithParentFactory<T, PT, D, PD>>> = this.state$.pipe(\n    map((x) => x.collectionFactory),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly collectionFactory$: Observable<FirestoreCollectionWithParentFactory<T, PT, D, PD>> = this.currentCollectionFactory$.pipe(filterMaybe());\n\n  // MARK: State Changes\n  /**\n   * Sets the collection factory function to use.\n   */\n  readonly setCollectionFactory = this.updater((state, collectionFactory: FirestoreCollectionWithParentFactory<T, PT, D, PD>) => ({ ...state, collectionFactory }));\n\n  /**\n   * Sets the parent on the current state.\n   */\n  readonly _setParentDocument = this.updater((state, parent: Maybe<PD>) => ({ ...state, parent }));\n}\n\n/**\n * AbstractDbxFirebaseDocumentWithParentStore extension for use with SingleItemFirestoreCollection.\n */\nexport class AbstractSingleItemDbxFirebaseDocument<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>, C extends DbxFirebaseDocumentWithParentStoreContextState<T, PT, D, PD> = DbxFirebaseDocumentWithParentStoreContextState<T, PT, D, PD>> extends AbstractDbxFirebaseDocumentWithParentStore<T, PT, D, PD, C> {\n  /**\n   * Sets the SingleItemFirestoreCollection to use.\n   */\n  override readonly setFirestoreCollection = this.updater((state, firestoreCollection: Maybe<FirestoreCollection<T, D>>) => {\n    if (firestoreCollection != null) {\n      const id = (firestoreCollection as SingleItemFirestoreCollection<T, PT, D, PD>).singleItemIdentifier;\n\n      if (id != null) {\n        return { ...state, firestoreCollection, id };\n      } else {\n        throw new Error('AbstractSingleItemDbxFirebaseDocument only accepts SingleItemFirestoreCollection values with a singleItemIdentifier set for setFirestoreCollection.');\n      }\n    } else {\n      return { ...state, firestoreCollection: null };\n    }\n  });\n\n  /**\n   * Does nothing on a AbstractSingleItemDbxFirebaseDocument.\n   *\n   * Ref is set with the FirestoreCollection\n   */\n  override readonly setId = this.updater((state, id: Maybe<FirestoreModelId>) => state) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\n\n  /**\n   * Does nothing on a AbstractSingleItemDbxFirebaseDocument.\n   *\n   * Ref is set with the FirestoreCollection\n   */\n  override readonly setKey = this.updater((state, key: Maybe<FirestoreModelKey>) => state) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\n\n  /**\n   * Does nothing on a AbstractSingleItemDbxFirebaseDocument.\n   *\n   * Ref is set with the FirestoreCollection\n   */\n  override readonly setRef = this.updater((state, ref: Maybe<DocumentReference<T>>) => state) as (observableOrValue: Maybe<DocumentReference<T>> | Observable<Maybe<DocumentReference<T>>>) => Subscription;\n  override readonly clearRefs = this.updater((state) => state);\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.subcollection.document.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/model/modules/store/store.subcollection.document.ts"],"names":[],"mappings":"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","sourcesContent":["import { filterMaybe } from '@dereekb/rxjs';\nimport { Injectable } from '@angular/core';\nimport { Observable, shareReplay, distinctUntilChanged, map, NEVER, switchMap, tap, Subscription } from 'rxjs';\nimport { FirestoreDocument, FirestoreCollectionWithParentFactory, FirestoreCollection, DocumentReference, FirestoreModelId, FirestoreModelKey, SingleItemFirestoreCollection, firestoreModelKeyParentKey } from '@dereekb/firebase';\nimport { type Maybe } from '@dereekb/util';\nimport { AbstractDbxFirebaseDocumentStore , DbxFirebaseDocumentStoreContextState } from './store.document';\nimport { DbxFirebaseDocumentStore } from './store';\nimport { DbxFirebaseComponentStoreWithParentSetParentStoreEffectFunction, setParentStoreEffect, DbxFirebaseComponentStoreWithParent, DbxFirebaseComponentStoreWithParentContextState, DbxFirebaseComponentStoreWithParentSetParentEffectFunction } from './store.subcollection.rxjs';\n\nexport interface DbxFirebaseDocumentWithParentStoreContextState<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>> extends DbxFirebaseDocumentStoreContextState<T, D>, DbxFirebaseComponentStoreWithParentContextState<T, PT, D, PD> {}\n\nexport interface DbxFirebaseDocumentWithParentStore<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>> extends DbxFirebaseDocumentStore<T, D>, DbxFirebaseComponentStoreWithParent<T, PT, D, PD, FirestoreCollection<T, D>> {}\n\n/**\n * Abstract DbxFirebaseDocumentStore that has a parent document from which is derives it's FiresbaseCollection from.\n */\n@Injectable()\nexport class AbstractDbxFirebaseDocumentWithParentStore<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>, C extends DbxFirebaseDocumentWithParentStoreContextState<T, PT, D, PD> = DbxFirebaseDocumentWithParentStoreContextState<T, PT, D, PD>> extends AbstractDbxFirebaseDocumentStore<T, D, C> implements DbxFirebaseDocumentWithParentStore<T, PT, D, PD> {\n  // MARK: Effects\n  readonly setParentStore: DbxFirebaseComponentStoreWithParentSetParentStoreEffectFunction<PT, PD> = setParentStoreEffect(this);\n  readonly setParent: DbxFirebaseComponentStoreWithParentSetParentEffectFunction<PD> = this.effect((input: Observable<Maybe<PD>>) => {\n    return input.pipe(\n      switchMap((parent) => {\n        this._setParentDocument(parent);\n\n        if (parent) {\n          return this.collectionFactory$.pipe(\n            tap((collectionFactory) => {\n              const collection = collectionFactory(parent);\n              this.setFirestoreCollection(collection);\n            })\n          );\n        } else {\n          // clear the current collection\n          this.setFirestoreCollection(undefined);\n\n          // do nothing until a parent is returned.\n          return NEVER;\n        }\n      })\n    );\n  });\n\n  readonly _setParent = this.setParent;\n\n  // MARK: Accessors\n  /**\n   * Returns the parent model key given the current key value.\n   */\n  readonly keyParentKey$ = this.key$.pipe(\n    map((x) => firestoreModelKeyParentKey(x, 1)),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly currentParent$: Observable<Maybe<PD>> = this.state$.pipe(\n    map((x) => x.parent),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly currentParentKey$: Observable<Maybe<FirestoreModelKey>> = this.state$.pipe(\n    map((x) => x.parent?.key),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly parent$: Observable<PD> = this.currentParent$.pipe(filterMaybe());\n  readonly parentKey$: Observable<Maybe<FirestoreModelKey>> = this.currentParentKey$.pipe(filterMaybe());\n\n  readonly currentCollectionFactory$: Observable<Maybe<FirestoreCollectionWithParentFactory<T, PT, D, PD>>> = this.state$.pipe(\n    map((x) => x.collectionFactory),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly collectionFactory$: Observable<FirestoreCollectionWithParentFactory<T, PT, D, PD>> = this.currentCollectionFactory$.pipe(filterMaybe());\n\n  // MARK: State Changes\n  /**\n   * Sets the collection factory function to use.\n   */\n  readonly setCollectionFactory = this.updater((state, collectionFactory: FirestoreCollectionWithParentFactory<T, PT, D, PD>) => ({ ...state, collectionFactory }));\n\n  /**\n   * Sets the parent on the current state.\n   */\n  readonly _setParentDocument = this.updater((state, parent: Maybe<PD>) => ({ ...state, parent }));\n}\n\n/**\n * AbstractDbxFirebaseDocumentWithParentStore extension for use with SingleItemFirestoreCollection.\n */\nexport class AbstractSingleItemDbxFirebaseDocument<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>, C extends DbxFirebaseDocumentWithParentStoreContextState<T, PT, D, PD> = DbxFirebaseDocumentWithParentStoreContextState<T, PT, D, PD>> extends AbstractDbxFirebaseDocumentWithParentStore<T, PT, D, PD, C> {\n  /**\n   * Sets the SingleItemFirestoreCollection to use.\n   */\n  override readonly setFirestoreCollection = this.updater((state, firestoreCollection: Maybe<FirestoreCollection<T, D>>) => {\n    if (firestoreCollection != null) {\n      const id = (firestoreCollection as SingleItemFirestoreCollection<T, PT, D, PD>).singleItemIdentifier;\n\n      if (id != null) {\n        return { ...state, firestoreCollection, id };\n      } else {\n        throw new Error('AbstractSingleItemDbxFirebaseDocument only accepts SingleItemFirestoreCollection values with a singleItemIdentifier set for setFirestoreCollection.');\n      }\n    } else {\n      return { ...state, firestoreCollection: null };\n    }\n  });\n\n  /**\n   * Does nothing on a AbstractSingleItemDbxFirebaseDocument.\n   *\n   * Ref is set with the FirestoreCollection\n   */\n  override readonly setId = this.updater((state, id: Maybe<FirestoreModelId>) => state) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\n\n  /**\n   * Does nothing on a AbstractSingleItemDbxFirebaseDocument.\n   *\n   * Ref is set with the FirestoreCollection\n   */\n  override readonly setKey = this.updater((state, key: Maybe<FirestoreModelKey>) => state) as (observableOrValue: Maybe<string> | Observable<Maybe<string>>) => Subscription;\n\n  /**\n   * Does nothing on a AbstractSingleItemDbxFirebaseDocument.\n   *\n   * Ref is set with the FirestoreCollection\n   */\n  override readonly setRef = this.updater((state, ref: Maybe<DocumentReference<T>>) => state) as (observableOrValue: Maybe<DocumentReference<T>> | Observable<Maybe<DocumentReference<T>>>) => Subscription;\n  override readonly clearRefs = this.updater((state) => state);\n}\n"]}

package/esm2022/lib/model/modules/store/store.subcollection.rxjs.mjs

@@ -20,4 +20,4 @@ export function setParentStoreEffect(store) {
         }));
     });
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RvcmUuc3ViY29sbGVjdGlvbi5yeGpzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZGJ4LWZpcmViYXNlL3NyYy9saWIvbW9kZWwvbW9kdWxlcy9zdG9yZS9zdG9yZS5zdWJjb2xsZWN0aW9uLnJ4anMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsT0FBTyxFQUFFLE9BQU8sRUFBMEIsTUFBTSxlQUFlLENBQUM7QUFHaEUsT0FBTyxFQUFFLEdBQUcsRUFBc0MsTUFBTSxNQUFNLENBQUM7QUFzQi9ELE1BQU0sVUFBVSxvQkFBb0IsQ0FBa00sS0FBMkQ7SUFDL1IsT0FBTyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUMsS0FBMEQsRUFBRSxFQUFFO1FBQ2pGLE9BQU8sS0FBSyxDQUFDLElBQUksQ0FDZixHQUFHLENBQUMsQ0FBQyxXQUFXLEVBQUUsRUFBRTtZQUNsQixJQUFJLE1BQTJCLENBQUM7WUFFaEMsSUFBSSxXQUFXLEVBQUUsQ0FBQztnQkFDaEIsTUFBTSxHQUFHLEtBQUssQ0FBQyxVQUFVLENBQUMsV0FBVyxDQUFDLGdCQUFnQixDQUFpQixDQUFDO1lBQzFFLENBQUM7aUJBQU0sQ0FBQztnQkFDTixNQUFNLEdBQUcsU0FBUyxDQUFDO1lBQ3JCLENBQUM7WUFFRCxpQ0FBaUM7WUFDakMsS0FBSyxDQUFDLGdCQUFnQixDQUFDLFdBQVcsQ0FBQyxDQUFDO1lBRXBDLE9BQU8sTUFBTSxDQUFDO1FBQ2hCLENBQUMsQ0FBQyxFQUNGLE9BQU8sQ0FBQyxDQUFDLEdBQUcsRUFBRSxFQUFFO1lBQ2QsSUFBSSxHQUFHLEVBQUUsQ0FBQztnQkFDUixHQUFHLENBQUMsV0FBVyxFQUFFLENBQUM7WUFDcEIsQ0FBQztRQUNILENBQUMsQ0FBQyxDQUNILENBQUM7SUFDSixDQUFDLENBQUMsQ0FBQztBQUNMLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyB0eXBlIExvY2tTZXRDb21wb25lbnRTdG9yZSB9IGZyb20gJ0BkZXJlZWtiL2RieC1jb3JlJztcbmltcG9ydCB7IHR5cGUgRmlyZXN0b3JlQ29sbGVjdGlvbkxpa2UsIHR5cGUgRmlyZXN0b3JlQ29sbGVjdGlvbldpdGhQYXJlbnRGYWN0b3J5LCB0eXBlIEZpcmVzdG9yZURvY3VtZW50IH0gZnJvbSAnQGRlcmVla2IvZmlyZWJhc2UnO1xuaW1wb3J0IHsgY2xlYW51cCwgdHlwZSBPYnNlcnZhYmxlT3JWYWx1ZSB9IGZyb20gJ0BkZXJlZWtiL3J4anMnO1xuaW1wb3J0IHsgdHlwZSBNYXliZSB9IGZyb20gJ0BkZXJlZWtiL3V0aWwnO1xuaW1wb3J0IHsgdHlwZSBDb21wb25lbnRTdG9yZSB9IGZyb20gJ0BuZ3J4L2NvbXBvbmVudC1zdG9yZSc7XG5pbXBvcnQgeyBtYXAsIHR5cGUgT2JzZXJ2YWJsZSwgdHlwZSBTdWJzY3JpcHRpb24gfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IHR5cGUgRGJ4RmlyZWJhc2VEb2N1bWVudFN0b3JlIH0gZnJvbSAnLi9zdG9yZS5kb2N1bWVudCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGJ4RmlyZWJhc2VDb21wb25lbnRTdG9yZVdpdGhQYXJlbnRDb250ZXh0U3RhdGU8VCwgUFQsIEQgZXh0ZW5kcyBGaXJlc3RvcmVEb2N1bWVudDxUPiA9IEZpcmVzdG9yZURvY3VtZW50PFQ+LCBQRCBleHRlbmRzIEZpcmVzdG9yZURvY3VtZW50PFBUPiA9IEZpcmVzdG9yZURvY3VtZW50PFBUPj4ge1xuICByZWFkb25seSBwYXJlbnQ/OiBNYXliZTxQRD47XG4gIHJlYWRvbmx5IGNvbGxlY3Rpb25GYWN0b3J5PzogTWF5YmU8RmlyZXN0b3JlQ29sbGVjdGlvbldpdGhQYXJlbnRGYWN0b3J5PFQsIFBULCBELCBQRD4+O1xufVxuXG5leHBvcnQgdHlwZSBEYnhGaXJlYmFzZUNvbXBvbmVudFN0b3JlU2V0UGFyZW50RWZmZWN0RnVuY3Rpb248UEQ+ID0gKHBhcmVudDogT2JzZXJ2YWJsZTxNYXliZTxQRD4+KSA9PiBTdWJzY3JpcHRpb247XG5leHBvcnQgdHlwZSBEYnhGaXJlYmFzZUNvbXBvbmVudFN0b3JlV2l0aFBhcmVudFNldFBhcmVudEVmZmVjdEZ1bmN0aW9uPFBEPiA9IChvYnNlcnZhYmxlT3JWYWx1ZTogT2JzZXJ2YWJsZU9yVmFsdWU8TWF5YmU8UEQ+PikgPT4gU3Vic2NyaXB0aW9uO1xuZXhwb3J0IHR5cGUgRGJ4RmlyZWJhc2VDb21wb25lbnRTdG9yZVdpdGhQYXJlbnRTZXRQYXJlbnRTdG9yZUVmZmVjdEZ1bmN0aW9uPFBULCBQRCBleHRlbmRzIEZpcmVzdG9yZURvY3VtZW50PFBUPiA9IEZpcmVzdG9yZURvY3VtZW50PFBUPj4gPSAob2JzZXJ2YWJsZU9yVmFsdWU6IE9ic2VydmFibGVPclZhbHVlPERieEZpcmViYXNlRG9jdW1lbnRTdG9yZTxQVCwgUEQ+PikgPT4gU3Vic2NyaXB0aW9uO1xuXG5leHBvcnQgaW50ZXJmYWNlIERieEZpcmViYXNlQ29tcG9uZW50U3RvcmVXaXRoUGFyZW50PFQsIFBULCBEIGV4dGVuZHMgRmlyZXN0b3JlRG9jdW1lbnQ8VD4gPSBGaXJlc3RvcmVEb2N1bWVudDxUPiwgUEQgZXh0ZW5kcyBGaXJlc3RvcmVEb2N1bWVudDxQVD4gPSBGaXJlc3RvcmVEb2N1bWVudDxQVD4sIEEgZXh0ZW5kcyBGaXJlc3RvcmVDb2xsZWN0aW9uTGlrZTxULCBEPiA9IEZpcmVzdG9yZUNvbGxlY3Rpb25MaWtlPFQsIEQ+PiBleHRlbmRzIExvY2tTZXRDb21wb25lbnRTdG9yZTxvYmplY3Q+LCBQaWNrPENvbXBvbmVudFN0b3JlPERieEZpcmViYXNlQ29tcG9uZW50U3RvcmVXaXRoUGFyZW50Q29udGV4dFN0YXRlPFQsIFBULCBELCBQRD4+LCAnZWZmZWN0Jz4ge1xuICByZWFkb25seSBjdXJyZW50UGFyZW50JDogT2JzZXJ2YWJsZTxNYXliZTxQRD4+O1xuICByZWFkb25seSBwYXJlbnQkOiBPYnNlcnZhYmxlPFBEPjtcbiAgcmVhZG9ubHkgY3VycmVudENvbGxlY3Rpb25GYWN0b3J5JDogT2JzZXJ2YWJsZTxNYXliZTxGaXJlc3RvcmVDb2xsZWN0aW9uV2l0aFBhcmVudEZhY3Rvcnk8VCwgUFQsIEQsIFBEPj4+O1xuICByZWFkb25seSBjb2xsZWN0aW9uRmFjdG9yeSQ6IE9ic2VydmFibGU8RmlyZXN0b3JlQ29sbGVjdGlvbldpdGhQYXJlbnRGYWN0b3J5PFQsIFBULCBELCBQRD4+O1xuICByZWFkb25seSBfc2V0UGFyZW50OiBEYnhGaXJlYmFzZUNvbXBvbmVudFN0b3JlU2V0UGFyZW50RWZmZWN0RnVuY3Rpb248UEQ+O1xuICByZWFkb25seSBfc2V0UGFyZW50RG9jdW1lbnQ6ICgoKSA9PiB2b2lkKSB8ICgob2JzZXJ2YWJsZU9yVmFsdWU6IE9ic2VydmFibGVPclZhbHVlPE1heWJlPFBEPj4pID0+IFN1YnNjcmlwdGlvbik7XG4gIHJlYWRvbmx5IHNldEZpcmVzdG9yZUNvbGxlY3Rpb246ICgoKSA9PiB2b2lkKSB8ICgob2JzZXJ2YWJsZU9yVmFsdWU6IE9ic2VydmFibGVPclZhbHVlPE1heWJlPEE+PikgPT4gU3Vic2NyaXB0aW9uKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHNldFBhcmVudFN0b3JlRWZmZWN0PFQsIFBULCBEIGV4dGVuZHMgRmlyZXN0b3JlRG9jdW1lbnQ8VD4gPSBGaXJlc3RvcmVEb2N1bWVudDxUPiwgUEQgZXh0ZW5kcyBGaXJlc3RvcmVEb2N1bWVudDxQVD4gPSBGaXJlc3RvcmVEb2N1bWVudDxQVD4sIEEgZXh0ZW5kcyBGaXJlc3RvcmVDb2xsZWN0aW9uTGlrZTxULCBEPiA9IEZpcmVzdG9yZUNvbGxlY3Rpb25MaWtlPFQsIEQ+PihzdG9yZTogRGJ4RmlyZWJhc2VDb21wb25lbnRTdG9yZVdpdGhQYXJlbnQ8VCwgUFQsIEQsIFBELCBBPik6IERieEZpcmViYXNlQ29tcG9uZW50U3RvcmVXaXRoUGFyZW50U2V0UGFyZW50U3RvcmVFZmZlY3RGdW5jdGlvbjxQVCwgUEQ+IHtcbiAgcmV0dXJuIHN0b3JlLmVmZmVjdCgoaW5wdXQ6IE9ic2VydmFibGU8TWF5YmU8RGJ4RmlyZWJhc2VEb2N1bWVudFN0b3JlPFBULCBQRD4+PikgPT4ge1xuICAgIHJldHVybiBpbnB1dC5waXBlKFxuICAgICAgbWFwKChwYXJlbnRTdG9yZSkgPT4ge1xuICAgICAgICBsZXQgcmVzdWx0OiBNYXliZTxTdWJzY3JpcHRpb24+O1xuXG4gICAgICAgIGlmIChwYXJlbnRTdG9yZSkge1xuICAgICAgICAgIHJlc3VsdCA9IHN0b3JlLl9zZXRQYXJlbnQocGFyZW50U3RvcmUuY3VycmVudERvY3VtZW50JCkgYXMgU3Vic2NyaXB0aW9uO1xuICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgIHJlc3VsdCA9IHVuZGVmaW5lZDtcbiAgICAgICAgfVxuXG4gICAgICAgIC8vIHNldCBhcyB0aGUgcGFyZW50IGxvY2sgc2V0IHRvb1xuICAgICAgICBzdG9yZS5zZXRQYXJlbnRMb2NrU2V0KHBhcmVudFN0b3JlKTtcblxuICAgICAgICByZXR1cm4gcmVzdWx0O1xuICAgICAgfSksXG4gICAgICBjbGVhbnVwKChzdWIpID0+IHtcbiAgICAgICAgaWYgKHN1Yikge1xuICAgICAgICAgIHN1Yi51bnN1YnNjcmliZSgpO1xuICAgICAgICB9XG4gICAgICB9KVxuICAgICk7XG4gIH0pO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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