@odx/angular 5.7.4 → 6.0.1

package/esm2022/cdk/connected-overlay/lib/models/connected-overlay-ref.mjs

@@ -1,15 +1,64 @@
 import { EMPTY } from 'rxjs';
+/**
+ * A reference to a connected overlay created by the `ConnectedOverlayService`. This class provides methods to interact
+ * with the overlay, such as updating its options or closing it. It encapsulates the `DynamicViewRef` for the overlay's instance,
+ * allowing for direct manipulation of the overlay's state and behavior.
+ *
+ * This example demonstrates how to use a `ConnectedOverlayRef` to update and close a connected overlay in response
+ * to user interactions.
+ *
+ * @example
+ * ```ts
+ * class MyComponent {
+ *   private overlayRef?: ConnectedOverlayRef;
+ *
+ *   constructor(private overlayService: ConnectedOverlayService) {}
+ *
+ *   openOverlay() {
+ *     this.overlayRef = this.overlayService.createOverlay(this.someElementRef.nativeElement, { position: 'bottom' });
+ *   }
+ *
+ *   updateOverlayPosition() {
+ *     if (this.overlayRef) {
+ *       this.overlayRef.update({ position: 'top' });
+ *     }
+ *   }
+ *
+ *   closeOverlay() {
+ *     this.overlayRef?.close();
+ *   }
+ * }
+ * ```
+ *
+ * In this example, `MyComponent` uses the `ConnectedOverlayService` to create an overlay. It stores a reference to
+ * the created overlay in `overlayRef`, allowing it to update the overlay's position or close it when necessary.
+ */
 export class ConnectedOverlayRef {
     constructor(dynamicViewRef) {
         this.dynamicViewRef = dynamicViewRef;
         this.element = this.dynamicViewRef.getElement();
+        /**
+         * An Observable that emits when the overlay is closed.
+         *
+         * @emits {void} - Emits when the overlay is closed.
+         */
         this.onClose$ = this.dynamicViewRef.getContext().closed ?? EMPTY;
     }
+    /**
+     * Updates the connected overlay with new options.
+     *
+     * @param options - The new options to be applied to the connected overlay.
+     */
     update(options) {
         this.dynamicViewRef.update({ options: options });
     }
+    /**
+     * Closes the connected overlay.
+     *
+     * @returns {void}
+     */
     close() {
         this.dynamicViewRef.destroy();
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdGVkLW92ZXJsYXktcmVmLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2Nkay9jb25uZWN0ZWQtb3ZlcmxheS9zcmMvbGliL21vZGVscy9jb25uZWN0ZWQtb3ZlcmxheS1yZWYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLEtBQUssRUFBYyxNQUFNLE1BQU0sQ0FBQztBQUl6QyxNQUFNLE9BQU8sbUJBQW1CO0lBSTlCLFlBQTZCLGNBQWdFO1FBQWhFLG1CQUFjLEdBQWQsY0FBYyxDQUFrRDtRQUg3RSxZQUFPLEdBQUcsSUFBSSxDQUFDLGNBQWMsQ0FBQyxVQUFVLEVBQUUsQ0FBQztRQUMzQyxhQUFRLEdBQXFCLElBQUksQ0FBQyxjQUFjLENBQUMsVUFBVSxFQUFFLENBQUMsTUFBTSxJQUFJLEtBQUssQ0FBQztJQUVFLENBQUM7SUFFMUYsTUFBTSxDQUFDLE9BQXlDO1FBQ3JELElBQUksQ0FBQyxjQUFjLENBQUMsTUFBTSxDQUFDLEVBQUUsT0FBTyxFQUFFLE9BQWtDLEVBQUUsQ0FBQyxDQUFDO0lBQzlFLENBQUM7SUFFTSxLQUFLO1FBQ1YsSUFBSSxDQUFDLGNBQWMsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUNoQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEeW5hbWljVmlld1JlZiB9IGZyb20gJ0BvZHgvYW5ndWxhci9jZGsvZHluYW1pYy12aWV3JztcbmltcG9ydCB7IEVNUFRZLCBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBDb25uZWN0ZWRPdmVybGF5Q29tcG9uZW50IH0gZnJvbSAnLi4vY29ubmVjdGVkLW92ZXJsYXkuY29tcG9uZW50JztcbmltcG9ydCB7IENvbm5lY3RlZE92ZXJsYXlPcHRpb25zIH0gZnJvbSAnLi9jb25uZWN0ZWQtb3ZlcmxheS1vcHRpb25zJztcblxuZXhwb3J0IGNsYXNzIENvbm5lY3RlZE92ZXJsYXlSZWYge1xuICBwdWJsaWMgcmVhZG9ubHkgZWxlbWVudCA9IHRoaXMuZHluYW1pY1ZpZXdSZWYuZ2V0RWxlbWVudCgpO1xuICBwdWJsaWMgcmVhZG9ubHkgb25DbG9zZSQ6IE9ic2VydmFibGU8dm9pZD4gPSB0aGlzLmR5bmFtaWNWaWV3UmVmLmdldENvbnRleHQoKS5jbG9zZWQgPz8gRU1QVFk7XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBkeW5hbWljVmlld1JlZjogRHluYW1pY1ZpZXdSZWY8dHlwZW9mIENvbm5lY3RlZE92ZXJsYXlDb21wb25lbnQ+KSB7fVxuXG4gIHB1YmxpYyB1cGRhdGUob3B0aW9uczogUGFydGlhbDxDb25uZWN0ZWRPdmVybGF5T3B0aW9ucz4pIHtcbiAgICB0aGlzLmR5bmFtaWNWaWV3UmVmLnVwZGF0ZSh7IG9wdGlvbnM6IG9wdGlvbnMgYXMgQ29ubmVjdGVkT3ZlcmxheU9wdGlvbnMgfSk7XG4gIH1cblxuICBwdWJsaWMgY2xvc2UoKTogdm9pZCB7XG4gICAgdGhpcy5keW5hbWljVmlld1JlZi5kZXN0cm95KCk7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/custom-form-control/lib/custom-form-control.mjs

@@ -5,26 +5,93 @@ import { Controller, DisabledController, ReadonlyController } from '@odx/angular
 import { arrayAttribute, Pure } from '@odx/angular/utils';
 import { ControlDirective } from './control.directive';
 import * as i0 from "@angular/core";
+/**
+ * An abstract directive that serves as a base for custom form controls, integrating seamlessly with Angular Forms.
+ * It incorporates common form control behaviors such as handling disabled and readonly states, validation, and more.
+ *
+ * This approach allows the creation of highly reusable and consistent form controls within Angular applications,
+ * simplifying the integration with Angular Forms and the handling of common form behaviors.
+ *
+ * Extends Controller to provide a consistent API for managing state changes and subscriptions.
+ *
+ * @see {Controller}
+ */
 export class CustomFormControl extends Controller {
     static { this.CURRENT_INDEX = 0; }
+    /**
+     * The current value of the form control. Setting this value updates the internal state and marks the control
+     * for checking changes. Getting this value returns the current internal value of the control.
+     *
+     * @example
+     * ```ts
+     * this.customInputControl.value = 'newValue'; // Sets the value
+     * const currentValue = this.customInputControl.value; // Gets the current value
+     * ```
+     */
     set value(value) {
         if (this.internalValue !== value) {
             this.internalValue = value;
             this.triggerControllerChange();
         }
     }
+    /**
+     * Gets the value of the custom form control.
+     *
+     * @returns {T} - The value of the custom form control.
+     */
     get value() {
         return this.internalValue;
     }
+    /**
+     * Indicates whether the form control currently has an error. This takes into account any ignored errors.
+     *
+     * @returns {boolean} - True if the form control has an error, false otherwise.
+     *
+     * @example
+     * ```ts
+     * if (this.customInputControl.hasError) { ... }
+     * ```
+     */
     get hasError() {
         return !!this.ngControl?.touched && !!this.ngControl?.invalid && this.hasNonIgnoredError(this.ngControl.errors);
     }
+    /**
+     * Indicates whether the form control is currently disabled.
+     *
+     * @returns {boolean} - True if the form control is disabled, false otherwise.
+     *
+     * @example
+     * ```ts
+     * if (this.customInputControl.isDisabled) { ... }
+     * ```
+     */
     get isDisabled() {
         return !!this.disabledController?.disabled;
     }
+    /**
+     * Indicates whether the form control is currently in a readonly state.
+     *
+     * @returns {boolean} - True if the form control is readonly, false otherwise.
+     *
+     * @example
+     * ```ts
+     * if (this.customInputControl.isReadonly) { ... }
+     * ```
+     */
     get isReadonly() {
         return !!this.readonlyController?.readonly;
     }
+    /**
+     * Indicates whether the form control is marked as required, either through Validators.required, Validators.requiredTrue,
+     * or by a required attribute on a parent form field.
+     *
+     * @returns {boolean} - True if the form control is required, false otherwise.
+     *
+     * @example
+     * ````ts
+     * if (this.customInputControl.isRequired) { ... }
+     * ````
+     */
     get isRequired() {
         return !!this.requiredValidator?.required || this.hasValidator(Validators.required) || this.hasValidator(Validators.requiredTrue);
     }
@@ -34,37 +101,76 @@ export class CustomFormControl extends Controller {
         this.disabledController = DisabledController.inject();
         this.readonlyController = ReadonlyController.inject();
         this.ngControl = inject(NgControl, { self: true, optional: true });
+        /**
+         * A unique identifier for the custom form control. If not provided, a unique ID is generated automatically.
+         * This can be useful for associating form control with a label.
+         *
+         * @type {string}
+         */
         this.id = null;
+        /**
+         * The name attribute for the custom form control. Defaults to a unique name if not provided.
+         * This is useful when the form control is part of a form and needs to be identified.
+         *
+         * @type {string}
+         */
         this.name = `odx-form-control-${CustomFormControl.CURRENT_INDEX++}`;
+        /**
+         * The tabindex attribute for the custom form control. Can be used to control the order of focus navigation.
+         *
+         * @type {string | null}
+         */
         this.tabindex = null;
+        /**
+         * An array of error codes to ignore. If an error code is included in this array, the form control will not
+         * consider it as an error state. Useful for ignoring specific validation errors.
+         *
+         * @type {string[]}
+         */
         this.ignoreErrors = [];
+        /**
+         * A reference to the `ControlDirective` if it exists within the same host. This allows for direct interaction
+         * with the underlying form control directive.
+         *
+         * @type {ControlDirective | null}
+         *
+         * @example
+         * ```ts
+         * this.customInputControl.control?.focus();
+         * ```
+         */
         this.control = null;
         this.internalValue = initialValue;
         if (this.ngControl) {
             this.ngControl.valueAccessor = this;
         }
     }
+    /** @internal */
     onTouched() {
         // implemented by control value accessor
     }
+    /** @internal */
     onChange(_value) {
         // implemented by control value accessor
     }
+    /** @internal */
     registerOnChange(fn) {
         this.onChange = fn;
     }
+    /** @internal */
     registerOnTouched(fn) {
         this.onTouched = fn;
     }
+    /** @internal */
     setDisabledState(isDisabled) {
         this.disabledController?.setDisabledState(isDisabled);
     }
+    /** @internal */
     writeValue(value) {
-        if (this.isDisabled)
-            return;
         this.value = value;
         this.onChange(value);
     }
+    /** @internal */
     updateValue(value) {
         if (this.isDisabled)
             return;
@@ -111,4 +217,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: ViewChild,
                 args: [ControlDirective]
             }], hasNonIgnoredError: [] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-form-control.js","sourceRoot":"","sources":["../../../../../../../libs/angular/cdk/custom-form-control/src/lib/custom-form-control.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, inject, Input, ViewChild } from '@angular/core';\nimport { ControlValueAccessor, NgControl, RequiredValidator, ValidationErrors, ValidatorFn, Validators } from '@angular/forms';\nimport { Controller, DisabledController, ReadonlyController } from '@odx/angular';\nimport { arrayAttribute, Pure } from '@odx/angular/utils';\nimport { ControlDirective } from './control.directive';\n\n@Directive({\n  host: {\n    '[class.has-error]': 'hasError',\n    '[class.is-disabled]': 'isDisabled',\n    '[class.is-readonly]': 'isReadonly',\n    '[class.is-required]': 'required',\n  },\n})\nexport abstract class CustomFormControl<T> extends Controller implements ControlValueAccessor {\n  private static CURRENT_INDEX = 0;\n\n  private readonly requiredValidator = inject(RequiredValidator, { optional: true, self: true });\n  private internalValue: T;\n  protected readonly disabledController = DisabledController.inject();\n  protected readonly readonlyController = ReadonlyController.inject();\n  protected readonly ngControl = inject(NgControl, { self: true, optional: true });\n\n  @Input()\n  public id: string | null = null;\n\n  @Input()\n  public name = `odx-form-control-${CustomFormControl.CURRENT_INDEX++}`;\n\n  @Input()\n  public tabindex: string | null = null;\n\n  @Input({ transform: arrayAttribute })\n  public ignoreErrors: string[] = [];\n\n  public set value(value: T) {\n    if (this.internalValue !== value) {\n      this.internalValue = value;\n      this.triggerControllerChange();\n    }\n  }\n  public get value(): T {\n    return this.internalValue;\n  }\n\n  public get hasError(): boolean {\n    return !!this.ngControl?.touched && !!this.ngControl?.invalid && this.hasNonIgnoredError(this.ngControl.errors);\n  }\n\n  public get isDisabled(): boolean {\n    return !!this.disabledController?.disabled;\n  }\n\n  public get isReadonly(): boolean {\n    return !!this.readonlyController?.readonly;\n  }\n\n  public get isRequired(): boolean {\n    return !!this.requiredValidator?.required || this.hasValidator(Validators.required) || this.hasValidator(Validators.requiredTrue);\n  }\n\n  @ViewChild(ControlDirective)\n  public readonly control: ControlDirective | null = null;\n\n  constructor(initialValue: T) {\n    super();\n    this.internalValue = initialValue;\n    if (this.ngControl) {\n      this.ngControl.valueAccessor = this;\n    }\n  }\n\n  public onTouched() {\n    // implemented by control value accessor\n  }\n\n  public onChange(_value: T) {\n    // implemented by control value accessor\n  }\n\n  public registerOnChange(fn: (value: T) => void): void {\n    this.onChange = fn;\n  }\n\n  public registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  public setDisabledState(isDisabled: boolean): void {\n    this.disabledController?.setDisabledState(isDisabled);\n  }\n\n  public writeValue(value: T): void {\n    if (this.isDisabled) return;\n    this.value = value;\n    this.onChange(value);\n  }\n\n  public updateValue(value: T): void {\n    if (this.isDisabled) return;\n    this.writeValue(value);\n    this.onTouched();\n  }\n\n  protected hasValidator(validator: ValidatorFn): boolean {\n    return !!this.ngControl?.control?.hasValidator(validator);\n  }\n\n  @Pure\n  private hasNonIgnoredError(errors: ValidationErrors | null): boolean {\n    if (!errors) return false;\n\n    return Object.keys(errors).some((error) => !this.ignoreErrors.includes(error));\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"custom-form-control.js","sourceRoot":"","sources":["../../../../../../../libs/angular/cdk/custom-form-control/src/lib/custom-form-control.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, inject, Input, ViewChild } from '@angular/core';\nimport { ControlValueAccessor, NgControl, RequiredValidator, ValidationErrors, ValidatorFn, Validators } from '@angular/forms';\nimport { Controller, DisabledController, ReadonlyController } from '@odx/angular';\nimport { arrayAttribute, Pure } from '@odx/angular/utils';\nimport { ControlDirective } from './control.directive';\n\n/**\n * An abstract directive that serves as a base for custom form controls, integrating seamlessly with Angular Forms.\n * It incorporates common form control behaviors such as handling disabled and readonly states, validation, and more.\n *\n * This approach allows the creation of highly reusable and consistent form controls within Angular applications,\n * simplifying the integration with Angular Forms and the handling of common form behaviors.\n *\n * Extends Controller to provide a consistent API for managing state changes and subscriptions.\n *\n * @see {Controller}\n */\n@Directive({\n  host: {\n    '[class.has-error]': 'hasError',\n    '[class.is-disabled]': 'isDisabled',\n    '[class.is-readonly]': 'isReadonly',\n    '[class.is-required]': 'required',\n  },\n})\nexport abstract class CustomFormControl<T> extends Controller implements ControlValueAccessor {\n  private static CURRENT_INDEX = 0;\n\n  private readonly requiredValidator = inject(RequiredValidator, { optional: true, self: true });\n  private internalValue: T;\n  protected readonly disabledController = DisabledController.inject();\n  protected readonly readonlyController = ReadonlyController.inject();\n  protected readonly ngControl = inject(NgControl, { self: true, optional: true });\n\n  /**\n   * A unique identifier for the custom form control. If not provided, a unique ID is generated automatically.\n   * This can be useful for associating form control with a label.\n   *\n   * @type {string}\n   */\n  @Input()\n  public id: string | null = null;\n\n  /**\n   * The name attribute for the custom form control. Defaults to a unique name if not provided.\n   * This is useful when the form control is part of a form and needs to be identified.\n   *\n   * @type {string}\n   */\n  @Input()\n  public name = `odx-form-control-${CustomFormControl.CURRENT_INDEX++}`;\n\n  /**\n   * The tabindex attribute for the custom form control. Can be used to control the order of focus navigation.\n   *\n   * @type {string | null}\n   */\n  @Input()\n  public tabindex: string | null = null;\n\n  /**\n   * An array of error codes to ignore. If an error code is included in this array, the form control will not\n   * consider it as an error state. Useful for ignoring specific validation errors.\n   *\n   * @type {string[]}\n   */\n  @Input({ transform: arrayAttribute })\n  public ignoreErrors: string[] = [];\n\n  /**\n   * The current value of the form control. Setting this value updates the internal state and marks the control\n   * for checking changes. Getting this value returns the current internal value of the control.\n   *\n   * @example\n   * ```ts\n   * this.customInputControl.value = 'newValue'; // Sets the value\n   * const currentValue = this.customInputControl.value; // Gets the current value\n   * ```\n   */\n  public set value(value: T) {\n    if (this.internalValue !== value) {\n      this.internalValue = value;\n      this.triggerControllerChange();\n    }\n  }\n\n  /**\n   * Gets the value of the custom form control.\n   *\n   * @returns {T} - The value of the custom form control.\n   */\n  public get value(): T {\n    return this.internalValue;\n  }\n\n  /**\n   * Indicates whether the form control currently has an error. This takes into account any ignored errors.\n   *\n   * @returns {boolean} - True if the form control has an error, false otherwise.\n   *\n   * @example\n   * ```ts\n   * if (this.customInputControl.hasError) { ... }\n   * ```\n   */\n  public get hasError(): boolean {\n    return !!this.ngControl?.touched && !!this.ngControl?.invalid && this.hasNonIgnoredError(this.ngControl.errors);\n  }\n\n  /**\n   * Indicates whether the form control is currently disabled.\n   *\n   * @returns {boolean} - True if the form control is disabled, false otherwise.\n   *\n   * @example\n   * ```ts\n   * if (this.customInputControl.isDisabled) { ... }\n   * ```\n   */\n  public get isDisabled(): boolean {\n    return !!this.disabledController?.disabled;\n  }\n\n  /**\n   * Indicates whether the form control is currently in a readonly state.\n   *\n   * @returns {boolean} - True if the form control is readonly, false otherwise.\n   *\n   * @example\n   * ```ts\n   * if (this.customInputControl.isReadonly) { ... }\n   * ```\n   */\n  public get isReadonly(): boolean {\n    return !!this.readonlyController?.readonly;\n  }\n\n  /**\n   * Indicates whether the form control is marked as required, either through Validators.required, Validators.requiredTrue,\n   * or by a required attribute on a parent form field.\n   *\n   * @returns {boolean} - True if the form control is required, false otherwise.\n   *\n   * @example\n   * ````ts\n   * if (this.customInputControl.isRequired) { ... }\n   * ````\n   */\n  public get isRequired(): boolean {\n    return !!this.requiredValidator?.required || this.hasValidator(Validators.required) || this.hasValidator(Validators.requiredTrue);\n  }\n\n  /**\n   * A reference to the `ControlDirective` if it exists within the same host. This allows for direct interaction\n   * with the underlying form control directive.\n   *\n   * @type {ControlDirective | null}\n   *\n   * @example\n   * ```ts\n   * this.customInputControl.control?.focus();\n   * ```\n   */\n  @ViewChild(ControlDirective)\n  public readonly control: ControlDirective | null = null;\n\n  constructor(initialValue: T) {\n    super();\n    this.internalValue = initialValue;\n    if (this.ngControl) {\n      this.ngControl.valueAccessor = this;\n    }\n  }\n\n  /** @internal */\n  public onTouched() {\n    // implemented by control value accessor\n  }\n\n  /** @internal */\n  public onChange(_value: T) {\n    // implemented by control value accessor\n  }\n\n  /** @internal */\n  public registerOnChange(fn: (value: T) => void): void {\n    this.onChange = fn;\n  }\n  /** @internal */\n  public registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  /** @internal */\n  public setDisabledState(isDisabled: boolean): void {\n    this.disabledController?.setDisabledState(isDisabled);\n  }\n\n  /** @internal */\n  public writeValue(value: T): void {\n    this.value = value;\n    this.onChange(value);\n  }\n\n  /** @internal */\n  public updateValue(value: T): void {\n    if (this.isDisabled) return;\n    this.writeValue(value);\n    this.onTouched();\n  }\n\n  protected hasValidator(validator: ValidatorFn): boolean {\n    return !!this.ngControl?.control?.hasValidator(validator);\n  }\n\n  @Pure\n  private hasNonIgnoredError(errors: ValidationErrors | null): boolean {\n    if (!errors) return false;\n\n    return Object.keys(errors).some((error) => !this.ignoreErrors.includes(error));\n  }\n}\n"]}

package/esm2022/cdk/custom-form-control/lib/input-control.directive.mjs

@@ -2,24 +2,99 @@ import { Directive } from '@angular/core';
 import { injectElement, untilDestroyed } from '@odx/angular/utils';
 import { distinctUntilChanged, fromEvent, map } from 'rxjs';
 import * as i0 from "@angular/core";
+/**
+ * An abstract directive that facilitates handling input changes, focusing, and blurring programmatically for input elements.
+ * It provides a reactive `valueChange$` observable to subscribe to input changes.
+ * This directive can be extended to create more specific input handlers.
+ *
+ * @example
+ * Extending InputControlDirective in a custom directive:
+ * ```ts
+ * @Directive({
+ *   selector: '[appCustomInput]',
+ *   standalone: true,
+ * })
+ * export class CustomInputDirective extends InputControlDirective {
+ *   // Custom logic here
+ * }
+ * ```
+ *
+ * Using the directive in a component template:
+ * ```html
+ * <input appCustomInput type="text" />
+ * ```
+ *
+ * Subscribing to input changes in the component:
+ * ```ts
+ * @Component({...})
+ * export class MyComponent implements AfterViewInit {
+ *   @ViewChild(CustomInputDirective) customInputDirective!: CustomInputDirective;
+ *
+ *   ngAfterViewInit(): void {
+ *     this.customInputDirective.valueChange$.subscribe(value => {
+ *       console.log('Input value changed to:', value);
+ *     });
+ *   }
+ * }
+ *
+ * // Focusing the input programmatically
+ * this.customInputDirective.focus();
+ *
+ * // Blurring the input programmatically
+ * this.customInputDirective.blur();
+ *
+ * // Resetting the input value programmatically
+ * this.customInputDirective.reset();
+ * ```
+ */
 export class InputControlDirective {
     constructor() {
         this.takeUntilDestroyed = untilDestroyed();
         this.element = injectElement();
+        /**
+         * Represents an observable stream of value changes for the input control.
+         *
+         * @emits {string} input value changes.
+         */
         this.valueChange$ = fromEvent(this.element.nativeElement, 'input').pipe(distinctUntilChanged(), map(() => this.nativeElementValue));
     }
+    /**
+     * Gets the current value of the input element.
+     *
+     * @type {string} The current value of the input element.
+     */
     get nativeElementValue() {
         return this.element.nativeElement.value;
     }
+    /**
+     * Sets the value of the input element.
+     *
+     * @param {string} value - The value to set.
+     */
     set nativeElementValue(value) {
         this.element.nativeElement.value = value;
     }
+    /**
+     * Sets focus on the input element.
+     *
+     * @returns {void}
+     */
     focus() {
         this.element.nativeElement.focus();
     }
+    /**
+     * Removes focus from the input element.
+     *
+     * @returns {void}
+     */
     blur() {
         this.element.nativeElement.blur();
     }
+    /**
+     * Resets the input element value to an empty string.
+     *
+     * @returns {void}
+     */
     reset() {
         this.element.nativeElement.value = '';
     }
@@ -32,4 +107,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                     standalone: true,
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/dynamic-view/lib/dynamic-view.directive.mjs

@@ -3,6 +3,13 @@ import { hasChanged, isComponent } from '@odx/angular/utils';
 import { DynamicViewService } from './dynamic-view.service';
 import { createProjectableNodes, isDynamicTextContent, isDynamicView } from './helpers';
 import * as i0 from "@angular/core";
+/**
+ * A directive that dynamically renders content based on the provided input. It supports rendering
+ * Angular components, templates, and text content, allowing for dynamic and flexible content
+ * management within Angular applications.
+ *
+ * @template T - A type parameter that extends `DynamicContent<unknown>`, representing the type of content to be dynamically rendered.
+ */
 export class DynamicViewDirective {
     constructor() {
         this.dynamicViewService = inject(DynamicViewService);
@@ -10,6 +17,10 @@ export class DynamicViewDirective {
         this.template = inject(TemplateRef);
         this.viewRef = null;
         this.contentViewRef = null;
+        /**
+         * The content to be dynamically rendered. This can be a component, template reference, or text content.
+         * The content is wrapped in a `DynamicViewRef`, providing additional control over the dynamically rendered view.
+         */
         // eslint-disable-next-line @angular-eslint/no-input-rename
         this.content = null;
     }
@@ -31,6 +42,12 @@ export class DynamicViewDirective {
     ngOnDestroy() {
         this.destroy();
     }
+    /**
+     * Retrieves the current `DynamicViewRef` associated with the rendered content, providing access
+     * to the view reference for additional operations like updating context or manual destruction.
+     *
+     * @returns {DynamicViewRef<T> | null} The current view reference for the dynamically rendered content, if available.
+     */
     getView() {
         return this.viewRef;
     }
@@ -91,4 +108,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
                 type: Input,
                 args: ['odxDynamicViewContext']
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-view.directive.js","sourceRoot":"","sources":["../../../../../../../libs/angular/cdk/dynamic-view/src/lib/dynamic-view.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, EmbeddedViewRef, inject, Injector, Input, OnChanges, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';\nimport { hasChanged, isComponent, NgChanges } from '@odx/angular/utils';\nimport { DynamicViewService } from './dynamic-view.service';\nimport { DynamicContent, DynamicViewRef, GetDynamicViewContext } from './facade';\nimport { createProjectableNodes, isDynamicTextContent, isDynamicView } from './helpers';\n\n@Directive({\n  selector: 'ng-template[odxDynamicView]',\n  standalone: true,\n})\nexport class DynamicViewDirective<T extends DynamicContent<unknown> = DynamicContent<unknown>> implements OnDestroy, OnInit, OnChanges {\n  private readonly dynamicViewService = inject(DynamicViewService);\n  private readonly viewContainer = inject(ViewContainerRef);\n  private readonly template = inject(TemplateRef);\n  private viewRef: DynamicViewRef<T> | null = null;\n  private contentViewRef: DynamicViewRef<TemplateRef<unknown>> | null = null;\n\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('odxDynamicView')\n  public content?: T | DynamicViewRef<T> | null = null;\n\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('odxDynamicViewInjector')\n  public injector?: Injector;\n\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('odxDynamicViewContext')\n  public context?: GetDynamicViewContext<T>;\n\n  public ngOnInit(): void {\n    this.render();\n  }\n\n  public ngOnChanges(changes: NgChanges<DynamicViewDirective<DynamicContent>>): void {\n    if (hasChanged(changes, 'injector')) {\n      this.render();\n    }\n    if (hasChanged(changes, 'content')) {\n      const hasChangedTextContent = isDynamicTextContent(changes.content?.previousValue) && isDynamicTextContent(changes.content?.currentValue);\n      this.render(!hasChangedTextContent);\n    }\n    if (hasChanged(changes, 'context')) {\n      this.viewRef?.update(changes.context?.currentValue ?? {});\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this.destroy();\n  }\n\n  public getView(): DynamicViewRef<T> | null {\n    return this.viewRef;\n  }\n\n  private render(reRender = true) {\n    if (!this.content) {\n      this.destroy();\n      return;\n    }\n    if (!reRender && this.viewRef) {\n      this.viewRef?.update({ content: this.content } as object);\n      return;\n    }\n    this.viewRef?.destroy();\n    if (isDynamicView(this.content)) {\n      this.viewRef = this.content;\n      const hostView = this.viewRef.getView();\n      if (hostView) {\n        this.viewContainer.insert(hostView);\n      }\n    } else {\n      let projectableNodes: Node[][] = [];\n      if (isComponent(this.content)) {\n        this.contentViewRef = this.dynamicViewService.createView(this.template, { injector: this.injector });\n        const rootNodes = (this.contentViewRef.getView() as EmbeddedViewRef<unknown>).rootNodes;\n        projectableNodes = createProjectableNodes(this.content, rootNodes);\n      }\n      this.viewRef = this.dynamicViewService.createView(this.content, {\n        context: this.context ?? undefined,\n        injector: this.injector ?? this.viewContainer.injector,\n        projectableNodes,\n        host: this.viewContainer,\n      });\n    }\n  }\n\n  private destroy() {\n    this.contentViewRef?.destroy();\n    this.viewRef?.destroy();\n    this.contentViewRef = null;\n    this.viewRef = null;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-view.directive.js","sourceRoot":"","sources":["../../../../../../../libs/angular/cdk/dynamic-view/src/lib/dynamic-view.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, EmbeddedViewRef, inject, Injector, Input, OnChanges, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';\nimport { hasChanged, isComponent, NgChanges } from '@odx/angular/utils';\nimport { DynamicViewService } from './dynamic-view.service';\nimport { DynamicContent, DynamicViewRef, GetDynamicViewContext } from './facade';\nimport { createProjectableNodes, isDynamicTextContent, isDynamicView } from './helpers';\n\n/**\n * A directive that dynamically renders content based on the provided input. It supports rendering\n * Angular components, templates, and text content, allowing for dynamic and flexible content\n * management within Angular applications.\n *\n * @template T - A type parameter that extends `DynamicContent<unknown>`, representing the type of content to be dynamically rendered.\n */\n@Directive({\n  selector: 'ng-template[odxDynamicView]',\n  standalone: true,\n})\nexport class DynamicViewDirective<T extends DynamicContent<unknown> = DynamicContent<unknown>> implements OnDestroy, OnInit, OnChanges {\n  private readonly dynamicViewService = inject(DynamicViewService);\n  private readonly viewContainer = inject(ViewContainerRef);\n  private readonly template = inject(TemplateRef);\n  private viewRef: DynamicViewRef<T> | null = null;\n  private contentViewRef: DynamicViewRef<TemplateRef<unknown>> | null = null;\n\n  /**\n   * The content to be dynamically rendered. This can be a component, template reference, or text content.\n   * The content is wrapped in a `DynamicViewRef`, providing additional control over the dynamically rendered view.\n   */\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('odxDynamicView')\n  public content?: T | DynamicViewRef<T> | null = null;\n\n  /**\n   * An optional injector to be used for dynamically created components. This allows for custom dependency injection\n   * into dynamically rendered components.\n   */\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('odxDynamicViewInjector')\n  public injector?: Injector;\n\n  /**\n   * An optional context providing function for dynamically created views. This function returns the context\n   * object to be passed to the dynamically rendered content, allowing for dynamic interaction with the content.\n   */\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('odxDynamicViewContext')\n  public context?: GetDynamicViewContext<T>;\n\n  public ngOnInit(): void {\n    this.render();\n  }\n\n  public ngOnChanges(changes: NgChanges<DynamicViewDirective<DynamicContent>>): void {\n    if (hasChanged(changes, 'injector')) {\n      this.render();\n    }\n    if (hasChanged(changes, 'content')) {\n      const hasChangedTextContent = isDynamicTextContent(changes.content?.previousValue) && isDynamicTextContent(changes.content?.currentValue);\n      this.render(!hasChangedTextContent);\n    }\n    if (hasChanged(changes, 'context')) {\n      this.viewRef?.update(changes.context?.currentValue ?? {});\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this.destroy();\n  }\n\n  /**\n   * Retrieves the current `DynamicViewRef` associated with the rendered content, providing access\n   * to the view reference for additional operations like updating context or manual destruction.\n   *\n   * @returns {DynamicViewRef<T> | null} The current view reference for the dynamically rendered content, if available.\n   */\n  public getView(): DynamicViewRef<T> | null {\n    return this.viewRef;\n  }\n\n  private render(reRender = true) {\n    if (!this.content) {\n      this.destroy();\n      return;\n    }\n    if (!reRender && this.viewRef) {\n      this.viewRef?.update({ content: this.content } as object);\n      return;\n    }\n    this.viewRef?.destroy();\n    if (isDynamicView(this.content)) {\n      this.viewRef = this.content;\n      const hostView = this.viewRef.getView();\n      if (hostView) {\n        this.viewContainer.insert(hostView);\n      }\n    } else {\n      let projectableNodes: Node[][] = [];\n      if (isComponent(this.content)) {\n        this.contentViewRef = this.dynamicViewService.createView(this.template, { injector: this.injector });\n        const rootNodes = (this.contentViewRef.getView() as EmbeddedViewRef<unknown>).rootNodes;\n        projectableNodes = createProjectableNodes(this.content, rootNodes);\n      }\n      this.viewRef = this.dynamicViewService.createView(this.content, {\n        context: this.context ?? undefined,\n        injector: this.injector ?? this.viewContainer.injector,\n        projectableNodes,\n        host: this.viewContainer,\n      });\n    }\n  }\n\n  private destroy() {\n    this.contentViewRef?.destroy();\n    this.viewRef?.destroy();\n    this.contentViewRef = null;\n    this.viewRef = null;\n  }\n}\n"]}

package/esm2022/cdk/dynamic-view/lib/dynamic-view.service.mjs

@@ -6,11 +6,41 @@ import { DynamicComponentRef } from './models';
 import { DynamicTemplateRef } from './models/dynamic-template-ref';
 import { DYNAMIC_VIEW_CONTEXT, getDynamicViewDefaultHost } from './tokens';
 import * as i0 from "@angular/core";
+/**
+ * A service for creating and managing dynamic views in an Angular application.
+ * It supports rendering Angular components, templates, and text content dynamically,
+ * allowing for flexible and dynamic content composition.
+ */
 export class DynamicViewService {
     constructor() {
         this.injector = inject(Injector);
         this.defaultHost = getDynamicViewDefaultHost();
     }
+    /**
+     * Creates and returns a reference to a dynamic view based on the provided content and options.
+     * The method supports dynamic creation of components, template references, and text content,
+     * providing a unified API for dynamic content rendering.
+     *
+     * @template T - The type of the content to be dynamically rendered.
+     * @param {T} content - The content to be rendered dynamically. This can be a component class,
+     * a template reference, or text content.
+     * @param {Partial<DynamicViewOptions<T>>} [options={}] - Optional configuration for the dynamic view creation,
+     * including a custom injector, context, host element, and additional providers for the dynamic component's injector.
+     * @returns {DynamicViewRef<T>} A reference to the dynamically created view, encapsulating the rendered content
+     * and providing methods for interaction and management.
+     * @throws {Error} Throws an error if the content type is not supported.
+     * @example
+     * ```ts
+     * // Create a dynamic view for a component
+     * const componentRef = dynamicViewService.createView(MyComponent, { context: { ... } });
+     *
+     * // Create a dynamic view for a template reference
+     * const templateRef = dynamicViewService.createView(myTemplate, { context: { ... } });
+     *
+     * // Create a dynamic view for text content
+     * const textRef = dynamicViewService.createView('Dynamic text content', {});
+     * ```
+     */
     createView(content, options = {}) {
         const viewOptions = {
             ...options,
@@ -42,4 +72,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImpo
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/cdk/dynamic-view/lib/helpers/create-projectable-nodes.mjs

@@ -1,4 +1,26 @@
 import { reflectComponentType } from '@angular/core';
+/**
+ * Prepares an array of node arrays suitable for projection into the `<ng-content>` slots
+ * of a dynamically created Angular component based on its content selectors.
+ *
+ * The function inspects the component's content selectors and aligns the provided nodes
+ * for projection according to these selectors. A selector of '*' indicates that the nodes
+ * should be projected into this slot. If a content selector does not match '*', an empty
+ * array is returned for that slot, indicating no nodes are projected into it.
+ *
+ * @param {Type<unknown>} component - The component class for which the projectable nodes are being prepared.
+ * @param {Node[]} nodes - The nodes intended for projection into the component's `<ng-content>` slots.
+ * @returns {Node[][]} An array of node arrays, each corresponding to a `<ng-content>` slot in the component.
+ * Each sub-array contains nodes to be projected into the respective `<ng-content>` slot, based on the component's content selectors.
+ *
+ * @example
+ * ```ts
+ * // Given a component with two `<ng-content>` slots, the first without a selector and the second with the selector `<ng-content select=".selector-class">`,
+ * const nodes = [document.createTextNode('Hello'), document.createElement('div')];
+ * const projectableNodes = createProjectableNodes(MyComponent, nodes);
+ * // projectableNodes would be `[[TextNode, DivElement], []]` for a component with selectors ['*', '.selector-class']
+ * ```
+ */
 export function createProjectableNodes(component, nodes) {
     const componentType = reflectComponentType(component);
     if (componentType && componentType.ngContentSelectors.length > 0) {
@@ -6,4 +28,4 @@ export function createProjectableNodes(component, nodes) {
     }
     return [];
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlLXByb2plY3RhYmxlLW5vZGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyL2Nkay9keW5hbWljLXZpZXcvc3JjL2xpYi9oZWxwZXJzL2NyZWF0ZS1wcm9qZWN0YWJsZS1ub2Rlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0JBQW9CLEVBQVEsTUFBTSxlQUFlLENBQUM7QUFFM0QsTUFBTSxVQUFVLHNCQUFzQixDQUFDLFNBQXdCLEVBQUUsS0FBYTtJQUM1RSxNQUFNLGFBQWEsR0FBRyxvQkFBb0IsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUN0RCxJQUFJLGFBQWEsSUFBSSxhQUFhLENBQUMsa0JBQWtCLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRTtRQUNoRSxPQUFPLGFBQWEsQ0FBQyxrQkFBa0IsQ0FBQyxHQUFHLENBQUMsQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUFDLENBQUMsUUFBUSxLQUFLLEdBQUcsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO0tBQzVGO0lBQ0QsT0FBTyxFQUFFLENBQUM7QUFDWixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcmVmbGVjdENvbXBvbmVudFR5cGUsIFR5cGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGZ1bmN0aW9uIGNyZWF0ZVByb2plY3RhYmxlTm9kZXMoY29tcG9uZW50OiBUeXBlPHVua25vd24+LCBub2RlczogTm9kZVtdKTogTm9kZVtdW10ge1xuICBjb25zdCBjb21wb25lbnRUeXBlID0gcmVmbGVjdENvbXBvbmVudFR5cGUoY29tcG9uZW50KTtcbiAgaWYgKGNvbXBvbmVudFR5cGUgJiYgY29tcG9uZW50VHlwZS5uZ0NvbnRlbnRTZWxlY3RvcnMubGVuZ3RoID4gMCkge1xuICAgIHJldHVybiBjb21wb25lbnRUeXBlLm5nQ29udGVudFNlbGVjdG9ycy5tYXAoKHNlbGVjdG9yKSA9PiAoc2VsZWN0b3IgPT09ICcqJyA/IG5vZGVzIDogW10pKTtcbiAgfVxuICByZXR1cm4gW107XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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