angular-toolbox 0.0.8 → 0.9.1

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

@@ -0,0 +1,183 @@
+/**
+ * @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
+ */
+import { Inject, Injectable, EventEmitter } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { CSS_PROP, DARK_MODE_CONFIG, STORAGE_KEY } from '../../business';
+import * as i0 from "@angular/core";
+// --> Internal constants
+/**
+ * @private
+ */
+const ADD_ACTION = "add";
+/**
+ * @private
+ */
+const REMOVE_ACTION = "remove";
+/**
+ * @private
+ */
+const TRUE = "true";
+/**
+ * A lightweight service that provides Dark Mode implementation for your Angular application.
+ */
+export class DarkModeService {
+    /**
+     * @private
+     * Creates a new `DarkModeService` instance.
+     *
+     * @param _document The reference to the `Document` singleton.
+     * @param config The reference to the `DarkModeConfig` provider.
+     */
+    constructor(_document, config) {
+        this._document = _document;
+        /**
+         * @private
+         */
+        this._darkModeEnabled = false;
+        /**
+         * @private
+         */
+        this._cssProperty = CSS_PROP;
+        /**
+         * @private
+         */
+        this._storageKey = STORAGE_KEY;
+        /**
+         * The callback function that is triggered when the dark mode changes.
+         *
+         * @typeParam `EventEmitter<boolean>` the value returned by the `darkModeEnabled()` property.
+         */
+        this.change = new EventEmitter(true);
+        this.initDarkMode(config);
+    }
+    /**
+     * Toogles the dark mode state.
+     */
+    toggleDarkMode() {
+        this._darkModeEnabled ? this.disableDarkMode() : this.enableDarkMode();
+    }
+    /**
+     * Sets the dark mode state to active.
+     */
+    enableDarkMode() {
+        this.setDarkMode(ADD_ACTION);
+        this.setStoredDarkMode();
+    }
+    /**
+     * Sets the dark mode state to inactive.
+     */
+    disableDarkMode() {
+        this.setDarkMode(REMOVE_ACTION);
+        this.setStoredDarkMode();
+    }
+    /**
+     * Returns a `boolean` value that indicates whether the dark mode state is active (`true`), or not (`false`).
+     *
+     * @returns `true` whether the dark mode state is active; `false` otherwise.
+     */
+    darkModeEnabled() {
+        return this._darkModeEnabled;
+    }
+    /**
+     * Returns the value of the CSS property as defined by the config provider.
+     *
+     * @returns The value of the CSS property.
+     */
+    getCssProperty() {
+        return this._cssProperty;
+    }
+    /**
+     * Returns the value of the storage key as defined by the config provider.
+     *
+     * @returns The value of the storage key.
+     */
+    getStorageKey() {
+        return this._storageKey;
+    }
+    /**
+     * Removes the dark mode information from local storage.
+     */
+    invalidateStorage() {
+        localStorage.removeItem(this._storageKey);
+    }
+    /**
+     * @private
+     */
+    initDarkMode(config) {
+        this._darkModeEnabled = config.darkModeEnabled || false;
+        this._cssProperty = config.cssProperty || CSS_PROP;
+        this._storageKey = config.storageKey || STORAGE_KEY;
+        if (this._darkModeEnabled) {
+            this.enableDarkMode();
+        }
+        else {
+            this.initStoredDarkMode();
+        }
+        if (config.detectBrowserSettings)
+            this.initBrowserMode();
+    }
+    /**
+     * @private
+     */
+    initStoredDarkMode() {
+        const result = localStorage.getItem(this._storageKey);
+        if (result === TRUE)
+            this.enableDarkMode();
+    }
+    /**
+     * @private
+     */
+    setStoredDarkMode() {
+        const data = String(this._darkModeEnabled);
+        localStorage.setItem(this._storageKey, data);
+    }
+    /**
+     * @private
+     */
+    setDarkMode(action) {
+        const classList = this._document.body.classList;
+        if (action === ADD_ACTION) {
+            classList.add(this._cssProperty);
+            this._darkModeEnabled = true;
+        }
+        else if (action === REMOVE_ACTION) {
+            classList.remove(this._cssProperty);
+            this._darkModeEnabled = false;
+        }
+        this.change.emit(this._darkModeEnabled);
+    }
+    /**
+     * @private
+     */
+    initBrowserMode() {
+        if (this.matchDarkTheme())
+            return this.enableDarkMode();
+        this.disableDarkMode();
+    }
+    /**
+     * @private
+     */
+    matchDarkTheme() {
+        return window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: DarkModeService, deps: [{ token: DOCUMENT }, { token: DARK_MODE_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: DarkModeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: DarkModeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    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"]}

package/esm2022/lib/model/service/ui/index.mjs

@@ -0,0 +1,4 @@
+export * from './dark-mode.service';
+export * from './scroll.service';
+export * from './app-bridge.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9tb2RlbC9zZXJ2aWNlL3VpL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kYXJrLW1vZGUuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc2Nyb2xsLnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2FwcC1icmlkZ2Uuc2VydmljZSc7Il19

package/esm2022/lib/model/service/ui/scroll.service.mjs

@@ -0,0 +1,93 @@
+/**
+ * @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 { DOCUMENT } from '@angular/common';
+import { EventEmitter, Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A lightweight service that provides scrolling capabilities to your Angular application.
+ */
+export class ScrollService {
+    /**
+     * @private
+     * Creates a new `ScrollService` instance.
+     *
+     * @param _document The reference to the `Document` singleton.
+     */
+    constructor(_document) {
+        this._document = _document;
+        /**
+         * The callback function that is triggered when a scroll operation is performed.
+         *
+         * @typeParam `EventEmitter<Event>` The reference to the original scroll event.
+         */
+        this.onScroll = new EventEmitter();
+        window.addEventListener("scroll", (e) => {
+            this.onScroll.next(e);
+        });
+    }
+    /**
+     * Scrolls the ancestor containers of the element with the specified selector such that
+     * this element  is visible to the user.
+     *
+     * @param selector The selector of the target element.
+     * @param arg A `boolean` value:
+     * If `true`, the top of the element will be aligned to the top of the visible area of the
+     * scrollable ancestor.
+     * If `false`, the bottom of the element will be aligned to the bottom of the visible area
+     * of the scrollable ancestor.
+     * @param arg A dictionary containing the scroll parameters.
+     */
+    scrollIntoView(selector, arg) {
+        const elm = this._document.querySelector(selector);
+        if (elm)
+            elm.scrollIntoView(arg);
+    }
+    /**
+     * Scrolls the app viewport to the top of the browser window.
+     *
+     * @param behavior Specifies whether the scrolling should animate smoothly (`smooth`),
+     *                 happen instantly in a single jump (`instant`), or let the browser
+     *                 choose (`auto`, `default`).
+     */
+    gotoTop(behavior = 'smooth') {
+        const options = {
+            top: 0,
+            behavior: behavior
+        };
+        this.scroll(options);
+    }
+    /**
+     * Scrolls the app viewport according to the specified options, into the browser window.
+     *
+     * @param options A dictionary containing the scroll parameters.
+     */
+    scroll(options) {
+        window.scroll(options);
+    }
+    /**
+     * Scrolls the app viewport by the specified `x/y` coordinates, into the browser window.
+     *
+     * @param x The horizontal pixel value that you want to scroll by.
+     * @param y The vertical  pixel value that you want to scroll by.
+     */
+    scrollBy(x, y) {
+        window.scrollBy(x, y);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ScrollService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ScrollService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: ScrollService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/model/service/version/version.service.mjs

@@ -0,0 +1,51 @@
+/**
+ * @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 { Inject, Injectable } from '@angular/core';
+import { VERSION_CONFIG } from '../../business';
+import { VersionImpl } from '../../../core/impl/version/version.impl';
+import * as i0 from "@angular/core";
+/**
+ * A lightweight service that provides Semantic Versioning implementation for your Angular projects.
+ */
+export class VersionService {
+    /**
+     * Creates a new VersionService instance.
+     * @param config the reference to the VersionConfig provider.
+     */
+    constructor(config) {
+        this._version = new VersionImpl(config.major, config.minor, config.patch, config.buildTimestamp);
+    }
+    /**
+     * Returns the version of the associated Angular project.
+     *
+     * @return the version of the associated Angular project.
+     */
+    getVersion() {
+        return this._version;
+    }
+    /**
+     * Returns the build timestamp of the associated Angular project.
+     *
+     * @return the  build timestamp of the associated Angular project.
+     */
+    getBuildTimestamp() {
+        return this._version.buildTimeStamp;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: VersionService, deps: [{ token: VERSION_CONFIG }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: VersionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: VersionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [VERSION_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2020 → esm2022}/lib/pipe/index.mjs

@@ -1,2 +1,2 @@
-export * from './safe/safe-html.pipe';
+export * from './safe/safe-html.pipe';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi9waXBlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3NhZmUvc2FmZS1odG1sLnBpcGUnOyJdfQ==

package/esm2022/lib/pipe/safe/safe-html.pipe.mjs

@@ -0,0 +1,34 @@
+import { Pipe } from "@angular/core";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+/**
+ * A basic implementation of HTML sanitization pipe.
+ */
+export class SafeHtmlPipe {
+    /**
+     * @private
+     */
+    constructor(_sanitizer) {
+        this._sanitizer = _sanitizer;
+    }
+    /**
+     * Transforms the HTML input string value into a `SafeHtml` instance and returns the result
+     * of the transformation.
+     *
+     * @param value The HTML input value to transform into a `SafeHtml` instance.
+     * @returns A `SafeHtml` instance based on the specified input value.
+     */
+    transform(value) {
+        return this._sanitizer.bypassSecurityTrustHtml(value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: SafeHtmlPipe, deps: [{ token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe }); }
+    static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.0.3", ngImport: i0, type: SafeHtmlPipe, isStandalone: true, name: "safeHtml" }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.3", ngImport: i0, type: SafeHtmlPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'safeHtml',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.DomSanitizer }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/util/aria-role.constant.mjs

@@ -0,0 +1,16 @@
+/**
+ * @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
+ */
+/**
+ * A reference to the `"button"` value of the `role` property.
+ */
+export const BUTTON_ROLE = 'button';
+/**
+ * A reference to the `"link"` value of the `role` property.
+ */
+export const LINK_ROLE = 'link';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXJpYS1yb2xlLmNvbnN0YW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci10b29sYm94L3NyYy9saWIvdXRpbC9hcmlhLXJvbGUuY29uc3RhbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUg7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQVcsUUFBUSxDQUFDO0FBRTVDOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFXLE1BQU0sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxyXG4gKiBAbGljZW5zZVxyXG4gKiBDb3B5cmlnaHQgUGFzY2FsIEVDSEVNQU5OLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxyXG4gKlxyXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZSBmb3VuZCBpblxyXG4gKiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vcGFzY2FsZWNoZW1hbm4uY29tL2FuZ3VsYXItdG9vbGJveC9yZXNvdXJjZXMvbGljZW5zZVxyXG4gKi9cclxuXHJcbi8qKlxyXG4gKiBBIHJlZmVyZW5jZSB0byB0aGUgYFwiYnV0dG9uXCJgIHZhbHVlIG9mIHRoZSBgcm9sZWAgcHJvcGVydHkuXHJcbiAqL1xyXG5leHBvcnQgY29uc3QgQlVUVE9OX1JPTEU6IHN0cmluZyA9ICdidXR0b24nO1xyXG5cclxuLyoqXHJcbiAqIEEgcmVmZXJlbmNlIHRvIHRoZSBgXCJsaW5rXCJgIHZhbHVlIG9mIHRoZSBgcm9sZWAgcHJvcGVydHkuXHJcbiAqL1xyXG5leHBvcnQgY29uc3QgTElOS19ST0xFOiBzdHJpbmcgPSAnbGluayc7XHJcbiJdfQ==

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

@@ -0,0 +1,13 @@
+/**
+ * @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
+ */
+/**
+ * @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=

package/esm2022/lib/util/empty-string.const.mjs

@@ -0,0 +1,12 @@
+/**
+ * @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
+ */
+/**
+ * A reference to an immutable empty string.
+ */
+export const EMPTY_STRING = "";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1wdHktc3RyaW5nLmNvbnN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci10b29sYm94L3NyYy9saWIvdXRpbC9lbXB0eS1zdHJpbmcuY29uc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUg7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQVcsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXHJcbiAqIEBsaWNlbnNlXHJcbiAqIENvcHlyaWdodCBQYXNjYWwgRUNIRU1BTk4uIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXHJcbiAqXHJcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlIGZvdW5kIGluXHJcbiAqIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9wYXNjYWxlY2hlbWFubi5jb20vYW5ndWxhci10b29sYm94L3Jlc291cmNlcy9saWNlbnNlXHJcbiAqL1xyXG5cclxuLyoqXHJcbiAqIEEgcmVmZXJlbmNlIHRvIGFuIGltbXV0YWJsZSBlbXB0eSBzdHJpbmcuXHJcbiAqL1xyXG5leHBvcnQgY29uc3QgRU1QVFlfU1RSSU5HOiBzdHJpbmcgPSBcIlwiOyJdfQ==

package/esm2022/lib/util/index.mjs

@@ -0,0 +1,5 @@
+export * from './empty-string.const';
+export * from './aria-role.constant';
+export * from './uuid';
+export * from './js-type';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hbmd1bGFyLXRvb2xib3gvc3JjL2xpYi91dGlsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLFFBQVEsQ0FBQztBQUN2QixjQUFjLFdBQVcsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZW1wdHktc3RyaW5nLmNvbnN0JztcclxuZXhwb3J0ICogZnJvbSAnLi9hcmlhLXJvbGUuY29uc3RhbnQnO1xyXG5leHBvcnQgKiBmcm9tICcuL3V1aWQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2pzLXR5cGUnOyJdfQ==

package/esm2022/lib/util/js-type.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
+ */
+/**
+ * A reference to the `"undefined"` type.
+ */
+export const UNDEFINED = "undefined";
+/**
+ * A reference to the `"object"` type.
+ */
+export const OBJECT = "object";
+/**
+ * A reference to the `"boolean"` type.
+ */
+export const BOOLEAN = "boolean";
+/**
+ * A reference to the `"number"` type.
+ */
+export const NUMBER = "number";
+/**
+ * A reference to the `"bigint"` type.
+ */
+export const BIGINT = "bigint";
+/**
+ * A reference to the `"function"` type.
+ */
+export const FUNCTION = "function";
+/**
+ * A reference to the `"string"` type.
+ */
+export const STRING = "string";
+/**
+ * A reference to the `"symbol"` type.
+ */
+export const SYMBOL = "symbol";
+//# sourceMappingURL=data:application/json;base64,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