@stemy/ngx-dynamic-form 19.1.14 → 19.2.1

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

@@ -1,37 +1,120 @@
-import { ChangeDetectorRef, EventEmitter, Injector, Type } from "@angular/core";
-import { AbstractControl } from "@angular/forms";
-import { DynamicFormControl, DynamicFormControlComponent, DynamicFormControlEvent, DynamicFormControlMapFn, DynamicFormControlModel, DynamicFormControlModelConfig, DynamicFormValueControlModel, DynamicFormComponent } from "@ng-dynamic-forms/core";
-import { IAsyncMessage, IOpenApiSchema, IOpenApiSchemaProperty } from "@stemy/ngx-utils";
+import { Injector, OutputRef, Signal } from "@angular/core";
+import { AbstractControl, FormGroup } from "@angular/forms";
+import { Observable } from "rxjs";
+import { FieldTypeConfig, FormlyFieldConfig, FormlyFieldProps } from "@ngx-formly/core";
+import { FormlySelectOption } from "@ngx-formly/core/select";
+import { IAsyncMessage, IOpenApiSchema, IOpenApiSchemaProperty, IRequestOptions } from "@stemy/ngx-utils";
+export type PromiseOrNot<T> = Promise<T> | T;
+export declare const FORM_ROOT_KEY = "__root";
 export type DynamicFormState = "VALID" | "INVALID" | "PENDING" | "DISABLED" | "LOADING";
 export type DynamicFormUpdateOn = "change" | "blur" | "submit";
