doui-react 1.0.0

package/lib/form/hook/index.js

@@ -0,0 +1,163 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  useFormValueChange: true,
+  useValidateForm: true,
+  useValidateNotExistValue: true
+};
+exports.useFormValueChange = useFormValueChange;
+exports.useValidateForm = useValidateForm;
+exports.useValidateNotExistValue = useValidateNotExistValue;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/regeneratorRuntime"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _ = require("./..");
+var _formItemMap = require("../component/form-item-map");
+var _hooks = require("../../hooks");
+var _react = require("react");
+var _constant = require("../component/constant");
+var _utils = require("../component/utils");
+var _listProvider = require("./list-provider");
+Object.keys(_listProvider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _listProvider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _listProvider[key];
+    }
+  });
+});
+var _provider = require("./provider");
+Object.keys(_provider).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _provider[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _provider[key];
+    }
+  });
+});
+var _useForm = require("./use-form");
+Object.keys(_useForm).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useForm[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _useForm[key];
+    }
+  });
+});
+var _excluded = ["loading", "value", "options"];
+function useFormValueChange(fn) {
+  var deps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var _useFormContext = (0, _.useFormContext)(),
+    values = _useFormContext.values;
+  var _useSafeState = (0, _hooks.useSafeState)(),
+    _useSafeState2 = (0, _slicedToArray2.default)(_useSafeState, 2),
+    result = _useSafeState2[0],
+    setResult = _useSafeState2[1];
+  (0, _hooks.useDeepEffect)( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee() {
+    var res;
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return fn(values);
+        case 2:
+          res = _context.sent;
+          setResult(res);
+        case 4:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })), [values].concat((0, _toConsumableArray2.default)(deps)));
+  return result;
+}
+function useValidateForm() {
+  var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    onValidate = _ref2.onValidate,
+    validateOnly = _ref2.validateOnly;
+  var _useFormContext2 = (0, _.useFormContext)(),
+    loading = _useFormContext2.loading,
+    form = _useFormContext2.form,
+    items = _useFormContext2.items,
+    values = _useFormContext2.values;
+  var _useSafeState3 = (0, _hooks.useSafeState)(false),
+    _useSafeState4 = (0, _slicedToArray2.default)(_useSafeState3, 2),
+    result = _useSafeState4[0],
+    setResult = _useSafeState4[1];
+  var validate = /*#__PURE__*/function () {
+    var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee2() {
+      var _onValidate;
+      var isValid, customValidate, final;
+      return (0, _regeneratorRuntime2.default)().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!(loading || (0, _utils.hasItemLoading)(items))) {
+              _context2.next = 2;
+              break;
+            }
+            return _context2.abrupt("return");
+          case 2:
+            _context2.next = 4;
+            return form.callMethod(_constant.registerMethods.internalValidate);
+          case 4:
+            isValid = _context2.sent;
+            customValidate = (_onValidate = onValidate === null || onValidate === void 0 ? void 0 : onValidate(isValid, form)) !== null && _onValidate !== void 0 ? _onValidate : true;
+            final = customValidate && isValid;
+            if (!validateOnly) {
+              setResult(final);
+            }
+          case 8:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    }));
+    return function validate() {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+  var onChangeDebounce = (0, _hooks.useDebounce)(validate, 100, {
+    leading: false
+  });
+  (0, _react.useEffect)(function () {
+    onChangeDebounce();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [values, loading, items]);
+
+  // 供 form.setError 使用
+  form.registerMethod(_constant.registerMethods.triggerValidate, onChangeDebounce);
+  return result;
+}
+function useValidateNotExistValue(_ref4) {
+  var loading = _ref4.loading,
+    value = _ref4.value,
+    options = _ref4.options,
+    props = (0, _objectWithoutProperties2.default)(_ref4, _excluded);
+  var _useFormContext3 = (0, _.useFormContext)(),
+    formLoading = _useFormContext3.loading;
+  var _useCollectFormItemSt = (0, _formItemMap.useCollectFormItemState)(props),
+    __callback__ = _useCollectFormItemSt.__callback__;
+  var params = {
+    options: options,
+    value: value,
+    loading: formLoading || loading
+  };
+  (0, _hooks.useDeepEffect)(function () {
+    __callback__(params);
+  }, [params]);
+}

package/lib/form/hook/list-provider.d.ts

@@ -0,0 +1,6 @@
+import { FormListContext } from "..";
+import { ReactNode } from 'react';
+export declare function FormListProvider({ children, ...props }: FormListContext & {
+    children: ReactNode;
+}): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare function useFormListContext(): FormListContext;

package/lib/form/hook/list-provider.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FormListProvider = FormListProvider;
+exports.useFormListContext = useFormListContext;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _react = require("react");
+var _jsxRuntime = require("@emotion/react/jsx-runtime");
+var _excluded = ["children"];
+var FormListCtx = /*#__PURE__*/(0, _react.createContext)({});
+function FormListProvider(_ref) {
+  var children = _ref.children,
+    props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  return (0, _jsxRuntime.jsx)(FormListCtx.Provider, {
+    value: props,
+    children: children
+  });
+}
+function useFormListContext() {
+  return (0, _react.useContext)(FormListCtx);
+}

package/lib/form/hook/provider.d.ts

@@ -0,0 +1,23 @@
+import { FormInstance, FormItemContext, FormValues } from "..";
+import { ReactNode } from 'react';
+export interface RemoveCollectOptions {
+    isFormList?: boolean;
+    isTableEditor?: boolean;
+    onlyResetLoading?: boolean;
+}
+export interface FormContext {
+    loading: boolean;
+    disabled?: boolean;
+    form: FormInstance;
+    values: FormValues;
+    items: FormItemContext[];
+    debug?: boolean;
+    [key: string]: any;
+    __collect__(item: FormItemContext): void;
+    __removeCollect__(name: string, options?: RemoveCollectOptions): void;
+}
+export declare function FormProvider({ children, ...props }: FormContext & {
+    children: ReactNode;
+}): import("@emotion/react/jsx-runtime").JSX.Element;
+export declare function useFormContext<T>(): T & FormContext;
+export declare function useFormValue(): FormValues;

package/lib/form/hook/provider.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FormProvider = FormProvider;
+exports.useFormContext = useFormContext;
+exports.useFormValue = useFormValue;
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+var _react = require("react");
+var _jsxRuntime = require("@emotion/react/jsx-runtime");
+var _excluded = ["children"];
+var FormCtx = /*#__PURE__*/(0, _react.createContext)({});
+function FormProvider(_ref) {
+  var children = _ref.children,
+    props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
+  return (0, _jsxRuntime.jsx)(FormCtx.Provider, {
+    value: props,
+    children: children
+  });
+}
+function useFormContext() {
+  return (0, _react.useContext)(FormCtx);
+}
+function useFormValue() {
+  var _useFormContext = useFormContext(),
+    values = _useFormContext.values;
+  return values;
+}

package/lib/form/hook/use-form.d.ts

@@ -0,0 +1,2 @@
+import { FormInstance } from "..";
+export declare function useForm(): FormInstance;

package/lib/form/hook/use-form.js

@@ -0,0 +1,342 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useForm = useForm;
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/regeneratorRuntime"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _api = require("../../api");
+var _antd = require("antd");
+var _delay = _interopRequireDefault(require("delay"));
+var _lodash = _interopRequireDefault(require("lodash"));
+var _reactUse = require("react-use");
+var _constant = require("../component/constant");
+var _utils = require("../component/utils");
+var pathMap = {
+  initForm: '__INTERNAL__.initForm',
+  name: '__INTERNAL__.name',
+  items: '__INTERNAL__.items',
+  itemsStatus: '__INTERNAL__.itemsStatus',
+  loading: '__INTERNAL__.loading',
+  errors: '__INTERNAL__.errors',
+  methods: '__INTERNAL__.methods'
+};
+function useForm() {
+  var form = _antd.Form.useForm()[0];
+  var update = (0, _reactUse.useUpdate)();
+
+  // 防止重复初始化
+  if (_lodash.default.get(form, pathMap.initForm)) {
+    return form;
+  }
+  _lodash.default.set(form, pathMap.initForm, true);
+  var methods = [registerAndCallMethod, updateForm, setError, setValue, getValue, validate, reset, submit, getName, processFormItems, processFormItemsStatus, getFieldInstance, getFormList, focus];
+  methods.forEach(function (fn) {
+    return fn(form, update);
+  });
+  return form;
+}
+function registerAndCallMethod(form) {
+  var path = pathMap.methods;
+  form.registerMethod = function (name, fn) {
+    _lodash.default.set(form, "".concat(path, ".").concat(name), fn);
+  };
+  form.callMethod = function (name) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+    return _lodash.default.invoke.apply(_lodash.default, [form, "".concat(path, ".").concat(name)].concat(args));
+  };
+}
+function getValue(form) {
+  form.getValue = function (name) {
+    var path = (0, _utils.transformNameToPath)(name);
+    return path ? form.getFieldValue(path) : form.getFieldsValue(true);
+  };
+}
+function setError(form) {
+  form.setError = /*#__PURE__*/function () {
+    var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee(nameOrParams, message) {
+      var errors, internalErrors;
+      return (0, _regeneratorRuntime2.default)().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return (0, _api.wait)(function () {
+              return !form.callMethod(_constant.registerMethods.getLoading);
+            });
+          case 2:
+            errors = [];
+            if (_lodash.default.isString(nameOrParams) || _lodash.default.isArray(nameOrParams)) {
+              errors.push({
+                name: (0, _utils.transformNameToPath)(nameOrParams),
+                errors: [message || '']
+              });
+            } else {
+              errors = _lodash.default.map(nameOrParams, function (value, name) {
+                return {
+                  name: (0, _utils.transformNameToPath)(name),
+                  errors: [value]
+                };
+              });
+            }
+            form.setFields(errors);
+
+            // 暂存 errors， 实时校验需要获取 errors
+            internalErrors = getInternalErrors(form);
+            _lodash.default.forEach(errors, function (error) {
+              return _lodash.default.set(internalErrors, error.name, error.errors[0]);
+            });
+            form.callMethod(_constant.registerMethods.triggerValidate);
+          case 8:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  form.registerMethod(_constant.registerMethods.getInternalErrors, function (name) {
+    var internalErrors = getInternalErrors(form);
+    return _lodash.default.get(internalErrors, name);
+  });
+  form.registerMethod(_constant.registerMethods.resetInternalError, function (name) {
+    var internalErrors = getInternalErrors(form);
+    if (name) {
+      _lodash.default.unset(internalErrors, name);
+    } else {
+      _lodash.default.set(form, pathMap.errors, {});
+    }
+
+    // reset itemsStatus
+    form.callMethod(_constant.registerMethods.setItemsStatus, name);
+  });
+  form.resetError = function (name) {
+    var nameList = _lodash.default.castArray(name);
+    var fields = nameList.map(function (x) {
+      return {
+        name: (0, _utils.transformNameToPath)(x),
+        errors: []
+      };
+    });
+    form.setFields(fields);
+    _lodash.default.forEach(nameList, function (name) {
+      return form.callMethod(_constant.registerMethods.resetInternalError, name);
+    });
+  };
+}
+function getInternalErrors(form) {
+  var errors = _lodash.default.get(form, pathMap.errors);
+  if (errors) {
+    return errors;
+  }
+  var defaultErrors = {};
+  _lodash.default.set(form, pathMap.errors, defaultErrors);
+  return defaultErrors;
+}
+function setValue(form, update) {
+  form.setValue = function (nameOrParams, value) {
+    if (_lodash.default.isString(nameOrParams) || _lodash.default.isArray(nameOrParams)) {
+      var name = (0, _utils.transformNameToPath)(nameOrParams);
+      // 该方法会替换 Value
+      form.setFieldValue(name, value);
+    } else {
+      var values = (0, _utils.transformKeyToPath)(nameOrParams);
+      // 该方法会 Merge Value，同时会清空状态
+      form.setFieldsValue(values);
+    }
+    update();
+  };
+}
+function validate(form) {
+  form.validate = /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee2() {
+    var _len2,
+      args,
+      _key2,
+      _args2 = arguments;
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          _context2.next = 2;
+          return (0, _api.wait)(function () {
+            return !form.callMethod(_constant.registerMethods.getLoading);
+          });
+        case 2:
+          for (_len2 = _args2.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+            args[_key2] = _args2[_key2];
+          }
+          return _context2.abrupt("return", form.callMethod.apply(form, [_constant.registerMethods.internalValidate].concat(args)));
+        case 4:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  form.registerMethod(_constant.registerMethods.internalValidate, /*#__PURE__*/function () {
+    var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee3(name, options) {
+      var path, nameList;
+      return (0, _regeneratorRuntime2.default)().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            _context3.prev = 0;
+            if (!name) {
+              _context3.next = 8;
+              break;
+            }
+            path = (0, _utils.transformNameToPath)(name);
+            nameList = _lodash.default.isString(name) ? [path] : path;
+            _context3.next = 6;
+            return form.validateFields(nameList, options);
+          case 6:
+            _context3.next = 10;
+            break;
+          case 8:
+            _context3.next = 10;
+            return form.validateFields((0, _objectSpread2.default)({
+              validateOnly: true
+            }, options));
+          case 10:
+            return _context3.abrupt("return", true);
+          case 13:
+            _context3.prev = 13;
+            _context3.t0 = _context3["catch"](0);
+            form.callMethod(_constant.registerMethods.onValidateFailed, (0, _utils.parseFormFailedError)(_context3.t0));
+            return _context3.abrupt("return", false);
+          case 17:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, null, [[0, 13]]);
+    }));
+    return function (_x3, _x4) {
+      return _ref3.apply(this, arguments);
+    };
+  }());
+}
+function reset(form) {
+  form.reset = function (name) {
+    if (name) {
+      var path = (0, _utils.transformNameToPath)(name);
+      var nameList = _lodash.default.isString(name) ? [path] : path;
+      _lodash.default.forEach(nameList, function (name) {
+        return form.callMethod(_constant.registerMethods.resetInternalError, name);
+      });
+      form.resetFields(nameList);
+      return;
+    }
+    form.callMethod(_constant.registerMethods.resetInternalError);
+    form.resetFields();
+  };
+}
+function submit(form) {
+  var originalSubmit = form.submit;
+  form.submit = /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee4() {
+    var err;
+    return (0, _regeneratorRuntime2.default)().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          _context4.prev = 0;
+          originalSubmit();
+          // 修复submit和validateFields同时调用时，某种场景会出现的bug
+          _context4.next = 4;
+          return (0, _delay.default)(20);
+        case 4:
+          _context4.next = 6;
+          return form.validateFields();
+        case 6:
+          return _context4.abrupt("return", form.getValue());
+        case 9:
+          _context4.prev = 9;
+          _context4.t0 = _context4["catch"](0);
+          err = (0, _utils.parseFormFailedError)(_context4.t0);
+          return _context4.abrupt("return", Promise.reject(err));
+        case 13:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4, null, [[0, 9]]);
+  }));
+}
+function updateForm(form, update) {
+  form.update = update;
+}
+function getName(form) {
+  var id = (0, _api.runDevOrJest)(_lodash.default.uniqueId('form_'), 'form');
+  var path = pathMap.name;
+  _lodash.default.set(form, path, id);
+  form.getName = function () {
+    return _lodash.default.get(form, path);
+  };
+}
+function processFormItems(form) {
+  var path = pathMap.items;
+  form.setItems = function (items) {
+    return _lodash.default.set(form, path, items);
+  };
+  form.getItems = function (name) {
+    var items = _lodash.default.get(form, path) || [];
+    if (name) {
+      var namePath = (0, _utils.transformPathToName)(name);
+      return _lodash.default.find(items, function (item) {
+        return (0, _utils.transformPathToName)(item.name) === namePath;
+      });
+    }
+    return items;
+  };
+}
+function processFormItemsStatus(form) {
+  var path = pathMap.itemsStatus;
+  form.registerMethod(_constant.registerMethods.setItemsStatus, function (name, errors) {
+    if (!name) {
+      return _lodash.default.set(form, path, {});
+    }
+    var namePath = (0, _utils.transformPathToName)(name);
+    var fullPath = "".concat(path, ".").concat(namePath);
+    if (_lodash.default.isEmpty(errors)) {
+      return _lodash.default.unset(form, fullPath);
+    }
+    _lodash.default.set(form, fullPath, errors);
+  });
+  form.registerMethod(_constant.registerMethods.getItemsStatus, function (name) {
+    var namePath = (0, _utils.transformPathToName)(name);
+    var fullPath = name ? "".concat(path, ".").concat(namePath) : path;
+    var errors = _lodash.default.get(form, fullPath);
+    return removeEmptyError(errors);
+  });
+  form.getError = function (name) {
+    return form.callMethod(_constant.registerMethods.getItemsStatus, name);
+  };
+}
+function removeEmptyError(error) {
+  if (!_lodash.default.isPlainObject(error)) {
+    return error;
+  }
+  var processed = _lodash.default.mapValues(error, removeEmptyError);
+  return _lodash.default.omitBy(processed, _lodash.default.isEmpty);
+}
+function getFieldInstance(form) {
+  form.getFieldInstance = function (name) {
+    var _form$getItems;
+    return (_form$getItems = form.getItems(name)) === null || _form$getItems === void 0 ? void 0 : _form$getItems.refs.current;
+  };
+}
+function getFormList(form) {
+  // @ts-ignore
+  form.getFormList = function (name) {
+    var list = (0, _lodash.default)(form.getItems()).map('formListContext').compact().unionBy('name').value();
+    return name ? _lodash.default.find(list, {
+      name: name
+    }) : list;
+  };
+}
+function focus(form) {
+  form.focus = function (name, option) {
+    var _form$getFieldInstanc;
+    (_form$getFieldInstanc = form.getFieldInstance(name)) === null || _form$getFieldInstanc === void 0 || _form$getFieldInstanc.focus(option);
+  };
+}

package/lib/form/index.d.ts

@@ -0,0 +1,3 @@
+export * from './component';
+export * from './hook';
+export * from './type';

package/lib/form/index.js

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _component = require("./component");
+Object.keys(_component).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _component[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _component[key];
+    }
+  });
+});
+var _hook = require("./hook");
+Object.keys(_hook).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _hook[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _hook[key];
+    }
+  });
+});
+var _type = require("./type");
+Object.keys(_type).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _type[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _type[key];
+    }
+  });
+});

package/lib/form/style/form-item.d.ts

@@ -0,0 +1,3 @@
+import { FormItemProps, FormItemPropsWithType } from "..";
+export declare function getFormItemWidth({ width, type }: FormItemPropsWithType): string | number | undefined;
+export declare function getFormItemStyle({ labelWidth, controlWidth, requiredMark, layout, type, ...props }: FormItemProps): string;