doui-react 1.0.0

package/es/form/component/utils.js

@@ -0,0 +1,435 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["onValidateFailed", "initialValues", "form"],
+  _excluded2 = ["tooltip"],
+  _excluded3 = ["className", "style"],
+  _excluded4 = ["children"];
+/* eslint-disable max-lines */
+import { includesNonStrictMode, renderComponentByType } from "../../api";
+import { getOptionsValue } from "../../select/component/utils";
+import { generateTooltip } from "../../text";
+import { getTooltipProps } from "../../tooltip";
+import { InfoCircleOutlined } from '@ant-design/icons';
+import { getFieldId } from 'antd/lib/form/util';
+import delay from 'delay';
+import _ from 'lodash';
+import { antdFormItemKeys, antdFormPropsKeys, registerMethods } from "./constant";
+import { jsx as _jsx } from "@emotion/react/jsx-runtime";
+export function getFormProps(props) {
+  var _props$form;
+  var _$pick = _.pick(props, antdFormPropsKeys),
+    onValidateFailed = _$pick.onValidateFailed,
+    initialValues = _$pick.initialValues,
+    form = _$pick.form,
+    formProps = _objectWithoutProperties(_$pick, _excluded);
+  return _.merge({
+    form: form,
+    name: (_props$form = props.form) === null || _props$form === void 0 ? void 0 : _props$form.getName(),
+    component: 'div',
+    autoComplete: 'off',
+    labelWrap: true,
+    validateMessages: {
+      required: '${label} is required.'
+    },
+    validateTrigger: ['onChange', 'onBlur'],
+    onFinishFailed: function onFinishFailed(error) {
+      var errorInfo = parseFormFailedError(error);
+      onValidateFailed === null || onValidateFailed === void 0 || onValidateFailed(errorInfo);
+    }
+  }, formProps);
+}
+export function getFormItemProps(props) {
+  var _props$initialValue;
+  var _$pick2 = _.pick(props, antdFormItemKeys),
+    tooltip = _$pick2.tooltip,
+    pickProps = _objectWithoutProperties(_$pick2, _excluded2);
+  var name = removePrefixNameIfNeed(props.formListContext, props.name);
+  return _objectSpread(_objectSpread({}, pickProps), {}, {
+    name: name,
+    tooltip: generateTooltipWithIcon(tooltip),
+    initialValue: (_props$initialValue = props.initialValue) !== null && _props$initialValue !== void 0 ? _props$initialValue : props.defaultValue
+  });
+}
+function generateTooltipWithIcon(tooltip) {
+  if (!tooltip) {
+    return;
+  }
+  var _getTooltipProps = getTooltipProps(generateTooltip(tooltip)),
+    className = _getTooltipProps.className,
+    style = _getTooltipProps.style,
+    tooltipProps = _objectWithoutProperties(_getTooltipProps, _excluded3);
+  return _objectSpread({
+    icon: _jsx(InfoCircleOutlined, {
+      className: className,
+      style: style
+    })
+  }, tooltipProps);
+}
+export function getComponentProps(props) {
+  var keys = [].concat(_toConsumableArray(antdFormItemKeys), ['formListContext', 'formItemContext', 'children', 'validator', 'removeErrorOnBlur', 'preserveStatus']);
+  return _.omit(props, keys);
+}
+export function generateFormItem(props) {
+  var item = props.item,
+    formListContext = props.formListContext;
+  var processedItem = processFormItemProps(item, formListContext);
+  return _objectSpread(_objectSpread({}, processedItem), {}, {
+    rules: generateRules(_objectSpread(_objectSpread({}, props), {}, {
+      item: processedItem
+    })),
+    type: item.type || 'input',
+    dependencies: transformNameToPath(item.dependencies)
+  });
+}
+function processFormItemProps(_ref, formListContext) {
+  var children = _ref.children,
+    item = _objectWithoutProperties(_ref, _excluded4);
+  if (children) {
+    item.render = function (params) {
+      var props = _.pick(params, ['refs', 'id', 'value', 'onChange', 'onBlur', 'onFocus']);
+      return renderComponentByType(children, props);
+    };
+  }
+
+  // 将嵌套的 name 转换 antd form 的 name
+  _.set(item, 'name', transformNameToPath(item.name));
+
+  // 挂载 formListContext 属性，并拼接 name
+  if (!_.isEmpty(formListContext)) {
+    item.formListContext = formListContext;
+    item.isListField = true;
+    _.set(item, 'name', generateListItemName(formListContext.name, item.name));
+  }
+  return item;
+}
+export function generateListItemName(listName, name) {
+  return _.flattenDeep([listName, name]).filter(function (x) {
+    return !_.isNil(x);
+  });
+}
+export function removePrefixNameIfNeed(formListContext, name) {
+  var listName = formListContext === null || formListContext === void 0 ? void 0 : formListContext.name;
+  return listName ? _.drop(name, _.castArray(listName).length) : name;
+}
+function generateRules(_ref2) {
+  var item = _ref2.item,
+    form = _ref2.form,
+    items = _ref2.items,
+    isFormList = _ref2.isFormList;
+  var rules = _.clone(item.rules || []);
+  var params = {
+    form: form,
+    items: items
+  };
+  if (item.required && !item.rules) {
+    var message = generateRequiredMessage(item);
+    rules.push({
+      required: true,
+      message: message
+    });
+  }
+  if (item.validator) {
+    rules.push({
+      validator: item.validator
+    });
+  }
+  if (!isFormList && !item.removeErrorOnBlur) {
+    rules.push({
+      validator: function validator() {
+        return form.callMethod(registerMethods.getInternalErrors, item.name);
+      }
+    });
+  }
+  if (item.requiredInOptions) {
+    var _message = _.isString(item.requiredInOptions) ? item.requiredInOptions : 'The value does not exist.';
+    var validator = function validator(_ref3) {
+      var _form$getItems;
+      var value = _ref3.value;
+      var options = (_form$getItems = form.getItems(item.name)) === null || _form$getItems === void 0 ? void 0 : _form$getItems.options;
+      if (!isEmpty(value) && isValueNotExistInOptions(value, options)) {
+        return _message;
+      }
+    };
+    rules.push({
+      validator: validator
+    });
+  }
+  return _.map(rules, function (r) {
+    var rule = _.clone(r);
+    var originValidator = r.validator;
+    if (originValidator) {
+      rule.validator = /*#__PURE__*/function () {
+        var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(__, value) {
+          var res;
+          return _regeneratorRuntime().wrap(function _callee$(_context) {
+            while (1) switch (_context.prev = _context.next) {
+              case 0:
+                _context.next = 2;
+                return originValidator(_objectSpread({
+                  value: value,
+                  item: item
+                }, params));
+              case 2:
+                res = _context.sent;
+                return _context.abrupt("return", res ? Promise.reject(res) : Promise.resolve());
+              case 4:
+              case "end":
+                return _context.stop();
+            }
+          }, _callee);
+        }));
+        return function (_x, _x2) {
+          return _ref4.apply(this, arguments);
+        };
+      }();
+    }
+    return rule;
+  });
+}
+function generateRequiredMessage(item) {
+  if (_.isString(item.required)) {
+    return item.required;
+  }
+  if (!item.label) {
+    return 'The value is required.';
+  }
+}
+export function isValueNotExistInOptions(value, options) {
+  var optionsValue = getOptionsValue(options);
+  var values = parseValueWhenLabelInValue(value);
+  return !includesNonStrictMode(optionsValue, values);
+}
+export function isEmpty(value) {
+  var arr = _(value).castArray().reject(_.isNil).value();
+  return _.isEmpty(arr);
+}
+export function parseValueWhenLabelInValue(value) {
+  return _.castArray(value).map(function (x) {
+    return _.isPlainObject(x) ? x === null || x === void 0 ? void 0 : x.value : x;
+  });
+}
+export function updateNotExistValue(_ref5) {
+  var form = _ref5.form,
+    value = _ref5.value,
+    name = _ref5.name,
+    options = _ref5.options,
+    _ref5$filterNotExistV = _ref5.filterNotExistValue,
+    filterNotExistValue = _ref5$filterNotExistV === void 0 ? false : _ref5$filterNotExistV,
+    labelInValue = _ref5.labelInValue;
+  if (filterNotExistValue === false || !isValueNotExistInOptions(value, options)) {
+    return;
+  }
+  var namePath = transformPathToName(name);
+  // 多选
+  if (_.isArray(value)) {
+    var filteredValue = _.filter(value, function (item) {
+      return !isValueNotExistInOptions(item, options);
+    });
+    form.setValue(namePath, filteredValue);
+    return true;
+  }
+
+  // 单选
+  if (filterNotExistValue === true) {
+    form.reset(namePath);
+  } else {
+    var val = filterNotExistValue === 'useFirstOption' ? getFirstOptionValue(options, labelInValue) : filterNotExistValue;
+    form.setValue(namePath, val);
+  }
+  return true;
+}
+function getFirstOptionValue(options, labelInValue) {
+  if (!options) {
+    return;
+  }
+  var value = _.first(getOptionsValue(options));
+  return labelInValue ? {
+    value: value
+  } : value;
+}
+export function validateFormOnMount(_x3, _x4) {
+  return _validateFormOnMount.apply(this, arguments);
+}
+function _validateFormOnMount() {
+  _validateFormOnMount = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(_ref6, validateOnMount) {
+    var form, items, fields;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          form = _ref6.form, items = _ref6.items;
+          fields = [];
+          _.forEach(items, function (item) {
+            if (validateOnMount || _.some(item.rules, 'validateOnMount')) {
+              fields.push(item.name);
+            }
+          });
+          if (!_.isEmpty(fields)) {
+            _context2.next = 5;
+            break;
+          }
+          return _context2.abrupt("return");
+        case 5:
+          _context2.next = 7;
+          return form.validate(fields);
+        case 7:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  }));
+  return _validateFormOnMount.apply(this, arguments);
+}
+export function transformNameToPath(name) {
+  if (_.isString(name) && _.includes(name, '.')) {
+    return _.toPath(name);
+  }
+  if (_.isArray(name)) {
+    return _.map(name, transformNameToPath);
+  }
+  return name;
+}
+export function transformPathToName(path) {
+  if (_.isNil(path)) {
+    return;
+  }
+  if (_.isArray(path)) {
+    return _(path).map(transformPathToName).reject(_.isNil).join('.');
+  }
+  return path.toString();
+}
+export function transformKeyToPath(params) {
+  var result = {};
+  _.forEach(params, function (value, key) {
+    return _.set(result, key, value);
+  });
+  return result;
+}
+export function parseFormFailedError(error) {
+  var errorInfo = {};
+  error.errorFields.forEach(function (item) {
+    var key = item.name.join('.');
+    errorInfo[key] = item.errors[0];
+  });
+  return errorInfo;
+}
+export function noStyle(item) {
+  return !item.name && !!item.render;
+}
+export function transformOptions(item, values, params) {
+  var options = item.options,
+    type = item.type;
+  if (!type || !_.isFunction(options)) {
+    return options;
+  }
+  if (['select', 'treeSelect'].includes(type)) {
+    return function () {
+      var search = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      return options(values, _objectSpread(_objectSpread({}, params), {}, {
+        search: search
+      }));
+    };
+  }
+  return options(values, _objectSpread(_objectSpread({}, params), {}, {
+    search: ''
+  }));
+}
+export function focusFirstInput(_ref7) {
+  var _parseFocusFirst;
+  var form = _ref7.form,
+    items = _ref7.items,
+    focusFirstOnMount = _ref7.focusFirstOnMount;
+  var name = (_parseFocusFirst = parseFocusFirst(focusFirstOnMount)) !== null && _parseFocusFirst !== void 0 ? _parseFocusFirst : _.get(items, '0.name');
+  if (!name) {
+    return;
+  }
+  form.focus(name);
+  return true;
+}
+function parseFocusFirst(focusFirstOnMount) {
+  if (focusFirstOnMount === true) {
+    return;
+  }
+  return focusFirstOnMount;
+}
+export function scrollToFieldOnAdd(_x5) {
+  return _scrollToFieldOnAdd.apply(this, arguments);
+}
+function _scrollToFieldOnAdd() {
+  _scrollToFieldOnAdd = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref8) {
+    var name, form, insertIndex, _ref8$focusFirstOnAdd, focusFirstOnAdd, prefixName, insertItems, focusFirstOnMount;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          name = _ref8.name, form = _ref8.form, insertIndex = _ref8.insertIndex, _ref8$focusFirstOnAdd = _ref8.focusFirstOnAdd, focusFirstOnAdd = _ref8$focusFirstOnAdd === void 0 ? true : _ref8$focusFirstOnAdd;
+          if (form) {
+            _context3.next = 3;
+            break;
+          }
+          return _context3.abrupt("return");
+        case 3:
+          _context3.next = 5;
+          return delay(50);
+        case 5:
+          // 等待 form.setItems 完成
+          prefixName = "".concat(transformPathToName(name), ".").concat(insertIndex);
+          insertItems = form.getItems().filter(function (item) {
+            var _transformPathToName;
+            return (_transformPathToName = transformPathToName(item.name)) === null || _transformPathToName === void 0 ? void 0 : _transformPathToName.startsWith(prefixName);
+          });
+          focusFirstOnMount = _.isString(focusFirstOnAdd) ? "".concat(prefixName, ".").concat(focusFirstOnAdd) : focusFirstOnAdd;
+          focusFirstInput({
+            form: form,
+            items: insertItems,
+            focusFirstOnMount: focusFirstOnMount
+          });
+        case 9:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  }));
+  return _scrollToFieldOnAdd.apply(this, arguments);
+}
+export function setContextWrapper(setContext) {
+  return function (nameOrParams, value) {
+    if (_.isString(nameOrParams)) {
+      setContext(function (state) {
+        return _.set(state, nameOrParams, value);
+      });
+      return;
+    }
+    nameOrParams && setContext(nameOrParams);
+  };
+}
+export function getContextWrapper(context) {
+  return function (name) {
+    return name ? _.get(context, name) : context;
+  };
+}
+export function generateCollectionKey(name) {
+  return _.camelCase(name);
+}
+export function removeFormListFormItems(name, collectionItems) {
+  var namePath = transformPathToName(name);
+  return _.omitBy(collectionItems, function (item) {
+    var _item$formListContext;
+    return transformPathToName((_item$formListContext = item.formListContext) === null || _item$formListContext === void 0 ? void 0 : _item$formListContext.name) === namePath;
+  });
+}
+export function removeTableEditorFormItems(name, collectionItems) {
+  var namePath = transformPathToName(name);
+  return _.omitBy(collectionItems, function (item) {
+    return _.startsWith(transformPathToName(item.name), namePath);
+  });
+}
+export function getFormItemId(name, form) {
+  return getFieldId(_.castArray(name), form.getName());
+}
+export function hasItemLoading(items) {
+  return _.some(items, {
+    loading: true
+  });
+}

