@abp/ng.oauth 7.0.0-rc.6

package/lib/strategies/auth-flow-strategy.d.ts

@@ -0,0 +1,25 @@
+import { Injector } from '@angular/core';
+import { Params } from '@angular/router';
+import { AuthConfig, OAuthService as OAuthService2 } from 'angular-oauth2-oidc';
+import { Observable } from 'rxjs';
+import { LoginParams, ConfigStateService, EnvironmentService, HttpErrorReporterService, SessionStateService } from '@abp/ng.core';
+export declare abstract class AuthFlowStrategy {
+    protected injector: Injector;
+    abstract readonly isInternalAuth: boolean;
+    protected httpErrorReporter: HttpErrorReporterService;
+    protected environment: EnvironmentService;
+    protected configState: ConfigStateService;
+    protected oAuthService: OAuthService2;
+    protected oAuthConfig: AuthConfig;
+    protected sessionState: SessionStateService;
+    protected tenantKey: string;
+    abstract checkIfInternalAuth(queryParams?: Params): boolean;
+    abstract navigateToLogin(queryParams?: Params): void;
+    abstract logout(queryParams?: Params): Observable<any>;
+    abstract login(params?: LoginParams | Params): Observable<any>;
+    private catchError;
+    constructor(injector: Injector);
+    init(): Promise<any>;
+    protected refreshToken(): Promise<void | import("angular-oauth2-oidc").TokenResponse>;
+    protected listenToOauthErrors(): void;
+}

package/lib/strategies/auth-password-flow-strategy.d.ts

@@ -0,0 +1,184 @@
+import { Params } from '@angular/router';
+import { Observable } from 'rxjs';
+import { AuthFlowStrategy } from './auth-flow-strategy';
+import { LoginParams } from '@abp/ng.core';
+export declare class AuthPasswordFlowStrategy extends AuthFlowStrategy {
+    readonly isInternalAuth = true;
+    private cookieKey;
+    private storageKey;
+    private listenToTokenExpiration;
+    init(): Promise<void>;
+    navigateToLogin(queryParams?: Params): Promise<boolean>;
+    checkIfInternalAuth(): boolean;
+    login(params: LoginParams): Observable<any>;
+    logout(queryParams?: Params): Observable<{
+        localization?: {
+            values?: {
+                [x: string]: {
+                    [x: string]: string;
+                };
+            };
+            resources?: {
+                [x: string]: {
+                    texts?: {
+                        [x: string]: string;
+                    };
+                    baseResources?: string[];
+                };
+            };
+            languages?: import("@abp/ng.core").LanguageInfo[];
+            currentCulture?: {
+                displayName?: string;
+                englishName?: string;
+                threeLetterIsoLanguageName?: string;
+                twoLetterIsoLanguageName?: string;
+                isRightToLeft?: boolean;
+                cultureName?: string;
+                name?: string;
+                nativeName?: string;
+                dateTimeFormat?: {
+                    calendarAlgorithmType?: string;
+                    dateTimeFormatLong?: string;
+                    shortDatePattern?: string;
+                    fullDateTimePattern?: string;
+                    dateSeparator?: string;
+                    shortTimePattern?: string;
+                    longTimePattern?: string;
+                };
+            };
+            defaultResourceName?: string;
+            languagesMap?: {
+                [x: string]: import("@abp/ng.core").NameValue<string>[];
+            };
+            languageFilesMap?: {
+                [x: string]: import("@abp/ng.core").NameValue<string>[];
+            };
+        };
+        auth?: {
+            grantedPolicies?: {
+                [x: string]: boolean;
+            };
+        };
+        setting?: {
+            values?: {
+                [x: string]: string;
+            };
+        };
+        currentUser?: {
+            isAuthenticated?: boolean;
+            id?: string;
+            tenantId?: string;
+            impersonatorUserId?: string;
+            impersonatorTenantId?: string;
+            impersonatorUserName?: string;
+            impersonatorTenantName?: string;
+            userName?: string;
+            name?: string;
+            surName?: string;
+            email?: string;
+            emailVerified?: boolean;
+            phoneNumber?: string;
+            phoneNumberVerified?: boolean;
+            roles?: string[];
+        };
+        features?: {
+            values?: {
+                [x: string]: string;
+            };
+        };
+        globalFeatures?: {
+            enabledFeatures?: string[];
+        };
+        multiTenancy?: {
+            isEnabled?: boolean;
+        };
+        currentTenant?: {
+            id?: string;
+            name?: string;
+            isAvailable?: boolean;
+        };
+        timing?: {
+            timeZone?: {
+                iana?: {
+                    timeZoneName?: string;
+                };
+                windows?: {
+                    timeZoneId?: string;
+                };
+            };
+        };
+        clock?: {
+            kind?: string;
+        };
+        objectExtensions?: {
+            modules?: {
+                [x: string]: {
+                    entities?: {
+                        [x: string]: {
+                            properties?: {
+                                [x: string]: {
+                                    type?: string;
+                                    typeSimple?: string;
+                                    displayName?: {
+                                        name?: string;
+                                        resource?: string;
+                                    };
+                                    api?: {
+                                        onGet?: {
+                                            isAvailable?: boolean;
+                                        };
+                                        onCreate?: {
+                                            isAvailable?: boolean;
+                                        };
+                                        onUpdate?: {
+                                            isAvailable?: boolean;
+                                        };
+                                    };
+                                    ui?: {
+                                        onTable?: {
+                                            isVisible?: boolean;
+                                        };
+                                        onCreateForm?: {
+                                            isVisible?: boolean;
+                                        };
+                                        onEditForm?: {
+                                            isVisible?: boolean;
+                                        };
+                                        lookup?: {
+                                            url?: string;
+                                            resultListPropertyName?: string;
+                                            displayPropertyName?: string;
+                                            valuePropertyName?: string;
+                                            filterParamName?: string;
+                                        };
+                                    };
+                                    attributes?: import("@abp/ng.core").ExtensionPropertyAttributeDto[];
+                                    configuration?: {
+                                        [x: string]: object;
+                                    };
+                                    defaultValue?: object;
+                                };
+                            };
+                            configuration?: {
+                                [x: string]: object;
+                            };
+                        };
+                    };
+                    configuration?: {
+                        [x: string]: object;
+                    };
+                };
+            };
+            enums?: {
+                [x: string]: {
+                    fields?: import("@abp/ng.core").ExtensionEnumFieldDto[];
+                    localizationResource?: string;
+                };
+            };
+        };
+        extraProperties?: {
+            [x: string]: object;
+        };
+    }>;
+    protected refreshToken(): Promise<void | import("angular-oauth2-oidc").TokenResponse>;
+}

