@stemy/ngx-dynamic-form 10.2.32 → 13.0.0

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

@@ -0,0 +1,158 @@
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Inject, Input, Output, QueryList, ViewChild, ViewChildren } from "@angular/core";
+import { NgForm } from "@angular/forms";
+import { Subscription } from "rxjs";
+import { first } from "rxjs/operators";
+import { DynamicFormComponent, DynamicFormGroupModel, DynamicTemplateDirective } from "@ng-dynamic-forms/core";
+import { EventsService, ObservableUtils } from "@stemy/ngx-utils";
+import { DynamicFormService } from "../../services/dynamic-form.service";
+import { collectPathAble } from "../../utils/misc";
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-dynamic-forms/core";
+import * as i2 from "../../services/dynamic-form.service";
+import * as i3 from "@stemy/ngx-utils";
+export class DynamicBaseFormComponent extends DynamicFormComponent {
+    constructor(formService, events, changeDetectorRef, componentService) {
+        super(changeDetectorRef, componentService);
+        this.formService = formService;
+        this.events = events;
+        this.blur = new EventEmitter();
+        this.change = new EventEmitter();
+        this.focus = new EventEmitter();
+        this.onValueChange = new EventEmitter();
+        this.onStatusChange = new EventEmitter();
+        this.onSubmit = new EventEmitter();
+        this.templates = new QueryList();
+        this.subscription = new Subscription();
+        this.groupSubscription = new Subscription();
+        this.labelPrefix = "label";
+    }
+    get status() {
+        return !this.group ? null : this.group.status;
+    }
+    ngOnChanges(changes) {
+        this.groupSubscription.unsubscribe();
+        if (this.group) {
+            this.groupSubscription = ObservableUtils.multiSubscription(this.group.statusChanges.subscribe(() => {
+                this.onStatusChange.emit(this);
+            }), this.group.valueChanges.subscribe(() => {
+                this.formService.notifyChanges(this.model, this.group, this.model);
+            }), this.change.subscribe(ev => {
+                this.onValueChange.emit({ ...ev, form: this });
+            }));
+        }
+    }
+    ngAfterViewInit() {
+        this.subscription = ObservableUtils.multiSubscription(ObservableUtils.subscribe({
+            subjects: [this.contentTemplates.changes, this.viewTemplates.changes],
+            cb: () => {
+                const templates = this.contentTemplates.toArray().concat(this.viewTemplates.toArray());
+                this.templates.reset(templates);
+            }
+        }), this.events.languageChanged.subscribe(() => {
+            this.formService.detectChanges(this);
+        }), this.ngForm.ngSubmit.subscribe(() => {
+            this.onSubmit.emit(this);
+        }));
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.subscription.unsubscribe();
+        this.groupSubscription.unsubscribe();
+    }
+    insertFormArrayGroup(index, formArray, formArrayModel) {
+        this.formService.insertFormArrayGroup(index, formArray, formArrayModel);
+        this.changeDetectorRef.detectChanges();
+    }
+    removeFormArrayGroup(index, formArray, formArrayModel) {
+        this.formService.removeFormArrayGroup(index, formArray, formArrayModel);
+        this.changeDetectorRef.detectChanges();
+    }
+    moveFormArrayGroup(index, step, formArray, formArrayModel) {
+        this.formService.moveFormArrayGroup(index, step, formArray, formArrayModel);
+        this.changeDetectorRef.detectChanges();
+    }
+    clearFormArray(formArray, formArrayModel) {
+        this.formService.clearFormArray(formArray, formArrayModel);
+        this.changeDetectorRef.detectChanges();
+    }
+    getClass(model) {
+        const parts = collectPathAble(model, p => p.id);
+        if (parts.length == 0)
+            return "";
+        if (model instanceof DynamicFormGroupModel) {
+            return `form-group-${parts.join("-")}`;
+        }
+        return `form-control-${parts.join("-")}`;
+    }
+    validate(showErrors = true) {
+        if (!this.group)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            this.group.statusChanges.pipe(first(status => status == "VALID" || status == "INVALID")).subscribe(status => {
+                if (showErrors) {
+                    this.formService.showErrors(this);
+                }
+                if (status == "VALID") {
+                    resolve(null);
+                    return;
+                }
+                reject(null);
+            });
+            this.group.updateValueAndValidity();
+        });
+    }
+    async serialize(validate) {
+        if (!this.group)
+            return null;
+        if (validate) {
+            await this.validate();
+        }
+        return await this.formService.serialize(this.model, this.group);
+    }
+}
+DynamicBaseFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormComponent, deps: [{ token: DynamicFormService }, { token: EventsService }, { token: i0.ChangeDetectorRef }, { token: i1.DynamicFormComponentService }], target: i0.ɵɵFactoryTarget.Component });
+DynamicBaseFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.8", type: DynamicBaseFormComponent, selector: "dynamic-base-form", inputs: { group: "group", model: "model", layout: "layout", labelPrefix: "labelPrefix" }, outputs: { blur: "blur", change: "change", focus: "focus", onValueChange: "onValueChange", onStatusChange: "onStatusChange", onSubmit: "onSubmit" }, queries: [{ propertyName: "contentTemplates", predicate: DynamicTemplateDirective }], viewQueries: [{ propertyName: "ngForm", first: true, predicate: NgForm, descendants: true }, { propertyName: "viewTemplates", predicate: DynamicTemplateDirective, descendants: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "", isInline: true, changeDetection: i0.ChangeDetectionStrategy.Default });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicBaseFormComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "dynamic-base-form",
+                    template: "",
+                    changeDetection: ChangeDetectionStrategy.Default
+                }]
+        }], ctorParameters: function () { return [{ type: i2.DynamicFormService, decorators: [{
+                    type: Inject,
+                    args: [DynamicFormService]
+                }] }, { type: i3.EventsService, decorators: [{
+                    type: Inject,
+                    args: [EventsService]
+                }] }, { type: i0.ChangeDetectorRef }, { type: i1.DynamicFormComponentService }]; }, propDecorators: { group: [{
+                type: Input
+            }], model: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], labelPrefix: [{
+                type: Input
+            }], blur: [{
+                type: Output
+            }], change: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }], contentTemplates: [{
+                type: ContentChildren,
+                args: [DynamicTemplateDirective]
+            }], viewTemplates: [{
+                type: ViewChildren,
+                args: [DynamicTemplateDirective]
+            }], onValueChange: [{
+                type: Output
+            }], onStatusChange: [{
+                type: Output
+            }], onSubmit: [{
+                type: Output
+            }], ngForm: [{
+                type: ViewChild,
+                args: [NgForm]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-base-form.component.js","sourceRoot":"","sources":["../../../../../src/ngx-dynamic-form/components/base/dynamic-base-form.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    AfterViewInit,\r\n    ChangeDetectionStrategy,\r\n    ChangeDetectorRef,\r\n    Component,\r\n    ContentChildren,\r\n    EventEmitter,\r\n    Inject,\r\n    Input,\r\n    OnChanges,\r\n    Output,\r\n    QueryList,\r\n    SimpleChanges,\r\n    ViewChild,\r\n    ViewChildren\r\n} from \"@angular/core\";\r\nimport {FormArray, FormGroup, NgForm} from \"@angular/forms\";\r\nimport {Subscription} from \"rxjs\";\r\nimport {first} from \"rxjs/operators\";\r\nimport {\r\n    DynamicFormArrayModel,\r\n    DynamicFormComponent,\r\n    DynamicFormComponentService,\r\n    DynamicFormControlEvent,\r\n    DynamicFormControlModel,\r\n    DynamicFormGroupModel,\r\n    DynamicFormLayout,\r\n    DynamicFormModel,\r\n    DynamicTemplateDirective\r\n} from \"@ng-dynamic-forms/core\";\r\nimport {EventsService, ObservableUtils} from \"@stemy/ngx-utils\";\r\nimport {DynamicFormState, IDynamicForm, IDynamicFormEvent} from \"../../common-types\";\r\nimport {DynamicFormService} from \"../../services/dynamic-form.service\";\r\nimport {collectPathAble} from \"../../utils/misc\";\r\n\r\n@Component({\r\n    selector: \"dynamic-base-form\",\r\n    template: \"\",\r\n    changeDetection: ChangeDetectionStrategy.Default\r\n})\r\nexport class DynamicBaseFormComponent extends DynamicFormComponent implements OnChanges, AfterViewInit, IDynamicForm {\r\n\r\n    @Input() group: FormGroup;\r\n    @Input() model: DynamicFormModel;\r\n    @Input() layout: DynamicFormLayout;\r\n    @Input() labelPrefix: string;\r\n\r\n    @Output() blur: EventEmitter<DynamicFormControlEvent>;\r\n    @Output() change: EventEmitter<DynamicFormControlEvent>;\r\n    @Output() focus: EventEmitter<DynamicFormControlEvent>;\r\n\r\n    @ContentChildren(DynamicTemplateDirective) contentTemplates: QueryList<DynamicTemplateDirective>;\r\n    @ViewChildren(DynamicTemplateDirective) viewTemplates: QueryList<DynamicTemplateDirective>;\r\n\r\n    get status(): DynamicFormState {\r\n        return !this.group ? null : this.group.status as DynamicFormState;\r\n    }\r\n\r\n    @Output() readonly onValueChange: EventEmitter<IDynamicFormEvent>;\r\n    @Output() readonly onStatusChange: EventEmitter<IDynamicForm>;\r\n    @Output() readonly onSubmit: EventEmitter<IDynamicForm>;\r\n\r\n    @ViewChild(NgForm)\r\n    protected ngForm: NgForm;\r\n    protected subscription: Subscription;\r\n    protected groupSubscription: Subscription;\r\n\r\n    constructor(@Inject(DynamicFormService) readonly formService: DynamicFormService,\r\n                @Inject(EventsService) readonly events: EventsService,\r\n                changeDetectorRef: ChangeDetectorRef,\r\n                componentService: DynamicFormComponentService,) {\r\n        super(changeDetectorRef, componentService);\r\n        this.blur = new EventEmitter<DynamicFormControlEvent>();\r\n        this.change = new EventEmitter<DynamicFormControlEvent>();\r\n        this.focus = new EventEmitter<DynamicFormControlEvent>();\r\n        this.onValueChange = new EventEmitter<IDynamicFormEvent>();\r\n        this.onStatusChange = new EventEmitter<IDynamicForm>();\r\n        this.onSubmit = new EventEmitter<IDynamicForm>();\r\n        this.templates = new QueryList<DynamicTemplateDirective>();\r\n        this.subscription = new Subscription();\r\n        this.groupSubscription = new Subscription();\r\n        this.labelPrefix = \"label\";\r\n    }\r\n\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        this.groupSubscription.unsubscribe();\r\n        if (this.group) {\r\n            this.groupSubscription = ObservableUtils.multiSubscription(\r\n                this.group.statusChanges.subscribe(() => {\r\n                    this.onStatusChange.emit(this);\r\n                }),\r\n                this.group.valueChanges.subscribe(() => {\r\n                    this.formService.notifyChanges(this.model, this.group, this.model);\r\n                }),\r\n                this.change.subscribe(ev => {\r\n                    this.onValueChange.emit({...ev, form: this});\r\n                })\r\n            );\r\n        }\r\n    }\r\n\r\n    ngAfterViewInit(): void {\r\n        this.subscription = ObservableUtils.multiSubscription(\r\n            ObservableUtils.subscribe(\r\n                {\r\n                    subjects: [this.contentTemplates.changes, this.viewTemplates.changes],\r\n                    cb: () => {\r\n                        const templates = this.contentTemplates.toArray().concat(this.viewTemplates.toArray());\r\n                        this.templates.reset(templates);\r\n                    }\r\n                }\r\n            ),\r\n            this.events.languageChanged.subscribe(() => {\r\n                this.formService.detectChanges(this)\r\n            }),\r\n            this.ngForm.ngSubmit.subscribe(() => {\r\n                this.onSubmit.emit(this);\r\n            })\r\n        );\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        super.ngOnDestroy();\r\n        this.subscription.unsubscribe();\r\n        this.groupSubscription.unsubscribe();\r\n    }\r\n\r\n    insertFormArrayGroup(index: number, formArray: FormArray, formArrayModel: DynamicFormArrayModel): void {\r\n        this.formService.insertFormArrayGroup(index, formArray, formArrayModel);\r\n        this.changeDetectorRef.detectChanges();\r\n    }\r\n\r\n    removeFormArrayGroup(index: number, formArray: FormArray, formArrayModel: DynamicFormArrayModel): void {\r\n        this.formService.removeFormArrayGroup(index, formArray, formArrayModel);\r\n        this.changeDetectorRef.detectChanges();\r\n    }\r\n\r\n    moveFormArrayGroup(index: number, step: number, formArray: FormArray, formArrayModel: DynamicFormArrayModel): void {\r\n        this.formService.moveFormArrayGroup(index, step, formArray, formArrayModel);\r\n        this.changeDetectorRef.detectChanges();\r\n    }\r\n\r\n    clearFormArray(formArray: FormArray, formArrayModel: DynamicFormArrayModel): void {\r\n        this.formService.clearFormArray(formArray, formArrayModel);\r\n        this.changeDetectorRef.detectChanges();\r\n    }\r\n\r\n    getClass(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    validate(showErrors: boolean = true): Promise<any> {\r\n        if (!this.group) return Promise.resolve();\r\n        return new Promise<any>((resolve, reject) => {\r\n            this.group.statusChanges.pipe(first(status => status == \"VALID\" || status == \"INVALID\")).subscribe(status => {\r\n                if (showErrors) {\r\n                    this.formService.showErrors(this);\r\n                }\r\n                if (status == \"VALID\") {\r\n                    resolve(null);\r\n                    return;\r\n                }\r\n                reject(null);\r\n            });\r\n            this.group.updateValueAndValidity();\r\n        });\r\n    }\r\n\r\n    async serialize(validate?: boolean): Promise<any> {\r\n        if (!this.group) return null;\r\n        if (validate) {\r\n            await this.validate();\r\n        }\r\n        return await this.formService.serialize(this.model, this.group);\r\n    }\r\n}\r\n"]}

