@unipin/angular-applet 18.9.7 → 21.0.1

package/fesm2022/unipin-angular-applet-auth.mjs

@@ -0,0 +1,707 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, signal, inject, Input, Directive, ChangeDetectionStrategy, Component, Inject } from '@angular/core';
+import * as i1$1 from '@angular/router';
+import { Router } from '@angular/router';
+import { tap, catchError, throwError, switchMap } from 'rxjs';
+import * as i1 from '@unipin/angular-gql';
+import { Location } from '@angular/common';
+import { NgIcon, provideIcons } from '@ng-icons/core';
+import { matLockRound } from '@ng-icons/material-icons/round';
+import { UpSpinnerComponent } from '@unipin/angular-applet/spinner';
+
+const LOADING_CONFIG = new InjectionToken('LOADING_CONFIG');
+function provideLoadingConfig(config) {
+    return {
+        provide: LOADING_CONFIG,
+        useValue: config
+    };
+}
+
+class ProfileService {
+    constructor(gql) {
+        this.gql = gql;
+    }
+    transformSubjetToUser(subject) {
+        const user = {
+            ...subject,
+            email: '',
+            photo: '/assets/imgs/profile.svg'
+        };
+        subject.appLoginExt?.forEach(({ paramCode, file: { publicUrl } }) => {
+            if (paramCode === 'USER_PROFILE_PHOTO') {
+                user.photo = publicUrl;
+            }
+        });
+        subject.appLoginPrincipal?.forEach(({ principalId, principalType }) => {
+            if (principalType === 'EMAIL_USERNAME') {
+                user.email = principalId;
+            }
+        });
+        return user;
+    }
+    /**
+     * A method to get the user profile information.
+     * @param {string} extraAttr - Contain extra attribute to get the user profile information.
+     * @param {CacheStrategy | undefined} cacheStrategy - Specifies how Apollo Client should handle data retrieval, determining whether it should make a network request to fetch fresh data from the server or use data from the local cache.
+     *
+     * @returns {Observable<QueryResult<{ authMsMyProfile: Maybe<AppLoginSubject> }>>} Contain user profile information.
+     */
+    getMyProfile(extraAttr = '', cacheStrategy) {
+        return this.gql.query({
+            cacheStrategy,
+            operationName: 'getMyProfile',
+            query: `
+        query getMyProfile {
+          authMsMyProfile {
+            guid
+            name
+            status
+            gender
+            birthday
+            category
+            totpSecretGuid
+            appLoginPrincipal {
+              guid
+              principalId
+              principalType
+            }
+            appLoginExt {
+              guid
+              paramCode
+              paramType
+              file {
+                publicUrl
+              }
+            }
+            company {
+              code
+              guid
+              isInternal
+              name
+              status
+            }
+            merchants {
+              guid
+              name
+              status
+            }
+            roles {
+              guid
+              code
+              name
+              status
+              isInternal
+            }
+            departments {
+              isLead
+              department {
+                hierarchyCode
+                hierarchyPath
+                name
+                guid
+                status
+              }
+            }
+            ${extraAttr}
+          }
+        }
+      `,
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: ProfileService, deps: [{ token: i1.GqlParser }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: ProfileService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: ProfileService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.GqlParser }] });
+
+class AuthService {
+    /**
+     * Both `authToken` and `refreshToken` are public static variable to store the auth token and refresh token obtained form the login API.
+     * They will be set as header param inside API calls.
+     * @type {string}
+     *
+     * @default ''
+     */
+    static { this.authToken = ''; }
+    static { this.refreshToken = ''; }
+    constructor(gql, profileService) {
+        this.gql = gql;
+        this.profileService = profileService;
+        /**
+         * A public variable to store the logined user information.
+         * @type {User} An interface contain user information.
+         * @default {} as User
+         */
+        this.user = signal({}, ...(ngDevMode ? [{ debugName: "user" }] : []));
+    }
+    static logout() {
+        AuthService.authToken = '';
+        AuthService.refreshToken = '';
+        localStorage.removeItem('authToken');
+        localStorage.removeItem('refreshToken');
+    }
+    logout() {
+        this.user.set({});
+        AuthService.logout();
+    }
+    /**
+     * This method is used by the `refreshTokenInterceptor`, to get the new token shortly before the auth token is expired.
+     * @param {MutationAuthMsRefreshAccessTokenArgs} variables - Contain `refreshToken` attribute which is the current refresh token.
+     * @returns {Observable<MutationResult<{ authMsRefreshAccessToken: Token }>>} Contain new `authToken` and `refreshToken`.
+     */
+    refreshToken(variables) {
+        return this.gql.mutate({
+            variables,
+            operationName: 'RefreshToken',
+            headers: {
+                'operation-type': 'Mutation',
+                'operation-name': 'RefreshToken'
+            },
+            mutation: `
+        mutation RefreshToken($refreshToken: String!) {
+          authMsRefreshAccessToken(refreshToken: $refreshToken) {
+            accessToken
+            refreshToken
+          }
+        }
+      `
+        });
+    }
+    /**
+     * A method to authenticate the user to get the session for applet or platform.
+     * When successful it will set the user information to the `user` variable, `authToken` and `refreshToken`.
+     * It will set the `authToken`, `refreshToken`, `userGuid` and `roles` to the localStorage also for API calls.
+     *
+     * @param {{ email: string, password: string, sourcePlatform: string }} input - Contain `email` which is registered user email, `password` which is registered user password and `sourcePlatform` it's value can be `ADMIN` to get the applet session or `CP_COMMERCE` to get the platform session.
+     *
+     * @returns {Observable<MutationResult<{ authMsLogin: LoginResponse }>>} Contain logined user information.
+     */
+    login(input) {
+        return this.gql.mutate({
+            operationName: 'Login',
+            variables: {
+                input
+            },
+            mutation: `
+        mutation Login($input: LoginRq!) {
+          authMsLogin(input: $input) {
+            accessToken
+            refreshToken
+            suggestedAction
+            user {
+              birthday
+              category
+              email
+              gender
+              guid
+              mobileNumber
+              name
+              status
+              departments {
+                department {
+                  hierarchyCode
+                  hierarchyPath
+                  name
+                  guid
+                  status
+                }
+                isLead
+              }
+            }
+            roles {
+              guid
+              code
+              name
+              isInternal
+              status
+            }
+          }
+        }
+      `
+        }).pipe(tap(({ data }) => {
+            if (!data?.authMsLogin) {
+                return;
+            }
+            const { accessToken, user, refreshToken, suggestedAction, roles } = data.authMsLogin;
+            this.user.set({
+                ...user,
+                roles: roles,
+                photo: '/assets/imgs/profile.svg'
+            });
+            AuthService.authToken = accessToken ?? '';
+            AuthService.refreshToken = refreshToken ?? '';
+            if (suggestedAction !== 'CHANGE_PASSWORD') {
+                localStorage.setItem('authToken', AuthService.authToken);
+            }
+            localStorage.setItem('roles', JSON.stringify(roles));
+            localStorage.setItem('userGuid', this.user().guid ?? '');
+            localStorage.setItem('refreshToken', AuthService.refreshToken);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: AuthService, deps: [{ token: i1.GqlParser }, { token: ProfileService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: AuthService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.GqlParser }, { type: ProfileService }] });
+
+/**
+ * The `AuthResolver` service provides methods for handling authentication-related tasks,
+ * such as checking user login status, retrieving authentication tokens, and managing token expiration.
+ */
+class AuthResolver {
+    /**
+     * Checks if the user is logged in by verifying the presence of an authentication token.
+     * @returns {boolean} - True if the user is logged in; otherwise, false.
+     */
+    isUserLoggedIn() {
+        return AuthService.authToken !== '';
+    }
+    /**
+     * Retrieves the authentication token, resolving it if needed.
+     * @returns {string | null} - The authentication token if the user is logged in; otherwise, null.
+     */
+    getAuthToken() {
+        this.resolveUserAuthToken();
+        if (this.isUserLoggedIn()) {
+            return AuthService.authToken;
+        }
+        return null;
+    }
+    /**
+     * Resolves the user's authentication token by checking expiration and whether the user still logged in or not.
+     */
+    resolveUserAuthToken() {
+        if (!this.isUserLoggedIn() ||
+            !this.isTokenExpired(AuthService.authToken)) {
+            return;
+        }
+        AuthService.logout();
+    }
+    /**
+     * Checks if a given token is expired or not yet.
+     * @param {string | null} token - The token to be checked for expiration.
+     * @returns {boolean} - True if the token is expired; otherwise, false.
+     */
+    isTokenExpired(token) {
+        if (!token || token === '') {
+            return true;
+        }
+        const date = this.getTokenExpirationDate(token);
+        if (date === null) {
+            return false;
+        }
+        return !(date.valueOf() > new Date().valueOf() + 0 * 1000);
+    }
+    /**
+     * Retrieves the expiration date of a token.
+     * @param {string | null} token - The token for which to retrieve the expiration date.
+     * @returns {Date | null} - The expiration date of the token if available; otherwise, null.
+     */
+    getTokenExpirationDate(token) {
+        const decoded = this.decodeToken(token);
+        if (!decoded || !decoded.hasOwnProperty('exp')) {
+            return null;
+        }
+        const date = new Date(0);
+        date.setUTCSeconds(decoded.exp);
+        return date;
+    }
+    /**
+     * Decodes a JWT token to extract payload information.
+     * @param {string | null} token - The JWT token to be decoded.
+     * @returns {string | null} - The decoded payload as a string if successful; otherwise, null.
+     */
+    decodeToken(token) {
+        if (!token || token === '') {
+            return null;
+        }
+        const parts = token.split('.');
+        if (parts.length !== 3) {
+            throw new Error(`The inspected token doesn't appear to be a JWT. Check to make sure it has three parts and see https://jwt.io for more.`);
+        }
+        const decoded = this.urlBase64Decode(parts[1]);
+        if (!decoded) {
+            throw new Error('Cannot decode the token.');
+        }
+        return JSON.parse(decoded);
+    }
+    /**
+     * Decodes a base64url-encoded string.
+     * @param {string} str - The base64url-encoded string to be decoded.
+     * @returns {string} - The decoded string.
+     */
+    urlBase64Decode(str) {
+        let output = str.replace(/-/g, '+').replace(/_/g, '/');
+        switch (output.length % 4) {
+            case 0:
+                break;
+            case 2:
+                output += '==';
+                break;
+            case 3:
+                output += '=';
+                break;
+            default:
+                throw new Error('Illegal base64url string!');
+        }
+        return this.b64DecodeUnicode(output);
+    }
+    /**
+     * Decodes a Unicode string from a base64-encoded string.
+     * @param {string} str - The base64-encoded string to be decoded.
+     * @returns {string} - The decoded Unicode string.
+     */
+    b64DecodeUnicode(str) {
+        return decodeURIComponent(Array.prototype.map.call(this.b64decode(str), (c) => '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)).join(''));
+    }
+    /**
+     * Decodes a base64-encoded string.
+     * @param {string} str - The base64-encoded string to be decoded.
+     * @returns {string} - The decoded string.
+     */
+    b64decode(str) {
+        const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+        let output = '';
+        str = String(str).replace(/=+$/, '');
+        if (str.length % 4 === 1) {
+            throw new Error(`'atob' failed: The string to be decoded is not correctly encoded.`);
+        }
+        for (let bc = 0, bs, buffer, idx = 0; (buffer = str.charAt(idx++)); ~buffer && ((bs = bc % 4 ? bs * 64 + buffer : buffer), bc++ % 4) ? (output += String.fromCharCode(255 & (bs >> ((-2 * bc) & 6)))) : 0)
+            buffer = chars.indexOf(buffer);
+        return output;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: AuthResolver, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: AuthResolver, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: AuthResolver, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+const authGuard = () => {
+    const router = inject(Router);
+    const resolver = inject(AuthResolver);
+    if (!resolver.isUserLoggedIn()) {
+        router.navigateByUrl('/auth/login');
+        return false;
+    }
+    return true;
+};
+
+class PermissionService {
+    constructor(gql) {
+        this.gql = gql;
+        this.permissions = signal(new Map(), ...(ngDevMode ? [{ debugName: "permissions" }] : []));
+        /**
+         * A boolean value that tells the permission service is initiated (permissions list is retrieved from Backend) or not.
+         * @default false
+         */
+        this.isInitiated = false;
+    }
+    /**
+     * A method that checking if the user has the permission or not based on the params value.
+     * @param {string} permission - Permission code that wanted to be checked
+     *
+     * @returns {boolean} Contain boolean value that tells the user has the permission or not.
+     */
+    has(permission) {
+        const permissions = this.permissions();
+        const [scope, module, type] = permission.split('.');
+        return (permissions.has(`${scope}.${module}.ADMIN`) ||
+            permissions.has(`${scope}.${module}.${type}`));
+    }
+    /**
+     * A method that set the permissions and permission modules.
+     * @param {string[]} permCodes - Contain list of permission codes.
+     */
+    setPermission(permCodes) {
+        this.permissions.update((map) => {
+            const newMap = new Map(map);
+            for (const code of permCodes) {
+                newMap.set(code, true);
+            }
+            return newMap;
+        });
+    }
+    /**
+     * A method that get the query value with authMsPermission as the object.
+     * @param {PermissionFilter} filter - Contain filter as a conditions for the query.
+     * @returns {Observable<ApolloQueryResult<{ authMsPermission: { data: AppPermDfn[] }}>>} Contain query value.
+     */
+    getPermissions(filter, cacheStrategy) {
+        return this.gql.query({
+            cacheStrategy,
+            operationName: 'QueryPermission',
+            variables: {
+                filter
+            },
+            query: `
+        query QueryPermission($filter: PermissionFilter!) {
+          authMsPermission(filter: $filter) {
+            data {
+              permCode
+            }
+          }
+        }
+      `
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: PermissionService, deps: [{ token: i1.GqlParser }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: PermissionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: PermissionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.GqlParser }] });
+
+const permissionGuard = (route) => {
+    const router = inject(Router);
+    const location = inject(Location);
+    const permissionService = inject(PermissionService);
+    const permissions = route.data['permissions'];
+    const aggregator = route.data['aggregator'] ?? 'OR';
+    if (!permissions ||
+        !permissions.length) {
+        console.error('Invalid config: permissions is a required parameter in route data for PermissionGuard');
+        return false;
+    }
+    if (!permissionService.isInitiated) {
+        router.navigate(['loading'], {
+            queryParams: {
+                url: `${location.path() + window.location.hash}`
+            }
+        });
+        return false;
+    }
+    if (aggregator === 'OR') {
+        for (let i = 0; i < permissions.length; i++) {
+            if (permissionService.has(permissions[i])) {
+                return true;
+            }
+        }
+    }
+    let hasPermission = true;
+    for (let i = 0; i < permissions.length; i++) {
+        if (!permissionService.has(permissions[i])) {
+            hasPermission = false;
+            break;
+        }
+    }
+    if (hasPermission) {
+        return true;
+    }
+    router.navigateByUrl('/401');
+    return false;
+};
+
+const authorizationInterceptor = (request, next) => {
+    return next(request.clone({
+        headers: request.headers,
+        setHeaders: {
+            authorization: AuthService.authToken,
+        }
+    }));
+};
+
+const refreshTokenInterceptor = (request, next) => {
+    const router = inject(Router);
+    const authService = inject(AuthService);
+    return next(request).pipe(catchError(({ error: { errors } }) => {
+        if (errors[0].extensions.code !== 'USER_INVALID_TOKEN') {
+            return throwError(() => errors[0]);
+        }
+        return authService.refreshToken({ refreshToken: AuthService.refreshToken }).pipe(switchMap(({ data }) => {
+            const { accessToken, refreshToken } = data.authMsRefreshAccessToken;
+            AuthService.authToken = accessToken;
+            AuthService.refreshToken = refreshToken;
+            localStorage.setItem('authToken', accessToken);
+            localStorage.setItem('refreshToken', refreshToken);
+            return next(request.clone({
+                setHeaders: {
+                    authorization: accessToken,
+                },
+            }));
+        }), catchError(() => {
+            authService.logout();
+            location.href = `/auth/login?url=${encodeURIComponent(router.url + location.hash)}`;
+            return throwError(() => errors[0]);
+        }));
+    }));
+};
+
+/**
+ * The `PermissionDirective` is a directive that conditionally renders content based on user permissions.
+ * @selector '[hasPermission]'
+ *
+ * @example
+ * ```html
+ *   <div *hasPermission="'MERCHANT.CONTRACT.READ'"></div>
+ * ```
+ */
+class PermissionDirective {
+    constructor(service, templateRef, viewContainer) {
+        this.service = service;
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+    }
+    set hasPermission(permission) {
+        if (this.service.has(permission)) {
+            this.viewContainer.createEmbeddedView(this.templateRef);
+            return;
+        }
+        this.viewContainer.clear();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: PermissionDirective, deps: [{ token: PermissionService }, { token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.0.0", type: PermissionDirective, isStandalone: true, selector: "[hasPermission]", inputs: { hasPermission: "hasPermission" }, exportAs: ["hasPermission"], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: PermissionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                    exportAs: 'hasPermission',
+                    selector: '[hasPermission]'
+                }]
+        }], ctorParameters: () => [{ type: PermissionService }, { type: i0.TemplateRef }, { type: i0.ViewContainerRef }], propDecorators: { hasPermission: [{
+                type: Input
+            }] } });
+
+class UnauthorizedPage {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: UnauthorizedPage, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.0.0", type: UnauthorizedPage, isStandalone: true, selector: "up-unauthorized", host: { classAttribute: "flex flex-col items-center justify-center size-full gap-4 p-5 select-none" }, providers: [
+            provideIcons({
+                matLockRound
+            })
+        ], ngImport: i0, template: `
+    <ng-icon 
+      name="matLockRound" 
+      class="text-3xl lg:text-5xl" 
+    />
+    
+    <h3 class="text-center text-lg lg:text-2xl font-bold">
+      Oops! You're not authorized to access this page.
+    </h3>
+    <p class="text-center">Please log in or re-check your permissions.</p>
+  `, isInline: true, dependencies: [{ kind: "component", type: NgIcon, selector: "ng-icon", inputs: ["name", "svg", "size", "strokeWidth", "color"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: UnauthorizedPage, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: 'up-unauthorized',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        class: 'flex flex-col items-center justify-center size-full gap-4 p-5 select-none'
+                    },
+                    providers: [
+                        provideIcons({
+                            matLockRound
+                        })
+                    ],
+                    imports: [
+                        NgIcon
+                    ],
+                    template: `
+    <ng-icon 
+      name="matLockRound" 
+      class="text-3xl lg:text-5xl" 
+    />
+    
+    <h3 class="text-center text-lg lg:text-2xl font-bold">
+      Oops! You're not authorized to access this page.
+    </h3>
+    <p class="text-center">Please log in or re-check your permissions.</p>
+  `,
+                }]
+        }] });
+
+class LoadingPage {
+    constructor(config, router, route, permissionService) {
+        this.config = config;
+        this.router = router;
+        this.route = route;
+        this.permissionService = permissionService;
+    }
+    ngOnInit() {
+        const subjectGuid = localStorage.getItem(this.config.subjectGuidStorageKey || 'userGuid');
+        if (!subjectGuid) {
+            this.router.navigate(['401']);
+            return;
+        }
+        const permCodeList = [];
+        this.sub = this.permissionService.getPermissions({
+            subjectGuid,
+            pageSize: 1000,
+            permType: this.config.permTypes,
+            permModule: this.config.permModules,
+        }, 'no-cache').subscribe({
+            error: () => {
+                this.router.navigate(['401']);
+            },
+            next: ({ data: { authMsPermission: { data } } }) => {
+                data.forEach(({ permCode }) => {
+                    if (!permCode) {
+                        return;
+                    }
+                    permCodeList.push(permCode);
+                });
+                this.permissionService.isInitiated = true;
+                this.permissionService.setPermission(permCodeList);
+                this.router.navigateByUrl(this.route.snapshot.queryParamMap.get('url') ?? '');
+            }
+        });
+    }
+    ngOnDestroy() {
+        this.sub?.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: LoadingPage, deps: [{ token: LOADING_CONFIG }, { token: i1$1.Router }, { token: i1$1.ActivatedRoute }, { token: PermissionService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.0.0", type: LoadingPage, isStandalone: true, selector: "up-loading", host: { classAttribute: "flex flex-col items-center gap-6 p-5 justify-center size-full select-none" }, ngImport: i0, template: `
+    <up-spinner class="size-10" />
+    
+    <h3 class="text-center text-lg lg:text-2xl font-bold">
+      Please wait, we're preparing the applet. Drink water or coffee while waiting.
+    </h3>
+  `, isInline: true, dependencies: [{ kind: "component", type: UpSpinnerComponent, selector: "up-spinner", inputs: ["stokeWidth", "inlineClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.0", ngImport: i0, type: LoadingPage, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: true,
+                    selector: 'up-loading',
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    host: {
+                        class: 'flex flex-col items-center gap-6 p-5 justify-center size-full select-none'
+                    },
+                    imports: [
+                        UpSpinnerComponent
+                    ],
+                    template: `
+    <up-spinner class="size-10" />
+    
+    <h3 class="text-center text-lg lg:text-2xl font-bold">
+      Please wait, we're preparing the applet. Drink water or coffee while waiting.
+    </h3>
+  `,
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOADING_CONFIG]
+                }] }, { type: i1$1.Router }, { type: i1$1.ActivatedRoute }, { type: PermissionService }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AuthResolver, AuthService, LoadingPage, PermissionDirective, PermissionService, ProfileService, UnauthorizedPage, authGuard, authorizationInterceptor, permissionGuard, provideLoadingConfig, refreshTokenInterceptor };
+//# sourceMappingURL=unipin-angular-applet-auth.mjs.map