@spscommerce/ds-react 5.13.0-ie → 5.14.0

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

@@ -1,736 +0,0 @@
-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