@messaia/cdk 17.1.0-rc15 → 17.1.0-rc16

package/lib/form-validators/abstract/typed-form.d.ts

@@ -1,4 +1,13 @@
 import { IFormGroup } from '../models/interface/i-form-group';
+/**
+ * This class sets up a blueprint for creating typed forms by providing a property (formGroup)
+ * for handling form data of a specific type (T). Users can extend this class and implement
+ * the formGroup property as needed to create typed forms for their applications.
+ */
 export declare abstract class TypedForm<T> {
+    /**
+     * Represents the form group that handles form data of the specified type (T).
+     * Implementations should assign an appropriate form group to this property.
+     */
     formGroup?: IFormGroup<T>;
 }

package/lib/form-validators/algorithm/luhn-algorithm.d.ts

@@ -1 +1,8 @@
+/**
+ * Calculates the checksum according to the Luhn algorithm for the provided string of digits.
+ * The Luhn algorithm is commonly used for validating identification numbers like credit card numbers.
+ *
+ * @param numbers A string of digits for which the checksum is to be calculated.
+ * @returns The calculated checksum value.
+ */
 export declare function calculate(numbers: string): number;

package/lib/form-validators/const/app.const.d.ts

@@ -1,16 +1,64 @@
+/**
+ * Constant string representing the error for form controls.
+ */
 export declare const CONTROLS_ERROR: string;
+/**
+ * Constant string representing a synchronous value change.
+ */
 export declare const VALUE_CHANGED_SYNC: string;
+/**
+ * Constant string representing a function type.
+ */
 export declare const FUNCTION_STRING: string;
+/**
+ * Constant string representing an object type.
+ */
 export declare const OBJECT_STRING: string;
+/**
+ * Constant string representing the RxWeb Validator.
+ */
 export declare const RX_WEB_VALIDATOR: string;
+/**
+ * Constant string representing a number type.
+ */
 export declare const NUMBER: string;
+/**
+ * Constant string representing a boolean type.
+ */
 export declare const BOOLEAN: string;
+/**
+ * Constant string representing a custom type.
+ */
 export declare const CUSTOM: string;
+/**
+ * Constant string representing a template validation configuration.
+ */
 export declare const TEMPLATE_VALIDATION_CONFIG: string;
+/**
+ * Constant string representing a conditional validator.
+ */
 export declare const CONDITIONAL_VALIDATOR: string;
+/**
+ * Constant string representing a validator configuration.
+ */
 export declare const VALIDATOR_CONFIG: string;
+/**
+ * Constant string representing the 'this' keyword.
+ */
 export declare const THIS: string;
+/**
+ * Constant string used as a separator for certain codes.
+ */
 export declare const RXCODE: string;
+/**
+ * Constant string representing a model.
+ */
 export declare const MODEL: string;
+/**
+ * Constant string representing a model instance.
+ */
 export declare const MODEL_INSTANCE: string;
+/**
+ * Constant string representing a patch operation.
+ */
 export declare const PATCH: string;

package/lib/form-validators/const/config-names.const.d.ts

@@ -1,8 +1,32 @@
+/**
+ * Constant string representing an array configuration.
+ */
 export declare const ARRAY_CONFIG: string;
+/**
+ * Constant string representing a field configuration.
+ */
 export declare const FIELD_CONFIG: string;
+/**
+ * Constant string representing an IP configuration.
+ */
 export declare const IP_CONFIG: string;
+/**
+ * Constant string representing a number configuration.
+ */
 export declare const NUMBER_CONFIG: string;
+/**
+ * Constant string representing a password configuration.
+ */
 export declare const PASSWORD_CONFIG: string;
+/**
+ * Constant string representing a pattern configuration.
+ */
 export declare const PATTERN_CONFIG: string;
+/**
+ * Constant string representing a range configuration.
+ */
 export declare const RANGE_CONFIG: string;
+/**
+ * Constant string representing a relational operator configuration.
+ */
 export declare const RELATIONAL_OPERATOR_CONFIG: string;

package/lib/form-validators/const/config-required-fields.const.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Constant object representing required fields for different configurations.
+ */
 export declare const CONFIG_REQUIRED_FIELDS: {
     [key: string]: string[];
 };

