angular-toolbox 0.12.2 → 1.0.0

package/esm2022/lib/framework/mock/http-monitoring-console/model/service/atx-log-io.service.mjs

@@ -7,66 +7,94 @@
  */
 import { Injectable } from "@angular/core";
 import { LogLevel } from '../../../../../model';
-import { LogConverter } from "./io/log-converter";
+import { LogConverter } from "../../util/io/log-converter";
+import { formatDate } from "@angular/common";
+import { HMFLBuilder } from "../../util/io/hmfl-builder";
 import * as i0 from "@angular/core";
 import * as i1 from "../../../../../model";
+/**
+ * @private
+ */
+const BLOB_TYPE = { type: 'application/json' };
+/**
+ * @private
+ */
+const UTF8 = "UTF-8";
+/**
+ * @private
+ * The service responsible for exporting and importing `hmfl` log files.
+ */
 export class AtxLogIoService {
+    /**
+     * @private
+     */
     constructor(_logger) {
         this._logger = _logger;
-        this._converter = new LogConverter();
     }
+    /**
+     * @private
+     * Exports the specified logs into a hmfl file.
+     *
+     * @param logs The logs to exports.
+     */
     exportFile(logs) {
         const logDtoList = [];
         let cursor = logs.length - 1;
         for (; cursor >= 0; cursor--) {
             const log = logs[cursor];
             if (log.level !== LogLevel.CONFIG)
-                logDtoList.push(this._converter.logToDto(log));
+                logDtoList.push(LogConverter.logToDto(log));
         }
-        const exportData = {
-            logs: logDtoList,
-            timestamp: Date.now()
-        };
+        const exportData = HMFLBuilder.build(logDtoList);
         const a = document.createElement("a");
-        const file = new Blob([JSON.stringify(exportData)], { type: 'application/json' });
+        const file = new Blob([JSON.stringify(exportData)], BLOB_TYPE);
+        const timeFmt = formatDate(exportData.timestamp, "MM/dd/yy-hh:mm-a", "en-US");
         a.href = URL.createObjectURL(file);
-        a.download = "logs.hmfl";
+        a.download = `logs-${timeFmt}.hmfl`;
         a.click();
     }
-    importFile() {
-        const input = document.createElement("input");
-        const converter = this._converter;
+    /**
+     * @private
+     * Imports the logs loaded through the specified `FileList` object.
+     *
+     * @param fileList The logs to import.
+     */
+    importFile(fileList) {
         const logger = this._logger;
-        input.setAttribute("type", "file");
-        input.setAttribute("accept", ".hmfl");
-        input.onchange = (event) => {
-            const fileList = event.target.files;
-            const file = fileList[0];
-            if (file) {
-                var reader = new FileReader();
-                reader.readAsText(file, "UTF-8");
-                reader.onload = function (evt) {
-                    const result = reader.result;
-                    const resultLogData = JSON.parse(result);
-                    const logs = resultLogData.logs;
-                    let cursor = logs.length - 1;
-                    for (; cursor >= 0; cursor--) {
-                        const log = converter.dtoToLog(logs[cursor]);
-                        const metadata = log.metadata;
-                        const level = log.level;
-                        if (level === LogLevel.INFO)
-                            logger.info(metadata);
-                        else if (level === LogLevel.ERROR)
-                            logger.error(metadata);
-                    }
-                    ;
-                };
-                reader.onerror = function (e) {
-                    console.log(e);
-                };
-            }
-        };
-        input.click();
+        const files = fileList[0];
+        const killReader = this.killReader;
+        if (files) {
+            const reader = new FileReader();
+            reader.readAsText(files, UTF8);
+            reader.onload = () => {
+                const result = reader.result;
+                const resultLogData = JSON.parse(result);
+                const logs = resultLogData.logs;
+                let cursor = logs.length - 1;
+                for (; cursor >= 0; cursor--) {
+                    const log = LogConverter.dtoToLog(logs[cursor]);
+                    const metadata = log.metadata;
+                    const level = log.level;
+                    if (level === LogLevel.INFO)
+                        logger.info(metadata);
+                    else if (level === LogLevel.ERROR)
+                        logger.error(metadata);
+                }
+                ;
+                killReader(reader);
+            };
+            reader.onerror = (e) => {
+                killReader(reader);
+                console.log(e);
+            };
+        }
+    }
+    /**
+     * @private
+     */
+    killReader(reader) {
+        reader.onload = null;
+        reader.onerror = null;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AtxLogIoService, deps: [{ token: i1.HttpMockLoggingService }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AtxLogIoService }); }
@@ -74,4 +102,4 @@ export class AtxLogIoService {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AtxLogIoService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [{ type: i1.HttpMockLoggingService }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"atx-log-io.service.js","sourceRoot":"","sources":["../../../../../../../../../projects/angular-toolbox/src/lib/framework/mock/http-monitoring-console/model/service/atx-log-io.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @license\r\n * Copyright Pascal ECHEMANN. All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be found in\r\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\r\n */\r\n\r\nimport { Injectable } from \"@angular/core\";\r\nimport { HttpMockLoggingMetadata, HttpMockLoggingService, Log, LogLevel } from '../../../../../model';\r\nimport { LogConverter } from \"../../util/io/log-converter\";\r\nimport { AtxHttpLogDto } from \"../business/io/atx-http-log.dto\";\r\nimport { HMFL } from \"../business/io/hmfl\";\r\nimport { formatDate } from \"@angular/common\";\r\nimport { HMFLBuilder } from \"../../util/io/hmfl-builder\";\r\n\r\n/**\r\n * @private\r\n */\r\nconst BLOB_TYPE: any = { type: 'application/json' };\r\n\r\n/**\r\n * @private\r\n */\r\nconst UTF8: any = \"UTF-8\";\r\n\r\n/**\r\n * @private\r\n * The service responsible for exporting and importing `hmfl` log files.\r\n */\r\n@Injectable()\r\nexport class AtxLogIoService {\r\n\r\n  /**\r\n   * @private\r\n   */\r\n  constructor(private _logger: HttpMockLoggingService) {}\r\n\r\n  /**\r\n   * @private\r\n   * Exports the specified logs into a hmfl file.\r\n   * \r\n   * @param logs The logs to exports.\r\n   */\r\n  public exportFile(logs: Log[]): void {\r\n    const logDtoList: AtxHttpLogDto[] = [];\r\n    let cursor: number = logs.length - 1;\r\n    for (; cursor >= 0; cursor--) {\r\n      const log: Log = logs[cursor];\r\n      if (log.level !== LogLevel.CONFIG) logDtoList.push(LogConverter.logToDto(log));\r\n    }\r\n    const exportData: HMFL = HMFLBuilder.build(logDtoList);\r\n    const a: HTMLAnchorElement = document.createElement(\"a\");\r\n    const file: Blob = new Blob([JSON.stringify(exportData)], BLOB_TYPE);\r\n    const timeFmt: string = formatDate(exportData.timestamp, \"MM/dd/yy-hh:mm-a\", \"en-US\");\r\n    a.href = URL.createObjectURL(file);\r\n    a.download = `logs-${timeFmt}.hmfl`;\r\n    a.click();\r\n  }\r\n\r\n  /**\r\n   * @private\r\n   * Imports the logs loaded through the specified `FileList` object.\r\n   * \r\n   * @param fileList The logs to import.\r\n   */\r\n  public importFile(fileList: FileList): void {\r\n    const logger: HttpMockLoggingService = this._logger;\r\n    const files: File = fileList[0];\r\n    const killReader: Function = this.killReader;\r\n    if (files) {\r\n      const reader: FileReader = new FileReader();\r\n      reader.readAsText(files, UTF8);\r\n      reader.onload = ()=> {\r\n        const result: string = reader.result as any;\r\n        const resultLogData: HMFL = JSON.parse(result);\r\n        const logs: AtxHttpLogDto[] = resultLogData.logs;\r\n        let cursor: number = logs.length - 1;\r\n        for (; cursor >= 0; cursor--) {\r\n          const log: Log = LogConverter.dtoToLog(logs[cursor]);\r\n          const metadata: HttpMockLoggingMetadata = log.metadata;\r\n          const level: LogLevel = log.level;\r\n          if (level === LogLevel.INFO) logger.info(metadata);\r\n          else if (level === LogLevel.ERROR) logger.error(metadata);\r\n        };\r\n        killReader(reader);\r\n      }\r\n      reader.onerror = (e)=> {\r\n        killReader(reader);\r\n        console.log(e)\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * @private\r\n   */\r\n  private killReader(reader: FileReader): void {\r\n    reader.onload = null;\r\n    reader.onerror = null;\r\n  }\r\n}"]}

package/esm2022/lib/framework/mock/http-monitoring-console/model/service/atx-monitoring-console.controller.mjs

@@ -0,0 +1,96 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+import { Injectable } from "@angular/core";
+import { HttpMonitoringConsoleLogConnector } from "../../connector/http-monitoring-console-log-connector";
+import { IdentifiableComponent } from '../../../../../core';
+import { AtxConsoleActionType } from "../business/atx-console-action-type";
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../../model";
+import * as i2 from "./atx-monitoring-console.state";
+import * as i3 from "./atx-log-io.service";
+import * as i4 from "./atx-user-action.service";
+/**
+ * @private
+ * The service that manages user interactions with an `AtxMonitoringConsoleComponent` instance.
+ */
+export class AtxMonitoringConsoleController extends IdentifiableComponent {
+    /**
+     * @private
+     */
+    constructor(_logger, _state, _ioSvc, _subscribe, action) {
+        super("AtxMonitoringConsoleController");
+        this._logger = _logger;
+        this._state = _state;
+        this._ioSvc = _ioSvc;
+        this._subscribe = _subscribe;
+        const connector = new HttpMonitoringConsoleLogConnector();
+        const logs = this._logger.getLogs();
+        this.connector = connector;
+        this._subscribe.register(this, connector.change.subscribe((log) => this.addLog(log)))
+            .append(action.action.subscribe((action) => this.onAction(action)));
+        this.connector.init(logs);
+        this._state.init(logs);
+        this._logger.setLogConnector(connector);
+    }
+    /**
+     * @private
+     */
+    ngOnDestroy() {
+        this._subscribe.clearAll(this);
+        this._logger.setLogConnector(null);
+        this.connector.destroy();
+        this.connector = null;
+    }
+    /**
+     * @private
+     */
+    clearLogs() {
+        this._logger.clearLogs();
+        this._state.clearLogs();
+    }
+    /**
+     * @private
+     */
+    exportLogs() {
+        this._ioSvc.exportFile(this._state.logs);
+    }
+    /**
+     * @private
+     */
+    addLog(log) {
+        this._state.addLog(log);
+    }
+    /**
+     * @private
+     */
+    onAction(action) {
+        switch (action.type) {
+            case AtxConsoleActionType.CLEAR_LOGS:
+                this.clearLogs();
+                break;
+            case AtxConsoleActionType.EXPORT_LOGS:
+                this.exportLogs();
+                break;
+            case AtxConsoleActionType.IMPORT_LOGS:
+                this._ioSvc.importFile(action.data);
+                break;
+            case AtxConsoleActionType.LOG_SELECT:
+                this._state.selectLog(action.data);
+                break;
+            case AtxConsoleActionType.CLOSE_DETAILS_PANEL:
+                this._state.selectLog(null);
+                break;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AtxMonitoringConsoleController, deps: [{ token: i1.HttpMockLoggingService }, { token: i2.AtxMonitoringConsoleState }, { token: i3.AtxLogIoService }, { token: i1.SubscriptionService }, { token: i4.AtxUserActionService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AtxMonitoringConsoleController }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AtxMonitoringConsoleController, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpMockLoggingService }, { type: i2.AtxMonitoringConsoleState }, { type: i3.AtxLogIoService }, { type: i1.SubscriptionService }, { type: i4.AtxUserActionService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/framework/mock/http-monitoring-console/model/service/atx-monitoring-console.state.mjs

@@ -0,0 +1,126 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+import { Injectable } from "@angular/core";
+import { LogLevel } from '../../../../../model';
+import { SizeUtil } from "../../util/size.util";
+import * as i0 from "@angular/core";
+/**
+ * @private
+ * A convenient service that stores the state of an `AtxMonitoringConsoleComponent` instance.
+ */
+export class AtxMonitoringConsoleState {
+    constructor() {
+        /**
+         * @private
+         */
+        this._selectedLog = null;
+        /**
+         * @private
+         */
+        this._cumulativeSize = SizeUtil.INITIAL_SIZE;
+        /**
+         * @private
+         */
+        this._logs = [];
+        /**
+         * @private
+         */
+        this._size = 0;
+    }
+    /**
+     * @private
+     * Returns the `Log` object currently selected, or `null` if no log is selected.
+     */
+    get selectedLog() {
+        return this._selectedLog;
+    }
+    ;
+    /**
+     * @private
+     * Returns a string that represents the size of all requests stored within this service.
+     * The string is in the format defined by the `SizeUtil.sizeToString()` method.
+     */
+    get cumulativeSize() {
+        return this._cumulativeSize;
+    }
+    ;
+    /**
+     * @private
+     * Returns the list of logs stored within this service.
+     */
+    get logs() {
+        return this._logs;
+    }
+    ;
+    /**
+     * @private
+     * Returns the number of logs stored within this service.
+     */
+    get numLogs() {
+        return this._logs.length;
+    }
+    ;
+    /**
+     * @private
+     * Initializes the service.
+     * Allows to inject the logs previously collected by the `HttpMockLoggingService` singleton.
+     *
+     * @param logs The list of logs that must be stored within this service.
+     */
+    init(logs) {
+        const len = logs.length - 1;
+        let i = 0;
+        for (; i <= len; ++i)
+            this.addLog(logs[i]);
+    }
+    /**
+     * @private
+     * Adds the specified log to the service for storage purpose.
+     *
+     * @param log The log to add to this service.
+     */
+    addLog(log) {
+        if (log.level !== LogLevel.CONFIG) {
+            const size = SizeUtil.getSize(log.metadata.response.body);
+            const id = log.metadata.requestMetadata.id;
+            this._size += size;
+            this._cumulativeSize = SizeUtil.sizeToString(this._size);
+            const idx = this._logs.findIndex(prefetch => prefetch.metadata.requestMetadata.id === id);
+            idx > -1 ? this._logs.splice(idx, 1, log) : this._logs.push(log);
+            if (this.selectedLog?.metadata.requestMetadata.id === id)
+                this._selectedLog = log;
+        }
+        else
+            this._logs.push(log);
+    }
+    /**
+     * @private
+     * Removes all the logs stored within this service and sets all service properties
+     * to their default value.
+     */
+    clearLogs() {
+        this._selectedLog = null;
+        this._size = this._logs.length = 0;
+        this._cumulativeSize = SizeUtil.INITIAL_SIZE;
+    }
+    /**
+     * @private
+     * Indicates that the specified log is the currently selected log.
+     *
+     * @param log The log to set as the currently selected log.
+     */
+    selectLog(log) {
+        this._selectedLog = log;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AtxMonitoringConsoleState, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AtxMonitoringConsoleState }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AtxMonitoringConsoleState, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/framework/mock/http-monitoring-console/model/service/atx-user-action.service.mjs

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * Copyright Pascal ECHEMANN. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be found in
+ * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ */
+import { EventEmitter, Injectable, Output } from "@angular/core";
+import * as i0 from "@angular/core";
+/**
+ * @private
+ * The service responsible for sending user's actions to the controller.
+ */
+export class AtxUserActionService {
+    constructor() {
+        /**
+         * @private
+         * An event emitter that triggers event representing user's actions.
+         */
+        this.action = new EventEmitter(true);
+    }
+    /**
+     * @private
+     * Sends a user's actions to the system.
+     *
+     * @param type The type of action to send.
+     * @param data Optional data associated with the user's actions.
+     */
+    sendAction(type, data = null) {
+        this.action.emit({ type: type, data: data });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AtxUserActionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AtxUserActionService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AtxUserActionService, decorators: [{
+            type: Injectable
+        }], propDecorators: { action: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/framework/mock/http-monitoring-console/util/console-body-type.mjs

@@ -5,14 +5,46 @@
  * Use of this source code is governed by an MIT-style license that can be found in
  * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
  */
+/**
+ * @private
+ * The list of object types used to qualify parsed objects.
+ */
 export var ConsoleBodyType;
 (function (ConsoleBodyType) {
+    /**
+     * @private
+     * Indicates that the type of object is not supported.
+     */
     ConsoleBodyType[ConsoleBodyType["INVALID"] = -1] = "INVALID";
+    /**
+     * @private
+     * Indicates that the object is null.
+     */
     ConsoleBodyType[ConsoleBodyType["NULL"] = 0] = "NULL";
+    /**
+     * @private
+     * Indicates that the object is a Json.
+     */
     ConsoleBodyType[ConsoleBodyType["JSON"] = 1] = "JSON";
+    /**
+     * @private
+     * Indicates that the object is a string.
+     */
     ConsoleBodyType[ConsoleBodyType["TEXT"] = 2] = "TEXT";
+    /**
+     * @private
+     * Indicates that the object is a Blob instance.
+     */
     ConsoleBodyType[ConsoleBodyType["BLOB"] = 3] = "BLOB";
+    /**
+     * @private
+     * Indicates that the object is a FormData instance.
+     */
     ConsoleBodyType[ConsoleBodyType["FORM_DATA"] = 4] = "FORM_DATA";
+    /**
+     * @private
+     * Indicates that the object is an ArrayBuffer instance.
+     */
     ConsoleBodyType[ConsoleBodyType["ARRAY_BUFFER"] = 5] = "ARRAY_BUFFER";
 })(ConsoleBodyType || (ConsoleBodyType = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc29sZS1ib2R5LXR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwLW1vbml0b3JpbmctY29uc29sZS91dGlsL2NvbnNvbGUtYm9keS10eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE1BQU0sQ0FBTixJQUFZLGVBVVg7QUFWRCxXQUFZLGVBQWU7SUFFdkIsNERBQVksQ0FBQTtJQUNaLHFEQUFRLENBQUE7SUFDUixxREFBUSxDQUFBO0lBQ1IscURBQVEsQ0FBQTtJQUNSLHFEQUFRLENBQUE7SUFDUiwrREFBYSxDQUFBO0lBQ2IscUVBQWdCLENBQUE7QUFFcEIsQ0FBQyxFQVZXLGVBQWUsS0FBZixlQUFlLFFBVTFCIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIEBsaWNlbnNlXHJcbiAqIENvcHlyaWdodCBQYXNjYWwgRUNIRU1BTk4uIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXHJcbiAqXHJcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlIGZvdW5kIGluXHJcbiAqIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9wYXNjYWxlY2hlbWFubi5jb20vYW5ndWxhci10b29sYm94L3Jlc291cmNlcy9saWNlbnNlXHJcbiAqL1xyXG5cclxuZXhwb3J0IGVudW0gQ29uc29sZUJvZHlUeXBlIHtcclxuXHJcbiAgICBJTlZBTElEID0gLTEsXHJcbiAgICBOVUxMID0gMCxcclxuICAgIEpTT04gPSAxLFxyXG4gICAgVEVYVCA9IDIsXHJcbiAgICBCTE9CID0gMyxcclxuICAgIEZPUk1fREFUQSA9IDQsXHJcbiAgICBBUlJBWV9CVUZGRVIgPSA1XHJcbiAgICBcclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc29sZS1ib2R5LXR5cGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9mcmFtZXdvcmsvbW9jay9odHRwLW1vbml0b3JpbmctY29uc29sZS91dGlsL2NvbnNvbGUtYm9keS10eXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOzs7R0FHRztBQUNILE1BQU0sQ0FBTixJQUFZLGVBMkNYO0FBM0NELFdBQVksZUFBZTtJQUV2Qjs7O09BR0c7SUFDSCw0REFBWSxDQUFBO0lBRVo7OztPQUdHO0lBQ0gscURBQVEsQ0FBQTtJQUVSOzs7T0FHRztJQUNILHFEQUFRLENBQUE7SUFFUjs7O09BR0c7SUFDSCxxREFBUSxDQUFBO0lBRVI7OztPQUdHO0lBQ0gscURBQVEsQ0FBQTtJQUVSOzs7T0FHRztJQUNILCtEQUFhLENBQUE7SUFFYjs7O09BR0c7SUFDSCxxRUFBZ0IsQ0FBQTtBQUNwQixDQUFDLEVBM0NXLGVBQWUsS0FBZixlQUFlLFFBMkMxQiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBAbGljZW5zZVxyXG4gKiBDb3B5cmlnaHQgUGFzY2FsIEVDSEVNQU5OLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxyXG4gKlxyXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZSBmb3VuZCBpblxyXG4gKiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vcGFzY2FsZWNoZW1hbm4uY29tL2FuZ3VsYXItdG9vbGJveC9yZXNvdXJjZXMvbGljZW5zZVxyXG4gKi9cclxuXHJcbi8qKlxyXG4gKiBAcHJpdmF0ZVxyXG4gKiBUaGUgbGlzdCBvZiBvYmplY3QgdHlwZXMgdXNlZCB0byBxdWFsaWZ5IHBhcnNlZCBvYmplY3RzLlxyXG4gKi9cclxuZXhwb3J0IGVudW0gQ29uc29sZUJvZHlUeXBlIHtcclxuXHJcbiAgICAvKipcclxuICAgICAqIEBwcml2YXRlXHJcbiAgICAgKiBJbmRpY2F0ZXMgdGhhdCB0aGUgdHlwZSBvZiBvYmplY3QgaXMgbm90IHN1cHBvcnRlZC5cclxuICAgICAqL1xyXG4gICAgSU5WQUxJRCA9IC0xLFxyXG4gICAgXHJcbiAgICAvKipcclxuICAgICAqIEBwcml2YXRlXHJcbiAgICAgKiBJbmRpY2F0ZXMgdGhhdCB0aGUgb2JqZWN0IGlzIG51bGwuXHJcbiAgICAgKi9cclxuICAgIE5VTEwgPSAwLFxyXG5cclxuICAgIC8qKlxyXG4gICAgICogQHByaXZhdGVcclxuICAgICAqIEluZGljYXRlcyB0aGF0IHRoZSBvYmplY3QgaXMgYSBKc29uLlxyXG4gICAgICovXHJcbiAgICBKU09OID0gMSxcclxuXHJcbiAgICAvKipcclxuICAgICAqIEBwcml2YXRlXHJcbiAgICAgKiBJbmRpY2F0ZXMgdGhhdCB0aGUgb2JqZWN0IGlzIGEgc3RyaW5nLlxyXG4gICAgICovXHJcbiAgICBURVhUID0gMixcclxuXHJcbiAgICAvKipcclxuICAgICAqIEBwcml2YXRlXHJcbiAgICAgKiBJbmRpY2F0ZXMgdGhhdCB0aGUgb2JqZWN0IGlzIGEgQmxvYiBpbnN0YW5jZS5cclxuICAgICAqL1xyXG4gICAgQkxPQiA9IDMsXHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBAcHJpdmF0ZVxyXG4gICAgICogSW5kaWNhdGVzIHRoYXQgdGhlIG9iamVjdCBpcyBhIEZvcm1EYXRhIGluc3RhbmNlLlxyXG4gICAgICovXHJcbiAgICBGT1JNX0RBVEEgPSA0LFxyXG5cclxuICAgIC8qKlxyXG4gICAgICogQHByaXZhdGVcclxuICAgICAqIEluZGljYXRlcyB0aGF0IHRoZSBvYmplY3QgaXMgYW4gQXJyYXlCdWZmZXIgaW5zdGFuY2UuXHJcbiAgICAgKi9cclxuICAgIEFSUkFZX0JVRkZFUiA9IDVcclxufVxyXG4iXX0=

package/esm2022/lib/framework/mock/http-monitoring-console/util/console-type-class.mjs

@@ -5,13 +5,41 @@
  * Use of this source code is governed by an MIT-style license that can be found in
  * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
  */
+/**
+ * @private
+ * The list of CSS class types for rendered objects.
+ */
 export var ConsoleTypeClass;
 (function (ConsoleTypeClass) {
+    /**
+     * @private
+     * The class type for JS vanilla objects.
+     */
     ConsoleTypeClass["OBJECT"] = "atx-object";
+    /**
+     * @private
+     * The class type for JS string primitives.
+     */
     ConsoleTypeClass["STRING"] = "atx-string";
+    /**
+     * @private
+     * The class type for JS number primitives.
+     */
     ConsoleTypeClass["NUMBER"] = "atx-number";
+    /**
+     * @private
+     * The class type for JS boolean primitives.
+     */
     ConsoleTypeClass["BOOLEAN"] = "atx-boolean";
+    /**
+     * @private
+     * The class type for JS Arrays.
+     */
     ConsoleTypeClass["ARRAY"] = "atx-array";
+    /**
+     * @private
+     * The class type for the JS `null` type.
+     */
     ConsoleTypeClass["NULL"] = "atx-null";
 })(ConsoleTypeClass || (ConsoleTypeClass = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc29sZS10eXBlLWNsYXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci10b29sYm94L3NyYy9saWIvZnJhbWV3b3JrL21vY2svaHR0cC1tb25pdG9yaW5nLWNvbnNvbGUvdXRpbC9jb25zb2xlLXR5cGUtY2xhc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsTUFBTSxDQUFOLElBQVksZ0JBUVg7QUFSRCxXQUFZLGdCQUFnQjtJQUV4Qix5Q0FBcUIsQ0FBQTtJQUNyQix5Q0FBcUIsQ0FBQTtJQUNyQix5Q0FBb0IsQ0FBQTtJQUNwQiwyQ0FBc0IsQ0FBQTtJQUN0Qix1Q0FBa0IsQ0FBQTtJQUNsQixxQ0FBZ0IsQ0FBQTtBQUNwQixDQUFDLEVBUlcsZ0JBQWdCLEtBQWhCLGdCQUFnQixRQVEzQiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBAbGljZW5zZVxyXG4gKiBDb3B5cmlnaHQgUGFzY2FsIEVDSEVNQU5OLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxyXG4gKlxyXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZSBmb3VuZCBpblxyXG4gKiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vcGFzY2FsZWNoZW1hbm4uY29tL2FuZ3VsYXItdG9vbGJveC9yZXNvdXJjZXMvbGljZW5zZVxyXG4gKi9cclxuXHJcbmV4cG9ydCBlbnVtIENvbnNvbGVUeXBlQ2xhc3Mge1xyXG5cclxuICAgIE9CSkVDVCA9IFwiYXR4LW9iamVjdFwiLFxyXG4gICAgU1RSSU5HID0gXCJhdHgtc3RyaW5nXCIsXHJcbiAgICBOVU1CRVI9IFwiYXR4LW51bWJlclwiLFxyXG4gICAgQk9PTEVBTj0gXCJhdHgtYm9vbGVhblwiLFxyXG4gICAgQVJSQVk9IFwiYXR4LWFycmF5XCIsXHJcbiAgICBOVUxMPSBcImF0eC1udWxsXCJcclxufVxyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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