@abp/ng.oauth 7.0.0-rc.6

package/README.md

@@ -0,0 +1,7 @@
+# oauth
+
+This library was generated with [Nx](https://nx.dev).
+
+## Running unit tests
+
+Run `nx test oauth` to execute the unit tests.

package/esm2020/abp-ng.oauth.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWJwLW5nLm9hdXRoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvb2F1dGgvc3JjL2FicC1uZy5vYXV0aC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/lib/guards/index.mjs

@@ -0,0 +1,2 @@
+export * from './oauth.guard';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9vYXV0aC9zcmMvbGliL2d1YXJkcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vb2F1dGguZ3VhcmQnO1xyXG4iXX0=

package/esm2020/lib/guards/oauth.guard.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { OAuthService } from 'angular-oauth2-oidc';
+import { AuthService } from '@abp/ng.core';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-oauth2-oidc";
+import * as i2 from "@abp/ng.core";
+export class AbpOAuthGuard {
+    constructor(oauthService, authService) {
+        this.oauthService = oauthService;
+        this.authService = authService;
+    }
+    canActivate() {
+        const hasValidAccessToken = this.oauthService.hasValidAccessToken();
+        if (hasValidAccessToken) {
+            return true;
+        }
+        this.authService.navigateToLogin();
+        return false;
+    }
+}
+AbpOAuthGuard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthGuard, deps: [{ token: i1.OAuthService }, { token: i2.AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+AbpOAuthGuard.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthGuard, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.OAuthService }, { type: i2.AuthService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2F1dGguZ3VhcmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9vYXV0aC9zcmMvbGliL2d1YXJkcy9vYXV0aC5ndWFyZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVuRCxPQUFPLEVBQUUsV0FBVyxFQUFjLE1BQU0sY0FBYyxDQUFDOzs7O0FBS3ZELE1BQU0sT0FBTyxhQUFhO0lBQ3hCLFlBQW9CLFlBQTBCLEVBQVUsV0FBd0I7UUFBNUQsaUJBQVksR0FBWixZQUFZLENBQWM7UUFBVSxnQkFBVyxHQUFYLFdBQVcsQ0FBYTtJQUFHLENBQUM7SUFFcEYsV0FBVztRQUNULE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxtQkFBbUIsRUFBRSxDQUFDO1FBQ3BFLElBQUksbUJBQW1CLEVBQUU7WUFDdkIsT0FBTyxJQUFJLENBQUM7U0FDYjtRQUVELElBQUksQ0FBQyxXQUFXLENBQUMsZUFBZSxFQUFFLENBQUM7UUFDbkMsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDOzswR0FYVSxhQUFhOzhHQUFiLGFBQWEsY0FGWixNQUFNOzJGQUVQLGFBQWE7a0JBSHpCLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBDYW5BY3RpdmF0ZSwgVXJsVHJlZSB9IGZyb20gJ0Bhbmd1bGFyL3JvdXRlcic7XHJcbmltcG9ydCB7IE9BdXRoU2VydmljZSB9IGZyb20gJ2FuZ3VsYXItb2F1dGgyLW9pZGMnO1xyXG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XHJcbmltcG9ydCB7IEF1dGhTZXJ2aWNlLCBJQXV0aEd1YXJkIH0gZnJvbSAnQGFicC9uZy5jb3JlJztcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCcsXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBBYnBPQXV0aEd1YXJkIGltcGxlbWVudHMgQ2FuQWN0aXZhdGUsIElBdXRoR3VhcmQge1xyXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgb2F1dGhTZXJ2aWNlOiBPQXV0aFNlcnZpY2UsIHByaXZhdGUgYXV0aFNlcnZpY2U6IEF1dGhTZXJ2aWNlKSB7fVxyXG5cclxuICBjYW5BY3RpdmF0ZSgpOiBPYnNlcnZhYmxlPGJvb2xlYW4+IHwgYm9vbGVhbiB8IFVybFRyZWUge1xyXG4gICAgY29uc3QgaGFzVmFsaWRBY2Nlc3NUb2tlbiA9IHRoaXMub2F1dGhTZXJ2aWNlLmhhc1ZhbGlkQWNjZXNzVG9rZW4oKTtcclxuICAgIGlmIChoYXNWYWxpZEFjY2Vzc1Rva2VuKSB7XHJcbiAgICAgIHJldHVybiB0cnVlO1xyXG4gICAgfVxyXG5cclxuICAgIHRoaXMuYXV0aFNlcnZpY2UubmF2aWdhdGVUb0xvZ2luKCk7XHJcbiAgICByZXR1cm4gZmFsc2U7XHJcbiAgfVxyXG59XHJcbiJdfQ==

package/esm2020/lib/handlers/index.mjs

@@ -0,0 +1,2 @@
+export * from './oauth-configuration.handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9vYXV0aC9zcmMvbGliL2hhbmRsZXJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsK0JBQStCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL29hdXRoLWNvbmZpZ3VyYXRpb24uaGFuZGxlcic7XHJcbiJdfQ==

package/esm2020/lib/handlers/oauth-configuration.handler.mjs

@@ -0,0 +1,36 @@
+import { Inject, Injectable } from '@angular/core';
+import { OAuthService } from 'angular-oauth2-oidc';
+import compare from 'just-compare';
+import { filter, map } from 'rxjs/operators';
+import { EnvironmentService, CORE_OPTIONS } from '@abp/ng.core';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-oauth2-oidc";
+import * as i2 from "@abp/ng.core";
+export class OAuthConfigurationHandler {
+    constructor(oAuthService, environmentService, options) {
+        this.oAuthService = oAuthService;
+        this.environmentService = environmentService;
+        this.options = options;
+        this.listenToSetEnvironment();
+    }
+    listenToSetEnvironment() {
+        this.environmentService
+            .createOnUpdateStream(state => state)
+            .pipe(map(environment => environment.oAuthConfig), filter(config => !compare(config, this.options.environment.oAuthConfig)))
+            .subscribe(config => {
+            this.oAuthService.configure(config);
+        });
+    }
+}
+OAuthConfigurationHandler.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: OAuthConfigurationHandler, deps: [{ token: i1.OAuthService }, { token: i2.EnvironmentService }, { token: CORE_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable });
+OAuthConfigurationHandler.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: OAuthConfigurationHandler, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: OAuthConfigurationHandler, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.OAuthService }, { type: i2.EnvironmentService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [CORE_OPTIONS]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/interceptors/api.interceptor.mjs

@@ -0,0 +1,52 @@
+import { Inject, Injectable } from '@angular/core';
+import { OAuthService } from 'angular-oauth2-oidc';
+import { finalize } from 'rxjs/operators';
+import { SessionStateService, HttpWaitService, TENANT_KEY } from '@abp/ng.core';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-oauth2-oidc";
+import * as i2 from "@abp/ng.core";
+export class OAuthApiInterceptor {
+    constructor(oAuthService, sessionState, httpWaitService, tenantKey) {
+        this.oAuthService = oAuthService;
+        this.sessionState = sessionState;
+        this.httpWaitService = httpWaitService;
+        this.tenantKey = tenantKey;
+    }
+    intercept(request, next) {
+        this.httpWaitService.addRequest(request);
+        return next
+            .handle(request.clone({
+            setHeaders: this.getAdditionalHeaders(request.headers),
+        }))
+            .pipe(finalize(() => this.httpWaitService.deleteRequest(request)));
+    }
+    getAdditionalHeaders(existingHeaders) {
+        const headers = {};
+        const token = this.oAuthService.getAccessToken();
+        if (!existingHeaders?.has('Authorization') && token) {
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        const lang = this.sessionState.getLanguage();
+        if (!existingHeaders?.has('Accept-Language') && lang) {
+            headers['Accept-Language'] = lang;
+        }
+        const tenant = this.sessionState.getTenant();
+        if (!existingHeaders?.has(this.tenantKey) && tenant?.id) {
+            headers[this.tenantKey] = tenant.id;
+        }
+        headers['X-Requested-With'] = 'XMLHttpRequest';
+        return headers;
+    }
+}
+OAuthApiInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: OAuthApiInterceptor, deps: [{ token: i1.OAuthService }, { token: i2.SessionStateService }, { token: i2.HttpWaitService }, { token: TENANT_KEY }], target: i0.ɵɵFactoryTarget.Injectable });
+OAuthApiInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: OAuthApiInterceptor, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: OAuthApiInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.OAuthService }, { type: i2.SessionStateService }, { type: i2.HttpWaitService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TENANT_KEY]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/interceptors/index.mjs

@@ -0,0 +1,2 @@
+export * from './api.interceptor';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9vYXV0aC9zcmMvbGliL2ludGVyY2VwdG9ycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hcGkuaW50ZXJjZXB0b3InO1xyXG4iXX0=

package/esm2020/lib/oauth.module.mjs

@@ -0,0 +1,70 @@
+import { APP_INITIALIZER, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { OAuthModule, OAuthStorage } from 'angular-oauth2-oidc';
+import { ApiInterceptor, AuthGuard, AuthService, CHECK_AUTHENTICATION_STATE_FN_KEY, noop, PIPE_TO_LOGIN_FN_KEY, SET_TOKEN_RESPONSE_TO_STORAGE_FN_KEY, } from '@abp/ng.core';
+import { storageFactory } from './utils/storage.factory';
+import { AbpOAuthService } from './services';
+import { OAuthConfigurationHandler } from './handlers/oauth-configuration.handler';
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
+import { OAuthApiInterceptor } from './interceptors/api.interceptor';
+import { AbpOAuthGuard } from './guards/oauth.guard';
+import { NavigateToManageProfileProvider } from './providers';
+import { checkAccessToken, pipeToLogin, setTokenResponseToStorage } from './utils';
+import * as i0 from "@angular/core";
+export class AbpOAuthModule {
+    static forRoot() {
+        return {
+            ngModule: AbpOAuthModule,
+            providers: [
+                {
+                    provide: AuthService,
+                    useClass: AbpOAuthService,
+                },
+                {
+                    provide: AuthGuard,
+                    useClass: AbpOAuthGuard,
+                },
+                {
+                    provide: ApiInterceptor,
+                    useClass: OAuthApiInterceptor,
+                },
+                {
+                    provide: PIPE_TO_LOGIN_FN_KEY,
+                    useValue: pipeToLogin,
+                },
+                {
+                    provide: SET_TOKEN_RESPONSE_TO_STORAGE_FN_KEY,
+                    useValue: setTokenResponseToStorage,
+                },
+                {
+                    provide: CHECK_AUTHENTICATION_STATE_FN_KEY,
+                    useValue: checkAccessToken,
+                },
+                {
+                    provide: HTTP_INTERCEPTORS,
+                    useExisting: ApiInterceptor,
+                    multi: true,
+                },
+                NavigateToManageProfileProvider,
+                {
+                    provide: APP_INITIALIZER,
+                    multi: true,
+                    deps: [OAuthConfigurationHandler],
+                    useFactory: noop,
+                },
+                OAuthModule.forRoot().providers,
+                { provide: OAuthStorage, useFactory: storageFactory },
+            ],
+        };
+    }
+}
+AbpOAuthModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AbpOAuthModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthModule, imports: [CommonModule, OAuthModule] });
+AbpOAuthModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthModule, imports: [CommonModule, OAuthModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, OAuthModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/providers/index.mjs

@@ -0,0 +1,2 @@
+export * from './navigate-to-manage-profile.provider';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9vYXV0aC9zcmMvbGliL3Byb3ZpZGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVDQUF1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9uYXZpZ2F0ZS10by1tYW5hZ2UtcHJvZmlsZS5wcm92aWRlcic7XHJcbiJdfQ==

package/esm2020/lib/providers/navigate-to-manage-profile.provider.mjs

@@ -0,0 +1,17 @@
+import { inject } from '@angular/core';
+import { EnvironmentService, NAVIGATE_TO_MANAGE_PROFILE } from '@abp/ng.core';
+export const NavigateToManageProfileProvider = {
+    provide: NAVIGATE_TO_MANAGE_PROFILE,
+    useFactory: () => {
+        const environment = inject(EnvironmentService);
+        return () => {
+            const env = environment.getEnvironment();
+            if (!env.oAuthConfig) {
+                console.warn('The oAuthConfig env is missing on environment.ts');
+                return;
+            }
+            window.open(`${env.oAuthConfig.issuer}/Account/Manage?returnUrl=${window.location.href}`, '_self');
+        };
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2aWdhdGUtdG8tbWFuYWdlLXByb2ZpbGUucHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9vYXV0aC9zcmMvbGliL3Byb3ZpZGVycy9uYXZpZ2F0ZS10by1tYW5hZ2UtcHJvZmlsZS5wcm92aWRlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxFQUFZLE1BQU0sZUFBZSxDQUFDO0FBQ2pELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUU5RSxNQUFNLENBQUMsTUFBTSwrQkFBK0IsR0FBYTtJQUN2RCxPQUFPLEVBQUUsMEJBQTBCO0lBQ25DLFVBQVUsRUFBRSxHQUFHLEVBQUU7UUFDZixNQUFNLFdBQVcsR0FBRyxNQUFNLENBQUMsa0JBQWtCLENBQUMsQ0FBQztRQUUvQyxPQUFPLEdBQUcsRUFBRTtZQUNWLE1BQU0sR0FBRyxHQUFHLFdBQVcsQ0FBQyxjQUFjLEVBQUUsQ0FBQztZQUN6QyxJQUFJLENBQUMsR0FBRyxDQUFDLFdBQVcsRUFBRTtnQkFDcEIsT0FBTyxDQUFDLElBQUksQ0FBQyxrREFBa0QsQ0FBQyxDQUFDO2dCQUNqRSxPQUFPO2FBQ1I7WUFDRCxNQUFNLENBQUMsSUFBSSxDQUNULEdBQUcsR0FBRyxDQUFDLFdBQVcsQ0FBQyxNQUFNLDZCQUE2QixNQUFNLENBQUMsUUFBUSxDQUFDLElBQUksRUFBRSxFQUM1RSxPQUFPLENBQ1IsQ0FBQztRQUNKLENBQUMsQ0FBQztJQUNKLENBQUM7Q0FDRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaW5qZWN0LCBQcm92aWRlciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBFbnZpcm9ubWVudFNlcnZpY2UsIE5BVklHQVRFX1RPX01BTkFHRV9QUk9GSUxFIH0gZnJvbSAnQGFicC9uZy5jb3JlJztcclxuXHJcbmV4cG9ydCBjb25zdCBOYXZpZ2F0ZVRvTWFuYWdlUHJvZmlsZVByb3ZpZGVyOiBQcm92aWRlciA9IHtcclxuICBwcm92aWRlOiBOQVZJR0FURV9UT19NQU5BR0VfUFJPRklMRSxcclxuICB1c2VGYWN0b3J5OiAoKSA9PiB7XHJcbiAgICBjb25zdCBlbnZpcm9ubWVudCA9IGluamVjdChFbnZpcm9ubWVudFNlcnZpY2UpO1xyXG5cclxuICAgIHJldHVybiAoKSA9PiB7XHJcbiAgICAgIGNvbnN0IGVudiA9IGVudmlyb25tZW50LmdldEVudmlyb25tZW50KCk7XHJcbiAgICAgIGlmICghZW52Lm9BdXRoQ29uZmlnKSB7XHJcbiAgICAgICAgY29uc29sZS53YXJuKCdUaGUgb0F1dGhDb25maWcgZW52IGlzIG1pc3Npbmcgb24gZW52aXJvbm1lbnQudHMnKTtcclxuICAgICAgICByZXR1cm47XHJcbiAgICAgIH1cclxuICAgICAgd2luZG93Lm9wZW4oXHJcbiAgICAgICAgYCR7ZW52Lm9BdXRoQ29uZmlnLmlzc3Vlcn0vQWNjb3VudC9NYW5hZ2U/cmV0dXJuVXJsPSR7d2luZG93LmxvY2F0aW9uLmhyZWZ9YCxcclxuICAgICAgICAnX3NlbGYnLFxyXG4gICAgICApO1xyXG4gICAgfTtcclxuICB9LFxyXG59O1xyXG4iXX0=

package/esm2020/lib/services/index.mjs

@@ -0,0 +1,2 @@
+export * from './oauth.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9vYXV0aC9zcmMvbGliL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL29hdXRoLnNlcnZpY2UnO1xyXG4iXX0=

package/esm2020/lib/services/oauth.service.mjs

@@ -0,0 +1,48 @@
+import { Injectable, Injector } from '@angular/core';
+import { from, lastValueFrom } from 'rxjs';
+import { filter, map, switchMap, take, tap } from 'rxjs/operators';
+import { EnvironmentService } from '@abp/ng.core';
+import { AUTH_FLOW_STRATEGY } from '../tokens/auth-flow-strategy';
+import { OAuthService } from 'angular-oauth2-oidc';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-oauth2-oidc";
+export class AbpOAuthService {
+    constructor(injector, oAuthService) {
+        this.injector = injector;
+        this.oAuthService = oAuthService;
+    }
+    get isInternalAuth() {
+        return this.strategy.isInternalAuth;
+    }
+    async init() {
+        const environmentService = this.injector.get(EnvironmentService);
+        const result$ = environmentService.getEnvironment$().pipe(map(env => env?.oAuthConfig), filter(oAuthConfig => !!oAuthConfig), tap(oAuthConfig => {
+            this.strategy =
+                oAuthConfig.responseType === 'code'
+                    ? AUTH_FLOW_STRATEGY.Code(this.injector)
+                    : AUTH_FLOW_STRATEGY.Password(this.injector);
+        }), switchMap(() => from(this.strategy.init())), take(1));
+        return await lastValueFrom(result$);
+    }
+    logout(queryParams) {
+        return this.strategy.logout(queryParams);
+    }
+    navigateToLogin(queryParams) {
+        this.strategy.navigateToLogin(queryParams);
+    }
+    login(params) {
+        return this.strategy.login(params);
+    }
+    get isAuthenticated() {
+        return this.oAuthService.hasValidAccessToken();
+    }
+}
+AbpOAuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthService, deps: [{ token: i0.Injector }, { token: i1.OAuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+AbpOAuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AbpOAuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.OAuthService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/strategies/auth-code-flow-strategy.mjs

@@ -0,0 +1,35 @@
+import { noop } from '@abp/ng.core';
+import { from, of } from 'rxjs';
+import { AuthFlowStrategy } from './auth-flow-strategy';
+export class AuthCodeFlowStrategy extends AuthFlowStrategy {
+    constructor() {
+        super(...arguments);
+        this.isInternalAuth = false;
+    }
+    async init() {
+        return super
+            .init()
+            .then(() => this.oAuthService.tryLogin().catch(noop))
+            .then(() => this.oAuthService.setupAutomaticSilentRefresh({}, 'access_token'));
+    }
+    navigateToLogin(queryParams) {
+        this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));
+    }
+    checkIfInternalAuth(queryParams) {
+        this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));
+        return false;
+    }
+    logout(queryParams) {
+        return from(this.oAuthService.revokeTokenAndLogout(this.getCultureParams(queryParams)));
+    }
+    login(queryParams) {
+        this.oAuthService.initCodeFlow('', this.getCultureParams(queryParams));
+        return of(null);
+    }
+    getCultureParams(queryParams) {
+        const lang = this.sessionState.getLanguage();
+        const culture = { culture: lang, 'ui-culture': lang };
+        return { ...(lang && culture), ...queryParams };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/strategies/auth-flow-strategy.mjs

@@ -0,0 +1,61 @@
+import { OAuthErrorEvent, OAuthService as OAuthService2, } from 'angular-oauth2-oidc';
+import { of } from 'rxjs';
+import { filter, switchMap, tap } from 'rxjs/operators';
+import { ConfigStateService, EnvironmentService, HttpErrorReporterService, SessionStateService, TENANT_KEY, } from '@abp/ng.core';
+import { clearOAuthStorage } from '../utils/clear-o-auth-storage';
+import { oAuthStorage } from '../utils/oauth-storage';
+export class AuthFlowStrategy {
+    constructor(injector) {
+        this.injector = injector;
+        this.catchError = err => {
+            this.httpErrorReporter.reportError(err);
+            return of(null);
+        };
+        this.httpErrorReporter = injector.get(HttpErrorReporterService);
+        this.environment = injector.get(EnvironmentService);
+        this.configState = injector.get(ConfigStateService);
+        this.oAuthService = injector.get(OAuthService2);
+        this.sessionState = injector.get(SessionStateService);
+        this.oAuthConfig = this.environment.getEnvironment().oAuthConfig;
+        this.tenantKey = injector.get(TENANT_KEY);
+        this.listenToOauthErrors();
+    }
+    async init() {
+        const shouldClear = shouldStorageClear(this.environment.getEnvironment().oAuthConfig.clientId, oAuthStorage);
+        if (shouldClear)
+            clearOAuthStorage(oAuthStorage);
+        this.oAuthService.configure(this.oAuthConfig);
+        this.oAuthService.events
+            .pipe(filter(event => event.type === 'token_refresh_error'))
+            .subscribe(() => this.navigateToLogin());
+        return this.oAuthService
+            .loadDiscoveryDocument()
+            .then(() => {
+            if (this.oAuthService.hasValidAccessToken() || !this.oAuthService.getRefreshToken()) {
+                return Promise.resolve();
+            }
+            return this.refreshToken();
+        })
+            .catch(this.catchError);
+    }
+    refreshToken() {
+        return this.oAuthService.refreshToken().catch(() => clearOAuthStorage());
+    }
+    listenToOauthErrors() {
+        this.oAuthService.events
+            .pipe(filter(event => event instanceof OAuthErrorEvent), tap(() => clearOAuthStorage()), switchMap(() => this.configState.refreshAppState()))
+            .subscribe();
+    }
+}
+function shouldStorageClear(clientId, storage) {
+    const key = 'abpOAuthClientId';
+    if (!storage.getItem(key)) {
+        storage.setItem(key, clientId);
+        return false;
+    }
+    const shouldClear = storage.getItem(key) !== clientId;
+    if (shouldClear)
+        storage.setItem(key, clientId);
+    return shouldClear;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-flow-strategy.js","sourceRoot":"","sources":["../../../../../../packages/oauth/src/lib/strategies/auth-flow-strategy.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,eAAe,EACf,YAAY,IAAI,aAAa,GAE9B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAc,EAAE,EAAE,MAAM,MAAM,CAAC;AACtC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAEL,kBAAkB,EAClB,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,EACnB,UAAU,GACX,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEtD,MAAM,OAAgB,gBAAgB;IAwBpC,YAAsB,QAAkB;QAAlB,aAAQ,GAAR,QAAQ,CAAU;QALhC,eAAU,GAAG,GAAG,CAAC,EAAE;YACzB,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;YACxC,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;QAClB,CAAC,CAAC;QAGA,IAAI,CAAC,iBAAiB,GAAG,QAAQ,CAAC,GAAG,CAAC,wBAAwB,CAAC,CAAC;QAChE,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QACpD,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;QACpD,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QAChD,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAC;QACtD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC,WAAW,CAAC;QACjE,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAE1C,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,IAAI;QACR,MAAM,WAAW,GAAG,kBAAkB,CACpC,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC,WAAW,CAAC,QAAQ,EACtD,YAAY,CACb,CAAC;QACF,IAAI,WAAW;YAAE,iBAAiB,CAAC,YAAY,CAAC,CAAC;QAEjD,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAE9C,IAAI,CAAC,YAAY,CAAC,MAAM;aACrB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,qBAAqB,CAAC,CAAC;aAC3D,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;QAE3C,OAAO,IAAI,CAAC,YAAY;aACrB,qBAAqB,EAAE;aACvB,IAAI,CAAC,GAAG,EAAE;YACT,IAAI,IAAI,CAAC,YAAY,CAAC,mBAAmB,EAAE,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,EAAE;gBACnF,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;aAC1B;YAED,OAAO,IAAI,CAAC,YAAY,EAAE,CAAC;QAC7B,CAAC,CAAC;aACD,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IAC5B,CAAC;IAES,YAAY;QACpB,OAAO,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,iBAAiB,EAAE,CAAC,CAAC;IAC3E,CAAC;IAES,mBAAmB;QAC3B,IAAI,CAAC,YAAY,CAAC,MAAM;aACrB,IAAI,CACH,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,YAAY,eAAe,CAAC,EACjD,GAAG,CAAC,GAAG,EAAE,CAAC,iBAAiB,EAAE,CAAC,EAC9B,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,CAAC,CACpD;aACA,SAAS,EAAE,CAAC;IACjB,CAAC;CACF;AAED,SAAS,kBAAkB,CAAC,QAAgB,EAAE,OAAqB;IACjE,MAAM,GAAG,GAAG,kBAAkB,CAAC;IAC/B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;QACzB,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QAC/B,OAAO,KAAK,CAAC;KACd;IAED,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,QAAQ,CAAC;IACtD,IAAI,WAAW;QAAE,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IAChD,OAAO,WAAW,CAAC;AACrB,CAAC","sourcesContent":["import { Injector } from '@angular/core';\r\nimport { Params } from '@angular/router';\r\nimport {\r\n  AuthConfig,\r\n  OAuthErrorEvent,\r\n  OAuthService as OAuthService2,\r\n  OAuthStorage,\r\n} from 'angular-oauth2-oidc';\r\nimport { Observable, of } from 'rxjs';\r\nimport { filter, switchMap, tap } from 'rxjs/operators';\r\nimport {\r\n  LoginParams,\r\n  ConfigStateService,\r\n  EnvironmentService,\r\n  HttpErrorReporterService,\r\n  SessionStateService,\r\n  TENANT_KEY,\r\n} from '@abp/ng.core';\r\nimport { clearOAuthStorage } from '../utils/clear-o-auth-storage';\r\nimport { oAuthStorage } from '../utils/oauth-storage';\r\n\r\nexport abstract class AuthFlowStrategy {\r\n  abstract readonly isInternalAuth: boolean;\r\n\r\n  protected httpErrorReporter: HttpErrorReporterService;\r\n  protected environment: EnvironmentService;\r\n  protected configState: ConfigStateService;\r\n  protected oAuthService: OAuthService2;\r\n  protected oAuthConfig: AuthConfig;\r\n  protected sessionState: SessionStateService;\r\n  protected tenantKey: string;\r\n\r\n  abstract checkIfInternalAuth(queryParams?: Params): boolean;\r\n\r\n  abstract navigateToLogin(queryParams?: Params): void;\r\n\r\n  abstract logout(queryParams?: Params): Observable<any>;\r\n\r\n  abstract login(params?: LoginParams | Params): Observable<any>;\r\n\r\n  private catchError = err => {\r\n    this.httpErrorReporter.reportError(err);\r\n    return of(null);\r\n  };\r\n\r\n  constructor(protected injector: Injector) {\r\n    this.httpErrorReporter = injector.get(HttpErrorReporterService);\r\n    this.environment = injector.get(EnvironmentService);\r\n    this.configState = injector.get(ConfigStateService);\r\n    this.oAuthService = injector.get(OAuthService2);\r\n    this.sessionState = injector.get(SessionStateService);\r\n    this.oAuthConfig = this.environment.getEnvironment().oAuthConfig;\r\n    this.tenantKey = injector.get(TENANT_KEY);\r\n\r\n    this.listenToOauthErrors();\r\n  }\r\n\r\n  async init(): Promise<any> {\r\n    const shouldClear = shouldStorageClear(\r\n      this.environment.getEnvironment().oAuthConfig.clientId,\r\n      oAuthStorage,\r\n    );\r\n    if (shouldClear) clearOAuthStorage(oAuthStorage);\r\n\r\n    this.oAuthService.configure(this.oAuthConfig);\r\n\r\n    this.oAuthService.events\r\n      .pipe(filter(event => event.type === 'token_refresh_error'))\r\n      .subscribe(() => this.navigateToLogin());\r\n\r\n    return this.oAuthService\r\n      .loadDiscoveryDocument()\r\n      .then(() => {\r\n        if (this.oAuthService.hasValidAccessToken() || !this.oAuthService.getRefreshToken()) {\r\n          return Promise.resolve();\r\n        }\r\n\r\n        return this.refreshToken();\r\n      })\r\n      .catch(this.catchError);\r\n  }\r\n\r\n  protected refreshToken() {\r\n    return this.oAuthService.refreshToken().catch(() => clearOAuthStorage());\r\n  }\r\n\r\n  protected listenToOauthErrors() {\r\n    this.oAuthService.events\r\n      .pipe(\r\n        filter(event => event instanceof OAuthErrorEvent),\r\n        tap(() => clearOAuthStorage()),\r\n        switchMap(() => this.configState.refreshAppState()),\r\n      )\r\n      .subscribe();\r\n  }\r\n}\r\n\r\nfunction shouldStorageClear(clientId: string, storage: OAuthStorage): boolean {\r\n  const key = 'abpOAuthClientId';\r\n  if (!storage.getItem(key)) {\r\n    storage.setItem(key, clientId);\r\n    return false;\r\n  }\r\n\r\n  const shouldClear = storage.getItem(key) !== clientId;\r\n  if (shouldClear) storage.setItem(key, clientId);\r\n  return shouldClear;\r\n}\r\n"]}

package/esm2020/lib/strategies/auth-password-flow-strategy.mjs

@@ -0,0 +1,67 @@
+import { filter, switchMap, tap } from 'rxjs/operators';
+import { OAuthInfoEvent } from 'angular-oauth2-oidc';
+import { Router } from '@angular/router';
+import { from } from 'rxjs';
+import { HttpHeaders } from '@angular/common/http';
+import { AuthFlowStrategy } from './auth-flow-strategy';
+import { pipeToLogin, removeRememberMe } from '../utils/auth-utils';
+import { clearOAuthStorage } from '../utils/clear-o-auth-storage';
+function getCookieValueByName(name) {
+    const match = document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
+    return match ? match[2] : '';
+}
+export class AuthPasswordFlowStrategy extends AuthFlowStrategy {
+    constructor() {
+        super(...arguments);
+        this.isInternalAuth = true;
+        this.cookieKey = 'rememberMe';
+        this.storageKey = 'passwordFlow';
+    }
+    listenToTokenExpiration() {
+        this.oAuthService.events
+            .pipe(filter(event => event instanceof OAuthInfoEvent &&
+            event.type === 'token_expires' &&
+            event.info === 'access_token'))
+            .subscribe(() => {
+            if (this.oAuthService.getRefreshToken()) {
+                this.refreshToken();
+            }
+            else {
+                this.oAuthService.logOut();
+                removeRememberMe();
+                this.configState.refreshAppState().subscribe();
+            }
+        });
+    }
+    async init() {
+        if (!getCookieValueByName(this.cookieKey) && localStorage.getItem(this.storageKey)) {
+            this.oAuthService.logOut();
+        }
+        return super.init().then(() => this.listenToTokenExpiration());
+    }
+    navigateToLogin(queryParams) {
+        const router = this.injector.get(Router);
+        return router.navigate(['/account/login'], { queryParams });
+    }
+    checkIfInternalAuth() {
+        return true;
+    }
+    login(params) {
+        const tenant = this.sessionState.getTenant();
+        return from(this.oAuthService.fetchTokenUsingPasswordFlow(params.username, params.password, new HttpHeaders({ ...(tenant && tenant.id && { [this.tenantKey]: tenant.id }) }))).pipe(pipeToLogin(params, this.injector));
+    }
+    logout(queryParams) {
+        const router = this.injector.get(Router);
+        return from(this.oAuthService.revokeTokenAndLogout(queryParams)).pipe(switchMap(() => this.configState.refreshAppState()), tap(() => {
+            router.navigateByUrl('/');
+            removeRememberMe();
+        }));
+    }
+    refreshToken() {
+        return this.oAuthService.refreshToken().catch(() => {
+            clearOAuthStorage();
+            removeRememberMe();
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/strategies/index.mjs

@@ -0,0 +1,4 @@
+export * from './auth-flow-strategy';
+export * from './auth-code-flow-strategy';
+export * from './auth-password-flow-strategy';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9vYXV0aC9zcmMvbGliL3N0cmF0ZWdpZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsK0JBQStCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2F1dGgtZmxvdy1zdHJhdGVneSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vYXV0aC1jb2RlLWZsb3ctc3RyYXRlZ3knO1xyXG5leHBvcnQgKiBmcm9tICcuL2F1dGgtcGFzc3dvcmQtZmxvdy1zdHJhdGVneSc7XHJcbiJdfQ==

package/esm2020/lib/tokens/auth-flow-strategy.mjs

@@ -0,0 +1,11 @@
+import { AuthCodeFlowStrategy } from '../strategies/auth-code-flow-strategy';
+import { AuthPasswordFlowStrategy } from '../strategies/auth-password-flow-strategy';
+export const AUTH_FLOW_STRATEGY = {
+    Code(injector) {
+        return new AuthCodeFlowStrategy(injector);
+    },
+    Password(injector) {
+        return new AuthPasswordFlowStrategy(injector);
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC1mbG93LXN0cmF0ZWd5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvb2F1dGgvc3JjL2xpYi90b2tlbnMvYXV0aC1mbG93LXN0cmF0ZWd5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBQzdFLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDJDQUEyQyxDQUFDO0FBRXJGLE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHO0lBQ2hDLElBQUksQ0FBQyxRQUFrQjtRQUNyQixPQUFPLElBQUksb0JBQW9CLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDNUMsQ0FBQztJQUNELFFBQVEsQ0FBQyxRQUFrQjtRQUN6QixPQUFPLElBQUksd0JBQXdCLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDaEQsQ0FBQztDQUNGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RvciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBBdXRoQ29kZUZsb3dTdHJhdGVneSB9IGZyb20gJy4uL3N0cmF0ZWdpZXMvYXV0aC1jb2RlLWZsb3ctc3RyYXRlZ3knO1xyXG5pbXBvcnQgeyBBdXRoUGFzc3dvcmRGbG93U3RyYXRlZ3kgfSBmcm9tICcuLi9zdHJhdGVnaWVzL2F1dGgtcGFzc3dvcmQtZmxvdy1zdHJhdGVneSc7XHJcblxyXG5leHBvcnQgY29uc3QgQVVUSF9GTE9XX1NUUkFURUdZID0ge1xyXG4gIENvZGUoaW5qZWN0b3I6IEluamVjdG9yKSB7XHJcbiAgICByZXR1cm4gbmV3IEF1dGhDb2RlRmxvd1N0cmF0ZWd5KGluamVjdG9yKTtcclxuICB9LFxyXG4gIFBhc3N3b3JkKGluamVjdG9yOiBJbmplY3Rvcikge1xyXG4gICAgcmV0dXJuIG5ldyBBdXRoUGFzc3dvcmRGbG93U3RyYXRlZ3koaW5qZWN0b3IpO1xyXG4gIH0sXHJcbn07XHJcbiJdfQ==

package/esm2020/lib/tokens/index.mjs

@@ -0,0 +1,2 @@
+export * from './auth-flow-strategy';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9vYXV0aC9zcmMvbGliL3Rva2Vucy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hdXRoLWZsb3ctc3RyYXRlZ3knO1xyXG4iXX0=

package/esm2020/lib/utils/auth-utils.mjs

@@ -0,0 +1,42 @@
+import { Router } from '@angular/router';
+import { OAuthStorage } from 'angular-oauth2-oidc';
+import { pipe } from 'rxjs';
+import { switchMap, tap } from 'rxjs/operators';
+import { ConfigStateService, } from '@abp/ng.core';
+const cookieKey = 'rememberMe';
+const storageKey = 'passwordFlow';
+export const pipeToLogin = function (params, injector) {
+    const configState = injector.get(ConfigStateService);
+    const router = injector.get(Router);
+    return pipe(switchMap(() => configState.refreshAppState()), tap(() => {
+        setRememberMe(params.rememberMe);
+        if (params.redirectUrl)
+            router.navigate([params.redirectUrl]);
+    }));
+};
+export const setTokenResponseToStorage = function (injector, tokenRes) {
+    const { access_token, refresh_token, scope: grantedScopes, expires_in } = tokenRes;
+    const storage = injector.get(OAuthStorage);
+    storage.setItem('access_token', access_token);
+    storage.setItem('refresh_token', refresh_token);
+    storage.setItem('access_token_stored_at', '' + Date.now());
+    if (grantedScopes) {
+        storage.setItem('granted_scopes', JSON.stringify(grantedScopes.split(' ')));
+    }
+    if (expires_in) {
+        const expiresInMilliSeconds = expires_in * 1000;
+        const now = new Date();
+        const expiresAt = now.getTime() + expiresInMilliSeconds;
+        storage.setItem('expires_at', '' + expiresAt);
+    }
+};
+export function setRememberMe(remember) {
+    removeRememberMe();
+    localStorage.setItem(storageKey, 'true');
+    document.cookie = `${cookieKey}=true; path=/${remember ? ' ;expires=Fri, 31 Dec 9999 23:59:59 GMT' : ''}`;
+}
+export function removeRememberMe() {
+    localStorage.removeItem(storageKey);
+    document.cookie = cookieKey + '= ; path=/; expires = Thu, 01 Jan 1970 00:00:00 GMT';
+}
+//# sourceMappingURL=data:application/json;base64,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