3195 lines
101 KiB
JavaScript
3195 lines
101 KiB
JavaScript
module.exports = (function() {
|
|
var __MODS__ = {};
|
|
var __DEFINE__ = function(modId, func, req) { var m = { exports: {}, _tempexports: {} }; __MODS__[modId] = { status: 0, func: func, req: req, m: m }; };
|
|
var __REQUIRE__ = function(modId, source) { if(!__MODS__[modId]) return require(source); if(!__MODS__[modId].status) { var m = __MODS__[modId].m; m._exports = m._tempexports; var desp = Object.getOwnPropertyDescriptor(m, "exports"); if (desp && desp.configurable) Object.defineProperty(m, "exports", { set: function (val) { if(typeof val === "object" && val !== m._exports) { m._exports.__proto__ = val.__proto__; Object.keys(val).forEach(function (k) { m._exports[k] = val[k]; }); } m._tempexports = val }, get: function () { return m._tempexports; } }); __MODS__[modId].status = 1; __MODS__[modId].func(__MODS__[modId].req, m, m.exports); } return __MODS__[modId].m.exports; };
|
|
var __REQUIRE_WILDCARD__ = function(obj) { if(obj && obj.__esModule) { return obj; } else { var newObj = {}; if(obj != null) { for(var k in obj) { if (Object.prototype.hasOwnProperty.call(obj, k)) newObj[k] = obj[k]; } } newObj.default = obj; return newObj; } };
|
|
var __REQUIRE_DEFAULT__ = function(obj) { return obj && obj.__esModule ? obj.default : obj; };
|
|
__DEFINE__(1656641690360, function(require, module, exports) {
|
|
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
Object.defineProperty(exports, "Field", {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _Field.default;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "FieldContext", {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _FieldContext.default;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "FormProvider", {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _FormContext.FormProvider;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "List", {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _List.default;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "ListContext", {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _ListContext.default;
|
|
}
|
|
});
|
|
exports.default = void 0;
|
|
Object.defineProperty(exports, "useForm", {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _useForm.default;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "useWatch", {
|
|
enumerable: true,
|
|
get: function get() {
|
|
return _useWatch.default;
|
|
}
|
|
});
|
|
|
|
var React = _interopRequireWildcard(require("react"));
|
|
|
|
var _Field = _interopRequireDefault(require("./Field"));
|
|
|
|
var _List = _interopRequireDefault(require("./List"));
|
|
|
|
var _useForm = _interopRequireDefault(require("./useForm"));
|
|
|
|
var _Form = _interopRequireDefault(require("./Form"));
|
|
|
|
var _FormContext = require("./FormContext");
|
|
|
|
var _FieldContext = _interopRequireDefault(require("./FieldContext"));
|
|
|
|
var _ListContext = _interopRequireDefault(require("./ListContext"));
|
|
|
|
var _useWatch = _interopRequireDefault(require("./useWatch"));
|
|
|
|
var InternalForm = /*#__PURE__*/React.forwardRef(_Form.default);
|
|
var RefForm = InternalForm;
|
|
RefForm.FormProvider = _FormContext.FormProvider;
|
|
RefForm.Field = _Field.default;
|
|
RefForm.List = _List.default;
|
|
RefForm.useForm = _useForm.default;
|
|
RefForm.useWatch = _useWatch.default;
|
|
var _default = RefForm;
|
|
exports.default = _default;
|
|
}, function(modId) {var map = {"./Field":1656641690361,"./List":1656641690368,"./useForm":1656641690370,"./Form":1656641690373,"./FormContext":1656641690374,"./FieldContext":1656641690362,"./ListContext":1656641690369,"./useWatch":1656641690375}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690361, function(require, module, exports) {
|
|
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
|
|
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
|
|
|
|
var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
|
|
|
|
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
|
|
|
|
var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
|
|
|
|
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
|
|
|
|
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
|
|
|
|
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
|
|
|
|
var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
|
|
|
|
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
|
|
|
|
var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
|
|
|
|
var _toArray = _interopRequireDefault(require("rc-util/lib/Children/toArray"));
|
|
|
|
var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
|
|
|
|
var React = _interopRequireWildcard(require("react"));
|
|
|
|
var _FieldContext = _interopRequireWildcard(require("./FieldContext"));
|
|
|
|
var _typeUtil = require("./utils/typeUtil");
|
|
|
|
var _validateUtil = require("./utils/validateUtil");
|
|
|
|
var _valueUtil = require("./utils/valueUtil");
|
|
|
|
var _excluded = ["name"];
|
|
var EMPTY_ERRORS = [];
|
|
|
|
function requireUpdate(shouldUpdate, prev, next, prevValue, nextValue, info) {
|
|
if (typeof shouldUpdate === 'function') {
|
|
return shouldUpdate(prev, next, 'source' in info ? {
|
|
source: info.source
|
|
} : {});
|
|
}
|
|
|
|
return prevValue !== nextValue;
|
|
} // We use Class instead of Hooks here since it will cost much code by using Hooks.
|
|
|
|
|
|
var Field = /*#__PURE__*/function (_React$Component) {
|
|
(0, _inherits2.default)(Field, _React$Component);
|
|
|
|
var _super = (0, _createSuper2.default)(Field);
|
|
|
|
/**
|
|
* Follow state should not management in State since it will async update by React.
|
|
* This makes first render of form can not get correct state value.
|
|
*/
|
|
|
|
/**
|
|
* Mark when touched & validated. Currently only used for `dependencies`.
|
|
* Note that we do not think field with `initialValue` is dirty
|
|
* but this will be by `isFieldDirty` func.
|
|
*/
|
|
// ============================== Subscriptions ==============================
|
|
function Field(props) {
|
|
var _this;
|
|
|
|
(0, _classCallCheck2.default)(this, Field);
|
|
_this = _super.call(this, props); // Register on init
|
|
|
|
_this.state = {
|
|
resetCount: 0
|
|
};
|
|
_this.cancelRegisterFunc = null;
|
|
_this.mounted = false;
|
|
_this.touched = false;
|
|
_this.dirty = false;
|
|
_this.validatePromise = null;
|
|
_this.prevValidating = void 0;
|
|
_this.errors = EMPTY_ERRORS;
|
|
_this.warnings = EMPTY_ERRORS;
|
|
|
|
_this.cancelRegister = function () {
|
|
var _this$props = _this.props,
|
|
preserve = _this$props.preserve,
|
|
isListField = _this$props.isListField,
|
|
name = _this$props.name;
|
|
|
|
if (_this.cancelRegisterFunc) {
|
|
_this.cancelRegisterFunc(isListField, preserve, (0, _valueUtil.getNamePath)(name));
|
|
}
|
|
|
|
_this.cancelRegisterFunc = null;
|
|
};
|
|
|
|
_this.getNamePath = function () {
|
|
var _this$props2 = _this.props,
|
|
name = _this$props2.name,
|
|
fieldContext = _this$props2.fieldContext;
|
|
var _fieldContext$prefixN = fieldContext.prefixName,
|
|
prefixName = _fieldContext$prefixN === void 0 ? [] : _fieldContext$prefixN;
|
|
return name !== undefined ? [].concat((0, _toConsumableArray2.default)(prefixName), (0, _toConsumableArray2.default)(name)) : [];
|
|
};
|
|
|
|
_this.getRules = function () {
|
|
var _this$props3 = _this.props,
|
|
_this$props3$rules = _this$props3.rules,
|
|
rules = _this$props3$rules === void 0 ? [] : _this$props3$rules,
|
|
fieldContext = _this$props3.fieldContext;
|
|
return rules.map(function (rule) {
|
|
if (typeof rule === 'function') {
|
|
return rule(fieldContext);
|
|
}
|
|
|
|
return rule;
|
|
});
|
|
};
|
|
|
|
_this.refresh = function () {
|
|
if (!_this.mounted) return;
|
|
/**
|
|
* Clean up current node.
|
|
*/
|
|
|
|
_this.setState(function (_ref) {
|
|
var resetCount = _ref.resetCount;
|
|
return {
|
|
resetCount: resetCount + 1
|
|
};
|
|
});
|
|
};
|
|
|
|
_this.triggerMetaEvent = function (destroy) {
|
|
var onMetaChange = _this.props.onMetaChange;
|
|
onMetaChange === null || onMetaChange === void 0 ? void 0 : onMetaChange((0, _objectSpread2.default)((0, _objectSpread2.default)({}, _this.getMeta()), {}, {
|
|
destroy: destroy
|
|
}));
|
|
};
|
|
|
|
_this.onStoreChange = function (prevStore, namePathList, info) {
|
|
var _this$props4 = _this.props,
|
|
shouldUpdate = _this$props4.shouldUpdate,
|
|
_this$props4$dependen = _this$props4.dependencies,
|
|
dependencies = _this$props4$dependen === void 0 ? [] : _this$props4$dependen,
|
|
onReset = _this$props4.onReset;
|
|
var store = info.store;
|
|
|
|
var namePath = _this.getNamePath();
|
|
|
|
var prevValue = _this.getValue(prevStore);
|
|
|
|
var curValue = _this.getValue(store);
|
|
|
|
var namePathMatch = namePathList && (0, _valueUtil.containsNamePath)(namePathList, namePath); // `setFieldsValue` is a quick access to update related status
|
|
|
|
if (info.type === 'valueUpdate' && info.source === 'external' && prevValue !== curValue) {
|
|
_this.touched = true;
|
|
_this.dirty = true;
|
|
_this.validatePromise = null;
|
|
_this.errors = EMPTY_ERRORS;
|
|
_this.warnings = EMPTY_ERRORS;
|
|
|
|
_this.triggerMetaEvent();
|
|
}
|
|
|
|
switch (info.type) {
|
|
case 'reset':
|
|
if (!namePathList || namePathMatch) {
|
|
// Clean up state
|
|
_this.touched = false;
|
|
_this.dirty = false;
|
|
_this.validatePromise = null;
|
|
_this.errors = EMPTY_ERRORS;
|
|
_this.warnings = EMPTY_ERRORS;
|
|
|
|
_this.triggerMetaEvent();
|
|
|
|
onReset === null || onReset === void 0 ? void 0 : onReset();
|
|
|
|
_this.refresh();
|
|
|
|
return;
|
|
}
|
|
|
|
break;
|
|
|
|
/**
|
|
* In case field with `preserve = false` nest deps like:
|
|
* - A = 1 => show B
|
|
* - B = 1 => show C
|
|
* - Reset A, need clean B, C
|
|
*/
|
|
|
|
case 'remove':
|
|
{
|
|
if (shouldUpdate) {
|
|
_this.reRender();
|
|
|
|
return;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 'setField':
|
|
{
|
|
if (namePathMatch) {
|
|
var data = info.data;
|
|
|
|
if ('touched' in data) {
|
|
_this.touched = data.touched;
|
|
}
|
|
|
|
if ('validating' in data && !('originRCField' in data)) {
|
|
_this.validatePromise = data.validating ? Promise.resolve([]) : null;
|
|
}
|
|
|
|
if ('errors' in data) {
|
|
_this.errors = data.errors || EMPTY_ERRORS;
|
|
}
|
|
|
|
if ('warnings' in data) {
|
|
_this.warnings = data.warnings || EMPTY_ERRORS;
|
|
}
|
|
|
|
_this.dirty = true;
|
|
|
|
_this.triggerMetaEvent();
|
|
|
|
_this.reRender();
|
|
|
|
return;
|
|
} // Handle update by `setField` with `shouldUpdate`
|
|
|
|
|
|
if (shouldUpdate && !namePath.length && requireUpdate(shouldUpdate, prevStore, store, prevValue, curValue, info)) {
|
|
_this.reRender();
|
|
|
|
return;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case 'dependenciesUpdate':
|
|
{
|
|
/**
|
|
* Trigger when marked `dependencies` updated. Related fields will all update
|
|
*/
|
|
var dependencyList = dependencies.map(_valueUtil.getNamePath); // No need for `namePathMath` check and `shouldUpdate` check, since `valueUpdate` will be
|
|
// emitted earlier and they will work there
|
|
// If set it may cause unnecessary twice rerendering
|
|
|
|
if (dependencyList.some(function (dependency) {
|
|
return (0, _valueUtil.containsNamePath)(info.relatedFields, dependency);
|
|
})) {
|
|
_this.reRender();
|
|
|
|
return;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
default:
|
|
// 1. If `namePath` exists in `namePathList`, means it's related value and should update
|
|
// For example <List name="list"><Field name={['list', 0]}></List>
|
|
// If `namePathList` is [['list']] (List value update), Field should be updated
|
|
// If `namePathList` is [['list', 0]] (Field value update), List shouldn't be updated
|
|
// 2.
|
|
// 2.1 If `dependencies` is set, `name` is not set and `shouldUpdate` is not set,
|
|
// don't use `shouldUpdate`. `dependencies` is view as a shortcut if `shouldUpdate`
|
|
// is not provided
|
|
// 2.2 If `shouldUpdate` provided, use customize logic to update the field
|
|
// else to check if value changed
|
|
if (namePathMatch || (!dependencies.length || namePath.length || shouldUpdate) && requireUpdate(shouldUpdate, prevStore, store, prevValue, curValue, info)) {
|
|
_this.reRender();
|
|
|
|
return;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (shouldUpdate === true) {
|
|
_this.reRender();
|
|
}
|
|
};
|
|
|
|
_this.validateRules = function (options) {
|
|
// We should fixed namePath & value to avoid developer change then by form function
|
|
var namePath = _this.getNamePath();
|
|
|
|
var currentValue = _this.getValue(); // Force change to async to avoid rule OOD under renderProps field
|
|
|
|
|
|
var rootPromise = Promise.resolve().then(function () {
|
|
if (!_this.mounted) {
|
|
return [];
|
|
}
|
|
|
|
var _this$props5 = _this.props,
|
|
_this$props5$validate = _this$props5.validateFirst,
|
|
validateFirst = _this$props5$validate === void 0 ? false : _this$props5$validate,
|
|
messageVariables = _this$props5.messageVariables;
|
|
|
|
var _ref2 = options || {},
|
|
triggerName = _ref2.triggerName;
|
|
|
|
var filteredRules = _this.getRules();
|
|
|
|
if (triggerName) {
|
|
filteredRules = filteredRules.filter(function (rule) {
|
|
var validateTrigger = rule.validateTrigger;
|
|
|
|
if (!validateTrigger) {
|
|
return true;
|
|
}
|
|
|
|
var triggerList = (0, _typeUtil.toArray)(validateTrigger);
|
|
return triggerList.includes(triggerName);
|
|
});
|
|
}
|
|
|
|
var promise = (0, _validateUtil.validateRules)(namePath, currentValue, filteredRules, options, validateFirst, messageVariables);
|
|
promise.catch(function (e) {
|
|
return e;
|
|
}).then(function () {
|
|
var ruleErrors = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : EMPTY_ERRORS;
|
|
|
|
if (_this.validatePromise === rootPromise) {
|
|
_this.validatePromise = null; // Get errors & warnings
|
|
|
|
var nextErrors = [];
|
|
var nextWarnings = [];
|
|
ruleErrors.forEach(function (_ref3) {
|
|
var warningOnly = _ref3.rule.warningOnly,
|
|
_ref3$errors = _ref3.errors,
|
|
errors = _ref3$errors === void 0 ? EMPTY_ERRORS : _ref3$errors;
|
|
|
|
if (warningOnly) {
|
|
nextWarnings.push.apply(nextWarnings, (0, _toConsumableArray2.default)(errors));
|
|
} else {
|
|
nextErrors.push.apply(nextErrors, (0, _toConsumableArray2.default)(errors));
|
|
}
|
|
});
|
|
_this.errors = nextErrors;
|
|
_this.warnings = nextWarnings;
|
|
|
|
_this.triggerMetaEvent();
|
|
|
|
_this.reRender();
|
|
}
|
|
});
|
|
return promise;
|
|
});
|
|
_this.validatePromise = rootPromise;
|
|
_this.dirty = true;
|
|
_this.errors = EMPTY_ERRORS;
|
|
_this.warnings = EMPTY_ERRORS;
|
|
|
|
_this.triggerMetaEvent(); // Force trigger re-render since we need sync renderProps with new meta
|
|
|
|
|
|
_this.reRender();
|
|
|
|
return rootPromise;
|
|
};
|
|
|
|
_this.isFieldValidating = function () {
|
|
return !!_this.validatePromise;
|
|
};
|
|
|
|
_this.isFieldTouched = function () {
|
|
return _this.touched;
|
|
};
|
|
|
|
_this.isFieldDirty = function () {
|
|
// Touched or validate or has initialValue
|
|
if (_this.dirty || _this.props.initialValue !== undefined) {
|
|
return true;
|
|
} // Form set initialValue
|
|
|
|
|
|
var fieldContext = _this.props.fieldContext;
|
|
|
|
var _fieldContext$getInte = fieldContext.getInternalHooks(_FieldContext.HOOK_MARK),
|
|
getInitialValue = _fieldContext$getInte.getInitialValue;
|
|
|
|
if (getInitialValue(_this.getNamePath()) !== undefined) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
_this.getErrors = function () {
|
|
return _this.errors;
|
|
};
|
|
|
|
_this.getWarnings = function () {
|
|
return _this.warnings;
|
|
};
|
|
|
|
_this.isListField = function () {
|
|
return _this.props.isListField;
|
|
};
|
|
|
|
_this.isList = function () {
|
|
return _this.props.isList;
|
|
};
|
|
|
|
_this.isPreserve = function () {
|
|
return _this.props.preserve;
|
|
};
|
|
|
|
_this.getMeta = function () {
|
|
// Make error & validating in cache to save perf
|
|
_this.prevValidating = _this.isFieldValidating();
|
|
var meta = {
|
|
touched: _this.isFieldTouched(),
|
|
validating: _this.prevValidating,
|
|
errors: _this.errors,
|
|
warnings: _this.warnings,
|
|
name: _this.getNamePath()
|
|
};
|
|
return meta;
|
|
};
|
|
|
|
_this.getOnlyChild = function (children) {
|
|
// Support render props
|
|
if (typeof children === 'function') {
|
|
var meta = _this.getMeta();
|
|
|
|
return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, _this.getOnlyChild(children(_this.getControlled(), meta, _this.props.fieldContext))), {}, {
|
|
isFunction: true
|
|
});
|
|
} // Filed element only
|
|
|
|
|
|
var childList = (0, _toArray.default)(children);
|
|
|
|
if (childList.length !== 1 || ! /*#__PURE__*/React.isValidElement(childList[0])) {
|
|
return {
|
|
child: childList,
|
|
isFunction: false
|
|
};
|
|
}
|
|
|
|
return {
|
|
child: childList[0],
|
|
isFunction: false
|
|
};
|
|
};
|
|
|
|
_this.getValue = function (store) {
|
|
var getFieldsValue = _this.props.fieldContext.getFieldsValue;
|
|
|
|
var namePath = _this.getNamePath();
|
|
|
|
return (0, _valueUtil.getValue)(store || getFieldsValue(true), namePath);
|
|
};
|
|
|
|
_this.getControlled = function () {
|
|
var childProps = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
var _this$props6 = _this.props,
|
|
trigger = _this$props6.trigger,
|
|
validateTrigger = _this$props6.validateTrigger,
|
|
getValueFromEvent = _this$props6.getValueFromEvent,
|
|
normalize = _this$props6.normalize,
|
|
valuePropName = _this$props6.valuePropName,
|
|
getValueProps = _this$props6.getValueProps,
|
|
fieldContext = _this$props6.fieldContext;
|
|
var mergedValidateTrigger = validateTrigger !== undefined ? validateTrigger : fieldContext.validateTrigger;
|
|
|
|
var namePath = _this.getNamePath();
|
|
|
|
var getInternalHooks = fieldContext.getInternalHooks,
|
|
getFieldsValue = fieldContext.getFieldsValue;
|
|
|
|
var _getInternalHooks = getInternalHooks(_FieldContext.HOOK_MARK),
|
|
dispatch = _getInternalHooks.dispatch;
|
|
|
|
var value = _this.getValue();
|
|
|
|
var mergedGetValueProps = getValueProps || function (val) {
|
|
return (0, _defineProperty2.default)({}, valuePropName, val);
|
|
}; // eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
|
|
|
|
var originTriggerFunc = childProps[trigger];
|
|
var control = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, childProps), mergedGetValueProps(value)); // Add trigger
|
|
|
|
control[trigger] = function () {
|
|
// Mark as touched
|
|
_this.touched = true;
|
|
_this.dirty = true;
|
|
|
|
_this.triggerMetaEvent();
|
|
|
|
var newValue;
|
|
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
if (getValueFromEvent) {
|
|
newValue = getValueFromEvent.apply(void 0, args);
|
|
} else {
|
|
newValue = _valueUtil.defaultGetValueFromEvent.apply(void 0, [valuePropName].concat(args));
|
|
}
|
|
|
|
if (normalize) {
|
|
newValue = normalize(newValue, value, getFieldsValue(true));
|
|
}
|
|
|
|
dispatch({
|
|
type: 'updateValue',
|
|
namePath: namePath,
|
|
value: newValue
|
|
});
|
|
|
|
if (originTriggerFunc) {
|
|
originTriggerFunc.apply(void 0, args);
|
|
}
|
|
}; // Add validateTrigger
|
|
|
|
|
|
var validateTriggerList = (0, _typeUtil.toArray)(mergedValidateTrigger || []);
|
|
validateTriggerList.forEach(function (triggerName) {
|
|
// Wrap additional function of component, so that we can get latest value from store
|
|
var originTrigger = control[triggerName];
|
|
|
|
control[triggerName] = function () {
|
|
if (originTrigger) {
|
|
originTrigger.apply(void 0, arguments);
|
|
} // Always use latest rules
|
|
|
|
|
|
var rules = _this.props.rules;
|
|
|
|
if (rules && rules.length) {
|
|
// We dispatch validate to root,
|
|
// since it will update related data with other field with same name
|
|
dispatch({
|
|
type: 'validateField',
|
|
namePath: namePath,
|
|
triggerName: triggerName
|
|
});
|
|
}
|
|
};
|
|
});
|
|
return control;
|
|
};
|
|
|
|
if (props.fieldContext) {
|
|
var getInternalHooks = props.fieldContext.getInternalHooks;
|
|
|
|
var _getInternalHooks2 = getInternalHooks(_FieldContext.HOOK_MARK),
|
|
initEntityValue = _getInternalHooks2.initEntityValue;
|
|
|
|
initEntityValue((0, _assertThisInitialized2.default)(_this));
|
|
}
|
|
|
|
return _this;
|
|
}
|
|
|
|
(0, _createClass2.default)(Field, [{
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
var _this$props7 = this.props,
|
|
shouldUpdate = _this$props7.shouldUpdate,
|
|
fieldContext = _this$props7.fieldContext;
|
|
this.mounted = true; // Register on init
|
|
|
|
if (fieldContext) {
|
|
var getInternalHooks = fieldContext.getInternalHooks;
|
|
|
|
var _getInternalHooks3 = getInternalHooks(_FieldContext.HOOK_MARK),
|
|
registerField = _getInternalHooks3.registerField;
|
|
|
|
this.cancelRegisterFunc = registerField(this);
|
|
} // One more render for component in case fields not ready
|
|
|
|
|
|
if (shouldUpdate === true) {
|
|
this.reRender();
|
|
}
|
|
}
|
|
}, {
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this.cancelRegister();
|
|
this.triggerMetaEvent(true);
|
|
this.mounted = false;
|
|
}
|
|
}, {
|
|
key: "reRender",
|
|
value: function reRender() {
|
|
if (!this.mounted) return;
|
|
this.forceUpdate();
|
|
}
|
|
}, {
|
|
key: "render",
|
|
value: function render() {
|
|
var resetCount = this.state.resetCount;
|
|
var children = this.props.children;
|
|
|
|
var _this$getOnlyChild = this.getOnlyChild(children),
|
|
child = _this$getOnlyChild.child,
|
|
isFunction = _this$getOnlyChild.isFunction; // Not need to `cloneElement` since user can handle this in render function self
|
|
|
|
|
|
var returnChildNode;
|
|
|
|
if (isFunction) {
|
|
returnChildNode = child;
|
|
} else if ( /*#__PURE__*/React.isValidElement(child)) {
|
|
returnChildNode = /*#__PURE__*/React.cloneElement(child, this.getControlled(child.props));
|
|
} else {
|
|
(0, _warning.default)(!child, '`children` of Field is not validate ReactElement.');
|
|
returnChildNode = child;
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement(React.Fragment, {
|
|
key: resetCount
|
|
}, returnChildNode);
|
|
}
|
|
}]);
|
|
return Field;
|
|
}(React.Component);
|
|
|
|
Field.contextType = _FieldContext.default;
|
|
Field.defaultProps = {
|
|
trigger: 'onChange',
|
|
valuePropName: 'value'
|
|
};
|
|
|
|
function WrapperField(_ref5) {
|
|
var name = _ref5.name,
|
|
restProps = (0, _objectWithoutProperties2.default)(_ref5, _excluded);
|
|
var fieldContext = React.useContext(_FieldContext.default);
|
|
var namePath = name !== undefined ? (0, _valueUtil.getNamePath)(name) : undefined;
|
|
var key = 'keep';
|
|
|
|
if (!restProps.isListField) {
|
|
key = "_".concat((namePath || []).join('_'));
|
|
} // Warning if it's a directly list field.
|
|
// We can still support multiple level field preserve.
|
|
|
|
|
|
if (process.env.NODE_ENV !== 'production' && restProps.preserve === false && restProps.isListField && namePath.length <= 1) {
|
|
(0, _warning.default)(false, '`preserve` should not apply on Form.List fields.');
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement(Field, (0, _extends2.default)({
|
|
key: key,
|
|
name: namePath
|
|
}, restProps, {
|
|
fieldContext: fieldContext
|
|
}));
|
|
}
|
|
|
|
var _default = WrapperField;
|
|
exports.default = _default;
|
|
}, function(modId) { var map = {"./FieldContext":1656641690362,"./utils/typeUtil":1656641690363,"./utils/validateUtil":1656641690364,"./utils/valueUtil":1656641690366}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690362, function(require, module, exports) {
|
|
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = exports.HOOK_MARK = void 0;
|
|
|
|
var React = _interopRequireWildcard(require("react"));
|
|
|
|
var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
|
|
|
|
var HOOK_MARK = 'RC_FORM_INTERNAL_HOOKS'; // eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
|
|
exports.HOOK_MARK = HOOK_MARK;
|
|
|
|
var warningFunc = function warningFunc() {
|
|
(0, _warning.default)(false, 'Can not find FormContext. Please make sure you wrap Field under Form.');
|
|
};
|
|
|
|
var Context = /*#__PURE__*/React.createContext({
|
|
getFieldValue: warningFunc,
|
|
getFieldsValue: warningFunc,
|
|
getFieldError: warningFunc,
|
|
getFieldWarning: warningFunc,
|
|
getFieldsError: warningFunc,
|
|
isFieldsTouched: warningFunc,
|
|
isFieldTouched: warningFunc,
|
|
isFieldValidating: warningFunc,
|
|
isFieldsValidating: warningFunc,
|
|
resetFields: warningFunc,
|
|
setFields: warningFunc,
|
|
setFieldsValue: warningFunc,
|
|
validateFields: warningFunc,
|
|
submit: warningFunc,
|
|
getInternalHooks: function getInternalHooks() {
|
|
warningFunc();
|
|
return {
|
|
dispatch: warningFunc,
|
|
initEntityValue: warningFunc,
|
|
registerField: warningFunc,
|
|
useSubscribe: warningFunc,
|
|
setInitialValues: warningFunc,
|
|
destroyForm: warningFunc,
|
|
setCallbacks: warningFunc,
|
|
registerWatch: warningFunc,
|
|
getFields: warningFunc,
|
|
setValidateMessages: warningFunc,
|
|
setPreserve: warningFunc,
|
|
getInitialValue: warningFunc
|
|
};
|
|
}
|
|
});
|
|
var _default = Context;
|
|
exports.default = _default;
|
|
}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690363, function(require, module, exports) {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.toArray = toArray;
|
|
|
|
function toArray(value) {
|
|
if (value === undefined || value === null) {
|
|
return [];
|
|
}
|
|
|
|
return Array.isArray(value) ? value : [value];
|
|
}
|
|
}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690364, function(require, module, exports) {
|
|
|
|
|
|
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.validateRules = validateRules;
|
|
|
|
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
|
|
|
|
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
|
|
|
|
var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/regeneratorRuntime"));
|
|
|
|
var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
|
|
|
|
var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
|
|
|
|
var _asyncValidator = _interopRequireDefault(require("async-validator"));
|
|
|
|
var React = _interopRequireWildcard(require("react"));
|
|
|
|
var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
|
|
|
|
var _messages = require("./messages");
|
|
|
|
var _valueUtil = require("./valueUtil");
|
|
|
|
// Remove incorrect original ts define
|
|
var AsyncValidator = _asyncValidator.default;
|
|
/**
|
|
* Replace with template.
|
|
* `I'm ${name}` + { name: 'bamboo' } = I'm bamboo
|
|
*/
|
|
|
|
function replaceMessage(template, kv) {
|
|
return template.replace(/\$\{\w+\}/g, function (str) {
|
|
var key = str.slice(2, -1);
|
|
return kv[key];
|
|
});
|
|
}
|
|
|
|
var CODE_LOGIC_ERROR = 'CODE_LOGIC_ERROR';
|
|
|
|
function validateRule(_x, _x2, _x3, _x4, _x5) {
|
|
return _validateRule.apply(this, arguments);
|
|
}
|
|
/**
|
|
* We use `async-validator` to validate the value.
|
|
* But only check one value in a time to avoid namePath validate issue.
|
|
*/
|
|
|
|
|
|
function _validateRule() {
|
|
_validateRule = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee2(name, value, rule, options, messageVariables) {
|
|
var cloneRule, originValidator, subRuleField, validator, messages, result, subResults, kv, fillVariableResult;
|
|
return (0, _regeneratorRuntime2.default)().wrap(function _callee2$(_context2) {
|
|
while (1) {
|
|
switch (_context2.prev = _context2.next) {
|
|
case 0:
|
|
cloneRule = (0, _objectSpread2.default)({}, rule); // Bug of `async-validator`
|
|
// https://github.com/react-component/field-form/issues/316
|
|
// https://github.com/react-component/field-form/issues/313
|
|
|
|
delete cloneRule.ruleIndex;
|
|
|
|
if (cloneRule.validator) {
|
|
originValidator = cloneRule.validator;
|
|
|
|
cloneRule.validator = function () {
|
|
try {
|
|
return originValidator.apply(void 0, arguments);
|
|
} catch (error) {
|
|
console.error(error);
|
|
return Promise.reject(CODE_LOGIC_ERROR);
|
|
}
|
|
};
|
|
} // We should special handle array validate
|
|
|
|
|
|
subRuleField = null;
|
|
|
|
if (cloneRule && cloneRule.type === 'array' && cloneRule.defaultField) {
|
|
subRuleField = cloneRule.defaultField;
|
|
delete cloneRule.defaultField;
|
|
}
|
|
|
|
validator = new AsyncValidator((0, _defineProperty2.default)({}, name, [cloneRule]));
|
|
messages = (0, _valueUtil.setValues)({}, _messages.defaultValidateMessages, options.validateMessages);
|
|
validator.messages(messages);
|
|
result = [];
|
|
_context2.prev = 9;
|
|
_context2.next = 12;
|
|
return Promise.resolve(validator.validate((0, _defineProperty2.default)({}, name, value), (0, _objectSpread2.default)({}, options)));
|
|
|
|
case 12:
|
|
_context2.next = 17;
|
|
break;
|
|
|
|
case 14:
|
|
_context2.prev = 14;
|
|
_context2.t0 = _context2["catch"](9);
|
|
|
|
if (_context2.t0.errors) {
|
|
result = _context2.t0.errors.map(function (_ref4, index) {
|
|
var message = _ref4.message;
|
|
var mergedMessage = message === CODE_LOGIC_ERROR ? messages.default : message;
|
|
return /*#__PURE__*/React.isValidElement(mergedMessage) ?
|
|
/*#__PURE__*/
|
|
// Wrap ReactNode with `key`
|
|
React.cloneElement(mergedMessage, {
|
|
key: "error_".concat(index)
|
|
}) : mergedMessage;
|
|
});
|
|
}
|
|
|
|
case 17:
|
|
if (!(!result.length && subRuleField)) {
|
|
_context2.next = 22;
|
|
break;
|
|
}
|
|
|
|
_context2.next = 20;
|
|
return Promise.all(value.map(function (subValue, i) {
|
|
return validateRule("".concat(name, ".").concat(i), subValue, subRuleField, options, messageVariables);
|
|
}));
|
|
|
|
case 20:
|
|
subResults = _context2.sent;
|
|
return _context2.abrupt("return", subResults.reduce(function (prev, errors) {
|
|
return [].concat((0, _toConsumableArray2.default)(prev), (0, _toConsumableArray2.default)(errors));
|
|
}, []));
|
|
|
|
case 22:
|
|
// Replace message with variables
|
|
kv = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, rule), {}, {
|
|
name: name,
|
|
enum: (rule.enum || []).join(', ')
|
|
}, messageVariables);
|
|
fillVariableResult = result.map(function (error) {
|
|
if (typeof error === 'string') {
|
|
return replaceMessage(error, kv);
|
|
}
|
|
|
|
return error;
|
|
});
|
|
return _context2.abrupt("return", fillVariableResult);
|
|
|
|
case 25:
|
|
case "end":
|
|
return _context2.stop();
|
|
}
|
|
}
|
|
}, _callee2, null, [[9, 14]]);
|
|
}));
|
|
return _validateRule.apply(this, arguments);
|
|
}
|
|
|
|
function validateRules(namePath, value, rules, options, validateFirst, messageVariables) {
|
|
var name = namePath.join('.'); // Fill rule with context
|
|
|
|
var filledRules = rules.map(function (currentRule, ruleIndex) {
|
|
var originValidatorFunc = currentRule.validator;
|
|
var cloneRule = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, currentRule), {}, {
|
|
ruleIndex: ruleIndex
|
|
}); // Replace validator if needed
|
|
|
|
if (originValidatorFunc) {
|
|
cloneRule.validator = function (rule, val, callback) {
|
|
var hasPromise = false; // Wrap callback only accept when promise not provided
|
|
|
|
var wrappedCallback = function wrappedCallback() {
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
// Wait a tick to make sure return type is a promise
|
|
Promise.resolve().then(function () {
|
|
(0, _warning.default)(!hasPromise, 'Your validator function has already return a promise. `callback` will be ignored.');
|
|
|
|
if (!hasPromise) {
|
|
callback.apply(void 0, args);
|
|
}
|
|
});
|
|
}; // Get promise
|
|
|
|
|
|
var promise = originValidatorFunc(rule, val, wrappedCallback);
|
|
hasPromise = promise && typeof promise.then === 'function' && typeof promise.catch === 'function';
|
|
/**
|
|
* 1. Use promise as the first priority.
|
|
* 2. If promise not exist, use callback with warning instead
|
|
*/
|
|
|
|
(0, _warning.default)(hasPromise, '`callback` is deprecated. Please return a promise instead.');
|
|
|
|
if (hasPromise) {
|
|
promise.then(function () {
|
|
callback();
|
|
}).catch(function (err) {
|
|
callback(err || ' ');
|
|
});
|
|
}
|
|
};
|
|
}
|
|
|
|
return cloneRule;
|
|
}).sort(function (_ref, _ref2) {
|
|
var w1 = _ref.warningOnly,
|
|
i1 = _ref.ruleIndex;
|
|
var w2 = _ref2.warningOnly,
|
|
i2 = _ref2.ruleIndex;
|
|
|
|
if (!!w1 === !!w2) {
|
|
// Let keep origin order
|
|
return i1 - i2;
|
|
}
|
|
|
|
if (w1) {
|
|
return 1;
|
|
}
|
|
|
|
return -1;
|
|
}); // Do validate rules
|
|
|
|
var summaryPromise;
|
|
|
|
if (validateFirst === true) {
|
|
// >>>>> Validate by serialization
|
|
summaryPromise = new Promise( /*#__PURE__*/function () {
|
|
var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee(resolve, reject) {
|
|
var i, rule, errors;
|
|
return (0, _regeneratorRuntime2.default)().wrap(function _callee$(_context) {
|
|
while (1) {
|
|
switch (_context.prev = _context.next) {
|
|
case 0:
|
|
i = 0;
|
|
|
|
case 1:
|
|
if (!(i < filledRules.length)) {
|
|
_context.next = 12;
|
|
break;
|
|
}
|
|
|
|
rule = filledRules[i];
|
|
_context.next = 5;
|
|
return validateRule(name, value, rule, options, messageVariables);
|
|
|
|
case 5:
|
|
errors = _context.sent;
|
|
|
|
if (!errors.length) {
|
|
_context.next = 9;
|
|
break;
|
|
}
|
|
|
|
reject([{
|
|
errors: errors,
|
|
rule: rule
|
|
}]);
|
|
return _context.abrupt("return");
|
|
|
|
case 9:
|
|
i += 1;
|
|
_context.next = 1;
|
|
break;
|
|
|
|
case 12:
|
|
/* eslint-enable */
|
|
resolve([]);
|
|
|
|
case 13:
|
|
case "end":
|
|
return _context.stop();
|
|
}
|
|
}
|
|
}, _callee);
|
|
}));
|
|
|
|
return function (_x6, _x7) {
|
|
return _ref3.apply(this, arguments);
|
|
};
|
|
}());
|
|
} else {
|
|
// >>>>> Validate by parallel
|
|
var rulePromises = filledRules.map(function (rule) {
|
|
return validateRule(name, value, rule, options, messageVariables).then(function (errors) {
|
|
return {
|
|
errors: errors,
|
|
rule: rule
|
|
};
|
|
});
|
|
});
|
|
summaryPromise = (validateFirst ? finishOnFirstFailed(rulePromises) : finishOnAllFailed(rulePromises)).then(function (errors) {
|
|
// Always change to rejection for Field to catch
|
|
return Promise.reject(errors);
|
|
});
|
|
} // Internal catch error to avoid console error log.
|
|
|
|
|
|
summaryPromise.catch(function (e) {
|
|
return e;
|
|
});
|
|
return summaryPromise;
|
|
}
|
|
|
|
function finishOnAllFailed(_x8) {
|
|
return _finishOnAllFailed.apply(this, arguments);
|
|
}
|
|
|
|
function _finishOnAllFailed() {
|
|
_finishOnAllFailed = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee3(rulePromises) {
|
|
return (0, _regeneratorRuntime2.default)().wrap(function _callee3$(_context3) {
|
|
while (1) {
|
|
switch (_context3.prev = _context3.next) {
|
|
case 0:
|
|
return _context3.abrupt("return", Promise.all(rulePromises).then(function (errorsList) {
|
|
var _ref5;
|
|
|
|
var errors = (_ref5 = []).concat.apply(_ref5, (0, _toConsumableArray2.default)(errorsList));
|
|
|
|
return errors;
|
|
}));
|
|
|
|
case 1:
|
|
case "end":
|
|
return _context3.stop();
|
|
}
|
|
}
|
|
}, _callee3);
|
|
}));
|
|
return _finishOnAllFailed.apply(this, arguments);
|
|
}
|
|
|
|
function finishOnFirstFailed(_x9) {
|
|
return _finishOnFirstFailed.apply(this, arguments);
|
|
}
|
|
|
|
function _finishOnFirstFailed() {
|
|
_finishOnFirstFailed = (0, _asyncToGenerator2.default)( /*#__PURE__*/(0, _regeneratorRuntime2.default)().mark(function _callee4(rulePromises) {
|
|
var count;
|
|
return (0, _regeneratorRuntime2.default)().wrap(function _callee4$(_context4) {
|
|
while (1) {
|
|
switch (_context4.prev = _context4.next) {
|
|
case 0:
|
|
count = 0;
|
|
return _context4.abrupt("return", new Promise(function (resolve) {
|
|
rulePromises.forEach(function (promise) {
|
|
promise.then(function (ruleError) {
|
|
if (ruleError.errors.length) {
|
|
resolve([ruleError]);
|
|
}
|
|
|
|
count += 1;
|
|
|
|
if (count === rulePromises.length) {
|
|
resolve([]);
|
|
}
|
|
});
|
|
});
|
|
}));
|
|
|
|
case 2:
|
|
case "end":
|
|
return _context4.stop();
|
|
}
|
|
}
|
|
}, _callee4);
|
|
}));
|
|
return _finishOnFirstFailed.apply(this, arguments);
|
|
}
|
|
}, function(modId) { var map = {"./messages":1656641690365,"./valueUtil":1656641690366}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690365, function(require, module, exports) {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.defaultValidateMessages = void 0;
|
|
var typeTemplate = "'${name}' is not a valid ${type}";
|
|
var defaultValidateMessages = {
|
|
default: "Validation error on field '${name}'",
|
|
required: "'${name}' is required",
|
|
enum: "'${name}' must be one of [${enum}]",
|
|
whitespace: "'${name}' cannot be empty",
|
|
date: {
|
|
format: "'${name}' is invalid for format date",
|
|
parse: "'${name}' could not be parsed as date",
|
|
invalid: "'${name}' is invalid date"
|
|
},
|
|
types: {
|
|
string: typeTemplate,
|
|
method: typeTemplate,
|
|
array: typeTemplate,
|
|
object: typeTemplate,
|
|
number: typeTemplate,
|
|
date: typeTemplate,
|
|
boolean: typeTemplate,
|
|
integer: typeTemplate,
|
|
float: typeTemplate,
|
|
regexp: typeTemplate,
|
|
email: typeTemplate,
|
|
url: typeTemplate,
|
|
hex: typeTemplate
|
|
},
|
|
string: {
|
|
len: "'${name}' must be exactly ${len} characters",
|
|
min: "'${name}' must be at least ${min} characters",
|
|
max: "'${name}' cannot be longer than ${max} characters",
|
|
range: "'${name}' must be between ${min} and ${max} characters"
|
|
},
|
|
number: {
|
|
len: "'${name}' must equal ${len}",
|
|
min: "'${name}' cannot be less than ${min}",
|
|
max: "'${name}' cannot be greater than ${max}",
|
|
range: "'${name}' must be between ${min} and ${max}"
|
|
},
|
|
array: {
|
|
len: "'${name}' must be exactly ${len} in length",
|
|
min: "'${name}' cannot be less than ${min} in length",
|
|
max: "'${name}' cannot be greater than ${max} in length",
|
|
range: "'${name}' must be between ${min} and ${max} in length"
|
|
},
|
|
pattern: {
|
|
mismatch: "'${name}' does not match pattern ${pattern}"
|
|
}
|
|
};
|
|
exports.defaultValidateMessages = defaultValidateMessages;
|
|
}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690366, function(require, module, exports) {
|
|
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.cloneByNamePathList = cloneByNamePathList;
|
|
exports.containsNamePath = containsNamePath;
|
|
exports.defaultGetValueFromEvent = defaultGetValueFromEvent;
|
|
exports.getNamePath = getNamePath;
|
|
exports.getValue = getValue;
|
|
exports.isSimilar = isSimilar;
|
|
exports.matchNamePath = matchNamePath;
|
|
exports.move = move;
|
|
exports.setValue = setValue;
|
|
exports.setValues = setValues;
|
|
|
|
var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
|
|
|
|
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
|
|
|
|
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
|
|
|
|
var _get = _interopRequireDefault(require("rc-util/lib/utils/get"));
|
|
|
|
var _set = _interopRequireDefault(require("rc-util/lib/utils/set"));
|
|
|
|
var _typeUtil = require("./typeUtil");
|
|
|
|
var _cloneDeep = _interopRequireDefault(require("../utils/cloneDeep"));
|
|
|
|
/**
|
|
* Convert name to internal supported format.
|
|
* This function should keep since we still thinking if need support like `a.b.c` format.
|
|
* 'a' => ['a']
|
|
* 123 => [123]
|
|
* ['a', 123] => ['a', 123]
|
|
*/
|
|
function getNamePath(path) {
|
|
return (0, _typeUtil.toArray)(path);
|
|
}
|
|
|
|
function getValue(store, namePath) {
|
|
var value = (0, _get.default)(store, namePath);
|
|
return value;
|
|
}
|
|
|
|
function setValue(store, namePath, value) {
|
|
var removeIfUndefined = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
|
|
var newStore = (0, _set.default)(store, namePath, value, removeIfUndefined);
|
|
return newStore;
|
|
}
|
|
|
|
function cloneByNamePathList(store, namePathList) {
|
|
var newStore = {};
|
|
namePathList.forEach(function (namePath) {
|
|
var value = getValue(store, namePath);
|
|
newStore = setValue(newStore, namePath, value);
|
|
});
|
|
return newStore;
|
|
}
|
|
|
|
function containsNamePath(namePathList, namePath) {
|
|
return namePathList && namePathList.some(function (path) {
|
|
return matchNamePath(path, namePath);
|
|
});
|
|
}
|
|
|
|
function isObject(obj) {
|
|
return (0, _typeof2.default)(obj) === 'object' && obj !== null && Object.getPrototypeOf(obj) === Object.prototype;
|
|
}
|
|
/**
|
|
* Copy values into store and return a new values object
|
|
* ({ a: 1, b: { c: 2 } }, { a: 4, b: { d: 5 } }) => { a: 4, b: { c: 2, d: 5 } }
|
|
*/
|
|
|
|
|
|
function internalSetValues(store, values) {
|
|
var newStore = Array.isArray(store) ? (0, _toConsumableArray2.default)(store) : (0, _objectSpread2.default)({}, store);
|
|
|
|
if (!values) {
|
|
return newStore;
|
|
}
|
|
|
|
Object.keys(values).forEach(function (key) {
|
|
var prevValue = newStore[key];
|
|
var value = values[key]; // If both are object (but target is not array), we use recursion to set deep value
|
|
|
|
var recursive = isObject(prevValue) && isObject(value);
|
|
newStore[key] = recursive ? internalSetValues(prevValue, value || {}) : (0, _cloneDeep.default)(value); // Clone deep for arrays
|
|
});
|
|
return newStore;
|
|
}
|
|
|
|
function setValues(store) {
|
|
for (var _len = arguments.length, restValues = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
restValues[_key - 1] = arguments[_key];
|
|
}
|
|
|
|
return restValues.reduce(function (current, newStore) {
|
|
return internalSetValues(current, newStore);
|
|
}, store);
|
|
}
|
|
|
|
function matchNamePath(namePath, changedNamePath) {
|
|
if (!namePath || !changedNamePath || namePath.length !== changedNamePath.length) {
|
|
return false;
|
|
}
|
|
|
|
return namePath.every(function (nameUnit, i) {
|
|
return changedNamePath[i] === nameUnit;
|
|
});
|
|
}
|
|
|
|
function isSimilar(source, target) {
|
|
if (source === target) {
|
|
return true;
|
|
}
|
|
|
|
if (!source && target || source && !target) {
|
|
return false;
|
|
}
|
|
|
|
if (!source || !target || (0, _typeof2.default)(source) !== 'object' || (0, _typeof2.default)(target) !== 'object') {
|
|
return false;
|
|
}
|
|
|
|
var sourceKeys = Object.keys(source);
|
|
var targetKeys = Object.keys(target);
|
|
var keys = new Set([].concat((0, _toConsumableArray2.default)(sourceKeys), (0, _toConsumableArray2.default)(targetKeys)));
|
|
return (0, _toConsumableArray2.default)(keys).every(function (key) {
|
|
var sourceValue = source[key];
|
|
var targetValue = target[key];
|
|
|
|
if (typeof sourceValue === 'function' && typeof targetValue === 'function') {
|
|
return true;
|
|
}
|
|
|
|
return sourceValue === targetValue;
|
|
});
|
|
}
|
|
|
|
function defaultGetValueFromEvent(valuePropName) {
|
|
var event = arguments.length <= 1 ? undefined : arguments[1];
|
|
|
|
if (event && event.target && (0, _typeof2.default)(event.target) === 'object' && valuePropName in event.target) {
|
|
return event.target[valuePropName];
|
|
}
|
|
|
|
return event;
|
|
}
|
|
/**
|
|
* Moves an array item from one position in an array to another.
|
|
*
|
|
* Note: This is a pure function so a new array will be returned, instead
|
|
* of altering the array argument.
|
|
*
|
|
* @param array Array in which to move an item. (required)
|
|
* @param moveIndex The index of the item to move. (required)
|
|
* @param toIndex The index to move item at moveIndex to. (required)
|
|
*/
|
|
|
|
|
|
function move(array, moveIndex, toIndex) {
|
|
var length = array.length;
|
|
|
|
if (moveIndex < 0 || moveIndex >= length || toIndex < 0 || toIndex >= length) {
|
|
return array;
|
|
}
|
|
|
|
var item = array[moveIndex];
|
|
var diff = moveIndex - toIndex;
|
|
|
|
if (diff > 0) {
|
|
// move left
|
|
return [].concat((0, _toConsumableArray2.default)(array.slice(0, toIndex)), [item], (0, _toConsumableArray2.default)(array.slice(toIndex, moveIndex)), (0, _toConsumableArray2.default)(array.slice(moveIndex + 1, length)));
|
|
}
|
|
|
|
if (diff < 0) {
|
|
// move right
|
|
return [].concat((0, _toConsumableArray2.default)(array.slice(0, moveIndex)), (0, _toConsumableArray2.default)(array.slice(moveIndex + 1, toIndex + 1)), [item], (0, _toConsumableArray2.default)(array.slice(toIndex + 1, length)));
|
|
}
|
|
|
|
return array;
|
|
}
|
|
}, function(modId) { var map = {"./typeUtil":1656641690363,"../utils/cloneDeep":1656641690367}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690367, function(require, module, exports) {
|
|
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
|
|
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
|
|
|
|
function cloneDeep(val) {
|
|
if (Array.isArray(val)) {
|
|
return cloneArrayDeep(val);
|
|
} else if ((0, _typeof2.default)(val) === 'object' && val !== null) {
|
|
return cloneObjectDeep(val);
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
function cloneObjectDeep(val) {
|
|
if (Object.getPrototypeOf(val) === Object.prototype) {
|
|
var res = {};
|
|
|
|
for (var key in val) {
|
|
res[key] = cloneDeep(val[key]);
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
return val;
|
|
}
|
|
|
|
function cloneArrayDeep(val) {
|
|
return val.map(function (item) {
|
|
return cloneDeep(item);
|
|
});
|
|
}
|
|
|
|
var _default = cloneDeep;
|
|
exports.default = _default;
|
|
}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690368, function(require, module, exports) {
|
|
|
|
|
|
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
|
|
var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
|
|
|
|
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
|
|
|
|
var React = _interopRequireWildcard(require("react"));
|
|
|
|
var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
|
|
|
|
var _FieldContext = _interopRequireDefault(require("./FieldContext"));
|
|
|
|
var _Field = _interopRequireDefault(require("./Field"));
|
|
|
|
var _valueUtil = require("./utils/valueUtil");
|
|
|
|
var _ListContext = _interopRequireDefault(require("./ListContext"));
|
|
|
|
var List = function List(_ref) {
|
|
var name = _ref.name,
|
|
initialValue = _ref.initialValue,
|
|
children = _ref.children,
|
|
rules = _ref.rules,
|
|
validateTrigger = _ref.validateTrigger;
|
|
var context = React.useContext(_FieldContext.default);
|
|
var keyRef = React.useRef({
|
|
keys: [],
|
|
id: 0
|
|
});
|
|
var keyManager = keyRef.current;
|
|
var prefixName = React.useMemo(function () {
|
|
var parentPrefixName = (0, _valueUtil.getNamePath)(context.prefixName) || [];
|
|
return [].concat((0, _toConsumableArray2.default)(parentPrefixName), (0, _toConsumableArray2.default)((0, _valueUtil.getNamePath)(name)));
|
|
}, [context.prefixName, name]);
|
|
var fieldContext = React.useMemo(function () {
|
|
return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, context), {}, {
|
|
prefixName: prefixName
|
|
});
|
|
}, [context, prefixName]); // List context
|
|
|
|
var listContext = React.useMemo(function () {
|
|
return {
|
|
getKey: function getKey(namePath) {
|
|
var len = prefixName.length;
|
|
var pathName = namePath[len];
|
|
return [keyManager.keys[pathName], namePath.slice(len + 1)];
|
|
}
|
|
};
|
|
}, [prefixName]); // User should not pass `children` as other type.
|
|
|
|
if (typeof children !== 'function') {
|
|
(0, _warning.default)(false, 'Form.List only accepts function as children.');
|
|
return null;
|
|
}
|
|
|
|
var shouldUpdate = function shouldUpdate(prevValue, nextValue, _ref2) {
|
|
var source = _ref2.source;
|
|
|
|
if (source === 'internal') {
|
|
return false;
|
|
}
|
|
|
|
return prevValue !== nextValue;
|
|
};
|
|
|
|
return /*#__PURE__*/React.createElement(_ListContext.default.Provider, {
|
|
value: listContext
|
|
}, /*#__PURE__*/React.createElement(_FieldContext.default.Provider, {
|
|
value: fieldContext
|
|
}, /*#__PURE__*/React.createElement(_Field.default, {
|
|
name: [],
|
|
shouldUpdate: shouldUpdate,
|
|
rules: rules,
|
|
validateTrigger: validateTrigger,
|
|
initialValue: initialValue,
|
|
isList: true
|
|
}, function (_ref3, meta) {
|
|
var _ref3$value = _ref3.value,
|
|
value = _ref3$value === void 0 ? [] : _ref3$value,
|
|
onChange = _ref3.onChange;
|
|
var getFieldValue = context.getFieldValue;
|
|
|
|
var getNewValue = function getNewValue() {
|
|
var values = getFieldValue(prefixName || []);
|
|
return values || [];
|
|
};
|
|
/**
|
|
* Always get latest value in case user update fields by `form` api.
|
|
*/
|
|
|
|
|
|
var operations = {
|
|
add: function add(defaultValue, index) {
|
|
// Mapping keys
|
|
var newValue = getNewValue();
|
|
|
|
if (index >= 0 && index <= newValue.length) {
|
|
keyManager.keys = [].concat((0, _toConsumableArray2.default)(keyManager.keys.slice(0, index)), [keyManager.id], (0, _toConsumableArray2.default)(keyManager.keys.slice(index)));
|
|
onChange([].concat((0, _toConsumableArray2.default)(newValue.slice(0, index)), [defaultValue], (0, _toConsumableArray2.default)(newValue.slice(index))));
|
|
} else {
|
|
if (process.env.NODE_ENV !== 'production' && (index < 0 || index > newValue.length)) {
|
|
(0, _warning.default)(false, 'The second parameter of the add function should be a valid positive number.');
|
|
}
|
|
|
|
keyManager.keys = [].concat((0, _toConsumableArray2.default)(keyManager.keys), [keyManager.id]);
|
|
onChange([].concat((0, _toConsumableArray2.default)(newValue), [defaultValue]));
|
|
}
|
|
|
|
keyManager.id += 1;
|
|
},
|
|
remove: function remove(index) {
|
|
var newValue = getNewValue();
|
|
var indexSet = new Set(Array.isArray(index) ? index : [index]);
|
|
|
|
if (indexSet.size <= 0) {
|
|
return;
|
|
}
|
|
|
|
keyManager.keys = keyManager.keys.filter(function (_, keysIndex) {
|
|
return !indexSet.has(keysIndex);
|
|
}); // Trigger store change
|
|
|
|
onChange(newValue.filter(function (_, valueIndex) {
|
|
return !indexSet.has(valueIndex);
|
|
}));
|
|
},
|
|
move: function move(from, to) {
|
|
if (from === to) {
|
|
return;
|
|
}
|
|
|
|
var newValue = getNewValue(); // Do not handle out of range
|
|
|
|
if (from < 0 || from >= newValue.length || to < 0 || to >= newValue.length) {
|
|
return;
|
|
}
|
|
|
|
keyManager.keys = (0, _valueUtil.move)(keyManager.keys, from, to); // Trigger store change
|
|
|
|
onChange((0, _valueUtil.move)(newValue, from, to));
|
|
}
|
|
};
|
|
var listValue = value || [];
|
|
|
|
if (!Array.isArray(listValue)) {
|
|
listValue = [];
|
|
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
(0, _warning.default)(false, "Current value of '".concat(prefixName.join(' > '), "' is not an array type."));
|
|
}
|
|
}
|
|
|
|
return children(listValue.map(function (__, index) {
|
|
var key = keyManager.keys[index];
|
|
|
|
if (key === undefined) {
|
|
keyManager.keys[index] = keyManager.id;
|
|
key = keyManager.keys[index];
|
|
keyManager.id += 1;
|
|
}
|
|
|
|
return {
|
|
name: index,
|
|
key: key,
|
|
isListField: true
|
|
};
|
|
}), operations, meta);
|
|
})));
|
|
};
|
|
|
|
var _default = List;
|
|
exports.default = _default;
|
|
}, function(modId) { var map = {"./FieldContext":1656641690362,"./Field":1656641690361,"./utils/valueUtil":1656641690366,"./ListContext":1656641690369}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690369, function(require, module, exports) {
|
|
|
|
|
|
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
|
|
var React = _interopRequireWildcard(require("react"));
|
|
|
|
var ListContext = /*#__PURE__*/React.createContext(null);
|
|
var _default = ListContext;
|
|
exports.default = _default;
|
|
}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690370, function(require, module, exports) {
|
|
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = exports.FormStore = void 0;
|
|
|
|
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
|
|
|
|
var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
|
|
|
|
var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
|
|
|
|
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
|
|
|
|
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
|
|
|
|
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
|
|
|
|
var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
|
|
|
|
var React = _interopRequireWildcard(require("react"));
|
|
|
|
var _FieldContext = require("./FieldContext");
|
|
|
|
var _asyncUtil = require("./utils/asyncUtil");
|
|
|
|
var _cloneDeep = _interopRequireDefault(require("./utils/cloneDeep"));
|
|
|
|
var _messages = require("./utils/messages");
|
|
|
|
var _NameMap = _interopRequireDefault(require("./utils/NameMap"));
|
|
|
|
var _valueUtil = require("./utils/valueUtil");
|
|
|
|
var _excluded = ["name", "errors"];
|
|
var FormStore = /*#__PURE__*/(0, _createClass2.default)(function FormStore(forceRootUpdate) {
|
|
var _this = this;
|
|
|
|
(0, _classCallCheck2.default)(this, FormStore);
|
|
this.formHooked = false;
|
|
this.forceRootUpdate = void 0;
|
|
this.subscribable = true;
|
|
this.store = {};
|
|
this.fieldEntities = [];
|
|
this.initialValues = {};
|
|
this.callbacks = {};
|
|
this.validateMessages = null;
|
|
this.preserve = null;
|
|
this.lastValidatePromise = null;
|
|
|
|
this.getForm = function () {
|
|
return {
|
|
getFieldValue: _this.getFieldValue,
|
|
getFieldsValue: _this.getFieldsValue,
|
|
getFieldError: _this.getFieldError,
|
|
getFieldWarning: _this.getFieldWarning,
|
|
getFieldsError: _this.getFieldsError,
|
|
isFieldsTouched: _this.isFieldsTouched,
|
|
isFieldTouched: _this.isFieldTouched,
|
|
isFieldValidating: _this.isFieldValidating,
|
|
isFieldsValidating: _this.isFieldsValidating,
|
|
resetFields: _this.resetFields,
|
|
setFields: _this.setFields,
|
|
setFieldsValue: _this.setFieldsValue,
|
|
validateFields: _this.validateFields,
|
|
submit: _this.submit,
|
|
_init: true,
|
|
getInternalHooks: _this.getInternalHooks
|
|
};
|
|
};
|
|
|
|
this.getInternalHooks = function (key) {
|
|
if (key === _FieldContext.HOOK_MARK) {
|
|
_this.formHooked = true;
|
|
return {
|
|
dispatch: _this.dispatch,
|
|
initEntityValue: _this.initEntityValue,
|
|
registerField: _this.registerField,
|
|
useSubscribe: _this.useSubscribe,
|
|
setInitialValues: _this.setInitialValues,
|
|
destroyForm: _this.destroyForm,
|
|
setCallbacks: _this.setCallbacks,
|
|
setValidateMessages: _this.setValidateMessages,
|
|
getFields: _this.getFields,
|
|
setPreserve: _this.setPreserve,
|
|
getInitialValue: _this.getInitialValue,
|
|
registerWatch: _this.registerWatch
|
|
};
|
|
}
|
|
|
|
(0, _warning.default)(false, '`getInternalHooks` is internal usage. Should not call directly.');
|
|
return null;
|
|
};
|
|
|
|
this.useSubscribe = function (subscribable) {
|
|
_this.subscribable = subscribable;
|
|
};
|
|
|
|
this.prevWithoutPreserves = null;
|
|
|
|
this.setInitialValues = function (initialValues, init) {
|
|
_this.initialValues = initialValues || {};
|
|
|
|
if (init) {
|
|
var _this$prevWithoutPres;
|
|
|
|
var nextStore = (0, _valueUtil.setValues)({}, initialValues, _this.store); // We will take consider prev form unmount fields.
|
|
// When the field is not `preserve`, we need fill this with initialValues instead of store.
|
|
// eslint-disable-next-line array-callback-return
|
|
|
|
(_this$prevWithoutPres = _this.prevWithoutPreserves) === null || _this$prevWithoutPres === void 0 ? void 0 : _this$prevWithoutPres.map(function (_ref) {
|
|
var namePath = _ref.key;
|
|
nextStore = (0, _valueUtil.setValue)(nextStore, namePath, (0, _valueUtil.getValue)(initialValues, namePath));
|
|
});
|
|
_this.prevWithoutPreserves = null;
|
|
|
|
_this.updateStore(nextStore);
|
|
}
|
|
};
|
|
|
|
this.destroyForm = function () {
|
|
var prevWithoutPreserves = new _NameMap.default();
|
|
|
|
_this.getFieldEntities(true).forEach(function (entity) {
|
|
if (!_this.isMergedPreserve(entity.isPreserve())) {
|
|
prevWithoutPreserves.set(entity.getNamePath(), true);
|
|
}
|
|
});
|
|
|
|
_this.prevWithoutPreserves = prevWithoutPreserves;
|
|
};
|
|
|
|
this.getInitialValue = function (namePath) {
|
|
var initValue = (0, _valueUtil.getValue)(_this.initialValues, namePath); // Not cloneDeep when without `namePath`
|
|
|
|
return namePath.length ? (0, _cloneDeep.default)(initValue) : initValue;
|
|
};
|
|
|
|
this.setCallbacks = function (callbacks) {
|
|
_this.callbacks = callbacks;
|
|
};
|
|
|
|
this.setValidateMessages = function (validateMessages) {
|
|
_this.validateMessages = validateMessages;
|
|
};
|
|
|
|
this.setPreserve = function (preserve) {
|
|
_this.preserve = preserve;
|
|
};
|
|
|
|
this.watchList = [];
|
|
|
|
this.registerWatch = function (callback) {
|
|
_this.watchList.push(callback);
|
|
|
|
return function () {
|
|
_this.watchList = _this.watchList.filter(function (fn) {
|
|
return fn !== callback;
|
|
});
|
|
};
|
|
};
|
|
|
|
this.notifyWatch = function () {
|
|
var namePath = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
|
|
|
|
// No need to cost perf when nothing need to watch
|
|
if (_this.watchList.length) {
|
|
var values = _this.getFieldsValue();
|
|
|
|
_this.watchList.forEach(function (callback) {
|
|
callback(values, namePath);
|
|
});
|
|
}
|
|
};
|
|
|
|
this.timeoutId = null;
|
|
|
|
this.warningUnhooked = function () {
|
|
if (process.env.NODE_ENV !== 'production' && !_this.timeoutId && typeof window !== 'undefined') {
|
|
_this.timeoutId = setTimeout(function () {
|
|
_this.timeoutId = null;
|
|
|
|
if (!_this.formHooked) {
|
|
(0, _warning.default)(false, 'Instance created by `useForm` is not connected to any Form element. Forget to pass `form` prop?');
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
this.updateStore = function (nextStore) {
|
|
_this.store = nextStore;
|
|
};
|
|
|
|
this.getFieldEntities = function () {
|
|
var pure = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
|
|
|
if (!pure) {
|
|
return _this.fieldEntities;
|
|
}
|
|
|
|
return _this.fieldEntities.filter(function (field) {
|
|
return field.getNamePath().length;
|
|
});
|
|
};
|
|
|
|
this.getFieldsMap = function () {
|
|
var pure = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
|
|
var cache = new _NameMap.default();
|
|
|
|
_this.getFieldEntities(pure).forEach(function (field) {
|
|
var namePath = field.getNamePath();
|
|
cache.set(namePath, field);
|
|
});
|
|
|
|
return cache;
|
|
};
|
|
|
|
this.getFieldEntitiesForNamePathList = function (nameList) {
|
|
if (!nameList) {
|
|
return _this.getFieldEntities(true);
|
|
}
|
|
|
|
var cache = _this.getFieldsMap(true);
|
|
|
|
return nameList.map(function (name) {
|
|
var namePath = (0, _valueUtil.getNamePath)(name);
|
|
return cache.get(namePath) || {
|
|
INVALIDATE_NAME_PATH: (0, _valueUtil.getNamePath)(name)
|
|
};
|
|
});
|
|
};
|
|
|
|
this.getFieldsValue = function (nameList, filterFunc) {
|
|
_this.warningUnhooked();
|
|
|
|
if (nameList === true && !filterFunc) {
|
|
return _this.store;
|
|
}
|
|
|
|
var fieldEntities = _this.getFieldEntitiesForNamePathList(Array.isArray(nameList) ? nameList : null);
|
|
|
|
var filteredNameList = [];
|
|
fieldEntities.forEach(function (entity) {
|
|
var _entity$isListField;
|
|
|
|
var namePath = 'INVALIDATE_NAME_PATH' in entity ? entity.INVALIDATE_NAME_PATH : entity.getNamePath(); // Ignore when it's a list item and not specific the namePath,
|
|
// since parent field is already take in count
|
|
|
|
if (!nameList && ((_entity$isListField = entity.isListField) === null || _entity$isListField === void 0 ? void 0 : _entity$isListField.call(entity))) {
|
|
return;
|
|
}
|
|
|
|
if (!filterFunc) {
|
|
filteredNameList.push(namePath);
|
|
} else {
|
|
var meta = 'getMeta' in entity ? entity.getMeta() : null;
|
|
|
|
if (filterFunc(meta)) {
|
|
filteredNameList.push(namePath);
|
|
}
|
|
}
|
|
});
|
|
return (0, _valueUtil.cloneByNamePathList)(_this.store, filteredNameList.map(_valueUtil.getNamePath));
|
|
};
|
|
|
|
this.getFieldValue = function (name) {
|
|
_this.warningUnhooked();
|
|
|
|
var namePath = (0, _valueUtil.getNamePath)(name);
|
|
return (0, _valueUtil.getValue)(_this.store, namePath);
|
|
};
|
|
|
|
this.getFieldsError = function (nameList) {
|
|
_this.warningUnhooked();
|
|
|
|
var fieldEntities = _this.getFieldEntitiesForNamePathList(nameList);
|
|
|
|
return fieldEntities.map(function (entity, index) {
|
|
if (entity && !('INVALIDATE_NAME_PATH' in entity)) {
|
|
return {
|
|
name: entity.getNamePath(),
|
|
errors: entity.getErrors(),
|
|
warnings: entity.getWarnings()
|
|
};
|
|
}
|
|
|
|
return {
|
|
name: (0, _valueUtil.getNamePath)(nameList[index]),
|
|
errors: [],
|
|
warnings: []
|
|
};
|
|
});
|
|
};
|
|
|
|
this.getFieldError = function (name) {
|
|
_this.warningUnhooked();
|
|
|
|
var namePath = (0, _valueUtil.getNamePath)(name);
|
|
|
|
var fieldError = _this.getFieldsError([namePath])[0];
|
|
|
|
return fieldError.errors;
|
|
};
|
|
|
|
this.getFieldWarning = function (name) {
|
|
_this.warningUnhooked();
|
|
|
|
var namePath = (0, _valueUtil.getNamePath)(name);
|
|
|
|
var fieldError = _this.getFieldsError([namePath])[0];
|
|
|
|
return fieldError.warnings;
|
|
};
|
|
|
|
this.isFieldsTouched = function () {
|
|
_this.warningUnhooked();
|
|
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
var arg0 = args[0],
|
|
arg1 = args[1];
|
|
var namePathList;
|
|
var isAllFieldsTouched = false;
|
|
|
|
if (args.length === 0) {
|
|
namePathList = null;
|
|
} else if (args.length === 1) {
|
|
if (Array.isArray(arg0)) {
|
|
namePathList = arg0.map(_valueUtil.getNamePath);
|
|
isAllFieldsTouched = false;
|
|
} else {
|
|
namePathList = null;
|
|
isAllFieldsTouched = arg0;
|
|
}
|
|
} else {
|
|
namePathList = arg0.map(_valueUtil.getNamePath);
|
|
isAllFieldsTouched = arg1;
|
|
}
|
|
|
|
var fieldEntities = _this.getFieldEntities(true);
|
|
|
|
var isFieldTouched = function isFieldTouched(field) {
|
|
return field.isFieldTouched();
|
|
}; // ===== Will get fully compare when not config namePathList =====
|
|
|
|
|
|
if (!namePathList) {
|
|
return isAllFieldsTouched ? fieldEntities.every(isFieldTouched) : fieldEntities.some(isFieldTouched);
|
|
} // Generate a nest tree for validate
|
|
|
|
|
|
var map = new _NameMap.default();
|
|
namePathList.forEach(function (shortNamePath) {
|
|
map.set(shortNamePath, []);
|
|
});
|
|
fieldEntities.forEach(function (field) {
|
|
var fieldNamePath = field.getNamePath(); // Find matched entity and put into list
|
|
|
|
namePathList.forEach(function (shortNamePath) {
|
|
if (shortNamePath.every(function (nameUnit, i) {
|
|
return fieldNamePath[i] === nameUnit;
|
|
})) {
|
|
map.update(shortNamePath, function (list) {
|
|
return [].concat((0, _toConsumableArray2.default)(list), [field]);
|
|
});
|
|
}
|
|
});
|
|
}); // Check if NameMap value is touched
|
|
|
|
var isNamePathListTouched = function isNamePathListTouched(entities) {
|
|
return entities.some(isFieldTouched);
|
|
};
|
|
|
|
var namePathListEntities = map.map(function (_ref2) {
|
|
var value = _ref2.value;
|
|
return value;
|
|
});
|
|
return isAllFieldsTouched ? namePathListEntities.every(isNamePathListTouched) : namePathListEntities.some(isNamePathListTouched);
|
|
};
|
|
|
|
this.isFieldTouched = function (name) {
|
|
_this.warningUnhooked();
|
|
|
|
return _this.isFieldsTouched([name]);
|
|
};
|
|
|
|
this.isFieldsValidating = function (nameList) {
|
|
_this.warningUnhooked();
|
|
|
|
var fieldEntities = _this.getFieldEntities();
|
|
|
|
if (!nameList) {
|
|
return fieldEntities.some(function (testField) {
|
|
return testField.isFieldValidating();
|
|
});
|
|
}
|
|
|
|
var namePathList = nameList.map(_valueUtil.getNamePath);
|
|
return fieldEntities.some(function (testField) {
|
|
var fieldNamePath = testField.getNamePath();
|
|
return (0, _valueUtil.containsNamePath)(namePathList, fieldNamePath) && testField.isFieldValidating();
|
|
});
|
|
};
|
|
|
|
this.isFieldValidating = function (name) {
|
|
_this.warningUnhooked();
|
|
|
|
return _this.isFieldsValidating([name]);
|
|
};
|
|
|
|
this.resetWithFieldInitialValue = function () {
|
|
var info = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
// Create cache
|
|
var cache = new _NameMap.default();
|
|
|
|
var fieldEntities = _this.getFieldEntities(true);
|
|
|
|
fieldEntities.forEach(function (field) {
|
|
var initialValue = field.props.initialValue;
|
|
var namePath = field.getNamePath(); // Record only if has `initialValue`
|
|
|
|
if (initialValue !== undefined) {
|
|
var records = cache.get(namePath) || new Set();
|
|
records.add({
|
|
entity: field,
|
|
value: initialValue
|
|
});
|
|
cache.set(namePath, records);
|
|
}
|
|
}); // Reset
|
|
|
|
var resetWithFields = function resetWithFields(entities) {
|
|
entities.forEach(function (field) {
|
|
var initialValue = field.props.initialValue;
|
|
|
|
if (initialValue !== undefined) {
|
|
var namePath = field.getNamePath();
|
|
|
|
var formInitialValue = _this.getInitialValue(namePath);
|
|
|
|
if (formInitialValue !== undefined) {
|
|
// Warning if conflict with form initialValues and do not modify value
|
|
(0, _warning.default)(false, "Form already set 'initialValues' with path '".concat(namePath.join('.'), "'. Field can not overwrite it."));
|
|
} else {
|
|
var records = cache.get(namePath);
|
|
|
|
if (records && records.size > 1) {
|
|
// Warning if multiple field set `initialValue`and do not modify value
|
|
(0, _warning.default)(false, "Multiple Field with path '".concat(namePath.join('.'), "' set 'initialValue'. Can not decide which one to pick."));
|
|
} else if (records) {
|
|
var originValue = _this.getFieldValue(namePath); // Set `initialValue`
|
|
|
|
|
|
if (!info.skipExist || originValue === undefined) {
|
|
_this.updateStore((0, _valueUtil.setValue)(_this.store, namePath, (0, _toConsumableArray2.default)(records)[0].value));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
};
|
|
|
|
var requiredFieldEntities;
|
|
|
|
if (info.entities) {
|
|
requiredFieldEntities = info.entities;
|
|
} else if (info.namePathList) {
|
|
requiredFieldEntities = [];
|
|
info.namePathList.forEach(function (namePath) {
|
|
var records = cache.get(namePath);
|
|
|
|
if (records) {
|
|
var _requiredFieldEntitie;
|
|
|
|
(_requiredFieldEntitie = requiredFieldEntities).push.apply(_requiredFieldEntitie, (0, _toConsumableArray2.default)((0, _toConsumableArray2.default)(records).map(function (r) {
|
|
return r.entity;
|
|
})));
|
|
}
|
|
});
|
|
} else {
|
|
requiredFieldEntities = fieldEntities;
|
|
}
|
|
|
|
resetWithFields(requiredFieldEntities);
|
|
};
|
|
|
|
this.resetFields = function (nameList) {
|
|
_this.warningUnhooked();
|
|
|
|
var prevStore = _this.store;
|
|
|
|
if (!nameList) {
|
|
_this.updateStore((0, _valueUtil.setValues)({}, _this.initialValues));
|
|
|
|
_this.resetWithFieldInitialValue();
|
|
|
|
_this.notifyObservers(prevStore, null, {
|
|
type: 'reset'
|
|
});
|
|
|
|
_this.notifyWatch();
|
|
|
|
return;
|
|
} // Reset by `nameList`
|
|
|
|
|
|
var namePathList = nameList.map(_valueUtil.getNamePath);
|
|
namePathList.forEach(function (namePath) {
|
|
var initialValue = _this.getInitialValue(namePath);
|
|
|
|
_this.updateStore((0, _valueUtil.setValue)(_this.store, namePath, initialValue));
|
|
});
|
|
|
|
_this.resetWithFieldInitialValue({
|
|
namePathList: namePathList
|
|
});
|
|
|
|
_this.notifyObservers(prevStore, namePathList, {
|
|
type: 'reset'
|
|
});
|
|
|
|
_this.notifyWatch(namePathList);
|
|
};
|
|
|
|
this.setFields = function (fields) {
|
|
_this.warningUnhooked();
|
|
|
|
var prevStore = _this.store;
|
|
var namePathList = [];
|
|
fields.forEach(function (fieldData) {
|
|
var name = fieldData.name,
|
|
errors = fieldData.errors,
|
|
data = (0, _objectWithoutProperties2.default)(fieldData, _excluded);
|
|
var namePath = (0, _valueUtil.getNamePath)(name);
|
|
namePathList.push(namePath); // Value
|
|
|
|
if ('value' in data) {
|
|
_this.updateStore((0, _valueUtil.setValue)(_this.store, namePath, data.value));
|
|
}
|
|
|
|
_this.notifyObservers(prevStore, [namePath], {
|
|
type: 'setField',
|
|
data: fieldData
|
|
});
|
|
});
|
|
|
|
_this.notifyWatch(namePathList);
|
|
};
|
|
|
|
this.getFields = function () {
|
|
var entities = _this.getFieldEntities(true);
|
|
|
|
var fields = entities.map(function (field) {
|
|
var namePath = field.getNamePath();
|
|
var meta = field.getMeta();
|
|
var fieldData = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, meta), {}, {
|
|
name: namePath,
|
|
value: _this.getFieldValue(namePath)
|
|
});
|
|
Object.defineProperty(fieldData, 'originRCField', {
|
|
value: true
|
|
});
|
|
return fieldData;
|
|
});
|
|
return fields;
|
|
};
|
|
|
|
this.initEntityValue = function (entity) {
|
|
var initialValue = entity.props.initialValue;
|
|
|
|
if (initialValue !== undefined) {
|
|
var namePath = entity.getNamePath();
|
|
var prevValue = (0, _valueUtil.getValue)(_this.store, namePath);
|
|
|
|
if (prevValue === undefined) {
|
|
_this.updateStore((0, _valueUtil.setValue)(_this.store, namePath, initialValue));
|
|
}
|
|
}
|
|
};
|
|
|
|
this.isMergedPreserve = function (fieldPreserve) {
|
|
var mergedPreserve = fieldPreserve !== undefined ? fieldPreserve : _this.preserve;
|
|
return mergedPreserve !== null && mergedPreserve !== void 0 ? mergedPreserve : true;
|
|
};
|
|
|
|
this.registerField = function (entity) {
|
|
_this.fieldEntities.push(entity);
|
|
|
|
var namePath = entity.getNamePath();
|
|
|
|
_this.notifyWatch([namePath]); // Set initial values
|
|
|
|
|
|
if (entity.props.initialValue !== undefined) {
|
|
var prevStore = _this.store;
|
|
|
|
_this.resetWithFieldInitialValue({
|
|
entities: [entity],
|
|
skipExist: true
|
|
});
|
|
|
|
_this.notifyObservers(prevStore, [entity.getNamePath()], {
|
|
type: 'valueUpdate',
|
|
source: 'internal'
|
|
});
|
|
} // un-register field callback
|
|
|
|
|
|
return function (isListField, preserve) {
|
|
var subNamePath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
|
|
_this.fieldEntities = _this.fieldEntities.filter(function (item) {
|
|
return item !== entity;
|
|
}); // Clean up store value if not preserve
|
|
|
|
if (!_this.isMergedPreserve(preserve) && (!isListField || subNamePath.length > 1)) {
|
|
var defaultValue = isListField ? undefined : _this.getInitialValue(namePath);
|
|
|
|
if (namePath.length && _this.getFieldValue(namePath) !== defaultValue && _this.fieldEntities.every(function (field) {
|
|
return (// Only reset when no namePath exist
|
|
!(0, _valueUtil.matchNamePath)(field.getNamePath(), namePath)
|
|
);
|
|
})) {
|
|
var _prevStore = _this.store;
|
|
|
|
_this.updateStore((0, _valueUtil.setValue)(_prevStore, namePath, defaultValue, true)); // Notify that field is unmount
|
|
|
|
|
|
_this.notifyObservers(_prevStore, [namePath], {
|
|
type: 'remove'
|
|
}); // Dependencies update
|
|
|
|
|
|
_this.triggerDependenciesUpdate(_prevStore, namePath);
|
|
}
|
|
}
|
|
|
|
_this.notifyWatch([namePath]);
|
|
};
|
|
};
|
|
|
|
this.dispatch = function (action) {
|
|
switch (action.type) {
|
|
case 'updateValue':
|
|
{
|
|
var namePath = action.namePath,
|
|
value = action.value;
|
|
|
|
_this.updateValue(namePath, value);
|
|
|
|
break;
|
|
}
|
|
|
|
case 'validateField':
|
|
{
|
|
var _namePath = action.namePath,
|
|
triggerName = action.triggerName;
|
|
|
|
_this.validateFields([_namePath], {
|
|
triggerName: triggerName
|
|
});
|
|
|
|
break;
|
|
}
|
|
|
|
default: // Currently we don't have other action. Do nothing.
|
|
|
|
}
|
|
};
|
|
|
|
this.notifyObservers = function (prevStore, namePathList, info) {
|
|
if (_this.subscribable) {
|
|
var mergedInfo = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, info), {}, {
|
|
store: _this.getFieldsValue(true)
|
|
});
|
|
|
|
_this.getFieldEntities().forEach(function (_ref3) {
|
|
var onStoreChange = _ref3.onStoreChange;
|
|
onStoreChange(prevStore, namePathList, mergedInfo);
|
|
});
|
|
} else {
|
|
_this.forceRootUpdate();
|
|
}
|
|
};
|
|
|
|
this.triggerDependenciesUpdate = function (prevStore, namePath) {
|
|
var childrenFields = _this.getDependencyChildrenFields(namePath);
|
|
|
|
if (childrenFields.length) {
|
|
_this.validateFields(childrenFields);
|
|
}
|
|
|
|
_this.notifyObservers(prevStore, childrenFields, {
|
|
type: 'dependenciesUpdate',
|
|
relatedFields: [namePath].concat((0, _toConsumableArray2.default)(childrenFields))
|
|
});
|
|
|
|
return childrenFields;
|
|
};
|
|
|
|
this.updateValue = function (name, value) {
|
|
var namePath = (0, _valueUtil.getNamePath)(name);
|
|
var prevStore = _this.store;
|
|
|
|
_this.updateStore((0, _valueUtil.setValue)(_this.store, namePath, value));
|
|
|
|
_this.notifyObservers(prevStore, [namePath], {
|
|
type: 'valueUpdate',
|
|
source: 'internal'
|
|
});
|
|
|
|
_this.notifyWatch([namePath]); // Dependencies update
|
|
|
|
|
|
var childrenFields = _this.triggerDependenciesUpdate(prevStore, namePath); // trigger callback function
|
|
|
|
|
|
var onValuesChange = _this.callbacks.onValuesChange;
|
|
|
|
if (onValuesChange) {
|
|
var changedValues = (0, _valueUtil.cloneByNamePathList)(_this.store, [namePath]);
|
|
onValuesChange(changedValues, _this.getFieldsValue());
|
|
}
|
|
|
|
_this.triggerOnFieldsChange([namePath].concat((0, _toConsumableArray2.default)(childrenFields)));
|
|
};
|
|
|
|
this.setFieldsValue = function (store) {
|
|
_this.warningUnhooked();
|
|
|
|
var prevStore = _this.store;
|
|
|
|
if (store) {
|
|
var nextStore = (0, _valueUtil.setValues)(_this.store, store);
|
|
|
|
_this.updateStore(nextStore);
|
|
}
|
|
|
|
_this.notifyObservers(prevStore, null, {
|
|
type: 'valueUpdate',
|
|
source: 'external'
|
|
});
|
|
|
|
_this.notifyWatch();
|
|
};
|
|
|
|
this.getDependencyChildrenFields = function (rootNamePath) {
|
|
var children = new Set();
|
|
var childrenFields = [];
|
|
var dependencies2fields = new _NameMap.default();
|
|
/**
|
|
* Generate maps
|
|
* Can use cache to save perf if user report performance issue with this
|
|
*/
|
|
|
|
_this.getFieldEntities().forEach(function (field) {
|
|
var dependencies = field.props.dependencies;
|
|
(dependencies || []).forEach(function (dependency) {
|
|
var dependencyNamePath = (0, _valueUtil.getNamePath)(dependency);
|
|
dependencies2fields.update(dependencyNamePath, function () {
|
|
var fields = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Set();
|
|
fields.add(field);
|
|
return fields;
|
|
});
|
|
});
|
|
});
|
|
|
|
var fillChildren = function fillChildren(namePath) {
|
|
var fields = dependencies2fields.get(namePath) || new Set();
|
|
fields.forEach(function (field) {
|
|
if (!children.has(field)) {
|
|
children.add(field);
|
|
var fieldNamePath = field.getNamePath();
|
|
|
|
if (field.isFieldDirty() && fieldNamePath.length) {
|
|
childrenFields.push(fieldNamePath);
|
|
fillChildren(fieldNamePath);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
|
|
fillChildren(rootNamePath);
|
|
return childrenFields;
|
|
};
|
|
|
|
this.triggerOnFieldsChange = function (namePathList, filedErrors) {
|
|
var onFieldsChange = _this.callbacks.onFieldsChange;
|
|
|
|
if (onFieldsChange) {
|
|
var fields = _this.getFields();
|
|
/**
|
|
* Fill errors since `fields` may be replaced by controlled fields
|
|
*/
|
|
|
|
|
|
if (filedErrors) {
|
|
var cache = new _NameMap.default();
|
|
filedErrors.forEach(function (_ref4) {
|
|
var name = _ref4.name,
|
|
errors = _ref4.errors;
|
|
cache.set(name, errors);
|
|
});
|
|
fields.forEach(function (field) {
|
|
// eslint-disable-next-line no-param-reassign
|
|
field.errors = cache.get(field.name) || field.errors;
|
|
});
|
|
}
|
|
|
|
var changedFields = fields.filter(function (_ref5) {
|
|
var fieldName = _ref5.name;
|
|
return (0, _valueUtil.containsNamePath)(namePathList, fieldName);
|
|
});
|
|
onFieldsChange(changedFields, fields);
|
|
}
|
|
};
|
|
|
|
this.validateFields = function (nameList, options) {
|
|
_this.warningUnhooked();
|
|
|
|
var provideNameList = !!nameList;
|
|
var namePathList = provideNameList ? nameList.map(_valueUtil.getNamePath) : []; // Collect result in promise list
|
|
|
|
var promiseList = [];
|
|
|
|
_this.getFieldEntities(true).forEach(function (field) {
|
|
// Add field if not provide `nameList`
|
|
if (!provideNameList) {
|
|
namePathList.push(field.getNamePath());
|
|
}
|
|
/**
|
|
* Recursive validate if configured.
|
|
* TODO: perf improvement @zombieJ
|
|
*/
|
|
|
|
|
|
if ((options === null || options === void 0 ? void 0 : options.recursive) && provideNameList) {
|
|
var namePath = field.getNamePath();
|
|
|
|
if ( // nameList[i] === undefined 说明是以 nameList 开头的
|
|
// ['name'] -> ['name','list']
|
|
namePath.every(function (nameUnit, i) {
|
|
return nameList[i] === nameUnit || nameList[i] === undefined;
|
|
})) {
|
|
namePathList.push(namePath);
|
|
}
|
|
} // Skip if without rule
|
|
|
|
|
|
if (!field.props.rules || !field.props.rules.length) {
|
|
return;
|
|
}
|
|
|
|
var fieldNamePath = field.getNamePath(); // Add field validate rule in to promise list
|
|
|
|
if (!provideNameList || (0, _valueUtil.containsNamePath)(namePathList, fieldNamePath)) {
|
|
var promise = field.validateRules((0, _objectSpread2.default)({
|
|
validateMessages: (0, _objectSpread2.default)((0, _objectSpread2.default)({}, _messages.defaultValidateMessages), _this.validateMessages)
|
|
}, options)); // Wrap promise with field
|
|
|
|
promiseList.push(promise.then(function () {
|
|
return {
|
|
name: fieldNamePath,
|
|
errors: [],
|
|
warnings: []
|
|
};
|
|
}).catch(function (ruleErrors) {
|
|
var mergedErrors = [];
|
|
var mergedWarnings = [];
|
|
ruleErrors.forEach(function (_ref6) {
|
|
var warningOnly = _ref6.rule.warningOnly,
|
|
errors = _ref6.errors;
|
|
|
|
if (warningOnly) {
|
|
mergedWarnings.push.apply(mergedWarnings, (0, _toConsumableArray2.default)(errors));
|
|
} else {
|
|
mergedErrors.push.apply(mergedErrors, (0, _toConsumableArray2.default)(errors));
|
|
}
|
|
});
|
|
|
|
if (mergedErrors.length) {
|
|
return Promise.reject({
|
|
name: fieldNamePath,
|
|
errors: mergedErrors,
|
|
warnings: mergedWarnings
|
|
});
|
|
}
|
|
|
|
return {
|
|
name: fieldNamePath,
|
|
errors: mergedErrors,
|
|
warnings: mergedWarnings
|
|
};
|
|
}));
|
|
}
|
|
});
|
|
|
|
var summaryPromise = (0, _asyncUtil.allPromiseFinish)(promiseList);
|
|
_this.lastValidatePromise = summaryPromise; // Notify fields with rule that validate has finished and need update
|
|
|
|
summaryPromise.catch(function (results) {
|
|
return results;
|
|
}).then(function (results) {
|
|
var resultNamePathList = results.map(function (_ref7) {
|
|
var name = _ref7.name;
|
|
return name;
|
|
});
|
|
|
|
_this.notifyObservers(_this.store, resultNamePathList, {
|
|
type: 'validateFinish'
|
|
});
|
|
|
|
_this.triggerOnFieldsChange(resultNamePathList, results);
|
|
});
|
|
var returnPromise = summaryPromise.then(function () {
|
|
if (_this.lastValidatePromise === summaryPromise) {
|
|
return Promise.resolve(_this.getFieldsValue(namePathList));
|
|
}
|
|
|
|
return Promise.reject([]);
|
|
}).catch(function (results) {
|
|
var errorList = results.filter(function (result) {
|
|
return result && result.errors.length;
|
|
});
|
|
return Promise.reject({
|
|
values: _this.getFieldsValue(namePathList),
|
|
errorFields: errorList,
|
|
outOfDate: _this.lastValidatePromise !== summaryPromise
|
|
});
|
|
}); // Do not throw in console
|
|
|
|
returnPromise.catch(function (e) {
|
|
return e;
|
|
});
|
|
return returnPromise;
|
|
};
|
|
|
|
this.submit = function () {
|
|
_this.warningUnhooked();
|
|
|
|
_this.validateFields().then(function (values) {
|
|
var onFinish = _this.callbacks.onFinish;
|
|
|
|
if (onFinish) {
|
|
try {
|
|
onFinish(values);
|
|
} catch (err) {
|
|
// Should print error if user `onFinish` callback failed
|
|
console.error(err);
|
|
}
|
|
}
|
|
}).catch(function (e) {
|
|
var onFinishFailed = _this.callbacks.onFinishFailed;
|
|
|
|
if (onFinishFailed) {
|
|
onFinishFailed(e);
|
|
}
|
|
});
|
|
};
|
|
|
|
this.forceRootUpdate = forceRootUpdate;
|
|
});
|
|
exports.FormStore = FormStore;
|
|
|
|
function useForm(form) {
|
|
var formRef = React.useRef();
|
|
|
|
var _React$useState = React.useState({}),
|
|
_React$useState2 = (0, _slicedToArray2.default)(_React$useState, 2),
|
|
forceUpdate = _React$useState2[1];
|
|
|
|
if (!formRef.current) {
|
|
if (form) {
|
|
formRef.current = form;
|
|
} else {
|
|
// Create a new FormStore if not provided
|
|
var forceReRender = function forceReRender() {
|
|
forceUpdate({});
|
|
};
|
|
|
|
var formStore = new FormStore(forceReRender);
|
|
formRef.current = formStore.getForm();
|
|
}
|
|
}
|
|
|
|
return [formRef.current];
|
|
}
|
|
|
|
var _default = useForm;
|
|
exports.default = _default;
|
|
}, function(modId) { var map = {"./FieldContext":1656641690362,"./utils/asyncUtil":1656641690371,"./utils/cloneDeep":1656641690367,"./utils/messages":1656641690365,"./utils/NameMap":1656641690372,"./utils/valueUtil":1656641690366}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690371, function(require, module, exports) {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.allPromiseFinish = allPromiseFinish;
|
|
|
|
function allPromiseFinish(promiseList) {
|
|
var hasError = false;
|
|
var count = promiseList.length;
|
|
var results = [];
|
|
|
|
if (!promiseList.length) {
|
|
return Promise.resolve([]);
|
|
}
|
|
|
|
return new Promise(function (resolve, reject) {
|
|
promiseList.forEach(function (promise, index) {
|
|
promise.catch(function (e) {
|
|
hasError = true;
|
|
return e;
|
|
}).then(function (result) {
|
|
count -= 1;
|
|
results[index] = result;
|
|
|
|
if (count > 0) {
|
|
return;
|
|
}
|
|
|
|
if (hasError) {
|
|
reject(results);
|
|
}
|
|
|
|
resolve(results);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690372, function(require, module, exports) {
|
|
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
|
|
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
|
|
|
|
var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
|
|
|
|
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
|
|
|
|
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
|
|
|
|
var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
|
|
|
|
var SPLIT = '__@field_split__';
|
|
/**
|
|
* Convert name path into string to fast the fetch speed of Map.
|
|
*/
|
|
|
|
function normalize(namePath) {
|
|
return namePath.map(function (cell) {
|
|
return "".concat((0, _typeof2.default)(cell), ":").concat(cell);
|
|
}) // Magic split
|
|
.join(SPLIT);
|
|
}
|
|
/**
|
|
* NameMap like a `Map` but accepts `string[]` as key.
|
|
*/
|
|
|
|
|
|
var NameMap = /*#__PURE__*/function () {
|
|
function NameMap() {
|
|
(0, _classCallCheck2.default)(this, NameMap);
|
|
this.kvs = new Map();
|
|
}
|
|
|
|
(0, _createClass2.default)(NameMap, [{
|
|
key: "set",
|
|
value: function set(key, value) {
|
|
this.kvs.set(normalize(key), value);
|
|
}
|
|
}, {
|
|
key: "get",
|
|
value: function get(key) {
|
|
return this.kvs.get(normalize(key));
|
|
}
|
|
}, {
|
|
key: "update",
|
|
value: function update(key, updater) {
|
|
var origin = this.get(key);
|
|
var next = updater(origin);
|
|
|
|
if (!next) {
|
|
this.delete(key);
|
|
} else {
|
|
this.set(key, next);
|
|
}
|
|
}
|
|
}, {
|
|
key: "delete",
|
|
value: function _delete(key) {
|
|
this.kvs.delete(normalize(key));
|
|
} // Since we only use this in test, let simply realize this
|
|
|
|
}, {
|
|
key: "map",
|
|
value: function map(callback) {
|
|
return (0, _toConsumableArray2.default)(this.kvs.entries()).map(function (_ref) {
|
|
var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
|
|
key = _ref2[0],
|
|
value = _ref2[1];
|
|
|
|
var cells = key.split(SPLIT);
|
|
return callback({
|
|
key: cells.map(function (cell) {
|
|
var _cell$match = cell.match(/^([^:]*):(.*)$/),
|
|
_cell$match2 = (0, _slicedToArray2.default)(_cell$match, 3),
|
|
type = _cell$match2[1],
|
|
unit = _cell$match2[2];
|
|
|
|
return type === 'number' ? Number(unit) : unit;
|
|
}),
|
|
value: value
|
|
});
|
|
});
|
|
}
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON() {
|
|
var json = {};
|
|
this.map(function (_ref3) {
|
|
var key = _ref3.key,
|
|
value = _ref3.value;
|
|
json[key.join('.')] = value;
|
|
return null;
|
|
});
|
|
return json;
|
|
}
|
|
}]);
|
|
return NameMap;
|
|
}();
|
|
|
|
var _default = NameMap;
|
|
exports.default = _default;
|
|
}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690373, function(require, module, exports) {
|
|
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
|
|
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
|
|
|
|
var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
|
|
|
|
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
|
|
|
|
var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
|
|
|
|
var React = _interopRequireWildcard(require("react"));
|
|
|
|
var _useForm3 = _interopRequireDefault(require("./useForm"));
|
|
|
|
var _FieldContext = _interopRequireWildcard(require("./FieldContext"));
|
|
|
|
var _FormContext = _interopRequireDefault(require("./FormContext"));
|
|
|
|
var _valueUtil = require("./utils/valueUtil");
|
|
|
|
var _excluded = ["name", "initialValues", "fields", "form", "preserve", "children", "component", "validateMessages", "validateTrigger", "onValuesChange", "onFieldsChange", "onFinish", "onFinishFailed"];
|
|
|
|
var Form = function Form(_ref, ref) {
|
|
var name = _ref.name,
|
|
initialValues = _ref.initialValues,
|
|
fields = _ref.fields,
|
|
form = _ref.form,
|
|
preserve = _ref.preserve,
|
|
children = _ref.children,
|
|
_ref$component = _ref.component,
|
|
Component = _ref$component === void 0 ? 'form' : _ref$component,
|
|
validateMessages = _ref.validateMessages,
|
|
_ref$validateTrigger = _ref.validateTrigger,
|
|
validateTrigger = _ref$validateTrigger === void 0 ? 'onChange' : _ref$validateTrigger,
|
|
onValuesChange = _ref.onValuesChange,
|
|
_onFieldsChange = _ref.onFieldsChange,
|
|
_onFinish = _ref.onFinish,
|
|
onFinishFailed = _ref.onFinishFailed,
|
|
restProps = (0, _objectWithoutProperties2.default)(_ref, _excluded);
|
|
var formContext = React.useContext(_FormContext.default); // We customize handle event since Context will makes all the consumer re-render:
|
|
// https://reactjs.org/docs/context.html#contextprovider
|
|
|
|
var _useForm = (0, _useForm3.default)(form),
|
|
_useForm2 = (0, _slicedToArray2.default)(_useForm, 1),
|
|
formInstance = _useForm2[0];
|
|
|
|
var _formInstance$getInte = formInstance.getInternalHooks(_FieldContext.HOOK_MARK),
|
|
useSubscribe = _formInstance$getInte.useSubscribe,
|
|
setInitialValues = _formInstance$getInte.setInitialValues,
|
|
setCallbacks = _formInstance$getInte.setCallbacks,
|
|
setValidateMessages = _formInstance$getInte.setValidateMessages,
|
|
setPreserve = _formInstance$getInte.setPreserve,
|
|
destroyForm = _formInstance$getInte.destroyForm; // Pass ref with form instance
|
|
|
|
|
|
React.useImperativeHandle(ref, function () {
|
|
return formInstance;
|
|
}); // Register form into Context
|
|
|
|
React.useEffect(function () {
|
|
formContext.registerForm(name, formInstance);
|
|
return function () {
|
|
formContext.unregisterForm(name);
|
|
};
|
|
}, [formContext, formInstance, name]); // Pass props to store
|
|
|
|
setValidateMessages((0, _objectSpread2.default)((0, _objectSpread2.default)({}, formContext.validateMessages), validateMessages));
|
|
setCallbacks({
|
|
onValuesChange: onValuesChange,
|
|
onFieldsChange: function onFieldsChange(changedFields) {
|
|
formContext.triggerFormChange(name, changedFields);
|
|
|
|
if (_onFieldsChange) {
|
|
for (var _len = arguments.length, rest = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
rest[_key - 1] = arguments[_key];
|
|
}
|
|
|
|
_onFieldsChange.apply(void 0, [changedFields].concat(rest));
|
|
}
|
|
},
|
|
onFinish: function onFinish(values) {
|
|
formContext.triggerFormFinish(name, values);
|
|
|
|
if (_onFinish) {
|
|
_onFinish(values);
|
|
}
|
|
},
|
|
onFinishFailed: onFinishFailed
|
|
});
|
|
setPreserve(preserve); // Set initial value, init store value when first mount
|
|
|
|
var mountRef = React.useRef(null);
|
|
setInitialValues(initialValues, !mountRef.current);
|
|
|
|
if (!mountRef.current) {
|
|
mountRef.current = true;
|
|
}
|
|
|
|
React.useEffect(function () {
|
|
return destroyForm;
|
|
}, // eslint-disable-next-line react-hooks/exhaustive-deps
|
|
[]); // Prepare children by `children` type
|
|
|
|
var childrenNode;
|
|
var childrenRenderProps = typeof children === 'function';
|
|
|
|
if (childrenRenderProps) {
|
|
var values = formInstance.getFieldsValue(true);
|
|
childrenNode = children(values, formInstance);
|
|
} else {
|
|
childrenNode = children;
|
|
} // Not use subscribe when using render props
|
|
|
|
|
|
useSubscribe(!childrenRenderProps); // Listen if fields provided. We use ref to save prev data here to avoid additional render
|
|
|
|
var prevFieldsRef = React.useRef();
|
|
React.useEffect(function () {
|
|
if (!(0, _valueUtil.isSimilar)(prevFieldsRef.current || [], fields || [])) {
|
|
formInstance.setFields(fields || []);
|
|
}
|
|
|
|
prevFieldsRef.current = fields;
|
|
}, [fields, formInstance]);
|
|
var formContextValue = React.useMemo(function () {
|
|
return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, formInstance), {}, {
|
|
validateTrigger: validateTrigger
|
|
});
|
|
}, [formInstance, validateTrigger]);
|
|
var wrapperNode = /*#__PURE__*/React.createElement(_FieldContext.default.Provider, {
|
|
value: formContextValue
|
|
}, childrenNode);
|
|
|
|
if (Component === false) {
|
|
return wrapperNode;
|
|
}
|
|
|
|
return /*#__PURE__*/React.createElement(Component, (0, _extends2.default)({}, restProps, {
|
|
onSubmit: function onSubmit(event) {
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
formInstance.submit();
|
|
},
|
|
onReset: function onReset(event) {
|
|
var _restProps$onReset;
|
|
|
|
event.preventDefault();
|
|
formInstance.resetFields();
|
|
(_restProps$onReset = restProps.onReset) === null || _restProps$onReset === void 0 ? void 0 : _restProps$onReset.call(restProps, event);
|
|
}
|
|
}), wrapperNode);
|
|
};
|
|
|
|
var _default = Form;
|
|
exports.default = _default;
|
|
}, function(modId) { var map = {"./useForm":1656641690370,"./FieldContext":1656641690362,"./FormContext":1656641690374,"./utils/valueUtil":1656641690366}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690374, function(require, module, exports) {
|
|
|
|
|
|
var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = exports.FormProvider = void 0;
|
|
|
|
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
|
|
|
|
var _objectSpread3 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
|
|
|
|
var React = _interopRequireWildcard(require("react"));
|
|
|
|
var FormContext = /*#__PURE__*/React.createContext({
|
|
triggerFormChange: function triggerFormChange() {},
|
|
triggerFormFinish: function triggerFormFinish() {},
|
|
registerForm: function registerForm() {},
|
|
unregisterForm: function unregisterForm() {}
|
|
});
|
|
|
|
var FormProvider = function FormProvider(_ref) {
|
|
var validateMessages = _ref.validateMessages,
|
|
onFormChange = _ref.onFormChange,
|
|
onFormFinish = _ref.onFormFinish,
|
|
children = _ref.children;
|
|
var formContext = React.useContext(FormContext);
|
|
var formsRef = React.useRef({});
|
|
return /*#__PURE__*/React.createElement(FormContext.Provider, {
|
|
value: (0, _objectSpread3.default)((0, _objectSpread3.default)({}, formContext), {}, {
|
|
validateMessages: (0, _objectSpread3.default)((0, _objectSpread3.default)({}, formContext.validateMessages), validateMessages),
|
|
// =========================================================
|
|
// = Global Form Control =
|
|
// =========================================================
|
|
triggerFormChange: function triggerFormChange(name, changedFields) {
|
|
if (onFormChange) {
|
|
onFormChange(name, {
|
|
changedFields: changedFields,
|
|
forms: formsRef.current
|
|
});
|
|
}
|
|
|
|
formContext.triggerFormChange(name, changedFields);
|
|
},
|
|
triggerFormFinish: function triggerFormFinish(name, values) {
|
|
if (onFormFinish) {
|
|
onFormFinish(name, {
|
|
values: values,
|
|
forms: formsRef.current
|
|
});
|
|
}
|
|
|
|
formContext.triggerFormFinish(name, values);
|
|
},
|
|
registerForm: function registerForm(name, form) {
|
|
if (name) {
|
|
formsRef.current = (0, _objectSpread3.default)((0, _objectSpread3.default)({}, formsRef.current), {}, (0, _defineProperty2.default)({}, name, form));
|
|
}
|
|
|
|
formContext.registerForm(name, form);
|
|
},
|
|
unregisterForm: function unregisterForm(name) {
|
|
var newForms = (0, _objectSpread3.default)({}, formsRef.current);
|
|
delete newForms[name];
|
|
formsRef.current = newForms;
|
|
formContext.unregisterForm(name);
|
|
}
|
|
})
|
|
}, children);
|
|
};
|
|
|
|
exports.FormProvider = FormProvider;
|
|
var _default = FormContext;
|
|
exports.default = _default;
|
|
}, function(modId) { var map = {}; return __REQUIRE__(map[modId], modId); })
|
|
__DEFINE__(1656641690375, function(require, module, exports) {
|
|
|
|
|
|
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
exports.stringify = stringify;
|
|
|
|
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
|
|
|
|
var _ = require(".");
|
|
|
|
var _warning = _interopRequireDefault(require("rc-util/lib/warning"));
|
|
|
|
var _FieldContext = require("./FieldContext");
|
|
|
|
var _react = require("react");
|
|
|
|
var _valueUtil = require("./utils/valueUtil");
|
|
|
|
function stringify(value) {
|
|
try {
|
|
return JSON.stringify(value);
|
|
} catch (err) {
|
|
return Math.random();
|
|
}
|
|
}
|
|
|
|
function useWatch() {
|
|
var dependencies = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
|
|
var form = arguments.length > 1 ? arguments[1] : undefined;
|
|
|
|
var _useState = (0, _react.useState)(),
|
|
_useState2 = (0, _slicedToArray2.default)(_useState, 2),
|
|
value = _useState2[0],
|
|
setValue = _useState2[1];
|
|
|
|
var valueStr = (0, _react.useMemo)(function () {
|
|
return stringify(value);
|
|
}, [value]);
|
|
var valueStrRef = (0, _react.useRef)(valueStr);
|
|
valueStrRef.current = valueStr;
|
|
var fieldContext = (0, _react.useContext)(_.FieldContext);
|
|
var formInstance = form || fieldContext;
|
|
var isValidForm = formInstance && formInstance._init; // Warning if not exist form instance
|
|
|
|
if (process.env.NODE_ENV !== 'production') {
|
|
(0, _warning.default)(isValidForm, 'useWatch requires a form instance since it can not auto detect from context.');
|
|
}
|
|
|
|
var namePath = (0, _valueUtil.getNamePath)(dependencies);
|
|
var namePathRef = (0, _react.useRef)(namePath);
|
|
namePathRef.current = namePath;
|
|
(0, _react.useEffect)(function () {
|
|
// Skip if not exist form instance
|
|
if (!isValidForm) {
|
|
return;
|
|
}
|
|
|
|
var getFieldsValue = formInstance.getFieldsValue,
|
|
getInternalHooks = formInstance.getInternalHooks;
|
|
|
|
var _getInternalHooks = getInternalHooks(_FieldContext.HOOK_MARK),
|
|
registerWatch = _getInternalHooks.registerWatch;
|
|
|
|
var cancelRegister = registerWatch(function (store) {
|
|
var newValue = (0, _valueUtil.getValue)(store, namePathRef.current);
|
|
var nextValueStr = stringify(newValue); // Compare stringify in case it's nest object
|
|
|
|
if (valueStrRef.current !== nextValueStr) {
|
|
valueStrRef.current = nextValueStr;
|
|
setValue(newValue);
|
|
}
|
|
}); // TODO: We can improve this perf in future
|
|
|
|
var initialValue = (0, _valueUtil.getValue)(getFieldsValue(), namePathRef.current);
|
|
setValue(initialValue);
|
|
return cancelRegister;
|
|
}, // We do not need re-register since namePath content is the same
|
|
// eslint-disable-next-line react-hooks/exhaustive-deps
|
|
[]);
|
|
return value;
|
|
}
|
|
|
|
var _default = useWatch;
|
|
exports.default = _default;
|
|
}, function(modId) { var map = {".":1656641690360,"./FieldContext":1656641690362,"./utils/valueUtil":1656641690366}; return __REQUIRE__(map[modId], modId); })
|
|
return __REQUIRE__(1656641690360);
|
|
})()
|
|
//miniprogram-npm-outsideDeps=["@babel/runtime/helpers/interopRequireDefault","@babel/runtime/helpers/interopRequireWildcard","react","@babel/runtime/helpers/extends","@babel/runtime/helpers/objectWithoutProperties","@babel/runtime/helpers/defineProperty","@babel/runtime/helpers/objectSpread2","@babel/runtime/helpers/toConsumableArray","@babel/runtime/helpers/classCallCheck","@babel/runtime/helpers/createClass","@babel/runtime/helpers/assertThisInitialized","@babel/runtime/helpers/inherits","@babel/runtime/helpers/createSuper","rc-util/lib/Children/toArray","rc-util/lib/warning","@babel/runtime/helpers/regeneratorRuntime","@babel/runtime/helpers/asyncToGenerator","async-validator","@babel/runtime/helpers/typeof","rc-util/lib/utils/get","rc-util/lib/utils/set","@babel/runtime/helpers/slicedToArray"]
|
|
//# sourceMappingURL=index.js.map
|