@formily/core
Version:
English | [简体中文](./README.zh-cn.md)
1,109 lines (1,108 loc) • 57.2 kB
JavaScript
"use strict";
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
function __export(m) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
Object.defineProperty(exports, "__esModule", { value: true });
var shared_1 = require("@formily/shared");
exports.FormPath = shared_1.FormPath;
exports.BigData = shared_1.BigData;
var validator_1 = require("@formily/validator");
exports.setValidationLanguage = validator_1.setValidationLanguage;
exports.setValidationLocale = validator_1.setValidationLocale;
var lifecycle_1 = require("./shared/lifecycle");
var graph_1 = require("./shared/graph");
exports.FormGraph = graph_1.FormGraph;
var form_1 = require("./state/form");
var virtual_field_1 = require("./state/virtual-field");
var field_1 = require("./state/field");
var types_1 = require("./types");
__export(require("./shared/lifecycle"));
__export(require("./types"));
function createForm(options) {
if (options === void 0) { options = {}; }
function onGraphChange(_a) {
var type = _a.type, payload = _a.payload;
heart.publish(types_1.LifeCycleTypes.ON_FORM_GRAPH_CHANGE, graph);
if (type === 'GRAPH_NODE_WILL_UNMOUNT') {
validator.unregister(payload.path.toString());
}
}
function syncFieldValues(state) {
var dataPath = shared_1.FormPath.parse(state.name);
var parent = graph.getLatestParent(state.path);
var parentValue = getFormValuesIn(parent.path);
var value = getFormValuesIn(state.name);
var removed = false;
if (shared_1.isArr(parentValue) && !dataPath.existIn(parentValue, parent.path)) {
if (!parent.path
.getNearestChildPathBy(state.path)
.existIn(parentValue, parent.path)) {
graph.remove(state.path);
removed = true;
}
}
else {
shared_1.each(env.removeNodes, function (_, name) {
if (dataPath.includes(name)) {
graph.remove(state.path);
delete env.removeNodes[name];
removed = true;
}
});
}
if (removed)
return;
if (!shared_1.isEqual(value, state.value)) {
state.value = value;
}
}
function syncFieldIntialValues(state) {
if (state.name === '')
return;
var initialValue = getFormInitialValuesIn(state.name);
if (!shared_1.isEqual(initialValue, state.initialValue)) {
state.initialValue = initialValue;
if (!shared_1.isValid(state.value)) {
state.value = initialValue;
}
else if (/array/gi.test(state.dataType) &&
state.value &&
state.value.length === 0) {
state.value = initialValue;
}
}
}
function notifyFormValuesChange() {
if (shared_1.isFn(options.onChange) &&
state.state.mounted &&
!state.state.unmounted) {
clearTimeout(env.onChangeTimer);
env.onChangeTimer = setTimeout(function () {
if (state.state.unmounted)
return;
options.onChange(shared_1.clone(getFormValuesIn('')));
});
}
heart.publish(types_1.LifeCycleTypes.ON_FORM_VALUES_CHANGE, state);
}
function notifyFormInitialValuesChange() {
heart.publish(types_1.LifeCycleTypes.ON_FORM_INITIAL_VALUES_CHANGE, state);
}
function onFormChange(published) {
heart.publish(types_1.LifeCycleTypes.ON_FORM_CHANGE, state);
var valuesChanged = state.isDirty('values');
var initialValuesChanged = state.isDirty('initialValues');
var unmountedChanged = state.isDirty('unmounted');
var mountedChanged = state.isDirty('mounted');
var initializedChanged = state.isDirty('initialized');
var editableChanged = state.isDirty('editable');
if (valuesChanged || initialValuesChanged) {
var updateFields_1 = function (field) {
if (types_1.isField(field)) {
field.setState(function (state) {
if (valuesChanged) {
syncFieldValues(state);
}
if (initialValuesChanged) {
syncFieldIntialValues(state);
}
});
}
};
if (valuesChanged || initialValuesChanged) {
if (graph.size > 20) {
clearTimeout(env.syncFormStateTimer);
env.syncFormStateTimer = setTimeout(function () {
graph.eachChildren(updateFields_1);
});
}
else {
graph.eachChildren(updateFields_1);
}
}
if (valuesChanged) {
notifyFormValuesChange();
}
if (initialValuesChanged) {
notifyFormInitialValuesChange();
}
}
if (editableChanged) {
graph.eachChildren(function (field) {
if (types_1.isField(field)) {
field.setState(function (state) {
state.formEditable = published.editable;
});
}
});
}
if (unmountedChanged && published.unmounted) {
heart.publish(types_1.LifeCycleTypes.ON_FORM_UNMOUNT, state);
}
if (mountedChanged && published.mounted) {
heart.publish(types_1.LifeCycleTypes.ON_FORM_MOUNT, state);
}
if (initializedChanged) {
heart.publish(types_1.LifeCycleTypes.ON_FORM_INIT, state);
}
}
function updateRecoverableShownState(parentState, childState, name) {
var lastShownState = env.lastShownStates[childState.path];
var lastStateValue = childState[name];
if (parentState[name] && lastShownState && lastShownState[name] === false) {
childState[name] = false;
delete lastShownState[name];
if (!lastShownState.hasOwnProperty('visible') &&
!lastShownState.hasOwnProperty('display')) {
delete env.lastShownStates[childState.path];
}
}
else {
childState[name] = parentState[name];
}
if (!parentState[name] && !lastStateValue) {
if (!lastShownState) {
env.lastShownStates[childState.path] = {};
}
env.lastShownStates[childState.path][name] = false;
}
}
function onFieldChange(_a) {
var field = _a.field, path = _a.path;
function notifyTreeFromValues() {
field.setState(syncFieldValues);
graph.eachParent(path, function (field) {
if (types_1.isField(field)) {
field.setState(syncFieldValues, true);
}
});
graph.eachChildren(path, function (field) {
if (types_1.isField(field)) {
field.setState(syncFieldValues);
}
});
notifyFormValuesChange();
}
function notifyTreeFromInitialValues() {
field.setState(syncFieldIntialValues);
graph.eachParent(path, function (field) {
if (types_1.isField(field)) {
field.setState(syncFieldIntialValues, true);
}
});
graph.eachChildren(path, function (field) {
if (types_1.isField(field)) {
field.setState(syncFieldIntialValues);
}
});
notifyFormInitialValuesChange();
}
return function (published) {
var valueChanged = field.isDirty('value');
var initialValueChanged = field.isDirty('initialValue');
var visibleChanged = field.isDirty('visible');
var displayChanged = field.isDirty('display');
var unmountedChanged = field.isDirty('unmounted');
var mountedChanged = field.isDirty('mounted');
var initializedChanged = field.isDirty('initialized');
var warningsChanged = field.isDirty('warnings');
var errorsChanged = field.isDirty('errors');
var editableChanged = field.isDirty('editable');
if (initializedChanged) {
heart.publish(types_1.LifeCycleTypes.ON_FIELD_INIT, field);
var isEmptyValue_1 = !shared_1.isValid(published.value);
var isEmptyInitialValue_1 = !shared_1.isValid(published.initialValue);
if (isEmptyValue_1 || isEmptyInitialValue_1) {
field.setSourceState(function (state) {
if (isEmptyValue_1) {
var formValue = getFormValuesIn(state.name);
state.value = shared_1.isValid(formValue) ? formValue : state.value;
}
if (isEmptyInitialValue_1) {
var formInitialValue = getFormInitialValuesIn(state.name);
state.initialValue = shared_1.isValid(formInitialValue)
? formInitialValue
: state.initialValue;
}
});
}
}
var wasHidden = published.visible == false || published.unmounted === true;
if (valueChanged) {
if (!wasHidden) {
setFormValuesIn(path, published.value, true);
notifyTreeFromValues();
}
heart.publish(types_1.LifeCycleTypes.ON_FIELD_VALUE_CHANGE, field);
}
if (initialValueChanged) {
if (!wasHidden) {
setFormInitialValuesIn(path, published.initialValue, true);
notifyTreeFromInitialValues();
}
heart.publish(types_1.LifeCycleTypes.ON_FIELD_INITIAL_VALUE_CHANGE, field);
}
if (displayChanged || visibleChanged) {
if (visibleChanged) {
if (!published.visible) {
if (shared_1.isValid(published.value)) {
field.setSourceState(function (state) {
state.visibleCacheValue = published.value;
});
}
deleteFormValuesIn(path);
notifyTreeFromValues();
}
else {
if (!existFormValuesIn(path)) {
setFormValuesIn(path, shared_1.isValid(published.visibleCacheValue)
? published.visibleCacheValue
: published.initialValue, true);
notifyTreeFromValues();
}
}
}
graph.eachChildren(path, function (childState) {
childState.setState(function (state) {
if (visibleChanged) {
updateRecoverableShownState(published, state, 'visible');
}
if (displayChanged) {
updateRecoverableShownState(published, state, 'display');
}
}, true);
});
}
if (unmountedChanged &&
(published.display !== false || published.visible === false) &&
published.unmountRemoveValue) {
if (published.unmounted) {
if (shared_1.isValid(published.value)) {
field.setSourceState(function (state) {
state.visibleCacheValue = published.value;
});
}
deleteFormValuesIn(path, true);
notifyTreeFromValues();
}
else {
if (!existFormValuesIn(path)) {
setFormValuesIn(path, shared_1.isValid(published.visibleCacheValue)
? published.visibleCacheValue
: published.initialValue, true);
notifyTreeFromValues();
}
}
heart.publish(types_1.LifeCycleTypes.ON_FIELD_UNMOUNT, field);
}
if (mountedChanged && published.mounted) {
heart.publish(types_1.LifeCycleTypes.ON_FIELD_MOUNT, field);
}
if (errorsChanged) {
syncFormMessages('errors', published);
}
if (warningsChanged) {
syncFormMessages('warnings', published);
}
if (unmountedChanged ||
visibleChanged ||
displayChanged ||
editableChanged) {
resetFormMessages(published);
}
heart.publish(types_1.LifeCycleTypes.ON_FIELD_CHANGE, field);
};
}
function onVirtualFieldChange(_a) {
var field = _a.field, path = _a.path;
return function (published) {
var visibleChanged = field.isDirty('visible');
var displayChanged = field.isDirty('display');
var mountedChanged = field.isDirty('mounted');
var initializedChanged = field.isDirty('initialized');
if (initializedChanged) {
heart.publish(types_1.LifeCycleTypes.ON_FIELD_INIT, field);
}
if (visibleChanged || displayChanged) {
graph.eachChildren(path, function (childState) {
childState.setState(function (state) {
if (visibleChanged) {
updateRecoverableShownState(published, state, 'visible');
}
if (displayChanged) {
updateRecoverableShownState(published, state, 'display');
}
}, true);
});
}
if (mountedChanged && published.mounted) {
heart.publish(types_1.LifeCycleTypes.ON_FIELD_MOUNT, field);
}
heart.publish(types_1.LifeCycleTypes.ON_FIELD_CHANGE, field);
};
}
function registerVirtualField(_a) {
var name = _a.name, path = _a.path, props = _a.props, display = _a.display, visible = _a.visible, computeState = _a.computeState, useDirty = _a.useDirty;
var nodePath = shared_1.FormPath.parse(path || name);
var dataPath = transformDataPath(nodePath);
var field;
var createField = function (field) {
var alreadyHaveField = !!field;
field =
field ||
new virtual_field_1.VirtualFieldState({
nodePath: nodePath,
dataPath: dataPath,
computeState: computeState,
useDirty: shared_1.isValid(useDirty) ? useDirty : options.useDirty
});
field.subscription = {
notify: onVirtualFieldChange({ field: field, path: nodePath })
};
heart.publish(types_1.LifeCycleTypes.ON_FIELD_WILL_INIT, field);
if (!alreadyHaveField) {
graph.appendNode(nodePath, field);
}
heart.batch(function () {
field.batch(function () {
field.setState(function (state) {
state.initialized = true;
state.props = props;
if (shared_1.isValid(visible)) {
state.visible = visible;
}
if (shared_1.isValid(display)) {
state.display = display;
}
});
batchRunTaskQueue(field, nodePath);
});
});
return field;
};
if (graph.exist(nodePath)) {
field = graph.get(nodePath);
if (types_1.isField(field)) {
graph.replace(nodePath, field);
}
}
else {
field = createField();
}
return field;
}
function registerField(_a) {
var path = _a.path, name = _a.name, value = _a.value, initialValue = _a.initialValue, required = _a.required, rules = _a.rules, editable = _a.editable, visible = _a.visible, display = _a.display, computeState = _a.computeState, dataType = _a.dataType, useDirty = _a.useDirty, unmountRemoveValue = _a.unmountRemoveValue, props = _a.props;
var field;
var nodePath = shared_1.FormPath.parse(path || name);
var dataPath = transformDataPath(nodePath);
var createField = function (field) {
var alreadyHaveField = !!field;
field =
field ||
new field_1.FieldState({
nodePath: nodePath,
dataPath: dataPath,
computeState: computeState,
dataType: dataType,
unmountRemoveValue: unmountRemoveValue,
useDirty: shared_1.isValid(useDirty) ? useDirty : options.useDirty
});
field.subscription = {
notify: onFieldChange({ field: field, path: nodePath })
};
heart.publish(types_1.LifeCycleTypes.ON_FIELD_WILL_INIT, field);
if (!alreadyHaveField) {
graph.appendNode(nodePath, field);
}
heart.batch(function () {
field.batch(function () {
field.setState(function (state) {
var formValue = getFormValuesIn(state.name);
var formInitialValue = getFormInitialValuesIn(state.name);
if (shared_1.isValid(value)) {
state.value = value;
}
else if (existFormValuesIn(state.name) ||
formValue !== undefined) {
state.value = formValue;
}
else if (shared_1.isValid(initialValue)) {
state.value = initialValue;
}
if (shared_1.isValid(initialValue)) {
state.initialValue = initialValue;
}
else if (shared_1.isValid(formInitialValue)) {
state.initialValue = formInitialValue;
}
if (shared_1.isValid(visible)) {
state.visible = visible;
}
if (shared_1.isValid(display)) {
state.display = display;
}
if (shared_1.isValid(props)) {
state.props = props;
}
if (shared_1.isValid(required)) {
state.required = required;
}
if (shared_1.isValid(rules)) {
state.rules = rules;
}
if (shared_1.isValid(editable)) {
state.selfEditable = editable;
}
if (shared_1.isValid(options.editable)) {
state.formEditable = options.editable;
}
state.initialized = true;
});
batchRunTaskQueue(field, nodePath);
});
});
validator.register(nodePath, function (validate) {
var _a = field.getState(), value = _a.value, rules = _a.rules, editable = _a.editable, visible = _a.visible, unmounted = _a.unmounted, display = _a.display;
if (editable === false ||
visible === false ||
unmounted === true ||
display === false ||
field.disabledValidate)
return validate(value, []);
clearTimeout(field.validateTimer);
field.validateTimer = setTimeout(function () {
field.setState(function (state) {
state.validating = true;
});
}, 60);
heart.publish(types_1.LifeCycleTypes.ON_FIELD_VALIDATE_START, field);
return validate(value, rules).then(function (_a) {
var errors = _a.errors, warnings = _a.warnings;
clearTimeout(field.validateTimer);
return new Promise(function (resolve) {
field.setState(function (state) {
state.validating = false;
state.ruleErrors = errors;
state.ruleWarnings = warnings;
});
heart.publish(types_1.LifeCycleTypes.ON_FIELD_VALIDATE_END, field);
resolve({
errors: errors,
warnings: warnings
});
});
});
});
return field;
};
if (graph.exist(nodePath)) {
field = graph.get(nodePath);
if (types_1.isVirtualField(field)) {
graph.replace(nodePath, field);
}
}
else {
field = createField();
}
return field;
}
function resetFormMessages(fieldState) {
var path = fieldState.path, visible = fieldState.visible, display = fieldState.display, unmounted = fieldState.unmounted, editable = fieldState.editable;
if (editable === false ||
visible === false ||
unmounted === true ||
display === false) {
state.setSourceState(function (state) {
state.errors = state.errors || [];
state.warnings = state.warnings || [];
state.errors = state.errors.reduce(function (buf, item) {
if (item.path === path) {
return buf;
}
else {
return buf.concat(item);
}
}, []);
state.warnings = state.warnings.reduce(function (buf, item) {
if (item.path === path) {
return buf;
}
else {
return buf.concat(item);
}
}, []);
if (state.errors.length) {
state.invalid = true;
state.valid = false;
}
else {
state.invalid = false;
state.valid = true;
}
});
}
}
function syncFormMessages(type, fieldState) {
var name = fieldState.name, path = fieldState.path;
var messages = fieldState[type];
state.setSourceState(function (state) {
var foundField = false;
state[type] = state[type] || [];
state[type] = state[type].reduce(function (buf, item) {
if (item.path === path) {
foundField = true;
return messages.length ? buf.concat({ path: path, messages: messages }) : buf;
}
else {
return buf.concat(item);
}
}, []);
if (!foundField && messages.length) {
state[type].push({
name: name,
path: path,
messages: messages
});
}
if (state.errors.length) {
state.invalid = true;
state.valid = false;
}
else {
state.invalid = false;
state.valid = true;
}
});
}
function transformDataPath(path) {
var newPath = shared_1.FormPath.getPath(path);
return newPath.reduce(function (path, key, index) {
if (index >= newPath.length - 1)
return path.concat([key]);
var realPath = newPath.slice(0, index + 1);
var dataPath = path.concat([key]);
var selected = graph.get(realPath);
if (types_1.isVirtualField(selected)) {
return path;
}
return dataPath;
}, shared_1.FormPath.getPath(''));
}
function setFormIn(path, key, value, silent) {
var method = silent ? 'setSourceState' : 'setState';
state[method](function (state) {
shared_1.FormPath.setIn(state[key], transformDataPath(path), value);
if (key === 'values') {
state.modified = true;
}
}, silent);
}
function deleteFormIn(path, key, silent) {
var method = silent ? 'setSourceState' : 'setState';
state[method](function (state) {
shared_1.FormPath.deleteIn(state[key], transformDataPath(path));
if (key === 'values') {
state.modified = true;
}
}, silent);
}
function deleteFormValuesIn(path, silent) {
deleteFormIn(path, 'values', silent);
}
function setFormValuesIn(path, value, silent) {
return setFormIn(path, 'values', value, silent);
}
function setFormInitialValuesIn(path, value, silent) {
return setFormIn(path, 'initialValues', value, silent);
}
function getFormIn(path, key) {
return state.getState(function (state) {
return shared_1.FormPath.getIn(state[key], transformDataPath(path));
});
}
function getFormValuesIn(path) {
return getFormIn(path, 'values');
}
function existFormValuesIn(path) {
return state.getState(function (state) {
return shared_1.FormPath.existIn(state.values, transformDataPath(path));
});
}
function getFormInitialValuesIn(path) {
return getFormIn(path, 'initialValues');
}
function createMutators(input) {
var field;
if (!types_1.isField(input)) {
var selected = graph.select(input);
if (selected) {
field = selected;
}
else {
throw new Error('The `createMutators` can only accept FieldState instance or FormPathPattern.');
}
}
else {
field = input;
}
function setValue() {
var values = [];
for (var _i = 0; _i < arguments.length; _i++) {
values[_i] = arguments[_i];
}
field.setState(function (state) {
state.value = values[0];
state.values = values;
});
heart.publish(types_1.LifeCycleTypes.ON_FIELD_INPUT_CHANGE, field);
heart.publish(types_1.LifeCycleTypes.ON_FORM_INPUT_CHANGE, state);
}
function removeValue(key) {
var nodePath = field.getSourceState(function (state) { return state.path; });
if (shared_1.isValid(key)) {
var childNodePath = shared_1.FormPath.parse(nodePath).concat(key);
env.removeNodes[childNodePath.toString()] = true;
deleteFormValuesIn(childNodePath);
field.notify(field.getState());
}
else {
var parent_1 = graph.selectParent(nodePath);
env.removeNodes[nodePath.toString()] = true;
deleteFormValuesIn(nodePath);
if (parent_1) {
parent_1.notify(parent_1.getState());
}
}
heart.publish(types_1.LifeCycleTypes.ON_FIELD_VALUE_CHANGE, field);
heart.publish(types_1.LifeCycleTypes.ON_FIELD_INPUT_CHANGE, field);
heart.publish(types_1.LifeCycleTypes.ON_FORM_INPUT_CHANGE, state);
}
function getValue() {
return field.getSourceState(function (state) { return state.value; });
}
function onGraphChange(callback) {
var timer = null;
var id = graph.subscribe(function () {
clearTimeout(timer);
timer = setTimeout(function () {
graph.unsubscribe(id);
callback();
});
});
}
function swapState($from, $to) {
var keys = ['initialValue', 'visibleCacheValue', 'values'];
var arrayName = field.getSourceState(function (state) { return state.name; });
var fromFieldsName = arrayName + "." + $from + ".*";
var toFieldsName = arrayName + "." + $to + ".*";
var cache = {};
var calculatePath = function (name, $from, $to) {
return name.replace(arrayName + "." + $from, arrayName + "." + $to);
};
graph.select(fromFieldsName, function (field) {
field.setSourceState(function (state) {
var targetState = getFieldState(calculatePath(state.name, $from, $to)) || {};
keys.forEach(function (key) {
cache[state.name] = cache[state.name] || {};
cache[state.name][key] = state[key];
state[key] = targetState && targetState[key];
});
});
});
graph.select(toFieldsName, function (field) {
field.setSourceState(function (state) {
var cacheState = cache[calculatePath(state.name, $to, $from)] || {};
keys.forEach(function (key) {
state[key] = cacheState[key];
});
});
});
}
function swapAfterState(start, arrayLength, step) {
if (step === void 0) { step = 1; }
for (var i = arrayLength - 1; i >= start + 1; i -= step) {
swapState(i, i - 1);
}
}
var mutators = {
change: function () {
var values = [];
for (var _i = 0; _i < arguments.length; _i++) {
values[_i] = arguments[_i];
}
setValue.apply(void 0, values);
return values[0];
},
focus: function () {
field.setState(function (state) {
state.active = true;
});
},
blur: function () {
field.setState(function (state) {
state.active = false;
state.visited = true;
});
},
push: function (value) {
var arr = shared_1.toArr(getValue()).slice();
arr.push(value);
setValue(arr);
return arr;
},
pop: function () {
var arr = shared_1.toArr(getValue()).slice();
arr.pop();
setValue(arr);
return arr;
},
insert: function (index, value) {
var arr = shared_1.toArr(getValue()).slice();
arr.splice(index, 0, value);
setValue(arr);
onGraphChange(function () {
swapAfterState(index, arr.length);
});
return arr;
},
remove: function (index) {
var val = getValue();
if (shared_1.isNum(index) && shared_1.isArr(val)) {
val = [].concat(val);
var lastIndex = val.length - 1;
val.splice(index, 1);
if (index < lastIndex) {
swapState(Number(index), Number(index) + 1);
}
setValue(val);
}
else {
removeValue(index);
}
},
exist: function (index) {
var newPath = field.getSourceState(function (state) {
return shared_1.FormPath.parse(state.path);
});
var val = getValue();
return (shared_1.isValid(index) ? newPath.concat(index) : newPath).existIn(val, newPath);
},
unshift: function (value) {
return mutators.insert(0, value);
},
shift: function () {
var arr = shared_1.toArr(getValue()).slice();
arr.shift();
swapState(0, 1);
setValue(arr);
return arr;
},
move: function ($from, $to) {
var arr = shared_1.toArr(getValue()).slice();
var item = arr[$from];
arr.splice($from, 1);
arr.splice($to, 0, item);
swapState($from, $to);
setValue(arr);
return arr;
},
moveUp: function (index) {
var len = shared_1.toArr(getValue()).length;
return mutators.move(index, index - 1 < 0 ? len - 1 : index - 1);
},
moveDown: function (index) {
var len = shared_1.toArr(getValue()).length;
return mutators.move(index, index + 1 > len ? 0 : index + 1);
},
validate: function (opts) {
return validate(field.getSourceState(function (state) { return state.path; }), __assign(__assign({}, opts), { hostRendering: false }));
}
};
return mutators;
}
function clearErrors(pattern) {
if (pattern === void 0) { pattern = '*'; }
hostUpdate(function () {
graph.eachChildren('', pattern, function (field) {
if (types_1.isField(field)) {
field.setState(function (state) {
state.ruleErrors = [];
state.ruleWarnings = [];
state.effectErrors = [];
state.effectWarnings = [];
});
}
});
});
}
function reset(_a) {
var _b = _a === void 0 ? {} : _a, _c = _b.selector, selector = _c === void 0 ? '*' : _c, _d = _b.forceClear, forceClear = _d === void 0 ? false : _d, _e = _b.validate, validate = _e === void 0 ? true : _e, _f = _b.clearInitialValue, clearInitialValue = _f === void 0 ? false : _f;
return __awaiter(this, void 0, void 0, function () {
var validateResult;
return __generator(this, function (_g) {
switch (_g.label) {
case 0:
hostUpdate(function () {
graph.eachChildren('', selector, function (field) {
;
field.disabledValidate = true;
field.setState(function (state) {
state.modified = false;
state.ruleErrors = [];
state.ruleWarnings = [];
state.effectErrors = [];
state.effectWarnings = [];
if (clearInitialValue) {
state.initialValue = undefined;
}
if (forceClear || !shared_1.isValid(state.initialValue)) {
if (shared_1.isArr(state.value)) {
state.value = [];
}
else if (!shared_1.isObj(state.value)) {
state.value = undefined;
}
}
else {
var value = shared_1.clone(state.initialValue);
if (shared_1.isArr(state.value)) {
if (shared_1.isArr(value)) {
state.value = value;
}
else {
state.value = [];
}
}
else if (shared_1.isObj(state.value)) {
if (shared_1.isObj(value)) {
state.value = value;
}
else {
state.value = {};
}
}
else {
state.value = value;
}
}
});
field.disabledValidate = false;
});
});
if (shared_1.isFn(options.onReset) && !state.state.unmounted) {
options.onReset();
}
heart.publish(types_1.LifeCycleTypes.ON_FORM_RESET, state);
if (!validate) return [3, 2];
return [4, formApi.validate(selector, { throwErrors: false })];
case 1:
validateResult = _g.sent();
_g.label = 2;
case 2: return [2, validateResult];
}
});
});
}
function submit(onSubmit) {
return __awaiter(this, void 0, void 0, function () {
var _this = this;
return __generator(this, function (_a) {
if (state.getState(function (state) { return state.submitting; }))
return [2, env.submittingTask];
heart.publish(types_1.LifeCycleTypes.ON_FORM_SUBMIT_START, state);
onSubmit = onSubmit || options.onSubmit;
state.setState(function (state) {
state.submitting = true;
});
env.submittingTask = function () { return __awaiter(_this, void 0, void 0, function () {
var validated, errors, payload, values, e_1;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
heart.publish(types_1.LifeCycleTypes.ON_FORM_SUBMIT_VALIDATE_START, state);
return [4, validate('', { throwErrors: false, hostRendering: true })];
case 1:
_a.sent();
validated = state.getState(function (state) { return ({
errors: state.errors,
warnings: state.warnings
}); });
errors = validated.errors;
if (errors.length) {
state.setState(function (state) {
state.submitting = false;
});
heart.publish(types_1.LifeCycleTypes.ON_FORM_SUBMIT_VALIDATE_FAILED, state);
heart.publish(types_1.LifeCycleTypes.ON_FORM_SUBMIT_END, state);
if (shared_1.isFn(options.onValidateFailed) && !state.state.unmounted) {
options.onValidateFailed(validated);
}
throw errors;
}
heart.publish(types_1.LifeCycleTypes.ON_FORM_SUBMIT_VALIDATE_SUCCESS, state);
heart.publish(types_1.LifeCycleTypes.ON_FORM_SUBMIT, state);
values = state.getState(function (state) { return shared_1.clone(state.values); });
if (!(shared_1.isFn(onSubmit) && !state.state.unmounted)) return [3, 5];
_a.label = 2;
case 2:
_a.trys.push([2, 4, , 5]);
return [4, Promise.resolve(onSubmit(values))];
case 3:
payload = _a.sent();
heart.publish(types_1.LifeCycleTypes.ON_FORM_ON_SUBMIT_SUCCESS, payload);
return [3, 5];
case 4:
e_1 = _a.sent();
heart.publish(types_1.LifeCycleTypes.ON_FORM_ON_SUBMIT_FAILED, e_1);
new Promise(function () {
throw e_1;
});
return [3, 5];
case 5:
state.setState(function (state) {
state.submitting = false;
});
heart.publish(types_1.LifeCycleTypes.ON_FORM_SUBMIT_END, state);
return [2, {
values: values,
validated: validated,
payload: payload
}];
}
});
}); };
return [2, env.submittingTask()];
});
});
}
function validate(path, opts) {
return __awaiter(this, void 0, void 0, function () {
var _a, _b, throwErrors, hostRendering, payload, result, errors, warnings;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_a = opts || {}, _b = _a.throwErrors, throwErrors = _b === void 0 ? true : _b, hostRendering = _a.hostRendering;
if (!state.getState(function (state) { return state.validating; })) {
state.setSourceState(function (state) {
state.validating = true;
});
clearTimeout(env.validateTimer);
env.validateTimer = setTimeout(function () {
state.notify();
}, 60);
}
heart.publish(types_1.LifeCycleTypes.ON_FORM_VALIDATE_START, state);
if (graph.size > 100 && hostRendering)
env.hostRendering = true;
return [4, validator.validate(path, opts)];
case 1:
payload = _c.sent();
clearTimeout(env.validateTimer);
state.setState(function (state) {
state.validating = false;
});
heart.publish(types_1.LifeCycleTypes.ON_FORM_VALIDATE_END, state);
if (graph.size > 100 && hostRendering) {
heart.publish(types_1.LifeCycleTypes.ON_FORM_HOST_RENDER, state);
env.hostRendering = false;
}
result = {
errors: payload.errors.map(function (item) { return (__assign(__assign({}, item), { name: getFieldState(item.path).name })); }),
warnings: payload.warnings.map(function (item) { return (__assign(__assign({}, item), { name: getFieldState(item.path).name })); })
};
errors = result.errors, warnings = result.warnings;
if (warnings.length) {
shared_1.log.warn(warnings);
}
if (errors.length > 0) {
if (throwErrors) {
throw result;
}
else {
return [2, result];
}
}
else {
return [2, result];
}
return [2];
}
});
});
}
function setFormState(callback, silent) {
state.setState(callback, silent);
}
function getFormState(callback) {
return state.getState(callback);
}
function batchRunTaskQueue(field, nodePath) {
for (var index = 0; index < env.taskQueue.length; index++) {
var _a = env.taskQueue[index], pattern = _a.pattern, callbacks = _a.callbacks;
var removed = false;
if (matchStrategy(pattern, nodePath)) {
callbacks.forEach(function (callback) {
field.setState(callback);
});
if (!pattern.isWildMatchPattern && !pattern.isMatchPattern) {
env.taskQueue.splice(index--, 1);
removed = true;
}
}
if (!removed) {
env.taskIndexes[pattern.toString()] = index;
}
else {
delete env.taskIndexes[pattern.toString()];
}
}
}
function pushTaskQueue(pattern, callback) {