@alfresco/adf-core 8.1.0-16295248176 → 8.1.0-16320806191

package/esm2022/lib/common/services/cookie.service.mjs

@@ -0,0 +1,82 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CookieService {
+    constructor() {
+        this.cookieEnabled = false;
+        // for certain scenarios Chrome may say 'true' but have cookies still disabled
+        if (navigator.cookieEnabled === false) {
+            this.cookieEnabled = false;
+        }
+        this.setItem('test-cookie', 'test');
+        this.cookieEnabled = document.cookie.indexOf('test-cookie') >= 0;
+        this.deleteCookie('test-cookie');
+    }
+    /**
+     * Checks if cookies are enabled.
+     *
+     * @returns True if enabled, false otherwise
+     */
+    isEnabled() {
+        return this.cookieEnabled;
+    }
+    /**
+     * Retrieves a cookie by its key.
+     *
+     * @param key Key to identify the cookie
+     * @returns The cookie data or null if it is not found
+     */
+    getItem(key) {
+        const regexp = new RegExp('(?:' + key + '|;\\s*' + key + ')=(.*?)(?:;|$)', 'g');
+        const result = regexp.exec(document.cookie);
+        return result === null ? null : result[1];
+    }
+    /**
+     * Sets a cookie.
+     *
+     * @param key Key to identify the cookie
+     * @param data Data value to set for the cookie
+     * @param expiration Expiration date of the data
+     * @param path "Pathname" to store the cookie
+     */
+    setItem(key, data, expiration = null, path = null) {
+        document.cookie = `${key}=${data}` + (expiration ? ';expires=' + expiration.toUTCString() : '') + (path ? `;path=${path}` : ';path=/');
+    }
+    /**
+     * Delete a cookie Key.
+     *
+     * @param key Key to identify the cookie
+     * @param path "Pathname" to store the cookie
+     */
+    deleteCookie(key, path = null) {
+        document.cookie = key + '=; expires=Thu, 01 Jan 1970 00:00:01 GMT;' + (path ? `;path=${path}` : ';path=/');
+    }
+    /** Placeholder for testing purposes - do not use. */
+    clear() {
+        /* placeholder for testing purposes */
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CookieService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CookieService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CookieService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/common/services/download.service.mjs

@@ -0,0 +1,102 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DownloadService {
+    constructor() {
+        this.saveData = (() => {
+            const a = document.createElement('a');
+            document.body.appendChild(a);
+            a.style.display = 'none';
+            return (fileData, format, fileName) => {
+                let blob = null;
+                if (format === 'blob' || format === 'data') {
+                    blob = new Blob([fileData], { type: 'octet/stream' });
+                }
+                if (format === 'object' || format === 'json') {
+                    const json = JSON.stringify(fileData);
+                    blob = new Blob([json], { type: 'octet/stream' });
+                }
+                if (blob) {
+                    if (window.navigator?.['msSaveOrOpenBlob']) {
+                        window.navigator['msSaveOrOpenBlob'](blob, fileName);
+                    }
+                    else {
+                        const url = window.URL.createObjectURL(blob);
+                        a.href = url;
+                        a.download = fileName;
+                        a.click();
+                        window.URL.revokeObjectURL(url);
+                    }
+                }
+            };
+        })();
+    }
+    /**
+     * Invokes content download for a Blob with a file name.
+     *
+     * @param blob Content to download.
+     * @param fileName Name of the resulting file.
+     */
+    downloadBlob(blob, fileName) {
+        this.saveData(blob, 'blob', fileName);
+    }
+    /**
+     * Invokes content download for a data array with a file name.
+     *
+     * @param data Data to download.
+     * @param fileName Name of the resulting file.
+     */
+    downloadData(data, fileName) {
+        this.saveData(data, 'data', fileName);
+    }
+    /**
+     * Invokes content download for a JSON object with a file name.
+     *
+     * @param json JSON object to download.
+     * @param fileName Name of the resulting file.
+     */
+    downloadJSON(json, fileName) {
+        this.saveData(json, 'json', fileName);
+    }
+    /**
+     * Invokes the download of the file by its URL address.
+     *
+     * @param url Url address pointing to the file.
+     * @param fileName Name of the file download.
+     */
+    downloadUrl(url, fileName) {
+        if (url && fileName) {
+            const link = document.createElement('a');
+            link.style.display = 'none';
+            link.download = fileName;
+            link.href = url;
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DownloadService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DownloadService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DownloadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/common/services/dynamic-component-mapper.service.mjs

@@ -0,0 +1,89 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const getType = (type) => () => type;
+export class DynamicComponentResolver {
+    static fromType(type) {
+        return getType(type);
+    }
+}
+export class DynamicComponentMapper {
+    constructor() {
+        this.defaultValue = undefined;
+        this.types = {};
+    }
+    /**
+     * Gets the currently active DynamicComponentResolveFunction for a field type.
+     *
+     * @param type The type whose resolver you want
+     * @param defaultValue Default type returned for types that are not yet mapped
+     * @returns Resolver function
+     */
+    getComponentTypeResolver(type, defaultValue = this.defaultValue) {
+        if (type) {
+            return this.types[type] || DynamicComponentResolver.fromType(defaultValue);
+        }
+        return DynamicComponentResolver.fromType(defaultValue);
+    }
+    /**
+     * Sets or optionally replaces a DynamicComponentResolveFunction for a field type.
+     *
+     * @param type The type whose resolver you want to set
+     * @param resolver The new resolver function
+     * @param override The new resolver will only replace an existing one if this parameter is true
+     */
+    setComponentTypeResolver(type, resolver, override = true) {
+        if (!type) {
+            throw new Error(`type is null or not defined`);
+        }
+        if (!resolver) {
+            throw new Error(`resolver is null or not defined`);
+        }
+        const existing = this.types[type];
+        if (existing && !override) {
+            throw new Error(`already mapped, use override option if you intend replacing existing mapping.`);
+        }
+        this.types[type] = resolver;
+    }
+    /**
+     * Register multiple components
+     *
+     * @param components map of components to register
+     * @param override replace existing components
+     */
+    register(components, override = false) {
+        if (components) {
+            for (const type of Object.keys(components)) {
+                this.setComponentTypeResolver(type, components[type], override);
+            }
+        }
+    }
+    /**
+     * Finds the component type that is needed to render a form field.
+     *
+     * @param model Form field model for the field to render
+     * @param defaultValue Default type returned for field types that are not yet mapped.
+     * @returns Component type
+     */
+    resolveComponentType(model, defaultValue = this.defaultValue) {
+        if (model) {
+            const resolver = this.getComponentTypeResolver(model.type, defaultValue);
+            return resolver(model);
+        }
+        return defaultValue;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/common/services/highlight-transform.service.mjs

@@ -0,0 +1,61 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class HighlightTransformService {
+    /**
+     * Searches for `search` string(s) within `text` and highlights all occurrences.
+     *
+     * @param text Text to search within
+     * @param search Text pattern to search for
+     * @param wrapperClass CSS class used to provide highlighting style
+     * @returns New text along with boolean value to indicate whether anything was highlighted
+     */
+    highlight(text, search, wrapperClass = 'adf-highlight') {
+        let isMatching = false;
+        let result = text;
+        if (search && text) {
+            // eslint-disable-next-line no-useless-escape
+            let pattern = search.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
+            pattern = pattern
+                .split(' ')
+                .filter((t) => t.length > 0)
+                .join('|');
+            const regex = new RegExp(pattern, 'gi');
+            result = this.removeHtmlTags(text).replace(regex, (match) => {
+                isMatching = true;
+                return `<span class="${wrapperClass}">${match}</span>`;
+            });
+            return { text: result, changed: isMatching };
+        }
+        else {
+            return { text: result, changed: isMatching };
+        }
+    }
+    removeHtmlTags(text) {
+        return text.split('>').pop().split('<')[0];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HighlightTransformService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HighlightTransformService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HighlightTransformService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/common/services/language-item.interface.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFuZ3VhZ2UtaXRlbS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2NvbW1vbi9zZXJ2aWNlcy9sYW5ndWFnZS1pdGVtLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUciLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7IERpcmVjdGlvbiB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9iaWRpJztcblxuZXhwb3J0IGludGVyZmFjZSBMYW5ndWFnZUl0ZW0ge1xuICAgIGtleTogc3RyaW5nO1xuICAgIGxhYmVsOiBzdHJpbmc7XG4gICAgZGlyZWN0aW9uPzogRGlyZWN0aW9uO1xufVxuIl19

package/esm2022/lib/common/services/log.service.mjs

@@ -0,0 +1,171 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable no-console */
+import { Injectable } from '@angular/core';
+import { AppConfigService, AppConfigValues } from '../../app-config/app-config.service';
+import { logLevels, LogLevelsEnum } from '../models/log-levels.model';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../../app-config/app-config.service";
+/**
+ * @deprecated This service is deprecated and will be removed in future versions.
+ */
+export class LogService {
+    get currentLogLevel() {
+        const configLevel = this.appConfig.get(AppConfigValues.LOG_LEVEL);
+        if (configLevel) {
+            return this.getLogLevel(configLevel);
+        }
+        return LogLevelsEnum.TRACE;
+    }
+    constructor(appConfig) {
+        this.appConfig = appConfig;
+        this.onMessage = new Subject();
+    }
+    /**
+     * Logs a message at the "ERROR" level.
+     *
+     * @param message Message to log
+     * @param optionalParams Interpolation values for the message in "printf" format
+     */
+    error(message, ...optionalParams) {
+        if (this.currentLogLevel >= LogLevelsEnum.ERROR) {
+            this.messageBus(message, 'ERROR');
+            console.error(message, ...optionalParams);
+        }
+    }
+    /**
+     * Logs a message at the "DEBUG" level.
+     *
+     * @param message Message to log
+     * @param optionalParams Interpolation values for the message in "printf" format
+     */
+    debug(message, ...optionalParams) {
+        if (this.currentLogLevel >= LogLevelsEnum.DEBUG) {
+            this.messageBus(message, 'DEBUG');
+            console.debug(message, ...optionalParams);
+        }
+    }
+    /**
+     * Logs a message at the "INFO" level.
+     *
+     * @param message Message to log
+     * @param optionalParams Interpolation values for the message in "printf" format
+     */
+    info(message, ...optionalParams) {
+        if (this.currentLogLevel >= LogLevelsEnum.INFO) {
+            this.messageBus(message, 'INFO');
+            console.info(message, ...optionalParams);
+        }
+    }
+    /**
+     * Logs a message at any level from "TRACE" upwards.
+     *
+     * @param message Message to log
+     * @param optionalParams Interpolation values for the message in "printf" format
+     */
+    log(message, ...optionalParams) {
+        if (this.currentLogLevel >= LogLevelsEnum.TRACE) {
+            this.messageBus(message, 'LOG');
+            console.log(message, ...optionalParams);
+        }
+    }
+    /**
+     * Logs a message at the "TRACE" level.
+     *
+     * @param message Message to log
+     * @param optionalParams Interpolation values for the message in "printf" format
+     */
+    trace(message, ...optionalParams) {
+        if (this.currentLogLevel >= LogLevelsEnum.TRACE) {
+            this.messageBus(message, 'TRACE');
+            console.trace(message, ...optionalParams);
+        }
+    }
+    /**
+     * Logs a message at the "WARN" level.
+     *
+     * @param message Message to log
+     * @param optionalParams Interpolation values for the message in "printf" format
+     */
+    warn(message, ...optionalParams) {
+        if (this.currentLogLevel >= LogLevelsEnum.WARN) {
+            this.messageBus(message, 'WARN');
+            console.warn(message, ...optionalParams);
+        }
+    }
+    /**
+     * Logs a message if a boolean test fails.
+     *
+     * @param test Test value (typically a boolean expression)
+     * @param message Message to show if test is false
+     * @param optionalParams Interpolation values for the message in "printf" format
+     */
+    assert(test, message, ...optionalParams) {
+        if (this.currentLogLevel !== LogLevelsEnum.SILENT) {
+            this.messageBus(message, 'ASSERT');
+            console.assert(test, message, ...optionalParams);
+        }
+    }
+    /**
+     * Starts an indented group of log messages.
+     *
+     * @param groupTitle Title shown at the start of the group
+     * @param optionalParams Interpolation values for the title in "printf" format
+     */
+    group(groupTitle, ...optionalParams) {
+        if (this.currentLogLevel !== LogLevelsEnum.SILENT) {
+            console.group(groupTitle, ...optionalParams);
+        }
+    }
+    /**
+     * Ends a indented group of log messages.
+     */
+    groupEnd() {
+        if (this.currentLogLevel !== LogLevelsEnum.SILENT) {
+            console.groupEnd();
+        }
+    }
+    /**
+     * Converts a log level name string into its numeric equivalent.
+     *
+     * @param level Level name
+     * @returns Numeric log level
+     */
+    getLogLevel(level) {
+        const referencedLevel = logLevels.find((currentLevel) => currentLevel.name.toLocaleLowerCase() === level.toLocaleLowerCase());
+        return referencedLevel ? referencedLevel.level : 5;
+    }
+    /**
+     * Triggers notification callback for log messages.
+     *
+     * @param text Message text
+     * @param logLevel Log level for the message
+     */
+    messageBus(text, logLevel) {
+        this.onMessage.next({ text, type: logLevel });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LogService, deps: [{ token: i1.AppConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.AppConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/common/services/log.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/* eslint-disable no-console */\n\nimport { Injectable } from '@angular/core';\nimport { AppConfigService, AppConfigValues } from '../../app-config/app-config.service';\nimport { logLevels, LogLevelsEnum } from '../models/log-levels.model';\nimport { Subject } from 'rxjs';\n\n/**\n * @deprecated This service is deprecated and will be removed in future versions.\n */\n@Injectable({\n    providedIn: 'root'\n})\nexport class LogService {\n    get currentLogLevel(): number {\n        const configLevel: string = this.appConfig.get<string>(AppConfigValues.LOG_LEVEL);\n\n        if (configLevel) {\n            return this.getLogLevel(configLevel);\n        }\n\n        return LogLevelsEnum.TRACE;\n    }\n\n    onMessage: Subject<any>;\n\n    constructor(private appConfig: AppConfigService) {\n        this.onMessage = new Subject();\n    }\n\n    /**\n     * Logs a message at the \"ERROR\" level.\n     *\n     * @param message Message to log\n     * @param optionalParams Interpolation values for the message in \"printf\" format\n     */\n    error(message?: any, ...optionalParams: any[]) {\n        if (this.currentLogLevel >= LogLevelsEnum.ERROR) {\n            this.messageBus(message, 'ERROR');\n\n            console.error(message, ...optionalParams);\n        }\n    }\n\n    /**\n     * Logs a message at the \"DEBUG\" level.\n     *\n     * @param message Message to log\n     * @param optionalParams Interpolation values for the message in \"printf\" format\n     */\n    debug(message?: any, ...optionalParams: any[]) {\n        if (this.currentLogLevel >= LogLevelsEnum.DEBUG) {\n            this.messageBus(message, 'DEBUG');\n\n            console.debug(message, ...optionalParams);\n        }\n    }\n\n    /**\n     * Logs a message at the \"INFO\" level.\n     *\n     * @param message Message to log\n     * @param optionalParams Interpolation values for the message in \"printf\" format\n     */\n    info(message?: any, ...optionalParams: any[]) {\n        if (this.currentLogLevel >= LogLevelsEnum.INFO) {\n            this.messageBus(message, 'INFO');\n\n            console.info(message, ...optionalParams);\n        }\n    }\n\n    /**\n     * Logs a message at any level from \"TRACE\" upwards.\n     *\n     * @param message Message to log\n     * @param optionalParams Interpolation values for the message in \"printf\" format\n     */\n    log(message?: any, ...optionalParams: any[]) {\n        if (this.currentLogLevel >= LogLevelsEnum.TRACE) {\n            this.messageBus(message, 'LOG');\n\n            console.log(message, ...optionalParams);\n        }\n    }\n\n    /**\n     * Logs a message at the \"TRACE\" level.\n     *\n     * @param message Message to log\n     * @param optionalParams Interpolation values for the message in \"printf\" format\n     */\n    trace(message?: any, ...optionalParams: any[]) {\n        if (this.currentLogLevel >= LogLevelsEnum.TRACE) {\n            this.messageBus(message, 'TRACE');\n\n            console.trace(message, ...optionalParams);\n        }\n    }\n\n    /**\n     * Logs a message at the \"WARN\" level.\n     *\n     * @param message Message to log\n     * @param optionalParams Interpolation values for the message in \"printf\" format\n     */\n    warn(message?: any, ...optionalParams: any[]) {\n        if (this.currentLogLevel >= LogLevelsEnum.WARN) {\n            this.messageBus(message, 'WARN');\n\n            console.warn(message, ...optionalParams);\n        }\n    }\n\n    /**\n     * Logs a message if a boolean test fails.\n     *\n     * @param test Test value (typically a boolean expression)\n     * @param message Message to show if test is false\n     * @param optionalParams Interpolation values for the message in \"printf\" format\n     */\n    assert(test?: boolean, message?: string, ...optionalParams: any[]) {\n        if (this.currentLogLevel !== LogLevelsEnum.SILENT) {\n            this.messageBus(message, 'ASSERT');\n\n            console.assert(test, message, ...optionalParams);\n        }\n    }\n\n    /**\n     * Starts an indented group of log messages.\n     *\n     * @param groupTitle Title shown at the start of the group\n     * @param optionalParams Interpolation values for the title in \"printf\" format\n     */\n    group(groupTitle?: string, ...optionalParams: any[]) {\n        if (this.currentLogLevel !== LogLevelsEnum.SILENT) {\n            console.group(groupTitle, ...optionalParams);\n        }\n    }\n\n    /**\n     * Ends a indented group of log messages.\n     */\n    groupEnd() {\n        if (this.currentLogLevel !== LogLevelsEnum.SILENT) {\n            console.groupEnd();\n        }\n    }\n\n    /**\n     * Converts a log level name string into its numeric equivalent.\n     *\n     * @param level Level name\n     * @returns Numeric log level\n     */\n    getLogLevel(level: string): number {\n        const referencedLevel = logLevels.find((currentLevel: any) => currentLevel.name.toLocaleLowerCase() === level.toLocaleLowerCase());\n\n        return referencedLevel ? referencedLevel.level : 5;\n    }\n\n    /**\n     * Triggers notification callback for log messages.\n     *\n     * @param text Message text\n     * @param logLevel Log level for the message\n     */\n    messageBus(text: string, logLevel: string) {\n        this.onMessage.next({ text, type: logLevel });\n    }\n}\n"]}