@dereekb/dbx-firebase 9.19.4 → 9.20.0

package/esm2020/lib/model/modules/store/store.document.router.key.directive.mjs

@@ -0,0 +1,67 @@
+import { Directive, Host, Input } from '@angular/core';
+import { DbxRouterService, AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { DbxFirebaseDocumentStoreDirective } from './store.document.directive';
+import { dbxFirebaseKeyRouteParamRedirect } from '../../../router';
+import * as i0 from "@angular/core";
+import * as i1 from "./store.document.directive";
+import * as i2 from "@dereekb/dbx-core";
+/**
+ * Used for synchronizing the document store key to the param of the route. The param is interpreted as a TwoWayFlatFirestoreModelKey.
+ */
+export class DbxFirebaseDocumentStoreRouteKeyDirective extends AbstractSubscriptionDirective {
+    constructor(dbxFirebaseDocumentStoreDirective, dbxRouterService) {
+        super();
+        this.dbxFirebaseDocumentStoreDirective = dbxFirebaseDocumentStoreDirective;
+        this.dbxRouterService = dbxRouterService;
+        this._redirectInstance = dbxFirebaseKeyRouteParamRedirect(this.dbxRouterService);
+        this.keyFromParams$ = this._redirectInstance.paramValue$;
+        this.key$ = this._redirectInstance.value$;
+    }
+    ngOnInit() {
+        this.sub = this.dbxFirebaseDocumentStoreDirective.store.setFlatKey(this.keyFromParams$); // use from the params, as the params should get updated eventually to the key$ value
+        this._redirectInstance.init();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._redirectInstance.destroy();
+    }
+    // MARK: Input
+    get keyParam() {
+        return this._redirectInstance.paramKey;
+    }
+    set keyParam(keyParam) {
+        this._redirectInstance.paramKey = keyParam;
+    }
+    set dbxFirebaseDocumentStoreRouteKeyDefault(defaultValue) {
+        this._redirectInstance.setDefaultValue(defaultValue);
+    }
+    /**
+     * Whether or not to enable the redirection. Is enabled by default.
+     */
+    set dbxFirebaseDocumentStoreRouteKeyDefaultRedirect(redirect) {
+        this._redirectInstance.setRedirectEnabled(redirect !== false); // true by default
+    }
+    set dbxFirebaseDocumentStoreRouteKeyDefaultDecision(decider) {
+        this._redirectInstance.setDecider(decider);
+    }
+}
+DbxFirebaseDocumentStoreRouteKeyDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxFirebaseDocumentStoreRouteKeyDirective, deps: [{ token: i1.DbxFirebaseDocumentStoreDirective, host: true }, { token: i2.DbxRouterService }], target: i0.ɵɵFactoryTarget.Directive });
+DbxFirebaseDocumentStoreRouteKeyDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.12", type: DbxFirebaseDocumentStoreRouteKeyDirective, selector: "[dbxFirebaseDocumentStoreRouteKey]", inputs: { keyParam: ["dbxFirebaseDocumentStoreRouteKey", "keyParam"], dbxFirebaseDocumentStoreRouteKeyDefault: "dbxFirebaseDocumentStoreRouteKeyDefault", dbxFirebaseDocumentStoreRouteKeyDefaultRedirect: "dbxFirebaseDocumentStoreRouteKeyDefaultRedirect", dbxFirebaseDocumentStoreRouteKeyDefaultDecision: "dbxFirebaseDocumentStoreRouteKeyDefaultDecision" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxFirebaseDocumentStoreRouteKeyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxFirebaseDocumentStoreRouteKey]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DbxFirebaseDocumentStoreDirective, decorators: [{
+                    type: Host
+                }] }, { type: i2.DbxRouterService }]; }, propDecorators: { keyParam: [{
+                type: Input,
+                args: ['dbxFirebaseDocumentStoreRouteKey']
+            }], dbxFirebaseDocumentStoreRouteKeyDefault: [{
+                type: Input
+            }], dbxFirebaseDocumentStoreRouteKeyDefaultRedirect: [{
+                type: Input
+            }], dbxFirebaseDocumentStoreRouteKeyDefaultDecision: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/modules/store/store.subcollection.directive.mjs

@@ -0,0 +1,30 @@
+import { Directive, forwardRef, Input } from '@angular/core';
+import { DbxFirebaseCollectionStoreDirective, provideDbxFirebaseCollectionStoreDirective } from './store.collection.directive';
+import * as i0 from "@angular/core";
+/**
+ * Abstract directive that contains a DbxFirebaseCollectionWithParentStore and provides an interface for communicating with other directives.
+ */
+export class DbxFirebaseCollectionWithParentStoreDirective extends DbxFirebaseCollectionStoreDirective {
+    // MARK: Inputs
+    set sourceMode(sourceMode) {
+        this.store.setSourceMode(sourceMode);
+    }
+}
+DbxFirebaseCollectionWithParentStoreDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxFirebaseCollectionWithParentStoreDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+DbxFirebaseCollectionWithParentStoreDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.12", type: DbxFirebaseCollectionWithParentStoreDirective, inputs: { sourceMode: "sourceMode" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxFirebaseCollectionWithParentStoreDirective, decorators: [{
+            type: Directive
+        }], propDecorators: { sourceMode: [{
+                type: Input
+            }] } });
+export function provideDbxFirebaseCollectionWithParentStoreDirective(sourceType, storeType) {
+    const providers = [
+        ...provideDbxFirebaseCollectionStoreDirective(sourceType, storeType),
+        {
+            provide: DbxFirebaseCollectionWithParentStoreDirective,
+            useExisting: forwardRef(() => sourceType)
+        }
+    ];
+    return providers;
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,98 @@
+import { filterMaybe } from '@dereekb/rxjs';
+import { Injectable } from '@angular/core';
+import { shareReplay, distinctUntilChanged, map, NEVER, switchMap, tap } from 'rxjs';
+import { AbstractDbxFirebaseDocumentStore } from './store.document';
+import { setParentStoreEffect } from './store.subcollection.rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Abstract DbxFirebaseDocumentStore that has a parent document from which is derives it's FiresbaseCollection from.
+ */
+export class AbstractDbxFirebaseDocumentWithParentStore extends AbstractDbxFirebaseDocumentStore {
+    constructor() {
+        super(...arguments);
+        // MARK: Effects
+        this.setParentStore = setParentStoreEffect(this);
+        this.setParent = this.effect((input) => {
+            return input.pipe(switchMap((parent) => {
+                this._setParentDocument(parent);
+                if (parent) {
+                    return this.collectionFactory$.pipe(tap((collectionFactory) => {
+                        const collection = collectionFactory(parent);
+                        this.setFirestoreCollection(collection);
+                    }));
+                }
+                else {
+                    // clear the current collection
+                    this.setFirestoreCollection(undefined);
+                    // do nothing until a parent is returned.
+                    return NEVER;
+                }
+            }));
+        });
+        this._setParent = this.setParent;
+        // MARK: Accessors
+        this.currentParent$ = this.state$.pipe(map((x) => x.parent), distinctUntilChanged(), shareReplay(1));
+        this.parent$ = this.currentParent$.pipe(filterMaybe());
+        this.currentCollectionFactory$ = this.state$.pipe(map((x) => x.collectionFactory), distinctUntilChanged(), shareReplay(1));
+        this.collectionFactory$ = this.currentCollectionFactory$.pipe(filterMaybe());
+        // MARK: State Changes
+        /**
+         * Sets the collection factory function to use.
+         */
+        this.setCollectionFactory = this.updater((state, collectionFactory) => ({ ...state, collectionFactory }));
+        /**
+         * Sets the parent on the current state.
+         */
+        this._setParentDocument = this.updater((state, parent) => ({ ...state, parent }));
+    }
+}
+AbstractDbxFirebaseDocumentWithParentStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AbstractDbxFirebaseDocumentWithParentStore, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+AbstractDbxFirebaseDocumentWithParentStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AbstractDbxFirebaseDocumentWithParentStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AbstractDbxFirebaseDocumentWithParentStore, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * AbstractDbxFirebaseDocumentWithParentStore extension for use with SingleItemFirestoreCollection.
+ */
+export class AbstractSingleItemDbxFirebaseDocument extends AbstractDbxFirebaseDocumentWithParentStore {
+    constructor() {
+        super(...arguments);
+        /**
+         * Sets the SingleItemFirestoreCollection to use.
+         */
+        this.setFirestoreCollection = this.updater((state, firestoreCollection) => {
+            if (firestoreCollection != null) {
+                const id = firestoreCollection.singleItemIdentifier;
+                if (id != null) {
+                    return { ...state, firestoreCollection, id };
+                }
+                else {
+                    throw new Error('AbstractSingleItemDbxFirebaseDocument only accepts SingleItemFirestoreCollection values with a singleItemIdentifier set for setFirestoreCollection.');
+                }
+            }
+            else {
+                return { ...state, firestoreCollection: null };
+            }
+        });
+        /**
+         * Does nothing on a AbstractSingleItemDbxFirebaseDocument.
+         *
+         * Ref is set with the FirestoreCollection
+         */
+        this.setId = this.updater((state, id) => state);
+        /**
+         * Does nothing on a AbstractSingleItemDbxFirebaseDocument.
+         *
+         * Ref is set with the FirestoreCollection
+         */
+        this.setKey = this.updater((state, key) => state);
+        /**
+         * Does nothing on a AbstractSingleItemDbxFirebaseDocument.
+         *
+         * Ref is set with the FirestoreCollection
+         */
+        this.setRef = this.updater((state, ref) => state);
+        this.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 } from '@dereekb/firebase';\nimport { 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  readonly currentParent$: Observable<Maybe<PD>> = this.state$.pipe(\n    map((x) => x.parent),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly parent$: Observable<PD> = this.currentParent$.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\n  override readonly clearRefs = this.updater((state) => state);\n}\n"]}

package/esm2020/lib/model/modules/store/store.subcollection.mjs

@@ -0,0 +1,79 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { filterMaybe } from '@dereekb/rxjs';
+import { shareReplay, distinctUntilChanged, map, NEVER, switchMap, tap } from 'rxjs';
+import { AbstractDbxFirebaseCollectionStore } from './store.collection';
+import { setParentStoreEffect } from './store.subcollection.rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Abstract DbxFirebaseCollectionStore that has a parent document from which is derives it's FiresbaseCollection from.
+ */
+export class AbstractDbxFirebaseCollectionWithParentStore extends AbstractDbxFirebaseCollectionStore {
+    constructor(state, defaultSourceMode) {
+        super(state);
+        // MARK: Effects
+        this.setParentStore = setParentStoreEffect(this);
+        this.setSourceMode = this.effect((input) => {
+            return input.pipe(distinctUntilChanged(), switchMap((inputMode) => {
+                const mode = inputMode?.toLowerCase() ?? 'parent'; // default to parent mode
+                if (mode === 'group') {
+                    return this.currentCollectionGroup$.pipe(tap((collectionGroup) => {
+                        this.setFirestoreCollection(collectionGroup);
+                    }));
+                }
+                else {
+                    // parent document collection
+                    return this.currentParent$.pipe(switchMap((parent) => {
+                        if (parent) {
+                            return this.collectionFactory$.pipe(tap((collectionFactory) => {
+                                const collection = collectionFactory(parent);
+                                this.setFirestoreCollection(collection);
+                            }));
+                        }
+                        else {
+                            this.setFirestoreCollection(undefined);
+                            return NEVER;
+                        }
+                    }));
+                }
+            }));
+        });
+        // MARK: Accessors
+        this.currentParent$ = this.state$.pipe(map((x) => x.parent), distinctUntilChanged(), shareReplay(1));
+        this.parent$ = this.currentParent$.pipe(filterMaybe());
+        this.currentCollectionFactory$ = this.state$.pipe(map((x) => x.collectionFactory), distinctUntilChanged(), shareReplay(1));
+        this.collectionFactory$ = this.currentCollectionFactory$.pipe(filterMaybe());
+        this.currentCollectionGroup$ = this.state$.pipe(map((x) => x.collectionGroup), distinctUntilChanged(), shareReplay(1));
+        this.collectionGroup$ = this.currentCollectionGroup$.pipe(filterMaybe());
+        // MARK: State Changes
+        /**
+         * Sets the collection factory function to use.
+         */
+        this.setCollectionFactory = this.updater((state, collectionFactory) => ({ ...state, collectionFactory }));
+        /**
+         * Sets the collection group to use.
+         */
+        this.setCollectionGroup = this.updater((state, collectionGroup) => ({ ...state, collectionGroup }));
+        /**
+         * Sets the parent on the current state.
+         */
+        this._setParentDocument = this.updater((state, parent) => ({ ...state, parent }));
+        this._setParent = this._setParentDocument;
+        this.setSourceMode(defaultSourceMode || 'parent');
+    }
+}
+AbstractDbxFirebaseCollectionWithParentStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AbstractDbxFirebaseCollectionWithParentStore, deps: [{ token: null, optional: true }, { token: null, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+AbstractDbxFirebaseCollectionWithParentStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AbstractDbxFirebaseCollectionWithParentStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: AbstractDbxFirebaseCollectionWithParentStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [null]
+                }, {
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [null]
+                }, {
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.subcollection.js","sourceRoot":"","sources":["../../../../../../../../packages/dbx-firebase/src/lib/model/modules/store/store.subcollection.ts"],"names":[],"mappings":"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","sourcesContent":["import { Maybe } from '@dereekb/util';\nimport { Inject, Injectable, Optional } from '@angular/core';\nimport { filterMaybe, ObservableOrValue } from '@dereekb/rxjs';\nimport { Observable, shareReplay, distinctUntilChanged, map, Subscription, NEVER, switchMap, tap } from 'rxjs';\nimport { FirestoreCollectionGroup, FirestoreCollectionWithParentFactory, FirestoreDocument } from '@dereekb/firebase';\nimport { AbstractDbxFirebaseCollectionStore, DbxFirebaseCollectionStore, DbxFirebaseCollectionStoreContextState } from './store.collection';\nimport { DbxFirebaseComponentStoreSetParentEffectFunction, DbxFirebaseComponentStoreWithParent, DbxFirebaseComponentStoreWithParentContextState, DbxFirebaseComponentStoreWithParentSetParentStoreEffectFunction, setParentStoreEffect } from './store.subcollection.rxjs';\n\n/**\n * Whether or not to load values from a parent or a group.\n */\nexport type DbxFirebaseComponentStoreWithParentSourceMode = 'parent' | 'group';\n\nexport interface DbxFirebaseCollectionWithParentStoreContextState<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>> extends DbxFirebaseCollectionStoreContextState<T, D>, DbxFirebaseComponentStoreWithParentContextState<T, PT, D, PD> {\n  readonly mode?: Maybe<DbxFirebaseComponentStoreWithParentSourceMode>;\n  readonly collectionGroup?: Maybe<FirestoreCollectionGroup<T, D>>;\n}\n\nexport type DbxFirebaseComponentStoreWithParentSetParentSourceModeFunction = (observableOrValue: ObservableOrValue<Maybe<DbxFirebaseComponentStoreWithParentSourceMode>>) => Subscription;\n\nexport interface DbxFirebaseCollectionWithParentStore<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>> extends DbxFirebaseCollectionStore<T, D>, DbxFirebaseComponentStoreWithParent<T, PT, D, PD> {\n  readonly setSourceMode: DbxFirebaseComponentStoreWithParentSetParentSourceModeFunction;\n  readonly setCollectionGroup: (observableOrValue: FirestoreCollectionGroup<T, D> | Observable<FirestoreCollectionGroup<T, D>>) => Subscription;\n  readonly currentCollectionGroup$: Observable<Maybe<FirestoreCollectionGroup<T, D>>>;\n  readonly collectionGroup$: Observable<FirestoreCollectionGroup<T, D>>;\n}\n\n/**\n * Abstract DbxFirebaseCollectionStore that has a parent document from which is derives it's FiresbaseCollection from.\n */\n@Injectable()\nexport class AbstractDbxFirebaseCollectionWithParentStore<T, PT, D extends FirestoreDocument<T> = FirestoreDocument<T>, PD extends FirestoreDocument<PT> = FirestoreDocument<PT>, C extends DbxFirebaseCollectionWithParentStoreContextState<T, PT, D, PD> = DbxFirebaseCollectionWithParentStoreContextState<T, PT, D, PD>> extends AbstractDbxFirebaseCollectionStore<T, D, C> implements DbxFirebaseCollectionWithParentStore<T, PT, D, PD> {\n  constructor(@Inject(null) @Optional() state: C, @Inject(null) @Optional() defaultSourceMode?: DbxFirebaseComponentStoreWithParentSourceMode) {\n    super(state);\n    this.setSourceMode(defaultSourceMode || 'parent');\n  }\n\n  // MARK: Effects\n  readonly setParentStore: DbxFirebaseComponentStoreWithParentSetParentStoreEffectFunction<PT, PD> = setParentStoreEffect(this);\n  readonly setSourceMode: DbxFirebaseComponentStoreWithParentSetParentSourceModeFunction = this.effect((input: Observable<Maybe<DbxFirebaseComponentStoreWithParentSourceMode>>) => {\n    return input.pipe(\n      distinctUntilChanged(),\n      switchMap((inputMode) => {\n        const mode = inputMode?.toLowerCase() ?? 'parent'; // default to parent mode\n\n        if (mode === 'group') {\n          return this.currentCollectionGroup$.pipe(\n            tap((collectionGroup) => {\n              this.setFirestoreCollection(collectionGroup);\n            })\n          );\n        } else {\n          // parent document collection\n          return this.currentParent$.pipe(\n            switchMap((parent) => {\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                this.setFirestoreCollection(undefined);\n                return NEVER;\n              }\n            })\n          );\n        }\n      })\n    );\n  });\n\n  // MARK: Accessors\n  readonly currentParent$: Observable<Maybe<PD>> = this.state$.pipe(\n    map((x) => x.parent),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly parent$: Observable<PD> = this.currentParent$.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  readonly currentCollectionGroup$: Observable<Maybe<FirestoreCollectionGroup<T, D>>> = this.state$.pipe(\n    map((x) => x.collectionGroup),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n\n  readonly collectionGroup$: Observable<FirestoreCollectionGroup<T, D>> = this.currentCollectionGroup$.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 collection group to use.\n   */\n  readonly setCollectionGroup = this.updater((state, collectionGroup: Maybe<FirestoreCollectionGroup<T, D>>) => ({ ...state, collectionGroup })) as (observableOrValue: Maybe<FirestoreCollectionGroup<T, D>> | Observable<Maybe<FirestoreCollectionGroup<T, D>>>) => Subscription;\n\n  /**\n   * Sets the parent on the current state.\n   */\n  readonly _setParentDocument = this.updater((state, parent: Maybe<PD>) => ({ ...state, parent }));\n  readonly _setParent = this._setParentDocument as DbxFirebaseComponentStoreSetParentEffectFunction<PD>;\n}\n"]}

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

@@ -0,0 +1,23 @@
+import { cleanup } from '@dereekb/rxjs';
+import { map } from 'rxjs';
+export function setParentStoreEffect(store) {
+    return store.effect((input) => {
+        return input.pipe(map((parentStore) => {
+            let result;
+            if (parentStore) {
+                result = store._setParent(parentStore.currentDocument$);
+            }
+            else {
+                result = undefined;
+            }
+            // set as the parent lock set too
+            store.setParentLockSet(parentStore);
+            return result;
+        }), cleanup((sub) => {
+            if (sub) {
+                sub.unsubscribe();
+            }
+        }));
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,2 +1,4 @@
+export * from './model.context.instance';
+export * from './model.context.service';
 export * from './model.context';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9tb2RlbC9zZXJ2aWNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21vZGVsLmNvbnRleHQnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9tb2RlbC9zZXJ2aWNlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLGlCQUFpQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9tb2RlbC5jb250ZXh0Lmluc3RhbmNlJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWwuY29udGV4dC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWwuY29udGV4dCc7XG4iXX0=

package/esm2020/lib/model/service/model.context.instance.mjs

@@ -0,0 +1,54 @@
+import { asObservable } from '@dereekb/rxjs';
+import { map, switchMap, shareReplay, distinctUntilChanged } from 'rxjs';
+export function dbxFirebaseInContextFirebaseModelServiceInstanceFactory(context$) {
+    return (type, keyObs) => {
+        const key$ = asObservable(keyObs);
+        const modelServiceObs = context$.pipe(map((x) => x(type)), switchMap((service) => key$.pipe(map((key) => service(key)))));
+        return new DbxFirebaseInContextFirebaseModelServiceInstance(modelServiceObs);
+    };
+}
+/**
+ * Wraps an InModelContextFirebaseModelService observable and provides different piped observables.
+ */
+export class DbxFirebaseInContextFirebaseModelServiceInstance {
+    constructor(modelService$) {
+        this.modelService$ = modelService$;
+        this.key$ = this.modelService$.pipe(map((x) => x.model.key));
+        // MARK: Model
+        this.modelType$ = this.modelService$.pipe(map((x) => x.model.modelType), distinctUntilChanged());
+        this.model$ = this.modelService$.pipe(map((x) => x.model), distinctUntilChanged((a, b) => a.key === b.key), shareReplay(1));
+        this.snapshotData$ = this.model$.pipe(switchMap((x) => x.snapshotData()), shareReplay(1));
+        // MARK: Roles
+        this.roleReader$ = this.modelService$.pipe(switchMap((x) => x.roleReader()), shareReplay(1));
+        this.roleMap$ = this.roleReader$.pipe(map((x) => x.roleMap), shareReplay(1));
+        this.hasNoAccess$ = this.roleReader$.pipe(map((x) => x.hasNoAccess()), shareReplay(1));
+    }
+    snapshotStream(mode) {
+        return this.model$.pipe(switchMap((x) => x.snapshotStream(mode)), shareReplay(1));
+    }
+    snapshotDataStream(mode, options) {
+        return this.model$.pipe(switchMap((x) => x.snapshotDataStream(mode)), shareReplay(1));
+    }
+    truthMap(input) {
+        return this.roleReader$.pipe(map((x) => x.truthMap(input)), shareReplay(1));
+    }
+    hasAnyRoles(roles) {
+        return this.hasRoles('any', roles);
+    }
+    hasAllRoles(roles) {
+        return this.hasRoles('all', roles);
+    }
+    hasRoles(setIncludes, roles) {
+        return this.roleReader$.pipe(map((x) => x.hasRoles(setIncludes, roles)), distinctUntilChanged(), shareReplay(1));
+    }
+    containsAnyRoles(roles) {
+        return this.containsRoles('any', roles);
+    }
+    containsAllRoles(roles) {
+        return this.containsRoles('all', roles);
+    }
+    containsRoles(setIncludes, roles) {
+        return this.roleReader$.pipe(map((x) => x.containsRoles(setIncludes, roles)), distinctUntilChanged(), shareReplay(1));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model.context.instance.js","sourceRoot":"","sources":["../../../../../../../packages/dbx-firebase/src/lib/model/service/model.context.instance.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAqB,MAAM,eAAe,CAAC;AAEhE,OAAO,EAAE,GAAG,EAAc,SAAS,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,MAAM,CAAC;AAKrF,MAAM,UAAU,uDAAuD,CAA2H,QAAuB;IACvN,OAAO,CAAwE,IAAuI,EAAE,MAAmC,EAAE,EAAE;QAC7P,MAAM,IAAI,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;QAClC,MAAM,eAAe,GAAG,QAAQ,CAAC,IAAI,CACnC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EACnB,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CACkC,CAAC;QAElG,OAAO,IAAI,gDAAgD,CAAU,eAAe,CAAC,CAAC;IACxF,CAAC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,OAAO,gDAAgD;IAC3D,YAAqB,aAAgG;QAAhG,kBAAa,GAAb,aAAa,CAAmF;QAE5G,SAAI,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;QAEjE,cAAc;QACL,eAAU,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAC3C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,SAAS,CAAC,EAC7B,oBAAoB,EAAE,CACvB,CAAC;QAEO,WAAM,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CACvC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,EACnB,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,EAC/C,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;QAEO,kBAAa,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CACvC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,EAClC,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;QAgBF,cAAc;QACL,gBAAW,GAAG,IAAI,CAAC,aAAa,CAAC,IAAI,CAC5C,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,EAChC,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;QAEO,aAAQ,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CACvC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,EACrB,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;QAEO,iBAAY,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAC3C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,EAC3B,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;IAjDsH,CAAC;IAqBzH,cAAc,CAAC,IAAiC;QAC9C,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CACrB,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EACxC,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;IACJ,CAAC;IAED,kBAAkB,CAAC,IAAiC,EAAE,OAAyB;QAC7E,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CACrB,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC,EAC5C,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;IACJ,CAAC;IAkBD,QAAQ,CAA8C,KAAQ;QAC5D,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAC1B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAC7B,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;IACJ,CAAC;IAED,WAAW,CAAC,KAAyB;QACnC,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACrC,CAAC;IAED,WAAW,CAAC,KAAyB;QACnC,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACrC,CAAC;IAED,QAAQ,CAAC,WAA4B,EAAE,KAAyB;QAC9D,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAC1B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,EAC1C,oBAAoB,EAAE,EACtB,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;IACJ,CAAC;IAED,gBAAgB,CAAC,KAAyB;QACxC,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED,gBAAgB,CAAC,KAAyB;QACxC,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAC1C,CAAC;IAED,aAAa,CAAC,WAA4B,EAAE,KAAyB;QACnE,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAC1B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,EAC/C,oBAAoB,EAAE,EACtB,WAAW,CAAC,CAAC,CAAC,CACf,CAAC;IACJ,CAAC;CACF","sourcesContent":["import { FirestoreDocument, FirebasePermissionErrorContext, InModelContextFirebaseModelService, FirestoreDocumentData, DocumentSnapshot, FirestoreAccessorStreamMode, SnapshotOptions, firestoreModelKeyCollectionType, FirestoreCollectionType, FirebaseModelServiceContext, FirebaseModelsServiceFactory, FirestoreModelIdentity, InContextFirebaseModelsService, FirestoreModelIdentityModelType, FirebaseModelsService } from '@dereekb/firebase';\nimport { GrantedRole, GrantedRoleTruthMap, GrantedRoleTruthMapObject } from '@dereekb/model';\nimport { asObservable, ObservableOrValue } from '@dereekb/rxjs';\nimport { SetIncludesMode, IterableOrValue, ModelKey } from '@dereekb/util';\nimport { map, Observable, switchMap, shareReplay, distinctUntilChanged } from 'rxjs';\nimport { DbxFirebaseInContextFirebaseModelInfoServiceInstance } from './model.context';\n\nexport type DbxFirebaseInContextFirebaseModelServiceInstanceFactory<S extends InContextFirebaseModelsService<any>, C extends FirebasePermissionErrorContext = FirebasePermissionErrorContext> = <D extends FirestoreDocument<any>, R extends GrantedRole = GrantedRole>(type: S extends InContextFirebaseModelsService<infer Y> ? (Y extends FirebaseModelsService<infer X, infer C> ? keyof X : never) : never, keyObs: ObservableOrValue<ModelKey>) => DbxFirebaseInContextFirebaseModelServiceInstance<D, R, C>;\n\nexport function dbxFirebaseInContextFirebaseModelServiceInstanceFactory<S extends InContextFirebaseModelsService<any>, C extends FirebasePermissionErrorContext = FirebasePermissionErrorContext>(context$: Observable<S>): DbxFirebaseInContextFirebaseModelServiceInstanceFactory<S, C> {\n  return <D extends FirestoreDocument<any>, R extends GrantedRole = GrantedRole>(type: S extends InContextFirebaseModelsService<infer Y> ? (Y extends FirebaseModelsService<infer X, infer C> ? keyof X : never) : never, keyObs: ObservableOrValue<ModelKey>) => {\n    const key$ = asObservable(keyObs);\n    const modelServiceObs = context$.pipe(\n      map((x) => x(type)),\n      switchMap((service) => key$.pipe(map((key) => service(key))))\n    ) as unknown as Observable<InModelContextFirebaseModelService<C, FirestoreDocumentData<D>, D, R>>;\n\n    return new DbxFirebaseInContextFirebaseModelServiceInstance<D, R, C>(modelServiceObs);\n  };\n}\n\n/**\n * Wraps an InModelContextFirebaseModelService observable and provides different piped observables.\n */\nexport class DbxFirebaseInContextFirebaseModelServiceInstance<D extends FirestoreDocument<any>, R extends GrantedRole = GrantedRole, C extends FirebasePermissionErrorContext = FirebasePermissionErrorContext> implements DbxFirebaseInContextFirebaseModelInfoServiceInstance<D, R> {\n  constructor(readonly modelService$: Observable<InModelContextFirebaseModelService<C, FirestoreDocumentData<D>, D, R>>) {}\n\n  readonly key$ = this.modelService$.pipe(map((x) => x.model.key));\n\n  // MARK: Model\n  readonly modelType$ = this.modelService$.pipe(\n    map((x) => x.model.modelType),\n    distinctUntilChanged()\n  );\n\n  readonly model$ = this.modelService$.pipe(\n    map((x) => x.model),\n    distinctUntilChanged((a, b) => a.key === b.key),\n    shareReplay(1)\n  );\n\n  readonly snapshotData$ = this.model$.pipe(\n    switchMap((x) => x.snapshotData()),\n    shareReplay(1)\n  );\n\n  snapshotStream(mode: FirestoreAccessorStreamMode): Observable<DocumentSnapshot<FirestoreDocumentData<D>>> {\n    return this.model$.pipe(\n      switchMap((x) => x.snapshotStream(mode)),\n      shareReplay(1)\n    );\n  }\n\n  snapshotDataStream(mode: FirestoreAccessorStreamMode, options?: SnapshotOptions): Observable<FirestoreDocumentData<D>> {\n    return this.model$.pipe(\n      switchMap((x) => x.snapshotDataStream(mode)),\n      shareReplay(1)\n    );\n  }\n\n  // MARK: Roles\n  readonly roleReader$ = this.modelService$.pipe(\n    switchMap((x) => x.roleReader()),\n    shareReplay(1)\n  );\n\n  readonly roleMap$ = this.roleReader$.pipe(\n    map((x) => x.roleMap),\n    shareReplay(1)\n  );\n\n  readonly hasNoAccess$ = this.roleReader$.pipe(\n    map((x) => x.hasNoAccess()),\n    shareReplay(1)\n  );\n\n  truthMap<M extends GrantedRoleTruthMapObject<any, R>>(input: M): Observable<GrantedRoleTruthMap<M>> {\n    return this.roleReader$.pipe(\n      map((x) => x.truthMap(input)),\n      shareReplay(1)\n    );\n  }\n\n  hasAnyRoles(roles: IterableOrValue<R>): Observable<boolean> {\n    return this.hasRoles('any', roles);\n  }\n\n  hasAllRoles(roles: IterableOrValue<R>): Observable<boolean> {\n    return this.hasRoles('all', roles);\n  }\n\n  hasRoles(setIncludes: SetIncludesMode, roles: IterableOrValue<R>): Observable<boolean> {\n    return this.roleReader$.pipe(\n      map((x) => x.hasRoles(setIncludes, roles)),\n      distinctUntilChanged(),\n      shareReplay(1)\n    );\n  }\n\n  containsAnyRoles(roles: IterableOrValue<R>): Observable<boolean> {\n    return this.containsRoles('any', roles);\n  }\n\n  containsAllRoles(roles: IterableOrValue<R>): Observable<boolean> {\n    return this.containsRoles('all', roles);\n  }\n\n  containsRoles(setIncludes: SetIncludesMode, roles: IterableOrValue<R>): Observable<boolean> {\n    return this.roleReader$.pipe(\n      map((x) => x.containsRoles(setIncludes, roles)),\n      distinctUntilChanged(),\n      shareReplay(1)\n    );\n  }\n}\n"]}

package/esm2020/lib/model/service/model.context.mjs

@@ -1,35 +1,2 @@
-import { map, switchMap, shareReplay, distinctUntilChanged } from 'rxjs';
-/**
- * Wraps an InModelContextFirebaseModelService observable and provides different piped observables.
- */
-export class DbxFirebaseInContextFirebaseModelServiceInstance {
-    constructor(modelService$) {
-        this.modelService$ = modelService$;
-        // MARK: Roles
-        this.roleReader$ = this.modelService$.pipe(switchMap((x) => x.roleReader()), shareReplay(1));
-        this.roleMap$ = this.roleReader$.pipe(map((x) => x.roleMap), shareReplay(1));
-        this.hasNoAccess$ = this.roleReader$.pipe(map((x) => x.hasNoAccess()), shareReplay(1));
-    }
-    truthMap(input) {
-        return this.roleReader$.pipe(map((x) => x.truthMap(input)), shareReplay(1));
-    }
-    hasAnyRoles(roles) {
-        return this.hasRoles('any', roles);
-    }
-    hasAllRoles(roles) {
-        return this.hasRoles('all', roles);
-    }
-    hasRoles(setIncludes, roles) {
-        return this.roleReader$.pipe(map((x) => x.hasRoles(setIncludes, roles)), distinctUntilChanged(), shareReplay(1));
-    }
-    containsAnyRoles(roles) {
-        return this.containsRoles('any', roles);
-    }
-    containsAllRoles(roles) {
-        return this.containsRoles('all', roles);
-    }
-    containsRoles(setIncludes, roles) {
-        return this.roleReader$.pipe(map((x) => x.containsRoles(setIncludes, roles)), distinctUntilChanged(), shareReplay(1));
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/service/model.context.service.mjs

@@ -0,0 +1,38 @@
+import { asFirestoreModelKeyCollectionType, buildFirebaseCollectionTypeModelTypeMap } from '@dereekb/firebase';
+import { asObservable } from '@dereekb/rxjs';
+import { shareReplay, map, first, switchMap } from 'rxjs';
+/**
+ * Used for retrieving contexts for a specific model type/identity.
+ */
+export class DbxFirebaseModelContextService {
+}
+export function dbxFirebaseModelContextServiceInfoInstanceFactory(config) {
+    const { modelService, entityMap$ } = config;
+    return (keyObs) => {
+        const key$ = asObservable(keyObs);
+        return key$.pipe(asFirestoreModelKeyCollectionType(), switchMap((pair) => {
+            return entityMap$.pipe(map((entityMap) => {
+                const modelType = entityMap.get(pair.collectionType);
+                if (!modelType) {
+                    const message = `dbxFirebaseModelContextServiceInfoInstanceFactory Error: Failed to retrieve model type for collection type "${pair.collectionType}"`;
+                    console.error(message);
+                    throw new Error(message);
+                }
+                return modelService(modelType, pair.key);
+            }));
+        }));
+    };
+}
+/**
+ * Operator function that builds a FirestoreModelIdentityTypeMap from the input context and shares the replay.
+ *
+ * Since the output won't change with different contexts, the map is built once and then shared.
+ *
+ * @returns
+ */
+export function firebaseContextServiceEntityMap() {
+    return (obs) => {
+        return obs.pipe(map((x) => buildFirebaseCollectionTypeModelTypeMap(x)), first(), shareReplay(1));
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/system/systemstate.collection.store.directive.mjs

@@ -1,5 +1,5 @@
 import { Directive } from '@angular/core';
-import { DbxFirebaseCollectionStoreDirective, provideDbxFirebaseCollectionStoreDirective } from '../store/store.collection.directive';
+import { DbxFirebaseCollectionStoreDirective, provideDbxFirebaseCollectionStoreDirective } from '../modules/store/store.collection.directive';
 import { SystemStateCollectionStore } from './systemstate.collection.store';
 import * as i0 from "@angular/core";
 import * as i1 from "./systemstate.collection.store";
@@ -17,4 +17,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImpo
                     providers: provideDbxFirebaseCollectionStoreDirective(DbxFirebaseSystemStateCollectionStoreDirective, SystemStateCollectionStore)
                 }]
         }], ctorParameters: function () { return [{ type: i1.SystemStateCollectionStore }]; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3lzdGVtc3RhdGUuY29sbGVjdGlvbi5zdG9yZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9tb2RlbC9zeXN0ZW0vc3lzdGVtc3RhdGUuY29sbGVjdGlvbi5zdG9yZS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUxQyxPQUFPLEVBQUUsbUNBQW1DLEVBQUUsMENBQTBDLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUN0SSxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQzs7O0FBTTVFLE1BQU0sT0FBTyw4Q0FBK0MsU0FBUSxtQ0FBaUc7SUFDbkssWUFBWSxLQUFpQztRQUMzQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDZixDQUFDOzs0SUFIVSw4Q0FBOEM7Z0lBQTlDLDhDQUE4Qyw2REFGOUMsMENBQTBDLENBQUMsOENBQThDLEVBQUUsMEJBQTBCLENBQUM7NEZBRXRILDhDQUE4QztrQkFKMUQsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsb0NBQW9DO29CQUM5QyxTQUFTLEVBQUUsMENBQTBDLGlEQUFpRCwwQkFBMEIsQ0FBQztpQkFDbEkiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFN5c3RlbVN0YXRlLCBTeXN0ZW1TdGF0ZURvY3VtZW50IH0gZnJvbSAnQGRlcmVla2IvZmlyZWJhc2UnO1xuaW1wb3J0IHsgRGJ4RmlyZWJhc2VDb2xsZWN0aW9uU3RvcmVEaXJlY3RpdmUsIHByb3ZpZGVEYnhGaXJlYmFzZUNvbGxlY3Rpb25TdG9yZURpcmVjdGl2ZSB9IGZyb20gJy4uL3N0b3JlL3N0b3JlLmNvbGxlY3Rpb24uZGlyZWN0aXZlJztcbmltcG9ydCB7IFN5c3RlbVN0YXRlQ29sbGVjdGlvblN0b3JlIH0gZnJvbSAnLi9zeXN0ZW1zdGF0ZS5jb2xsZWN0aW9uLnN0b3JlJztcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW2RieEZpcmViYXNlU3lzdGVtU3RhdGVDb2xsZWN0aW9uXScsXG4gIHByb3ZpZGVyczogcHJvdmlkZURieEZpcmViYXNlQ29sbGVjdGlvblN0b3JlRGlyZWN0aXZlKERieEZpcmViYXNlU3lzdGVtU3RhdGVDb2xsZWN0aW9uU3RvcmVEaXJlY3RpdmUsIFN5c3RlbVN0YXRlQ29sbGVjdGlvblN0b3JlKVxufSlcbmV4cG9ydCBjbGFzcyBEYnhGaXJlYmFzZVN5c3RlbVN0YXRlQ29sbGVjdGlvblN0b3JlRGlyZWN0aXZlIGV4dGVuZHMgRGJ4RmlyZWJhc2VDb2xsZWN0aW9uU3RvcmVEaXJlY3RpdmU8U3lzdGVtU3RhdGUsIFN5c3RlbVN0YXRlRG9jdW1lbnQsIFN5c3RlbVN0YXRlQ29sbGVjdGlvblN0b3JlPiB7XG4gIGNvbnN0cnVjdG9yKHN0b3JlOiBTeXN0ZW1TdGF0ZUNvbGxlY3Rpb25TdG9yZSkge1xuICAgIHN1cGVyKHN0b3JlKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3lzdGVtc3RhdGUuY29sbGVjdGlvbi5zdG9yZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9kYngtZmlyZWJhc2Uvc3JjL2xpYi9tb2RlbC9zeXN0ZW0vc3lzdGVtc3RhdGUuY29sbGVjdGlvbi5zdG9yZS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUxQyxPQUFPLEVBQUUsbUNBQW1DLEVBQUUsMENBQTBDLEVBQUUsTUFBTSw2Q0FBNkMsQ0FBQztBQUM5SSxPQUFPLEVBQUUsMEJBQTBCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQzs7O0FBTTVFLE1BQU0sT0FBTyw4Q0FBK0MsU0FBUSxtQ0FBaUc7SUFDbkssWUFBWSxLQUFpQztRQUMzQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDZixDQUFDOzs0SUFIVSw4Q0FBOEM7Z0lBQTlDLDhDQUE4Qyw2REFGOUMsMENBQTBDLENBQUMsOENBQThDLEVBQUUsMEJBQTBCLENBQUM7NEZBRXRILDhDQUE4QztrQkFKMUQsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsb0NBQW9DO29CQUM5QyxTQUFTLEVBQUUsMENBQTBDLGlEQUFpRCwwQkFBMEIsQ0FBQztpQkFDbEkiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFN5c3RlbVN0YXRlLCBTeXN0ZW1TdGF0ZURvY3VtZW50IH0gZnJvbSAnQGRlcmVla2IvZmlyZWJhc2UnO1xuaW1wb3J0IHsgRGJ4RmlyZWJhc2VDb2xsZWN0aW9uU3RvcmVEaXJlY3RpdmUsIHByb3ZpZGVEYnhGaXJlYmFzZUNvbGxlY3Rpb25TdG9yZURpcmVjdGl2ZSB9IGZyb20gJy4uL21vZHVsZXMvc3RvcmUvc3RvcmUuY29sbGVjdGlvbi5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgU3lzdGVtU3RhdGVDb2xsZWN0aW9uU3RvcmUgfSBmcm9tICcuL3N5c3RlbXN0YXRlLmNvbGxlY3Rpb24uc3RvcmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbZGJ4RmlyZWJhc2VTeXN0ZW1TdGF0ZUNvbGxlY3Rpb25dJyxcbiAgcHJvdmlkZXJzOiBwcm92aWRlRGJ4RmlyZWJhc2VDb2xsZWN0aW9uU3RvcmVEaXJlY3RpdmUoRGJ4RmlyZWJhc2VTeXN0ZW1TdGF0ZUNvbGxlY3Rpb25TdG9yZURpcmVjdGl2ZSwgU3lzdGVtU3RhdGVDb2xsZWN0aW9uU3RvcmUpXG59KVxuZXhwb3J0IGNsYXNzIERieEZpcmViYXNlU3lzdGVtU3RhdGVDb2xsZWN0aW9uU3RvcmVEaXJlY3RpdmUgZXh0ZW5kcyBEYnhGaXJlYmFzZUNvbGxlY3Rpb25TdG9yZURpcmVjdGl2ZTxTeXN0ZW1TdGF0ZSwgU3lzdGVtU3RhdGVEb2N1bWVudCwgU3lzdGVtU3RhdGVDb2xsZWN0aW9uU3RvcmU+IHtcbiAgY29uc3RydWN0b3Ioc3RvcmU6IFN5c3RlbVN0YXRlQ29sbGVjdGlvblN0b3JlKSB7XG4gICAgc3VwZXIoc3RvcmUpO1xuICB9XG59XG4iXX0=