@lenne.tech/ng-base 18.1.3 → 22.0.1

package/fesm2022/lenne.tech-ng-base.mjs

@@ -1,928 +1,633 @@
-import { APOLLO_OPTIONS, ApolloModule } from 'apollo-angular';
-import { HttpLink } from 'apollo-angular/http';
-import * as i0 from '@angular/core';
-import { NgModule, Directive, HostBinding, Input, PLATFORM_ID, Inject, HostListener, Injectable, Pipe } from '@angular/core';
-import { ApolloLink, fromPromise, split, concat } from '@apollo/client/core';
-import { InMemoryCache } from '@apollo/client/cache';
-import { getMainDefinition } from '@apollo/client/utilities';
-import * as i2 from '@lenne.tech/ng-base/shared';
-import { createRestartableClient, BASE_MODULE_CONFIG, AuthService, WsService } from '@lenne.tech/ng-base/shared';
-import { GraphQLWsLink } from '@apollo/client/link/subscriptions';
-import { firstValueFrom, Observable, BehaviorSubject } from 'rxjs';
-import { onError } from '@apollo/client/link/error';
-import { provideHttpClient, withInterceptorsFromDi } from '@angular/common/http';
-import { isPlatformBrowser, DOCUMENT } from '@angular/common';
-import * as i1 from '@angular/router';
-import * as i1$1 from '@angular/platform-browser';
-
-/**
- * Inspired by Inpspired by https://github.com/jaydenseric/extract-files/releases/tag/v11.0.0
- */
-/**
- * Reactive native file
- */
-class ReactNativeFile {
-    uri;
-    name;
-    type;
-    constructor(uri, name, type) {
-        this.uri = uri;
-        this.name = name;
-        this.type = type;
-    }
+import { DOCUMENT, isPlatformBrowser, isPlatformServer } from "@angular/common";
+import * as i0 from "@angular/core";
+import { ApplicationRef, InjectionToken, PLATFORM_ID, REQUEST, REQUEST_CONTEXT, Service, computed, inject, isDevMode, makeEnvironmentProviders, provideAppInitializer, signal } from "@angular/core";
+const warnedKeys = /* @__PURE__ */ new Set();
+function warnLtOnce(key, message, level = "warn") {
+	if (warnedKeys.has(key)) return;
+	warnedKeys.add(key);
+	console[level](message);
 }
-/**
- * Check whether value is an extractable file
- */
-function isExtractableFile(value) {
-    return ((typeof File !== 'undefined' && value instanceof File) ||
-        (typeof Blob !== 'undefined' && value instanceof Blob) ||
-        value instanceof ReactNativeFile);
+function resetLtWarnOnceState() {
+	warnedKeys.clear();
 }
-/**
- * Clones a value, recursively extracting
- */
-function extractFiles(value, path = '', isExtractableFileFunc = isExtractableFile) {
-    // Map of extracted files and their object paths within the input value.
-    const files = new Map();
-    // Map of arrays and objects recursed within the input value and their clones,
-    // for reusing clones of values that are referenced multiple times within the
-    // input value.
-    const clones = new Map();
-    /**
-     * Recursively clones the value, extracting files.
-     */
-    function recurse(recurseValue, recursePath, recursed) {
-        let clone = recurseValue;
-        if (isExtractableFileFunc(recurseValue)) {
-            clone = null;
-            const filePaths = files.get(recurseValue);
-            filePaths ? filePaths.push(recursePath) : files.set(recurseValue, [recursePath]);
-        }
-        else {
-            const isList = Array.isArray(recurseValue) || (typeof FileList !== 'undefined' && recurseValue instanceof FileList);
-            const isObject = recurseValue && recurseValue.constructor === Object;
-            if (isList || isObject) {
-                const hasClone = clones.has(recurseValue);
-                if (hasClone) {
-                    clone = clones.get(recurseValue);
-                }
-                else {
-                    clone = isList ? [] : {};
-                    clones.set(recurseValue, clone);
-                }
-                if (!recursed.has(recurseValue)) {
-                    const pathPrefix = recursePath ? `${recursePath}.` : '';
-                    const recursedDeeper = new Set(recursed).add(recurseValue);
-                    if (isList) {
-                        let index = 0;
-                        for (const item of recurseValue) {
-                            const itemClone = recurse(item, pathPrefix + index++, recursedDeeper);
-                            if (!hasClone) {
-                                clone.push(itemClone);
-                            }
-                        }
-                    }
-                    else {
-                        for (const key of Object.keys(recurseValue)) {
-                            const propertyClone = recurse(recurseValue[key], pathPrefix + key, recursedDeeper);
-                            if (!hasClone) {
-                                clone[key] = propertyClone;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return clone;
-    }
-    return {
-        clone: recurse(value, path, new Set()),
-        files,
-    };
+function collectLtEditedFields(root) {
+	const edited = /* @__PURE__ */ new Map();
+	for (const node of Array.from(root.querySelectorAll("input, textarea"))) {
+		const field = node;
+		if (field.value !== field.defaultValue) edited.set(field, field.value);
+	}
+	return edited;
 }
-
-/**
- * Factory for apollo-angular options
- */
-function apolloOptionsFactory(baseModuleConfig, httpLink, authService, wsService) {
-    const links = [];
-    const http = httpLink.create({
-        uri: baseModuleConfig.apiUrl,
-        extractFiles,
-    });
-    const authMiddleware = new ApolloLink((operation, forward) => {
-        const headers = {};
-        const operationName = operation.query.definitions[0]?.selectionSet?.selections[0]?.name?.value;
-        if (localStorage) {
-            let token;
-            if (operationName === 'refreshToken') {
-                token = authService.refreshToken || null;
-            }
-            else {
-                token = authService.token || null;
-            }
-            if (token) {
-                headers.Authorization = 'Bearer ' + token;
-            }
-            operation.setContext(() => ({ headers }));
-        }
-        return forward(operation);
-    });
-    const errorLink = onError(({ graphQLErrors, networkError, operation, forward }) => {
-        if (graphQLErrors) {
-            for (const err of graphQLErrors) {
-                switch (err.extensions.code) {
-                    case 'UNAUTHENTICATED': {
-                        if (err.message !== 'Expired refresh token' &&
-                            err.message !== 'Expired token' &&
-                            err.message !== 'Invalid token') {
-                            return;
-                        }
-                        if (err.message === 'Expired refresh token' || err.message === 'Invalid token') {
-                            authService.clearSession();
-                            return;
-                        }
-                        return fromPromise(firstValueFrom(authService.requestNewToken()))
-                            .filter((value) => Boolean(value))
-                            .flatMap((response) => {
-                            const oldHeaders = operation.getContext().headers;
-                            // modify the operation context with a new token
-                            operation.setContext({
-                                headers: {
-                                    ...oldHeaders,
-                                    Authorization: `Bearer ${response.token}`,
-                                },
-                            });
-                            // retry the request, returning the new observable
-                            return forward(operation);
-                        });
-                    }
-                }
-            }
-        }
-    });
-    if (baseModuleConfig.logging) {
-        console.log(baseModuleConfig);
-    }
-    if (baseModuleConfig.wsUrl) {
-        const wsLink = new GraphQLWsLink(createRestartableClient({
-            url: baseModuleConfig.wsUrl,
-            connectionParams: () => {
-                return {
-                    Authorization: authService.token ? 'Bearer ' + authService.token : undefined,
-                };
-            },
-        }));
-        // Set client for reconnection on logout/login
-        wsService.client = wsLink.client;
-        // using the ability to split links, you can send data to each link
-        // depending on what kind of operation is being sent
-        links.push(split(
-        // split based on operation type
-        ({ query }) => {
-            // @ts-ignore
-            const { kind, operation } = getMainDefinition(query);
-            return kind === 'OperationDefinition' && operation === 'subscription';
-        }, wsLink, concat(concat(authMiddleware, errorLink), http)));
-    }
-    else {
-        links.push(authMiddleware);
-        links.push(errorLink);
-        links.push(http);
-    }
-    return {
-        link: ApolloLink.from(links),
-        cache: new InMemoryCache(),
-        defaultOptions: {
-            query: {
-                fetchPolicy: 'network-only',
-            },
-        },
-    };
+function restoreLtField(field, value) {
+	if (!field.isConnected || field.value === value) return false;
+	field.value = value;
+	field.dispatchEvent(new Event("input", { bubbles: true }));
+	return true;
 }
-
-/**
- * Base module
- */
-class BaseModule {
-    /**
-     * Set configuration of base module in root module of the app
-     */
-    static forRoot(baseModuleConfig = {}, AppAuthService) {
-        // Default config
-        const config = {
-            apiUrl: '',
-            authGuardRedirectUrl: '/auth',
-            logging: false,
-            version: null,
-            prefix: null,
-            scrollDetectionOffset: 200,
-            scrollOffset: 100,
-            storageType: 'local',
-            securePasswordTransfer: true,
-            ...baseModuleConfig,
-        };
-        if (config.logging) {
-            console.log('Config:', config);
-        }
-        // Prepare providers
-        const providers = [
-            {
-                provide: BASE_MODULE_CONFIG,
-                useValue: config,
-            },
-        ];
-        // Add apollo features if API URL is set
-        if (baseModuleConfig.apiUrl) {
-            providers.push({
-                provide: APOLLO_OPTIONS,
-                useFactory: apolloOptionsFactory,
-                deps: [BASE_MODULE_CONFIG, HttpLink, AppAuthService ? AppAuthService : AuthService, WsService],
-            });
-        }
-        else if (config.logging) {
-            console.log('apiUrl is missing, ApolloLink is not initialized');
-        }
-        // Return root module
-        return {
-            ngModule: BaseModule,
-            providers,
-        };
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: BaseModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.2", ngImport: i0, type: BaseModule, imports: [ApolloModule], exports: [ApolloModule] });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: BaseModule, providers: [provideHttpClient(withInterceptorsFromDi())], imports: [ApolloModule, ApolloModule] });
+function provideLtPreHydrationInput(options = {}) {
+	return provideAppInitializer(() => {
+		if (options.enabled === false || !isPlatformBrowser(inject(PLATFORM_ID)) || typeof document === "undefined") return;
+		const edited = collectLtEditedFields(document);
+		if (edited.size === 0) return;
+		const configured = options.maxRestoreMs ?? 1500;
+		const maxRestoreMs = Number.isFinite(configured) && configured > 0 ? Math.min(configured, 3e4) : 0;
+		const sweep = () => {
+			for (const [field, value] of edited) if (restoreLtField(field, value) || !field.isConnected) edited.delete(field);
+		};
+		inject(ApplicationRef).whenStable().then(() => {
+			sweep();
+			if (maxRestoreMs <= 0 || edited.size === 0) {
+				edited.clear();
+				return;
+			}
+			const interval = setInterval(sweep, 250);
+			setTimeout(() => {
+				clearInterval(interval);
+				edited.clear();
+			}, maxRestoreMs);
+		});
+	});
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: BaseModule, decorators: [{
-            type: NgModule,
-            args: [{ exports: [ApolloModule], imports: [ApolloModule], providers: [provideHttpClient(withInterceptorsFromDi())] }]
-        }] });
-
-/**
- * Decorator for automatically unsubscribe subscriptions
- * Inspired by https://codereacter.medium.com/angular-advanced-features-and-tips-you-may-not-know-about-cae3b8527184#9bd6
- */
-function AutoUnsubscribe(blackList = []) {
-    return function (constructor) {
-        const original = constructor.prototype.ngOnDestroy;
-        constructor.prototype.ngOnDestroy = function () {
-            for (const prop of Object.keys(this)) {
-                if (!blackList.includes(prop)) {
-                    const property = this[prop];
-                    if (property && typeof property.unsubscribe === 'function') {
-                        property.unsubscribe();
-                    }
-                }
-            }
-            if (original && typeof original === 'function') {
-                original.apply(this, arguments);
-            }
-        };
-    };
+const LT_PRE_HYDRATION_SUBMIT_GUARD_SCRIPT = "document.addEventListener('submit',function(e){var f=e.target;if(f instanceof HTMLFormElement&&!f.hasAttribute('action')){e.preventDefault();}},true);";
+const LT_RUNTIME_CONFIG_DEFAULTS = {
+	apiProxy: null,
+	apiUrl: "",
+	cookiePrefix: "",
+	lt: {},
+	siteUrl: "",
+	storagePrefix: ""
+};
+const LT_RUNTIME_CONFIG = new InjectionToken("LT_RUNTIME_CONFIG");
+const LT_SERVER_RUNTIME_CONFIG = new InjectionToken("LT_SERVER_RUNTIME_CONFIG", { factory: () => {
+	const context = inject(REQUEST_CONTEXT, { optional: true });
+	if (!context || typeof context !== "object" || !context.runtimeConfig) return null;
+	return {
+		public: context.runtimeConfig,
+		serverApiUrl: context.serverApiUrl ?? ""
+	};
+} });
+const LT_RUNTIME_CONFIG_SCRIPT_ID = "ng-runtime-config";
+function readLtRuntimeConfigFromDocument(doc) {
+	const text = doc?.getElementById?.(LT_RUNTIME_CONFIG_SCRIPT_ID)?.textContent;
+	if (!text) return null;
+	try {
+		const parsed = JSON.parse(text);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
 }
-
-/**
- * Directive for lazy loading images
- */
-class LazyLoadDirective {
-    el;
-    srcAttr = null;
-    src;
-    constructor(el) {
-        this.el = el;
-    }
-    ngAfterViewInit() {
-        this.canLazyLoad() ? this.lazyLoadImage() : this.loadImage();
-    }
-    canLazyLoad() {
-        return window && 'IntersectionObserver' in window;
-    }
-    lazyLoadImage() {
-        const obs = new IntersectionObserver((entries) => {
-            entries.forEach(({ isIntersecting }) => {
-                if (isIntersecting) {
-                    this.loadImage();
-                    obs.unobserve(this.el.nativeElement);
-                }
-            });
-        });
-        obs.observe(this.el.nativeElement);
-    }
-    loadImage() {
-        this.srcAttr = this.src;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: LazyLoadDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.2", type: LazyLoadDirective, isStandalone: true, selector: "img[ltLazyLoad]", inputs: { src: "src" }, host: { properties: { "attr.src": "this.srcAttr" } }, ngImport: i0 });
+function serializeLtRuntimeConfig(config) {
+	return JSON.stringify(config).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: LazyLoadDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: 'img[ltLazyLoad]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { srcAttr: [{
-                type: HostBinding,
-                args: ['attr.src']
-            }], src: [{
-                type: Input
-            }] } });
-
-/**
- * Set same height (maximum) to different elements
- */
-class MatchHeightDirective {
-    el;
-    imageService;
-    // class name to match height
-    ltMatchHeight;
-    // Replace lazy loading images with immediate loading images
-    loadImages = true;
-    // Wether current platform is a browser
-    isBrowser;
-    observer;
-    constructor(el, imageService, platformId) {
-        this.el = el;
-        this.imageService = imageService;
-        this.isBrowser = isPlatformBrowser(platformId);
-    }
-    onResize() {
-        this.matchHeight(this.el.nativeElement, this.ltMatchHeight);
-    }
-    ngAfterViewInit() {
-        this.matchHeight(this.el.nativeElement, this.ltMatchHeight);
-        this.observer = new MutationObserver(() => {
-            this.matchHeight(this.el.nativeElement, this.ltMatchHeight);
-        });
-        //Observes if one or more elements get added to or removed from the childlist and applies matching heights
-        this.observer.observe(this.el.nativeElement, { childList: true });
-    }
-    async matchHeight(parent, target) {
-        if (!parent) {
-            return;
-        }
-        let classNames;
-        if (!Array.isArray(target)) {
-            classNames = [target];
-        }
-        else {
-            classNames = target;
-        }
-        for (const className of classNames) {
-            // find all child structureElements with the selected class name
-            const children = parent.getElementsByClassName(className);
-            if (!children || children.length < 2) {
-                continue;
-            }
-            // Load images of children
-            if (this.loadImages) {
-                await this.imageService.preLoadImages({ elements: children });
-            }
-            // reset all children height
-            Array.from(children).forEach((element) => {
-                element.style.height = 'initial';
-            });
-            // get all the child structureElements heights
-            const itemHeights = Array.from(children).map((element) => {
-                if (element.getBoundingClientRect) {
-                    return element.getBoundingClientRect().height;
-                }
-                return 0;
-            });
-            // find out the tallest one
-            const maxHeight = itemHeights.reduce((prev, curr) => (curr > prev ? curr : prev), 0);
-            // update the child structureElements height to the tallest one
-            Array.from(children).forEach((element) => (element.style.height = `${maxHeight}px`));
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MatchHeightDirective, deps: [{ token: i0.ElementRef }, { token: i2.ImageService }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.2", type: MatchHeightDirective, isStandalone: true, selector: "[ltMatchHeight]", inputs: { ltMatchHeight: "ltMatchHeight", loadImages: "loadImages" }, host: { listeners: { "window:resize": "onResize()" } }, ngImport: i0 });
+function injectLtRuntimeConfigScript(html, config, options = {}) {
+	const head = /<head(\s[^>]*)?>/i.exec(html);
+	if (!head) return html;
+	const at = head.index + head[0].length;
+	const guard = options.submitGuard === false ? "" : `<script>${LT_PRE_HYDRATION_SUBMIT_GUARD_SCRIPT}<\/script>`;
+	return `${html.slice(0, at)}${guard}<script id="${LT_RUNTIME_CONFIG_SCRIPT_ID}" type="application/json">${serializeLtRuntimeConfig(config)}<\/script>${html.slice(at)}`;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: MatchHeightDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[ltMatchHeight]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i2.ImageService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [PLATFORM_ID]
-                }] }], propDecorators: { ltMatchHeight: [{
-                type: Input
-            }], loadImages: [{
-                type: Input
-            }], onResize: [{
-                type: HostListener,
-                args: ['window:resize']
-            }] } });
-
-/**
- * Reszise detection
- * (inpsired by: https://stackblitz.com/edit/angular-resizable)
- */
-class ResizableDirective {
-    el;
-    resizableGrabWidth = 8;
-    resizableMinWidth = 10;
-    dragging = false;
-    constructor(el) {
-        this.el = el;
-    }
-    ngOnInit() {
-        this.addListenerToDocument();
-        this.addListenerToElement();
-    }
-    mouseMoveG(evt) {
-        if (!this.dragging) {
-            return;
-        }
-        this.newWidth(evt.clientX - this.el.nativeElement.offsetLeft);
-        evt.stopPropagation();
-    }
-    newWidth(wid) {
-        const result = Math.max(this.resizableMinWidth, wid);
-        this.el.nativeElement.style.width = result + 'px';
-    }
-    mouseDown(evt) {
-        if (this.inDragRegion(evt)) {
-            this.dragging = true;
-            this.preventGlobalMouseEvents();
-            evt.stopPropagation();
-        }
-    }
-    restoreGlobalMouseEvents() {
-        document.body.style['pointer-events'] = 'auto';
-    }
-    mouseUpG(evt) {
-        if (!this.dragging) {
-            return;
-        }
-        this.restoreGlobalMouseEvents();
-        this.dragging = false;
-        evt.stopPropagation();
-    }
-    mouseMove(evt) {
-        if (this.inDragRegion(evt) || this.dragging) {
-            this.el.nativeElement.style.cursor = 'col-resize';
-        }
-        else {
-            this.el.nativeElement.style.cursor = 'default';
-        }
-    }
-    preventGlobalMouseEvents() {
-        document.body.style['pointer-events'] = 'none';
-    }
-    inDragRegion(evt) {
-        return this.el.nativeElement.clientWidth - evt.clientX + this.el.nativeElement.offsetLeft < this.resizableGrabWidth;
-    }
-    addListenerToDocument() {
-        document.addEventListener('mousemove', (e) => {
-            this.mouseMoveG(e);
-        }, true);
-        document.addEventListener('mouseup', (e) => {
-            this.mouseUpG(e);
-        }, true);
-    }
-    addListenerToElement() {
-        this.el.nativeElement.addEventListener('mousedown', (e) => {
-            this.mouseDown(e);
-        }, true);
-        this.el.nativeElement.addEventListener('mousemove', (e) => {
-            this.mouseMove(e);
-        }, true);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ResizableDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.2", type: ResizableDirective, isStandalone: true, selector: "[ltResizable]", inputs: { resizableGrabWidth: "resizableGrabWidth", resizableMinWidth: "resizableMinWidth" }, ngImport: i0 });
+function mergeLtRuntimeConfig(base, ...overrides) {
+	const result = {
+		...base,
+		lt: { ...base.lt }
+	};
+	for (const override of overrides) {
+		if (!override) continue;
+		for (const [key, value] of Object.entries(override)) {
+			if (value === void 0) continue;
+			if (key === "lt") {
+				for (const [feature, options] of Object.entries(value ?? {})) result.lt[feature] = {
+					...result.lt[feature],
+					...definedEntries(options ?? {})
+				};
+				continue;
+			}
+			result[key] = value;
+		}
+	}
+	return result;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ResizableDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[ltResizable]',
-                    standalone: true,
-                }]
-        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { resizableGrabWidth: [{
-                type: Input
-            }], resizableMinWidth: [{
-                type: Input
-            }] } });
-
-/**
- * Authentication guard
- */
-class AuthGuard {
-    router;
-    authService;
-    moduleConfig;
-    platformId;
-    /**
-     * Imports
-     */
-    constructor(router, authService, moduleConfig, platformId) {
-        this.router = router;
-        this.authService = authService;
-        this.moduleConfig = moduleConfig;
-        this.platformId = platformId;
-    }
-    /**
-     * Can activate main route
-     */
-    canActivate(route, state) {
-        if (isPlatformBrowser(this.platformId)) {
-            return new Observable((subscriber) => {
-                let allowed = false;
-                let redirected = false;
-                /* If the user is logged in and the route is not marked as opposite, then the user is allowed to access the route. */
-                const opposite = route?.data?.opposite ? route?.data?.opposite : false;
-                const redirectAuthUrl = route?.data?.redirectAuthUrl
-                    ? route.data.redirectAuthUrl
-                    : this.moduleConfig.authGuardRedirectUrl;
-                const redirectRoleUrl = route?.data?.redirectRoleUrl
-                    ? route.data.redirectRoleUrl
-                    : this.moduleConfig.authGuardRedirectUrl;
-                const disableQueryParams = route?.data?.disableQueryParams ?? false;
-                const queryParams = disableQueryParams
-                    ? {}
-                    : {
-                        queryParams: {
-                            redirectUrl: route['_routerState'].url,
-                        },
-                    };
-                if (this.authService.token && !opposite) {
-                    if (route.data?.roles) {
-                        const user = this.authService.currentUser;
-                        allowed = !!route.data.roles.find((role) => user.roles?.includes(role));
-                        if (!allowed && redirectRoleUrl) {
-                            this.router.navigate([redirectRoleUrl], queryParams);
-                            redirected = true;
-                        }
-                    }
-                    else {
-                        allowed = true;
-                    }
-                }
-                else if (!this.authService.token && opposite) {
-                    allowed = true;
-                }
-                if (!allowed && redirectAuthUrl && !redirected) {
-                    this.router.navigate([redirectAuthUrl], queryParams);
-                }
-                subscriber.next(allowed);
-                subscriber.complete();
-            });
-        }
-    }
-    /**
-     * Can activate child route
-     */
-    canActivateChild(route, state) {
-        return this.canActivate(route, state);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AuthGuard, deps: [{ token: i1.Router }, { token: i2.AuthService }, { token: BASE_MODULE_CONFIG }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AuthGuard });
+function mergeLtFeatureOptions(defaults, ...overrides) {
+	const result = { ...defaults };
+	for (const override of overrides) {
+		if (!override) continue;
+		for (const [key, value] of Object.entries(override)) {
+			if (value === void 0) continue;
+			const current = result[key];
+			result[key] = isPlainObject(current) && isPlainObject(value) ? {
+				...current,
+				...definedEntries(value)
+			} : value;
+		}
+	}
+	return result;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: AuthGuard, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.AuthService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [BASE_MODULE_CONFIG]
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [PLATFORM_ID]
-                }] }] });
-
-/**
- * Guard to check if a component can be deactivated
- */
-class CanDeactivateGuard {
-    canDeactivate(component) {
-        return component.canDeactivate ? component.canDeactivate() : true;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: CanDeactivateGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: CanDeactivateGuard });
+function definedEntries(source) {
+	return Object.fromEntries(Object.entries(source).filter(([, value]) => value !== void 0));
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: CanDeactivateGuard, decorators: [{
-            type: Injectable
-        }] });
-
-/**
- * Logout guard
- */
-class LogoutGuard {
-    router;
-    authService;
-    constructor(router, authService) {
-        this.router = router;
-        this.authService = authService;
-    }
-    canActivate(route, state) {
-        return new Observable((subscriber) => {
-            if (this.authService.token) {
-                this.authService.logout();
-            }
-            subscriber.next(true);
-            subscriber.complete();
-        });
-    }
-    canActivateChild(route, state) {
-        return this.canActivate(route, state);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: LogoutGuard, deps: [{ token: i1.Router }, { token: i2.AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: LogoutGuard });
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: LogoutGuard, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: i1.Router }, { type: i2.AuthService }] });
-
-/**
- * Declarate html as safe
- */
-class SafeHtmlPipe {
-    sanitized;
-    constructor(sanitized) {
-        this.sanitized = sanitized;
-    }
-    transform(value) {
-        return this.sanitized.bypassSecurityTrustHtml(value);
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: SafeHtmlPipe, deps: [{ token: i1$1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
-    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.0.2", ngImport: i0, type: SafeHtmlPipe, isStandalone: true, name: "ltSafeHtml" });
+const MISSING_API_URL_WARNING = {
+	browser: "[@lenne.tech/ng-base] No API URL configured. Set NG_PUBLIC_API_URL. API paths stay relative and resolve against the app origin, so auth and setup calls 404 unless the app is served behind a same-origin reverse proxy.",
+	server: "[@lenne.tech/ng-base] No API URL configured for SSR. Set NG_API_URL or NG_PUBLIC_API_URL. API paths stay relative, so server-side requests never reach the backend."
+};
+function resolveLtApiBaseUrl(inputs) {
+	if (inputs.scope === "server") {
+		const apiUrl = inputs.serverApiUrl || inputs.apiUrl || "";
+		return {
+			baseUrl: stripTrailingSlashes(apiUrl),
+			missing: !apiUrl,
+			proxy: false,
+			scope: "server"
+		};
+	}
+	if (inputs.apiProxy === true || inputs.apiProxy === null && inputs.devMode) return {
+		baseUrl: "/api",
+		missing: false,
+		proxy: true,
+		scope: "browser"
+	};
+	const apiUrl = inputs.apiUrl || "";
+	return {
+		baseUrl: stripTrailingSlashes(apiUrl),
+		missing: !apiUrl,
+		proxy: false,
+		scope: "browser"
+	};
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: SafeHtmlPipe, decorators: [{
-            type: Pipe,
-            args: [{ name: 'ltSafeHtml', standalone: true }]
-        }], ctorParameters: () => [{ type: i1$1.DomSanitizer }] });
-
-class DateAgoPipe {
-    intervals = {
-        year: 31536000,
-        month: 2592000,
-        week: 604800,
-        day: 86400,
-        hour: 3600,
-        minute: 60,
-        second: 1,
-    };
-    singular = {
-        year: 'Jahr',
-        month: 'Monat',
-        week: 'Woche',
-        day: 'Tag',
-        hour: 'Stunde',
-        minute: 'Minute',
-        second: 'Sekunde',
-    };
-    plural = {
-        year: 'Jahren',
-        month: 'Monaten',
-        week: 'Wochen',
-        day: 'Tagen',
-        hour: 'Stunden',
-        minute: 'Minuten',
-        second: 'Sekunden',
-    };
-    transform(value, currentDate) {
-        const now = currentDate ?? new Date();
-        if (value) {
-            const seconds = Math.floor((+now - +new Date(value)) / 1000);
-            if (seconds < 29) {
-                return 'gerade eben'; // less than 30 seconds ago will show as 'Just now'
-            }
-            let counter;
-            for (const i of Object.keys(this.intervals)) {
-                counter = Math.floor(seconds / this.intervals[i]);
-                if (counter > 0) {
-                    if (counter === 1) {
-                        return 'vor ' + counter + ' ' + this.singular[i]; // singular (1 day ago)
-                    }
-                    else {
-                        return 'vor ' + counter + ' ' + this.plural[i]; // plural (2 days ago)
-                    }
-                }
-            }
-        }
-        return value;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: DateAgoPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
-    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.0.2", ngImport: i0, type: DateAgoPipe, isStandalone: true, name: "dateAgo" });
+function isLtAbsoluteUrl(url) {
+	return /^[a-z][a-z\d+\-.]*:/i.test(url) || url.startsWith("//");
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: DateAgoPipe, decorators: [{
-            type: Pipe,
-            args: [{
-                    name: 'dateAgo',
-                    pure: true,
-                    standalone: true,
-                }]
-        }] });
-
-/**
- * Fullscreen service
- */
-class FullscreenService {
-    _isFullscreenActive = new BehaviorSubject(false);
-    constructor() {
-        this.listenToFullscreenEvent();
-    }
-    get fullscreenState() {
-        return this._isFullscreenActive.value;
-    }
-    get fullscreenStateAsObservable() {
-        return this._isFullscreenActive.asObservable();
-    }
-    toggleFullscreen() {
-        const elem = document.documentElement;
-        if (!this._isFullscreenActive.value) {
-            elem.requestFullscreen();
-            this._isFullscreenActive.next(true);
-        }
-        else {
-            document.exitFullscreen();
-            this._isFullscreenActive.next(false);
-        }
-    }
-    /**
-     * Event Listener for fullscreen toggle
-     */
-    listenToFullscreenEvent() {
-        document.addEventListener('fullscreenchange', () => {
-            if (document.fullscreenElement) {
-                this._isFullscreenActive.next(true);
-            }
-            else {
-                this._isFullscreenActive.next(false);
-            }
-        });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: FullscreenService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: FullscreenService, providedIn: 'root' });
+var LtApiUrlService = class LtApiUrlService {
+	runtimeConfig = inject(LT_RUNTIME_CONFIG, { optional: true });
+	serverConfig = inject(LT_SERVER_RUNTIME_CONFIG, { optional: true });
+	isServer = isPlatformServer(inject(PLATFORM_ID));
+	resolve() {
+		return resolveLtApiBaseUrl({
+			apiProxy: this.runtimeConfig?.apiProxy ?? null,
+			apiUrl: this.runtimeConfig?.apiUrl ?? "",
+			devMode: isDevMode(),
+			scope: this.isServer ? "server" : "browser",
+			serverApiUrl: this.serverConfig?.serverApiUrl
+		});
+	}
+	baseUrl() {
+		return this.resolveAndWarn().baseUrl;
+	}
+	buildUrl(path) {
+		if (isLtAbsoluteUrl(path)) return path;
+		const normalized = path.startsWith("/") ? path : `/${path}`;
+		return `${this.resolveAndWarn().baseUrl}${normalized}`;
+	}
+	isProxy() {
+		return this.resolve().proxy;
+	}
+	reportMissing() {
+		const resolution = this.resolve();
+		if (resolution.missing) warnLtOnce(`missing-api-url:${resolution.scope}`, MISSING_API_URL_WARNING[resolution.scope], isDevMode() ? "warn" : "error");
+		return resolution.missing;
+	}
+	resolveAndWarn() {
+		const resolution = this.resolve();
+		if (resolution.missing) warnLtOnce(`missing-api-url:${resolution.scope}`, MISSING_API_URL_WARNING[resolution.scope]);
+		if (resolution.proxy && this.runtimeConfig?.apiProxy === null) warnLtOnce("api-proxy-implicit", "[@lenne.tech/ng-base] API proxy (/api) activated implicitly because the app runs in dev mode. Set NG_PUBLIC_API_PROXY=true to make it explicit, or NG_PUBLIC_API_PROXY=false to call the API directly.");
+		return resolution;
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtApiUrlService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtApiUrlService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtApiUrlService,
+	decorators: [{ type: Service }]
+});
+function stripTrailingSlashes(url) {
+	return url.replace(/\/+$/, "");
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: FullscreenService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [] });
-
-/**
- * SEO service for setting HTML meta data
- *
- * Sets the same tags in the browser and during server-side rendering: crawlers for link previews read the HTML of
- * the server and run no JavaScript. The page URL is taken from the document, which also exists on the server
- * (window does not); pass `url` to set a canonical URL instead, e.g. when the server sits behind a proxy.
- */
-class SEOService {
-    titleService;
-    metaTagService;
-    document;
-    constructor(titleService, metaTagService, document) {
-        this.titleService = titleService;
-        this.metaTagService = metaTagService;
-        this.document = document;
-    }
-    initPageForSEO(input) {
-        this.setGeneralData(input);
-        this.setTwitterData(input);
-        this.setFacebookData(input);
-        if (input.keywords) {
-            this.setPageKeywords(input.keywords);
-        }
-    }
-    /**
-     * Set general metadata
-     *
-     * @param data
-     * @private
-     */
-    setGeneralData(data) {
-        this.titleService.setTitle(data.title);
-        this.metaTagService.updateTag({ name: 'description', content: data.description });
-    }
-    /**
-     * Set metadata for twitter
-     *
-     * @param data
-     * @private
-     */
-    setTwitterData(data) {
-        this.metaTagService.updateTag({ name: 'twitter:title', content: data.title });
-        this.metaTagService.updateTag({ name: 'twitter:description', content: data.description });
-        const url = this.getUrl(data);
-        if (url) {
-            this.metaTagService.updateTag({ property: 'twitter:url', content: url });
-        }
-        if (data.image) {
-            this.metaTagService.updateTag({
-                property: 'twitter:image',
-                content: data.image,
-            });
-            this.metaTagService.updateTag({
-                property: 'twitter:card',
-                content: 'summary_large_image',
-            });
-        }
-    }
-    /**
-     * Set metadata for facebook
-     *
-     * @param data
-     * @private
-     */
-    setFacebookData(data) {
-        this.metaTagService.updateTag({ property: 'og:title', content: data.title });
-        this.metaTagService.updateTag({ property: 'og:description', content: data.description });
-        this.metaTagService.updateTag({
-            property: 'og:type',
-            content: 'website',
-        });
-        const url = this.getUrl(data);
-        if (url) {
-            this.metaTagService.updateTag({ property: 'og:url', content: url });
-        }
-        if (data.image) {
-            this.metaTagService.updateTag({
-                property: 'og:image',
-                content: data.image,
-            });
-        }
-    }
-    /**
-     * URL of the page: the given one, otherwise the one of the document (none if neither exists)
-     *
-     * @param data
-     * @private
-     */
-    getUrl(data) {
-        return data.url || this.document?.location?.href || undefined;
-    }
-    /**
-     * Set page keywords
-     *
-     * @param keywords
-     * @private
-     */
-    setPageKeywords(keywords) {
-        this.metaTagService.updateTag({ name: 'keywords', content: keywords });
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: SEOService, deps: [{ token: i1$1.Title }, { token: i1$1.Meta }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: SEOService, providedIn: 'root' });
+var LtCookieService = class LtCookieService {
+	document = inject(DOCUMENT);
+	request = inject(REQUEST, { optional: true });
+	isServer = isPlatformServer(inject(PLATFORM_ID));
+	raw() {
+		if (this.isServer) return this.request?.headers.get("cookie") ?? "";
+		try {
+			return this.document.cookie ?? "";
+		} catch {
+			return "";
+		}
+	}
+	get(name) {
+		return this.getAll(name)[0] ?? null;
+	}
+	getAll(name) {
+		return parseLtCookies(this.raw(), name);
+	}
+	set(name, value, options = {}) {
+		if (this.isServer) return;
+		const secure = options.secure ?? this.document.location?.protocol === "https:";
+		const parts = [
+			`${name}=${encodeURIComponent(value)}`,
+			`path=${options.path ?? "/"}`,
+			`samesite=${options.sameSite ?? "lax"}`
+		];
+		if (options.maxAge !== void 0) parts.push(`max-age=${Math.max(0, Math.floor(options.maxAge))}`);
+		if (options.domain) parts.push(`domain=${options.domain}`);
+		if (secure) parts.push("secure");
+		this.document.cookie = parts.join("; ");
+	}
+	delete(name, options = {}) {
+		if (this.isServer) return;
+		const parts = [
+			`${name}=`,
+			`path=${options.path ?? "/"}`,
+			"expires=Thu, 01 Jan 1970 00:00:00 GMT",
+			"max-age=0"
+		];
+		if (options.domain) parts.push(`domain=${options.domain}`);
+		this.document.cookie = parts.join("; ");
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtCookieService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtCookieService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtCookieService,
+	decorators: [{ type: Service }]
+});
+function parseLtCookies(cookieString, name) {
+	const prefix = `${name}=`;
+	const values = [];
+	for (const entry of (cookieString || "").split(/;\s*/)) {
+		if (!entry.startsWith(prefix)) continue;
+		const value = entry.slice(prefix.length);
+		try {
+			values.push(decodeURIComponent(value));
+		} catch {
+			values.push(value);
+		}
+	}
+	return values;
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: SEOService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i1$1.Title }, { type: i1$1.Meta }, { type: Document, decorators: [{
-                    type: Inject,
-                    args: [DOCUMENT]
-                }] }] });
-
-class ThemeService {
-    storageService;
-    _theme = new BehaviorSubject('light');
-    get theme() {
-        return this._theme.value;
-    }
-    set theme(theme) {
-        this._theme.next(theme);
-        this.storageService.save('theme', theme);
-    }
-    get themeObservable() {
-        return this._theme.asObservable();
-    }
-    constructor(storageService) {
-        this.storageService = storageService;
-        // Load from storage
-        this.theme = this.storageService.load('theme');
-        // Use system theme if no theme is set
-        if (!this.theme) {
-            this.checkSystemTheme();
-        }
-    }
-    /**
-     * Check theme from system
-     */
-    checkSystemTheme() {
-        if (window?.matchMedia) {
-            this.theme = window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ThemeService, deps: [{ token: i2.StorageService }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ThemeService, providedIn: 'root' });
+async function ltSha256(message) {
+	const data = new TextEncoder().encode(message);
+	const hash = await crypto.subtle.digest("SHA-256", data);
+	return Array.from(new Uint8Array(hash), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.2", ngImport: i0, type: ThemeService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                }]
-        }], ctorParameters: () => [{ type: i2.StorageService }] });
-
-/**
- * Exports for public API
- */
-// Module
-
-/**
- * Generated bundle index. Do not edit.
- */
+function ltArrayBufferToBase64Url(buffer) {
+	const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function ltBase64UrlToUint8Array(base64url) {
+	const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+	const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+	const binary = atob(padded);
+	const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+	for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
+	return bytes;
+}
+const LT_FETCH = new InjectionToken("LT_FETCH", { factory: () => ltCredentialsFetch });
+const ltCredentialsFetch = (input, init) => fetch(input, {
+	credentials: "include",
+	...init
+});
+var de_default = { lt: { "error": {
+	"title": "Fehler",
+	"loadFailed": "Fehlerübersetzungen konnten nicht geladen werden"
+} } };
+var en_default = { lt: { "error": {
+	"title": "Error",
+	"loadFailed": "Failed to load error translations"
+} } };
+const LT_I18N_ADAPTER = new InjectionToken("LT_I18N_ADAPTER");
+const LT_I18N_OPTIONS = new InjectionToken("LT_I18N_OPTIONS", { factory: () => ({}) });
+const LT_I18N_MESSAGES = {
+	de: de_default,
+	en: en_default
+};
+var LtI18nService = class LtI18nService {
+	adapter = inject(LT_I18N_ADAPTER, { optional: true });
+	options = inject(LT_I18N_OPTIONS);
+	isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+	explicitLocale = signal(null, ...ngDevMode ? [{ debugName: "explicitLocale" }] : /* istanbul ignore next */ []);
+	extraMessages = signal(this.options.messages ?? {}, ...ngDevMode ? [{ debugName: "extraMessages" }] : /* istanbul ignore next */ []);
+	libraryMessages = {};
+	libraryIds = /* @__PURE__ */ new Set();
+	locale = computed(() => this.adapter?.locale() || this.explicitLocale() || this.detectBrowserLocale() || this.options.defaultLocale || "de", ...ngDevMode ? [{ debugName: "locale" }] : /* istanbul ignore next */ []);
+	setLocale(locale) {
+		this.explicitLocale.set(locale);
+	}
+	registerMessages(locale, messages) {
+		this.extraMessages.update((current) => ({
+			...current,
+			[locale]: deepMerge(current[locale] ?? {}, messages)
+		}));
+	}
+	registerLibraryMessages(id, messages) {
+		if (this.libraryIds.has(id)) return;
+		this.libraryIds.add(id);
+		for (const [locale, tree] of Object.entries(messages)) this.libraryMessages[locale] = deepMerge(this.libraryMessages[locale] ?? {}, tree);
+	}
+	t(key, params) {
+		const fromAdapter = this.adapter?.translate(key, params);
+		if (fromAdapter && fromAdapter !== key) return fromAdapter;
+		const locale = this.locale();
+		return interpolate(lookup(this.extraMessages()[locale], key) ?? lookup(LT_I18N_MESSAGES[locale], key) ?? lookup(this.libraryMessages[locale], key) ?? lookup(this.extraMessages()["de"], key) ?? lookup(LT_I18N_MESSAGES.de, key) ?? lookup(this.libraryMessages["de"], key) ?? key, params);
+	}
+	detectBrowserLocale() {
+		if (!this.isBrowser || typeof navigator === "undefined" || !navigator.language) return null;
+		const language = navigator.language.split("-")[0]?.toLowerCase() ?? "";
+		return language === "de" || language === "en" ? language : null;
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtI18nService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtI18nService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtI18nService,
+	decorators: [{ type: Service }]
+});
+function lookup(messages, key) {
+	let node = messages;
+	for (const part of key.split(".")) {
+		if (!node || typeof node === "string") return null;
+		node = node[part];
+	}
+	return typeof node === "string" ? node : null;
+}
+function interpolate(message, params) {
+	if (!params) return message;
+	return message.replace(/\{(\w+)\}/g, (match, name) => name in params ? String(params[name]) : match);
+}
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const [key, value] of Object.entries(source)) {
+		const current = result[key];
+		result[key] = typeof value === "object" && typeof current === "object" ? deepMerge(current, value) : value;
+	}
+	return result;
+}
+const LT_TOAST_ADAPTER = new InjectionToken("LT_TOAST_ADAPTER");
+var LtToastService = class LtToastService {
+	adapter = inject(LT_TOAST_ADAPTER, { optional: true });
+	show(options) {
+		if (!this.adapter) return false;
+		try {
+			return this.adapter.show(options) !== false;
+		} catch {
+			return false;
+		}
+	}
+	success(title, description) {
+		return this.show({
+			color: "success",
+			description,
+			title
+		});
+	}
+	error(title, description) {
+		return this.show({
+			color: "error",
+			description,
+			title
+		});
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtToastService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtToastService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtToastService,
+	decorators: [{ type: Service }]
+});
+const LT_ERROR_TRANSLATION_OPTIONS = new InjectionToken("LT_ERROR_TRANSLATION_OPTIONS", { factory: () => ({
+	defaultLocale: "de",
+	enabled: true,
+	preload: true
+}) });
+const ERROR_CODE_REGEX = /^#([A-Z_]+_\d+):\s*(.+)$/s;
+const LT_ERROR_TRANSLATION_TIMEOUT_MS = 1e4;
+var LtErrorTranslationService = class LtErrorTranslationService {
+	api = inject(LtApiUrlService);
+	fetch = inject(LT_FETCH);
+	i18n = inject(LtI18nService);
+	toast = inject(LtToastService);
+	options = inject(LT_ERROR_TRANSLATION_OPTIONS);
+	isBrowser = isPlatformBrowser(inject(PLATFORM_ID));
+	translations = signal({}, ...ngDevMode ? [{ debugName: "translations" }] : /* istanbul ignore next */ []);
+	inFlight = /* @__PURE__ */ new Map();
+	currentLocale = computed(() => this.i18n.locale() || this.options.defaultLocale || "de", ...ngDevMode ? [{ debugName: "currentLocale" }] : /* istanbul ignore next */ []);
+	isLoaded = computed(() => !!this.translations()[this.currentLocale()], ...ngDevMode ? [{ debugName: "isLoaded" }] : /* istanbul ignore next */ []);
+	isLoading = signal(false, ...ngDevMode ? [{ debugName: "isLoading" }] : /* istanbul ignore next */ []);
+	async loadTranslations(locale) {
+		if (!this.options.enabled) return;
+		const target = locale || this.currentLocale();
+		if (this.translations()[target]) return;
+		const running = this.inFlight.get(target);
+		if (running) return running;
+		const load = (async () => {
+			this.isLoading.set(true);
+			try {
+				const response = await this.fetch(this.api.buildUrl(`/i18n/errors/${encodeURIComponent(target)}`), {
+					headers: { accept: "application/json" },
+					signal: AbortSignal.timeout(LT_ERROR_TRANSLATION_TIMEOUT_MS)
+				});
+				if (!response.ok) throw new Error(`HTTP ${response.status}`);
+				const body = await response.json();
+				if (body?.errors && typeof body.errors === "object") this.translations.update((current) => ({
+					...current,
+					[target]: body.errors
+				}));
+			} catch (error) {
+				console.warn(`[@lenne.tech/ng-base] Failed to load error translations for ${target}:`, error);
+			} finally {
+				this.inFlight.delete(target);
+				this.isLoading.set(this.inFlight.size > 0);
+			}
+		})();
+		this.inFlight.set(target, load);
+		return load;
+	}
+	parseError(errorOrMessage) {
+		const message = extractLtErrorMessage(errorOrMessage);
+		const match = message.match(ERROR_CODE_REGEX);
+		if (!match) return {
+			code: null,
+			developerMessage: message,
+			translatedMessage: message
+		};
+		const code = match[1] ?? "";
+		const developerMessage = (match[2] ?? "").trim();
+		return {
+			code,
+			developerMessage,
+			translatedMessage: this.translations()[this.currentLocale()]?.[code] || developerMessage
+		};
+	}
+	translateError(errorOrMessage) {
+		return this.parseError(errorOrMessage).translatedMessage;
+	}
+	showErrorToast(errorOrMessage, title) {
+		if (!this.isBrowser) return;
+		const parsed = this.parseError(errorOrMessage);
+		if (!this.toast.show({
+			color: "error",
+			description: parsed.translatedMessage,
+			title: title || this.i18n.t("lt.error.title")
+		})) console.error("[@lenne.tech/ng-base]", parsed.translatedMessage);
+	}
+	static ɵfac = i0.ɵɵngDeclareFactory({
+		minVersion: "12.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtErrorTranslationService,
+		deps: [],
+		target: i0.ɵɵFactoryTarget.Service
+	});
+	static ɵprov = i0.ɵɵngDeclareService({
+		minVersion: "22.0.0",
+		version: "22.2.4",
+		ngImport: i0,
+		type: LtErrorTranslationService
+	});
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.4",
+	ngImport: i0,
+	type: LtErrorTranslationService,
+	decorators: [{ type: Service }]
+});
+function extractLtErrorMessage(errorOrMessage) {
+	if (typeof errorOrMessage === "string") return errorOrMessage;
+	if (errorOrMessage === null || errorOrMessage === void 0) return "";
+	if (typeof errorOrMessage !== "object") return String(errorOrMessage);
+	const source = errorOrMessage;
+	for (const candidate of [
+		source["error"],
+		source["data"],
+		source["body"]
+	]) {
+		const fromBody = messageOf(candidate);
+		if (fromBody) return fromBody;
+	}
+	return messageOf(source) || typeof source["statusText"] === "string" && source["statusText"] || String(errorOrMessage);
+}
+function messageOf(value) {
+	if (typeof value === "string") return value;
+	if (!value || typeof value !== "object") return "";
+	const message = value["message"];
+	if (typeof message === "string") return message;
+	if (Array.isArray(message)) return message.filter((part) => typeof part === "string").join(", ");
+	const nested = value["error"];
+	if (nested && typeof nested === "object") return messageOf(nested);
+	return "";
+}
+const LT_NG_BASE_VERSION = "22.0.1";
+const LT_HYDRATED_FLAG = "__ltNgBaseHydrated";
+function provideLtNgBase(config = {}) {
+	return makeEnvironmentProviders([
+		{
+			provide: LT_RUNTIME_CONFIG,
+			useFactory: () => {
+				const base = mergeLtRuntimeConfig(LT_RUNTIME_CONFIG_DEFAULTS, config.runtime);
+				if (!isPlatformBrowser(inject(PLATFORM_ID))) return mergeLtRuntimeConfig(base, inject(LT_SERVER_RUNTIME_CONFIG, { optional: true })?.public);
+				return mergeLtRuntimeConfig(base, readLtRuntimeConfigFromDocument(inject(DOCUMENT)));
+			}
+		},
+		{
+			provide: LT_ERROR_TRANSLATION_OPTIONS,
+			useFactory: () => mergeLtFeatureOptions({
+				defaultLocale: config.i18n?.defaultLocale ?? "de",
+				enabled: true,
+				preload: true
+			}, config.errorTranslation, inject(LT_RUNTIME_CONFIG).lt.errorTranslation)
+		},
+		{
+			provide: LT_I18N_OPTIONS,
+			useValue: config.i18n ?? {}
+		},
+		provideLtPreHydrationInput(config.preHydrationInput),
+		provideAppInitializer(() => {
+			if (config.configCheck !== false) inject(LtApiUrlService).reportMissing();
+		}),
+		provideAppInitializer(() => {
+			const options = inject(LT_ERROR_TRANSLATION_OPTIONS);
+			if (!isPlatformBrowser(inject(PLATFORM_ID)) || !options.enabled || !options.preload) return;
+			inject(LtErrorTranslationService).loadTranslations();
+		}),
+		provideAppInitializer(() => {
+			if (!isPlatformBrowser(inject(PLATFORM_ID))) return;
+			inject(ApplicationRef).whenStable().then(() => {
+				globalThis[LT_HYDRATED_FLAG] = true;
+				globalThis["__ltNgBaseVersion"] = LT_NG_BASE_VERSION;
+			});
+		})
+	]);
+}
+function tw(strings, ...values) {
+	if (typeof strings === "string") return strings;
+	return strings.reduce((result, part, index) => result + part + (index < values.length ? String(values[index]) : ""), "");
+}
+export { LT_ERROR_TRANSLATION_OPTIONS, LT_FETCH, LT_HYDRATED_FLAG, LT_I18N_ADAPTER, LT_I18N_MESSAGES, LT_I18N_OPTIONS, LT_NG_BASE_VERSION, LT_PRE_HYDRATION_SUBMIT_GUARD_SCRIPT, LT_RUNTIME_CONFIG, LT_RUNTIME_CONFIG_DEFAULTS, LT_RUNTIME_CONFIG_SCRIPT_ID, LT_SERVER_RUNTIME_CONFIG, LT_TOAST_ADAPTER, LtApiUrlService, LtCookieService, LtErrorTranslationService, LtI18nService, LtToastService, collectLtEditedFields, extractLtErrorMessage, injectLtRuntimeConfigScript, isLtAbsoluteUrl, ltArrayBufferToBase64Url, ltBase64UrlToUint8Array, ltCredentialsFetch, ltSha256, mergeLtFeatureOptions, mergeLtRuntimeConfig, parseLtCookies, provideLtNgBase, provideLtPreHydrationInput, readLtRuntimeConfigFromDocument, resetLtWarnOnceState, resolveLtApiBaseUrl, restoreLtField, serializeLtRuntimeConfig, tw, warnLtOnce };
 
-export { AuthGuard, AutoUnsubscribe, BaseModule, CanDeactivateGuard, DateAgoPipe, FullscreenService, LazyLoadDirective, LogoutGuard, MatchHeightDirective, ResizableDirective, SEOService, SafeHtmlPipe, ThemeService, apolloOptionsFactory };
-//# sourceMappingURL=lenne.tech-ng-base.mjs.map
+//# sourceMappingURL=lenne.tech-ng-base.mjs.map