@odx/angular 5.7.4 → 6.0.1

package/esm2022/cdk/dynamic-view/lib/helpers/is-dynamic-text-content.mjs

@@ -1,6 +1,28 @@
 import { isString } from '@odx/angular/utils';
 import { isObservable } from 'rxjs';
+/**
+ * Type guard function to check if a given value is considered dynamic text content.
+ * Dynamic text content can either be a plain string or an Observable. This function
+ * facilitates type-safe handling of dynamic text content by checking the type of the value.
+ *
+ * @param {unknown} value - The value to be checked.
+ * @returns {value is DynamicTextContent} Returns `true` if the value is a string or an Observable,
+ * indicating it can be used as dynamic text content; otherwise, returns `false`.
+ *
+ * @example
+ * ```ts
+ * // Example usage of the isDynamicTextContent function
+ * const textValue: unknown = getTextValue(); // This function may return either string or Observable
+ *
+ * if (isDynamicTextContent(textValue)) {
+ *   // The type of textValue is now narrowed to DynamicTextContent (string | Observable)
+ *   console.log('The value can be used as dynamic text content.');
+ * } else {
+ *   console.log('The value is not suitable as dynamic text content.');
+ * }
+ * ```
+ */
 export function isDynamicTextContent(value) {
     return isString(value) || isObservable(value);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtZHluYW1pYy10ZXh0LWNvbnRlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL2R5bmFtaWMtdmlldy9zcmMvbGliL2hlbHBlcnMvaXMtZHluYW1pYy10ZXh0LWNvbnRlbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQzlDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFHcEMsTUFBTSxVQUFVLG9CQUFvQixDQUFDLEtBQWM7SUFDakQsT0FBTyxRQUFRLENBQUMsS0FBSyxDQUFDLElBQUksWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDO0FBQ2hELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpc1N0cmluZyB9IGZyb20gJ0BvZHgvYW5ndWxhci91dGlscyc7XG5pbXBvcnQgeyBpc09ic2VydmFibGUgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IER5bmFtaWNUZXh0Q29udGVudCB9IGZyb20gJy4uL2ZhY2FkZSc7XG5cbmV4cG9ydCBmdW5jdGlvbiBpc0R5bmFtaWNUZXh0Q29udGVudCh2YWx1ZTogdW5rbm93bik6IHZhbHVlIGlzIER5bmFtaWNUZXh0Q29udGVudCB7XG4gIHJldHVybiBpc1N0cmluZyh2YWx1ZSkgfHwgaXNPYnNlcnZhYmxlKHZhbHVlKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/dynamic-view/lib/helpers/is-dynamic-view.mjs

@@ -1,5 +1,27 @@
 import { DynamicComponentRef, DynamicTemplateRef } from '../models';
+/**
+ * Type guard function to check if a given value is a reference to a dynamically created view.
+ * This helps in distinguishing between dynamic view references (`DynamicComponentRef` or `DynamicTemplateRef`)
+ * and other types of values, facilitating type-safe operations on dynamic views.
+ *
+ * @param {unknown} value - The value to check.
+ * @returns {value is DynamicViewRef<DynamicContent>} `true` if the value is an instance of `DynamicComponentRef`
+ * or `DynamicTemplateRef`, indicating it is a dynamic view reference; otherwise, `false`.
+ *
+ * @example
+ * ```ts
+ * // Given a value that could be a dynamic view reference or something else
+ * const value: unknown = getSomeValue();
+ *
+ * if (isDynamicView(value)) {
+ *   // TypeScript now knows `value` is a dynamic view reference, so you can access its methods safely
+ *   value.detectChanges();
+ * } else {
+ *   console.log('Value is not a dynamic view reference');
+ * }
+ * ```
+ */
 export function isDynamicView(value) {
     return value instanceof DynamicComponentRef || value instanceof DynamicTemplateRef;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXMtZHluYW1pYy12aWV3LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2Nkay9keW5hbWljLXZpZXcvc3JjL2xpYi9oZWxwZXJzL2lzLWR5bmFtaWMtdmlldy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFFcEUsTUFBTSxVQUFVLGFBQWEsQ0FBQyxLQUFjO0lBQzFDLE9BQU8sS0FBSyxZQUFZLG1CQUFtQixJQUFJLEtBQUssWUFBWSxrQkFBa0IsQ0FBQztBQUNyRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRHluYW1pY0NvbnRlbnQsIER5bmFtaWNWaWV3UmVmIH0gZnJvbSAnLi4vZmFjYWRlJztcbmltcG9ydCB7IER5bmFtaWNDb21wb25lbnRSZWYsIER5bmFtaWNUZW1wbGF0ZVJlZiB9IGZyb20gJy4uL21vZGVscyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBpc0R5bmFtaWNWaWV3KHZhbHVlOiB1bmtub3duKTogdmFsdWUgaXMgRHluYW1pY1ZpZXdSZWY8RHluYW1pY0NvbnRlbnQ+IHtcbiAgcmV0dXJuIHZhbHVlIGluc3RhbmNlb2YgRHluYW1pY0NvbXBvbmVudFJlZiB8fCB2YWx1ZSBpbnN0YW5jZW9mIER5bmFtaWNUZW1wbGF0ZVJlZjtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/dynamic-view/lib/models/dynamic-component-ref.mjs

@@ -1,6 +1,17 @@
 import { ApplicationRef, createComponent, EnvironmentInjector, reflectComponentType } from '@angular/core';
 import { deepmerge } from '@odx/angular/internal';
 import { isViewContainer } from '@odx/angular/utils';
+/**
+ * The DynamicComponentRef class is a powerful utility for dynamically creating and managing
+ * Angular components at runtime. It encapsulates the logic for component creation, input handling,
+ * and lifecycle management, making it easier to work with dynamic components in complex applications.
+ *
+ * A reference to a dynamically created component, providing methods to manage its lifecycle,
+ * detect changes, and update its inputs based on a context.
+ *
+ * @template T - The type of the component being managed.
+ * @template C - The type of the context used to update the component's inputs.
+ */
 export class DynamicComponentRef {
     constructor(options) {
         this.options = options;
@@ -31,9 +42,16 @@ export class DynamicComponentRef {
             this.update(context);
         }
     }
+    /**
+     * Triggers change detection for the dynamically created component, ensuring that any updates to inputs
+     * or internal state are reflected in the view.
+     */
     detectChanges() {
         this.componentRef?.changeDetectorRef.detectChanges();
     }
+    /**
+     * Destroys the dynamically created component, cleaning up resources and detaching it from the application view.
+     */
     destroy() {
         if (this.componentRef?.hostView.destroyed) {
             this.componentRef = null;
@@ -46,9 +64,20 @@ export class DynamicComponentRef {
         this.componentRef = null;
         this.componentInputs = null;
     }
+    /**
+     * Retrieves the native element associated with the dynamically created component's host view.
+     *
+     * @returns {Element} The native DOM element of the component.
+     */
     getElement() {
         return this.componentRef?.location.nativeElement ?? null;
     }
+    /**
+     * Updates the component's inputs based on the provided context. Merges the new context with the existing
+     * context and applies the combined context as inputs to the component.
+     *
+     * @param {C} context - The context containing new values for the component's inputs.
+     */
     update(context) {
         this.options.context = deepmerge({}, this.options.context, context);
         if (!this.componentRef)
@@ -59,11 +88,21 @@ export class DynamicComponentRef {
             }
         }
     }
+    /**
+     * Retrieves the current context used for the component's inputs.
+     *
+     * @returns {GetDynamicViewContext<T>} The current context object.
+     */
     getContext() {
         return this.options.context ?? {};
     }
+    /**
+     * Retrieves the view reference associated with the dynamically created component.
+     *
+     * @returns {ViewRef | null} The view reference, or null if the component has not been created or has been destroyed.
+     */
     getView() {
         return this.componentRef?.hostView ?? null;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-component-ref.js","sourceRoot":"","sources":["../../../../../../../../libs/angular/cdk/dynamic-view/src/lib/models/dynamic-component-ref.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAgB,eAAe,EAAE,mBAAmB,EAAE,oBAAoB,EAAiB,MAAM,eAAe,CAAC;AACxI,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AASrD;;;;;;;;;;GAUG;AACH,MAAM,OAAO,mBAAmB;IAK9B,YAA6B,OAAmC;QAAnC,YAAO,GAAP,OAAO,CAA4B;QAJ/C,gBAAW,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;QACjE,iBAAY,GAA2B,IAAI,CAAC;QAC5C,oBAAe,GAAgC,IAAI,CAAC;QAG1D,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC;QAEzE,IAAI,CAAC,YAAY,GAAG,eAAe,CAAC,SAAoB,EAAE;YACxD,mBAAmB,EAAE,QAAQ,CAAC,GAAG,CAAC,mBAAmB,CAAC;YACtD,eAAe,EAAE,QAAQ;YACzB,gBAAgB;SACjB,CAAC,CAAC;QACH,IAAI,CAAC,eAAe;YAClB,oBAAoB,CAAC,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,CAClE,CAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE;gBACpB,GAAG,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC;gBACrB,OAAO,GAAG,CAAC;YACb,CAAC,EACD,EAA0B,CAC3B,IAAI,IAAI,CAAC;QAEZ,IAAI,eAAe,CAAC,IAAI,CAAC,EAAE;YACzB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;SACzC;aAAM;YACL,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;YACxD,IAAI,IAAI,EAAE;gBACR,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;aACrC;SACF;QACD,IAAI,OAAO,EAAE;YACX,IAAI,CAAC,MAAM,CAAC,OAAY,CAAC,CAAC;SAC3B;IACH,CAAC;IAED;;;OAGG;IACI,aAAa;QAClB,IAAI,CAAC,YAAY,EAAE,iBAAiB,CAAC,aAAa,EAAE,CAAC;IACvD,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,IAAI,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,SAAS,EAAE;YACzC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;YACzB,OAAO;SACR;QACD,IAAI,IAAI,CAAC,YAAY,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YAC5D,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;SACzD;QACD,IAAI,CAAC,YAAY,EAAE,OAAO,EAAE,CAAC;QAC7B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;IAC9B,CAAC;IAED;;;;OAIG;IACI,UAAU;QACf,OAAO,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,aAAa,IAAI,IAAI,CAAC;IAC3D,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,OAAU;QACtB,IAAI,CAAC,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,CAAM,CAAC;QACzE,IAAI,CAAC,IAAI,CAAC,YAAY;YAAE,OAAO;QAC/B,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE;YACtC,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC,GAAG,CAAC,EAAE;gBAC/B,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;aAC5D;SACF;IACH,CAAC;IAED;;;;OAIG;IACI,UAAU;QACf,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;IACpC,CAAC;IAED;;;;OAIG;IACI,OAAO;QACZ,OAAO,IAAI,CAAC,YAAY,EAAE,QAAQ,IAAI,IAAI,CAAC;IAC7C,CAAC;CACF","sourcesContent":["import { ApplicationRef, ComponentRef, createComponent, EnvironmentInjector, reflectComponentType, Type, ViewRef } from '@angular/core';\nimport { deepmerge } from '@odx/angular/internal';\nimport { isViewContainer } from '@odx/angular/utils';\nimport { GetDynamicViewContext } from '../facade';\nimport { DynamicViewRef } from '../facade/dynamic-view-ref';\nimport { DynamicViewOptions } from './dynamic-view-options';\n\nexport interface DynamicComponentOptions<T extends Type<unknown>> extends DynamicViewOptions<T> {\n  component: T;\n}\n\n/**\n * The DynamicComponentRef class is a powerful utility for dynamically creating and managing\n * Angular components at runtime. It encapsulates the logic for component creation, input handling,\n * and lifecycle management, making it easier to work with dynamic components in complex applications.\n *\n * A reference to a dynamically created component, providing methods to manage its lifecycle,\n * detect changes, and update its inputs based on a context.\n *\n * @template T - The type of the component being managed.\n * @template C - The type of the context used to update the component's inputs.\n */\nexport class DynamicComponentRef<T extends Type<unknown>, C extends GetDynamicViewContext<T>> implements DynamicViewRef<T> {\n  private readonly application = this.options.injector.get(ApplicationRef);\n  private componentRef: ComponentRef<T> | null = null;\n  private componentInputs: Record<string, true> | null = null;\n\n  constructor(private readonly options: DynamicComponentOptions<T>) {\n    const { component, context, injector, projectableNodes, host } = options;\n\n    this.componentRef = createComponent(component as Type<T>, {\n      environmentInjector: injector.get(EnvironmentInjector),\n      elementInjector: injector,\n      projectableNodes,\n    });\n    this.componentInputs =\n      reflectComponentType(this.componentRef.componentType)?.inputs.reduce(\n        (acc, { propName }) => {\n          acc[propName] = true;\n          return acc;\n        },\n        {} as Record<string, true>,\n      ) ?? null;\n\n    if (isViewContainer(host)) {\n      host.insert(this.componentRef.hostView);\n    } else {\n      this.application.attachView(this.componentRef.hostView);\n      if (host) {\n        host.appendChild(this.getElement());\n      }\n    }\n    if (context) {\n      this.update(context as C);\n    }\n  }\n\n  /**\n   * Triggers change detection for the dynamically created component, ensuring that any updates to inputs\n   * or internal state are reflected in the view.\n   */\n  public detectChanges(): void {\n    this.componentRef?.changeDetectorRef.detectChanges();\n  }\n\n  /**\n   * Destroys the dynamically created component, cleaning up resources and detaching it from the application view.\n   */\n  public destroy(): void {\n    if (this.componentRef?.hostView.destroyed) {\n      this.componentRef = null;\n      return;\n    }\n    if (this.componentRef && !isViewContainer(this.options.host)) {\n      this.application.detachView(this.componentRef.hostView);\n    }\n    this.componentRef?.destroy();\n    this.componentRef = null;\n    this.componentInputs = null;\n  }\n\n  /**\n   * Retrieves the native element associated with the dynamically created component's host view.\n   *\n   * @returns {Element} The native DOM element of the component.\n   */\n  public getElement(): Element {\n    return this.componentRef?.location.nativeElement ?? null;\n  }\n\n  /**\n   * Updates the component's inputs based on the provided context. Merges the new context with the existing\n   * context and applies the combined context as inputs to the component.\n   *\n   * @param {C} context - The context containing new values for the component's inputs.\n   */\n  public update(context: C): void {\n    this.options.context = deepmerge({}, this.options.context, context) as C;\n    if (!this.componentRef) return;\n    for (const key in this.options.context) {\n      if (this.componentInputs?.[key]) {\n        this.componentRef.setInput(key, this.options.context[key]);\n      }\n    }\n  }\n\n  /**\n   * Retrieves the current context used for the component's inputs.\n   *\n   * @returns {GetDynamicViewContext<T>} The current context object.\n   */\n  public getContext(): GetDynamicViewContext<T> {\n    return this.options.context ?? {};\n  }\n\n  /**\n   * Retrieves the view reference associated with the dynamically created component.\n   *\n   * @returns {ViewRef | null} The view reference, or null if the component has not been created or has been destroyed.\n   */\n  public getView(): ViewRef | null {\n    return this.componentRef?.hostView ?? null;\n  }\n}\n"]}

package/esm2022/cdk/dynamic-view/lib/models/dynamic-template-ref.mjs

@@ -1,6 +1,13 @@
 import { ApplicationRef } from '@angular/core';
 import { deepmerge } from '@odx/angular/internal';
 import { isViewContainer } from '@odx/angular/utils';
+/**
+ * A reference to a dynamically created template, offering methods to manage its lifecycle,
+ * detect changes, and update its context. It encapsulates the logic for creating and manipulating
+ * an `EmbeddedViewRef` from a given `TemplateRef`.
+ *
+ * @template T - The type of the `NgTemplateRef` being managed.
+ */
 export class DynamicTemplateRef {
     constructor(options) {
         this.options = options;
@@ -8,9 +15,17 @@ export class DynamicTemplateRef {
         this.embeddedViewRef = null;
         this.create(options);
     }
+    /**
+     * Triggers change detection on the embedded view created from the template, ensuring that any updates
+     * to the context or internal state are reflected in the view.
+     */
     detectChanges() {
         this.embeddedViewRef?.detectChanges();
     }
+    /**
+     * Destroys the embedded view associated with the template, cleaning up resources and detaching it from the
+     * application view if necessary.
+     */
     destroy() {
         if (this.embeddedViewRef?.destroyed) {
             this.embeddedViewRef = null;
@@ -22,9 +37,20 @@ export class DynamicTemplateRef {
         this.embeddedViewRef?.destroy();
         this.embeddedViewRef = null;
     }
+    /**
+     * Retrieves the native element associated with the template's embedded view's root node.
+     *
+     * @returns {Element} The native DOM element of the embedded view's root node, if available.
+     */
     getElement() {
         return this.embeddedViewRef?.rootNodes?.[0] ?? null;
     }
+    /**
+     * Updates the context of the embedded view based on the provided context object. Merges the new context
+     * with the existing one and applies the combined context to the embedded view.
+     *
+     * @param {GetDynamicViewContext<T>} context - The context containing new values for the template's view.
+     */
     update(context) {
         this.options.context = deepmerge({}, this.options.context, context);
         if (this.embeddedViewRef) {
@@ -32,9 +58,19 @@ export class DynamicTemplateRef {
             this.detectChanges();
         }
     }
+    /**
+     * Retrieves the current context used for the template's view.
+     *
+     * @returns {GetDynamicViewContext<T>} The current context object.
+     */
     getContext() {
         return this.options.context ?? {};
     }
+    /**
+     * Retrieves the view reference (`ViewRef`) associated with the dynamically created template's embedded view.
+     *
+     * @returns {ViewRef | null} The view reference, or null if the template has not been instantiated or has been destroyed.
+     */
     getView() {
         return this.embeddedViewRef;
     }
@@ -48,4 +84,4 @@ export class DynamicTemplateRef {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/event-plugins/lib/event-plugins.config.mjs

@@ -7,7 +7,42 @@ export const EVENT_PLUGINS = PLUGINS.map((useClass) => ({
     useClass,
     multi: true,
 }));
+/**
+ * Provides a set of custom event plugins to Angular's event handling system. This function
+ * registers custom event plugins like `DebounceEventPlugin` and `DeferEventPlugin`, enhancing
+ * the capabilities of Angular's native event management. By using `EVENT_MANAGER_PLUGINS`, these
+ * plugins are integrated into Angular's event system and can be utilized in templates and components
+ * to handle events with custom behaviors such as debouncing or deferring event execution.
+ *
+ * @example
+ * Registering the event plugins in an Angular module:
+ * ```ts
+ * @NgModule({
+ *   imports: [
+ *     BrowserModule,
+ *     BrowserAnimationsModule,
+ *     // other imports...
+ *   ],
+ *   declarations: [AppComponent],
+ *   providers: [
+ *     provideEventPlugins(),
+ *   ],
+ *   bootstrap: [AppComponent],
+ * })
+ * export class AppModule {}
+ * ```
+ * Assuming `DebounceEventPlugin` modifies event names with a `.debounce` modifier:
+ * ```html
+ * <button (click.debounce)="handleDebouncedClick($event)">Click Me</button>
+ *  ```
+ * Assuming `DeferEventPlugin` modifies event names with a `.defer` modifier:
+ * ```html
+ * <div (mouseenter.defer)="handleDeferredMouseEnter($event)"></div>
+ * ```
+ *
+ * @returns {EnvironmentProviders} - A configuration object for Angular's DI system, to be used with `makeEnvironmentProviders`.
+ */
 export function provideEventPlugins() {
     return makeEnvironmentProviders(EVENT_PLUGINS);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtcGx1Z2lucy5jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXIvY2RrL2V2ZW50LXBsdWdpbnMvc3JjL2xpYi9ldmVudC1wbHVnaW5zLmNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsd0JBQXdCLEVBQWtDLE1BQU0sZUFBZSxDQUFDO0FBQ3pGLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUVsRSxNQUFNLE9BQU8sR0FBRyxDQUFDLG1CQUFtQixFQUFFLGdCQUFnQixDQUFDLENBQUM7QUFFeEQsTUFBTSxDQUFDLE1BQU0sYUFBYSxHQUFlLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDbEUsT0FBTyxFQUFFLHFCQUFxQjtJQUM5QixRQUFRO0lBQ1IsS0FBSyxFQUFFLElBQUk7Q0FDWixDQUFDLENBQUMsQ0FBQztBQUVKLE1BQU0sVUFBVSxtQkFBbUI7SUFDakMsT0FBTyx3QkFBd0IsQ0FBQyxhQUFhLENBQUMsQ0FBQztBQUNqRCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbWFrZUVudmlyb25tZW50UHJvdmlkZXJzLCBFbnZpcm9ubWVudFByb3ZpZGVycywgUHJvdmlkZXIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEVWRU5UX01BTkFHRVJfUExVR0lOUyB9IGZyb20gJ0Bhbmd1bGFyL3BsYXRmb3JtLWJyb3dzZXInO1xuaW1wb3J0IHsgRGVib3VuY2VFdmVudFBsdWdpbiwgRGVmZXJFdmVudFBsdWdpbiB9IGZyb20gJy4vcGx1Z2lucyc7XG5cbmNvbnN0IFBMVUdJTlMgPSBbRGVib3VuY2VFdmVudFBsdWdpbiwgRGVmZXJFdmVudFBsdWdpbl07XG5cbmV4cG9ydCBjb25zdCBFVkVOVF9QTFVHSU5TOiBQcm92aWRlcltdID0gUExVR0lOUy5tYXAoKHVzZUNsYXNzKSA9PiAoe1xuICBwcm92aWRlOiBFVkVOVF9NQU5BR0VSX1BMVUdJTlMsXG4gIHVzZUNsYXNzLFxuICBtdWx0aTogdHJ1ZSxcbn0pKTtcblxuZXhwb3J0IGZ1bmN0aW9uIHByb3ZpZGVFdmVudFBsdWdpbnMoKTogRW52aXJvbm1lbnRQcm92aWRlcnMge1xuICByZXR1cm4gbWFrZUVudmlyb25tZW50UHJvdmlkZXJzKEVWRU5UX1BMVUdJTlMpO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/event-plugins/lib/models/event-plugin.mjs

@@ -1,16 +1,60 @@
 import { isFunction } from '@odx/angular/utils';
+/**
+ * An abstract class for implementing custom event plugins in Angular. This class provides
+ * the core functionality required to create a custom event listener with specific behavior,
+ * allowing developers to extend Angular's native event handling capabilities.
+ *
+ * @example
+ * Extending EventPlugin to create a custom event plugin:
+ * ```ts
+ * @Injectable()
+ * class CustomEventPlugin extends EventPlugin {
+ *   public readonly modifier = /custom/;
+ *
+ *   public addEventListener(element: HTMLElement, eventName: string, handler: EventListener): Function {
+ *     // Custom logic for adding an event listener
+ *   }
+ * }
+ * ```
+ *
+ * ```html
+ * <div (click.custom)="handleClick($event)"></div>
+ * ```
+ */
 export class EventPlugin {
+    /**
+     * Adds a global event listener.
+     *
+     * @returns {Function} - A function that does nothing.
+     */
     addGlobalEventListener() {
         return () => void 0;
     }
+    /**
+     * Checks if the event plugin supports the given event name.
+     *
+     * @param {string} eventName - The name of the event.
+     * @returns {boolean} - `true` if the event plugin supports the event, `false` otherwise.
+     */
     supports(eventName) {
         return this.modifier.test(eventName);
     }
+    /**
+     * Gets the NgZone instance from the event manager.
+     *
+     * @returns {NgZone} - The NgZone instance.
+     */
     getZone() {
         return this.manager.getZone();
     }
+    /**
+     * Tears down the event listener.
+     *
+     * @param {Function | null} listener - The event listener function.
+     * @returns {Function} - A function that can be called to clean up the listener.
+     */
     teardown(listener) {
         return () => (isFunction(listener) ? listener() : void 0);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/event-plugins/lib/plugins/debounce-event-plugin.mjs

@@ -5,6 +5,38 @@ import { debounce } from '@odx/angular/utils';
 import { EventPlugin } from '../models';
 import * as i0 from "@angular/core";
 const DEFAULT_DELAY = 250;
+/**
+ * A service that extends `EventPlugin` for debouncing events. This service wraps event listeners
+ * and ensures that they are triggered no more than once per specified delay period. It is
+ * particularly useful for handling events that fire frequently, such as mouse movements
+ * or keystrokes, in a performant manner.
+ *
+ * The delay period can be specified directly in the event name using the syntax
+ * `(eventName.debounce.delay)`, where `delay` is the debounce duration in milliseconds.
+ * If no delay is specified, a default delay of 250 milliseconds is used.
+ *
+ * @example
+ * Provide the `DebounceEventPlugin` in an Angular module:
+ * ```ts
+ * @NgModule({
+ *  providers: [
+ *   ...
+ *   provideEventPlugins(),
+ *   ...
+ *  ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * In a component template, apply the debounce modifier to an event, specifying a custom delay:
+ * ```html
+ * <button (click.debounce.400)="handleClick($event)"></button>
+ * ```
+ * In a component template, apply the debounce modifier with the default delay:
+ * ```html
+ * <input (keyup.debounce)="onKeyUp($event)" placeholder="Type here...">
+ * ```
+ */
 export class DebounceEventPlugin extends EventPlugin {
     constructor() {
         super(...arguments);
@@ -32,4 +64,4 @@ export class DebounceEventPlugin extends EventPlugin {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DebounceEventPlugin, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/event-plugins/lib/plugins/defer-event-plugin.mjs

@@ -3,6 +3,30 @@
 import { Injectable } from '@angular/core';
 import { EventPlugin } from '../models';
 import * as i0 from "@angular/core";
+/**
+ * A service that extends `EventPlugin` to allow event handlers to be deferred until the end of the current call stack.
+ * This can improve performance by avoiding triggering Angular's change detection unnecessarily.
+ *
+ * @example
+ * Provide the `DeferEventPlugin` in an Angular module:
+ * ```ts
+ * @NgModule({
+ *  providers: [
+ *   ...
+ *   provideEventPlugins(),
+ *   ...
+ *  ],
+ * })
+ * export class AppModule {}
+ * ```
+ *
+ * In your Angular component:
+ * ```html
+ * <button (click.defer)="handleClick($event)"></button>
+ * ```
+ *
+ * The `.defer` modifier in the event name `click.defer` indicates that the event handler should be deferred.
+ */
 export class DeferEventPlugin extends EventPlugin {
     constructor() {
         super(...arguments);
@@ -24,4 +48,4 @@ export class DeferEventPlugin extends EventPlugin {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DeferEventPlugin, decorators: [{
             type: Injectable
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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