@stemy/ngx-dynamic-form 12.0.0 → 13.0.2

package/fesm2015/stemy-ngx-dynamic-form.mjs

@@ -0,0 +1,1341 @@
+import * as i2 from '@stemy/ngx-utils';
+import { ReflectUtils, ObjectUtils, StringUtils, OpenApiService, TOASTER_SERVICE, ObservableUtils, EventsService, NgxUtilsModule } from '@stemy/ngx-utils';
+import * as i1 from '@ng-dynamic-forms/core';
+import { DynamicFormArrayModel as DynamicFormArrayModel$1, DynamicFormService as DynamicFormService$1, DynamicSelectModel, DynamicFormGroupModel, DynamicInputModel, DynamicFileUploadModel, DynamicCheckboxModel, DynamicTextAreaModel, DynamicFormComponent, DynamicTemplateDirective, DynamicFormArrayComponent, DynamicFormValueControlModel, DynamicFormControlContainerComponent, DYNAMIC_FORM_CONTROL_TYPE_ARRAY, DynamicFormGroupComponent, DYNAMIC_FORM_CONTROL_MAP_FN, DYNAMIC_VALIDATORS } from '@ng-dynamic-forms/core';
+import { Subject, Subscription } from 'rxjs';
+import { __awaiter } from 'tslib';
+import * as i0 from '@angular/core';
+import { EventEmitter, Injector, Injectable, Inject, Directive, Input, Output, HostBinding, HostListener, QueryList, Component, ChangeDetectionStrategy, ContentChildren, ViewChildren, ViewChild, forwardRef, ViewContainerRef, NgModule } from '@angular/core';
+import { FormGroup, FormArray, NgForm, FormsModule, ReactiveFormsModule, NG_VALIDATORS } from '@angular/forms';
+import { first } from 'rxjs/operators';
+import { CommonModule } from '@angular/common';
+
+// --- Decorator functions ---
+function defaultSerializer(id, parent) {
+    const control = parent.get(id);
+    return !control ? null : control.value;
+}
+function FormSerializable(serializer) {
+    return (target, propertyKey) => {
+        ReflectUtils.defineMetadata("dynamicFormSerializer", serializer || defaultSerializer, target, propertyKey);
+    };
+}
+function FormInput(data) {
+    return (target, propertyKey) => {
+        const meta = ReflectUtils.getOwnMetadata("design:type", target, propertyKey);
+        const type = meta ? meta.name : "";
+        let inputType = propertyKey.indexOf("password") < 0 ? "text" : "password";
+        switch (type) {
+            case "Number":
+                inputType = "number";
+                break;
+            case "Boolean":
+                inputType = "checkbox";
+                break;
+        }
+        defineFormControl(target, propertyKey, createFormInput(propertyKey, data, inputType));
+    };
+}
+function FormSelect(data) {
+    return (target, propertyKey) => {
+        defineFormControl(target, propertyKey, createFormSelect(propertyKey, data));
+    };
+}
+function FormStatic(data) {
+    return (target, propertyKey) => {
+        defineFormControl(target, propertyKey, createFormStatic(propertyKey, data));
+    };
+}
+function FormModel(data) {
+    return (target, propertyKey) => {
+        defineFormControl(target, propertyKey, createFormModel(propertyKey, data));
+    };
+}
+function FormFile(data) {
+    return (target, propertyKey) => {
+        defineFormControl(target, propertyKey, createFormFile(propertyKey, data));
+    };
+}
+function defineFormControl(target, propertyKey, control) {
+    ReflectUtils.defineMetadata("dynamicFormControl", control, target, propertyKey);
+}
+function getFormControl(target, propertyKey) {
+    return ReflectUtils.getMetadata("dynamicFormControl", target, propertyKey);
+}
+function getFormSerializer(target, propertyKey) {
+    return ReflectUtils.getMetadata("dynamicFormSerializer", target, propertyKey);
+}
+function createFormControl(id, type, config) {
+    config = config || { id };
+    config.id = id;
+    config.label = ObjectUtils.isNullOrUndefined(config.label) ? id : config.label;
+    config.disabled = config.disabled || false;
+    config.hidden = config.hidden || false;
+    return { id, type, config };
+}
+function createFormInput(id, config, type = "text") {
+    const control = createFormControl(id, "input", config);
+    config = control.config;
+    config.inputType = config.inputType || type;
+    config.placeholder = config.placeholder || (config.inputType == "mask" ? "_" : "");
+    config.step = config.step || 1;
+    config.mask = config.mask || null;
+    return control;
+}
+function createFormSelect(id, data) {
+    const control = createFormControl(id, "select", data);
+    data = control.config;
+    data.options = data.options || [];
+    return control;
+}
+function createFormStatic(id, config) {
+    return createFormControl(id, "static", config);
+}
+function createFormModel(id, data) {
+    const control = createFormControl(id, "group", data);
+    data = control.config;
+    data.name = data.name || "";
+    return control;
+}
+function createFormFile(id, data) {
+    const control = createFormControl(id, "file", data);
+    data = control.config;
+    data.accept = data.accept || ["jpg", "jpeg", "png"];
+    data.multiple = data.multiple || false;
+    data.url = ObjectUtils.isString(data.url) ? data.url : "assets";
+    return control;
+}
+
+function isStringWithVal(val) {
+    return typeof val == "string" && val.length > 0;
+}
+function collectPathAble(start, getter) {
+    if (!start || !getter(start))
+        return [];
+    const parts = [];
+    let currentPath = start;
+    while (currentPath) {
+        const val = getter(currentPath);
+        if (val) {
+            parts.unshift(val);
+        }
+        currentPath = currentPath.parent;
+    }
+    return parts;
+}
+const MIN_INPUT_NUM = -99999999999999;
+const MAX_INPUT_NUM = 99999999999999;
+
+function validateJSON(control) {
+    const value = control.value;
+    if (!value)
+        return null;
+    try {
+        JSON.parse(value);
+        return null;
+    }
+    catch (e) {
+        return { json: true };
+    }
+}
+function validateRequiredTranslation(control) {
+    const value = control.value;
+    if (!value || value.length == 0)
+        return { requiredTranslation: true };
+    return value.findIndex(t => (t.lang == "de" || t.lang == "en") && !t.translation) < 0
+        ? null
+        : { requiredTranslation: true };
+}
+function validatePhone(control) {
+    const value = control.value;
+    if (!value)
+        return Promise.resolve(null);
+    const phoneRegexp = /^(?:\d){10,12}$/;
+    return phoneRegexp.test(value) ? null : { phone: true };
+}
+function validateItemsMinLength(minLength) {
+    return (control) => {
+        const value = control.value;
+        return (Array.isArray(value) && value.every(v => typeof v == "string" && v.length >= minLength))
+            ? null : { itemsMinLength: minLength };
+    };
+}
+function validateItemsMaxLength(maxLength) {
+    return (control) => {
+        const value = control.value;
+        return (Array.isArray(value) && value.every(v => typeof v == "string" && v.length <= maxLength))
+            ? null : { itemsMaxLength: maxLength };
+    };
+}
+function validateItemsMinValue(min) {
+    return (control) => {
+        const value = control.value;
+        return (Array.isArray(value) && value.every(v => typeof v == "number" && v >= min))
+            ? null : { itemsMinValue: min };
+    };
+}
+function validateItemsMaxValue(max) {
+    return (control) => {
+        const value = control.value;
+        return (Array.isArray(value) && value.every(v => typeof v == "number" && v <= max))
+            ? null : { itemsMaxValue: max };
+    };
+}
+
+class DynamicFormArrayModel extends DynamicFormArrayModel$1 {
+    constructor(config, layout) {
+        super(config, layout);
+        this.useTabs = config.useTabs || false;
+        this.saveTab = ObjectUtils.isFunction(config.saveTab) ? config.saveTab : ((index, model) => {
+            model.tabIndex = index;
+        });
+        this.restoreTab = ObjectUtils.isFunction(config.restoreTab) ? config.restoreTab : ((model) => {
+            return model.tabIndex;
+        });
+        this.additional = config.additional || {};
+    }
+}
+
+const indexLabels = ["$ix", "$pix"];
+class FormSubject extends Subject {
+    constructor(notifyCallback) {
+        super();
+        this.notifyCallback = notifyCallback;
+    }
+    handleNotifiedValue(controlModel, control, val) {
+        val.then(v => this.next(v));
+    }
+    notify(controlModel, control, root) {
+        const indexes = {};
+        let path = controlModel;
+        let ix = 0;
+        while (path) {
+            if (!isNaN(path.index)) {
+                const key = indexLabels[ix++] || `$pix${ix}`;
+                indexes[key] = path.index;
+            }
+            path = path.parent;
+        }
+        let value = this.notifyCallback(controlModel, control, root, indexes);
+        if (!(value instanceof Promise)) {
+            value = Promise.resolve(value);
+        }
+        this.handleNotifiedValue(controlModel, control, value);
+    }
+}
+
+class FormSelectSubject extends FormSubject {
+    handleNotifiedValue(controlModel, control, val) {
+        val.then(options => {
+            var _a, _b;
+            this.next(options);
+            if (options.length == 0)
+                return;
+            const currentVal = control.value;
+            if (controlModel.multiple) {
+                const correctVal = (currentVal || []).filter(t => options.findIndex(o => o.value == t) >= 0);
+                if (correctVal.length !== (currentVal === null || currentVal === void 0 ? void 0 : currentVal.length)) {
+                    control.setValue(correctVal, { onlySelf: true, emitEvent: false });
+                }
+                return;
+            }
+            const option = options.find(t => t.value == currentVal);
+            if (!option) {
+                control.setValue((_b = (_a = options[0]) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : null, { onlySelf: true, emitEvent: false });
+            }
+        });
+    }
+}
+
+class DynamicFormService extends DynamicFormService$1 {
+    constructor(cs, vs, openApi, injector) {
+        super(cs, vs);
+        this.openApi = openApi;
+        this.injector = injector;
+        this.onDetectChanges = new EventEmitter();
+    }
+    get api() {
+        return this.openApi.api;
+    }
+    get language() {
+        return this.api.language;
+    }
+    patchGroup(value, formModel, formGroup) {
+        this.patchValueRecursive(value, formModel, formGroup);
+        this.detectChanges();
+        formGroup.patchValue(ObjectUtils.copy(value));
+    }
+    patchForm(value, component) {
+        this.patchValueRecursive(value, component.model, component.group);
+        this.detectChanges(component);
+        component.group.patchValue(value);
+    }
+    serialize(formModel, formGroup) {
+        return this.serializeRecursive(formModel, formGroup);
+    }
+    notifyChanges(formModel, formGroup, root) {
+        this.notifyChangesRecursive(formModel, formGroup, root);
+    }
+    updateSelectOptions(formControlModel, formControl, root) {
+        if (formControlModel instanceof DynamicSelectModel) {
+            let options = formControlModel.options$;
+            if (options instanceof FormSubject) {
+                options.notify(formControlModel, formControl, root);
+                return;
+            }
+            while (options instanceof Subject && options.source) {
+                options = options.source;
+                if (options instanceof FormSubject) {
+                    options.notify(formControlModel, formControl, root);
+                }
+            }
+        }
+    }
+    showErrors(form) {
+        this.showErrorsForGroup(form.group);
+        this.detectChanges(form);
+    }
+    detectChanges(formComponent) {
+        super.detectChanges(formComponent);
+        this.onDetectChanges.emit(formComponent);
+    }
+    patchValueRecursive(value, formModel, formGroup) {
+        Object.keys(value).forEach(key => {
+            const subModel = this.findModelById(key, formModel);
+            const subValue = value[key];
+            if (!subModel)
+                return;
+            const subControl = this.findControlByModel(subModel, formGroup);
+            if (subModel instanceof DynamicSelectModel && ObjectUtils.isObject(subValue)) {
+                value[key] = subValue.id || subValue._id || subValue;
+                return;
+            }
+            if (subModel instanceof DynamicFormArrayModel$1) {
+                const length = Array.isArray(subValue) ? subValue.length : 0;
+                const subArray = subControl;
+                while (subModel.size > length) {
+                    this.removeFormArrayGroup(0, subArray, subModel);
+                }
+                while (subModel.size < length) {
+                    this.insertFormArrayGroup(subModel.size, subArray, subModel);
+                }
+                for (let i = 0; i < length; i++) {
+                    const itemModel = subModel.get(i);
+                    this.patchValueRecursive(subValue[i], itemModel.group, subArray.at(i));
+                }
+                return;
+            }
+            if (subModel instanceof DynamicFormGroupModel) {
+                this.patchValueRecursive(subValue, subModel.group, subControl);
+            }
+        });
+    }
+    serializeRecursive(formModel, formGroup) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {};
+            if (!formModel || !formGroup || !formGroup.value)
+                return result;
+            for (const i in formModel) {
+                const subModel = formModel[i];
+                const subControl = this.findControlByModel(subModel, formGroup);
+                const serializer = (_a = subModel.additional) === null || _a === void 0 ? void 0 : _a.serializer;
+                if (ObjectUtils.isFunction(serializer)) {
+                    result[subModel.id] = yield serializer(subModel, subControl);
+                    continue;
+                }
+                if (subModel instanceof DynamicFormArrayModel$1) {
+                    const length = Array.isArray(subControl.value) ? subControl.value.length : 0;
+                    const subArray = subControl;
+                    const resArray = [];
+                    for (let i = 0; i < length; i++) {
+                        const itemModel = subModel.get(i);
+                        resArray.push(yield this.serializeRecursive(itemModel.group, subArray.at(i)));
+                    }
+                    result[subModel.id] = resArray;
+                    continue;
+                }
+                if (subModel instanceof DynamicFormGroupModel) {
+                    result[subModel.id] = yield this.serializeRecursive(subModel.group, subControl);
+                    continue;
+                }
+                if (subModel instanceof DynamicInputModel && !ObjectUtils.isNullOrUndefined(subControl.value)) {
+                    result[subModel.id] = subModel.inputType == "number"
+                        ? (_b = parseFloat((`${subControl.value}` || "0").replace(/,/gi, "."))) !== null && _b !== void 0 ? _b : null
+                        : subControl.value;
+                    continue;
+                }
+                result[subModel.id] = subControl.value;
+            }
+            return result;
+        });
+    }
+    notifyChangesRecursive(formModel, formGroup, root) {
+        if (!formModel || !formGroup)
+            return;
+        for (const i in formModel) {
+            const subModel = formModel[i];
+            const subControl = this.findControlByModel(subModel, formGroup);
+            if (subModel instanceof DynamicFormArrayModel$1) {
+                const length = Array.isArray(subControl.value) ? subControl.value.length : 0;
+                const subArray = subControl;
+                for (let i = 0; i < length; i++) {
+                    const itemModel = subModel.get(i);
+                    this.notifyChangesRecursive(itemModel.group, subArray.at(i), root);
+                }
+                continue;
+            }
+            if (subModel instanceof DynamicFormGroupModel) {
+                this.notifyChangesRecursive(subModel.group, subControl, root);
+                continue;
+            }
+            this.updateSelectOptions(subModel, subControl, root);
+        }
+    }
+    showErrorsForGroup(formGroup) {
+        if (!formGroup)
+            return;
+        formGroup.markAsTouched({ onlySelf: true });
+        const controls = Object.keys(formGroup.controls).map(id => formGroup.controls[id]);
+        this.showErrorsForControls(controls);
+    }
+    showErrorsForControls(controls) {
+        controls.forEach(control => {
+            if (control instanceof FormGroup) {
+                this.showErrorsForGroup(control);
+                return;
+            }
+            control.markAsTouched({ onlySelf: true });
+            if (control instanceof FormArray) {
+                this.showErrorsForControls(control.controls);
+            }
+        });
+    }
+    getFormModelForSchema(name, customizeModel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.api.cache = {};
+            this.schemas = yield this.openApi.getSchemas();
+            const customizeModels = (property, schema, modelType, config) => {
+                const model = new modelType(config);
+                if (!ObjectUtils.isFunction(customizeModel))
+                    return [model];
+                const res = customizeModel(property, schema, model, config, this.injector);
+                return Array.isArray(res) ? res : [res];
+            };
+            return this.getFormModelForSchemaDef(this.schemas[name], customizeModels);
+        });
+    }
+    getFormModelForSchemaDef(schema, customizeModels) {
+        if (!schema)
+            return [];
+        const keys = Object.keys(schema.properties || {});
+        const controls = [];
+        for (const p of keys) {
+            const property = schema.properties[p];
+            controls.push(...this.getFormControlModels(property, schema, customizeModels));
+        }
+        return controls.filter(t => null !== t);
+    }
+    getFormControlModels(property, schema, customizeModels) {
+        var _a, _b;
+        const $enum = ((_a = property.items) === null || _a === void 0 ? void 0 : _a.enum) || property.enum;
+        if (Array.isArray($enum) || isStringWithVal(property.optionsPath) || isStringWithVal(property.endpoint)) {
+            return customizeModels(property, schema, DynamicSelectModel, this.getFormSelectConfig(property, schema));
+        }
+        switch (property.type) {
+            case "string":
+            case "number":
+            case "integer":
+                return customizeModels(property, schema, DynamicInputModel, this.getFormInputConfig(property, schema));
+            case "textarea":
+                return customizeModels(property, schema, DynamicTextAreaModel, this.getFormTextareaConfig(property, schema));
+            case "boolean":
+                return customizeModels(property, schema, DynamicCheckboxModel, this.getFormCheckboxConfig(property, schema));
+            case "array":
+                if (((_b = property.items) === null || _b === void 0 ? void 0 : _b.$ref) || property.$ref) {
+                    return customizeModels(property, schema, DynamicFormArrayModel, this.getFormArrayConfig(property, schema, customizeModels));
+                }
+                else {
+                    return customizeModels(property, schema, DynamicInputModel, this.getFormInputConfig(property, schema));
+                }
+            case "file":
+                return customizeModels(property, schema, DynamicFileUploadModel, this.getFormUploadConfig(property, schema));
+        }
+        if (property.$ref) {
+            return customizeModels(property, schema, DynamicFormGroupModel, this.getFormGroupConfig(property, schema, customizeModels));
+        }
+        return [];
+    }
+    findModelByPath(parent, path) {
+        if (path.length == 0)
+            return parent;
+        const next = path.shift();
+        if (Array.isArray(parent)) {
+            return this.findModelByPath(parent.find(t => t.id == next), path);
+        }
+        if (parent instanceof DynamicFormGroupModel) {
+            return this.findModelByPath(parent.group.find(t => t.id == next), path);
+        }
+        if (parent instanceof DynamicFormArrayModel) {
+            return this.findModelByPath(parent.groups.find(t => t.index == next), path);
+        }
+        return parent;
+    }
+    getFormControlConfig(property, schema) {
+        const validators = this.getValidators(property, schema);
+        const errorMessages = Object.keys(validators).reduce((res, key) => {
+            res[key] = `error.${key}`;
+            return res;
+        }, {});
+        return {
+            id: property.id,
+            label: ObjectUtils.isString(property.label) ? property.label : property.id,
+            hidden: property.hidden,
+            disabled: property.disabled,
+            validators,
+            errorMessages,
+            additional: Object.assign({}, property)
+        };
+    }
+    getFormArrayConfig(property, schema, customizeModels) {
+        var _a;
+        const ref = ((_a = property.items) === null || _a === void 0 ? void 0 : _a.$ref) || property.$ref || "";
+        const subSchema = this.schemas[ref.split("/").pop()];
+        return Object.assign(this.getFormControlConfig(property, schema), {
+            groupFactory: () => this.getFormModelForSchemaDef(subSchema, customizeModels),
+            useTabs: property.useTabs || false
+        });
+    }
+    getFormGroupConfig(property, schema, customizeModels) {
+        const ref = property.$ref || "";
+        const subSchema = this.schemas[ref.split("/").pop()];
+        return Object.assign(this.getFormControlConfig(property, schema), { group: this.getFormModelForSchemaDef(subSchema, customizeModels) });
+    }
+    getFormInputConfig(property, schema) {
+        var _a;
+        let inputType = StringUtils.has(property.id, "password", "Password") ? "password" : (property.format || ((_a = property.items) === null || _a === void 0 ? void 0 : _a.type) || property.type);
+        switch (inputType) {
+            case "boolean":
+                inputType = "checkbox";
+                break;
+            case "textarea":
+                inputType = "textarea";
+                break;
+            case "integer":
+                inputType = "number";
+                break;
+        }
+        const sub = property.type == "array" ? property.items || property : property;
+        return Object.assign(this.getFormControlConfig(property, schema), {
+            inputType,
+            autoComplete: property.autoComplete || "off",
+            multiple: property.type == "array",
+            accept: ObjectUtils.isString(property.accept) ? property.accept : null,
+            mask: ObjectUtils.isString(property.mask) ? property.mask : null,
+            pattern: ObjectUtils.isString(property.pattern) ? property.pattern : null,
+            step: isNaN(sub.step) ? (isNaN(property.step) ? 1 : property.step) : sub.step,
+            min: isNaN(sub.minimum) ? MIN_INPUT_NUM : sub.minimum,
+            max: isNaN(sub.maximum) ? MAX_INPUT_NUM : sub.maximum,
+            minLength: isNaN(sub.minLength) ? MIN_INPUT_NUM : sub.minLength,
+            maxLength: isNaN(sub.maxLength) ? MAX_INPUT_NUM : sub.maxLength,
+            placeholder: property.placeholder || ""
+        });
+    }
+    getFormTextareaConfig(property, schema) {
+        return Object.assign(this.getFormControlConfig(property, schema), {
+            cols: property.cols || null,
+            rows: property.rows || 10,
+            wrap: property.wrap || false,
+            autoComplete: property.autoComplete || "off",
+            multiple: property.type == "array"
+        });
+    }
+    getFormSelectConfig(property, schema) {
+        return Object.assign(this.getFormControlConfig(property, schema), {
+            options: this.getFormSelectOptions(property, schema),
+            multiple: property.type == "array"
+        });
+    }
+    getFormCheckboxConfig(property, schema) {
+        return Object.assign(this.getFormControlConfig(property, schema), {
+            indeterminate: property.indeterminate === true
+        });
+    }
+    translateOptions(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!options)
+                return [];
+            for (const option of options) {
+                option.label = yield this.language.getTranslation(option.label);
+            }
+            return options;
+        });
+    }
+    getFormSelectOptions(property, schema) {
+        var _a;
+        const $enum = ((_a = property.items) === null || _a === void 0 ? void 0 : _a.enum) || property.enum;
+        if (Array.isArray($enum)) {
+            return new FormSelectSubject(() => {
+                const options = $enum.map(value => {
+                    const label = property.translatable ? `${property.id}.${value}` : `${value}`;
+                    return { value, label };
+                });
+                return this.translateOptions(options);
+            });
+        }
+        if (isStringWithVal(property.optionsPath)) {
+            return new FormSelectSubject((formModel, control, root, indexes) => {
+                let path = property.optionsPath;
+                let target = control;
+                let model = formModel;
+                if (path.startsWith("$root")) {
+                    path = path.substr(5);
+                    while (target.parent) {
+                        target = target.parent;
+                    }
+                    model = root;
+                }
+                while (path.startsWith(".")) {
+                    path = path.substr(1);
+                    if (target.parent) {
+                        target = target.parent;
+                    }
+                    model = model.parent || root;
+                }
+                Object.keys(indexes).forEach(key => {
+                    path = path.replace(key, indexes[key]);
+                });
+                model = this.findModelByPath(model, path.split("."));
+                const modelOptions = (model instanceof DynamicSelectModel ? model.options : []);
+                const value = ObjectUtils.getValue(target.value, path);
+                const options = (!ObjectUtils.isArray(value) ? [] : value).map(value => {
+                    const modelOption = modelOptions.find(t => t.value == value);
+                    return { value, label: (modelOption === null || modelOption === void 0 ? void 0 : modelOption.label) || value };
+                });
+                return this.translateOptions(options);
+            });
+        }
+        return new FormSelectSubject(() => __awaiter(this, void 0, void 0, function* () {
+            this.api.cache[property.endpoint] = this.api.cache[property.endpoint] || this.api.list(property.endpoint, this.api.makeListParams(1, -1)).then(result => {
+                return result.items.map(i => {
+                    return { value: i.id || i._id, label: i[property.labelField] || i.label || i.id || i._id };
+                });
+            });
+            const options = (yield this.api.cache[property.endpoint]).map(t => Object.assign({}, t));
+            return this.translateOptions(options);
+        }));
+    }
+    getFormUploadConfig(property, schema) {
+        const url = this.api.url(property.url || "assets");
+        const { accept, autoUpload, maxSize, minSize, removeUrl, showFileList } = property;
+        return Object.assign(this.getFormControlConfig(property, schema), {
+            url,
+            accept,
+            autoUpload,
+            maxSize,
+            minSize,
+            removeUrl,
+            showFileList
+        });
+    }
+    getValidators(property, schema) {
+        const validators = {};
+        if (ObjectUtils.isArray(schema.required) && schema.required.indexOf(property.id) >= 0) {
+            validators.required = null;
+        }
+        this.addPropertyValidators(validators, property);
+        this.addItemsValidators(validators, property.items);
+        return validators;
+    }
+    addPropertyValidators(validators, property) {
+        if (!property)
+            return;
+        if (!isNaN(property.minLength)) {
+            validators.minLength = property.minLength;
+        }
+        if (!isNaN(property.maxLength)) {
+            validators.maxLength = property.maxLength;
+        }
+        if (!isNaN(property.minimum)) {
+            validators.min = property.minimum;
+        }
+        if (!isNaN(property.maximum)) {
+            validators.max = property.maximum;
+        }
+        switch (property.format) {
+            case "email":
+                validators.email = null;
+                break;
+        }
+    }
+    addItemsValidators(validators, items) {
+        if (!items)
+            return;
+        if (!isNaN(items.minLength)) {
+            validators.itemsMinLength = items.minLength;
+        }
+        if (!isNaN(items.maxLength)) {
+            validators.itemsMaxLength = items.maxLength;
+        }
+        if (!isNaN(items.minimum)) {
+            validators.itemsMinValue = items.minimum;
+        }
+        if (!isNaN(items.maximum)) {
+            validators.itemsMaxValue = items.maximum;
+        }
+    }
+}
+DynamicFormService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicFormService, deps: [{ token: i1.DynamicFormComponentService }, { token: i1.DynamicFormValidationService }, { token: OpenApiService }, { token: Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+DynamicFormService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicFormService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicFormService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () {
+        return [{ type: i1.DynamicFormComponentService }, { type: i1.DynamicFormValidationService }, { type: i2.OpenApiService, decorators: [{
+                        type: Inject,
+                        args: [OpenApiService]
+                    }] }, { type: i0.Injector, decorators: [{
+                        type: Inject,
+                        args: [Injector]
+                    }] }];
+    } });
+
+class AsyncSubmitDirective {
+    constructor(toaster, cdr, elem, renderer) {
+        this.toaster = toaster;
+        this.cdr = cdr;
+        this.elem = elem;
+        this.renderer = renderer;
+        this.onSuccess = new EventEmitter();
+        this.onError = new EventEmitter();
+        if (elem.nativeElement.tagName !== "BUTTON")
+            return;
+        renderer.setAttribute(elem.nativeElement, "type", "button");
+    }
+    get isDisabled() {
+        return this.disabled;
+    }
+    set isDisabled(value) {
+        this.disabled = value;
+        if (value) {
+            this.renderer.setAttribute(this.elem.nativeElement, "disabled", "disabled");
+            return;
+        }
+        this.renderer.removeAttribute(this.elem.nativeElement, "disabled");
+    }
+    get isLoading() {
+        return this.loading;
+    }
+    ngOnInit() {
+        if (!this.form)
+            return;
+        this.isDisabled = this.form.status !== "VALID";
+        this.cdr.detectChanges();
+        this.onStatusChange = this.form.onStatusChange.subscribe(() => {
+            this.isDisabled = this.form.status !== "VALID";
+            this.cdr.detectChanges();
+            if (!this.callback || this.form.status == "PENDING")
+                return;
+            if (!this.disabled) {
+                this.callback();
+            }
+            this.callback = null;
+        });
+        this.onSubmit = this.form.onSubmit.subscribe(() => this.callMethod());
+    }
+    ngOnDestroy() {
+        if (this.onStatusChange)
+            this.onStatusChange.unsubscribe();
+        if (this.onSubmit)
+            this.onSubmit.unsubscribe();
+    }
+    click() {
+        this.callback = () => this.callMethod();
+        if (this.form.status !== "VALID" && this.form.status !== "INVALID")
+            return;
+        this.callback();
+        this.callback = null;
+    }
+    callMethod() {
+        if (this.loading)
+            return;
+        this.loading = true;
+        this.method(this.form, this.context).then(result => {
+            this.loading = false;
+            if (result) {
+                this.onSuccess.emit(result);
+                this.toaster.success(result.message, result.context);
+            }
+        }, reason => {
+            if (!reason || !reason.message)
+                throw new Error("Reason must implement IAsyncMessage interface");
+            this.loading = false;
+            this.onError.emit(reason);
+            this.toaster.error(reason.message, reason.context);
+        });
+    }
+}
+AsyncSubmitDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: AsyncSubmitDirective, deps: [{ token: TOASTER_SERVICE }, { token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+AsyncSubmitDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: AsyncSubmitDirective, selector: "[async-submit]", inputs: { method: ["async-submit", "method"], form: "form", context: "context" }, outputs: { onSuccess: "onSuccess", onError: "onError" }, host: { listeners: { "click": "click()" }, properties: { "class.disabled": "this.isDisabled", "class.loading": "this.isLoading" } }, exportAs: ["async-submit"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: AsyncSubmitDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[async-submit]",
+                    exportAs: "async-submit"
+                }]
+        }], ctorParameters: function () {
+        return [{ type: undefined, decorators: [{
+                        type: Inject,
+                        args: [TOASTER_SERVICE]
+                    }] }, { type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.Renderer2 }];
+    }, propDecorators: { method: [{
+                type: Input,
+                args: ["async-submit"]
+            }], form: [{
+                type: Input
+            }], context: [{
+                type: Input
+            }], onSuccess: [{
+                type: Output
+            }], onError: [{
+                type: Output
+            }], isDisabled: [{
+                type: HostBinding,
+                args: ["class.disabled"]
+            }], isLoading: [{
+                type: HostBinding,
+                args: ["class.loading"]
+            }], click: [{
+                type: HostListener,
+                args: ["click"]
+            }] } });
+
+class DynamicBaseFormComponent extends DynamicFormComponent {
+    constructor(formService, events, changeDetectorRef, componentService) {
+        super(changeDetectorRef, componentService);
+        this.formService = formService;
+        this.events = events;
+        this.blur = new EventEmitter();
+        this.change = new EventEmitter();
+        this.focus = new EventEmitter();
+        this.onValueChange = new EventEmitter();
+        this.onStatusChange = new EventEmitter();
+        this.onSubmit = new EventEmitter();
+        this.templates = new QueryList();
+        this.subscription = new Subscription();
+        this.groupSubscription = new Subscription();
+        this.labelPrefix = "label";
+    }
+    get status() {
+        return !this.group ? null : this.group.status;
+    }
+    ngOnChanges(changes) {
+        this.groupSubscription.unsubscribe();
+        if (this.group) {
+            this.groupSubscription = ObservableUtils.multiSubscription(this.group.statusChanges.subscribe(() => {
+                this.onStatusChange.emit(this);
+            }), this.group.valueChanges.subscribe(() => {
+                this.formService.notifyChanges(this.model, this.group, this.model);
+            }), this.change.subscribe(ev => {
+                this.onValueChange.emit(Object.assign(Object.assign({}, ev), { form: this }));
+            }));
+        }
+    }
+    ngAfterViewInit() {
+        this.subscription = ObservableUtils.multiSubscription(ObservableUtils.subscribe({
+            subjects: [this.contentTemplates.changes, this.viewTemplates.changes],
+            cb: () => {
+                const templates = this.contentTemplates.toArray().concat(this.viewTemplates.toArray());
+                this.templates.reset(templates);
+            }
+        }), this.events.languageChanged.subscribe(() => {
+            this.formService.detectChanges(this);
+        }), this.ngForm.ngSubmit.subscribe(() => {
+            this.onSubmit.emit(this);
+        }));
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.subscription.unsubscribe();
+        this.groupSubscription.unsubscribe();
+    }
+    insertFormArrayGroup(index, formArray, formArrayModel) {
+        this.formService.insertFormArrayGroup(index, formArray, formArrayModel);
+        this.changeDetectorRef.detectChanges();
+    }
+    removeFormArrayGroup(index, formArray, formArrayModel) {
+        this.formService.removeFormArrayGroup(index, formArray, formArrayModel);
+        this.changeDetectorRef.detectChanges();
+    }
+    moveFormArrayGroup(index, step, formArray, formArrayModel) {
+        this.formService.moveFormArrayGroup(index, step, formArray, formArrayModel);
+        this.changeDetectorRef.detectChanges();
+    }
+    clearFormArray(formArray, formArrayModel) {
+        this.formService.clearFormArray(formArray, formArrayModel);
+        this.changeDetectorRef.detectChanges();
+    }
+    getClass(model) {
+        const parts = collectPathAble(model, p => p.id);
+        if (parts.length == 0)
+            return "";
+        if (model instanceof DynamicFormGroupModel) {
+            return `form-group-${parts.join("-")}`;
+        }
+        return `form-control-${parts.join("-")}`;
+    }
+    validate(showErrors = true) {
+        if (!this.group)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            this.group.statusChanges.pipe(first(status => status == "VALID" || status == "INVALID")).subscribe(status => {
+                if (showErrors) {
+                    this.formService.showErrors(this);
+                }
+                if (status == "VALID") {
+                    resolve(null);
+                    return;
+                }
+                reject(null);
+            });
+            this.group.updateValueAndValidity();
+        });
+    }
+    serialize(validate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.group)
+                return null;
+            if (validate) {
+                yield this.validate();
+            }
+            return yield this.formService.serialize(this.model, this.group);
+        });
+    }
+}
+DynamicBaseFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormComponent, deps: [{ token: DynamicFormService }, { token: EventsService }, { token: i0.ChangeDetectorRef }, { token: i1.DynamicFormComponentService }], target: i0.ɵɵFactoryTarget.Component });
+DynamicBaseFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.8", type: DynamicBaseFormComponent, selector: "dynamic-base-form", inputs: { group: "group", model: "model", layout: "layout", labelPrefix: "labelPrefix" }, outputs: { blur: "blur", change: "change", focus: "focus", onValueChange: "onValueChange", onStatusChange: "onStatusChange", onSubmit: "onSubmit" }, queries: [{ propertyName: "contentTemplates", predicate: DynamicTemplateDirective }], viewQueries: [{ propertyName: "ngForm", first: true, predicate: NgForm, descendants: true }, { propertyName: "viewTemplates", predicate: DynamicTemplateDirective, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "", isInline: true, changeDetection: i0.ChangeDetectionStrategy.Default });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "dynamic-base-form",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.Default
+                }]
+        }], ctorParameters: function () {
+        return [{ type: DynamicFormService, decorators: [{
+                        type: Inject,
+                        args: [DynamicFormService]
+                    }] }, { type: i2.EventsService, decorators: [{
+                        type: Inject,
+                        args: [EventsService]
+                    }] }, { type: i0.ChangeDetectorRef }, { type: i1.DynamicFormComponentService }];
+    }, propDecorators: { group: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], labelPrefix: [{
+                type: Input
+            }], blur: [{
+                type: Output
+            }], change: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }], contentTemplates: [{
+                type: ContentChildren,
+                args: [DynamicTemplateDirective]
+            }], viewTemplates: [{
+                type: ViewChildren,
+                args: [DynamicTemplateDirective]
+            }], onValueChange: [{
+                type: Output
+            }], onStatusChange: [{
+                type: Output
+            }], onSubmit: [{
+                type: Output
+            }], ngForm: [{
+                type: ViewChild,
+                args: [NgForm]
+            }] } });
+
+class DynamicBaseFormArrayComponent extends DynamicFormArrayComponent {
+    constructor(layoutService, validationService, injector) {
+        super(layoutService, validationService);
+        this.layoutService = layoutService;
+        this.validationService = validationService;
+        this.injector = injector;
+        this.blur = new EventEmitter();
+        this.change = new EventEmitter();
+        this.customEvent = new EventEmitter();
+        this.focus = new EventEmitter();
+    }
+    get useTabs() {
+        var _a;
+        return (_a = this.model) === null || _a === void 0 ? void 0 : _a.useTabs;
+    }
+    saveTab(index) {
+        this.model.saveTab(index, this.model, this.injector);
+    }
+    restoreTab() {
+        return this.model.restoreTab(this.model, this.injector);
+    }
+    getClass(context, place, model) {
+        var _a;
+        return [
+            context == "element" ? this.getModelClass(model) : null,
+            context == "element" ? this.getAdditionalClass(model) : null,
+            super.getClass(context, place, model),
+            model instanceof DynamicFormValueControlModel ? (_a = model.additional) === null || _a === void 0 ? void 0 : _a.classes : null
+        ].filter(cls => !!cls).join(" ");
+    }
+    getModelClass(model) {
+        const parts = collectPathAble(model, p => p.id);
+        if (parts.length == 0)
+            return "";
+        if (model instanceof DynamicFormGroupModel) {
+            return `form-group-${parts.join("-")}`;
+        }
+        return `form-control-${parts.join("-")}`;
+    }
+    getAdditionalClass(model) {
+        var _a, _b;
+        if (model instanceof DynamicFormArrayModel) {
+            return (_a = model.additional) === null || _a === void 0 ? void 0 : _a.classes;
+        }
+        if (model instanceof DynamicFormValueControlModel) {
+            return (_b = model.additional) === null || _b === void 0 ? void 0 : _b.classes;
+        }
+        return null;
+    }
+}
+DynamicBaseFormArrayComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormArrayComponent, deps: [{ token: i1.DynamicFormLayoutService }, { token: i1.DynamicFormValidationService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+DynamicBaseFormArrayComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.8", type: DynamicBaseFormArrayComponent, selector: "dynamic-base-form-array", inputs: { formLayout: "formLayout", group: "group", layout: "layout", model: "model", templates: "templates" }, outputs: { blur: "blur", change: "change", customEvent: "customEvent", focus: "focus" }, viewQueries: [{ propertyName: "components", predicate: i0.forwardRef(function () { return DynamicFormControlContainerComponent; }), descendants: true }], usesInheritance: true, ngImport: i0, template: "", isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormArrayComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "dynamic-base-form-array",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DynamicFormLayoutService }, { type: i1.DynamicFormValidationService }, { type: i0.Injector }]; }, propDecorators: { formLayout: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], templates: [{
+                type: Input
+            }], blur: [{
+                type: Output
+            }], change: [{
+                type: Output
+            }], customEvent: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }], components: [{
+                type: ViewChildren,
+                args: [forwardRef(() => DynamicFormControlContainerComponent)]
+            }] } });
+
+class DynamicBaseFormControlContainerComponent extends DynamicFormControlContainerComponent {
+    constructor(form, changeDetectorRef, componentFactoryResolver, layoutService, validationService, componentService, relationService) {
+        super(changeDetectorRef, componentFactoryResolver, layoutService, validationService, componentService, relationService);
+        this.form = form;
+        this.changeDetectorRef = changeDetectorRef;
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.layoutService = layoutService;
+        this.validationService = validationService;
+        this.componentService = componentService;
+        this.relationService = relationService;
+        this.context = null;
+        this.blur = new EventEmitter();
+        this.change = new EventEmitter();
+        this.focus = new EventEmitter();
+    }
+    get componentType() {
+        var _a;
+        return (_a = this.componentService.getCustomComponentType(this.model)) !== null && _a !== void 0 ? _a : this.getComponentType(this.model);
+    }
+    get startTemplate() {
+        return (this.model.type == DYNAMIC_FORM_CONTROL_TYPE_ARRAY)
+            ? this.layoutService.getAlignedTemplate(this.model, this.templates, "ARRAY_START")
+            : this.layoutService.getStartTemplate(this.model, this.templates);
+    }
+    get endTemplate() {
+        return (this.model.type == DYNAMIC_FORM_CONTROL_TYPE_ARRAY)
+            ? this.layoutService.getAlignedTemplate(this.model, this.templates, "ARRAY_END")
+            : this.layoutService.getEndTemplate(this.model, this.templates);
+    }
+    get formService() {
+        return this.form.formService;
+    }
+    ngOnInit() {
+        this.onDetectChanges = this.formService.onDetectChanges.subscribe(form => {
+            if (form !== this.form)
+                return;
+            this.changeDetectorRef.detectChanges();
+            this.formService.updateSelectOptions(this.model, this.control, this.form.model);
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.onDetectChanges.unsubscribe();
+    }
+    getLabel() {
+        var _a;
+        const label = collectPathAble(this.model, p => p.label);
+        if (label.length == 0)
+            return "";
+        if ((_a = this.form) === null || _a === void 0 ? void 0 : _a.labelPrefix) {
+            label.unshift(this.form.labelPrefix);
+        }
+        return label.join(".");
+    }
+    createFormControlComponent() {
+        var _a;
+        super.createFormControlComponent();
+        const component = (_a = this.componentRef) === null || _a === void 0 ? void 0 : _a.instance;
+        if (!component || !ObjectUtils.isFunction(component.onCreated))
+            return;
+        component.onCreated();
+    }
+    getComponentType(model) {
+        return null;
+    }
+}
+DynamicBaseFormControlContainerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormControlContainerComponent, deps: [{ token: DynamicBaseFormComponent }, { token: i0.ChangeDetectorRef }, { token: i0.ComponentFactoryResolver }, { token: i1.DynamicFormLayoutService }, { token: i1.DynamicFormValidationService }, { token: i1.DynamicFormComponentService }, { token: i1.DynamicFormRelationService }], target: i0.ɵɵFactoryTarget.Component });
+DynamicBaseFormControlContainerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.8", type: DynamicBaseFormControlContainerComponent, selector: "dynamic-base-form-control", inputs: { context: "context", group: "group", hostClass: "hostClass", inputTemplateList: ["templates", "inputTemplateList"], layout: "layout", model: "model" }, outputs: { blur: "blur", change: "change", focus: "focus" }, host: { properties: { "class": "this.klass" } }, queries: [{ propertyName: "contentTemplateList", predicate: DynamicTemplateDirective }], viewQueries: [{ propertyName: "componentViewContainerRef", first: true, predicate: ["componentViewContainer"], descendants: true, read: ViewContainerRef, static: true }], usesInheritance: true, ngImport: i0, template: "", isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormControlContainerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "dynamic-base-form-control",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: DynamicBaseFormComponent }, { type: i0.ChangeDetectorRef }, { type: i0.ComponentFactoryResolver }, { type: i1.DynamicFormLayoutService }, { type: i1.DynamicFormValidationService }, { type: i1.DynamicFormComponentService }, { type: i1.DynamicFormRelationService }]; }, propDecorators: { contentTemplateList: [{
+                type: ContentChildren,
+                args: [DynamicTemplateDirective]
+            }], klass: [{
+                type: HostBinding,
+                args: ["class"]
+            }], context: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }], hostClass: [{
+                type: Input
+            }], inputTemplateList: [{
+                type: Input,
+                args: ["templates"]
+            }], layout: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], blur: [{
+                type: Output
+            }], change: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }], componentViewContainerRef: [{
+                type: ViewChild,
+                args: ["componentViewContainer", { read: ViewContainerRef, static: true }]
+            }] } });
+
+class DynamicBaseFormGroupComponent extends DynamicFormGroupComponent {
+    constructor(layoutService, validationService) {
+        super(layoutService, validationService);
+        this.layoutService = layoutService;
+        this.validationService = validationService;
+        this.blur = new EventEmitter();
+        this.change = new EventEmitter();
+        this.customEvent = new EventEmitter();
+        this.focus = new EventEmitter();
+    }
+    getClass(context, place, model) {
+        return [
+            context == "element" ? this.getModelClass(model) : null,
+            context == "element" ? this.getAdditionalClass(model) : null,
+            super.getClass(context, place, model)
+        ].filter(cls => !!cls).join(" ");
+    }
+    getModelClass(model) {
+        const parts = collectPathAble(model, p => p.id);
+        if (parts.length == 0)
+            return "";
+        if (model instanceof DynamicFormGroupModel) {
+            return `form-group-${parts.join("-")}`;
+        }
+        return `form-control-${parts.join("-")}`;
+    }
+    getAdditionalClass(model) {
+        var _a, _b;
+        if (model instanceof DynamicFormArrayModel) {
+            return (_a = model.additional) === null || _a === void 0 ? void 0 : _a.classes;
+        }
+        if (model instanceof DynamicFormValueControlModel) {
+            return (_b = model.additional) === null || _b === void 0 ? void 0 : _b.classes;
+        }
+        return null;
+    }
+}
+DynamicBaseFormGroupComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormGroupComponent, deps: [{ token: i1.DynamicFormLayoutService }, { token: i1.DynamicFormValidationService }], target: i0.ɵɵFactoryTarget.Component });
+DynamicBaseFormGroupComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.8", type: DynamicBaseFormGroupComponent, selector: "dynamic-base-form-group", inputs: { formLayout: "formLayout", group: "group", layout: "layout", model: "model", templates: "templates" }, outputs: { blur: "blur", change: "change", customEvent: "customEvent", focus: "focus" }, viewQueries: [{ propertyName: "components", predicate: i0.forwardRef(function () { return DynamicFormControlContainerComponent; }), descendants: true }], usesInheritance: true, ngImport: i0, template: "", isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormGroupComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "dynamic-base-form-group",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DynamicFormLayoutService }, { type: i1.DynamicFormValidationService }]; }, propDecorators: { formLayout: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], templates: [{
+                type: Input
+            }], blur: [{
+                type: Output
+            }], change: [{
+                type: Output
+            }], customEvent: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }], components: [{
+                type: ViewChildren,
+                args: [forwardRef(() => DynamicFormControlContainerComponent)]
+            }] } });
+
+// --- Components ---
+const components = [
+    DynamicBaseFormComponent,
+    DynamicBaseFormArrayComponent,
+    DynamicBaseFormControlContainerComponent,
+    DynamicBaseFormGroupComponent
+];
+// --- Directives ---
+const directives = [
+    AsyncSubmitDirective,
+];
+// --- Pipes ---
+const pipes = [];
+function defaultFormControlProvider() {
+    return () => null;
+}
+
+class NgxDynamicFormModule {
+    static forRoot(config) {
+        return {
+            ngModule: NgxDynamicFormModule,
+            providers: [
+                DynamicFormService,
+                {
+                    provide: DynamicFormService$1,
+                    useExisting: DynamicFormService
+                },
+                {
+                    provide: DYNAMIC_FORM_CONTROL_MAP_FN,
+                    useFactory: ((config === null || config === void 0 ? void 0 : config.controlProvider) || defaultFormControlProvider),
+                    deps: [Injector]
+                }
+            ]
+        };
+    }
+}
+NgxDynamicFormModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxDynamicFormModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgxDynamicFormModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxDynamicFormModule, declarations: [DynamicBaseFormComponent, DynamicBaseFormArrayComponent, DynamicBaseFormControlContainerComponent, DynamicBaseFormGroupComponent, AsyncSubmitDirective], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        NgxUtilsModule], exports: [DynamicBaseFormComponent, DynamicBaseFormArrayComponent, DynamicBaseFormControlContainerComponent, DynamicBaseFormGroupComponent, AsyncSubmitDirective, FormsModule,
+        ReactiveFormsModule,
+        NgxUtilsModule] });
+NgxDynamicFormModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxDynamicFormModule, providers: [
+        ...pipes,
+        { provide: NG_VALIDATORS, useValue: validateJSON, multi: true },
+        { provide: NG_VALIDATORS, useValue: validateRequiredTranslation, multi: true },
+        { provide: NG_VALIDATORS, useValue: validateItemsMinLength, multi: true },
+        { provide: NG_VALIDATORS, useValue: validateItemsMaxLength, multi: true },
+        { provide: NG_VALIDATORS, useValue: validateItemsMinValue, multi: true },
+        { provide: NG_VALIDATORS, useValue: validateItemsMaxValue, multi: true },
+        {
+            provide: DYNAMIC_VALIDATORS,
+            useValue: new Map([
+                ["json", validateJSON],
+                ["requiredTranslation", validateRequiredTranslation],
+                ["phone", validatePhone],
+                ["itemsMinLength", validateItemsMinLength],
+                ["itemsMaxLength", validateItemsMaxLength],
+                ["itemsMinValue", validateItemsMinValue],
+                ["itemsMaxValue", validateItemsMaxValue],
+            ])
+        }
+    ], imports: [[
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            NgxUtilsModule
+        ], FormsModule,
+        ReactiveFormsModule,
+        NgxUtilsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxDynamicFormModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ...components,
+                        ...directives,
+                        ...pipes
+                    ],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        NgxUtilsModule
+                    ],
+                    exports: [
+                        ...components,
+                        ...directives,
+                        ...pipes,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        NgxUtilsModule
+                    ],
+                    entryComponents: components,
+                    providers: [
+                        ...pipes,
+                        { provide: NG_VALIDATORS, useValue: validateJSON, multi: true },
+                        { provide: NG_VALIDATORS, useValue: validateRequiredTranslation, multi: true },
+                        { provide: NG_VALIDATORS, useValue: validateItemsMinLength, multi: true },
+                        { provide: NG_VALIDATORS, useValue: validateItemsMaxLength, multi: true },
+                        { provide: NG_VALIDATORS, useValue: validateItemsMinValue, multi: true },
+                        { provide: NG_VALIDATORS, useValue: validateItemsMaxValue, multi: true },
+                        {
+                            provide: DYNAMIC_VALIDATORS,
+                            useValue: new Map([
+                                ["json", validateJSON],
+                                ["requiredTranslation", validateRequiredTranslation],
+                                ["phone", validatePhone],
+                                ["itemsMinLength", validateItemsMinLength],
+                                ["itemsMaxLength", validateItemsMaxLength],
+                                ["itemsMinValue", validateItemsMinValue],
+                                ["itemsMaxValue", validateItemsMaxValue],
+                            ])
+                        }
+                    ]
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AsyncSubmitDirective, DynamicBaseFormArrayComponent, DynamicBaseFormComponent, DynamicBaseFormControlContainerComponent, DynamicBaseFormGroupComponent, DynamicFormArrayModel, DynamicFormService, FormFile, FormInput, FormModel, FormSelect, FormSelectSubject, FormSerializable, FormStatic, FormSubject, MAX_INPUT_NUM, MIN_INPUT_NUM, NgxDynamicFormModule, createFormControl, createFormInput, createFormModel, createFormSelect, createFormStatic, defaultSerializer, defineFormControl, getFormControl, getFormSerializer, validateItemsMaxLength, validateItemsMaxValue, validateItemsMinLength, validateItemsMinValue, validateJSON, validatePhone, validateRequiredTranslation };
+//# sourceMappingURL=stemy-ngx-dynamic-form.mjs.map