@stemy/ngx-dynamic-form 10.2.33 → 13.0.1

package/esm2020/ngx-dynamic-form/common-types.mjs

@@ -0,0 +1,97 @@
+import { ObjectUtils, ReflectUtils } from "@stemy/ngx-utils";
+// --- Decorator functions ---
+export function defaultSerializer(id, parent) {
+    const control = parent.get(id);
+    return !control ? null : control.value;
+}
+export function FormSerializable(serializer) {
+    return (target, propertyKey) => {
+        ReflectUtils.defineMetadata("dynamicFormSerializer", serializer || defaultSerializer, target, propertyKey);
+    };
+}
+export function FormInput(data) {
+    return (target, propertyKey) => {
+        const meta = ReflectUtils.getOwnMetadata("design:type", target, propertyKey);
+        const type = meta ? meta.name : "";
+        let inputType = propertyKey.indexOf("password") < 0 ? "text" : "password";
+        switch (type) {
+            case "Number":
+                inputType = "number";
+                break;
+            case "Boolean":
+                inputType = "checkbox";
+                break;
+        }
+        defineFormControl(target, propertyKey, createFormInput(propertyKey, data, inputType));
+    };
+}
+export function FormSelect(data) {
+    return (target, propertyKey) => {
+        defineFormControl(target, propertyKey, createFormSelect(propertyKey, data));
+    };
+}
+export function FormStatic(data) {
+    return (target, propertyKey) => {
+        defineFormControl(target, propertyKey, createFormStatic(propertyKey, data));
+    };
+}
+export function FormModel(data) {
+    return (target, propertyKey) => {
+        defineFormControl(target, propertyKey, createFormModel(propertyKey, data));
+    };
+}
+export function FormFile(data) {
+    return (target, propertyKey) => {
+        defineFormControl(target, propertyKey, createFormFile(propertyKey, data));
+    };
+}
+export function defineFormControl(target, propertyKey, control) {
+    ReflectUtils.defineMetadata("dynamicFormControl", control, target, propertyKey);
+}
+export function getFormControl(target, propertyKey) {
+    return ReflectUtils.getMetadata("dynamicFormControl", target, propertyKey);
+}
+export function getFormSerializer(target, propertyKey) {
+    return ReflectUtils.getMetadata("dynamicFormSerializer", target, propertyKey);
+}
+export function createFormControl(id, type, config) {
+    config = config || { id };
+    config.id = id;
+    config.label = ObjectUtils.isNullOrUndefined(config.label) ? id : config.label;
+    config.disabled = config.disabled || false;
+    config.hidden = config.hidden || false;
+    return { id, type, config };
+}
+export function createFormInput(id, config, type = "text") {
+    const control = createFormControl(id, "input", config);
+    config = control.config;
+    config.inputType = config.inputType || type;
+    config.placeholder = config.placeholder || (config.inputType == "mask" ? "_" : "");
+    config.step = config.step || 1;
+    config.mask = config.mask || null;
+    return control;
+}
+export function createFormSelect(id, data) {
+    const control = createFormControl(id, "select", data);
+    data = control.config;
+    data.options = data.options || [];
+    return control;
+}
+export function createFormStatic(id, config) {
+    return createFormControl(id, "static", config);
+}
+export function createFormModel(id, data) {
+    const control = createFormControl(id, "group", data);
+    data = control.config;
+    data.name = data.name || "";
+    return control;
+}
+export function createFormFile(id, data) {
+    const control = createFormControl(id, "file", data);
+    data = control.config;
+    data.accept = data.accept || ["jpg", "jpeg", "png"];
+    data.multiple = data.multiple || false;
+    data.url = ObjectUtils.isString(data.url) ? data.url : "assets";
+    return control;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common-types.js","sourceRoot":"","sources":["../../../src/ngx-dynamic-form/common-types.ts"],"names":[],"mappings":"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","sourcesContent":["import {EventEmitter, Injector, TemplateRef} from \"@angular/core\";\r\nimport {AbstractControl, FormArray} from \"@angular/forms\";\r\nimport {\r\n    DynamicFileUploadModelConfig,\r\n    DynamicFormControl, DynamicFormControlEvent,\r\n    DynamicFormControlModel,\r\n    DynamicFormControlModelConfig,\r\n    DynamicFormGroupModelConfig,\r\n    DynamicFormValueControlModel,\r\n    DynamicInputModelConfig,\r\n    DynamicSelectModelConfig\r\n} from \"@ng-dynamic-forms/core\";\r\nimport {\r\n    IAsyncMessage,\r\n    IOpenApiSchema,\r\n    IOpenApiSchemaProperty,\r\n    IResolveFactory,\r\n    ObjectUtils,\r\n    ReflectUtils\r\n} from \"@stemy/ngx-utils\";\r\nimport {DynamicFormControlMapFn} from \"@ng-dynamic-forms/core/lib/service/dynamic-form-component.service\";\r\n\r\n// --- Basic form control interfaces ---\r\n\r\nexport type DynamicFormState = \"VALID\" | \"INVALID\" | \"PENDING\" | \"DISABLED\" | \"LOADING\";\r\nexport type DynamicFormUpdateOn = \"change\" | \"blur\" | \"submit\";\r\n\r\nexport interface IDynamicFormEvent extends DynamicFormControlEvent {\r\n    form: IDynamicForm;\r\n}\r\n\r\nexport interface IDynamicForm {\r\n    status: DynamicFormState;\r\n\r\n    onValueChange: EventEmitter<IDynamicFormEvent>;\r\n    onStatusChange: EventEmitter<IDynamicForm>;\r\n    onSubmit: EventEmitter<IDynamicForm>;\r\n\r\n    validate(): Promise<any>;\r\n    serialize(validate?: boolean): Promise<any>;\r\n}\r\n\r\nexport interface OnCreatedFormControl extends DynamicFormControl {\r\n    onCreated(): any;\r\n}\r\n\r\nexport declare interface ModelType extends Function {\r\n    new (config: DynamicFormControlModelConfig): DynamicFormControlModel;\r\n}\r\n\r\nexport type FormControlSerializer = (model: DynamicFormValueControlModel<any>, control: AbstractControl) => Promise<any>;\r\nexport type FormModelCustomizer = (\r\n    property: IOpenApiSchemaProperty, schema: IOpenApiSchema,\r\n    model: DynamicFormControlModel, config: DynamicFormControlModelConfig, injector: Injector\r\n) => DynamicFormControlModel | DynamicFormControlModel[];\r\nexport type FormModelCustomizerWrap = (\r\n    property: IOpenApiSchemaProperty, schema: IOpenApiSchema,\r\n    modelType: ModelType, config: DynamicFormControlModelConfig\r\n) => DynamicFormControlModel[];\r\n\r\nexport interface IFormControl {\r\n    id: string;\r\n    type: string;\r\n    config?: DynamicFormControlModelConfig;\r\n}\r\n\r\nexport interface IFormControlOption {\r\n    id: any;\r\n    label: string;\r\n    selectable?: boolean;\r\n}\r\n\r\n// --- Basic form interfaces ---\r\n\r\nexport interface IDynamicFormTemplates {\r\n    [id: string]: TemplateRef<any>;\r\n}\r\n\r\nexport interface IDynamicFormConfig {\r\n    path?: string | number | Array<string | number>;\r\n    name?: string;\r\n    classes?: string;\r\n    formClasses?: string;\r\n    innerFormClasses?: string;\r\n    id: string;\r\n}\r\n\r\nexport interface IDynamicSingleFormConfig extends IDynamicFormConfig, IDynamicFormInfo {\r\n    data: any;\r\n    controlData?: DynamicFormGroupModelConfig;\r\n    multi?: false;\r\n}\r\n\r\nexport interface IDynamicMultiFormConfig extends IDynamicFormConfig {\r\n    data: IDynamicFormsConfigs;\r\n    multi: true;\r\n}\r\n\r\nexport type IDynamicFormsConfigs = Array<IDynamicSingleFormConfig | IDynamicMultiFormConfig>;\r\n\r\nexport declare type AsyncSubmitMethod = (form: IDynamicForm, context?: any) => Promise<IAsyncMessage>;\r\n\r\nexport interface IDynamicFormInfo {\r\n    name?: string;\r\n    controls?: IFormControl[];\r\n}\r\n\r\n// --- Decorator functions ---\r\nexport function defaultSerializer(id: string, parent: FormArray): Promise<any> {\r\n    const control = parent.get(id);\r\n    return !control ? null: control.value;\r\n}\r\n\r\nexport function FormSerializable(serializer?: FormControlSerializer | IResolveFactory): PropertyDecorator {\r\n    return (target: any, propertyKey: string): void => {\r\n        ReflectUtils.defineMetadata(\"dynamicFormSerializer\", serializer || defaultSerializer, target, propertyKey);\r\n    };\r\n}\r\n\r\nexport function FormInput(data?: DynamicInputModelConfig): PropertyDecorator {\r\n    return (target: any, propertyKey: string): void => {\r\n        const meta = ReflectUtils.getOwnMetadata(\"design:type\", target, propertyKey);\r\n        const type = meta ? meta.name : \"\";\r\n        let inputType = propertyKey.indexOf(\"password\") < 0 ? \"text\" : \"password\";\r\n        switch (type) {\r\n            case \"Number\":\r\n                inputType = \"number\";\r\n                break;\r\n            case \"Boolean\":\r\n                inputType = \"checkbox\";\r\n                break;\r\n        }\r\n        defineFormControl(target, propertyKey, createFormInput(propertyKey, data, inputType));\r\n    };\r\n}\r\n\r\nexport function FormSelect(data?: DynamicSelectModelConfig<any>): PropertyDecorator {\r\n    return (target: any, propertyKey: string): void => {\r\n        defineFormControl(target, propertyKey, createFormSelect(propertyKey, data));\r\n    };\r\n}\r\n\r\nexport function FormStatic(data?: DynamicFormControlModelConfig): PropertyDecorator {\r\n    return (target: any, propertyKey: string): void => {\r\n        defineFormControl(target, propertyKey, createFormStatic(propertyKey, data));\r\n    };\r\n}\r\n\r\nexport function FormModel(data?: DynamicFormGroupModelConfig): PropertyDecorator {\r\n    return (target: any, propertyKey: string): void => {\r\n        defineFormControl(target, propertyKey, createFormModel(propertyKey, data));\r\n    };\r\n}\r\n\r\nexport function FormFile(data?: DynamicFileUploadModelConfig): PropertyDecorator {\r\n    return (target: any, propertyKey: string): void => {\r\n        defineFormControl(target, propertyKey, createFormFile(propertyKey, data));\r\n    };\r\n}\r\n\r\nexport function defineFormControl(target: any, propertyKey: string, control: IFormControl): void {\r\n    ReflectUtils.defineMetadata(\"dynamicFormControl\", control, target, propertyKey);\r\n}\r\n\r\nexport function getFormControl(target: any, propertyKey: string): IFormControl {\r\n    return ReflectUtils.getMetadata(\"dynamicFormControl\", target, propertyKey);\r\n}\r\n\r\nexport function getFormSerializer(target: any, propertyKey: string): FormControlSerializer | IResolveFactory {\r\n    return ReflectUtils.getMetadata(\"dynamicFormSerializer\", target, propertyKey);\r\n}\r\n\r\nexport function createFormControl(id: string, type: string, config?: DynamicFormControlModelConfig): IFormControl {\r\n    config = config || {id};\r\n    config.id = id;\r\n    config.label = ObjectUtils.isNullOrUndefined(config.label) ? id : config.label;\r\n    config.disabled = config.disabled || false;\r\n    config.hidden = config.hidden || false;\r\n    return {id, type, config};\r\n}\r\n\r\nexport function createFormInput(id: string, config: DynamicInputModelConfig, type: string = \"text\"): IFormControl {\r\n    const control = createFormControl(id, \"input\", config);\r\n    config = control.config;\r\n    config.inputType = config.inputType || type;\r\n    config.placeholder = config.placeholder || (config.inputType == \"mask\" ? \"_\" : \"\");\r\n    config.step = config.step || 1;\r\n    config.mask = config.mask || null;\r\n    return control;\r\n}\r\n\r\nexport function createFormSelect(id: string, data: DynamicSelectModelConfig<any>): IFormControl {\r\n    const control = createFormControl(id, \"select\", data);\r\n    data = control.config;\r\n    data.options = data.options || [];\r\n    return control;\r\n}\r\n\r\nexport function createFormStatic(id: string, config: DynamicFormControlModelConfig): IFormControl {\r\n    return createFormControl(id, \"static\", config);\r\n}\r\n\r\nexport function createFormModel(id: string, data: DynamicFormGroupModelConfig): IFormControl {\r\n    const control = createFormControl(id, \"group\", data);\r\n    data = control.config;\r\n    data.name = data.name || \"\";\r\n    return control;\r\n}\r\n\r\nexport function createFormFile(id: string, data: DynamicFileUploadModelConfig): IFormControl {\r\n    const control = createFormControl(id, \"file\", data);\r\n    data = control.config;\r\n    data.accept = data.accept || [\"jpg\", \"jpeg\", \"png\"];\r\n    data.multiple = data.multiple || false;\r\n    data.url = ObjectUtils.isString(data.url) ? data.url : \"assets\";\r\n    return control;\r\n}\r\n\r\nexport interface IDynamicFormModuleConfig {\r\n    controlProvider?: (injector: Injector) => DynamicFormControlMapFn;\r\n}\r\n"]}

