npm - @dereekb/dbx-firebase - Versions diffs - 8.5.0 → 8.5.3 - Mend

@dereekb/dbx-firebase 8.5.0 → 8.5.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/esm2020/lib/auth/service/firebase.auth.service.mjs CHANGED Viewed

@@ -161,4 +161,4 @@ export class DbxFirebaseAuthContextInfo {
         return this._token();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"firebase.auth.service.js","sourceRoot":"","sources":["../../../../../../../packages/dbx-firebase/src/lib/auth/service/firebase.auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { filterMaybe, isNot, timeoutStartWith } from '@dereekb/rxjs';\nimport { Injectable, Optional } from '@angular/core';\nimport { AuthUserState, DbxAuthService, loggedOutObsFromIsLoggedIn, loggedInObsFromIsLoggedIn, AuthUserIdentifier, authUserIdentifier } from '@dereekb/dbx-core';\nimport { Auth, authState, User, IdTokenResult, ParsedToken, GoogleAuthProvider, signInWithPopup, AuthProvider, PopupRedirectResolver, signInAnonymously, signInWithEmailAndPassword, UserCredential, FacebookAuthProvider, GithubAuthProvider, TwitterAuthProvider, createUserWithEmailAndPassword } from '@angular/fire/auth';\nimport { Observable, timeout, startWith, distinctUntilChanged, shareReplay, map, switchMap, firstValueFrom } from 'rxjs';\nimport { AuthClaims, AuthClaimsObject, AuthRoleClaimsService, AuthRoleSet, AUTH_ADMIN_ROLE, cachedGetter, Maybe } from '@dereekb/util';\nimport { AuthUserInfo, authUserInfoFromAuthUser, firebaseAuthTokenFromUser } from '../auth';\nimport { sendPasswordResetEmail } from 'firebase/auth';\nimport { authUserStateFromFirebaseAuthService } from './firebase.auth.rxjs';\nimport { FirebaseAuthContextInfo, FirebaseAuthToken } from '@dereekb/firebase';\n\n// MARK: Delegate\nexport abstract class DbxFirebaseAuthServiceDelegate {\n  abstract authUserStateObs(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<AuthUserState>;\n  abstract authRolesObs(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<AuthRoleSet>;\n  abstract isOnboarded(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<boolean>;\n  /**\n   * Whether or not the input roles imply the admin priviledges.\n   */\n  abstract isAdminInAuthRoleSet(authRoleSet: AuthRoleSet): boolean;\n  abstract authRoleClaimsService?: Maybe<AuthRoleClaimsService<AuthClaimsObject>>;\n}\n\nexport const DEFAULT_DBX_FIREBASE_AUTH_SERVICE_DELEGATE: DbxFirebaseAuthServiceDelegate = {\n  authUserStateObs(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<AuthUserState> {\n    return authUserStateFromFirebaseAuthService(dbxFirebaseAuthService);\n  },\n  authRolesObs(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<AuthRoleSet> {\n    return dbxFirebaseAuthService.authUserState$.pipe(map((x) => (x === 'user' ? new Set(['user']) : new Set())));\n  },\n  isOnboarded(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<boolean> {\n    return dbxFirebaseAuthService.authUserState$.pipe(map((x) => x === 'user'));\n  },\n  isAdminInAuthRoleSet(authRoleSet: AuthRoleSet): boolean {\n    return authRoleSet.has(AUTH_ADMIN_ROLE);\n  }\n};\n\n// MARK: Service\n@Injectable()\nexport class DbxFirebaseAuthService implements DbxAuthService {\n  private readonly _authState$: Observable<Maybe<User>> = authState(this.firebaseAuth);\n\n  readonly currentAuthUser$: Observable<Maybe<User>> = this._authState$.pipe(timeoutStartWith(null as Maybe<User>, 1000), distinctUntilChanged(), shareReplay(1));\n\n  readonly currentAuthUserInfo$: Observable<Maybe<AuthUserInfo>> = this.currentAuthUser$.pipe(map((x) => (x ? authUserInfoFromAuthUser(x) : undefined)));\n\n  readonly authUser$: Observable<User> = this.currentAuthUser$.pipe(filterMaybe());\n  readonly authUserInfo$: Observable<AuthUserInfo> = this.authUser$.pipe(map(authUserInfoFromAuthUser));\n\n  readonly hasAuthUser$: Observable<boolean> = this.currentAuthUser$.pipe(\n    map((x) => Boolean(x)),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n  readonly isAnonymousUser$: Observable<boolean> = this.authUser$.pipe(\n    map((x) => x.isAnonymous),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n  readonly isNotAnonymousUser$: Observable<boolean> = this.isAnonymousUser$.pipe(isNot());\n\n  readonly isLoggedIn$: Observable<boolean> = this.hasAuthUser$;\n\n  readonly isNotLoggedIn$: Observable<boolean> = this.isLoggedIn$.pipe(isNot());\n  readonly onLogIn$: Observable<void> = loggedInObsFromIsLoggedIn(this.isLoggedIn$);\n  readonly onLogOut$: Observable<void> = loggedOutObsFromIsLoggedIn(this.isLoggedIn$);\n  readonly userIdentifier$: Observable<AuthUserIdentifier> = this.currentAuthUser$.pipe(map((x) => authUserIdentifier(x?.uid)));\n  readonly uid$: Observable<AuthUserIdentifier> = this.userIdentifier$;\n\n  readonly idTokenResult$: Observable<IdTokenResult> = this.authUser$.pipe(switchMap((x) => x.getIdTokenResult()));\n\n  readonly claims$: Observable<ParsedToken> = this.idTokenResult$.pipe(map((x) => x.claims));\n  readonly currentAuthContextInfo$: Observable<Maybe<DbxFirebaseAuthContextInfo>> = this.currentAuthUser$.pipe(\n    switchMap((x) => this.loadAuthContextInfoForUser(x)),\n    shareReplay(1)\n  );\n  readonly authContextInfo$: Observable<Maybe<DbxFirebaseAuthContextInfo>> = this.currentAuthContextInfo$.pipe(filterMaybe());\n\n  readonly authUserState$: Observable<AuthUserState>;\n  readonly authRoles$: Observable<AuthRoleSet>;\n  readonly isOnboarded$: Observable<boolean>;\n\n  private _authRoleClaimsService?: Maybe<AuthRoleClaimsService<AuthClaimsObject>>;\n  readonly isAdminInAuthRoleSet: (authRoleSet: AuthRoleSet) => boolean;\n\n  constructor(readonly firebaseAuth: Auth, @Optional() delegate: DbxFirebaseAuthServiceDelegate) {\n    delegate = delegate ?? DEFAULT_DBX_FIREBASE_AUTH_SERVICE_DELEGATE;\n    this.authUserState$ = delegate.authUserStateObs(this).pipe(distinctUntilChanged(), shareReplay(1));\n    this.authRoles$ = delegate.authRolesObs(this);\n    this.isOnboarded$ = delegate.isOnboarded(this);\n    this._authRoleClaimsService = delegate.authRoleClaimsService;\n    this.isAdminInAuthRoleSet = delegate.isAdminInAuthRoleSet;\n  }\n\n  async refreshToken(): Promise<IdTokenResult> {\n    const user = this.firebaseAuth.currentUser;\n\n    if (!user) {\n      throw new Error('no user to refresh the token for.');\n    }\n\n    return user.getIdTokenResult(true);\n  }\n\n  rolesForClaims<T extends AuthClaimsObject = AuthClaimsObject>(claims: AuthClaims<T>): AuthRoleSet {\n    let result: AuthRoleSet;\n\n    if (this._authRoleClaimsService) {\n      return this._authRoleClaimsService.toRoles(claims);\n    } else {\n      console.warn('DbxFirebaseAuthService: rolesForClaims called with no authRoleClaimsService provided. An empty set is returned.');\n      result = new Set();\n    }\n\n    return result;\n  }\n\n  getAuthContextInfo(): Promise<Maybe<DbxFirebaseAuthContextInfo>> {\n    return firstValueFrom(this.authUser$).then((user) => this.loadAuthContextInfoForUser(user));\n  }\n\n  async loadAuthContextInfoForUser(user: Maybe<User>): Promise<Maybe<DbxFirebaseAuthContextInfo>> {\n    let result: Maybe<DbxFirebaseAuthContextInfo>;\n\n    if (user) {\n      const jwtToken: IdTokenResult = await user.getIdTokenResult();\n      result = new DbxFirebaseAuthContextInfo(this, user, jwtToken);\n    }\n\n    return result;\n  }\n\n  logInWithGoogle(): Promise<UserCredential> {\n    return this.logInWithPopup(new GoogleAuthProvider());\n  }\n\n  logInWithFacebook(): Promise<UserCredential> {\n    return this.logInWithPopup(new FacebookAuthProvider());\n  }\n\n  logInWithTwitter(): Promise<UserCredential> {\n    return this.logInWithPopup(new TwitterAuthProvider());\n  }\n\n  logInWithGithub(): Promise<UserCredential> {\n    return this.logInWithPopup(new GithubAuthProvider());\n  }\n\n  logInWithApple(): Promise<UserCredential> {\n    throw new Error('todo');\n  }\n\n  logInWithMicrosoft(): Promise<UserCredential> {\n    // return this.logInWithPopup(new MicrosoftAuthProvider());\n    throw new Error('todo');\n  }\n\n  logInWithPhone(): Promise<UserCredential> {\n    throw new Error('todo');\n    // return signInWithPhoneNumber(this.firebaseAuth, )\n  }\n\n  logInWithPopup(provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential> {\n    return signInWithPopup(this.firebaseAuth, provider, resolver);\n  }\n\n  registerWithEmailAndPassword(email: string, password: string): Promise<UserCredential> {\n    return createUserWithEmailAndPassword(this.firebaseAuth, email, password);\n  }\n\n  sendPasswordResetEmail(email: string): Promise<void> {\n    return sendPasswordResetEmail(this.firebaseAuth, email);\n  }\n\n  logInWithEmailAndPassword(email: string, password: string): Promise<UserCredential> {\n    return signInWithEmailAndPassword(this.firebaseAuth, email, password);\n  }\n\n  logInAsAnonymous(): Promise<UserCredential> {\n    return signInAnonymously(this.firebaseAuth);\n  }\n\n  logOut(): Promise<void> {\n    return this.firebaseAuth.signOut();\n  }\n}\n\n/**\n * FirebaseAuthContextInfo implementation from DbxFirebaseAuthService.\n */\nexport class DbxFirebaseAuthContextInfo implements FirebaseAuthContextInfo {\n  private _token = cachedGetter(() => firebaseAuthTokenFromUser(this.user));\n  private _roles = cachedGetter(() => this.service.rolesForClaims(this.getClaims()));\n  private _isAdmin = cachedGetter(() => this.service.isAdminInAuthRoleSet(this._roles()));\n\n  constructor(readonly service: DbxFirebaseAuthService, readonly user: User, readonly jwtToken: IdTokenResult) {}\n\n  get uid() {\n    return this.user.uid;\n  }\n\n  isAdmin(): boolean {\n    return this._isAdmin();\n  }\n\n  getClaims<T extends AuthClaimsObject = AuthClaimsObject>(): AuthClaims<T> {\n    return this.jwtToken.claims as AuthClaims<T>;\n  }\n\n  getAuthRoles(): AuthRoleSet {\n    return this._roles();\n  }\n\n  get token(): FirebaseAuthToken {\n    return this._token();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"firebase.auth.service.js","sourceRoot":"","sources":["../../../../../../../packages/dbx-firebase/src/lib/auth/service/firebase.auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { filterMaybe, isNot, timeoutStartWith } from '@dereekb/rxjs';\nimport { Injectable, Optional } from '@angular/core';\nimport { AuthUserState, DbxAuthService, loggedOutObsFromIsLoggedIn, loggedInObsFromIsLoggedIn, AuthUserIdentifier, authUserIdentifier } from '@dereekb/dbx-core';\nimport { Auth, authState, User, IdTokenResult, ParsedToken, GoogleAuthProvider, signInWithPopup, AuthProvider, PopupRedirectResolver, signInAnonymously, signInWithEmailAndPassword, UserCredential, FacebookAuthProvider, GithubAuthProvider, TwitterAuthProvider, createUserWithEmailAndPassword } from '@angular/fire/auth';\nimport { Observable, distinctUntilChanged, shareReplay, map, switchMap, firstValueFrom } from 'rxjs';\nimport { AuthClaims, AuthClaimsObject, AuthRoleClaimsService, AuthRoleSet, AUTH_ADMIN_ROLE, cachedGetter, Maybe } from '@dereekb/util';\nimport { AuthUserInfo, authUserInfoFromAuthUser, firebaseAuthTokenFromUser } from '../auth';\nimport { sendPasswordResetEmail } from 'firebase/auth';\nimport { authUserStateFromFirebaseAuthService } from './firebase.auth.rxjs';\nimport { FirebaseAuthContextInfo, FirebaseAuthToken } from '@dereekb/firebase';\n\n// MARK: Delegate\nexport abstract class DbxFirebaseAuthServiceDelegate {\n  abstract authUserStateObs(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<AuthUserState>;\n  abstract authRolesObs(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<AuthRoleSet>;\n  abstract isOnboarded(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<boolean>;\n  /**\n   * Whether or not the input roles imply the admin priviledges.\n   */\n  abstract isAdminInAuthRoleSet(authRoleSet: AuthRoleSet): boolean;\n  abstract authRoleClaimsService?: Maybe<AuthRoleClaimsService<AuthClaimsObject>>;\n}\n\nexport const DEFAULT_DBX_FIREBASE_AUTH_SERVICE_DELEGATE: DbxFirebaseAuthServiceDelegate = {\n  authUserStateObs(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<AuthUserState> {\n    return authUserStateFromFirebaseAuthService(dbxFirebaseAuthService);\n  },\n  authRolesObs(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<AuthRoleSet> {\n    return dbxFirebaseAuthService.authUserState$.pipe(map((x) => (x === 'user' ? new Set(['user']) : new Set())));\n  },\n  isOnboarded(dbxFirebaseAuthService: DbxFirebaseAuthService): Observable<boolean> {\n    return dbxFirebaseAuthService.authUserState$.pipe(map((x) => x === 'user'));\n  },\n  isAdminInAuthRoleSet(authRoleSet: AuthRoleSet): boolean {\n    return authRoleSet.has(AUTH_ADMIN_ROLE);\n  }\n};\n\n// MARK: Service\n@Injectable()\nexport class DbxFirebaseAuthService implements DbxAuthService {\n  private readonly _authState$: Observable<Maybe<User>> = authState(this.firebaseAuth);\n\n  readonly currentAuthUser$: Observable<Maybe<User>> = this._authState$.pipe(timeoutStartWith(null as Maybe<User>, 1000), distinctUntilChanged(), shareReplay(1));\n\n  readonly currentAuthUserInfo$: Observable<Maybe<AuthUserInfo>> = this.currentAuthUser$.pipe(map((x) => (x ? authUserInfoFromAuthUser(x) : undefined)));\n\n  readonly authUser$: Observable<User> = this.currentAuthUser$.pipe(filterMaybe());\n  readonly authUserInfo$: Observable<AuthUserInfo> = this.authUser$.pipe(map(authUserInfoFromAuthUser));\n\n  readonly hasAuthUser$: Observable<boolean> = this.currentAuthUser$.pipe(\n    map((x) => Boolean(x)),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n  readonly isAnonymousUser$: Observable<boolean> = this.authUser$.pipe(\n    map((x) => x.isAnonymous),\n    distinctUntilChanged(),\n    shareReplay(1)\n  );\n  readonly isNotAnonymousUser$: Observable<boolean> = this.isAnonymousUser$.pipe(isNot());\n\n  readonly isLoggedIn$: Observable<boolean> = this.hasAuthUser$;\n\n  readonly isNotLoggedIn$: Observable<boolean> = this.isLoggedIn$.pipe(isNot());\n  readonly onLogIn$: Observable<void> = loggedInObsFromIsLoggedIn(this.isLoggedIn$);\n  readonly onLogOut$: Observable<void> = loggedOutObsFromIsLoggedIn(this.isLoggedIn$);\n  readonly userIdentifier$: Observable<AuthUserIdentifier> = this.currentAuthUser$.pipe(map((x) => authUserIdentifier(x?.uid)));\n  readonly uid$: Observable<AuthUserIdentifier> = this.userIdentifier$;\n\n  readonly idTokenResult$: Observable<IdTokenResult> = this.authUser$.pipe(switchMap((x) => x.getIdTokenResult()));\n\n  readonly claims$: Observable<ParsedToken> = this.idTokenResult$.pipe(map((x) => x.claims));\n  readonly currentAuthContextInfo$: Observable<Maybe<DbxFirebaseAuthContextInfo>> = this.currentAuthUser$.pipe(\n    switchMap((x) => this.loadAuthContextInfoForUser(x)),\n    shareReplay(1)\n  );\n  readonly authContextInfo$: Observable<Maybe<DbxFirebaseAuthContextInfo>> = this.currentAuthContextInfo$.pipe(filterMaybe());\n\n  readonly authUserState$: Observable<AuthUserState>;\n  readonly authRoles$: Observable<AuthRoleSet>;\n  readonly isOnboarded$: Observable<boolean>;\n\n  private _authRoleClaimsService?: Maybe<AuthRoleClaimsService<AuthClaimsObject>>;\n  readonly isAdminInAuthRoleSet: (authRoleSet: AuthRoleSet) => boolean;\n\n  constructor(readonly firebaseAuth: Auth, @Optional() delegate: DbxFirebaseAuthServiceDelegate) {\n    delegate = delegate ?? DEFAULT_DBX_FIREBASE_AUTH_SERVICE_DELEGATE;\n    this.authUserState$ = delegate.authUserStateObs(this).pipe(distinctUntilChanged(), shareReplay(1));\n    this.authRoles$ = delegate.authRolesObs(this);\n    this.isOnboarded$ = delegate.isOnboarded(this);\n    this._authRoleClaimsService = delegate.authRoleClaimsService;\n    this.isAdminInAuthRoleSet = delegate.isAdminInAuthRoleSet;\n  }\n\n  async refreshToken(): Promise<IdTokenResult> {\n    const user = this.firebaseAuth.currentUser;\n\n    if (!user) {\n      throw new Error('no user to refresh the token for.');\n    }\n\n    return user.getIdTokenResult(true);\n  }\n\n  rolesForClaims<T extends AuthClaimsObject = AuthClaimsObject>(claims: AuthClaims<T>): AuthRoleSet {\n    let result: AuthRoleSet;\n\n    if (this._authRoleClaimsService) {\n      return this._authRoleClaimsService.toRoles(claims);\n    } else {\n      console.warn('DbxFirebaseAuthService: rolesForClaims called with no authRoleClaimsService provided. An empty set is returned.');\n      result = new Set();\n    }\n\n    return result;\n  }\n\n  getAuthContextInfo(): Promise<Maybe<DbxFirebaseAuthContextInfo>> {\n    return firstValueFrom(this.authUser$).then((user) => this.loadAuthContextInfoForUser(user));\n  }\n\n  async loadAuthContextInfoForUser(user: Maybe<User>): Promise<Maybe<DbxFirebaseAuthContextInfo>> {\n    let result: Maybe<DbxFirebaseAuthContextInfo>;\n\n    if (user) {\n      const jwtToken: IdTokenResult = await user.getIdTokenResult();\n      result = new DbxFirebaseAuthContextInfo(this, user, jwtToken);\n    }\n\n    return result;\n  }\n\n  logInWithGoogle(): Promise<UserCredential> {\n    return this.logInWithPopup(new GoogleAuthProvider());\n  }\n\n  logInWithFacebook(): Promise<UserCredential> {\n    return this.logInWithPopup(new FacebookAuthProvider());\n  }\n\n  logInWithTwitter(): Promise<UserCredential> {\n    return this.logInWithPopup(new TwitterAuthProvider());\n  }\n\n  logInWithGithub(): Promise<UserCredential> {\n    return this.logInWithPopup(new GithubAuthProvider());\n  }\n\n  logInWithApple(): Promise<UserCredential> {\n    throw new Error('todo');\n  }\n\n  logInWithMicrosoft(): Promise<UserCredential> {\n    // return this.logInWithPopup(new MicrosoftAuthProvider());\n    throw new Error('todo');\n  }\n\n  logInWithPhone(): Promise<UserCredential> {\n    throw new Error('todo');\n    // return signInWithPhoneNumber(this.firebaseAuth, )\n  }\n\n  logInWithPopup(provider: AuthProvider, resolver?: PopupRedirectResolver): Promise<UserCredential> {\n    return signInWithPopup(this.firebaseAuth, provider, resolver);\n  }\n\n  registerWithEmailAndPassword(email: string, password: string): Promise<UserCredential> {\n    return createUserWithEmailAndPassword(this.firebaseAuth, email, password);\n  }\n\n  sendPasswordResetEmail(email: string): Promise<void> {\n    return sendPasswordResetEmail(this.firebaseAuth, email);\n  }\n\n  logInWithEmailAndPassword(email: string, password: string): Promise<UserCredential> {\n    return signInWithEmailAndPassword(this.firebaseAuth, email, password);\n  }\n\n  logInAsAnonymous(): Promise<UserCredential> {\n    return signInAnonymously(this.firebaseAuth);\n  }\n\n  logOut(): Promise<void> {\n    return this.firebaseAuth.signOut();\n  }\n}\n\n/**\n * FirebaseAuthContextInfo implementation from DbxFirebaseAuthService.\n */\nexport class DbxFirebaseAuthContextInfo implements FirebaseAuthContextInfo {\n  private _token = cachedGetter(() => firebaseAuthTokenFromUser(this.user));\n  private _roles = cachedGetter(() => this.service.rolesForClaims(this.getClaims()));\n  private _isAdmin = cachedGetter(() => this.service.isAdminInAuthRoleSet(this._roles()));\n\n  constructor(readonly service: DbxFirebaseAuthService, readonly user: User, readonly jwtToken: IdTokenResult) {}\n\n  get uid() {\n    return this.user.uid;\n  }\n\n  isAdmin(): boolean {\n    return this._isAdmin();\n  }\n\n  getClaims<T extends AuthClaimsObject = AuthClaimsObject>(): AuthClaims<T> {\n    return this.jwtToken.claims as AuthClaims<T>;\n  }\n\n  getAuthRoles(): AuthRoleSet {\n    return this._roles();\n  }\n\n  get token(): FirebaseAuthToken {\n    return this._token();\n  }\n}\n"]}

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

@@ -0,0 +1,68 @@
+import { SubscriptionObject, asObservable } from '@dereekb/rxjs';
+import { BehaviorSubject, filter, switchMap, exhaustMap, EMPTY } from 'rxjs';
+import { dbxFirebaseCollectionChangeWatcher } from './collection.change.watcher';
+/**
+ * Restarts the store.
+ *
+ * @param instance
+ * @returns
+ */
+export const DEFAULT_FIREBASE_COLLECTION_CHANGE_TRIGGER_FUNCTION = (instance) => instance.watcher.store.restart();
+export class DbxFirebaseCollectionChangeTriggerInstance {
+    constructor(config) {
+        this.config = config;
+        this._triggerFunction = new BehaviorSubject(undefined);
+        this._sub = new SubscriptionObject();
+        this.watcher = config.watcher;
+        this.triggerFunction = config.triggerFunction ?? DEFAULT_FIREBASE_COLLECTION_CHANGE_TRIGGER_FUNCTION;
+    }
+    init() {
+        this._sub.subscription = this._triggerFunction
+            .pipe(switchMap((triggerFunction) => {
+            if (triggerFunction) {
+                return this.watcher.triggered$.pipe(filter((triggered) => triggered), exhaustMap(() => asObservable(triggerFunction(this))));
+            }
+            else {
+                return EMPTY;
+            }
+        }))
+            .subscribe();
+    }
+    destroy() {
+        this._triggerFunction.complete();
+        if (this.config.destroyWatcherOnDestroy === true) {
+            this.watcher?.destroy();
+        }
+    }
+    get triggerFunction() {
+        return this._triggerFunction.value;
+    }
+    set triggerFunction(triggerFunction) {
+        this._triggerFunction.next(triggerFunction);
+    }
+}
+/**
+ * Creates a new DbxFirebaseCollectionChangeWatcher, set the modes to "auto", and creates a new DbxFirebaseCollectionChangeTriggerInstance.
+ *
+ * @param store
+ * @param triggerFunction
+ * @returns
+ */
+export function dbxFirebaseCollectionChangeTriggerInstanceForStore(store, triggerFunction) {
+    return dbxFirebaseCollectionChangeTriggerInstance({
+        watcher: dbxFirebaseCollectionChangeWatcher(store, 'auto'),
+        destroyWatcherOnDestroy: true,
+        triggerFunction
+    });
+}
+export function dbxFirebaseCollectionChangeTriggerInstanceForWatcher(watcher, triggerFunction) {
+    return dbxFirebaseCollectionChangeTriggerInstance({
+        watcher,
+        destroyWatcherOnDestroy: false,
+        triggerFunction
+    });
+}
+export function dbxFirebaseCollectionChangeTriggerInstance(config) {
+    return new DbxFirebaseCollectionChangeTriggerInstance(config);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection.change.trigger.js","sourceRoot":"","sources":["../../../../../../../packages/dbx-firebase/src/lib/model/loader/collection.change.trigger.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,kBAAkB,EAAkC,YAAY,EAAE,MAAM,eAAe,CAAC;AAC3H,OAAO,EAAE,eAAe,EAAiB,MAAM,EAAe,SAAS,EAAE,UAAU,EAA2C,KAAK,EAAc,MAAM,MAAM,CAAC;AAI9J,OAAO,EAAsC,kCAAkC,EAA8C,MAAM,6BAA6B,CAAC;AAIjK;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mDAAmD,GAAyD,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;AAuBxK,MAAM,OAAO,0CAA0C;IAMrD,YAAqB,MAAiE;QAAjE,WAAM,GAAN,MAAM,CAA2D;QAH9E,qBAAgB,GAAG,IAAI,eAAe,CAA6D,SAAS,CAAC,CAAC;QAC9G,SAAI,GAAG,IAAI,kBAAkB,EAAE,CAAC;QAGtC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC;QAC9B,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,IAAI,mDAAmD,CAAC;IACvG,CAAC;IAED,IAAI;QACF,IAAI,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,gBAAgB;aAC3C,IAAI,CACH,SAAS,CAAC,CAAC,eAAe,EAAE,EAAE;YAC5B,IAAI,eAAe,EAAE;gBACnB,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CACjC,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,EAChC,UAAU,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CACtD,CAAC;aACH;iBAAM;gBACL,OAAO,KAAK,CAAC;aACd;QACH,CAAC,CAAC,CACH;aACA,SAAS,EAAE,CAAC;IACjB,CAAC;IAED,OAAO;QACL,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC;QAEjC,IAAI,IAAI,CAAC,MAAM,CAAC,uBAAuB,KAAK,IAAI,EAAE;YAC/C,IAAI,CAAC,OAAkC,EAAE,OAAO,EAAE,CAAC;SACrD;IACH,CAAC;IAED,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC;IACrC,CAAC;IAED,IAAI,eAAe,CAAC,eAA2E;QAC7F,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;IAC9C,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kDAAkD,CAA0I,KAAQ,EAAE,eAA4E;IAChS,OAAO,0CAA0C,CAAU;QACzD,OAAO,EAAE,kCAAkC,CAAU,KAAK,EAAE,MAAM,CAAC;QACnE,uBAAuB,EAAE,IAAI;QAC7B,eAAe;KAChB,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,oDAAoD,CAA0I,OAAoD,EAAE,eAA4E;IAC9U,OAAO,0CAA0C,CAAU;QACzD,OAAO;QACP,uBAAuB,EAAE,KAAK;QAC9B,eAAe;KAChB,CAAC,CAAC;AACL,CAAC;AAED,MAAM,UAAU,0CAA0C,CAA0I,MAAiE;IACnQ,OAAO,IAAI,0CAA0C,CAAC,MAAM,CAAC,CAAC;AAChE,CAAC","sourcesContent":["import { onFalseToTrue, scanCount, SubscriptionObject, filterMaybe, ObservableOrValue, asObservable } from '@dereekb/rxjs';\nimport { BehaviorSubject, combineLatest, filter, shareReplay, switchMap, exhaustMap, combineLatestWith, distinctUntilChanged, EMPTY, Observable } from 'rxjs';\nimport { FirestoreDocument } from '@dereekb/firebase';\nimport { Destroyable, Maybe, Initialized } from '@dereekb/util';\nimport { DbxFirebaseCollectionStore } from '../store';\nimport { DbxFirebaseCollectionChangeWatcher, dbxFirebaseCollectionChangeWatcher, DbxFirebaseCollectionChangeWatcherInstance } from './collection.change.watcher';\n\nexport type DbxFirebaseCollectionChangeTriggerFunction<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseCollectionStore<T, D> = DbxFirebaseCollectionStore<T, D>> = (instance: DbxFirebaseCollectionChangeTriggerInstance<T, D, S>) => ObservableOrValue<void>;\n\n/**\n * Restarts the store.\n *\n * @param instance\n * @returns\n */\nexport const DEFAULT_FIREBASE_COLLECTION_CHANGE_TRIGGER_FUNCTION: DbxFirebaseCollectionChangeTriggerFunction<any, any> = (instance) => instance.watcher.store.restart();\n\nexport interface DbxFirebaseCollectionChangeTriggerInstanceConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseCollectionStore<T, D> = DbxFirebaseCollectionStore<T, D>> {\n  readonly watcher: DbxFirebaseCollectionChangeWatcher<T, D, S> & Partial<Destroyable>;\n  /**\n   * Whether or not to also destroy the watcher when the trigger instance is destroyed.\n   *\n   * Defaults to false.\n   */\n  readonly destroyWatcherOnDestroy?: boolean;\n  /**\n   * Initial trigger function to use.\n   *\n   * By default restarts the store.\n   */\n  readonly triggerFunction?: Maybe<DbxFirebaseCollectionChangeTriggerFunction<T, D, S>>;\n}\n\nexport interface DbxFirebaseCollectionChangeTrigger<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseCollectionStore<T, D> = DbxFirebaseCollectionStore<T, D>> {\n  readonly watcher: DbxFirebaseCollectionChangeWatcher<T, D, S>;\n  triggerFunction?: Maybe<DbxFirebaseCollectionChangeTriggerFunction<T, D, S>>;\n}\n\nexport class DbxFirebaseCollectionChangeTriggerInstance<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseCollectionStore<T, D> = DbxFirebaseCollectionStore<T, D>> implements DbxFirebaseCollectionChangeTrigger<T, D, S>, Initialized, Destroyable {\n  readonly watcher: DbxFirebaseCollectionChangeWatcher<T, D, S>;\n\n  private _triggerFunction = new BehaviorSubject<Maybe<DbxFirebaseCollectionChangeTriggerFunction<T, D, S>>>(undefined);\n  private _sub = new SubscriptionObject();\n\n  constructor(readonly config: DbxFirebaseCollectionChangeTriggerInstanceConfig<T, D, S>) {\n    this.watcher = config.watcher;\n    this.triggerFunction = config.triggerFunction ?? DEFAULT_FIREBASE_COLLECTION_CHANGE_TRIGGER_FUNCTION;\n  }\n\n  init(): void {\n    this._sub.subscription = this._triggerFunction\n      .pipe(\n        switchMap((triggerFunction) => {\n          if (triggerFunction) {\n            return this.watcher.triggered$.pipe(\n              filter((triggered) => triggered),\n              exhaustMap(() => asObservable(triggerFunction(this)))\n            );\n          } else {\n            return EMPTY;\n          }\n        })\n      )\n      .subscribe();\n  }\n\n  destroy(): void {\n    this._triggerFunction.complete();\n\n    if (this.config.destroyWatcherOnDestroy === true) {\n      (this.watcher as unknown as Destroyable)?.destroy();\n    }\n  }\n\n  get triggerFunction(): Maybe<DbxFirebaseCollectionChangeTriggerFunction<T, D, S>> {\n    return this._triggerFunction.value;\n  }\n\n  set triggerFunction(triggerFunction: Maybe<DbxFirebaseCollectionChangeTriggerFunction<T, D, S>>) {\n    this._triggerFunction.next(triggerFunction);\n  }\n}\n\n/**\n * Creates a new DbxFirebaseCollectionChangeWatcher, set the modes to \"auto\", and creates a new DbxFirebaseCollectionChangeTriggerInstance.\n *\n * @param store\n * @param triggerFunction\n * @returns\n */\nexport function dbxFirebaseCollectionChangeTriggerInstanceForStore<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseCollectionStore<T, D> = DbxFirebaseCollectionStore<T, D>>(store: S, triggerFunction?: Maybe<DbxFirebaseCollectionChangeTriggerFunction<T, D, S>>): DbxFirebaseCollectionChangeTriggerInstance<T, D, S> {\n  return dbxFirebaseCollectionChangeTriggerInstance<T, D, S>({\n    watcher: dbxFirebaseCollectionChangeWatcher<T, D, S>(store, 'auto'),\n    destroyWatcherOnDestroy: true,\n    triggerFunction\n  });\n}\n\nexport function dbxFirebaseCollectionChangeTriggerInstanceForWatcher<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseCollectionStore<T, D> = DbxFirebaseCollectionStore<T, D>>(watcher: DbxFirebaseCollectionChangeWatcher<T, D, S>, triggerFunction?: Maybe<DbxFirebaseCollectionChangeTriggerFunction<T, D, S>>): DbxFirebaseCollectionChangeTriggerInstance<T, D, S> {\n  return dbxFirebaseCollectionChangeTriggerInstance<T, D, S>({\n    watcher,\n    destroyWatcherOnDestroy: false,\n    triggerFunction\n  });\n}\n\nexport function dbxFirebaseCollectionChangeTriggerInstance<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, S extends DbxFirebaseCollectionStore<T, D> = DbxFirebaseCollectionStore<T, D>>(config: DbxFirebaseCollectionChangeTriggerInstanceConfig<T, D, S>): DbxFirebaseCollectionChangeTriggerInstance<T, D, S> {\n  return new DbxFirebaseCollectionChangeTriggerInstance(config);\n}\n"]}

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

@@ -0,0 +1,37 @@
+import { SubscriptionObject } from '@dereekb/rxjs';
+import { filter, take, map, BehaviorSubject, distinctUntilChanged, switchMap, startWith, shareReplay, combineLatest } from 'rxjs';
+/**
+ * DbxFirebaseCollectionChangeWatcher instance
+ */
+export class DbxFirebaseCollectionChangeWatcherInstance {
+    constructor(store, _initialMode = 'off') {
+        this.store = store;
+        this._initialMode = _initialMode;
+        this._mode = new BehaviorSubject(this._initialMode);
+        this._sub = new SubscriptionObject();
+        this.mode$ = this._mode.pipe(distinctUntilChanged());
+        this.event$ = this.store.queryChangeWatcher$.pipe(switchMap((x) => x.event$.pipe(filter((x) => x.type !== 'none'), // do not share 'none' events.
+        take(1), // only need one event to mark as change is available.
+        startWith({
+            time: new Date(),
+            type: 'none'
+        }))), shareReplay(1));
+        this.hasChangeAvailable$ = this.event$.pipe(map((x) => x.type !== 'none'), shareReplay(1));
+        this.triggered$ = combineLatest([this.mode$, this.hasChangeAvailable$]).pipe(map(([mode, hasChange]) => mode === 'auto' && hasChange));
+        this.trigger$ = this.triggered$.pipe(filter((triggered) => triggered), map(() => undefined));
+    }
+    destroy() {
+        this._sub.destroy();
+        this._mode.complete();
+    }
+    get mode() {
+        return this._mode.value;
+    }
+    set mode(mode) {
+        this._mode.next(mode);
+    }
+}
+export function dbxFirebaseCollectionChangeWatcher(store, mode) {
+    return new DbxFirebaseCollectionChangeWatcherInstance(store, mode);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/model/loader/document.loader.instance.mjs CHANGED Viewed

@@ -1,6 +1,6 @@
 import { useAsObservable, filterMaybe, SubscriptionObject, asObservable, pageLoadingStateFromObs } from '@dereekb/rxjs';
 import { BehaviorSubject, map, shareReplay, distinctUntilChanged, Subject, switchMap, startWith, exhaustMap } from 'rxjs';
-import { documentReferencesFromDocuments, firestoreModelIdsFromDocuments, firestoreModelKeysFromDocuments, getDataFromDocumentSnapshots, getDocumentSnapshots, loadDocumentsForDocumentReferences, loadDocumentsForIds, loadDocumentsForKeys } from '@dereekb/firebase';
+import { dataFromDocumentSnapshots, documentReferencesFromDocuments, firestoreModelIdsFromDocuments, firestoreModelKeysFromDocuments, getDataFromDocumentSnapshots, getDocumentSnapshots, loadDocumentsForDocumentReferences, loadDocumentsForIds, loadDocumentsForKeys, streamDocumentSnapshots } from '@dereekb/firebase';
 import { asArray } from '@dereekb/util';
 /**
  * DbxLimitedFirebaseDocumentLoader implementation within an instance.
@@ -18,7 +18,16 @@ export class DbxLimitedFirebaseDocumentLoaderInstance {
         this.refs$ = this.documents$.pipe(map(documentReferencesFromDocuments));
         this.snapshots$ = this.documents$.pipe(switchMap((docs) => this._restart.pipe(startWith(null), exhaustMap(() => getDocumentSnapshots(docs)))), shareReplay(1));
         this.data$ = this.snapshots$.pipe(map((snapshots) => getDataFromDocumentSnapshots(snapshots, true)), shareReplay(1));
+        /**
+         * Snapshot stream of the documents
+         */
+        this.snapshotsStream$ = this.documents$.pipe(switchMap((docs) => streamDocumentSnapshots(docs)), shareReplay(1));
+        /**
+         * Data streamd of the documents.
+         */
+        this.dataStream$ = this.snapshotsStream$.pipe(dataFromDocumentSnapshots(), shareReplay(1));
         this.pageLoadingState$ = pageLoadingStateFromObs(this.data$, false);
+        this.pageLoadingStateStream$ = pageLoadingStateFromObs(this.dataStream$, false);
     }
     destroy() {
         this._documents.complete();
@@ -56,4 +65,4 @@ export function dbxFirebaseDocumentLoaderInstance(config) {
 export function dbxFirebaseDocumentLoaderInstanceWithAccessor(accessor) {
     return new DbxFirebaseDocumentLoaderInstance({ accessor });
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"document.loader.instance.js","sourceRoot":"","sources":["../../../../../../../packages/dbx-firebase/src/lib/model/loader/document.loader.instance.ts"],"names":[],"mappings":"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","sourcesContent":["import { ObservableOrValue, useAsObservable, PageListLoadingState, filterMaybe, SubscriptionObject, asObservable, pageLoadingStateFromObs, tapLog } from '@dereekb/rxjs';\nimport { BehaviorSubject, map, shareReplay, distinctUntilChanged, Subject, switchMap, Observable, startWith, exhaustMap } from 'rxjs';\nimport { DocumentDataWithId, DocumentReference, documentReferencesFromDocuments, DocumentSnapshot, FirestoreDocument, FirestoreDocumentAccessor, firestoreModelIdsFromDocuments, FirestoreModelKey, firestoreModelKeysFromDocuments, getDataFromDocumentSnapshots, getDocumentSnapshots, LimitedFirestoreDocumentAccessor, loadDocumentsForDocumentReferences, loadDocumentsForIds, loadDocumentsForKeys } from '@dereekb/firebase';\nimport { ArrayOrValue, asArray, Destroyable, Maybe } from '@dereekb/util';\nimport { DbxFirebaseDocumentLoader, DbxLimitedFirebaseDocumentLoader } from './document.loader';\n\nexport interface DbxFirebaseDocumentLoaderInstanceInitConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>> {\n  readonly accessor: A;\n}\n\n/**\n * DbxLimitedFirebaseDocumentLoader implementation within an instance.\n */\nexport class DbxLimitedFirebaseDocumentLoaderInstance<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>> implements DbxLimitedFirebaseDocumentLoader<T>, Destroyable {\n  readonly accessor: A = this._initConfig.accessor;\n\n  protected readonly _documents = new BehaviorSubject<Maybe<D[]>>(undefined);\n  protected readonly _restart = new Subject<void>();\n  protected readonly _sub = new SubscriptionObject();\n\n  readonly documents$ = this._documents.pipe(filterMaybe(), distinctUntilChanged());\n  readonly keys$ = this.documents$.pipe(map(firestoreModelKeysFromDocuments));\n  readonly ids$ = this.documents$.pipe(map(firestoreModelIdsFromDocuments));\n  readonly refs$ = this.documents$.pipe(map(documentReferencesFromDocuments));\n\n  readonly snapshots$: Observable<DocumentSnapshot<T>[]> = this.documents$.pipe(\n    switchMap((docs) =>\n      this._restart.pipe(\n        startWith(null),\n        exhaustMap(() => getDocumentSnapshots<T, D>(docs))\n      )\n    ),\n    shareReplay(1)\n  );\n\n  readonly data$: Observable<DocumentDataWithId<T>[]> = this.snapshots$.pipe(\n    map((snapshots) => getDataFromDocumentSnapshots(snapshots, true)),\n    shareReplay(1)\n  );\n\n  readonly pageLoadingState$: Observable<PageListLoadingState<DocumentDataWithId<T>>> = pageLoadingStateFromObs(this.data$, false);\n\n  constructor(private readonly _initConfig: DbxFirebaseDocumentLoaderInstanceInitConfig<T, D, A>) {}\n\n  destroy(): void {\n    this._documents.complete();\n    this._restart.complete();\n    this._sub.destroy();\n  }\n\n  restart() {\n    this._restart.next();\n  }\n\n  setKeys(keys: Maybe<ObservableOrValue<ArrayOrValue<FirestoreModelKey>>>): void {\n    this.setDocuments(asObservable(keys).pipe(map((x) => loadDocumentsForKeys(this.accessor, asArray(x)))));\n  }\n\n  setRefs(refs: Maybe<ObservableOrValue<ArrayOrValue<DocumentReference<T>>>>): void {\n    this.setDocuments(asObservable(refs).pipe(map((x) => loadDocumentsForDocumentReferences(this.accessor, asArray(x)))));\n  }\n\n  setDocuments(docs: Maybe<ObservableOrValue<ArrayOrValue<D>>>): void {\n    this._sub.subscription = useAsObservable(docs, (x) => this._documents.next(asArray(x)));\n  }\n}\n\nexport function dbxLimitedFirebaseDocumentLoaderInstance<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>>(config: DbxFirebaseDocumentLoaderInstanceInitConfig<T, D, A>): DbxLimitedFirebaseDocumentLoaderInstance<T, D, A> {\n  return new DbxLimitedFirebaseDocumentLoaderInstance<T, D, A>(config);\n}\n\nexport function dbxLimitedFirebaseDocumentLoaderInstanceWithAccessor<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>>(accessor: A): DbxLimitedFirebaseDocumentLoaderInstance<T, D, A> {\n  return new DbxLimitedFirebaseDocumentLoaderInstance<T, D, A>({ accessor });\n}\n\n// MARK: Full DbxFirebaseDocumentLoaderInstance\nexport class DbxFirebaseDocumentLoaderInstance<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends FirestoreDocumentAccessor<T, D> = FirestoreDocumentAccessor<T, D>> extends DbxLimitedFirebaseDocumentLoaderInstance<T, D, A> implements DbxFirebaseDocumentLoader<T>, Destroyable {\n  setIds(ids: Maybe<ObservableOrValue<ArrayOrValue<FirestoreModelKey>>>): void {\n    this.setDocuments(asObservable(ids).pipe(map((x) => loadDocumentsForIds(this.accessor, asArray(x)))));\n  }\n}\n\nexport function dbxFirebaseDocumentLoaderInstance<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends FirestoreDocumentAccessor<T, D> = FirestoreDocumentAccessor<T, D>>(config: DbxFirebaseDocumentLoaderInstanceInitConfig<T, D, A>): DbxFirebaseDocumentLoaderInstance<T, D, A> {\n  return new DbxFirebaseDocumentLoaderInstance<T, D, A>(config);\n}\n\nexport function dbxFirebaseDocumentLoaderInstanceWithAccessor<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends FirestoreDocumentAccessor<T, D> = FirestoreDocumentAccessor<T, D>>(accessor: A): DbxFirebaseDocumentLoaderInstance<T, D, A> {\n  return new DbxFirebaseDocumentLoaderInstance<T, D, A>({ accessor });\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"document.loader.instance.js","sourceRoot":"","sources":["../../../../../../../packages/dbx-firebase/src/lib/model/loader/document.loader.instance.ts"],"names":[],"mappings":"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","sourcesContent":["import { ObservableOrValue, useAsObservable, PageListLoadingState, filterMaybe, SubscriptionObject, asObservable, pageLoadingStateFromObs } from '@dereekb/rxjs';\nimport { BehaviorSubject, map, shareReplay, distinctUntilChanged, Subject, switchMap, Observable, startWith, exhaustMap } from 'rxjs';\nimport { dataFromDocumentSnapshots, DocumentDataWithId, DocumentReference, documentReferencesFromDocuments, DocumentSnapshot, FirestoreDocument, FirestoreDocumentAccessor, firestoreModelIdsFromDocuments, FirestoreModelKey, firestoreModelKeysFromDocuments, getDataFromDocumentSnapshots, getDocumentSnapshots, LimitedFirestoreDocumentAccessor, loadDocumentsForDocumentReferences, loadDocumentsForIds, loadDocumentsForKeys, streamDocumentSnapshots } from '@dereekb/firebase';\nimport { ArrayOrValue, asArray, Destroyable, Maybe } from '@dereekb/util';\nimport { DbxFirebaseDocumentLoader, DbxLimitedFirebaseDocumentLoader } from './document.loader';\n\nexport interface DbxFirebaseDocumentLoaderInstanceInitConfig<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>> {\n  readonly accessor: A;\n}\n\n/**\n * DbxLimitedFirebaseDocumentLoader implementation within an instance.\n */\nexport class DbxLimitedFirebaseDocumentLoaderInstance<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>> implements DbxLimitedFirebaseDocumentLoader<T>, Destroyable {\n  readonly accessor: A = this._initConfig.accessor;\n\n  protected readonly _documents = new BehaviorSubject<Maybe<D[]>>(undefined);\n  protected readonly _restart = new Subject<void>();\n  protected readonly _sub = new SubscriptionObject();\n\n  readonly documents$ = this._documents.pipe(filterMaybe(), distinctUntilChanged());\n  readonly keys$ = this.documents$.pipe(map(firestoreModelKeysFromDocuments));\n  readonly ids$ = this.documents$.pipe(map(firestoreModelIdsFromDocuments));\n  readonly refs$ = this.documents$.pipe(map(documentReferencesFromDocuments));\n\n  readonly snapshots$: Observable<DocumentSnapshot<T>[]> = this.documents$.pipe(\n    switchMap((docs) =>\n      this._restart.pipe(\n        startWith(null),\n        exhaustMap(() => getDocumentSnapshots<T, D>(docs))\n      )\n    ),\n    shareReplay(1)\n  );\n\n  readonly data$: Observable<DocumentDataWithId<T>[]> = this.snapshots$.pipe(\n    map((snapshots) => getDataFromDocumentSnapshots(snapshots, true)),\n    shareReplay(1)\n  );\n\n  /**\n   * Snapshot stream of the documents\n   */\n  readonly snapshotsStream$: Observable<DocumentSnapshot<T>[]> = this.documents$.pipe(\n    switchMap((docs) => streamDocumentSnapshots<T, D>(docs)),\n    shareReplay(1)\n  );\n\n  /**\n   * Data streamd of the documents.\n   */\n  readonly dataStream$: Observable<DocumentDataWithId<T>[]> = this.snapshotsStream$.pipe(dataFromDocumentSnapshots(), shareReplay(1));\n\n  readonly pageLoadingState$: Observable<PageListLoadingState<DocumentDataWithId<T>>> = pageLoadingStateFromObs(this.data$, false);\n  readonly pageLoadingStateStream$: Observable<PageListLoadingState<DocumentDataWithId<T>>> = pageLoadingStateFromObs(this.dataStream$, false);\n\n  constructor(private readonly _initConfig: DbxFirebaseDocumentLoaderInstanceInitConfig<T, D, A>) {}\n\n  destroy(): void {\n    this._documents.complete();\n    this._restart.complete();\n    this._sub.destroy();\n  }\n\n  restart() {\n    this._restart.next();\n  }\n\n  setKeys(keys: Maybe<ObservableOrValue<ArrayOrValue<FirestoreModelKey>>>): void {\n    this.setDocuments(asObservable(keys).pipe(map((x) => loadDocumentsForKeys(this.accessor, asArray(x)))));\n  }\n\n  setRefs(refs: Maybe<ObservableOrValue<ArrayOrValue<DocumentReference<T>>>>): void {\n    this.setDocuments(asObservable(refs).pipe(map((x) => loadDocumentsForDocumentReferences(this.accessor, asArray(x)))));\n  }\n\n  setDocuments(docs: Maybe<ObservableOrValue<ArrayOrValue<D>>>): void {\n    this._sub.subscription = useAsObservable(docs, (x) => this._documents.next(asArray(x)));\n  }\n}\n\nexport function dbxLimitedFirebaseDocumentLoaderInstance<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>>(config: DbxFirebaseDocumentLoaderInstanceInitConfig<T, D, A>): DbxLimitedFirebaseDocumentLoaderInstance<T, D, A> {\n  return new DbxLimitedFirebaseDocumentLoaderInstance<T, D, A>(config);\n}\n\nexport function dbxLimitedFirebaseDocumentLoaderInstanceWithAccessor<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends LimitedFirestoreDocumentAccessor<T, D> = LimitedFirestoreDocumentAccessor<T, D>>(accessor: A): DbxLimitedFirebaseDocumentLoaderInstance<T, D, A> {\n  return new DbxLimitedFirebaseDocumentLoaderInstance<T, D, A>({ accessor });\n}\n\n// MARK: Full DbxFirebaseDocumentLoaderInstance\nexport class DbxFirebaseDocumentLoaderInstance<T = unknown, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends FirestoreDocumentAccessor<T, D> = FirestoreDocumentAccessor<T, D>> extends DbxLimitedFirebaseDocumentLoaderInstance<T, D, A> implements DbxFirebaseDocumentLoader<T>, Destroyable {\n  setIds(ids: Maybe<ObservableOrValue<ArrayOrValue<FirestoreModelKey>>>): void {\n    this.setDocuments(asObservable(ids).pipe(map((x) => loadDocumentsForIds(this.accessor, asArray(x)))));\n  }\n}\n\nexport function dbxFirebaseDocumentLoaderInstance<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends FirestoreDocumentAccessor<T, D> = FirestoreDocumentAccessor<T, D>>(config: DbxFirebaseDocumentLoaderInstanceInitConfig<T, D, A>): DbxFirebaseDocumentLoaderInstance<T, D, A> {\n  return new DbxFirebaseDocumentLoaderInstance<T, D, A>(config);\n}\n\nexport function dbxFirebaseDocumentLoaderInstanceWithAccessor<T, D extends FirestoreDocument<T> = FirestoreDocument<T>, A extends FirestoreDocumentAccessor<T, D> = FirestoreDocumentAccessor<T, D>>(accessor: A): DbxFirebaseDocumentLoaderInstance<T, D, A> {\n  return new DbxFirebaseDocumentLoaderInstance<T, D, A>({ accessor });\n}\n"]}

package/esm2020/lib/model/loader/document.loader.mjs CHANGED Viewed

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZG9jdW1lbnQubG9hZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvZGJ4LWZpcmViYXNlL3NyYy9saWIvbW9kZWwvbG9hZGVyL2RvY3VtZW50LmxvYWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRG9jdW1lbnREYXRhV2l0aElkLCBGaXJlc3RvcmVNb2RlbEtleSwgRG9jdW1lbnRSZWZlcmVuY2UsIEZpcmVzdG9yZURvY3VtZW50LCBGaXJlc3RvcmVNb2RlbElkLCBEb2N1bWVudFNuYXBzaG90IH0gZnJvbSAnQGRlcmVla2IvZmlyZWJhc2UnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZU9yVmFsdWUsIFBhZ2VMaXN0TG9hZGluZ1N0YXRlIH0gZnJvbSAnQGRlcmVla2Ivcnhqcyc7XG5pbXBvcnQgeyBNYXliZSwgQXJyYXlPclZhbHVlIH0gZnJvbSAnQGRlcmVla2IvdXRpbCc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5cbi8qKlxuICogQWJzdHJhY3QgdHlwZSB0aGF0IGxvYWRzIGRvY3VtZW50IHNuYXBzaG90cyBmcm9tIGtleXMsIHJlZnMsIG9yIGRvY3VtZW50cy5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBEYnhMaW1pdGVkRmlyZWJhc2VEb2N1bWVudExvYWRlcjxUID0gdW5rbm93biwgRCBleHRlbmRzIEZpcmVzdG9yZURvY3VtZW50PFQ+ID0gRmlyZXN0b3JlRG9jdW1lbnQ8VD4+IHtcbiAgLyoqXG4gICAqIEtleXMgb2YgdGhlIGRvY3VtZW50c1xuICAgKi9cbiAgcmVhZG9ubHkga2V5cyQ6IE9ic2VydmFibGU8RmlyZXN0b3JlTW9kZWxLZXlbXT47XG5cbiAgLyoqXG4gICAqIFJlZnMgb2YgdGhlIGRvY3VtZW50c1xuICAgKi9cbiAgcmVhZG9ubHkgcmVmcyQ6IE9ic2VydmFibGU8RG9jdW1lbnRSZWZlcmVuY2U8VD5bXT47XG5cbiAgLyoqXG4gICAqIElkcyBvZiB0aGUgZG9jdW1lbnRzXG4gICAqL1xuICByZWFkb25seSBpZHMkOiBPYnNlcnZhYmxlPEZpcmVzdG9yZU1vZGVsSWRbXT47XG5cbiAgLyoqXG4gICAqIERvY3VtZW50cyB0byBsb2FkLlxuICAgKi9cbiAgcmVhZG9ubHkgZG9jdW1lbnRzJDogT2JzZXJ2YWJsZTxEW10+O1xuXG4gIC8qKlxuICAgKiBTbmFwc2hvdHMgb2YgdGhlIGRvY3VtZW50c1xuICAgKi9cbiAgcmVhZG9ubHkgc25hcHNob3RzJDogT2JzZXJ2YWJsZTxEb2N1bWVudFNuYXBzaG90PFQ+W10+O1xuXG4gIC8qKlxuICAgKiBEYXRhIGZyb20gdGhlIGRvY3VtZW50cy5cbiAgICovXG4gIHJlYWRvbmx5IGRhdGEkOiBPYnNlcnZhYmxlPERvY3VtZW50RGF0YVdpdGhJZDxUPltdPjtcblxuICAvKipcbiAgICogTG9hZGluZyBzdGF0ZSBmb3IgdGhlIGRvY3VtZW50IGRhdGEuXG4gICAqL1xuICByZWFkb25seSBwYWdlTG9hZGluZ1N0YXRlJDogT2JzZXJ2YWJsZTxQYWdlTGlzdExvYWRpbmdTdGF0ZTxEb2N1bWVudERhdGFXaXRoSWQ8VD4+PjtcblxuICAvKipcbiAgICogU2V0cyB0aGUga2V5cyBvZiB0aGUgbW9kZWxzIHRvIGxvYWQuXG4gICAqXG4gICAqIEBwYXJhbSBjb25zdHJhaW50c1xuICAgKi9cbiAgc2V0S2V5cyhrZXlzOiBNYXliZTxPYnNlcnZhYmxlT3JWYWx1ZTxBcnJheU9yVmFsdWU8RmlyZXN0b3JlTW9kZWxLZXk+Pj4pOiB2b2lkO1xuXG4gIC8qKlxuICAgKiBTZXRzIHRoZSBkb2N1bWVudCByZWZlcmVuY2VzIHRvIGxvYWQuXG4gICAqXG4gICAqIEBwYXJhbSBjb25zdHJhaW50c1xuICAgKi9cbiAgc2V0UmVmcyhyZWZzOiBNYXliZTxPYnNlcnZhYmxlT3JWYWx1ZTxBcnJheU9yVmFsdWU8RG9jdW1lbnRSZWZlcmVuY2U8VD4+Pj4pOiB2b2lkO1xuXG4gIC8qKlxuICAgKiBTZXRzIHRoZSBkb2N1bWVudHMgdG8gbG9hZCBmcm9tLlxuICAgKlxuICAgKiBAcGFyYW0gY29uc3RyYWludHNcbiAgICovXG4gIHNldERvY3VtZW50cyhkb2NzOiBNYXliZTxPYnNlcnZhYmxlT3JWYWx1ZTxBcnJheU9yVmFsdWU8RD4+Pik6IHZvaWQ7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGJ4RmlyZWJhc2VEb2N1bWVudExvYWRlcjxUID0gdW5rbm93biwgRCBleHRlbmRzIEZpcmVzdG9yZURvY3VtZW50PFQ+ID0gRmlyZXN0b3JlRG9jdW1lbnQ8VD4+IGV4dGVuZHMgRGJ4TGltaXRlZEZpcmViYXNlRG9jdW1lbnRMb2FkZXI8VCwgRD4ge1xuICAvKipcbiAgICogU2V0cyB0aGUgaWRzIG9mIHRoZSBtb2RlbHMgdG8gbG9hZC5cbiAgICpcbiAgICogQHBhcmFtIGNvbnN0cmFpbnRzXG4gICAqL1xuICBzZXRJZHMoaWRzOiBNYXliZTxPYnNlcnZhYmxlT3JWYWx1ZTxBcnJheU9yVmFsdWU8RmlyZXN0b3JlTW9kZWxJZD4+Pik6IHZvaWQ7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -1,49 +1,45 @@
-import { shareReplay, startWith, switchMap, BehaviorSubject, distinctUntilChanged, combineLatest, map, filter, take } from 'rxjs';
 import { Directive, Input } from '@angular/core';
 import { DbxFirebaseCollectionStoreDirective } from './store.collection.directive';
-import { AbstractSubscriptionDirective } from '@dereekb/dbx-core';
+import { dbxFirebaseCollectionChangeWatcher } from '../loader/collection.change.watcher';
+import { dbxFirebaseCollectionChangeTriggerInstanceForWatcher } from '../loader/collection.change.trigger';
 import * as i0 from "@angular/core";
 import * as i1 from "./store.collection.directive";
 /**
  * Used to watch query doc changes and respond to them accordingly.
  */
-export class DbxFirebaseCollectionChangeDirective extends AbstractSubscriptionDirective {
+export class DbxFirebaseCollectionChangeDirective {
     constructor(dbxFirebaseCollectionStoreDirective) {
-        super();
         this.dbxFirebaseCollectionStoreDirective = dbxFirebaseCollectionStoreDirective;
-        this._mode = new BehaviorSubject('manual');
-        this.mode$ = this._mode.pipe(distinctUntilChanged());
-        this.event$ = this.dbxFirebaseCollectionStoreDirective.store.queryChangeWatcher$.pipe(switchMap((x) => x.event$.pipe(filter((x) => x.type !== 'none'), // do not share 'none' events.
-        take(1), // only need one event to mark as change is available.
-        startWith({
-            time: new Date(),
-            type: 'none'
-        }))), shareReplay(1));
-        this.hasChangeAvailable$ = this.event$.pipe(map((x) => x.type !== 'none'), shareReplay(1));
+        this._watcher = dbxFirebaseCollectionChangeWatcher(this.dbxFirebaseCollectionStoreDirective.store);
+        this._trigger = dbxFirebaseCollectionChangeTriggerInstanceForWatcher(this._watcher, () => this.restart());
+        this.mode$ = this._watcher.mode$;
+        this.event$ = this._watcher.event$;
+        this.hasChangeAvailable$ = this._watcher.hasChangeAvailable$;
+        this.triggered$ = this._watcher.triggered$;
+        this.trigger$ = this._watcher.trigger$;
+    }
+    get store() {
+        return this._watcher.store;
     }
     ngOnInit() {
-        this.sub = combineLatest([this.mode$, this.hasChangeAvailable$])
-            .pipe(filter(([mode, hasChange]) => mode === 'auto' && hasChange))
-            .subscribe(() => {
-            this.restart();
-        });
+        this._trigger.init();
     }
     ngOnDestroy() {
-        super.ngOnDestroy();
-        this._mode.complete();
+        this._watcher.destroy();
+        this._trigger.destroy();
     }
     get mode() {
-        return this._mode.value;
+        return this._watcher.mode;
     }
     set mode(mode) {
-        this._mode.next(mode || 'manual');
+        this._watcher.mode = mode || 'off';
     }
     restart() {
         this.dbxFirebaseCollectionStoreDirective.store.restart();
     }
 }
 DbxFirebaseCollectionChangeDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFirebaseCollectionChangeDirective, deps: [{ token: i1.DbxFirebaseCollectionStoreDirective }], target: i0.ɵɵFactoryTarget.Directive });
-DbxFirebaseCollectionChangeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.2", type: DbxFirebaseCollectionChangeDirective, selector: "[dbxFirebaseCollectionChange]", inputs: { mode: ["dbxFirebaseCollectionChange", "mode"] }, usesInheritance: true, ngImport: i0 });
+DbxFirebaseCollectionChangeDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.2", type: DbxFirebaseCollectionChangeDirective, selector: "[dbxFirebaseCollectionChange]", inputs: { mode: ["dbxFirebaseCollectionChange", "mode"] }, ngImport: i0 });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: DbxFirebaseCollectionChangeDirective, decorators: [{
             type: Directive,
             args: [{
@@ -53,4 +49,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImpor
                 type: Input,
                 args: ['dbxFirebaseCollectionChange']
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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