@stemy/ngx-dynamic-form 13.3.12 → 19.0.1

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

@@ -0,0 +1,1993 @@
+import * as i1 from '@ng-dynamic-forms/core';
+import { DynamicInputControlModel, DYNAMIC_FORM_CONTROL_TYPE_EDITOR, serializable, DynamicFormArrayGroupModel as DynamicFormArrayGroupModel$1, DynamicFormArrayModel as DynamicFormArrayModel$1, DynamicFormGroupModel as DynamicFormGroupModel$1, DynamicFormOption as DynamicFormOption$1, DynamicSelectModel as DynamicSelectModel$1, DynamicCheckboxModel, DynamicDatePickerModel, DynamicInputModel, DynamicTextAreaModel, DynamicFileUploadModel, DynamicFormService as DynamicFormService$1, DynamicFormValueControlModel, DynamicFormComponent, DynamicTemplateDirective, DynamicFormControlContainerComponent, DYNAMIC_FORM_CONTROL_TYPE_ARRAY, DynamicFormArrayComponent, DynamicFormControlComponent, DynamicFormGroupComponent, DYNAMIC_FORM_CONTROL_MAP_FN, DYNAMIC_VALIDATORS } from '@ng-dynamic-forms/core';
+export { DYNAMIC_FORM_CONTROL_TYPE_ARRAY, DYNAMIC_FORM_CONTROL_TYPE_CHECKBOX, DYNAMIC_FORM_CONTROL_TYPE_CHECKBOX_GROUP, DYNAMIC_FORM_CONTROL_TYPE_DATEPICKER, DYNAMIC_FORM_CONTROL_TYPE_EDITOR, DYNAMIC_FORM_CONTROL_TYPE_FILE_UPLOAD, DYNAMIC_FORM_CONTROL_TYPE_GROUP, DYNAMIC_FORM_CONTROL_TYPE_INPUT, DYNAMIC_FORM_CONTROL_TYPE_RADIO_GROUP, DYNAMIC_FORM_CONTROL_TYPE_SELECT, DYNAMIC_FORM_CONTROL_TYPE_TEXTAREA, DynamicCheckboxGroupModel, DynamicCheckboxModel, DynamicDatePickerModel, DynamicFileUploadModel, DynamicFormControlComponent, DynamicFormControlModel, DynamicFormsCoreModule, DynamicInputModel, DynamicListDirective, DynamicRadioGroupModel, DynamicTemplateDirective, DynamicTextAreaModel } from '@ng-dynamic-forms/core';
+import * as i2 from '@stemy/ngx-utils';
+import { ObjectUtils, TimerUtils, cachedFactory, StringUtils, OpenApiService, TOASTER_SERVICE, ObservableUtils, EventsService, NgxUtilsModule } from '@stemy/ngx-utils';
+import { __decorate } from 'tslib';
+import { BehaviorSubject, of, isObservable, Subject, firstValueFrom, Subscription } from 'rxjs';
+import { map, debounceTime, groupBy, mergeMap, first } from 'rxjs/operators';
+import * as i0 from '@angular/core';
+import { Injector, Injectable, Inject, EventEmitter, Directive, Input, Output, HostBinding, HostListener, Component, ChangeDetectionStrategy, ContentChildren, ViewChildren, ViewContainerRef, ViewChild, forwardRef, NgModule } from '@angular/core';
+import { FormGroup, FormArray, FormsModule, ReactiveFormsModule, NG_VALIDATORS } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+
+class DynamicEditorModel extends DynamicInputControlModel {
+    type = DYNAMIC_FORM_CONTROL_TYPE_EDITOR;
+    inputType;
+    convertObject;
+    constructor(config, layout) {
+        super(config, layout);
+        this.inputType = config.inputType || "javascript";
+        this.convertObject = config.convertObject !== false;
+    }
+}
+__decorate([
+    serializable()
+], DynamicEditorModel.prototype, "type", void 0);
+
+class DynamicFormArrayGroupModel extends DynamicFormArrayGroupModel$1 {
+    context;
+    get hidden() {
+        return this.isHidden;
+    }
+    set hidden(value) {
+        if (this.isHidden == value)
+            return;
+        this.isHidden = value || false;
+        this.context?.filterGroups();
+    }
+    isHidden;
+    constructor(context, group, index = -1) {
+        super(context, group, index);
+        this.context = context;
+        this.isHidden = false;
+    }
+}
+class DynamicFormArrayModel extends DynamicFormArrayModel$1 {
+    config;
+    filteredGroups;
+    sortable;
+    useTabs;
+    saveTab;
+    restoreTab;
+    getTabLabel;
+    additional;
+    groups = [];
+    tabIndex = 0;
+    _sortBy;
+    _sortDescending;
+    _formArray;
+    _filteredGroups;
+    _filterTimer;
+    get addItem() {
+        return this.config.addItem !== false;
+    }
+    get insertItem() {
+        return !this._sortBy && this.config.insertItem !== false;
+    }
+    get cloneItem() {
+        return this.config.cloneItem !== false;
+    }
+    get moveItem() {
+        return !this._sortBy && this.config.moveItem !== false;
+    }
+    get removeItem() {
+        return this.config.removeItem !== false;
+    }
+    get clearItems() {
+        return this.config.clearItems !== false;
+    }
+    get sortBy() {
+        return this._sortBy;
+    }
+    set sortBy(value) {
+        if (!this.sortable)
+            return;
+        value = value || null;
+        if (this._sortBy !== value) {
+            this._sortBy = value;
+            this._sortDescending = false;
+        }
+        else if (this._sortDescending) {
+            this._sortBy = null;
+            this._sortDescending = false;
+        }
+        else {
+            this._sortDescending = true;
+        }
+        this.filterGroups();
+    }
+    get sortDescending() {
+        return this._sortDescending;
+    }
+    get sortOrder() {
+        return this.sortDescending ? "desc" : "asc";
+    }
+    constructor(config, layout) {
+        super(config, layout);
+        this.config = config;
+        this.filteredGroups = new BehaviorSubject([]);
+        this.sortable = config.sortable || false;
+        this.useTabs = config.useTabs || false;
+        this.saveTab = ObjectUtils.isFunction(config.saveTab) ? config.saveTab : ((index, model, arrayModel) => {
+            arrayModel.tabIndex = index;
+        });
+        this.restoreTab = ObjectUtils.isFunction(config.restoreTab) ? config.restoreTab : ((model) => {
+            return model.tabIndex;
+        });
+        this.getTabLabel = ObjectUtils.isFunction(config.getTabLabel) ? config.getTabLabel : ((index) => {
+            return `${index + 1}`;
+        });
+        this.additional = config.additional || {};
+        this.tabIndex = 0;
+        this._sortBy = null;
+        this._sortDescending = false;
+        this._formArray = null;
+    }
+    initialize(array) {
+        this._formArray = array || this._formArray;
+        this.filterGroups();
+    }
+    filterGroups() {
+        this._filterTimer = this._filterTimer || TimerUtils.createTimeout();
+        this._filterTimer.set(() => {
+            const filtered = this.groups.filter(g => !g.hidden);
+            if (this._sortBy && this._formArray) {
+                const compare = this._sortDescending
+                    ? (a, b) => this.compareModels(b, a)
+                    : (a, b) => this.compareModels(a, b);
+                filtered.sort(compare);
+            }
+            this._filteredGroups = filtered;
+            this.filteredGroups.next(filtered);
+        }, 100);
+    }
+    getFiltered(index) {
+        return !this._filteredGroups ? null : this._filteredGroups[index];
+    }
+    insertGroup(index) {
+        const group = new DynamicFormArrayGroupModel(this, this.groupFactory());
+        this.groups.splice(index, 0, group);
+        this.groups.forEach((g, index) => g.index = index);
+        this.filterGroups();
+        return group;
+    }
+    moveGroup(index, step) {
+        super.moveGroup(index, step);
+        this.filterGroups();
+    }
+    removeGroup(index) {
+        super.removeGroup(index);
+        this.filterGroups();
+    }
+    compareModels(a, b) {
+        const aGroup = this._formArray.at(a.index).get(this._sortBy)?.value || null;
+        const bGroup = this._formArray.at(b.index).get(this._sortBy)?.value || null;
+        return ObjectUtils.compare(aGroup, bGroup);
+    }
+}
+
+class DynamicFormGroupModel extends DynamicFormGroupModel$1 {
+    groups;
+    constructor(config, layout) {
+        super(config, layout);
+        const controls = [...config.group];
+        const groups = [];
+        const sets = config.fieldSets || [];
+        for (const fs of sets) {
+            const fields = [];
+            for (const f of fs.fields) {
+                const ix = controls.findIndex(c => c.id === f);
+                if (ix < 0)
+                    continue;
+                fields.push(controls.splice(ix, 1)[0]);
+            }
+            if (fields.length === 0)
+                continue;
+            groups.push({ id: fs.id, legend: fs.legend, fields });
+        }
+        if (controls.length > 0) {
+            groups.unshift({ id: "root-controls", legend: config.legend, fields: controls });
+        }
+        this.groups = groups;
+    }
+}
+
+const ignoredKeys = ["disabled", "label", "value", "classes"];
+class DynamicFormOption extends DynamicFormOption$1 {
+    classes;
+    props;
+    constructor(config) {
+        super(config);
+        this.classes = config.classes || "";
+        this.props = Object.keys(config).reduce((res, k) => {
+            if (ignoredKeys.indexOf(k) >= 0)
+                return res;
+            res[k] = config[k];
+            return res;
+        }, {});
+    }
+}
+class DynamicSelectModel extends DynamicSelectModel$1 {
+    groupBy;
+    inline;
+    getClasses;
+    allowEmpty;
+    options$ = null;
+    mOptions;
+    constructor(config, layout) {
+        super(config, layout);
+        this.groupBy = config.groupBy || null;
+        this.inline = config.inline || false;
+        this.getClasses = ObjectUtils.isFunction(config.getClasses) ? config.getClasses : (() => "");
+        this.allowEmpty = config.allowEmpty || false;
+        this.mOptions = this.mOptions || [];
+    }
+    updateOptions() {
+        this.options$ = of(this.mOptions);
+    }
+    set options(options) {
+        if (Array.isArray(options)) {
+            this.mOptions = options.map(optionConfig => new DynamicFormOption(optionConfig));
+            this.updateOptions();
+        }
+        else if (isObservable(options)) {
+            this.options$ = options.pipe(map(optionsConfig => {
+                this.mOptions = optionsConfig.map(optionConfig => new DynamicFormOption(optionConfig));
+                return this.mOptions;
+            }));
+        }
+        else {
+            this.updateOptions();
+        }
+    }
+    get options() {
+        return this.mOptions;
+    }
+    insert(index, optionConfig) {
+        const option = new DynamicFormOption(optionConfig);
+        this.mOptions.splice(index, 0, option);
+        this.updateOptions();
+        return option;
+    }
+    remove(...indices) {
+        indices.forEach(index => this.mOptions.splice(index, 1));
+        this.updateOptions();
+    }
+}
+
+function createFormConfig(id, config) {
+    const res = (config || { id });
+    res.id = id;
+    res.label = ObjectUtils.isNullOrUndefined(config.label) ? id : config.label;
+    res.disabled = config.disabled || false;
+    res.hidden = config.hidden || false;
+    return res;
+}
+function createFormCheckbox(id, config, layout) {
+    const res = createFormConfig(id, config);
+    res.indeterminate = config.indeterminate || false;
+    return new DynamicCheckboxModel(res, layout);
+}
+function createFormDate(id, config, layout) {
+    const res = createFormConfig(id, config);
+    res.autoFocus = config.autoFocus || false;
+    res.focusedDate = config.focusedDate || new Date();
+    res.inline = config.inline || false;
+    return new DynamicDatePickerModel(res, layout);
+}
+function createFormEditor(id, config, layout) {
+    const res = createFormConfig(id, config);
+    return new DynamicEditorModel(res, layout);
+}
+function createFormArray(id, config, layout) {
+    const res = createFormConfig(id, config);
+    return new DynamicFormArrayModel(res, layout);
+}
+function createFormGroup(id, config, layout) {
+    const res = createFormConfig(id, config);
+    res.name = config.name || "";
+    return new DynamicFormGroupModel(res, layout);
+}
+function createFormInput(id, config, type = "text", layout) {
+    const res = createFormConfig(id, config);
+    res.inputType = config.inputType || type;
+    res.placeholder = config.placeholder || (config.inputType == "mask" ? "_" : "");
+    res.step = config.step || 1;
+    res.mask = config.mask || null;
+    return new DynamicInputModel(res, layout);
+}
+function createFormSelect(id, config, layout) {
+    const res = createFormConfig(id, config);
+    res.options = config.options || [];
+    return new DynamicSelectModel(res, layout);
+}
+function createFormTextarea(id, config, layout) {
+    const res = createFormConfig(id, config);
+    res.cols = config.cols || 10;
+    res.rows = config.rows || 3;
+    res.wrap = config.wrap || "soft";
+    return new DynamicTextAreaModel(res, layout);
+}
+function createFormFile(id, config, layout) {
+    const res = createFormConfig(id, config);
+    res.accept = config.accept || ["jpg", "jpeg", "png"];
+    res.multiple = config.multiple || false;
+    res.url = ObjectUtils.isString(config.url) ? config.url : "assets";
+    return new DynamicFileUploadModel(res, layout);
+}
+
+function getFormComponent(...providers) {
+    const factory = cachedFactory(providers);
+    return (model, injector) => {
+        const customizers = factory(injector);
+        for (const customizer of customizers) {
+            const component = customizer.acceptModel(model) ? customizer.getFormComponent(model) : null;
+            if (component) {
+                return component;
+            }
+        }
+        return null;
+    };
+}
+function customizeFormModel(...providers) {
+    const factory = cachedFactory(providers);
+    return async (property, schema, model, config, injector) => {
+        const customizers = factory(injector);
+        for (const customizer of customizers) {
+            const accept = customizer.acceptModel(model);
+            if (accept) {
+                return customizer.customizeModel(model, config, property, schema);
+            }
+        }
+        return model;
+    };
+}
+
+function isStringWithVal(val) {
+    return typeof val == "string" && val.length > 0;
+}
+function findRefs(property) {
+    const refs = Array.isArray(property.allOf)
+        ? property.allOf.map(o => o.$ref).filter(isStringWithVal)
+        : [property.items?.$ref, property.$ref].filter(isStringWithVal);
+    return refs.map(t => t.split("/").pop());
+}
+function replaceSpecialChars(str, to = "-") {
+    return `${str}`.replace(/[&\/\\#, +()$~%.@'":*?<>{}]/g, to);
+}
+function mergeFormModels(formModels) {
+    const res = [];
+    for (const formModel of formModels) {
+        for (const subModel of formModel) {
+            const index = res.findIndex(t => t.id == subModel.id);
+            if (index >= 0) {
+                res[index] = subModel;
+                continue;
+            }
+            res.push(subModel);
+        }
+    }
+    return res;
+}
+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;
+}
+function getDynamicPath(start) {
+    return collectPathAble(start, t => t.id).join(".");
+}
+const MIN_INPUT_NUM = -999999999;
+const MAX_INPUT_NUM = 999999999;
+const EDITOR_FORMATS = ["php", "json", "html", "css", "scss"];
+
+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 };
+    };
+}
+
+const indexLabels = ["$ix", "$pix"];
+class FormSubject extends Subject {
+    notifyCallback;
+    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 => {
+            if (options.length == 0) {
+                this.next(options);
+                return;
+            }
+            const currentVal = control.value;
+            if (controlModel.multiple) {
+                const correctVal = (currentVal || []).filter(t => options.findIndex(o => o.value == t) >= 0);
+                if (correctVal.length !== currentVal?.length) {
+                    control.setValue(correctVal, { onlySelf: true, emitEvent: false });
+                }
+            }
+            else {
+                const option = options.find(t => t.value == currentVal);
+                if (!option) {
+                    control.setValue(controlModel.allowEmpty ? null : options[0]?.value ?? null, { onlySelf: true, emitEvent: false });
+                }
+            }
+            this.next(options);
+        });
+    }
+}
+
+function getFormValidationErrors(controls, parentPath = "") {
+    const errors = [];
+    Object.entries(controls).forEach(([name, control], ix) => {
+        const path = !parentPath ? name : `${parentPath}.${name}`;
+        if (control instanceof FormGroup) {
+            getFormValidationErrors(control.controls, path).forEach(error => errors.push(error));
+            return;
+        }
+        if (control instanceof FormArray) {
+            control.controls.forEach((control, ix) => {
+                getFormValidationErrors(control.controls, `${path}.${ix}`).forEach(error => errors.push(error));
+            });
+            return;
+        }
+        Object.entries(control.errors || {}).forEach(([errorKey, errorValue]) => {
+            errors.push({ control, path, errorKey, errorValue });
+        });
+    });
+    return errors;
+}
+
+class DynamicFormService extends DynamicFormService$1 {
+    openApi;
+    injector;
+    get api() {
+        return this.openApi.api;
+    }
+    get language() {
+        return this.api.language;
+    }
+    schemas;
+    constructor(cs, vs, openApi, injector) {
+        super(cs, vs);
+        this.openApi = openApi;
+        this.injector = injector;
+    }
+    patchGroup(value, formModel, formGroup) {
+        value = ObjectUtils.copy(value);
+        this.patchValueRecursive(value, formModel, formGroup);
+        formGroup.patchValue(value);
+        this.detectChanges();
+    }
+    patchForm(value, component) {
+        value = ObjectUtils.copy(value);
+        this.patchValueRecursive(value, component.model, component.group);
+        component.group.patchValue(value);
+        this.detectChanges(component);
+    }
+    serialize(formModel, formGroup) {
+        return this.serializeRecursive(formModel, formGroup);
+    }
+    notifyChanges(formModel, formGroup) {
+        this.notifyChangesRecursive(formModel, formGroup, formModel);
+    }
+    showErrors(form) {
+        this.showErrorsForGroup(form.group);
+        this.detectChanges(form);
+    }
+    getErrors(form) {
+        this.showErrors(form);
+        return new Promise(resolve => {
+            setTimeout(() => {
+                resolve(getFormValidationErrors(form.group.controls, ""));
+            }, 500);
+        });
+    }
+    patchValueRecursive(value, formModel, formGroup) {
+        if (!value)
+            return;
+        formModel?.forEach(subModel => {
+            const key = subModel.id;
+            const subValue = value[key];
+            const subControl = this.findControlByModel(subModel, formGroup);
+            if (subModel instanceof DynamicSelectModel && ObjectUtils.isObject(subValue)) {
+                value[key] = subValue.id || subValue._id || subValue;
+                return;
+            }
+            if (subModel instanceof DynamicDatePickerModel) {
+                value[key] = this.convertToDate(subValue);
+                return;
+            }
+            if (subModel instanceof DynamicFormArrayModel) {
+                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);
+            }
+        });
+    }
+    async serializeRecursive(formModel, formGroup) {
+        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 = subModel.additional?.serializer;
+            if (ObjectUtils.isFunction(serializer)) {
+                result[subModel.id] = await serializer(subModel, subControl);
+                continue;
+            }
+            if (subModel.hidden && !subModel.additional?.serialize)
+                continue;
+            if (subModel instanceof DynamicFormArrayModel) {
+                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(await this.serializeRecursive(itemModel.group, subArray.at(i)));
+                }
+                result[subModel.id] = resArray;
+                continue;
+            }
+            if (subModel instanceof DynamicInputModel && !ObjectUtils.isNullOrUndefined(subControl.value)) {
+                result[subModel.id] = subModel.inputType == "number"
+                    ? parseFloat((`${subControl.value}` || "0").replace(/,/gi, ".")) ?? null
+                    : subControl.value;
+                continue;
+            }
+            if (subModel instanceof DynamicFormGroupModel) {
+                result[subModel.id] = await this.serializeRecursive(subModel.group, subControl);
+                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) {
+                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);
+        }
+    }
+    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);
+                }
+            }
+        }
+    }
+    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);
+            }
+        });
+    }
+    convertToDate(value) {
+        if (ObjectUtils.isNullOrUndefined(value))
+            return null;
+        const date = ObjectUtils.isDate(value)
+            ? value
+            : new Date(value);
+        return isNaN(date) ? new Date() : date;
+    }
+    async getFormModelForSchema(name, customizeModel) {
+        return (await this.getFormGroupModelForSchema(name, customizeModel)).group;
+    }
+    async getFormGroupModelForSchema(name, customizeModel) {
+        this.api.cache = {};
+        this.schemas = await this.openApi.getSchemas();
+        const fieldSets = [];
+        const customizeModels = async (property, schema, modelType, config) => {
+            const model = new modelType(config);
+            if (model instanceof DynamicFormValueControlModel) {
+                model.value = (model instanceof DynamicDatePickerModel)
+                    ? this.convertToDate(property.default) : property.default;
+            }
+            if (!ObjectUtils.isFunction(customizeModel))
+                return [model];
+            let res = customizeModel(property, schema, model, config, this.injector);
+            if (!res)
+                return [model];
+            if (res instanceof Promise) {
+                res = await res;
+            }
+            return Array.isArray(res) ? res : [res];
+        };
+        const schema = this.schemas[name];
+        const controls = await this.getFormModelForSchemaDef(schema, fieldSets, customizeModels);
+        const idFields = [
+            createFormInput("id", { hidden: true }),
+            createFormInput("_id", { hidden: true })
+        ].filter(t => !controls.some(c => c.id == t.id));
+        const config = {
+            id: "root",
+            group: [
+                // -- Hidden id fields --
+                ...idFields,
+                // -- Main form controls --
+                ...controls
+            ],
+            fieldSets
+        };
+        const root = await customizeModels({
+            id: "root",
+            type: "object",
+            properties: schema.properties
+        }, schema, DynamicFormGroupModel, config);
+        // Check if the customized root wrapper returned an array
+        if (Array.isArray(root)) {
+            controls.length = 0;
+            for (const model of root) {
+                if (model instanceof DynamicFormGroupModel && model.id === "root") {
+                    return model;
+                }
+                else {
+                    controls.push(model);
+                }
+            }
+        }
+        return new DynamicFormGroupModel({
+            ...config,
+            group: controls
+        });
+    }
+    async getFormModelForSchemaDef(schema, fieldSets, customizeModels) {
+        if (!schema)
+            return [];
+        const keys = Object.keys(schema.properties || {});
+        const controls = [];
+        for (const p of keys) {
+            const property = schema.properties[p];
+            const fsName = property.hidden ? null : String(property.fieldSet || "");
+            if (fsName) {
+                const fs = fieldSets.find(t => t.id === fsName);
+                if (fs) {
+                    fs.fields.push(p);
+                }
+                else {
+                    fieldSets.push({ id: fsName, legend: `legend.${fsName}`, fields: [p] });
+                }
+            }
+            const models = await this.getFormControlModels(property, schema, customizeModels);
+            controls.push(...models);
+        }
+        return controls.filter(t => null !== t);
+    }
+    checkIsEditorProperty(property) {
+        if (!property.format)
+            return false;
+        return EDITOR_FORMATS.indexOf(property.format) >= 0 || property.format.endsWith("script");
+    }
+    async getFormControlModels(property, schema, customizeModels) {
+        const $enum = property.items?.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":
+            case "textarea":
+                if (this.checkIsEditorProperty(property)) {
+                    return customizeModels(property, schema, DynamicEditorModel, this.getFormEditorConfig(property, schema));
+                }
+                if (property.format == "textarea") {
+                    return customizeModels(property, schema, DynamicTextAreaModel, this.getFormTextareaConfig(property, schema));
+                }
+                if (property.format == "date") {
+                    return customizeModels(property, schema, DynamicDatePickerModel, this.getFormDatepickerConfig(property, schema));
+                }
+                return customizeModels(property, schema, DynamicInputModel, this.getFormInputConfig(property, schema));
+            case "object":
+                return customizeModels(property, schema, DynamicEditorModel, this.getFormEditorConfig(property, schema));
+            case "boolean":
+                return customizeModels(property, schema, DynamicCheckboxModel, this.getFormCheckboxConfig(property, schema));
+            case "array":
+                if (findRefs(property).length > 0) {
+                    return customizeModels(property, schema, DynamicFormArrayModel, await 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 (findRefs(property).length > 0) {
+            return customizeModels(property, schema, DynamicFormGroupModel, await 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 || parent instanceof DynamicFormArrayGroupModel) {
+            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)
+        };
+    }
+    async getFormArrayConfig(property, schema, customizeModels) {
+        const fieldSets = [];
+        const subSchemas = findRefs(property).map(ref => this.schemas[ref]);
+        const subModels = await Promise.all(subSchemas.map(s => this.getFormModelForSchemaDef(s, fieldSets, customizeModels)));
+        return Object.assign(this.getFormControlConfig(property, schema), {
+            groupFactory: () => mergeFormModels(ObjectUtils.copy(subModels)),
+            initialCount: property.initialCount || 0,
+            sortable: property.sortable || false,
+            useTabs: property.useTabs || false,
+            addItem: property.addItem !== false,
+            insertItem: property.insertItem !== false,
+            cloneItem: property.cloneItem !== false,
+            moveItem: property.moveItem !== false,
+            removeItem: property.removeItem !== false,
+            clearItems: property.clearItems !== false
+        });
+    }
+    async getFormGroupConfig(property, schema, customizeModels) {
+        const fieldSets = [];
+        const subSchemas = findRefs(property).map(ref => this.schemas[ref]);
+        const subModels = await Promise.all(subSchemas.map(s => this.getFormModelForSchemaDef(s, fieldSets, customizeModels)));
+        return Object.assign(this.getFormControlConfig(property, schema), {
+            fieldSets,
+            group: mergeFormModels(subModels)
+        });
+    }
+    getFormInputConfig(property, schema) {
+        let inputType = StringUtils.has(property.id, "password", "Password") ? "password" : (property.format || property.items?.type || property.type);
+        switch (inputType) {
+            case "string":
+                inputType = "text";
+                break;
+            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) ? 0 : sub.minLength,
+            maxLength: isNaN(sub.maxLength) ? MAX_INPUT_NUM : sub.maxLength,
+            placeholder: property.placeholder || ""
+        });
+    }
+    getFormEditorConfig(property, schema) {
+        const sub = property.type == "array" ? property.items || property : property;
+        return Object.assign(this.getFormControlConfig(property, schema), {
+            inputType: property.format || "json",
+            convertObject: property.type !== "string",
+            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,
+            minLength: isNaN(sub.minLength) ? 0 : 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",
+            minLength: isNaN(property.minLength) ? 0 : property.minLength,
+            maxLength: isNaN(property.maxLength) ? MAX_INPUT_NUM : property.maxLength,
+            placeholder: property.placeholder || ""
+        });
+    }
+    getFormDatepickerConfig(property, schema) {
+        return Object.assign(this.getFormControlConfig(property, schema), {
+            format: property.dateFormat || "dd.MM.yyyy",
+            min: this.convertToDate(property.min),
+            max: this.convertToDate(property.max),
+        });
+    }
+    getFormSelectOptions(property, schema) {
+        const $enum = property.items?.enum || property.enum;
+        if (Array.isArray($enum)) {
+            return new FormSelectSubject((selectModel, formControl) => {
+                const options = $enum.map(value => {
+                    const label = property.translatable ? `${property.id}.${value}` : `${value}`;
+                    return { value, label };
+                });
+                return this.fixSelectOptions(selectModel, formControl, options);
+            });
+        }
+        if (isStringWithVal(property.optionsPath)) {
+            return new FormSelectSubject(async (selectModel, control, root, indexes) => {
+                let path = property.optionsPath;
+                let target = control;
+                let model = selectModel;
+                if (path.startsWith("$root")) {
+                    path = path.substring(5);
+                    while (target.parent) {
+                        target = target.parent;
+                    }
+                    model = root;
+                }
+                while (path.startsWith(".")) {
+                    path = path.substring(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
+                    ? await firstValueFrom(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?.label || value };
+                });
+                return this.fixSelectOptions(selectModel, control, options);
+            });
+        }
+        return new FormSelectSubject(async (selectModel, control) => {
+            console.log(control.root?.value, "form select subject");
+            const entries = Object.entries(control.root?.value || {});
+            const endpoint = entries.reduce((res, [key, value]) => {
+                return res.replace(new RegExp(`$${key}`, "gi"), `${value}`);
+            }, `${property.endpoint}`);
+            this.api.cache[endpoint] = this.api.cache[endpoint] || this.api.list(endpoint, this.api.makeListParams(1, -1)).then(result => {
+                const items = ObjectUtils.isArray(result)
+                    ? result
+                    : (ObjectUtils.isArray(result.items) ? result.items : []);
+                return items.map(i => {
+                    const item = ObjectUtils.isObject(i) ? i : { id: i };
+                    return {
+                        ...item,
+                        value: item.id || item._id,
+                        label: item[property.labelField] || item.label || item.id || item._id
+                    };
+                });
+            });
+            const options = (await this.api.cache[endpoint]).map(t => Object.assign({}, t));
+            return this.fixSelectOptions(selectModel, control, options);
+        });
+    }
+    getFormSelectConfig(property, schema) {
+        return Object.assign(this.getFormControlConfig(property, schema), {
+            options: this.getFormSelectOptions(property, schema),
+            multiple: property.type == "array",
+            groupBy: property.groupBy,
+            inline: property.inline,
+            allowEmpty: property.allowEmpty,
+        });
+    }
+    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
+        });
+    }
+    getFormCheckboxConfig(property, schema) {
+        return Object.assign(this.getFormControlConfig(property, schema), {
+            indeterminate: property.indeterminate || false
+        });
+    }
+    cloneFormArrayGroup(index, formArray, formArrayModel) {
+        this.insertFormArrayGroup(index, formArray, formArrayModel);
+        this.patchGroup(formArray.at(index + 1).value, formArrayModel.groups[index].group, formArray.at(index));
+        formArrayModel.filterGroups();
+    }
+    async fixSelectOptions(model, control, options) {
+        if (!options)
+            return [];
+        for (const option of options) {
+            option.classes = [option.classes, model.getClasses(option, model, control, this.injector)].filter(isStringWithVal).join(" ");
+            option.label = await this.language.getTranslation(option.label);
+        }
+        return options;
+    }
+    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;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: DynamicFormService, deps: [{ token: i1.DynamicFormComponentService }, { token: i1.DynamicFormValidationService }, { token: OpenApiService }, { token: Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: DynamicFormService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: DynamicFormService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.DynamicFormComponentService }, { type: i1.DynamicFormValidationService }, { type: i2.OpenApiService, decorators: [{
+                    type: Inject,
+                    args: [OpenApiService]
+                }] }, { type: i0.Injector, decorators: [{
+                    type: Inject,
+                    args: [Injector]
+                }] }] });
+
+class AsyncSubmitDirective {
+    toaster;
+    cdr;
+    elem;
+    renderer;
+    method;
+    form;
+    context;
+    onSuccess;
+    onError;
+    loading;
+    disabled;
+    callback;
+    onStatusChange;
+    onSubmit;
+    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;
+    }
+    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");
+    }
+    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.pipe(debounceTime(200)).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 === "INVALID") {
+            console.log(getFormValidationErrors(this.form.group.controls));
+        }
+        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);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: AsyncSubmitDirective, deps: [{ token: TOASTER_SERVICE }, { token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "19.0.3", type: AsyncSubmitDirective, isStandalone: false, 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: "19.0.3", ngImport: i0, type: AsyncSubmitDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: false,
+                    selector: "[async-submit]",
+                    exportAs: "async-submit"
+                }]
+        }], ctorParameters: () => [{ 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 {
+    formService;
+    events;
+    group = null;
+    groupModel = null;
+    model = null;
+    layout = null;
+    labelPrefix = "label";
+    getComponentType = null;
+    blur = new EventEmitter();
+    change = new EventEmitter();
+    focus = new EventEmitter();
+    contentTemplates = null;
+    viewTemplates = null;
+    get status() {
+        return !this.group ? null : this.group.status;
+    }
+    onValueChange = new EventEmitter();
+    onStatusChange = new EventEmitter();
+    onSubmit = new EventEmitter();
+    onDetectChanges = new EventEmitter();
+    subscription = new Subscription();
+    groupSubscription = new Subscription();
+    constructor(formService, events, changeDetectorRef, componentService) {
+        super(changeDetectorRef, componentService);
+        this.formService = formService;
+        this.events = events;
+        this.getComponentType = () => null;
+    }
+    submit() {
+        this.onSubmit.emit(this);
+    }
+    ngOnChanges(changes) {
+        this.groupSubscription.unsubscribe();
+        if (this.group) {
+            this.groupSubscription = ObservableUtils.multiSubscription(this.group.statusChanges.subscribe(() => {
+                this.onStatusChange.emit(this);
+            }), this.group.valueChanges.pipe(debounceTime(500)).subscribe(() => {
+                this.formService.notifyChanges(this.model, this.group);
+            }), this.change.pipe(groupBy(ev => ev.model))
+                .pipe(mergeMap(t => t.pipe(debounceTime(500))))
+                .subscribe(ev => {
+                this.onValueChange.emit({ ...ev, form: this });
+            }));
+        }
+        if (changes.groupModel) {
+            this.model = this.groupModel?.group;
+        }
+        if (changes.model) {
+            this.groupModel = new DynamicFormGroupModel({ id: "root", group: this.model });
+        }
+    }
+    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.notifyChanges(this.model, this.group);
+            this.formService.detectChanges(this);
+        }));
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.subscription.unsubscribe();
+        this.groupSubscription.unsubscribe();
+    }
+    detectChanges() {
+        super.detectChanges();
+        this.onDetectChanges.emit(this);
+    }
+    insertFormArrayGroup(index, formArray, formArrayModel) {
+        this.formService.insertFormArrayGroup(index, formArray, formArrayModel);
+        this.detectChanges();
+    }
+    cloneFormArrayGroup(index, formArray, formArrayModel) {
+        this.formService.cloneFormArrayGroup(index, formArray, formArrayModel);
+        this.detectChanges();
+    }
+    removeFormArrayGroup(index, formArray, formArrayModel) {
+        this.formService.removeFormArrayGroup(index, formArray, formArrayModel);
+        this.detectChanges();
+    }
+    moveFormArrayGroup(index, step, formArray, formArrayModel) {
+        this.formService.moveFormArrayGroup(index, step, formArray, formArrayModel);
+        this.detectChanges();
+    }
+    clearFormArray(formArray, formArrayModel) {
+        this.formService.clearFormArray(formArray, formArrayModel);
+        this.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();
+        });
+    }
+    async serialize(validate) {
+        if (!this.group)
+            return null;
+        if (validate) {
+            await this.validate();
+        }
+        return await this.formService.serialize(this.model, this.group);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: DynamicBaseFormComponent, deps: [{ token: DynamicFormService }, { token: EventsService }, { token: i0.ChangeDetectorRef }, { token: i1.DynamicFormComponentService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: DynamicBaseFormComponent, isStandalone: false, selector: "dynamic-base-form", inputs: { group: "group", groupModel: "groupModel", model: "model", layout: "layout", labelPrefix: "labelPrefix", getComponentType: "getComponentType" }, outputs: { blur: "blur", change: "change", focus: "focus", onValueChange: "onValueChange", onStatusChange: "onStatusChange", onSubmit: "onSubmit", onDetectChanges: "onDetectChanges" }, queries: [{ propertyName: "contentTemplates", predicate: DynamicTemplateDirective }], viewQueries: [{ 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: "19.0.3", ngImport: i0, type: DynamicBaseFormComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: false,
+                    selector: "dynamic-base-form",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.Default
+                }]
+        }], ctorParameters: () => [{ 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
+            }], groupModel: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], labelPrefix: [{
+                type: Input
+            }], getComponentType: [{
+                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
+            }], onDetectChanges: [{
+                type: Output
+            }] } });
+
+class DynamicBaseFormControlContainerComponent extends DynamicFormControlContainerComponent {
+    form;
+    cdr;
+    injector;
+    contentTemplateList = null;
+    klass = null;
+    context = null;
+    group = null;
+    hostClass = null;
+    inputTemplateList = null;
+    layout = null;
+    model = null;
+    blur = new EventEmitter();
+    change = new EventEmitter();
+    focus = new EventEmitter();
+    componentViewContainerRef = null;
+    get componentType() {
+        return this.form.getComponentType?.(this.model, this.injector)
+            ?? this.componentService.getCustomComponentType(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;
+    }
+    onDetectChanges;
+    constructor(form, cdr, injector, cfr, layoutService, validationService, componentService, relationService) {
+        super(cdr, cfr, layoutService, validationService, componentService, relationService);
+        this.form = form;
+        this.cdr = cdr;
+        this.injector = injector;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.onDetectChanges = this.form.onDetectChanges.subscribe(() => {
+            this.changeDetectorRef.detectChanges();
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.onDetectChanges.unsubscribe();
+    }
+    getLabel() {
+        const label = collectPathAble(this.model, p => p.label);
+        if (label.length == 0)
+            return "";
+        if (this.form?.labelPrefix) {
+            label.unshift(this.form.labelPrefix);
+        }
+        return label.join(".");
+    }
+    getLabelIcon() {
+        if (this.context instanceof DynamicFormArrayGroupModel) {
+            const arrayModel = this.context.context;
+            if (arrayModel && arrayModel.sortBy == this.model.id) {
+                return arrayModel.sortOrder;
+            }
+        }
+        return null;
+    }
+    clickLabel() {
+        if (this.context instanceof DynamicFormArrayGroupModel) {
+            const arrayModel = this.context.context;
+            if (arrayModel) {
+                arrayModel.sortBy = this.model.id;
+            }
+        }
+    }
+    createFormControlComponent() {
+        super.createFormControlComponent();
+        const component = this.componentRef?.instance;
+        if (!component || !ObjectUtils.isFunction(component.initialize))
+            return;
+        component.initialize(this.changeDetectorRef);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: DynamicBaseFormControlContainerComponent, deps: [{ token: DynamicBaseFormComponent }, { token: i0.ChangeDetectorRef }, { token: i0.Injector }, { token: i0.ComponentFactoryResolver }, { token: i1.DynamicFormLayoutService }, { token: i1.DynamicFormValidationService }, { token: i1.DynamicFormComponentService }, { token: i1.DynamicFormRelationService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: DynamicBaseFormControlContainerComponent, isStandalone: false, 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" } }, providers: [
+            { provide: DynamicFormControlContainerComponent, useExisting: DynamicBaseFormControlContainerComponent }
+        ], 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: "19.0.3", ngImport: i0, type: DynamicBaseFormControlContainerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: false,
+                    selector: "dynamic-base-form-control",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    providers: [
+                        { provide: DynamicFormControlContainerComponent, useExisting: DynamicBaseFormControlContainerComponent }
+                    ]
+                }]
+        }], ctorParameters: () => [{ type: DynamicBaseFormComponent }, { type: i0.ChangeDetectorRef }, { type: i0.Injector }, { 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 DynamicBaseFormArrayComponent extends DynamicFormArrayComponent {
+    form;
+    injector;
+    cdr;
+    formLayout = null;
+    group = null;
+    layout = null;
+    model = null;
+    templates = null;
+    blur = new EventEmitter();
+    change = new EventEmitter();
+    customEvent = new EventEmitter();
+    focus = new EventEmitter();
+    components = null;
+    get useTabs() {
+        return this.model?.useTabs;
+    }
+    subscription;
+    constructor(layoutService, validationService, form, injector, cdr) {
+        super(layoutService, validationService);
+        this.form = form;
+        this.injector = injector;
+        this.cdr = cdr;
+    }
+    initialize(cdr) {
+        this.subscription = this.model.filteredGroups.subscribe(filteredGroups => {
+            this.updateGroups(filteredGroups);
+        });
+        this.model.initialize(this.array);
+    }
+    ngOnDestroy() {
+        if (this.subscription)
+            this.subscription.unsubscribe();
+    }
+    saveTab(index) {
+        this.model.saveTab(index, this.model.getFiltered(index), this.model, this.injector);
+    }
+    restoreTab() {
+        return this.model.restoreTab(this.model, this.injector);
+    }
+    getTabLabel(index, model) {
+        return this.model.getTabLabel(index, model, this.model, this.array, this.injector);
+    }
+    getClass(context, place, model) {
+        return [
+            context == "element" ? this.getModelClass(model) : null,
+            context == "element" ? this.getAdditionalClass(model) : null,
+            super.getClass(context, place, model),
+            model instanceof DynamicFormValueControlModel ? model.additional?.classes : null
+        ].filter(cls => !!cls).join(" ");
+    }
+    getModelClass(model) {
+        const parts = collectPathAble(model, p => p.id);
+        if (parts.length == 0)
+            return "";
+        if (model instanceof DynamicFormGroupModel$1) {
+            return `form-group-${parts.join("-")}`;
+        }
+        return `form-control-${parts.join("-")}`;
+    }
+    getAdditionalClass(model) {
+        if (model instanceof DynamicFormArrayModel) {
+            return model.additional?.classes;
+        }
+        if (model instanceof DynamicFormValueControlModel) {
+            return model.additional?.classes;
+        }
+        return null;
+    }
+    updateGroups(filteredGroups) {
+        this.cdr.detectChanges();
+        this.components.forEach(t => t.cdr.detectChanges());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: DynamicBaseFormArrayComponent, deps: [{ token: i1.DynamicFormLayoutService }, { token: i1.DynamicFormValidationService }, { token: DynamicBaseFormComponent }, { token: i0.Injector }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: DynamicBaseFormArrayComponent, isStandalone: false, 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(() => DynamicBaseFormControlContainerComponent), descendants: true }], usesInheritance: true, ngImport: i0, template: "", isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: DynamicBaseFormArrayComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: false,
+                    selector: "dynamic-base-form-array",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: () => [{ type: i1.DynamicFormLayoutService }, { type: i1.DynamicFormValidationService }, { type: DynamicBaseFormComponent }, { type: i0.Injector }, { type: i0.ChangeDetectorRef }], 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(() => DynamicBaseFormControlContainerComponent)]
+            }] } });
+
+class DynamicBaseFormControlComponent extends DynamicFormControlComponent {
+    form;
+    injector;
+    cdr;
+    formLayout = null;
+    group = null;
+    layout = null;
+    model = null;
+    blur = new EventEmitter();
+    change = new EventEmitter();
+    focus = new EventEmitter();
+    subscription;
+    constructor(layoutService, validationService, form, injector, cdr) {
+        super(layoutService, validationService);
+        this.form = form;
+        this.injector = injector;
+        this.cdr = cdr;
+    }
+    ngAfterViewInit() {
+        this.subscription = this.control.valueChanges.pipe(debounceTime(500)).subscribe(value => {
+            this.onValueChanged(value);
+        });
+    }
+    ngOnDestroy() {
+        if (!this.subscription)
+            return;
+        this.subscription.unsubscribe();
+    }
+    submit() {
+        this.form.submit();
+    }
+    onValueChanged(value) {
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: DynamicBaseFormControlComponent, deps: [{ token: i1.DynamicFormLayoutService }, { token: i1.DynamicFormValidationService }, { token: DynamicBaseFormComponent }, { token: i0.Injector }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: DynamicBaseFormControlComponent, isStandalone: false, selector: "dynamic-base-form-control", inputs: { formLayout: "formLayout", group: "group", layout: "layout", model: "model" }, outputs: { blur: "blur", change: "change", focus: "focus" }, usesInheritance: true, ngImport: i0, template: "", isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: DynamicBaseFormControlComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: false,
+                    selector: "dynamic-base-form-control",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: () => [{ type: i1.DynamicFormLayoutService }, { type: i1.DynamicFormValidationService }, { type: DynamicBaseFormComponent }, { type: i0.Injector }, { type: i0.ChangeDetectorRef }], propDecorators: { formLayout: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], blur: [{
+                type: Output
+            }], change: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }] } });
+
+class DynamicBaseFormGroupComponent extends DynamicFormGroupComponent {
+    layoutService;
+    validationService;
+    formLayout = null;
+    group = null;
+    layout = null;
+    model = null;
+    templates = [];
+    blur = new EventEmitter();
+    change = new EventEmitter();
+    customEvent = new EventEmitter();
+    focus = new EventEmitter();
+    components = null;
+    constructor(layoutService, validationService) {
+        super(layoutService, validationService);
+        this.layoutService = layoutService;
+        this.validationService = validationService;
+    }
+    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) {
+        if (model instanceof DynamicFormArrayModel) {
+            return model.additional?.classes;
+        }
+        if (model instanceof DynamicFormValueControlModel) {
+            return model.additional?.classes;
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: DynamicBaseFormGroupComponent, deps: [{ token: i1.DynamicFormLayoutService }, { token: i1.DynamicFormValidationService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: DynamicBaseFormGroupComponent, isStandalone: false, 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(() => DynamicFormControlContainerComponent), descendants: true }], usesInheritance: true, ngImport: i0, template: "", isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: DynamicBaseFormGroupComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: false,
+                    selector: "dynamic-base-form-group",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: () => [{ 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)]
+            }] } });
+
+class DynamicBaseSelectComponent extends DynamicBaseFormControlComponent {
+    groups$;
+    hasOptions;
+    ngOnInit() {
+        this.groups$ = new BehaviorSubject([]);
+        this.subscription = this.model.options$.subscribe(options => {
+            const groupBy = this.model.inline || !this.model.multiple ? this.model.groupBy : null;
+            const grouped = options.reduce((res, option) => {
+                const key = replaceSpecialChars(groupBy ? option.props[this.model.groupBy] || "default" : "default", "-");
+                res[key] = res[key] || [];
+                res[key].push(option);
+                return res;
+            }, {});
+            const groups = Object.keys(grouped).map(group => {
+                return {
+                    group,
+                    options: grouped[group]
+                };
+            });
+            this.hasOptions = groups.length > 0;
+            this.groups$.next(groups);
+            this.cdr.detectChanges();
+        });
+    }
+    ngOnDestroy() {
+        if (this.subscription)
+            this.subscription.unsubscribe();
+    }
+    isSelected(option) {
+        if (this.model.multiple) {
+            return this.control.value?.indexOf(option.value) >= 0;
+        }
+        return this.control.value == option.value;
+    }
+    selectToggle(option, state) {
+        if (this.model.multiple) {
+            const value = Array.from(this.control.value || []);
+            const index = value.indexOf(option.value);
+            if (index >= 0) {
+                value.splice(index, 1);
+            }
+            if (state) {
+                value.push(option.value);
+            }
+            this.control.setValue(value);
+            this.onChange(value);
+            return;
+        }
+        this.control.setValue(option.value);
+        this.onChange(option.value);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: DynamicBaseSelectComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.0.3", type: DynamicBaseSelectComponent, isStandalone: false, selector: "dynamic-base-select", usesInheritance: true, ngImport: i0, template: "", isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: DynamicBaseSelectComponent, decorators: [{
+            type: Component,
+            args: [{
+                    standalone: false,
+                    selector: "dynamic-base-select",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }] });
+
+// --- Components ---
+const components = [
+    DynamicBaseFormComponent,
+    DynamicBaseFormArrayComponent,
+    DynamicBaseFormControlComponent,
+    DynamicBaseFormControlContainerComponent,
+    DynamicBaseFormGroupComponent,
+    DynamicBaseSelectComponent
+];
+// --- 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?.controlProvider || defaultFormControlProvider),
+                    deps: [Injector]
+                }
+            ]
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.3", ngImport: i0, type: NgxDynamicFormModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.0.3", ngImport: i0, type: NgxDynamicFormModule, declarations: [DynamicBaseFormComponent, DynamicBaseFormArrayComponent, DynamicBaseFormControlComponent, DynamicBaseFormControlContainerComponent, DynamicBaseFormGroupComponent, DynamicBaseSelectComponent, AsyncSubmitDirective], imports: [CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            NgxUtilsModule], exports: [DynamicBaseFormComponent, DynamicBaseFormArrayComponent, DynamicBaseFormControlComponent, DynamicBaseFormControlContainerComponent, DynamicBaseFormGroupComponent, DynamicBaseSelectComponent, AsyncSubmitDirective, FormsModule,
+            ReactiveFormsModule,
+            NgxUtilsModule] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.0.3", 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: "19.0.3", ngImport: i0, type: NgxDynamicFormModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ...components,
+                        ...directives,
+                        ...pipes
+                    ],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        NgxUtilsModule
+                    ],
+                    exports: [
+                        ...components,
+                        ...directives,
+                        ...pipes,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        NgxUtilsModule
+                    ],
+                    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, DynamicBaseFormControlComponent, DynamicBaseFormControlContainerComponent, DynamicBaseFormGroupComponent, DynamicBaseSelectComponent, DynamicEditorModel, DynamicFormArrayGroupModel, DynamicFormArrayModel, DynamicFormGroupModel, DynamicFormOption, DynamicFormService, DynamicSelectModel, EDITOR_FORMATS, FormSelectSubject, FormSubject, MAX_INPUT_NUM, MIN_INPUT_NUM, NgxDynamicFormModule, collectPathAble, createFormArray, createFormCheckbox, createFormDate, createFormEditor, createFormFile, createFormGroup, createFormInput, createFormSelect, createFormTextarea, customizeFormModel, getDynamicPath, getFormComponent, mergeFormModels, replaceSpecialChars, validateItemsMaxLength, validateItemsMaxValue, validateItemsMinLength, validateItemsMinValue, validateJSON, validatePhone, validateRequiredTranslation };
+//# sourceMappingURL=stemy-ngx-dynamic-form.mjs.map