@rolster/forms 2.7.2 → 2.8.0

package/dist/cjs/index.js

@@ -5,530 +5,530 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var uuid = require('uuid');
 var commons = require('@rolster/commons');
 
-function itIsControlOptions(options) {
-    return (typeof options === 'object' &&
-        ('value' in options || 'validators' in options));
-}
-function itIsGroupOptions(options) {
-    return typeof options === 'object' && 'controls' in options;
-}
-function itIsArrayOptions(options) {
-    return (typeof options === 'object' &&
-        ('groups' in options || 'validators' in options));
-}
-function createFormControlOptions(...controlOptions) {
-    const [options, validators] = controlOptions;
-    if (!options) {
-        return { value: options, validators };
-    }
-    if (!validators && itIsControlOptions(options)) {
-        return options;
-    }
-    return {
-        value: options,
-        validators
-    };
-}
-function createFormGroupOptions(...groupOptions) {
-    const [options, validators] = groupOptions;
-    if (!validators && itIsGroupOptions(options)) {
-        return options;
-    }
-    return {
-        controls: options,
-        validators
-    };
-}
-function createFormArrayOptions(...arrayOptions) {
-    const [options, validators] = arrayOptions;
-    if (!options) {
-        return { groups: options, validators };
-    }
-    if (!validators && itIsArrayOptions(options)) {
-        return options;
-    }
-    return {
-        groups: options,
-        validators
-    };
+function itIsControlOptions(options) {
+    return (typeof options === 'object' &&
+        ('value' in options || 'validators' in options));
+}
+function itIsGroupOptions(options) {
+    return typeof options === 'object' && 'controls' in options;
+}
+function itIsArrayOptions(options) {
+    return (typeof options === 'object' &&
+        ('groups' in options || 'validators' in options));
+}
+function createFormControlOptions(...controlOptions) {
+    const [options, validators] = controlOptions;
+    if (!options) {
+        return { value: options, validators };
+    }
+    if (!validators && itIsControlOptions(options)) {
+        return options;
+    }
+    return {
+        value: options,
+        validators
+    };
+}
+function createFormGroupOptions(...groupOptions) {
+    const [options, validators] = groupOptions;
+    if (!validators && itIsGroupOptions(options)) {
+        return options;
+    }
+    return {
+        controls: options,
+        validators
+    };
+}
+function createFormArrayOptions(...arrayOptions) {
+    const [options, validators] = arrayOptions;
+    if (!options) {
+        return { groups: options, validators };
+    }
+    if (!validators && itIsArrayOptions(options)) {
+        return options;
+    }
+    return {
+        groups: options,
+        validators
+    };
 }
 
-function reduceErrors(errors) {
-    return errors.reduce((keys, { id }) => [...keys, id], []);
-}
-const controlIsValid = ({ value, validators }) => {
-    return validators.reduce((errors, validator) => {
-        const error = validator(value);
-        if (error) {
-            errors.push(error);
-        }
-        return errors;
-    }, []);
-};
-const controlsAllChecked = (controls, key) => {
-    return Object.values(controls).reduce((value, control) => control.disabled ? value : value && commons.parseBoolean(control[key]), true);
-};
-const controlsPartialChecked = (controls, key) => {
-    return Object.values(controls).reduce((value, control) => control.disabled ? value : value || commons.parseBoolean(control[key]), false);
-};
-const controlsToValue = (controls) => {
-    return Object.entries(controls).reduce((result, [key, { value }]) => {
-        result[key] = value;
-        return result;
-    }, {});
-};
-const groupIsValid = ({ controls, validators }) => {
-    return validators.reduce((errors, validator) => {
-        const error = validator(controls);
-        if (error) {
-            errors.push(error);
-        }
-        return errors;
-    }, []);
-};
-function groupAllChecked(groups, key) {
-    return groups.reduce((value, group) => value && commons.parseBoolean(group[key]), true);
-}
-function groupPartialChecked(groups, key) {
-    return groups.reduce((value, group) => value || commons.parseBoolean(group[key]), false);
-}
-const arrayIsValid = ({ groups, validators }) => {
-    return validators.reduce((errors, validator) => {
-        const error = validator(groups);
-        if (error) {
-            errors.push(error);
-        }
-        return errors;
-    }, []);
-};
-function hasError(errors, key) {
-    return reduceErrors(errors).includes(key);
-}
-function someErrors(errors, keys) {
-    return reduceErrors(errors).some((key) => keys.includes(key));
+function reduceErrors(errors) {
+    return errors.reduce((keys, { id }) => [...keys, id], []);
+}
+const controlIsValid = ({ value, validators }) => {
+    return validators.reduce((errors, validator) => {
+        const error = validator(value);
+        if (error) {
+            errors.push(error);
+        }
+        return errors;
+    }, []);
+};
+const controlsAllChecked = (controls, key) => {
+    return Object.values(controls).reduce((value, control) => control.disabled ? value : value && commons.parseBoolean(control[key]), true);
+};
+const controlsPartialChecked = (controls, key) => {
+    return Object.values(controls).reduce((value, control) => control.disabled ? value : value || commons.parseBoolean(control[key]), false);
+};
+const controlsToValue = (controls) => {
+    return Object.entries(controls).reduce((result, [key, { value }]) => {
+        result[key] = value;
+        return result;
+    }, {});
+};
+const groupIsValid = ({ controls, validators }) => {
+    return validators.reduce((errors, validator) => {
+        const error = validator(controls);
+        if (error) {
+            errors.push(error);
+        }
+        return errors;
+    }, []);
+};
+function groupAllChecked(groups, key) {
+    return groups.reduce((value, group) => value && commons.parseBoolean(group[key]), true);
+}
+function groupPartialChecked(groups, key) {
+    return groups.reduce((value, group) => value || commons.parseBoolean(group[key]), false);
+}
+const arrayIsValid = ({ groups, validators }) => {
+    return validators.reduce((errors, validator) => {
+        const error = validator(groups);
+        if (error) {
+            errors.push(error);
+        }
+        return errors;
+    }, []);
+};
+function hasError(errors, key) {
+    return reduceErrors(errors).includes(key);
+}
+function someErrors(errors, keys) {
+    return reduceErrors(errors).some((key) => keys.includes(key));
 }
 
-class FormControl {
-    constructor(controlOptions, controlValidators) {
-        this.currentFocused = false;
-        this.currentTouched = false;
-        this.currentDirty = false;
-        this.currentDisabled = false;
-        this.currentValid = true;
-        this.currentErrors = [];
-        const { value, validators } = createFormControlOptions(controlOptions, controlValidators);
-        this.observable = commons.observable(value);
-        this.initialValue = value;
-        this.validators = validators;
-        this.currentValue = value;
-        this.updateValueAndValidity(value, validators);
-    }
-    get focused() {
-        return this.currentFocused;
-    }
-    get unfocused() {
-        return !this.currentFocused;
-    }
-    get touched() {
-        return this.currentTouched;
-    }
-    get untouched() {
-        return !this.currentTouched;
-    }
-    get dirty() {
-        return this.currentDirty;
-    }
-    get pristine() {
-        return !this.currentDirty;
-    }
-    get disabled() {
-        return this.currentDisabled;
-    }
-    get enabled() {
-        return !this.currentDisabled;
-    }
-    get valid() {
-        return this.currentValid;
-    }
-    get invalid() {
-        return !this.currentValid;
-    }
-    get value() {
-        return this.currentValue;
-    }
-    get errors() {
-        return this.currentErrors;
-    }
-    get error() {
-        return this.currentError;
-    }
-    get wrong() {
-        return this.touched && this.invalid;
-    }
-    hasError(key) {
-        return hasError(this.errors, key);
-    }
-    someErrors(keys) {
-        return someErrors(this.errors, keys);
-    }
-    reset() {
-        this.setValue(this.initialValue);
-        this.currentDirty = false;
-        this.currentTouched = false;
-    }
-    focus() {
-        this.currentFocused = true;
-    }
-    blur() {
-        this.currentFocused = false;
-        this.currentTouched = true;
-    }
-    disable() {
-        this.currentDisabled = true;
-    }
-    enable() {
-        this.currentDisabled = false;
-    }
-    touch() {
-        this.currentTouched = true;
-    }
-    setValue(value) {
-        if (this.enabled) {
-            this.currentValue = value;
-            this.currentDirty = true;
-            this.updateValueAndValidity(value, this.validators);
-            this.observable.next(value);
-        }
-    }
-    setValidators(validators = []) {
-        this.validators = validators;
-        this.updateValueAndValidity(this.value, validators);
-    }
-    subscribe(subscriber) {
-        return this.observable.subscribe(subscriber);
-    }
-    updateValueAndValidity(value, validators) {
-        if (validators) {
-            const errors = controlIsValid({ value, validators });
-            this.currentError = errors[0];
-            this.currentErrors = errors;
-            this.currentValid = errors.length === 0;
-        }
-        else {
-            this.currentValid = true;
-            this.currentError = undefined;
-            this.currentErrors = [];
-        }
-    }
-}
-function formControl(options, validators) {
-    return new FormControl(createFormControlOptions(options, validators));
+class FormControl {
+    constructor(controlOptions, controlValidators) {
+        this.currentFocused = false;
+        this.currentTouched = false;
+        this.currentDirty = false;
+        this.currentDisabled = false;
+        this.currentValid = true;
+        this.currentErrors = [];
+        const { value, validators } = createFormControlOptions(controlOptions, controlValidators);
+        this.observable = commons.observable(value);
+        this.initialValue = value;
+        this.validators = validators;
+        this.currentValue = value;
+        this.updateValueAndValidity(value, validators);
+    }
+    get focused() {
+        return this.currentFocused;
+    }
+    get unfocused() {
+        return !this.currentFocused;
+    }
+    get touched() {
+        return this.currentTouched;
+    }
+    get untouched() {
+        return !this.currentTouched;
+    }
+    get dirty() {
+        return this.currentDirty;
+    }
+    get pristine() {
+        return !this.currentDirty;
+    }
+    get disabled() {
+        return this.currentDisabled;
+    }
+    get enabled() {
+        return !this.currentDisabled;
+    }
+    get valid() {
+        return this.currentValid;
+    }
+    get invalid() {
+        return !this.currentValid;
+    }
+    get value() {
+        return this.currentValue;
+    }
+    get errors() {
+        return this.currentErrors;
+    }
+    get error() {
+        return this.currentError;
+    }
+    get wrong() {
+        return this.touched && this.invalid;
+    }
+    hasError(key) {
+        return hasError(this.errors, key);
+    }
+    someErrors(keys) {
+        return someErrors(this.errors, keys);
+    }
+    reset() {
+        this.setValue(this.initialValue);
+        this.currentDirty = false;
+        this.currentTouched = false;
+    }
+    focus() {
+        this.currentFocused = true;
+    }
+    blur() {
+        this.currentFocused = false;
+        this.currentTouched = true;
+    }
+    disable() {
+        this.currentDisabled = true;
+    }
+    enable() {
+        this.currentDisabled = false;
+    }
+    touch() {
+        this.currentTouched = true;
+    }
+    setValue(value) {
+        if (this.enabled) {
+            this.currentValue = value;
+            this.currentDirty = true;
+            this.updateValueAndValidity(value, this.validators);
+            this.observable.next(value);
+        }
+    }
+    setValidators(validators = []) {
+        this.validators = validators;
+        this.updateValueAndValidity(this.value, validators);
+    }
+    subscribe(subscriber) {
+        return this.observable.subscribe(subscriber);
+    }
+    updateValueAndValidity(value, validators) {
+        if (validators) {
+            const errors = controlIsValid({ value, validators });
+            this.currentError = errors[0];
+            this.currentErrors = errors;
+            this.currentValid = errors.length === 0;
+        }
+        else {
+            this.currentValid = true;
+            this.currentError = undefined;
+            this.currentErrors = [];
+        }
+    }
+}
+function formControl(options, validators) {
+    return new FormControl(createFormControlOptions(options, validators));
 }
 
-class FormArrayControl extends FormControl {
-    constructor(controlOptions, controlValidators) {
-        const { value, validators } = createFormControlOptions(controlOptions, controlValidators);
-        super(value, validators);
-        this.uuid = uuid.v4();
-    }
-}
-function formArrayControl(options, validators) {
-    return new FormArrayControl(createFormControlOptions(options, validators));
+class FormArrayControl extends FormControl {
+    constructor(controlOptions, controlValidators) {
+        const { value, validators } = createFormControlOptions(controlOptions, controlValidators);
+        super(value, validators);
+        this.uuid = uuid.v4();
+    }
+}
+function formArrayControl(options, validators) {
+    return new FormArrayControl(createFormControlOptions(options, validators));
 }
 
-class FormGroup {
-    constructor(groupOptions, groupValidators) {
-        this.currentErrors = [];
-        this.currentValid = true;
-        const { controls, validators } = createFormGroupOptions(groupOptions, groupValidators);
-        this.currentControls = controls;
-        this.validators = validators;
-        this.updateValueAndValidity(controls, validators);
-        this.observable = commons.observable(this.value);
-        Object.values(controls).forEach((control) => {
-            control.subscribe(() => {
-                this.updateValueAndValidity(this.controls, this.validators);
-                this.observable.next(this.value);
-            });
-        });
-    }
-    get controls() {
-        return this.currentControls;
-    }
-    get touched() {
-        return controlsPartialChecked(this.controls, 'touched');
-    }
-    get touchedAll() {
-        return controlsAllChecked(this.controls, 'touched');
-    }
-    get untouched() {
-        return !this.touched;
-    }
-    get untouchedAll() {
-        return !this.touchedAll;
-    }
-    get dirty() {
-        return controlsPartialChecked(this.controls, 'dirty');
-    }
-    get dirtyAll() {
-        return controlsAllChecked(this.controls, 'dirty');
-    }
-    get pristine() {
-        return !this.dirty;
-    }
-    get pristineAll() {
-        return this.dirtyAll;
-    }
-    get valid() {
-        return this.currentValid && controlsAllChecked(this.controls, 'valid');
-    }
-    get invalid() {
-        return !this.valid;
-    }
-    get value() {
-        return controlsToValue(this.controls);
-    }
-    get errors() {
-        return this.currentErrors;
-    }
-    get error() {
-        return this.currentError;
-    }
-    get wrong() {
-        return this.touched && this.invalid;
-    }
-    reset() {
-        Object.values(this.controls).forEach((control) => {
-            control.reset();
-        });
-    }
-    setValidators(validators) {
-        this.validators = validators;
-        this.updateValueAndValidity(this.controls, validators);
-    }
-    subscribe(subscriber) {
-        return this.observable.subscribe(subscriber);
-    }
-    updateValueAndValidity(controls, validators) {
-        if (validators) {
-            const errors = groupIsValid({ controls, validators });
-            this.currentErrors = errors;
-            this.currentError = errors[0];
-            this.currentValid = errors.length === 0;
-        }
-        else {
-            this.currentErrors = [];
-            this.currentError = undefined;
-            this.currentValid = true;
-        }
-    }
-}
-function formGroup(options, validators) {
-    return new FormGroup(createFormGroupOptions(options, validators));
+class FormGroup {
+    constructor(groupOptions, groupValidators) {
+        this.currentErrors = [];
+        this.currentValid = true;
+        const { controls, validators } = createFormGroupOptions(groupOptions, groupValidators);
+        this.currentControls = controls;
+        this.validators = validators;
+        this.updateValueAndValidity(controls, validators);
+        this.observable = commons.observable(this.value);
+        Object.values(controls).forEach((control) => {
+            control.subscribe(() => {
+                this.updateValueAndValidity(this.controls, this.validators);
+                this.observable.next(this.value);
+            });
+        });
+    }
+    get controls() {
+        return this.currentControls;
+    }
+    get touched() {
+        return controlsPartialChecked(this.controls, 'touched');
+    }
+    get touchedAll() {
+        return controlsAllChecked(this.controls, 'touched');
+    }
+    get untouched() {
+        return !this.touched;
+    }
+    get untouchedAll() {
+        return !this.touchedAll;
+    }
+    get dirty() {
+        return controlsPartialChecked(this.controls, 'dirty');
+    }
+    get dirtyAll() {
+        return controlsAllChecked(this.controls, 'dirty');
+    }
+    get pristine() {
+        return !this.dirty;
+    }
+    get pristineAll() {
+        return this.dirtyAll;
+    }
+    get valid() {
+        return this.currentValid && controlsAllChecked(this.controls, 'valid');
+    }
+    get invalid() {
+        return !this.valid;
+    }
+    get value() {
+        return controlsToValue(this.controls);
+    }
+    get errors() {
+        return this.currentErrors;
+    }
+    get error() {
+        return this.currentError;
+    }
+    get wrong() {
+        return this.touched && this.invalid;
+    }
+    reset() {
+        Object.values(this.controls).forEach((control) => {
+            control.reset();
+        });
+    }
+    setValidators(validators) {
+        this.validators = validators;
+        this.updateValueAndValidity(this.controls, validators);
+    }
+    subscribe(subscriber) {
+        return this.observable.subscribe(subscriber);
+    }
+    updateValueAndValidity(controls, validators) {
+        if (validators) {
+            const errors = groupIsValid({ controls, validators });
+            this.currentErrors = errors;
+            this.currentError = errors[0];
+            this.currentValid = errors.length === 0;
+        }
+        else {
+            this.currentErrors = [];
+            this.currentError = undefined;
+            this.currentValid = true;
+        }
+    }
+}
+function formGroup(options, validators) {
+    return new FormGroup(createFormGroupOptions(options, validators));
 }
 
-class FormArrayGroup extends FormGroup {
-    constructor(groupOptions, groupValidators) {
-        const { controls, resource, validators } = createFormGroupOptions(groupOptions, groupValidators);
-        super(controls, validators);
-        this.uuid = uuid.v4();
-        this.resource = resource;
-    }
-}
-function formArrayGroup(options, validators) {
-    return new FormArrayGroup(createFormGroupOptions(options, validators));
+class FormArrayGroup extends FormGroup {
+    constructor(groupOptions, groupValidators) {
+        const { controls, resource, validators } = createFormGroupOptions(groupOptions, groupValidators);
+        super(controls, validators);
+        this.uuid = uuid.v4();
+        this.resource = resource;
+    }
+}
+function formArrayGroup(options, validators) {
+    return new FormArrayGroup(createFormGroupOptions(options, validators));
 }
 
-class FormArrayList extends FormControl {
-    constructor(valueToControls, value, validators) {
-        const initialValue = value || [];
-        super(initialValue, validators);
-        this.valueToControls = valueToControls;
-        this.currentControls = initialValue.map((value) => this.createControls(value));
-        this.uuid = uuid.v4();
-    }
-    get controls() {
-        return this.currentControls;
-    }
-    get touched() {
-        return this.controls.reduce((valid, controls) => valid && controlsPartialChecked(controls, 'touched'), true);
-    }
-    get dirty() {
-        return this.controls.reduce((valid, controls) => valid && controlsPartialChecked(controls, 'dirty'), true);
-    }
-    get valid() {
-        return (this.currentValid &&
-            this.controls.reduce((valid, controls) => valid && controlsAllChecked(controls, 'valid'), true));
-    }
-    get value() {
-        return this.controls.map((controls) => controlsToValue(controls));
-    }
-    setValue(values) {
-        this.currentControls = values.map((value) => this.createControls(value));
-    }
-    push(controls) {
-        this.currentControls = this.currentControls.concat([controls]);
-    }
-    remove(controls) {
-        this.currentControls = this.currentControls.filter((currentControls) => currentControls !== controls);
-    }
-    createControls(value) {
-        const controls = this.valueToControls(value);
-        Object.values(controls).forEach((control) => {
-            control.subscribe(() => {
-                const { value, validators } = this;
-                this.updateValueAndValidity(value, validators);
-                this.observable.next(value);
-            });
-        });
-        return controls;
-    }
-}
-function formArrayList(valueToControl, value, validators) {
-    return new FormArrayList(valueToControl, value, validators);
+class FormArrayList extends FormControl {
+    constructor(valueToControls, value, validators) {
+        const initialValue = value || [];
+        super(initialValue, validators);
+        this.valueToControls = valueToControls;
+        this.currentControls = initialValue.map((value) => this.createControls(value));
+        this.uuid = uuid.v4();
+    }
+    get controls() {
+        return this.currentControls;
+    }
+    get touched() {
+        return this.controls.reduce((valid, controls) => valid && controlsPartialChecked(controls, 'touched'), true);
+    }
+    get dirty() {
+        return this.controls.reduce((valid, controls) => valid && controlsPartialChecked(controls, 'dirty'), true);
+    }
+    get valid() {
+        return (this.currentValid &&
+            this.controls.reduce((valid, controls) => valid && controlsAllChecked(controls, 'valid'), true));
+    }
+    get value() {
+        return this.controls.map((controls) => controlsToValue(controls));
+    }
+    setValue(values) {
+        this.currentControls = values.map((value) => this.createControls(value));
+    }
+    push(controls) {
+        this.currentControls = this.currentControls.concat([controls]);
+    }
+    remove(controls) {
+        this.currentControls = this.currentControls.filter((currentControls) => currentControls !== controls);
+    }
+    createControls(value) {
+        const controls = this.valueToControls(value);
+        Object.values(controls).forEach((control) => {
+            control.subscribe(() => {
+                const { value, validators } = this;
+                this.updateValueAndValidity(value, validators);
+                this.observable.next(value);
+            });
+        });
+        return controls;
+    }
+}
+function formArrayList(valueToControl, value, validators) {
+    return new FormArrayList(valueToControl, value, validators);
 }
 
-class FormArray {
-    constructor(arrayOptions, arrayValidators) {
-        this.currentGroups = [];
-        this.currentValid = true;
-        this.currentDisabled = false;
-        this.currentErrors = [];
-        const { groups, validators } = createFormArrayOptions(arrayOptions, arrayValidators);
-        this.unsusbcriptions = new Map();
-        this.initialState = groups;
-        this.validators = validators;
-        this.refresh(this.initialState);
-        this.observable = commons.observable(this.value);
-        groups?.forEach((group) => {
-            this.subscription(group);
-        });
-    }
-    get groups() {
-        return this.currentGroups;
-    }
-    get controls() {
-        return this.groups.map(({ controls }) => controls);
-    }
-    get touched() {
-        return groupPartialChecked(this.groups, 'touched');
-    }
-    get touchedAll() {
-        return groupAllChecked(this.groups, 'touchedAll');
-    }
-    get untouched() {
-        return !this.touched;
-    }
-    get untouchedAll() {
-        return !this.touchedAll;
-    }
-    get dirty() {
-        return groupPartialChecked(this.groups, 'dirty');
-    }
-    get dirtyAll() {
-        return groupAllChecked(this.groups, 'dirtyAll');
-    }
-    get pristine() {
-        return !this.dirty;
-    }
-    get pristineAll() {
-        return !this.dirtyAll;
-    }
-    get disabled() {
-        return this.currentDisabled;
-    }
-    get enabled() {
-        return !this.currentDisabled;
-    }
-    get valid() {
-        return this.currentValid && groupAllChecked(this.groups, 'valid');
-    }
-    get invalid() {
-        return !this.currentValid;
-    }
-    get value() {
-        return this.groups.map(({ value: state }) => state);
-    }
-    get error() {
-        return this.currentError;
-    }
-    get errors() {
-        return this.currentErrors;
-    }
-    get wrong() {
-        return this.touched && this.invalid;
-    }
-    hasError(key) {
-        return hasError(this.errors, key);
-    }
-    someErrors(keys) {
-        return someErrors(this.errors, keys);
-    }
-    reset() {
-        this.refresh(this.initialState);
-    }
-    disable() {
-        this.currentDisabled = true;
-    }
-    enable() {
-        this.currentDisabled = false;
-    }
-    push(group) {
-        this.subscription(group);
-        this.refresh([...this.groups, group]);
-    }
-    merge(groups) {
-        groups.forEach((group) => {
-            this.subscription(group);
-        });
-        this.refresh([...this.groups, ...groups]);
-    }
-    set(groups) {
-        this.currentGroups.forEach(({ uuid }) => {
-            this.unsusbcriptions.delete(uuid);
-        });
-        groups.forEach((group) => {
-            this.subscription(group);
-        });
-        this.refresh(groups); // Update groups
-    }
-    remove({ uuid }) {
-        this.refresh(this.groups.filter((group) => group.uuid !== uuid));
-    }
-    setValidators(validators) {
-        this.validators = validators;
-        this.updateValidityStatus(this.groups, validators);
-    }
-    subscribe(subscriber) {
-        return this.observable.subscribe(subscriber);
-    }
-    subscription(group) {
-        const unsusbcription = group.subscribe(() => {
-            this.updateValidityStatus(this.groups, this.validators);
-        });
-        this.unsusbcriptions.set(group.uuid, unsusbcription);
-    }
-    updateValidityStatus(groups, validators) {
-        if (validators) {
-            const errors = arrayIsValid({ groups, validators });
-            this.currentErrors = errors;
-            this.currentError = errors[0];
-            this.currentValid = errors.length === 0;
-        }
-        else {
-            this.currentValid = true;
-            this.currentErrors = [];
-            this.currentError = undefined;
-        }
-    }
-    refresh(newGroups) {
-        const groups = newGroups || [];
-        this.currentGroups = groups;
-        this.updateValidityStatus(groups, this.validators);
-    }
-}
-function formArray(options, validators) {
-    return new FormArray(createFormArrayOptions(options, validators));
+class FormArray {
+    constructor(arrayOptions, arrayValidators) {
+        this.currentGroups = [];
+        this.currentValid = true;
+        this.currentDisabled = false;
+        this.currentErrors = [];
+        const { groups, validators } = createFormArrayOptions(arrayOptions, arrayValidators);
+        this.unsusbcriptions = new Map();
+        this.initialState = groups;
+        this.validators = validators;
+        this.refresh(this.initialState);
+        this.observable = commons.observable(this.value);
+        groups?.forEach((group) => {
+            this.subscription(group);
+        });
+    }
+    get groups() {
+        return this.currentGroups;
+    }
+    get controls() {
+        return this.groups.map(({ controls }) => controls);
+    }
+    get touched() {
+        return groupPartialChecked(this.groups, 'touched');
+    }
+    get touchedAll() {
+        return groupAllChecked(this.groups, 'touchedAll');
+    }
+    get untouched() {
+        return !this.touched;
+    }
+    get untouchedAll() {
+        return !this.touchedAll;
+    }
+    get dirty() {
+        return groupPartialChecked(this.groups, 'dirty');
+    }
+    get dirtyAll() {
+        return groupAllChecked(this.groups, 'dirtyAll');
+    }
+    get pristine() {
+        return !this.dirty;
+    }
+    get pristineAll() {
+        return !this.dirtyAll;
+    }
+    get disabled() {
+        return this.currentDisabled;
+    }
+    get enabled() {
+        return !this.currentDisabled;
+    }
+    get valid() {
+        return this.currentValid && groupAllChecked(this.groups, 'valid');
+    }
+    get invalid() {
+        return !this.currentValid;
+    }
+    get value() {
+        return this.groups.map(({ value: state }) => state);
+    }
+    get error() {
+        return this.currentError;
+    }
+    get errors() {
+        return this.currentErrors;
+    }
+    get wrong() {
+        return this.touched && this.invalid;
+    }
+    hasError(key) {
+        return hasError(this.errors, key);
+    }
+    someErrors(keys) {
+        return someErrors(this.errors, keys);
+    }
+    reset() {
+        this.refresh(this.initialState);
+    }
+    disable() {
+        this.currentDisabled = true;
+    }
+    enable() {
+        this.currentDisabled = false;
+    }
+    push(group) {
+        this.subscription(group);
+        this.refresh([...this.groups, group]);
+    }
+    merge(groups) {
+        groups.forEach((group) => {
+            this.subscription(group);
+        });
+        this.refresh([...this.groups, ...groups]);
+    }
+    set(groups) {
+        this.currentGroups.forEach(({ uuid }) => {
+            this.unsusbcriptions.delete(uuid);
+        });
+        groups.forEach((group) => {
+            this.subscription(group);
+        });
+        this.refresh(groups); // Update groups
+    }
+    remove({ uuid }) {
+        this.refresh(this.groups.filter((group) => group.uuid !== uuid));
+    }
+    setValidators(validators) {
+        this.validators = validators;
+        this.updateValidityStatus(this.groups, validators);
+    }
+    subscribe(subscriber) {
+        return this.observable.subscribe(subscriber);
+    }
+    subscription(group) {
+        const unsusbcription = group.subscribe(() => {
+            this.updateValidityStatus(this.groups, this.validators);
+        });
+        this.unsusbcriptions.set(group.uuid, unsusbcription);
+    }
+    updateValidityStatus(groups, validators) {
+        if (validators) {
+            const errors = arrayIsValid({ groups, validators });
+            this.currentErrors = errors;
+            this.currentError = errors[0];
+            this.currentValid = errors.length === 0;
+        }
+        else {
+            this.currentValid = true;
+            this.currentErrors = [];
+            this.currentError = undefined;
+        }
+    }
+    refresh(newGroups) {
+        const groups = newGroups || [];
+        this.currentGroups = groups;
+        this.updateValidityStatus(groups, this.validators);
+    }
+}
+function formArray(options, validators) {
+    return new FormArray(createFormArrayOptions(options, validators));
 }
 
 exports.FormArray = FormArray;