package/lib/form-validators/const/events.const.d.ts

@@ -1,13 +1,52 @@
+/**
+ * Event type for keypress event.
+ */
 export declare const KEYPRESS: string;
+/**
+ * Event type for onchange event.
+ */
 export declare const ONCHANGE: string;
+/**
+ * Event type for onclick event.
+ */
 export declare const ONCLICK: string;
+/**
+ * Event type for onkeyup event.
+ */
 export declare const ONKEYUP: string;
+/**
+ * Event type for onblur event.
+ */
 export declare const ONBLUR: string;
+/**
+ * Event type for onfocus event.
+ */
 export declare const ONFOCUS: string;
+/**
+ * Element value identifier.
+ */
 export declare const ELEMENT_VALUE: string;
+/**
+ * Event type for blur event.
+ */
 export declare const BLUR: string;
+/**
+ * Event type for focus event.
+ */
 export declare const FOCUS: string;
+/**
+ * Event type for change event.
+ */
 export declare const CHANGE: string;
+/**
+ * Event type for keydown event.
+ */
 export declare const KEY_DOWN: string;
+/**
+ * Event type for keypress event.
+ */
 export declare const KEY_PRESS: string;
+/**
+ * Event type for paste event.
+ */
 export declare const PASTE: string;

package/lib/form-validators/const/html-elements.const.d.ts

@@ -1,6 +1,24 @@
+/**
+ * Element type for input elements.
+ */
 export declare const INPUT: string;
+/**
+ * Element type for select elements.
+ */
 export declare const SELECT: string;
+/**
+ * Element type for checkbox elements.
+ */
 export declare const CHECKBOX: string;
+/**
+ * Element type for radio elements.
+ */
 export declare const RADIO: string;
+/**
+ * Element type for file input elements.
+ */
 export declare const FILE: string;
+/**
+ * Element type for textarea elements.
+ */
 export declare const TEXTAREA: string;

package/lib/form-validators/const/validator.const.d.ts

@@ -1,7 +1,28 @@
+/**
+ * Represents the state of being invalid.
+ */
 export declare const INVALID: string;
+/**
+ * Represents a property.
+ */
 export declare const PROPERTY: string;
+/**
+ * Represents an object property.
+ */
 export declare const OBJECT_PROPERTY: string;
+/**
+ * Represents an array property.
+ */
 export declare const ARRAY_PROPERTY: string;
+/**
+ * Represents a string data type.
+ */
 export declare const STRING: string;
+/**
+ * Represents a message.
+ */
 export declare const MESSAGE: string;
+/**
+ * Represents a blank value.
+ */
 export declare const BLANK: string;

package/lib/form-validators/core/default-container.d.ts

