@rolster/react-forms 18.11.4 → 18.12.0

package/dist/cjs/index.js

@@ -7,10 +7,11 @@ var helpers = require('@rolster/forms/helpers');
 var uuid = require('uuid');
 var react = require('react');
 
-class RolsterReactArrayControl {
+class RolsterArrayControl {
     constructor(options) {
-        this.initialValue = options.initialValue;
         this.uuid = options.uuid;
+        this.value = options.value;
+        this.initialValue = options.initialValue;
         this.focused = !!options.focused;
         this.unfocused = !this.focused;
         this.touched = !!options.touched;
@@ -19,36 +20,42 @@ class RolsterReactArrayControl {
         this.pristine = !this.dirty;
         this.disabled = !!options.disabled;
         this.enabled = !this.disabled;
-        const { value, validators } = options;
-        this.value = value;
-        this.validators = validators;
-        this.errors = validators ? helpers.controlIsValid({ value, validators }) : [];
+        this.valid = this.isValid(options.errors);
+        this.invalid = !this.valid;
+        this.wrong = this.touched && this.invalid;
+        this.errors = options.errors;
         this.error = this.errors[0];
+        this.validators = options.validators;
     }
     focus() {
-        this.unfocused && this.refresh({ focused: true });
+        this.unfocused && this.refresh('focused', { focused: true });
     }
     blur() {
-        this.focused && this.refresh({ focused: false, touched: true });
+        this.focused && this.refresh('focused', { focused: false, touched: true });
     }
     disable() {
-        this.enabled && this.refresh({ disabled: true });
+        this.enabled && this.refresh('disabled', { disabled: true });
     }
     enable() {
-        this.disabled && this.refresh({ disabled: false });
+        this.disabled && this.refresh('disabled', { disabled: false });
     }
     touch() {
-        this.untouched && this.refresh({ touched: true });
+        this.untouched && this.refresh('touched', { touched: true });
     }
     setInitialValue(value) {
-        this.initialValue = value;
-        this.setValue(value);
+        const { validators } = this;
+        const errors = validators ? helpers.controlIsValid({ value, validators }) : [];
+        this.refresh('value', { dirty: false, errors, initialValue: value, value });
     }
     setValue(value) {
-        this.refresh({ value });
+        const { validators } = this;
+        const errors = validators ? helpers.controlIsValid({ value, validators }) : [];
+        this.refresh('value', { dirty: true, errors, value });
     }
     setValidators(validators) {
-        this.refresh({ validators });
+        const { value } = this;
+        const errors = validators ? helpers.controlIsValid({ value, validators }) : [];
+        this.refresh('validators', { errors, validators });
     }
     subscribe(subscriber) {
         this.subscriber = subscriber;
@@ -60,37 +67,37 @@ class RolsterReactArrayControl {
         return helpers.someErrors(this.errors, keys);
     }
     reset() {
-        this.refresh({
+        const { initialValue: value, validators } = this;
+        const errors = validators ? helpers.controlIsValid({ value, validators }) : [];
+        this.refresh('reset', {
             dirty: false,
+            errors,
             touched: false,
-            value: this.initialValue
+            value
         });
     }
-    refresh(changes) {
-        this.subscriber &&
-            this.subscriber({
-                ...this,
-                ...changes,
-                initialValue: this.initialValue
-            });
+    isValid(errors) {
+        return errors.length === 0;
+    }
+    builder(options) {
+        return new RolsterArrayControl({ ...this, ...options });
+    }
+    refresh(action, options) {
+        this.subscriber && this.subscriber(action, this.builder(options));
     }
 }
-class RolsterArrayControl extends RolsterReactArrayControl {
+class ReactRolsterArrayControl extends RolsterArrayControl {
     constructor(options) {
-        super(options);
-        this.valid = this.errors.length === 0;
-        this.invalid = !this.valid;
-        this.wrong = this.touched && this.invalid;
-    }
-    clone(options) {
-        return new RolsterArrayControl(options);
+        const { value, validators } = options;
+        const errors = validators ? helpers.controlIsValid({ value, validators }) : [];
+        super({ ...options, errors });
     }
 }
 function rolsterArrayControl(options, validators) {
-    const controlOptions = _arguments.createFormControlOptions(options, validators);
-    return new RolsterArrayControl({
-        ...controlOptions,
-        initialValue: controlOptions.value,
+    const _options = _arguments.createFormControlOptions(options, validators);
+    return new ReactRolsterArrayControl({
+        ..._options,
+        initialValue: _options.value,
         uuid: uuid.v4()
     });
 }
@@ -104,49 +111,112 @@ function inputArrayControl(options, validators) {
     return rolsterArrayControl(options, validators);
 }
 
-class RolsterArrayGroup {
+function replaceControl(controls, control) {
+    return Object.entries(controls).reduce((controls, [key, _control]) => {
+        if (_control.uuid === control.uuid) {
+            controls[key] = control;
+        }
+        return controls;
+    }, controls);
+}
+
+function refactorForValid$2(controls, validators) {
+    const errors = validators ? helpers.groupIsValid({ controls, validators }) : [];
+    return {
+        errors,
+        valid: errors.length === 0 && helpers.controlsAllChecked(controls, 'valid')
+    };
+}
+function refactorForControls$1(group, controls, action) {
+    switch (action) {
+        case 'focused':
+        case 'touched':
+            return {
+                touched: helpers.controlsPartialChecked(controls, 'touched'),
+                toucheds: helpers.controlsAllChecked(controls, 'touched')
+            };
+        case 'validators':
+            return refactorForValid$2(controls, group.validators);
+        case 'reset':
+            return {
+                ...refactorForValid$2(controls, group.validators),
+                dirty: helpers.controlsPartialChecked(controls, 'dirty'),
+                dirties: helpers.controlsAllChecked(controls, 'dirty'),
+                touched: helpers.controlsPartialChecked(controls, 'touched'),
+                toucheds: helpers.controlsAllChecked(controls, 'touched'),
+                value: helpers.controlsToValue(controls)
+            };
+        case 'list':
+        case 'value':
+            return {
+                ...refactorForValid$2(controls, group.validators),
+                dirty: helpers.controlsPartialChecked(controls, 'dirty'),
+                dirties: helpers.controlsAllChecked(controls, 'dirty'),
+                value: helpers.controlsToValue(controls)
+            };
+        default:
+            return {};
+    }
+}
+class BaseArrayGroup {
     constructor(options) {
-        const { controls, resource, uuid, validators } = options;
-        this.uuid = uuid;
-        this.controls = controls;
-        this.validators = validators;
-        this.resource = resource;
-        this.errors = validators ? helpers.groupIsValid({ controls, validators }) : [];
-        this.error = this.errors[0];
-        this.valid =
-            this.errors.length === 0 && helpers.controlsAllChecked(controls, 'valid');
-        this.invalid = !this.valid;
-        this.dirty = helpers.controlsPartialChecked(controls, 'dirty');
-        this.dirties = helpers.controlsAllChecked(controls, 'dirty');
-        this.touched = helpers.controlsPartialChecked(controls, 'touched');
-        this.toucheds = helpers.controlsAllChecked(controls, 'touched');
+        this.uuid = options.uuid;
+        this.controls = options.controls;
+        this.value = options.value;
+        this.resource = options.resource;
+        this.dirty = !!options.dirty;
+        this.dirties = !!options.dirties;
         this.pristine = !this.dirty;
         this.pristines = !this.dirties;
+        this.touched = !!options.touched;
+        this.toucheds = !!options.toucheds;
         this.untouched = !this.touched;
         this.untoucheds = !this.toucheds;
+        this.valid = !!options.valid;
+        this.invalid = !this.valid;
         this.wrong = this.touched && this.invalid;
-        this.value = helpers.controlsToValue(controls);
-        const subscriber = (options) => {
-            this.refresh({
-                controls: Object.entries(this.controls).reduce((controls, [key, control]) => {
-                    controls[key] =
-                        control.uuid === options.uuid ? control.clone(options) : control;
-                    return controls;
-                }, {})
+        this.errors = options.errors;
+        this.error = this.errors[0];
+        this.validators = options.validators;
+        const subscriber = (action, control) => {
+            const controls = replaceControl(this.controls, control);
+            this.refresh(action, {
+                ...refactorForControls$1(this, controls, action),
+                controls
             });
         };
-        Object.values(controls).forEach((control) => {
+        Object.values(this.controls).forEach((control) => {
             control.subscribe(subscriber);
         });
     }
-    setValidators(validators) {
-        this.refresh({ validators });
-    }
     subscribe(subscriber) {
         this.subscriber = subscriber;
     }
-    refresh(changes) {
-        this.subscriber && this.subscriber({ ...this, ...changes });
+    setValidators(validators) {
+        this.refresh('validators', {
+            ...refactorForValid$2(this.controls, validators),
+            validators
+        });
+    }
+    refresh(action, options) {
+        this.subscriber &&
+            this.subscriber(action, new BaseArrayGroup({ ...this, ...options }));
+    }
+}
+class RolsterArrayGroup extends BaseArrayGroup {
+    constructor(options) {
+        const { controls, validators } = options;
+        const errors = validators ? helpers.groupIsValid({ controls, validators }) : [];
+        super({
+            ...options,
+            errors,
+            value: helpers.controlsToValue(controls),
+            dirties: helpers.controlsAllChecked(controls, 'dirty'),
+            dirty: helpers.controlsPartialChecked(controls, 'dirty'),
+            touched: helpers.controlsPartialChecked(controls, 'touched'),
+            toucheds: helpers.controlsAllChecked(controls, 'touched'),
+            valid: errors.length === 0 && helpers.controlsAllChecked(controls, 'valid')
+        });
     }
 }
 function formArrayGroup(options, validators) {
@@ -156,111 +226,102 @@ function formArrayGroup(options, validators) {
     });
 }
 
-class RolsterArrayList extends RolsterReactArrayControl {
+class RolsterArrayList extends RolsterArrayControl {
     constructor(options) {
-        const value = options.controls.map((controls) => helpers.controlsToValue(controls));
-        super({ ...options, value });
-        this.valueToControls = options.valueToControls;
-        this.controls = options.controls;
+        const { controls, valueToControls, validators } = options;
+        const value = controls.map((controls) => helpers.controlsToValue(controls));
+        const errors = validators ? helpers.controlIsValid({ value, validators }) : [];
+        super({ ...options, errors, value });
+        this.valueToControls = valueToControls;
+        this.controls = controls;
         this.valid =
-            this.errors.length === 0 &&
-                this.controls.reduce((valid, controls) => valid && helpers.controlsAllChecked(controls, 'valid'), true);
+            errors.length === 0 &&
+                controls.reduce((valid, controls) => valid && helpers.controlsAllChecked(controls, 'valid'), true);
         this.invalid = !this.valid;
         this.wrong = this.touched && this.invalid;
-        options.controls.forEach((controls) => {
-            this.subscribeControls(controls);
+        controls.forEach((reactControls) => {
+            this._subscribe(reactControls);
         });
     }
     setValue(value) {
-        this.refresh({
+        this.refresh('list', {
             controls: value.map((value) => this.valueToControls(value))
         });
     }
-    clone(options) {
-        return new RolsterArrayList(options);
-    }
     push(controls) {
-        this.refresh({
+        this.refresh('list', {
             controls: [...this.controls, controls]
         });
     }
     remove(controls) {
-        this.refresh({
-            controls: this.controls.filter((currentControls) => currentControls !== controls)
+        this.refresh('list', {
+            controls: this.controls.filter((_controls) => _controls !== controls)
+        });
+    }
+    builder(options) {
+        return new RolsterArrayList({
+            ...this,
+            ...options,
+            valueToControls: this.valueToControls
         });
     }
-    refresh(changes) {
-        super.refresh(changes);
+    refresh(action, options) {
+        super.refresh(action, options);
     }
-    subscribeControls(newControls) {
-        Object.values(newControls).forEach((control) => {
-            control.subscribe((options) => {
-                const controls = this.controls.map((_controls) => _controls !== newControls
+    _subscribe(reactControls) {
+        Object.values(reactControls).forEach((control) => {
+            control.subscribe((action, _control) => {
+                const _reactControls = this.controls.map((_controls) => reactControls !== _controls
                     ? _controls
-                    : Object.entries(newControls).reduce((controls, [key, control]) => {
-                        controls[key] =
-                            control.uuid === options.uuid
-                                ? control.clone(options)
-                                : control;
-                        return controls;
-                    }, {}));
-                this.refresh({ controls });
+                    : replaceControl(reactControls, _control));
+                this.refresh(action, { controls: _reactControls });
             });
         });
     }
 }
-function formArrayList(valueToControls, options) {
+function formArrayList(options) {
     const value = options?.value || [];
     return new RolsterArrayList({
         ...options,
-        valueToControls,
-        controls: value.map((value) => valueToControls(value)),
+        controls: value.map((value) => options.valueToControls(value)),
         initialValue: value,
         uuid: uuid.v4()
     });
 }
 
-var Language;
-(function (Language) {
-    Language["English"] = "en";
-    Language["French"] = "fr";
-    Language["Portuguese"] = "pt";
-    Language["Spanish"] = "es";
-})(Language || (Language = {}));
-
-Language.Spanish;
-let subscribers = [];
-function i18nSubscribe(subscriber) {
-    subscribers.push(subscriber);
-    return () => {
-        subscribers = subscribers.filter((currentSubscriber) => subscriber !== currentSubscriber);
-    };
-}
-
-function errorsInArray(groups, validators) {
-    return validators ? helpers.arrayIsValid({ groups, validators }) : [];
-}
-function validStateInArray(groups, validators) {
-    const errors = errorsInArray(groups, validators);
+function refactorForValid$1(groups, validators) {
+    const errors = validators ? helpers.arrayIsValid({ groups, validators }) : [];
     return {
         errors,
         valid: errors.length === 0 && helpers.groupAllChecked(groups, 'valid')
     };
 }
-function replaceStateInArray(groups, validators) {
+function refactorForGroups(groups, validators) {
     return {
-        ...validStateInArray(groups, validators),
+        ...refactorForValid$1(groups, validators),
         groups,
         controls: groups.map(({ controls }) => controls),
         value: groups.map(({ controls }) => helpers.controlsToValue(controls))
     };
 }
+function refactorForControls(state, groups, action) {
+    switch (action) {
+        case 'validators':
+            return refactorForValid$1(groups, state.validators);
+        case 'reset':
+        case 'list':
+        case 'value':
+            return refactorForGroups(groups, state.validators);
+        default:
+            return { groups };
+    }
+}
 function useFormArray(options, validators) {
     const _options = _arguments.createFormArrayOptions(options, validators);
     const groups = _options.groups || [];
     const initialValue = react.useRef(groups);
     const [state, setState] = react.useState({
-        ...validStateInArray(groups, _options.validators),
+        ...refactorForValid$1(groups, _options.validators),
         controls: groups.map(({ controls }) => controls),
         dirty: false,
         dirties: false,
@@ -272,21 +333,14 @@ function useFormArray(options, validators) {
         validators: _options.validators
     });
     react.useEffect(() => {
-        return i18nSubscribe(() => {
-            setState((state) => ({
-                ...state,
-                errors: errorsInArray(state.groups, state.validators)
-            }));
-        });
-    }, []);
-    react.useEffect(() => {
-        const subscriber = (options) => {
-            setState((state) => ({
-                ...state,
-                ...replaceStateInArray(state.groups.map((group) => group.uuid === options.uuid
-                    ? new RolsterArrayGroup(options)
-                    : group), state.validators)
-            }));
+        const subscriber = (action, group) => {
+            setState((state) => {
+                const groups = state.groups.map((_group) => _group.uuid === group.uuid ? group : _group);
+                return {
+                    ...state,
+                    ...refactorForControls(state, groups, action)
+                };
+            });
         };
         state.groups.forEach((group) => {
             group.subscribe(subscriber);
@@ -301,49 +355,49 @@ function useFormArray(options, validators) {
     const setValue = react.useCallback((groups) => {
         setState((state) => ({
             ...state,
-            ...replaceStateInArray(groups, state.validators)
+            ...refactorForGroups(groups, state.validators)
         }));
     }, []);
     const setInitialValue = react.useCallback((groups) => {
         setState((state) => ({
             ...state,
-            ...replaceStateInArray(groups, state.validators)
+            ...refactorForGroups(groups, state.validators)
         }));
         initialValue.current = groups;
     }, []);
     const push = react.useCallback((group) => {
         setState((state) => ({
             ...state,
-            ...replaceStateInArray([...state.groups, group], state.validators)
+            ...refactorForGroups([...state.groups, group], state.validators)
         }));
     }, []);
     const merge = react.useCallback((groups) => {
         setState((state) => ({
             ...state,
-            ...replaceStateInArray([...state.groups, ...groups], state.validators)
+            ...refactorForGroups([...state.groups, ...groups], state.validators)
         }));
     }, []);
     const remove = react.useCallback(({ uuid }) => {
         setState((state) => ({
             ...state,
-            ...replaceStateInArray(state.groups.filter((group) => group.uuid !== uuid), state.validators)
-        }));
-    }, []);
-    const reset = react.useCallback(() => {
-        setState((state) => ({
-            ...state,
-            ...replaceStateInArray(initialValue.current, state.validators)
+            ...refactorForGroups(state.groups.filter((group) => group.uuid !== uuid), state.validators)
         }));
     }, []);
     const setValidators = react.useCallback((validators) => {
         setState((state) => ({
             ...state,
-            ...validStateInArray(state.groups, validators),
+            ...refactorForValid$1(state.groups, validators),
             validators
         }));
     }, []);
     const hasError = react.useCallback((key) => helpers.hasError(state.errors, key), [state.errors]);
     const someErrors = react.useCallback((keys) => helpers.someErrors(state.errors, keys), [state.errors]);
+    const reset = react.useCallback(() => {
+        setState((state) => ({
+            ...state,
+            ...refactorForGroups(initialValue.current, state.validators)
+        }));
+    }, []);
     return {
         ...state,
         disable,
@@ -384,14 +438,6 @@ function useControl(options, validators) {
         validators: _options.validators
     });
     const elementRef = react.useRef(null);
-    react.useEffect(() => {
-        return i18nSubscribe(() => {
-            setState((state) => ({
-                ...state,
-                errors: errorsInControl(state.value, state.validators)
-            }));
-        });
-    }, []);
     const focus = react.useCallback(() => {
         setState((state) => ({ ...state, focused: true }));
     }, []);
@@ -477,11 +523,8 @@ function useInputControl(options, validators) {
     return useControl(options, validators);
 }
 
-function errorsInGroup(controls, validators) {
-    return validators ? helpers.groupIsValid({ controls, validators }) : [];
-}
-function validStateInGroup(controls, validators) {
-    const errors = errorsInGroup(controls, validators);
+function refactorForValid(controls, validators) {
+    const errors = validators ? helpers.groupIsValid({ controls, validators }) : [];
     return {
         errors,
         valid: errors.length === 0 && helpers.controlsAllChecked(controls, 'valid')
@@ -490,8 +533,14 @@ function validStateInGroup(controls, validators) {
 function useFormGroup(options, validators) {
     const _options = _arguments.createFormGroupOptions(options, validators);
     const { controls } = _options;
+    const firstEffects = react.useRef({
+        dirty: true,
+        disabledFocused: true,
+        touched: true,
+        value: true
+    });
     const [state, setState] = react.useState({
-        ...validStateInGroup(controls, _options.validators),
+        ...refactorForValid(controls, _options.validators),
         controls,
         dirties: helpers.controlsAllChecked(controls, 'dirty'),
         dirty: helpers.controlsPartialChecked(controls, 'dirty'),
@@ -501,50 +550,62 @@ function useFormGroup(options, validators) {
         validators: _options.validators
     });
     react.useEffect(() => {
-        return i18nSubscribe(() => {
+        if (!firstEffects.current.value) {
             setState((state) => ({
                 ...state,
-                errors: errorsInGroup(state.controls, state.validators)
+                ...refactorForValid(controls, state.validators),
+                controls,
+                value: helpers.controlsToValue(controls)
             }));
-        });
-    }, []);
-    react.useEffect(() => {
-        setState((state) => ({
-            ...state,
-            ...validStateInGroup(controls, state.validators),
-            controls,
-            value: helpers.controlsToValue(controls)
-        }));
+        }
+        else {
+            firstEffects.current.value = false;
+        }
     }, helpers.reduceControlsToArray(controls, 'value'));
     react.useEffect(() => {
-        setState((state) => ({
-            ...state,
-            controls
-        }));
+        if (!firstEffects.current.disabledFocused) {
+            setState((state) => ({
+                ...state,
+                controls
+            }));
+        }
+        else {
+            firstEffects.current.disabledFocused = false;
+        }
     }, [
         ...helpers.reduceControlsToArray(controls, 'disabled'),
         ...helpers.reduceControlsToArray(controls, 'focused')
     ]);
     react.useEffect(() => {
-        setState((state) => ({
-            ...state,
-            controls,
-            dirty: helpers.controlsPartialChecked(controls, 'dirty'),
-            dirties: helpers.controlsAllChecked(controls, 'dirty')
-        }));
+        if (!firstEffects.current.dirty) {
+            setState((state) => ({
+                ...state,
+                controls,
+                dirty: helpers.controlsPartialChecked(controls, 'dirty'),
+                dirties: helpers.controlsAllChecked(controls, 'dirty')
+            }));
+        }
+        else {
+            firstEffects.current.dirty = false;
+        }
     }, helpers.reduceControlsToArray(controls, 'dirty'));
     react.useEffect(() => {
-        setState((state) => ({
-            ...state,
-            controls,
-            touched: helpers.controlsPartialChecked(controls, 'touched'),
-            toucheds: helpers.controlsAllChecked(controls, 'touched')
-        }));
+        if (!firstEffects.current.touched) {
+            setState((state) => ({
+                ...state,
+                controls,
+                touched: helpers.controlsPartialChecked(controls, 'touched'),
+                toucheds: helpers.controlsAllChecked(controls, 'touched')
+            }));
+        }
+        else {
+            firstEffects.current.touched = false;
+        }
     }, helpers.reduceControlsToArray(controls, 'touched'));
     const setValidators = react.useCallback((validators) => {
         setState((state) => ({
             ...state,
-            ...validStateInGroup(state.controls, validators)
+            ...refactorForValid(state.controls, validators)
         }));
     }, []);
     const reset = react.useCallback(() => {