@olafvv/ngx-dynamic-form 0.0.2

package/esm2022/lib/services/dynamic-form-relations.service.mjs

@@ -0,0 +1,103 @@
+import { inject, Injectable, Injector } from '@angular/core';
+import { distinctUntilChanged, startWith } from 'rxjs';
+import { RELATION_ACTIONS, RelationOperator } from '../models/constants/dynamic-relations.const';
+import * as i0 from "@angular/core";
+export class DynamicFormRelationsService {
+    constructor() {
+        this._injector = inject(Injector);
+    }
+    /**
+     * Get an object with all FormField the provided model has a relation with
+     * @param model
+     * @param group
+     * @returns
+     */
+    findRelatedFormField(model, group) {
+        const conditionReducer = (controls, condition) => {
+            const control = group.get(condition.fieldName);
+            if (!control) {
+                console.warn(`No related form control with the name ${condition.fieldName} found`);
+                return controls;
+            }
+            controls[condition.fieldName] = control;
+            return controls;
+        };
+        const relationsReducer = (controls, relation) => {
+            return relation.conditions.reduce(conditionReducer, controls);
+        };
+        return model.relations.reduce(relationsReducer, {});
+    }
+    getRelationSubscriptions(relatedFormControls, model, control) {
+        const subs = [];
+        // Subscribe to value changes of all FormControls, provide the current value inside the startWith
+        Object.values(relatedFormControls).forEach((relatedControl) => {
+            subs.push(relatedControl.valueChanges.pipe(startWith(relatedControl.value), distinctUntilChanged()).subscribe(() => {
+                model.relations.forEach((relation) => {
+                    // Find the RelationAction object based on the actionType passed inside the DynamicFormConfig
+                    const action = RELATION_ACTIONS.find((action) => relation.actionType === action.type || relation.actionType === action.reversedType);
+                    if (action) {
+                        const shouldTrigger = this.checkRelationCondition(relation, relatedFormControls, action);
+                        action.change(shouldTrigger, model, control, this._injector);
+                    }
+                });
+            }));
+        });
+        return subs;
+    }
+    /**
+     * Check the conditions inside the relations
+     * @param relation
+     * @param relatedControl
+     * @param action
+     * @returns
+     */
+    checkRelationCondition(relation, relatedControls, action) {
+        // Default operator is AND, meaning all conditions should return true before the provided action is triggered.
+        // In the case of a reversed type, the return value whould be false.
+        const operator = relation.operator ?? RelationOperator.AND;
+        // Use a reducer to map all conditions to a single boolean value to decide if we want to trigger the provided action type
+        const reducer = (isMatch, condition, index) => {
+            // Find the FormControl of the related field
+            let relatedControl;
+            for (const [fieldName, control] of Object.entries(relatedControls)) {
+                if (fieldName === condition.fieldName) {
+                    relatedControl = control;
+                    break;
+                }
+            }
+            if (!relatedControl)
+                return false;
+            // Using the 'normal' type should return true when the condition matches
+            if (relation.actionType === action.type) {
+                // Shortcut to false when a previous condition check was resolved as false
+                if (index > 0 && operator === RelationOperator.AND && !isMatch)
+                    return false;
+                // Shortcut to true when a previous condition check was resolved as true
+                if (index > 0 && operator === RelationOperator.OR && isMatch)
+                    return true;
+                return condition.value(relatedControl.value);
+            }
+            // Using the reversed type should return false when the condition matches, because we want to the opposite of the configured change Function
+            if (relation.actionType === action.reversedType) {
+                // Shortcut to true when a previous condition check was resolved as true
+                if (index > 0 && operator === RelationOperator.AND && isMatch)
+                    return true;
+                // Shortcut to false when a previous condition check was resolved as false
+                if (index > 0 && operator === RelationOperator.OR && !isMatch)
+                    return false;
+                return !condition.value(relatedControl.value);
+            }
+            return false;
+        };
+        return relation.conditions.reduce(reducer, false);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicFormRelationsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicFormRelationsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicFormRelationsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-form-relations.service.js","sourceRoot":"","sources":["../../../../../projects/ngx-dynamic-form/src/lib/services/dynamic-form-relations.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { inject, Injectable, Injector } from '@angular/core';\nimport { FormControl, FormGroup, UntypedFormControl } from '@angular/forms';\nimport { distinctUntilChanged, startWith, Subscription } from 'rxjs';\nimport { DynamicFormFieldModel } from '../models/classes/dynamic-form-field-model';\nimport {\n  DynamicFormFieldRelation,\n  DynamicRelationAction,\n  RELATION_ACTIONS,\n  RelationCondition,\n  RelationOperator\n} from '../models/constants/dynamic-relations.const';\nimport { RelatedFormControls } from '../models/types/related-form-controls.type';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class DynamicFormRelationsService {\n  private _injector = inject(Injector);\n  /**\n   * Get an object with all FormField the provided model has a relation with\n   * @param model\n   * @param group\n   * @returns\n   */\n  public findRelatedFormField(model: DynamicFormFieldModel, group: FormGroup): RelatedFormControls {\n    const conditionReducer = (controls: RelatedFormControls, condition: RelationCondition) => {\n      const control = group.get(condition.fieldName) as UntypedFormControl;\n\n      if (!control) {\n        console.warn(`No related form control with the name ${condition.fieldName} found`);\n        return controls;\n      }\n\n      controls[condition.fieldName] = control;\n      return controls;\n    };\n\n    const relationsReducer = (controls: RelatedFormControls, relation: DynamicFormFieldRelation) => {\n      return relation.conditions.reduce(conditionReducer, controls);\n    };\n\n    return model.relations!.reduce(relationsReducer, {});\n  }\n\n  public getRelationSubscriptions(\n    relatedFormControls: RelatedFormControls,\n    model: DynamicFormFieldModel,\n    control: FormControl\n  ): Subscription[] {\n    const subs: Subscription[] = [];\n\n    // Subscribe to value changes of all FormControls, provide the current value inside the startWith\n    Object.values(relatedFormControls).forEach((relatedControl) => {\n      subs.push(\n        relatedControl.valueChanges.pipe(startWith(relatedControl.value), distinctUntilChanged()).subscribe(() => {\n          model.relations!.forEach((relation) => {\n            // Find the RelationAction object based on the actionType passed inside the DynamicFormConfig\n            const action = RELATION_ACTIONS.find(\n              (action) => relation.actionType === action.type || relation.actionType === action.reversedType\n            );\n\n            if (action) {\n              const shouldTrigger = this.checkRelationCondition(relation, relatedFormControls, action);\n\n              action.change(shouldTrigger, model, control, this._injector);\n            }\n          });\n        })\n      );\n    });\n\n    return subs;\n  }\n\n  /**\n   * Check the conditions inside the relations\n   * @param relation\n   * @param relatedControl\n   * @param action\n   * @returns\n   */\n  private checkRelationCondition(\n    relation: DynamicFormFieldRelation,\n    relatedControls: RelatedFormControls,\n    action: DynamicRelationAction\n  ): boolean {\n    // Default operator is AND, meaning all conditions should return true before the provided action is triggered.\n    // In the case of a reversed type, the return value whould be false.\n    const operator = relation.operator ?? RelationOperator.AND;\n\n    // Use a reducer to map all conditions to a single boolean value to decide if we want to trigger the provided action type\n    const reducer = (isMatch: boolean, condition: RelationCondition, index: number): boolean => {\n      // Find the FormControl of the related field\n      let relatedControl: UntypedFormControl | undefined;\n\n      for (const [fieldName, control] of Object.entries(relatedControls)) {\n        if (fieldName === condition.fieldName) {\n          relatedControl = control;\n          break;\n        }\n      }\n\n      if (!relatedControl) return false;\n\n      // Using the 'normal' type should return true when the condition matches\n      if (relation.actionType === action.type) {\n        // Shortcut to false when a previous condition check was resolved as false\n        if (index > 0 && operator === RelationOperator.AND && !isMatch) return false;\n\n        // Shortcut to true when a previous condition check was resolved as true\n        if (index > 0 && operator === RelationOperator.OR && isMatch) return true;\n\n        return condition.value(relatedControl.value);\n      }\n\n      // Using the reversed type should return false when the condition matches, because we want to the opposite of the configured change Function\n      if (relation.actionType === action.reversedType) {\n        // Shortcut to true when a previous condition check was resolved as true\n        if (index > 0 && operator === RelationOperator.AND && isMatch) return true;\n\n        // Shortcut to false when a previous condition check was resolved as false\n        if (index > 0 && operator === RelationOperator.OR && !isMatch) return false;\n\n        return !condition.value(relatedControl.value);\n      }\n\n      return false;\n    };\n\n    return relation.conditions.reduce(reducer, false);\n  }\n}\n"]}

package/esm2022/lib/services/dynamic-form.service.mjs

@@ -0,0 +1,77 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { UntypedFormControl } from '@angular/forms';
+import { map } from 'rxjs';
+import { DYNAMIC_FORM_FIELD_MAP_FN } from '../models/tokens/dynamic-form-field-map-fn.token';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "./dynamic-validations.service";
+export class DynamicFormService {
+    constructor(DYNAMIC_FORM_FIELD_MAP_FN, fb, validatorsService) {
+        this.DYNAMIC_FORM_FIELD_MAP_FN = DYNAMIC_FORM_FIELD_MAP_FN;
+        this.fb = fb;
+        this.validatorsService = validatorsService;
+    }
+    /**
+     * Check if there is a function provided to use custom form controls
+     * @param model
+     * @returns
+     */
+    getCustomControlComponentType(model) {
+        return typeof this.DYNAMIC_FORM_FIELD_MAP_FN === 'function' ? this.DYNAMIC_FORM_FIELD_MAP_FN(model) : null;
+    }
+    /**
+     * Create a FormGroup from the provided form configuration.
+     * Returns a FormGroup.
+     * @param config
+     * @returns
+     */
+    createFormGroup(config) {
+        const group = this.fb.group({});
+        config.forEach((row) => {
+            row.forEach((controlConfig) => {
+                const controlValueConfig = controlConfig;
+                const controlOptions = {
+                    updateOn: controlConfig.updateOn,
+                    validators: this.validatorsService.getValidatorFns(controlConfig.validators)
+                };
+                const control = new UntypedFormControl({ value: controlValueConfig.value ?? controlValueConfig.defaultValue, disabled: controlValueConfig.disabled }, controlOptions);
+                group.addControl(controlConfig.name, control);
+            });
+        });
+        return group;
+    }
+    /**
+     * Transform any list (Observable) to a list of DynamicFormFieldOption which is used in any Dynamic Form Field with options (e.g. DynamicSelect).
+     * Generic types:
+     * T = The type of the items in the provided list
+     * K = The type of the value inside an DynamicFormFieldOption
+     * @param listObs
+     * @param labelCb
+     * @param valueCb
+     * @returns
+     */
+    toDynamicOptionListObs(listObs, labelCb, valueCb) {
+        return listObs.pipe(map((list) => {
+            return list.map((item) => {
+                return {
+                    label: labelCb(item),
+                    value: valueCb(item)
+                };
+            });
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicFormService, deps: [{ token: DYNAMIC_FORM_FIELD_MAP_FN, optional: true }, { token: i1.FormBuilder }, { token: i2.DynamicFormValidationsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicFormService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicFormService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DYNAMIC_FORM_FIELD_MAP_FN]
+                }, {
+                    type: Optional
+                }] }, { type: i1.FormBuilder }, { type: i2.DynamicFormValidationsService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy1mb3JtLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtZHluYW1pYy1mb3JtL3NyYy9saWIvc2VydmljZXMvZHluYW1pYy1mb3JtLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFRLE1BQU0sZUFBZSxDQUFDO0FBQ25FLE9BQU8sRUFBbUMsa0JBQWtCLEVBQW9CLE1BQU0sZ0JBQWdCLENBQUM7QUFDdkcsT0FBTyxFQUFFLEdBQUcsRUFBYyxNQUFNLE1BQU0sQ0FBQztBQUt2QyxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxrREFBa0QsQ0FBQzs7OztBQVM3RixNQUFNLE9BQU8sa0JBQWtCO0lBQzdCLFlBQ3lELHlCQUFvRCxFQUNuRyxFQUFlLEVBQ2YsaUJBQWdEO1FBRkQsOEJBQXlCLEdBQXpCLHlCQUF5QixDQUEyQjtRQUNuRyxPQUFFLEdBQUYsRUFBRSxDQUFhO1FBQ2Ysc0JBQWlCLEdBQWpCLGlCQUFpQixDQUErQjtJQUN2RCxDQUFDO0lBRUo7Ozs7T0FJRztJQUNJLDZCQUE2QixDQUFDLEtBQTRCO1FBQy9ELE9BQU8sT0FBTyxJQUFJLENBQUMseUJBQXlCLEtBQUssVUFBVSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMseUJBQXlCLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztJQUM3RyxDQUFDO0lBRUQ7Ozs7O09BS0c7SUFDSSxlQUFlLENBQUMsTUFBeUI7UUFDOUMsTUFBTSxLQUFLLEdBQXFCLElBQUksQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBRWxELE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQyxHQUFHLEVBQUUsRUFBRTtZQUNyQixHQUFHLENBQUMsT0FBTyxDQUFDLENBQUMsYUFBYSxFQUFFLEVBQUU7Z0JBQzVCLE1BQU0sa0JBQWtCLEdBQUcsYUFBcUQsQ0FBQztnQkFDakYsTUFBTSxjQUFjLEdBQXVCO29CQUN6QyxRQUFRLEVBQUUsYUFBYSxDQUFDLFFBQVE7b0JBQ2hDLFVBQVUsRUFBRSxJQUFJLENBQUMsaUJBQWlCLENBQUMsZUFBZSxDQUFDLGFBQWEsQ0FBQyxVQUFVLENBQUM7aUJBQzdFLENBQUM7Z0JBRUYsTUFBTSxPQUFPLEdBQUcsSUFBSSxrQkFBa0IsQ0FDcEMsRUFBRSxLQUFLLEVBQUUsa0JBQWtCLENBQUMsS0FBSyxJQUFJLGtCQUFrQixDQUFDLFlBQVksRUFBRSxRQUFRLEVBQUUsa0JBQWtCLENBQUMsUUFBUSxFQUFFLEVBQzdHLGNBQWMsQ0FDZixDQUFDO2dCQUVGLEtBQUssQ0FBQyxVQUFVLENBQUMsYUFBYSxDQUFDLElBQUksRUFBRSxPQUFPLENBQUMsQ0FBQztZQUNoRCxDQUFDLENBQUMsQ0FBQztRQUNMLENBQUMsQ0FBQyxDQUFDO1FBRUgsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDO0lBRUQ7Ozs7Ozs7OztPQVNHO0lBQ0ksc0JBQXNCLENBQzNCLE9BQXdCLEVBQ3hCLE9BQTRCLEVBQzVCLE9BQXVCO1FBRXZCLE9BQU8sT0FBTyxDQUFDLElBQUksQ0FDakIsR0FBRyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUU7WUFDWCxPQUFPLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRTtnQkFDdkIsT0FBTztvQkFDTCxLQUFLLEVBQUUsT0FBTyxDQUFDLElBQUksQ0FBQztvQkFDcEIsS0FBSyxFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUM7aUJBQ3JCLENBQUM7WUFDSixDQUFDLENBQUMsQ0FBQztRQUNMLENBQUMsQ0FBQyxDQUNILENBQUM7SUFDSixDQUFDOytHQXRFVSxrQkFBa0Isa0JBRW5CLHlCQUF5QjttSEFGeEIsa0JBQWtCLGNBRmpCLE1BQU07OzRGQUVQLGtCQUFrQjtrQkFIOUIsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkI7OzBCQUdJLE1BQU07MkJBQUMseUJBQXlCOzswQkFBRyxRQUFRIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0LCBJbmplY3RhYmxlLCBPcHRpb25hbCwgVHlwZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRm9ybUJ1aWxkZXIsIEZvcm1Db250cm9sT3B0aW9ucywgVW50eXBlZEZvcm1Db250cm9sLCBVbnR5cGVkRm9ybUdyb3VwIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHsgbWFwLCBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBEeW5hbWljRm9ybUZpZWxkIH0gZnJvbSAnLi4vbW9kZWxzL2NsYXNzZXMvZHluYW1pYy1mb3JtLWZpZWxkLWJhc2UtY29tcG9uZW50JztcbmltcG9ydCB7IER5bmFtaWNGb3JtRmllbGRNb2RlbCB9IGZyb20gJy4uL21vZGVscy9jbGFzc2VzL2R5bmFtaWMtZm9ybS1maWVsZC1tb2RlbCc7XG5pbXBvcnQgeyBEeW5hbWljRm9ybUZpZWxkT3B0aW9uIH0gZnJvbSAnLi4vbW9kZWxzL2NsYXNzZXMvZHluYW1pYy1mb3JtLWZpZWxkLW9wdGlvbi1tb2RlbCc7XG5pbXBvcnQgeyBEeW5hbWljRm9ybUZpZWxkVmFsdWVDb25maWcgfSBmcm9tICcuLi9tb2RlbHMvY2xhc3Nlcy9keW5hbWljLWZvcm0tZmllbGQtdmFsdWUtbW9kZWwnO1xuaW1wb3J0IHsgRFlOQU1JQ19GT1JNX0ZJRUxEX01BUF9GTiB9IGZyb20gJy4uL21vZGVscy90b2tlbnMvZHluYW1pYy1mb3JtLWZpZWxkLW1hcC1mbi50b2tlbic7XG5pbXBvcnQgeyBEeW5hbWljRm9ybUNvbmZpZyB9IGZyb20gJy4uL21vZGVscy90eXBlcy9keW5hbWljLWZvcm0tY29uZmlnLnR5cGUnO1xuaW1wb3J0IHsgRHluYW1pY0Zvcm1WYWxpZGF0aW9uc1NlcnZpY2UgfSBmcm9tICcuL2R5bmFtaWMtdmFsaWRhdGlvbnMuc2VydmljZSc7XG5cbmV4cG9ydCB0eXBlIER5bmFtaWNGb3JtRmllbGRUeXBlTWFwRm4gPSAoZmllbGQ6IER5bmFtaWNGb3JtRmllbGRNb2RlbCkgPT4gVHlwZTxEeW5hbWljRm9ybUZpZWxkPiB8IG51bGw7XG5cbkBJbmplY3RhYmxlKHtcbiAgcHJvdmlkZWRJbjogJ3Jvb3QnXG59KVxuZXhwb3J0IGNsYXNzIER5bmFtaWNGb3JtU2VydmljZSB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIEBJbmplY3QoRFlOQU1JQ19GT1JNX0ZJRUxEX01BUF9GTikgQE9wdGlvbmFsKCkgcHJpdmF0ZSBEWU5BTUlDX0ZPUk1fRklFTERfTUFQX0ZOOiBEeW5hbWljRm9ybUZpZWxkVHlwZU1hcEZuLFxuICAgIHByaXZhdGUgZmI6IEZvcm1CdWlsZGVyLFxuICAgIHByaXZhdGUgdmFsaWRhdG9yc1NlcnZpY2U6IER5bmFtaWNGb3JtVmFsaWRhdGlvbnNTZXJ2aWNlXG4gICkge31cblxuICAvKipcbiAgICogQ2hlY2sgaWYgdGhlcmUgaXMgYSBmdW5jdGlvbiBwcm92aWRlZCB0byB1c2UgY3VzdG9tIGZvcm0gY29udHJvbHNcbiAgICogQHBhcmFtIG1vZGVsXG4gICAqIEByZXR1cm5zXG4gICAqL1xuICBwdWJsaWMgZ2V0Q3VzdG9tQ29udHJvbENvbXBvbmVudFR5cGUobW9kZWw6IER5bmFtaWNGb3JtRmllbGRNb2RlbCk6IFR5cGU8RHluYW1pY0Zvcm1GaWVsZD4gfCBudWxsIHtcbiAgICByZXR1cm4gdHlwZW9mIHRoaXMuRFlOQU1JQ19GT1JNX0ZJRUxEX01BUF9GTiA9PT0gJ2Z1bmN0aW9uJyA/IHRoaXMuRFlOQU1JQ19GT1JNX0ZJRUxEX01BUF9GTihtb2RlbCkgOiBudWxsO1xuICB9XG5cbiAgLyoqXG4gICAqIENyZWF0ZSBhIEZvcm1Hcm91cCBmcm9tIHRoZSBwcm92aWRlZCBmb3JtIGNvbmZpZ3VyYXRpb24uXG4gICAqIFJldHVybnMgYSBGb3JtR3JvdXAuXG4gICAqIEBwYXJhbSBjb25maWdcbiAgICogQHJldHVybnNcbiAgICovXG4gIHB1YmxpYyBjcmVhdGVGb3JtR3JvdXAoY29uZmlnOiBEeW5hbWljRm9ybUNvbmZpZyk6IFVudHlwZWRGb3JtR3JvdXAge1xuICAgIGNvbnN0IGdyb3VwOiBVbnR5cGVkRm9ybUdyb3VwID0gdGhpcy5mYi5ncm91cCh7fSk7XG5cbiAgICBjb25maWcuZm9yRWFjaCgocm93KSA9PiB7XG4gICAgICByb3cuZm9yRWFjaCgoY29udHJvbENvbmZpZykgPT4ge1xuICAgICAgICBjb25zdCBjb250cm9sVmFsdWVDb25maWcgPSBjb250cm9sQ29uZmlnIGFzIER5bmFtaWNGb3JtRmllbGRWYWx1ZUNvbmZpZzx1bmtub3duPjtcbiAgICAgICAgY29uc3QgY29udHJvbE9wdGlvbnM6IEZvcm1Db250cm9sT3B0aW9ucyA9IHtcbiAgICAgICAgICB1cGRhdGVPbjogY29udHJvbENvbmZpZy51cGRhdGVPbixcbiAgICAgICAgICB2YWxpZGF0b3JzOiB0aGlzLnZhbGlkYXRvcnNTZXJ2aWNlLmdldFZhbGlkYXRvckZucyhjb250cm9sQ29uZmlnLnZhbGlkYXRvcnMpXG4gICAgICAgIH07XG5cbiAgICAgICAgY29uc3QgY29udHJvbCA9IG5ldyBVbnR5cGVkRm9ybUNvbnRyb2woXG4gICAgICAgICAgeyB2YWx1ZTogY29udHJvbFZhbHVlQ29uZmlnLnZhbHVlID8/IGNvbnRyb2xWYWx1ZUNvbmZpZy5kZWZhdWx0VmFsdWUsIGRpc2FibGVkOiBjb250cm9sVmFsdWVDb25maWcuZGlzYWJsZWQgfSxcbiAgICAgICAgICBjb250cm9sT3B0aW9uc1xuICAgICAgICApO1xuXG4gICAgICAgIGdyb3VwLmFkZENvbnRyb2woY29udHJvbENvbmZpZy5uYW1lLCBjb250cm9sKTtcbiAgICAgIH0pO1xuICAgIH0pO1xuXG4gICAgcmV0dXJuIGdyb3VwO1xuICB9XG5cbiAgLyoqXG4gICAqIFRyYW5zZm9ybSBhbnkgbGlzdCAoT2JzZXJ2YWJsZSkgdG8gYSBsaXN0IG9mIER5bmFtaWNGb3JtRmllbGRPcHRpb24gd2hpY2ggaXMgdXNlZCBpbiBhbnkgRHluYW1pYyBGb3JtIEZpZWxkIHdpdGggb3B0aW9ucyAoZS5nLiBEeW5hbWljU2VsZWN0KS5cbiAgICogR2VuZXJpYyB0eXBlczpcbiAgICogVCA9IFRoZSB0eXBlIG9mIHRoZSBpdGVtcyBpbiB0aGUgcHJvdmlkZWQgbGlzdFxuICAgKiBLID0gVGhlIHR5cGUgb2YgdGhlIHZhbHVlIGluc2lkZSBhbiBEeW5hbWljRm9ybUZpZWxkT3B0aW9uXG4gICAqIEBwYXJhbSBsaXN0T2JzXG4gICAqIEBwYXJhbSBsYWJlbENiXG4gICAqIEBwYXJhbSB2YWx1ZUNiXG4gICAqIEByZXR1cm5zXG4gICAqL1xuICBwdWJsaWMgdG9EeW5hbWljT3B0aW9uTGlzdE9iczxULCBLID0gc3RyaW5nPihcbiAgICBsaXN0T2JzOiBPYnNlcnZhYmxlPFRbXT4sXG4gICAgbGFiZWxDYjogKGl0ZW06IFQpID0+IHN0cmluZyxcbiAgICB2YWx1ZUNiOiAoaXRlbTogVCkgPT4gS1xuICApOiBPYnNlcnZhYmxlPER5bmFtaWNGb3JtRmllbGRPcHRpb248Sz5bXT4ge1xuICAgIHJldHVybiBsaXN0T2JzLnBpcGUoXG4gICAgICBtYXAoKGxpc3QpID0+IHtcbiAgICAgICAgcmV0dXJuIGxpc3QubWFwKChpdGVtKSA9PiB7XG4gICAgICAgICAgcmV0dXJuIHtcbiAgICAgICAgICAgIGxhYmVsOiBsYWJlbENiKGl0ZW0pLFxuICAgICAgICAgICAgdmFsdWU6IHZhbHVlQ2IoaXRlbSlcbiAgICAgICAgICB9O1xuICAgICAgICB9KTtcbiAgICAgIH0pXG4gICAgKTtcbiAgfVxufVxuIl19

package/esm2022/lib/services/dynamic-validations.service.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DynamicFormValidationsService {
+    /**
+     * Get all Validator Functions from the validator configuration
+     * @param validatorConfig
+     * @returns
+     */
+    getValidatorFns(validatorConfig) {
+        return validatorConfig.map((v) => v.validator);
+    }
+    /**
+     * Update the validators on a FormControl based on the provided validator configuration.
+     * This will replace any existing validators on the control or removes all validators when none provided
+     * @param validatorConfig
+     * @param control
+     */
+    updateValidators(validatorConfig, control) {
+        if (!validatorConfig || validatorConfig.length === 0) {
+            control.clearValidators();
+        }
+        else {
+            const validatorFns = this.getValidatorFns(validatorConfig);
+            control.setValidators(validatorFns);
+        }
+        control.updateValueAndValidity();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicFormValidationsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicFormValidationsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DynamicFormValidationsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/olafvv-ngx-dynamic-form.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2xhZnZ2LW5neC1keW5hbWljLWZvcm0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9wcm9qZWN0cy9uZ3gtZHluYW1pYy1mb3JtL3NyYy9vbGFmdnYtbmd4LWR5bmFtaWMtZm9ybS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/public-api.mjs

@@ -0,0 +1,8 @@
+/*
+ * Public API Surface of ngx-dynamic-form
+ */
+export * from './lib/components/dynamic-form/dynamic-form.component';
+export * from './lib/controls';
+export * from './lib/models';
+export * from './lib/services/dynamic-form.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1keW5hbWljLWZvcm0vc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFDSCxjQUFjLHNEQUFzRCxDQUFDO0FBRXJFLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxjQUFjLENBQUM7QUFFN0IsY0FBYyxxQ0FBcUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2Ygbmd4LWR5bmFtaWMtZm9ybVxuICovXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2R5bmFtaWMtZm9ybS9keW5hbWljLWZvcm0uY29tcG9uZW50JztcblxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29udHJvbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbW9kZWxzJztcblxuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvZHluYW1pYy1mb3JtLnNlcnZpY2UnO1xuIl19