@odx/angular 6.0.0 → 6.1.0

package/esm2022/theming/lib/theming.config.mjs

@@ -2,11 +2,44 @@ import { ENVIRONMENT_INITIALIZER, inject, makeEnvironmentProviders } from '@angu
 import { createConfigTokens } from '@odx/angular/utils';
 import { Theme } from './models';
 import { ThemingService } from './theming.service';
+/**
+ * Utility created by `createConfigTokens` for managing theming configuration tokens and functions.
+ * Provides easy access to theming configuration, default values, and dependency injection utilities.
+ */
 export const { ThemingConfig, injectThemingConfig, provideThemingConfig } = createConfigTokens('Theming', '@odx/angular/theme', {
     autoDetect: false,
     defaultTheme: Theme.LIGHT,
     storage: null,
 });
+/**
+ * Provides the theming configuration to the application and initializes the `ThemingService`
+ * based on the provided configuration. This function simplifies the setup of a dynamic theming
+ * system, integrating with Angular's environment initializers to ensure proper initialization.
+ *
+ * @template D - The dependencies required by the theming configuration, if any.
+ * @param {ConfigProvider<Partial<ThemingConfig>, D>} config - The theming configuration or a configuration factory provider.
+ * @returns {EnvironmentProviders} An array of providers for setting up theming in the application.
+ *
+ * @example
+ * ```ts
+ * // Providing a simple theming configuration
+ * provideTheming({
+ *   autoDetect: true,
+ *   defaultTheme: Theme.DARK,
+ *   storage: localStorage,
+ * });
+ *
+ * // Providing a theming configuration with dependencies
+ * provideTheming({
+ *   useFactory: (deps: Dependencies) => ({
+ *     autoDetect: deps.setting,
+ *     defaultTheme: Theme.DARK,
+ *     storage: localStorage,
+ *   }),
+ *   deps: [SomeDependency],
+ * });
+ * ```
+ */
 export function provideTheming(config) {
     return makeEnvironmentProviders([
         provideThemingConfig(config),
@@ -18,4 +51,4 @@ export function provideTheming(config) {
         },
     ]);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/theming/lib/theming.service.mjs

@@ -7,24 +7,49 @@ import { Theme } from './models';
 import { injectThemingConfig } from './theming.config';
 import * as i0 from "@angular/core";
 export const THEME_ATTRIBUTE_NAME = 'odxTheme';
+/**
+ * Manages theming for the application. It allows for dynamic theme selection, automatically saves theme preferences,
+ * and applies the user's preferred theme or the default theme based on configuration settings.
+ *
+ * The service leverages the BehaviorSubject pattern to reactively handle theme changes across the application,
+ * ensuring that subscribers are notified whenever the theme changes. It also interacts with the DOM directly
+ * to apply the current theme and with the provided storage mechanism to persist theme preferences.
+ */
 export class ThemingService {
     constructor() {
         this.config = injectThemingConfig();
         this.document = inject(DOCUMENT);
         this.windowRef = inject(WindowRef);
         this.theme$$ = new BehaviorSubject(this.getInitialTheme());
+        /**
+         * An observable stream of the current theme, emitting values whenever the theme changes.
+         * Subscribers to this observable can react to theme changes in real-time.
+         */
         this.theme$ = this.theme$$.pipe(distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
         this.theme$.subscribe((theme) => {
             this.document.body.setAttribute(THEME_ATTRIBUTE_NAME, theme);
             saveTheme(this.config.storage, theme);
         });
     }
+    /**
+     * Selects and applies a given theme by updating the BehaviorSubject and persisting the preference.
+     *
+     * @param {Theme} theme - The theme to apply.
+     */
     selectTheme(theme) {
         this.theme$$.next(theme);
     }
+    /**
+     * Retrieves the currently selected theme.
+     *
+     * @returns {Theme} The currently selected theme.
+     */
     getSelectedTheme() {
         return this.theme$$.getValue();
     }
+    /**
+     * Toggles between dark and light themes, depending on the current theme.
+     */
     toggleDarkMode() {
         const currentTheme = this.getSelectedTheme();
         if (currentTheme === Theme.DARK) {
@@ -34,9 +59,15 @@ export class ThemingService {
             this.enableDarkMode();
         }
     }
+    /**
+     * Enables the dark mode theme.
+     */
     enableDarkMode() {
         this.selectTheme(Theme.DARK);
     }
+    /**
+     * Enables the light mode theme.
+     */
     enableLightMode() {
         this.selectTheme(Theme.LIGHT);
     }
@@ -54,4 +85,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/decorators/pure.mjs

@@ -1,3 +1,54 @@
+/**
+ * A decorator that transforms a class method or getter into a pure function. For methods, it caches the result
+ * of the first invocation with a given set of arguments and returns the cached result on subsequent invocations
+ * with the same arguments. For getters, it caches the result of the first access and returns the cached value
+ * on subsequent accesses.
+ *
+ * This decorator is intended to improve performance by avoiding unnecessary recalculations or processing
+ * when the inputs have not changed.
+ *
+ * @template T The type of the property being decorated.
+ * @param {object} _target The prototype of the class.
+ * @param {string} propertyKey The name of the method or getter.
+ * @param {TypedPropertyDescriptor<T>} descriptor The property descriptor for the method or getter.
+ * @throws {Error} Throws an error if applied to non-function properties.
+ * @returns {TypedPropertyDescriptor<T>} A new descriptor with the getter or method patched for pure behavior.
+ *
+ * @example
+ * Usage with a getter:
+ * ```ts
+ * class ExampleClass {
+ *   private _value: number = Math.random();
+ *
+ *   @Pure
+ *   get value(): number {
+ *     console.log('Getter called');
+ *     return this._value;
+ *   }
+ * }
+ *
+ * const example = new ExampleClass();
+ * console.log(example.value); // Logs 'Getter called' and the value
+ * console.log(example.value); // Logs only the value, without calling the getter again
+ * ```
+ *
+ * Usage with a method:
+ * ```ts
+ * class Counter {
+ *   private count = 0;
+ *
+ *   @Pure
+ *   increment(step: number) {
+ *     console.log('Increment called');
+ *     return (this.count += step);
+ *   }
+ * }
+ *
+ * const counter = new Counter();
+ * console.log(counter.increment(1)); // Logs 'Increment called' and 1
+ * console.log(counter.increment(1)); // Logs 1 without calling increment again
+ * ```
+ */
 export function Pure(_target, propertyKey, { get, enumerable, value }) {
     if (get) {
         return {
@@ -34,4 +85,4 @@ export function Pure(_target, propertyKey, { get, enumerable, value }) {
         },
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/helpers/angular.mjs

@@ -6,12 +6,28 @@ function reactiveBinding(updateFn) {
     const takeUntilDestroyed = untilDestroyed();
     return (source$) => source$.pipe(tap((state) => updateFn(state)), takeUntilDestroyed());
 }
+/**
+ * Binds an observable to toggle a CSS class on the host element based on the truthiness of the emitted values.
+ * The subscription automatically ends when the component is destroyed.
+ *
+ * @template T The type of items emitted by the source observable.
+ * @param {Observable<T> | null | undefined} source$ The observable source emitting truthy or falsy values.
+ * @param {string} cssClass The CSS class to toggle based on the emitted values.
+ */
 export function reactiveClassBinding(source$, cssClass) {
     const { nativeElement } = injectElement();
     if (source$) {
         source$.pipe(reactiveBinding((state) => nativeElement.classList.toggle(cssClass, !!state))).subscribe();
     }
 }
+/**
+ * Binds an observable to update attributes on the host element with the emitted values.
+ * The subscription automatically ends when the component is destroyed.
+ *
+ * @template T The type of items emitted by the source observable.
+ * @param {Observable<T> | null | undefined} source$ The observable source.
+ * @param {...string[]} attributes The attributes to set on the host element based on the emitted values.
+ */
 export function reactiveAttributeBinding(source$, ...attributes) {
     const { nativeElement } = injectElement();
     if (source$) {
@@ -24,13 +40,33 @@ export function reactiveAttributeBinding(source$, ...attributes) {
             .subscribe();
     }
 }
+/**
+ * Injects the ElementRef of the host element in an Angular component or directive.
+ *
+ * @template T The expected type of the native element.
+ * @returns {ElementRef<T>} The injected ElementRef instance.
+ */
 export function injectElement() {
     return inject(ElementRef);
 }
+/**
+ * Tracking function for use with `*ngFor` that tracks items by their index.
+ *
+ * @param {number} index The index of the item in the iterable.
+ * @returns {number} The index, used as the trackBy identity.
+ */
 export function trackByIndex(index) {
     return index;
 }
+/**
+ * Tracking function for use with `*ngFor` that tracks items by their unique ID.
+ *
+ * @template T The type of the items in the iterable, must have an 'id' property.
+ * @param {number} _ The index of the item in the iterable, not used.
+ * @param {T} item The item in the iterable.
+ * @returns {T['id']} The item's ID, used as the trackBy identity.
+ */
 export function trackById(_, { id }) {
     return id;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/helpers/array.mjs

@@ -8,8 +8,10 @@ import { isNumber, isString } from './type-guards';
  * @param {K} key - The key whose values are to be plucked from each object in the array.
  * @returns {Array<T[K]>} An array of values corresponding to the specified key from each object.
  * @example
+ * ```ts
  * const users = [{ name: 'Alice' }, { name: 'Bob' }];
  * const names = pluckFromArray(users, 'name'); // ['Alice', 'Bob']
+ * ```
  */
 export function pluckFromArray(arr, key) {
     return arr.map((value) => value[key]);
@@ -22,8 +24,10 @@ export function pluckFromArray(arr, key) {
  * @param {OrderByDirection} [direction='ASC'] - The direction to sort ('ASC' for ascending, 'DESC' for descending).
  * @returns {(a: T, b: T) => number} A compare function that can be used in the array sort method.
  * @example
+ * ```ts
  * const items = [{ value: 10 }, { value: 5 }, { value: 7 }];
  * const sortedItems = items.sort(orderBy('value', 'ASC')); // Sorted by value in ascending order
+ * ```
  */
 export function orderBy(key, direction = 'ASC') {
     return (a, b) => {
@@ -44,4 +48,4 @@ export function orderBy(key, direction = 'ASC') {
         return 0;
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/helpers/build-url.mjs

@@ -1,4 +1,24 @@
+/**
+ * Constructs a URL string from provided segments, ensuring proper slash separation without duplications.
+ * It gracefully handles `null`, `undefined`, and symbol values by omitting them from the final URL.
+ * Additionally, the function preserves the protocol part of the URL, if specified.
+ *
+ * @param {...Array<string | number | symbol | null | undefined>} args - The segments to concatenate into a URL.
+ * Can be a mix of strings, numbers, symbols (converted to strings), or `null`/`undefined` (which are omitted).
+ * @returns {string} The constructed URL string with correctly formatted slashes.
+ *
+ * @example
+ * ```ts
+ * // Basic usage
+ * console.log(buildUrl('http://example.com', 'path', 'to', 'resource'));
+ * // Outputs: "http://example.com/path/to/resource"
+ *
+ * // Removing duplicate slashes
+ * console.log(buildUrl('http://example.com/', '/path/', '//to', '/resource/'));
+ * // Outputs: "http://example.com/path/to/resource/"
+ * ```
+ */
 export function buildUrl(...args) {
     return args.join('/').replace(/(^.*)(https?:\/\/)|(\/)+/g, '$2$3');
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQtdXJsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3V0aWxzL3NyYy9saWIvaGVscGVycy9idWlsZC11cmwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxVQUFVLFFBQVEsQ0FBQyxHQUFHLElBQXdEO0lBQ2xGLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxPQUFPLENBQUMsMkJBQTJCLEVBQUUsTUFBTSxDQUFDLENBQUM7QUFDckUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBidWlsZFVybCguLi5hcmdzOiBBcnJheTxzdHJpbmcgfCBudW1iZXIgfCBzeW1ib2wgfCBudWxsIHwgdW5kZWZpbmVkPik6IHN0cmluZyB7XG4gIHJldHVybiBhcmdzLmpvaW4oJy8nKS5yZXBsYWNlKC8oXi4qKShodHRwcz86XFwvXFwvKXwoXFwvKSsvZywgJyQyJDMnKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGQtdXJsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3V0aWxzL3NyYy9saWIvaGVscGVycy9idWlsZC11cmwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FtQkc7QUFDSCxNQUFNLFVBQVUsUUFBUSxDQUFDLEdBQUcsSUFBd0Q7SUFDbEYsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLE9BQU8sQ0FBQywyQkFBMkIsRUFBRSxNQUFNLENBQUMsQ0FBQztBQUNyRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb25zdHJ1Y3RzIGEgVVJMIHN0cmluZyBmcm9tIHByb3ZpZGVkIHNlZ21lbnRzLCBlbnN1cmluZyBwcm9wZXIgc2xhc2ggc2VwYXJhdGlvbiB3aXRob3V0IGR1cGxpY2F0aW9ucy5cbiAqIEl0IGdyYWNlZnVsbHkgaGFuZGxlcyBgbnVsbGAsIGB1bmRlZmluZWRgLCBhbmQgc3ltYm9sIHZhbHVlcyBieSBvbWl0dGluZyB0aGVtIGZyb20gdGhlIGZpbmFsIFVSTC5cbiAqIEFkZGl0aW9uYWxseSwgdGhlIGZ1bmN0aW9uIHByZXNlcnZlcyB0aGUgcHJvdG9jb2wgcGFydCBvZiB0aGUgVVJMLCBpZiBzcGVjaWZpZWQuXG4gKlxuICogQHBhcmFtIHsuLi5BcnJheTxzdHJpbmcgfCBudW1iZXIgfCBzeW1ib2wgfCBudWxsIHwgdW5kZWZpbmVkPn0gYXJncyAtIFRoZSBzZWdtZW50cyB0byBjb25jYXRlbmF0ZSBpbnRvIGEgVVJMLlxuICogQ2FuIGJlIGEgbWl4IG9mIHN0cmluZ3MsIG51bWJlcnMsIHN5bWJvbHMgKGNvbnZlcnRlZCB0byBzdHJpbmdzKSwgb3IgYG51bGxgL2B1bmRlZmluZWRgICh3aGljaCBhcmUgb21pdHRlZCkuXG4gKiBAcmV0dXJucyB7c3RyaW5nfSBUaGUgY29uc3RydWN0ZWQgVVJMIHN0cmluZyB3aXRoIGNvcnJlY3RseSBmb3JtYXR0ZWQgc2xhc2hlcy5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIC8vIEJhc2ljIHVzYWdlXG4gKiBjb25zb2xlLmxvZyhidWlsZFVybCgnaHR0cDovL2V4YW1wbGUuY29tJywgJ3BhdGgnLCAndG8nLCAncmVzb3VyY2UnKSk7XG4gKiAvLyBPdXRwdXRzOiBcImh0dHA6Ly9leGFtcGxlLmNvbS9wYXRoL3RvL3Jlc291cmNlXCJcbiAqXG4gKiAvLyBSZW1vdmluZyBkdXBsaWNhdGUgc2xhc2hlc1xuICogY29uc29sZS5sb2coYnVpbGRVcmwoJ2h0dHA6Ly9leGFtcGxlLmNvbS8nLCAnL3BhdGgvJywgJy8vdG8nLCAnL3Jlc291cmNlLycpKTtcbiAqIC8vIE91dHB1dHM6IFwiaHR0cDovL2V4YW1wbGUuY29tL3BhdGgvdG8vcmVzb3VyY2UvXCJcbiAqIGBgYFxuICovXG5leHBvcnQgZnVuY3Rpb24gYnVpbGRVcmwoLi4uYXJnczogQXJyYXk8c3RyaW5nIHwgbnVtYmVyIHwgc3ltYm9sIHwgbnVsbCB8IHVuZGVmaW5lZD4pOiBzdHJpbmcge1xuICByZXR1cm4gYXJncy5qb2luKCcvJykucmVwbGFjZSgvKF4uKikoaHR0cHM/OlxcL1xcLyl8KFxcLykrL2csICckMiQzJyk7XG59XG4iXX0=

package/esm2022/utils/lib/helpers/build-website-url.mjs

@@ -16,14 +16,15 @@ export const DRAEGER_WEBSITE_URL = 'https://www.draeger.com';
  * @returns {string} The fully constructed URL, including the base URL and all provided path segments.
  *
  * @example
+ * ```ts
  * // Returns 'https://www.draeger.com/about-us'
  * const url = buildWebsiteUrl('about-us');
  *
- * @example
  * // Can also handle multiple segments, returning 'https://www.draeger.com/products/search/123'
  * const productUrl = buildWebsiteUrl('products', 'search', 123);
+ * ```
  */
 export function buildWebsiteUrl(...segments) {
     return buildUrl(DRAEGER_WEBSITE_URL, ...segments);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/helpers/cache-storage-client.mjs

@@ -1,21 +1,72 @@
+/**
+ * The HTTP 'Etag' header, used for web cache validation.
+ */
 export const HTTP_ETAG_HEADER = 'Etag';
+/**
+ * The HTTP 'If-None-Match' header, used in conditional requests to compare against the ETag.
+ */
 export const HTTP_IF_NONE_MATCH_HEADER = 'If-None-Match';
+/**
+ * The HTTP 'Cache-Control' header, used to specify directives for caching mechanisms in requests and responses.
+ */
 export const HTTP_CACHE_CONTROL_HEADER = 'Cache-Control';
+/**
+ * A client for managing cache storage for web applications. It simplifies interactions with the Cache Storage API,
+ * allowing for the caching, retrieval, and deletion of request responses. This class uses HTTP caching headers to
+ * optimize network requests and cache management.
+ *
+ * @example
+ * ```ts
+ * // Creating an instance of CacheStorageClient
+ * const cacheClient = new CacheStorageClient('my-cache');
+ *
+ * // Requesting and caching data
+ * cacheClient.request('https://api.example.com/data').then(data => {
+ *   console.log(data);
+ * });
+ *
+ * // Deleting a specific cache entry
+ * cacheClient.delete('https://api.example.com/data');
+ *
+ * // Clearing all cache entries
+ * cacheClient.deleteAll();
+ * ```
+ */
 export class CacheStorageClient {
     constructor(cacheKey, cacheStorage = window.caches) {
         this.cacheKey = cacheKey;
         this.cacheStorage = cacheStorage;
     }
+    /**
+     * Deletes a specific cache entry.
+     *
+     * @param {RequestInfo | URL} request - The request or URL to delete from the cache.
+     * @returns {Promise<boolean>} A promise that resolves to a boolean indicating whether the deletion was successful.
+     */
     async delete(request) {
         const cache = await this.getCache();
         return cache.delete(request);
     }
+    /**
+     * Deletes all entries from the cache.
+     *
+     * @returns {Promise<void>} A promise that resolves when all entries have been deleted.
+     */
     async deleteAll() {
         const cache = await this.getCache();
         for (const key of await cache.keys()) {
             await cache.delete(key);
         }
     }
+    /**
+     * Performs a request, caching the response if applicable. If a response is cached for the request and still valid,
+     * it returns the cached response instead of making a new network request.
+     *
+     * @template T - The expected response data type.
+     * @param {RequestInfo | URL} requestInfo - The request information or URL to fetch and cache.
+     * @param {(response: Response) => boolean} [shouldDelete=({ status }) => status >= 400 && status < 500] - An optional function to determine if the cache entry should be deleted based on the response.
+     * @returns {Promise<T | null>} A promise that resolves to the response data, or null if the request fails.
+     */
     async request(requestInfo, shouldDelete = ({ status }) => status >= 400 && status < 500) {
         const cache = await this.getCache();
         const request = await this.prepareRequest(cache, requestInfo);
@@ -50,4 +101,4 @@ export class CacheStorageClient {
         return cache.match(request).then((res) => res ?? null);
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGUtc3RvcmFnZS1jbGllbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2NhY2hlLXN0b3JhZ2UtY2xpZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLE1BQU0sQ0FBQztBQUN2QyxNQUFNLENBQUMsTUFBTSx5QkFBeUIsR0FBRyxlQUFlLENBQUM7QUFDekQsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQUcsZUFBZSxDQUFDO0FBRXpELE1BQU0sT0FBTyxrQkFBa0I7SUFDN0IsWUFDbUIsUUFBZ0IsRUFDaEIsZUFBZSxNQUFNLENBQUMsTUFBTTtRQUQ1QixhQUFRLEdBQVIsUUFBUSxDQUFRO1FBQ2hCLGlCQUFZLEdBQVosWUFBWSxDQUFnQjtJQUM1QyxDQUFDO0lBRUcsS0FBSyxDQUFDLE1BQU0sQ0FBQyxPQUEwQjtRQUM1QyxNQUFNLEtBQUssR0FBRyxNQUFNLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUVwQyxPQUFPLEtBQUssQ0FBQyxNQUFNLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUVNLEtBQUssQ0FBQyxTQUFTO1FBQ3BCLE1BQU0sS0FBSyxHQUFHLE1BQU0sSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ3BDLEtBQUssTUFBTSxHQUFHLElBQUksTUFBTSxLQUFLLENBQUMsSUFBSSxFQUFFLEVBQUU7WUFDcEMsTUFBTSxLQUFLLENBQUMsTUFBTSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1NBQ3pCO0lBQ0gsQ0FBQztJQUVNLEtBQUssQ0FBQyxPQUFPLENBQUksV0FBOEIsRUFBRSxlQUFlLENBQUMsRUFBRSxNQUFNLEVBQVksRUFBRSxFQUFFLENBQUMsTUFBTSxJQUFJLEdBQUcsSUFBSSxNQUFNLEdBQUcsR0FBRztRQUM1SCxNQUFNLEtBQUssR0FBRyxNQUFNLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUNwQyxNQUFNLE9BQU8sR0FBRyxNQUFNLElBQUksQ0FBQyxjQUFjLENBQUMsS0FBSyxFQUFFLFdBQVcsQ0FBQyxDQUFDO1FBQzlELE1BQU0sUUFBUSxHQUFHLE1BQU0sSUFBSSxDQUFDLFdBQVcsQ0FBQyxLQUFLLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDeEQsSUFBSSxRQUFRLElBQUksWUFBWSxFQUFFLENBQUMsUUFBUSxDQUFDLEVBQUU7WUFDeEMsTUFBTSxLQUFLLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1NBQzdCO1FBQ0QsT0FBTyxRQUFRLEVBQUUsSUFBSSxFQUFFLElBQUksSUFBSSxDQUFDO0lBQ2xDLENBQUM7SUFFUyxLQUFLLENBQUMsUUFBUTtRQUN0QixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUMvQyxDQUFDO0lBRVMsS0FBSyxDQUFDLGNBQWMsQ0FBQyxLQUFZLEVBQUUsV0FBOEI7UUFDekUsTUFBTSxjQUFjLEdBQUcsTUFBTSxLQUFLLENBQUMsS0FBSyxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQ3RELE1BQU0sSUFBSSxHQUFHLGNBQWMsRUFBRSxPQUFPLEVBQUUsR0FBRyxDQUFDLGdCQUFnQixDQUFDLElBQUksSUFBSSxDQUFDO1FBQ3BFLE1BQU0sT0FBTyxHQUFHLElBQUksT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQUFDO1FBQ3pDLElBQUksSUFBSSxFQUFFO1lBQ1IsT0FBTyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMseUJBQXlCLEVBQUUsSUFBSSxDQUFDLENBQUM7U0FDdEQ7UUFFRCxPQUFPLE9BQU8sQ0FBQztJQUNqQixDQUFDO0lBRVMsS0FBSyxDQUFDLFdBQVcsQ0FBQyxLQUFZLEVBQUUsT0FBZ0I7UUFDeEQsTUFBTSxRQUFRLEdBQUcsTUFBTSxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ3hELE1BQU0sWUFBWSxHQUFHLFFBQVEsRUFBRSxPQUFPLEVBQUUsR0FBRyxDQUFDLHlCQUF5QixDQUFDLENBQUM7UUFDdkUsSUFBSSxZQUFZLEtBQUssVUFBVSxFQUFFO1lBQy9CLE1BQU0sS0FBSyxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUU1QixPQUFPLFFBQVEsQ0FBQztTQUNqQjtRQUNELElBQUksUUFBUSxFQUFFLEVBQUUsRUFBRTtZQUNoQixNQUFNLEtBQUssQ0FBQyxHQUFHLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUUsQ0FBQyxJQUFJLENBQUMsQ0FBQztTQUN0RDtRQUVELE9BQU8sS0FBSyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLEdBQUcsSUFBSSxJQUFJLENBQUMsQ0FBQztJQUN6RCxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgSFRUUF9FVEFHX0hFQURFUiA9ICdFdGFnJztcbmV4cG9ydCBjb25zdCBIVFRQX0lGX05PTkVfTUFUQ0hfSEVBREVSID0gJ0lmLU5vbmUtTWF0Y2gnO1xuZXhwb3J0IGNvbnN0IEhUVFBfQ0FDSEVfQ09OVFJPTF9IRUFERVIgPSAnQ2FjaGUtQ29udHJvbCc7XG5cbmV4cG9ydCBjbGFzcyBDYWNoZVN0b3JhZ2VDbGllbnQge1xuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIHJlYWRvbmx5IGNhY2hlS2V5OiBzdHJpbmcsXG4gICAgcHJpdmF0ZSByZWFkb25seSBjYWNoZVN0b3JhZ2UgPSB3aW5kb3cuY2FjaGVzLFxuICApIHt9XG5cbiAgcHVibGljIGFzeW5jIGRlbGV0ZShyZXF1ZXN0OiBSZXF1ZXN0SW5mbyB8IFVSTCk6IFByb21pc2U8Ym9vbGVhbj4ge1xuICAgIGNvbnN0IGNhY2hlID0gYXdhaXQgdGhpcy5nZXRDYWNoZSgpO1xuXG4gICAgcmV0dXJuIGNhY2hlLmRlbGV0ZShyZXF1ZXN0KTtcbiAgfVxuXG4gIHB1YmxpYyBhc3luYyBkZWxldGVBbGwoKTogUHJvbWlzZTx2b2lkPiB7XG4gICAgY29uc3QgY2FjaGUgPSBhd2FpdCB0aGlzLmdldENhY2hlKCk7XG4gICAgZm9yIChjb25zdCBrZXkgb2YgYXdhaXQgY2FjaGUua2V5cygpKSB7XG4gICAgICBhd2FpdCBjYWNoZS5kZWxldGUoa2V5KTtcbiAgICB9XG4gIH1cblxuICBwdWJsaWMgYXN5bmMgcmVxdWVzdDxUPihyZXF1ZXN0SW5mbzogUmVxdWVzdEluZm8gfCBVUkwsIHNob3VsZERlbGV0ZSA9ICh7IHN0YXR1cyB9OiBSZXNwb25zZSkgPT4gc3RhdHVzID49IDQwMCAmJiBzdGF0dXMgPCA1MDApOiBQcm9taXNlPFQgfCBudWxsPiB7XG4gICAgY29uc3QgY2FjaGUgPSBhd2FpdCB0aGlzLmdldENhY2hlKCk7XG4gICAgY29uc3QgcmVxdWVzdCA9IGF3YWl0IHRoaXMucHJlcGFyZVJlcXVlc3QoY2FjaGUsIHJlcXVlc3RJbmZvKTtcbiAgICBjb25zdCByZXNwb25zZSA9IGF3YWl0IHRoaXMuc2VuZFJlcXVlc3QoY2FjaGUsIHJlcXVlc3QpO1xuICAgIGlmIChyZXNwb25zZSAmJiBzaG91bGREZWxldGU/LihyZXNwb25zZSkpIHtcbiAgICAgIGF3YWl0IGNhY2hlLmRlbGV0ZShyZXF1ZXN0KTtcbiAgICB9XG4gICAgcmV0dXJuIHJlc3BvbnNlPy5qc29uKCkgPz8gbnVsbDtcbiAgfVxuXG4gIHByb3RlY3RlZCBhc3luYyBnZXRDYWNoZSgpOiBQcm9taXNlPENhY2hlPiB7XG4gICAgcmV0dXJuIHRoaXMuY2FjaGVTdG9yYWdlLm9wZW4odGhpcy5jYWNoZUtleSk7XG4gIH1cblxuICBwcm90ZWN0ZWQgYXN5bmMgcHJlcGFyZVJlcXVlc3QoY2FjaGU6IENhY2hlLCByZXF1ZXN0SW5mbzogUmVxdWVzdEluZm8gfCBVUkwpOiBQcm9taXNlPFJlcXVlc3Q+IHtcbiAgICBjb25zdCBjYWNoZWRSZXNwb25zZSA9IGF3YWl0IGNhY2hlLm1hdGNoKHJlcXVlc3RJbmZvKTtcbiAgICBjb25zdCBldGFnID0gY2FjaGVkUmVzcG9uc2U/LmhlYWRlcnM/LmdldChIVFRQX0VUQUdfSEVBREVSKSA/PyBudWxsO1xuICAgIGNvbnN0IHJlcXVlc3QgPSBuZXcgUmVxdWVzdChyZXF1ZXN0SW5mbyk7XG4gICAgaWYgKGV0YWcpIHtcbiAgICAgIHJlcXVlc3QuaGVhZGVycy5zZXQoSFRUUF9JRl9OT05FX01BVENIX0hFQURFUiwgZXRhZyk7XG4gICAgfVxuXG4gICAgcmV0dXJuIHJlcXVlc3Q7XG4gIH1cblxuICBwcm90ZWN0ZWQgYXN5bmMgc2VuZFJlcXVlc3QoY2FjaGU6IENhY2hlLCByZXF1ZXN0OiBSZXF1ZXN0KTogUHJvbWlzZTxSZXNwb25zZSB8IG51bGw+IHtcbiAgICBjb25zdCByZXNwb25zZSA9IGF3YWl0IGZldGNoKHJlcXVlc3QpLmNhdGNoKCgpID0+IG51bGwpO1xuICAgIGNvbnN0IGNhY2hlQ29udHJvbCA9IHJlc3BvbnNlPy5oZWFkZXJzPy5nZXQoSFRUUF9DQUNIRV9DT05UUk9MX0hFQURFUik7XG4gICAgaWYgKGNhY2hlQ29udHJvbCA9PT0gJ25vLWNhY2hlJykge1xuICAgICAgYXdhaXQgY2FjaGUuZGVsZXRlKHJlcXVlc3QpO1xuXG4gICAgICByZXR1cm4gcmVzcG9uc2U7XG4gICAgfVxuICAgIGlmIChyZXNwb25zZT8ub2spIHtcbiAgICAgIGF3YWl0IGNhY2hlLnB1dChyZXF1ZXN0LCByZXNwb25zZSkuY2F0Y2goKCkgPT4gbnVsbCk7XG4gICAgfVxuXG4gICAgcmV0dXJuIGNhY2hlLm1hdGNoKHJlcXVlc3QpLnRoZW4oKHJlcykgPT4gcmVzID8/IG51bGwpO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cache-storage-client.js","sourceRoot":"","sources":["../../../../../../../libs/angular/utils/src/lib/helpers/cache-storage-client.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,MAAM,CAAC;AAEvC;;GAEG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,eAAe,CAAC;AAEzD;;GAEG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,eAAe,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,kBAAkB;IAC7B,YACmB,QAAgB,EAChB,eAAe,MAAM,CAAC,MAAM;QAD5B,aAAQ,GAAR,QAAQ,CAAQ;QAChB,iBAAY,GAAZ,YAAY,CAAgB;IAC5C,CAAC;IAEJ;;;;;OAKG;IACI,KAAK,CAAC,MAAM,CAAC,OAA0B;QAC5C,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;QAEpC,OAAO,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC/B,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,SAAS;QACpB,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;QACpC,KAAK,MAAM,GAAG,IAAI,MAAM,KAAK,CAAC,IAAI,EAAE,EAAE;YACpC,MAAM,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;SACzB;IACH,CAAC;IAED;;;;;;;;OAQG;IACI,KAAK,CAAC,OAAO,CAAI,WAA8B,EAAE,eAAe,CAAC,EAAE,MAAM,EAAY,EAAE,EAAE,CAAC,MAAM,IAAI,GAAG,IAAI,MAAM,GAAG,GAAG;QAC5H,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;QACpC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;QAC9D,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;QACxD,IAAI,QAAQ,IAAI,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE;YACxC,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;SAC7B;QACD,OAAO,QAAQ,EAAE,IAAI,EAAE,IAAI,IAAI,CAAC;IAClC,CAAC;IAES,KAAK,CAAC,QAAQ;QACtB,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC/C,CAAC;IAES,KAAK,CAAC,cAAc,CAAC,KAAY,EAAE,WAA8B;QACzE,MAAM,cAAc,GAAG,MAAM,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;QACtD,MAAM,IAAI,GAAG,cAAc,EAAE,OAAO,EAAE,GAAG,CAAC,gBAAgB,CAAC,IAAI,IAAI,CAAC;QACpE,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,WAAW,CAAC,CAAC;QACzC,IAAI,IAAI,EAAE;YACR,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,yBAAyB,EAAE,IAAI,CAAC,CAAC;SACtD;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAES,KAAK,CAAC,WAAW,CAAC,KAAY,EAAE,OAAgB;QACxD,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,OAAO,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;QACxD,MAAM,YAAY,GAAG,QAAQ,EAAE,OAAO,EAAE,GAAG,CAAC,yBAAyB,CAAC,CAAC;QACvE,IAAI,YAAY,KAAK,UAAU,EAAE;YAC/B,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAE5B,OAAO,QAAQ,CAAC;SACjB;QACD,IAAI,QAAQ,EAAE,EAAE,EAAE;YAChB,MAAM,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;SACtD;QAED,OAAO,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,IAAI,CAAC,CAAC;IACzD,CAAC;CACF","sourcesContent":["/**\n * The HTTP 'Etag' header, used for web cache validation.\n */\nexport const HTTP_ETAG_HEADER = 'Etag';\n\n/**\n * The HTTP 'If-None-Match' header, used in conditional requests to compare against the ETag.\n */\nexport const HTTP_IF_NONE_MATCH_HEADER = 'If-None-Match';\n\n/**\n * The HTTP 'Cache-Control' header, used to specify directives for caching mechanisms in requests and responses.\n */\nexport const HTTP_CACHE_CONTROL_HEADER = 'Cache-Control';\n\n/**\n * A client for managing cache storage for web applications. It simplifies interactions with the Cache Storage API,\n * allowing for the caching, retrieval, and deletion of request responses. This class uses HTTP caching headers to\n * optimize network requests and cache management.\n *\n * @example\n * ```ts\n * // Creating an instance of CacheStorageClient\n * const cacheClient = new CacheStorageClient('my-cache');\n *\n * // Requesting and caching data\n * cacheClient.request('https://api.example.com/data').then(data => {\n *   console.log(data);\n * });\n *\n * // Deleting a specific cache entry\n * cacheClient.delete('https://api.example.com/data');\n *\n * // Clearing all cache entries\n * cacheClient.deleteAll();\n * ```\n */\nexport class CacheStorageClient {\n  constructor(\n    private readonly cacheKey: string,\n    private readonly cacheStorage = window.caches,\n  ) {}\n\n  /**\n   * Deletes a specific cache entry.\n   *\n   * @param {RequestInfo | URL} request - The request or URL to delete from the cache.\n   * @returns {Promise<boolean>} A promise that resolves to a boolean indicating whether the deletion was successful.\n   */\n  public async delete(request: RequestInfo | URL): Promise<boolean> {\n    const cache = await this.getCache();\n\n    return cache.delete(request);\n  }\n\n  /**\n   * Deletes all entries from the cache.\n   *\n   * @returns {Promise<void>} A promise that resolves when all entries have been deleted.\n   */\n  public async deleteAll(): Promise<void> {\n    const cache = await this.getCache();\n    for (const key of await cache.keys()) {\n      await cache.delete(key);\n    }\n  }\n\n  /**\n   * Performs a request, caching the response if applicable. If a response is cached for the request and still valid,\n   * it returns the cached response instead of making a new network request.\n   *\n   * @template T - The expected response data type.\n   * @param {RequestInfo | URL} requestInfo - The request information or URL to fetch and cache.\n   * @param {(response: Response) => boolean} [shouldDelete=({ status }) => status >= 400 && status < 500] - An optional function to determine if the cache entry should be deleted based on the response.\n   * @returns {Promise<T | null>} A promise that resolves to the response data, or null if the request fails.\n   */\n  public async request<T>(requestInfo: RequestInfo | URL, shouldDelete = ({ status }: Response) => status >= 400 && status < 500): Promise<T | null> {\n    const cache = await this.getCache();\n    const request = await this.prepareRequest(cache, requestInfo);\n    const response = await this.sendRequest(cache, request);\n    if (response && shouldDelete?.(response)) {\n      await cache.delete(request);\n    }\n    return response?.json() ?? null;\n  }\n\n  protected async getCache(): Promise<Cache> {\n    return this.cacheStorage.open(this.cacheKey);\n  }\n\n  protected async prepareRequest(cache: Cache, requestInfo: RequestInfo | URL): Promise<Request> {\n    const cachedResponse = await cache.match(requestInfo);\n    const etag = cachedResponse?.headers?.get(HTTP_ETAG_HEADER) ?? null;\n    const request = new Request(requestInfo);\n    if (etag) {\n      request.headers.set(HTTP_IF_NONE_MATCH_HEADER, etag);\n    }\n\n    return request;\n  }\n\n  protected async sendRequest(cache: Cache, request: Request): Promise<Response | null> {\n    const response = await fetch(request).catch(() => null);\n    const cacheControl = response?.headers?.get(HTTP_CACHE_CONTROL_HEADER);\n    if (cacheControl === 'no-cache') {\n      await cache.delete(request);\n\n      return response;\n    }\n    if (response?.ok) {\n      await cache.put(request, response).catch(() => null);\n    }\n\n    return cache.match(request).then((res) => res ?? null);\n  }\n}\n"]}

package/esm2022/utils/lib/helpers/coercion.mjs

@@ -1,6 +1,23 @@
 import { coerceArray } from '@angular/cdk/coercion';
+/**
+ * Coerces a value to an array. If the value is already an array, it is returned directly.
+ * If the value is not an array, it is wrapped in an array. This utility is useful for
+ * handling values that can be either single values or arrays, ensuring consistent array handling.
+ *
+ * @param {string | string[]} value - The value to coerce to an array. Can be a single string or an array of strings.
+ * @returns {string[]} The coerced value as an array of strings.
+ *
+ * @example
+ * ```ts
+ * // Coercing a single string to an array
+ * console.log(arrayAttribute('singleValue')); // Outputs: ['singleValue']
+ *
+ * // Returning an array directly
+ * console.log(arrayAttribute(['value1', 'value2'])); // Outputs: ['value1', 'value2']
+ * ```
+ */
 export function arrayAttribute(value) {
     return coerceArray(value);
 }
 export { coerceArray, coerceCssPixelValue, coerceElement, coerceStringArray } from '@angular/cdk/coercion';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29lcmNpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2NvZXJjaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUVwRCxNQUFNLFVBQVUsY0FBYyxDQUFDLEtBQXdCO0lBQ3JELE9BQU8sV0FBVyxDQUFTLEtBQUssQ0FBQyxDQUFDO0FBQ3BDLENBQUM7QUFFRCxPQUFPLEVBQUUsV0FBVyxFQUFFLG1CQUFtQixFQUFFLGFBQWEsRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY29lcmNlQXJyYXkgfSBmcm9tICdAYW5ndWxhci9jZGsvY29lcmNpb24nO1xuXG5leHBvcnQgZnVuY3Rpb24gYXJyYXlBdHRyaWJ1dGUodmFsdWU6IHN0cmluZyB8IHN0cmluZ1tdKTogc3RyaW5nW10ge1xuICByZXR1cm4gY29lcmNlQXJyYXk8c3RyaW5nPih2YWx1ZSk7XG59XG5cbmV4cG9ydCB7IGNvZXJjZUFycmF5LCBjb2VyY2VDc3NQaXhlbFZhbHVlLCBjb2VyY2VFbGVtZW50LCBjb2VyY2VTdHJpbmdBcnJheSB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9jb2VyY2lvbic7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29lcmNpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2NvZXJjaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUVwRDs7Ozs7Ozs7Ozs7Ozs7OztHQWdCRztBQUNILE1BQU0sVUFBVSxjQUFjLENBQUMsS0FBd0I7SUFDckQsT0FBTyxXQUFXLENBQVMsS0FBSyxDQUFDLENBQUM7QUFDcEMsQ0FBQztBQUVELE9BQU8sRUFBRSxXQUFXLEVBQUUsbUJBQW1CLEVBQUUsYUFBYSxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjb2VyY2VBcnJheSB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9jb2VyY2lvbic7XG5cbi8qKlxuICogQ29lcmNlcyBhIHZhbHVlIHRvIGFuIGFycmF5LiBJZiB0aGUgdmFsdWUgaXMgYWxyZWFkeSBhbiBhcnJheSwgaXQgaXMgcmV0dXJuZWQgZGlyZWN0bHkuXG4gKiBJZiB0aGUgdmFsdWUgaXMgbm90IGFuIGFycmF5LCBpdCBpcyB3cmFwcGVkIGluIGFuIGFycmF5LiBUaGlzIHV0aWxpdHkgaXMgdXNlZnVsIGZvclxuICogaGFuZGxpbmcgdmFsdWVzIHRoYXQgY2FuIGJlIGVpdGhlciBzaW5nbGUgdmFsdWVzIG9yIGFycmF5cywgZW5zdXJpbmcgY29uc2lzdGVudCBhcnJheSBoYW5kbGluZy5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZyB8IHN0cmluZ1tdfSB2YWx1ZSAtIFRoZSB2YWx1ZSB0byBjb2VyY2UgdG8gYW4gYXJyYXkuIENhbiBiZSBhIHNpbmdsZSBzdHJpbmcgb3IgYW4gYXJyYXkgb2Ygc3RyaW5ncy5cbiAqIEByZXR1cm5zIHtzdHJpbmdbXX0gVGhlIGNvZXJjZWQgdmFsdWUgYXMgYW4gYXJyYXkgb2Ygc3RyaW5ncy5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIC8vIENvZXJjaW5nIGEgc2luZ2xlIHN0cmluZyB0byBhbiBhcnJheVxuICogY29uc29sZS5sb2coYXJyYXlBdHRyaWJ1dGUoJ3NpbmdsZVZhbHVlJykpOyAvLyBPdXRwdXRzOiBbJ3NpbmdsZVZhbHVlJ11cbiAqXG4gKiAvLyBSZXR1cm5pbmcgYW4gYXJyYXkgZGlyZWN0bHlcbiAqIGNvbnNvbGUubG9nKGFycmF5QXR0cmlidXRlKFsndmFsdWUxJywgJ3ZhbHVlMiddKSk7IC8vIE91dHB1dHM6IFsndmFsdWUxJywgJ3ZhbHVlMiddXG4gKiBgYGBcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGFycmF5QXR0cmlidXRlKHZhbHVlOiBzdHJpbmcgfCBzdHJpbmdbXSk6IHN0cmluZ1tdIHtcbiAgcmV0dXJuIGNvZXJjZUFycmF5PHN0cmluZz4odmFsdWUpO1xufVxuXG5leHBvcnQgeyBjb2VyY2VBcnJheSwgY29lcmNlQ3NzUGl4ZWxWYWx1ZSwgY29lcmNlRWxlbWVudCwgY29lcmNlU3RyaW5nQXJyYXkgfSBmcm9tICdAYW5ndWxhci9jZGsvY29lcmNpb24nO1xuIl19

package/esm2022/utils/lib/helpers/debounce.mjs

@@ -1,3 +1,30 @@
+/**
+ * Creates a debounced function that delays invoking the provided function until after `delay` milliseconds
+ * have elapsed since the last time the debounced function was invoked. Optionally, the function can be
+ * triggered immediately on the first call, then debounced for subsequent calls.
+ *
+ * @template Args - A tuple representing the types of arguments the `func` accepts.
+ * @param {(...args: Args) => void} func - The function to debounce.
+ * @param {number} delay - The number of milliseconds to delay.
+ * @param {boolean} [immediate=false] - Whether to trigger the function immediately on the first call,
+ * and then debounce subsequent calls.
+ * @returns {(...args: Args) => void} A new, debounced function.
+ *
+ * @example
+ * ```ts
+ * // Example usage with a window resize event
+ * const handleResize = debounce(() => {
+ *   console.log('Window resized');
+ * }, 250);
+ * window.addEventListener('resize', handleResize);
+ *
+ * // Example using immediate invocation
+ * const processKeyPress = debounce((event) => {
+ *   console.log('Key pressed:', event.key);
+ * }, 200, true);
+ * document.addEventListener('keypress', processKeyPress);
+ * ```
+ */
 export function debounce(func, delay, immediate = false) {
     let timeout = null;
     return function (...args) {
@@ -18,4 +45,4 @@ export function debounce(func, delay, immediate = false) {
         }
     };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVib3VuY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2RlYm91bmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxRQUFRLENBQXlCLElBQTZCLEVBQUUsS0FBYSxFQUFFLFNBQVMsR0FBRyxLQUFLO0lBQzlHLElBQUksT0FBTyxHQUFrQixJQUFJLENBQUM7SUFFbEMsT0FBTyxVQUF5QixHQUFHLElBQVU7UUFDM0MsNERBQTREO1FBQzVELE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQztRQUNyQixNQUFNLGVBQWUsR0FBRyxTQUFTLElBQUksT0FBTyxLQUFLLElBQUksQ0FBQztRQUN0RCxJQUFJLE9BQU8sS0FBSyxJQUFJLEVBQUU7WUFDcEIsWUFBWSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1NBQ3ZCO1FBQ0QsT0FBTyxHQUFHLFVBQVUsQ0FBQztZQUNuQixPQUFPLEdBQUcsSUFBSSxDQUFDO1lBQ2YsSUFBSSxDQUFDLGVBQWUsRUFBRTtnQkFDcEIsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLENBQUM7YUFDM0I7UUFDSCxDQUFDLEVBQUUsS0FBSyxDQUFzQixDQUFDO1FBQy9CLElBQUksZUFBZSxFQUFFO1lBQ25CLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxDQUFDO1NBQzNCO0lBQ0gsQ0FBQyxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBkZWJvdW5jZTxBcmdzIGV4dGVuZHMgdW5rbm93bltdPihmdW5jOiAoLi4uYXJnczogQXJncykgPT4gdm9pZCwgZGVsYXk6IG51bWJlciwgaW1tZWRpYXRlID0gZmFsc2UpOiAoLi4uYXJnczogQXJncykgPT4gdm9pZCB7XG4gIGxldCB0aW1lb3V0OiBudW1iZXIgfCBudWxsID0gbnVsbDtcblxuICByZXR1cm4gZnVuY3Rpb24gKHRoaXM6IHVua25vd24sIC4uLmFyZ3M6IEFyZ3MpIHtcbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXRoaXMtYWxpYXNcbiAgICBjb25zdCBjb250ZXh0ID0gdGhpcztcbiAgICBjb25zdCBjYWxsSW1tZWRpYXRlbHkgPSBpbW1lZGlhdGUgJiYgdGltZW91dCA9PT0gbnVsbDtcbiAgICBpZiAodGltZW91dCAhPT0gbnVsbCkge1xuICAgICAgY2xlYXJUaW1lb3V0KHRpbWVvdXQpO1xuICAgIH1cbiAgICB0aW1lb3V0ID0gc2V0VGltZW91dChmdW5jdGlvbiAoKSB7XG4gICAgICB0aW1lb3V0ID0gbnVsbDtcbiAgICAgIGlmICghY2FsbEltbWVkaWF0ZWx5KSB7XG4gICAgICAgIGZ1bmMuYXBwbHkoY29udGV4dCwgYXJncyk7XG4gICAgICB9XG4gICAgfSwgZGVsYXkpIGFzIHVua25vd24gYXMgbnVtYmVyO1xuICAgIGlmIChjYWxsSW1tZWRpYXRlbHkpIHtcbiAgICAgIGZ1bmMuYXBwbHkoY29udGV4dCwgYXJncyk7XG4gICAgfVxuICB9O1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVib3VuY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2RlYm91bmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQTBCRztBQUNILE1BQU0sVUFBVSxRQUFRLENBQXlCLElBQTZCLEVBQUUsS0FBYSxFQUFFLFNBQVMsR0FBRyxLQUFLO0lBQzlHLElBQUksT0FBTyxHQUFrQixJQUFJLENBQUM7SUFFbEMsT0FBTyxVQUF5QixHQUFHLElBQVU7UUFDM0MsNERBQTREO1FBQzVELE1BQU0sT0FBTyxHQUFHLElBQUksQ0FBQztRQUNyQixNQUFNLGVBQWUsR0FBRyxTQUFTLElBQUksT0FBTyxLQUFLLElBQUksQ0FBQztRQUN0RCxJQUFJLE9BQU8sS0FBSyxJQUFJLEVBQUU7WUFDcEIsWUFBWSxDQUFDLE9BQU8sQ0FBQyxDQUFDO1NBQ3ZCO1FBQ0QsT0FBTyxHQUFHLFVBQVUsQ0FBQztZQUNuQixPQUFPLEdBQUcsSUFBSSxDQUFDO1lBQ2YsSUFBSSxDQUFDLGVBQWUsRUFBRTtnQkFDcEIsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLENBQUM7YUFDM0I7UUFDSCxDQUFDLEVBQUUsS0FBSyxDQUFzQixDQUFDO1FBQy9CLElBQUksZUFBZSxFQUFFO1lBQ25CLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxDQUFDO1NBQzNCO0lBQ0gsQ0FBQyxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ3JlYXRlcyBhIGRlYm91bmNlZCBmdW5jdGlvbiB0aGF0IGRlbGF5cyBpbnZva2luZyB0aGUgcHJvdmlkZWQgZnVuY3Rpb24gdW50aWwgYWZ0ZXIgYGRlbGF5YCBtaWxsaXNlY29uZHNcbiAqIGhhdmUgZWxhcHNlZCBzaW5jZSB0aGUgbGFzdCB0aW1lIHRoZSBkZWJvdW5jZWQgZnVuY3Rpb24gd2FzIGludm9rZWQuIE9wdGlvbmFsbHksIHRoZSBmdW5jdGlvbiBjYW4gYmVcbiAqIHRyaWdnZXJlZCBpbW1lZGlhdGVseSBvbiB0aGUgZmlyc3QgY2FsbCwgdGhlbiBkZWJvdW5jZWQgZm9yIHN1YnNlcXVlbnQgY2FsbHMuXG4gKlxuICogQHRlbXBsYXRlIEFyZ3MgLSBBIHR1cGxlIHJlcHJlc2VudGluZyB0aGUgdHlwZXMgb2YgYXJndW1lbnRzIHRoZSBgZnVuY2AgYWNjZXB0cy5cbiAqIEBwYXJhbSB7KC4uLmFyZ3M6IEFyZ3MpID0+IHZvaWR9IGZ1bmMgLSBUaGUgZnVuY3Rpb24gdG8gZGVib3VuY2UuXG4gKiBAcGFyYW0ge251bWJlcn0gZGVsYXkgLSBUaGUgbnVtYmVyIG9mIG1pbGxpc2Vjb25kcyB0byBkZWxheS5cbiAqIEBwYXJhbSB7Ym9vbGVhbn0gW2ltbWVkaWF0ZT1mYWxzZV0gLSBXaGV0aGVyIHRvIHRyaWdnZXIgdGhlIGZ1bmN0aW9uIGltbWVkaWF0ZWx5IG9uIHRoZSBmaXJzdCBjYWxsLFxuICogYW5kIHRoZW4gZGVib3VuY2Ugc3Vic2VxdWVudCBjYWxscy5cbiAqIEByZXR1cm5zIHsoLi4uYXJnczogQXJncykgPT4gdm9pZH0gQSBuZXcsIGRlYm91bmNlZCBmdW5jdGlvbi5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIC8vIEV4YW1wbGUgdXNhZ2Ugd2l0aCBhIHdpbmRvdyByZXNpemUgZXZlbnRcbiAqIGNvbnN0IGhhbmRsZVJlc2l6ZSA9IGRlYm91bmNlKCgpID0+IHtcbiAqICAgY29uc29sZS5sb2coJ1dpbmRvdyByZXNpemVkJyk7XG4gKiB9LCAyNTApO1xuICogd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoJ3Jlc2l6ZScsIGhhbmRsZVJlc2l6ZSk7XG4gKlxuICogLy8gRXhhbXBsZSB1c2luZyBpbW1lZGlhdGUgaW52b2NhdGlvblxuICogY29uc3QgcHJvY2Vzc0tleVByZXNzID0gZGVib3VuY2UoKGV2ZW50KSA9PiB7XG4gKiAgIGNvbnNvbGUubG9nKCdLZXkgcHJlc3NlZDonLCBldmVudC5rZXkpO1xuICogfSwgMjAwLCB0cnVlKTtcbiAqIGRvY3VtZW50LmFkZEV2ZW50TGlzdGVuZXIoJ2tleXByZXNzJywgcHJvY2Vzc0tleVByZXNzKTtcbiAqIGBgYFxuICovXG5leHBvcnQgZnVuY3Rpb24gZGVib3VuY2U8QXJncyBleHRlbmRzIHVua25vd25bXT4oZnVuYzogKC4uLmFyZ3M6IEFyZ3MpID0+IHZvaWQsIGRlbGF5OiBudW1iZXIsIGltbWVkaWF0ZSA9IGZhbHNlKTogKC4uLmFyZ3M6IEFyZ3MpID0+IHZvaWQge1xuICBsZXQgdGltZW91dDogbnVtYmVyIHwgbnVsbCA9IG51bGw7XG5cbiAgcmV0dXJuIGZ1bmN0aW9uICh0aGlzOiB1bmtub3duLCAuLi5hcmdzOiBBcmdzKSB7XG4gICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby10aGlzLWFsaWFzXG4gICAgY29uc3QgY29udGV4dCA9IHRoaXM7XG4gICAgY29uc3QgY2FsbEltbWVkaWF0ZWx5ID0gaW1tZWRpYXRlICYmIHRpbWVvdXQgPT09IG51bGw7XG4gICAgaWYgKHRpbWVvdXQgIT09IG51bGwpIHtcbiAgICAgIGNsZWFyVGltZW91dCh0aW1lb3V0KTtcbiAgICB9XG4gICAgdGltZW91dCA9IHNldFRpbWVvdXQoZnVuY3Rpb24gKCkge1xuICAgICAgdGltZW91dCA9IG51bGw7XG4gICAgICBpZiAoIWNhbGxJbW1lZGlhdGVseSkge1xuICAgICAgICBmdW5jLmFwcGx5KGNvbnRleHQsIGFyZ3MpO1xuICAgICAgfVxuICAgIH0sIGRlbGF5KSBhcyB1bmtub3duIGFzIG51bWJlcjtcbiAgICBpZiAoY2FsbEltbWVkaWF0ZWx5KSB7XG4gICAgICBmdW5jLmFwcGx5KGNvbnRleHQsIGFyZ3MpO1xuICAgIH1cbiAgfTtcbn1cbiJdfQ==