angular-toolbox 0.11.3 → 0.11.4

package/esm2022/lib/model/service/mock/http/logging/http-mock-logging-service.mjs

@@ -0,0 +1,110 @@
+/**
+ * @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 { HttpMockLogger } from "../../../../../framework/mock/http/logging/http-mock-logger";
+import { HttpMockLoggingConstant } from "../../../../business/logging/http-mock-logging-constant.enum";
+import * as i0 from "@angular/core";
+/**
+ * @private
+ *
+ * The utility service that manages the HTTP Mocking Framework logs.
+ */
+export class HttpMockLoggingService {
+    /**
+     * Returns the number of logs currently processed by this logger.
+     */
+    get size() {
+        return this._logger.getLogs().length;
+    }
+    /**
+     * @private
+     */
+    constructor() {
+        this._logger = new HttpMockLogger();
+    }
+    /**
+     * Processes information logs with the specified metadata.
+     *
+     * @param metadata The metadata associated with the HTTP method to log.
+     *
+     * @return The log for the specified metadata.
+     */
+    info(metadata) {
+        this._logger.info(HttpMockLoggingConstant.CALLER, HttpMockLoggingConstant.RESPONSE_MESSAGE, metadata);
+        return this.getLastLog();
+    }
+    /**
+     * Processes error logs with the specified metadata.
+     *
+     * @param metadata The metadata associated with the HTTP method to log.
+     *
+     * @return The log for the specified metadata.
+     */
+    error(metadata) {
+        this._logger.error(HttpMockLoggingConstant.CALLER, HttpMockLoggingConstant.ERROR_MESSAGE, metadata);
+        return this.getLastLog();
+    }
+    /**
+     * Processes a special kind of logs that are used to indicate that a HTTP operation
+     * started and no response is available yet.
+     *
+     * @param metadata The metadata associated with the HTTP method to log.
+     */
+    prefetch(metadata) {
+        this._logger.config(HttpMockLoggingConstant.CALLER, HttpMockLoggingConstant.CONFIG_MESSAGE, metadata);
+    }
+    /**
+     * @inheritdoc
+     */
+    clearLogs() {
+        this._logger.clearLogs();
+        this._logger.getLogConnector().clearLogs();
+    }
+    /**
+     * @inheritdoc
+     */
+    setLogConnector(value) {
+        this._logger.setLogConnector(value);
+    }
+    /**
+     * @inheritdoc
+     */
+    getLogConnector() {
+        return this._logger.getLogConnector();
+    }
+    /**
+     * @inheritdoc
+     */
+    destroy() {
+        if (this._logger)
+            this._logger.destroy();
+        this._logger = null;
+    }
+    /**
+     * @inheritdoc
+     */
+    ngOnDestroy() {
+        this.destroy();
+    }
+    /**
+     * @inheritdoc
+     */
+    getLastLog() {
+        const logs = this._logger.getLogs();
+        return logs[logs.length - 1];
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: HttpMockLoggingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: HttpMockLoggingService, providedIn: 'platform' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: HttpMockLoggingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'platform'
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/model/service/mock/http/logging/index.mjs

@@ -0,0 +1,2 @@
+export * from "./http-mock-logging-service";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9tb2RlbC9zZXJ2aWNlL21vY2svaHR0cC9sb2dnaW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNkJBQTZCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9odHRwLW1vY2stbG9nZ2luZy1zZXJ2aWNlXCI7Il19

package/esm2022/lib/model/service/ui/app-bridge.service.mjs

@@ -2,8 +2,8 @@
  * @license
  * Copyright Pascal ECHEMANN. All Rights Reserved.
  *
- * Use of this source code is governed by an MIT-style license that can be ound in
- * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ * 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 { DOCUMENT } from '@angular/common';
 import { Injectable, Inject } from '@angular/core';
@@ -139,4 +139,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImpor
                     type: Inject,
                     args: [DOCUMENT]
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-bridge.service.js","sourceRoot":"","sources":["../../../../../../../projects/angular-toolbox/src/lib/model/service/ui/app-bridge.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 ound in\r\n * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\r\n */\r\n\r\nimport { DOCUMENT } from '@angular/common';\r\nimport { Injectable, NgZone, Inject } from '@angular/core';\r\nimport { NavigationExtras, Router } from '@angular/router';\r\nimport { DEFAULT_SCROLL_BEHAVIOR } from '../../../util/default-scroll-behavior';\r\nimport { AppBridge } from '../../../core/bridge/app-bridge';\r\nimport { AppBridgeError } from '../../../core';\r\nimport { AppBridgeCommand } from '../../business/lang/app-bridge-command';\r\n\r\n/**\r\n * @private\r\n */\r\nexport const APP_PRIDGE_REF: string = \"appBridge\";\r\n\r\n/**\r\n * @private\r\n */\r\nconst HREF: string = \"href\";\r\n\r\n/**\r\n * @private\r\n */\r\nconst NATIVE_COMMANDS: string = \"navigate|goToAnchor|declareCommand|deleteCommand|getCommand\";\r\n\r\n/**\r\n * A utility service that allows dynamically injected HTML fragments, to interact with the Angular application.\r\n */\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class AppBrigeService {\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private readonly _defaultView: any;\r\n\r\n    /**\r\n     * @private\r\n     * Thereference to the command invoker.\r\n     */\r\n    private readonly _appBridge: AppBridge;\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    constructor(private _router: Router,\r\n                private _zone: NgZone,\r\n                @Inject(DOCUMENT) private _document: any) {\r\n        this._defaultView = _document.defaultView;\r\n        this._appBridge = new AppBridge();\r\n        if(!this._defaultView[APP_PRIDGE_REF]) this._defaultView[APP_PRIDGE_REF] = this;\r\n    }\r\n\r\n    /**\r\n     * Provides the ability to invoke the `navigate()` method of the Angular app router.\r\n     * \r\n     * @param commands The commands array as specified by the Angular router `navigate()` method.\r\n     * @param extras The navigation options as specified by the Angular router `navigate()` method.\r\n     * @return `Promise` that resolves to `true` when navigation succeeds, or `false` when navigation fails.\r\n     * \r\n     * @see https://angular.dev/api/router/Router#navigate\r\n     */\r\n    public navigate(commands: string[], extras?: NavigationExtras | undefined): Promise<boolean> {\r\n        return this._zone.run(() => {\r\n            return this._router.navigate(commands, extras);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Allows to scroll to the fragment specified by the `href` attribute when the user element interact with the associated element.\r\n     * \r\n     * @example\r\n     * <a href=\"#myAnchor\" onclick=\"appBridge.goToAnchor(event)\">My Section</a></code>\r\n     * \r\n     * @param event The event that triggers the anchor navigation.\r\n     * @return `Promise` that resolves to `true` when navigation succeeds, or `false` when navigation fails.\r\n     * \r\n     * @see https://angular.dev/api/router/Router#navigate\r\n     */\r\n    public goToAnchor(event: Event): Promise<boolean> {\r\n        event.preventDefault();\r\n        const anchor: string = (event.target as any).getAttribute(HREF);\r\n        if (!anchor) throw new ReferenceError(\"href attribute is not defined.\");\r\n        const elm: any = this._document.querySelector(anchor);\r\n        if (!elm) return new Promise((resolve: Function) => resolve(false));\r\n        elm.scrollIntoView(DEFAULT_SCROLL_BEHAVIOR);\r\n        return this._zone.run(() => {\r\n           return this._router.navigate([], { fragment: anchor.slice(1)});\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Declares a new JavaScript command to be used with dynamically loaded documents.\r\n     * \r\n     * @param name The name of the command to declare.\r\n     * @param command The reference to a JavaScript command to be used with dynamically loaded documents.\r\n     */\r\n    public declareCommand(name: string, command: AppBridgeCommand): void {\r\n        this.checkCommandName(name);\r\n        if(!this._appBridge.hasCommand(name)) {\r\n            this._appBridge.addCommand(name, command);\r\n            Object.defineProperty(this, name, {\r\n                configurable: true,\r\n                get: function() {\r\n                    return this._appBridge.getCommand(name);\r\n                }\r\n            });\r\n        }\r\n    }\r\n    \r\n    /**\r\n     * Unregisters a JavaScript command previously referenced with the `declareCommand()` method.\r\n     * \r\n     * @param name The name of the command to remove.\r\n     * \r\n     * @returns `true` whether the command existed and has been removed; `false` otherwise.\r\n     */\r\n    public deleteCommand(name: string): boolean {\r\n        this.checkCommandName(name);\r\n        if(!this._appBridge.removeCommand(name)) return false;\r\n        delete this._defaultView[APP_PRIDGE_REF][name];\r\n        return true;\r\n    }\r\n    \r\n    /**\r\n     * Returns the JavaScript command previously referenced with the `declareCommand()` method.\r\n     * \r\n     * @param name The name of the command to retrieve.\r\n     * @returns The JavaScript command previously referenced with the specified `name` parameter.\r\n     *          If no command is found, returns `undefined`.\r\n     */\r\n    public getCommand(name: string): AppBridgeCommand | undefined {   \r\n        return this._appBridge.getCommand(name);\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private checkCommandName(name: string): void {\r\n        if (NATIVE_COMMANDS.includes(name)) throw new AppBridgeError(\"Command name cannot be the reference to a native command: \" + name);\r\n    }\r\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-bridge.service.js","sourceRoot":"","sources":["../../../../../../../projects/angular-toolbox/src/lib/model/service/ui/app-bridge.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 { DOCUMENT } from '@angular/common';\r\nimport { Injectable, NgZone, Inject } from '@angular/core';\r\nimport { NavigationExtras, Router } from '@angular/router';\r\nimport { DEFAULT_SCROLL_BEHAVIOR } from '../../../util/default-scroll-behavior';\r\nimport { AppBridge } from '../../../core/bridge/app-bridge';\r\nimport { AppBridgeError } from '../../../core';\r\nimport { AppBridgeCommand } from '../../business/lang/app-bridge-command';\r\n\r\n/**\r\n * @private\r\n */\r\nexport const APP_PRIDGE_REF: string = \"appBridge\";\r\n\r\n/**\r\n * @private\r\n */\r\nconst HREF: string = \"href\";\r\n\r\n/**\r\n * @private\r\n */\r\nconst NATIVE_COMMANDS: string = \"navigate|goToAnchor|declareCommand|deleteCommand|getCommand\";\r\n\r\n/**\r\n * A utility service that allows dynamically injected HTML fragments, to interact with the Angular application.\r\n */\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\nexport class AppBrigeService {\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private readonly _defaultView: any;\r\n\r\n    /**\r\n     * @private\r\n     * Thereference to the command invoker.\r\n     */\r\n    private readonly _appBridge: AppBridge;\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    constructor(private _router: Router,\r\n                private _zone: NgZone,\r\n                @Inject(DOCUMENT) private _document: any) {\r\n        this._defaultView = _document.defaultView;\r\n        this._appBridge = new AppBridge();\r\n        if(!this._defaultView[APP_PRIDGE_REF]) this._defaultView[APP_PRIDGE_REF] = this;\r\n    }\r\n\r\n    /**\r\n     * Provides the ability to invoke the `navigate()` method of the Angular app router.\r\n     * \r\n     * @param commands The commands array as specified by the Angular router `navigate()` method.\r\n     * @param extras The navigation options as specified by the Angular router `navigate()` method.\r\n     * @return `Promise` that resolves to `true` when navigation succeeds, or `false` when navigation fails.\r\n     * \r\n     * @see https://angular.dev/api/router/Router#navigate\r\n     */\r\n    public navigate(commands: string[], extras?: NavigationExtras | undefined): Promise<boolean> {\r\n        return this._zone.run(() => {\r\n            return this._router.navigate(commands, extras);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Allows to scroll to the fragment specified by the `href` attribute when the user element interact with the associated element.\r\n     * \r\n     * @example\r\n     * <a href=\"#myAnchor\" onclick=\"appBridge.goToAnchor(event)\">My Section</a></code>\r\n     * \r\n     * @param event The event that triggers the anchor navigation.\r\n     * @return `Promise` that resolves to `true` when navigation succeeds, or `false` when navigation fails.\r\n     * \r\n     * @see https://angular.dev/api/router/Router#navigate\r\n     */\r\n    public goToAnchor(event: Event): Promise<boolean> {\r\n        event.preventDefault();\r\n        const anchor: string = (event.target as any).getAttribute(HREF);\r\n        if (!anchor) throw new ReferenceError(\"href attribute is not defined.\");\r\n        const elm: any = this._document.querySelector(anchor);\r\n        if (!elm) return new Promise((resolve: Function) => resolve(false));\r\n        elm.scrollIntoView(DEFAULT_SCROLL_BEHAVIOR);\r\n        return this._zone.run(() => {\r\n           return this._router.navigate([], { fragment: anchor.slice(1)});\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Declares a new JavaScript command to be used with dynamically loaded documents.\r\n     * \r\n     * @param name The name of the command to declare.\r\n     * @param command The reference to a JavaScript command to be used with dynamically loaded documents.\r\n     */\r\n    public declareCommand(name: string, command: AppBridgeCommand): void {\r\n        this.checkCommandName(name);\r\n        if(!this._appBridge.hasCommand(name)) {\r\n            this._appBridge.addCommand(name, command);\r\n            Object.defineProperty(this, name, {\r\n                configurable: true,\r\n                get: function() {\r\n                    return this._appBridge.getCommand(name);\r\n                }\r\n            });\r\n        }\r\n    }\r\n    \r\n    /**\r\n     * Unregisters a JavaScript command previously referenced with the `declareCommand()` method.\r\n     * \r\n     * @param name The name of the command to remove.\r\n     * \r\n     * @returns `true` whether the command existed and has been removed; `false` otherwise.\r\n     */\r\n    public deleteCommand(name: string): boolean {\r\n        this.checkCommandName(name);\r\n        if(!this._appBridge.removeCommand(name)) return false;\r\n        delete this._defaultView[APP_PRIDGE_REF][name];\r\n        return true;\r\n    }\r\n    \r\n    /**\r\n     * Returns the JavaScript command previously referenced with the `declareCommand()` method.\r\n     * \r\n     * @param name The name of the command to retrieve.\r\n     * @returns The JavaScript command previously referenced with the specified `name` parameter.\r\n     *          If no command is found, returns `undefined`.\r\n     */\r\n    public getCommand(name: string): AppBridgeCommand | undefined {   \r\n        return this._appBridge.getCommand(name);\r\n    }\r\n\r\n    /**\r\n     * @private\r\n     */\r\n    private checkCommandName(name: string): void {\r\n        if (NATIVE_COMMANDS.includes(name)) throw new AppBridgeError(\"Command name cannot be the reference to a native command: \" + name);\r\n    }\r\n}"]}

package/esm2022/lib/model/service/ui/dark-mode.service.mjs

@@ -2,8 +2,8 @@
  * @license
  * Copyright Pascal ECHEMANN. All Rights Reserved.
  *
- * Use of this source code is governed by an MIT-style license that can be ound in
- * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ * 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 { Inject, Injectable, EventEmitter } from '@angular/core';
 import { DOCUMENT } from '@angular/common';
@@ -180,4 +180,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImpor
                     type: Inject,
                     args: [DARK_MODE_CONFIG]
                 }] }] });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dark-mode.service.js","sourceRoot":"","sources":["../../../../../../../projects/angular-toolbox/src/lib/model/service/ui/dark-mode.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Pascal ECHEMANN. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be ound in\n * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\n */\n\nimport { Inject, Injectable, EventEmitter } from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\nimport { CSS_PROP, DARK_MODE_CONFIG, DarkModeConfig, STORAGE_KEY } from '../../business';\n\n// --> Internal constants\n/**\n * @private\n */\nconst ADD_ACTION: string = \"add\";\n\n/**\n * @private\n */\nconst REMOVE_ACTION: string = \"remove\";\n\n/**\n * @private\n */\nconst TRUE: string = \"true\";\n\n@Injectable({\n    providedIn: 'root'\n})\n/**\n * A lightweight service that provides Dark Mode implementation for your Angular application.\n */\nexport class DarkModeService {\n    \n    /**\n     * @private\n     */\n    private _darkModeEnabled: boolean = false;\n\n    /**\n     * @private\n     */\n    private _cssProperty: string = CSS_PROP;\n\n    /**\n     * @private\n     */\n    private _storageKey: string = STORAGE_KEY;\n\n    /**\n     * The callback function that is triggered when the dark mode changes.\n     * \n     * @typeParam `EventEmitter<boolean>` the value returned by the `darkModeEnabled()` property.\n     */\n    public readonly change: EventEmitter<boolean> = new EventEmitter<boolean>(true);\n\n    /**\n     * @private\n     * Creates a new `DarkModeService` instance.\n     * \n     * @param _document The reference to the `Document` singleton.\n     * @param config The reference to the `DarkModeConfig` provider.\n     */\n    constructor(@Inject(DOCUMENT) private _document: Document, @Inject(DARK_MODE_CONFIG) config: DarkModeConfig) {\n        this.initDarkMode(config);\n    }\n\n    /**\n     * Toogles the dark mode state.\n     */\n    public toggleDarkMode(): void {\n        this._darkModeEnabled ? this.disableDarkMode() : this.enableDarkMode();\n    }\n\n    /**\n     * Sets the dark mode state to active.\n     */\n    public enableDarkMode(): void {\n        this.setDarkMode(ADD_ACTION);\n        this.setStoredDarkMode();\n    }\n\n    /**\n     * Sets the dark mode state to inactive.\n     */\n    public disableDarkMode(): void {\n        this.setDarkMode(REMOVE_ACTION);\n        this.setStoredDarkMode();\n    }\n\n    /**\n     * Returns a `boolean` value that indicates whether the dark mode state is active (`true`), or not (`false`).\n     * \n     * @returns `true` whether the dark mode state is active; `false` otherwise.\n     */\n    public darkModeEnabled(): boolean {\n        return this._darkModeEnabled;\n    }\n\n    /**\n     * Returns the value of the CSS property as defined by the config provider.\n     * \n     * @returns The value of the CSS property.\n     */\n    public getCssProperty(): string {\n        return this._cssProperty;\n    }\n\n    /**\n     * Returns the value of the storage key as defined by the config provider.\n     * \n     * @returns The value of the storage key.\n     */\n    public getStorageKey(): string {\n        return this._storageKey;\n    }\n    \n    /**\n     * Removes the dark mode information from local storage.\n     */\n    public invalidateStorage(): void {\n        localStorage.removeItem(this._storageKey);\n    }\n    \n    /**\n     * @private\n     */\n    private initDarkMode(config: DarkModeConfig): void {\n        this._darkModeEnabled = config.darkModeEnabled || false;\n        this._cssProperty = config.cssProperty || CSS_PROP;\n        this._storageKey = config.storageKey || STORAGE_KEY;\n        if (this._darkModeEnabled) {\n            this.enableDarkMode();\n        } else {\n            this.initStoredDarkMode();\n        }\n        if (config.detectBrowserSettings) this.initBrowserMode();\n    }\n\n    /**\n     * @private\n     */\n    private initStoredDarkMode(): void {\n        const result: string | null = localStorage.getItem(this._storageKey);\n        if (result === TRUE) this.enableDarkMode();\n    }\n    \n    /**\n     * @private\n     */\n    private setStoredDarkMode(): void {\n        const data: string = String(this._darkModeEnabled);\n        localStorage.setItem(this._storageKey, data);\n    }\n    \n    /**\n     * @private\n     */\n    private setDarkMode(action: string): void {\n        const classList: DOMTokenList = this._document.body.classList;\n        if (action === ADD_ACTION) {\n            classList.add(this._cssProperty);\n            this._darkModeEnabled = true;\n        } else if (action === REMOVE_ACTION) {\n            classList.remove(this._cssProperty);\n            this._darkModeEnabled = false;\n        }\n        this.change.emit(this._darkModeEnabled);\n    }\n    \n    /**\n     * @private\n     */\n    private initBrowserMode(): void {\n        if (this.matchDarkTheme()) return this.enableDarkMode();\n        this.disableDarkMode();\n    }\n    \n    /**\n     * @private\n     */\n    private matchDarkTheme(): boolean {\n        return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dark-mode.service.js","sourceRoot":"","sources":["../../../../../../../projects/angular-toolbox/src/lib/model/service/ui/dark-mode.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Pascal ECHEMANN. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be found in\n * the LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license\n */\n\nimport { Inject, Injectable, EventEmitter } from '@angular/core';\nimport { DOCUMENT } from '@angular/common';\nimport { CSS_PROP, DARK_MODE_CONFIG, DarkModeConfig, STORAGE_KEY } from '../../business';\n\n// --> Internal constants\n/**\n * @private\n */\nconst ADD_ACTION: string = \"add\";\n\n/**\n * @private\n */\nconst REMOVE_ACTION: string = \"remove\";\n\n/**\n * @private\n */\nconst TRUE: string = \"true\";\n\n@Injectable({\n    providedIn: 'root'\n})\n/**\n * A lightweight service that provides Dark Mode implementation for your Angular application.\n */\nexport class DarkModeService {\n    \n    /**\n     * @private\n     */\n    private _darkModeEnabled: boolean = false;\n\n    /**\n     * @private\n     */\n    private _cssProperty: string = CSS_PROP;\n\n    /**\n     * @private\n     */\n    private _storageKey: string = STORAGE_KEY;\n\n    /**\n     * The callback function that is triggered when the dark mode changes.\n     * \n     * @typeParam `EventEmitter<boolean>` the value returned by the `darkModeEnabled()` property.\n     */\n    public readonly change: EventEmitter<boolean> = new EventEmitter<boolean>(true);\n\n    /**\n     * @private\n     * Creates a new `DarkModeService` instance.\n     * \n     * @param _document The reference to the `Document` singleton.\n     * @param config The reference to the `DarkModeConfig` provider.\n     */\n    constructor(@Inject(DOCUMENT) private _document: Document, @Inject(DARK_MODE_CONFIG) config: DarkModeConfig) {\n        this.initDarkMode(config);\n    }\n\n    /**\n     * Toogles the dark mode state.\n     */\n    public toggleDarkMode(): void {\n        this._darkModeEnabled ? this.disableDarkMode() : this.enableDarkMode();\n    }\n\n    /**\n     * Sets the dark mode state to active.\n     */\n    public enableDarkMode(): void {\n        this.setDarkMode(ADD_ACTION);\n        this.setStoredDarkMode();\n    }\n\n    /**\n     * Sets the dark mode state to inactive.\n     */\n    public disableDarkMode(): void {\n        this.setDarkMode(REMOVE_ACTION);\n        this.setStoredDarkMode();\n    }\n\n    /**\n     * Returns a `boolean` value that indicates whether the dark mode state is active (`true`), or not (`false`).\n     * \n     * @returns `true` whether the dark mode state is active; `false` otherwise.\n     */\n    public darkModeEnabled(): boolean {\n        return this._darkModeEnabled;\n    }\n\n    /**\n     * Returns the value of the CSS property as defined by the config provider.\n     * \n     * @returns The value of the CSS property.\n     */\n    public getCssProperty(): string {\n        return this._cssProperty;\n    }\n\n    /**\n     * Returns the value of the storage key as defined by the config provider.\n     * \n     * @returns The value of the storage key.\n     */\n    public getStorageKey(): string {\n        return this._storageKey;\n    }\n    \n    /**\n     * Removes the dark mode information from local storage.\n     */\n    public invalidateStorage(): void {\n        localStorage.removeItem(this._storageKey);\n    }\n    \n    /**\n     * @private\n     */\n    private initDarkMode(config: DarkModeConfig): void {\n        this._darkModeEnabled = config.darkModeEnabled || false;\n        this._cssProperty = config.cssProperty || CSS_PROP;\n        this._storageKey = config.storageKey || STORAGE_KEY;\n        if (this._darkModeEnabled) {\n            this.enableDarkMode();\n        } else {\n            this.initStoredDarkMode();\n        }\n        if (config.detectBrowserSettings) this.initBrowserMode();\n    }\n\n    /**\n     * @private\n     */\n    private initStoredDarkMode(): void {\n        const result: string | null = localStorage.getItem(this._storageKey);\n        if (result === TRUE) this.enableDarkMode();\n    }\n    \n    /**\n     * @private\n     */\n    private setStoredDarkMode(): void {\n        const data: string = String(this._darkModeEnabled);\n        localStorage.setItem(this._storageKey, data);\n    }\n    \n    /**\n     * @private\n     */\n    private setDarkMode(action: string): void {\n        const classList: DOMTokenList = this._document.body.classList;\n        if (action === ADD_ACTION) {\n            classList.add(this._cssProperty);\n            this._darkModeEnabled = true;\n        } else if (action === REMOVE_ACTION) {\n            classList.remove(this._cssProperty);\n            this._darkModeEnabled = false;\n        }\n        this.change.emit(this._darkModeEnabled);\n    }\n    \n    /**\n     * @private\n     */\n    private initBrowserMode(): void {\n        if (this.matchDarkTheme()) return this.enableDarkMode();\n        this.disableDarkMode();\n    }\n    \n    /**\n     * @private\n     */\n    private matchDarkTheme(): boolean {\n        return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;\n    }\n}\n"]}