package/esm2020/ngx-dynamic-form/directives/async-submit.directive.mjs

@@ -0,0 +1,111 @@
+import { Directive, EventEmitter, HostBinding, HostListener, Inject, Input, Output } from "@angular/core";
+import { TOASTER_SERVICE } from "@stemy/ngx-utils";
+import * as i0 from "@angular/core";
+export class AsyncSubmitDirective {
+    constructor(toaster, cdr, elem, renderer) {
+        this.toaster = toaster;
+        this.cdr = cdr;
+        this.elem = elem;
+        this.renderer = renderer;
+        this.onSuccess = new EventEmitter();
+        this.onError = new EventEmitter();
+        if (elem.nativeElement.tagName !== "BUTTON")
+            return;
+        renderer.setAttribute(elem.nativeElement, "type", "button");
+    }
+    get isDisabled() {
+        return this.disabled;
+    }
+    set isDisabled(value) {
+        this.disabled = value;
+        if (value) {
+            this.renderer.setAttribute(this.elem.nativeElement, "disabled", "disabled");
+            return;
+        }
+        this.renderer.removeAttribute(this.elem.nativeElement, "disabled");
+    }
+    get isLoading() {
+        return this.loading;
+    }
+    ngOnInit() {
+        if (!this.form)
+            return;
+        this.isDisabled = this.form.status !== "VALID";
+        this.cdr.detectChanges();
+        this.onStatusChange = this.form.onStatusChange.subscribe(() => {
+            this.isDisabled = this.form.status !== "VALID";
+            this.cdr.detectChanges();
+            if (!this.callback || this.form.status == "PENDING")
+                return;
+            if (!this.disabled) {
+                this.callback();
+            }
+            this.callback = null;
+        });
+        this.onSubmit = this.form.onSubmit.subscribe(() => this.callMethod());
+    }
+    ngOnDestroy() {
+        if (this.onStatusChange)
+            this.onStatusChange.unsubscribe();
+        if (this.onSubmit)
+            this.onSubmit.unsubscribe();
+    }
+    click() {
+        this.callback = () => this.callMethod();
+        if (this.form.status !== "VALID" && this.form.status !== "INVALID")
+            return;
+        this.callback();
+        this.callback = null;
+    }
+    callMethod() {
+        if (this.loading)
+            return;
+        this.loading = true;
+        this.method(this.form, this.context).then(result => {
+            this.loading = false;
+            if (result) {
+                this.onSuccess.emit(result);
+                this.toaster.success(result.message, result.context);
+            }
+        }, reason => {
+            if (!reason || !reason.message)
+                throw new Error("Reason must implement IAsyncMessage interface");
+            this.loading = false;
+            this.onError.emit(reason);
+            this.toaster.error(reason.message, reason.context);
+        });
+    }
+}
+AsyncSubmitDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: AsyncSubmitDirective, deps: [{ token: TOASTER_SERVICE }, { token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+AsyncSubmitDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: AsyncSubmitDirective, selector: "[async-submit]", inputs: { method: ["async-submit", "method"], form: "form", context: "context" }, outputs: { onSuccess: "onSuccess", onError: "onError" }, host: { listeners: { "click": "click()" }, properties: { "class.disabled": "this.isDisabled", "class.loading": "this.isLoading" } }, exportAs: ["async-submit"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: AsyncSubmitDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[async-submit]",
+                    exportAs: "async-submit"
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TOASTER_SERVICE]
+                }] }, { type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { method: [{
+                type: Input,
+                args: ["async-submit"]
+            }], form: [{
+                type: Input
+            }], context: [{
+                type: Input
+            }], onSuccess: [{
+                type: Output
+            }], onError: [{
+                type: Output
+            }], isDisabled: [{
+                type: HostBinding,
+                args: ["class.disabled"]
+            }], isLoading: [{
+                type: HostBinding,
+                args: ["class.loading"]
+            }], click: [{
+                type: HostListener,
+                args: ["click"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"async-submit.directive.js","sourceRoot":"","sources":["../../../../src/ngx-dynamic-form/directives/async-submit.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    ChangeDetectorRef,\r\n    Directive,\r\n    ElementRef,\r\n    EventEmitter,\r\n    HostBinding,\r\n    HostListener,\r\n    Inject,\r\n    Input,\r\n    OnDestroy,\r\n    OnInit,\r\n    Output,\r\n    Renderer2\r\n} from \"@angular/core\";\r\nimport {Subscription} from \"rxjs\";\r\nimport {IAsyncMessage, IToasterService, TOASTER_SERVICE} from \"@stemy/ngx-utils\";\r\nimport {AsyncSubmitMethod, IDynamicForm} from \"../common-types\";\r\n\r\n@Directive({\r\n    selector: \"[async-submit]\",\r\n    exportAs: \"async-submit\"\r\n})\r\nexport class AsyncSubmitDirective implements OnInit, OnDestroy {\r\n\r\n    @Input(\"async-submit\") method: AsyncSubmitMethod;\r\n    @Input() form: IDynamicForm;\r\n    @Input() context: any;\r\n\r\n    @Output() onSuccess: EventEmitter<IAsyncMessage>;\r\n    @Output() onError: EventEmitter<IAsyncMessage>;\r\n\r\n    private loading: boolean;\r\n    private disabled: boolean;\r\n    private callback: Function;\r\n    private onStatusChange: Subscription;\r\n    private onSubmit: Subscription;\r\n\r\n    @HostBinding(\"class.disabled\")\r\n    get isDisabled(): boolean {\r\n        return this.disabled;\r\n    }\r\n\r\n    set isDisabled(value: boolean) {\r\n        this.disabled = value;\r\n        if (value) {\r\n            this.renderer.setAttribute(this.elem.nativeElement, \"disabled\", \"disabled\");\r\n            return;\r\n        }\r\n        this.renderer.removeAttribute(this.elem.nativeElement, \"disabled\");\r\n    }\r\n\r\n    @HostBinding(\"class.loading\")\r\n    get isLoading(): boolean {\r\n        return this.loading;\r\n    }\r\n\r\n    constructor(@Inject(TOASTER_SERVICE) private toaster: IToasterService,\r\n                readonly cdr: ChangeDetectorRef,\r\n                readonly elem: ElementRef,\r\n                readonly renderer: Renderer2) {\r\n        this.onSuccess = new EventEmitter<IAsyncMessage>();\r\n        this.onError = new EventEmitter<IAsyncMessage>();\r\n        if (elem.nativeElement.tagName !== \"BUTTON\") return;\r\n        renderer.setAttribute(elem.nativeElement, \"type\", \"button\");\r\n    }\r\n\r\n    ngOnInit(): void {\r\n        if (!this.form) return;\r\n        this.isDisabled = this.form.status !== \"VALID\";\r\n        this.cdr.detectChanges();\r\n        this.onStatusChange = this.form.onStatusChange.subscribe(() => {\r\n            this.isDisabled = this.form.status !== \"VALID\";\r\n            this.cdr.detectChanges();\r\n            if (!this.callback || this.form.status == \"PENDING\") return;\r\n            if (!this.disabled) {\r\n                this.callback();\r\n            }\r\n            this.callback = null;\r\n        });\r\n        this.onSubmit = this.form.onSubmit.subscribe(() => this.callMethod());\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        if (this.onStatusChange) this.onStatusChange.unsubscribe();\r\n        if (this.onSubmit) this.onSubmit.unsubscribe();\r\n    }\r\n\r\n    @HostListener(\"click\")\r\n    click(): void {\r\n        this.callback = () => this.callMethod();\r\n        if (this.form.status !== \"VALID\" && this.form.status !== \"INVALID\") return;\r\n        this.callback();\r\n        this.callback = null;\r\n    }\r\n\r\n    callMethod(): void {\r\n        if (this.loading) return;\r\n        this.loading = true;\r\n        this.method(this.form, this.context).then(result => {\r\n            this.loading = false;\r\n            if (result) {\r\n                this.onSuccess.emit(result);\r\n                this.toaster.success(result.message, result.context);\r\n            }\r\n        }, reason => {\r\n            if (!reason || !reason.message)\r\n                throw new Error(\"Reason must implement IAsyncMessage interface\");\r\n            this.loading = false;\r\n            this.onError.emit(reason);\r\n            this.toaster.error(reason.message, reason.context);\r\n        });\r\n    }\r\n}\r\n"]}

package/esm2020/ngx-dynamic-form/ngx-dynamic-form.imports.mjs

@@ -0,0 +1,19 @@
+import { AsyncSubmitDirective } from "./directives/async-submit.directive";
+import { DynamicBaseFormComponent } from "./components/base/dynamic-base-form.component";
+import { DynamicBaseFormArrayComponent } from "./components/base/dynamic-base-form-array.component";
+import { DynamicBaseFormControlContainerComponent } from "./components/base/dynamic-base-form-control-container.component";
+import { DynamicBaseFormGroupComponent } from "./components/base/dynamic-base-form-group.component";
+// --- Components ---
+export const components = [
+    DynamicBaseFormComponent,
+    DynamicBaseFormArrayComponent,
+    DynamicBaseFormControlContainerComponent,
+    DynamicBaseFormGroupComponent
+];
+// --- Directives ---
+export const directives = [
+    AsyncSubmitDirective,
+];
+// --- Pipes ---
+export const pipes = [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-dynamic-form/ngx-dynamic-form.module.mjs

@@ -0,0 +1,110 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { FormsModule, NG_VALIDATORS, ReactiveFormsModule } from "@angular/forms";
+import { DYNAMIC_VALIDATORS, DynamicFormService as BaseDynamicFormService } from "@ng-dynamic-forms/core";
+import { NgxUtilsModule } from "@stemy/ngx-utils";
+import { validateItemsMaxLength, validateItemsMaxValue, validateItemsMinLength, validateItemsMinValue, validateJSON, validatePhone, validateRequiredTranslation } from "./utils/validators";
+import { DynamicFormService } from "./services/dynamic-form.service";
+import { components, directives, pipes } from "./ngx-dynamic-form.imports";
+import * as i0 from "@angular/core";
+import * as i1 from "./components/base/dynamic-base-form.component";
+import * as i2 from "./components/base/dynamic-base-form-array.component";
+import * as i3 from "./components/base/dynamic-base-form-control-container.component";
+import * as i4 from "./components/base/dynamic-base-form-group.component";
+import * as i5 from "./directives/async-submit.directive";
+export class NgxDynamicFormModule {
+    static forRoot() {
+        return {
+            ngModule: NgxDynamicFormModule,
+            providers: [
+                DynamicFormService,
+                {
+                    provide: BaseDynamicFormService,
+                    useExisting: DynamicFormService
+                }
+            ]
+        };
+    }
+}
+NgxDynamicFormModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxDynamicFormModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NgxDynamicFormModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxDynamicFormModule, declarations: [i1.DynamicBaseFormComponent, i2.DynamicBaseFormArrayComponent, i3.DynamicBaseFormControlContainerComponent, i4.DynamicBaseFormGroupComponent, i5.AsyncSubmitDirective], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        NgxUtilsModule], exports: [i1.DynamicBaseFormComponent, i2.DynamicBaseFormArrayComponent, i3.DynamicBaseFormControlContainerComponent, i4.DynamicBaseFormGroupComponent, i5.AsyncSubmitDirective, FormsModule,
+        ReactiveFormsModule,
+        NgxUtilsModule] });
+NgxDynamicFormModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxDynamicFormModule, providers: [
+        ...pipes,
+        { provide: NG_VALIDATORS, useValue: validateJSON, multi: true },
+        { provide: NG_VALIDATORS, useValue: validateRequiredTranslation, multi: true },
+        { provide: NG_VALIDATORS, useValue: validateItemsMinLength, multi: true },
+        { provide: NG_VALIDATORS, useValue: validateItemsMaxLength, multi: true },
+        { provide: NG_VALIDATORS, useValue: validateItemsMinValue, multi: true },
+        { provide: NG_VALIDATORS, useValue: validateItemsMaxValue, multi: true },
+        {
+            provide: DYNAMIC_VALIDATORS,
+            useValue: new Map([
+                ["json", validateJSON],
+                ["requiredTranslation", validateRequiredTranslation],
+                ["phone", validatePhone],
+                ["itemsMinLength", validateItemsMinLength],
+                ["itemsMaxLength", validateItemsMaxLength],
+                ["itemsMinValue", validateItemsMinValue],
+                ["itemsMaxValue", validateItemsMaxValue],
+            ])
+        }
+    ], imports: [[
+            CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            NgxUtilsModule
+        ], FormsModule,
+        ReactiveFormsModule,
+        NgxUtilsModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxDynamicFormModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ...components,
+                        ...directives,
+                        ...pipes
+                    ],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        NgxUtilsModule
+                    ],
+                    exports: [
+                        ...components,
+                        ...directives,
+                        ...pipes,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        NgxUtilsModule
+                    ],
+                    entryComponents: components,
+                    providers: [
+                        ...pipes,
+                        { provide: NG_VALIDATORS, useValue: validateJSON, multi: true },
+                        { provide: NG_VALIDATORS, useValue: validateRequiredTranslation, multi: true },
+                        { provide: NG_VALIDATORS, useValue: validateItemsMinLength, multi: true },
+                        { provide: NG_VALIDATORS, useValue: validateItemsMaxLength, multi: true },
+                        { provide: NG_VALIDATORS, useValue: validateItemsMinValue, multi: true },
+                        { provide: NG_VALIDATORS, useValue: validateItemsMaxValue, multi: true },
+                        {
+                            provide: DYNAMIC_VALIDATORS,
+                            useValue: new Map([
+                                ["json", validateJSON],
+                                ["requiredTranslation", validateRequiredTranslation],
+                                ["phone", validatePhone],
+                                ["itemsMinLength", validateItemsMinLength],
+                                ["itemsMaxLength", validateItemsMaxLength],
+                                ["itemsMinValue", validateItemsMinValue],
+                                ["itemsMaxValue", validateItemsMaxValue],
+                            ])
+                        }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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