@odx/angular 5.7.4 → 6.0.1

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

@@ -1,3 +1,32 @@
+/**
+ * Checks if the specified property or properties have changed in the current change detection cycle.
+ * Optionally ignores changes that occur during the first change detection cycle (e.g., initialization).
+ *
+ * @template U - The component or directive class.
+ * @template T - The type representing the changes, typically `NgChanges<U>`.
+ * @template K - The key or keys representing the properties to check for changes.
+ * @param {T} changes - The `NgChanges` object containing information about all changes.
+ * @param {K | K[]} keyOrKeys - The property name(s) to check for changes.
+ * @param {boolean} [ignoreFirstChange=true] - Whether to ignore changes that occur during the first change detection cycle.
+ * @returns {boolean} `true` if the specified property or properties have changed, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * // Example usage within an Angular component's `ngOnChanges` method
+ * ngOnChanges(changes: NgChanges<MyComponent>): void {
+ *   if (hasChanged(changes, 'name')) {
+ *     console.log('Name has changed');
+ *   }
+ * }
+ *
+ * // Checking multiple properties for changes
+ * ngOnChanges(changes: NgChanges<MyComponent>): void {
+ *   if (hasChanged(changes, ['name', 'age'], false)) {
+ *     console.log('Name or age has changed (including first change)');
+ *   }
+ * }
+ * ```
+ */
 export function hasChanged(changes, keyOrKeys, ignoreFirstChange = true) {
     if (Array.isArray(keyOrKeys)) {
         for (const key of keyOrKeys) {
@@ -11,4 +40,4 @@ export function hasChanged(changes, keyOrKeys, ignoreFirstChange = true) {
         return keyOrKeys in changes && (!ignoreFirstChange || !changes[keyOrKeys]?.isFirstChange());
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctY2hhbmdlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci91dGlscy9zcmMvbGliL2hlbHBlcnMvbmctY2hhbmdlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFXQSxNQUFNLFVBQVUsVUFBVSxDQUN4QixPQUFVLEVBQ1YsU0FBa0IsRUFDbEIsaUJBQWlCLEdBQUcsSUFBSTtJQUV4QixJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLEVBQUU7UUFDNUIsS0FBSyxNQUFNLEdBQUcsSUFBSSxTQUFTLEVBQUU7WUFDM0IsSUFBSSxVQUFVLENBQUMsT0FBTyxFQUFFLEdBQUcsRUFBRSxpQkFBaUIsQ0FBQyxFQUFFO2dCQUMvQyxPQUFPLElBQUksQ0FBQzthQUNiO1NBQ0Y7UUFDRCxPQUFPLEtBQUssQ0FBQztLQUNkO1NBQU07UUFDTCxPQUFPLFNBQVMsSUFBSSxPQUFPLElBQUksQ0FBQyxDQUFDLGlCQUFpQixJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFLGFBQWEsRUFBRSxDQUFDLENBQUM7S0FDN0Y7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgR2V0UHJvcGVydGllcyB9IGZyb20gJy4uL3R5cGVzJztcblxuZXhwb3J0IHR5cGUgTmdDaGFuZ2VzPEMsIFByb3BlcnRpZXMgPSBHZXRQcm9wZXJ0aWVzPEM+PiA9IHtcbiAgW0tleSBpbiBrZXlvZiBQcm9wZXJ0aWVzXToge1xuICAgIHByZXZpb3VzVmFsdWU6IFByb3BlcnRpZXNbS2V5XTtcbiAgICBjdXJyZW50VmFsdWU6IFByb3BlcnRpZXNbS2V5XTtcbiAgICBmaXJzdENoYW5nZTogYm9vbGVhbjtcbiAgICBpc0ZpcnN0Q2hhbmdlKCk6IGJvb2xlYW47XG4gIH07XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gaGFzQ2hhbmdlZDxVIGV4dGVuZHMgUmVjb3JkPHN0cmluZywgdW5rbm93bj4sIFQgZXh0ZW5kcyBOZ0NoYW5nZXM8VT4sIEsgZXh0ZW5kcyBrZXlvZiBUPihcbiAgY2hhbmdlczogVCxcbiAga2V5T3JLZXlzOiBLIHwgS1tdLFxuICBpZ25vcmVGaXJzdENoYW5nZSA9IHRydWUsXG4pOiBib29sZWFuIHtcbiAgaWYgKEFycmF5LmlzQXJyYXkoa2V5T3JLZXlzKSkge1xuICAgIGZvciAoY29uc3Qga2V5IG9mIGtleU9yS2V5cykge1xuICAgICAgaWYgKGhhc0NoYW5nZWQoY2hhbmdlcywga2V5LCBpZ25vcmVGaXJzdENoYW5nZSkpIHtcbiAgICAgICAgcmV0dXJuIHRydWU7XG4gICAgICB9XG4gICAgfVxuICAgIHJldHVybiBmYWxzZTtcbiAgfSBlbHNlIHtcbiAgICByZXR1cm4ga2V5T3JLZXlzIGluIGNoYW5nZXMgJiYgKCFpZ25vcmVGaXJzdENoYW5nZSB8fCAhY2hhbmdlc1trZXlPcktleXNdPy5pc0ZpcnN0Q2hhbmdlKCkpO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctY2hhbmdlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci91dGlscy9zcmMvbGliL2hlbHBlcnMvbmctY2hhbmdlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFrQ0E7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0E0Qkc7QUFDSCxNQUFNLFVBQVUsVUFBVSxDQUN4QixPQUFVLEVBQ1YsU0FBa0IsRUFDbEIsaUJBQWlCLEdBQUcsSUFBSTtJQUV4QixJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLEVBQUU7UUFDNUIsS0FBSyxNQUFNLEdBQUcsSUFBSSxTQUFTLEVBQUU7WUFDM0IsSUFBSSxVQUFVLENBQUMsT0FBTyxFQUFFLEdBQUcsRUFBRSxpQkFBaUIsQ0FBQyxFQUFFO2dCQUMvQyxPQUFPLElBQUksQ0FBQzthQUNiO1NBQ0Y7UUFDRCxPQUFPLEtBQUssQ0FBQztLQUNkO1NBQU07UUFDTCxPQUFPLFNBQVMsSUFBSSxPQUFPLElBQUksQ0FBQyxDQUFDLGlCQUFpQixJQUFJLENBQUMsT0FBTyxDQUFDLFNBQVMsQ0FBQyxFQUFFLGFBQWEsRUFBRSxDQUFDLENBQUM7S0FDN0Y7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgR2V0UHJvcGVydGllcyB9IGZyb20gJy4uL3R5cGVzJztcblxuLyoqXG4gKiBSZXByZXNlbnRzIGEgdHlwZWQgdmVyc2lvbiBvZiBBbmd1bGFyJ3MgYFNpbXBsZUNoYW5nZXNgIG9iamVjdCwgZGVzY3JpYmluZyB0aGUgY2hhbmdlcyB0byBlYWNoXG4gKiBwcm9wZXJ0eSBvZiBhIGNvbXBvbmVudCBvciBkaXJlY3RpdmUuIFRoaXMgdXRpbGl0eSBlbmhhbmNlcyB0eXBlIHNhZmV0eSB3aGVuIHdvcmtpbmcgd2l0aCBBbmd1bGFyJ3NcbiAqIGNoYW5nZSBkZXRlY3Rpb24gbWVjaGFuaXNtIGJ5IHByb3ZpZGluZyBzcGVjaWZpYyBwcm9wZXJ0eSB0eXBlcy5cbiAqXG4gKiBAdGVtcGxhdGUgQyAtIFRoZSBjb21wb25lbnQgb3IgZGlyZWN0aXZlIGNsYXNzLlxuICogQHRlbXBsYXRlIFByb3BlcnRpZXMgLSBUaGUgcHJvcGVydGllcyBvZiB0aGUgY29tcG9uZW50IG9yIGRpcmVjdGl2ZSwgaW5mZXJyZWQgZnJvbSBgQ2AgYnkgZGVmYXVsdC5cbiAqIEB0eXBlIHtPYmplY3R9IC0gQSBtYXBwaW5nIGZyb20gcHJvcGVydHkgbmFtZXMgdG8gY2hhbmdlIGluZm9ybWF0aW9uIGZvciBlYWNoIHByb3BlcnR5LlxuICpcbiAqIEBleGFtcGxlXG4gKiBgYGB0c1xuICogaW50ZXJmYWNlIE15Q29tcG9uZW50IHtcbiAqICAgbmFtZTogc3RyaW5nO1xuICogICBhZ2U6IG51bWJlcjtcbiAqIH1cbiAqXG4gKiBmdW5jdGlvbiBuZ09uQ2hhbmdlcyhjaGFuZ2VzOiBOZ0NoYW5nZXM8TXlDb21wb25lbnQ+KSB7XG4gKiAgIGlmIChjaGFuZ2VzLm5hbWUpIHtcbiAqICAgICBjb25zb2xlLmxvZygnTmFtZSBjaGFuZ2VkIGZyb20nLCBjaGFuZ2VzLm5hbWUucHJldmlvdXNWYWx1ZSwgJ3RvJywgY2hhbmdlcy5uYW1lLmN1cnJlbnRWYWx1ZSk7XG4gKiAgIH1cbiAqIH1cbiAqIGBgYFxuICovXG5leHBvcnQgdHlwZSBOZ0NoYW5nZXM8QywgUHJvcGVydGllcyA9IEdldFByb3BlcnRpZXM8Qz4+ID0ge1xuICBbS2V5IGluIGtleW9mIFByb3BlcnRpZXNdOiB7XG4gICAgcHJldmlvdXNWYWx1ZTogUHJvcGVydGllc1tLZXldO1xuICAgIGN1cnJlbnRWYWx1ZTogUHJvcGVydGllc1tLZXldO1xuICAgIGZpcnN0Q2hhbmdlOiBib29sZWFuO1xuICAgIGlzRmlyc3RDaGFuZ2UoKTogYm9vbGVhbjtcbiAgfTtcbn07XG5cbi8qKlxuICogQ2hlY2tzIGlmIHRoZSBzcGVjaWZpZWQgcHJvcGVydHkgb3IgcHJvcGVydGllcyBoYXZlIGNoYW5nZWQgaW4gdGhlIGN1cnJlbnQgY2hhbmdlIGRldGVjdGlvbiBjeWNsZS5cbiAqIE9wdGlvbmFsbHkgaWdub3JlcyBjaGFuZ2VzIHRoYXQgb2NjdXIgZHVyaW5nIHRoZSBmaXJzdCBjaGFuZ2UgZGV0ZWN0aW9uIGN5Y2xlIChlLmcuLCBpbml0aWFsaXphdGlvbikuXG4gKlxuICogQHRlbXBsYXRlIFUgLSBUaGUgY29tcG9uZW50IG9yIGRpcmVjdGl2ZSBjbGFzcy5cbiAqIEB0ZW1wbGF0ZSBUIC0gVGhlIHR5cGUgcmVwcmVzZW50aW5nIHRoZSBjaGFuZ2VzLCB0eXBpY2FsbHkgYE5nQ2hhbmdlczxVPmAuXG4gKiBAdGVtcGxhdGUgSyAtIFRoZSBrZXkgb3Iga2V5cyByZXByZXNlbnRpbmcgdGhlIHByb3BlcnRpZXMgdG8gY2hlY2sgZm9yIGNoYW5nZXMuXG4gKiBAcGFyYW0ge1R9IGNoYW5nZXMgLSBUaGUgYE5nQ2hhbmdlc2Agb2JqZWN0IGNvbnRhaW5pbmcgaW5mb3JtYXRpb24gYWJvdXQgYWxsIGNoYW5nZXMuXG4gKiBAcGFyYW0ge0sgfCBLW119IGtleU9yS2V5cyAtIFRoZSBwcm9wZXJ0eSBuYW1lKHMpIHRvIGNoZWNrIGZvciBjaGFuZ2VzLlxuICogQHBhcmFtIHtib29sZWFufSBbaWdub3JlRmlyc3RDaGFuZ2U9dHJ1ZV0gLSBXaGV0aGVyIHRvIGlnbm9yZSBjaGFuZ2VzIHRoYXQgb2NjdXIgZHVyaW5nIHRoZSBmaXJzdCBjaGFuZ2UgZGV0ZWN0aW9uIGN5Y2xlLlxuICogQHJldHVybnMge2Jvb2xlYW59IGB0cnVlYCBpZiB0aGUgc3BlY2lmaWVkIHByb3BlcnR5IG9yIHByb3BlcnRpZXMgaGF2ZSBjaGFuZ2VkLCBvdGhlcndpc2UgYGZhbHNlYC5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIC8vIEV4YW1wbGUgdXNhZ2Ugd2l0aGluIGFuIEFuZ3VsYXIgY29tcG9uZW50J3MgYG5nT25DaGFuZ2VzYCBtZXRob2RcbiAqIG5nT25DaGFuZ2VzKGNoYW5nZXM6IE5nQ2hhbmdlczxNeUNvbXBvbmVudD4pOiB2b2lkIHtcbiAqICAgaWYgKGhhc0NoYW5nZWQoY2hhbmdlcywgJ25hbWUnKSkge1xuICogICAgIGNvbnNvbGUubG9nKCdOYW1lIGhhcyBjaGFuZ2VkJyk7XG4gKiAgIH1cbiAqIH1cbiAqXG4gKiAvLyBDaGVja2luZyBtdWx0aXBsZSBwcm9wZXJ0aWVzIGZvciBjaGFuZ2VzXG4gKiBuZ09uQ2hhbmdlcyhjaGFuZ2VzOiBOZ0NoYW5nZXM8TXlDb21wb25lbnQ+KTogdm9pZCB7XG4gKiAgIGlmIChoYXNDaGFuZ2VkKGNoYW5nZXMsIFsnbmFtZScsICdhZ2UnXSwgZmFsc2UpKSB7XG4gKiAgICAgY29uc29sZS5sb2coJ05hbWUgb3IgYWdlIGhhcyBjaGFuZ2VkIChpbmNsdWRpbmcgZmlyc3QgY2hhbmdlKScpO1xuICogICB9XG4gKiB9XG4gKiBgYGBcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGhhc0NoYW5nZWQ8VSBleHRlbmRzIFJlY29yZDxzdHJpbmcsIHVua25vd24+LCBUIGV4dGVuZHMgTmdDaGFuZ2VzPFU+LCBLIGV4dGVuZHMga2V5b2YgVD4oXG4gIGNoYW5nZXM6IFQsXG4gIGtleU9yS2V5czogSyB8IEtbXSxcbiAgaWdub3JlRmlyc3RDaGFuZ2UgPSB0cnVlLFxuKTogYm9vbGVhbiB7XG4gIGlmIChBcnJheS5pc0FycmF5KGtleU9yS2V5cykpIHtcbiAgICBmb3IgKGNvbnN0IGtleSBvZiBrZXlPcktleXMpIHtcbiAgICAgIGlmIChoYXNDaGFuZ2VkKGNoYW5nZXMsIGtleSwgaWdub3JlRmlyc3RDaGFuZ2UpKSB7XG4gICAgICAgIHJldHVybiB0cnVlO1xuICAgICAgfVxuICAgIH1cbiAgICByZXR1cm4gZmFsc2U7XG4gIH0gZWxzZSB7XG4gICAgcmV0dXJuIGtleU9yS2V5cyBpbiBjaGFuZ2VzICYmICghaWdub3JlRmlyc3RDaGFuZ2UgfHwgIWNoYW5nZXNba2V5T3JLZXlzXT8uaXNGaXJzdENoYW5nZSgpKTtcbiAgfVxufVxuIl19

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

@@ -1,5 +1,34 @@
 import { inject, InjectionToken } from '@angular/core';
 import { deepmerge } from '@odx/angular/internal';
+/**
+ * Provides a configuration object or a factory for creating the configuration object, optionally applying a transformation function.
+ * This utility simplifies the process of defining and injecting configuration objects throughout an Angular application.
+ *
+ * @template T - The type of the configuration object.
+ * @template D - The dependencies required by the configuration factory, if any.
+ * @param {InjectionToken<T> | string} token - The injection token or string token associated with the configuration.
+ * @param {ConfigProvider<T, D>} config - The configuration object or a factory provider that produces the configuration.
+ * @param {ConfigTransformFn<T>} [transform=() => ({}))] - An optional transformation function to apply to the configuration object.
+ * @returns {FactoryProvider | ValueProvider} - An Angular provider object for the given configuration.
+ *
+ * @example
+ * ```ts
+ * // Define a simple configuration object
+ * const appConfig = { apiEndpoint: 'https://api.example.com' };
+ *
+ * // Provide the configuration with an optional transformation function
+ * provideConfig(appConfigToken, appConfig, (config) => ({
+ *   ...config,
+ *   apiEndpoint: `${config.apiEndpoint}/v2`,
+ * }));
+ *
+ * // Using a factory provider for dynamic configuration
+ * provideConfig(appConfigToken, {
+ *   useFactory: (envService) => ({ apiEndpoint: envService.getApiEndpoint() }),
+ *   deps: [EnvironmentService],
+ * });
+ * ```
+ */
 export function provideConfig(token, config, transform = () => ({})) {
     const prepareConfig = (value) => deepmerge(value, transform(value));
     if ('useFactory' in config) {
@@ -20,6 +49,33 @@ function mergeConfig(token, defaultValue) {
     const parentConfig = inject(token, { skipSelf: true, optional: true }) ?? {};
     return deepmerge(defaultValue, parentConfig, config);
 }
+/**
+ * Generates a set of configuration-related tokens and utility functions for managing configuration in an Angular application.
+ * This function creates a standardized way to define, provide, and inject configurations, including defaults and transformations.
+ *
+ * @template T - The type of the configuration object.
+ * @template N - The name of the configuration, used to generate token names and utility functions.
+ * @param {N} name - The name of the configuration.
+ * @param {string} prefix - A prefix for the injection token to ensure uniqueness across the application.
+ * @param {T} defaultValue - The default value for the configuration.
+ * @param {ConfigTransformFn<T>} [transform] - An optional transformation function to be applied to the configuration.
+ * @returns An object containing the generated injection token, default configuration, and utility functions for the configuration.
+ *
+ * @example
+ * ```ts
+ * // Create configuration tokens and utilities for "appConfig" with a default value and optional transform function
+ * const { appConfigConfig, provideAppConfigConfig } = createConfigTokens('appConfig', 'myPrefix', { debug: false }, (config) => ({
+ *   ...config,
+ *   debug: true, // Enable debug mode by default
+ * }));
+ *
+ * // Later, in a module or component, provide the customized configuration
+ * @NgModule({
+ *   providers: [provideAppConfigConfig({ apiEndpoint: 'https://api.example.com' })]
+ * })
+ * class AppModule {}
+ * ```
+ */
 export function createConfigTokens(name, prefix, defaultValue, transform) {
     const configName = `${name}Config`;
     const defaultConfigName = `${name}DefaultConfig`;
@@ -34,4 +90,4 @@ export function createConfigTokens(name, prefix, defaultValue, transform) {
         [provideConfigName]: ((config) => provideConfig(token, config, transform)),
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# 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"]}

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

@@ -4,6 +4,13 @@ import { isNumber, isString } from './type-guards';
 function isQueueItemId(value) {
     return isString(value) || isNumber(value);
 }
+/**
+ * A class representing a queue structure with advanced functionalities including adding, removing,
+ * updating items, and observing changes through RxJS observables. It supports generic queue item types,
+ * allowing for flexible usage across different contexts.
+ *
+ * @template T - The type of items stored in the queue. Each item must extend an object containing a unique `id`.
+ */
 export class Queue {
     constructor() {
         this.queue = new Map();
@@ -11,29 +18,82 @@ export class Queue {
         this.values = [];
         this.firstItem = null;
         this.lastItem = null;
+        /**
+         * An observable that emits when an item is added to the queue.
+         * @type {Observable<T>}
+         */
         this.onAdd$ = this.createEventObserver('add');
+        /**
+         * An observable that emits when an item in the queue is updated.
+         * @type {Observable<T>}
+         */
         this.onUpdate$ = this.createEventObserver('update');
+        /**
+         * An observable that emits when an item is removed from the queue.
+         * @type {Observable<T>}
+         */
         this.onRemove$ = this.createEventObserver('remove');
+        /**
+         * An observable representing the current state of the queue as an array of items.
+         * @type {Observable<QueueItem<T>[]>}
+         */
         this.value$ = this.events$$.pipe(startWith(() => void 0), map(() => this.values), shareReplay({ bufferSize: 1, refCount: true }));
+        /**
+         * An observable that emits the current size of the queue.
+         * @type {Observable<number>}
+         */
         this.size$ = this.value$.pipe(map(() => this.size), distinctUntilChanged(), shareReplay({ bufferSize: 1, refCount: true }));
     }
+    /**
+     * Gets the size of the queue.
+     * @returns The number of elements in the queue.
+     */
     get size() {
         return this.queue.size;
     }
+    /**
+     * Checks if the specified item is the first item in the queue.
+     * @param {QueueItem<T>} item - The item to check.
+     * @returns {boolean} - Returns `true` if the item is the first item in the queue, `false` otherwise.
+     */
     isFirst({ id }) {
         return this.firstItem?.id === id;
     }
+    /**
+     * Checks if the specified item is the last item in the queue.
+     * @param {QueueItem<T>} item - The item to check.
+     * @returns {boolean} - Returns true if the item is the last item, otherwise returns false.
+     */
     isLast({ id }) {
         return this.lastItem?.id === id;
     }
+    /**
+     * Retrieves a queue item from the queue based on the provided item or item ID.
+     * @param itemOrId - The queue item or item ID to retrieve.
+     * @returns The queue item if found, or `null` if not found.
+     */
     get(itemOrId) {
         const id = isQueueItemId(itemOrId) ? itemOrId.toString() : itemOrId.id.toString();
         return this.queue.get(id) ?? null;
     }
+    /**
+     * Adds an item to the queue, optionally emitting an event.
+     *
+     * @param {QueueItem<T>} item - The item to add.
+     * @param {boolean} [emitEvent=true] - Whether to emit an event for this action.
+     * @returns {QueueItem<T>} The item added to the queue.
+     */
     add(item, emitEvent = true) {
         this.remove(item, false);
         return this.addMany([item], emitEvent)[0];
     }
+    /**
+     * Adds multiple items to the queue.
+     *
+     * @param items - An array of items to be added to the queue.
+     * @param emitEvent - (Optional) A boolean indicating whether to emit an event after adding the items. Default is true.
+     * @returns An array of added items.
+     */
     addMany(items, emitEvent = true) {
         const addedItems = [];
         const updatedItems = [];
@@ -54,9 +114,22 @@ export class Queue {
         }
         return items;
     }
+    /**
+     * Removes an item from the queue.
+     *
+     * @param itemOrId - The item or ID of the item to be removed.
+     * @param emitEvent - Whether to emit an event after removing the item. Default is `true`.
+     * @returns The removed item, or `null` if the item was not found.
+     */
     remove(itemOrId, emitEvent = true) {
         return this.removeMany([itemOrId], emitEvent)[0];
     }
+    /**
+     * Removes multiple items from the queue based on the provided item or item IDs.
+     * @param itemOrIds - An array of QueueItem or QueueItemId objects representing the items to be removed.
+     * @param emitEvent - A boolean indicating whether to emit an event after removing the items. Default is true.
+     * @returns An array of removed QueueItem objects or null values.
+     */
     removeMany(itemOrIds, emitEvent = true) {
         const items = itemOrIds.map((itemOrId) => this.get(itemOrId)).filter(Boolean);
         const removedItems = [];
@@ -69,11 +142,21 @@ export class Queue {
         this.notify({ type: 'remove', items: removedItems }, emitEvent);
         return items;
     }
+    /**
+     * Clears the queue by removing all items.
+     *
+     * @param emitEvent - Whether to emit an event after clearing the queue. Default is true.
+     */
     clear(emitEvent = true) {
         const items = this.toArray();
         this.queue.clear();
         this.notify({ type: 'remove', items }, emitEvent);
     }
+    /**
+     * Returns an array representation of the queue.
+     *
+     * @returns An array containing all the items in the queue.
+     */
     toArray() {
         return this.values;
     }
@@ -89,4 +172,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\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  public readonly onAdd$ = this.createEventObserver('add');\n  public readonly onUpdate$ = this.createEventObserver('update');\n  public readonly onRemove$ = this.createEventObserver('remove');\n  public readonly value$ = this.events$$.pipe(\n    startWith(() => void 0),\n    map(() => this.values),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n  public readonly size$ = this.value$.pipe(\n    map(() => this.size),\n    distinctUntilChanged(),\n    shareReplay({ bufferSize: 1, refCount: true }),\n  );\n\n  public get size(): number {\n    return this.queue.size;\n  }\n\n  public isFirst({ id }: QueueItem<T>): boolean {\n    return this.firstItem?.id === id;\n  }\n\n  public isLast({ id }: QueueItem<T>): boolean {\n    return this.lastItem?.id === id;\n  }\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  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  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  public remove(itemOrId: QueueItem<T> | QueueItemId, emitEvent = true): QueueItem<T> | null {\n    return this.removeMany([itemOrId], emitEvent)[0];\n  }\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  public clear(emitEvent = true): void {\n    const items = this.toArray();\n    this.queue.clear();\n    this.notify({ type: 'remove', items }, emitEvent);\n  }\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   * @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   * @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   * @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   * @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   * @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   * @returns 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   * @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   * @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   * @param itemOrId - The queue item or item ID to retrieve.\n   * @returns 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 items - An array of items to be added to the queue.\n   * @param emitEvent - (Optional) A boolean indicating whether to emit an event after adding the items. Default is true.\n   * @returns 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 itemOrId - The item or ID of the item to be removed.\n   * @param 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   * @param itemOrIds - An array of QueueItem or QueueItemId objects representing the items to be removed.\n   * @param emitEvent - A boolean indicating whether to emit an event after removing the items. Default is true.\n   * @returns 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 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 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/esm2022/utils/lib/helpers/type-guards.mjs

@@ -1,29 +1,86 @@
 import { TemplateRef } from '@angular/core';
+/**
+ * Checks if the given value is a `ViewContainerRef`.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is ViewContainerRef} `true` if the value is a `ViewContainerRef`, otherwise `false`.
+ */
 export function isViewContainer(value) {
     return isFunction(value?.createComponent);
 }
+/**
+ * Checks if the given value is a `TemplateRef`.
+ *
+ * @template T - The embedded view type.
+ * @param {unknown} value - The value to check.
+ * @returns {value is TemplateRef<T>} `true` if the value is a `TemplateRef`, otherwise `false`.
+ */
 export function isTemplateRef(value) {
     return value instanceof TemplateRef;
 }
+/**
+ * Checks if the given value is an Angular component class.
+ *
+ * @template T - The component class type.
+ * @param {unknown} value - The value to check.
+ * @returns {value is Type<T>} `true` if the value is a component class, otherwise `false`.
+ */
 export function isComponent(value) {
     return isFunction(value);
 }
+/**
+ * Checks if the given value is a string.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is string} `true` if the value is a string, otherwise `false`.
+ */
 export function isString(value) {
     return typeof value === 'string';
 }
+/**
+ * Checks if the given value is a non-empty string.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is string} `true` if the value is a non-empty string, otherwise `false`.
+ */
 export function isNonEmptyString(value) {
     return isString(value) && value.length > 0;
 }
+/**
+ * Checks if the given value is a boolean.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is boolean} `true` if the value is a boolean, otherwise `false`.
+ */
 export function isBoolean(value) {
     return value === true || value === false;
 }
+/**
+ * Checks if the given value is a function.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is CallableFunction} `true` if the value is a function, otherwise `false`.
+ */
 export function isFunction(value) {
     return typeof value === 'function';
 }
+/**
+ * Checks if the given value is present (not null or undefined).
+ *
+ * @template T - The value type.
+ * @param {T | null | undefined} value - The value to check.
+ * @returns {value is NonNullable<T>} `true` if the value is present, otherwise `false`.
+ */
 export function isPresent(value) {
     return value !== null && value !== undefined;
 }
+/**
+ * Checks if the given value is a number.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is number} `true` if the value is a number, otherwise `false`.
+ */
 export function isNumber(value) {
     return typeof value === 'number';
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/utils/lib/helpers/until-destroyed.mjs

@@ -1,7 +1,45 @@
 import { DestroyRef, inject } from '@angular/core';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+/**
+ * Creates a MonoTypeOperatorFunction that automatically unsubscribes from observables when the host component or service is destroyed.
+ * It uses Angular's `DestroyRef` to detect when the component or service is destroyed and triggers the unsubscription at that point.
+ * This utility function helps in managing subscriptions and prevents memory leaks by ensuring observables are unsubscribed when no longer needed.
+ *
+ * @returns A function that returns a `MonoTypeOperatorFunction<T>`, which can be used in an RxJS pipe to automatically unsubscribe
+ * based on the component's or service's lifecycle.
+ *
+ * @example
+ * ```ts
+ * // In an Angular component or service
+ * import { Component } from '@angular/core';
+ * import { Observable } from 'rxjs';
+ * import { untilDestroyed } from './path/to/untilDestroyed';
+ *
+ * @Component({
+ *   selector: 'app-example',
+ *   template: `<div>Example Component</div>`,
+ * })
+ * export class ExampleComponent {
+ *   private readonly takeUntilDestroyed = untilDestroyed();
+ *
+ *   constructor() {
+ *     const exampleObservable$ = new Observable(observer => {
+ *       // Observable logic here
+ *     });
+ *
+ *     exampleObservable$.pipe(
+ *       this.takeUntilDestroyed(),
+ *     ).subscribe(data => {
+ *       // Subscription logic here
+ *     });
+ *   }
+ *
+ *   // No need to manually implement ngOnDestroy to unsubscribe
+ * }
+ * ```
+ */
 export function untilDestroyed() {
     const destroyRef = inject(DestroyRef);
     return () => takeUntilDestroyed(destroyRef);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW50aWwtZGVzdHJveWVkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL3V0aWxzL3NyYy9saWIvaGVscGVycy91bnRpbC1kZXN0cm95ZWQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDbkQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFHaEUsTUFBTSxVQUFVLGNBQWM7SUFDNUIsTUFBTSxVQUFVLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQUFDO0lBRXRDLE9BQU8sR0FBRyxFQUFFLENBQUMsa0JBQWtCLENBQUMsVUFBVSxDQUFDLENBQUM7QUFDOUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERlc3Ryb3lSZWYsIGluamVjdCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgdGFrZVVudGlsRGVzdHJveWVkIH0gZnJvbSAnQGFuZ3VsYXIvY29yZS9yeGpzLWludGVyb3AnO1xuaW1wb3J0IHsgTW9ub1R5cGVPcGVyYXRvckZ1bmN0aW9uIH0gZnJvbSAncnhqcyc7XG5cbmV4cG9ydCBmdW5jdGlvbiB1bnRpbERlc3Ryb3llZCgpOiA8VD4oKSA9PiBNb25vVHlwZU9wZXJhdG9yRnVuY3Rpb248VD4ge1xuICBjb25zdCBkZXN0cm95UmVmID0gaW5qZWN0KERlc3Ryb3lSZWYpO1xuXG4gIHJldHVybiAoKSA9PiB0YWtlVW50aWxEZXN0cm95ZWQoZGVzdHJveVJlZik7XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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