package/lib/strategies/index.d.ts

@@ -0,0 +1,3 @@
+export * from './auth-flow-strategy';
+export * from './auth-code-flow-strategy';
+export * from './auth-password-flow-strategy';

package/lib/tokens/auth-flow-strategy.d.ts

@@ -0,0 +1,7 @@
+import { Injector } from '@angular/core';
+import { AuthCodeFlowStrategy } from '../strategies/auth-code-flow-strategy';
+import { AuthPasswordFlowStrategy } from '../strategies/auth-password-flow-strategy';
+export declare const AUTH_FLOW_STRATEGY: {
+    Code(injector: Injector): AuthCodeFlowStrategy;
+    Password(injector: Injector): AuthPasswordFlowStrategy;
+};

package/lib/tokens/index.d.ts

@@ -0,0 +1 @@
+export * from './auth-flow-strategy';

package/lib/utils/auth-utils.d.ts

@@ -0,0 +1,6 @@
+import { TokenResponse } from 'angular-oauth2-oidc';
+import { PipeToLoginFn, SetTokenResponseToStorageFn } from '@abp/ng.core';
+export declare const pipeToLogin: PipeToLoginFn;
+export declare const setTokenResponseToStorage: SetTokenResponseToStorageFn<TokenResponse>;
+export declare function setRememberMe(remember: boolean): void;
+export declare function removeRememberMe(): void;

package/lib/utils/check-access-token.d.ts

@@ -0,0 +1,2 @@
+import { CheckAuthenticationStateFn } from '@abp/ng.core';
+export declare const checkAccessToken: CheckAuthenticationStateFn;

package/lib/utils/clear-o-auth-storage.d.ts

@@ -0,0 +1,2 @@
+import { OAuthStorage } from 'angular-oauth2-oidc';
+export declare function clearOAuthStorage(storage?: OAuthStorage): void;

package/lib/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './oauth-storage';
+export * from './storage.factory';
+export * from './auth-utils';
+export * from './clear-o-auth-storage';
+export * from './check-access-token';

package/lib/utils/oauth-storage.d.ts

@@ -0,0 +1 @@
+export declare const oAuthStorage: Storage;

package/lib/utils/storage.factory.d.ts

@@ -0,0 +1,2 @@
+import { OAuthStorage } from 'angular-oauth2-oidc';
+export declare function storageFactory(): OAuthStorage;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@abp/ng.oauth",
+  "version": "7.0.0-rc.6",
+  "homepage": "https://abp.io",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/abpframework/abp.git"
+  },
+  "dependencies": {
+    "@abp/ng.core": "~7.0.0-rc.6",
+    "@abp/utils": "~7.0.0-rc.6",
+    "angular-oauth2-oidc": "^15.0.1",
+    "just-clone": "^6.1.1",
+    "just-compare": "^1.4.0",
+    "tslib": "^2.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "module": "fesm2015/abp-ng.oauth.mjs",
+  "es2020": "fesm2020/abp-ng.oauth.mjs",
+  "esm2020": "esm2020/abp-ng.oauth.mjs",
+  "fesm2020": "fesm2020/abp-ng.oauth.mjs",
+  "fesm2015": "fesm2015/abp-ng.oauth.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "esm2020": "./esm2020/abp-ng.oauth.mjs",
+      "es2020": "./fesm2020/abp-ng.oauth.mjs",
+      "es2015": "./fesm2015/abp-ng.oauth.mjs",
+      "node": "./fesm2015/abp-ng.oauth.mjs",
+      "default": "./fesm2020/abp-ng.oauth.mjs"
+    }
+  },
+  "sideEffects": false
+}

package/public-api.d.ts

@@ -0,0 +1,9 @@
+export * from './lib/oauth.module';
+export * from './lib/utils';
+export * from './lib/tokens';
+export * from './lib/services';
+export * from './lib/strategies';
+export * from './lib/handlers';
+export * from './lib/interceptors';
+export * from './lib/guards';
+export * from './lib/providers';