package/es/form/component/validator-item.d.ts

@@ -0,0 +1,7 @@
+import { FunctionReturn } from "../../api";
+import { FormContext, FormItemProps } from "..";
+export interface ValidatorItemProps extends Omit<FormItemProps, 'validator'> {
+    validator?: (props: FormContext) => FunctionReturn<boolean | void>;
+    shouldTriggerValidate?: any;
+}
+export declare function ValidatorItem({ validator, shouldTriggerValidate, ...props }: ValidatorItemProps): import("@emotion/react/jsx-runtime").JSX.Element;

package/es/form/component/validator-item.js

@@ -0,0 +1,53 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["validator", "shouldTriggerValidate"];
+import { useFormContext } from "./..";
+import { useUpdateEffect } from 'react-use';
+import { registerMethods } from "./constant";
+import { FormItem } from "./form-item";
+import { Fragment as _Fragment, jsx as _jsx } from "@emotion/react/jsx-runtime";
+export function ValidatorItem(_ref) {
+  var validator = _ref.validator,
+    shouldTriggerValidate = _ref.shouldTriggerValidate,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var context = useFormContext();
+  function validate() {
+    return _validate.apply(this, arguments);
+  }
+  function _validate() {
+    _validate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+      var res;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return validator === null || validator === void 0 ? void 0 : validator(context);
+          case 2:
+            res = _context.sent;
+            return _context.abrupt("return", res === false ? 'error' : '');
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return _validate.apply(this, arguments);
+  }
+  useUpdateEffect(function () {
+    context.form.callMethod(registerMethods.triggerValidate);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [shouldTriggerValidate]);
+  return _jsx(FormItem, _objectSpread(_objectSpread({
+    name: "__validatorItem__"
+  }, props), {}, {
+    hidden: true,
+    noStyle: true,
+    __noCollectState__: true,
+    validator: validate,
+    render: function render() {
+      return _jsx(_Fragment, {});
+    }
+  }));
+}

package/es/form/hook/index.d.ts

@@ -0,0 +1,16 @@
+import { FunctionReturn } from "../../api";
+import { FormProps, FormValues } from "..";
+import { FormItemSelectProps } from "../component/form-item-map";
+import { SelectCallbackProps } from "../../select";
+import { DependencyList } from 'react';
+export * from './list-provider';
+export * from './provider';
+export * from './use-form';
+export declare function useFormValueChange<T>(fn: (values: FormValues) => FunctionReturn<T>, deps?: DependencyList): T | undefined;
+interface UseValidateFormProps extends Pick<FormProps, 'onValidate'> {
+    validateOnly?: boolean;
+}
+export declare function useValidateForm({ onValidate, validateOnly }?: UseValidateFormProps): boolean;
+export interface ValidateNotExistValueProps extends FormItemSelectProps, SelectCallbackProps {
+}
+export declare function useValidateNotExistValue({ loading, value, options, ...props }: ValidateNotExistValueProps): void;

package/es/form/hook/index.js

@@ -0,0 +1,116 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+var _excluded = ["loading", "value", "options"];
+import { useFormContext } from "./..";
+import { useCollectFormItemState } from "../component/form-item-map";
+import { useDebounce, useDeepEffect, useSafeState } from "../../hooks";
+import { useEffect } from 'react';
+import { registerMethods } from "../component/constant";
+import { hasItemLoading } from "../component/utils";
+export * from "./list-provider";
+export * from "./provider";
+export * from "./use-form";
+export function useFormValueChange(fn) {
+  var deps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var _useFormContext = useFormContext(),
+    values = _useFormContext.values;
+  var _useSafeState = useSafeState(),
+    _useSafeState2 = _slicedToArray(_useSafeState, 2),
+    result = _useSafeState2[0],
+    setResult = _useSafeState2[1];
+  useDeepEffect( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    var res;
+    return _regeneratorRuntime().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(_toConsumableArray(deps)));
+  return result;
+}
+export function useValidateForm() {
+  var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    onValidate = _ref2.onValidate,
+    validateOnly = _ref2.validateOnly;
+  var _useFormContext2 = useFormContext(),
+    loading = _useFormContext2.loading,
+    form = _useFormContext2.form,
+    items = _useFormContext2.items,
+    values = _useFormContext2.values;
+  var _useSafeState3 = useSafeState(false),
+    _useSafeState4 = _slicedToArray(_useSafeState3, 2),
+    result = _useSafeState4[0],
+    setResult = _useSafeState4[1];
+  var validate = /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+      var _onValidate;
+      var isValid, customValidate, final;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!(loading || hasItemLoading(items))) {
+              _context2.next = 2;
+              break;
+            }
+            return _context2.abrupt("return");
+          case 2:
+            _context2.next = 4;
+            return form.callMethod(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 = useDebounce(validate, 100, {
+    leading: false
+  });
+  useEffect(function () {
+    onChangeDebounce();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [values, loading, items]);
+
+  // 供 form.setError 使用
+  form.registerMethod(registerMethods.triggerValidate, onChangeDebounce);
+  return result;
+}
+export function useValidateNotExistValue(_ref4) {
+  var loading = _ref4.loading,
+    value = _ref4.value,
+    options = _ref4.options,
+    props = _objectWithoutProperties(_ref4, _excluded);
+  var _useFormContext3 = useFormContext(),
+    formLoading = _useFormContext3.loading;
+  var _useCollectFormItemSt = useCollectFormItemState(props),
+    __callback__ = _useCollectFormItemSt.__callback__;
+  var params = {
+    options: options,
+    value: value,
+    loading: formLoading || loading
+  };
+  useDeepEffect(function () {
+    __callback__(params);
+  }, [params]);
+}

package/es/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/es/form/hook/list-provider.js

@@ -0,0 +1,16 @@
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["children"];
+import { createContext, useContext } from 'react';
+import { jsx as _jsx } from "@emotion/react/jsx-runtime";
+var FormListCtx = /*#__PURE__*/createContext({});
+export function FormListProvider(_ref) {
+  var children = _ref.children,
+    props = _objectWithoutProperties(_ref, _excluded);
+  return _jsx(FormListCtx.Provider, {
+    value: props,
+    children: children
+  });
+}
+export function useFormListContext() {
+  return useContext(FormListCtx);
+}

package/es/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;