@abp/ng.oauth 7.2.2 → 7.3.0-rc.2

package/README.md

@@ -1,7 +1,130 @@
-# oauth
+## ℹ️ Description
 
-This library was generated with [Nx](https://nx.dev).
+ABP Framework is a complete open-source infrastructure to create modern web applications by following the best practices and conventions of software development. This package is a part of the [ABP Framework](https://abp.io) and contains client-side files. 
+For more information, check out the below links: 
 
-## Running unit tests
+🔗Official Website: https://abp.io
 
-Run `nx test oauth` to execute the unit tests.
+🔗Commercial Website: https://commercial.abp.io
+
+🔗Commercial Demo: https://commercial.abp.io/demo
+
+🔗GitHub Repository: https://github.com/abpframework/abp
+
+🔗Official Theme: https://www.LeptonTheme.com
+
+🔗Documentation: https://docs.abp.io
+
+🔗Community: https://community.abp.io
+
+🔗Blog: https://blog.abp.io
+
+🔗Books: https://abp.io/books
+
+🔗Twitter: https://twitter.com/abpframework
+
+🔗Discord: https://community.abp.io/discord
+
+🔗Stackoverflow: https://stackoverflow.com/questions/tagged/abp
+
+🔗YouTube: https://www.youtube.com/@Volosoft
+
+
+## 🤔 Why ABP Platform?
+
+Why should you use the ABP.IO Platform instead of creating a new solution from scratch?
+
+You can find the answer here 👉🏻 [Why ABP Platform?](https://docs.abp.io/en/commercial/latest/why-abp-io-platform)
+
+
+## 🚀 Key Features of the ABP Framework
+
+🟡 Modularity
+
+🟡 Multi-Tenancy
+
+🟡 Bootstrap Tag Helpers
+
+🟡 Dynamic Forms
+
+🟡 Authentication
+
+🟡 Authorization
+
+🟡 Distributed Event Bus
+
+🟡 BLOB Storing
+
+🟡 Text Templating
+
+🟡 Tooling: ABP CLI
+
+🟡 Cross-Cutting Concerns
+
+🟡 Bundling & Minification
+
+🟡 Virtual File System
+
+🟡 Theming
+
+🟡 Background Jobs
+
+🟡 DDD Infrastructure
+
+🟡 Auto REST APIs
+
+🟡 Dynamic Client Proxies
+
+🟡 Multiple Database Providers
+
+🟡 Data filtering
+
+🟡 Test Infrastructure
+
+🟡 Audit Logging
+
+🟡 Object to Object Mapping
+
+🟡 Email & SMS Abstractions
+
+🟡 Localization
+
+🟡 Setting Management
+
+🟡 Extension Methods
+
+🟡 Aspect Oriented Programming
+
+🟡 Dependency Injection
+
+
+## 🧐 How It Works?
+
+The following page explains how you use the ABP.IO Platform as a .NET developer 👉 [How it works?](https://commercial.abp.io/how-it-works)
+
+
+### 📘 Supported Database Providers
+
+🔵 Entity Framework Core
+
+🔵 MongoDB
+
+🔵 Dapper
+
+
+### 🎴 Supported UI Frameworks
+
+🔵 Angular
+
+🔵 Razor Pages
+
+🔵 Blazor Web Assembly
+
+🔵 Blazor Server
+
+🔵 MAUI with Blazor Hybrid
+
+
+## 📫 Bug & Support
+
+Support for open-source ABP Framework client-side packages is available at [GitHub Issues](https://github.com/abpframework/abp/issues), and the commercial support is available at [support.abp.io](https://support.abp.io).

package/{esm2020 → esm2022}/abp-ng.oauth.mjs

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

package/{esm2020 → esm2022}/lib/guards/index.mjs

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

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

@@ -0,0 +1,32 @@
+import { Injectable, inject } from '@angular/core';
+import { delay, of, tap } from 'rxjs';
+import { OAuthService } from 'angular-oauth2-oidc';
+import { AuthService, HttpErrorReporterService } from '@abp/ng.core';
+import * as i0 from "@angular/core";
+class AbpOAuthGuard {
+    constructor() {
+        this.oAuthService = inject(OAuthService);
+        this.authService = inject(AuthService);
+        this.httpErrorReporter = inject(HttpErrorReporterService);
+    }
+    canActivate(route, state) {
+        const hasValidAccessToken = this.oAuthService.hasValidAccessToken();
+        if (hasValidAccessToken) {
+            return true;
+        }
+        return of(false).pipe(tap(() => this.httpErrorReporter.reportError({ status: 401 })), delay(1500), tap(() => {
+            const params = { returnUrl: state.url };
+            this.authService.navigateToLogin(params);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthGuard, providedIn: 'root' }); }
+}
+export { AbpOAuthGuard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/handlers/index.mjs

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

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

@@ -0,0 +1,37 @@
+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";
+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);
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: OAuthConfigurationHandler, deps: [{ token: i1.OAuthService }, { token: i2.EnvironmentService }, { token: CORE_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: OAuthConfigurationHandler, providedIn: 'root' }); }
+}
+export { OAuthConfigurationHandler };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", 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/esm2022/lib/interceptors/api.interceptor.mjs

@@ -0,0 +1,57 @@
+import { Inject, Injectable } from '@angular/core';
+import { OAuthService } from 'angular-oauth2-oidc';
+import { finalize } from 'rxjs/operators';
+import { HttpWaitService, IS_EXTERNAL_REQUEST, SessionStateService, 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";
+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);
+        const isExternalRequest = request.context?.get(IS_EXTERNAL_REQUEST);
+        const newRequest = isExternalRequest
+            ? request
+            : request.clone({
+                setHeaders: this.getAdditionalHeaders(request.headers),
+            });
+        return next
+            .handle(newRequest)
+            .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;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: OAuthApiInterceptor, deps: [{ token: i1.OAuthService }, { token: i2.SessionStateService }, { token: i2.HttpWaitService }, { token: TENANT_KEY }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: OAuthApiInterceptor, providedIn: 'root' }); }
+}
+export { OAuthApiInterceptor };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", 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 → esm2022}/lib/interceptors/index.mjs

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

package/esm2022/lib/oauth.module.mjs

@@ -0,0 +1,66 @@
+import { APP_INITIALIZER, NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { OAuthModule, OAuthStorage } from 'angular-oauth2-oidc';
+import { AbpLocalStorageService, ApiInterceptor, AuthGuard, AuthService, CHECK_AUTHENTICATION_STATE_FN_KEY, noop, PIPE_TO_LOGIN_FN_KEY, } from '@abp/ng.core';
+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 } from './utils';
+import * as i0 from "@angular/core";
+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: 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, useClass: AbpLocalStorageService },
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthModule, imports: [CommonModule, OAuthModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthModule, imports: [CommonModule, OAuthModule] }); }
+}
+export { AbpOAuthModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, OAuthModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/providers/index.mjs

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

package/{esm2020 → esm2022}/lib/providers/navigate-to-manage-profile.provider.mjs

@@ -1,19 +1,19 @@
-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;
-            }
-            const { issuer } = env.oAuthConfig;
-            const path = issuer.endsWith('/') ? issuer : `${issuer}/`;
-            window.open(`${path}Account/Manage?returnUrl=${window.location.href}`, '_self');
-        };
-    },
-};
+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;
+            }
+            const { issuer } = env.oAuthConfig;
+            const path = issuer.endsWith('/') ? issuer : `${issuer}/`;
+            window.open(`${path}Account/Manage?returnUrl=${window.location.href}`, '_self');
+        };
+    },
+};
 //# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/services/index.mjs

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

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