@@ -0,0 +1,153 @@
+import { PropsConfig } from "../models/config/props-config";
+import { DecoratorConfiguration } from "../models/decorator-configuration";
+import { InstanceContainer } from "../models/instance-container";
+import { PropertyInfo } from "../models/property-info";
+/**
+ * Represents a default container for managing instance configurations.
+ *
+ * Manages the configuration and instantiation of validation decorators, sanitizers, and other properties for classes.
+ * This class serves as a container for managing instance-related configurations and properties.
+ */
+export declare class DefaultContainer {
+    /**
+  * Represents whether the container is operating in experimental mode.
+  * Experimental mode may introduce features that are still under development or testing.
+  */
+    isExperimental: boolean;
+    /**
+     * Array containing instances and their configurations.
+     * Each element represents an instance of the application with associated properties and decorators.
+     */
+    private instances;
+    /**
+     * Counter used for generating unique identifiers for model instances.
+     * This counter is incremented each time a new model instance is added to the container.
+     */
+    modelIncrementCount: number;
+    /**
+     * Retrieves an instance container based on the provided instance function.
+     * @param instanceFunc The instance function.
+     * @returns The instance container.
+     */
+    get<T>(instanceFunc: any): InstanceContainer;
+    /**
+     * Retrieves or creates an instance container based on the provided parameters.
+     * @param target The target.
+     * @param parameterIndex The parameter index.
+     * @param propertyKey The property key.
+     * @param decoratorType The decorator type.
+     * @returns The instance container.
+     */
+    getInstance(target: any, parameterIndex: any, propertyKey: string, decoratorType: string): InstanceContainer;
+    /**
+     * Adds property configurations to the instance container.
+     * @param target The target.
+     * @param configs The configurations.
+     */
+    addPropsConfig(target: any, configs?: PropsConfig[]): void;
+    /**
+     * Adds a property configuration to the instance container.
+     * @param target The target.
+     * @param properties The properties.
+     * @param config The configuration.
+     */
+    addPropConfig(target: any, properties: PropertyInfo[], config: PropsConfig): void;
+    /**
+     * Adds a sanitizer to the instance container.
+     * @param target The target.
+     * @param parameterIndex The parameter index.
+     * @param propertyKey The property key.
+     * @param decoratorType The decorator type.
+     * @param value The value.
+     */
+    addSanitizer(target: any, parameterIndex: any, propertyKey: string, decoratorType: string, value?: any): void;
+    /**
+     * Adds a decorator configuration to the instance container.
+     * @param target The target.
+     * @param parameterIndex The parameter index.
+     * @param propertyKey The property key.
+     * @param config The configuration.
+     * @param decoratorType The decorator type.
+     */
+    addDecoratorConfig(target: any, parameterIndex: any, propertyKey: string, config: any, decoratorType: string): void;
+    /**
+     * Initializes a decorator configuration.
+     * @param target The target.
+     * @param parameterIndex The parameter index.
+     * @param propertyKey The property key.
+     * @param annotationType The annotation type.
+     * @param config The configuration.
+     * @param isAsync Indicates whether it's an asynchronous operation.
+     */
+    init(target: any, parameterIndex: any, propertyKey: string, annotationType: string, config: any, isAsync: boolean): void;
+    /**
+     * Initializes a property object.
+     * @param name The name.
+     * @param propertyType The property type.
+     * @param entity The entity.
+     * @param target The target.
+     * @param config The configuration.
+     */
+    initPropertyObject(name: string, propertyType: string, entity: any, target: any, config?: any): void;
+    /**
+     * Adds an instance container to the list of instances.
+     * @param instanceFunc The instance function.
+     * @returns The added instance container.
+     */
+    addInstanceContainer(instanceFunc: any): InstanceContainer;
+    /**
+     * Adds a property to the instance container.
+     * @param instanceFunc The instance function.
+     * @param propertyInfo The property information.
+     * @param isFromAnnotation Indicates whether it's added from an annotation.
+     */
+    addProperty(instanceFunc: any, propertyInfo: PropertyInfo, isFromAnnotation?: boolean): void;
+    /**
+     * Adds property information to the instance container.
+     * @param instance The instance container.
+     * @param propertyInfo The property information.
+     * @param isAddProperty Indicates whether it's added as a new property.
+     */
+    addPropertyInfo(instance: InstanceContainer, propertyInfo: PropertyInfo, isAddProperty?: boolean): void;
+    /**
+     * Adds an annotation to the instance container.
+     * @param instanceFunc The instance function.
+     * @param decoratorConfiguration The decorator configuration.
+     */
+    addAnnotation(instanceFunc: any, decoratorConfiguration: DecoratorConfiguration): void;
+    /**
+     * Sets conditional columns based on the decorator configuration.
+     * @param instance The instance container.
+     * @param decoratorConfiguration The decorator configuration.
+     */
+    setConditionalColumns(instance: any, decoratorConfiguration: DecoratorConfiguration): void;
+    /**
+     * Sets logical conditionals based on the decorator configuration.
+     * @param instance The instance container.
+     * @param annotationType The annotation type.
+     * @param fieldName The field name.
+     * @param propertyName The property name.
+     */
+    setLogicalConditional(instance: any, annotationType: string, fieldName: string, propertyName: string): void;
+    /**
+     * Sets conditional value properties based on the decorator configuration.
+     * @param instance The instance container.
+     * @param propertyName The property name.
+     * @param refPropertyName The reference property name.
+     */
+    setConditionalValueProp(instance: InstanceContainer, propertyName: string, refPropertyName: string): void;
+    /**
+     * Adds change validation based on the columns.
+     * @param instance The instance container.
+     * @param propertyName The property name.
+     * @param columns The columns.
+     */
+    addChangeValidation(instance: InstanceContainer, propertyName: string, columns: any[]): void;
+}
+/**
+ * Represents a default container for managing instance configurations.
+ *
+ * Manages the configuration and instantiation of validation decorators, sanitizers, and other properties for classes.
+ * This class serves as a container for managing instance-related configurations and properties.
+ */
+export declare const defaultContainer: DefaultContainer;

