@lenne.tech/ng-base 15.0.0-beta-3 → 16.1.0

package/esm2022/src/functions/extract-files.function.mjs

@@ -0,0 +1,87 @@
+/**
+ * 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;
+    }
+}
+/**
+ * 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);
+}
+/**
+ * Clones a value, recursively extracting
+ */
+export default 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,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXh0cmFjdC1maWxlcy5mdW5jdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLWJhc2Uvc3JjL2Z1bmN0aW9ucy9leHRyYWN0LWZpbGVzLmZ1bmN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUg7O0dBRUc7QUFDSCxNQUFNLGVBQWU7SUFDQTtJQUFvQjtJQUFxQjtJQUE1RCxZQUFtQixHQUFXLEVBQVMsSUFBWSxFQUFTLElBQVk7UUFBckQsUUFBRyxHQUFILEdBQUcsQ0FBUTtRQUFTLFNBQUksR0FBSixJQUFJLENBQVE7UUFBUyxTQUFJLEdBQUosSUFBSSxDQUFRO0lBQUcsQ0FBQztDQUM3RTtBQUVEOztHQUVHO0FBQ0gsU0FBUyxpQkFBaUIsQ0FBQyxLQUFLO0lBQzlCLE9BQU8sQ0FDTCxDQUFDLE9BQU8sSUFBSSxLQUFLLFdBQVcsSUFBSSxLQUFLLFlBQVksSUFBSSxDQUFDO1FBQ3RELENBQUMsT0FBTyxJQUFJLEtBQUssV0FBVyxJQUFJLEtBQUssWUFBWSxJQUFJLENBQUM7UUFDdEQsS0FBSyxZQUFZLGVBQWUsQ0FDakMsQ0FBQztBQUNKLENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sQ0FBQyxPQUFPLFVBQVUsWUFBWSxDQUFDLEtBQUssRUFBRSxJQUFJLEdBQUcsRUFBRSxFQUFFLHFCQUFxQixHQUFHLGlCQUFpQjtJQUM5Rix3RUFBd0U7SUFDeEUsTUFBTSxLQUFLLEdBQUcsSUFBSSxHQUFHLEVBQUUsQ0FBQztJQUV4Qiw4RUFBOEU7SUFDOUUsNkVBQTZFO0lBQzdFLGVBQWU7SUFDZixNQUFNLE1BQU0sR0FBRyxJQUFJLEdBQUcsRUFBRSxDQUFDO0lBRXpCOztPQUVHO0lBQ0gsU0FBUyxPQUFPLENBQUMsWUFBWSxFQUFFLFdBQVcsRUFBRSxRQUFRO1FBQ2xELElBQUksS0FBSyxHQUFHLFlBQVksQ0FBQztRQUV6QixJQUFJLHFCQUFxQixDQUFDLFlBQVksQ0FBQyxFQUFFO1lBQ3ZDLEtBQUssR0FBRyxJQUFJLENBQUM7WUFFYixNQUFNLFNBQVMsR0FBRyxLQUFLLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDO1lBRTFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxZQUFZLEVBQUUsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDO1NBQ2xGO2FBQU07WUFDTCxNQUFNLE1BQU0sR0FDVixLQUFLLENBQUMsT0FBTyxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsT0FBTyxRQUFRLEtBQUssV0FBVyxJQUFJLFlBQVksWUFBWSxRQUFRLENBQUMsQ0FBQztZQUN2RyxNQUFNLFFBQVEsR0FBRyxZQUFZLElBQUksWUFBWSxDQUFDLFdBQVcsS0FBSyxNQUFNLENBQUM7WUFFckUsSUFBSSxNQUFNLElBQUksUUFBUSxFQUFFO2dCQUN0QixNQUFNLFFBQVEsR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDO2dCQUUxQyxJQUFJLFFBQVEsRUFBRTtvQkFDWixLQUFLLEdBQUcsTUFBTSxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsQ0FBQztpQkFDbEM7cUJBQU07b0JBQ0wsS0FBSyxHQUFHLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7b0JBRXpCLE1BQU0sQ0FBQyxHQUFHLENBQUMsWUFBWSxFQUFFLEtBQUssQ0FBQyxDQUFDO2lCQUNqQztnQkFFRCxJQUFJLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsRUFBRTtvQkFDL0IsTUFBTSxVQUFVLEdBQUcsV0FBVyxDQUFDLENBQUMsQ0FBQyxHQUFHLFdBQVcsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7b0JBQ3hELE1BQU0sY0FBYyxHQUFHLElBQUksR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxZQUFZLENBQUMsQ0FBQztvQkFFM0QsSUFBSSxNQUFNLEVBQUU7d0JBQ1YsSUFBSSxLQUFLLEdBQUcsQ0FBQyxDQUFDO3dCQUVkLEtBQUssTUFBTSxJQUFJLElBQUksWUFBbUIsRUFBRTs0QkFDdEMsTUFBTSxTQUFTLEdBQUcsT0FBTyxDQUFDLElBQUksRUFBRSxVQUFVLEdBQUcsS0FBSyxFQUFFLEVBQUUsY0FBYyxDQUFDLENBQUM7NEJBRXRFLElBQUksQ0FBQyxRQUFRLEVBQUU7Z0NBQ2IsS0FBSyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQzs2QkFDdkI7eUJBQ0Y7cUJBQ0Y7eUJBQU07d0JBQ0wsS0FBSyxNQUFNLEdBQUcsSUFBSSxNQUFNLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxFQUFFOzRCQUMzQyxNQUFNLGFBQWEsR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFDLEdBQUcsQ0FBQyxFQUFFLFVBQVUsR0FBRyxHQUFHLEVBQUUsY0FBYyxDQUFDLENBQUM7NEJBRW5GLElBQUksQ0FBQyxRQUFRLEVBQUU7Z0NBQ2IsS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFHLGFBQWEsQ0FBQzs2QkFDNUI7eUJBQ0Y7cUJBQ0Y7aUJBQ0Y7YUFDRjtTQUNGO1FBRUQsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBRUQsT0FBTztRQUNMLEtBQUssRUFBRSxPQUFPLENBQUMsS0FBSyxFQUFFLElBQUksRUFBRSxJQUFJLEdBQUcsRUFBRSxDQUFDO1FBQ3RDLEtBQUs7S0FDTixDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogSW5zcGlyZWQgYnkgSW5wc3BpcmVkIGJ5IGh0dHBzOi8vZ2l0aHViLmNvbS9qYXlkZW5zZXJpYy9leHRyYWN0LWZpbGVzL3JlbGVhc2VzL3RhZy92MTEuMC4wXG4gKi9cblxuLyoqXG4gKiBSZWFjdGl2ZSBuYXRpdmUgZmlsZVxuICovXG5jbGFzcyBSZWFjdE5hdGl2ZUZpbGUge1xuICBjb25zdHJ1Y3RvcihwdWJsaWMgdXJpOiBzdHJpbmcsIHB1YmxpYyBuYW1lOiBzdHJpbmcsIHB1YmxpYyB0eXBlOiBzdHJpbmcpIHt9XG59XG5cbi8qKlxuICogQ2hlY2sgd2hldGhlciB2YWx1ZSBpcyBhbiBleHRyYWN0YWJsZSBmaWxlXG4gKi9cbmZ1bmN0aW9uIGlzRXh0cmFjdGFibGVGaWxlKHZhbHVlKSB7XG4gIHJldHVybiAoXG4gICAgKHR5cGVvZiBGaWxlICE9PSAndW5kZWZpbmVkJyAmJiB2YWx1ZSBpbnN0YW5jZW9mIEZpbGUpIHx8XG4gICAgKHR5cGVvZiBCbG9iICE9PSAndW5kZWZpbmVkJyAmJiB2YWx1ZSBpbnN0YW5jZW9mIEJsb2IpIHx8XG4gICAgdmFsdWUgaW5zdGFuY2VvZiBSZWFjdE5hdGl2ZUZpbGVcbiAgKTtcbn1cblxuLyoqXG4gKiBDbG9uZXMgYSB2YWx1ZSwgcmVjdXJzaXZlbHkgZXh0cmFjdGluZ1xuICovXG5leHBvcnQgZGVmYXVsdCBmdW5jdGlvbiBleHRyYWN0RmlsZXModmFsdWUsIHBhdGggPSAnJywgaXNFeHRyYWN0YWJsZUZpbGVGdW5jID0gaXNFeHRyYWN0YWJsZUZpbGUpIHtcbiAgLy8gTWFwIG9mIGV4dHJhY3RlZCBmaWxlcyBhbmQgdGhlaXIgb2JqZWN0IHBhdGhzIHdpdGhpbiB0aGUgaW5wdXQgdmFsdWUuXG4gIGNvbnN0IGZpbGVzID0gbmV3IE1hcCgpO1xuXG4gIC8vIE1hcCBvZiBhcnJheXMgYW5kIG9iamVjdHMgcmVjdXJzZWQgd2l0aGluIHRoZSBpbnB1dCB2YWx1ZSBhbmQgdGhlaXIgY2xvbmVzLFxuICAvLyBmb3IgcmV1c2luZyBjbG9uZXMgb2YgdmFsdWVzIHRoYXQgYXJlIHJlZmVyZW5jZWQgbXVsdGlwbGUgdGltZXMgd2l0aGluIHRoZVxuICAvLyBpbnB1dCB2YWx1ZS5cbiAgY29uc3QgY2xvbmVzID0gbmV3IE1hcCgpO1xuXG4gIC8qKlxuICAgKiBSZWN1cnNpdmVseSBjbG9uZXMgdGhlIHZhbHVlLCBleHRyYWN0aW5nIGZpbGVzLlxuICAgKi9cbiAgZnVuY3Rpb24gcmVjdXJzZShyZWN1cnNlVmFsdWUsIHJlY3Vyc2VQYXRoLCByZWN1cnNlZCkge1xuICAgIGxldCBjbG9uZSA9IHJlY3Vyc2VWYWx1ZTtcblxuICAgIGlmIChpc0V4dHJhY3RhYmxlRmlsZUZ1bmMocmVjdXJzZVZhbHVlKSkge1xuICAgICAgY2xvbmUgPSBudWxsO1xuXG4gICAgICBjb25zdCBmaWxlUGF0aHMgPSBmaWxlcy5nZXQocmVjdXJzZVZhbHVlKTtcblxuICAgICAgZmlsZVBhdGhzID8gZmlsZVBhdGhzLnB1c2gocmVjdXJzZVBhdGgpIDogZmlsZXMuc2V0KHJlY3Vyc2VWYWx1ZSwgW3JlY3Vyc2VQYXRoXSk7XG4gICAgfSBlbHNlIHtcbiAgICAgIGNvbnN0IGlzTGlzdCA9XG4gICAgICAgIEFycmF5LmlzQXJyYXkocmVjdXJzZVZhbHVlKSB8fCAodHlwZW9mIEZpbGVMaXN0ICE9PSAndW5kZWZpbmVkJyAmJiByZWN1cnNlVmFsdWUgaW5zdGFuY2VvZiBGaWxlTGlzdCk7XG4gICAgICBjb25zdCBpc09iamVjdCA9IHJlY3Vyc2VWYWx1ZSAmJiByZWN1cnNlVmFsdWUuY29uc3RydWN0b3IgPT09IE9iamVjdDtcblxuICAgICAgaWYgKGlzTGlzdCB8fCBpc09iamVjdCkge1xuICAgICAgICBjb25zdCBoYXNDbG9uZSA9IGNsb25lcy5oYXMocmVjdXJzZVZhbHVlKTtcblxuICAgICAgICBpZiAoaGFzQ2xvbmUpIHtcbiAgICAgICAgICBjbG9uZSA9IGNsb25lcy5nZXQocmVjdXJzZVZhbHVlKTtcbiAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICBjbG9uZSA9IGlzTGlzdCA/IFtdIDoge307XG5cbiAgICAgICAgICBjbG9uZXMuc2V0KHJlY3Vyc2VWYWx1ZSwgY2xvbmUpO1xuICAgICAgICB9XG5cbiAgICAgICAgaWYgKCFyZWN1cnNlZC5oYXMocmVjdXJzZVZhbHVlKSkge1xuICAgICAgICAgIGNvbnN0IHBhdGhQcmVmaXggPSByZWN1cnNlUGF0aCA/IGAke3JlY3Vyc2VQYXRofS5gIDogJyc7XG4gICAgICAgICAgY29uc3QgcmVjdXJzZWREZWVwZXIgPSBuZXcgU2V0KHJlY3Vyc2VkKS5hZGQocmVjdXJzZVZhbHVlKTtcblxuICAgICAgICAgIGlmIChpc0xpc3QpIHtcbiAgICAgICAgICAgIGxldCBpbmRleCA9IDA7XG5cbiAgICAgICAgICAgIGZvciAoY29uc3QgaXRlbSBvZiByZWN1cnNlVmFsdWUgYXMgYW55KSB7XG4gICAgICAgICAgICAgIGNvbnN0IGl0ZW1DbG9uZSA9IHJlY3Vyc2UoaXRlbSwgcGF0aFByZWZpeCArIGluZGV4KyssIHJlY3Vyc2VkRGVlcGVyKTtcblxuICAgICAgICAgICAgICBpZiAoIWhhc0Nsb25lKSB7XG4gICAgICAgICAgICAgICAgY2xvbmUucHVzaChpdGVtQ2xvbmUpO1xuICAgICAgICAgICAgICB9XG4gICAgICAgICAgICB9XG4gICAgICAgICAgfSBlbHNlIHtcbiAgICAgICAgICAgIGZvciAoY29uc3Qga2V5IG9mIE9iamVjdC5rZXlzKHJlY3Vyc2VWYWx1ZSkpIHtcbiAgICAgICAgICAgICAgY29uc3QgcHJvcGVydHlDbG9uZSA9IHJlY3Vyc2UocmVjdXJzZVZhbHVlW2tleV0sIHBhdGhQcmVmaXggKyBrZXksIHJlY3Vyc2VkRGVlcGVyKTtcblxuICAgICAgICAgICAgICBpZiAoIWhhc0Nsb25lKSB7XG4gICAgICAgICAgICAgICAgY2xvbmVba2V5XSA9IHByb3BlcnR5Q2xvbmU7XG4gICAgICAgICAgICAgIH1cbiAgICAgICAgICAgIH1cbiAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICAgIH1cbiAgICB9XG5cbiAgICByZXR1cm4gY2xvbmU7XG4gIH1cblxuICByZXR1cm4ge1xuICAgIGNsb25lOiByZWN1cnNlKHZhbHVlLCBwYXRoLCBuZXcgU2V0KCkpLFxuICAgIGZpbGVzLFxuICB9O1xufVxuIl19

