@odx/angular 9.2.2 → 10.0.1

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

@@ -101,4 +101,4 @@ export class CacheStorageClient {
         return cache.match(request).then((res) => res ?? null);
     }
 }
-//# 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"]}
+//# 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,CAAC;YACrC,MAAM,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC1B,CAAC;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,CAAC;YACzC,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAC9B,CAAC;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,CAAC;YACT,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,yBAAyB,EAAE,IAAI,CAAC,CAAC;QACvD,CAAC;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,CAAC;YAChC,MAAM,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAE5B,OAAO,QAAQ,CAAC;QAClB,CAAC;QACD,IAAI,QAAQ,EAAE,EAAE,EAAE,CAAC;YACjB,MAAM,KAAK,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,CAAC;QACvD,CAAC;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/debounce.mjs

@@ -45,4 +45,4 @@ export function debounce(func, delay, immediate = false) {
         }
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -131,4 +131,4 @@ export function containsElement(parent, other, inclusive = true) {
         return false;
     return parent.contains(other);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dom.js","sourceRoot":"","sources":["../../../../../../../libs/angular/utils/src/lib/helpers/dom.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,OAAoB,EAAE,MAAuF;IACvI,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;AACvC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,wBAAwB,CAAC,KAAc;IACrD,OAAO,gCAAgC,CAAC,KAAK,CAAC,IAAI,OAAO,CAAC;AAC5D,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gCAAgC,CAAC,KAAc;IAC7D,OAAO,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;AAC/B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,EAAE,CAAC,KAAc;IAC/B,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;AAChD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,CAAa,EAAE,CAAa;IACvD,OAAO,eAAe,CAAC,KAAK,CAAC,MAAM,CAAC;AACtC,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,OAAoB,EAAE,QAAiB;IAC3E,IAAI,QAAQ,EAAE;QACZ,WAAW,CAAC,OAAO,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,CAAC,CAAC;KAC9C;SAAM;QACL,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAC3B,WAAW,CAAC,OAAO,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;KAC5C;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAoB;IACpD,OAAO,CAAC,YAAY,CAAC;AACvB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,YAAY,CAAC,OAAoB,EAAE,SAAiB,EAAE,KAAe;IACnF,IAAI,QAAQ,CAAC,KAAK,CAAC,IAAI,QAAQ,CAAC,KAAK,CAAC,EAAE;QACtC,OAAO,CAAC,YAAY,CAAC,SAAS,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC;KACnD;SAAM;QACL,OAAO,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;KAC7C;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAAgC;IACnE,IAAI;QACF,OAAO,IAAI,cAAc,CAAC,QAAQ,CAAC,CAAC;KACrC;IAAC,MAAM;QACN,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,CAAC;KACrF;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CAAC,QAAoC,EAAE,QAAkD;IAC7H,IAAI;QACF,OAAO,IAAI,gBAAgB,CAAC,CAAC,SAAS,EAAE,EAAE;YACxC,IAAI,QAAQ,CAAC,SAAS,CAAC,EAAE;gBACvB,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;aAC7B;QACH,CAAC,CAAC,CAAC;KACJ;IAAC,OAAO,KAAK,EAAE;QACd,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,EAAE,WAAW,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;KACnF;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,MAAuB,EAAE,KAAsB,EAAE,SAAS,GAAG,IAAI;IAC/F,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IACpC,IAAI,CAAC,SAAS,IAAI,MAAM,KAAK,KAAK;QAAE,OAAO,KAAK,CAAC;IACjD,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAChC,CAAC","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"]}
+//# 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/event-manager.mjs

@@ -40,10 +40,10 @@ export class EventManager {
     getActiveListenersNames() {
         return Array.from(this.listeners.keys());
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EventManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EventManager }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EventManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EventManager }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: EventManager, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: EventManager, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -31,4 +31,4 @@ export function getAxis(position) {
             return Axis.X;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -33,4 +33,4 @@ export function getOppositeSide(position) {
             return Side.RIGHT;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/helpers/ng-changes.mjs

@@ -40,4 +40,4 @@ export function hasChanged(changes, keyOrKeys, ignoreFirstChange = true) {
         return keyOrKeys in changes && (!ignoreFirstChange || !changes[keyOrKeys]?.isFirstChange());
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/helpers/provide-config.mjs

@@ -90,4 +90,4 @@ export function createConfigTokens(name, prefix, defaultValue, transform) {
         [provideConfigName]: ((config) => provideConfig(token, config, transform)),
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provide-config.js","sourceRoot":"","sources":["../../../../../../../libs/angular/utils/src/lib/helpers/provide-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,MAAM,EAAE,cAAc,EAAuB,MAAM,eAAe,CAAC;AAE7F,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAYlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAiC,EACjC,MAA4B,EAC5B,YAAkC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC;IAE5C,MAAM,aAAa,GAAG,CAAC,KAAiB,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IAChF,IAAI,YAAY,IAAI,MAAM,EAAE;QAC1B,OAAO;YACL,OAAO,EAAE,KAAK;YACd,8DAA8D;YAC9D,UAAU,EAAE,CAAC,GAAG,IAAe,EAAE,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,GAAI,IAAY,CAAC,CAAC;YACtF,IAAI,EAAE,MAAM,CAAC,IAAI;SAClB,CAAC;KACH;IAED,OAAO;QACL,OAAO,EAAE,KAAK;QACd,UAAU,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC;KACxC,CAAC;AACJ,CAAC;AAED,SAAS,WAAW,CAAI,KAAiC,EAAE,YAAe;IACxE,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC7B,MAAM,YAAY,GAAG,MAAM,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC;IAE7E,OAAO,SAAS,CAAC,YAAY,EAAE,YAAY,EAAE,MAAM,CAAM,CAAC;AAC5D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,kBAAkB,CAAsB,IAAO,EAAE,MAAc,EAAE,YAAe,EAAE,SAAgC;IAIhI,MAAM,UAAU,GAAG,GAAG,IAAI,QAAiB,CAAC;IAC5C,MAAM,iBAAiB,GAAG,GAAG,IAAI,eAAwB,CAAC;IAC1D,MAAM,gBAAgB,GAAG,SAAS,IAAI,QAAiB,CAAC;IACxD,MAAM,iBAAiB,GAAG,UAAU,IAAI,QAAiB,CAAC;IAC1D,MAAM,SAAS,GAAG,GAAG,MAAM,KAAK,UAAU,EAAE,CAAC;IAC7C,MAAM,KAAK,GAAG,IAAI,cAAc,CAAa,SAAS,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,YAAY,EAAE,CAAC,CAAC;IAE7G,OAAO;QACL,CAAC,UAAU,CAAC,EAAE,KAAK;QACnB,CAAC,iBAAiB,CAAC,EAAE,YAAY;QACjC,CAAC,gBAAgB,CAAC,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE,YAAY,CAAC;QAC1D,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAqB;KAI5C,CAAC;AACvD,CAAC","sourcesContent":["import { FactoryProvider, inject, InjectionToken, Type, ValueProvider } from '@angular/core';\n\nimport { deepmerge } from '@odx/angular/internal';\n\ninterface ConfigFactoryProvider<T, D extends ConfigDependencies> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  useFactory: (...args: { [I in keyof D]: D[I] extends Type<unknown> ? InstanceType<D[I]> : D[I] extends InjectionToken<unknown> ? any : never }) => T;\n  deps?: [...D];\n}\n\nexport type ConfigDependencies<T = unknown> = ReadonlyArray<Type<T> | InjectionToken<T>>;\nexport type ConfigProvider<T = unknown, D extends ConfigDependencies = []> = ConfigFactoryProvider<T, D> | T;\nexport type ConfigTransformFn<T = unknown> = (config: Partial<T>) => Partial<T>;\n\n/**\n * Provides a configuration object or a factory for creating the configuration object, optionally applying a transformation function.\n * This utility simplifies the process of defining and injecting configuration objects throughout an Angular application.\n *\n * @template T - The type of the configuration object.\n * @template D - The dependencies required by the configuration factory, if any.\n * @param {InjectionToken<T> | string} token - The injection token or string token associated with the configuration.\n * @param {ConfigProvider<T, D>} config - The configuration object or a factory provider that produces the configuration.\n * @param {ConfigTransformFn<T>} [transform=() => ({}))] - An optional transformation function to apply to the configuration object.\n * @returns {FactoryProvider | ValueProvider} - An Angular provider object for the given configuration.\n *\n * @example\n * ```ts\n * // Define a simple configuration object\n * const appConfig = { apiEndpoint: 'https://api.example.com' };\n *\n * // Provide the configuration with an optional transformation function\n * provideConfig(appConfigToken, appConfig, (config) => ({\n *   ...config,\n *   apiEndpoint: `${config.apiEndpoint}/v2`,\n * }));\n *\n * // Using a factory provider for dynamic configuration\n * provideConfig(appConfigToken, {\n *   useFactory: (envService) => ({ apiEndpoint: envService.getApiEndpoint() }),\n *   deps: [EnvironmentService],\n * });\n * ```\n */\nexport function provideConfig<T extends object, D extends ConfigDependencies = ConfigDependencies>(\n  token: InjectionToken<T> | string,\n  config: ConfigProvider<T, D>,\n  transform: ConfigTransformFn<T> = () => ({}),\n): FactoryProvider | ValueProvider {\n  const prepareConfig = (value: Partial<T>) => deepmerge(value, transform(value));\n  if ('useFactory' in config) {\n    return {\n      provide: token,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      useFactory: (...args: unknown[]) => prepareConfig(config.useFactory(...(args as any))),\n      deps: config.deps,\n    };\n  }\n\n  return {\n    provide: token,\n    useFactory: () => prepareConfig(config),\n  };\n}\n\nfunction mergeConfig<T>(token: InjectionToken<Partial<T>>, defaultValue: T): Partial<T> {\n  const config = inject(token);\n  const parentConfig = inject(token, { skipSelf: true, optional: true }) ?? {};\n\n  return deepmerge(defaultValue, parentConfig, config) as T;\n}\n\n/**\n * Generates a set of configuration-related tokens and utility functions for managing configuration in an Angular application.\n * This function creates a standardized way to define, provide, and inject configurations, including defaults and transformations.\n *\n * @template T - The type of the configuration object.\n * @template N - The name of the configuration, used to generate token names and utility functions.\n * @param {N} name - The name of the configuration.\n * @param {string} prefix - A prefix for the injection token to ensure uniqueness across the application.\n * @param {T} defaultValue - The default value for the configuration.\n * @param {ConfigTransformFn<T>} [transform] - An optional transformation function to be applied to the configuration.\n * @returns An object containing the generated injection token, default configuration, and utility functions for the configuration.\n *\n * @example\n * ```ts\n * // Create configuration tokens and utilities for \"appConfig\" with a default value and optional transform function\n * const { appConfigConfig, provideAppConfigConfig } = createConfigTokens('appConfig', 'myPrefix', { debug: false }, (config) => ({\n *   ...config,\n *   debug: true, // Enable debug mode by default\n * }));\n *\n * // Later, in a module or component, provide the customized configuration\n * @NgModule({\n *   providers: [provideAppConfigConfig({ apiEndpoint: 'https://api.example.com' })]\n * })\n * class AppModule {}\n * ```\n */\nexport function createConfigTokens<T, N extends string>(name: N, prefix: string, defaultValue: T, transform?: ConfigTransformFn<T>) {\n  type ConfigProviderFn = <D extends ConfigDependencies = ConfigDependencies<Partial<T>>>(\n    config: ConfigProvider<Partial<T>, D>,\n  ) => FactoryProvider | ValueProvider;\n  const configName = `${name}Config` as const;\n  const defaultConfigName = `${name}DefaultConfig` as const;\n  const injectConfigName = `inject${name}Config` as const;\n  const provideConfigName = `provide${name}Config` as const;\n  const tokenName = `${prefix}::${configName}`;\n  const token = new InjectionToken<Partial<T>>(tokenName, { providedIn: 'root', factory: () => defaultValue });\n\n  return {\n    [configName]: token,\n    [defaultConfigName]: defaultValue,\n    [injectConfigName]: () => mergeConfig(token, defaultValue),\n    [provideConfigName]: ((config) => provideConfig(token, config, transform)) as ConfigProviderFn,\n  } as Record<typeof configName, InjectionToken<Partial<T>>> &\n    Record<typeof defaultConfigName, T> &\n    Record<typeof injectConfigName, () => T> &\n    Record<typeof provideConfigName, ConfigProviderFn>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"provide-config.js","sourceRoot":"","sources":["../../../../../../../libs/angular/utils/src/lib/helpers/provide-config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,MAAM,EAAE,cAAc,EAAuB,MAAM,eAAe,CAAC;AAE7F,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAYlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAiC,EACjC,MAA4B,EAC5B,YAAkC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC;IAE5C,MAAM,aAAa,GAAG,CAAC,KAAiB,EAAE,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IAChF,IAAI,YAAY,IAAI,MAAM,EAAE,CAAC;QAC3B,OAAO;YACL,OAAO,EAAE,KAAK;YACd,8DAA8D;YAC9D,UAAU,EAAE,CAAC,GAAG,IAAe,EAAE,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,GAAI,IAAY,CAAC,CAAC;YACtF,IAAI,EAAE,MAAM,CAAC,IAAI;SAClB,CAAC;IACJ,CAAC;IAED,OAAO;QACL,OAAO,EAAE,KAAK;QACd,UAAU,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC;KACxC,CAAC;AACJ,CAAC;AAED,SAAS,WAAW,CAAI,KAAiC,EAAE,YAAe;IACxE,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC7B,MAAM,YAAY,GAAG,MAAM,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC;IAE7E,OAAO,SAAS,CAAC,YAAY,EAAE,YAAY,EAAE,MAAM,CAAM,CAAC;AAC5D,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,UAAU,kBAAkB,CAAsB,IAAO,EAAE,MAAc,EAAE,YAAe,EAAE,SAAgC;IAIhI,MAAM,UAAU,GAAG,GAAG,IAAI,QAAiB,CAAC;IAC5C,MAAM,iBAAiB,GAAG,GAAG,IAAI,eAAwB,CAAC;IAC1D,MAAM,gBAAgB,GAAG,SAAS,IAAI,QAAiB,CAAC;IACxD,MAAM,iBAAiB,GAAG,UAAU,IAAI,QAAiB,CAAC;IAC1D,MAAM,SAAS,GAAG,GAAG,MAAM,KAAK,UAAU,EAAE,CAAC;IAC7C,MAAM,KAAK,GAAG,IAAI,cAAc,CAAa,SAAS,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,YAAY,EAAE,CAAC,CAAC;IAE7G,OAAO;QACL,CAAC,UAAU,CAAC,EAAE,KAAK;QACnB,CAAC,iBAAiB,CAAC,EAAE,YAAY;QACjC,CAAC,gBAAgB,CAAC,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,EAAE,YAAY,CAAC;QAC1D,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAqB;KAI5C,CAAC;AACvD,CAAC","sourcesContent":["import { FactoryProvider, inject, InjectionToken, Type, ValueProvider } from '@angular/core';\n\nimport { deepmerge } from '@odx/angular/internal';\n\ninterface ConfigFactoryProvider<T, D extends ConfigDependencies> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  useFactory: (...args: { [I in keyof D]: D[I] extends Type<unknown> ? InstanceType<D[I]> : D[I] extends InjectionToken<unknown> ? any : never }) => T;\n  deps?: [...D];\n}\n\nexport type ConfigDependencies<T = unknown> = ReadonlyArray<Type<T> | InjectionToken<T>>;\nexport type ConfigProvider<T = unknown, D extends ConfigDependencies = []> = ConfigFactoryProvider<T, D> | T;\nexport type ConfigTransformFn<T = unknown> = (config: Partial<T>) => Partial<T>;\n\n/**\n * Provides a configuration object or a factory for creating the configuration object, optionally applying a transformation function.\n * This utility simplifies the process of defining and injecting configuration objects throughout an Angular application.\n *\n * @template T - The type of the configuration object.\n * @template D - The dependencies required by the configuration factory, if any.\n * @param {InjectionToken<T> | string} token - The injection token or string token associated with the configuration.\n * @param {ConfigProvider<T, D>} config - The configuration object or a factory provider that produces the configuration.\n * @param {ConfigTransformFn<T>} [transform=() => ({}))] - An optional transformation function to apply to the configuration object.\n * @returns {FactoryProvider | ValueProvider} - An Angular provider object for the given configuration.\n *\n * @example\n * ```ts\n * // Define a simple configuration object\n * const appConfig = { apiEndpoint: 'https://api.example.com' };\n *\n * // Provide the configuration with an optional transformation function\n * provideConfig(appConfigToken, appConfig, (config) => ({\n *   ...config,\n *   apiEndpoint: `${config.apiEndpoint}/v2`,\n * }));\n *\n * // Using a factory provider for dynamic configuration\n * provideConfig(appConfigToken, {\n *   useFactory: (envService) => ({ apiEndpoint: envService.getApiEndpoint() }),\n *   deps: [EnvironmentService],\n * });\n * ```\n */\nexport function provideConfig<T extends object, D extends ConfigDependencies = ConfigDependencies>(\n  token: InjectionToken<T> | string,\n  config: ConfigProvider<T, D>,\n  transform: ConfigTransformFn<T> = () => ({}),\n): FactoryProvider | ValueProvider {\n  const prepareConfig = (value: Partial<T>) => deepmerge(value, transform(value));\n  if ('useFactory' in config) {\n    return {\n      provide: token,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      useFactory: (...args: unknown[]) => prepareConfig(config.useFactory(...(args as any))),\n      deps: config.deps,\n    };\n  }\n\n  return {\n    provide: token,\n    useFactory: () => prepareConfig(config),\n  };\n}\n\nfunction mergeConfig<T>(token: InjectionToken<Partial<T>>, defaultValue: T): Partial<T> {\n  const config = inject(token);\n  const parentConfig = inject(token, { skipSelf: true, optional: true }) ?? {};\n\n  return deepmerge(defaultValue, parentConfig, config) as T;\n}\n\n/**\n * Generates a set of configuration-related tokens and utility functions for managing configuration in an Angular application.\n * This function creates a standardized way to define, provide, and inject configurations, including defaults and transformations.\n *\n * @template T - The type of the configuration object.\n * @template N - The name of the configuration, used to generate token names and utility functions.\n * @param {N} name - The name of the configuration.\n * @param {string} prefix - A prefix for the injection token to ensure uniqueness across the application.\n * @param {T} defaultValue - The default value for the configuration.\n * @param {ConfigTransformFn<T>} [transform] - An optional transformation function to be applied to the configuration.\n * @returns An object containing the generated injection token, default configuration, and utility functions for the configuration.\n *\n * @example\n * ```ts\n * // Create configuration tokens and utilities for \"appConfig\" with a default value and optional transform function\n * const { appConfigConfig, provideAppConfigConfig } = createConfigTokens('appConfig', 'myPrefix', { debug: false }, (config) => ({\n *   ...config,\n *   debug: true, // Enable debug mode by default\n * }));\n *\n * // Later, in a module or component, provide the customized configuration\n * @NgModule({\n *   providers: [provideAppConfigConfig({ apiEndpoint: 'https://api.example.com' })]\n * })\n * class AppModule {}\n * ```\n */\nexport function createConfigTokens<T, N extends string>(name: N, prefix: string, defaultValue: T, transform?: ConfigTransformFn<T>) {\n  type ConfigProviderFn = <D extends ConfigDependencies = ConfigDependencies<Partial<T>>>(\n    config: ConfigProvider<Partial<T>, D>,\n  ) => FactoryProvider | ValueProvider;\n  const configName = `${name}Config` as const;\n  const defaultConfigName = `${name}DefaultConfig` as const;\n  const injectConfigName = `inject${name}Config` as const;\n  const provideConfigName = `provide${name}Config` as const;\n  const tokenName = `${prefix}::${configName}`;\n  const token = new InjectionToken<Partial<T>>(tokenName, { providedIn: 'root', factory: () => defaultValue });\n\n  return {\n    [configName]: token,\n    [defaultConfigName]: defaultValue,\n    [injectConfigName]: () => mergeConfig(token, defaultValue),\n    [provideConfigName]: ((config) => provideConfig(token, config, transform)) as ConfigProviderFn,\n  } as Record<typeof configName, InjectionToken<Partial<T>>> &\n    Record<typeof defaultConfigName, T> &\n    Record<typeof injectConfigName, () => T> &\n    Record<typeof provideConfigName, ConfigProviderFn>;\n}\n"]}

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

@@ -182,4 +182,4 @@ export class Queue {
         return this.events$$.pipe(filter((event) => event.type === type), map(({ items }) => items), concatAll(), share());
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../../../../../../libs/angular/utils/src/lib/helpers/queue.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subject } from 'rxjs';\nimport { concatAll, distinctUntilChanged, filter, map, share, shareReplay, startWith } from 'rxjs/operators';\nimport { isNumber, isString } from './type-guards';\n\ntype QueueItemId = string | number;\ntype QueueItem<T> = T & { id: QueueItemId };\ntype QueueEventType = 'remove' | 'add' | 'update';\ntype QueueEvent<T> = { items: QueueItem<T>[]; type: QueueEventType };\n\nfunction isQueueItemId(value: unknown): value is QueueItemId {\n  return isString(value) || isNumber(value);\n}\n\n/**\n * A class representing a queue structure with advanced functionalities including adding, removing,\n * updating items, and observing changes through RxJS observables. It supports generic queue item types,\n * allowing for flexible usage across different contexts.\n *\n * @template T - The type of items stored in the queue. Each item must extend an object containing a unique `id`.\n */\nexport class Queue<T> {\n  private readonly queue = new Map<string, QueueItem<T>>();\n  private readonly events$$ = new Subject<QueueEvent<T>>();\n  private values: QueueItem<T>[] = [];\n  private firstItem: QueueItem<T> | null = null;\n  private lastItem: QueueItem<T> | null = null;\n\n  /**\n   * An observable that emits when an item is added to the queue.\n   *\n   * @type {Observable<T>}\n   */\n  public readonly onAdd$ = this.createEventObserver('add');\n\n  /**\n   * An observable that emits when an item in the queue is updated.\n   *\n   * @type {Observable<T>}\n   */\n  public readonly onUpdate$ = this.createEventObserver('update');\n\n  /**\n   * An observable that emits when an item is removed from the queue.\n   *\n   * @type {Observable<T>}\n   */\n  public readonly onRemove$ = this.createEventObserver('remove');\n\n  /**\n   * An observable representing the current state of the queue as an array of items.\n   *\n   * @type {Observable<QueueItem<T>[]>}\n   */\n  public readonly value$ = this.events$$.pipe(\n    startWith(() => void 0),\n    map(() => this.values),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /**\n   * An observable that emits the current size of the queue.\n   *\n   * @type {Observable<number>}\n   */\n  public readonly size$ = this.value$.pipe(\n    map(() => this.size),\n    distinctUntilChanged(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /**\n   * Gets the size of the queue.\n   *\n   * @returns {number} - The number of elements in the queue.\n   */\n  public get size(): number {\n    return this.queue.size;\n  }\n\n  /**\n   * Checks if the specified item is the first item in the queue.\n   *\n   * @param {QueueItem<T>} item - The item to check.\n   * @returns {boolean} - Returns `true` if the item is the first item in the queue, `false` otherwise.\n   */\n  public isFirst({ id }: QueueItem<T>): boolean {\n    return this.firstItem?.id === id;\n  }\n\n  /**\n   * Checks if the specified item is the last item in the queue.\n   *\n   * @param {QueueItem<T>} item - The item to check.\n   * @returns {boolean} - Returns true if the item is the last item, otherwise returns false.\n   */\n  public isLast({ id }: QueueItem<T>): boolean {\n    return this.lastItem?.id === id;\n  }\n\n  /**\n   * Retrieves a queue item from the queue based on the provided item or item ID.\n   *\n   * @param {QueueItem<T> | QueueItemId} itemOrId - The queue item or item ID to retrieve.\n   * @returns {QueueItem<T> | null} - The queue item if found, or `null` if not found.\n   */\n  public get(itemOrId: QueueItem<T> | QueueItemId): QueueItem<T> | null {\n    const id = isQueueItemId(itemOrId) ? itemOrId.toString() : itemOrId.id.toString();\n\n    return this.queue.get(id) ?? null;\n  }\n\n  /**\n   * Adds an item to the queue, optionally emitting an event.\n   *\n   * @param {QueueItem<T>} item - The item to add.\n   * @param {boolean} [emitEvent=true] - Whether to emit an event for this action.\n   * @returns {QueueItem<T>} The item added to the queue.\n   */\n  public add(item: QueueItem<T>, emitEvent = true): QueueItem<T> {\n    this.remove(item, false);\n\n    return this.addMany([item], emitEvent)[0];\n  }\n\n  /**\n   * Adds multiple items to the queue.\n   *\n   * @param {Array<QueueItem<T>>} items - An array of items to be added to the queue.\n   * @param {boolean} emitEvent - (Optional) A boolean indicating whether to emit an event after adding the items. Default is true.\n   * @returns {Array<QueueItem<T>>} An array of added items.\n   */\n  public addMany(items: Array<QueueItem<T>>, emitEvent = true): Array<QueueItem<T>> {\n    const addedItems = [];\n    const updatedItems = [];\n    for (const item of items) {\n      if (!this.get(item)) {\n        addedItems.push(item);\n      } else {\n        updatedItems.push(item);\n      }\n      this.queue.set(item.id.toString(), item);\n    }\n    if (addedItems.length) {\n      this.notify({ type: 'add', items: addedItems }, emitEvent);\n    }\n    if (updatedItems.length) {\n      this.notify({ type: 'update', items: updatedItems }, emitEvent);\n    }\n\n    return items;\n  }\n\n  /**\n   * Removes an item from the queue.\n   *\n   * @param {Array<QueueItem<T> | QueueItemId>} itemOrId - The item or ID of the item to be removed.\n   * @param {boolean} emitEvent - Whether to emit an event after removing the item. Default is `true`.\n   * @returns The removed item, or `null` if the item was not found.\n   */\n  public remove(itemOrId: QueueItem<T> | QueueItemId, emitEvent = true): QueueItem<T> | null {\n    return this.removeMany([itemOrId], emitEvent)[0];\n  }\n\n  /**\n   * Removes multiple items from the queue based on the provided item or item IDs.\n   *\n   * @param {Array<QueueItem<T> | QueueItemId>} itemOrIds - An array of QueueItem or QueueItemId objects representing the items to be removed.\n   * @param {boolean} emitEvent - A boolean indicating whether to emit an event after removing the items. Default is true.\n   * @returns {Array<QueueItem<T> | null>} An array of removed QueueItem objects or null values.\n   */\n  public removeMany(itemOrIds: Array<QueueItem<T> | QueueItemId>, emitEvent = true): Array<QueueItem<T> | null> {\n    const items = itemOrIds.map((itemOrId) => this.get(itemOrId)).filter(Boolean) as QueueItem<T>[];\n    const removedItems = [];\n    for (const item of items) {\n      const itemRemoved = this.queue.delete(item.id.toString());\n      if (!itemRemoved) continue;\n      removedItems.push(item);\n    }\n    this.notify({ type: 'remove', items: removedItems }, emitEvent);\n\n    return items;\n  }\n\n  /**\n   * Clears the queue by removing all items.\n   *\n   * @param {boolean} emitEvent - Whether to emit an event after clearing the queue. Default is true.\n   */\n  public clear(emitEvent = true): void {\n    const items = this.toArray();\n    this.queue.clear();\n    this.notify({ type: 'remove', items }, emitEvent);\n  }\n\n  /**\n   * Returns an array representation of the queue.\n   *\n   * @returns {QueueItem<T>[]} An array containing all the items in the queue.\n   */\n  public toArray(): QueueItem<T>[] {\n    return this.values;\n  }\n\n  private notify(event: QueueEvent<T>, emitEvent = true): void {\n    this.values = Array.from(this.queue, ([_, item]) => item).reverse();\n    this.firstItem = this.values[0] ?? null;\n    this.lastItem = this.values[this.values.length - 1] ?? null;\n    if (!emitEvent) return;\n    this.events$$.next(event);\n  }\n\n  private createEventObserver(type: QueueEventType): Observable<T> {\n    return this.events$$.pipe(\n      filter((event) => event.type === type),\n      map(({ items }) => items),\n      concatAll(),\n      share(),\n    );\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"queue.js","sourceRoot":"","sources":["../../../../../../../libs/angular/utils/src/lib/helpers/queue.ts"],"names":[],"mappings":"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","sourcesContent":["import { Observable, Subject } from 'rxjs';\nimport { concatAll, distinctUntilChanged, filter, map, share, shareReplay, startWith } from 'rxjs/operators';\nimport { isNumber, isString } from './type-guards';\n\ntype QueueItemId = string | number;\ntype QueueItem<T> = T & { id: QueueItemId };\ntype QueueEventType = 'remove' | 'add' | 'update';\ntype QueueEvent<T> = { items: QueueItem<T>[]; type: QueueEventType };\n\nfunction isQueueItemId(value: unknown): value is QueueItemId {\n  return isString(value) || isNumber(value);\n}\n\n/**\n * A class representing a queue structure with advanced functionalities including adding, removing,\n * updating items, and observing changes through RxJS observables. It supports generic queue item types,\n * allowing for flexible usage across different contexts.\n *\n * @template T - The type of items stored in the queue. Each item must extend an object containing a unique `id`.\n */\nexport class Queue<T> {\n  private readonly queue = new Map<string, QueueItem<T>>();\n  private readonly events$$ = new Subject<QueueEvent<T>>();\n  private values: QueueItem<T>[] = [];\n  private firstItem: QueueItem<T> | null = null;\n  private lastItem: QueueItem<T> | null = null;\n\n  /**\n   * An observable that emits when an item is added to the queue.\n   *\n   * @type {Observable<T>}\n   */\n  public readonly onAdd$ = this.createEventObserver('add');\n\n  /**\n   * An observable that emits when an item in the queue is updated.\n   *\n   * @type {Observable<T>}\n   */\n  public readonly onUpdate$ = this.createEventObserver('update');\n\n  /**\n   * An observable that emits when an item is removed from the queue.\n   *\n   * @type {Observable<T>}\n   */\n  public readonly onRemove$ = this.createEventObserver('remove');\n\n  /**\n   * An observable representing the current state of the queue as an array of items.\n   *\n   * @type {Observable<QueueItem<T>[]>}\n   */\n  public readonly value$ = this.events$$.pipe(\n    startWith(() => void 0),\n    map(() => this.values),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /**\n   * An observable that emits the current size of the queue.\n   *\n   * @type {Observable<number>}\n   */\n  public readonly size$ = this.value$.pipe(\n    map(() => this.size),\n    distinctUntilChanged(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  /**\n   * Gets the size of the queue.\n   *\n   * @returns {number} - The number of elements in the queue.\n   */\n  public get size(): number {\n    return this.queue.size;\n  }\n\n  /**\n   * Checks if the specified item is the first item in the queue.\n   *\n   * @param {QueueItem<T>} item - The item to check.\n   * @returns {boolean} - Returns `true` if the item is the first item in the queue, `false` otherwise.\n   */\n  public isFirst({ id }: QueueItem<T>): boolean {\n    return this.firstItem?.id === id;\n  }\n\n  /**\n   * Checks if the specified item is the last item in the queue.\n   *\n   * @param {QueueItem<T>} item - The item to check.\n   * @returns {boolean} - Returns true if the item is the last item, otherwise returns false.\n   */\n  public isLast({ id }: QueueItem<T>): boolean {\n    return this.lastItem?.id === id;\n  }\n\n  /**\n   * Retrieves a queue item from the queue based on the provided item or item ID.\n   *\n   * @param {QueueItem<T> | QueueItemId} itemOrId - The queue item or item ID to retrieve.\n   * @returns {QueueItem<T> | null} - The queue item if found, or `null` if not found.\n   */\n  public get(itemOrId: QueueItem<T> | QueueItemId): QueueItem<T> | null {\n    const id = isQueueItemId(itemOrId) ? itemOrId.toString() : itemOrId.id.toString();\n\n    return this.queue.get(id) ?? null;\n  }\n\n  /**\n   * Adds an item to the queue, optionally emitting an event.\n   *\n   * @param {QueueItem<T>} item - The item to add.\n   * @param {boolean} [emitEvent=true] - Whether to emit an event for this action.\n   * @returns {QueueItem<T>} The item added to the queue.\n   */\n  public add(item: QueueItem<T>, emitEvent = true): QueueItem<T> {\n    this.remove(item, false);\n\n    return this.addMany([item], emitEvent)[0];\n  }\n\n  /**\n   * Adds multiple items to the queue.\n   *\n   * @param {Array<QueueItem<T>>} items - An array of items to be added to the queue.\n   * @param {boolean} emitEvent - (Optional) A boolean indicating whether to emit an event after adding the items. Default is true.\n   * @returns {Array<QueueItem<T>>} An array of added items.\n   */\n  public addMany(items: Array<QueueItem<T>>, emitEvent = true): Array<QueueItem<T>> {\n    const addedItems = [];\n    const updatedItems = [];\n    for (const item of items) {\n      if (!this.get(item)) {\n        addedItems.push(item);\n      } else {\n        updatedItems.push(item);\n      }\n      this.queue.set(item.id.toString(), item);\n    }\n    if (addedItems.length) {\n      this.notify({ type: 'add', items: addedItems }, emitEvent);\n    }\n    if (updatedItems.length) {\n      this.notify({ type: 'update', items: updatedItems }, emitEvent);\n    }\n\n    return items;\n  }\n\n  /**\n   * Removes an item from the queue.\n   *\n   * @param {Array<QueueItem<T> | QueueItemId>} itemOrId - The item or ID of the item to be removed.\n   * @param {boolean} emitEvent - Whether to emit an event after removing the item. Default is `true`.\n   * @returns The removed item, or `null` if the item was not found.\n   */\n  public remove(itemOrId: QueueItem<T> | QueueItemId, emitEvent = true): QueueItem<T> | null {\n    return this.removeMany([itemOrId], emitEvent)[0];\n  }\n\n  /**\n   * Removes multiple items from the queue based on the provided item or item IDs.\n   *\n   * @param {Array<QueueItem<T> | QueueItemId>} itemOrIds - An array of QueueItem or QueueItemId objects representing the items to be removed.\n   * @param {boolean} emitEvent - A boolean indicating whether to emit an event after removing the items. Default is true.\n   * @returns {Array<QueueItem<T> | null>} An array of removed QueueItem objects or null values.\n   */\n  public removeMany(itemOrIds: Array<QueueItem<T> | QueueItemId>, emitEvent = true): Array<QueueItem<T> | null> {\n    const items = itemOrIds.map((itemOrId) => this.get(itemOrId)).filter(Boolean) as QueueItem<T>[];\n    const removedItems = [];\n    for (const item of items) {\n      const itemRemoved = this.queue.delete(item.id.toString());\n      if (!itemRemoved) continue;\n      removedItems.push(item);\n    }\n    this.notify({ type: 'remove', items: removedItems }, emitEvent);\n\n    return items;\n  }\n\n  /**\n   * Clears the queue by removing all items.\n   *\n   * @param {boolean} emitEvent - Whether to emit an event after clearing the queue. Default is true.\n   */\n  public clear(emitEvent = true): void {\n    const items = this.toArray();\n    this.queue.clear();\n    this.notify({ type: 'remove', items }, emitEvent);\n  }\n\n  /**\n   * Returns an array representation of the queue.\n   *\n   * @returns {QueueItem<T>[]} An array containing all the items in the queue.\n   */\n  public toArray(): QueueItem<T>[] {\n    return this.values;\n  }\n\n  private notify(event: QueueEvent<T>, emitEvent = true): void {\n    this.values = Array.from(this.queue, ([_, item]) => item).reverse();\n    this.firstItem = this.values[0] ?? null;\n    this.lastItem = this.values[this.values.length - 1] ?? null;\n    if (!emitEvent) return;\n    this.events$$.next(event);\n  }\n\n  private createEventObserver(type: QueueEventType): Observable<T> {\n    return this.events$$.pipe(\n      filter((event) => event.type === type),\n      map(({ items }) => items),\n      concatAll(),\n      share(),\n    );\n  }\n}\n"]}

package/fesm2022/odx-angular-breakpoints.mjs

@@ -144,10 +144,10 @@ class BreakpointsService {
             return of(false);
         return this.breakpointObserver.observe(mediaQueries).pipe(map(({ matches }) => matches), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BreakpointsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BreakpointsService, providedIn: 'root' }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BreakpointsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BreakpointsService, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BreakpointsService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BreakpointsService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
@@ -214,10 +214,10 @@ class MatchBreakpointsDirective {
             viewRef.markForCheck();
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MatchBreakpointsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: MatchBreakpointsDirective, isStandalone: true, selector: "ng-template[odxMatchBreakpoints]", inputs: { breakpoints: ["odxMatchBreakpoints", "breakpoints"], elseTemplate: ["odxMatchBreakpointsElse", "elseTemplate"] }, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatchBreakpointsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: MatchBreakpointsDirective, isStandalone: true, selector: "ng-template[odxMatchBreakpoints]", inputs: { breakpoints: ["odxMatchBreakpoints", "breakpoints"], elseTemplate: ["odxMatchBreakpointsElse", "elseTemplate"] }, ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: MatchBreakpointsDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MatchBreakpointsDirective, decorators: [{
             type: Directive,
             args: [{
                     standalone: true,
@@ -233,11 +233,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
 
 const modules = [MatchBreakpointsDirective];
 class BreakpointsModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BreakpointsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: BreakpointsModule, imports: [MatchBreakpointsDirective], exports: [MatchBreakpointsDirective] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BreakpointsModule }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BreakpointsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: BreakpointsModule, imports: [MatchBreakpointsDirective], exports: [MatchBreakpointsDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BreakpointsModule }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: BreakpointsModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BreakpointsModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: modules,

package/fesm2022/odx-angular-breakpoints.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"odx-angular-breakpoints.mjs","sources":["../../../../libs/angular/breakpoints/src/lib/helpers/configure-breakpoint.ts","../../../../libs/angular/breakpoints/src/lib/breakpoints.config.ts","../../../../libs/angular/breakpoints/src/lib/breakpoints.service.ts","../../../../libs/angular/breakpoints/src/lib/directives/match-breakpoints.directive.ts","../../../../libs/angular/breakpoints/src/lib/breakpoints.module.ts","../../../../libs/angular/breakpoints/src/odx-angular-breakpoints.ts"],"sourcesContent":["type BreakpointOperators = '<' | '=' | '>';\ntype BreakpointConfig<T extends string> = Record<`${BreakpointOperators}${T}`, string>;\n\n/**\n * Generates a configuration object containing CSS media query strings for a named breakpoint.\n * The function creates media queries for three scenarios: below (`<`), exactly (`=`), and above (`>`) the specified breakpoint.\n *\n * @template T - The string literal type representing the name of the breakpoint.\n * @param {T} name - The name of the breakpoint (e.g., 'md' for medium).\n * @param {number} min - The minimum width (inclusive) where the breakpoint starts.\n * @param {number} max - The maximum width (exclusive) where the breakpoint ends.\n * @returns {BreakpointConfig<T>} An object containing media query strings for targeting screen sizes relative to the breakpoint.\n *\n * @example\n * ```ts\n * // Define a medium (md) breakpoint\n * const mdBreakpoint = configureBreakpoint('md', 768, 1024);\n * console.log(mdBreakpoint['<md']); // Outputs: \"(max-width: 767px)\"\n * console.log(mdBreakpoint['=md']); // Outputs: \"(min-width: 768px) and (max-width: 1023px)\"\n * console.log(mdBreakpoint['>md']); // Outputs: \"(min-width: 768px)\"\n * ```\n */\nexport function configureBreakpoint<T extends string>(name: T, min: number, max: number): BreakpointConfig<T> {\n  return {\n    [`<${name}` as const]: `(max-width: ${min - 1}px)`,\n    [`=${name}` as const]: `(min-width: ${min}px) and (max-width: ${max - 1}px)`,\n    [`>${name}` as const]: `(min-width: ${min}px)`,\n  } as BreakpointConfig<T>;\n}\n","import { createConfigTokens } from '@odx/angular/utils';\nimport { configureBreakpoint } from './helpers/configure-breakpoint';\n\n/**\n * Defines default responsive breakpoints for the application. These breakpoints are used to\n * apply responsive styles and behaviors across various device sizes. Each breakpoint is\n * configured with a name, a minimum width, and a maximum width, defining the range of device\n * sizes it targets.\n *\n * @constant\n * @type {Record<string, string>}\n *\n * @example\n * ```ts\n * // Accessing a breakpoint value\n * console.log(DEFAULT_BREAKPOINTS['=phone']); // Outputs: \"(min-width: 480px) and (max-width: 767px)\"\n * ```\n */\nexport const DEFAULT_BREAKPOINTS = {\n  ...configureBreakpoint('phone-s', 360, 480),\n  ...configureBreakpoint('phone', 480, 768),\n  ...configureBreakpoint('tablet', 768, 960),\n  ...configureBreakpoint('desktop-s', 960, 1200),\n  ...configureBreakpoint('desktop', 1200, 9999),\n} as const;\n\nexport interface BreakpointsConfig {\n  breakpoints: Partial<OdxAngular.Breakpoints>;\n}\n\n/**\n * Provides Angular dependency injection tokens for accessing and configuring breakpoints\n * within the application. This enables a type-safe and modular way to manage responsive\n * design breakpoints across the app.\n *\n * @example\n * ```ts\n * // Providing custom breakpoints in an Angular module\n * import { NgModule } from '@angular/core';\n * import { provideBreakpointsConfig } from '@odx/angular/breakpoints';\n *\n * @NgModule({\n *   providers: [\n *     provideBreakpointsConfig({\n *       breakpoints: {\n *         ...configureBreakpoint('custom-tablet', 640, 1024),\n *       },\n *     }),\n *   ],\n * })\n * export class CustomModule {}\n * ```\n */\nexport const { BreakpointsConfig, BreakpointsDefaultConfig, injectBreakpointsConfig, provideBreakpointsConfig } = createConfigTokens(\n  'Breakpoints',\n  '@odx/angular/breakpoints',\n  {\n    breakpoints: DEFAULT_BREAKPOINTS,\n  } as BreakpointsConfig,\n);\n","import { BreakpointObserver } from '@angular/cdk/layout';\nimport { inject, Injectable } from '@angular/core';\nimport { distinctUntilChanged, map, Observable, of, shareReplay } from 'rxjs';\nimport { injectBreakpointsConfig } from './breakpoints.config';\nimport { BreakpointName } from './models';\n\n/**\n * Service to observe and react to changes in viewport size based on predefined breakpoints.\n * Utilizes Angular CDK's BreakpointObserver for listening to media query changes and integrates\n * it with the application's custom breakpoints configuration.\n *\n * @Injectable({ providedIn: 'root' })\n */\n@Injectable({ providedIn: 'root' })\nexport class BreakpointsService {\n  private readonly breakpointObserver = inject(BreakpointObserver);\n  private readonly config = injectBreakpointsConfig();\n\n  /**\n   * Observes the specified breakpoints and returns an Observable that emits true if any\n   * of the specified breakpoints match the current viewport size, and false otherwise.\n   *\n   * @param {BreakpointName[]} breakpoints - An array of breakpoints to observe.\n   * @returns {Observable<boolean>} - An Observable that emits true if the viewport matches the specified breakpoints.\n   *\n   * @example\n   * ```ts\n   * // Component that uses BreakpointsService to apply dynamic styles based on breakpoints\n   * @Component({\n   *   selector: 'app-responsive-component',\n   *   templateUrl: './responsive-component.component.html',\n   * })\n   * export class ResponsiveComponent {\n   *   isMobile$: Observable<boolean>;\n   *\n   *   constructor(private breakpointsService: BreakpointsService) {\n   *     this.isMobile$ = this.breakpointsService.observe(['phone', 'tablet']);\n   *   }\n   * }\n   * ```\n   */\n  public observe(breakpoints: BreakpointName[]): Observable<boolean> {\n    const mediaQueries = this.getMediaQueries(breakpoints);\n\n    return this.createBreakpointObserver(mediaQueries);\n  }\n\n  /**\n   * Checks if any of the specified breakpoints match the current viewport size.\n   *\n   * @param {BreakpointName[]} breakpoints - An array of breakpoints to check.\n   * @returns {boolean} - Returns true if the viewport matches the specified breakpoints, false otherwise.\n   *\n   * @example\n   * ```ts\n   * // Checking if the current viewport matches the 'desktop' breakpoint\n   * const isDesktop = this.breakpointsService.matches(['desktop']);\n   * console.log(`Is desktop view? ${isDesktop}`);\n   * ```\n   */\n  public matches(breakpoints: BreakpointName[]): boolean {\n    const mediaQueries = this.getMediaQueries(breakpoints);\n\n    return this.breakpointObserver.isMatched(mediaQueries);\n  }\n\n  private getMediaQueries(breakpointNames: BreakpointName[]): string[] {\n    return breakpointNames.map((name) => this.config.breakpoints[name] as string).filter(Boolean);\n  }\n\n  private createBreakpointObserver(mediaQueries: string[]): Observable<boolean> {\n    if (mediaQueries.length < 1) return of(false);\n\n    return this.breakpointObserver.observe(mediaQueries).pipe(\n      map(({ matches }) => matches),\n      distinctUntilChanged(),\n      shareReplay({ bufferSize: 1, refCount: true }),\n    );\n  }\n}\n","import { Directive, inject, Input, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';\nimport { coerceArray, untilDestroyed } from '@odx/angular/utils';\nimport { BehaviorSubject, switchMap, tap } from 'rxjs';\nimport { BreakpointsService } from '../breakpoints.service';\nimport { BreakpointName } from '../models';\n\n/**\n * A structural directive that conditionally includes an Angular template based on whether the viewport matches\n * specified breakpoints. It leverages the BreakpointsService to observe changes in viewport size and apply\n * the appropriate template.\n *\n * @Directive\n * @param {BreakpointsService} breakpointsService - Injects BreakpointsService to observe breakpoint changes.\n * @param {TemplateRef} template - Injects the Angular template to render when breakpoints match.\n * @param {ViewContainerRef} viewContainer - Injects the container where the template will be rendered.\n *\n * @example\n * ```html\n * // Usage in a component template to conditionally display content based on breakpoints\n * // Assume 'mobile' and 'tablet' are defined breakpoints\n * <ng-template [odxMatchBreakpoints]=\"['mobile', 'tablet']\">\n *   Content to display on mobile and tablet sizes.\n * </ng-template>\n * <ng-template [odxMatchBreakpoints]=\"['desktop']\" [odxMatchBreakpointsElse]=\"elseTemplate\">\n *   Content to display on desktop size.\n * </ng-template>\n * <ng-template #elseTemplate>\n *   Content to display when not on desktop size.\n * </ng-template>\n * ```\n */\n@Directive({\n  standalone: true,\n  selector: 'ng-template[odxMatchBreakpoints]',\n})\nexport class MatchBreakpointsDirective implements OnInit {\n  private readonly breakpoints$$ = new BehaviorSubject<BreakpointName[]>([]);\n  private readonly breakpointsService = inject(BreakpointsService);\n  private readonly takeUntilDestroyed = untilDestroyed();\n  private readonly template = inject(TemplateRef);\n  private readonly viewContainer = inject(ViewContainerRef);\n\n  /**\n   * Sets the breakpoints to observe. The directive's content is displayed if the current viewport matches\n   * any of the specified breakpoints.\n   *\n   * @param {BreakpointName | BreakpointName[]} value - The breakpoint(s) to match against the current viewport size.\n   */\n  @Input('odxMatchBreakpoints')\n  public set breakpoints(value: BreakpointName | BreakpointName[] | null | undefined) {\n    this.breakpoints$$.next(coerceArray(value ?? []));\n  }\n\n  /**\n   * Optionally specifies a template to render when the viewport does not match the specified breakpoints.\n   *\n   * @param {TemplateRef<unknown>} elseTemplate - The template to render when the viewport does not match the breakpoints.\n   */\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('odxMatchBreakpointsElse')\n  public elseTemplate?: TemplateRef<unknown> | null = null;\n\n  public ngOnInit(): void {\n    this.breakpoints$$\n      .pipe(\n        switchMap((breakpoints) => this.breakpointsService.observe(breakpoints)),\n        tap((matchesBreakpoints) => this.render(matchesBreakpoints)),\n        this.takeUntilDestroyed(),\n      )\n      .subscribe();\n  }\n\n  private render(matchesBreakpoints: boolean): void {\n    this.viewContainer.clear();\n    const template = matchesBreakpoints ? this.template : this.elseTemplate;\n    if (template) {\n      const viewRef = this.viewContainer.createEmbeddedView(template);\n      viewRef.markForCheck();\n    }\n  }\n}\n","import { NgModule } from '@angular/core';\nimport { MatchBreakpointsDirective } from './directives';\n\nconst modules = [MatchBreakpointsDirective];\n\n@NgModule({\n  imports: modules,\n  exports: modules,\n})\nexport class BreakpointsModule {}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"odx-angular-breakpoints.mjs","sources":["../../../../libs/angular/breakpoints/src/lib/helpers/configure-breakpoint.ts","../../../../libs/angular/breakpoints/src/lib/breakpoints.config.ts","../../../../libs/angular/breakpoints/src/lib/breakpoints.service.ts","../../../../libs/angular/breakpoints/src/lib/directives/match-breakpoints.directive.ts","../../../../libs/angular/breakpoints/src/lib/breakpoints.module.ts","../../../../libs/angular/breakpoints/src/odx-angular-breakpoints.ts"],"sourcesContent":["type BreakpointOperators = '<' | '=' | '>';\ntype BreakpointConfig<T extends string> = Record<`${BreakpointOperators}${T}`, string>;\n\n/**\n * Generates a configuration object containing CSS media query strings for a named breakpoint.\n * The function creates media queries for three scenarios: below (`<`), exactly (`=`), and above (`>`) the specified breakpoint.\n *\n * @template T - The string literal type representing the name of the breakpoint.\n * @param {T} name - The name of the breakpoint (e.g., 'md' for medium).\n * @param {number} min - The minimum width (inclusive) where the breakpoint starts.\n * @param {number} max - The maximum width (exclusive) where the breakpoint ends.\n * @returns {BreakpointConfig<T>} An object containing media query strings for targeting screen sizes relative to the breakpoint.\n *\n * @example\n * ```ts\n * // Define a medium (md) breakpoint\n * const mdBreakpoint = configureBreakpoint('md', 768, 1024);\n * console.log(mdBreakpoint['<md']); // Outputs: \"(max-width: 767px)\"\n * console.log(mdBreakpoint['=md']); // Outputs: \"(min-width: 768px) and (max-width: 1023px)\"\n * console.log(mdBreakpoint['>md']); // Outputs: \"(min-width: 768px)\"\n * ```\n */\nexport function configureBreakpoint<T extends string>(name: T, min: number, max: number): BreakpointConfig<T> {\n  return {\n    [`<${name}` as const]: `(max-width: ${min - 1}px)`,\n    [`=${name}` as const]: `(min-width: ${min}px) and (max-width: ${max - 1}px)`,\n    [`>${name}` as const]: `(min-width: ${min}px)`,\n  } as BreakpointConfig<T>;\n}\n","import { createConfigTokens } from '@odx/angular/utils';\nimport { configureBreakpoint } from './helpers/configure-breakpoint';\n\n/**\n * Defines default responsive breakpoints for the application. These breakpoints are used to\n * apply responsive styles and behaviors across various device sizes. Each breakpoint is\n * configured with a name, a minimum width, and a maximum width, defining the range of device\n * sizes it targets.\n *\n * @constant\n * @type {Record<string, string>}\n *\n * @example\n * ```ts\n * // Accessing a breakpoint value\n * console.log(DEFAULT_BREAKPOINTS['=phone']); // Outputs: \"(min-width: 480px) and (max-width: 767px)\"\n * ```\n */\nexport const DEFAULT_BREAKPOINTS = {\n  ...configureBreakpoint('phone-s', 360, 480),\n  ...configureBreakpoint('phone', 480, 768),\n  ...configureBreakpoint('tablet', 768, 960),\n  ...configureBreakpoint('desktop-s', 960, 1200),\n  ...configureBreakpoint('desktop', 1200, 9999),\n} as const;\n\nexport interface BreakpointsConfig {\n  breakpoints: Partial<OdxAngular.Breakpoints>;\n}\n\n/**\n * Provides Angular dependency injection tokens for accessing and configuring breakpoints\n * within the application. This enables a type-safe and modular way to manage responsive\n * design breakpoints across the app.\n *\n * @example\n * ```ts\n * // Providing custom breakpoints in an Angular module\n * import { NgModule } from '@angular/core';\n * import { provideBreakpointsConfig } from '@odx/angular/breakpoints';\n *\n * @NgModule({\n *   providers: [\n *     provideBreakpointsConfig({\n *       breakpoints: {\n *         ...configureBreakpoint('custom-tablet', 640, 1024),\n *       },\n *     }),\n *   ],\n * })\n * export class CustomModule {}\n * ```\n */\nexport const { BreakpointsConfig, BreakpointsDefaultConfig, injectBreakpointsConfig, provideBreakpointsConfig } = createConfigTokens(\n  'Breakpoints',\n  '@odx/angular/breakpoints',\n  {\n    breakpoints: DEFAULT_BREAKPOINTS,\n  } as BreakpointsConfig,\n);\n","import { BreakpointObserver } from '@angular/cdk/layout';\nimport { inject, Injectable } from '@angular/core';\nimport { distinctUntilChanged, map, Observable, of, shareReplay } from 'rxjs';\nimport { injectBreakpointsConfig } from './breakpoints.config';\nimport { BreakpointName } from './models';\n\n/**\n * Service to observe and react to changes in viewport size based on predefined breakpoints.\n * Utilizes Angular CDK's BreakpointObserver for listening to media query changes and integrates\n * it with the application's custom breakpoints configuration.\n *\n * @Injectable({ providedIn: 'root' })\n */\n@Injectable({ providedIn: 'root' })\nexport class BreakpointsService {\n  private readonly breakpointObserver = inject(BreakpointObserver);\n  private readonly config = injectBreakpointsConfig();\n\n  /**\n   * Observes the specified breakpoints and returns an Observable that emits true if any\n   * of the specified breakpoints match the current viewport size, and false otherwise.\n   *\n   * @param {BreakpointName[]} breakpoints - An array of breakpoints to observe.\n   * @returns {Observable<boolean>} - An Observable that emits true if the viewport matches the specified breakpoints.\n   *\n   * @example\n   * ```ts\n   * // Component that uses BreakpointsService to apply dynamic styles based on breakpoints\n   * @Component({\n   *   selector: 'app-responsive-component',\n   *   templateUrl: './responsive-component.component.html',\n   * })\n   * export class ResponsiveComponent {\n   *   isMobile$: Observable<boolean>;\n   *\n   *   constructor(private breakpointsService: BreakpointsService) {\n   *     this.isMobile$ = this.breakpointsService.observe(['phone', 'tablet']);\n   *   }\n   * }\n   * ```\n   */\n  public observe(breakpoints: BreakpointName[]): Observable<boolean> {\n    const mediaQueries = this.getMediaQueries(breakpoints);\n\n    return this.createBreakpointObserver(mediaQueries);\n  }\n\n  /**\n   * Checks if any of the specified breakpoints match the current viewport size.\n   *\n   * @param {BreakpointName[]} breakpoints - An array of breakpoints to check.\n   * @returns {boolean} - Returns true if the viewport matches the specified breakpoints, false otherwise.\n   *\n   * @example\n   * ```ts\n   * // Checking if the current viewport matches the 'desktop' breakpoint\n   * const isDesktop = this.breakpointsService.matches(['desktop']);\n   * console.log(`Is desktop view? ${isDesktop}`);\n   * ```\n   */\n  public matches(breakpoints: BreakpointName[]): boolean {\n    const mediaQueries = this.getMediaQueries(breakpoints);\n\n    return this.breakpointObserver.isMatched(mediaQueries);\n  }\n\n  private getMediaQueries(breakpointNames: BreakpointName[]): string[] {\n    return breakpointNames.map((name) => this.config.breakpoints[name] as string).filter(Boolean);\n  }\n\n  private createBreakpointObserver(mediaQueries: string[]): Observable<boolean> {\n    if (mediaQueries.length < 1) return of(false);\n\n    return this.breakpointObserver.observe(mediaQueries).pipe(\n      map(({ matches }) => matches),\n      distinctUntilChanged(),\n      shareReplay({ bufferSize: 1, refCount: true }),\n    );\n  }\n}\n","import { Directive, inject, Input, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';\nimport { coerceArray, untilDestroyed } from '@odx/angular/utils';\nimport { BehaviorSubject, switchMap, tap } from 'rxjs';\nimport { BreakpointsService } from '../breakpoints.service';\nimport { BreakpointName } from '../models';\n\n/**\n * A structural directive that conditionally includes an Angular template based on whether the viewport matches\n * specified breakpoints. It leverages the BreakpointsService to observe changes in viewport size and apply\n * the appropriate template.\n *\n * @Directive\n * @param {BreakpointsService} breakpointsService - Injects BreakpointsService to observe breakpoint changes.\n * @param {TemplateRef} template - Injects the Angular template to render when breakpoints match.\n * @param {ViewContainerRef} viewContainer - Injects the container where the template will be rendered.\n *\n * @example\n * ```html\n * // Usage in a component template to conditionally display content based on breakpoints\n * // Assume 'mobile' and 'tablet' are defined breakpoints\n * <ng-template [odxMatchBreakpoints]=\"['mobile', 'tablet']\">\n *   Content to display on mobile and tablet sizes.\n * </ng-template>\n * <ng-template [odxMatchBreakpoints]=\"['desktop']\" [odxMatchBreakpointsElse]=\"elseTemplate\">\n *   Content to display on desktop size.\n * </ng-template>\n * <ng-template #elseTemplate>\n *   Content to display when not on desktop size.\n * </ng-template>\n * ```\n */\n@Directive({\n  standalone: true,\n  selector: 'ng-template[odxMatchBreakpoints]',\n})\nexport class MatchBreakpointsDirective implements OnInit {\n  private readonly breakpoints$$ = new BehaviorSubject<BreakpointName[]>([]);\n  private readonly breakpointsService = inject(BreakpointsService);\n  private readonly takeUntilDestroyed = untilDestroyed();\n  private readonly template = inject(TemplateRef);\n  private readonly viewContainer = inject(ViewContainerRef);\n\n  /**\n   * Sets the breakpoints to observe. The directive's content is displayed if the current viewport matches\n   * any of the specified breakpoints.\n   *\n   * @param {BreakpointName | BreakpointName[]} value - The breakpoint(s) to match against the current viewport size.\n   */\n  @Input('odxMatchBreakpoints')\n  public set breakpoints(value: BreakpointName | BreakpointName[] | null | undefined) {\n    this.breakpoints$$.next(coerceArray(value ?? []));\n  }\n\n  /**\n   * Optionally specifies a template to render when the viewport does not match the specified breakpoints.\n   *\n   * @param {TemplateRef<unknown>} elseTemplate - The template to render when the viewport does not match the breakpoints.\n   */\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('odxMatchBreakpointsElse')\n  public elseTemplate?: TemplateRef<unknown> | null = null;\n\n  public ngOnInit(): void {\n    this.breakpoints$$\n      .pipe(\n        switchMap((breakpoints) => this.breakpointsService.observe(breakpoints)),\n        tap((matchesBreakpoints) => this.render(matchesBreakpoints)),\n        this.takeUntilDestroyed(),\n      )\n      .subscribe();\n  }\n\n  private render(matchesBreakpoints: boolean): void {\n    this.viewContainer.clear();\n    const template = matchesBreakpoints ? this.template : this.elseTemplate;\n    if (template) {\n      const viewRef = this.viewContainer.createEmbeddedView(template);\n      viewRef.markForCheck();\n    }\n  }\n}\n","import { NgModule } from '@angular/core';\nimport { MatchBreakpointsDirective } from './directives';\n\nconst modules = [MatchBreakpointsDirective];\n\n@NgModule({\n  imports: modules,\n  exports: modules,\n})\nexport class BreakpointsModule {}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":"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"}

package/fesm2022/odx-angular-cdk-a11y.mjs

@@ -50,13 +50,13 @@ let InteractiveDirective = class InteractiveDirective {
             return;
         this.interact.next(event);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: InteractiveDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: InteractiveDirective, isStandalone: true, selector: "[odxCdkInteractive]", outputs: { interact: "odxCdkInteractive" }, host: { attributes: { "role": "button" }, listeners: { "click": "handleEvents($event)", "keyup.enter": "handleEvents($event)", "keyup.space": "handleEvents($event)" } }, hostDirectives: [{ directive: i1.WithDisabledState }, { directive: i1.WithTabIndex }], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InteractiveDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: InteractiveDirective, isStandalone: true, selector: "[odxCdkInteractive]", outputs: { interact: "odxCdkInteractive" }, host: { attributes: { "role": "button" }, listeners: { "click": "handleEvents($event)", "keyup.enter": "handleEvents($event)", "keyup.space": "handleEvents($event)" } }, hostDirectives: [{ directive: i1.WithDisabledState }, { directive: i1.WithTabIndex }], ngImport: i0 }); }
 };
 InteractiveDirective = __decorate([
     CSSComponent('cdk-interactive')
 ], InteractiveDirective);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: InteractiveDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: InteractiveDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[odxCdkInteractive]',
@@ -113,10 +113,10 @@ class ListFocusManagerOptionDirective {
     focus() {
         this.element.nativeElement.focus();
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ListFocusManagerOptionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ListFocusManagerOptionDirective, isStandalone: true, selector: "[odxListFocusManagerOption]", ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ListFocusManagerOptionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: ListFocusManagerOptionDirective, isStandalone: true, selector: "[odxListFocusManagerOption]", ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ListFocusManagerOptionDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ListFocusManagerOptionDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[odxListFocusManagerOption]',
@@ -159,10 +159,10 @@ class ListFocusManagerDirective {
     onKeyDown(event) {
         this.keyManager?.onKeydown(event);
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ListFocusManagerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ListFocusManagerDirective, isStandalone: true, selector: "[odxListFocusManager]", host: { listeners: { "keydown": "onKeyDown($event)" } }, queries: [{ propertyName: "options", predicate: ListFocusManagerOptionDirective }], ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ListFocusManagerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: ListFocusManagerDirective, isStandalone: true, selector: "[odxListFocusManager]", host: { listeners: { "keydown": "onKeyDown($event)" } }, queries: [{ propertyName: "options", predicate: ListFocusManagerOptionDirective }], ngImport: i0 }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ListFocusManagerDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ListFocusManagerDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[odxListFocusManager]',
@@ -178,11 +178,11 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
 
 const modules = [ListFocusManagerDirective, ListFocusManagerOptionDirective, InteractiveDirective];
 class A11yModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: A11yModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
-    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: A11yModule, imports: [A11yModule$1, ListFocusManagerDirective, ListFocusManagerOptionDirective, InteractiveDirective], exports: [CoreModule, A11yModule$1, ListFocusManagerDirective, ListFocusManagerOptionDirective, InteractiveDirective] }); }
-    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: A11yModule, imports: [A11yModule$1, CoreModule, A11yModule$1] }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: A11yModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: A11yModule, imports: [A11yModule$1, ListFocusManagerDirective, ListFocusManagerOptionDirective, InteractiveDirective], exports: [CoreModule, A11yModule$1, ListFocusManagerDirective, ListFocusManagerOptionDirective, InteractiveDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: A11yModule, imports: [A11yModule$1, CoreModule, A11yModule$1] }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: A11yModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: A11yModule, decorators: [{
             type: NgModule,
             args: [{
                     imports: [A11yModule$1, ...modules],

package/fesm2022/odx-angular-cdk-active-indicator.mjs

@@ -164,8 +164,8 @@ let ActiveIndicatorDirective = class ActiveIndicatorDirective {
                 return -100;
         }
     }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ActiveIndicatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ActiveIndicatorDirective, isStandalone: true, selector: "[odxActiveIndicator]", inputs: { activeElement: ["odxActiveIndicator", "activeElement"], parent: ["odxActiveIndicatorParent", "parent"], direction: ["odxActiveIndicatorDirection", "direction"], position: ["odxActiveIndicatorPosition", "position"] }, usesOnChanges: true, ngImport: i0 }); }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ActiveIndicatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: ActiveIndicatorDirective, isStandalone: true, selector: "[odxActiveIndicator]", inputs: { activeElement: ["odxActiveIndicator", "activeElement"], parent: ["odxActiveIndicatorParent", "parent"], direction: ["odxActiveIndicatorDirection", "direction"], position: ["odxActiveIndicatorPosition", "position"] }, usesOnChanges: true, ngImport: i0 }); }
 };
 __decorate([
     CSSModifier(),
@@ -178,7 +178,7 @@ __decorate([
 ActiveIndicatorDirective = __decorate([
     CSSComponent('cdk-active-indicator')
 ], ActiveIndicatorDirective);
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ActiveIndicatorDirective, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ActiveIndicatorDirective, decorators: [{
             type: Directive,
             args: [{
                     standalone: true,