@rolster/forms 2.4.1 → 2.5.0

package/dist/esm/helpers.js

@@ -1,7 +1,7 @@
 import { parseBoolean } from '@rolster/commons';
-export const controlIsValid = ({ state, validators }) => {
+export const controlIsValid = ({ value, validators }) => {
     return validators.reduce((errors, validator) => {
-        const error = validator(state);
+        const error = validator(value);
         if (error) {
             errors.push(error);
         }
@@ -15,8 +15,8 @@ export const controlsPartialChecked = (controls, key) => {
     return Object.values(controls).reduce((value, control) => control.disabled ? value : value || parseBoolean(control[key]), false);
 };
 export const controlsToState = (controls) => {
-    return Object.entries(controls).reduce((result, [key, { state }]) => {
-        result[key] = state;
+    return Object.entries(controls).reduce((result, [key, { value }]) => {
+        result[key] = value;
         return result;
     }, {});
 };

package/dist/esm/types.d.ts

@@ -3,7 +3,7 @@ export type ValidationFormType = 'control' | 'group' | 'array';
 export interface ValidationFormError<T = any> extends ValidatorError<T> {
     type: ValidationFormType;
 }
-export type SubscriberControl<T> = (state: T) => void;
+export type SubscriberControl<T> = (value: T) => void;
 export interface AbstractControl<T = any> {
     readonly dirty: boolean;
     readonly disabled: boolean;
@@ -17,7 +17,7 @@ export interface AbstractControl<T = any> {
     readonly valid: boolean;
     readonly wrong: boolean;
     readonly error?: ValidatorError;
-    readonly state?: T;
+    readonly value?: T;
 }
 export interface AbstractFormControl<T = any> extends AbstractControl<T> {
     blur: () => void;
@@ -25,16 +25,17 @@ export interface AbstractFormControl<T = any> extends AbstractControl<T> {
     enable: () => void;
     focus: () => void;
     readonly focused: boolean;
-    setState: (state: T) => void;
+    setValue: (value: T) => void;
     setValidators: (validators?: ValidatorFn<T>[]) => void;
+    touch: () => void;
     readonly unfocused: boolean;
 }
 export interface AbstractReactiveControl<T = any> extends AbstractFormControl<T> {
     subscribe: (subscriber: SubscriberControl<T>) => Unsubscription;
 }
 export type AbstractControls<T extends AbstractControl = AbstractControl> = Record<string, T>;
-export interface AbstractGroup<T extends AbstractControls = AbstractControls> {
-    readonly controls: T;
+export interface AbstractGroup<C extends AbstractControls = AbstractControls> {
+    readonly controls: C;
     readonly dirty: boolean;
     readonly dirtyAll: boolean;
     readonly errors: ValidatorError[];
@@ -49,15 +50,15 @@ export interface AbstractGroup<T extends AbstractControls = AbstractControls> {
     readonly wrong: boolean;
     readonly error?: ValidatorError;
 }
-export type StateGroup<C extends AbstractControls = AbstractControls> = {
-    [K in keyof C]: C[K]['state'];
+export type ValueGroup<C extends AbstractControls = AbstractControls> = {
+    [K in keyof C]: C[K]['value'];
 };
 export type ValidatorGroupFn<C extends AbstractControls = AbstractControls, V = any> = (controls: C) => ValidatorResult<V>;
-export type SubscriberGroup<C extends AbstractControls = AbstractControls> = (state: StateGroup<C>) => void;
+export type SubscriberGroup<C extends AbstractControls = AbstractControls> = (value: ValueGroup<C>) => void;
 export interface AbstractFormGroup<C extends AbstractControls = AbstractControls> extends AbstractGroup<C> {
     reset: () => void;
     setValidators: (validators: ValidatorGroupFn<C>[]) => void;
-    readonly state: StateGroup<C>;
+    readonly value: ValueGroup<C>;
 }
 export interface AbstractReactiveGroup<C extends AbstractControls = AbstractControls> extends AbstractFormGroup<C> {
     subscribe: (subscriber: SubscriberGroup<C>) => Unsubscription;
@@ -71,7 +72,7 @@ export interface AbstractReactiveArrayControl<T = any> extends AbstractArrayCont
 export type AbstractArrayControls<T extends AbstractArrayControl = AbstractArrayControl> = AbstractControls<T>;
 export interface AbstractArrayGroup<C extends AbstractArrayControls, R = any> extends AbstractGroup<C> {
     setValidators: (validators: ValidatorGroupFn<C>[]) => void;
-    readonly state: ArrayStateGroup<C>;
+    readonly value: ArrayStateGroup<C>;
     readonly uuid: string;
     resource?: R;
 }
@@ -79,7 +80,7 @@ export interface AbstractReactiveArrayGroup<C extends AbstractArrayControls, R =
     subscribe: (subscriber: SubscriberGroup<C>) => Unsubscription;
 }
 export type ArrayStateGroup<C extends AbstractArrayControls> = {
-    [K in keyof C]: C[K]['state'];
+    [K in keyof C]: C[K]['value'];
 };
 export type ValidatorArrayFn<T extends AbstractArrayControls = AbstractArrayControls, R = any, G extends AbstractArrayGroup<T, R> = AbstractArrayGroup<T, R>, V = any> = (groups: G[]) => ValidatorResult<V>;
 export type ArrayFormControls<T extends AbstractArrayControl = AbstractArrayControl> = AbstractArrayControls<T>;
@@ -104,11 +105,11 @@ export interface AbstractReactiveArray<C extends AbstractArrayControls = Abstrac
     subscribe: (subscriber: SubscriberArray<C>) => Unsubscription;
 }
 export interface FormControlOptions<T = any> {
-    state: T;
+    value: T;
     validators?: ValidatorFn<T>[];
 }
 export type FormStateOptions<T> = Omit<FormControlOptions<T>, 'validators'>;
-export type FormValidatorsOptions<T> = Omit<FormControlOptions<T>, 'state'>;
+export type FormValidatorsOptions<T> = Omit<FormControlOptions<T>, 'value'>;
 export interface FormGroupOptions<C extends AbstractControls = AbstractControls> {
     controls: C;
     validators?: ValidatorGroupFn<C>[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rolster/forms",
-  "version": "2.4.1",
+  "version": "2.5.0",
   "description": "It implements a set of classes that allow managing the control of states of the input components of the UI.",
   "module": "dist/esm/index.js",
   "main": "dist/cjs/index.js",