-export interface IDynamicFormEvent extends DynamicFormControlEvent {
-    form: IDynamicForm;
+export type UploadData = Record<string, any> | ArrayBuffer | FormData;
+export interface FormBuilderOptions {
+    labelPrefix?: string;
 }
-export interface IDynamicForm extends DynamicFormComponent {
-    status?: DynamicFormState;
-    onValueChange?: EventEmitter<IDynamicFormEvent>;
-    onStatusChange?: EventEmitter<IDynamicForm>;
-    onSubmit?: EventEmitter<IDynamicForm>;
+export interface FormFieldProps extends FormlyFieldProps {
+    autocomplete?: string;
+    formCheck?: string;
+    indeterminate?: boolean;
+    multiple?: boolean;
+    inline?: boolean;
+    allowEmpty?: boolean;
+    groupBy?: string;
+    useTabs?: boolean;
+    tabsLabel?: string;
+    addItem?: boolean;
+    insertItem?: boolean;
+    cloneItem?: boolean;
+    moveItem?: boolean;
+    removeItem?: boolean;
+    clearItems?: boolean;
+    accept?: string | string[];
+    url?: string;
+    maxSize?: number;
+    uploadOptions?: IRequestOptions;
+    createUploadData?: (file: File) => UploadData | Promise<UploadData>;
+    multi?: boolean;
+    asFile?: boolean;
+    uploadUrl?: string;
 }
-export declare interface ModelType extends Function {
-    new (config: DynamicFormControlModelConfig): DynamicFormControlModel;
+export interface FormBaseFieldConfig<T = FormFieldProps> extends FormlyFieldConfig<T> {
 }
-export type PromiseOrNot<T> = Promise<T> | T;
-export type FormControlSerializer = (model: DynamicFormValueControlModel<any>, control: AbstractControl) => Promise<any>;
-export type FormModelCustomizer = (property: IOpenApiSchemaProperty, schema: IOpenApiSchema, model: DynamicFormControlModel, config: DynamicFormControlModelConfig, path: string, injector: Injector) => PromiseOrNot<DynamicFormControlModel | DynamicFormControlModel[]>;
-export interface ModelForSchemaOptions {
-    labelPrefix?: string;
-    customizer?: FormModelCustomizer;
+export type FormFieldSerializer = (field: FormBaseFieldConfig, injector: Injector) => PromiseOrNot<any>;
+export declare type FormHookFn = (field: FormBaseFieldConfig) => void;
+export interface FormHookConfig {
+    onInit?: FormHookFn | ((field: FormBaseFieldConfig) => Observable<any>);
+    onChanges?: FormHookFn;
+    afterContentInit?: FormHookFn;
+    afterViewInit?: FormHookFn;
+    onDestroy?: FormHookFn;
 }
-export interface ModelForSchemaWrapOptions extends Omit<ModelForSchemaOptions, "customizer"> {
-    schema: IOpenApiSchema;
-    customizer?: (property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions, modelType: ModelType, config: DynamicFormControlModelConfig, path: string) => Promise<DynamicFormControlModel[]>;
+export interface FormFieldConfig<T = FormFieldProps> extends FormBaseFieldConfig<T> {
+    serializer?: FormFieldSerializer;
+    serialize?: boolean;
+    fieldSet?: string;
+    hooks?: FormHookConfig;
+}
+export interface FormFieldType<T = FormFieldProps> extends FieldTypeConfig<T> {
 }
-export interface DynamicFormInitControl extends DynamicFormControl {
-    initialize(cdr?: ChangeDetectorRef): void;
+export interface FormSerializeResult {
+    [key: string]: any;
+}
+export interface FormSelectOption extends FormlySelectOption {
+    className?: string;
+    classes?: string[] | string;
+    id?: any;
+}
+export type FormSelectOptions = FormSelectOption[] | Observable<FormSelectOption[]>;
+export interface IDynamicForm {
+    readonly config: Signal<FormFieldConfig[]>;
+    readonly group: Signal<FormGroup>;
+    readonly status: Signal<DynamicFormState>;
+    readonly onSubmit: OutputRef<IDynamicForm>;
+}
+type FormFieldValidatorFn<T> = ((control: AbstractControl, field?: FormlyFieldConfig) => T) & {
+    validatorName?: string;
+};
+export type ValidationMessageFn = (error: any, field: FormFieldConfig) => string | Observable<string>;
+interface FormFieldValidatorExpression<T> {
+    expression: FormFieldValidatorFn<T>;
+    message: ValidationMessageFn;
+}
+type FormFieldValidation<T, R> = {
+    validation?: (string | T)[];
+} & {
+    [key: string]: FormFieldValidatorFn<R> | FormFieldValidatorExpression<R>;
+};
+export type ValidatorFn = FormFieldValidatorFn<boolean>;
+export type ValidatorExpression = FormFieldValidatorExpression<boolean>;
+export type Validators = FormFieldValidation<ValidatorFn, boolean>;
+export type AsyncBoolean = Promise<boolean> | Observable<boolean>;
+export type AsyncValidatorFn = FormFieldValidatorFn<AsyncBoolean>;
+export type AsyncValidatorExpression = FormFieldValidatorExpression<AsyncBoolean>;
+export type AsyncValidators = FormFieldValidation<AsyncValidatorFn, AsyncBoolean>;
+export type FormFieldCustom = Pick<FormFieldConfig, "wrappers" | "hooks" | "fieldGroup" | "fieldArray">;
+export type FormFieldData = Pick<FormFieldProps, "label" | "readonly" | "hidden"> & {
+    validators?: Validators | ValidatorFn[];
+    serializer?: FormFieldSerializer;
+    fieldSet?: string;
+    classes?: string[] | string;
+};
+export type FormInputData = FormFieldData & Pick<FormFieldProps, "type" | "pattern" | "placeholder" | "step" | "min" | "max" | "minLength" | "maxLength" | "autocomplete" | "indeterminate" | "cols" | "rows">;
+export type FormSelectData = FormFieldData & Pick<FormFieldProps, "multiple" | "type" | "inline" | "allowEmpty" | "groupBy"> & {
+    options: (field: FormFieldConfig) => FormSelectOptions | Promise<FormSelectOption[]>;
+};
+export type FormUploadData = FormFieldData & Pick<FormFieldProps, "inline" | "multiple" | "accept" | "url" | "maxSize" | "uploadOptions" | "createUploadData" | "multi" | "asFile" | "uploadUrl">;
+export type FormGroupData = FormFieldData;
+export type FormArrayData = FormFieldData & Pick<FormFieldProps, "useTabs" | "tabsLabel" | "addItem" | "insertItem" | "cloneItem" | "moveItem" | "removeItem" | "clearItems">;
+export type FormFieldCustomizer = (property: IOpenApiSchemaProperty, schema: IOpenApiSchema, field: FormlyFieldConfig, parent: FormFieldConfig, options: FormBuilderOptions, injector: Injector) => PromiseOrNot<FormlyFieldConfig | FormlyFieldConfig[]>;
+export interface ConfigForSchemaOptions extends FormBuilderOptions {
+    customizer?: FormFieldCustomizer;
+}
+export interface ConfigForSchemaWrapOptions extends Omit<ConfigForSchemaOptions, "customizer"> {
+    schema: IOpenApiSchema;
+    injector?: Injector;
+    customizer?: (property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions, field: FormFieldConfig, parent: FormFieldConfig) => Promise<FormFieldConfig[]>;
 }
 export declare type AsyncSubmitMethod = (form: IDynamicForm, context?: any) => Promise<IAsyncMessage>;
-export type GetFormControlComponentType = (model: DynamicFormControlModel, injector: Injector) => Type<DynamicFormControlComponent>;
 export interface IDynamicFormModuleConfig {
-    controlProvider?: (injector: Injector) => DynamicFormControlMapFn;
 }
+export {};

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

@@ -0,0 +1,21 @@
+import { FormGroup } from "@angular/forms";
+import { FormlyFormOptions } from "@ngx-formly/core";
+import { FormFieldConfig, IDynamicForm } from "../../common-types";
+import { DynamicFormBuilderService } from "../../services/dynamic-form-builder.service";
+import * as i0 from "@angular/core";
+export declare class DynamicFormComponent implements IDynamicForm {
+    protected readonly builder: DynamicFormBuilderService;
+    readonly labelPrefix: import("@angular/core").InputSignal<string>;
+    readonly data: import("@angular/core").InputSignal<any>;
+    readonly fields: import("@angular/core").InputSignal<FormFieldConfig<import("../../common-types").FormFieldProps>[]>;
+    protected readonly config$: import("@angular/core").ResourceRef<FormFieldConfig<import("../../common-types").FormFieldProps>[]>;
+    readonly config: import("@angular/core").Signal<FormFieldConfig<import("../../common-types").FormFieldProps>[]>;
+    readonly group: import("@angular/core").Signal<FormGroup<{}>>;
+    protected readonly status$: import("@angular/core").ResourceRef<import("@angular/forms").FormControlStatus>;
+    readonly status: import("@angular/core").Signal<import("@angular/forms").FormControlStatus>;
+    readonly onSubmit: import("@angular/core").OutputEmitterRef<IDynamicForm>;
+    readonly options: FormlyFormOptions;
+    submit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormComponent, "dynamic-form", never, { "labelPrefix": { "alias": "labelPrefix"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "fields": { "alias": "fields"; "required": false; "isSignal": true; }; }, { "onSubmit": "onSubmit"; }, never, ["*"], false, never>;
+}

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

@@ -0,0 +1,9 @@
+import { FieldArrayType } from "@ngx-formly/core";
+import { FormFieldConfig } from "../../common-types";
+import * as i0 from "@angular/core";
+export declare class DynamicFormArrayComponent extends FieldArrayType<FormFieldConfig> {
+    readonly currentTab: import("@angular/core").WritableSignal<number>;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormArrayComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormArrayComponent, "dynamic-form-array", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,7 @@
+import { FieldType } from "@ngx-formly/core";
+import { FormFieldType } from "../../common-types";
+import * as i0 from "@angular/core";
+export declare class DynamicFormChipsComponent extends FieldType<FormFieldType> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormChipsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormChipsComponent, "dynamic-form-chips", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,6 @@
+import { FieldWrapper } from "@ngx-formly/core";
+import * as i0 from "@angular/core";
+export declare class DynamicFormFieldComponent extends FieldWrapper {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormFieldComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormFieldComponent, "dynamic-form-field", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,7 @@
+import { FieldWrapper } from "@ngx-formly/core";
+import * as i0 from "@angular/core";
+export declare class DynamicFormFieldsetComponent extends FieldWrapper {
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormFieldsetComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormFieldsetComponent, "dynamic-form-field", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,6 @@
+import { FieldWrapper } from "@ngx-formly/core";
+import * as i0 from "@angular/core";
+export declare class DynamicFormGroupComponent extends FieldWrapper {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormGroupComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormGroupComponent, "dynamic-form-group", never, {}, {}, never, never, false, never>;
+}

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

@@ -0,0 +1,7 @@
+import { FieldType } from "@ngx-formly/core";
+import { FormFieldType } from "../../common-types";
+import * as i0 from "@angular/core";
+export declare class DynamicFormUploadComponent extends FieldType<FormFieldType> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormUploadComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormUploadComponent, "dynamic-form-upload", never, {}, {}, never, never, false, never>;
+}

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

@@ -1,31 +1,25 @@
-import { ChangeDetectorRef, ElementRef, EventEmitter, NgZone, OnChanges, OnDestroy, Renderer2, SimpleChanges } from "@angular/core";
-import { Subscription } from "rxjs";
-import { IAsyncMessage, IToasterService } from "@stemy/ngx-utils";
+import { ElementRef, Renderer2 } from "@angular/core";
+import { IAsyncMessage } from "@stemy/ngx-utils";
 import { AsyncSubmitMethod, IDynamicForm } from "../common-types";
 import * as i0 from "@angular/core";
-export declare class AsyncSubmitDirective implements OnChanges, OnDestroy {
-    private toaster;
-    readonly cdr: ChangeDetectorRef;
-    readonly zone: NgZone;
-    readonly elem: ElementRef<HTMLElement>;
-    readonly renderer: Renderer2;
-    method: AsyncSubmitMethod;
-    form: IDynamicForm;
-    context: any;
-    onSuccess: EventEmitter<IAsyncMessage>;
-    onError: EventEmitter<IAsyncMessage>;
-    protected loading: boolean;
-    protected disabled: boolean;
-    protected callback: Function;
-    protected subscription: Subscription;
+export declare class AsyncSubmitDirective {
+    method: import("@angular/core").InputSignal<AsyncSubmitMethod>;
+    form: import("@angular/core").InputSignal<IDynamicForm>;
+    context: import("@angular/core").InputSignal<any>;
+    onSuccess: import("@angular/core").OutputEmitterRef<IAsyncMessage>;
+    onError: import("@angular/core").OutputEmitterRef<IAsyncMessage>;
+    toaster: import("@stemy/ngx-utils").IToasterService;
+    renderer: Renderer2;
+    elem: ElementRef<HTMLElement>;
+    protected status: import("@angular/core").Signal<import("../common-types").DynamicFormState>;
+    protected group: import("@angular/core").Signal<import("@angular/forms").FormGroup<any>>;
+    protected loading: import("@angular/core").WritableSignal<boolean>;
+    protected callback: import("@angular/core").WritableSignal<() => void>;
     get isDisabled(): boolean;
-    set isDisabled(value: boolean);
     get isLoading(): boolean;
-    constructor(toaster: IToasterService, cdr: ChangeDetectorRef, zone: NgZone, elem: ElementRef<HTMLElement>, renderer: Renderer2);
-    ngOnChanges(changes: SimpleChanges): void;
-    ngOnDestroy(): void;
+    constructor();
     click(): void;
     callMethod(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<AsyncSubmitDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<AsyncSubmitDirective, "[async-submit]", ["async-submit"], { "method": { "alias": "async-submit"; "required": false; }; "form": { "alias": "form"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, { "onSuccess": "onSuccess"; "onError": "onError"; }, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AsyncSubmitDirective, "[async-submit]", ["async-submit"], { "method": { "alias": "async-submit"; "required": false; "isSignal": true; }; "form": { "alias": "form"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; }, { "onSuccess": "onSuccess"; "onError": "onError"; }, never, never, false, never>;
 }

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

@@ -1,12 +1,8 @@
-import { DynamicFormControlMapFn } from "@ng-dynamic-forms/core";
 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 { DynamicBaseFormControlComponent } from "./components/base/dynamic-base-form-control.component";
-import { DynamicBaseFormControlContainerComponent } from "./components/base/dynamic-base-form-control-container.component";
-import { DynamicBaseFormGroupComponent } from "./components/base/dynamic-base-form-group.component";
-import { DynamicBaseSelectComponent } from "./components/base/dynamic-base-select.component";
-export declare const components: (typeof DynamicBaseFormComponent | typeof DynamicBaseFormControlContainerComponent | typeof DynamicBaseFormArrayComponent | typeof DynamicBaseFormControlComponent | typeof DynamicBaseFormGroupComponent | typeof DynamicBaseSelectComponent)[];
+import { DynamicFormComponent } from "./components/dynamic-form/dynamic-form.component";
+import { DynamicFormArrayComponent } from "./components/dynamic-form-array/dynamic-form-array.component";
+import { DynamicFormChipsComponent } from "./components/dynamic-form-chips/dynamic-form-chips.component";
+import { DynamicFormFieldComponent } from "./components/dynamic-form-field/dynamic-form-field.component";
+export declare const components: (typeof DynamicFormComponent | typeof DynamicFormArrayComponent | typeof DynamicFormChipsComponent | typeof DynamicFormFieldComponent)[];
 export declare const directives: (typeof AsyncSubmitDirective)[];
 export declare const pipes: any[];
-export declare function defaultFormControlProvider(): DynamicFormControlMapFn;

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

@@ -1,21 +1,23 @@
 import { EnvironmentProviders, ModuleWithProviders } from "@angular/core";
 import { IDynamicFormModuleConfig } from "./common-types";
 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.component";
-import * as i4 from "./components/base/dynamic-base-form-control-container.component";
-import * as i5 from "./components/base/dynamic-base-form-group.component";
-import * as i6 from "./components/base/dynamic-base-select.component";
-import * as i7 from "./directives/async-submit.directive";
-import * as i8 from "@angular/common";
-import * as i9 from "@angular/forms";
-import * as i10 from "@stemy/ngx-utils";
+import * as i1 from "./components/dynamic-form/dynamic-form.component";
+import * as i2 from "./components/dynamic-form-array/dynamic-form-array.component";
+import * as i3 from "./components/dynamic-form-chips/dynamic-form-chips.component";
+import * as i4 from "./components/dynamic-form-field/dynamic-form-field.component";
+import * as i5 from "./components/dynamic-form-fieldset/dynamic-form-fieldset.component";
+import * as i6 from "./components/dynamic-form-group/dynamic-form-group.component";
+import * as i7 from "./components/dynamic-form-upload/dynamic-form-upload.component";
+import * as i8 from "./directives/async-submit.directive";
+import * as i9 from "@angular/common";
+import * as i10 from "@angular/forms";
+import * as i11 from "@stemy/ngx-utils";
+import * as i12 from "@ngx-formly/core";
 export declare class NgxDynamicFormModule {
     private static getProviders;
     static forRoot(config?: IDynamicFormModuleConfig): ModuleWithProviders<NgxDynamicFormModule>;
     static provideForms(config?: IDynamicFormModuleConfig): EnvironmentProviders;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgxDynamicFormModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxDynamicFormModule, [typeof i1.DynamicBaseFormComponent, typeof i2.DynamicBaseFormArrayComponent, typeof i3.DynamicBaseFormControlComponent, typeof i4.DynamicBaseFormControlContainerComponent, typeof i5.DynamicBaseFormGroupComponent, typeof i6.DynamicBaseSelectComponent, typeof i7.AsyncSubmitDirective], [typeof i8.CommonModule, typeof i9.FormsModule, typeof i9.ReactiveFormsModule, typeof i10.NgxUtilsModule], [typeof i1.DynamicBaseFormComponent, typeof i2.DynamicBaseFormArrayComponent, typeof i3.DynamicBaseFormControlComponent, typeof i4.DynamicBaseFormControlContainerComponent, typeof i5.DynamicBaseFormGroupComponent, typeof i6.DynamicBaseSelectComponent, typeof i7.AsyncSubmitDirective, typeof i9.FormsModule, typeof i9.ReactiveFormsModule, typeof i10.NgxUtilsModule]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NgxDynamicFormModule, [typeof i1.DynamicFormComponent, typeof i2.DynamicFormArrayComponent, typeof i3.DynamicFormChipsComponent, typeof i4.DynamicFormFieldComponent, typeof i5.DynamicFormFieldsetComponent, typeof i6.DynamicFormGroupComponent, typeof i7.DynamicFormUploadComponent, typeof i8.AsyncSubmitDirective], [typeof i9.CommonModule, typeof i10.FormsModule, typeof i10.ReactiveFormsModule, typeof i11.NgxUtilsModule, typeof i12.FormlyModule], [typeof i1.DynamicFormComponent, typeof i2.DynamicFormArrayComponent, typeof i3.DynamicFormChipsComponent, typeof i4.DynamicFormFieldComponent, typeof i5.DynamicFormFieldsetComponent, typeof i6.DynamicFormGroupComponent, typeof i7.DynamicFormUploadComponent, typeof i8.AsyncSubmitDirective, typeof i10.FormsModule, typeof i10.ReactiveFormsModule, typeof i11.NgxUtilsModule, typeof i12.FormlyModule]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<NgxDynamicFormModule>;
 }

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

@@ -0,0 +1,27 @@
+import { Injector, Type } from "@angular/core";
+import { IApiService, ILanguageService } from "@stemy/ngx-utils";
+import { FormArrayData, FormBuilderOptions, FormFieldConfig, FormFieldData, FormFieldProps, FormGroupData, FormInputData, FormSelectData, FormSelectOption, FormUploadData } from "../common-types";
+import * as i0 from "@angular/core";
+export type FormFieldBuilder = (fb: DynamicFormBuilderService, parent: FormFieldConfig, options: FormBuilderOptions) => FormFieldConfig;
+export declare class DynamicFormBuilderService {
+    readonly injector: Injector;
+    readonly api: IApiService;
+    readonly language: ILanguageService;
+    constructor(injector: Injector, api: IApiService, language: ILanguageService);
+    protected getLabel(key: string, label: string, parent: FormFieldConfig, options: FormBuilderOptions): string;
+    protected createFormField(key: string, type: string, data: FormFieldData, props: FormFieldProps, parent: FormFieldConfig, options: FormBuilderOptions): FormFieldConfig;
+    resolveFormFields(target: Type<any>, parent: FormFieldConfig, options: FormBuilderOptions): FormFieldConfig[];
+    resolveFormGroup(key: string, target: Type<any>, data: FormGroupData, parent?: FormFieldConfig, options?: FormBuilderOptions): FormFieldConfig;
+    resolveFormArray(key: string, itemType: string | FormInputData | Type<any>, data: FormArrayData, parent?: FormFieldConfig, options?: FormBuilderOptions): FormFieldConfig;
+    createFieldSets(fields: FormFieldConfig[], parent: FormFieldConfig, options: FormBuilderOptions): FormFieldConfig[];
+    createFormInput(key: string, data: FormInputData, parent: FormFieldConfig, options: FormBuilderOptions): FormFieldConfig;
+    createFormSelect(key: string, data: FormSelectData, parent: FormFieldConfig, options: FormBuilderOptions): FormFieldConfig;
+    createFormUpload(key: string, data: FormUploadData, parent: FormFieldConfig, options: FormBuilderOptions): FormFieldConfig;
+    createFormGroup(key: string, fields: (parent: FormFieldConfig) => FormFieldConfig[], data: FormGroupData, parent: FormFieldConfig, options: FormBuilderOptions): FormFieldConfig;
+    createFormGroup(key: string, fields: (parent: FormFieldConfig) => Promise<FormFieldConfig[]>, data: FormGroupData, parent: FormFieldConfig, options: FormBuilderOptions): Promise<FormFieldConfig>;
+    createFormArray(key: string, fields: (parent: FormFieldConfig) => FormFieldConfig | FormFieldConfig[], data: FormArrayData, parent: FormFieldConfig, options: FormBuilderOptions): FormFieldConfig;
+    createFormArray(key: string, fields: (parent: FormFieldConfig) => Promise<FormFieldConfig | FormFieldConfig[]>, data: FormArrayData, parent: FormFieldConfig, options: FormBuilderOptions): Promise<FormFieldConfig>;
+    fixSelectOptions(field: FormFieldConfig, options: FormSelectOption[]): Promise<FormSelectOption[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicFormBuilderService>;
+}

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

@@ -1,61 +1,43 @@
 import { Injector } from "@angular/core";
-import { AbstractControl, AbstractControlOptions, FormArray, FormControl, FormGroup } from "@angular/forms";
-import { DynamicCheckboxModelConfig, DynamicDatePickerModelConfig, DynamicFileUploadModelConfig, DynamicFormComponentService, DynamicFormControlModel, DynamicFormModel, DynamicFormService as Base, DynamicFormValidationService, DynamicFormValueControlModelConfig, DynamicInputModelConfig, DynamicPathable, DynamicRadioGroupModelConfig, DynamicTextAreaModelConfig, DynamicValidatorsConfig } from "@ng-dynamic-forms/core";
+import { AbstractControl, FormGroup } from "@angular/forms";
+import { FormlyFieldConfig } from "@ngx-formly/core";
 import { IApiService, ILanguageService, IOpenApiSchema, IOpenApiSchemaProperty, IOpenApiSchemas, OpenApiService } from "@stemy/ngx-utils";
-import { FormModelCustomizer, IDynamicForm, ModelForSchemaOptions, ModelForSchemaWrapOptions } from "../common-types";
-import { FormSelectSubject } from "../utils/form-select-subject";
-import { DynamicEditorModelConfig } from "../utils/dynamic-editor.model";
-import { DynamicFormArrayModel, DynamicFormArrayModelConfig } from "../utils/dynamic-form-array.model";
-import { DynamicFormFieldSet, DynamicFormGroupModel, DynamicFormGroupModelConfig } from "../utils/dynamic-form-group.model";
-import { DynamicFormOptionConfig, DynamicSelectModel, DynamicSelectModelConfig } from "../utils/dynamic-select.model";
-import { DynamicBaseFormComponent } from "../components/base/dynamic-base-form.component";
-import { AllValidationErrors } from "../utils/validation-errors";
+import { ConfigForSchemaOptions, ConfigForSchemaWrapOptions, FormFieldConfig, FormFieldCustomizer, FormFieldData, FormSelectOptions, FormSerializeResult, IDynamicForm, Validators } from "../common-types";
+import { DynamicFormBuilderService } from "./dynamic-form-builder.service";
 import * as i0 from "@angular/core";
-export declare class DynamicFormService extends Base {
+export declare class DynamicFormService {
     readonly openApi: OpenApiService;
     readonly injector: Injector;
+    readonly builder: DynamicFormBuilderService;
     get api(): IApiService;
     get language(): ILanguageService;
     protected schemas: IOpenApiSchemas;
-    constructor(cs: DynamicFormComponentService, vs: DynamicFormValidationService, openApi: OpenApiService, injector: Injector);
-    serializeForm(form: IDynamicForm, validate?: boolean): Promise<any>;
-    getFormModelForSchema(name: string, customizeOrOptions?: FormModelCustomizer | ModelForSchemaOptions): Promise<DynamicFormModel>;
-    getErrors(form: DynamicBaseFormComponent): Promise<AllValidationErrors[]>;
-    createFormGroup(formModel: DynamicFormModel, options?: AbstractControlOptions | null, parent?: DynamicPathable | null): import("@angular/forms").UntypedFormGroup;
-    patchGroup(value: any, formModel: DynamicFormModel, formGroup: FormGroup): void;
-    patchForm(value: any, component: DynamicBaseFormComponent): void;
+    constructor(openApi: OpenApiService, injector: Injector, builder: DynamicFormBuilderService);
+    getFormFieldsForSchema(name: string, customizeOrOptions?: FormFieldCustomizer | ConfigForSchemaOptions): Promise<FormlyFieldConfig[]>;
+    serializeForm(form: IDynamicForm, validate?: boolean): Promise<FormSerializeResult>;
     validateForm(form: IDynamicForm, showErrors?: boolean): Promise<any>;
-    serialize(formModel: DynamicFormModel, formGroup: FormGroup): Promise<any>;
-    showErrors(form: IDynamicForm): void;
-    notifyChanges(formModel: DynamicFormModel, formGroup: FormGroup, root: DynamicFormModel): void;
-    protected patchValues(value: any, formModel: DynamicFormModel, formGroup: FormGroup): void;
-    protected updateSelectOptions(formControlModel: DynamicFormControlModel, formControl: FormControl, root: DynamicFormModel): void;
+    serialize(fields: FormFieldConfig[]): Promise<FormSerializeResult>;
     protected showErrorsForGroup(formGroup: FormGroup): void;
     protected showErrorsForControls(controls: AbstractControl[]): void;
-    protected convertToDate(value: any): Date;
-    getFormGroupModelForSchema(name: string, customizeOrOptions?: FormModelCustomizer | ModelForSchemaOptions): Promise<DynamicFormGroupModel>;
-    protected getFormModelForSchemaDef(schema: IOpenApiSchema, fieldSets: DynamicFormFieldSet<string>[], options: ModelForSchemaWrapOptions, path: string): Promise<DynamicFormModel>;
-    protected checkIsEditorProperty(property: IOpenApiSchemaProperty): boolean;
-    protected getFormControlModels(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions, path: string): Promise<DynamicFormControlModel[]>;
-    findModelByPath(parent: DynamicPathable | DynamicFormModel, path: string[]): DynamicPathable;
-    getFormControlConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicFormValueControlModelConfig<any>;
-    getFormArrayConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions, path: string): Promise<DynamicFormArrayModelConfig>;
-    getFormGroupConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions, path: string): Promise<DynamicFormGroupModelConfig>;
-    getFormInputConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicInputModelConfig;
-    getFormEditorConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicEditorModelConfig;
-    getFormTextareaConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicTextAreaModelConfig;
-    getFormDatepickerConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicDatePickerModelConfig;
-    getFormSelectOptions(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): FormSelectSubject<DynamicFormOptionConfig<any>[]>;
-    getFormRadioConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicRadioGroupModelConfig<any>;
-    getFormSelectConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicSelectModelConfig<any>;
-    getFormUploadConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicFileUploadModelConfig;
-    getFormCheckboxConfig(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicCheckboxModelConfig;
-    cloneFormArrayGroup(index: number, formArray: FormArray, formArrayModel: DynamicFormArrayModel): void;
+    protected convertToDate(value: any): any;
+    getFormFieldGroupForSchema(name: string, customizeOrOptions?: FormFieldCustomizer | ConfigForSchemaOptions): Promise<FormlyFieldConfig>;
+    protected getFormFieldsForSchemaDef(schema: IOpenApiSchema, parent: FormFieldConfig, options: ConfigForSchemaWrapOptions): Promise<FormFieldConfig[]>;
+    protected getFormFieldsForProp(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions, parent: FormFieldConfig): Promise<FormFieldConfig[]>;
+    protected getFormFieldForProp(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions, parent: FormFieldConfig): Promise<FormFieldConfig>;
+    protected getFormFieldData(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions): FormFieldData;
+    protected getFormArrayConfig(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions, parent: FormFieldConfig): Promise<FormlyFieldConfig>;
+    protected getFormGroupConfig(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions, parent: FormFieldConfig): Promise<FormlyFieldConfig>;
+    protected getFormInputConfig(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions, parent: FormFieldConfig): FormFieldConfig;
+    protected getFormTextareaConfig(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions, parent: FormFieldConfig): FormFieldConfig;
+    protected getFormDatepickerConfig(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions, parent: FormFieldConfig): FormFieldConfig;
+    protected getFormRadioConfig(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions, parent: FormFieldConfig): FormFieldConfig;
+    protected getFormSelectConfig(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions, parent: FormFieldConfig): FormFieldConfig;
+    protected getFormUploadConfig(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions, parent: FormFieldConfig): FormFieldConfig;
+    protected getFormCheckboxConfig(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions, parent: FormFieldConfig): FormFieldConfig;
+    protected getFormSelectOptions(property: IOpenApiSchemaProperty, options: ConfigForSchemaWrapOptions, field: FormFieldConfig): FormSelectOptions;
     protected replaceOptionsEndpoint(endpoint: string, key: string, value: any): string;
-    protected fixSelectOptions(model: DynamicSelectModel<any>, control: FormControl, options: DynamicFormOptionConfig<any>[]): Promise<DynamicFormOptionConfig<any>[]>;
-    protected getValidators(property: IOpenApiSchemaProperty, options: ModelForSchemaWrapOptions): DynamicValidatorsConfig;
-    protected addPropertyValidators(validators: DynamicValidatorsConfig, property: IOpenApiSchemaProperty): void;
-    protected addItemsValidators(validators: DynamicValidatorsConfig, items: IOpenApiSchemaProperty): void;
+    protected addPropertyValidators(validators: Validators, property: IOpenApiSchemaProperty): void;
+    protected addItemsValidators(validators: Validators, items: IOpenApiSchemaProperty): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DynamicFormService>;
 }

package/ngx-dynamic-form/utils/customizer.d.ts

@@ -1,14 +1,7 @@
-import { Type } from "@angular/core";
-import { DynamicFormControlComponent, DynamicFormControlModel, DynamicFormControlModelConfig } from "@ng-dynamic-forms/core";
 import { CachedProvider, IOpenApiSchema, IOpenApiSchemaProperty } from "@stemy/ngx-utils";
-import { FormModelCustomizer, GetFormControlComponentType, PromiseOrNot } from "../common-types";
-export interface IFormComponentCustomizer {
-    acceptModel(model: DynamicFormControlModel, path: string): boolean;
-    getFormComponent(model: DynamicFormControlModel): Type<DynamicFormControlComponent>;
+import { FormBuilderOptions, FormFieldConfig, FormFieldCustomizer, PromiseOrNot } from "../common-types";
+export interface IFormFieldCustomizer {
+    acceptField(config: FormFieldConfig, parent: FormFieldConfig): boolean;
+    customizeField(config: FormFieldConfig, property: IOpenApiSchemaProperty, schema: IOpenApiSchema, parent: FormFieldConfig, options: FormBuilderOptions): PromiseOrNot<FormFieldConfig | FormFieldConfig[]>;
 }
-export declare function getFormComponent(...providers: CachedProvider<IFormComponentCustomizer>[]): GetFormControlComponentType;
-export interface IFormModelCustomizer {
-    acceptModel(model: DynamicFormControlModel, path: string): boolean;
-    customizeModel(model: DynamicFormControlModel, config: DynamicFormControlModelConfig, property: IOpenApiSchemaProperty, schema: IOpenApiSchema, path: string): PromiseOrNot<DynamicFormControlModel | DynamicFormControlModel[]>;
-}
-export declare function customizeFormModel(...providers: CachedProvider<IFormModelCustomizer>[]): FormModelCustomizer;
+export declare function customizeFormField(...providers: CachedProvider<IFormFieldCustomizer>[]): FormFieldCustomizer;

package/ngx-dynamic-form/utils/decorators.d.ts

@@ -0,0 +1,10 @@
+import { FormArrayData, FormFieldSerializer, FormGroupData, FormInputData, FormSelectData, FormUploadData } from "../common-types";
+import { Type } from "@angular/core";
+export declare function FormSerializable(serializer?: FormFieldSerializer): PropertyDecorator;
+export declare function FormInput(data?: FormInputData): PropertyDecorator;
+export declare function FormSelect(data?: FormSelectData): PropertyDecorator;
+export declare function FormUpload(data?: FormUploadData): PropertyDecorator;
+export declare function FormFile(data?: FormUploadData): PropertyDecorator;
+export declare function FormGroup(data?: FormGroupData): PropertyDecorator;
+export declare function FormArray(itemType: string | FormInputData | Type<any>, data?: FormArrayData): PropertyDecorator;
+export declare function FormModel(data?: FormGroupData): PropertyDecorator;

package/ngx-dynamic-form/utils/misc.d.ts

@@ -1,11 +1,9 @@
-import { DynamicFormModel, DynamicPathable } from "@ng-dynamic-forms/core";
 import { IOpenApiSchemaProperty } from "@stemy/ngx-utils";
+import { FormlyFieldConfig } from "@ngx-formly/core";
 export declare function isStringWithVal(val: any): boolean;
 export declare function findRefs(property: IOpenApiSchemaProperty): string[];
 export declare function replaceSpecialChars(str: string, to?: string): string;
-export declare function mergeFormModels(formModels: DynamicFormModel[]): DynamicFormModel;
-export declare function collectPathAble<T extends DynamicPathable>(start: T, getter: (cur: T & DynamicPathable) => string): string[];
-export declare function getDynamicPath(start: DynamicPathable): string;
+export declare function mergeFormFields(formFields: FormlyFieldConfig[][]): FormlyFieldConfig[];
 export declare const MIN_INPUT_NUM = -999999999;
 export declare const MAX_INPUT_NUM = 999999999;
 export declare const EDITOR_FORMATS: string[];

package/ngx-dynamic-form/utils/validation.d.ts

@@ -0,0 +1,13 @@
+import { Injector } from "@angular/core";
+import { ValidationMessageFn, ValidatorFn } from "../common-types";
+export declare function validationMessage(injector: Injector, key: string, labelPrefix?: string): ValidationMessageFn;
+export declare function withName(fn: ValidatorFn, name: string): ValidatorFn;
+export declare function jsonValidation(): ValidatorFn;
+export declare function requiredValidation(): ValidatorFn;
+export declare function translationValidation(langs?: string[]): ValidatorFn;
+export declare function phoneValidation(): ValidatorFn;
+export declare function emailValidation(): ValidatorFn;
+export declare function minLengthValidation(minLength: number, each?: boolean): ValidatorFn;
+export declare function maxLengthValidation(maxLength: number, each?: boolean): ValidatorFn;
+export declare function minValueValidation(min: number, each?: boolean): ValidatorFn;
+export declare function maxValueValidation(max: number, each?: boolean): ValidatorFn;

package/package.json

@@ -1,29 +1,30 @@
 {
   "name": "@stemy/ngx-dynamic-form",
-  "version": "19.1.14",
+  "version": "19.2.1",
   "license": "MIT",
   "public": true,
   "repository": "https://github.com/stemyke/ngx-dynamic-form.git",
   "author": "stemy <balazs.stemler@metrix.co.hu>",
   "peerDependencies": {
-    "@angular/animations": "^17.0.0 || ^18.0.0 || ^19.0.0",
-    "@angular/common": "^17.0.0 || ^18.0.0 || ^19.0.0",
-    "@angular/compiler": "^17.0.0 || ^18.0.0 || ^19.0.0",
-    "@angular/core": "^17.0.0 || ^18.0.0 || ^19.0.0",
-    "@angular/forms": "^17.0.0 || ^18.0.0 || ^19.0.0",
-    "@angular/router": "^17.0.0 || ^18.0.0 || ^19.0.0",
-    "@angular/platform-browser": "^17.0.0 || ^18.0.0 || ^19.0.0",
-    "@angular/platform-server": "^17.0.0 || ^18.0.0 || ^19.0.0",
-    "express": "^4.21.2",
+    "@angular/animations": "^19.2.14",
+    "@angular/common": "^19.2.14",
+    "@angular/compiler": "^19.2.14",
+    "@angular/core": "^19.2.14",
+    "@angular/forms": "^19.2.14",
+    "@angular/router": "^19.2.14",
+    "@angular/platform-browser": "^19.2.14",
+    "@angular/platform-server": "^19.2.14",
+    "express": "~4.21.2",
     "element-resize-detector": "^1.2.4",
-    "rxjs": "^6.6.2 || ~7.8.0",
-    "moment": "^2.30.1",
+    "rxjs": "^7.8.2",
+    "luxon": "^3.6.1",
     "invokable": "^1.0.3",
-    "ngx-device-detector": "^5.0.1 || ^8.0.0",
+    "ngx-device-detector": "^9.0.0",
+    "@floating-ui/dom": "^1.7.1",
     "json5": "^2.2.3",
-    "@stemy/ngx-utils": "^17.1.5 || ^19.0.0",
-    "@ng-dynamic-forms/core": "^18.0.0",
-    "@ng-dynamic-forms/ui-basic": "^18.0.0",
+    "@stemy/ngx-utils": "^19.5.0",
+    "@ngx-formly/core": "^6.3.12",
+    "@ngx-formly/bootstrap": "^6.3.12",
     "ngx-mask": "^17.1.8"
   },
   "main": "dist/bundles/stemy-ngx-dynamic-form.umd.js",
@@ -45,6 +46,10 @@
     ".": {
       "types": "./index.d.ts",
       "default": "./fesm2022/stemy-ngx-dynamic-form.mjs"
+    },
+    "./ui-nebular": {
+      "types": "./ui-nebular/index.d.ts",
+      "default": "./fesm2022/stemy-ngx-dynamic-form-ui-nebular.mjs"
     }
   },
   "sideEffects": false