@lenne.tech/ng-base 15.0.0-beta-2 → 16.0.0

package/esm2022/src/factories/apollo-options.factory.mjs

@@ -0,0 +1,108 @@
+import { ApolloLink, concat, fromPromise, split } from '@apollo/client/core';
+import { InMemoryCache } from '@apollo/client/cache';
+import { getMainDefinition } from '@apollo/client/utilities';
+import { createRestartableClient, } from '@lenne.tech/ng-base/shared';
+import { GraphQLWsLink } from '@apollo/client/link/subscriptions';
+import extractFiles from '../functions/extract-files.function';
+import { firstValueFrom } from 'rxjs';
+import { onError } from '@apollo/client/link/error';
+/**
+ * Factory for apollo-angular options
+ */
+export 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',
+            },
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apollo-options.factory.js","sourceRoot":"","sources":["../../../../../projects/ng-base/src/factories/apollo-options.factory.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpLink } from 'apollo-angular/http';\nimport { ApolloLink, concat, fromPromise, split } from '@apollo/client/core';\nimport { InMemoryCache } from '@apollo/client/cache';\nimport { getMainDefinition } from '@apollo/client/utilities';\nimport {\n  AuthService,\n  BaseModuleConfig,\n  createRestartableClient,\n  RestartableClient,\n  WsService,\n} from '@lenne.tech/ng-base/shared';\nimport { GraphQLWsLink } from '@apollo/client/link/subscriptions';\nimport extractFiles from '../functions/extract-files.function';\nimport { firstValueFrom } from 'rxjs';\nimport { onError } from '@apollo/client/link/error';\n\n/**\n * Factory for apollo-angular options\n */\nexport function apolloOptionsFactory(\n  baseModuleConfig: BaseModuleConfig,\n  httpLink: HttpLink,\n  authService: AuthService,\n  wsService: WsService\n) {\n  const links = [];\n\n  const http = httpLink.create({\n    uri: baseModuleConfig.apiUrl,\n    extractFiles,\n  });\n\n  const authMiddleware = new ApolloLink((operation, forward) => {\n    const headers: any = {};\n    const operationName = (operation.query.definitions[0] as any)?.selectionSet?.selections[0]?.name?.value;\n\n    if (localStorage) {\n      let token: string;\n\n      if (operationName === 'refreshToken') {\n        token = authService.refreshToken || null;\n      } else {\n        token = authService.token || null;\n      }\n\n      if (token) {\n        headers.Authorization = 'Bearer ' + token;\n      }\n\n      operation.setContext(() => ({ headers }));\n    }\n    return forward(operation);\n  });\n\n  const errorLink = onError(({ graphQLErrors, networkError, operation, forward }) => {\n    if (graphQLErrors) {\n      for (const err of graphQLErrors) {\n        switch (err.extensions.code) {\n          case 'UNAUTHENTICATED': {\n            if (\n              err.message !== 'Expired refresh token' &&\n              err.message !== 'Expired token' &&\n              err.message !== 'Invalid token'\n            ) {\n              return;\n            }\n\n            if (err.message === 'Expired refresh token' || err.message === 'Invalid token') {\n              authService.clearSession();\n              return;\n            }\n\n            return fromPromise(firstValueFrom(authService.requestNewToken()))\n              .filter((value) => Boolean(value))\n              .flatMap((response) => {\n                const oldHeaders = operation.getContext().headers;\n                // modify the operation context with a new token\n                operation.setContext({\n                  headers: {\n                    ...oldHeaders,\n                    Authorization: `Bearer ${response.token}`,\n                  },\n                });\n\n                // retry the request, returning the new observable\n                return forward(operation);\n              });\n          }\n        }\n      }\n    }\n  });\n\n  if (baseModuleConfig.logging) {\n    console.log(baseModuleConfig);\n  }\n\n  if (baseModuleConfig.wsUrl) {\n    const wsLink = new GraphQLWsLink(\n      createRestartableClient({\n        url: baseModuleConfig.wsUrl,\n        connectionParams: () => {\n          return {\n            Authorization: authService.token ? 'Bearer ' + authService.token : undefined,\n          };\n        },\n      })\n    );\n\n    // Set client for reconnection on logout/login\n    wsService.client = wsLink.client as RestartableClient;\n\n    // using the ability to split links, you can send data to each link\n    // depending on what kind of operation is being sent\n    links.push(\n      split(\n        // split based on operation type\n        ({ query }) => {\n          // @ts-ignore\n          const { kind, operation } = getMainDefinition(query);\n          return kind === 'OperationDefinition' && operation === 'subscription';\n        },\n        wsLink,\n        concat(concat(authMiddleware, errorLink), http)\n      )\n    );\n  } else {\n    links.push(authMiddleware);\n    links.push(errorLink);\n    links.push(http);\n  }\n\n  return {\n    link: ApolloLink.from(links),\n    cache: new InMemoryCache(),\n    defaultOptions: {\n      query: {\n        fetchPolicy: 'network-only',\n      },\n    },\n  };\n}\n"]}

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,84 @@
+import { Inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import { BASE_MODULE_CONFIG } from '@lenne.tech/ng-base/shared';
+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;
+    /**
+     * Imports
+     */
+    constructor(router, authService, moduleConfig) {
+        this.router = router;
+        this.authService = authService;
+        this.moduleConfig = moduleConfig;
+    }
+    /**
+     * Can activate main route
+     */
+    canActivate(route, state) {
+        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 }], 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]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9nb3V0Lmd1YXJkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctYmFzZS9zcmMvZ3VhcmRzL2xvZ291dC5ndWFyZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxNQUFNLENBQUM7Ozs7QUFHbEM7O0dBRUc7QUFDSCxNQUNhLFdBQVc7SUFDRjtJQUF3QjtJQUE1QyxZQUFvQixNQUFjLEVBQVUsV0FBd0I7UUFBaEQsV0FBTSxHQUFOLE1BQU0sQ0FBUTtRQUFVLGdCQUFXLEdBQVgsV0FBVyxDQUFhO0lBQUcsQ0FBQztJQUV4RSxXQUFXLENBQUMsS0FBNkIsRUFBRSxLQUEwQjtRQUNuRSxPQUFPLElBQUksVUFBVSxDQUFDLENBQUMsVUFBVSxFQUFFLEVBQUU7WUFDbkMsSUFBSSxJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssRUFBRTtnQkFDMUIsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLEVBQUUsQ0FBQzthQUMzQjtZQUVELFVBQVUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDdEIsVUFBVSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ3hCLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVELGdCQUFnQixDQUFDLEtBQTZCLEVBQUUsS0FBMEI7UUFDeEUsT0FBTyxJQUFJLENBQUMsV0FBVyxDQUFDLEtBQUssRUFBRSxLQUFLLENBQUMsQ0FBQztJQUN4QyxDQUFDO3VHQWhCVSxXQUFXOzJHQUFYLFdBQVc7O1NBQVgsV0FBVzsyRkFBWCxXQUFXO2tCQUR2QixVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQWN0aXZhdGVkUm91dGVTbmFwc2hvdCwgUm91dGVyLCBSb3V0ZXJTdGF0ZVNuYXBzaG90IH0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCB7IE9ic2VydmFibGUgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IEF1dGhTZXJ2aWNlIH0gZnJvbSAnQGxlbm5lLnRlY2gvbmctYmFzZS9zaGFyZWQnO1xuXG4vKipcbiAqIExvZ291dCBndWFyZFxuICovXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgTG9nb3V0R3VhcmQge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJvdXRlcjogUm91dGVyLCBwcml2YXRlIGF1dGhTZXJ2aWNlOiBBdXRoU2VydmljZSkge31cblxuICBjYW5BY3RpdmF0ZShyb3V0ZTogQWN0aXZhdGVkUm91dGVTbmFwc2hvdCwgc3RhdGU6IFJvdXRlclN0YXRlU25hcHNob3QpOiBPYnNlcnZhYmxlPGJvb2xlYW4+IHtcbiAgICByZXR1cm4gbmV3IE9ic2VydmFibGUoKHN1YnNjcmliZXIpID0+IHtcbiAgICAgIGlmICh0aGlzLmF1dGhTZXJ2aWNlLnRva2VuKSB7XG4gICAgICAgIHRoaXMuYXV0aFNlcnZpY2UubG9nb3V0KCk7XG4gICAgICB9XG5cbiAgICAgIHN1YnNjcmliZXIubmV4dCh0cnVlKTtcbiAgICAgIHN1YnNjcmliZXIuY29tcGxldGUoKTtcbiAgICB9KTtcbiAgfVxuXG4gIGNhbkFjdGl2YXRlQ2hpbGQocm91dGU6IEFjdGl2YXRlZFJvdXRlU25hcHNob3QsIHN0YXRlOiBSb3V0ZXJTdGF0ZVNuYXBzaG90KTogT2JzZXJ2YWJsZTxib29sZWFuPiB7XG4gICAgcmV0dXJuIHRoaXMuY2FuQWN0aXZhdGUocm91dGUsIHN0YXRlKTtcbiAgfVxufVxuIl19

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,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