package/esm2022/src/guards/auth.guard.mjs

@@ -0,0 +1,92 @@
+import { Inject, Injectable, PLATFORM_ID } from '@angular/core';
+import { Observable } from 'rxjs';
+import { BASE_MODULE_CONFIG } from '@lenne.tech/ng-base/shared';
+import { isPlatformBrowser } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@lenne.tech/ng-base/shared";
+/**
+ * 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: "16.0.0", 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: "16.0.0", ngImport: i0, type: AuthGuard });
+}
+export { AuthGuard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: AuthGuard, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.AuthService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [BASE_MODULE_CONFIG]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC5ndWFyZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25nLWJhc2Uvc3JjL2d1YXJkcy9hdXRoLmd1YXJkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVoRSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQ2xDLE9BQU8sRUFBZSxrQkFBa0IsRUFBb0IsTUFBTSw0QkFBNEIsQ0FBQztBQUMvRixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQzs7OztBQUVwRDs7R0FFRztBQUNILE1BQ2EsU0FBUztJQUtWO0lBQ0E7SUFDNEI7SUFDUDtJQVAvQjs7T0FFRztJQUNILFlBQ1UsTUFBYyxFQUNkLFdBQXdCLEVBQ0ksWUFBOEIsRUFDckMsVUFBa0I7UUFIdkMsV0FBTSxHQUFOLE1BQU0sQ0FBUTtRQUNkLGdCQUFXLEdBQVgsV0FBVyxDQUFhO1FBQ0ksaUJBQVksR0FBWixZQUFZLENBQWtCO1FBQ3JDLGVBQVUsR0FBVixVQUFVLENBQVE7SUFDOUMsQ0FBQztJQUVKOztPQUVHO0lBQ0gsV0FBVyxDQUFDLEtBQTZCLEVBQUUsS0FBMEI7UUFDbkUsSUFBSSxpQkFBaUIsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLEVBQUU7WUFDdEMsT0FBTyxJQUFJLFVBQVUsQ0FBQyxDQUFDLFVBQVUsRUFBRSxFQUFFO2dCQUNuQyxJQUFJLE9BQU8sR0FBRyxLQUFLLENBQUM7Z0JBQ3BCLElBQUksVUFBVSxHQUFHLEtBQUssQ0FBQztnQkFDdkIscUhBQXFIO2dCQUNySCxNQUFNLFFBQVEsR0FBRyxLQUFLLEVBQUUsSUFBSSxFQUFFLFFBQVEsQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLElBQUksRUFBRSxRQUFRLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQztnQkFDdkUsTUFBTSxlQUFlLEdBQUcsS0FBSyxFQUFFLElBQUksRUFBRSxlQUFlO29CQUNsRCxDQUFDLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxlQUFlO29CQUM1QixDQUFDLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxvQkFBb0IsQ0FBQztnQkFDM0MsTUFBTSxlQUFlLEdBQUcsS0FBSyxFQUFFLElBQUksRUFBRSxlQUFlO29CQUNsRCxDQUFDLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxlQUFlO29CQUM1QixDQUFDLENBQUMsSUFBSSxDQUFDLFlBQVksQ0FBQyxvQkFBb0IsQ0FBQztnQkFDM0MsTUFBTSxrQkFBa0IsR0FBRyxLQUFLLEVBQUUsSUFBSSxFQUFFLGtCQUFrQixJQUFJLEtBQUssQ0FBQztnQkFDcEUsTUFBTSxXQUFXLEdBQUcsa0JBQWtCO29CQUNwQyxDQUFDLENBQUMsRUFBRTtvQkFDSixDQUFDLENBQUM7d0JBQ0UsV0FBVyxFQUFFOzRCQUNYLFdBQVcsRUFBRSxLQUFLLENBQUMsY0FBYyxDQUFDLENBQUMsR0FBRzt5QkFDdkM7cUJBQ0YsQ0FBQztnQkFFTixJQUFJLElBQUksQ0FBQyxXQUFXLENBQUMsS0FBSyxJQUFJLENBQUMsUUFBUSxFQUFFO29CQUN2QyxJQUFJLEtBQUssQ0FBQyxJQUFJLEVBQUUsS0FBSyxFQUFFO3dCQUNyQixNQUFNLElBQUksR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDLFdBQVcsQ0FBQzt3QkFDMUMsT0FBTyxHQUFHLENBQUMsQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsUUFBUSxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7d0JBRXhFLElBQUksQ0FBQyxPQUFPLElBQUksZUFBZSxFQUFFOzRCQUMvQixJQUFJLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDLGVBQWUsQ0FBQyxFQUFFLFdBQVcsQ0FBQyxDQUFDOzRCQUNyRCxVQUFVLEdBQUcsSUFBSSxDQUFDO3lCQUNuQjtxQkFDRjt5QkFBTTt3QkFDTCxPQUFPLEdBQUcsSUFBSSxDQUFDO3FCQUNoQjtpQkFDRjtxQkFBTSxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFLLElBQUksUUFBUSxFQUFFO29CQUM5QyxPQUFPLEdBQUcsSUFBSSxDQUFDO2lCQUNoQjtnQkFFRCxJQUFJLENBQUMsT0FBTyxJQUFJLGVBQWUsSUFBSSxDQUFDLFVBQVUsRUFBRTtvQkFDOUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxRQUFRLENBQUMsQ0FBQyxlQUFlLENBQUMsRUFBRSxXQUFXLENBQUMsQ0FBQztpQkFDdEQ7Z0JBRUQsVUFBVSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztnQkFDekIsVUFBVSxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ3hCLENBQUMsQ0FBQyxDQUFDO1NBQ0o7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxnQkFBZ0IsQ0FBQyxLQUE2QixFQUFFLEtBQTBCO1FBQ3hFLE9BQU8sSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFLLEVBQUUsS0FBSyxDQUFDLENBQUM7SUFDeEMsQ0FBQzt1R0FuRVUsU0FBUyxtRUFPVixrQkFBa0IsYUFDbEIsV0FBVzsyR0FSVixTQUFTOztTQUFULFNBQVM7MkZBQVQsU0FBUztrQkFEckIsVUFBVTs7MEJBUU4sTUFBTTsyQkFBQyxrQkFBa0I7OzBCQUN6QixNQUFNOzJCQUFDLFdBQVciLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3QsIEluamVjdGFibGUsIFBMQVRGT1JNX0lEIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LCBSb3V0ZXIsIFJvdXRlclN0YXRlU25hcHNob3QgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgQXV0aFNlcnZpY2UsIEJBU0VfTU9EVUxFX0NPTkZJRywgQmFzZU1vZHVsZUNvbmZpZyB9IGZyb20gJ0BsZW5uZS50ZWNoL25nLWJhc2Uvc2hhcmVkJztcbmltcG9ydCB7IGlzUGxhdGZvcm1Ccm93c2VyIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcblxuLyoqXG4gKiBBdXRoZW50aWNhdGlvbiBndWFyZFxuICovXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgQXV0aEd1YXJkIHtcbiAgLyoqXG4gICAqIEltcG9ydHNcbiAgICovXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgcm91dGVyOiBSb3V0ZXIsXG4gICAgcHJpdmF0ZSBhdXRoU2VydmljZTogQXV0aFNlcnZpY2UsXG4gICAgQEluamVjdChCQVNFX01PRFVMRV9DT05GSUcpIHByaXZhdGUgbW9kdWxlQ29uZmlnOiBCYXNlTW9kdWxlQ29uZmlnLFxuICAgIEBJbmplY3QoUExBVEZPUk1fSUQpIHByaXZhdGUgcGxhdGZvcm1JZDogb2JqZWN0XG4gICkge31cblxuICAvKipcbiAgICogQ2FuIGFjdGl2YXRlIG1haW4gcm91dGVcbiAgICovXG4gIGNhbkFjdGl2YXRlKHJvdXRlOiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LCBzdGF0ZTogUm91dGVyU3RhdGVTbmFwc2hvdCk6IE9ic2VydmFibGU8Ym9vbGVhbj4ge1xuICAgIGlmIChpc1BsYXRmb3JtQnJvd3Nlcih0aGlzLnBsYXRmb3JtSWQpKSB7XG4gICAgICByZXR1cm4gbmV3IE9ic2VydmFibGUoKHN1YnNjcmliZXIpID0+IHtcbiAgICAgICAgbGV0IGFsbG93ZWQgPSBmYWxzZTtcbiAgICAgICAgbGV0IHJlZGlyZWN0ZWQgPSBmYWxzZTtcbiAgICAgICAgLyogSWYgdGhlIHVzZXIgaXMgbG9nZ2VkIGluIGFuZCB0aGUgcm91dGUgaXMgbm90IG1hcmtlZCBhcyBvcHBvc2l0ZSwgdGhlbiB0aGUgdXNlciBpcyBhbGxvd2VkIHRvIGFjY2VzcyB0aGUgcm91dGUuICovXG4gICAgICAgIGNvbnN0IG9wcG9zaXRlID0gcm91dGU/LmRhdGE/Lm9wcG9zaXRlID8gcm91dGU/LmRhdGE/Lm9wcG9zaXRlIDogZmFsc2U7XG4gICAgICAgIGNvbnN0IHJlZGlyZWN0QXV0aFVybCA9IHJvdXRlPy5kYXRhPy5yZWRpcmVjdEF1dGhVcmxcbiAgICAgICAgICA/IHJvdXRlLmRhdGEucmVkaXJlY3RBdXRoVXJsXG4gICAgICAgICAgOiB0aGlzLm1vZHVsZUNvbmZpZy5hdXRoR3VhcmRSZWRpcmVjdFVybDtcbiAgICAgICAgY29uc3QgcmVkaXJlY3RSb2xlVXJsID0gcm91dGU/LmRhdGE/LnJlZGlyZWN0Um9sZVVybFxuICAgICAgICAgID8gcm91dGUuZGF0YS5yZWRpcmVjdFJvbGVVcmxcbiAgICAgICAgICA6IHRoaXMubW9kdWxlQ29uZmlnLmF1dGhHdWFyZFJlZGlyZWN0VXJsO1xuICAgICAgICBjb25zdCBkaXNhYmxlUXVlcnlQYXJhbXMgPSByb3V0ZT8uZGF0YT8uZGlzYWJsZVF1ZXJ5UGFyYW1zID8/IGZhbHNlO1xuICAgICAgICBjb25zdCBxdWVyeVBhcmFtcyA9IGRpc2FibGVRdWVyeVBhcmFtc1xuICAgICAgICAgID8ge31cbiAgICAgICAgICA6IHtcbiAgICAgICAgICAgICAgcXVlcnlQYXJhbXM6IHtcbiAgICAgICAgICAgICAgICByZWRpcmVjdFVybDogcm91dGVbJ19yb3V0ZXJTdGF0ZSddLnVybCxcbiAgICAgICAgICAgICAgfSxcbiAgICAgICAgICAgIH07XG5cbiAgICAgICAgaWYgKHRoaXMuYXV0aFNlcnZpY2UudG9rZW4gJiYgIW9wcG9zaXRlKSB7XG4gICAgICAgICAgaWYgKHJvdXRlLmRhdGE/LnJvbGVzKSB7XG4gICAgICAgICAgICBjb25zdCB1c2VyID0gdGhpcy5hdXRoU2VydmljZS5jdXJyZW50VXNlcjtcbiAgICAgICAgICAgIGFsbG93ZWQgPSAhIXJvdXRlLmRhdGEucm9sZXMuZmluZCgocm9sZSkgPT4gdXNlci5yb2xlcz8uaW5jbHVkZXMocm9sZSkpO1xuXG4gICAgICAgICAgICBpZiAoIWFsbG93ZWQgJiYgcmVkaXJlY3RSb2xlVXJsKSB7XG4gICAgICAgICAgICAgIHRoaXMucm91dGVyLm5hdmlnYXRlKFtyZWRpcmVjdFJvbGVVcmxdLCBxdWVyeVBhcmFtcyk7XG4gICAgICAgICAgICAgIHJlZGlyZWN0ZWQgPSB0cnVlO1xuICAgICAgICAgICAgfVxuICAgICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgICBhbGxvd2VkID0gdHJ1ZTtcbiAgICAgICAgICB9XG4gICAgICAgIH0gZWxzZSBpZiAoIXRoaXMuYXV0aFNlcnZpY2UudG9rZW4gJiYgb3Bwb3NpdGUpIHtcbiAgICAgICAgICBhbGxvd2VkID0gdHJ1ZTtcbiAgICAgICAgfVxuXG4gICAgICAgIGlmICghYWxsb3dlZCAmJiByZWRpcmVjdEF1dGhVcmwgJiYgIXJlZGlyZWN0ZWQpIHtcbiAgICAgICAgICB0aGlzLnJvdXRlci5uYXZpZ2F0ZShbcmVkaXJlY3RBdXRoVXJsXSwgcXVlcnlQYXJhbXMpO1xuICAgICAgICB9XG5cbiAgICAgICAgc3Vic2NyaWJlci5uZXh0KGFsbG93ZWQpO1xuICAgICAgICBzdWJzY3JpYmVyLmNvbXBsZXRlKCk7XG4gICAgICB9KTtcbiAgICB9XG4gIH1cblxuICAvKipcbiAgICogQ2FuIGFjdGl2YXRlIGNoaWxkIHJvdXRlXG4gICAqL1xuICBjYW5BY3RpdmF0ZUNoaWxkKHJvdXRlOiBBY3RpdmF0ZWRSb3V0ZVNuYXBzaG90LCBzdGF0ZTogUm91dGVyU3RhdGVTbmFwc2hvdCk6IE9ic2VydmFibGU8Ym9vbGVhbj4ge1xuICAgIHJldHVybiB0aGlzLmNhbkFjdGl2YXRlKHJvdXRlLCBzdGF0ZSk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/src/guards/can-deactivate.guard.mjs

@@ -0,0 +1,17 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * 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: "16.0.0", ngImport: i0, type: CanDeactivateGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: CanDeactivateGuard });
+}
+export { CanDeactivateGuard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: CanDeactivateGuard, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FuLWRlYWN0aXZhdGUuZ3VhcmQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1iYXNlL3NyYy9ndWFyZHMvY2FuLWRlYWN0aXZhdGUuZ3VhcmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFJM0M7O0dBRUc7QUFDSCxNQUNhLGtCQUFrQjtJQUM3QixhQUFhLENBQUMsU0FBa0M7UUFDOUMsT0FBTyxTQUFTLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsYUFBYSxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztJQUNwRSxDQUFDO3VHQUhVLGtCQUFrQjsyR0FBbEIsa0JBQWtCOztTQUFsQixrQkFBa0I7MkZBQWxCLGtCQUFrQjtrQkFEOUIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgSUNhbkNvbXBvbmVudERlYWN0aXZhdGUgfSBmcm9tICdAbGVubmUudGVjaC9uZy1iYXNlL3NoYXJlZCc7XG5cbi8qKlxuICogR3VhcmQgdG8gY2hlY2sgaWYgYSBjb21wb25lbnQgY2FuIGJlIGRlYWN0aXZhdGVkXG4gKi9cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBDYW5EZWFjdGl2YXRlR3VhcmQge1xuICBjYW5EZWFjdGl2YXRlKGNvbXBvbmVudDogSUNhbkNvbXBvbmVudERlYWN0aXZhdGUpIHtcbiAgICByZXR1cm4gY29tcG9uZW50LmNhbkRlYWN0aXZhdGUgPyBjb21wb25lbnQuY2FuRGVhY3RpdmF0ZSgpIDogdHJ1ZTtcbiAgfVxufVxuIl19

package/esm2022/src/guards/logout.guard.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@lenne.tech/ng-base/shared";
+/**
+ * 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: "16.0.0", ngImport: i0, type: LogoutGuard, deps: [{ token: i1.Router }, { token: i2.AuthService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LogoutGuard });
+}
+export { LogoutGuard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: LogoutGuard, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i2.AuthService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/pipes/date-ago.pipe.mjs

@@ -0,0 +1,64 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+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: "16.0.0", ngImport: i0, type: DateAgoPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: DateAgoPipe, name: "dateAgo" });
+}
+export { DateAgoPipe };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: DateAgoPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'dateAgo',
+                    pure: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/pipes/safe-html.pipe.mjs

@@ -0,0 +1,23 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+/**
+ * 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: "16.0.0", ngImport: i0, type: SafeHtmlPipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: SafeHtmlPipe, name: "ltSafeHtml" });
+}
+export { SafeHtmlPipe };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SafeHtmlPipe, decorators: [{
+            type: Pipe,
+            args: [{ name: 'ltSafeHtml' }]
+        }], ctorParameters: function () { return [{ type: i1.DomSanitizer }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2FmZS1odG1sLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1iYXNlL3NyYy9waXBlcy9zYWZlLWh0bWwucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7O0FBRXBEOztHQUVHO0FBQ0gsTUFDYSxZQUFZO0lBQ0g7SUFBcEIsWUFBb0IsU0FBdUI7UUFBdkIsY0FBUyxHQUFULFNBQVMsQ0FBYztJQUFHLENBQUM7SUFFL0MsU0FBUyxDQUFDLEtBQUs7UUFDYixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsdUJBQXVCLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDdkQsQ0FBQzt1R0FMVSxZQUFZO3FHQUFaLFlBQVk7O1NBQVosWUFBWTsyRkFBWixZQUFZO2tCQUR4QixJQUFJO21CQUFDLEVBQUUsSUFBSSxFQUFFLFlBQVksRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERvbVNhbml0aXplciB9IGZyb20gJ0Bhbmd1bGFyL3BsYXRmb3JtLWJyb3dzZXInO1xuaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIERlY2xhcmF0ZSBodG1sIGFzIHNhZmVcbiAqL1xuQFBpcGUoeyBuYW1lOiAnbHRTYWZlSHRtbCcgfSlcbmV4cG9ydCBjbGFzcyBTYWZlSHRtbFBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcbiAgY29uc3RydWN0b3IocHJpdmF0ZSBzYW5pdGl6ZWQ6IERvbVNhbml0aXplcikge31cblxuICB0cmFuc2Zvcm0odmFsdWUpIHtcbiAgICByZXR1cm4gdGhpcy5zYW5pdGl6ZWQuYnlwYXNzU2VjdXJpdHlUcnVzdEh0bWwodmFsdWUpO1xuICB9XG59XG4iXX0=

package/esm2022/src/services/fullscreen.service.mjs

@@ -0,0 +1,52 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * 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: "16.0.0", ngImport: i0, type: FullscreenService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FullscreenService, providedIn: 'root' });
+}
+export { FullscreenService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: FullscreenService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnVsbHNjcmVlbi5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctYmFzZS9zcmMvc2VydmljZXMvZnVsbHNjcmVlbi5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLGVBQWUsRUFBYyxNQUFNLE1BQU0sQ0FBQzs7QUFFbkQ7O0dBRUc7QUFDSCxNQUdhLGlCQUFpQjtJQUNwQixtQkFBbUIsR0FBNkIsSUFBSSxlQUFlLENBQVUsS0FBSyxDQUFDLENBQUM7SUFFNUY7UUFDRSxJQUFJLENBQUMsdUJBQXVCLEVBQUUsQ0FBQztJQUNqQyxDQUFDO0lBRUQsSUFBSSxlQUFlO1FBQ2pCLE9BQU8sSUFBSSxDQUFDLG1CQUFtQixDQUFDLEtBQUssQ0FBQztJQUN4QyxDQUFDO0lBRUQsSUFBSSwyQkFBMkI7UUFDN0IsT0FBTyxJQUFJLENBQUMsbUJBQW1CLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDakQsQ0FBQztJQUVNLGdCQUFnQjtRQUNyQixNQUFNLElBQUksR0FBRyxRQUFRLENBQUMsZUFBZSxDQUFDO1FBQ3RDLElBQUksQ0FBQyxJQUFJLENBQUMsbUJBQW1CLENBQUMsS0FBSyxFQUFFO1lBQ25DLElBQUksQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO1lBQ3pCLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7U0FDckM7YUFBTTtZQUNMLFFBQVEsQ0FBQyxjQUFjLEVBQUUsQ0FBQztZQUMxQixJQUFJLENBQUMsbUJBQW1CLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1NBQ3RDO0lBQ0gsQ0FBQztJQUVEOztPQUVHO0lBQ0ssdUJBQXVCO1FBQzdCLFFBQVEsQ0FBQyxnQkFBZ0IsQ0FBQyxrQkFBa0IsRUFBRSxHQUFHLEVBQUU7WUFDakQsSUFBSSxRQUFRLENBQUMsaUJBQWlCLEVBQUU7Z0JBQzlCLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7YUFDckM7aUJBQU07Z0JBQ0wsSUFBSSxDQUFDLG1CQUFtQixDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQzthQUN0QztRQUNILENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQzt1R0FyQ1UsaUJBQWlCOzJHQUFqQixpQkFBaUIsY0FGaEIsTUFBTTs7U0FFUCxpQkFBaUI7MkZBQWpCLGlCQUFpQjtrQkFIN0IsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBCZWhhdmlvclN1YmplY3QsIE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcblxuLyoqXG4gKiBGdWxsc2NyZWVuIHNlcnZpY2VcbiAqL1xuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCcsXG59KVxuZXhwb3J0IGNsYXNzIEZ1bGxzY3JlZW5TZXJ2aWNlIHtcbiAgcHJpdmF0ZSBfaXNGdWxsc2NyZWVuQWN0aXZlOiBCZWhhdmlvclN1YmplY3Q8Ym9vbGVhbj4gPSBuZXcgQmVoYXZpb3JTdWJqZWN0PGJvb2xlYW4+KGZhbHNlKTtcblxuICBjb25zdHJ1Y3RvcigpIHtcbiAgICB0aGlzLmxpc3RlblRvRnVsbHNjcmVlbkV2ZW50KCk7XG4gIH1cblxuICBnZXQgZnVsbHNjcmVlblN0YXRlKCk6IGJvb2xlYW4ge1xuICAgIHJldHVybiB0aGlzLl9pc0Z1bGxzY3JlZW5BY3RpdmUudmFsdWU7XG4gIH1cblxuICBnZXQgZnVsbHNjcmVlblN0YXRlQXNPYnNlcnZhYmxlKCk6IE9ic2VydmFibGU8Ym9vbGVhbj4ge1xuICAgIHJldHVybiB0aGlzLl9pc0Z1bGxzY3JlZW5BY3RpdmUuYXNPYnNlcnZhYmxlKCk7XG4gIH1cblxuICBwdWJsaWMgdG9nZ2xlRnVsbHNjcmVlbigpIHtcbiAgICBjb25zdCBlbGVtID0gZG9jdW1lbnQuZG9jdW1lbnRFbGVtZW50O1xuICAgIGlmICghdGhpcy5faXNGdWxsc2NyZWVuQWN0aXZlLnZhbHVlKSB7XG4gICAgICBlbGVtLnJlcXVlc3RGdWxsc2NyZWVuKCk7XG4gICAgICB0aGlzLl9pc0Z1bGxzY3JlZW5BY3RpdmUubmV4dCh0cnVlKTtcbiAgICB9IGVsc2Uge1xuICAgICAgZG9jdW1lbnQuZXhpdEZ1bGxzY3JlZW4oKTtcbiAgICAgIHRoaXMuX2lzRnVsbHNjcmVlbkFjdGl2ZS5uZXh0KGZhbHNlKTtcbiAgICB9XG4gIH1cblxuICAvKipcbiAgICogRXZlbnQgTGlzdGVuZXIgZm9yIGZ1bGxzY3JlZW4gdG9nZ2xlXG4gICAqL1xuICBwcml2YXRlIGxpc3RlblRvRnVsbHNjcmVlbkV2ZW50KCkge1xuICAgIGRvY3VtZW50LmFkZEV2ZW50TGlzdGVuZXIoJ2Z1bGxzY3JlZW5jaGFuZ2UnLCAoKSA9PiB7XG4gICAgICBpZiAoZG9jdW1lbnQuZnVsbHNjcmVlbkVsZW1lbnQpIHtcbiAgICAgICAgdGhpcy5faXNGdWxsc2NyZWVuQWN0aXZlLm5leHQodHJ1ZSk7XG4gICAgICB9IGVsc2Uge1xuICAgICAgICB0aGlzLl9pc0Z1bGxzY3JlZW5BY3RpdmUubmV4dChmYWxzZSk7XG4gICAgICB9XG4gICAgfSk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/src/services/seo.service.mjs

@@ -0,0 +1,100 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+/**
+ * SEO service for setting HTML meta data
+ */
+class SEOService {
+    titleService;
+    metaTagService;
+    constructor(titleService, metaTagService) {
+        this.titleService = titleService;
+        this.metaTagService = metaTagService;
+    }
+    initPageForSEO(input) {
+        this.setGeneralData(input);
+        this.setTwitterData(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 });
+        this.metaTagService.updateTag({
+            property: 'twitter:url',
+            content: data.url ? data.url : window?.location.href,
+        });
+        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',
+        });
+        this.metaTagService.updateTag({
+            property: 'og:url',
+            content: data.url ? data.url : window?.location.href,
+        });
+        if (data.image) {
+            this.metaTagService.updateTag({
+                property: 'og:image',
+                content: data.image,
+            });
+        }
+    }
+    /**
+     * Set page keywords
+     *
+     * @param keywords
+     * @private
+     */
+    setPageKeywords(keywords) {
+        this.metaTagService.updateTag({ name: 'keywords', content: keywords });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SEOService, deps: [{ token: i1.Title }, { token: i1.Meta }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SEOService, providedIn: 'root' });
+}
+export { SEOService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: SEOService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Title }, { type: i1.Meta }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/services/theme.service.mjs

@@ -0,0 +1,45 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@lenne.tech/ng-base/shared";
+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: "16.0.0", ngImport: i0, type: ThemeService, deps: [{ token: i1.StorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ThemeService, providedIn: 'root' });
+}
+export { ThemeService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: ThemeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.StorageService }]; } });
+//# sourceMappingURL=data:application/json;base64,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