@spscommerce/ds-react 5.20.0 → 5.20.3-ie

package/dist/out-tsc/form/hooks/useSpsForm.js

@@ -0,0 +1,736 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+/* eslint-disable
+    max-classes-per-file,
+    @typescript-eslint/no-use-before-define,
+    no-param-reassign,
+*/
+import { diff, DiffChange, getPath, setPath, deepFreeze, } from "@spscommerce/utils";
+import { useCallback, useEffect, useMemo, useReducer, useRef, } from "react";
+import nanoid from "nanoid";
+import isPlainObject from "lodash.isplainobject";
+import { AsTypingErrorKeys, PreventativeErrorKeys, OnSubmitErrorKeys, } from "../validation/types";
+import { SpsValidators } from "../validation/SpsValidators";
+import { validate } from "../validation/validate";
+// Base class for all form metadata structures: controls, groups, and arrays
+var SpsFormMetaBase = /** @class */ (function () {
+    function SpsFormMetaBase(path, update) {
+        this.path = path;
+        this.update = update;
+        this.validators = [];
+        this.errors = null;
+        this.revealAllErrors = false;
+        this.preventativeErrors = [];
+        this.submitted = false;
+    }
+    SpsFormMetaBase.prototype.setValidators = function (newValidators) {
+        this.update(this.path, null, null, newValidators);
+        return this;
+    };
+    SpsFormMetaBase.prototype.validate = function (newValue) {
+        if (this.validators && this.validators.length > 0) {
+            this.errors = validate(newValue, this.validators);
+            this.update(null);
+            if (this.isFocused() && this.onFocus) {
+                this.onFocus();
+            }
+        }
+        else if (this.errors) {
+            this.errors = null;
+            this.update(null);
+        }
+        return this;
+    };
+    SpsFormMetaBase.prototype.isValid = function () {
+        return !this.errors || this.isPristine();
+    };
+    SpsFormMetaBase.prototype.hasErrors = function () {
+        return !!this.errors;
+    };
+    SpsFormMetaBase.prototype.isVisibilyInvalid = function () {
+        return (this.errors &&
+            ((this.revealAllErrors &&
+                !Object.keys(this.errors).some(function (key) { return OnSubmitErrorKeys.has(key); })) ||
+                (this.revealAllErrors &&
+                    Object.keys(this.errors).some(function (key) { return OnSubmitErrorKeys.has(key); }) &&
+                    this.isSubmitted()) ||
+                (!this.isPristine() &&
+                    Object.keys(this.errors).some(function (key) { return AsTypingErrorKeys.has(key); }))));
+    };
+    SpsFormMetaBase.prototype.hasError = function (errorKey) {
+        return this.errors && Object.prototype.hasOwnProperty.call(this.errors, errorKey);
+    };
+    SpsFormMetaBase.prototype.hasPreventativeError = function (errorKey) {
+        return this.preventativeErrors.includes(errorKey);
+    };
+    SpsFormMetaBase.prototype.hasPreventativeErrors = function () {
+        return this.preventativeErrors.length > 0;
+    };
+    SpsFormMetaBase.prototype.isRequired = function () {
+        return this.validators && this.validators.indexOf(SpsValidators.required) > -1;
+    };
+    SpsFormMetaBase.prototype.isSubmitted = function () {
+        return this.submitted;
+    };
+    SpsFormMetaBase.prototype.onFocus = function () { }; // eslint-disable-line class-methods-use-this
+    SpsFormMetaBase.prototype.onBlur = function () { }; // eslint-disable-line class-methods-use-this
+    return SpsFormMetaBase;
+}());
+export { SpsFormMetaBase };
+// Metadata for an individual control such as a text input or checkbox
+var SpsFormFieldMeta = /** @class */ (function (_super) {
+    __extends(SpsFormFieldMeta, _super);
+    function SpsFormFieldMeta() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.id = nanoid();
+        _this.focused = false;
+        _this.pristine = true;
+        return _this;
+    }
+    SpsFormFieldMeta.prototype.setValue = function (newValue) {
+        this.revealAllErrors = false;
+        this.preventativeErrors = [];
+        if (this.validators && this.validators.length > 0) {
+            var errors = validate(newValue, this.validators);
+            if (errors) {
+                var currentPreventativeErrors = Object.keys(errors)
+                    .filter(function (key) { return PreventativeErrorKeys.has(key); });
+                if (currentPreventativeErrors.length > 0) {
+                    this.preventativeErrors = Object.keys(errors);
+                    return;
+                }
+            }
+        }
+        this.update(this.path, newValue);
+    };
+    SpsFormFieldMeta.prototype.isPristine = function () {
+        return this.pristine;
+    };
+    SpsFormFieldMeta.prototype.markAsPristine = function () {
+        this.pristine = true;
+        this.revealAllErrors = false;
+        this.update(null);
+        return this;
+    };
+    SpsFormFieldMeta.prototype.markAsDirty = function () {
+        this.pristine = false;
+        this.update(null);
+        return this;
+    };
+    SpsFormFieldMeta.prototype.isFocused = function () {
+        return this.focused;
+    };
+    SpsFormFieldMeta.prototype.markAsFocused = function () {
+        this.focused = true;
+        this.update(null);
+        if (this.onFocus) {
+            this.onFocus();
+        }
+        return this;
+    };
+    SpsFormFieldMeta.prototype.markAsBlurred = function () {
+        this.update(this.path, null, true);
+        if (this.onBlur) {
+            this.onBlur();
+        }
+        this.preventativeErrors = [];
+        return this;
+    };
+    SpsFormFieldMeta.prototype.markAsSubmitted = function () {
+        this.submitted = true;
+        this.update(null);
+        return this;
+    };
+    return SpsFormFieldMeta;
+}(SpsFormMetaBase));
+export { SpsFormFieldMeta };
+/*
+ * Base class for form metadata structures that contain other form metadata
+ * structures: arrays and groups, which have "fields" that can be other
+ * form arrays or form groups, or form controls (i.e. any SpsFormMetaBase)
+ */
+var SpsFormSetMeta = /** @class */ (function (_super) {
+    __extends(SpsFormSetMeta, _super);
+    function SpsFormSetMeta(inferValOrPath, pathOrUpdate, updateWhenInferring) {
+        var _this = this;
+        var path = (updateWhenInferring ? pathOrUpdate : inferValOrPath);
+        var update = updateWhenInferring || pathOrUpdate;
+        _this = _super.call(this, path, update) || this;
+        if (updateWhenInferring) {
+            _this.inferMembers(inferValOrPath);
+        }
+        return _this;
+    }
+    SpsFormSetMeta.prototype.inferSpsControl = function (valueOrControl, key) {
+        return inferSpsControl(valueOrControl, __spreadArray(__spreadArray([], __read(this.path), false), [key], false), this.update);
+    };
+    SpsFormSetMeta.prototype.rollup = function (methodName) {
+        var _this = this;
+        return Object.keys(this.fields).reduce(function (acc, key) { return acc && (!_this.fields[key][methodName] || _this.fields[key][methodName]()); }, true);
+    };
+    SpsFormSetMeta.prototype.isFocused = function () {
+        return _super.prototype.isFocused.call(this) || this.rollup("isFocused");
+    };
+    SpsFormSetMeta.prototype.isValid = function () {
+        return _super.prototype.isValid.call(this) && this.rollup("isValid");
+    };
+    SpsFormSetMeta.prototype.hasErrors = function () {
+        var _this = this;
+        return (_super.prototype.hasErrors.call(this) || Object.keys(this.fields).some(function (key) { return _this.fields[key].hasErrors(); }));
+    };
+    SpsFormSetMeta.prototype.contentsAreValid = function () {
+        /*
+         * The distinction between "isValid" and "contentsAreValid" is that a form group
+         * or form array can have a validator attached, which means the group/array in and
+         * of itself has a validation status and associated errors. That is "isValid" for
+         * a group/array, the same as for a control.
+         */
+        return this.rollup("isValid") && this.rollup("contentsAreValid");
+    };
+    SpsFormSetMeta.prototype.isPristine = function () {
+        return _super.prototype.isPristine.call(this) && this.rollup("isPristine");
+    };
+    SpsFormSetMeta.prototype.markAsPristine = function () {
+        var e_1, _a;
+        _super.prototype.markAsPristine.call(this);
+        try {
+            for (var _b = __values(Object.keys(this.fields)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                this.fields[key].markAsPristine();
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return this;
+    };
+    SpsFormSetMeta.prototype.markAsDirty = function () {
+        var e_2, _a;
+        _super.prototype.markAsDirty.call(this);
+        try {
+            for (var _b = __values(Object.keys(this.fields)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                this.fields[key].markAsDirty();
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return this;
+    };
+    SpsFormSetMeta.prototype.markAsBlurred = function () {
+        var e_3, _a;
+        _super.prototype.markAsBlurred.call(this);
+        try {
+            for (var _b = __values(Object.keys(this.fields)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                this.fields[key].markAsBlurred();
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return this;
+    };
+    SpsFormSetMeta.prototype.markAsSubmitted = function () {
+        var e_4, _a;
+        _super.prototype.markAsSubmitted.call(this);
+        try {
+            for (var _b = __values(Object.keys(this.fields)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                this.fields[key].markAsSubmitted();
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return this;
+    };
+    return SpsFormSetMeta;
+}(SpsFormFieldMeta));
+export { SpsFormSetMeta };
+/*
+ * Ultimately the difference between SpsFormGroupMeta and SpsFormArrayMeta is merely the type
+ * of their `fields` property: an object or an array.
+ */
+var SpsFormGroupMeta = /** @class */ (function (_super) {
+    __extends(SpsFormGroupMeta, _super);
+    function SpsFormGroupMeta() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpsFormGroupMeta.prototype.inferMembers = function (inferFromValue) {
+        var e_5, _a;
+        this.fields = {};
+        try {
+            for (var _b = __values(Object.keys(inferFromValue)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var key = _c.value;
+                this.fields[key] = this.inferSpsControl(inferFromValue[key], key);
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    };
+    return SpsFormGroupMeta;
+}(SpsFormSetMeta));
+export { SpsFormGroupMeta };
+var SpsFormArrayMeta = /** @class */ (function (_super) {
+    __extends(SpsFormArrayMeta, _super);
+    function SpsFormArrayMeta() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SpsFormArrayMeta.prototype.inferMembers = function (inferFromValue) {
+        var _this = this;
+        this.fields = (inferFromValue.map(function (item, i) { return _this.inferSpsControl(item, String(i)); }));
+    };
+    return SpsFormArrayMeta;
+}(SpsFormSetMeta));
+export { SpsFormArrayMeta };
+function inferSpsControl(valueOrControl, path, update) {
+    if (valueOrControl instanceof SpsFormMetaBase) {
+        valueOrControl.path = path;
+        valueOrControl.update = update;
+        return valueOrControl;
+    }
+    if (Array.isArray(valueOrControl)) {
+        return new SpsFormArrayMeta(valueOrControl, path, update);
+    }
+    if (isPlainObject(valueOrControl)) {
+        return new SpsFormGroupMeta(valueOrControl, path, update);
+    }
+    return new SpsFormFieldMeta(path, update);
+}
+function getMember(obj, path) {
+    if (path.length === 0 || !obj) {
+        return obj;
+    }
+    return getMember(obj.fields[path[0]], path.slice(1, path.length));
+}
+function getMembers(obj, path) {
+    if (path.length === 0 || !obj) {
+        return [obj];
+    }
+    var nextPath = path[0];
+    path = path.slice(1, path.length);
+    if (nextPath === "*") {
+        var fieldsArray = Array.isArray(obj.fields)
+            ? obj.fields
+            : Object.keys(obj.fields).map(function (k) { return obj.fields[k]; });
+        if (path.length === 0) {
+            return fieldsArray;
+        }
+        return fieldsArray.reduce(function (arr, member) { return __spreadArray(__spreadArray([], __read(arr), false), __read(getMembers(member, path)), false); }, []);
+    }
+    return getMembers(obj.fields[nextPath], path);
+}
+function validatorMapForEach(formMeta, validatorMap, fn) {
+    var e_6, _a, e_7, _b;
+    try {
+        for (var _c = __values(Object.keys(validatorMap)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var path = _d.value;
+            var validators = validatorMap[path];
+            try {
+                for (var _e = (e_7 = void 0, __values(getMembers(formMeta, path.split(".")))), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var control = _f.value;
+                    if (control && validators) {
+                        fn(control, validators);
+                    }
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+}
+function updateValidators(value, formMeta, validatorMap, runValidators) {
+    if (runValidators === void 0) { runValidators = false; }
+    validatorMapForEach(formMeta, validatorMap, function (control, validators) {
+        control.validators = typeof validators === "function"
+            ? validators(value)
+            : validators;
+        if (runValidators) {
+            control.errors = validate(getPath(value, control.path), control.validators);
+        }
+    });
+}
+function cloneFormValue(value, path) {
+    var next = path[0];
+    path = path.slice(1);
+    if (Array.isArray(value)) {
+        return value.map(function (x, i) { return (i === Number(next)
+            ? cloneFormValue(x, path)
+            : x); });
+    }
+    if (isPlainObject(value)) {
+        return Object.keys(value)
+            .reduce(function (acc, key) {
+            var _a;
+            return Object.assign(acc, (_a = {},
+                _a[key] = key === next
+                    ? cloneFormValue(value[key], path)
+                    : value[key],
+                _a));
+        }, {});
+    }
+    return value;
+}
+function checkFormObject(value) {
+    if (typeof value !== "object"
+        || value === null
+        || Array.isArray(value)) {
+        throw new TypeError("The initial value of useSpsForm() hook must be an object.");
+    }
+}
+export function useSpsForm(value, validatorMap) {
+    checkFormObject(value);
+    /*
+     * Do the work of instantiating `formMeta` the first time the hook is run and ONLY
+     * the first time. Thereafter we will keep it up to date as we go.
+     */
+    var formMeta = useMemo(function () {
+        deepFreeze(value);
+        var controlSet = inferSpsControl(value, [], update);
+        if (validatorMap) {
+            updateValidators(value, controlSet, validatorMap, true);
+        }
+        return controlSet;
+    }, []);
+    /*
+     * Stores a timeout id, used for aggregating `updateForm` calls
+     * into a single `useReducer` dispatch per cycle
+     */
+    var scheduledDispatch = useRef();
+    var currentValidatorMap = validatorMap;
+    // A stable identity for `reducer` is important to avoid constant re-render thrashing
+    var reducer = useCallback(function (currentState, action) {
+        var e_8, _a, e_9, _b, e_10, _c, e_11, _d;
+        var newValue;
+        scheduledDispatch.current = null;
+        if (action) {
+            if (action.path) {
+                if (action.markAsBlurred) {
+                    var control = getMember(currentState.formMeta, action.path);
+                    if (control) {
+                        control.focused = false;
+                        control.revealAllErrors = true;
+                    }
+                }
+                else if (action.newValidators) {
+                    if (currentValidatorMap) {
+                        var controlPath = action.path.join(".");
+                        var newValidatorMap = __assign({}, currentValidatorMap);
+                        newValidatorMap[controlPath] = action.newValidators;
+                        currentValidatorMap = newValidatorMap;
+                        updateValidators(currentState.formValue, currentState.formMeta, currentValidatorMap, true);
+                    }
+                }
+                else {
+                    /*
+                     * This branch is used when an SpsFormFieldMeta's value is updated by
+                     * its associated component, i.e. when the user interacts with it
+                     */
+                    newValue = cloneFormValue(currentState.formValue, action.path);
+                    setPath(newValue, action.path, action.value);
+                }
+            }
+            else {
+                newValue = action.value;
+            }
+        }
+        if (newValue) {
+            deepFreeze(newValue);
+            var valueDiff = diff(currentState.formValue, newValue);
+            try {
+                for (var valueDiff_1 = __values(valueDiff), valueDiff_1_1 = valueDiff_1.next(); !valueDiff_1_1.done; valueDiff_1_1 = valueDiff_1.next()) {
+                    var _e = valueDiff_1_1.value, dType = _e.type, key = _e.key, parentPath = _e.parentPath, _f = __read(_e.objects, 2), oldSubValue = _f[0], newSubValue = _f[1];
+                    var meta = getMember(currentState.formMeta, parentPath);
+                    /*
+                     * I don't expect anyone to have symbol properties on their form value;
+                     * this is mainly for TypeScript to understand that `key` is a number or string
+                     * within this block. And if someone does have a symbol-keyed property, I
+                     * don't know what would be going on there and we'll err on the side of not
+                     * touching it.
+                     */
+                    if (typeof key !== "symbol" && meta) {
+                        /*
+                         * Update `formMeta` in sync with new fields
+                         * added or fields removed within the value
+                         */
+                        switch (dType) {
+                            case DiffChange.ADDITION:
+                                meta.fields[key] = inferSpsControl(newSubValue[key], __spreadArray(__spreadArray([], __read(parentPath), false), [key], false), update);
+                                break;
+                            case DiffChange.DELETION:
+                                if (Array.isArray(meta.fields)) {
+                                    meta.fields.splice(Number(key), 1);
+                                }
+                                else {
+                                    delete meta.fields[key];
+                                }
+                                break;
+                            case DiffChange.ALTERATION:
+                                if (!oldSubValue[key]
+                                    && newSubValue[key]
+                                    && !(meta.fields[key] instanceof SpsFormSetMeta)) {
+                                    var newControl = inferSpsControl(newSubValue[key], __spreadArray(__spreadArray([], __read(parentPath), false), [key], false), update);
+                                    if (newControl instanceof SpsFormFieldMeta
+                                        && meta.fields[key] instanceof SpsFormFieldMeta) {
+                                        newControl.id = meta.fields[key].id;
+                                        newControl.focused = meta.fields[key].focused;
+                                        newControl.pristine = meta.fields[key].pristine;
+                                    }
+                                    meta.fields[key] = newControl;
+                                }
+                                break;
+                            default:
+                        }
+                    }
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (valueDiff_1_1 && !valueDiff_1_1.done && (_a = valueDiff_1.return)) _a.call(valueDiff_1);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+            if (currentValidatorMap) {
+                /**
+                 * The changes may alter the results of dynamic validator configurations
+                 * (i.e. cases where they are defined as a function that returns conditionally
+                 * different lists of validators). As well, any items added during the
+                 * previous step may be included in a wildcard validator config, and therefore
+                 * need their validators added.
+                 */
+                updateValidators(newValue, currentState.formMeta, currentValidatorMap);
+                var alreadyValidated_1 = new Set();
+                validatorMapForEach(currentState.formMeta, validatorMap, function (control, validators) {
+                    /**
+                     * For any control with dynamic validators, its list of validators might
+                     * have changed. So re-run validation and keep track of these so we don't
+                     * needlessly run them again in the next step.
+                     */
+                    if (typeof validators === "function") {
+                        control.validate(getPath(newValue, control.path));
+                        alreadyValidated_1.add(control);
+                    }
+                });
+                try {
+                    /**
+                     * Targeted validation of changes, excluding things that were already
+                     * validated in the previous step
+                     */
+                    for (var valueDiff_2 = __values(valueDiff), valueDiff_2_1 = valueDiff_2.next(); !valueDiff_2_1.done; valueDiff_2_1 = valueDiff_2.next()) {
+                        var _g = valueDiff_2_1.value, dType = _g.type, key = _g.key, parentPath = _g.parentPath, _h = __read(_g.objects, 2), newSubValue = _h[1];
+                        if (typeof key !== "symbol") {
+                            /**
+                             * Revalidate each group/array that contains the added,
+                             * removed, or altered value
+                             */
+                            var meta = currentState.formMeta;
+                            var subValue = newValue;
+                            if (meta) {
+                                try {
+                                    for (var _j = (e_10 = void 0, __values(parentPath)), _k = _j.next(); !_k.done; _k = _j.next()) {
+                                        var pathPiece = _k.value;
+                                        meta = meta.fields[pathPiece];
+                                        subValue = subValue[pathPiece];
+                                        if (!alreadyValidated_1.has(meta)) {
+                                            meta.validate(subValue);
+                                        }
+                                    }
+                                }
+                                catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                                finally {
+                                    try {
+                                        if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                                    }
+                                    finally { if (e_10) throw e_10.error; }
+                                }
+                                if (dType === DiffChange.ADDITION || dType === DiffChange.ALTERATION) {
+                                    // Validate the thing that was added or altered
+                                    var childMeta = meta.fields[key];
+                                    if (!alreadyValidated_1.has(childMeta)) {
+                                        meta.fields[key].validate(newSubValue[key]);
+                                        /**
+                                         * If we have a list of objects the above validation wont validate
+                                         * each field of the newly added object. So we need to trigger this
+                                         * validation.
+                                         */
+                                        if (dType === DiffChange.ADDITION && childMeta.fields) {
+                                            try {
+                                                for (var _l = (e_11 = void 0, __values(Object.entries(childMeta.fields))), _m = _l.next(); !_m.done; _m = _l.next()) {
+                                                    var _o = __read(_m.value, 2), fieldKey = _o[0], field = _o[1];
+                                                    field.validate(newSubValue[key][fieldKey]);
+                                                }
+                                            }
+                                            catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                                            finally {
+                                                try {
+                                                    if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+                                                }
+                                                finally { if (e_11) throw e_11.error; }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                finally {
+                    try {
+                        if (valueDiff_2_1 && !valueDiff_2_1.done && (_b = valueDiff_2.return)) _b.call(valueDiff_2);
+                    }
+                    finally { if (e_9) throw e_9.error; }
+                }
+            }
+        }
+        return {
+            formValue: newValue || currentState.formValue,
+            formMeta: currentState.formMeta,
+            updateForm: currentState.updateForm,
+        };
+    }, []);
+    var _a = __read(useReducer(reducer, { formValue: value, formMeta: formMeta, updateForm: updateForm }), 2), state = _a[0], dispatch = _a[1];
+    function update(path, newValue, markAsBlurred, newValidators) {
+        if (markAsBlurred === void 0) { markAsBlurred = false; }
+        if (path) {
+            dispatch({
+                path: path,
+                value: newValue,
+                markAsBlurred: markAsBlurred,
+                newValidators: newValidators,
+            });
+        }
+        else {
+            updateForm();
+        }
+    }
+    function updateForm(newValue) {
+        if (newValue) {
+            /*
+             * For multiple updateForm calls with a new value in the same cycle,
+             * use the most recent. (Or have a call with a new value supercede
+             * previous calls that did not have a new value.)
+             */
+            if (scheduledDispatch.current) {
+                window.clearTimeout(scheduledDispatch.current);
+            }
+            var sd = window.setTimeout(dispatch, 0, { value: newValue });
+            scheduledDispatch.current = sd;
+        }
+        else if (!scheduledDispatch.current) {
+            /*
+             * All updateForm calls *without* a value are the same, so no need
+             * to do any superceding; if there's a dispatch scheduled already,
+             * then great, that's what we needed. Otherwise get one set up.
+             */
+            var sd = window.setTimeout(dispatch, 0, {});
+            scheduledDispatch.current = sd;
+        }
+    }
+    /**
+     * Prevents scheduled updates from occurring if the hook gets unmounted
+     */
+    useEffect(function () { return function () {
+        if (scheduledDispatch.current) {
+            window.clearTimeout(scheduledDispatch.current);
+        }
+    }; }, []);
+    return state;
+}
+//# sourceMappingURL=useSpsForm.js.map