@radicalbit/formbit 1.0.0

package/dist/index.modern.js

@@ -0,0 +1,654 @@
+import React, { useRef, useEffect, useCallback, useState, createContext, useContext } from 'react';
+import { isEmpty, set, cloneDeep, omit, get, once } from 'lodash';
+import { object } from 'yup';
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+
+  return target;
+}
+
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+
+  return arr2;
+}
+
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it;
+
+  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+      return function () {
+        if (i >= o.length) return {
+          done: true
+        };
+        return {
+          done: false,
+          value: o[i++]
+        };
+      };
+    }
+
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+
+  it = o[Symbol.iterator]();
+  return it.next.bind(it);
+}
+
+function isObject(val) {
+  return val != null && typeof val === 'object' && Array.isArray(val) === false;
+}
+
+var objLeaves = function objLeaves(obj, acc) {
+  if (acc === void 0) {
+    acc = [];
+  }
+
+  var fn = function fn(o, s) {
+    if (Array.isArray(o)) {
+      return Object.keys(o).forEach(function (k) {
+        var path = s ? s + "[" + k + "]" : k;
+        var isLeaf = fn(o[+k], path) === false;
+
+        if (isLeaf) {
+          acc.push(path);
+        }
+      });
+    }
+
+    if (isObject(o)) {
+      return Object.keys(o).forEach(function (k) {
+        var path = s ? s + "." + k : k;
+        var isLeaf = fn(o[k], path) === false;
+
+        if (isLeaf) {
+          acc.push(path);
+        }
+      });
+    }
+
+    return false;
+  };
+
+  fn(obj);
+  return acc;
+};
+
+var ACTIONS;
+
+(function (ACTIONS) {
+  ACTIONS["write"] = "write";
+  ACTIONS["remove"] = "remove";
+})(ACTIONS || (ACTIONS = {}));
+
+var MISSING_CONTEXT_ERROR = 'No FormbitContext.Provider found, useFormbitContext can only be called inside proper context';
+
+var isValidationError = function isValidationError(error) {
+  if (error && typeof error === 'object' && 'message' in error && 'path' in error && 'inner' in error) {
+    var path = error.path,
+        message = error.message,
+        inner = error.inner;
+    return (typeof path === 'string' || path === undefined) && (typeof message === 'string' || path === undefined) && Array.isArray(inner);
+  }
+
+  return false;
+};
+
+var validateSyncAll = function validateSyncAll(paths, schema, form, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  var errors = [];
+
+  if (isEmpty(paths)) {
+    return errors;
+  }
+
+  for (var _iterator = _createForOfIteratorHelperLoose(paths), _step; !(_step = _iterator()).done;) {
+    var pathToValidate = _step.value;
+
+    try {
+      schema.validateSyncAt(pathToValidate, form, options);
+    } catch (e) {
+      var _options;
+
+      if (isValidationError(e)) {
+        var message = e.message,
+            path = e.path;
+        errors = errors.concat({
+          message: message,
+          path: path
+        });
+      }
+
+      if ((_options = options) !== null && _options !== void 0 && _options.abortEarly) {
+        break;
+      }
+    }
+  }
+
+  return errors;
+};
+
+var useExecuteCallbacks = (function (writer, setError) {
+  var callbacksStore = useRef([]);
+  useEffect(function () {
+    if (callbacksStore.current.length) {
+      callbacksStore.current.forEach(function (cb) {
+        if (cb) {
+          cb(writer, setError);
+        }
+      });
+      callbacksStore.current = [];
+    }
+  }, [setError, writer]);
+  return useCallback(function (cb) {
+    if (cb) {
+      callbacksStore.current.push(cb);
+    }
+  }, []);
+});
+
+var useFormbit = (function (_ref) {
+  var _ref$initialValues = _ref.initialValues,
+      initialValues = _ref$initialValues === void 0 ? {} : _ref$initialValues,
+      schema = _ref.yup;
+  var schemaRef = useRef(schema);
+
+  var _useState = useState({
+    form: initialValues,
+    initialValues: initialValues,
+    errors: {},
+    liveValidation: {},
+    isDirty: false
+  }),
+      writer = _useState[0],
+      setWriter = _useState[1];
+
+  var initialize = useCallback(function (values) {
+    setWriter(function (w) {
+      return _extends({}, w, {
+        initialValues: values,
+        form: values,
+        errors: {},
+        liveValidation: {},
+        isDirty: false
+      });
+    });
+  }, []);
+  var setSchema = useCallback(function (newSchema) {
+    schemaRef.current = newSchema;
+  }, []);
+  var setError = useCallback(function (path, value) {
+    setWriter(function (w) {
+      var errors = set(cloneDeep(w.errors), path, value);
+      return _extends({}, w, {
+        errors: errors
+      });
+    });
+  }, []);
+  var executeCb = useExecuteCallbacks(writer, setError);
+  var writeOrRemove = useCallback(function (path, value, _temp, action) {
+    var _ref2 = _temp === void 0 ? {} : _temp,
+        _ref2$noLiveValidatio = _ref2.noLiveValidation,
+        noLiveValidation = _ref2$noLiveValidatio === void 0 ? false : _ref2$noLiveValidatio,
+        _ref2$pathsToValidate = _ref2.pathsToValidate,
+        pathsToValidate = _ref2$pathsToValidate === void 0 ? [] : _ref2$pathsToValidate,
+        successCallback = _ref2.successCallback,
+        errorCallback = _ref2.errorCallback,
+        _ref2$options = _ref2.options,
+        options = _ref2$options === void 0 ? {} : _ref2$options;
+
+    setWriter(function (w) {
+      var liveValidationPaths = noLiveValidation ? [] : Object.keys(w.liveValidation);
+      var paths = pathsToValidate.concat(liveValidationPaths);
+
+      var form = function execute() {
+        switch (action) {
+          case ACTIONS.write:
+            return set(cloneDeep(w.form), path, value);
+
+          case ACTIONS.remove:
+            return omit(cloneDeep(w.form), path);
+
+          default:
+            return cloneDeep(w.form);
+        }
+      }();
+
+      var newWriter = _extends({}, w, {
+        form: form,
+        isDirty: true
+      });
+
+      if (paths.length === 0) {
+        executeCb(successCallback);
+        return newWriter;
+      }
+
+      var cleanErrors = paths.reduce(function (acc, key) {
+        return set(acc, key, undefined);
+      }, cloneDeep(newWriter.errors));
+      var inner = validateSyncAll(paths, schemaRef.current, newWriter.form, options);
+
+      if (isEmpty(inner)) {
+        var _neww = _extends({}, newWriter, {
+          errors: cleanErrors
+        });
+
+        executeCb(successCallback);
+        return _neww;
+      }
+
+      var errors = inner.reduce(function (acc, _ref3) {
+        var innerPath = _ref3.path,
+            message = _ref3.message;
+        return innerPath ? set(acc, innerPath, message) : acc;
+      }, cleanErrors);
+      var liveValidation = inner.reduce(function (acc, _ref4) {
+        var _extends2;
+
+        var innerPath = _ref4.path;
+        return innerPath ? _extends({}, acc, (_extends2 = {}, _extends2[innerPath] = true, _extends2)) : acc;
+      }, newWriter.liveValidation);
+
+      var neww = _extends({}, newWriter, {
+        errors: errors,
+        liveValidation: liveValidation
+      });
+
+      executeCb(errorCallback);
+      return neww;
+    });
+  }, [executeCb]);
+  var write = useCallback(function (path, value, options) {
+    return writeOrRemove(path, value, options, ACTIONS.write);
+  }, [writeOrRemove]);
+  var remove = useCallback(function (path, options) {
+    return writeOrRemove(path, undefined, options, ACTIONS.remove);
+  }, [writeOrRemove]);
+  var writeAll = useCallback(function (arr, _temp2) {
+    var _ref5 = _temp2 === void 0 ? {} : _temp2,
+        _ref5$noLiveValidatio = _ref5.noLiveValidation,
+        noLiveValidation = _ref5$noLiveValidatio === void 0 ? false : _ref5$noLiveValidatio,
+        _ref5$pathsToValidate = _ref5.pathsToValidate,
+        pathsToValidate = _ref5$pathsToValidate === void 0 ? [] : _ref5$pathsToValidate,
+        successCallback = _ref5.successCallback,
+        errorCallback = _ref5.errorCallback,
+        _ref5$options = _ref5.options,
+        options = _ref5$options === void 0 ? {} : _ref5$options;
+
+    setWriter(function (w) {
+      var liveValidationPaths = noLiveValidation ? [] : Object.keys(w.liveValidation);
+      var paths = pathsToValidate.concat(liveValidationPaths);
+      var form = arr.reduce(function (acc, _ref6) {
+        var key = _ref6[0],
+            val = _ref6[1];
+        return set(acc, key, val);
+      }, cloneDeep(w.form));
+
+      var newWriter = _extends({}, w, {
+        form: form,
+        isDirty: true
+      });
+
+      if (paths.length === 0) {
+        executeCb(successCallback);
+        return newWriter;
+      }
+
+      var cleanErrors = paths.reduce(function (acc, key) {
+        return set(acc, key, undefined);
+      }, cloneDeep(newWriter.errors));
+      var inner = validateSyncAll(paths, schemaRef.current, newWriter.form, options);
+
+      if (isEmpty(inner)) {
+        var _neww2 = _extends({}, newWriter, {
+          errors: cleanErrors
+        });
+
+        executeCb(successCallback);
+        return _neww2;
+      }
+
+      var errors = inner.reduce(function (acc, _ref7) {
+        var _ref7$path = _ref7.path,
+            path = _ref7$path === void 0 ? '' : _ref7$path,
+            message = _ref7.message;
+        return set(acc, path, message);
+      }, cleanErrors);
+      var liveValidation = inner.reduce(function (acc, _ref8) {
+        var _extends3;
+
+        var _ref8$path = _ref8.path,
+            path = _ref8$path === void 0 ? '' : _ref8$path;
+        return _extends({}, acc, (_extends3 = {}, _extends3[path] = true, _extends3));
+      }, newWriter.liveValidation);
+
+      var neww = _extends({}, newWriter, {
+        errors: errors,
+        liveValidation: liveValidation
+      });
+
+      executeCb(errorCallback);
+      return neww;
+    });
+  }, [executeCb]);
+  var validate = useCallback(function (path, _temp3) {
+    var _ref9 = _temp3 === void 0 ? {} : _temp3,
+        successCallback = _ref9.successCallback,
+        errorCallback = _ref9.errorCallback,
+        options = _ref9.options;
+
+    setWriter(function (w) {
+      var cleanErrors = set(cloneDeep(w.errors), path, undefined);
+      var inner = validateSyncAll([path], schemaRef.current, w.form, options);
+
+      if (isEmpty(inner)) {
+        var _neww3 = _extends({}, w, {
+          errors: cleanErrors
+        });
+
+        executeCb(successCallback);
+        return _neww3;
+      }
+
+      var errors = inner.reduce(function (acc, _ref10) {
+        var _ref10$path = _ref10.path,
+            errorPath = _ref10$path === void 0 ? '' : _ref10$path,
+            message = _ref10.message;
+        return set(acc, errorPath, message);
+      }, cleanErrors);
+      var liveValidation = inner.reduce(function (acc, _ref11) {
+        var _extends4;
+
+        var _ref11$path = _ref11.path,
+            errorPath = _ref11$path === void 0 ? '' : _ref11$path;
+        return _extends({}, acc, (_extends4 = {}, _extends4[errorPath] = true, _extends4));
+      }, w.liveValidation);
+
+      var neww = _extends({}, w, {
+        errors: errors,
+        liveValidation: liveValidation
+      });
+
+      executeCb(errorCallback);
+      return neww;
+    });
+  }, [executeCb]);
+  var validateAll = useCallback(function (paths, _temp4) {
+    var _ref12 = _temp4 === void 0 ? {} : _temp4,
+        successCallback = _ref12.successCallback,
+        errorCallback = _ref12.errorCallback,
+        options = _ref12.options;
+
+    setWriter(function (w) {
+      var cleanErrors = paths.reduce(function (acc, path) {
+        return set(acc, path, undefined);
+      }, cloneDeep(w.errors));
+      var inner = validateSyncAll(paths, schemaRef.current, w.form, options);
+
+      if (isEmpty(inner)) {
+        var _neww4 = _extends({}, w, {
+          errors: cleanErrors
+        });
+
+        executeCb(successCallback);
+        return _neww4;
+      }
+
+      var errors = inner.reduce(function (acc, _ref13) {
+        var _ref13$path = _ref13.path,
+            path = _ref13$path === void 0 ? '' : _ref13$path,
+            message = _ref13.message;
+        return set(acc, path, message);
+      }, cleanErrors);
+      var liveValidation = inner.reduce(function (acc, _ref14) {
+        var _extends5;
+
+        var _ref14$path = _ref14.path,
+            path = _ref14$path === void 0 ? '' : _ref14$path;
+        return _extends({}, acc, (_extends5 = {}, _extends5[path] = true, _extends5));
+      }, w.liveValidation);
+
+      var neww = _extends({}, w, {
+        errors: errors,
+        liveValidation: liveValidation
+      });
+
+      executeCb(errorCallback);
+      return neww;
+    });
+  }, [executeCb]);
+  var check = useCallback(function (json, _temp5) {
+    var _ref15 = _temp5 === void 0 ? {} : _temp5,
+        successCallback = _ref15.successCallback,
+        errorCallback = _ref15.errorCallback,
+        options = _ref15.options;
+
+    try {
+      schema.validateSync(json, _extends({
+        abortEarly: false
+      }, options));
+      successCallback === null || successCallback === void 0 ? void 0 : successCallback(json, writer, setError);
+      return undefined;
+    } catch (e) {
+      if (isValidationError(e)) {
+        var inner = e.inner;
+        errorCallback === null || errorCallback === void 0 ? void 0 : errorCallback(json, inner, writer, setError);
+        return inner;
+      }
+
+      return undefined;
+    }
+  }, [schema, setError, writer]);
+  var privateValidateForm = useCallback(function (successCallback, errorCallback, _temp6) {
+    var _ref16 = _temp6 === void 0 ? {} : _temp6,
+        options = _ref16.options;
+
+    setWriter(function (w) {
+      try {
+        schemaRef.current.validateSync(w.form, _extends({
+          abortEarly: false
+        }, options));
+        executeCb(successCallback);
+        return _extends({}, w, {
+          errors: {}
+        });
+      } catch (e) {
+        if (!isValidationError(e)) {
+          console.error(e);
+          return w;
+        }
+
+        var inner = e.inner;
+        var errors = inner.reduce(function (acc, _ref17) {
+          var message = _ref17.message,
+              _ref17$path = _ref17.path,
+              path = _ref17$path === void 0 ? '' : _ref17$path;
+          return set(acc, path, message);
+        }, {});
+
+        var _liveValidation = inner.reduce(function (acc, _ref18) {
+          var _extends6;
+
+          var _ref18$path = _ref18.path,
+              path = _ref18$path === void 0 ? '' : _ref18$path;
+          return _extends({}, acc, (_extends6 = {}, _extends6[path] = true, _extends6));
+        }, w.liveValidation);
+
+        var newWriter = _extends({}, w, {
+          errors: errors,
+          liveValidation: _liveValidation
+        });
+
+        executeCb(errorCallback);
+        return newWriter;
+      }
+    });
+  }, [executeCb]);
+  var validateForm = useCallback(function (successCallback, errorCallback, options) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    return privateValidateForm(successCallback, errorCallback, {
+      options: options
+    });
+  }, [privateValidateForm]);
+  var submitForm = useCallback(function (successCallback, errorCallback, options) {
+    if (options === void 0) {
+      options = {};
+    }
+
+    var fn = function fn() {
+      return setWriter(function (w) {
+        return _extends({}, w, {
+          isDirty: false
+        });
+      });
+    };
+
+    var successCallbackAndClearIsDirty = function successCallbackAndClearIsDirty(a, b) {
+      var writer = a;
+
+      var _writer$form = writer.form,
+          form = _objectWithoutPropertiesLoose(_writer$form, ["__metadata"]);
+
+      return successCallback(_extends({}, writer, {
+        form: form
+      }), b, fn);
+    };
+
+    return privateValidateForm(successCallbackAndClearIsDirty, errorCallback, {
+      options: options
+    });
+  }, [privateValidateForm]);
+  var resetForm = useCallback(function () {
+    setWriter(function (w) {
+      return _extends({}, w, {
+        form: w.initialValues,
+        errors: {},
+        isDirty: false,
+        liveValidation: {}
+      });
+    });
+  }, []);
+  var isFormValid = useCallback(function () {
+    var _writer$errors = writer.errors,
+        e = _objectWithoutPropertiesLoose(_writer$errors, ["silent"]);
+
+    return objLeaves(e).every(function (leaf) {
+      return !get(e, leaf);
+    });
+  }, [writer.errors]);
+  var isFormInvalid = useCallback(function () {
+    var _writer$errors2 = writer.errors,
+        e = _objectWithoutPropertiesLoose(_writer$errors2, ["silent"]);
+
+    return objLeaves(e).some(function (leaf) {
+      return get(e, leaf);
+    });
+  }, [writer.errors]);
+  var error = useCallback(function (path) {
+    return get(writer.errors, path, undefined);
+  }, [writer.errors]);
+  var liveValidation = useCallback(function (path) {
+    return get(writer.liveValidation, path, undefined);
+  }, [writer.liveValidation]);
+  return {
+    check: check,
+    error: error,
+    errors: writer.errors,
+    form: writer.form,
+    initialize: initialize,
+    isDirty: writer.isDirty,
+    isFormInvalid: isFormInvalid,
+    isFormValid: isFormValid,
+    liveValidation: liveValidation,
+    remove: remove,
+    resetForm: resetForm,
+    setError: setError,
+    setSchema: setSchema,
+    submitForm: submitForm,
+    validate: validate,
+    validateAll: validateAll,
+    validateForm: validateForm,
+    write: write,
+    writeAll: writeAll
+  };
+});
+
+var createFormbitContext = once(function () {
+  return createContext(undefined);
+});
+function FormbitContextProvider(_ref) {
+  var _ref$initialValues = _ref.initialValues,
+      initialValues = _ref$initialValues === void 0 ? {} : _ref$initialValues,
+      schema = _ref.schema,
+      children = _ref.children;
+  var FormbitContext = createFormbitContext();
+  var value = useFormbit({
+    initialValues: initialValues,
+    yup: schema || object()
+  });
+  return /*#__PURE__*/React.createElement(FormbitContext.Provider, {
+    value: value
+  }, children);
+}
+var useFormbitContext = function useFormbitContext() {
+  var context = useContext(createFormbitContext());
+
+  if (!context) {
+    throw new Error(MISSING_CONTEXT_ERROR);
+  }
+
+  return context;
+};
+
+export default useFormbit;
+export { FormbitContextProvider, useFormbitContext };
+//# sourceMappingURL=index.modern.js.map