@bravobit/bb-foundation 0.26.2 → 0.27.0

package/esm2022/auth/lib/auth.service.mjs

@@ -0,0 +1,271 @@
+import { AUTH_REDIRECT_HANDLER } from './interfaces/config.interface';
+import { HttpContext } from '@angular/common/http';
+import { makeStateKey } from '@angular/platform-browser';
+import { Inject, Injectable, Optional } from '@angular/core';
+import { USE_AUTHORIZATION } from './tokens/use-authorization.token';
+import { AuthVerifyProvider } from './providers/verify.provider';
+import { AuthEmailProvider } from './providers/email.provider';
+import { firstValueFrom, of } from 'rxjs';
+import { AuthSession } from './auth.session';
+import { map, tap } from 'rxjs/operators';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@bravobit/bb-foundation/storage";
+import * as i2 from "@angular/cdk/platform";
+import * as i3 from "@angular/common/http";
+import * as i4 from "./interfaces/config.interface";
+import * as i5 from "@angular/platform-browser";
+import * as i6 from "@bravobit/bb-foundation/http";
+class Auth {
+    constructor(_storage, _injector, _platform, _httpClient, _config, _state, _httpConfig, _handler) {
+        this._storage = _storage;
+        this._injector = _injector;
+        this._platform = _platform;
+        this._httpClient = _httpClient;
+        this._config = _config;
+        this._state = _state;
+        this._httpConfig = _httpConfig;
+        this._handler = _handler;
+        // Readonly data.
+        this._authStateKey = makeStateKey(`bbAuthStateKey`);
+        this._httpAlias = this._httpConfig?.defaultAlias ?? null;
+        this._refreshHandler = null;
+        // We select a storage strategy based on the server/browser.
+        // Only cookies CAN work on the server.
+        const storageStrategy = this._platform.isBrowser
+            ? this._storage.select(["cookie" /* StorageOption.Cookie */, "local" /* StorageOption.Local */])
+            : this._storage.cookie;
+        // Starting the new session.
+        this.session = new AuthSession({
+            id: this._config?.applicationId,
+            storage: storageStrategy
+        });
+        this.user = this.session.user;
+    }
+    initialize() {
+        return async () => {
+            // Check if the app should bootstrap the authentication.
+            const shouldBootstrap = this._config?.bootstrap ?? true;
+            if (!shouldBootstrap) {
+                return this.handleAutoRefreshing();
+            }
+            // Only retrieve from the server when we are actually authenticated.
+            if (!this.session.authenticated()) {
+                return;
+            }
+            // Get the key from the server state.
+            if (this._state && this._state?.hasKey(this._authStateKey)) {
+                const user = this._state?.get(this._authStateKey, null) ?? null;
+                return this.session.setUser(user);
+            }
+            // Try to fetch the user from the server.
+            const user$ = this.me();
+            const user = await firstValueFrom(user$, { defaultValue: null });
+            // Set the state if exists.
+            if (this._state) {
+                this._state?.set(this._authStateKey, user ?? null);
+            }
+            // Save the user in the storage and handle auto refreshing.
+            this.session.setUser(user);
+            this.handleAutoRefreshing();
+        };
+    }
+    me() {
+        const url = this.getUrl('auth/me');
+        return this._httpClient.get(url);
+    }
+    async signIn(provider, as) {
+        const { accessToken, refreshToken, user, ...result } = await provider.authenticate(this._httpClient);
+        // Check if the role matches.
+        const role = user?.role ?? null;
+        if (as && !as.includes(role)) {
+            throw new Error('Invalid role.');
+        }
+        // Validate if the provider is one of the available
+        // providers then return the user object and the provider.
+        const apiProvider = result?.provider ?? null;
+        const apiVerifyToken = result?.verifyToken ?? null;
+        const availableProviders = this._config?.providers ?? ['email', 'sms', 'totp'];
+        if (availableProviders.includes(apiProvider)) {
+            return { user, provider: apiProvider, verifyToken: apiVerifyToken };
+        }
+        // Set the tokens in storage.
+        this.setTokens(accessToken, refreshToken);
+        // Set the user in storage.
+        this.session.setUser(user);
+        // Return the user.
+        return { user };
+    }
+    async signInWithEmail(email, password, as) {
+        const url = this.getUrl('auth/login');
+        return this.signIn(new AuthEmailProvider(email, password, url), as);
+    }
+    async signInWithVerifyCode(code, verifyToken) {
+        const url = this.getUrl('auth/verify');
+        return this.signIn(new AuthVerifyProvider(code, verifyToken, url));
+    }
+    async resendVerifyCode(verifyToken) {
+        const url = this.getUrl('auth/resend');
+        const result$ = this._httpClient.post(url, {
+            verify_token: verifyToken
+        });
+        return firstValueFrom(result$);
+    }
+    async register(data, options) {
+        // Execute API call.
+        const url = this.getUrl('auth/register');
+        const result$ = this._httpClient.post(url, data, options);
+        const result = await firstValueFrom(result$);
+        // Set the tokens in storage.
+        this.setTokens(result?.token, result?.refresh_token);
+        // Set the user in storage.
+        const user = result?.user;
+        this.session.setUser(user);
+        // Return the user.
+        return user;
+    }
+    logout() {
+        // If we don't have a refresh token just clear the session.
+        // Note: We do this because else we try to invalidate
+        // an "undefined" refresh token.
+        const refreshToken = this.session.refreshToken;
+        if (!refreshToken) {
+            return this.session.clear();
+        }
+        // We do have a refresh token, so try to
+        // invalidate it in the backend.
+        try {
+            const url = this.getUrl('auth/logout');
+            const headerName = this._config?.http?.header ?? 'Authorization';
+            const observable$ = this._httpClient.get(url, {
+                headers: { [headerName]: refreshToken }
+            });
+            firstValueFrom(observable$).then(_ => _).catch(_ => _);
+        }
+        catch {
+            // Do nothing because the tokens will be deleted anyways from the session.
+        }
+        // Delete the tokens from the session.
+        return this.session.clear();
+    }
+    refresh() {
+        // If the refresh token does
+        // not exist just return an observable of null.
+        const refreshToken = this.session.refreshToken;
+        if (!refreshToken) {
+            return of(null);
+        }
+        // Perform the refresh call.
+        const headerName = this._config?.http?.header ?? 'Authorization';
+        const scheme = this._config?.http?.scheme ?? 'Bearer';
+        const url = this.getUrl('auth/refresh');
+        const context = new HttpContext().set(USE_AUTHORIZATION, false);
+        return this._httpClient.get(url, {
+            headers: { [headerName]: `${scheme} ${refreshToken}` },
+            context: context
+        }).pipe(tap(({ token, refresh_token }) => this.setTokens(token, refresh_token)), map(({ token }) => token));
+    }
+    async requestPassword(email, extraParams = {}) {
+        const url = this.getUrl('auth/reset');
+        const observable$ = this._httpClient.post(url, { ...extraParams, email });
+        return firstValueFrom(observable$);
+    }
+    async resetPassword(token, newPassword, extraParams = {}) {
+        const url = this.getUrl('auth/reset-password');
+        const observable$ = this._httpClient.post(url, { ...extraParams, token, password: newPassword });
+        return firstValueFrom(observable$);
+    }
+    clearAndRedirect() {
+        // 1. Delete the tokens from the session.
+        this.session.clear();
+        if (this._handler) {
+            const urlTree = this._handler.onFailedAuthenticated();
+            if (!urlTree || urlTree === true) {
+                return;
+            }
+            this.router.navigateByUrl(urlTree).then(_ => _);
+            return;
+        }
+        // 2. Compose the route url.
+        const redirectUrl = this._config?.redirects.unauthenticated ?? null;
+        // 3. Route back if the user provided a redirect url.
+        if (this.router && redirectUrl) {
+            const commands = Array.isArray(redirectUrl) ? redirectUrl : [redirectUrl];
+            this.router.navigate(commands).then(_ => _);
+        }
+    }
+    setTokens(accessToken, refreshToken) {
+        // Set the tokens in our session.
+        this.session.setTokens(accessToken, refreshToken);
+        // We need to update the auto refresh of the refresh token.
+        this.handleAutoRefreshing();
+    }
+    handleAutoRefreshing() {
+        const shouldAutoRefresh = this._config?.autoRefresh ?? false;
+        if (!shouldAutoRefresh) {
+            return;
+        }
+        const expiresAt = this.session.refreshTokenPayload?.expiresAt ?? null;
+        if (expiresAt === null || !this._platform.isBrowser) {
+            return;
+        }
+        const differenceInMilliseconds = expiresAt.getTime() - Date.now();
+        const offsetInMilliseconds = 10000; // 10 seconds.
+        // We want to start the refresh 10 seconds before it expires.
+        const actualTiming = differenceInMilliseconds - offsetInMilliseconds;
+        if (actualTiming <= 0) {
+            return;
+        }
+        // We need to cap the timings because if
+        // we get large numbers it might cause unwanted results.
+        const maxTiming = 1000 * 60 * 60 * 24; // 24 hours.
+        const cappedTiming = Math.max(1, Math.min(actualTiming, maxTiming));
+        try {
+            if (this._refreshHandler !== null) {
+                clearTimeout?.(this._refreshHandler);
+                this._refreshHandler = null;
+            }
+            this._refreshHandler = window?.setTimeout?.(() => this.autoRefresh(), cappedTiming);
+        }
+        catch {
+            // Just ignore it.
+        }
+    }
+    async autoRefresh() {
+        try {
+            // We just need to wait for it to refresh.
+            const refresh$ = this.refresh();
+            await firstValueFrom(refresh$);
+        }
+        catch {
+            // Something went wrong refreshing, we need to clear.
+            this.clearAndRedirect();
+        }
+    }
+    get router() {
+        return this._injector.get(Router);
+    }
+    getUrl(endpoint) {
+        return [this._httpAlias, endpoint]
+            .filter(item => !!item)
+            .join('/');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Auth, deps: [{ token: i1.Storage }, { token: i0.Injector }, { token: i2.Platform }, { token: i3.HttpClient }, { token: i4.AuthConfig, optional: true }, { token: i5.TransferState, optional: true }, { token: i6.HttpConfig, optional: true }, { token: AUTH_REDIRECT_HANDLER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Auth }); }
+}
+export { Auth };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: Auth, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Storage }, { type: i0.Injector }, { type: i2.Platform }, { type: i3.HttpClient }, { type: i4.AuthConfig, decorators: [{
+                    type: Optional
+                }] }, { type: i5.TransferState, decorators: [{
+                    type: Optional
+                }] }, { type: i6.HttpConfig, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AUTH_REDIRECT_HANDLER]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.service.js","sourceRoot":"","sources":["../../../../../projects/bb-foundation/auth/src/lib/auth.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {AUTH_REDIRECT_HANDLER, AuthConfig, AuthRedirectHandler} from './interfaces/config.interface';\nimport {HttpClient, HttpContext, HttpHeaders, HttpParams} from '@angular/common/http';\nimport {AuthProvider, AuthSignInResponse} from './interfaces/provider.interface';\nimport {makeStateKey, StateKey, TransferState} from '@angular/platform-browser';\nimport {Storage, StorageOption} from '@bravobit/bb-foundation/storage';\nimport {Inject, Injectable, Injector, Optional} from '@angular/core';\nimport {USE_AUTHORIZATION} from './tokens/use-authorization.token';\nimport {AuthVerifyProvider} from './providers/verify.provider';\nimport {AuthEmailProvider} from './providers/email.provider';\nimport {HttpConfig} from '@bravobit/bb-foundation/http';\nimport {firstValueFrom, Observable, of} from 'rxjs';\nimport {Platform} from '@angular/cdk/platform';\nimport {AuthSession} from './auth.session';\nimport {map, tap} from 'rxjs/operators';\nimport {Router} from '@angular/router';\n\n@Injectable()\nexport class Auth {\n\n    // Readonly data.\n    private readonly _authStateKey: StateKey<any | null> = makeStateKey(`bbAuthStateKey`);\n    private readonly _httpAlias: string | null = this._httpConfig?.defaultAlias ?? null;\n\n    readonly session: AuthSession;\n    readonly user: Observable<any | null>;\n\n    private _refreshHandler: number | null = null;\n\n    constructor(private _storage: Storage,\n                private _injector: Injector,\n                private _platform: Platform,\n                private _httpClient: HttpClient,\n                @Optional() private _config?: AuthConfig,\n                @Optional() private _state?: TransferState,\n                @Optional() private _httpConfig?: HttpConfig,\n                @Optional() @Inject(AUTH_REDIRECT_HANDLER) private _handler?: AuthRedirectHandler) {\n        // We select a storage strategy based on the server/browser.\n        // Only cookies CAN work on the server.\n        const storageStrategy = this._platform.isBrowser\n            ? this._storage.select([StorageOption.Cookie, StorageOption.Local])\n            : this._storage.cookie;\n\n        // Starting the new session.\n        this.session = new AuthSession({\n            id: this._config?.applicationId,\n            storage: storageStrategy\n        });\n        this.user = this.session.user;\n    }\n\n    initialize() {\n        return async () => {\n            // Check if the app should bootstrap the authentication.\n            const shouldBootstrap = this._config?.bootstrap ?? true;\n            if (!shouldBootstrap) {\n                return this.handleAutoRefreshing();\n            }\n\n            // Only retrieve from the server when we are actually authenticated.\n            if (!this.session.authenticated()) {\n                return;\n            }\n\n            // Get the key from the server state.\n            if (this._state && this._state?.hasKey(this._authStateKey)) {\n                const user = this._state?.get(this._authStateKey, null) ?? null;\n                return this.session.setUser(user);\n            }\n\n            // Try to fetch the user from the server.\n            const user$ = this.me();\n            const user = await firstValueFrom(user$, {defaultValue: null});\n\n            // Set the state if exists.\n            if (this._state) {\n                this._state?.set<any>(this._authStateKey, user ?? null);\n            }\n\n            // Save the user in the storage and handle auto refreshing.\n            this.session.setUser(user);\n            this.handleAutoRefreshing();\n        };\n    }\n\n    me<T = any>() {\n        const url = this.getUrl('auth/me');\n        return this._httpClient.get<T>(url);\n    }\n\n    async signIn(provider: AuthProvider, as?: string[]) {\n        const {accessToken, refreshToken, user, ...result} = await provider.authenticate(this._httpClient);\n\n        // Check if the role matches.\n        const role = user?.role ?? null;\n        if (as && !as.includes(role)) {\n            throw new Error('Invalid role.');\n        }\n\n        // Validate if the provider is one of the available\n        // providers then return the user object and the provider.\n        const apiProvider = result?.provider ?? null;\n        const apiVerifyToken = result?.verifyToken ?? null;\n        const availableProviders = this._config?.providers ?? ['email', 'sms', 'totp'];\n        if (availableProviders.includes(apiProvider)) {\n            return <AuthSignInResponse>{user, provider: apiProvider, verifyToken: apiVerifyToken};\n        }\n\n        // Set the tokens in storage.\n        this.setTokens(accessToken, refreshToken);\n\n        // Set the user in storage.\n        this.session.setUser(user);\n\n        // Return the user.\n        return <AuthSignInResponse>{user};\n    }\n\n    async signInWithEmail(email: string, password: string, as?: string[]) {\n        const url = this.getUrl('auth/login');\n        return this.signIn(new AuthEmailProvider(email, password, url), as);\n    }\n\n    async signInWithVerifyCode(code: string, verifyToken: string) {\n        const url = this.getUrl('auth/verify');\n        return this.signIn(new AuthVerifyProvider(code, verifyToken, url));\n    }\n\n    async resendVerifyCode(verifyToken: string) {\n        const url = this.getUrl('auth/resend');\n        const result$ = this._httpClient.post(url, {\n            verify_token: verifyToken\n        });\n\n        return firstValueFrom(result$);\n    }\n\n    async register<T = any>(data: any, options?: {\n        headers?: HttpHeaders | {\n            [header: string]: string | string[];\n        };\n        params?: HttpParams | {\n            [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;\n        };\n    }) {\n        // Execute API call.\n        const url = this.getUrl('auth/register');\n        const result$ = this._httpClient.post<{ token: string, refresh_token: string, user: any }>(url, data, options);\n        const result = await firstValueFrom(result$);\n\n        // Set the tokens in storage.\n        this.setTokens(result?.token, result?.refresh_token);\n\n        // Set the user in storage.\n        const user = result?.user;\n        this.session.setUser(user);\n\n        // Return the user.\n        return <T>user;\n    }\n\n    logout() {\n        // If we don't have a refresh token just clear the session.\n        // Note: We do this because else we try to invalidate\n        // an \"undefined\" refresh token.\n        const refreshToken = this.session.refreshToken;\n        if (!refreshToken) {\n            return this.session.clear();\n        }\n\n        // We do have a refresh token, so try to\n        // invalidate it in the backend.\n        try {\n            const url = this.getUrl('auth/logout');\n            const headerName = this._config?.http?.header ?? 'Authorization';\n            const observable$ = this._httpClient.get(url, {\n                headers: {[headerName]: refreshToken}\n            });\n            firstValueFrom(observable$).then(_ => _).catch(_ => _);\n        } catch {\n            // Do nothing because the tokens will be deleted anyways from the session.\n        }\n\n        // Delete the tokens from the session.\n        return this.session.clear();\n    }\n\n    refresh() {\n        // If the refresh token does\n        // not exist just return an observable of null.\n        const refreshToken = this.session.refreshToken;\n        if (!refreshToken) {\n            return of(null);\n        }\n\n        // Perform the refresh call.\n        const headerName = this._config?.http?.header ?? 'Authorization';\n        const scheme = this._config?.http?.scheme ?? 'Bearer';\n\n        const url = this.getUrl('auth/refresh');\n        const context = new HttpContext().set(USE_AUTHORIZATION, false);\n\n        return this._httpClient.get<{ token: string, refresh_token: string }>(url, {\n            headers: {[headerName]: `${scheme} ${refreshToken}`},\n            context: context\n        }).pipe(\n            tap(({token, refresh_token}) => this.setTokens(token, refresh_token)),\n            map(({token}) => token)\n        );\n    }\n\n    async requestPassword(email: string, extraParams: { [key: string]: any } = {}) {\n        const url = this.getUrl('auth/reset');\n        const observable$ = this._httpClient.post(url, {...extraParams, email});\n        return firstValueFrom(observable$);\n    }\n\n    async resetPassword(token: string, newPassword: string, extraParams: { [key: string]: any } = {}) {\n        const url = this.getUrl('auth/reset-password');\n        const observable$ = this._httpClient.post(url, {...extraParams, token, password: newPassword});\n        return firstValueFrom(observable$);\n    }\n\n    clearAndRedirect() {\n        // 1. Delete the tokens from the session.\n        this.session.clear();\n\n        if (this._handler) {\n            const urlTree = this._handler.onFailedAuthenticated();\n            if (!urlTree || urlTree === true) {\n                return;\n            }\n\n            this.router.navigateByUrl(urlTree).then(_ => _);\n            return;\n        }\n\n        // 2. Compose the route url.\n        const redirectUrl = this._config?.redirects.unauthenticated ?? null;\n\n        // 3. Route back if the user provided a redirect url.\n        if (this.router && redirectUrl) {\n            const commands = Array.isArray(redirectUrl) ? redirectUrl : [redirectUrl];\n            this.router.navigate(commands).then(_ => _);\n        }\n    }\n\n    private setTokens(accessToken: string, refreshToken: string) {\n        // Set the tokens in our session.\n        this.session.setTokens(accessToken, refreshToken);\n\n        // We need to update the auto refresh of the refresh token.\n        this.handleAutoRefreshing();\n    }\n\n    private handleAutoRefreshing() {\n        const shouldAutoRefresh = this._config?.autoRefresh ?? false;\n        if (!shouldAutoRefresh) {\n            return;\n        }\n\n        const expiresAt = this.session.refreshTokenPayload?.expiresAt ?? null;\n        if (expiresAt === null || !this._platform.isBrowser) {\n            return;\n        }\n\n        const differenceInMilliseconds = expiresAt.getTime() - Date.now();\n        const offsetInMilliseconds = 10_000; // 10 seconds.\n\n        // We want to start the refresh 10 seconds before it expires.\n        const actualTiming = differenceInMilliseconds - offsetInMilliseconds;\n        if (actualTiming <= 0) {\n            return;\n        }\n\n        // We need to cap the timings because if\n        // we get large numbers it might cause unwanted results.\n        const maxTiming = 1000 * 60 * 60 * 24; // 24 hours.\n        const cappedTiming = Math.max(1, Math.min(actualTiming, maxTiming));\n        try {\n            if (this._refreshHandler !== null) {\n                clearTimeout?.(this._refreshHandler);\n                this._refreshHandler = null;\n            }\n            this._refreshHandler = window?.setTimeout?.(() => this.autoRefresh(), cappedTiming);\n        } catch {\n            // Just ignore it.\n        }\n    }\n\n    private async autoRefresh() {\n        try {\n            // We just need to wait for it to refresh.\n            const refresh$ = this.refresh();\n            await firstValueFrom(refresh$);\n        } catch {\n            // Something went wrong refreshing, we need to clear.\n            this.clearAndRedirect();\n        }\n    }\n\n    private get router() {\n        return this._injector.get(Router);\n    }\n\n    private getUrl(endpoint: string) {\n        return [this._httpAlias, endpoint]\n            .filter(item => !!item)\n            .join('/');\n    }\n\n}\n"]}

package/esm2022/auth/lib/directives/authenticated.directive.mjs

@@ -0,0 +1,43 @@
+import { Directive, Input } from '@angular/core';
+import { AbstractAuthDirective } from './abstract.directive';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../auth.service";
+class BbAuthenticated extends AbstractAuthDirective {
+    set bbAuthenticatedElse(templateRef) {
+        this.assertTemplate('bbAuthenticatedElse', templateRef);
+        this.elseTemplateRef = templateRef;
+        this.updateView();
+    }
+    constructor(_auth, _templateRef, _viewContainerRef) {
+        super(_templateRef, _viewContainerRef);
+        this._auth = _auth;
+        this._templateRef = _templateRef;
+        this._viewContainerRef = _viewContainerRef;
+        // Subscriptions.
+        this._subscription = new Subscription();
+    }
+    ngOnInit() {
+        const subscription = this._auth.user.pipe(map(user => !!user), distinctUntilChanged()).subscribe(valid => {
+            this.valid = valid;
+            this.updateView();
+        });
+        this._subscription.add(subscription);
+    }
+    ngOnDestroy() {
+        this._subscription?.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbAuthenticated, deps: [{ token: i1.Auth }, { token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: BbAuthenticated, selector: "[bbAuthenticated]", inputs: { bbAuthenticatedElse: "bbAuthenticatedElse" }, usesInheritance: true, ngImport: i0 }); }
+}
+export { BbAuthenticated };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbAuthenticated, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[bbAuthenticated]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Auth }, { type: i0.TemplateRef }, { type: i0.ViewContainerRef }]; }, propDecorators: { bbAuthenticatedElse: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/auth/lib/guards/anonymous.guard.mjs

@@ -0,0 +1,54 @@
+import { AUTH_REDIRECT_HANDLER } from '../interfaces/config.interface';
+import { Inject, Injectable, Optional } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { first } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../auth.service";
+import * as i2 from "@angular/router";
+import * as i3 from "../interfaces/config.interface";
+class BbAnonymousGuard {
+    constructor(_auth, _router, _config, _handler) {
+        this._auth = _auth;
+        this._router = _router;
+        this._config = _config;
+        this._handler = _handler;
+    }
+    canActivate(snapshot, state) {
+        return this._auth.user.pipe(map(user => !!user), map(isAuthenticated => {
+            if (!isAuthenticated) {
+                return true;
+            }
+            if (this._handler) {
+                return this._handler.onFailedAnonymous(snapshot, state);
+            }
+            // If we don't have a URL to go to we can just say
+            // the user is not allowed in this route by returning false.
+            const nextUrl = this._config?.redirects?.authenticated ?? null;
+            if (!nextUrl) {
+                return false;
+            }
+            const commands = Array.isArray(nextUrl) ? nextUrl : [nextUrl];
+            return this._router.createUrlTree(commands);
+        }), first());
+    }
+    canActivateChild(childRoute, state) {
+        return this.canActivate(childRoute, state);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbAnonymousGuard, deps: [{ token: i1.Auth }, { token: i2.Router }, { token: i3.AuthConfig, optional: true }, { token: AUTH_REDIRECT_HANDLER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbAnonymousGuard, providedIn: 'root' }); }
+}
+export { BbAnonymousGuard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbAnonymousGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Auth }, { type: i2.Router }, { type: i3.AuthConfig, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AUTH_REDIRECT_HANDLER]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/auth/lib/guards/authenticated.guard.mjs

@@ -0,0 +1,57 @@
+import { AUTH_REDIRECT_HANDLER } from '../interfaces/config.interface';
+import { Inject, Injectable, Optional } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { first } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../auth.service";
+import * as i2 from "@angular/router";
+import * as i3 from "../interfaces/config.interface";
+class BbAuthenticatedGuard {
+    constructor(_auth, _router, _config, _handler) {
+        this._auth = _auth;
+        this._router = _router;
+        this._config = _config;
+        this._handler = _handler;
+    }
+    canActivate(snapshot, state) {
+        return this._auth.user.pipe(map(user => !!user), map(isAuthenticated => {
+            if (isAuthenticated) {
+                return true;
+            }
+            if (this._handler) {
+                return this._handler.onFailedAuthenticated(snapshot, state);
+            }
+            // If we don't have a URL to go to we can just say
+            // the user is not allowed in this route by returning false.
+            const nextUrl = this._config?.redirects?.unauthenticated ?? null;
+            if (!nextUrl) {
+                return false;
+            }
+            const setRedirectOnFailedAuth = this._config?.setRedirectOnFailedAuth ?? true;
+            const redirectUrl = state?.url ?? null;
+            const queryParams = setRedirectOnFailedAuth && redirectUrl ? { redirectUrl } : {};
+            const commands = Array.isArray(nextUrl) ? nextUrl : [nextUrl];
+            return this._router.createUrlTree(commands, { queryParams });
+        }), first());
+    }
+    canActivateChild(childRoute, state) {
+        return this.canActivate(childRoute, state);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbAuthenticatedGuard, deps: [{ token: i1.Auth }, { token: i2.Router }, { token: i3.AuthConfig, optional: true }, { token: AUTH_REDIRECT_HANDLER, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbAuthenticatedGuard, providedIn: 'root' }); }
+}
+export { BbAuthenticatedGuard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BbAuthenticatedGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Auth }, { type: i2.Router }, { type: i3.AuthConfig, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AUTH_REDIRECT_HANDLER]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/collections/lib/collections.module.mjs

@@ -0,0 +1,55 @@
+import { BbCollectionsData, BbCollectionsEmpty, BbCollectionsError, BbCollectionsInitial } from './components/collections.directive';
+import { BbCollectionsViewer } from './components/collections-viewer/collections-viewer.component';
+import { BbCollectionsPager } from './components/collections-pager/collections-pager.component';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import * as i0 from "@angular/core";
+class CollectionsModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: CollectionsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: CollectionsModule, declarations: [
+            // Components.
+            BbCollectionsViewer,
+            BbCollectionsPager,
+            // Directives.
+            BbCollectionsData,
+            BbCollectionsEmpty,
+            BbCollectionsError,
+            BbCollectionsInitial], imports: [CommonModule], exports: [
+            // Components.
+            BbCollectionsViewer,
+            BbCollectionsPager,
+            // Directives.
+            BbCollectionsData,
+            BbCollectionsEmpty,
+            BbCollectionsError,
+            BbCollectionsInitial] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: CollectionsModule, imports: [CommonModule] }); }
+}
+export { CollectionsModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: CollectionsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [
+                        // Components.
+                        BbCollectionsViewer,
+                        BbCollectionsPager,
+                        // Directives.
+                        BbCollectionsData,
+                        BbCollectionsEmpty,
+                        BbCollectionsError,
+                        BbCollectionsInitial
+                    ],
+                    exports: [
+                        // Components.
+                        BbCollectionsViewer,
+                        BbCollectionsPager,
+                        // Directives.
+                        BbCollectionsData,
+                        BbCollectionsEmpty,
+                        BbCollectionsError,
+                        BbCollectionsInitial
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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