@odx/angular 5.7.4 → 6.0.1

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,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
+//# 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":"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","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,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

package/esm2022/utils/lib/helpers/defer-fn.mjs

@@ -1,4 +1,24 @@
+/**
+ * Defers the execution of a function until the current call stack is clear.
+ * This is achieved by using `setTimeout` with a delay of `0`, effectively placing the function
+ * at the end of the event queue and allowing the browser to complete any pending tasks before execution.
+ *
+ * @param {() => void} fn - The function to be deferred.
+ *
+ * @example
+ * ```ts
+ * // Deferring a simple function
+ * deferFn(() => console.log('This will be logged after the current execution context completes.'));
+ *
+ * // Using deferFn to update the UI after a synchronous operation
+ * function updateUI() {
+ *   // UI update logic here
+ * }
+ * // Assume we're inside a synchronous block of code that updates data
+ * deferFn(updateUI); // Ensures UI is updated after data changes are fully applied
+ * ```
+ */
 export function deferFn(fn) {
     setTimeout(fn, 0);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmZXItZm4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2RlZmVyLWZuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxPQUFPLENBQUMsRUFBYztJQUNwQyxVQUFVLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDO0FBQ3BCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gZGVmZXJGbihmbjogKCkgPT4gdm9pZCk6IHZvaWQge1xuICBzZXRUaW1lb3V0KGZuLCAwKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmZXItZm4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2RlZmVyLWZuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBbUJHO0FBQ0gsTUFBTSxVQUFVLE9BQU8sQ0FBQyxFQUFjO0lBQ3BDLFVBQVUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDLENBQUM7QUFDcEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogRGVmZXJzIHRoZSBleGVjdXRpb24gb2YgYSBmdW5jdGlvbiB1bnRpbCB0aGUgY3VycmVudCBjYWxsIHN0YWNrIGlzIGNsZWFyLlxuICogVGhpcyBpcyBhY2hpZXZlZCBieSB1c2luZyBgc2V0VGltZW91dGAgd2l0aCBhIGRlbGF5IG9mIGAwYCwgZWZmZWN0aXZlbHkgcGxhY2luZyB0aGUgZnVuY3Rpb25cbiAqIGF0IHRoZSBlbmQgb2YgdGhlIGV2ZW50IHF1ZXVlIGFuZCBhbGxvd2luZyB0aGUgYnJvd3NlciB0byBjb21wbGV0ZSBhbnkgcGVuZGluZyB0YXNrcyBiZWZvcmUgZXhlY3V0aW9uLlxuICpcbiAqIEBwYXJhbSB7KCkgPT4gdm9pZH0gZm4gLSBUaGUgZnVuY3Rpb24gdG8gYmUgZGVmZXJyZWQuXG4gKlxuICogQGV4YW1wbGVcbiAqIGBgYHRzXG4gKiAvLyBEZWZlcnJpbmcgYSBzaW1wbGUgZnVuY3Rpb25cbiAqIGRlZmVyRm4oKCkgPT4gY29uc29sZS5sb2coJ1RoaXMgd2lsbCBiZSBsb2dnZWQgYWZ0ZXIgdGhlIGN1cnJlbnQgZXhlY3V0aW9uIGNvbnRleHQgY29tcGxldGVzLicpKTtcbiAqXG4gKiAvLyBVc2luZyBkZWZlckZuIHRvIHVwZGF0ZSB0aGUgVUkgYWZ0ZXIgYSBzeW5jaHJvbm91cyBvcGVyYXRpb25cbiAqIGZ1bmN0aW9uIHVwZGF0ZVVJKCkge1xuICogICAvLyBVSSB1cGRhdGUgbG9naWMgaGVyZVxuICogfVxuICogLy8gQXNzdW1lIHdlJ3JlIGluc2lkZSBhIHN5bmNocm9ub3VzIGJsb2NrIG9mIGNvZGUgdGhhdCB1cGRhdGVzIGRhdGFcbiAqIGRlZmVyRm4odXBkYXRlVUkpOyAvLyBFbnN1cmVzIFVJIGlzIHVwZGF0ZWQgYWZ0ZXIgZGF0YSBjaGFuZ2VzIGFyZSBmdWxseSBhcHBsaWVkXG4gKiBgYGBcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGRlZmVyRm4oZm46ICgpID0+IHZvaWQpOiB2b2lkIHtcbiAgc2V0VGltZW91dChmbiwgMCk7XG59XG4iXX0=

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

@@ -1,19 +1,56 @@
 import { isNumber, isString } from './type-guards';
+/**
+ * Applies a set of CSS styles to an HTML element.
+ *
+ * @param {HTMLElement} element - The element to apply styles to.
+ * @param {Partial<CSSStyleDeclaration | Record<keyof CSSStyleDeclaration, string | null>>} styles - An object containing CSS properties and values to apply.
+ */
 export function applyStyles(element, styles) {
     Object.assign(element.style, styles);
 }
+/**
+ * Converts a boolean value to a corresponding attribute string.
+ *
+ * @param {boolean} state - The boolean state to convert.
+ * @returns {string} 'true' if the state is true; otherwise, 'false'.
+ */
 export function booleanToAttributeString(state) {
     return booleanToOptionalAttributeString(state) ?? 'false';
 }
+/**
+ * Converts a boolean value to 'true' or null, useful for setting attributes based on boolean conditions.
+ *
+ * @param {boolean} state - The boolean state to convert.
+ * @returns {string | null} 'true' if the state is true; otherwise, null.
+ */
 export function booleanToOptionalAttributeString(state) {
     return state ? 'true' : null;
 }
+/**
+ * Converts a numeric value to a pixel string, appending 'px' to the number.
+ *
+ * @param {unknown} value - The value to convert to pixels.
+ * @returns {`${number}px`} The value in pixels, or '0px' if the input is not a number.
+ */
 export function px(value) {
     return isNumber(value) ? `${value}px` : '0px';
 }
+/**
+ * Generates a CSS translate3d string for given x and y values.
+ *
+ * @param {string | 0} x - The translation value along the x-axis.
+ * @param {string | 0} y - The translation value along the y-axis.
+ * @returns {`translate3d(${string | 0}, ${string | 0}, 0)`} The CSS translate3d value.
+ */
 export function cssTranslate(x, y) {
     return `translate3d(${x}, ${y}, 0)`;
 }
+/**
+ * Disables or re-enables CSS transitions on an element.
+ *
+ * @param {HTMLElement} element - The element to modify.
+ * @param {boolean} disabled - Whether to disable CSS transitions.
+ */
 export function disableCSSTransitions(element, disabled) {
     if (disabled) {
         applyStyles(element, { transition: 'none' });
@@ -23,9 +60,21 @@ export function disableCSSTransitions(element, disabled) {
         applyStyles(element, { transition: null });
     }
 }
+/**
+ * Forces the browser to reflow the layout, useful for triggering CSS transitions or animations.
+ *
+ * @param {HTMLElement} element - The element to force a reflow on.
+ */
 export function forceLayoutReflow(element) {
     element.offsetHeight;
 }
+/**
+ * Sets an attribute on an HTML element, converting the value to a string if necessary.
+ *
+ * @param {HTMLElement} element - The element to set the attribute on.
+ * @param {string} attribute - The name of the attribute to set.
+ * @param {unknown} value - The value of the attribute; will be converted to a string if it's not null or undefined.
+ */
 export function setAttribute(element, attribute, value) {
     if (isString(value) || isNumber(value)) {
         element.setAttribute(attribute, value.toString());
@@ -34,6 +83,12 @@ export function setAttribute(element, attribute, value) {
         element.toggleAttribute(attribute, !!value);
     }
 }
+/**
+ * Creates a ResizeObserver instance safely, falling back to a dummy if the API is not supported.
+ *
+ * @param {ResizeObserverCallback} callback - The callback to execute when an observed element's size changes.
+ * @returns {ResizeObserver} A ResizeObserver instance or a dummy object with no-op methods if unsupported.
+ */
 export function createResizeObserver(callback) {
     try {
         return new ResizeObserver(callback);
@@ -42,6 +97,13 @@ export function createResizeObserver(callback) {
         return { observe: () => void 0, disconnect: () => void 0, unobserve: () => void 0 };
     }
 }
+/**
+ * Creates a MutationObserver instance safely, falling back to a dummy if the API is not supported.
+ *
+ * @param {Subscriber<MutationRecord>} observer - The RxJS Subscriber to emit next values to.
+ * @param {(mutations: MutationRecord[]) => boolean} callback - The callback that determines whether to notify the observer based on mutations.
+ * @returns {MutationObserver} A MutationObserver instance or a dummy object with no-op methods if unsupported.
+ */
 export function createMutationObserver(observer, callback) {
     try {
         return new MutationObserver((mutations) => {
@@ -54,6 +116,14 @@ export function createMutationObserver(observer, callback) {
         return { disconnect: () => void 0, observe: () => void 0, takeRecords: () => [] };
     }
 }
+/**
+ * Checks whether one element contains another in the DOM tree.
+ *
+ * @param {Element | null} parent - The parent element.
+ * @param {Element | null} other - The element to check for containment.
+ * @param {boolean} [inclusive=true] - Whether to consider an element as containing itself.
+ * @returns {boolean} True if the parent contains the other element; false otherwise.
+ */
 export function containsElement(parent, other, inclusive = true) {
     if (!parent || !other)
         return false;
@@ -61,4 +131,4 @@ export function containsElement(parent, other, inclusive = true) {
         return false;
     return parent.contains(other);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dom.js","sourceRoot":"","sources":["../../../../../../../libs/angular/utils/src/lib/helpers/dom.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subscriber } from 'rxjs';\nimport { isNumber, isString } from './type-guards';\n\n/**\n * Applies a set of CSS styles to an HTML element.\n *\n * @param {HTMLElement} element - The element to apply styles to.\n * @param {Partial<CSSStyleDeclaration | Record<keyof CSSStyleDeclaration, string | null>>} styles - An object containing CSS properties and values to apply.\n */\nexport function applyStyles(element: HTMLElement, styles: Partial<CSSStyleDeclaration | Record<keyof CSSStyleDeclaration, string | null>>): void {\n  Object.assign(element.style, styles);\n}\n\n/**\n * Converts a boolean value to a corresponding attribute string.\n *\n * @param {boolean} state - The boolean state to convert.\n * @returns {string} 'true' if the state is true; otherwise, 'false'.\n */\nexport function booleanToAttributeString(state: boolean): string {\n  return booleanToOptionalAttributeString(state) ?? 'false';\n}\n\n/**\n * Converts a boolean value to 'true' or null, useful for setting attributes based on boolean conditions.\n *\n * @param {boolean} state - The boolean state to convert.\n * @returns {string | null} 'true' if the state is true; otherwise, null.\n */\nexport function booleanToOptionalAttributeString(state: boolean): string | null {\n  return state ? 'true' : null;\n}\n\n/**\n * Converts a numeric value to a pixel string, appending 'px' to the number.\n *\n * @param {unknown} value - The value to convert to pixels.\n * @returns {`${number}px`} The value in pixels, or '0px' if the input is not a number.\n */\nexport function px(value: unknown): `${number}px` {\n  return isNumber(value) ? `${value}px` : '0px';\n}\n\n/**\n * Generates a CSS translate3d string for given x and y values.\n *\n * @param {string | 0} x - The translation value along the x-axis.\n * @param {string | 0} y - The translation value along the y-axis.\n * @returns {`translate3d(${string | 0}, ${string | 0}, 0)`} The CSS translate3d value.\n */\nexport function cssTranslate(x: string | 0, y: string | 0): `translate3d(${string | 0}, ${string | 0}, 0)` {\n  return `translate3d(${x}, ${y}, 0)`;\n}\n\n/**\n * Disables or re-enables CSS transitions on an element.\n *\n * @param {HTMLElement} element - The element to modify.\n * @param {boolean} disabled - Whether to disable CSS transitions.\n */\nexport function disableCSSTransitions(element: HTMLElement, disabled: boolean): void {\n  if (disabled) {\n    applyStyles(element, { transition: 'none' });\n  } else {\n    forceLayoutReflow(element);\n    applyStyles(element, { transition: null });\n  }\n}\n\n/**\n * Forces the browser to reflow the layout, useful for triggering CSS transitions or animations.\n *\n * @param {HTMLElement} element - The element to force a reflow on.\n */\nexport function forceLayoutReflow(element: HTMLElement): void {\n  element.offsetHeight;\n}\n\n/**\n * Sets an attribute on an HTML element, converting the value to a string if necessary.\n *\n * @param {HTMLElement} element - The element to set the attribute on.\n * @param {string} attribute - The name of the attribute to set.\n * @param {unknown} value - The value of the attribute; will be converted to a string if it's not null or undefined.\n */\nexport function setAttribute(element: HTMLElement, attribute: string, value?: unknown) {\n  if (isString(value) || isNumber(value)) {\n    element.setAttribute(attribute, value.toString());\n  } else {\n    element.toggleAttribute(attribute, !!value);\n  }\n}\n\n/**\n * Creates a ResizeObserver instance safely, falling back to a dummy if the API is not supported.\n *\n * @param {ResizeObserverCallback} callback - The callback to execute when an observed element's size changes.\n * @returns {ResizeObserver} A ResizeObserver instance or a dummy object with no-op methods if unsupported.\n */\nexport function createResizeObserver(callback: ResizeObserverCallback): ResizeObserver {\n  try {\n    return new ResizeObserver(callback);\n  } catch {\n    return { observe: () => void 0, disconnect: () => void 0, unobserve: () => void 0 };\n  }\n}\n\n/**\n * Creates a MutationObserver instance safely, falling back to a dummy if the API is not supported.\n *\n * @param {Subscriber<MutationRecord>} observer - The RxJS Subscriber to emit next values to.\n * @param {(mutations: MutationRecord[]) => boolean} callback - The callback that determines whether to notify the observer based on mutations.\n * @returns {MutationObserver} A MutationObserver instance or a dummy object with no-op methods if unsupported.\n */\nexport function createMutationObserver(observer: Subscriber<MutationRecord>, callback: (mutations: MutationRecord[]) => boolean): MutationObserver {\n  try {\n    return new MutationObserver((mutations) => {\n      if (callback(mutations)) {\n        observer.next(mutations[0]);\n      }\n    });\n  } catch (error) {\n    return { disconnect: () => void 0, observe: () => void 0, takeRecords: () => [] };\n  }\n}\n\n/**\n * Checks whether one element contains another in the DOM tree.\n *\n * @param {Element | null} parent - The parent element.\n * @param {Element | null} other - The element to check for containment.\n * @param {boolean} [inclusive=true] - Whether to consider an element as containing itself.\n * @returns {boolean} True if the parent contains the other element; false otherwise.\n */\nexport function containsElement(parent?: Element | null, other?: Element | null, inclusive = true): boolean {\n  if (!parent || !other) return false;\n  if (!inclusive && parent === other) return false;\n  return parent.contains(other);\n}\n"]}

package/esm2022/utils/lib/helpers/get-axis.mjs

@@ -1,5 +1,25 @@
 import { Axis, Side } from '../types';
 import { getSide } from './get-side';
+/**
+ * Determines the axis associated with a given position. The function first extracts the side from the position,
+ * then evaluates whether that side corresponds to the X-axis (left or right) or the Y-axis (top or bottom).
+ *
+ * @param {Position} position - The position string, which includes a side (top, bottom, left, right) and possibly an alignment.
+ * @returns {Axis} The axis (X or Y) associated with the given position's side.
+ *
+ * @example
+ * ```ts
+ * // Determining the axis for different positions
+ * console.log(getAxis('top-left')); // Outputs: 'Y'
+ * console.log(getAxis('right'));    // Outputs: 'X'
+ *
+ * // Using getAxis in UI element positioning logic
+ * const elementPosition = 'bottom';
+ * const axis = getAxis(elementPosition);
+ * // Assuming a function that adjusts UI elements based on the axis
+ * adjustElementAlongAxis(axis);
+ * ```
+ */
 export function getAxis(position) {
     const side = getSide(position);
     switch (side) {
@@ -11,4 +31,4 @@ export function getAxis(position) {
             return Axis.X;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWF4aXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2dldC1heGlzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQVksSUFBSSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQ2hELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFckMsTUFBTSxVQUFVLE9BQU8sQ0FBQyxRQUFrQjtJQUN4QyxNQUFNLElBQUksR0FBRyxPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7SUFFL0IsUUFBUSxJQUFJLEVBQUU7UUFDWixLQUFLLElBQUksQ0FBQyxHQUFHLENBQUM7UUFDZCxLQUFLLElBQUksQ0FBQyxNQUFNO1lBQ2QsT0FBTyxJQUFJLENBQUMsQ0FBQyxDQUFDO1FBQ2hCLEtBQUssSUFBSSxDQUFDLElBQUksQ0FBQztRQUNmLEtBQUssSUFBSSxDQUFDLEtBQUs7WUFDYixPQUFPLElBQUksQ0FBQyxDQUFDLENBQUM7S0FDakI7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXhpcywgUG9zaXRpb24sIFNpZGUgfSBmcm9tICcuLi90eXBlcyc7XG5pbXBvcnQgeyBnZXRTaWRlIH0gZnJvbSAnLi9nZXQtc2lkZSc7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRBeGlzKHBvc2l0aW9uOiBQb3NpdGlvbik6IEF4aXMge1xuICBjb25zdCBzaWRlID0gZ2V0U2lkZShwb3NpdGlvbik7XG5cbiAgc3dpdGNoIChzaWRlKSB7XG4gICAgY2FzZSBTaWRlLlRPUDpcbiAgICBjYXNlIFNpZGUuQk9UVE9NOlxuICAgICAgcmV0dXJuIEF4aXMuWTtcbiAgICBjYXNlIFNpZGUuTEVGVDpcbiAgICBjYXNlIFNpZGUuUklHSFQ6XG4gICAgICByZXR1cm4gQXhpcy5YO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWF4aXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2dldC1heGlzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQVksSUFBSSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQ2hELE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFFckM7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0FtQkc7QUFDSCxNQUFNLFVBQVUsT0FBTyxDQUFDLFFBQWtCO0lBQ3hDLE1BQU0sSUFBSSxHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQztJQUUvQixRQUFRLElBQUksRUFBRTtRQUNaLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQztRQUNkLEtBQUssSUFBSSxDQUFDLE1BQU07WUFDZCxPQUFPLElBQUksQ0FBQyxDQUFDLENBQUM7UUFDaEIsS0FBSyxJQUFJLENBQUMsSUFBSSxDQUFDO1FBQ2YsS0FBSyxJQUFJLENBQUMsS0FBSztZQUNiLE9BQU8sSUFBSSxDQUFDLENBQUMsQ0FBQztLQUNqQjtBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBeGlzLCBQb3NpdGlvbiwgU2lkZSB9IGZyb20gJy4uL3R5cGVzJztcbmltcG9ydCB7IGdldFNpZGUgfSBmcm9tICcuL2dldC1zaWRlJztcblxuLyoqXG4gKiBEZXRlcm1pbmVzIHRoZSBheGlzIGFzc29jaWF0ZWQgd2l0aCBhIGdpdmVuIHBvc2l0aW9uLiBUaGUgZnVuY3Rpb24gZmlyc3QgZXh0cmFjdHMgdGhlIHNpZGUgZnJvbSB0aGUgcG9zaXRpb24sXG4gKiB0aGVuIGV2YWx1YXRlcyB3aGV0aGVyIHRoYXQgc2lkZSBjb3JyZXNwb25kcyB0byB0aGUgWC1heGlzIChsZWZ0IG9yIHJpZ2h0KSBvciB0aGUgWS1heGlzICh0b3Agb3IgYm90dG9tKS5cbiAqXG4gKiBAcGFyYW0ge1Bvc2l0aW9ufSBwb3NpdGlvbiAtIFRoZSBwb3NpdGlvbiBzdHJpbmcsIHdoaWNoIGluY2x1ZGVzIGEgc2lkZSAodG9wLCBib3R0b20sIGxlZnQsIHJpZ2h0KSBhbmQgcG9zc2libHkgYW4gYWxpZ25tZW50LlxuICogQHJldHVybnMge0F4aXN9IFRoZSBheGlzIChYIG9yIFkpIGFzc29jaWF0ZWQgd2l0aCB0aGUgZ2l2ZW4gcG9zaXRpb24ncyBzaWRlLlxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGB0c1xuICogLy8gRGV0ZXJtaW5pbmcgdGhlIGF4aXMgZm9yIGRpZmZlcmVudCBwb3NpdGlvbnNcbiAqIGNvbnNvbGUubG9nKGdldEF4aXMoJ3RvcC1sZWZ0JykpOyAvLyBPdXRwdXRzOiAnWSdcbiAqIGNvbnNvbGUubG9nKGdldEF4aXMoJ3JpZ2h0JykpOyAgICAvLyBPdXRwdXRzOiAnWCdcbiAqXG4gKiAvLyBVc2luZyBnZXRBeGlzIGluIFVJIGVsZW1lbnQgcG9zaXRpb25pbmcgbG9naWNcbiAqIGNvbnN0IGVsZW1lbnRQb3NpdGlvbiA9ICdib3R0b20nO1xuICogY29uc3QgYXhpcyA9IGdldEF4aXMoZWxlbWVudFBvc2l0aW9uKTtcbiAqIC8vIEFzc3VtaW5nIGEgZnVuY3Rpb24gdGhhdCBhZGp1c3RzIFVJIGVsZW1lbnRzIGJhc2VkIG9uIHRoZSBheGlzXG4gKiBhZGp1c3RFbGVtZW50QWxvbmdBeGlzKGF4aXMpO1xuICogYGBgXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRBeGlzKHBvc2l0aW9uOiBQb3NpdGlvbik6IEF4aXMge1xuICBjb25zdCBzaWRlID0gZ2V0U2lkZShwb3NpdGlvbik7XG5cbiAgc3dpdGNoIChzaWRlKSB7XG4gICAgY2FzZSBTaWRlLlRPUDpcbiAgICBjYXNlIFNpZGUuQk9UVE9NOlxuICAgICAgcmV0dXJuIEF4aXMuWTtcbiAgICBjYXNlIFNpZGUuTEVGVDpcbiAgICBjYXNlIFNpZGUuUklHSFQ6XG4gICAgICByZXR1cm4gQXhpcy5YO1xuICB9XG59XG4iXX0=

package/esm2022/utils/lib/helpers/get-language-code.mjs

@@ -1,5 +1,22 @@
+/**
+ * Extracts the language code from a language string that may include both a language and a region code.
+ * The function supports language strings formatted with either a hyphen (`-`) or an underscore (`_`) as the separator.
+ *
+ * @param {string} language - The complete language string, potentially including both language and region codes.
+ * @returns {string} The extracted language code, converted to lower case.
+ *
+ * @example
+ * ```ts
+ * // Extracting language code from a language-region string
+ * console.log(getLanguageCode('en-US')); // Outputs: 'en'
+ * console.log(getLanguageCode('zh_CN')); // Outputs: 'zh'
+ *
+ * // Handling language codes without region codes
+ * console.log(getLanguageCode('fr'));    // Outputs: 'fr'
+ * ```
+ */
 export function getLanguageCode(language) {
     const [languageCode] = language.split(/-|_/);
     return languageCode?.toLowerCase();
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWxhbmd1YWdlLWNvZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2dldC1sYW5ndWFnZS1jb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxlQUFlLENBQUMsUUFBZ0I7SUFDOUMsTUFBTSxDQUFDLFlBQVksQ0FBQyxHQUFHLFFBQVEsQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUM7SUFFN0MsT0FBTyxZQUFZLEVBQUUsV0FBVyxFQUFFLENBQUM7QUFDckMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBmdW5jdGlvbiBnZXRMYW5ndWFnZUNvZGUobGFuZ3VhZ2U6IHN0cmluZyk6IHN0cmluZyB7XG4gIGNvbnN0IFtsYW5ndWFnZUNvZGVdID0gbGFuZ3VhZ2Uuc3BsaXQoLy18Xy8pO1xuXG4gIHJldHVybiBsYW5ndWFnZUNvZGU/LnRvTG93ZXJDYXNlKCk7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWxhbmd1YWdlLWNvZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2dldC1sYW5ndWFnZS1jb2RlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7O0dBZ0JHO0FBQ0gsTUFBTSxVQUFVLGVBQWUsQ0FBQyxRQUFnQjtJQUM5QyxNQUFNLENBQUMsWUFBWSxDQUFDLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUU3QyxPQUFPLFlBQVksRUFBRSxXQUFXLEVBQUUsQ0FBQztBQUNyQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBFeHRyYWN0cyB0aGUgbGFuZ3VhZ2UgY29kZSBmcm9tIGEgbGFuZ3VhZ2Ugc3RyaW5nIHRoYXQgbWF5IGluY2x1ZGUgYm90aCBhIGxhbmd1YWdlIGFuZCBhIHJlZ2lvbiBjb2RlLlxuICogVGhlIGZ1bmN0aW9uIHN1cHBvcnRzIGxhbmd1YWdlIHN0cmluZ3MgZm9ybWF0dGVkIHdpdGggZWl0aGVyIGEgaHlwaGVuIChgLWApIG9yIGFuIHVuZGVyc2NvcmUgKGBfYCkgYXMgdGhlIHNlcGFyYXRvci5cbiAqXG4gKiBAcGFyYW0ge3N0cmluZ30gbGFuZ3VhZ2UgLSBUaGUgY29tcGxldGUgbGFuZ3VhZ2Ugc3RyaW5nLCBwb3RlbnRpYWxseSBpbmNsdWRpbmcgYm90aCBsYW5ndWFnZSBhbmQgcmVnaW9uIGNvZGVzLlxuICogQHJldHVybnMge3N0cmluZ30gVGhlIGV4dHJhY3RlZCBsYW5ndWFnZSBjb2RlLCBjb252ZXJ0ZWQgdG8gbG93ZXIgY2FzZS5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIC8vIEV4dHJhY3RpbmcgbGFuZ3VhZ2UgY29kZSBmcm9tIGEgbGFuZ3VhZ2UtcmVnaW9uIHN0cmluZ1xuICogY29uc29sZS5sb2coZ2V0TGFuZ3VhZ2VDb2RlKCdlbi1VUycpKTsgLy8gT3V0cHV0czogJ2VuJ1xuICogY29uc29sZS5sb2coZ2V0TGFuZ3VhZ2VDb2RlKCd6aF9DTicpKTsgLy8gT3V0cHV0czogJ3poJ1xuICpcbiAqIC8vIEhhbmRsaW5nIGxhbmd1YWdlIGNvZGVzIHdpdGhvdXQgcmVnaW9uIGNvZGVzXG4gKiBjb25zb2xlLmxvZyhnZXRMYW5ndWFnZUNvZGUoJ2ZyJykpOyAgICAvLyBPdXRwdXRzOiAnZnInXG4gKiBgYGBcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldExhbmd1YWdlQ29kZShsYW5ndWFnZTogc3RyaW5nKTogc3RyaW5nIHtcbiAgY29uc3QgW2xhbmd1YWdlQ29kZV0gPSBsYW5ndWFnZS5zcGxpdCgvLXxfLyk7XG5cbiAgcmV0dXJuIGxhbmd1YWdlQ29kZT8udG9Mb3dlckNhc2UoKTtcbn1cbiJdfQ==

package/esm2022/utils/lib/helpers/get-opposite-side.mjs

@@ -1,5 +1,26 @@
 import { Side } from '../types';
 import { getSide } from './get-side';
+/**
+ * Determines the opposite side for a given position. This function is useful for scenarios
+ * where you need to dynamically calculate the positioning or alignment opposite to the current one,
+ * such as inverting tooltips, popovers, or any UI elements that adjust based on available viewport space.
+ *
+ * @param {Position} position - The position string, which includes a side and possibly an alignment.
+ * @returns {Side} The opposite side relative to the provided position's side.
+ *
+ * @example
+ * ```ts
+ * // Getting the opposite side of a given position
+ * console.log(getOppositeSide('top-left')); // Outputs: 'bottom'
+ * console.log(getOppositeSide('right'));    // Outputs: 'left'
+ *
+ * // Using getOppositeSide to adjust UI elements
+ * const currentSide = 'left';
+ * const newPosition = getOppositeSide(currentSide);
+ * // Assuming an element's position or orientation needs to be dynamically updated
+ * updateElementPosition(newPosition);
+ * ```
+ */
 export function getOppositeSide(position) {
     switch (getSide(position)) {
         case Side.TOP:
@@ -12,4 +33,4 @@ export function getOppositeSide(position) {
             return Side.RIGHT;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LW9wcG9zaXRlLXNpZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2dldC1vcHBvc2l0ZS1zaWRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBWSxJQUFJLEVBQUUsTUFBTSxVQUFVLENBQUM7QUFDMUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLFlBQVksQ0FBQztBQUVyQyxNQUFNLFVBQVUsZUFBZSxDQUFDLFFBQWtCO0lBQ2hELFFBQVEsT0FBTyxDQUFDLFFBQVEsQ0FBQyxFQUFFO1FBQ3pCLEtBQUssSUFBSSxDQUFDLEdBQUc7WUFDWCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUM7UUFDckIsS0FBSyxJQUFJLENBQUMsS0FBSztZQUNiLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQztRQUNuQixLQUFLLElBQUksQ0FBQyxNQUFNO1lBQ2QsT0FBTyxJQUFJLENBQUMsR0FBRyxDQUFDO1FBQ2xCLEtBQUssSUFBSSxDQUFDLElBQUk7WUFDWixPQUFPLElBQUksQ0FBQyxLQUFLLENBQUM7S0FDckI7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUG9zaXRpb24sIFNpZGUgfSBmcm9tICcuLi90eXBlcyc7XG5pbXBvcnQgeyBnZXRTaWRlIH0gZnJvbSAnLi9nZXQtc2lkZSc7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRPcHBvc2l0ZVNpZGUocG9zaXRpb246IFBvc2l0aW9uKTogU2lkZSB7XG4gIHN3aXRjaCAoZ2V0U2lkZShwb3NpdGlvbikpIHtcbiAgICBjYXNlIFNpZGUuVE9QOlxuICAgICAgcmV0dXJuIFNpZGUuQk9UVE9NO1xuICAgIGNhc2UgU2lkZS5SSUdIVDpcbiAgICAgIHJldHVybiBTaWRlLkxFRlQ7XG4gICAgY2FzZSBTaWRlLkJPVFRPTTpcbiAgICAgIHJldHVybiBTaWRlLlRPUDtcbiAgICBjYXNlIFNpZGUuTEVGVDpcbiAgICAgIHJldHVybiBTaWRlLlJJR0hUO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/helpers/get-side.mjs

@@ -1,4 +1,21 @@
+/**
+ * Extracts the side part from a position string. The position format generally combines
+ * a side (e.g., "top", "bottom", "left", "right") with an optional alignment
+ * (e.g., "left", "center", "right" for vertical positions or "top", "middle", "bottom" for horizontal positions).
+ *
+ * @param {Position} position - The position string from which to extract the side.
+ * @returns {Side} The side part of the position, indicating the general placement direction.
+ *
+ * @example
+ * ```ts
+ * // Extracting the side from a position with alignment
+ * console.log(getSide('top-left')); // Outputs: 'top'
+ *
+ * // Extracting the side from a simple position
+ * console.log(getSide('bottom')); // Outputs: 'bottom'
+ * ```
+ */
 export function getSide(position) {
     return position.split('-')[0];
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXNpZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2dldC1zaWRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sVUFBVSxPQUFPLENBQUMsUUFBa0I7SUFDeEMsT0FBTyxRQUFRLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBUyxDQUFDO0FBQ3hDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQb3NpdGlvbiwgU2lkZSB9IGZyb20gJy4uL3R5cGVzJztcblxuZXhwb3J0IGZ1bmN0aW9uIGdldFNpZGUocG9zaXRpb246IFBvc2l0aW9uKTogU2lkZSB7XG4gIHJldHVybiBwb3NpdGlvbi5zcGxpdCgnLScpWzBdIGFzIFNpZGU7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXNpZGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvdXRpbHMvc3JjL2xpYi9oZWxwZXJzL2dldC1zaWRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOzs7Ozs7Ozs7Ozs7Ozs7O0dBZ0JHO0FBQ0gsTUFBTSxVQUFVLE9BQU8sQ0FBQyxRQUFrQjtJQUN4QyxPQUFPLFFBQVEsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFTLENBQUM7QUFDeEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBvc2l0aW9uLCBTaWRlIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG4vKipcbiAqIEV4dHJhY3RzIHRoZSBzaWRlIHBhcnQgZnJvbSBhIHBvc2l0aW9uIHN0cmluZy4gVGhlIHBvc2l0aW9uIGZvcm1hdCBnZW5lcmFsbHkgY29tYmluZXNcbiAqIGEgc2lkZSAoZS5nLiwgXCJ0b3BcIiwgXCJib3R0b21cIiwgXCJsZWZ0XCIsIFwicmlnaHRcIikgd2l0aCBhbiBvcHRpb25hbCBhbGlnbm1lbnRcbiAqIChlLmcuLCBcImxlZnRcIiwgXCJjZW50ZXJcIiwgXCJyaWdodFwiIGZvciB2ZXJ0aWNhbCBwb3NpdGlvbnMgb3IgXCJ0b3BcIiwgXCJtaWRkbGVcIiwgXCJib3R0b21cIiBmb3IgaG9yaXpvbnRhbCBwb3NpdGlvbnMpLlxuICpcbiAqIEBwYXJhbSB7UG9zaXRpb259IHBvc2l0aW9uIC0gVGhlIHBvc2l0aW9uIHN0cmluZyBmcm9tIHdoaWNoIHRvIGV4dHJhY3QgdGhlIHNpZGUuXG4gKiBAcmV0dXJucyB7U2lkZX0gVGhlIHNpZGUgcGFydCBvZiB0aGUgcG9zaXRpb24sIGluZGljYXRpbmcgdGhlIGdlbmVyYWwgcGxhY2VtZW50IGRpcmVjdGlvbi5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIC8vIEV4dHJhY3RpbmcgdGhlIHNpZGUgZnJvbSBhIHBvc2l0aW9uIHdpdGggYWxpZ25tZW50XG4gKiBjb25zb2xlLmxvZyhnZXRTaWRlKCd0b3AtbGVmdCcpKTsgLy8gT3V0cHV0czogJ3RvcCdcbiAqXG4gKiAvLyBFeHRyYWN0aW5nIHRoZSBzaWRlIGZyb20gYSBzaW1wbGUgcG9zaXRpb25cbiAqIGNvbnNvbGUubG9nKGdldFNpZGUoJ2JvdHRvbScpKTsgLy8gT3V0cHV0czogJ2JvdHRvbSdcbiAqIGBgYFxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0U2lkZShwb3NpdGlvbjogUG9zaXRpb24pOiBTaWRlIHtcbiAgcmV0dXJuIHBvc2l0aW9uLnNwbGl0KCctJylbMF0gYXMgU2lkZTtcbn1cbiJdfQ==

package/esm2022/utils/lib/helpers/get-unique-id.mjs

@@ -1,9 +1,42 @@
 let uniqueIdCache = {};
+/**
+ * Generates a unique identifier for a given key. If the key has previously been used,
+ * the function increments a counter associated with that key to ensure uniqueness.
+ * The generated ID is in the format of `${key}-${counter}`.
+ *
+ * @param {string} key - The key for which to generate a unique identifier.
+ * @returns {string} A unique identifier string based on the provided key.
+ *
+ * @example
+ * ```ts
+ * const id1 = getUniqueId('component');
+ * console.log(id1); // Outputs: "component-1"
+ *
+ * const id2 = getUniqueId('component');
+ * console.log(id2); // Outputs: "component-2"
+ * ```
+ */
 export function getUniqueId(key) {
     uniqueIdCache[key] = (uniqueIdCache[key] ?? 0) + 1;
     return `${key}-${uniqueIdCache[key]}`;
 }
+/**
+ * Clears the cache used by `getUniqueId` to generate unique identifiers. This function
+ * resets all counters associated with each key, effectively restarting the generation
+ * of unique IDs from their initial state.
+ *
+ * This can be useful in scenarios such as testing or when starting a new session that
+ * requires resetting the state of unique ID generation.
+ *
+ * @example
+ * ```ts
+ * getUniqueId('component'); // Returns "component-1"
+ * getUniqueId('component'); // Returns "component-2"
+ * clearUniqueIdCache();
+ * getUniqueId('component'); // Returns "component-1" after cache reset
+ * ```
+ */
 export function clearUniqueIdCache() {
     uniqueIdCache = {};
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXVuaXF1ZS1pZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci91dGlscy9zcmMvbGliL2hlbHBlcnMvZ2V0LXVuaXF1ZS1pZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxJQUFJLGFBQWEsR0FBOEIsRUFBRSxDQUFDO0FBRWxELE1BQU0sVUFBVSxXQUFXLENBQUMsR0FBVztJQUNyQyxhQUFhLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBRW5ELE9BQU8sR0FBRyxHQUFHLElBQUksYUFBYSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7QUFDeEMsQ0FBQztBQUVELE1BQU0sVUFBVSxrQkFBa0I7SUFDaEMsYUFBYSxHQUFHLEVBQUUsQ0FBQztBQUNyQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsibGV0IHVuaXF1ZUlkQ2FjaGU6IHsgW2tleTogc3RyaW5nXTogbnVtYmVyIH0gPSB7fTtcblxuZXhwb3J0IGZ1bmN0aW9uIGdldFVuaXF1ZUlkKGtleTogc3RyaW5nKTogc3RyaW5nIHtcbiAgdW5pcXVlSWRDYWNoZVtrZXldID0gKHVuaXF1ZUlkQ2FjaGVba2V5XSA/PyAwKSArIDE7XG5cbiAgcmV0dXJuIGAke2tleX0tJHt1bmlxdWVJZENhY2hlW2tleV19YDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGNsZWFyVW5pcXVlSWRDYWNoZSgpOiB2b2lkIHtcbiAgdW5pcXVlSWRDYWNoZSA9IHt9O1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,8 +1,48 @@
 import { isString } from './type-guards';
+/**
+ * Checks if a given value is a valid URL matcher, which can be either a string or a regular expression.
+ * This function serves as a type guard to facilitate URL matching operations by verifying the type of the filter.
+ *
+ * @param {unknown} value - The value to check for being a valid URL matcher.
+ * @returns {value is string | RegExp} `true` if the value is a string or RegExp, indicating it can be used for URL matching; otherwise, `false`.
+ *
+ * @example
+ * ```ts
+ * // Checking a string URL matcher
+ * console.log(isUrlMatcher('https://example.com')); // true
+ *
+ * // Checking a RegExp URL matcher
+ * console.log(isUrlMatcher(/https:\/\/example\.com/)); // true
+ *
+ * // Checking a non-matcher value
+ * console.log(isUrlMatcher(123)); // false
+ * ```
+ */
 export function isUrlMatcher(value) {
     return isString(value) || value instanceof RegExp;
 }
+/**
+ * Determines if a given URL matches a specified filter, which can be either a string or a regular expression.
+ * For string filters, the function checks if the URL starts with the filter value. For RegExp filters,
+ * it checks if the URL matches the regular expression pattern.
+ *
+ * @param {string} url - The URL to be checked against the filter.
+ * @param {string | RegExp} filter - The filter used to match the URL, which can be a prefix string or a RegExp pattern.
+ * @returns {boolean} `true` if the URL matches the filter; otherwise, `false`.
+ *
+ * @example
+ * ```ts
+ * // Matching a URL with a string filter
+ * console.log(matchUrl('https://example.com/page', 'https://example.com')); // true
+ *
+ * // Matching a URL with a RegExp filter
+ * console.log(matchUrl('https://example.com/page', /example\.com\/page/)); // true
+ *
+ * // A non-matching example
+ * console.log(matchUrl('https://example.com/page', 'https://another.com')); // false
+ * ```
+ */
 export function matchUrl(url, filter) {
     return isString(filter) ? url.startsWith(filter) : !!url.match(filter);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWF0Y2gtdXJsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3V0aWxzL3NyYy9saWIvaGVscGVycy9tYXRjaC11cmwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxNQUFNLFVBQVUsWUFBWSxDQUFDLEtBQWM7SUFDekMsT0FBTyxRQUFRLENBQUMsS0FBSyxDQUFDLElBQUksS0FBSyxZQUFZLE1BQU0sQ0FBQztBQUNwRCxDQUFDO0FBRUQsTUFBTSxVQUFVLFFBQVEsQ0FBQyxHQUFXLEVBQUUsTUFBdUI7SUFDM0QsT0FBTyxRQUFRLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0FBQ3pFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpc1N0cmluZyB9IGZyb20gJy4vdHlwZS1ndWFyZHMnO1xuXG5leHBvcnQgZnVuY3Rpb24gaXNVcmxNYXRjaGVyKHZhbHVlOiB1bmtub3duKTogdmFsdWUgaXMgc3RyaW5nIHwgUmVnRXhwIHtcbiAgcmV0dXJuIGlzU3RyaW5nKHZhbHVlKSB8fCB2YWx1ZSBpbnN0YW5jZW9mIFJlZ0V4cDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIG1hdGNoVXJsKHVybDogc3RyaW5nLCBmaWx0ZXI6IHN0cmluZyB8IFJlZ0V4cCk6IGJvb2xlYW4ge1xuICByZXR1cm4gaXNTdHJpbmcoZmlsdGVyKSA/IHVybC5zdGFydHNXaXRoKGZpbHRlcikgOiAhIXVybC5tYXRjaChmaWx0ZXIpO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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