@stemy/ngx-dynamic-form 19.2.14 → 19.3.1

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

@@ -1,6 +1,6 @@
 import * as i2 from '@stemy/ngx-utils';
-import { cachedFactory, ReflectUtils, ObjectUtils, LANGUAGE_SERVICE, API_SERVICE, StringUtils, TOASTER_SERVICE, EventsService, NgxUtilsModule } from '@stemy/ngx-utils';
-import { Subject, BehaviorSubject, startWith, distinctUntilChanged, switchMap, first, from, isObservable, firstValueFrom } from 'rxjs';
+import { cachedFactory, ReflectUtils, ObjectUtils, LANGUAGE_SERVICE, ForbiddenZone, API_SERVICE, StringUtils, TOASTER_SERVICE, EventsService, NgxUtilsModule } from '@stemy/ngx-utils';
+import { Subject, BehaviorSubject, startWith, distinctUntilChanged, switchMap, from, isObservable, firstValueFrom, first } from 'rxjs';
 import * as i0 from '@angular/core';
 import { Inject, Injectable, input, output, inject, Renderer2, ElementRef, computed, signal, effect, HostListener, HostBinding, Directive, Injector, ChangeDetectionStrategy, ViewEncapsulation, Component, makeEnvironmentProviders, NgModule } from '@angular/core';
 import * as i1 from '@angular/forms';
