@dynamicforms/vue-forms 0.2.6 → 0.3.1

package/dist/index.d.ts

@@ -4,22 +4,22 @@ import { Ref } from 'vue';
 export declare class AbortEventHandlingException extends Error {
 }
 
-export declare class Action extends FieldBase {
-    private readonly _value;
-    protected constructor(params?: Partial<IFieldConstructorParams<ActionValue>>);
-    static create(params?: Partial<IField<ActionValue>>): Action;
-    get value(): ActionValue;
-    set value(newValue: ActionValue);
-    setValue(newValue: ActionValue): Promise<void>;
+export declare class Action<T extends ActionValue = ActionValue> extends FieldBase<T> {
+    private _value;
+    protected constructor();
+    protected init(params?: Partial<IFieldConstructorParams<T>>): void;
+    static create<T extends ActionValue = ActionValue>(params?: Partial<IField<T>>): Action<T>;
+    get value(): T;
+    set value(newValue: T);
     get icon(): string | undefined;
     set icon(newValue: string | undefined);
     get label(): string | undefined;
     set label(newValue: string | undefined);
-    clone(overrides?: Partial<IField>): Action;
+    clone(overrides?: Partial<IField<T>>): Action<T>;
     execute(params: any): void;
 }
 
-declare type ActionExecutor = (field: IField, supr: FieldActionExecute, ...params: any[]) => Promise<any>;
+declare type ActionExecutor = (field: IField, supr: FieldActionExecute, ...params: any[]) => any;
 
 export declare class ActionsMap extends Map<symbol, FieldActionExecute> {
     private readonly eagerActions;
@@ -28,8 +28,9 @@ export declare class ActionsMap extends Map<symbol, FieldActionExecute> {
     trigger<T extends FieldActionBase>(ActionClass: {
         new (...args: any[]): T;
         classIdentifier: symbol;
-    }, field: IField, ...params: any[]): Promise<any>;
-    triggerEager(field: IField, ...params: any[]): Promise<any>;
+    }, field: IField, ...params: any[]): any;
+    triggerEager(field: IField, ...params: any[]): any;
+    clone(): ActionsMap;
     cloneWithoutValidators(): ActionsMap;
 }
 
@@ -52,7 +53,7 @@ export declare class ConditionalEnabledAction extends ConditionalStatementAction
     constructor(statement: Statement);
 }
 
-declare type ConditionalExecutorFn = (field: IField, currentResult: boolean, previousResult: boolean | undefined) => Promise<void>;
+declare type ConditionalExecutorFn = (field: IField, currentResult: boolean, previousResult: boolean | undefined) => void;
 
 export declare class ConditionalStatementAction extends ValueChangedAction {
     private lastResult;
@@ -98,26 +99,27 @@ export declare namespace DisplayMode {
 export declare const EmptyField: Field<string>;
 
 export declare class EnabledChangedAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => Promise<void>);
+    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => void);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): Promise<void>;
+    execute(field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): void;
 }
 
 export declare class EnabledChangingAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => Promise<boolean>);
+    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => boolean);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): Promise<boolean>;
+    execute(field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): boolean;
 }
 
 export declare class ExecuteAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, params: any) => Promise<any>);