package/lib/form-validators/directives/base-directive.d.ts

@@ -1,7 +1,24 @@
 import * as i0 from "@angular/core";
+/**
+ * Abstract base directive for applying validations to form controls.
+ */
 export declare abstract class BaseDirective {
+    /**
+     * Input property for the model object.
+     */
     model: any;
+    /**
+     * Applies validations to the given controls based on the model configuration.
+     * @param controls The controls to which validations are applied.
+     * @param model Optional model object. If not provided, the model property of the directive is used.
+     */
     applyValidations(controls: any, model?: any): void;
+    /**
+     * Sets the validator configuration for a specific control based on model annotations.
+     * @param control The control to which the validator configuration is applied.
+     * @param modelConfig The configuration of the model.
+     * @param property The property info of the control.
+     */
     private setValidatorConfig;
     static ɵfac: i0.ɵɵFactoryDeclaration<BaseDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<BaseDirective, never, never, { "model": { "alias": "model"; "required": false; }; }, {}, never, never, false, never>;

package/lib/form-validators/directives/control-host.directive.d.ts

@@ -1,10 +1,27 @@
 import { EmbeddedViewRef, OnDestroy, ViewContainerRef } from '@angular/core';
 import * as i0 from "@angular/core";
+/**
+ * Directive for hosting dynamic form controls.
+ */
 export declare class ControlHostDirective implements OnDestroy {
     viewContainerRef: ViewContainerRef;
+    /**
+     * Reference to the embedded view.
+     */
     view?: EmbeddedViewRef<any>;
+    /**
+     * Constructor
+     * @param viewContainerRef The view container reference
+     */
     constructor(viewContainerRef: ViewContainerRef);
+    /**
+     * Setter for the portal input.
+     * @param context The context for the control
+     */
     set portal(context: any);
+    /**
+     * Lifecycle hook that is called when the directive is destroyed.
+     */
     ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ControlHostDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<ControlHostDirective, "[controlHost]", never, { "portal": { "alias": "controlHost"; "required": false; }; }, {}, never, never, false, never>;

package/lib/form-validators/directives/html-control-template.directive.d.ts

@@ -1,8 +1,21 @@
 import { TemplateRef } from "@angular/core";
 import * as i0 from "@angular/core";
+/**
+ * Directive for defining custom HTML templates for form controls.
+ */
 export declare class HtmlControlTemplateDirective {
+    /**
+     * Reference to the template
+     */
     templateRef: TemplateRef<any>;
+    /**
+     * Type of the control
+     */
     type?: string;
+    /**
+     * Constructor
+     * @param templateRef The template reference
+     */
     constructor(templateRef: TemplateRef<any>);
     static ɵfac: i0.ɵɵFactoryDeclaration<HtmlControlTemplateDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<HtmlControlTemplateDirective, "[htmlControlTemplate]", never, { "type": { "alias": "htmlControlTemplate"; "required": false; }; }, {}, never, never, false, never>;

package/lib/form-validators/directives/rx-form.directive.d.ts

@@ -1,18 +1,49 @@
-import { AfterContentInit, OnDestroy } from "@angular/core";
+import { AfterContentInit } from "@angular/core";
 import { FormGroup, NgForm } from "@angular/forms";
 import { BaseDirective } from "./base-directive";
 import * as i0 from "@angular/core";
-export declare class RxwebFormDirective extends BaseDirective implements AfterContentInit, OnDestroy {
+/**
+ * This directive provides functionality for integrating RxWebForms with Angular forms.
+ */
+export declare class RxwebFormDirective extends BaseDirective implements AfterContentInit {
+    /**
+     * Timeout ID for clearing the timeout
+     */
     private clearTimeoutNumber;
+    /**
+     * Object to store validation rules
+     */
     private validationRule;
+    /**
+     * The formGroup input property for binding the form group to the directive.
+     */
     formGroup?: FormGroup;
+    /**
+     * The ngForm input property for binding the NgForm to the directive.
+     */
     ngForm?: NgForm;
+    /**
+     * After the content is initialized, this method configures model validations based on the formGroup or ngForm.
+     */
     ngAfterContentInit(): void;
+    /**
+     * Configures model validations based on the ngForm if present.
+     */
     private configureModelValidations;
+    /**
+     * Updates the value and validity of the form controls.
+     */
     private updateValueAndValidity;
+    /**
+     * Processes the expressions for configuring model validations.
+     * @param controls - The form controls to process.
+     * @param rootFieldName - The root field name for nested controls.
+     */
     private expressionProcessor;
+    /**
+     * Sets conditional validators based on the validation rule.
+     */
     private setConditionalValidator;
-    ngOnDestroy(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RxwebFormDirective, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<RxwebFormDirective, "[formGroup],[rxwebForm]", never, { "formGroup": { "alias": "formGroup"; "required": false; }; "ngForm": { "alias": "rxwebForm"; "required": false; }; }, {}, never, never, false, never>;
 }

package/lib/form-validators/directives/template-validations/async-validation.directive.d.ts

@@ -3,15 +3,13 @@ import { Observable } from 'rxjs';
 import * as i0 from "@angular/core";
 export declare class AsyncValidationDirective implements AsyncValidator {
     /**
-     * @property
+     * The async validation function.
      */
     async: any;
     /**
-     * @description
      * Method that performs async validation against the provided control.
      *
      * @param control The control to validate against.
-     *
      * @returns A promise or observable that resolves a map of validation errors
      * if validation fails, otherwise null.
      */

package/lib/form-validators/directives/template-validations/base-validator.directive.d.ts

@@ -7,15 +7,25 @@ import * as i0 from "@angular/core";
  * It extends ControlExpressionProcess to handle control expressions.
  */
 export declare class BaseValidator extends ControlExpressionProcess {
-    /** Input property for the form control associated with the validator. */
+    /**
+     * Input property for the form control associated with the validator.
+     */
     formControl?: FormControl | AbstractControl;
-    /** Array to store the validator functions. */
+    /**
+     * Array to store the validator functions.
+     */
     protected validators: ValidatorFn[];
-    /** Reference to the HTML element associated with the validator. */
+    /**
+     * Reference to the HTML element associated with the validator.
+     */
     protected element: any;
-    /** Name of the event triggering the validation. */
+    /**
+     * Name of the event triggering the validation.
+     */
     protected eventName?: string;
-    /** Provider for handling masks in validation. */
+    /**
+     * Provider for handling masks in validation.
+     */
     protected maskProvider?: MaskProvider;
     /**
      * Performs validation on the provided control using the defined validators and mask provider.

package/lib/form-validators/directives/template-validations/control-expression-process.d.ts

@@ -4,23 +4,34 @@ import * as i0 from "@angular/core";
  * Abstract class providing common functionality for processing control expressions in Angular directives.
  */
 export declare abstract class ControlExpressionProcess {
-    /** Validator function for the control. */
+    /**
+     * Validator function for the control.
+     */
     protected validator?: ValidatorFn;
-    /** Conditional validator function for the control. */
+    /**
+     * Conditional validator function for the control.
+     */
     protected conditionalValidator?: ValidatorFn;
-    /** Configuration for the control. */
+    /**
+     * Configuration for the control.
+     */
     protected controlConfig: {
         [key: string]: any;
     } | undefined;
-    /** Optional name for the control. */
+    /**
+     * Optional name for the control.
+     */
     name?: string;
-    /** Optional form control name. */
+    /**
+     * Optional form control name.
+     */
     formControlName?: string;
-    /** Flag indicating whether control processing has occurred. */
     isProcessed: boolean;
-    /** Collection of form controls associated with the directive. */
+    /**
+     * Collection of form controls associated with the directive.
+     */
     protected controls?: {
-        [key: string]: FormControl;
+        [name: string]: FormControl;
     };
     /**
      * Sets the configuration for the control model.