@formily/core
Version:
1,123 lines (1,103 loc) • 153 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
typeof define === 'function' && define.amd ? define('formily.core', ['exports'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.Formily = global.Formily || {}, global.Formily.Core = {})));
})(this, (function (exports) { 'use strict';
(function() {
const env = {"NODE_ENV":"development"};
try {
if (process) {
process.env = Object.assign({}, process.env);
Object.assign(process.env, env);
return;
}
} catch (e) {} // avoid ReferenceError: process is not defined
globalThis.process = { env:env };
})();
/******************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise, SuppressedError, Symbol */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign(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);
};
function __awaiter(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());
});
}
function __generator(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 (g && (g = 0, op[0] && (_ = 0)), _) 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 __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
function __spreadArray(to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
}
typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};
var LifeCycle = /** @class */ (function () {
function LifeCycle() {
var params = [];
for (var _i = 0; _i < arguments.length; _i++) {
params[_i] = arguments[_i];
}
var _this = this;
this.buildListener = function (params) {
return function (payload, ctx) {
var _this = this;
for (var index = 0; index < params.length; index++) {
var item = params[index];
if (Formily.Shared.isFn(item)) {
item.call(this, payload, ctx);
}
else if (Formily.Shared.isStr(item) && Formily.Shared.isFn(params[index + 1])) {
if (item === payload.type) {
params[index + 1].call(this, payload.payload, ctx);
}
index++;
}
else {
Formily.Shared.each(item, function (handler, type) {
if (Formily.Shared.isFn(handler) && Formily.Shared.isStr(type)) {
if (type === payload.type) {
handler.call(_this, payload.payload, ctx);
return false;
}
}
});
}
}
};
};
this.notify = function (type, payload, ctx) {
if (Formily.Shared.isStr(type)) {
_this.listener.call(ctx, { type: type, payload: payload }, ctx);
}
};
this.listener = this.buildListener(params);
}
return LifeCycle;
}());
var Heart = /** @class */ (function (_super) {
__extends(Heart, _super);
function Heart(_a) {
var _b = _a === void 0 ? {} : _a, lifecycles = _b.lifecycles, context = _b.context;
var _this = _super.call(this) || this;
_this.lifecycles = [];
_this.outerLifecycles = new Map();
_this.buildLifeCycles = function (lifecycles) {
return lifecycles.reduce(function (buf, item) {
if (item instanceof LifeCycle) {
return buf.concat(item);
}
else {
if (Formily.Shared.isArr(item)) {
return _this.buildLifeCycles(item);
}
else if (typeof item === 'object') {
_this.context = item;
return buf;
}
return buf;
}
}, []);
};
_this.addLifeCycles = function (id, lifecycles) {
if (lifecycles === void 0) { lifecycles = []; }
var observers = _this.buildLifeCycles(lifecycles);
if (observers.length) {
_this.outerLifecycles.set(id, observers);
}
};
_this.hasLifeCycles = function (id) {
return _this.outerLifecycles.has(id);
};
_this.removeLifeCycles = function (id) {
_this.outerLifecycles.delete(id);
};
_this.setLifeCycles = function (lifecycles) {
if (lifecycles === void 0) { lifecycles = []; }
_this.lifecycles = _this.buildLifeCycles(lifecycles);
};
_this.publish = function (type, payload, context) {
if (Formily.Shared.isStr(type)) {
_this.lifecycles.forEach(function (lifecycle) {
lifecycle.notify(type, payload, context || _this.context);
});
_this.outerLifecycles.forEach(function (lifecycles) {
lifecycles.forEach(function (lifecycle) {
lifecycle.notify(type, payload, context || _this.context);
});
});
_this.notify({
type: type,
payload: payload,
});
}
};
_this.clear = function () {
_this.lifecycles = [];
_this.outerLifecycles.clear();
_this.unsubscribe();
};
_this.lifecycles = _this.buildLifeCycles(lifecycles || []);
_this.context = context;
return _this;
}
return Heart;
}(Formily.Shared.Subscribable));
var isForm = function (node) {
return node instanceof Form;
};
var isGeneralField = function (node) {
return node instanceof Field || node instanceof VoidField;
};
var isField = function (node) {
return node instanceof Field;
};
var isArrayField = function (node) {
return node instanceof ArrayField;
};
var isObjectField = function (node) {
return node instanceof ObjectField;
};
var isVoidField = function (node) {
return node instanceof VoidField;
};
var isFormState = function (state) {
if (Formily.Shared.isFn(state === null || state === void 0 ? void 0 : state.initialize))
return false;
return (state === null || state === void 0 ? void 0 : state.displayName) === 'Form';
};
var isFieldState = function (state) {
if (Formily.Shared.isFn(state === null || state === void 0 ? void 0 : state.initialize))
return false;
return (state === null || state === void 0 ? void 0 : state.displayName) === 'Field';
};
var isGeneralFieldState = function (node) {
var _a;
if (Formily.Shared.isFn(node === null || node === void 0 ? void 0 : node.initialize))
return false;
return ((_a = node === null || node === void 0 ? void 0 : node.displayName) === null || _a === void 0 ? void 0 : _a.indexOf('Field')) > -1;
};
var isArrayFieldState = function (state) {
if (Formily.Shared.isFn(state === null || state === void 0 ? void 0 : state.initialize))
return false;
return (state === null || state === void 0 ? void 0 : state.displayName) === 'ArrayField';
};
var isDataField = function (node) {
return isField(node) || isArrayField(node) || isObjectField(node);
};
var isDataFieldState = function (node) {
return (isFieldState(node) || isObjectFieldState(node) || isArrayFieldState(node));
};
var isObjectFieldState = function (state) {
if (Formily.Shared.isFn(state === null || state === void 0 ? void 0 : state.initialize))
return false;
return (state === null || state === void 0 ? void 0 : state.displayName) === 'ObjectField';
};
var isVoidFieldState = function (state) {
if (Formily.Shared.isFn(state === null || state === void 0 ? void 0 : state.initialize))
return false;
return (state === null || state === void 0 ? void 0 : state.displayName) === 'VoidField';
};
var isQuery = function (query) {
return query && query instanceof Query;
};
var Graph = /** @class */ (function () {
function Graph(form) {
var _this = this;
this.getGraph = function () {
var graph = {};
graph[''] = _this.form.getState();
Formily.Shared.each(_this.form.fields, function (field, identifier) {
graph[identifier] = field.getState();
});
return graph;
};
this.setGraph = function (graph) {
var form = _this.form;
var createField = function (identifier, state) {
var address = Formily.Shared.FormPath.parse(identifier);
var name = address.segments[address.segments.length - 1];
var basePath = address.parent();
if (isFieldState(state)) {
return _this.form.createField({ name: name, basePath: basePath });
}
else if (isArrayFieldState(state)) {
return _this.form.createArrayField({ name: name, basePath: basePath });
}
else if (isObjectFieldState(state)) {
return _this.form.createObjectField({ name: name, basePath: basePath });
}
else {
return _this.form.createVoidField({ name: name, basePath: basePath });
}
};
Formily.Shared.each(graph, function (state, address) {
if (isFormState(state)) {
form.setState(state);
}
else {
var field = form.fields[address];
if (field) {
field.setState(state);
}
else {
createField(address, state).setState(state);
}
}
});
};
this.form = form;
Formily.Reactive.define(this, {
setGraph: Formily.Reactive.batch,
});
}
return Graph;
}());
exports.LifeCycleTypes = void 0;
(function (LifeCycleTypes) {
/**
* Form LifeCycle
**/
LifeCycleTypes["ON_FORM_INIT"] = "onFormInit";
LifeCycleTypes["ON_FORM_MOUNT"] = "onFormMount";
LifeCycleTypes["ON_FORM_UNMOUNT"] = "onFormUnmount";
LifeCycleTypes["ON_FORM_INPUT_CHANGE"] = "onFormInputChange";
LifeCycleTypes["ON_FORM_VALUES_CHANGE"] = "onFormValuesChange";
LifeCycleTypes["ON_FORM_INITIAL_VALUES_CHANGE"] = "onFormInitialValuesChange";
LifeCycleTypes["ON_FORM_SUBMIT"] = "onFormSubmit";
LifeCycleTypes["ON_FORM_RESET"] = "onFormReset";
LifeCycleTypes["ON_FORM_SUBMIT_START"] = "onFormSubmitStart";
LifeCycleTypes["ON_FORM_SUBMITTING"] = "onFormSubmitting";
LifeCycleTypes["ON_FORM_SUBMIT_END"] = "onFormSubmitEnd";
LifeCycleTypes["ON_FORM_SUBMIT_VALIDATE_START"] = "onFormSubmitValidateStart";
LifeCycleTypes["ON_FORM_SUBMIT_VALIDATE_SUCCESS"] = "onFormSubmitValidateSuccess";
LifeCycleTypes["ON_FORM_SUBMIT_VALIDATE_FAILED"] = "onFormSubmitValidateFailed";
LifeCycleTypes["ON_FORM_SUBMIT_VALIDATE_END"] = "onFormSubmitValidateEnd";
LifeCycleTypes["ON_FORM_SUBMIT_SUCCESS"] = "onFormSubmitSuccess";
LifeCycleTypes["ON_FORM_SUBMIT_FAILED"] = "onFormSubmitFailed";
LifeCycleTypes["ON_FORM_VALIDATE_START"] = "onFormValidateStart";
LifeCycleTypes["ON_FORM_VALIDATING"] = "onFormValidating";
LifeCycleTypes["ON_FORM_VALIDATE_SUCCESS"] = "onFormValidateSuccess";
LifeCycleTypes["ON_FORM_VALIDATE_FAILED"] = "onFormValidateFailed";
LifeCycleTypes["ON_FORM_VALIDATE_END"] = "onFormValidateEnd";
LifeCycleTypes["ON_FORM_GRAPH_CHANGE"] = "onFormGraphChange";
LifeCycleTypes["ON_FORM_LOADING"] = "onFormLoading";
/**
* Field LifeCycle
**/
LifeCycleTypes["ON_FIELD_INIT"] = "onFieldInit";
LifeCycleTypes["ON_FIELD_INPUT_VALUE_CHANGE"] = "onFieldInputValueChange";
LifeCycleTypes["ON_FIELD_VALUE_CHANGE"] = "onFieldValueChange";
LifeCycleTypes["ON_FIELD_INITIAL_VALUE_CHANGE"] = "onFieldInitialValueChange";
LifeCycleTypes["ON_FIELD_SUBMIT"] = "onFieldSubmit";
LifeCycleTypes["ON_FIELD_SUBMIT_START"] = "onFieldSubmitStart";
LifeCycleTypes["ON_FIELD_SUBMITTING"] = "onFieldSubmitting";
LifeCycleTypes["ON_FIELD_SUBMIT_END"] = "onFieldSubmitEnd";
LifeCycleTypes["ON_FIELD_SUBMIT_VALIDATE_START"] = "onFieldSubmitValidateStart";
LifeCycleTypes["ON_FIELD_SUBMIT_VALIDATE_SUCCESS"] = "onFieldSubmitValidateSuccess";
LifeCycleTypes["ON_FIELD_SUBMIT_VALIDATE_FAILED"] = "onFieldSubmitValidateFailed";
LifeCycleTypes["ON_FIELD_SUBMIT_VALIDATE_END"] = "onFieldSubmitValidateEnd";
LifeCycleTypes["ON_FIELD_SUBMIT_SUCCESS"] = "onFieldSubmitSuccess";
LifeCycleTypes["ON_FIELD_SUBMIT_FAILED"] = "onFieldSubmitFailed";
LifeCycleTypes["ON_FIELD_VALIDATE_START"] = "onFieldValidateStart";
LifeCycleTypes["ON_FIELD_VALIDATING"] = "onFieldValidating";
LifeCycleTypes["ON_FIELD_VALIDATE_SUCCESS"] = "onFieldValidateSuccess";
LifeCycleTypes["ON_FIELD_VALIDATE_FAILED"] = "onFieldValidateFailed";
LifeCycleTypes["ON_FIELD_VALIDATE_END"] = "onFieldValidateEnd";
LifeCycleTypes["ON_FIELD_LOADING"] = "onFieldLoading";
LifeCycleTypes["ON_FIELD_RESET"] = "onFieldReset";
LifeCycleTypes["ON_FIELD_MOUNT"] = "onFieldMount";
LifeCycleTypes["ON_FIELD_UNMOUNT"] = "onFieldUnmount";
})(exports.LifeCycleTypes || (exports.LifeCycleTypes = {}));
var ReservedProperties = {
form: true,
parent: true,
props: true,
caches: true,
requests: true,
disposers: true,
heart: true,
graph: true,
indexes: true,
fields: true,
lifecycles: true,
componentType: true,
componentProps: true,
decoratorType: true,
decoratorProps: true,
};
var ReadOnlyProperties = {
address: true,
path: true,
valid: true,
invalid: true,
selfValid: true,
selfInvalid: true,
errors: true,
successes: true,
warnings: true,
validateStatus: true,
};
var SELF_DISPLAY = 'selfDisplay';
var SELF_PATTERN = 'selfPattern';
var MutuallyExclusiveProperties = {
pattern: SELF_PATTERN,
editable: SELF_PATTERN,
readOnly: SELF_PATTERN,
readPretty: SELF_PATTERN,
disabled: SELF_PATTERN,
display: SELF_DISPLAY,
hidden: SELF_DISPLAY,
visible: SELF_DISPLAY,
};
var RESPONSE_REQUEST_DURATION = 100;
var GlobalState = {
lifecycles: [],
context: [],
effectStart: false,
effectEnd: false,
initializing: false,
};
var NumberIndexReg = /^\.(\d+)/;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var notify = function (target, formType, fieldType) {
if (isForm(target)) {
target.notify(formType);
}
else {
target.notify(fieldType);
}
};
var isHTMLInputEvent = function (event, stopPropagation) {
var _a;
if (stopPropagation === void 0) { stopPropagation = true; }
if (event === null || event === void 0 ? void 0 : event.target) {
if (typeof event.target === 'object' &&
('value' in event.target || 'checked' in event.target))
return true;
if (stopPropagation)
(_a = event.stopPropagation) === null || _a === void 0 ? void 0 : _a.call(event);
}
return false;
};
var getValuesFromEvent = function (args) {
return args.map(function (event) {
if (event === null || event === void 0 ? void 0 : event.target) {
if (Formily.Shared.isValid(event.target.value))
return event.target.value;
if (Formily.Shared.isValid(event.target.checked))
return event.target.checked;
return;
}
return event;
});
};
var getTypedDefaultValue = function (field) {
if (isArrayField(field))
return [];
if (isObjectField(field))
return {};
};
var buildFieldPath = function (field) {
return buildDataPath(field.form.fields, field.address);
};
var buildDataPath = function (fields, pattern) {
var prevArray = false;
var segments = pattern.segments;
var path = segments.reduce(function (path, key, index) {
var currentPath = path.concat(key);
var currentAddress = segments.slice(0, index + 1);
var current = fields[currentAddress.join('.')];
if (prevArray) {
if (!isVoidField(current)) {
prevArray = false;
}
return path;
}
if (index >= segments.length - 1) {
return currentPath;
}
if (isVoidField(current)) {
var parentAddress = segments.slice(0, index);
var parent_1 = fields[parentAddress.join('.')];
if (isArrayField(parent_1) && Formily.Shared.isNumberLike(key)) {
prevArray = true;
return currentPath;
}
return path;
}
else {
prevArray = false;
}
return currentPath;
}, []);
return new Formily.Shared.FormPath(path);
};
var locateNode = function (field, address) {
field.address = Formily.Shared.FormPath.parse(address);
field.path = buildFieldPath(field);
field.form.indexes[field.path.toString()] = field.address.toString();
return field;
};
var patchFieldStates = function (target, patches) {
patches.forEach(function (_a) {
var type = _a.type, address = _a.address, oldAddress = _a.oldAddress, payload = _a.payload;
if (type === 'remove') {
destroy(target, address, false);
}
else if (type === 'update') {
if (payload) {
target[address] = payload;
if (target[oldAddress] === payload) {
target[oldAddress] = undefined;
}
}
if (address && payload) {
locateNode(payload, address);
}
}
});
};
var destroy = function (target, address, forceClear) {
if (forceClear === void 0) { forceClear = true; }
var field = target[address];
field === null || field === void 0 ? void 0 : field.dispose();
if (isDataField(field) && forceClear) {
var form = field.form;
var path = field.path;
form.deleteValuesIn(path);
form.deleteInitialValuesIn(path);
}
delete target[address];
};
var patchFormValues = function (form, path, source) {
var update = function (path, source) {
if (path.length) {
form.setValuesIn(path, Formily.Shared.clone(source));
}
else {
Object.assign(form.values, Formily.Shared.clone(source));
}
};
var patch = function (source, path) {
if (path === void 0) { path = []; }
var targetValue = form.getValuesIn(path);
var targetField = form.query(path).take();
var isUnVoidField = targetField && !isVoidField(targetField);
if (isUnVoidField && targetField.display === 'none') {
targetField.caches.value = Formily.Shared.clone(source);
return;
}
if (allowAssignDefaultValue(targetValue, source)) {
update(path, source);
}
else {
if (Formily.Shared.isEmpty(source))
return;
if (GlobalState.initializing)
return;
if (Formily.Shared.isPlainObj(targetValue) && Formily.Shared.isPlainObj(source)) {
Formily.Shared.each(source, function (value, key) {
patch(value, path.concat(key));
});
}
else {
if (targetField) {
if (isUnVoidField && !targetField.selfModified) {
update(path, source);
}
}
else if (form.initialized) {
update(path, source);
}
}
}
};
patch(source, path);
};
var matchFeedback = function (search, feedback) {
if (!search || !feedback)
return false;
if (search.type && search.type !== feedback.type)
return false;
if (search.code && search.code !== feedback.code)
return false;
if (search.path && feedback.path) {
if (!Formily.Shared.FormPath.parse(search.path).match(feedback.path))
return false;
}
if (search.address && feedback.address) {
if (!Formily.Shared.FormPath.parse(search.address).match(feedback.address))
return false;
}
if (search.triggerType && search.triggerType !== feedback.triggerType)
return false;
return true;
};
var queryFeedbacks = function (field, search) {
return field.feedbacks.filter(function (feedback) {
var _a, _b, _c;
if (!((_a = feedback.messages) === null || _a === void 0 ? void 0 : _a.length))
return false;
return matchFeedback(search, __assign(__assign({}, feedback), { address: (_b = field.address) === null || _b === void 0 ? void 0 : _b.toString(), path: (_c = field.path) === null || _c === void 0 ? void 0 : _c.toString() }));
});
};
var queryFeedbackMessages = function (field, search) {
if (!field.feedbacks.length)
return [];
return queryFeedbacks(field, search).reduce(function (buf, info) { return (Formily.Shared.isEmpty(info.messages) ? buf : buf.concat(info.messages)); }, []);
};
var updateFeedback = function (field, feedback) {
if (!feedback)
return;
return Formily.Reactive.batch(function () {
var _a, _b;
if (!field.feedbacks.length) {
if (!((_a = feedback.messages) === null || _a === void 0 ? void 0 : _a.length)) {
return;
}
field.feedbacks = [feedback];
}
else {
var searched_1 = queryFeedbacks(field, feedback);
if (searched_1.length) {
field.feedbacks = field.feedbacks.reduce(function (buf, item) {
var _a;
if (searched_1.includes(item)) {
if ((_a = feedback.messages) === null || _a === void 0 ? void 0 : _a.length) {
item.messages = feedback.messages;
return buf.concat(item);
}
else {
return buf;
}
}
else {
return buf.concat(item);
}
}, []);
return;
}
else if ((_b = feedback.messages) === null || _b === void 0 ? void 0 : _b.length) {
field.feedbacks = field.feedbacks.concat(feedback);
}
}
});
};
var validateToFeedbacks = function (field, triggerType) {
if (triggerType === void 0) { triggerType = 'onInput'; }
return __awaiter(void 0, void 0, void 0, function () {
var results;
var _a;
return __generator(this, function (_b) {
switch (_b.label) {
case 0: return [4 /*yield*/, Formily.Validator.validate(field.value, field.validator, {
triggerType: triggerType,
validateFirst: (_a = field.props.validateFirst) !== null && _a !== void 0 ? _a : field.form.props.validateFirst,
context: { field: field, form: field.form },
})];
case 1:
results = _b.sent();
Formily.Reactive.batch(function () {
Formily.Shared.each(results, function (messages, type) {
field.setFeedback({
triggerType: triggerType,
type: type,
code: Formily.Shared.pascalCase("validate-".concat(type)),
messages: messages,
});
});
});
return [2 /*return*/, results];
}
});
});
};
var setValidatorRule = function (field, name, value) {
var _a;
if (!Formily.Shared.isValid(value))
return;
var validators = Formily.Validator.parseValidatorDescriptions(field.validator);
var hasRule = validators.some(function (desc) { return name in desc; });
var rule = (_a = {},
_a[name] = value,
_a);
if (hasRule) {
field.validator = validators.map(function (desc) {
if (Formily.Shared.isPlainObj(desc) && hasOwnProperty.call(desc, name)) {
desc[name] = value;
return desc;
}
return desc;
});
}
else {
if (name === 'required') {
field.validator = [rule].concat(validators);
}
else {
field.validator = validators.concat(rule);
}
}
};
var spliceArrayState = function (field, props) {
var _a = __assign({ startIndex: 0, deleteCount: 0, insertCount: 0 }, props), startIndex = _a.startIndex, deleteCount = _a.deleteCount, insertCount = _a.insertCount;
var address = field.address.toString();
var addrLength = address.length;
var form = field.form;
var fields = form.fields;
var fieldPatches = [];
var offset = insertCount - deleteCount;
var isArrayChildren = function (identifier) {
return identifier.indexOf(address) === 0 && identifier.length > addrLength;
};
var isAfterNode = function (identifier) {
var _a;
var afterStr = identifier.substring(addrLength);
var number = (_a = afterStr.match(NumberIndexReg)) === null || _a === void 0 ? void 0 : _a[1];
if (number === undefined)
return false;
var index = Number(number);
return index > startIndex + deleteCount - 1;
};
var isInsertNode = function (identifier) {
var _a;
var afterStr = identifier.substring(addrLength);
var number = (_a = afterStr.match(NumberIndexReg)) === null || _a === void 0 ? void 0 : _a[1];
if (number === undefined)
return false;
var index = Number(number);
return index >= startIndex && index < startIndex + insertCount;
};
var isDeleteNode = function (identifier) {
var _a;
var preStr = identifier.substring(0, addrLength);
var afterStr = identifier.substring(addrLength);
var number = (_a = afterStr.match(NumberIndexReg)) === null || _a === void 0 ? void 0 : _a[1];
if (number === undefined)
return false;
var index = Number(number);
return ((index > startIndex &&
!fields["".concat(preStr).concat(afterStr.replace(/^\.\d+/, ".".concat(index + deleteCount)))]) ||
index === startIndex);
};
var moveIndex = function (identifier) {
var _a;
if (offset === 0)
return identifier;
var preStr = identifier.substring(0, addrLength);
var afterStr = identifier.substring(addrLength);
var number = (_a = afterStr.match(NumberIndexReg)) === null || _a === void 0 ? void 0 : _a[1];
if (number === undefined)
return identifier;
var index = Number(number) + offset;
return "".concat(preStr).concat(afterStr.replace(/^\.\d+/, ".".concat(index)));
};
Formily.Reactive.batch(function () {
Formily.Shared.each(fields, function (field, identifier) {
if (isArrayChildren(identifier)) {
if (isAfterNode(identifier)) {
var newIdentifier = moveIndex(identifier);
fieldPatches.push({
type: 'update',
address: newIdentifier,
oldAddress: identifier,
payload: field,
});
}
if (isInsertNode(identifier) || isDeleteNode(identifier)) {
fieldPatches.push({ type: 'remove', address: identifier });
}
}
});
patchFieldStates(fields, fieldPatches);
});
field.form.notify(exports.LifeCycleTypes.ON_FORM_GRAPH_CHANGE);
};
var exchangeArrayState = function (field, props) {
var _a = __assign({ fromIndex: 0, toIndex: 0 }, props), fromIndex = _a.fromIndex, toIndex = _a.toIndex;
var address = field.address.toString();
var fields = field.form.fields;
var addrLength = address.length;
var fieldPatches = [];
var isArrayChildren = function (identifier) {
return identifier.indexOf(address) === 0 && identifier.length > addrLength;
};
var isDown = fromIndex < toIndex;
var isMoveNode = function (identifier) {
var _a;
var afterStr = identifier.slice(address.length);
var number = (_a = afterStr.match(NumberIndexReg)) === null || _a === void 0 ? void 0 : _a[1];
if (number === undefined)
return false;
var index = Number(number);
return isDown
? index > fromIndex && index <= toIndex
: index < fromIndex && index >= toIndex;
};
var isFromNode = function (identifier) {
var _a;
var afterStr = identifier.substring(addrLength);
var number = (_a = afterStr.match(NumberIndexReg)) === null || _a === void 0 ? void 0 : _a[1];
if (number === undefined)
return false;
var index = Number(number);
return index === fromIndex;
};
var moveIndex = function (identifier) {
var preStr = identifier.substring(0, addrLength);
var afterStr = identifier.substring(addrLength);
var number = afterStr.match(NumberIndexReg)[1];
var current = Number(number);
var index = current;
if (index === fromIndex) {
index = toIndex;
}
else {
index += isDown ? -1 : 1;
}
return "".concat(preStr).concat(afterStr.replace(/^\.\d+/, ".".concat(index)));
};
Formily.Reactive.batch(function () {
Formily.Shared.each(fields, function (field, identifier) {
if (isArrayChildren(identifier)) {
if (isMoveNode(identifier) || isFromNode(identifier)) {
var newIdentifier = moveIndex(identifier);
fieldPatches.push({
type: 'update',
address: newIdentifier,
oldAddress: identifier,
payload: field,
});
if (!fields[newIdentifier]) {
fieldPatches.push({
type: 'remove',
address: identifier,
});
}
}
}
});
patchFieldStates(fields, fieldPatches);
});
field.form.notify(exports.LifeCycleTypes.ON_FORM_GRAPH_CHANGE);
};
var cleanupArrayChildren = function (field, start) {
var address = field.address.toString();
var fields = field.form.fields;
var isArrayChildren = function (identifier) {
return (identifier.indexOf(address) === 0 && identifier.length > address.length);
};
var isNeedCleanup = function (identifier) {
var _a;
var afterStr = identifier.slice(address.length);
var numStr = (_a = afterStr.match(NumberIndexReg)) === null || _a === void 0 ? void 0 : _a[1];
if (numStr === undefined)
return false;
var index = Number(numStr);
return index >= start;
};
Formily.Reactive.batch(function () {
Formily.Shared.each(fields, function (field, identifier) {
if (isArrayChildren(identifier) && isNeedCleanup(identifier)) {
field.destroy();
}
});
});
};
var cleanupObjectChildren = function (field, keys) {
if (keys.length === 0)
return;
var address = field.address.toString();
var fields = field.form.fields;
var isObjectChildren = function (identifier) {
return (identifier.indexOf(address) === 0 && identifier.length > address.length);
};
var isNeedCleanup = function (identifier) {
var _a;
var afterStr = identifier.slice(address.length);
var key = (_a = afterStr.match(/^\.([^.]+)/)) === null || _a === void 0 ? void 0 : _a[1];
if (key === undefined)
return false;
return keys.includes(key);
};
Formily.Reactive.batch(function () {
Formily.Shared.each(fields, function (field, identifier) {
if (isObjectChildren(identifier) && isNeedCleanup(identifier)) {
field.destroy();
}
});
});
};
var initFieldUpdate = Formily.Reactive.batch.scope.bound(function (field) {
var form = field.form;
var updates = Formily.Shared.FormPath.ensureIn(form, 'requests.updates', []);
var indexes = Formily.Shared.FormPath.ensureIn(form, 'requests.updateIndexes', {});
for (var index = 0; index < updates.length; index++) {
var _a = updates[index], pattern = _a.pattern, callbacks = _a.callbacks;
var removed = false;
if (field.match(pattern)) {
callbacks.forEach(function (callback) {
field.setState(callback);
});
if (!pattern.isWildMatchPattern && !pattern.isMatchPattern) {
updates.splice(index--, 1);
removed = true;
}
}
if (!removed) {
indexes[pattern.toString()] = index;
}
else {
delete indexes[pattern.toString()];
}
}
});
var subscribeUpdate = function (form, pattern, callback) {
var updates = Formily.Shared.FormPath.ensureIn(form, 'requests.updates', []);
var indexes = Formily.Shared.FormPath.ensureIn(form, 'requests.updateIndexes', {});
var id = pattern.toString();
var current = indexes[id];
if (Formily.Shared.isValid(current)) {
if (updates[current] &&
!updates[current].callbacks.some(function (fn) {
return fn.toString() === callback.toString() ? fn === callback : false;
})) {
updates[current].callbacks.push(callback);
}
}
else {
indexes[id] = updates.length;
updates.push({
pattern: pattern,
callbacks: [callback],
});
}
};
var deserialize = function (model, setter) {
if (!model)
return;
if (Formily.Shared.isFn(setter)) {
setter(model);
}
else {
for (var key in setter) {
if (!hasOwnProperty.call(setter, key))
continue;
if (ReadOnlyProperties[key] || ReservedProperties[key])
continue;
var MutuallyExclusiveKey = MutuallyExclusiveProperties[key];
if (MutuallyExclusiveKey &&
hasOwnProperty.call(setter, MutuallyExclusiveKey) &&
!Formily.Shared.isValid(setter[MutuallyExclusiveKey]))
continue;
var value = setter[key];
if (Formily.Shared.isFn(value))
continue;
model[key] = value;
}
}
return model;
};
var serialize = function (model, getter) {
if (Formily.Shared.isFn(getter)) {
return getter(model);
}
else {
var results = {};
for (var key in model) {
if (!hasOwnProperty.call(model, key))
continue;
if (ReservedProperties[key])
continue;
if (key === 'address' || key === 'path') {
results[key] = model[key].toString();
continue;
}
var value = model[key];
if (Formily.Shared.isFn(value))
continue;
results[key] = Formily.Reactive.toJS(value);
}
return results;
}
};
var createChildrenFeedbackFilter = function (field) {
var _a;
var identifier = (_a = field.address) === null || _a === void 0 ? void 0 : _a.toString();
return function (_a) {
var address = _a.address;
return address === identifier || address.indexOf(identifier + '.') === 0;
};
};
var createStateSetter = function (model) {
return Formily.Reactive.batch.bound(function (setter) { return deserialize(model, setter); });
};
var createStateGetter = function (model) {
return function (getter) { return serialize(model, getter); };
};
var createBatchStateSetter = function (form) {
return Formily.Reactive.batch.bound(function (pattern, payload) {
if (isQuery(pattern)) {
pattern.forEach(function (field) {
field.setState(payload);
});
}
else if (isGeneralField(pattern)) {
pattern.setState(payload);
}
else {
var matchCount_1 = 0, path = Formily.Shared.FormPath.parse(pattern);
form.query(path).forEach(function (field) {
field.setState(payload);
matchCount_1++;
});
if (matchCount_1 === 0 || path.isWildMatchPattern) {
subscribeUpdate(form, path, payload);
}
}
});
};
var createBatchStateGetter = function (form) {
return function (pattern, payload) {
if (isQuery(pattern)) {
return pattern.take(payload);
}
else if (isGeneralField(pattern)) {
return pattern.getState(payload);
}
else {
return form.query(pattern).take(function (field) {
return field.getState(payload);
});
}
};
};
var triggerFormInitialValuesChange = function (form, change) {
if (Array.isArray(change.object) && change.key === 'length')
return;
if (Formily.Reactive.contains(form.initialValues, change.object) ||
form.initialValues === change.value) {
if (change.type === 'add' || change.type === 'set') {
patchFormValues(form, change.path.slice(1), change.value);
}
if (form.initialized) {
form.notify(exports.LifeCycleTypes.ON_FORM_INITIAL_VALUES_CHANGE);
}
}
};
var triggerFormValuesChange = function (form, change) {
if (Array.isArray(change.object) && change.key === 'length')
return;
if ((Formily.Reactive.contains(form.values, change.object) || form.values === change.value) &&
form.initialized) {
form.notify(exports.LifeCycleTypes.ON_FORM_VALUES_CHANGE);
}
};
var setValidating = function (target, validating) {
clearTimeout(target.requests.validate);
if (validating) {
target.requests.validate = setTimeout(function () {
Formily.Reactive.batch(function () {
target.validating = validating;
notify(target, exports.LifeCycleTypes.ON_FORM_VALIDATING, exports.LifeCycleTypes.ON_FIELD_VALIDATING);
});
}, RESPONSE_REQUEST_DURATION);
notify(target, exports.LifeCycleTypes.ON_FORM_VALIDATE_START, exports.LifeCycleTypes.ON_FIELD_VALIDATE_START);
}
else {
if (target.validating !== validating) {
target.validating = validating;
}
notify(target, exports.LifeCycleTypes.ON_FORM_VALIDATE_END, exports.LifeCycleTypes.ON_FIELD_VALIDATE_END);
}
};
var setSubmitting = function (target, submitting) {
clearTimeout(target.requests.submit);
if (submitting) {
target.requests.submit = setTimeout(function () {
Formily.Reactive.batch(function () {
target.submitting = submitting;