package/esm2022/lib/model/service/version/angular-toolbox-version.service.mjs

@@ -15,8 +15,8 @@ import * as i0 from "@angular/core";
 const LAYERS_VERSION_CONFIG = {
     major: 0,
     minor: 11,
-    patch: 3,
-    buildTimestamp: 1722599248501,
+    patch: 4,
+    buildTimestamp: 1724056397828,
     metadata: "beta"
 };
 /**
@@ -35,4 +35,4 @@ export class AngularToolboxVersionService extends AbstractVersionManager {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: AngularToolboxVersionService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/util/default-scroll-behavior.mjs

@@ -2,12 +2,12 @@
  * @license
  * Copyright Pascal ECHEMANN. All Rights Reserved.
  *
- * Use of this source code is governed by an MIT-style license that can be ound in
- * fthe LICENSE file at https://pascalechemann.com/angular-toolbox/resources/license
+ * 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
  * An internal convenient object that defined default `ScrollIntoViewOptions` objects.
  */
 export const DEFAULT_SCROLL_BEHAVIOR = { behavior: "smooth", block: "start", inline: "nearest" };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1zY3JvbGwtYmVoYXZpb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi91dGlsL2RlZmF1bHQtc2Nyb2xsLWJlaGF2aW9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUEwQixFQUFFLFFBQVEsRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQGxpY2Vuc2VcclxuICogQ29weXJpZ2h0IFBhc2NhbCBFQ0hFTUFOTi4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cclxuICpcclxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmUgb3VuZCBpblxyXG4gKiBmdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL3Bhc2NhbGVjaGVtYW5uLmNvbS9hbmd1bGFyLXRvb2xib3gvcmVzb3VyY2VzL2xpY2Vuc2VcclxuICovXHJcblxyXG4vKipcclxuICogQHByaXZhdGVcclxuICogQW4gaW50ZXJuYWwgY29udmVuaWVudCBvYmplY3QgdGhhdCBkZWZpbmVkIGRlZmF1bHQgYFNjcm9sbEludG9WaWV3T3B0aW9uc2Agb2JqZWN0cy5cclxuICovXHJcbmV4cG9ydCBjb25zdCBERUZBVUxUX1NDUk9MTF9CRUhBVklPUjogU2Nyb2xsSW50b1ZpZXdPcHRpb25zID0geyBiZWhhdmlvcjogXCJzbW9vdGhcIiwgYmxvY2s6IFwic3RhcnRcIiwgaW5saW5lOiBcIm5lYXJlc3RcIiB9O1xyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC1zY3JvbGwtYmVoYXZpb3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi91dGlsL2RlZmF1bHQtc2Nyb2xsLWJlaGF2aW9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVIOzs7R0FHRztBQUNILE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUEwQixFQUFFLFFBQVEsRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogQGxpY2Vuc2VcclxuICogQ29weXJpZ2h0IFBhc2NhbCBFQ0hFTUFOTi4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cclxuICpcclxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmUgZm91bmQgaW5cclxuICogdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL3Bhc2NhbGVjaGVtYW5uLmNvbS9hbmd1bGFyLXRvb2xib3gvcmVzb3VyY2VzL2xpY2Vuc2VcclxuICovXHJcblxyXG4vKipcclxuICogQHByaXZhdGVcclxuICogQW4gaW50ZXJuYWwgY29udmVuaWVudCBvYmplY3QgdGhhdCBkZWZpbmVkIGRlZmF1bHQgYFNjcm9sbEludG9WaWV3T3B0aW9uc2Agb2JqZWN0cy5cclxuICovXHJcbmV4cG9ydCBjb25zdCBERUZBVUxUX1NDUk9MTF9CRUhBVklPUjogU2Nyb2xsSW50b1ZpZXdPcHRpb25zID0geyBiZWhhdmlvcjogXCJzbW9vdGhcIiwgYmxvY2s6IFwic3RhcnRcIiwgaW5saW5lOiBcIm5lYXJlc3RcIiB9O1xyXG4iXX0=