+    constructor(executorFn: (field: IField, supr: FieldActionExecute, params: any) => any);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, params: any): Promise<any>;
+    execute(field: IField, supr: FieldActionExecute, params: any): any;
 }
 
 export declare class Field<T = any> extends FieldBase {
     private _value;
-    protected constructor(params?: Partial<IFieldConstructorParams<T>>);
+    protected constructor();
+    protected init(params?: Partial<IFieldConstructorParams<T>>): void;
     /**
      * Creates a new reactive Field instance.
      * @param params Initial field parameters
@@ -126,7 +128,6 @@ export declare class Field<T = any> extends FieldBase {
     static create<T = any>(params?: Partial<IFieldConstructorParams<T>>): Field<T>;
     get value(): T;
     set value(newValue: T);
-    setValue(newValue: T): Promise<void>;
     clone(overrides?: Partial<IField<T>>): Field<T>;
 }
 
@@ -135,22 +136,23 @@ export declare abstract class FieldActionBase implements IFieldAction {
     get classIdentifier(): symbol;
     private readonly executorFn;
     constructor(executorFn: ActionExecutor);
-    execute(field: IField, supr: IFieldAction['execute'], ...params: any[]): Promise<any>;
+    execute(field: IField, supr: IFieldAction['execute'], ...params: any[]): any;
     get eager(): boolean;
     boundToField(field: IField): void;
     unregister(): void;
 }
 
-export declare type FieldActionExecute<T = any> = (field: IField<T>, ...params: any[]) => Promise<any>;
+export declare type FieldActionExecute<T = any> = (field: IField<T>, ...params: any[]) => any;
 
 export declare abstract class FieldBase<T = any> implements IField<T> {
     abstract get value(): T;
     abstract set value(newValue: T);
-    abstract setValue(newValue: T): Promise<void>;
     readonly reactiveValue: ComputedRef<T>;
     abstract clone(overrides?: Partial<IField<T>>): IField<T>;
     originalValue: T;
-    valid: boolean;
+    protected validatingCount: number;
+    readonly validating = false;
+    protected _valid: boolean;
     errors: ValidationError[];
     parent?: Group;
     fieldName?: string;
@@ -158,12 +160,11 @@ export declare abstract class FieldBase<T = any> implements IField<T> {
     private _visibility;
     get visibility(): DisplayMode;
     set visibility(newValue: DisplayMode);
-    setVisibility(newValue: DisplayMode): Promise<void>;
     private _enabled;
     get enabled(): boolean;
     set enabled(newValue: boolean);
-    setEnabled(newValue: boolean): Promise<void>;
     validate(): void;
+    get valid(): boolean;
     get fullValue(): any;
     get isChanged(): boolean;
     registerAction(action: IFieldAction<T>): this;
@@ -220,6 +221,7 @@ declare namespace Form {
         ValidationError,
         ValidationErrorText,
         ValidationErrorRenderContent,
+        ValidationFunctionResult,
         ValidationFunction,
         Validator
     }
@@ -241,16 +243,16 @@ export declare class Group<T extends GenericFieldsInterface = GenericFieldsInter
     private _value;
     private suppressNotifyValueChanged;
     constructor(fields: T, params?: Partial<IFieldConstructorParams>);
-    addField(fieldName: string, field: IField): void;
+    private addField;
     private static isValidFields;
     static createFromFormData(data: Record<string, any> | null): Group;
     field<K extends keyof T>(fieldName: K): T[K] | null;
     get fields(): T;
     get value(): Record<string, any> | null;
     set value(newValue: Record<string, any> | null);
-    setValue(newValue: Record<string, any> | null): Promise<void>;
     get fullValue(): Record<string, any>;
-    notifyValueChanged(): Promise<void>;
+    notifyValueChanged(): void;
+    get valid(): boolean;
     clone(overrides?: Partial<IField>): Group<T>;
 }
 
@@ -260,15 +262,13 @@ export declare interface IField<T = any> {
     fullValue: T;
     originalValue: T;
     valid: boolean;
+    validating: boolean;
     errors: ValidationError[];
     enabled: boolean;
     visibility: DisplayMode;
     parent?: any;
     fieldName?: string;
     clone(overrides?: Partial<IField<T>>): IField<T>;
-    setVisibility(newValue: DisplayMode): Promise<void>;
-    setEnabled(newValue: boolean): Promise<void>;
-    setValue(newValue: T): Promise<void>;
     registerAction(action: IFieldAction<T>): this;
     triggerAction<T2 extends IFieldAction<T>>(actionClass: abstract new (...args: any[]) => T2, ...params: any[]): any;
     validate(): void;
@@ -311,9 +311,9 @@ export declare class List<T extends GenericFieldsInterface = GenericFieldsInterf
     private setValueInternal;
     get value(): Record<string, any>[] | null;
     set value(newValue: Record<string, any>[]);
-    setValue(newValue: Record<string, any>[]): Promise<void>;
     clone(overrides?: Partial<IField>): List<T>;
     notifyValueChanged(): void;
+    get valid(): boolean;
     get(index: number): Group<T> | undefined;
     push(item: any): number;
     pop(): Group<T> | undefined;
@@ -323,15 +323,15 @@ export declare class List<T extends GenericFieldsInterface = GenericFieldsInterf
 }
 
 export declare class ListItemAddedAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, item: any, index: number) => Promise<void>);
+    constructor(executorFn: (field: IField, supr: FieldActionExecute, item: any, index: number) => void);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, item: any, index: number): Promise<void>;
+    execute(field: IField, supr: FieldActionExecute, item: any, index: number): void;
 }
 
 export declare class ListItemRemovedAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, item: any, index: number) => Promise<void>);
+    constructor(executorFn: (field: IField, supr: FieldActionExecute, item: any, index: number) => void);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, item: any, index: number): Promise<void>;
+    execute(field: IField, supr: FieldActionExecute, item: any, index: number): void;
 }
 
 declare class MaxLength<T = any> extends Validator {
@@ -461,7 +461,9 @@ export declare class ValidationErrorText extends ValidationError {
     get componentBody(): string;
 }
 
-export declare type ValidationFunction<T = any> = (newValue: T, oldValue: T, field: IField<T>) => ValidationError[] | null;
+export declare type ValidationFunction<T = any> = (newValue: T, oldValue: T, field: IField<T>) => ValidationFunctionResult | Promise<ValidationFunctionResult>;
+
+export declare type ValidationFunctionResult = ValidationError[] | null;
 
 /**
  * Validator is a specialized action that performs validation when a field's value changes.
@@ -485,6 +487,9 @@ export declare namespace Validators {
         InAllowedValues,
         Required_2 as Required,
         Pattern,
+        ValidationFunctionResult,
+        ValidationFunction,
+        Validator,
         MinValue,
         MaxValue,
         ValueInRange,
@@ -495,15 +500,15 @@ export declare namespace Validators {
 }
 
 export declare class ValidChangedAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => Promise<void>);
+    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean) => void);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): Promise<void>;
+    execute(field: IField, supr: FieldActionExecute, newValue: boolean, oldValue: boolean): void;
 }
 
 export declare class ValueChangedAction<T = any> extends FieldActionBase {
-    constructor(executorFn: (field: IField<T>, supr: FieldActionExecute<T>, newValue: T, oldValue: T) => Promise<void>);
+    constructor(executorFn: (field: IField<T>, supr: FieldActionExecute<T>, newValue: T, oldValue: T) => void);
     static get classIdentifier(): symbol;
-    execute(field: IField<T>, supr: FieldActionExecute<T>, newValue: T, oldValue: T): Promise<void>;
+    execute(field: IField<T>, supr: FieldActionExecute<T>, newValue: T, oldValue: T): void;
 }
 
 declare class ValueInRange<T = any> extends Validator {
@@ -511,15 +516,15 @@ declare class ValueInRange<T = any> extends Validator {
 }
 
 export declare class VisibilityChangedAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode) => Promise<void>);
+    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode) => void);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode): Promise<void>;
+    execute(field: IField, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode): void;
 }
 
 export declare class VisibilityChangingAction extends FieldActionBase {
-    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode) => Promise<DisplayMode>);
+    constructor(executorFn: (field: IField, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode) => DisplayMode);
     static get classIdentifier(): symbol;
-    execute(field: IField, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode): Promise<DisplayMode>;
+    execute(field: IField, supr: FieldActionExecute, newValue: DisplayMode, oldValue: DisplayMode): DisplayMode;
 }
 
 export { }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dynamicforms/vue-forms",
   "private": false,
-  "version": "0.2.6",
+  "version": "0.3.1",
   "type": "module",
   "description": "Data entry forms for vue - logic (no controls here)",
   "author": "Jure Erznožnik",

package/readme.md

@@ -68,7 +68,7 @@ The library provides a powerful event system for field changes and other actions
 import { Field, Group, ValueChangedAction, ValidationErrorText } from '@dynamicforms/vue-forms';
 
 const emailField = Field.create({ value: '' })
-  .registerAction(new ValueChangedAction(async (field, supr, newValue, oldValue) => {
+  .registerAction(new ValueChangedAction((field, supr, newValue, oldValue) => {
     // Custom validation on value change
     if (!newValue.includes('@')) {
       field.errors = [new ValidationErrorText('Invalid email format')];
@@ -84,7 +84,7 @@ const emailField = Field.create({ value: '' })
 const form = new Group({
   email: emailField,
   username: Field.create()
-}).registerAction(new ValueChangedAction(async (field, supr, newValue, oldValue) => {
+}).registerAction(new ValueChangedAction((field, supr, newValue, oldValue) => {
   console.log('Form data changed:', newValue);
   return supr(field, newValue, oldValue);
 }));