package/esm2020/ngx-dynamic-form/components/base/dynamic-base-form-array.component.mjs

@@ -0,0 +1,85 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, forwardRef, Input, Output, ViewChildren } from "@angular/core";
+import { DynamicFormArrayComponent, DynamicFormControlContainerComponent, DynamicFormGroupModel, DynamicFormValueControlModel } from "@ng-dynamic-forms/core";
+import { DynamicFormArrayModel } from "../../utils/dynamic-form-array.model";
+import { collectPathAble } from "../../utils/misc";
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-dynamic-forms/core";
+export class DynamicBaseFormArrayComponent extends DynamicFormArrayComponent {
+    constructor(layoutService, validationService, injector) {
+        super(layoutService, validationService);
+        this.layoutService = layoutService;
+        this.validationService = validationService;
+        this.injector = injector;
+        this.blur = new EventEmitter();
+        this.change = new EventEmitter();
+        this.customEvent = new EventEmitter();
+        this.focus = new EventEmitter();
+    }
+    get useTabs() {
+        return this.model?.useTabs;
+    }
+    saveTab(index) {
+        this.model.saveTab(index, this.model, this.injector);
+    }
+    restoreTab() {
+        return this.model.restoreTab(this.model, 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) {
+            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;
+    }
+}
+DynamicBaseFormArrayComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormArrayComponent, deps: [{ token: i1.DynamicFormLayoutService }, { token: i1.DynamicFormValidationService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+DynamicBaseFormArrayComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.8", type: DynamicBaseFormArrayComponent, selector: "dynamic-base-form-array", inputs: { formLayout: "formLayout", group: "group", layout: "layout", model: "model", templates: "templates" }, outputs: { blur: "blur", change: "change", customEvent: "customEvent", focus: "focus" }, viewQueries: [{ propertyName: "components", predicate: i0.forwardRef(function () { return DynamicFormControlContainerComponent; }), descendants: true }], usesInheritance: true, ngImport: i0, template: "", isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormArrayComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "dynamic-base-form-array",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DynamicFormLayoutService }, { type: i1.DynamicFormValidationService }, { type: i0.Injector }]; }, propDecorators: { formLayout: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], templates: [{
+                type: Input
+            }], blur: [{
+                type: Output
+            }], change: [{
+                type: Output
+            }], customEvent: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }], components: [{
+                type: ViewChildren,
+                args: [forwardRef(() => DynamicFormControlContainerComponent)]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-base-form-array.component.js","sourceRoot":"","sources":["../../../../../src/ngx-dynamic-form/components/base/dynamic-base-form-array.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    ChangeDetectionStrategy,\r\n    Component,\r\n    EventEmitter,\r\n    forwardRef,\r\n    Injector,\r\n    Input,\r\n    Output,\r\n    QueryList,\r\n    ViewChildren\r\n} from \"@angular/core\";\r\nimport {FormGroup} from \"@angular/forms\";\r\nimport {\r\n    DynamicFormArrayComponent,\r\n    DynamicFormControlContainerComponent,\r\n    DynamicFormControlCustomEvent,\r\n    DynamicFormControlLayout,\r\n    DynamicFormControlLayoutContext,\r\n    DynamicFormControlLayoutPlace,\r\n    DynamicFormControlModel,\r\n    DynamicFormGroupModel,\r\n    DynamicFormLayout,\r\n    DynamicFormLayoutService,\r\n    DynamicFormValidationService,\r\n    DynamicFormValueControlModel,\r\n    DynamicTemplateDirective\r\n} from \"@ng-dynamic-forms/core\";\r\nimport {DynamicFormArrayModel} from \"../../utils/dynamic-form-array.model\";\r\nimport {collectPathAble} from \"../../utils/misc\";\r\n\r\n@Component({\r\n    selector: \"dynamic-base-form-array\",\r\n    template: \"\",\r\n    changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\nexport class DynamicBaseFormArrayComponent extends DynamicFormArrayComponent {\r\n\r\n    @Input() formLayout: DynamicFormLayout;\r\n    @Input() group: FormGroup;\r\n    @Input() layout: DynamicFormControlLayout;\r\n    @Input() model: DynamicFormArrayModel;\r\n    @Input() templates: QueryList<DynamicTemplateDirective> | undefined;\r\n\r\n    @Output() blur: EventEmitter<any> = new EventEmitter();\r\n    @Output() change: EventEmitter<any> = new EventEmitter();\r\n    @Output() customEvent: EventEmitter<DynamicFormControlCustomEvent> = new EventEmitter();\r\n    @Output() focus: EventEmitter<any> = new EventEmitter();\r\n\r\n    @ViewChildren(forwardRef(() => DynamicFormControlContainerComponent))\r\n    components: QueryList<DynamicFormControlContainerComponent>;\r\n\r\n    get useTabs(): boolean {\r\n        return this.model?.useTabs;\r\n    }\r\n\r\n    constructor(protected layoutService: DynamicFormLayoutService,\r\n                protected validationService: DynamicFormValidationService,\r\n                protected injector: Injector) {\r\n\r\n        super(layoutService, validationService);\r\n    }\r\n\r\n    saveTab(index: number): void {\r\n        this.model.saveTab(index, this.model, this.injector);\r\n    }\r\n\r\n    restoreTab(): number {\r\n        return this.model.restoreTab(this.model, this.injector);\r\n    }\r\n\r\n    getClass(context: DynamicFormControlLayoutContext, place: DynamicFormControlLayoutPlace, model?: DynamicFormControlModel): string {\r\n        return [\r\n            context == \"element\" ? this.getModelClass(model) : null,\r\n            context == \"element\" ? this.getAdditionalClass(model) : null,\r\n            super.getClass(context, place, model),\r\n            model instanceof DynamicFormValueControlModel ? model.additional?.classes : null\r\n        ].filter(cls => !!cls).join(\" \");\r\n    }\r\n\r\n    protected getModelClass(model?: DynamicFormControlModel): string {\r\n        const parts = collectPathAble(model, p => p.id);\r\n        if (parts.length == 0) return \"\";\r\n        if (model instanceof DynamicFormGroupModel) {\r\n            return `form-group-${parts.join(\"-\")}`;\r\n        }\r\n        return `form-control-${parts.join(\"-\")}`;\r\n    }\r\n\r\n    protected getAdditionalClass(model?: DynamicFormControlModel): string {\r\n        if (model instanceof DynamicFormArrayModel) {\r\n            return model.additional?.classes;\r\n        }\r\n        if (model instanceof DynamicFormValueControlModel) {\r\n            return model.additional?.classes;\r\n        }\r\n        return null;\r\n    }\r\n}\r\n"]}

