@stemy/ngx-dynamic-form 10.2.22 → 12.0.0

package/ngx-dynamic-form/common-types.d.ts

@@ -1,25 +1,33 @@
-import { EventEmitter, TemplateRef } from "@angular/core";
-import { AbstractControl, FormArray } from "@angular/forms";
-import { Observable } from "rxjs";
-import { DynamicFormControl, DynamicFormOptionConfig, DynamicFormValueControlModel, DynamicValidatorDescriptor, DynamicValidatorsConfig } from "@ng-dynamic-forms/core";
-import { IAsyncMessage, IRequestOptions, IResolveFactory } from "@stemy/ngx-utils";
-export interface IDynamicFormBase {
-    status: DynamicFormState;
-    onStatusChange: EventEmitter<IDynamicFormBase>;
-    onValueChange: EventEmitter<IDynamicFormBase>;
-    onSubmit: EventEmitter<IDynamicFormBase>;
-    validate(): Promise<any>;
-    serialize(validate?: boolean): Promise<any>;
+import { ChangeDetectorRef, EventEmitter, InjectionToken, Injector, TemplateRef, Type, ValueProvider } from "@angular/core";
+import { FormControl, FormGroup, ValidationErrors } from "@angular/forms";
+import { IResolveFactory, IAsyncMessage, IRequestOptions } from "@stemy/ngx-utils";
+export declare const FORM_GROUP_TYPE: InjectionToken<Type<IFormControlComponent>>;
+export declare const FORM_CONTROL_PROVIDER: InjectionToken<IFormControlProvider>;
+export interface IFormControlComponent {
+    control: IDynamicFormControl;
+}
+export interface IFormGroupComponent {
+    form: IDynamicForm;
+    control: IDynamicFormControl;
 }
-export interface IDynamicForm extends IDynamicFormBase {
+export declare abstract class FormControlComponent<T extends IFormControlData> implements IFormControlComponent {
+    control: IDynamicFormControl;
+    get form(): IDynamicFormBase;
+    get data(): T;
+    get value(): any;
+    get meta(): any;
+    get inputClass(): boolean;
 }
-export interface OnCreatedFormControl extends DynamicFormControl {
-    onCreated(): any;
+export declare type IFormControlProviderAcceptor = (control: IDynamicFormControl) => boolean;
+export declare type IFormControlProviderLoader = (control: IDynamicFormControl) => Promise<any>;
+export declare type IFormControlOptions = (control: IDynamicFormControl) => Promise<IFormControlOption[]>;
+export declare type IFormControlSerializer = (id: string, parent: IDynamicFormControl) => Promise<any>;
+export interface IFormControlProvider {
+    component: Type<IFormControlComponent>;
+    priority: number;
+    acceptor: IFormControlProviderAcceptor;
+    loader: IFormControlProviderLoader;
 }
-export declare type IFormControlSerializer = (model: DynamicFormValueControlModel<any>, control: AbstractControl) => Promise<any>;
-export declare type IFormInputMask = string | RegExp;
-export declare type IFormInputMaskFunction = (raw: string) => IFormInputMask[];
-export declare type IFormInputUnMaskFunction = (value: string) => any;
 export interface IFormSerializer {
     id: string;
     func: IFormControlSerializer;
@@ -29,6 +37,106 @@ export interface IFormSerializers {
 }
 export declare type DynamicFormState = "VALID" | "INVALID" | "PENDING" | "DISABLED" | "LOADING";
 export declare type DynamicFormUpdateOn = "change" | "blur" | "submit";
+export interface IDynamicFormControl {
+    id: string;
+    type: string;
+    data: IFormControlData;
+    visible: boolean;
+    meta: any;
+    form: IDynamicFormBase;
+    injector: Injector;
+    label: string;
+    provider: IFormControlProvider;
+    model: any;
+    formId: string;
+    errors: ValidationErrors;
+    value: any;
+    touched: boolean;
+    disabled: boolean;
+    updateOn: DynamicFormUpdateOn;
+    setValue(value: any): void;
+    getData<T extends IFormControlData>(): T;
+    getControl(id: string): IDynamicFormControl;
+    load(): Promise<any>;
+    check(): Promise<any>;
+    shouldSerialize(): Promise<boolean>;
+    shouldValidate(): Promise<boolean>;
+    serialize(): Promise<any>;
+    onFocus(): void;
+    onBlur(): void;
+    showErrors(): void;
+}
+export declare class DynamicFormGroup extends FormGroup implements IDynamicFormControl {
+    readonly form: IDynamicFormBase;
+    get id(): string;
+    get type(): string;
+    get data(): IFormControlData;
+    get visible(): boolean;
+    get meta(): any;
+    get injector(): Injector;
+    get label(): string;
+    get provider(): IFormControlProvider;
+    get model(): any;
+    get formId(): string;
+    get formControls(): IDynamicFormControl[];
+    get formFields(): IDynamicFormFieldSets;
+    get prefix(): string;
+    get name(): string;
+    get state(): DynamicFormState;
+    private helper;
+    private mName;
+    private mModel;
+    private mControls;
+    private mSerializers;
+    private mFieldSets;
+    private initialized;
+    private loading;
+    private changeTimer;
+    private static createFormControls;
+    private static createFormSerializers;
+    constructor(form: IDynamicFormBase, control?: IFormControl);
+    getData<T extends IFormControlData>(): T;
+    getControl(id: string): IDynamicFormControl;
+    load(): Promise<any>;
+    check(): Promise<any>;
+    shouldSerialize(): Promise<boolean>;
+    shouldValidate(): Promise<boolean>;
+    serialize(): Promise<any>;
+    onFocus(): void;
+    onBlur(): void;
+    showErrors(): void;
+    reloadControls(): Promise<any>;
+    setup(model: any, info: IDynamicFormInfo): void;
+    updateModel(control: IDynamicFormControl): void;
+    private reloadControlsFrom;
+}
+export declare class DynamicFormControl extends FormControl implements IDynamicFormControl {
+    private control;
+    readonly group: DynamicFormGroup;
+    get id(): string;
+    get type(): string;
+    get data(): IFormControlData;
+    get visible(): boolean;
+    get meta(): any;
+    get form(): IDynamicFormBase;
+    get injector(): Injector;
+    get label(): string;
+    get provider(): IFormControlProvider;
+    get model(): any;
+    get formId(): string;
+    private helper;
+    constructor(control: IFormControl, group: DynamicFormGroup);
+    getData<T extends IFormControlData>(): T;
+    getControl(id: string): IDynamicFormControl;
+    load(): Promise<any>;
+    check(): Promise<any>;
+    shouldSerialize(): Promise<boolean>;
+    shouldValidate(): Promise<boolean>;
+    serialize(): Promise<any>;
+    onFocus(): void;
+    onBlur(): void;
+    showErrors(): void;
+}
 export interface IFormControl {
     id: string;
     type: string;
@@ -44,8 +152,8 @@ export interface IFormControlData {
     hidden?: FormControlTesterFactory;
     shouldSerialize?: FormControlTesterFactory;
     shouldValidate?: FormControlTesterFactory;
-    validator?: DynamicValidatorDescriptor;
-    validators?: DynamicValidatorsConfig;
+    validator?: FormControlValidatorFactory;
+    validators?: FormControlValidatorFactory[];
     updateOn?: DynamicFormUpdateOn;
     reload?: string | string[];
 }
@@ -54,14 +162,12 @@ export interface IFormInputData extends IFormControlData {
     autocomplete?: string;
     placeholder?: string;
     useLanguage?: boolean;
-    mask?: IFormInputMaskFunction | IFormInputMask[];
-    unmask?: IFormInputUnMaskFunction;
     step?: number;
     min?: number;
     max?: number;
 }
 export interface IFormSelectData extends IFormControlData {
-    options?: DynamicFormOptionConfig<any>[] | Observable<DynamicFormOptionConfig<any>[]>;
+    options?: IFormControlOptions | IResolveFactory;
     emptyOption?: boolean;
     type?: string;
     multi?: boolean;
@@ -116,19 +222,55 @@ export interface IDynamicMultiFormConfig extends IDynamicFormConfig {
     multi: true;
 }
 export declare type IDynamicFormsConfigs = Array<IDynamicSingleFormConfig | IDynamicMultiFormConfig>;
-export declare type AsyncSubmitMethod = (form: IDynamicFormBase, context?: any) => Promise<IAsyncMessage>;
+export interface IDynamicFormBase {
+    name?: string;
+    readonly?: boolean;
+    updateOn?: "change" | "blur" | "submit";
+    classes: string;
+    parent: IDynamicFormBase;
+    wrapperTemplate: TemplateRef<any>;
+    fieldSetTemplate: TemplateRef<any>;
+    controlTemplate: TemplateRef<any>;
+    controlTemplates: IDynamicFormTemplates;
+    labelTemplates: IDynamicFormTemplates;
+    inputTemplates: IDynamicFormTemplates;
+    prefixTemplates: IDynamicFormTemplates;
+    suffixTemplates: IDynamicFormTemplates;
+    setPrefixTemplates: IDynamicFormTemplates;
+    setSuffixTemplates: IDynamicFormTemplates;
+    onChange: EventEmitter<IDynamicFormControl>;
+    onStatusChange: EventEmitter<IDynamicFormBase>;
+    onInit: EventEmitter<IDynamicFormBase>;
+    onSubmit: EventEmitter<IDynamicFormBase>;
+    root?: IDynamicFormBase;
+    status: DynamicFormState;
+    injector?: Injector;
+    cdr?: ChangeDetectorRef;
+    validate(showErrors?: boolean): Promise<any>;
+    serialize(validate?: boolean): Promise<any>;
+    check(): Promise<any>;
+    getControl(id: string): IDynamicFormControl;
+    findProvider(control: IDynamicFormControl): IFormControlProvider;
+}
+export declare type AsyncSubmitMethod = (form: IDynamicFormBase) => Promise<IAsyncMessage>;
 export interface IDynamicFormInfo {
+    group?: DynamicFormGroup;
     name?: string;
     controls?: IFormControl[];
     serializers?: IFormSerializers;
     fieldSets?: IFormFieldSet[];
 }
+export interface IDynamicForm extends IDynamicFormBase, IDynamicFormInfo {
+    data: any;
+}
 export interface IDynamicFormFieldSets {
     [id: string]: IFormFieldSet;
 }
-export declare type FormControlTester = (control: AbstractControl) => Promise<boolean>;
+export declare type FormControlTester = (control: IDynamicFormControl) => Promise<boolean>;
 export declare type FormControlTesterFactory = FormControlTester | IResolveFactory;
-export declare function defaultSerializer(id: string, parent: FormArray): Promise<any>;
+export declare type FormControlValidator = (control: IDynamicFormControl) => Promise<string | ValidationErrors>;
+export declare type FormControlValidatorFactory = FormControlValidator | IResolveFactory;
+export declare function defaultSerializer(id: string, parent: IDynamicFormControl): Promise<any>;
 export declare function FormSerializable(serializer?: IFormControlSerializer | IResolveFactory): PropertyDecorator;
 export declare function FormInput(data?: IFormInputData): PropertyDecorator;
 export declare function FormSelect(data?: IFormSelectData): PropertyDecorator;
@@ -136,6 +278,18 @@ export declare function FormStatic(data?: IFormStaticData): PropertyDecorator;
 export declare function FormModel(data?: IFormModelData): PropertyDecorator;
 export declare function FormFile(data?: IFormFileData): PropertyDecorator;
 export declare function FormFieldSet(data: IFormFieldSet): ClassDecorator;
+export interface FormGroupProvider extends ValueProvider {
+    provide: InjectionToken<Type<IFormGroupComponent>>;
+    multi?: boolean;
+    useValue: Type<IFormGroupComponent>;
+}
+export declare function provideFormGroup(component: Type<IFormGroupComponent>): FormGroupProvider;
+export interface FormControlProvider {
+    provide: InjectionToken<IFormControlProvider>;
+    multi?: boolean;
+    useValue: IFormControlProvider;
+}
+export declare function provideFormControl(component: Type<IFormControlComponent>, acceptor: IFormControlProviderAcceptor, loader: IFormControlProviderLoader, priority?: number): FormControlProvider;
 export declare function defineFormControl(target: any, propertyKey: string, control: IFormControl): void;
 export declare function getFormFieldSets(target: any): IDynamicFormFieldSets;
 export declare function getFormControl(target: any, propertyKey: string): IFormControl;

package/ngx-dynamic-form/components/base/dynamic-form-base.component.d.ts

@@ -0,0 +1,44 @@
+import { AfterContentInit, ChangeDetectorRef, EventEmitter, Injector, QueryList, TemplateRef } from "@angular/core";
+import { DynamicFormState, IDynamicFormBase, IDynamicFormControl, IDynamicFormTemplates, IFormControlProvider } from "../../common-types";
+import { DynamicFormTemplateDirective } from "../../directives/dynamic-form-template.directive";
+import { DynamicFormService } from "../../services/dynamic-form.service";
+export declare abstract class DynamicFormBaseComponent implements IDynamicFormBase, AfterContentInit {
+    private formService;
+    name: string;
+    readonly: boolean;
+    updateOn: "change" | "blur" | "submit";
+    classes: any;
+    parent: IDynamicFormBase;
+    wrapperTemplate: TemplateRef<any>;
+    fieldSetTemplate: TemplateRef<any>;
+    controlTemplate: TemplateRef<any>;
+    controlTemplates: IDynamicFormTemplates;
+    labelTemplates: IDynamicFormTemplates;
+    inputTemplates: IDynamicFormTemplates;
+    prefixTemplates: IDynamicFormTemplates;
+    suffixTemplates: IDynamicFormTemplates;
+    setPrefixTemplates: IDynamicFormTemplates;
+    setSuffixTemplates: IDynamicFormTemplates;
+    onChange: EventEmitter<IDynamicFormControl>;
+    onStatusChange: EventEmitter<IDynamicFormBase>;
+    onInit: EventEmitter<IDynamicFormBase>;
+    onSubmit: EventEmitter<IDynamicFormBase>;
+    prefixTemplate: TemplateRef<any>;
+    suffixTemplate: TemplateRef<any>;
+    get root(): IDynamicFormBase;
+    abstract status: DynamicFormState;
+    readonly injector: Injector;
+    readonly cdr: ChangeDetectorRef;
+    protected templates: QueryList<DynamicFormTemplateDirective>;
+    protected cWrapperTemplate: TemplateRef<any>;
+    protected cFieldSetTemplate: TemplateRef<any>;
+    protected cControlTemplate: TemplateRef<any>;
+    protected constructor(cdr: ChangeDetectorRef, formService: DynamicFormService);
+    abstract validate(showErrors?: boolean): Promise<any>;
+    abstract serialize(validate?: boolean): Promise<any>;
+    abstract check(): Promise<any>;
+    abstract getControl(id: string): IDynamicFormControl;
+    findProvider(control: IDynamicFormControl): IFormControlProvider;
+    ngAfterContentInit(): void;
+    protected filterTemplates(templates: IDynamicFormTemplates, type: string): IDynamicFormTemplates;
+}

package/ngx-dynamic-form/components/dynamic-form/dynamic-form.component.d.ts

@@ -0,0 +1,21 @@
+import { AfterContentInit, ChangeDetectorRef, OnChanges, SimpleChanges } from "@angular/core";
+import { DynamicFormGroup, DynamicFormState, IDynamicForm, IDynamicFormControl, IFormControl, IFormFieldSet, IFormSerializers } from "../../common-types";
+import { DynamicFormService } from "../../services/dynamic-form.service";
+import { DynamicFormBaseComponent } from "../base/dynamic-form-base.component";
+export declare class DynamicFormComponent extends DynamicFormBaseComponent implements IDynamicForm, AfterContentInit, OnChanges {
+    group: DynamicFormGroup;
+    controls: IFormControl[];
+    serializers: IFormSerializers;
+    fieldSets: IFormFieldSet[];
+    data: any;
+    defaultFieldSet: IFormFieldSet;
+    get status(): DynamicFormState;
+    get formControls(): IDynamicFormControl[];
+    constructor(cdr: ChangeDetectorRef, forms: DynamicFormService);
+    ngOnChanges(changes: SimpleChanges): void;
+    onFormSubmit(): void;
+    validate(showErrors?: boolean): Promise<any>;
+    serialize(validate?: boolean): Promise<any>;
+    check(): Promise<any>;
+    getControl(id: string): IDynamicFormControl;
+}

package/ngx-dynamic-form/components/dynamic-form-file/dynamic-form-file.component.d.ts

@@ -0,0 +1,16 @@
+import { FormControlComponent, IDynamicFormControl, IFormFileData } from "../../common-types";
+import { ApiService, IToasterService } from "@stemy/ngx-utils";
+export declare class DynamicFormFileComponent extends FormControlComponent<IFormFileData> {
+    readonly api: ApiService;
+    readonly toaster: IToasterService;
+    private fileImageCache;
+    static acceptor(control: IDynamicFormControl): boolean;
+    static loader(): Promise<any>;
+    constructor(api: ApiService, toaster: IToasterService);
+    onSelect(input: HTMLInputElement): void;
+    protected processFiles(fileList: FileList): void;
+    protected upload(files: File[]): void;
+    delete(index?: number): void;
+    getUrl(image: any): string;
+    private getImgUrl;
+}

package/ngx-dynamic-form/components/dynamic-form-group/dynamic-form-group.component.d.ts

@@ -0,0 +1,6 @@
+import { IDynamicForm, IDynamicFormControl, IFormGroupComponent } from "../../common-types";
+export declare class DynamicFormGroupComponent implements IFormGroupComponent {
+    form: IDynamicForm;
+    control: IDynamicFormControl;
+    get classes(): string;
+}

package/ngx-dynamic-form/components/dynamic-form-input/dynamic-form-input.component.d.ts

@@ -0,0 +1,12 @@
+import { ILanguageService } from "@stemy/ngx-utils";
+import { DynamicFormControl, FormControlComponent, IFormInputData } from "../../common-types";
+export declare class DynamicFormInputComponent extends FormControlComponent<IFormInputData> {
+    private language;
+    static acceptor(control: DynamicFormControl): boolean;
+    static loader(): Promise<any>;
+    get isChecked(): boolean;
+    constructor(language: ILanguageService);
+    onDateChange(value: string): void;
+    onTextChange(value: string): void;
+    onNumberBlur(): void;
+}

package/ngx-dynamic-form/components/dynamic-form-model/dynamic-form-model.component.d.ts

@@ -0,0 +1,6 @@
+import { DynamicFormControl, FormControlComponent, IFormModelData } from "../../common-types";
+export declare class DynamicFormModelComponent extends FormControlComponent<IFormModelData> {
+    private subForm;
+    static acceptor(control: DynamicFormControl): boolean;
+    static loader(): Promise<any>;
+}

package/ngx-dynamic-form/components/dynamic-form-select/dynamic-form-select.component.d.ts

@@ -0,0 +1,9 @@
+import { DynamicFormControl, FormControlComponent, IDynamicFormControl, IFormControlOption, IFormSelectData } from "../../common-types";
+export declare class DynamicFormSelectComponent extends FormControlComponent<IFormSelectData> {
+    static acceptor(control: DynamicFormControl): boolean;
+    static loader(control: IDynamicFormControl): Promise<any>;
+    static fillOptions(control: IDynamicFormControl, options: IFormControlOption[]): void;
+    onSelectChange(value: any): void;
+    checkValue(option: IFormControlOption): boolean;
+    findOption(option: IFormControlOption, index: number, id: string): boolean;
+}

package/ngx-dynamic-form/components/dynamic-form-static/dynamic-form-static.component.d.ts

@@ -0,0 +1,5 @@
+import { DynamicFormControl, FormControlComponent, IFormStaticData } from "../../common-types";
+export declare class DynamicFormStaticComponent extends FormControlComponent<IFormStaticData> {
+    static acceptor(control: DynamicFormControl): boolean;
+    static loader(): Promise<any>;
+}

package/ngx-dynamic-form/components/dynamic-forms/dynamic-forms.component.d.ts

@@ -0,0 +1,26 @@
+import { AfterContentInit, ChangeDetectorRef, OnChanges, SimpleChanges, TemplateRef } from "@angular/core";
+import { DynamicFormState, IDynamicFormBase, IDynamicFormControl, IDynamicFormsConfigs, IDynamicFormTemplates } from "../../common-types";
+import { DynamicFormBaseComponent } from "../base/dynamic-form-base.component";
+import { DynamicFormService } from "../../services/dynamic-form.service";
+export declare class DynamicFormsComponent extends DynamicFormBaseComponent implements IDynamicFormBase, AfterContentInit, OnChanges {
+    data: IDynamicFormsConfigs;
+    containerTemplate: TemplateRef<any>;
+    formPrefixTemplates: IDynamicFormTemplates;
+    formSuffixTemplates: IDynamicFormTemplates;
+    innerFormPrefixTemplates: IDynamicFormTemplates;
+    innerFormSuffixTemplates: IDynamicFormTemplates;
+    get status(): DynamicFormState;
+    configs: IDynamicFormsConfigs;
+    protected cContainerTemplate: TemplateRef<any>;
+    private forms;
+    constructor(cdr: ChangeDetectorRef, formService: DynamicFormService);
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    validate(showErrors?: boolean): Promise<any>;
+    serialize(validate?: boolean): Promise<any>;
+    check(): Promise<any>;
+    getControl(id: string): IDynamicFormControl;
+    private checkForms;
+    private getFromValue;
+    private createFormGroups;
+}

package/ngx-dynamic-form/directives/async-submit.directive.d.ts

@@ -3,12 +3,9 @@ import { IAsyncMessage, IToasterService } from "@stemy/ngx-utils";
 import { AsyncSubmitMethod, IDynamicFormBase } from "../common-types";
 export declare class AsyncSubmitDirective implements OnInit, OnDestroy {
     private toaster;
-    readonly cdr: ChangeDetectorRef;
-    readonly elem: ElementRef;
-    readonly renderer: Renderer2;
+    private cdr;
     method: AsyncSubmitMethod;
     form: IDynamicFormBase;
-    context: any;
     onSuccess: EventEmitter<IAsyncMessage>;
     onError: EventEmitter<IAsyncMessage>;
     private loading;
@@ -17,7 +14,6 @@ export declare class AsyncSubmitDirective implements OnInit, OnDestroy {
     private onStatusChange;
     private onSubmit;
     get isDisabled(): boolean;
-    set isDisabled(value: boolean);
     get isLoading(): boolean;
     constructor(toaster: IToasterService, cdr: ChangeDetectorRef, elem: ElementRef, renderer: Renderer2);
     ngOnInit(): void;

package/ngx-dynamic-form/directives/dynamic-form-control.directive.d.ts

@@ -0,0 +1,12 @@
+import { OnChanges, SimpleChanges, ViewContainerRef } from "@angular/core";
+import { IDynamicFormControl, IFormControlComponent } from "../common-types";
+import { DynamicFormService } from "../services/dynamic-form.service";
+export declare class DynamicFormControlDirective implements OnChanges {
+    private vcr;
+    private forms;
+    control: IDynamicFormControl;
+    get component(): IFormControlComponent;
+    private comp;
+    constructor(vcr: ViewContainerRef, forms: DynamicFormService);
+    ngOnChanges(changes: SimpleChanges): void;
+}

package/ngx-dynamic-form/directives/dynamic-form-group.directive.d.ts

@@ -0,0 +1,14 @@
+import { OnChanges, SimpleChanges, ViewContainerRef } from "@angular/core";
+import { IDynamicForm, IDynamicFormControl, IFormControlComponent } from "../common-types";
+import { DynamicFormService } from "../services/dynamic-form.service";
+export declare class DynamicFormGroupDirective implements OnChanges {
+    private vcr;
+    private forms;
+    control: IDynamicFormControl;
+    form: IDynamicForm;
+    visible: boolean;
+    get component(): IFormControlComponent;
+    private comp;
+    constructor(vcr: ViewContainerRef, forms: DynamicFormService);
+    ngOnChanges(changes: SimpleChanges): void;
+}

package/ngx-dynamic-form/directives/dynamic-form-template.directive.d.ts

@@ -0,0 +1,16 @@
+import { TemplateRef } from "@angular/core";
+export declare class DynamicFormTemplateDirective {
+    template: TemplateRef<any>;
+    control: string;
+    label: string;
+    input: string;
+    prefix: string;
+    suffix: string;
+    setPrefix: string;
+    setSuffix: string;
+    formPrefix: string;
+    formSuffix: string;
+    innerFormPrefix: string;
+    innerFormSuffix: string;
+    constructor(template: TemplateRef<any>);
+}

package/ngx-dynamic-form/ngx-dynamic-form.module.d.ts

@@ -1,10 +1,20 @@
 import { ModuleWithProviders } from "@angular/core";
+import { FormControlProvider, FormGroupProvider } from "./common-types";
 import { AsyncSubmitDirective } from "./directives/async-submit.directive";
-import { DynamicBaseFormComponent } from "./components/base/dynamic-base-form.component";
-import { DynamicBaseFormControlContainerComponent } from "./components/base/dynamic-base-form-control-container.component";
-export declare const components: (typeof DynamicBaseFormComponent | typeof DynamicBaseFormControlContainerComponent)[];
-export declare const directives: (typeof AsyncSubmitDirective)[];
+import { DynamicFormControlDirective } from "./directives/dynamic-form-control.directive";
+import { DynamicFormGroupDirective } from "./directives/dynamic-form-group.directive";
+import { DynamicFormTemplateDirective } from "./directives/dynamic-form-template.directive";
+import { DynamicFormsComponent } from "./components/dynamic-forms/dynamic-forms.component";
+import { DynamicFormComponent } from "./components/dynamic-form/dynamic-form.component";
+import { DynamicFormGroupComponent } from "./components/dynamic-form-group/dynamic-form-group.component";
+import { DynamicFormFileComponent } from "./components/dynamic-form-file/dynamic-form-file.component";
+import { DynamicFormInputComponent } from "./components/dynamic-form-input/dynamic-form-input.component";
+import { DynamicFormSelectComponent } from "./components/dynamic-form-select/dynamic-form-select.component";
+import { DynamicFormStaticComponent } from "./components/dynamic-form-static/dynamic-form-static.component";
+import { DynamicFormModelComponent } from "./components/dynamic-form-model/dynamic-form-model.component";
+export declare const components: (typeof DynamicFormComponent | typeof DynamicFormsComponent | typeof DynamicFormGroupComponent | typeof DynamicFormFileComponent | typeof DynamicFormInputComponent | typeof DynamicFormSelectComponent | typeof DynamicFormStaticComponent | typeof DynamicFormModelComponent)[];
+export declare const directives: (typeof AsyncSubmitDirective | typeof DynamicFormControlDirective | typeof DynamicFormTemplateDirective | typeof DynamicFormGroupDirective)[];
 export declare const pipes: any[];
 export declare class NgxDynamicFormModule {
-    static forRoot(): ModuleWithProviders<NgxDynamicFormModule>;
+    static forRoot(controlProviders?: Array<FormControlProvider>, groupProvider?: FormGroupProvider): ModuleWithProviders<NgxDynamicFormModule>;
 }

package/ngx-dynamic-form/services/dynamic-form.service.d.ts

@@ -1,40 +1,12 @@
-import { EventEmitter } from "@angular/core";
-import { AbstractControl, FormGroup } from "@angular/forms";
-import { DynamicCheckboxModelConfig, DynamicFileUploadModelConfig, DynamicFormComponent, DynamicFormComponentService, DynamicFormControlModel, DynamicFormGroupModelConfig, DynamicFormModel, DynamicFormOptionConfig, DynamicFormService as Base, DynamicFormValidationService, DynamicFormValueControlModelConfig, DynamicInputModelConfig, DynamicSelectModelConfig, DynamicTextAreaModelConfig, DynamicValidatorsConfig } from "@ng-dynamic-forms/core";
-import { IApiService, ILanguageService, IOpenApiSchema, IOpenApiSchemaProperty, IOpenApiSchemas, OpenApiService } from "@stemy/ngx-utils";
-import { FormSubject } from "../utils/form-subject";
-import { DynamicFormArrayModelConfig } from "../utils/dynamic-form-array.model";
-export declare class DynamicFormService extends Base {
-    readonly openApi: OpenApiService;
-    get api(): IApiService;
-    get language(): ILanguageService;
-    readonly onDetectChanges: EventEmitter<DynamicFormComponent>;
-    protected schemas: IOpenApiSchemas;
-    constructor(cs: DynamicFormComponentService, vs: DynamicFormValidationService, openApi: OpenApiService);
-    patchGroup(value: any, formModel: DynamicFormModel, formGroup: FormGroup): void;
-    patchForm(value: any, component: DynamicFormComponent): void;
-    serialize(formModel: DynamicFormModel, formGroup: FormGroup): Promise<any>;
-    notifyChanges(formModel: DynamicFormModel, formGroup: FormGroup): void;
-    updateSelectOptions(formControlModel: DynamicFormControlModel, formControl: AbstractControl): void;
-    showErrors(form: DynamicFormComponent): void;
-    detectChanges(formComponent?: DynamicFormComponent): void;
-    protected patchValueRecursive(value: any, formModel: DynamicFormModel, formGroup: FormGroup): void;
-    protected serializeRecursive(formModel: DynamicFormModel, formGroup: FormGroup): Promise<any>;
-    protected notifyChangesRecursive(formModel: DynamicFormModel, formGroup: FormGroup): void;
-    protected showErrorsForGroup(formGroup: FormGroup): void;
-    protected showErrorsForControls(controls: AbstractControl[]): void;
-    getFormModelForSchema(name: string): Promise<DynamicFormModel>;
-    protected getFormModelForSchemaDef(schema: IOpenApiSchema): DynamicFormModel;
-    protected getFormControlModel(property: IOpenApiSchemaProperty, schema: IOpenApiSchema): DynamicFormControlModel;
-    protected getFormControlConfig(property: IOpenApiSchemaProperty, schema: IOpenApiSchema): DynamicFormValueControlModelConfig<any>;
-    protected getFormArrayConfig(property: IOpenApiSchemaProperty, schema: IOpenApiSchema): DynamicFormArrayModelConfig;
-    protected getFormGroupConfig(property: IOpenApiSchemaProperty, schema: IOpenApiSchema): DynamicFormGroupModelConfig;
-    protected getFormInputConfig(property: IOpenApiSchemaProperty, schema: IOpenApiSchema): DynamicInputModelConfig;
-    protected getFormTextareaConfig(property: IOpenApiSchemaProperty, schema: IOpenApiSchema): DynamicTextAreaModelConfig;
-    protected getFormSelectConfig(property: IOpenApiSchemaProperty, schema: IOpenApiSchema): DynamicSelectModelConfig<any>;
-    protected getFormCheckboxConfig(property: IOpenApiSchemaProperty, schema: IOpenApiSchema): DynamicCheckboxModelConfig;
-    protected translateOptions(options: DynamicFormOptionConfig<any>[]): Promise<DynamicFormOptionConfig<any>[]>;
-    protected getFormSelectOptions(property: IOpenApiSchemaProperty, schema: IOpenApiSchema): FormSubject<DynamicFormOptionConfig<any>[]>;
-    protected getFormUploadConfig(property: IOpenApiSchemaProperty, schema: IOpenApiSchema): DynamicFileUploadModelConfig;
-    protected getValidators(property: IOpenApiSchemaProperty, schema: IOpenApiSchema): DynamicValidatorsConfig;
+import { ComponentFactoryResolver, Injector, Type, ViewContainerRef } from "@angular/core";
+import { IDynamicFormControl, IFormControlComponent, IFormControlProvider, IFormGroupComponent } from "../common-types";
+export declare class DynamicFormService {
+    private components;
+    private groupType;
+    private resolver;
+    readonly injector: Injector;
+    constructor(components: IFormControlProvider[], groupType: Type<IFormGroupComponent>, resolver: ComponentFactoryResolver, injector: Injector);
+    findProvider(control: IDynamicFormControl): IFormControlProvider;
+    createComponent(vcr: ViewContainerRef, provider: IFormControlProvider): IFormControlComponent;
+    createGroup(vcr: ViewContainerRef): IFormGroupComponent;
 }

package/ngx-dynamic-form/services/form-utilities.d.ts

@@ -0,0 +1,19 @@
+import { DatePipe } from "@angular/common";
+import { FormControlTester, FormControlValidator, IDynamicFormControl, IFormControlSerializer } from "../common-types";
+export declare class FormUtilities {
+    static checkField(expression?: string): FormControlTester;
+    static checkReadonly(control: IDynamicFormControl): Promise<boolean>;
+    static readonly(): Promise<boolean>;
+    static validateJSON(control: IDynamicFormControl): Promise<string>;
+    static validateRequired(control: IDynamicFormControl): Promise<string>;
+    static validateMinLength(length: number): FormControlValidator;
+    static validateMaxLength(length: number): FormControlValidator;
+    static validateRequiredTranslation(control: IDynamicFormControl): Promise<string>;
+    static validateEmail(control: IDynamicFormControl): Promise<string>;
+    static validatePhone(control: IDynamicFormControl): Promise<string>;
+    static serializeLogo(id: string, parent: IDynamicFormControl): Promise<any>;
+    static serializeFile(id: string, parent: IDynamicFormControl): Promise<any>;
+    static serializeNumber(id: string, parent: IDynamicFormControl): Promise<any>;
+    static serializeJSON(id: string, parent: IDynamicFormControl): Promise<any>;
+    static serializeDate(date: DatePipe, format?: string, defaultValue?: string): IFormControlSerializer;
+}

package/ngx-dynamic-form/services/open-api.service.d.ts

@@ -0,0 +1,37 @@
+import { ApiService } from "@stemy/ngx-utils";
+import { IFormControl, IFormSerializers } from "../common-types";
+export interface IOpenApiSchemaProperty {
+    id: string;
+    type: string;
+    format: string;
+    column: boolean;
+    additionalProperties: any;
+    $ref: string;
+    enum: string[];
+    [key: string]: any;
+}
+export interface IOpenApiSchema {
+    properties: {
+        [name: string]: IOpenApiSchemaProperty;
+    };
+    required: string[];
+}
+export interface IDynamicFormInputs {
+    controls?: IFormControl[];
+    serializers?: IFormSerializers;
+    schema?: IOpenApiSchema;
+}
+export declare class OpenApiService {
+    private api;
+    private schemasPromise;
+    private schemas;
+    constructor(api: ApiService);
+    getFormInputsForSchema(name: string): Promise<IDynamicFormInputs>;
+    private getFormInputsForSchemaDef;
+    private getFormControlForProperty;
+    private getBaseFormData;
+    private getFormInputData;
+    private getFormSelectData;
+    private getFormFileData;
+    private getValidators;
+}