@tanstack/form-core 0.0.9 → 0.0.12

package/build/umd/index.development.js

@@ -1,785 +0,0 @@
-/**
- * form-core
- *
- * Copyright (c) TanStack
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE.md file in the root directory of this source tree.
- *
- * @license MIT
- */
-(function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-  typeof define === 'function' && define.amd ? define(['exports'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FormCore = {}));
-})(this, (function (exports) { 'use strict';
-
-  /**
-   * store
-   *
-   * Copyright (c) TanStack
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE.md file in the root directory of this source tree.
-   *
-   * @license MIT
-   */
-  class Store {
-    listeners = new Set();
-    batching = false;
-    queue = [];
-    constructor(initialState, options) {
-      this.state = initialState;
-      this.options = options;
-    }
-    subscribe = listener => {
-      this.listeners.add(listener);
-      const unsub = this.options?.onSubscribe?.(listener, this);
-      return () => {
-        this.listeners.delete(listener);
-        unsub?.();
-      };
-    };
-    setState = updater => {
-      const previous = this.state;
-      this.state = this.options?.updateFn ? this.options.updateFn(previous)(updater) : updater(previous);
-      if (this.state === previous) return;
-      this.options?.onUpdate?.(this.state, previous);
-      this.queue.push(() => {
-        this.listeners.forEach(listener => listener(this.state, previous));
-      });
-      this.#flush();
-    };
-    #flush = () => {
-      if (this.batching) return;
-      this.queue.forEach(cb => cb());
-      this.queue = [];
-    };
-    batch = cb => {
-      this.batching = true;
-      cb();
-      this.batching = false;
-      this.#flush();
-    };
-  }
-
-  function functionalUpdate(updater, input) {
-    return typeof updater === 'function' ? updater(input) : updater;
-  }
-  function getBy(obj, path) {
-    const pathArray = makePathArray(path);
-    const pathObj = pathArray;
-    return pathObj.reduce((current, pathPart) => {
-      if (typeof current !== 'undefined') {
-        return current[pathPart];
-      }
-
-      return undefined;
-    }, obj);
-  }
-  function setBy(obj, _path, updater) {
-    const path = makePathArray(_path);
-
-    function doSet(parent) {
-      if (!path.length) {
-        return functionalUpdate(updater, parent);
-      }
-
-      const key = path.shift();
-
-      if (typeof key === 'string') {
-        if (typeof parent === 'object') {
-          return { ...parent,
-            [key]: doSet(parent[key])
-          };
-        }
-
-        return {
-          [key]: doSet()
-        };
-      }
-
-      if (typeof key === 'number') {
-        if (Array.isArray(parent)) {
-          const prefix = parent.slice(0, key);
-          return [...(prefix.length ? prefix : new Array(key)), doSet(parent[key]), ...parent.slice(key + 1)];
-        }
-
-        return [...new Array(key), doSet()];
-      }
-
-      throw new Error('Uh oh!');
-    }
-
-    return doSet(obj);
-  }
-  const reFindNumbers0 = /^(\d*)$/gm;
-  const reFindNumbers1 = /\.(\d*)\./gm;
-  const reFindNumbers2 = /^(\d*)\./gm;
-  const reFindNumbers3 = /\.(\d*$)/gm;
-  const reFindMultiplePeriods = /\.{2,}/gm;
-  const intPrefix = '__int__';
-  const intReplace = intPrefix + "$1";
-
-  function makePathArray(str) {
-    if (typeof str !== 'string') {
-      throw new Error();
-    }
-
-    return str.replace('[', '.').replace(']', '').replace(reFindNumbers0, intReplace).replace(reFindNumbers1, "." + intReplace + ".").replace(reFindNumbers2, intReplace + ".").replace(reFindNumbers3, "." + intReplace).replace(reFindMultiplePeriods, '.').split('.').map(d => {
-      if (d.indexOf(intPrefix) === 0) {
-        return parseInt(d.substring(intPrefix.length), 10);
-      }
-
-      return d;
-    });
-  }
-
-  function getDefaultFormState(defaultState) {
-    return {
-      values: {},
-      fieldMeta: {},
-      canSubmit: true,
-      isFieldsValid: false,
-      isFieldsValidating: false,
-      isFormValid: false,
-      isFormValidating: false,
-      isSubmitted: false,
-      isSubmitting: false,
-      isTouched: false,
-      isValid: false,
-      isValidating: false,
-      submissionAttempts: 0,
-      formValidationCount: 0,
-      ...defaultState
-    };
-  }
-
-  class FormApi {
-    // // This carries the context for nested fields
-    constructor(_opts) {
-      var _opts$defaultValues, _opts$defaultState;
-
-      this.options = {};
-      this.fieldInfo = {};
-      this.validationMeta = {};
-
-      this.update = options => {
-        if (!options) return;
-        this.store.batch(() => {
-          if (options.defaultState && options.defaultState !== this.options.defaultState) {
-            this.store.setState(prev => ({ ...prev,
-              ...options.defaultState
-            }));
-          }
-
-          if (options.defaultValues !== this.options.defaultValues) {
-            this.store.setState(prev => ({ ...prev,
-              values: options.defaultValues
-            }));
-          }
-        });
-        this.options = options;
-      };
-
-      this.reset = () => this.store.setState(() => getDefaultFormState(this.options.defaultValues));
-
-      this.validateAllFields = async () => {
-        const fieldValidationPromises = [];
-        this.store.batch(() => {
-          void Object.values(this.fieldInfo).forEach(field => {
-            Object.values(field.instances).forEach(instance => {
-              // If any fields are not touched
-              if (!instance.state.meta.isTouched) {
-                // Mark them as touched
-                instance.setMeta(prev => ({ ...prev,
-                  isTouched: true
-                })); // Validate the field
-
-                if (instance.options.validate) {
-                  fieldValidationPromises.push(instance.validate());
-                }
-              }
-            });
-          });
-        });
-        return Promise.all(fieldValidationPromises);
-      };
-
-      this.validateForm = async () => {
-        const {
-          validate
-        } = this.options;
-
-        if (!validate) {
-          return;
-        } // Use the formValidationCount for all field instances to
-        // track freshness of the validation
-
-
-        this.store.setState(prev => ({ ...prev,
-          isValidating: true,
-          formValidationCount: prev.formValidationCount + 1
-        }));
-        const formValidationCount = this.state.formValidationCount;
-
-        const checkLatest = () => formValidationCount === this.state.formValidationCount;
-
-        if (!this.validationMeta.validationPromise) {
-          this.validationMeta.validationPromise = new Promise((resolve, reject) => {
-            this.validationMeta.validationResolve = resolve;
-            this.validationMeta.validationReject = reject;
-          });
-        }
-
-        const doValidation = async () => {
-          try {
-            const error = await validate(this.state.values, this);
-
-            if (checkLatest()) {
-              var _this$validationMeta$, _this$validationMeta;
-
-              this.store.setState(prev => ({ ...prev,
-                isValidating: false,
-                error: error ? typeof error === 'string' ? error : 'Invalid Form Values' : null
-              }));
-              (_this$validationMeta$ = (_this$validationMeta = this.validationMeta).validationResolve) == null ? void 0 : _this$validationMeta$.call(_this$validationMeta, error);
-            }
-          } catch (err) {
-            if (checkLatest()) {
-              var _this$validationMeta$2, _this$validationMeta2;
-
-              (_this$validationMeta$2 = (_this$validationMeta2 = this.validationMeta).validationReject) == null ? void 0 : _this$validationMeta$2.call(_this$validationMeta2, err);
-            }
-          } finally {
-            delete this.validationMeta.validationPromise;
-          }
-        };
-
-        doValidation();
-        return this.validationMeta.validationPromise;
-      };
-
-      this.handleSubmit = async e => {
-        e.preventDefault();
-        e.stopPropagation(); // Check to see that the form and all fields have been touched
-        // If they have not, touch them all and run validation
-        // Run form validation
-        // Submit the form
-
-        this.store.setState(old => ({ ...old,
-          // Submittion attempts mark the form as not submitted
-          isSubmitted: false,
-          // Count submission attempts
-          submissionAttempts: old.submissionAttempts + 1
-        })); // Don't let invalid forms submit
-
-        if (!this.state.canSubmit) return;
-        this.store.setState(d => ({ ...d,
-          isSubmitting: true
-        }));
-
-        const done = () => {
-          this.store.setState(prev => ({ ...prev,
-            isSubmitting: false
-          }));
-        }; // Validate all fields
-
-
-        await this.validateAllFields(); // Fields are invalid, do not submit
-
-        if (!this.state.isFieldsValid) {
-          var _this$options$onInval, _this$options;
-
-          done();
-          (_this$options$onInval = (_this$options = this.options).onInvalidSubmit) == null ? void 0 : _this$options$onInval.call(_this$options, this.state.values, this);
-          return;
-        } // Run validation for the form
-
-
-        await this.validateForm();
-
-        if (!this.state.isValid) {
-          var _this$options$onInval2, _this$options2;
-
-          done();
-          (_this$options$onInval2 = (_this$options2 = this.options).onInvalidSubmit) == null ? void 0 : _this$options$onInval2.call(_this$options2, this.state.values, this);
-          return;
-        }
-
-        try {
-          var _this$options$onSubmi, _this$options3;
-
-          // Run the submit code
-          await ((_this$options$onSubmi = (_this$options3 = this.options).onSubmit) == null ? void 0 : _this$options$onSubmi.call(_this$options3, this.state.values, this));
-          this.store.batch(() => {
-            this.store.setState(prev => ({ ...prev,
-              isSubmitted: true
-            }));
-            done();
-          });
-        } catch (err) {
-          done();
-          throw err;
-        }
-      };
-
-      this.getFieldValue = field => getBy(this.state.values, field);
-
-      this.getFieldMeta = field => {
-        return this.state.fieldMeta[field];
-      };
-
-      this.getFieldInfo = field => {
-        var _this$fieldInfo;
-
-        return (_this$fieldInfo = this.fieldInfo)[field] || (_this$fieldInfo[field] = {
-          instances: {}
-        });
-      };
-
-      this.setFieldMeta = (field, updater) => {
-        this.store.setState(prev => {
-          return { ...prev,
-            fieldMeta: { ...prev.fieldMeta,
-              [field]: functionalUpdate(updater, prev.fieldMeta[field])
-            }
-          };
-        });
-      };
-
-      this.setFieldValue = (field, updater, opts) => {
-        var _opts$touch;
-
-        const touch = (_opts$touch = opts == null ? void 0 : opts.touch) != null ? _opts$touch : true;
-        this.store.batch(() => {
-          this.store.setState(prev => {
-            return { ...prev,
-              values: setBy(prev.values, field, updater)
-            };
-          });
-
-          if (touch) {
-            this.setFieldMeta(field, prev => ({ ...prev,
-              isTouched: true
-            }));
-          }
-        });
-      };
-
-      this.pushFieldValue = (field, value, opts) => {
-        return this.setFieldValue(field, prev => [...(Array.isArray(prev) ? prev : []), value], opts);
-      };
-
-      this.insertFieldValue = (field, index, value, opts) => {
-        this.setFieldValue(field, prev => {
-          // invariant( // TODO: bring in invariant
-          //   Array.isArray(prev),
-          //   `Cannot insert a field value into a non-array field. Check that this field's existing value is an array: ${field}.`
-          // )
-          return prev.map((d, i) => i === index ? value : d);
-        }, opts);
-      };
-
-      this.removeFieldValue = (field, index, opts) => {
-        this.setFieldValue(field, prev => {
-          // invariant( // TODO: bring in invariant
-          //   Array.isArray(prev),
-          //   `Cannot insert a field value into a non-array field. Check that this field's existing value is an array: ${field}.`
-          // )
-          return prev.filter((_d, i) => i !== index);
-        }, opts);
-      };
-
-      this.swapFieldValues = (field, index1, index2) => {
-        this.setFieldValue(field, prev => {
-          const prev1 = prev[index1];
-          const prev2 = prev[index2];
-          return setBy(setBy(prev, [index1], prev2), [index2], prev1);
-        });
-      };
-
-      this.store = new Store(getDefaultFormState({ ...(_opts == null ? void 0 : _opts.defaultState),
-        values: (_opts$defaultValues = _opts == null ? void 0 : _opts.defaultValues) != null ? _opts$defaultValues : _opts == null ? void 0 : (_opts$defaultState = _opts.defaultState) == null ? void 0 : _opts$defaultState.values,
-        isFormValid: !(_opts != null && _opts.validate)
-      }), {
-        onUpdate: next => {
-          // Computed state
-          const fieldMetaValues = Object.values(next.fieldMeta);
-          const isFieldsValidating = fieldMetaValues.some(field => field == null ? void 0 : field.isValidating);
-          const isFieldsValid = !fieldMetaValues.some(field => field == null ? void 0 : field.error);
-          const isTouched = fieldMetaValues.some(field => field == null ? void 0 : field.isTouched);
-          const isValidating = isFieldsValidating || next.isFormValidating;
-          const isFormValid = !next.formError;
-          const isValid = isFieldsValid && isFormValid;
-          const canSubmit = next.submissionAttempts === 0 && !isTouched || !isValidating && !next.isSubmitting && isValid;
-          next = { ...next,
-            isFieldsValidating,
-            isFieldsValid,
-            isFormValid,
-            isValid,
-            canSubmit,
-            isTouched
-          }; // Create a shortcut for the state
-          // Write it back to the store
-
-          this.store.state = next;
-          this.state = next;
-        }
-      });
-      this.state = this.store.state;
-      this.update(_opts || {});
-    }
-
-  }
-
-  var id = 0;
-
-  function _classPrivateFieldLooseKey(name) {
-    return "__private_" + id++ + "_" + name;
-  }
-
-  function _classPrivateFieldLooseBase(receiver, privateKey) {
-    if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
-      throw new TypeError("attempted to use private field on non-instance");
-    }
-
-    return receiver;
-  }
-
-  let uid = 0;
-
-  var _updateStore = /*#__PURE__*/_classPrivateFieldLooseKey("updateStore");
-
-  var _leaseValidateAsync = /*#__PURE__*/_classPrivateFieldLooseKey("leaseValidateAsync");
-
-  class FieldApi {
-    constructor(_opts) {
-      var _this$getMeta;
-
-      this.options = {};
-
-      this.mount = () => {
-        const info = this.getInfo();
-        info.instances[this.uid] = this;
-        const unsubscribe = this.form.store.subscribe(() => {
-          _classPrivateFieldLooseBase(this, _updateStore)[_updateStore]();
-        });
-        return () => {
-          unsubscribe();
-          delete info.instances[this.uid];
-
-          if (!Object.keys(info.instances).length) {
-            delete this.form.fieldInfo[this.name];
-          }
-        };
-      };
-
-      Object.defineProperty(this, _updateStore, {
-        writable: true,
-        value: () => {
-          this.store.batch(() => {
-            const nextValue = this.getValue();
-            const nextMeta = this.getMeta();
-
-            if (nextValue !== this.state.value) {
-              this.store.setState(prev => ({ ...prev,
-                value: nextValue
-              }));
-            }
-
-            if (nextMeta !== this.state.meta) {
-              this.store.setState(prev => ({ ...prev,
-                meta: nextMeta
-              }));
-            }
-          });
-        }
-      });
-
-      this.update = opts => {
-        var _this$form$options$de, _this$form$options$de2, _this$form$options$de3, _this$form$options$de4;
-
-        this.options = {
-          validatePristine: (_this$form$options$de = this.form.options.defaultValidatePristine) != null ? _this$form$options$de : false,
-          validateOn: (_this$form$options$de2 = this.form.options.defaultValidateOn) != null ? _this$form$options$de2 : 'change',
-          validateAsyncOn: (_this$form$options$de3 = this.form.options.defaultValidateAsyncOn) != null ? _this$form$options$de3 : 'blur',
-          validateAsyncDebounceMs: (_this$form$options$de4 = this.form.options.defaultValidateAsyncDebounceMs) != null ? _this$form$options$de4 : 0,
-          ...opts
-        }; // Default Value
-
-        if (this.state.value === undefined && this.options.defaultValue !== undefined) {
-          this.setValue(this.options.defaultValue);
-        } // Default Meta
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-
-
-        if (this.getMeta() === undefined) {
-          this.setMeta(this.state.meta);
-        }
-      };
-
-      this.getValue = () => {
-        return this.form.getFieldValue(this.name);
-      };
-
-      this.setValue = (updater, options) => this.form.setFieldValue(this.name, updater, options);
-
-      this.getMeta = () => this.form.getFieldMeta(this.name);
-
-      this.setMeta = updater => this.form.setFieldMeta(this.name, updater);
-
-      this.getInfo = () => this.form.getFieldInfo(this.name);
-
-      this.pushValue = value => this.form.pushFieldValue(this.name, value);
-
-      this.insertValue = (index, value) => this.form.insertFieldValue(this.name, index, value);
-
-      this.removeValue = index => this.form.removeFieldValue(this.name, index);
-
-      this.swapValues = (aIndex, bIndex) => this.form.swapFieldValues(this.name, aIndex, bIndex);
-
-      this.getSubField = name => new FieldApi({
-        name: this.name + "." + name,
-        form: this.form
-      });
-
-      this.validateSync = async (value = this.state.value) => {
-        const {
-          validate
-        } = this.options;
-
-        if (!validate) {
-          return;
-        } // Use the validationCount for all field instances to
-        // track freshness of the validation
-
-
-        const validationCount = (this.getInfo().validationCount || 0) + 1;
-        this.getInfo().validationCount = validationCount;
-        const error = normalizeError(validate(value, this));
-
-        if (this.state.meta.error !== error) {
-          this.setMeta(prev => ({ ...prev,
-            error
-          }));
-        } // If a sync error is encountered, cancel any async validation
-
-
-        if (this.state.meta.error) {
-          this.cancelValidateAsync();
-        }
-      };
-
-      Object.defineProperty(this, _leaseValidateAsync, {
-        writable: true,
-        value: () => {
-          const count = (this.getInfo().validationAsyncCount || 0) + 1;
-          this.getInfo().validationAsyncCount = count;
-          return count;
-        }
-      });
-
-      this.cancelValidateAsync = () => {
-        // Lease a new validation count to ignore any pending validations
-        _classPrivateFieldLooseBase(this, _leaseValidateAsync)[_leaseValidateAsync](); // Cancel any pending validation state
-
-
-        this.setMeta(prev => ({ ...prev,
-          isValidating: false
-        }));
-      };
-
-      this.validateAsync = async (value = this.state.value) => {
-        const {
-          validateAsync,
-          validateAsyncDebounceMs
-        } = this.options;
-
-        if (!validateAsync) {
-          return;
-        }
-
-        if (this.state.meta.isValidating !== true) this.setMeta(prev => ({ ...prev,
-          isValidating: true
-        })); // Use the validationCount for all field instances to
-        // track freshness of the validation
-
-        const validationAsyncCount = _classPrivateFieldLooseBase(this, _leaseValidateAsync)[_leaseValidateAsync]();
-
-        const checkLatest = () => validationAsyncCount === this.getInfo().validationAsyncCount;
-
-        if (!this.getInfo().validationPromise) {
-          this.getInfo().validationPromise = new Promise((resolve, reject) => {
-            this.getInfo().validationResolve = resolve;
-            this.getInfo().validationReject = reject;
-          });
-        }
-
-        if (validateAsyncDebounceMs > 0) {
-          await new Promise(r => setTimeout(r, validateAsyncDebounceMs));
-        } // Only kick off validation if this validation is the latest attempt
-
-
-        if (checkLatest()) {
-          try {
-            const rawError = await validateAsync(value, this);
-
-            if (checkLatest()) {
-              var _this$getInfo$validat, _this$getInfo;
-
-              const error = normalizeError(rawError);
-              this.setMeta(prev => ({ ...prev,
-                isValidating: false,
-                error
-              }));
-              (_this$getInfo$validat = (_this$getInfo = this.getInfo()).validationResolve) == null ? void 0 : _this$getInfo$validat.call(_this$getInfo, error);
-            }
-          } catch (error) {
-            if (checkLatest()) {
-              var _this$getInfo$validat2, _this$getInfo2;
-
-              (_this$getInfo$validat2 = (_this$getInfo2 = this.getInfo()).validationReject) == null ? void 0 : _this$getInfo$validat2.call(_this$getInfo2, error);
-              throw error;
-            }
-          } finally {
-            if (checkLatest()) {
-              this.setMeta(prev => ({ ...prev,
-                isValidating: false
-              }));
-              delete this.getInfo().validationPromise;
-            }
-          }
-        } // Always return the latest validation promise to the caller
-
-
-        return this.getInfo().validationPromise;
-      };
-
-      this.shouldValidate = (isAsync, cause) => {
-        const {
-          validateOn,
-          validateAsyncOn
-        } = this.options;
-        const level = getValidationCauseLevel(cause); // Must meet *at least* the validation level to validate,
-        // e.g. if validateOn is 'change' and validateCause is 'blur',
-        // the field will still validate
-
-        return Object.keys(validateCauseLevels).some(d => isAsync ? validateAsyncOn : validateOn === d && level >= validateCauseLevels[d]);
-      };
-
-      this.validate = async (cause, value) => {
-        // If the field is pristine and validatePristine is false, do not validate
-        if (!this.options.validatePristine && !this.state.meta.isTouched) return; // Attempt to sync validate first
-
-        if (this.shouldValidate(false, cause)) {
-          this.validateSync(value);
-        } // If there is an error, return it, do not attempt async validation
-
-
-        if (this.state.meta.error) {
-          return this.state.meta.error;
-        } // No error? Attempt async validation
-
-
-        if (this.shouldValidate(true, cause)) {
-          return this.validateAsync(value);
-        } // If there is no sync error or async validation attempt, there is no error
-
-
-        return undefined;
-      };
-
-      this.getChangeProps = (props = {}) => {
-        return { ...props,
-          value: this.state.value,
-          onChange: value => {
-            this.setValue(value);
-            props.onChange == null ? void 0 : props.onChange(value);
-          },
-          onBlur: e => {
-            this.setMeta(prev => ({ ...prev,
-              isTouched: true
-            }));
-            this.validate('blur');
-            props.onBlur == null ? void 0 : props.onBlur(e);
-          }
-        };
-      };
-
-      this.getInputProps = (props = {}) => {
-        return { ...props,
-          value: String(this.state.value),
-          onChange: e => {
-            this.setValue(e.target.value);
-            props.onChange == null ? void 0 : props.onChange(e.target.value);
-          },
-          onBlur: this.getChangeProps(props).onBlur
-        };
-      };
-
-      this.form = _opts.form;
-      this.uid = uid++; // Support field prefixing from FieldScope
-      // let fieldPrefix = ''
-      // if (this.form.fieldName) {
-      //   fieldPrefix = `${this.form.fieldName}.`
-      // }
-
-      this.name = _opts.name;
-      this.store = new Store({
-        value: this.getValue(),
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        meta: (_this$getMeta = this.getMeta()) != null ? _this$getMeta : {
-          isValidating: false,
-          isTouched: false,
-          ...this.options.defaultMeta
-        }
-      }, {
-        onUpdate: next => {
-          next.meta.touchedError = next.meta.isTouched ? next.meta.error : undefined; // Do not validate pristine fields
-
-          const prevState = this.state;
-          this.state = next;
-
-          if (next.value !== prevState.value) {
-            this.validate('change', next.value);
-          }
-        }
-      });
-      this.state = this.store.state;
-      this.update(_opts);
-    }
-
-  }
-  const validateCauseLevels = {
-    change: 0,
-    blur: 1,
-    submit: 2
-  };
-
-  function getValidationCauseLevel(cause) {
-    return !cause ? 3 : validateCauseLevels[cause];
-  }
-
-  function normalizeError(rawError) {
-    if (rawError) {
-      if (typeof rawError !== 'string') {
-        return 'Invalid Form Values';
-      }
-
-      return rawError;
-    }
-
-    return undefined;
-  }
-
-  exports.FieldApi = FieldApi;
-  exports.FormApi = FormApi;
-  exports.functionalUpdate = functionalUpdate;
-  exports.getBy = getBy;
-  exports.setBy = setBy;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-}));
-//# sourceMappingURL=index.development.js.map