@igo2/auth 20.1.0-next.9 → 21.0.0-next.1

package/{index.d.ts → types/igo2-auth.d.ts}

@@ -1,13 +1,80 @@
 import * as i0 from '@angular/core';
-import { Provider, EnvironmentProviders } from '@angular/core';
+import { OnDestroy, Provider, InjectionToken, EnvironmentProviders } from '@angular/core';
 import { BaseUser } from '@igo2/core/user';
-import { JwtPayload } from 'jwt-decode';
-import * as rxjs from 'rxjs';
-import { BehaviorSubject, Observable } from 'rxjs';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
 import { StorageOptions, BaseStorage, StorageScope } from '@igo2/core/storage';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject } from 'rxjs';
 import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
-import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { JwtPayload } from 'jwt-decode';
+
+declare class AdminGuard {
+    private authService;
+    private config;
+    private router;
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdminGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdminGuard>;
+}
+
+type AuthStorageOptions = StorageOptions;
+
+declare class AuthStorageService extends BaseStorage<AuthStorageOptions> implements OnDestroy {
+    private authService;
+    private userService;
+    private tokenService;
+    private preferencesChanged$;
+    private destroy$;
+    private pendingPreferences;
+    private serverPreferences;
+    constructor();
+    ngOnDestroy(): void;
+    set(key: string, value: string | object | boolean | number, scope?: StorageScope): void;
+    remove(key: string, scope?: StorageScope): void;
+    clear(scope?: StorageScope): void;
+    private syncPreferences;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthStorageService>;
+}
+
+declare class AuthGuard {
+    private authService;
+    private config;
+    private router;
+    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthGuard, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthGuard>;
+}
 
