@rolster/react-forms 19.3.0 → 19.4.1

package/dist/es/index.js

@@ -1,737 +0,0 @@
-import { createFormControlOptions, formControlIsValid, hasError, someErrors, createFormGroupOptions, formGroupIsValid, controlsToValue, verifyAllTrueInControls, verifyAnyTrueInControls, createFormArrayOptions, formArrayIsValid, verifyAllTrueInGroups, reduceControlsToArray } from '@rolster/forms/helpers';
-import { v4 } from 'uuid';
-import { useRef, useState, useEffect, useCallback, useMemo } from 'react';
-
-class RolsterArrayControl {
-    constructor(options) {
-        this.uuid = options.uuid;
-        this.defaultValue = options.defaultValue;
-        this.value = options.value;
-        this.focused = !!options.focused;
-        this.unfocused = !this.focused;
-        this.touched = !!options.touched;
-        this.untouched = !this.touched;
-        this.dirty = !!options.dirty;
-        this.pristine = !this.dirty;
-        this.disabled = !!options.disabled;
-        this.enabled = !this.disabled;
-        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', { focused: true });
-    }
-    blur() {
-        this.focused && this.refresh('focused', { focused: false, touched: true });
-    }
-    disable() {
-        this.enabled && this.refresh('disabled', { disabled: true });
-    }
-    enable() {
-        this.disabled && this.refresh('disabled', { disabled: false });
-    }
-    touch() {
-        this.untouched && this.refresh('touched', { touched: true });
-    }
-    setDefaultValue(value) {
-        if (value !== this.defaultValue) {
-            const errors = this.validators
-                ? formControlIsValid({ value, validators: this.validators })
-                : [];
-            this.refresh('value', { errors, defaultValue: value, value });
-        }
-    }
-    setStartValue(value) {
-        if (value !== this.value) {
-            const errors = this.validators
-                ? formControlIsValid({ value, validators: this.validators })
-                : [];
-            this.refresh('value', { errors, value });
-        }
-    }
-    setValue(value) {
-        if (value !== this.value) {
-            const errors = this.validators
-                ? formControlIsValid({ value, validators: this.validators })
-                : [];
-            this.refresh('value', { dirty: true, errors, value });
-        }
-    }
-    setValidators(validators) {
-        const errors = validators
-            ? formControlIsValid({ value: this.value, validators })
-            : [];
-        this.refresh('validators', { errors, validators });
-    }
-    subscribe(subscriber) {
-        this.subscriber = subscriber;
-    }
-    hasError(key) {
-        return hasError(this.errors, key);
-    }
-    someErrors(keys) {
-        return someErrors(this.errors, keys);
-    }
-    reset() {
-        const errors = this.validators
-            ? formControlIsValid({
-                value: this.defaultValue,
-                validators: this.validators
-            })
-            : [];
-        this.refresh('reset', {
-            dirty: false,
-            errors,
-            touched: false,
-            value: this.defaultValue
-        });
-    }
-    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 ReactRolsterArrayControl extends RolsterArrayControl {
-    constructor(options) {
-        const { value, validators } = options;
-        const errors = validators ? formControlIsValid({ value, validators }) : [];
-        super({ ...options, errors });
-    }
-}
-function rolsterArrayControl(options, validators) {
-    const formControl = createFormControlOptions(options, validators);
-    return new ReactRolsterArrayControl({
-        ...formControl,
-        defaultValue: formControl.value,
-        uuid: v4()
-    });
-}
-function reactArrayControl(options, validators) {
-    return rolsterArrayControl(options, validators);
-}
-function formArrayControl(options, validators) {
-    return rolsterArrayControl(options, validators);
-}
-function inputArrayControl(options, validators) {
-    return rolsterArrayControl(options, validators);
-}
-
-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 ? formGroupIsValid({ controls, validators }) : [];
-    return {
-        errors,
-        valid: errors.length === 0 && verifyAllTrueInControls(controls, 'valid')
-    };
-}
-function refactorForControls$1(action, group, controls) {
-    switch (action) {
-        case 'focused':
-        case 'touched':
-            return {
-                touched: verifyAnyTrueInControls(controls, 'touched'),
-                toucheds: verifyAllTrueInControls(controls, 'touched')
-            };
-        case 'validators':
-            return refactorForValid$2(controls, group.validators);
-        case 'reset':
-            return {
-                ...refactorForValid$2(controls, group.validators),
-                dirty: verifyAnyTrueInControls(controls, 'dirty'),
-                dirties: verifyAllTrueInControls(controls, 'dirty'),
-                touched: verifyAnyTrueInControls(controls, 'touched'),
-                toucheds: verifyAllTrueInControls(controls, 'touched'),
-                value: controlsToValue(controls)
-            };
-        case 'list':
-        case 'value':
-            return {
-                ...refactorForValid$2(controls, group.validators),
-                dirty: verifyAnyTrueInControls(controls, 'dirty'),
-                dirties: verifyAllTrueInControls(controls, 'dirty'),
-                value: controlsToValue(controls)
-            };
-        default:
-            return {};
-    }
-}
-class RolsterArrayGroup {
-    constructor(options) {
-        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.errors = options.errors;
-        this.error = this.errors[0];
-        this.validators = options.validators;
-        this.subscriberControl = (action, control) => {
-            const controls = replaceControl(this.controls, control);
-            this.refresh(action, {
-                ...refactorForControls$1(action, this, controls),
-                controls
-            });
-        };
-    }
-    subscribe(subscriber) {
-        this.subscriber = subscriber;
-        Object.values(this.controls).forEach((control) => {
-            control.subscribe(this.subscriberControl);
-        });
-    }
-    setValidators(validators) {
-        this.refresh('validators', {
-            ...refactorForValid$2(this.controls, validators),
-            validators
-        });
-    }
-    setResource(resource) {
-        this.refresh('resource', { resource });
-    }
-    refresh(action, options) {
-        this.subscriber &&
-            this.subscriber(action, new RolsterArrayGroup({ ...this, ...options }));
-    }
-}
-class ReactRolsterArrayGroup extends RolsterArrayGroup {
-    constructor(options) {
-        const { controls, validators } = options;
-        const errors = validators ? formGroupIsValid({ controls, validators }) : [];
-        super({
-            ...options,
-            errors,
-            dirties: verifyAllTrueInControls(controls, 'dirty'),
-            dirty: verifyAnyTrueInControls(controls, 'dirty'),
-            touched: verifyAnyTrueInControls(controls, 'touched'),
-            toucheds: verifyAllTrueInControls(controls, 'touched'),
-            valid: errors.length === 0 && verifyAllTrueInControls(controls, 'valid'),
-            value: controlsToValue(controls)
-        });
-    }
-}
-function valueIsGroupOptions(options) {
-    return typeof options === 'object' && 'controls' in options;
-}
-function formArrayGroup(options, validators) {
-    const _uuid = valueIsGroupOptions(options) ? options.uuid || v4() : v4();
-    return new ReactRolsterArrayGroup({
-        ...createFormGroupOptions(options, validators),
-        uuid: _uuid
-    });
-}
-
-class RolsterArrayList extends RolsterArrayControl {
-    constructor(options) {
-        const { controls, valueToControls, validators } = options;
-        const value = controls.map(controlsToValue);
-        const errors = validators ? formControlIsValid({ value, validators }) : [];
-        super({ ...options, errors, value });
-        this.valueToControls = valueToControls;
-        this.controls = controls;
-        this.valid =
-            errors.length === 0 &&
-                controls.reduce((valid, controls) => valid && verifyAllTrueInControls(controls, 'valid'), true);
-        this.invalid = !this.valid;
-        this.wrong = this.touched && this.invalid;
-        controls.forEach((reactControls) => {
-            this._subscribe(reactControls);
-        });
-    }
-    setDefaultValue(value) {
-        this.refresh('list', {
-            controls: value.map(this.valueToControls),
-            defaultValue: value
-        });
-    }
-    setStartValue(value) {
-        this.refresh('list', {
-            controls: value.map(this.valueToControls)
-        });
-    }
-    setValue(value) {
-        this.refresh('list', {
-            controls: value.map(this.valueToControls),
-            dirty: true
-        });
-    }
-    reset() {
-        this.refresh('list', {
-            controls: this.defaultValue.map(this.valueToControls),
-            dirty: false,
-            touched: false
-        });
-    }
-    push(controls) {
-        this.refresh('list', {
-            controls: [...this.controls, controls]
-        });
-    }
-    remove(controls) {
-        this.refresh('list', {
-            controls: this.controls.filter((_controls) => _controls !== controls)
-        });
-    }
-    builder(options) {
-        return new RolsterArrayList({
-            ...this,
-            ...options,
-            valueToControls: this.valueToControls
-        });
-    }
-    refresh(action, options) {
-        super.refresh(action, options);
-    }
-    _subscribe(reactControls) {
-        Object.values(reactControls).forEach((control) => {
-            control.subscribe((action, _control) => {
-                const _reactControls = this.controls.map((_controls) => reactControls !== _controls
-                    ? _controls
-                    : replaceControl(reactControls, _control));
-                this.refresh(action, { controls: _reactControls });
-            });
-        });
-    }
-}
-function formArrayList(options) {
-    const value = options?.value || [];
-    return new RolsterArrayList({
-        ...options,
-        controls: value.map((value) => options.valueToControls(value)),
-        defaultValue: value,
-        uuid: v4()
-    });
-}
-
-function refactorForValid$1(groups, validators) {
-    const errors = validators ? formArrayIsValid({ groups, validators }) : [];
-    return {
-        errors,
-        valid: errors.length === 0 && verifyAllTrueInGroups(groups, 'valid')
-    };
-}
-function refactorForGroups(groups, validators) {
-    return {
-        ...refactorForValid$1(groups, validators),
-        groups,
-        controls: groups.map(({ controls }) => controls),
-        value: groups.map(({ controls }) => controlsToValue(controls))
-    };
-}
-function refactorForControls(action, state, groups) {
-    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 formArray = createFormArrayOptions(options, validators);
-    const defaultValue = useRef(formArray.groups || []);
-    const formGroups = useRef(new Map());
-    const [state, setState] = useState(() => {
-        return {
-            ...refactorForValid$1(defaultValue.current, formArray.validators),
-            controls: defaultValue.current.map(({ controls }) => controls),
-            dirty: false,
-            dirties: false,
-            disabled: false,
-            groups: defaultValue.current,
-            touched: false,
-            toucheds: false,
-            value: defaultValue.current.map(({ controls }) => controlsToValue(controls)),
-            validators: formArray.validators
-        };
-    });
-    useEffect(() => {
-        formGroups.current.clear();
-        state.groups.forEach((group) => {
-            formGroups.current.set(group.uuid, group);
-            group.subscribe(subscriber);
-        });
-    }, [state.groups]);
-    const subscriber = useCallback((action, group) => {
-        setState((state) => {
-            const groups = state.groups.map((currentGroup) => {
-                return currentGroup.uuid === group.uuid ? group : currentGroup;
-            });
-            return {
-                ...state,
-                ...refactorForControls(action, state, groups)
-            };
-        });
-    }, []);
-    const disable = useCallback(() => {
-        setState((state) => ({ ...state, disabled: true }));
-    }, []);
-    const enable = useCallback(() => {
-        setState((state) => ({ ...state, disabled: false }));
-    }, []);
-    const setValue = useCallback((groups) => {
-        setState((state) => ({
-            ...state,
-            ...refactorForGroups(groups, state.validators)
-        }));
-    }, []);
-    const setDefaultValue = useCallback((groups) => {
-        setState((state) => ({
-            ...state,
-            ...refactorForGroups(groups, state.validators)
-        }));
-        defaultValue.current = groups;
-    }, []);
-    const push = useCallback((group) => {
-        setState((state) => ({
-            ...state,
-            ...refactorForGroups([...state.groups, group], state.validators)
-        }));
-    }, []);
-    const merge = useCallback((groups) => {
-        setState((state) => ({
-            ...state,
-            ...refactorForGroups([...state.groups, ...groups], state.validators)
-        }));
-    }, []);
-    const remove = useCallback(({ uuid }) => {
-        setState((state) => ({
-            ...state,
-            ...refactorForGroups(state.groups.filter((group) => group.uuid !== uuid), state.validators)
-        }));
-    }, []);
-    const findByUuid = useCallback((uuid) => {
-        return formGroups.current.get(uuid);
-    }, [state.groups]);
-    const setValidators = useCallback((validators) => {
-        setState((state) => ({
-            ...state,
-            ...refactorForValid$1(state.groups, validators),
-            validators
-        }));
-    }, []);
-    const hasError$1 = useCallback((key) => {
-        return hasError(state.errors, key);
-    }, [state.errors]);
-    const someErrors$1 = useCallback((keys) => {
-        return someErrors(state.errors, keys);
-    }, [state.errors]);
-    const reset = useCallback(() => {
-        setState((state) => ({
-            ...state,
-            ...refactorForGroups(defaultValue.current, state.validators)
-        }));
-    }, []);
-    return {
-        ...state,
-        disable,
-        enable,
-        enabled: !state.disabled,
-        error: state.errors[0],
-        findByUuid,
-        hasError: hasError$1,
-        invalid: !state.valid,
-        merge,
-        pristine: !state.dirty,
-        pristines: !state.dirties,
-        push,
-        remove,
-        reset,
-        setDefaultValue,
-        setValidators,
-        setValue,
-        someErrors: someErrors$1,
-        untouched: !state.touched,
-        untoucheds: !state.toucheds,
-        wrong: state.touched && !state.valid
-    };
-}
-
-function errorsInControl(value, validators) {
-    return validators ? formControlIsValid({ value, validators }) : [];
-}
-function useControl(options, validators) {
-    const formControl = createFormControlOptions(options, validators);
-    const defaultValue = useRef(formControl.value);
-    const [state, setState] = useState(() => {
-        return {
-            dirty: false,
-            disabled: false,
-            errors: errorsInControl(formControl.value, formControl.validators),
-            focused: false,
-            touched: !!formControl.touched,
-            value: formControl.value,
-            validators: formControl.validators
-        };
-    });
-    const elementRef = useRef(null);
-    const focus = useCallback(() => {
-        setState((state) => ({ ...state, focused: true }));
-    }, []);
-    const blur = useCallback(() => {
-        setState((state) => ({ ...state, focused: false, touched: true }));
-    }, []);
-    const disable = useCallback(() => {
-        setState((state) => ({ ...state, disabled: true }));
-    }, []);
-    const enable = useCallback(() => {
-        setState((state) => ({ ...state, disabled: false }));
-    }, []);
-    const touch = useCallback(() => {
-        setState((state) => ({ ...state, touched: true }));
-    }, []);
-    const setDefaultValue = useCallback((value) => {
-        defaultValue.current = value;
-        setState((state) => ({
-            ...state,
-            errors: errorsInControl(value, state.validators),
-            value
-        }));
-    }, []);
-    const setStartValue = useCallback((value) => {
-        setState((state) => ({
-            ...state,
-            errors: errorsInControl(value, state.validators),
-            value
-        }));
-    }, []);
-    const setValue = useCallback((value) => {
-        setState((state) => ({
-            ...state,
-            dirty: true,
-            errors: errorsInControl(value, state.validators),
-            value
-        }));
-    }, []);
-    const setValidators = useCallback((validators) => {
-        setState((state) => ({
-            ...state,
-            errors: errorsInControl(state.value, validators),
-            validators
-        }));
-    }, []);
-    const reset = useCallback(() => {
-        setState((state) => ({
-            ...state,
-            dirty: false,
-            errors: errorsInControl(defaultValue.current, state.validators),
-            value: defaultValue.current,
-            touched: false
-        }));
-    }, []);
-    const hasError$1 = useCallback((key) => {
-        return hasError(state.errors, key);
-    }, [state.errors]);
-    const someErrors$1 = useCallback((keys) => {
-        return someErrors(state.errors, keys);
-    }, [state.errors]);
-    const valid = state.errors.length === 0;
-    return {
-        ...state,
-        blur,
-        disable,
-        elementRef,
-        enable,
-        enabled: !state.disabled,
-        error: state.errors[0],
-        focus,
-        hasError: hasError$1,
-        invalid: !valid,
-        pristine: !state.dirty,
-        reset,
-        setDefaultValue,
-        setStartValue,
-        setValidators,
-        setValue,
-        someErrors: someErrors$1,
-        touch,
-        unfocused: !state.focused,
-        untouched: !state.touched,
-        valid,
-        wrong: state.touched && !valid
-    };
-}
-function useReactControl(options, validators) {
-    return useControl(options, validators);
-}
-function useFormControl(options, validators) {
-    return useControl(options, validators);
-}
-function useInputControl(options, validators) {
-    return useControl(options, validators);
-}
-
-function refactorForValid(controls, validators) {
-    const errors = validators ? formGroupIsValid({ controls, validators }) : [];
-    return {
-        errors,
-        valid: errors.length === 0 && verifyAllTrueInControls(controls, 'valid')
-    };
-}
-function checkAllSuccess(status) {
-    return status.reduce((success, status) => success && status, true);
-}
-function checkPartialSuccess(status) {
-    return status.reduce((success, status) => success || status, false);
-}
-function useFormGroup(options, validators) {
-    const formGroup = createFormGroupOptions(options, validators);
-    const formInitialized = useRef({
-        dirty: false,
-        touched: false,
-        value: false,
-        visual: false
-    });
-    const formGroupStatus = useMemo(() => {
-        const dirty = [];
-        const touched = [];
-        const value = [];
-        const visual = [];
-        Object.values(formGroup.controls).forEach((control) => {
-            dirty.push(control.dirty);
-            touched.push(control.touched);
-            value.push(control.value);
-            visual.push(control.disabled);
-            visual.push(control.focused);
-        });
-        return {
-            dirty,
-            touched,
-            value,
-            visual
-        };
-    }, [formGroup.controls]);
-    const [state, setState] = useState(() => {
-        return {
-            ...refactorForValid(formGroup.controls, formGroup.validators),
-            controls: formGroup.controls,
-            dirties: checkAllSuccess(formGroupStatus.dirty),
-            dirty: checkPartialSuccess(formGroupStatus.dirty),
-            touched: checkPartialSuccess(formGroupStatus.touched),
-            toucheds: checkAllSuccess(formGroupStatus.touched),
-            validators: formGroup.validators,
-            value: controlsToValue(formGroup.controls)
-        };
-    });
-    useEffect(() => {
-        if (formInitialized.current.value) {
-            setState((state) => ({
-                ...state,
-                ...refactorForValid(formGroup.controls, state.validators),
-                controls: formGroup.controls,
-                value: controlsToValue(formGroup.controls)
-            }));
-        }
-        else {
-            formInitialized.current.value = true;
-        }
-    }, formGroupStatus.value);
-    useEffect(() => {
-        if (formInitialized.current.dirty) {
-            setState((state) => ({
-                ...state,
-                controls: formGroup.controls,
-                dirty: checkPartialSuccess(formGroupStatus.dirty),
-                dirties: checkAllSuccess(formGroupStatus.dirty)
-            }));
-        }
-        else {
-            formInitialized.current.dirty = true;
-        }
-    }, formGroupStatus.dirty);
-    useEffect(() => {
-        if (formInitialized.current.touched) {
-            setState((state) => ({
-                ...state,
-                controls: formGroup.controls,
-                touched: checkPartialSuccess(formGroupStatus.touched),
-                toucheds: checkAllSuccess(formGroupStatus.touched)
-            }));
-        }
-        else {
-            formInitialized.current.touched = true;
-        }
-    }, formGroupStatus.touched);
-    useEffect(() => {
-        if (formInitialized.current.visual) {
-            setState((state) => ({
-                ...state,
-                controls: formGroup.controls
-            }));
-        }
-        else {
-            formInitialized.current.visual = true;
-        }
-    }, formGroupStatus.visual);
-    const setValidators = useCallback((validators) => {
-        setState((state) => ({
-            ...state,
-            ...refactorForValid(state.controls, validators)
-        }));
-    }, []);
-    const reset = useCallback(() => {
-        Object.values(formGroup.controls).forEach((control) => {
-            control.reset();
-        });
-    }, []);
-    return {
-        ...state,
-        error: state.errors[0],
-        invalid: !state.valid,
-        pristine: !state.dirty,
-        pristines: !state.dirties,
-        reset,
-        setValidators,
-        untouched: !state.touched,
-        untoucheds: !state.toucheds,
-        wrong: state.touched && !state.valid
-    };
-}
-
-function reduceControlsToValues(controls) {
-    return reduceControlsToArray(controls, 'value');
-}
-function reduceGroupToValues(group) {
-    return reduceControlsToValues(group.controls);
-}
-
-function useFormArrayGroupSelect({ formArray }) {
-    const [formSelect, setFormGroup] = useState();
-    const formGroup = useMemo(() => {
-        return (formSelect &&
-            formArray.groups.find(({ uuid }) => formSelect.uuid === uuid));
-    }, [formArray.value, formSelect]);
-    return { formGroup, setFormGroup };
-}
-
-export { formArrayControl, formArrayGroup, formArrayList, inputArrayControl, reactArrayControl, reduceControlsToValues, reduceGroupToValues, useFormArray, useFormArrayGroupSelect, useFormControl, useFormGroup, useInputControl, useReactControl };
-//# sourceMappingURL=index.js.map