package/esm2020/ngx-dynamic-form/components/base/dynamic-base-form-control-container.component.mjs

@@ -0,0 +1,109 @@
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, HostBinding, Input, Output, ViewChild, ViewContainerRef } from "@angular/core";
+import { DYNAMIC_FORM_CONTROL_TYPE_ARRAY, DynamicFormControlContainerComponent, DynamicTemplateDirective } from "@ng-dynamic-forms/core";
+import { ObjectUtils } from "@stemy/ngx-utils";
+import { collectPathAble } from "../../utils/misc";
+import * as i0 from "@angular/core";
+import * as i1 from "./dynamic-base-form.component";
+import * as i2 from "@ng-dynamic-forms/core";
+export class DynamicBaseFormControlContainerComponent extends DynamicFormControlContainerComponent {
+    constructor(form, changeDetectorRef, componentFactoryResolver, layoutService, validationService, componentService, relationService) {
+        super(changeDetectorRef, componentFactoryResolver, layoutService, validationService, componentService, relationService);
+        this.form = form;
+        this.changeDetectorRef = changeDetectorRef;
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.layoutService = layoutService;
+        this.validationService = validationService;
+        this.componentService = componentService;
+        this.relationService = relationService;
+        this.context = null;
+        this.blur = new EventEmitter();
+        this.change = new EventEmitter();
+        this.focus = new EventEmitter();
+    }
+    get componentType() {
+        return this.componentService.getCustomComponentType(this.model) ?? this.getComponentType(this.model);
+    }
+    get startTemplate() {
+        return (this.model.type == DYNAMIC_FORM_CONTROL_TYPE_ARRAY)
+            ? this.layoutService.getAlignedTemplate(this.model, this.templates, "ARRAY_START")
+            : this.layoutService.getStartTemplate(this.model, this.templates);
+    }
+    get endTemplate() {
+        return (this.model.type == DYNAMIC_FORM_CONTROL_TYPE_ARRAY)
+            ? this.layoutService.getAlignedTemplate(this.model, this.templates, "ARRAY_END")
+            : this.layoutService.getEndTemplate(this.model, this.templates);
+    }
+    get formService() {
+        return this.form.formService;
+    }
+    ngOnInit() {
+        this.onDetectChanges = this.formService.onDetectChanges.subscribe(form => {
+            if (form !== this.form)
+                return;
+            this.changeDetectorRef.detectChanges();
+            this.formService.updateSelectOptions(this.model, this.control, this.form.model);
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.onDetectChanges.unsubscribe();
+    }
+    getLabel() {
+        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(".");
+    }
+    createFormControlComponent() {
+        super.createFormControlComponent();
+        const component = this.componentRef?.instance;
+        if (!component || !ObjectUtils.isFunction(component.onCreated))
+            return;
+        component.onCreated();
+    }
+    getComponentType(model) {
+        return null;
+    }
+}
+DynamicBaseFormControlContainerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormControlContainerComponent, deps: [{ token: i1.DynamicBaseFormComponent }, { token: i0.ChangeDetectorRef }, { token: i0.ComponentFactoryResolver }, { token: i2.DynamicFormLayoutService }, { token: i2.DynamicFormValidationService }, { token: i2.DynamicFormComponentService }, { token: i2.DynamicFormRelationService }], target: i0.ɵɵFactoryTarget.Component });
+DynamicBaseFormControlContainerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.8", type: DynamicBaseFormControlContainerComponent, selector: "dynamic-base-form-control", inputs: { context: "context", group: "group", hostClass: "hostClass", inputTemplateList: ["templates", "inputTemplateList"], layout: "layout", model: "model" }, outputs: { blur: "blur", change: "change", focus: "focus" }, host: { properties: { "class": "this.klass" } }, queries: [{ propertyName: "contentTemplateList", predicate: DynamicTemplateDirective }], viewQueries: [{ propertyName: "componentViewContainerRef", first: true, predicate: ["componentViewContainer"], descendants: true, read: ViewContainerRef, static: true }], usesInheritance: true, ngImport: i0, template: "", isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormControlContainerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "dynamic-base-form-control",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DynamicBaseFormComponent }, { type: i0.ChangeDetectorRef }, { type: i0.ComponentFactoryResolver }, { type: i2.DynamicFormLayoutService }, { type: i2.DynamicFormValidationService }, { type: i2.DynamicFormComponentService }, { type: i2.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 }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-base-form-control-container.component.js","sourceRoot":"","sources":["../../../../../src/ngx-dynamic-form/components/base/dynamic-base-form-control-container.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    ChangeDetectionStrategy,\r\n    ChangeDetectorRef,\r\n    Component,\r\n    ComponentFactoryResolver,\r\n    ContentChildren,\r\n    EventEmitter,\r\n    HostBinding,\r\n    Input,\r\n    OnInit,\r\n    Output,\r\n    QueryList,\r\n    Type,\r\n    ViewChild,\r\n    ViewContainerRef\r\n} from \"@angular/core\";\r\nimport {FormGroup} from \"@angular/forms\";\r\nimport {Subscription} from \"rxjs\";\r\nimport {\r\n    DYNAMIC_FORM_CONTROL_TYPE_ARRAY,\r\n    DynamicFormArrayGroupModel,\r\n    DynamicFormComponentService,\r\n    DynamicFormControl,\r\n    DynamicFormControlContainerComponent,\r\n    DynamicFormControlEvent,\r\n    DynamicFormControlModel,\r\n    DynamicFormLayout,\r\n    DynamicFormLayoutService,\r\n    DynamicFormRelationService,\r\n    DynamicFormValidationService,\r\n    DynamicTemplateDirective\r\n} from \"@ng-dynamic-forms/core\";\r\nimport {ObjectUtils} from \"@stemy/ngx-utils\";\r\n\r\nimport {OnCreatedFormControl} from \"../../common-types\";\r\nimport {collectPathAble} from \"../../utils/misc\";\r\nimport {DynamicBaseFormComponent} from \"./dynamic-base-form.component\";\r\nimport {DynamicFormService} from \"../../services/dynamic-form.service\";\r\n\r\n@Component({\r\n    selector: \"dynamic-base-form-control\",\r\n    template: \"\",\r\n    changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\nexport class DynamicBaseFormControlContainerComponent extends DynamicFormControlContainerComponent implements OnInit {\r\n\r\n    @ContentChildren(DynamicTemplateDirective) contentTemplateList: QueryList<DynamicTemplateDirective>;\r\n\r\n    @HostBinding(\"class\") klass;\r\n\r\n    @Input() context: DynamicFormArrayGroupModel | null = null;\r\n    @Input() group: FormGroup;\r\n    @Input() hostClass: string[];\r\n    @Input(\"templates\") inputTemplateList: QueryList<DynamicTemplateDirective>;\r\n    @Input() layout: DynamicFormLayout;\r\n    @Input() model: DynamicFormControlModel;\r\n\r\n    @Output() blur: EventEmitter<DynamicFormControlEvent> = new EventEmitter<DynamicFormControlEvent>();\r\n    @Output() change: EventEmitter<DynamicFormControlEvent> = new EventEmitter<DynamicFormControlEvent>();\r\n    @Output() focus: EventEmitter<DynamicFormControlEvent> = new EventEmitter<DynamicFormControlEvent>();\r\n\r\n    @ViewChild(\"componentViewContainer\", {read: ViewContainerRef, static: true}) componentViewContainerRef: ViewContainerRef;\r\n\r\n    protected onDetectChanges: Subscription;\r\n\r\n    get componentType(): Type<DynamicFormControl> | null {\r\n        return this.componentService.getCustomComponentType(this.model) ?? this.getComponentType(this.model);\r\n    }\r\n\r\n    get startTemplate(): DynamicTemplateDirective {\r\n        return (this.model.type == DYNAMIC_FORM_CONTROL_TYPE_ARRAY)\r\n            ? this.layoutService.getAlignedTemplate(this.model, this.templates, \"ARRAY_START\" as any)\r\n            : this.layoutService.getStartTemplate(this.model, this.templates);\r\n    }\r\n\r\n    get endTemplate(): DynamicTemplateDirective {\r\n        return (this.model.type == DYNAMIC_FORM_CONTROL_TYPE_ARRAY)\r\n            ? this.layoutService.getAlignedTemplate(this.model, this.templates, \"ARRAY_END\" as any)\r\n            : this.layoutService.getEndTemplate(this.model, this.templates);\r\n    }\r\n\r\n    get formService(): DynamicFormService {\r\n        return this.form.formService;\r\n    }\r\n\r\n    constructor(readonly form: DynamicBaseFormComponent,\r\n                readonly changeDetectorRef: ChangeDetectorRef,\r\n                readonly componentFactoryResolver: ComponentFactoryResolver,\r\n                readonly layoutService: DynamicFormLayoutService,\r\n                readonly validationService: DynamicFormValidationService,\r\n                readonly componentService: DynamicFormComponentService,\r\n                readonly relationService: DynamicFormRelationService) {\r\n        super(changeDetectorRef, componentFactoryResolver, layoutService, validationService, componentService, relationService);\r\n    }\r\n\r\n    ngOnInit(): void {\r\n        this.onDetectChanges = this.formService.onDetectChanges.subscribe(form => {\r\n            if (form !== this.form) return;\r\n            this.changeDetectorRef.detectChanges();\r\n            this.formService.updateSelectOptions(this.model, this.control, this.form.model);\r\n        });\r\n    }\r\n\r\n    ngOnDestroy() {\r\n        super.ngOnDestroy();\r\n        this.onDetectChanges.unsubscribe();\r\n    }\r\n\r\n    getLabel(): string {\r\n        const label = collectPathAble(this.model, p => p.label);\r\n        if (label.length == 0) return \"\";\r\n        if (this.form?.labelPrefix) {\r\n            label.unshift(this.form.labelPrefix);\r\n        }\r\n        return label.join(\".\");\r\n    }\r\n\r\n    protected createFormControlComponent() {\r\n        super.createFormControlComponent();\r\n        const component = this.componentRef?.instance as OnCreatedFormControl;\r\n        if (!component || !ObjectUtils.isFunction(component.onCreated)) return;\r\n        component.onCreated();\r\n    }\r\n\r\n    protected getComponentType(model: DynamicFormControlModel): Type<DynamicFormControl> | null {\r\n        return null;\r\n    }\r\n}\r\n"]}