@@ -17,18 +17,18 @@ const FORM_ROOT_KEY = "__root";
 
 function customizeFormField(...providers) {
     const factory = cachedFactory(providers);
-    return async (property, schema, config, options, injector) => {
+    return async (field, options, injector, property, schema) => {
         const customizers = factory(injector);
-        const configs = [config];
+        const fields = [field];
         for (const customizer of customizers) {
-            const index = configs.findIndex(m => customizer.acceptField(m));
+            const index = fields.findIndex(m => customizer.acceptField(m, property, schema));
             if (index >= 0) {
-                const custom = await customizer.customizeField(configs[index], property, schema, options);
+                const custom = await customizer.customizeField(fields[index], options, property, schema);
                 const result = Array.isArray(custom) ? custom : [custom];
-                configs.splice(index, 1, ...result);
+                fields.splice(index, 1, ...result);
             }
         }
-        return configs;
+        return fields;
     };
 }
 
@@ -176,32 +176,9 @@ function maxValueValidation(max, each) {
     return validateEach(each, v => typeof v == "number" && v <= max, "maxValue");
 }
 
-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 mergeFormFields(formFields) {
-    const res = [];
-    for (const formModel of formFields) {
-        for (const subModel of formModel) {
-            const index = res.findIndex(t => t.key == subModel.key);
-            if (index >= 0) {
-                res[index] = subModel;
-                continue;
-            }
-            res.push(subModel);
-        }
-    }
-    return res;
-}
 function getFieldByPath(field, path) {
     if (field.path === path) {
         return field;
@@ -215,6 +192,18 @@ function getFieldByPath(field, path) {
     }
     return null;
 }
+function getFieldsByKey(field, key) {
+    if (field.key === key) {
+        return [field];
+    }
+    if (!field.fieldGroup)
+        return [];
+    const results = [];
+    for (const sf of field.fieldGroup) {
+        results.push(...getFieldsByKey(sf, key));
+    }
+    return results;
+}
 function setFieldHidden(field, hidden = true) {
     const hide = field.expressions?.hide;
     if (hide) {
@@ -245,6 +234,113 @@ const MIN_INPUT_NUM = -999999999;
 const MAX_INPUT_NUM = 999999999;
 const EDITOR_FORMATS = ["php", "json", "html", "css", "scss"];
 
+class ConfigForSchemaWrap {
+    opts;
+    mode;
+    injector;
+    schema;
+    get labelPrefix() {
+        return this.opts.labelPrefix;
+    }
+    get labelCustomizer() {
+        return this.opts.labelCustomizer;
+    }
+    get testId() {
+        return this.opts.testId;
+    }
+    fieldCustomizer;
+    constructor(opts, mode, injector, schema) {
+        this.opts = opts;
+        this.mode = mode;
+        this.injector = injector;
+        this.schema = schema;
+        this.fieldCustomizer = this.mode !== "wrap" || !ObjectUtils.isFunction(this.opts.fieldCustomizer)
+            ? field => field
+            : this.opts.fieldCustomizer;
+    }
+    async customize(field, property, schema) {
+        field.defaultValue = `${field.props?.type}`.startsWith("date")
+            ? convertToDate(property.default) : property.default;
+        const res = await ForbiddenZone.run("customizer", () => this.fieldCustomizer(field, this.forCustomizer(), this.injector, property, schema));
+        return !res ? [field] : handleConfigs(res);
+    }
+    forCustomizer() {
+        return new ConfigForSchemaWrap(this.opts, "customizer", this.injector, this.schema);
+    }
+    forSchema(schema) {
+        return new ConfigForSchemaWrap(this.opts, this.mode, this.injector, schema);
+    }
+}
+async function toWrapOptions(customizeOrOptions, injector, schema, errorMsg) {
+    if (errorMsg && ForbiddenZone.isForbidden("customizer")) {
+        throw new Error(errorMsg);
+    }
+    if (customizeOrOptions instanceof ConfigForSchemaWrap) {
+        return customizeOrOptions;
+    }
+    let schemaOptions = customizeOrOptions;
+    if (!ObjectUtils.isObject(schemaOptions)) {
+        schemaOptions = {
+            fieldCustomizer: customizeOrOptions
+        };
+    }
+    return new ConfigForSchemaWrap(schemaOptions, "wrap", injector, schema);
+}
+function convertToDate(value) {
+    if (ObjectUtils.isNullOrUndefined(value))
+        return null;
+    const date = ObjectUtils.isDate(value)
+        ? value
+        : new Date(value);
+    return isNaN(date) ? new Date() : date;
+}
+function handleConfigs(configs) {
+    return Array.isArray(configs) ? configs : [configs];
+}
+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 mergeFormFields(formFields) {
+    const res = [];
+    for (const formModel of formFields) {
+        for (const subModel of formModel) {
+            const index = res.findIndex(t => t.key == subModel.key);
+            if (index >= 0) {
+                res[index] = subModel;
+                continue;
+            }
+            res.push(subModel);
+        }
+    }
+    return res;
+}
+function getFormValidationErrors(controls, parentPath = "") {
+    const errors = [];
+    Object.entries(controls).forEach(([name, control], ix) => {
+        const path = !parentPath ? name : `${parentPath}.${name}`;
+        if (control instanceof FormGroup$1) {
+            getFormValidationErrors(control.controls, path).forEach(error => errors.push(error));
+            return;
+        }
+        if (control instanceof FormArray$1) {
+            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 DynamicFormBuilderService {
     injector;
     api;
@@ -254,57 +350,6 @@ class DynamicFormBuilderService {
         this.api = api;
         this.language = language;
     }
-    getLabel(key, label, parent, options) {
-        const labelPrefix = !ObjectUtils.isString(options.labelPrefix) ? `` : options.labelPrefix;
-        const pathPrefix = `${parent?.props?.label || labelPrefix}`;
-        const labelItems = ObjectUtils.isString(label)
-            ? (!label ? [] : [labelPrefix, label])
-            : [pathPrefix, `${key || ""}`];
-        return labelItems.filter(l => l.length > 0).join(".");
-    }
-    createFormField(key, type, data, props, parent, options) {
-        const validators = Array.isArray(data.validators)
-            ? data.validators.reduce((res, validator, ix) => {
-                res[validator.validatorName || `validator_${ix}`] = validator;
-                return res;
-            }, {})
-            : data.validators || {};
-        const hide = new BehaviorSubject(data.hidden === true);
-        const additional = new BehaviorSubject({});
-        return {
-            key,
-            type,
-            validators,
-            parent,
-            fieldSet: String(data.fieldSet || ""),
-            resetOnHide: false,
-            validation: {
-                messages: Object.keys(validators).reduce((res, key) => {
-                    res[key] = validationMessage(this.injector, key, options.labelPrefix);
-                    return res;
-                }, {})
-            },
-            props: {
-                ...props,
-                disabled: data.disabled === true,
-                formCheck: "nolabel",
-                required: !!validators.required,
-                label: this.getLabel(key, data.label, parent, options),
-            },
-            modelOptions: {
-                updateOn: "change"
-            },
-            fieldGroupClassName: "field-container",
-            expressions: {
-                hide,
-                additional,
-                className: (target) => {
-                    return target.hide ? `` : [`dynamic-form-field`, `dynamic-form-field-${target.key}`, `dynamic-form-${target.type || "group"}`].concat(Array.isArray(data.classes) ? data.classes : [data.classes || ""]).filter(c => c?.length > 0).join(" ");
-                },
-                ...this.getExpressions(options)
-            }
-        };
-    }
     resolveFormFields(target, parent, options) {
         const prototype = target?.prototype || {};
         const fields = ReflectUtils.getMetadata("dynamicFormFields", target?.prototype || {}) || new Set();
@@ -344,7 +389,7 @@ class DynamicFormBuilderService {
         }
         // Create a field-set wrapper for each group and concat the other fields to the end
         return Object.keys(groups).map(group => {
-            return {
+            const fieldSet = {
                 fieldGroup: groups[group],
                 wrappers: ["form-fieldset"],
                 className: `dynamic-form-fieldset dynamic-form-fieldset-${group}`,
@@ -352,11 +397,10 @@ class DynamicFormBuilderService {
                 props: {
                     label: this.getLabel(group, group, parent, options),
                     hidden: false
-                },
-                expressions: {
-                    ...this.getExpressions(options)
                 }
             };
+            this.setExpressions(fieldSet, options);
+            return fieldSet;
         }).concat(others);
     }
     createFormInput(key, data, parent, options) {
@@ -499,8 +543,61 @@ class DynamicFormBuilderService {
         control.setValue(options[0].value);
         return options;
     }
-    getExpressions(options) {
-        return {
+    getLabel(key, label, parent, options) {
+        const labelPrefix = !ObjectUtils.isString(options.labelPrefix) ? `` : options.labelPrefix;
+        const pathPrefix = `${parent?.props?.label || labelPrefix}`;
+        const labelItems = ObjectUtils.isString(label)
+            ? (!label ? [] : [labelPrefix, label])
+            : [pathPrefix, `${key || ""}`];
+        return options.labelCustomizer?.(key, label, parent, options.labelPrefix)
+            ?? labelItems.filter(l => l.length > 0).join(".");
+    }
+    createFormField(key, type, data, props, parent, options) {
+        const validators = Array.isArray(data.validators)
+            ? data.validators.reduce((res, validator, ix) => {
+                res[validator.validatorName || `validator_${ix}`] = validator;
+                return res;
+            }, {})
+            : data.validators || {};
+        const hide = new BehaviorSubject(data.hidden === true);
+        const additional = new BehaviorSubject({});
+        const field = {
+            key,
+            type,
+            validators,
+            parent,
+            fieldSet: String(data.fieldSet || ""),
+            resetOnHide: false,
+            validation: {
+                messages: Object.keys(validators).reduce((res, key) => {
+                    res[key] = validationMessage(this.injector, key, options.labelPrefix);
+                    return res;
+                }, {})
+            },
+            props: {
+                ...props,
+                disabled: data.disabled === true,
+                formCheck: "nolabel",
+                required: !!validators.required,
+                label: this.getLabel(key, data.label, parent, options),
+            },
+            modelOptions: {
+                updateOn: "change"
+            },
+            fieldGroupClassName: "field-container",
+            expressions: {
+                hide,
+                additional,
+                className: (target) => {
+                    return target.hide ? `` : [`dynamic-form-field`, `dynamic-form-field-${target.key}`, `dynamic-form-${target.type || "group"}`].concat(Array.isArray(data.classes) ? data.classes : [data.classes || ""]).filter(c => c?.length > 0).join(" ");
+                }
+            }
+        };
+        this.setExpressions(field, options);
+        return field;
+    }
+    setExpressions(field, options) {
+        const expressions = {
             path: target => {
                 const tp = target.parent;
                 const key = !target.key ? `` : `.${target.key}`;
@@ -513,6 +610,13 @@ class DynamicFormBuilderService {
                 return !tp?.testId ? `${prefix}${target.key || key}` : `${tp.testId}${key}`;
             }
         };
+        Object.entries(expressions).forEach(([key, expression]) => {
+            field.expressions = field.expressions ?? {};
+            field.expressions[key] = expression;
+            if (ObjectUtils.isFunction(expression)) {
+                field[key] = expression(field);
+            }
+        });
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DynamicFormBuilderService, deps: [{ token: i0.Injector }, { token: API_SERVICE }, { token: LANGUAGE_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DynamicFormBuilderService });
@@ -527,28 +631,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
                     args: [LANGUAGE_SERVICE]
                 }] }] });
 
-function getFormValidationErrors(controls, parentPath = "") {
-    const errors = [];
-    Object.entries(controls).forEach(([name, control], ix) => {
-        const path = !parentPath ? name : `${parentPath}.${name}`;
-        if (control instanceof FormGroup$1) {
-            getFormValidationErrors(control.controls, path).forEach(error => errors.push(error));
-            return;
-        }
-        if (control instanceof FormArray$1) {
-            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 {
+class DynamicFormSchemaService {
     openApi;
     injector;
     builder;
@@ -558,149 +641,32 @@ class DynamicFormService {
     get language() {
         return this.api.language;
     }
-    schemas;
     constructor(openApi, injector, builder) {
         this.openApi = openApi;
         this.injector = injector;
         this.builder = builder;
     }
-    async validateForm(form, showErrors = true) {
-        const group = form.group();
-        if (!group)
-            return Promise.resolve();
-        return new Promise((resolve, reject) => {
-            group.statusChanges
-                .pipe(first(status => status == "VALID" || status == "INVALID"))
-                .subscribe(status => {
-                if (showErrors) {
-                    this.showErrorsForGroup(group);
-                }
-                if (status == "VALID") {
-                    resolve(null);
-                    return;
-                }
-                reject(getFormValidationErrors(group.controls));
-            });
-            group.updateValueAndValidity();
-        });
-    }
-    async serializeForm(form, validate = true) {
-        const fields = form.config();
-        if (!fields)
-            return null;
-        if (validate) {
-            await this.validateForm(form);
-        }
-        return this.serialize(fields);
+    async getSchema(name) {
+        return this.openApi.getSchema(name);
     }
-    async serialize(fields) {
-        const result = {};
-        if (!fields)
-            return result;
-        for (const field of fields) {
-            const serializer = field.serializer;
-            const key = `${field.key}`;
-            if (ObjectUtils.isFunction(serializer)) {
-                result[key] = await serializer(field, this.injector);
-                continue;
-            }
-            if (field.hide && !field.serialize) {
-                continue;
-            }
-            const control = field.formControl;
-            if (field.fieldGroup) {
-                const group = await this.serialize(field.fieldGroup);
-                if (field.key) {
-                    result[key] = !field.fieldArray ? group : Object.values(group);
-                    continue;
-                }
-                Object.assign(result, group);
-                continue;
-            }
-            result[key] = control.value;
-        }
-        return result;
-    }
-    async getFormFieldsForSchema(name, customizeOrOptions) {
-        const group = await this.getFormFieldGroupForSchema(name, customizeOrOptions);
-        return group.fieldGroup;
-    }
-    async getFormFieldGroupForSchema(name, customizeOrOptions) {
-        this.schemas = await this.openApi.getSchemas();
-        const schemaOptions = ObjectUtils.isObject(customizeOrOptions) ? customizeOrOptions : {};
-        const customizeConfig = ObjectUtils.isFunction(customizeOrOptions) ? customizeOrOptions : schemaOptions.customizer;
-        const schema = this.schemas[name];
-        const wrapOptions = {
-            ...schemaOptions,
-            schema,
-            injector: this.injector,
-            customizer: async (property, options, config) => {
-                config.defaultValue = `${config.type}`.startsWith("date")
-                    ? this.convertToDate(property.default) : property.default;
-                if (!ObjectUtils.isFunction(customizeConfig))
-                    return [config];
-                let res = customizeConfig(property, schema, config, options, this.injector);
-                if (!res)
-                    return [config];
-                if (res instanceof Promise) {
-                    res = await res;
-                }
-                return Array.isArray(res) ? res : [res];
-            }
-        };
-        const config = {
-            key: FORM_ROOT_KEY,
-            path: "",
-            wrappers: ["form-group"]
-        };
-        const fields = await this.getFormFieldsForSchemaDef(schema, config, wrapOptions);
-        const fieldGroup = [...fields];
-        // Add id fields if necessary
-        if (fields.length > 0) {
-            const idFields = [
-                { key: "id", props: { hidden: true } },
-                { key: "_id", props: { hidden: true } },
-            ];
-            fieldGroup.unshift(...idFields
-                .filter(t => !fields.some(c => c.key == t.key)));
-        }
-        config.fieldGroup = fieldGroup;
-        const root = await wrapOptions.customizer({
-            id: FORM_ROOT_KEY,
-            type: "object",
-            properties: schema?.properties || {}
-        }, wrapOptions, config);
-        // Check if the customized root wrapper returned an array
-        fields.length = 0;
-        for (const model of root) {
-            if (model.key === FORM_ROOT_KEY) {
-                return model;
-            }
-            else {
-                fields.push(model);
-            }
-        }
-        return {
-            ...config,
-            fieldGroup: fields
-        };
-    }
-    async getFormFieldsForSchemaDef(schema, parent, options) {
+    async getFormFieldsForSchema(name, parent, customizeOrOptions) {
+        const schema = await this.getSchema(name);
         if (!schema)
             return [];
+        const options = await toWrapOptions(customizeOrOptions, this.injector, schema);
         const keys = Object.keys(schema.properties || {});
         const fields = [];
         // Collect all properties of this schema def
         for (const key of keys) {
             const property = schema.properties[key];
-            const propFields = await this.getFormFieldsForProp(property, options, parent);
+            const propFields = await this.getFormFieldsForProp(property, schema, options, parent);
             fields.push(...propFields);
         }
         return this.builder.createFieldSets(fields.filter(f => null !== f), parent, options);
     }
-    async getFormFieldsForProp(property, options, parent) {
+    async getFormFieldsForProp(property, schema, options, parent) {
         const field = await this.getFormFieldForProp(property, options, parent);
-        return !field ? [] : options.customizer(property, options, field);
+        return !field ? [] : options.customize(field, property, schema);
     }
     async getFormFieldForProp(property, options, parent) {
         const $enum = property.items?.enum || property.enum;
@@ -754,9 +720,9 @@ class DynamicFormService {
     }
     async getFormArrayConfig(property, options, parent) {
         return this.builder.createFormArray(property.id, async (sp) => {
-            const subSchemas = findRefs(property).map(ref => this.schemas[ref]);
+            const subSchemas = findRefs(property);
             if (subSchemas.length > 0) {
-                const subModels = await Promise.all(subSchemas.map(s => this.getFormFieldsForSchemaDef(s, sp, options)));
+                const subModels = await Promise.all(subSchemas.map(s => this.getFormFieldsForSchema(s, sp, options)));
                 return mergeFormFields(ObjectUtils.copy(subModels));
             }
             return this.getFormFieldForProp(property.items, options, null);
@@ -775,9 +741,9 @@ class DynamicFormService {
         }, parent, options);
     }
     async getFormGroupConfig(property, options, parent) {
-        const subSchemas = findRefs(property).map(ref => this.schemas[ref]);
         return this.builder.createFormGroup(property.id, async (sp) => {
-            const subModels = await Promise.all(subSchemas.map(s => this.getFormFieldsForSchemaDef(s, sp, options)));
+            const subSchemas = findRefs(property);
+            const subModels = await Promise.all(subSchemas.map(s => this.getFormFieldsForSchema(s, sp, options)));
             return mergeFormFields(subModels);
         }, {
             ...this.getFormFieldData(property, options),
@@ -827,7 +793,7 @@ class DynamicFormService {
             placeholder: property.placeholder || ""
         }, parent, options);
     }
-    // getFormEditorConfig(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions): DynamicEditorModelConfig {
+    // getFormEditorConfig(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrap): DynamicEditorModelConfig {
     //     const sub = property.type == "array" ? property.items || property : property;
     //     return Object.assign(
     //         this.getFormControlConfig(property, options),
@@ -851,8 +817,8 @@ class DynamicFormService {
             ...this.getFormFieldData(property, options),
             type: property.format == "date-time" ? "datetime-local" : "date",
             // format: property.dateFormat || "dd.MM.yyyy",
-            min: this.convertToDate(property.min),
-            max: this.convertToDate(property.max),
+            min: convertToDate(property.min),
+            max: convertToDate(property.max),
         }, parent, options);
     }
     getFormSelectConfig(property, options, parent) {
@@ -975,14 +941,6 @@ class DynamicFormService {
             }
         });
     }
-    convertToDate(value) {
-        if (ObjectUtils.isNullOrUndefined(value))
-            return null;
-        const date = ObjectUtils.isDate(value)
-            ? value
-            : new Date(value);
-        return isNaN(date) ? new Date() : date;
-    }
     addPropertyValidators(validators, property) {
         if (!property)
             return;
@@ -1023,12 +981,155 @@ class DynamicFormService {
             validators.itemsMaxValue = maxValueValidation(items.maximum, true);
         }
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DynamicFormService, deps: [{ token: i2.OpenApiService }, { token: i0.Injector }, { token: DynamicFormBuilderService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DynamicFormSchemaService, deps: [{ token: i2.OpenApiService }, { token: i0.Injector }, { token: DynamicFormBuilderService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DynamicFormSchemaService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DynamicFormSchemaService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i2.OpenApiService }, { type: i0.Injector }, { type: DynamicFormBuilderService }] });
+
+class DynamicFormService {
+    fs;
+    injector;
+    api;
+    constructor(fs, injector, api) {
+        this.fs = fs;
+        this.injector = injector;
+        this.api = api;
+    }
+    async getFormFieldsForSchema(name, customizeOrOptions) {
+        const group = await this.getFormFieldGroupBySchemaName(name, customizeOrOptions, "getFormFieldsForSchema");
+        return group.fieldGroup;
+    }
+    async getFormFieldGroupForSchema(name, customizeOrOptions) {
+        return this.getFormFieldGroupBySchemaName(name, customizeOrOptions, "getFormFieldsForSchema");
+    }
+    async getFormFieldGroupBySchemaName(name, customizeOrOptions, restrictedMethod) {
+        const config = {
+            key: FORM_ROOT_KEY,
+            path: "",
+            wrappers: ["form-group"]
+        };
+        const schema = await this.fs.getSchema(name);
+        const wrapOptions = await toWrapOptions(customizeOrOptions, this.injector, schema, `"DynamicFormService.${restrictedMethod}" is called from a customizer, which is not allowed. Please use DynamicFormSchemaService instead!`);
+        const fields = await this.fs.getFormFieldsForSchema(name, config, wrapOptions);
+        const fieldGroup = [...fields];
+        config.fieldGroup = fieldGroup;
+        // There are no actual fields in the schema, or no schema exists
+        if (fields.length === 0)
+            return config;
+        // Add id fields if necessary
+        const idFields = [
+            { key: "id", props: { hidden: true } },
+            { key: "_id", props: { hidden: true } },
+        ];
+        fieldGroup.unshift(...idFields
+            .filter(t => !fields.some(c => c.key == t.key)));
+        const root = await wrapOptions.customize(config, {
+            id: FORM_ROOT_KEY,
+            type: "object",
+            properties: schema?.properties || {}
+        }, schema);
+        // Check if the customized root wrapper returned an array
+        fields.length = 0;
+        for (const model of root) {
+            if (model.key === FORM_ROOT_KEY) {
+                return model;
+            }
+            else {
+                fields.push(model);
+            }
+        }
+        return {
+            ...config,
+            fieldGroup: fields
+        };
+    }
+    async validateForm(form, showErrors = true) {
+        const group = form.group();
+        if (!group)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            group.statusChanges
+                .pipe(first(status => status == "VALID" || status == "INVALID"))
+                .subscribe(status => {
+                if (showErrors) {
+                    this.showErrorsForGroup(group);
+                }
+                if (status == "VALID") {
+                    resolve(null);
+                    return;
+                }
+                reject(getFormValidationErrors(group.controls));
+            });
+            group.updateValueAndValidity();
+        });
+    }
+    async serializeForm(form, validate = true) {
+        const fields = form.config();
+        if (!fields)
+            return null;
+        if (validate) {
+            await this.validateForm(form);
+        }
+        return this.serialize(fields);
+    }
+    async serialize(fields) {
+        const result = {};
+        if (!fields)
+            return result;
+        for (const field of fields) {
+            const serializer = field.serializer;
+            const key = `${field.key}`;
+            if (ObjectUtils.isFunction(serializer)) {
+                result[key] = await serializer(field, this.injector);
+                continue;
+            }
+            if (field.hide && !field.serialize) {
+                continue;
+            }
+            const control = field.formControl;
+            if (field.fieldGroup) {
+                const group = await this.serialize(field.fieldGroup);
+                if (field.key) {
+                    result[key] = !field.fieldArray ? group : Object.values(group);
+                    continue;
+                }
+                Object.assign(result, group);
+                continue;
+            }
+            result[key] = control.value;
+        }
+        return result;
+    }
+    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$1) {
+                this.showErrorsForGroup(control);
+                return;
+            }
+            control.markAsTouched({ onlySelf: true });
+            if (control instanceof FormArray$1) {
+                this.showErrorsForControls(control.controls);
+            }
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DynamicFormService, deps: [{ token: DynamicFormSchemaService }, { token: i0.Injector }, { token: API_SERVICE }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DynamicFormService });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DynamicFormService, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: i2.OpenApiService }, { type: i0.Injector }, { type: DynamicFormBuilderService }] });
+        }], ctorParameters: () => [{ type: DynamicFormSchemaService }, { type: i0.Injector }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [API_SERVICE]
+                }] }] });
 
 class AsyncSubmitDirective {
     method = input(null, { alias: "async-submit" });
@@ -1132,6 +1233,7 @@ class DynamicFormComponent {
     events = inject(EventsService);
     languages = inject(LANGUAGE_SERVICE);
     labelPrefix = input("label");
+    labelCustomizer = input(null);
     testId = input("");
     data = input({});
     fields = input(null);
@@ -1142,6 +1244,7 @@ class DynamicFormComponent {
     config = computed(() => {
         return this.fields() || this.builder.resolveFormFields(this.data()?.constructor, null, {
             labelPrefix: this.labelPrefix(),
+            labelCustomizer: this.labelCustomizer(),
             testId: this.testId(),
         });
     });
@@ -1180,7 +1283,7 @@ class DynamicFormComponent {
         this.options?.resetModel?.();
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DynamicFormComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.14", type: DynamicFormComponent, isStandalone: false, selector: "dynamic-form", inputs: { labelPrefix: { classPropertyName: "labelPrefix", publicName: "labelPrefix", isSignal: true, isRequired: false, transformFunction: null }, testId: { classPropertyName: "testId", publicName: "testId", isSignal: true, isRequired: false, transformFunction: null }, data: { classPropertyName: "data", publicName: "data", isSignal: true, isRequired: false, transformFunction: null }, fields: { classPropertyName: "fields", publicName: "fields", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { onSubmit: "onSubmit" }, ngImport: i0, template: "@if (config() && group()) {\n    <form [formGroup]=\"group()\" (ngSubmit)=\"submit()\" autocomplete=\"off\" role=\"presentation\">\n        <input type=\"submit\" [hidden]=\"true\" />\n        <formly-form [model]=\"data()\"\n                     [fields]=\"config()\"\n                     [form]=\"group()\"\n                     [options]=\"options\"></formly-form>\n        <ng-content></ng-content>\n    </form>\n}\n", dependencies: [{ kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i3.FormlyForm, selector: "formly-form", inputs: ["form", "model", "fields", "options"], outputs: ["modelChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "19.2.14", type: DynamicFormComponent, isStandalone: false, selector: "dynamic-form", inputs: { labelPrefix: { classPropertyName: "labelPrefix", publicName: "labelPrefix", isSignal: true, isRequired: false, transformFunction: null }, labelCustomizer: { classPropertyName: "labelCustomizer", publicName: "labelCustomizer", isSignal: true, isRequired: false, transformFunction: null }, testId: { classPropertyName: "testId", publicName: "testId", isSignal: true, isRequired: false, transformFunction: null }, data: { classPropertyName: "data", publicName: "data", isSignal: true, isRequired: false, transformFunction: null }, fields: { classPropertyName: "fields", publicName: "fields", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { onSubmit: "onSubmit" }, ngImport: i0, template: "@if (config() && group()) {\n    <form [formGroup]=\"group()\" (ngSubmit)=\"submit()\" autocomplete=\"off\" role=\"presentation\">\n        <input type=\"submit\" [hidden]=\"true\" />\n        <formly-form [model]=\"data()\"\n                     [fields]=\"config()\"\n                     [form]=\"group()\"\n                     [options]=\"options\"></formly-form>\n        <ng-content></ng-content>\n    </form>\n}\n", dependencies: [{ kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i3.FormlyForm, selector: "formly-form", inputs: ["form", "model", "fields", "options"], outputs: ["modelChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImport: i0, type: DynamicFormComponent, decorators: [{
             type: Component,
@@ -1294,7 +1397,8 @@ class NgxDynamicFormModule {
         return [
             ...providers,
             DynamicFormService,
-            DynamicFormBuilderService
+            DynamicFormBuilderService,
+            DynamicFormSchemaService
         ];
     }
     static forRoot(config) {
@@ -1360,5 +1464,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.14", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { AsyncSubmitDirective, DynamicFormArrayComponent, DynamicFormBuilderService, DynamicFormChipsComponent, DynamicFormComponent, DynamicFormFieldComponent, DynamicFormFieldsetComponent, DynamicFormGroupComponent, DynamicFormService, DynamicFormUploadComponent, EDITOR_FORMATS, FORM_ROOT_KEY, FormFile, FormGroup, FormInput, FormModel, FormSelect, FormSerializable, FormUpload, MAX_INPUT_NUM, MIN_INPUT_NUM, NgxDynamicFormModule, additionalFieldValues, customizeFormField, emailValidation, getFieldByPath, jsonValidation, maxLengthValidation, maxValueValidation, mergeFormFields, minLengthValidation, minValueValidation, phoneValidation, replaceSpecialChars, requiredValidation, setFieldDisabled, setFieldHidden, translationValidation, validationMessage };
+export { AsyncSubmitDirective, DynamicFormArrayComponent, DynamicFormBuilderService, DynamicFormChipsComponent, DynamicFormComponent, DynamicFormFieldComponent, DynamicFormFieldsetComponent, DynamicFormGroupComponent, DynamicFormSchemaService, DynamicFormService, DynamicFormUploadComponent, EDITOR_FORMATS, FORM_ROOT_KEY, FormFile, FormGroup, FormInput, FormModel, FormSelect, FormSerializable, FormUpload, MAX_INPUT_NUM, MIN_INPUT_NUM, NgxDynamicFormModule, additionalFieldValues, customizeFormField, emailValidation, getFieldByPath, getFieldsByKey, jsonValidation, maxLengthValidation, maxValueValidation, minLengthValidation, minValueValidation, phoneValidation, replaceSpecialChars, requiredValidation, setFieldDisabled, setFieldHidden, translationValidation, validationMessage };
 //# sourceMappingURL=stemy-ngx-dynamic-form.mjs.map