@@ -0,0 +1,62 @@
+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";
+class AbpOAuthService {
+    get isInternalAuth() {
+        return this.strategy.isInternalAuth;
+    }
+    constructor(injector) {
+        this.injector = injector;
+        this.oAuthService = this.injector.get(OAuthService);
+    }
+    async init() {
+        const environmentService = this.injector.get(EnvironmentService);
+        const result$ = environmentService.getEnvironment$().pipe(map(env => env?.oAuthConfig), filter(Boolean), 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();
+    }
+    loginUsingGrant(grantType, parameters, headers) {
+        const { clientId: client_id, dummyClientSecret: client_secret } = this.oAuthService;
+        const access_token = this.oAuthService.getAccessToken();
+        const p = {
+            access_token,
+            grant_type: grantType,
+            client_id,
+            ...parameters,
+        };
+        if (client_secret) {
+            p['client_secret'] = client_secret;
+        }
+        return this.oAuthService.fetchTokenUsingGrant(grantType, p, headers);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthService, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthService, providedIn: 'root' }); }
+}
+export { AbpOAuthService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: AbpOAuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,40 @@
+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) {
+        let additionalState = '';
+        if (queryParams?.returnUrl) {
+            additionalState = queryParams.returnUrl;
+        }
+        const cultureParams = this.getCultureParams(queryParams);
+        this.oAuthService.initCodeFlow(additionalState, cultureParams);
+    }
+    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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