package/esm2020/ngx-dynamic-form/components/base/dynamic-base-form-group.component.mjs

@@ -0,0 +1,74 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, forwardRef, Input, Output, ViewChildren } from "@angular/core";
+import { DynamicFormControlContainerComponent, DynamicFormGroupComponent, DynamicFormGroupModel, DynamicFormValueControlModel } from "@ng-dynamic-forms/core";
+import { DynamicFormArrayModel } from "../../utils/dynamic-form-array.model";
+import { collectPathAble } from "../../utils/misc";
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-dynamic-forms/core";
+export class DynamicBaseFormGroupComponent extends DynamicFormGroupComponent {
+    constructor(layoutService, validationService) {
+        super(layoutService, validationService);
+        this.layoutService = layoutService;
+        this.validationService = validationService;
+        this.blur = new EventEmitter();
+        this.change = new EventEmitter();
+        this.customEvent = new EventEmitter();
+        this.focus = new EventEmitter();
+    }
+    getClass(context, place, model) {
+        return [
+            context == "element" ? this.getModelClass(model) : null,
+            context == "element" ? this.getAdditionalClass(model) : null,
+            super.getClass(context, place, model)
+        ].filter(cls => !!cls).join(" ");
+    }
+    getModelClass(model) {
+        const parts = collectPathAble(model, p => p.id);
+        if (parts.length == 0)
+            return "";
+        if (model instanceof DynamicFormGroupModel) {
+            return `form-group-${parts.join("-")}`;
+        }
+        return `form-control-${parts.join("-")}`;
+    }
+    getAdditionalClass(model) {
+        if (model instanceof DynamicFormArrayModel) {
+            return model.additional?.classes;
+        }
+        if (model instanceof DynamicFormValueControlModel) {
+            return model.additional?.classes;
+        }
+        return null;
+    }
+}
+DynamicBaseFormGroupComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormGroupComponent, deps: [{ token: i1.DynamicFormLayoutService }, { token: i1.DynamicFormValidationService }], target: i0.ɵɵFactoryTarget.Component });
+DynamicBaseFormGroupComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.8", type: DynamicBaseFormGroupComponent, selector: "dynamic-base-form-group", inputs: { formLayout: "formLayout", group: "group", layout: "layout", model: "model", templates: "templates" }, outputs: { blur: "blur", change: "change", customEvent: "customEvent", focus: "focus" }, viewQueries: [{ propertyName: "components", predicate: i0.forwardRef(function () { return DynamicFormControlContainerComponent; }), descendants: true }], usesInheritance: true, ngImport: i0, template: "", isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormGroupComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "dynamic-base-form-group",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DynamicFormLayoutService }, { type: i1.DynamicFormValidationService }]; }, propDecorators: { formLayout: [{
+                type: Input
+            }], group: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], templates: [{
+                type: Input
+            }], blur: [{
+                type: Output
+            }], change: [{
+                type: Output
+            }], customEvent: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }], components: [{
+                type: ViewChildren,
+                args: [forwardRef(() => DynamicFormControlContainerComponent)]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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