@cccteam/ccc-lib 0.0.10

package/README.md

@@ -0,0 +1,24 @@
+# CccLib
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 18.2.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project ccc-lib` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project ccc-lib`.
+> Note: Don't forget to add `--project ccc-lib` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build ccc-lib` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build ccc-lib`, go to the dist folder `cd dist/ccc-lib` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test ccc-lib` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.dev/tools/cli) page.

package/esm2022/cccteam-ccc-lib.mjs

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

package/esm2022/lib/auth/directives/has-permission.directive.mjs

@@ -0,0 +1,44 @@
+import { Directive, Input, TemplateRef, ViewContainerRef, inject } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { Store } from '@ngxs/store';
+import { Subject, catchError, combineLatest, map, of } from 'rxjs';
+import { AuthState } from '../state/auth.state';
+import * as i0 from "@angular/core";
+export class HasPermissionDirective {
+    templateRef = inject((TemplateRef));
+    viewContainer = inject(ViewContainerRef);
+    store = inject(Store);
+    scope = new Subject();
+    set cccHasPermission(scope) {
+        this.scope.next(scope);
+    }
+    constructor() {
+        combineLatest({
+            permissionFn: this.store.select(AuthState.hasPermission),
+            scope: this.scope.asObservable(),
+        })
+            .pipe(takeUntilDestroyed(), map(({ permissionFn, scope }) => (scope !== undefined ? permissionFn(scope) : true)), catchError(() => of(false)))
+            .subscribe((result) => {
+            if (result) {
+                if (!this.viewContainer.get(0)) {
+                    this.viewContainer.createEmbeddedView(this.templateRef);
+                }
+            }
+            else {
+                this.viewContainer.clear();
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: HasPermissionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.7", type: HasPermissionDirective, isStandalone: true, selector: "[cccHasPermission]", inputs: { cccHasPermission: "cccHasPermission" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: HasPermissionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cccHasPermission]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [], propDecorators: { cccHasPermission: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/forms/ccc-field/ccc-field.component.mjs

@@ -0,0 +1,77 @@
+import { Component, computed, inject, input, signal } from '@angular/core';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { Store } from '@ngxs/store';
+import { ReadPermission, UpdatePermission } from '../../../types/permissions';
+import { AuthState } from '../../state/auth.state';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/form-field";
+import * as i2 from "@angular/material/input";
+export var InputMode;
+(function (InputMode) {
+    InputMode["Read"] = "read";
+    InputMode["Edit"] = "edit";
+})(InputMode || (InputMode = {}));
+export class CccInputFieldComponent {
+    store = inject(Store);
+    className = input();
+    mode = input.required();
+    resource = input.required();
+    domain = input.required();
+    value = input.required();
+    name = input.required();
+    inputMode = InputMode;
+    canEdit = signal(false);
+    canEditSelector = false;
+    canRead = signal(false);
+    canReadSelector = false;
+    ngOnInit() {
+        this.canEditSelector = this.store.selectSnapshot(AuthState.hasPermission)({
+            resource: this.resource(),
+            permission: ReadPermission,
+            domain: this.domain(),
+        });
+        this.canReadSelector = this.store.selectSnapshot(AuthState.hasPermission)({
+            resource: this.resource(),
+            permission: UpdatePermission,
+            domain: this.domain(),
+        });
+        this.canRead = computed(() => {
+            const res = this.resource();
+            if (!res) {
+                return false;
+            }
+            if (AuthState.requiresPermission(this.resource(), ReadPermission)) {
+                return this.canReadSelector;
+            }
+            return false;
+        });
+        this.canEdit = computed(() => {
+            const res = this.resource();
+            if (!res) {
+                return false;
+            }
+            if (AuthState.requiresPermission(this.resource(), UpdatePermission)) {
+                return this.canEditSelector;
+            }
+            return false;
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CccInputFieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.1.0", version: "18.2.7", type: CccInputFieldComponent, isStandalone: true, selector: "ccc-input-field", inputs: { className: { classPropertyName: "className", publicName: "className", isSignal: true, isRequired: false, transformFunction: null }, mode: { classPropertyName: "mode", publicName: "mode", isSignal: true, isRequired: true, transformFunction: null }, resource: { classPropertyName: "resource", publicName: "resource", isSignal: true, isRequired: true, transformFunction: null }, domain: { classPropertyName: "domain", publicName: "domain", isSignal: true, isRequired: true, transformFunction: null }, value: { classPropertyName: "value", publicName: "value", isSignal: true, isRequired: true, transformFunction: null }, name: { classPropertyName: "name", publicName: "name", isSignal: true, isRequired: true, transformFunction: null } }, ngImport: i0, template: `
+    <mat-form-field [class]="className()">
+      <mat-label>{{ name() }}</mat-label>
+      <input matInput [disabled]="mode() === inputMode.Edit && canEdit()" [value]="value()" />
+    </mat-form-field>
+  `, isInline: true, styles: [""], dependencies: [{ kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i1.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i1.MatLabel, selector: "mat-label" }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i2.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: CccInputFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ccc-input-field', standalone: true, imports: [MatFormFieldModule, MatInputModule], template: `
+    <mat-form-field [class]="className()">
+      <mat-label>{{ name() }}</mat-label>
+      <input matInput [disabled]="mode() === inputMode.Edit && canEdit()" [value]="value()" />
+    </mat-form-field>
+  ` }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/forms/form-helpers.mjs

@@ -0,0 +1,34 @@
+import { isEqual } from 'lodash-es';
+/**
+ * Accepts a FormGroup and compares it to an object to return the dirty form values
+ * as a sparse object
+ * @param form - FormGroup
+ * @param compareData - object to compare form values against
+ * @returns Partial<T>
+ * @example sparseFormData<UserCreate>(this.userForm, initUser)
+ */
+export function sparseFormData(form, compareData) {
+    const sparseFormData = {};
+    for (const [key, control] of Object.entries(form.controls)) {
+        const controlValue = control.value;
+        const compareValue = compareData[key];
+        if (!isEqual(controlValue, compareValue)) {
+            sparseFormData[key] = controlValue;
+        }
+    }
+    return sparseFormData;
+}
+/**
+ * Accepts a FormArray and removes empty strings
+ * @param formArray - FormArray
+ * @returns FormArray
+ */
+export function cleanStringFormArray(formArray) {
+    for (let i = formArray.controls.length - 1; i >= 0; i--) {
+        if (formArray.at(i).value === '') {
+            formArray.removeAt(i);
+        }
+    }
+    return formArray;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/guards/authentication.guard.mjs

@@ -0,0 +1,38 @@
+import { inject } from '@angular/core';
+import { Store } from '@ngxs/store';
+import { of } from 'rxjs';
+import { catchError, map, switchMap } from 'rxjs/operators';
+import { BASE_URL } from '../../types/base/tokens';
+import { AuthService } from '../services/auth.service';
+import { AuthenticationGuardAction } from '../state/auth.actions';
+import { AuthState } from '../state/auth.state';
+export const AuthenticationGuard = (route, routerState) => {
+    const store = inject(Store);
+    const authService = inject(AuthService);
+    const baseUrl = inject(BASE_URL);
+    const authenticate = () => {
+        const url = routerState.url;
+        const absoluteUrl = baseUrl + (!url.toString().startsWith('/') ? '/' + url : url);
+        const encodedUrl = encodeURIComponent(absoluteUrl);
+        window.location.href = `${authService.loginRoute()}?returnUrl=${encodedUrl}`;
+    };
+    return store.select(AuthState.isAuthenticated).pipe(switchMap((authenticated) => {
+        if (authenticated) {
+            return of(authenticated);
+        }
+        // Handle uninitialized state (ie Browser reload)
+        return store.dispatch(AuthenticationGuardAction.CheckUserSession).pipe(switchMap(() => {
+            return store.select(AuthState.isAuthenticated);
+        }));
+    }), map((authenticated) => {
+        if (authenticated) {
+            return true;
+        }
+        authenticate();
+        return false;
+    }), catchError(() => {
+        authenticate();
+        return of(false);
+    }));
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/guards/authorization.guard.mjs

@@ -0,0 +1,17 @@
+import { inject } from '@angular/core';
+import { Router } from '@angular/router';
+import { Store } from '@ngxs/store';
+import { map } from 'rxjs';
+import { AuthState } from '../state/auth.state';
+export const AuthorizationGuard = (route) => {
+    const store = inject(Store);
+    const router = inject(Router);
+    return store.select(AuthState.hasPermission).pipe(map((permissionFn) => permissionFn(route.data['scope'])), map((hasPermission) => {
+        if (hasPermission) {
+            return true;
+        }
+        router.navigate(['/']);
+        return false;
+    }));
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,49 @@
+import { Inject, Injectable } from '@angular/core';
+import { map } from 'rxjs';
+import { API_URL } from '../../types/base/tokens';
+import { errorOptions } from './request-options';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+const routes = {
+    login: (rootUrl) => `${rootUrl}/user/login`,
+    session: (rootUrl) => `${rootUrl}/user/session`,
+};
+export class AuthService {
+    http;
+    apiUrl;
+    constructor(http, apiUrl) {
+        this.http = http;
+        this.apiUrl = apiUrl;
+    }
+    /**
+     * Logs a user out.
+     *
+     * @returns Observable with a boolean indicating whether they were logged out.
+     */
+    logout() {
+        return this.http.delete(routes.session(this.apiUrl), errorOptions(false)).pipe(map(() => true));
+    }
+    /**
+     * Checks a user's session with the server.
+     *
+     * @returns Observable with the user session info
+     */
+    checkUserSession() {
+        return this.http.get(routes.session(this.apiUrl), errorOptions(false));
+    }
+    loginRoute() {
+        return routes.login(this.apiUrl);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AuthService, deps: [{ token: i1.HttpClient }, { token: API_URL }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AuthService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [API_URL]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/services/request-options.mjs

@@ -0,0 +1,12 @@
+import { HttpContext, HttpContextToken } from '@angular/common/http';
+export const CUSTOM_HTTP_REQUEST_OPTIONS = new HttpContextToken(() => ({
+    suppressGlobalError: false,
+}));
+export function errorOptions(suppressGlobalError) {
+    return {
+        context: new HttpContext().set(CUSTOM_HTTP_REQUEST_OPTIONS, {
+            suppressGlobalError: suppressGlobalError ?? false,
+        }),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVxdWVzdC1vcHRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NjLWxpYi9zcmMvbGliL2F1dGgvc2VydmljZXMvcmVxdWVzdC1vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQU1yRSxNQUFNLENBQUMsTUFBTSwyQkFBMkIsR0FBRyxJQUFJLGdCQUFnQixDQUEyQixHQUFHLEVBQUUsQ0FBQyxDQUFDO0lBQy9GLG1CQUFtQixFQUFFLEtBQUs7Q0FDM0IsQ0FBQyxDQUFDLENBQUM7QUFFSixNQUFNLFVBQVUsWUFBWSxDQUFDLG1CQUF3QztJQUNuRSxPQUFPO1FBQ0wsT0FBTyxFQUFFLElBQUksV0FBVyxFQUFFLENBQUMsR0FBRyxDQUFDLDJCQUEyQixFQUFFO1lBQzFELG1CQUFtQixFQUFFLG1CQUFtQixJQUFJLEtBQUs7U0FDbEQsQ0FBQztLQUNILENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cENvbnRleHQsIEh0dHBDb250ZXh0VG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQ3VzdG9tSHR0cFJlcXVlc3RPcHRpb25zIHtcbiAgc3VwcHJlc3NHbG9iYWxFcnJvcjogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGNvbnN0IENVU1RPTV9IVFRQX1JFUVVFU1RfT1BUSU9OUyA9IG5ldyBIdHRwQ29udGV4dFRva2VuPEN1c3RvbUh0dHBSZXF1ZXN0T3B0aW9ucz4oKCkgPT4gKHtcbiAgc3VwcHJlc3NHbG9iYWxFcnJvcjogZmFsc2UsXG59KSk7XG5cbmV4cG9ydCBmdW5jdGlvbiBlcnJvck9wdGlvbnMoc3VwcHJlc3NHbG9iYWxFcnJvcjogYm9vbGVhbiB8IHVuZGVmaW5lZCk6IHsgY29udGV4dDogSHR0cENvbnRleHQgfSB7XG4gIHJldHVybiB7XG4gICAgY29udGV4dDogbmV3IEh0dHBDb250ZXh0KCkuc2V0KENVU1RPTV9IVFRQX1JFUVVFU1RfT1BUSU9OUywge1xuICAgICAgc3VwcHJlc3NHbG9iYWxFcnJvcjogc3VwcHJlc3NHbG9iYWxFcnJvciA/PyBmYWxzZSxcbiAgICB9KSxcbiAgfTtcbn1cbiJdfQ==

package/esm2022/lib/auth/state/auth.actions.mjs

@@ -0,0 +1,64 @@
+/* eslint-disable @typescript-eslint/no-namespace */
+// no-namespace rule is disabled because action hygiene prevents import pollution
+export var AuthenticationGuardAction;
+(function (AuthenticationGuardAction) {
+    class SetRedirectUrl {
+        redirectUrl;
+        static type = '[AuthenticationGuard] Set Redirect Url And Navigate To Login Page';
+        constructor(redirectUrl) {
+            this.redirectUrl = redirectUrl;
+        }
+    }
+    AuthenticationGuardAction.SetRedirectUrl = SetRedirectUrl;
+    class CheckUserSession {
+        static type = '[AuthenticationGuard] Check User Session';
+    }
+    AuthenticationGuardAction.CheckUserSession = CheckUserSession;
+})(AuthenticationGuardAction || (AuthenticationGuardAction = {}));
+export var LoginAction;
+(function (LoginAction) {
+    class Logout {
+        static type = '[Login] Auto Logout';
+    }
+    LoginAction.Logout = Logout;
+    class SetRedirectUrl {
+        redirectUrl;
+        static type = '[Login] Set Redirect Url';
+        constructor(redirectUrl) {
+            this.redirectUrl = redirectUrl;
+        }
+    }
+    LoginAction.SetRedirectUrl = SetRedirectUrl;
+    class PublishError {
+        message;
+        static type = '[Login] Publish Error';
+        constructor(message) {
+            this.message = message;
+        }
+    }
+    LoginAction.PublishError = PublishError;
+})(LoginAction || (LoginAction = {}));
+export var AppAction;
+(function (AppAction) {
+    class CheckUserSession {
+        static type = '[App] Check User Session';
+    }
+    AppAction.CheckUserSession = CheckUserSession;
+    class SetRedirectUrl {
+        redirectUrl;
+        static type = '[App] Set Redirect Url';
+        constructor(redirectUrl) {
+            this.redirectUrl = redirectUrl;
+        }
+    }
+    AppAction.SetRedirectUrl = SetRedirectUrl;
+    class SetNavIdentifier {
+        identifier;
+        static type = '[App] Set Nav Identifier';
+        constructor(identifier) {
+            this.identifier = identifier;
+        }
+    }
+    AppAction.SetNavIdentifier = SetNavIdentifier;
+})(AppAction || (AppAction = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/state/auth.state.mjs

@@ -0,0 +1,105 @@
+var AuthState_1;
+import { __decorate } from "tslib";
+import { inject, Injectable } from '@angular/core';
+import { Action, Selector, State } from '@ngxs/store';
+import { patch } from '@ngxs/store/operators';
+import { cloneDeep } from 'lodash-es';
+import { tap } from 'rxjs';
+import { PERMISSION_REQUIRED } from '../../types/base/tokens';
+import { ApiInterceptorAction } from '../../ui/state/core.actions';
+import { AuthService } from '../services/auth.service';
+import { AppAction, AuthenticationGuardAction, LoginAction } from './auth.actions';
+import * as i0 from "@angular/core";
+export const initState = {
+    authenticated: false,
+    redirectUrl: '',
+    sessionInfo: null,
+};
+let AuthState = class AuthState {
+    static { AuthState_1 = this; }
+    authService = inject(AuthService);
+    static permissionFn;
+    constructor() {
+        AuthState_1.initializePermissionFn();
+    }
+    static initializePermissionFn() {
+        if (!AuthState_1.permissionFn) {
+            AuthState_1.permissionFn = inject(PERMISSION_REQUIRED);
+        }
+    }
+    static hasPermission(state) {
+        return (scope) => {
+            if (!scope)
+                return true;
+            const resourcePermissions = state?.sessionInfo?.permissions?.[scope.domain]?.[scope.resource];
+            return Array.isArray(resourcePermissions) && resourcePermissions.includes(scope.permission);
+        };
+    }
+    static requiresPermission(resource, permission) {
+        if (!AuthState_1.permissionFn) {
+            throw new Error(`AuthState has not been initialized. Ensure AuthState is provided in your module or instantiated at least once.`);
+        }
+        return AuthState_1.permissionFn(resource, permission);
+    }
+    static isAuthenticated(state) {
+        return state?.authenticated;
+    }
+    static redirectUrl(state) {
+        return state?.redirectUrl;
+    }
+    checkUserSession(ctx) {
+        return this.authService.checkUserSession().pipe(tap((result) => ctx.setState(patch({
+            authenticated: !!result?.authenticated,
+            sessionInfo: result,
+        }))));
+    }
+    logout(ctx) {
+        const localStateCopy = cloneDeep(initState);
+        localStateCopy.redirectUrl = ctx.getState().redirectUrl;
+        return this.authService.logout().pipe(tap(() => {
+            ctx.setState(localStateCopy);
+        }));
+    }
+    setRedirectUrl(ctx, action) {
+        ctx.setState(patch({
+            redirectUrl: action.redirectUrl,
+        }));
+        return ctx.getState();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AuthState, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AuthState });
+};
+__decorate([
+    Action([AppAction.CheckUserSession, AuthenticationGuardAction.CheckUserSession])
+], AuthState.prototype, "checkUserSession", null);
+__decorate([
+    Action([LoginAction.Logout])
+], AuthState.prototype, "logout", null);
+__decorate([
+    Action([
+        AppAction.SetRedirectUrl,
+        LoginAction.SetRedirectUrl,
+        AuthenticationGuardAction.SetRedirectUrl,
+        ApiInterceptorAction.SetRedirectUrl,
+    ])
+], AuthState.prototype, "setRedirectUrl", null);
+__decorate([
+    Selector()
+], AuthState, "hasPermission", null);
+__decorate([
+    Selector()
+], AuthState, "isAuthenticated", null);
+__decorate([
+    Selector()
+], AuthState, "redirectUrl", null);
+AuthState = AuthState_1 = __decorate([
+    State({
+        name: 'authState',
+        defaults: initState,
+    })
+], AuthState);
+export { AuthState };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.7", ngImport: i0, type: AuthState, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [], propDecorators: { checkUserSession: [], logout: [], setRedirectUrl: [] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth.state.js","sourceRoot":"","sources":["../../../../../../projects/ccc-lib/src/lib/auth/state/auth.state.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable } from '@angular/core';\nimport { Action, Selector, State, StateContext } from '@ngxs/store';\nimport { patch } from '@ngxs/store/operators';\nimport { cloneDeep } from 'lodash-es';\nimport { Observable, tap } from 'rxjs';\nimport { PERMISSION_REQUIRED } from '../../types/base/tokens';\nimport { Permission, PermissionScope, Resource } from '../../types/permissions';\nimport { SessionInfo } from '../../types/session-info';\nimport { ApiInterceptorAction } from '../../ui/state/core.actions';\nimport { AuthService } from '../services/auth.service';\nimport { AppAction, AuthenticationGuardAction, LoginAction } from './auth.actions';\n\nexport interface AuthStateModel {\n  authenticated: boolean;\n  redirectUrl: string;\n  sessionInfo: SessionInfo | null;\n}\n\nexport const initState: AuthStateModel = {\n  authenticated: false,\n  redirectUrl: '',\n  sessionInfo: null,\n};\n\n@State<AuthStateModel>({\n  name: 'authState',\n  defaults: initState,\n})\n@Injectable()\nexport class AuthState {\n  private authService = inject(AuthService);\n  private static permissionFn: (resource: Resource, permission: Permission) => boolean;\n\n  constructor() {\n    AuthState.initializePermissionFn();\n  }\n\n  private static initializePermissionFn(): void {\n    if (!AuthState.permissionFn) {\n      AuthState.permissionFn = inject(PERMISSION_REQUIRED);\n    }\n  }\n\n  @Selector()\n  static hasPermission(state: AuthStateModel): (scope?: PermissionScope) => boolean {\n    return (scope?: PermissionScope) => {\n      if (!scope) return true;\n      const resourcePermissions = state?.sessionInfo?.permissions?.[scope.domain]?.[scope.resource];\n      return Array.isArray(resourcePermissions) && resourcePermissions.includes(scope.permission);\n    };\n  }\n\n  static requiresPermission(resource: Resource, permission: Permission): boolean {\n    if (!AuthState.permissionFn) {\n      throw new Error(\n        `AuthState has not been initialized. Ensure AuthState is provided in your module or instantiated at least once.`,\n      );\n    }\n    return AuthState.permissionFn(resource, permission);\n  }\n\n  @Selector()\n  static isAuthenticated(state: AuthStateModel): boolean {\n    return state?.authenticated;\n  }\n\n  @Selector()\n  static redirectUrl(state: AuthStateModel): string {\n    return state?.redirectUrl;\n  }\n\n  @Action([AppAction.CheckUserSession, AuthenticationGuardAction.CheckUserSession])\n  checkUserSession(ctx: StateContext<AuthStateModel>): Observable<SessionInfo | null> {\n    return this.authService.checkUserSession().pipe(\n      tap((result) =>\n        ctx.setState(\n          patch({\n            authenticated: !!result?.authenticated,\n            sessionInfo: result,\n          }),\n        ),\n      ),\n    );\n  }\n\n  @Action([LoginAction.Logout])\n  logout(ctx: StateContext<AuthStateModel>): Observable<boolean> {\n    const localStateCopy = cloneDeep(initState);\n    localStateCopy.redirectUrl = ctx.getState().redirectUrl;\n    return this.authService.logout().pipe(\n      tap(() => {\n        ctx.setState(localStateCopy);\n      }),\n    );\n  }\n\n  @Action([\n    AppAction.SetRedirectUrl,\n    LoginAction.SetRedirectUrl,\n    AuthenticationGuardAction.SetRedirectUrl,\n    ApiInterceptorAction.SetRedirectUrl,\n  ])\n  setRedirectUrl(ctx: StateContext<AuthStateModel>, action: { redirectUrl: string }): AuthStateModel {\n    ctx.setState(\n      patch({\n        redirectUrl: action.redirectUrl,\n      }),\n    );\n    return ctx.getState();\n  }\n}\n"]}

package/esm2022/lib/types/base/tokens.mjs

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+export const BASE_URL = new InjectionToken('BASE_URL');
+export const API_URL = new InjectionToken('API_URL');
+export const PERMISSION_REQUIRED = new InjectionToken('PERMISSION_REQUIRED');
+export const AVAILABLE_PERMISSIONS = new InjectionToken('AVAILABLE_PERMISSIONS');
+export const AVAILABLE_DOMAINS = new InjectionToken('AVAILABLE_DOMAINS');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NjLWxpYi9zcmMvbGliL3R5cGVzL2Jhc2UvdG9rZW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFHL0MsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLElBQUksY0FBYyxDQUFTLFVBQVUsQ0FBQyxDQUFDO0FBQy9ELE1BQU0sQ0FBQyxNQUFNLE9BQU8sR0FBRyxJQUFJLGNBQWMsQ0FBUyxTQUFTLENBQUMsQ0FBQztBQUM3RCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxJQUFJLGNBQWMsQ0FDbkQscUJBQXFCLENBQ3RCLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxJQUFJLGNBQWMsQ0FNcEQsdUJBQXVCLENBQUMsQ0FBQztBQUM1QixNQUFNLENBQUMsTUFBTSxpQkFBaUIsR0FBRyxJQUFJLGNBQWMsQ0FBMkIsbUJBQW1CLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEb21haW4sIFBlcm1pc3Npb24sIFJlc291cmNlIH0gZnJvbSAnLi4vcGVybWlzc2lvbnMnO1xuXG5leHBvcnQgY29uc3QgQkFTRV9VUkwgPSBuZXcgSW5qZWN0aW9uVG9rZW48c3RyaW5nPignQkFTRV9VUkwnKTtcbmV4cG9ydCBjb25zdCBBUElfVVJMID0gbmV3IEluamVjdGlvblRva2VuPHN0cmluZz4oJ0FQSV9VUkwnKTtcbmV4cG9ydCBjb25zdCBQRVJNSVNTSU9OX1JFUVVJUkVEID0gbmV3IEluamVjdGlvblRva2VuPChyZXNvdXJjZTogUmVzb3VyY2UsIHBlcm1pc3Npb246IFBlcm1pc3Npb24pID0+IGJvb2xlYW4+KFxuICAnUEVSTUlTU0lPTl9SRVFVSVJFRCcsXG4pO1xuXG5leHBvcnQgY29uc3QgQVZBSUxBQkxFX1BFUk1JU1NJT05TID0gbmV3IEluamVjdGlvblRva2VuPHtcbiAgQ3JlYXRlOiBQZXJtaXNzaW9uO1xuICBEZWxldGU6IFBlcm1pc3Npb247XG4gIExpc3Q6IFBlcm1pc3Npb247XG4gIFJlYWQ6IFBlcm1pc3Npb247XG4gIFVwZGF0ZTogUGVybWlzc2lvbjtcbn0+KCdBVkFJTEFCTEVfUEVSTUlTU0lPTlMnKTtcbmV4cG9ydCBjb25zdCBBVkFJTEFCTEVfRE9NQUlOUyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxSZWNvcmQ8c3RyaW5nLCBEb21haW4+W10+KCdBVkFJTEFCTEVfRE9NQUlOUycpO1xuIl19

package/esm2022/lib/types/notification-message.mjs

@@ -0,0 +1,7 @@
+export var AlertLevel;
+(function (AlertLevel) {
+    AlertLevel["ERROR"] = "warn";
+    AlertLevel["INFO"] = "accent";
+    AlertLevel["SUCCESS"] = "success";
+})(AlertLevel || (AlertLevel = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLW1lc3NhZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2MtbGliL3NyYy9saWIvdHlwZXMvbm90aWZpY2F0aW9uLW1lc3NhZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksVUFJWDtBQUpELFdBQVksVUFBVTtJQUNwQiw0QkFBYyxDQUFBO0lBQ2QsNkJBQWUsQ0FBQTtJQUNmLGlDQUFtQixDQUFBO0FBQ3JCLENBQUMsRUFKVyxVQUFVLEtBQVYsVUFBVSxRQUlyQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIEFsZXJ0TGV2ZWwge1xuICBFUlJPUiA9ICd3YXJuJyxcbiAgSU5GTyA9ICdhY2NlbnQnLFxuICBTVUNDRVNTID0gJ3N1Y2Nlc3MnLFxufVxuXG5leHBvcnQgaW50ZXJmYWNlIENyZWF0ZU5vdGlmaWNhdGlvbk1lc3NhZ2Uge1xuICBkdXJhdGlvbj86IG51bWJlcjtcbiAgbWVzc2FnZTogc3RyaW5nO1xuICBsaW5rOiBzdHJpbmc7XG4gIGxldmVsOiBBbGVydExldmVsO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIE5vdGlmaWNhdGlvbk1lc3NhZ2Uge1xuICBpZDogbnVtYmVyO1xuICBkdXJhdGlvbj86IG51bWJlcjtcbiAgbWVzc2FnZTogc3RyaW5nO1xuICBsaW5rOiBzdHJpbmc7XG4gIGxldmVsOiBBbGVydExldmVsO1xufVxuIl19

package/esm2022/lib/types/permissions.mjs

@@ -0,0 +1,3 @@
+export const ReadPermission = 'Read';
+export const UpdatePermission = 'Update';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGVybWlzc2lvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jY2MtbGliL3NyYy9saWIvdHlwZXMvcGVybWlzc2lvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBYUEsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLE1BQW9CLENBQUM7QUFDbkQsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsUUFBc0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbInR5cGUgQnJhbmQ8SywgVD4gPSBLICYgeyBfX2JyYW5kOiBUIH07XG5cbmV4cG9ydCB0eXBlIFBlcm1pc3Npb24gPSBCcmFuZDxzdHJpbmcsICdQZXJtaXNzaW9uJz47XG5leHBvcnQgdHlwZSBSZXNvdXJjZSA9IEJyYW5kPHN0cmluZywgJ1Jlc291cmNlJz47XG5leHBvcnQgdHlwZSBEb21haW4gPSBCcmFuZDxzdHJpbmcsICdEb21haW4nPjtcbmV4cG9ydCB0eXBlIERvbWFpblBlcm1pc3Npb25zID0gUmVjb3JkPERvbWFpbiwgUmVjb3JkPFJlc291cmNlLCBSZWNvcmQ8UGVybWlzc2lvbiwgUGVybWlzc2lvbnM+Pj47XG5cbmV4cG9ydCBpbnRlcmZhY2UgUGVybWlzc2lvblNjb3BlIHtcbiAgcmVzb3VyY2U6IFJlc291cmNlO1xuICBwZXJtaXNzaW9uOiBQZXJtaXNzaW9uO1xuICBkb21haW46IERvbWFpbjtcbn1cblxuZXhwb3J0IGNvbnN0IFJlYWRQZXJtaXNzaW9uID0gJ1JlYWQnIGFzIFBlcm1pc3Npb247XG5leHBvcnQgY29uc3QgVXBkYXRlUGVybWlzc2lvbiA9ICdVcGRhdGUnIGFzIFBlcm1pc3Npb247XG4iXX0=

package/esm2022/lib/types/session-info.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbi1pbmZvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2NjLWxpYi9zcmMvbGliL3R5cGVzL3Nlc3Npb24taW5mby50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRG9tYWluUGVybWlzc2lvbnMgfSBmcm9tICcuL3Blcm1pc3Npb25zJztcblxuLyoqXG4gKiBTZXNzaW9uIEluZm9ybWF0aW9uIGZvciBhIGxvZ2dlZCBpbiB1c2VyXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2Vzc2lvbkluZm8ge1xuICBhdXRoZW50aWNhdGVkOiBib29sZWFuO1xuICB1c2VybmFtZTogc3RyaW5nO1xuICBwZXJtaXNzaW9uczogRG9tYWluUGVybWlzc2lvbnM7XG59XG4iXX0=