+declare class AuthInterceptor implements HttpInterceptor {
+    private config;
+    private tokenService;
+    private http;
+    private authOptions;
+    private refreshInProgress;
+    private trustHosts;
+    private hostsWithCredentials;
+    private hostsWithAuthByKey;
+    constructor();
+    intercept(originalReq: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
+    interceptXhr(xhr: any, url: string): boolean;
+    alterUrlWithKeyAuth(url: string): string;
+    private handleHostsWithCredentials;
+    private handleHostsAuthByKey;
+    refreshToken(): rxjs.Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthInterceptor>;
+}
+
+interface AuthFacebookOptions {
+    enabled?: boolean;
+    appId: string;
+}
+interface AuthGoogleOptions {
+    enabled?: boolean;
+    apiKey: string;
+    clientId: string;
+}
 interface User extends BaseUser {
     source?: string;
     sourceId?: string;
@@ -20,10 +87,13 @@ interface IInfosUser {
     tokenId: string;
 }
 interface AuthOptions {
-    url?: string;
+    url: string;
+    /** User api url is the igo user versus the url is the authentification API */
+    user?: IAuthUserIgoOptions;
     tokenKey?: string;
     allowAnonymous?: boolean;
     loginRoute?: string;
+    logoutRedirectRoute?: string;
     logoutRoute?: string;
     homeRoute?: string;
     trustHosts?: string[];
@@ -32,6 +102,15 @@ interface AuthOptions {
     hostsByKey?: AuthByKeyOptions[];
     intern?: AuthInternOptions;
 }
+interface IAuthUserIgoOptions {
+    apiUrl: string;
+    withSync?: boolean;
+}
+interface AuthByKeyOptions {
+    domainRegFilters?: string;
+    keyProperty?: string;
+    keyValue?: string;
+}
 interface AuthByKeyOptions {
     domainRegFilters?: string;
     keyProperty?: string;
@@ -41,6 +120,13 @@ interface WithCredentialsOptions {
     withCredentials?: boolean;
     domainRegFilters?: string;
 }
+interface WithCredentialsOptions {
+    withCredentials?: boolean;
+    domainRegFilters?: string;
+}
+interface AuthInternOptions {
+    enabled?: boolean;
+}
 interface AuthInternOptions {
     enabled?: boolean;
 }
@@ -49,30 +135,32 @@ interface AuthFeature<KindT extends AuthFeatureKind> {
     providers: Provider[];
 }
 declare enum AuthFeatureKind {
-    Microsoft = 0
+    Microsoft = 0,
+    User = 1
 }
 
 interface IgoJwtPayload extends JwtPayload {
     user: User;
 }
 
-declare class TokenService {
-    private injector;
-    private options?;
-    private tokenKey;
-    constructor();
-    set(token: string): void;
-    remove(): void;
-    get(): string;
-    decode(): IgoJwtPayload | null;
-    isExpired(): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TokenService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<TokenService>;
+interface IUser {
+    id: number;
+    defaultContextId: number | null;
+    preference: IUserPreference | null;
+    externalId: number;
+    guides?: string[];
+    createdAt: Date;
+    updatedAt: Date;
 }
+type IUserPreference = Record<string, unknown>;
 
-declare class AuthService {
+interface IToken {
+    token: string;
+}
+declare class AuthService<T extends AuthOptions = AuthOptions> {
     private http;
     private tokenService;
+    private userService;
     private config;
     private languageService;
     private messageService;
@@ -81,16 +169,18 @@ declare class AuthService {
     logged$: BehaviorSubject<boolean>;
     redirectUrl: string;
     languageForce: boolean;
+    authOptions: T;
     private anonymous;
-    private authOptions;
+    isLogging: i0.WritableSignal<boolean>;
     get hasAuthService(): boolean;
     get user(): User | null;
     constructor();
-    login(username: string, password: string): Observable<void>;
-    loginWithToken(token: string, type: string, infosUser?: IInfosUser): Observable<void>;
+    login(username: string, password: string): Observable<IUser>;
+    loginWithToken(token: string, type: string, infosUser?: IInfosUser, applicationId?: string): Observable<IUser>;
     loginAnonymous(): Observable<boolean>;
-    refresh(): Observable<void>;
-    logout(): Observable<boolean>;
+    refresh(): Observable<IToken>;
+    logout(): void;
+    private logoutInternal;
     isAuthenticated(): boolean;
     getToken(): string;
     decodeToken(): IgoJwtPayload | null;
@@ -100,50 +190,16 @@ declare class AuthService {
         profils: string[];
     }>;
     updateUser(user: User): Observable<User>;
+    translateError(prefix: string, error: any): Observable<string>;
     private encodePassword;
     get logged(): boolean;
     get isAnonymous(): boolean;
     get authenticated(): boolean;
     get isAdmin(): boolean;
-    private loginCall;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService>;
-}
-
-interface AuthStorageOptions extends StorageOptions {
-    url: string;
-}
-
-declare class AuthStorageService extends BaseStorage<AuthStorageOptions> {
-    private http;
-    private authService;
-    private tokenService;
-    constructor();
-    set(key: string, value: string | object | boolean | number, scope?: StorageScope): void;
-    remove(key: string, scope?: StorageScope): void;
-    clear(scope?: StorageScope): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AuthStorageService, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AuthStorageService>;
-}
-
-declare class AuthInterceptor implements HttpInterceptor {
-    private config;
-    private tokenService;
-    private http;
-    private authOptions;
-    private refreshInProgress;
-    private trustHosts;
-    private hostsWithCredentials;
-    private hostsWithAuthByKey;
-    constructor();
-    intercept(originalReq: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
-    interceptXhr(xhr: any, url: string): boolean;
-    alterUrlWithKeyAuth(url: string): string;
-    private handleHostsWithCredentials;
-    private handleHostsAuthByKey;
-    refreshToken(): rxjs.Subscription;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AuthInterceptor, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AuthInterceptor>;
+    protected loginCall(body: any, headers: any): Observable<IUser>;
+    private initializeAuthentication;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AuthService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AuthService<any>>;
 }
 
 declare class LoggedGuard {
@@ -155,24 +211,6 @@ declare class LoggedGuard {
     static ɵprov: i0.ɵɵInjectableDeclaration<LoggedGuard>;
 }
 
-declare class AuthGuard {
-    private authService;
-    private config;
-    private router;
-    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AuthGuard, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AuthGuard>;
-}
-
-declare class AdminGuard {
-    private authService;
-    private config;
-    private router;
-    canActivate(route: ActivatedRouteSnapshot, state: RouterStateSnapshot): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<AdminGuard, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<AdminGuard>;
-}
-
 declare class ProfilsGuard {
     private authService;
     private config;
@@ -182,7 +220,40 @@ declare class ProfilsGuard {
     static ɵprov: i0.ɵɵInjectableDeclaration<ProfilsGuard>;
 }
 
+declare class TokenService {
+    private injector;
+    private options?;
+    private tokenKey;
+    constructor();
+    set(token: string): void;
+    remove(): void;
+    get(): string;
+    decode(): IgoJwtPayload | null;
+    isExpired(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TokenService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TokenService>;
+}
+
+declare const USER_AUTH_OPTIONS: InjectionToken<IAuthUserIgoOptions>;
+declare class UserService {
+    private http;
+    private options;
+    private baseUrl;
+    private _user$;
+    user$: Observable<IUser>;
+    constructor();
+    getUser(): Observable<IUser>;
+    sync(): Observable<IUser>;
+    updatePreference(preference: IUserPreference): Observable<{
+        id: number;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserService>;
+}
+
+declare function withUserIgo(): AuthFeature<AuthFeatureKind.User>;
+
 declare function provideAuthentification(...features: AuthFeature<AuthFeatureKind>[]): EnvironmentProviders;
 
-export { AdminGuard, AuthFeatureKind, AuthGuard, AuthInterceptor, AuthService, AuthStorageService, LoggedGuard, ProfilsGuard, TokenService, provideAuthentification };
-export type { AuthByKeyOptions, AuthFeature, AuthInternOptions, AuthOptions, AuthStorageOptions, IInfosUser, IgoJwtPayload, User, WithCredentialsOptions };
+export { AdminGuard, AuthFeatureKind, AuthGuard, AuthInterceptor, AuthService, AuthStorageService, LoggedGuard, ProfilsGuard, TokenService, USER_AUTH_OPTIONS, UserService, provideAuthentification, withUserIgo };
+export type { AuthByKeyOptions, AuthFacebookOptions, AuthFeature, AuthGoogleOptions, AuthInternOptions, AuthOptions, AuthStorageOptions, IAuthUserIgoOptions, IInfosUser, IUser, IUserPreference, IgoJwtPayload, User, WithCredentialsOptions };