@messaia/cdk 17.1.0-rc15 → 17.1.0-rc17

package/esm2022/lib/form-validators/core/default-container.mjs

@@ -0,0 +1,493 @@
+import { ARRAY_PROPERTY, OBJECT_PROPERTY, PROPERTY, RXCODE } from "../const";
+import { DECORATORS } from "../const/decorators.const";
+import { Linq } from "../util/linq";
+import { AnnotationTypes } from "./annotation-types";
+/**
+ * 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 class DefaultContainer {
+    /**
+  * Represents whether the container is operating in experimental mode.
+  * Experimental mode may introduce features that are still under development or testing.
+  */
+    isExperimental = false;
+    /**
+     * Array containing instances and their configurations.
+     * Each element represents an instance of the application with associated properties and decorators.
+     */
+    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 = 0;
+    /**
+     * Retrieves an instance container based on the provided instance function.
+     * @param instanceFunc The instance function.
+     * @returns The instance container.
+     */
+    get(instanceFunc) {
+        return this.instances.filter(instance => instance.instance === instanceFunc)[0];
+    }
+    /**
+     * 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, parameterIndex, propertyKey, decoratorType) {
+        /* Determine if the property key is defined */
+        let isPropertyKey = (propertyKey != undefined);
+        /* Get the instance function based on whether the property key is defined */
+        let instanceFunc = !isPropertyKey ? target : target.constructor;
+        /* Filter instances to find the one matching the instance function */
+        let instance = this.instances.filter(instance => instance.instance === instanceFunc)[0];
+        /* If no instance is found, create a new instance container */
+        if (!instance) {
+            instance = this.addInstanceContainer(instanceFunc);
+        }
+        /* Return the instance container */
+        return instance;
+    }
+    /**
+     * Adds property configurations to the instance container.
+     * @param target The target.
+     * @param configs The configurations.
+     */
+    addPropsConfig(target, configs) {
+        /* Find the instance container associated with the target */
+        let instanceContainer = this.instances.find(instance => instance.instance === target);
+        /* Check if the instance container exists */
+        if (instanceContainer) {
+            /* Iterate through the provided configurations or an empty array if none are provided */
+            for (let config of configs ?? []) {
+                /* Iterate through the property names in the configuration */
+                for (let prop of config.propNames) {
+                    /* Find the property info in the instance container's properties */
+                    let propertyInfo = instanceContainer.properties?.find(t => t.name == prop && (t.propertyType !== OBJECT_PROPERTY && t.propertyType !== ARRAY_PROPERTY));
+                    /* If the property info exists, add property configuration */
+                    if (propertyInfo) {
+                        this.addPropConfig(target, [propertyInfo], config);
+                    }
+                    else {
+                        /* If the property name is ':all:', add property configuration for all properties */
+                        if (prop === ":all:") {
+                            this.addPropConfig(target, instanceContainer.properties?.filter(t => t.propertyType !== OBJECT_PROPERTY && t.propertyType !== ARRAY_PROPERTY), config);
+                        }
+                    }
+                }
+            }
+        }
+        else if (configs === undefined) {
+            /* If the instance container does not exist and no configurations are provided, create a new instance container */
+            this.addInstanceContainer(target);
+        }
+    }
+    /**
+     * Adds a property configuration to the instance container.
+     * @param target The target.
+     * @param properties The properties.
+     * @param config The configuration.
+     */
+    addPropConfig(target, properties, config) {
+        /* Iterates through the provided properties and applies configurations based on the provided config object */
+        for (var propertyInfo of properties) {
+            let excludeProp = false;
+            /* Check if excludePropNames exist in the config */
+            if (config.excludePropNames) {
+                /* Check if the current property should be excluded based on its name */
+                excludeProp = config.excludePropNames.find(t => t == propertyInfo.name) !== undefined;
+            }
+            /* If the property should not be excluded */
+            if (!excludeProp) {
+                /* Apply validation configurations */
+                if (config.validationConfig) {
+                    /* Iterate through the validation configurations */
+                    for (let typeName in config.validationConfig) {
+                        /* Initialize validation for the property */
+                        this.init({ constructor: target }, 0, propertyInfo.name, typeName, config.validationConfig[typeName] === true ? undefined : config.validationConfig[typeName], false);
+                    }
+                }
+                /* Apply error decorator configuration */
+                if (config.error) {
+                    this.addDecoratorConfig({ constructor: target }, 0, propertyInfo.name, config.error, DECORATORS.error);
+                }
+                /* Apply disable decorator configuration */
+                if (config.disable) {
+                    this.addDecoratorConfig({ constructor: target }, 0, propertyInfo.name, config.disable, DECORATORS.disabled);
+                }
+                /* Apply elementClass decorator configuration */
+                if (config.elementClass) {
+                    this.addDecoratorConfig({ constructor: target }, 0, propertyInfo.name, config.elementClass, DECORATORS.elementClass);
+                }
+                /* Apply ignore configuration */
+                if (config.ignore) {
+                    propertyInfo.ignore = config.ignore;
+                }
+            }
+        }
+    }
+    /**
+     * 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, parameterIndex, propertyKey, decoratorType, value) {
+        /* Retrieves the instance container based on the provided parameters and adds a sanitizer configuration to it */
+        let instance = this.getInstance(target, parameterIndex, propertyKey, decoratorType);
+        if (instance) {
+            /* Check if the sanitizers object for the property exists */
+            if (!instance.sanitizers[propertyKey]) {
+                instance.sanitizers[propertyKey] = [];
+            }
+            /* Push the sanitizer configuration to the sanitizers object */
+            instance.sanitizers[propertyKey].push({ name: decoratorType, config: value });
+        }
+    }
+    /**
+     * 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, parameterIndex, propertyKey, config, decoratorType) {
+        /* Determine if the property key is defined */
+        let isPropertyKey = (propertyKey != undefined);
+        /* Determine the function or constructor to be used as instanceFunc */
+        let instanceFunc = !isPropertyKey ? target : target.constructor;
+        /* Find the instance container based on instanceFunc */
+        let instance = this.instances.find(instance => instance.instance === instanceFunc);
+        /* If the instance container doesn't exist, create a new one */
+        if (!instance) {
+            instance = this.addInstanceContainer(instanceFunc);
+        }
+        /* Add conditional expressions to the non-validation decorators of the instance container */
+        (instance?.nonValidationDecorators)[decoratorType].conditionalExpressions[propertyKey] = config.conditionalExpression;
+        /* Extract columns from the conditional expression */
+        let columns = Linq.expressionColumns(config.conditionalExpression, true);
+        /* Iterate over each column */
+        columns.forEach(column => {
+            if (column.argumentIndex !== -1) {
+                /* Construct the column name based on whether objectPropName is defined */
+                let columnName = (!column.objectPropName) ? `${column.propName}${RXCODE}${column.argumentIndex}` : `${column.objectPropName}.${column.propName}${RXCODE}${column.argumentIndex}`;
+                /* Check if the column exists in changeDetection and initialize it if necessary */
+                if (!(instance?.nonValidationDecorators)[decoratorType].changeDetection[columnName]) {
+                    (instance?.nonValidationDecorators)[decoratorType].changeDetection[columnName] = [];
+                }
+                /* Add the property key to the changeDetection column */
+                let disabledColumns = (instance?.nonValidationDecorators)[decoratorType].changeDetection[columnName];
+                if (disabledColumns.indexOf(columnName) === -1) {
+                    disabledColumns.push(propertyKey);
+                }
+            }
+            else {
+                /* Handle the controlProp if argumentIndex is -1 */
+                if (!(instance?.nonValidationDecorators)[decoratorType].controlProp[propertyKey]) {
+                    (instance?.nonValidationDecorators)[decoratorType].controlProp[propertyKey] = {};
+                }
+                /* Set the column name to true in controlProp */
+                (instance?.nonValidationDecorators)[decoratorType].controlProp[propertyKey][column.propName.replace(";", "")] = true;
+            }
+        });
+    }
+    /**
+     * 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, parameterIndex, propertyKey, annotationType, config, isAsync) {
+        /* Define the decorator configuration */
+        var decoratorConfiguration = {
+            propertyIndex: parameterIndex,
+            propertyName: propertyKey,
+            annotationType: annotationType,
+            config: config,
+            isAsync: isAsync,
+            isValidator: annotationType !== "updateOn"
+        };
+        /* Determine if the property key is defined */
+        let isPropertyKey = (propertyKey != undefined);
+        /* Determine the function or constructor to be used as instanceFunc */
+        this.addAnnotation(!isPropertyKey ? target : target.constructor, decoratorConfiguration);
+    }
+    /**
+     * 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, propertyType, entity, target, config) {
+        /* Define the property information */
+        var propertyInfo = {
+            name: name,
+            propertyType: propertyType,
+            entity: entity,
+            dataPropertyName: config ? config.name : undefined,
+            entityProvider: config ? config.entityProvider : undefined
+        };
+        /* Add the property to the target's constructor */
+        this.addProperty(target.constructor, propertyInfo);
+    }
+    /**
+     * Adds an instance container to the list of instances.
+     * @param instanceFunc The instance function.
+     * @returns The added instance container.
+     */
+    addInstanceContainer(instanceFunc) {
+        /* Define an instance container */
+        let instanceContainer = {
+            instance: instanceFunc,
+            propertyAnnotations: [],
+            properties: [],
+            nonValidationDecorators: {
+                /* Disabled decorators */
+                disabled: {
+                    conditionalExpressions: {},
+                    changeDetection: {},
+                    controlProp: {} /* Control properties for disabled decorators */
+                },
+                /* Error decorators */
+                error: {
+                    conditionalExpressions: {},
+                    changeDetection: {},
+                    controlProp: {} /* Control properties for error decorators */
+                },
+                /* Element class decorators */
+                elementClass: {
+                    conditionalExpressions: {},
+                    changeDetection: {},
+                    controlProp: {} /* Control properties for element class decorators */
+                }
+            },
+            /* Sanitizers associated with the instance */
+            sanitizers: {}
+        };
+        /* Add the instance container to the instances array */
+        this.instances.push(instanceContainer);
+        /* Return the created instance container */
+        return 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, propertyInfo, isFromAnnotation = false) {
+        /* Find the instance in the instances array */
+        let instance = this.instances.find(instance => instance.instance === instanceFunc);
+        /* Check if the instance exists */
+        if (instance) {
+            /* Add property information to the existing instance */
+            this.addPropertyInfo(instance, propertyInfo, !isFromAnnotation);
+        }
+        else {
+            /* Create a new instance container if it doesn't exist */
+            instance = this.addInstanceContainer(instanceFunc);
+            /* Add property information to the newly created instance */
+            this.addPropertyInfo(instance, propertyInfo);
+        }
+    }
+    /**
+     * 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, propertyInfo, isAddProperty = false) {
+        /* Find the property with the same name in the instance's properties */
+        var property = instance.properties?.find(t => t.name == propertyInfo.name);
+        /* Check if the property doesn't already exist */
+        if (!property) {
+            /* Add the property information to the instance's properties */
+            instance.properties?.push(propertyInfo);
+        }
+        else if (isAddProperty) {
+            /* Update property information if requested */
+            property.dataPropertyName = propertyInfo.dataPropertyName;
+            property.defaultValue = propertyInfo.defaultValue;
+        }
+    }
+    /**
+     * Adds an annotation to the instance container.
+     * @param instanceFunc The instance function.
+     * @param decoratorConfiguration The decorator configuration.
+     */
+    addAnnotation(instanceFunc, decoratorConfiguration) {
+        /* Add property information to the instance */
+        this.addProperty(instanceFunc, { propertyType: PROPERTY, name: decoratorConfiguration.propertyName }, true);
+        /* Find or create the instance in the instances array */
+        let instance = this.instances.find(instance => instance.instance === instanceFunc);
+        if (instance) {
+            /* Add the decorator configuration to the instance's property annotations */
+            instance.propertyAnnotations.push(decoratorConfiguration);
+        }
+        else {
+            instance = this.addInstanceContainer(instanceFunc);
+            instance.propertyAnnotations.push(decoratorConfiguration);
+        }
+        /* Add change validation based on the provided configuration */
+        if (decoratorConfiguration.config && decoratorConfiguration.config.conditionalExpression) {
+            let columns = Linq.expressionColumns(decoratorConfiguration.config.conditionalExpression);
+            this.addChangeValidation(instance, decoratorConfiguration.propertyName, columns);
+        }
+        /* Add dynamic configuration and validation */
+        if (decoratorConfiguration.config && decoratorConfiguration.config.dynamicConfig) {
+            let columns = Linq.dynamicConfigParser(decoratorConfiguration.config.dynamicConfig, decoratorConfiguration.propertyName);
+            this.addChangeValidation(instance, decoratorConfiguration.propertyName, columns);
+        }
+        /* Set conditional columns based on the decorator configuration */
+        this.setConditionalColumns(instance, decoratorConfiguration);
+    }
+    /**
+     * Sets conditional columns based on the decorator configuration.
+     * @param instance The instance container.
+     * @param decoratorConfiguration The decorator configuration.
+     */
+    setConditionalColumns(instance, decoratorConfiguration) {
+        /* Checks if there is an instance and decorator configuration present */
+        if (instance && decoratorConfiguration.config) {
+            /* Handles logical annotations (AND, OR, NOT) */
+            if (decoratorConfiguration.annotationType == AnnotationTypes.and ||
+                decoratorConfiguration.annotationType == AnnotationTypes.or ||
+                decoratorConfiguration.annotationType == AnnotationTypes.not) {
+                /* Iterates over validation configurations */
+                Object.keys(decoratorConfiguration.config.validation).forEach(t => {
+                    /* Checks if the validation configuration is not a boolean */
+                    if (typeof decoratorConfiguration.config.validation[t] !== "boolean") {
+                        /* Sets logical conditional based on the validation configuration */
+                        this.setLogicalConditional(instance, t, decoratorConfiguration.config.validation[t].fieldName, decoratorConfiguration.propertyName);
+                    }
+                });
+            }
+            else {
+                /* Sets logical conditional for non-logical annotations */
+                this.setLogicalConditional(instance, decoratorConfiguration.annotationType, decoratorConfiguration.config.fieldName, decoratorConfiguration.propertyName);
+            }
+        }
+    }
+    /**
+     * 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, annotationType, fieldName, propertyName) {
+        /*
+         * Checks if there is an instance and annotation type with applicable conditions
+         * for setting conditional value properties.
+         */
+        if (instance && ((annotationType == AnnotationTypes.compare ||
+            annotationType == AnnotationTypes.greaterThan ||
+            annotationType == AnnotationTypes.greaterThanEqualTo ||
+            annotationType == AnnotationTypes.lessThan ||
+            annotationType == AnnotationTypes.lessThanEqualTo ||
+            annotationType == AnnotationTypes.different ||
+            annotationType == AnnotationTypes.factor ||
+            annotationType == AnnotationTypes.minTime ||
+            annotationType == AnnotationTypes.maxTime) ||
+            (annotationType == AnnotationTypes.creditCard && fieldName) ||
+            ((annotationType == AnnotationTypes.minDate || annotationType == AnnotationTypes.maxDate) && fieldName))) {
+            /* Sets conditional value property based on the conditions */
+            this.setConditionalValueProp(instance, fieldName, propertyName);
+        }
+    }
+    /**
+     * 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, propertyName, refPropertyName) {
+        /* Checks if propName exists */
+        if (propertyName) {
+            /* Splits propName into individual properties */
+            let splitProps = propertyName.split ? propertyName.split('.') : '';
+            /* Checks if the length of splitProps is less than 2 */
+            if (splitProps.length < 2) {
+                /* Initializes conditionalValidationProps if it does not exist */
+                if (!instance.conditionalValidationProps) {
+                    instance.conditionalValidationProps = {};
+                }
+                /* Initializes conditionalValidationProps[propName] if it does not exist */
+                if (!instance.conditionalValidationProps[propertyName]) {
+                    instance.conditionalValidationProps[propertyName] = [];
+                }
+                /* Pushes refPropName into conditionalValidationProps[propName] if it does not exist */
+                if (instance.conditionalValidationProps[propertyName].indexOf(refPropertyName) == -1) {
+                    instance.conditionalValidationProps[propertyName].push(refPropertyName);
+                }
+            }
+            else {
+                /* Adds change validation for complex properties */
+                this.addChangeValidation(instance, refPropertyName, [{ argumentIndex: 1, objectPropName: splitProps[0], propName: splitProps[1], referencePropName: refPropertyName }]);
+            }
+        }
+    }
+    /**
+     * Adds change validation based on the columns.
+     * @param instance The instance container.
+     * @param propertyName The property name.
+     * @param columns The columns.
+     */
+    addChangeValidation(instance, propertyName, columns) {
+        /* Checks if instance exists. */
+        if (instance) {
+            /* Initializes conditionalValidationProps if it does not exist. */
+            if (!instance.conditionalValidationProps) {
+                instance.conditionalValidationProps = {};
+            }
+            /* Iterates through columns. */
+            columns.forEach(t => {
+                /* Checks if propName exists and objectPropName does not exist. */
+                if (t.propName && !t.objectPropName) {
+                    /* Initializes conditionalValidationProps[t.propName] if it does not exist. */
+                    if (!instance.conditionalValidationProps[t.propName]) {
+                        instance.conditionalValidationProps[t.propName] = [];
+                    }
+                    /* Pushes propertyName into conditionalValidationProps[t.propName] if it does not exist. */
+                    if (instance.conditionalValidationProps[t.propName].indexOf(propertyName) == -1) {
+                        instance.conditionalValidationProps[t.propName].push(propertyName);
+                    }
+                }
+                else {
+                    /* Checks if propName and objectPropName exist. */
+                    if (t.propName && t.objectPropName) {
+                        /* Initializes conditionalObjectProps if it does not exist. */
+                        if (!instance.conditionalObjectProps) {
+                            instance.conditionalObjectProps = [];
+                        }
+                        /* Sets referencePropName and adds it to conditionalObjectProps. */
+                        t.referencePropName = propertyName;
+                        instance.conditionalObjectProps.push(t);
+                    }
+                }
+            });
+        }
+    }
+}
+/**
+ * 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 const defaultContainer = new DefaultContainer();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default-container.js","sourceRoot":"","sources":["../../../../../../projects/cdk/src/lib/form-validators/core/default-container.ts"],"names":[],"mappings":"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","sourcesContent":["import { ARRAY_PROPERTY, OBJECT_PROPERTY, PROPERTY, RXCODE } from \"../const\";\r\nimport { DECORATORS } from \"../const/decorators.const\";\r\nimport { PropsConfig } from \"../models/config/props-config\";\r\nimport { DecoratorConfiguration } from \"../models/decorator-configuration\";\r\nimport { InstanceContainer } from \"../models/instance-container\";\r\nimport { PropertyInfo } from \"../models/property-info\";\r\nimport { Linq } from \"../util/linq\";\r\nimport { AnnotationTypes } from \"./annotation-types\";\r\n\r\n/**\r\n * Represents a default container for managing instance configurations.\r\n * \r\n * Manages the configuration and instantiation of validation decorators, sanitizers, and other properties for classes.\r\n * This class serves as a container for managing instance-related configurations and properties.\r\n */\r\nexport class DefaultContainer {\r\n    /**\r\n  * Represents whether the container is operating in experimental mode.\r\n  * Experimental mode may introduce features that are still under development or testing.\r\n  */\r\n    public isExperimental: boolean = false;\r\n\r\n    /**\r\n     * Array containing instances and their configurations.\r\n     * Each element represents an instance of the application with associated properties and decorators.\r\n     */\r\n    private instances: InstanceContainer[] = [];\r\n\r\n    /**\r\n     * Counter used for generating unique identifiers for model instances.\r\n     * This counter is incremented each time a new model instance is added to the container.\r\n     */\r\n    public modelIncrementCount: number = 0;\r\n\r\n    /**\r\n     * Retrieves an instance container based on the provided instance function.\r\n     * @param instanceFunc The instance function.\r\n     * @returns The instance container.\r\n     */\r\n    public get<T>(instanceFunc: any): InstanceContainer {\r\n        return this.instances.filter(instance => instance.instance === instanceFunc)[0];\r\n    }\r\n\r\n    /**\r\n     * Retrieves or creates an instance container based on the provided parameters.\r\n     * @param target The target.\r\n     * @param parameterIndex The parameter index.\r\n     * @param propertyKey The property key.\r\n     * @param decoratorType The decorator type.\r\n     * @returns The instance container.\r\n     */\r\n    public getInstance(target: any, parameterIndex: any, propertyKey: string, decoratorType: string) {\r\n        /* Determine if the property key is defined */\r\n        let isPropertyKey = (propertyKey != undefined);\r\n\r\n        /* Get the instance function based on whether the property key is defined */\r\n        let instanceFunc = !isPropertyKey ? target : target.constructor;\r\n\r\n        /* Filter instances to find the one matching the instance function */\r\n        let instance = this.instances.filter(instance => instance.instance === instanceFunc)[0];\r\n\r\n        /* If no instance is found, create a new instance container */\r\n        if (!instance) {\r\n            instance = this.addInstanceContainer(instanceFunc);\r\n        }\r\n\r\n        /* Return the instance container */\r\n        return instance;\r\n    }\r\n\r\n    /**\r\n     * Adds property configurations to the instance container.\r\n     * @param target The target.\r\n     * @param configs The configurations.\r\n     */\r\n    public addPropsConfig(target: any, configs?: PropsConfig[]) {\r\n        /* Find the instance container associated with the target */\r\n        let instanceContainer = this.instances.find(instance => instance.instance === target);\r\n\r\n        /* Check if the instance container exists */\r\n        if (instanceContainer) {\r\n            /* Iterate through the provided configurations or an empty array if none are provided */\r\n            for (let config of configs ?? []) {\r\n                /* Iterate through the property names in the configuration */\r\n                for (let prop of config.propNames) {\r\n                    /* Find the property info in the instance container's properties */\r\n                    let propertyInfo = instanceContainer.properties?.find(t => t.name == prop && (t.propertyType !== OBJECT_PROPERTY && t.propertyType !== ARRAY_PROPERTY));\r\n\r\n                    /* If the property info exists, add property configuration */\r\n                    if (propertyInfo) {\r\n                        this.addPropConfig(target, [propertyInfo], config)\r\n                    } else {\r\n                        /* If the property name is ':all:', add property configuration for all properties */\r\n                        if (prop === \":all:\") {\r\n                            this.addPropConfig(target, instanceContainer.properties?.filter(t => t.propertyType !== OBJECT_PROPERTY && t.propertyType !== ARRAY_PROPERTY)!, config);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        } else if (configs === undefined) {\r\n            /* If the instance container does not exist and no configurations are provided, create a new instance container */\r\n            this.addInstanceContainer(target);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Adds a property configuration to the instance container.\r\n     * @param target The target.\r\n     * @param properties The properties.\r\n     * @param config The configuration.\r\n     */\r\n    public addPropConfig(target: any, properties: PropertyInfo[], config: PropsConfig) {\r\n        /* Iterates through the provided properties and applies configurations based on the provided config object */\r\n        for (var propertyInfo of properties) {\r\n            let excludeProp: boolean = false;\r\n\r\n            /* Check if excludePropNames exist in the config */\r\n            if (config.excludePropNames) {\r\n                /* Check if the current property should be excluded based on its name */\r\n                excludeProp = config.excludePropNames.find(t => t == propertyInfo.name) !== undefined;\r\n            }\r\n\r\n            /* If the property should not be excluded */\r\n            if (!excludeProp) {\r\n                /* Apply validation configurations */\r\n                if (config.validationConfig) {\r\n                    /* Iterate through the validation configurations */\r\n                    for (let typeName in config.validationConfig) {\r\n                        /* Initialize validation for the property */\r\n                        this.init({ constructor: target }, 0, propertyInfo.name, typeName, (config.validationConfig as any)[typeName] === true ? undefined : (config.validationConfig as any)[typeName], false);\r\n                    }\r\n                }\r\n\r\n                /* Apply error decorator configuration */\r\n                if (config.error) {\r\n                    this.addDecoratorConfig({ constructor: target }, 0, propertyInfo.name, config.error, DECORATORS.error)\r\n                }\r\n\r\n                /* Apply disable decorator configuration */\r\n                if (config.disable) {\r\n                    this.addDecoratorConfig({ constructor: target }, 0, propertyInfo.name, config.disable, DECORATORS.disabled)\r\n                }\r\n\r\n                /* Apply elementClass decorator configuration */\r\n                if (config.elementClass) {\r\n                    this.addDecoratorConfig({ constructor: target }, 0, propertyInfo.name, config.elementClass, DECORATORS.elementClass)\r\n                }\r\n\r\n                /* Apply ignore configuration */\r\n                if (config.ignore) {\r\n                    propertyInfo.ignore = config.ignore\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Adds a sanitizer to the instance container.\r\n     * @param target The target.\r\n     * @param parameterIndex The parameter index.\r\n     * @param propertyKey The property key.\r\n     * @param decoratorType The decorator type.\r\n     * @param value The value.\r\n     */\r\n    public addSanitizer(target: any, parameterIndex: any, propertyKey: string, decoratorType: string, value?: any) {\r\n        /* Retrieves the instance container based on the provided parameters and adds a sanitizer configuration to it */\r\n        let instance = this.getInstance(target, parameterIndex, propertyKey, decoratorType);\r\n        if (instance) {\r\n            /* Check if the sanitizers object for the property exists */\r\n            if (!(instance.sanitizers as any)[propertyKey]) {\r\n                (instance.sanitizers as any)[propertyKey] = [];\r\n            }\r\n\r\n            /* Push the sanitizer configuration to the sanitizers object */\r\n            (instance.sanitizers as any)[propertyKey].push({ name: decoratorType, config: value });\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Adds a decorator configuration to the instance container.\r\n     * @param target The target.\r\n     * @param parameterIndex The parameter index.\r\n     * @param propertyKey The property key.\r\n     * @param config The configuration.\r\n     * @param decoratorType The decorator type.\r\n     */\r\n    public addDecoratorConfig(target: any, parameterIndex: any, propertyKey: string, config: any, decoratorType: string): void {\r\n        /* Determine if the property key is defined */\r\n        let isPropertyKey = (propertyKey != undefined);\r\n\r\n        /* Determine the function or constructor to be used as instanceFunc */\r\n        let instanceFunc = !isPropertyKey ? target : target.constructor;\r\n\r\n        /* Find the instance container based on instanceFunc */\r\n        let instance = this.instances.find(instance => instance.instance === instanceFunc);\r\n\r\n        /* If the instance container doesn't exist, create a new one */\r\n        if (!instance) {\r\n            instance = this.addInstanceContainer(instanceFunc);\r\n        }\r\n\r\n        /* Add conditional expressions to the non-validation decorators of the instance container */\r\n        (instance?.nonValidationDecorators as any)[decoratorType].conditionalExpressions[propertyKey] = config.conditionalExpression;\r\n\r\n        /* Extract columns from the conditional expression */\r\n        let columns = Linq.expressionColumns(config.conditionalExpression, true);\r\n\r\n        /* Iterate over each column */\r\n        columns.forEach(column => {\r\n            if (column.argumentIndex !== -1) {\r\n                /* Construct the column name based on whether objectPropName is defined */\r\n                let columnName = (!column.objectPropName) ? `${column.propName}${RXCODE}${column.argumentIndex}` : `${column.objectPropName}.${column.propName}${RXCODE}${column.argumentIndex}`;\r\n\r\n                /* Check if the column exists in changeDetection and initialize it if necessary */\r\n                if (!(instance?.nonValidationDecorators as any)[decoratorType].changeDetection[columnName]) {\r\n                    (instance?.nonValidationDecorators as any)[decoratorType].changeDetection[columnName] = [];\r\n                }\r\n\r\n                /* Add the property key to the changeDetection column */\r\n                let disabledColumns = (instance?.nonValidationDecorators as any)[decoratorType].changeDetection[columnName];\r\n                if (disabledColumns.indexOf(columnName) === -1) {\r\n                    disabledColumns.push(propertyKey);\r\n                }\r\n            } else {\r\n                /* Handle the controlProp if argumentIndex is -1 */\r\n                if (!(instance?.nonValidationDecorators as any)[decoratorType].controlProp[propertyKey]) {\r\n                    (instance?.nonValidationDecorators as any)[decoratorType].controlProp[propertyKey] = {};\r\n                }\r\n\r\n                /* Set the column name to true in controlProp */\r\n                (instance?.nonValidationDecorators as any)[decoratorType].controlProp[propertyKey][column.propName.replace(\";\", \"\")] = true;\r\n            }\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Initializes a decorator configuration.\r\n     * @param target The target.\r\n     * @param parameterIndex The parameter index.\r\n     * @param propertyKey The property key.\r\n     * @param annotationType The annotation type.\r\n     * @param config The configuration.\r\n     * @param isAsync Indicates whether it's an asynchronous operation.\r\n     */\r\n    public init(target: any, parameterIndex: any, propertyKey: string, annotationType: string, config: any, isAsync: boolean): void {\r\n        /* Define the decorator configuration */\r\n        var decoratorConfiguration: DecoratorConfiguration = {\r\n            propertyIndex: parameterIndex,\r\n            propertyName: propertyKey,\r\n            annotationType: annotationType,\r\n            config: config,\r\n            isAsync: isAsync,\r\n            isValidator: annotationType !== \"updateOn\"\r\n        }\r\n\r\n        /* Determine if the property key is defined */\r\n        let isPropertyKey = (propertyKey != undefined);\r\n\r\n        /* Determine the function or constructor to be used as instanceFunc */\r\n        this.addAnnotation(!isPropertyKey ? target : target.constructor, decoratorConfiguration);\r\n    }\r\n\r\n    /**\r\n     * Initializes a property object.\r\n     * @param name The name.\r\n     * @param propertyType The property type.\r\n     * @param entity The entity.\r\n     * @param target The target.\r\n     * @param config The configuration.\r\n     */\r\n    public initPropertyObject(name: string, propertyType: string, entity: any, target: any, config?: any) {\r\n        /* Define the property information */\r\n        var propertyInfo: PropertyInfo = {\r\n            name: name,\r\n            propertyType: propertyType,\r\n            entity: entity,\r\n            dataPropertyName: config ? config.name : undefined,\r\n            entityProvider: config ? config.entityProvider : undefined\r\n        }\r\n\r\n        /* Add the property to the target's constructor */\r\n        this.addProperty(target.constructor, propertyInfo);\r\n    }\r\n\r\n    /**\r\n     * Adds an instance container to the list of instances.\r\n     * @param instanceFunc The instance function.\r\n     * @returns The added instance container.\r\n     */\r\n    public addInstanceContainer(instanceFunc: any): InstanceContainer {\r\n        /* Define an instance container */\r\n        let instanceContainer: InstanceContainer = {\r\n            instance: instanceFunc,     /* Instance associated with the container */\r\n            propertyAnnotations: [],    /* Annotations for the properties */\r\n            properties: [],             /* Properties associated with the instance */\r\n            nonValidationDecorators: {\r\n                /* Disabled decorators */\r\n                disabled: {\r\n                    conditionalExpressions: {}, /* Conditional expressions for disabled decorators */\r\n                    changeDetection: {},        /* Change detection for disabled decorators */\r\n                    controlProp: {}             /* Control properties for disabled decorators */\r\n                },\r\n\r\n                /* Error decorators */\r\n                error: {\r\n                    conditionalExpressions: {}, /* Conditional expressions for error decorators */\r\n                    changeDetection: {},        /* Change detection for error decorators */\r\n                    controlProp: {}             /* Control properties for error decorators */\r\n                },\r\n\r\n                /* Element class decorators */\r\n                elementClass: {\r\n                    conditionalExpressions: {}, /* Conditional expressions for element class decorators */\r\n                    changeDetection: {},        /* Change detection for element class decorators */\r\n                    controlProp: {}             /* Control properties for element class decorators */\r\n                }\r\n            },\r\n\r\n            /* Sanitizers associated with the instance */\r\n            sanitizers: {}\r\n        };\r\n\r\n        /* Add the instance container to the instances array */\r\n        this.instances.push(instanceContainer);\r\n\r\n        /* Return the created instance container */\r\n        return instanceContainer;\r\n    }\r\n\r\n    /**\r\n     * Adds a property to the instance container.\r\n     * @param instanceFunc The instance function.\r\n     * @param propertyInfo The property information.\r\n     * @param isFromAnnotation Indicates whether it's added from an annotation.\r\n     */\r\n    public addProperty(instanceFunc: any, propertyInfo: PropertyInfo, isFromAnnotation: boolean = false): void {\r\n        /* Find the instance in the instances array */\r\n        let instance = this.instances.find(instance => instance.instance === instanceFunc);\r\n\r\n        /* Check if the instance exists */\r\n        if (instance) {\r\n            /* Add property information to the existing instance */\r\n            this.addPropertyInfo(instance, propertyInfo, !isFromAnnotation);\r\n        } else {\r\n            /* Create a new instance container if it doesn't exist */\r\n            instance = this.addInstanceContainer(instanceFunc);\r\n\r\n            /* Add property information to the newly created instance */\r\n            this.addPropertyInfo(instance, propertyInfo);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Adds property information to the instance container.\r\n     * @param instance The instance container.\r\n     * @param propertyInfo The property information.\r\n     * @param isAddProperty Indicates whether it's added as a new property.\r\n     */\r\n    public addPropertyInfo(instance: InstanceContainer, propertyInfo: PropertyInfo, isAddProperty: boolean = false) {\r\n        /* Find the property with the same name in the instance's properties */\r\n        var property = instance.properties?.find(t => t.name == propertyInfo.name);\r\n\r\n        /* Check if the property doesn't already exist */\r\n        if (!property) {\r\n            /* Add the property information to the instance's properties */\r\n            instance.properties?.push(propertyInfo);\r\n        } else if (isAddProperty) {\r\n            /* Update property information if requested */\r\n            property.dataPropertyName = propertyInfo.dataPropertyName;\r\n            property.defaultValue = propertyInfo.defaultValue;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Adds an annotation to the instance container.\r\n     * @param instanceFunc The instance function.\r\n     * @param decoratorConfiguration The decorator configuration.\r\n     */\r\n    public addAnnotation(instanceFunc: any, decoratorConfiguration: DecoratorConfiguration): void {\r\n        /* Add property information to the instance */\r\n        this.addProperty(instanceFunc, { propertyType: PROPERTY, name: decoratorConfiguration.propertyName }, true);\r\n\r\n        /* Find or create the instance in the instances array */\r\n        let instance = this.instances.find(instance => instance.instance === instanceFunc);\r\n        if (instance) {\r\n            /* Add the decorator configuration to the instance's property annotations */\r\n            instance.propertyAnnotations.push(decoratorConfiguration);\r\n        } else {\r\n            instance = this.addInstanceContainer(instanceFunc);\r\n            instance.propertyAnnotations.push(decoratorConfiguration);\r\n        }\r\n\r\n        /* Add change validation based on the provided configuration */\r\n        if (decoratorConfiguration.config && decoratorConfiguration.config.conditionalExpression) {\r\n            let columns = Linq.expressionColumns(decoratorConfiguration.config.conditionalExpression);\r\n            this.addChangeValidation(instance, decoratorConfiguration.propertyName, columns);\r\n        }\r\n\r\n        /* Add dynamic configuration and validation */\r\n        if (decoratorConfiguration.config && decoratorConfiguration.config.dynamicConfig) {\r\n            let columns = Linq.dynamicConfigParser(decoratorConfiguration.config.dynamicConfig, decoratorConfiguration.propertyName);\r\n            this.addChangeValidation(instance, decoratorConfiguration.propertyName, columns);\r\n        }\r\n\r\n        /* Set conditional columns based on the decorator configuration */\r\n        this.setConditionalColumns(instance, decoratorConfiguration);\r\n    }\r\n\r\n    /**\r\n     * Sets conditional columns based on the decorator configuration.\r\n     * @param instance The instance container.\r\n     * @param decoratorConfiguration The decorator configuration.\r\n     */\r\n    public setConditionalColumns(instance: any, decoratorConfiguration: DecoratorConfiguration) {\r\n        /* Checks if there is an instance and decorator configuration present */\r\n        if (instance && decoratorConfiguration.config) {\r\n            /* Handles logical annotations (AND, OR, NOT) */\r\n            if (decoratorConfiguration.annotationType == AnnotationTypes.and ||\r\n                decoratorConfiguration.annotationType == AnnotationTypes.or ||\r\n                decoratorConfiguration.annotationType == AnnotationTypes.not\r\n            ) {\r\n                /* Iterates over validation configurations */\r\n                Object.keys(decoratorConfiguration.config.validation).forEach(t => {\r\n                    /* Checks if the validation configuration is not a boolean */\r\n                    if (typeof decoratorConfiguration.config.validation[t] !== \"boolean\") {\r\n                        /* Sets logical conditional based on the validation configuration */\r\n                        this.setLogicalConditional(instance, t, decoratorConfiguration.config.validation[t].fieldName, decoratorConfiguration.propertyName)\r\n                    }\r\n                });\r\n            } else {\r\n                /* Sets logical conditional for non-logical annotations */\r\n                this.setLogicalConditional(instance, decoratorConfiguration.annotationType, decoratorConfiguration.config.fieldName, decoratorConfiguration.propertyName);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Sets logical conditionals based on the decorator configuration.\r\n     * @param instance The instance container.\r\n     * @param annotationType The annotation type.\r\n     * @param fieldName The field name.\r\n     * @param propertyName The property name.\r\n     */\r\n    public setLogicalConditional(instance: any, annotationType: string, fieldName: string, propertyName: string) {\r\n        /* \r\n         * Checks if there is an instance and annotation type with applicable conditions\r\n         * for setting conditional value properties.\r\n         */\r\n        if (instance && (\r\n            (annotationType == AnnotationTypes.compare ||\r\n                annotationType == AnnotationTypes.greaterThan ||\r\n                annotationType == AnnotationTypes.greaterThanEqualTo ||\r\n                annotationType == AnnotationTypes.lessThan ||\r\n                annotationType == AnnotationTypes.lessThanEqualTo ||\r\n                annotationType == AnnotationTypes.different ||\r\n                annotationType == AnnotationTypes.factor ||\r\n                annotationType == AnnotationTypes.minTime ||\r\n                annotationType == AnnotationTypes.maxTime) ||\r\n            (annotationType == AnnotationTypes.creditCard && fieldName) ||\r\n            ((annotationType == AnnotationTypes.minDate || annotationType == AnnotationTypes.maxDate) && fieldName)\r\n        )) {\r\n            /* Sets conditional value property based on the conditions */\r\n            this.setConditionalValueProp(instance, fieldName, propertyName);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Sets conditional value properties based on the decorator configuration.\r\n     * @param instance The instance container.\r\n     * @param propertyName The property name.\r\n     * @param refPropertyName The reference property name.\r\n     */\r\n    public setConditionalValueProp(instance: InstanceContainer, propertyName: string, refPropertyName: string) {\r\n        /* Checks if propName exists */\r\n        if (propertyName) {\r\n            /* Splits propName into individual properties */\r\n            let splitProps = propertyName.split ? propertyName.split('.') : '';\r\n\r\n            /* Checks if the length of splitProps is less than 2 */\r\n            if (splitProps.length < 2) {\r\n                /* Initializes conditionalValidationProps if it does not exist */\r\n                if (!instance.conditionalValidationProps) {\r\n                    instance.conditionalValidationProps = {};\r\n                }\r\n\r\n                /* Initializes conditionalValidationProps[propName] if it does not exist */\r\n                if (!instance.conditionalValidationProps[propertyName]) {\r\n                    instance.conditionalValidationProps[propertyName] = [];\r\n                }\r\n\r\n                /* Pushes refPropName into conditionalValidationProps[propName] if it does not exist */\r\n                if (instance.conditionalValidationProps[propertyName].indexOf(refPropertyName) == -1) {\r\n                    instance.conditionalValidationProps[propertyName].push(refPropertyName);\r\n                }\r\n            } else {\r\n                /* Adds change validation for complex properties */\r\n                this.addChangeValidation(instance, refPropertyName, [{ argumentIndex: 1, objectPropName: splitProps[0], propName: splitProps[1], referencePropName: refPropertyName }])\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Adds change validation based on the columns.\r\n     * @param instance The instance container.\r\n     * @param propertyName The property name.\r\n     * @param columns The columns.\r\n     */\r\n    public addChangeValidation(instance: InstanceContainer, propertyName: string, columns: any[]): void {\r\n        /* Checks if instance exists. */\r\n        if (instance) {\r\n            /* Initializes conditionalValidationProps if it does not exist. */\r\n            if (!instance.conditionalValidationProps) {\r\n                instance.conditionalValidationProps = {};\r\n            }\r\n\r\n            /* Iterates through columns. */\r\n            columns.forEach(t => {\r\n                /* Checks if propName exists and objectPropName does not exist. */\r\n                if (t.propName && !t.objectPropName) {\r\n                    /* Initializes conditionalValidationProps[t.propName] if it does not exist. */\r\n                    if (!(instance.conditionalValidationProps as any)[t.propName]) {\r\n                        (instance.conditionalValidationProps as any)[t.propName] = [];\r\n                    }\r\n\r\n                    /* Pushes propertyName into conditionalValidationProps[t.propName] if it does not exist. */\r\n                    if ((instance.conditionalValidationProps as any)[t.propName].indexOf(propertyName) == -1) {\r\n                        (instance.conditionalValidationProps as any)[t.propName].push(propertyName);\r\n                    }\r\n                } else {\r\n                    /* Checks if propName and objectPropName exist. */\r\n                    if (t.propName && t.objectPropName) {\r\n                        /* Initializes conditionalObjectProps if it does not exist. */\r\n                        if (!instance.conditionalObjectProps) {\r\n                            instance.conditionalObjectProps = [];\r\n                        }\r\n\r\n                        /* Sets referencePropName and adds it to conditionalObjectProps. */\r\n                        t.referencePropName = propertyName;\r\n                        instance.conditionalObjectProps.push(t);\r\n                    }\r\n                }\r\n            });\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Represents a default container for managing instance configurations.\r\n * \r\n * Manages the configuration and instantiation of validation decorators, sanitizers, and other properties for classes.\r\n * This class serves as a container for managing instance-related configurations and properties.\r\n */\r\nexport const defaultContainer = new DefaultContainer();"]}

package/esm2022/lib/form-validators/decorators/allOf.decorator.mjs

@@ -1,4 +1,4 @@
-import { AnnotationTypes } from '../core/validator.static';
+import { AnnotationTypes } from '../core/annotation-types';
 import { baseAsyncValidator } from "../reactive-form-validators/async/base.async.validator";
 import { baseDecoratorFunction } from "./base-decorator.function";
 export function allOf(config) {
@@ -7,4 +7,4 @@ export function allOf(config) {
 export function allOfAsync(config) {
     return baseDecoratorFunction(AnnotationTypes.allOf, [baseAsyncValidator(config, AnnotationTypes.allOf)], true);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsT2YuZGVjb3JhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2RrL3NyYy9saWIvZm9ybS12YWxpZGF0b3JzL2RlY29yYXRvcnMvYWxsT2YuZGVjb3JhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUUzRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3REFBd0QsQ0FBQztBQUM1RixPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUVsRSxNQUFNLFVBQVUsS0FBSyxDQUFDLE1BQW9CO0lBQ3RDLE9BQU8scUJBQXFCLENBQUMsZUFBZSxDQUFDLEtBQUssRUFBRSxNQUFNLENBQUMsQ0FBQztBQUNoRSxDQUFDO0FBRUQsTUFBTSxVQUFVLFVBQVUsQ0FBQyxNQUFvQjtJQUMzQyxPQUFPLHFCQUFxQixDQUFDLGVBQWUsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxrQkFBa0IsQ0FBQyxNQUFNLEVBQUUsZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsSUFBSSxDQUFDLENBQUM7QUFDbkgsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFubm90YXRpb25UeXBlcyB9IGZyb20gJy4uL2NvcmUvdmFsaWRhdG9yLnN0YXRpYyc7XHJcbmltcG9ydCB7IEFycmF5Q29uZmlnIH0gZnJvbSBcIi4uL21vZGVscy9jb25maWcvYXJyYXktY29uZmlnXCI7XHJcbmltcG9ydCB7IGJhc2VBc3luY1ZhbGlkYXRvciB9IGZyb20gXCIuLi9yZWFjdGl2ZS1mb3JtLXZhbGlkYXRvcnMvYXN5bmMvYmFzZS5hc3luYy52YWxpZGF0b3JcIjtcclxuaW1wb3J0IHsgYmFzZURlY29yYXRvckZ1bmN0aW9uIH0gZnJvbSBcIi4vYmFzZS1kZWNvcmF0b3IuZnVuY3Rpb25cIjtcclxuXHJcbmV4cG9ydCBmdW5jdGlvbiBhbGxPZihjb25maWc/OiBBcnJheUNvbmZpZykge1xyXG4gICAgcmV0dXJuIGJhc2VEZWNvcmF0b3JGdW5jdGlvbihBbm5vdGF0aW9uVHlwZXMuYWxsT2YsIGNvbmZpZyk7XHJcbn1cclxuXHJcbmV4cG9ydCBmdW5jdGlvbiBhbGxPZkFzeW5jKGNvbmZpZz86IEFycmF5Q29uZmlnKSB7XHJcbiAgICByZXR1cm4gYmFzZURlY29yYXRvckZ1bmN0aW9uKEFubm90YXRpb25UeXBlcy5hbGxPZiwgW2Jhc2VBc3luY1ZhbGlkYXRvcihjb25maWcsIEFubm90YXRpb25UeXBlcy5hbGxPZildLCB0cnVlKTtcclxufSJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsT2YuZGVjb3JhdG9yLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY2RrL3NyYy9saWIvZm9ybS12YWxpZGF0b3JzL2RlY29yYXRvcnMvYWxsT2YuZGVjb3JhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUUzRCxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3REFBd0QsQ0FBQztBQUM1RixPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUVsRSxNQUFNLFVBQVUsS0FBSyxDQUFDLE1BQW9CO0lBQ3RDLE9BQU8scUJBQXFCLENBQUMsZUFBZSxDQUFDLEtBQUssRUFBRSxNQUFNLENBQUMsQ0FBQztBQUNoRSxDQUFDO0FBRUQsTUFBTSxVQUFVLFVBQVUsQ0FBQyxNQUFvQjtJQUMzQyxPQUFPLHFCQUFxQixDQUFDLGVBQWUsQ0FBQyxLQUFLLEVBQUUsQ0FBQyxrQkFBa0IsQ0FBQyxNQUFNLEVBQUUsZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsSUFBSSxDQUFDLENBQUM7QUFDbkgsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFubm90YXRpb25UeXBlcyB9IGZyb20gJy4uL2NvcmUvYW5ub3RhdGlvbi10eXBlcyc7XHJcbmltcG9ydCB7IEFycmF5Q29uZmlnIH0gZnJvbSBcIi4uL21vZGVscy9jb25maWcvYXJyYXktY29uZmlnXCI7XHJcbmltcG9ydCB7IGJhc2VBc3luY1ZhbGlkYXRvciB9IGZyb20gXCIuLi9yZWFjdGl2ZS1mb3JtLXZhbGlkYXRvcnMvYXN5bmMvYmFzZS5hc3luYy52YWxpZGF0b3JcIjtcclxuaW1wb3J0IHsgYmFzZURlY29yYXRvckZ1bmN0aW9uIH0gZnJvbSBcIi4vYmFzZS1kZWNvcmF0b3IuZnVuY3Rpb25cIjtcclxuXHJcbmV4cG9ydCBmdW5jdGlvbiBhbGxPZihjb25maWc/OiBBcnJheUNvbmZpZykge1xyXG4gICAgcmV0dXJuIGJhc2VEZWNvcmF0b3JGdW5jdGlvbihBbm5vdGF0aW9uVHlwZXMuYWxsT2YsIGNvbmZpZyk7XHJcbn1cclxuXHJcbmV4cG9ydCBmdW5jdGlvbiBhbGxPZkFzeW5jKGNvbmZpZz86IEFycmF5Q29uZmlnKSB7XHJcbiAgICByZXR1cm4gYmFzZURlY29yYXRvckZ1bmN0aW9uKEFubm90YXRpb25UeXBlcy5hbGxPZiwgW2Jhc2VBc3luY1ZhbGlkYXRvcihjb25maWcsIEFubm90YXRpb25UeXBlcy5hbGxPZildLCB0cnVlKTtcclxufSJdfQ==