@tachybase/schema 0.23.41 → 0.23.48

package/lib/core/shared/internals.js

@@ -0,0 +1,956 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var internals_exports = {};
+__export(internals_exports, {
+  allowAssignDefaultValue: () => allowAssignDefaultValue,
+  batchReset: () => batchReset,
+  batchSubmit: () => batchSubmit,
+  batchValidate: () => batchValidate,
+  buildDataPath: () => buildDataPath,
+  buildFieldPath: () => buildFieldPath,
+  cleanupArrayChildren: () => cleanupArrayChildren,
+  cleanupObjectChildren: () => cleanupObjectChildren,
+  createBatchStateGetter: () => createBatchStateGetter,
+  createBatchStateSetter: () => createBatchStateSetter,
+  createChildrenFeedbackFilter: () => createChildrenFeedbackFilter,
+  createReaction: () => createReaction,
+  createReactions: () => createReactions,
+  createStateGetter: () => createStateGetter,
+  createStateSetter: () => createStateSetter,
+  deserialize: () => deserialize,
+  destroy: () => destroy,
+  exchangeArrayState: () => exchangeArrayState,
+  getArrayParent: () => getArrayParent,
+  getObjectParent: () => getObjectParent,
+  getTypedDefaultValue: () => getTypedDefaultValue,
+  getValidFieldDefaultValue: () => getValidFieldDefaultValue,
+  getValidFormValues: () => getValidFormValues,
+  getValuesFromEvent: () => getValuesFromEvent,
+  initFieldUpdate: () => initFieldUpdate,
+  initializeEnd: () => initializeEnd,
+  initializeStart: () => initializeStart,
+  isHTMLInputEvent: () => isHTMLInputEvent,
+  locateNode: () => locateNode,
+  matchFeedback: () => matchFeedback,
+  modifySelf: () => modifySelf,
+  patchFieldStates: () => patchFieldStates,
+  patchFormValues: () => patchFormValues,
+  queryFeedbackMessages: () => queryFeedbackMessages,
+  queryFeedbacks: () => queryFeedbacks,
+  resetSelf: () => resetSelf,
+  serialize: () => serialize,
+  setLoading: () => setLoading,
+  setSubmitting: () => setSubmitting,
+  setValidating: () => setValidating,
+  setValidatorRule: () => setValidatorRule,
+  spliceArrayState: () => spliceArrayState,
+  subscribeUpdate: () => subscribeUpdate,
+  triggerFormInitialValuesChange: () => triggerFormInitialValuesChange,
+  triggerFormValuesChange: () => triggerFormValuesChange,
+  updateFeedback: () => updateFeedback,
+  validateSelf: () => validateSelf,
+  validateToFeedbacks: () => validateToFeedbacks
+});
+module.exports = __toCommonJS(internals_exports);
+var import_reactive = require("../../reactive");
+var import_shared = require("../../shared");
+var import_validator = require("../../validator");
+var import_types = require("../types");
+var import_constants = require("./constants");
+var import_externals = require("./externals");
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const notify = /* @__PURE__ */ __name((target, formType, fieldType) => {
+  if ((0, import_externals.isForm)(target)) {
+    target.notify(formType);
+  } else {
+    target.notify(fieldType);
+  }
+}, "notify");
+const isHTMLInputEvent = /* @__PURE__ */ __name((event, stopPropagation = true) => {
+  var _a;
+  if (event == null ? 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 ? void 0 : _a.call(event);
+  }
+  return false;
+}, "isHTMLInputEvent");
+const getValuesFromEvent = /* @__PURE__ */ __name((args) => {
+  return args.map((event) => {
+    if (event == null ? void 0 : event.target) {
+      if ((0, import_shared.isValid)(event.target.value)) return event.target.value;
+      if ((0, import_shared.isValid)(event.target.checked)) return event.target.checked;
+      return;
+    }
+    return event;
+  });
+}, "getValuesFromEvent");
+const getTypedDefaultValue = /* @__PURE__ */ __name((field) => {
+  if ((0, import_externals.isArrayField)(field)) return [];
+  if ((0, import_externals.isObjectField)(field)) return {};
+}, "getTypedDefaultValue");
+const buildFieldPath = /* @__PURE__ */ __name((field) => {
+  return buildDataPath(field.form.fields, field.address);
+}, "buildFieldPath");
+const buildDataPath = /* @__PURE__ */ __name((fields, pattern) => {
+  let prevArray = false;
+  const segments = pattern.segments;
+  const path = segments.reduce((path2, key, index) => {
+    const currentPath = path2.concat(key);
+    const currentAddress = segments.slice(0, index + 1);
+    const current = fields[currentAddress.join(".")];
+    if (prevArray) {
+      if (!(0, import_externals.isVoidField)(current)) {
+        prevArray = false;
+      }
+      return path2;
+    }
+    if (index >= segments.length - 1) {
+      return currentPath;
+    }
+    if ((0, import_externals.isVoidField)(current)) {
+      const parentAddress = segments.slice(0, index);
+      const parent = fields[parentAddress.join(".")];
+      if ((0, import_externals.isArrayField)(parent) && (0, import_shared.isNumberLike)(key)) {
+        prevArray = true;
+        return currentPath;
+      }
+      return path2;
+    } else {
+      prevArray = false;
+    }
+    return currentPath;
+  }, []);
+  return new import_shared.FormPath(path);
+}, "buildDataPath");
+const locateNode = /* @__PURE__ */ __name((field, address) => {
+  field.address = import_shared.FormPath.parse(address);
+  field.path = buildFieldPath(field);
+  field.form.indexes[field.path.toString()] = field.address.toString();
+  return field;
+}, "locateNode");
+const patchFieldStates = /* @__PURE__ */ __name((target, patches) => {
+  patches.forEach(({ type, address, oldAddress, payload }) => {
+    if (type === "remove") {
+      destroy(target, address, false);
+    } else if (type === "update") {
+      if (payload) {
+        target[address] = payload;
+        if (target[oldAddress] === payload) {
+          target[oldAddress] = void 0;
+        }
+      }
+      if (address && payload) {
+        locateNode(payload, address);
+      }
+    }
+  });
+}, "patchFieldStates");
+const destroy = /* @__PURE__ */ __name((target, address, forceClear = true) => {
+  const field = target[address];
+  field == null ? void 0 : field.dispose();
+  if ((0, import_externals.isDataField)(field) && forceClear) {
+    const form = field.form;
+    const path = field.path;
+    form.deleteValuesIn(path);
+    form.deleteInitialValuesIn(path);
+  }
+  delete target[address];
+}, "destroy");
+const patchFormValues = /* @__PURE__ */ __name((form, path, source) => {
+  const update = /* @__PURE__ */ __name((path2, source2) => {
+    if (path2.length) {
+      form.setValuesIn(path2, (0, import_shared.clone)(source2));
+    } else {
+      Object.assign(form.values, (0, import_shared.clone)(source2));
+    }
+  }, "update");
+  const patch = /* @__PURE__ */ __name((source2, path2 = []) => {
+    const targetValue = form.getValuesIn(path2);
+    const targetField = form.query(path2).take();
+    const isUnVoidField = targetField && !(0, import_externals.isVoidField)(targetField);
+    if (isUnVoidField && targetField.display === "none") {
+      targetField.caches.value = (0, import_shared.clone)(source2);
+      return;
+    }
+    if (allowAssignDefaultValue(targetValue, source2)) {
+      update(path2, source2);
+    } else {
+      if ((0, import_shared.isEmpty)(source2)) return;
+      if (import_constants.GlobalState.initializing) return;
+      if ((0, import_shared.isPlainObj)(targetValue) && (0, import_shared.isPlainObj)(source2)) {
+        (0, import_shared.each)(source2, (value, key) => {
+          patch(value, path2.concat(key));
+        });
+      } else {
+        if (targetField) {
+          if (isUnVoidField && !targetField.selfModified) {
+            update(path2, source2);
+          }
+        } else if (form.initialized) {
+          update(path2, source2);
+        }
+      }
+    }
+  }, "patch");
+  patch(source, path);
+}, "patchFormValues");
+const matchFeedback = /* @__PURE__ */ __name((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 (!import_shared.FormPath.parse(search.path).match(feedback.path)) return false;
+  }
+  if (search.address && feedback.address) {
+    if (!import_shared.FormPath.parse(search.address).match(feedback.address)) return false;
+  }
+  if (search.triggerType && search.triggerType !== feedback.triggerType) return false;
+  return true;
+}, "matchFeedback");
+const queryFeedbacks = /* @__PURE__ */ __name((field, search) => {
+  return field.feedbacks.filter((feedback) => {
+    var _a, _b, _c;
+    if (!((_a = feedback.messages) == null ? void 0 : _a.length)) return false;
+    return matchFeedback(search, {
+      ...feedback,
+      address: (_b = field.address) == null ? void 0 : _b.toString(),
+      path: (_c = field.path) == null ? void 0 : _c.toString()
+    });
+  });
+}, "queryFeedbacks");
+const queryFeedbackMessages = /* @__PURE__ */ __name((field, search) => {
+  if (!field.feedbacks.length) return [];
+  return queryFeedbacks(field, search).reduce(
+    (buf, info) => (0, import_shared.isEmpty)(info.messages) ? buf : buf.concat(info.messages),
+    []
+  );
+}, "queryFeedbackMessages");
+const updateFeedback = /* @__PURE__ */ __name((field, feedback) => {
+  if (!feedback) return;
+  return (0, import_reactive.batch)(() => {
+    var _a, _b;
+    if (!field.feedbacks.length) {
+      if (!((_a = feedback.messages) == null ? void 0 : _a.length)) {
+        return;
+      }
+      field.feedbacks = [feedback];
+    } else {
+      const searched = queryFeedbacks(field, feedback);
+      if (searched.length) {
+        field.feedbacks = field.feedbacks.reduce((buf, item) => {
+          var _a2;
+          if (searched.includes(item)) {
+            if ((_a2 = feedback.messages) == null ? void 0 : _a2.length) {
+              item.messages = feedback.messages;
+              return buf.concat(item);
+            } else {
+              return buf;
+            }
+          } else {
+            return buf.concat(item);
+          }
+        }, []);
+        return;
+      } else if ((_b = feedback.messages) == null ? void 0 : _b.length) {
+        field.feedbacks = field.feedbacks.concat(feedback);
+      }
+    }
+  });
+}, "updateFeedback");
+const validateToFeedbacks = /* @__PURE__ */ __name(async (field, triggerType = "onInput") => {
+  const results = await (0, import_validator.validate)(field.value, field.validator, {
+    triggerType,
+    validateFirst: field.props.validateFirst ?? field.form.props.validateFirst,
+    context: { field, form: field.form }
+  });
+  (0, import_reactive.batch)(() => {
+    (0, import_shared.each)(results, (messages, type) => {
+      field.setFeedback({
+        triggerType,
+        type,
+        code: (0, import_shared.pascalCase)(`validate-${type}`),
+        messages
+      });
+    });
+  });
+  return results;
+}, "validateToFeedbacks");
+const setValidatorRule = /* @__PURE__ */ __name((field, name, value) => {
+  if (!(0, import_shared.isValid)(value)) return;
+  const validators = (0, import_validator.parseValidatorDescriptions)(field.validator);
+  const hasRule = validators.some((desc) => name in desc);
+  const rule = {
+    [name]: value
+  };
+  if (hasRule) {
+    field.validator = validators.map((desc) => {
+      if ((0, import_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);
+    }
+  }
+}, "setValidatorRule");
+const spliceArrayState = /* @__PURE__ */ __name((field, props) => {
+  const { startIndex, deleteCount, insertCount } = {
+    startIndex: 0,
+    deleteCount: 0,
+    insertCount: 0,
+    ...props
+  };
+  const address = field.address.toString();
+  const addrLength = address.length;
+  const form = field.form;
+  const fields = form.fields;
+  const fieldPatches = [];
+  const offset = insertCount - deleteCount;
+  const isArrayChildren = /* @__PURE__ */ __name((identifier) => {
+    return identifier.indexOf(address) === 0 && identifier.length > addrLength;
+  }, "isArrayChildren");
+  const isAfterNode = /* @__PURE__ */ __name((identifier) => {
+    var _a;
+    const afterStr = identifier.substring(addrLength);
+    const number = (_a = afterStr.match(import_constants.NumberIndexReg)) == null ? void 0 : _a[1];
+    if (number === void 0) return false;
+    const index = Number(number);
+    return index > startIndex + deleteCount - 1;
+  }, "isAfterNode");
+  const isInsertNode = /* @__PURE__ */ __name((identifier) => {
+    var _a;
+    const afterStr = identifier.substring(addrLength);
+    const number = (_a = afterStr.match(import_constants.NumberIndexReg)) == null ? void 0 : _a[1];
+    if (number === void 0) return false;
+    const index = Number(number);
+    return index >= startIndex && index < startIndex + insertCount;
+  }, "isInsertNode");
+  const isDeleteNode = /* @__PURE__ */ __name((identifier) => {
+    var _a;
+    const preStr = identifier.substring(0, addrLength);
+    const afterStr = identifier.substring(addrLength);
+    const number = (_a = afterStr.match(import_constants.NumberIndexReg)) == null ? void 0 : _a[1];
+    if (number === void 0) return false;
+    const index = Number(number);
+    return index > startIndex && !fields[`${preStr}${afterStr.replace(/^\.\d+/, `.${index + deleteCount}`)}`] || index === startIndex;
+  }, "isDeleteNode");
+  const moveIndex = /* @__PURE__ */ __name((identifier) => {
+    var _a;
+    if (offset === 0) return identifier;
+    const preStr = identifier.substring(0, addrLength);
+    const afterStr = identifier.substring(addrLength);
+    const number = (_a = afterStr.match(import_constants.NumberIndexReg)) == null ? void 0 : _a[1];
+    if (number === void 0) return identifier;
+    const index = Number(number) + offset;
+    return `${preStr}${afterStr.replace(/^\.\d+/, `.${index}`)}`;
+  }, "moveIndex");
+  (0, import_reactive.batch)(() => {
+    (0, import_shared.each)(fields, (field2, identifier) => {
+      if (isArrayChildren(identifier)) {
+        if (isAfterNode(identifier)) {
+          const newIdentifier = moveIndex(identifier);
+          fieldPatches.push({
+            type: "update",
+            address: newIdentifier,
+            oldAddress: identifier,
+            payload: field2
+          });
+        }
+        if (isInsertNode(identifier) || isDeleteNode(identifier)) {
+          fieldPatches.push({ type: "remove", address: identifier });
+        }
+      }
+    });
+    patchFieldStates(fields, fieldPatches);
+  });
+  field.form.notify(import_types.LifeCycleTypes.ON_FORM_GRAPH_CHANGE);
+}, "spliceArrayState");
+const exchangeArrayState = /* @__PURE__ */ __name((field, props) => {
+  const { fromIndex, toIndex } = {
+    fromIndex: 0,
+    toIndex: 0,
+    ...props
+  };
+  const address = field.address.toString();
+  const fields = field.form.fields;
+  const addrLength = address.length;
+  const fieldPatches = [];
+  const isArrayChildren = /* @__PURE__ */ __name((identifier) => {
+    return identifier.indexOf(address) === 0 && identifier.length > addrLength;
+  }, "isArrayChildren");
+  const isDown = fromIndex < toIndex;
+  const isMoveNode = /* @__PURE__ */ __name((identifier) => {
+    var _a;
+    const afterStr = identifier.slice(address.length);
+    const number = (_a = afterStr.match(import_constants.NumberIndexReg)) == null ? void 0 : _a[1];
+    if (number === void 0) return false;
+    const index = Number(number);
+    return isDown ? index > fromIndex && index <= toIndex : index < fromIndex && index >= toIndex;
+  }, "isMoveNode");
+  const isFromNode = /* @__PURE__ */ __name((identifier) => {
+    var _a;
+    const afterStr = identifier.substring(addrLength);
+    const number = (_a = afterStr.match(import_constants.NumberIndexReg)) == null ? void 0 : _a[1];
+    if (number === void 0) return false;
+    const index = Number(number);
+    return index === fromIndex;
+  }, "isFromNode");
+  const moveIndex = /* @__PURE__ */ __name((identifier) => {
+    const preStr = identifier.substring(0, addrLength);
+    const afterStr = identifier.substring(addrLength);
+    const number = afterStr.match(import_constants.NumberIndexReg)[1];
+    const current = Number(number);
+    let index = current;
+    if (index === fromIndex) {
+      index = toIndex;
+    } else {
+      index += isDown ? -1 : 1;
+    }
+    return `${preStr}${afterStr.replace(/^\.\d+/, `.${index}`)}`;
+  }, "moveIndex");
+  (0, import_reactive.batch)(() => {
+    (0, import_shared.each)(fields, (field2, identifier) => {
+      if (isArrayChildren(identifier)) {
+        if (isMoveNode(identifier) || isFromNode(identifier)) {
+          const newIdentifier = moveIndex(identifier);
+          fieldPatches.push({
+            type: "update",
+            address: newIdentifier,
+            oldAddress: identifier,
+            payload: field2
+          });
+          if (!fields[newIdentifier]) {
+            fieldPatches.push({
+              type: "remove",
+              address: identifier
+            });
+          }
+        }
+      }
+    });
+    patchFieldStates(fields, fieldPatches);
+  });
+  field.form.notify(import_types.LifeCycleTypes.ON_FORM_GRAPH_CHANGE);
+}, "exchangeArrayState");
+const cleanupArrayChildren = /* @__PURE__ */ __name((field, start) => {
+  const address = field.address.toString();
+  const fields = field.form.fields;
+  const isArrayChildren = /* @__PURE__ */ __name((identifier) => {
+    return identifier.indexOf(address) === 0 && identifier.length > address.length;
+  }, "isArrayChildren");
+  const isNeedCleanup = /* @__PURE__ */ __name((identifier) => {
+    var _a;
+    const afterStr = identifier.slice(address.length);
+    const numStr = (_a = afterStr.match(import_constants.NumberIndexReg)) == null ? void 0 : _a[1];
+    if (numStr === void 0) return false;
+    const index = Number(numStr);
+    return index >= start;
+  }, "isNeedCleanup");
+  (0, import_reactive.batch)(() => {
+    (0, import_shared.each)(fields, (field2, identifier) => {
+      if (isArrayChildren(identifier) && isNeedCleanup(identifier)) {
+        field2.destroy();
+      }
+    });
+  });
+}, "cleanupArrayChildren");
+const cleanupObjectChildren = /* @__PURE__ */ __name((field, keys) => {
+  if (keys.length === 0) return;
+  const address = field.address.toString();
+  const fields = field.form.fields;
+  const isObjectChildren = /* @__PURE__ */ __name((identifier) => {
+    return identifier.indexOf(address) === 0 && identifier.length > address.length;
+  }, "isObjectChildren");
+  const isNeedCleanup = /* @__PURE__ */ __name((identifier) => {
+    var _a;
+    const afterStr = identifier.slice(address.length);
+    const key = (_a = afterStr.match(/^\.([^.]+)/)) == null ? void 0 : _a[1];
+    if (key === void 0) return false;
+    return keys.includes(key);
+  }, "isNeedCleanup");
+  (0, import_reactive.batch)(() => {
+    (0, import_shared.each)(fields, (field2, identifier) => {
+      if (isObjectChildren(identifier) && isNeedCleanup(identifier)) {
+        field2.destroy();
+      }
+    });
+  });
+}, "cleanupObjectChildren");
+const initFieldUpdate = import_reactive.batch.scope.bound((field) => {
+  const form = field.form;
+  const updates = import_shared.FormPath.ensureIn(form, "requests.updates", []);
+  const indexes = import_shared.FormPath.ensureIn(form, "requests.updateIndexes", {});
+  for (let index = 0; index < updates.length; index++) {
+    const { pattern, callbacks } = updates[index];
+    let removed = false;
+    if (field.match(pattern)) {
+      callbacks.forEach((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()];
+    }
+  }
+});
+const subscribeUpdate = /* @__PURE__ */ __name((form, pattern, callback) => {
+  const updates = import_shared.FormPath.ensureIn(form, "requests.updates", []);
+  const indexes = import_shared.FormPath.ensureIn(form, "requests.updateIndexes", {});
+  const id = pattern.toString();
+  const current = indexes[id];
+  if ((0, import_shared.isValid)(current)) {
+    if (updates[current] && !updates[current].callbacks.some((fn) => fn.toString() === callback.toString() ? fn === callback : false)) {
+      updates[current].callbacks.push(callback);
+    }
+  } else {
+    indexes[id] = updates.length;
+    updates.push({
+      pattern,
+      callbacks: [callback]
+    });
+  }
+}, "subscribeUpdate");
+const deserialize = /* @__PURE__ */ __name((model, setter) => {
+  if (!model) return;
+  if ((0, import_shared.isFn)(setter)) {
+    setter(model);
+  } else {
+    for (let key in setter) {
+      if (!hasOwnProperty.call(setter, key)) continue;
+      if (import_constants.ReadOnlyProperties[key] || import_constants.ReservedProperties[key]) continue;
+      const MutuallyExclusiveKey = import_constants.MutuallyExclusiveProperties[key];
+      if (MutuallyExclusiveKey && hasOwnProperty.call(setter, MutuallyExclusiveKey) && !(0, import_shared.isValid)(setter[MutuallyExclusiveKey]))
+        continue;
+      const value = setter[key];
+      if ((0, import_shared.isFn)(value)) continue;
+      model[key] = value;
+    }
+  }
+  return model;
+}, "deserialize");
+const serialize = /* @__PURE__ */ __name((model, getter) => {
+  if ((0, import_shared.isFn)(getter)) {
+    return getter(model);
+  } else {
+    const results = {};
+    for (let key in model) {
+      if (!hasOwnProperty.call(model, key)) continue;
+      if (import_constants.ReservedProperties[key]) continue;
+      if (key === "address" || key === "path") {
+        results[key] = model[key].toString();
+        continue;
+      }
+      const value = model[key];
+      if ((0, import_shared.isFn)(value)) continue;
+      results[key] = (0, import_reactive.toJS)(value);
+    }
+    return results;
+  }
+}, "serialize");
+const createChildrenFeedbackFilter = /* @__PURE__ */ __name((field) => {
+  var _a;
+  const identifier = (_a = field.address) == null ? void 0 : _a.toString();
+  return ({ address }) => {
+    return address === identifier || address.indexOf(identifier + ".") === 0;
+  };
+}, "createChildrenFeedbackFilter");
+const createStateSetter = /* @__PURE__ */ __name((model) => {
+  return import_reactive.batch.bound((setter) => deserialize(model, setter));
+}, "createStateSetter");
+const createStateGetter = /* @__PURE__ */ __name((model) => {
+  return (getter) => serialize(model, getter);
+}, "createStateGetter");
+const createBatchStateSetter = /* @__PURE__ */ __name((form) => {
+  return import_reactive.batch.bound((pattern, payload) => {
+    if ((0, import_externals.isQuery)(pattern)) {
+      pattern.forEach((field) => {
+        field.setState(payload);
+      });
+    } else if ((0, import_externals.isGeneralField)(pattern)) {
+      pattern.setState(payload);
+    } else {
+      let matchCount = 0, path = import_shared.FormPath.parse(pattern);
+      form.query(path).forEach((field) => {
+        field.setState(payload);
+        matchCount++;
+      });
+      if (matchCount === 0 || path.isWildMatchPattern) {
+        subscribeUpdate(form, path, payload);
+      }
+    }
+  });
+}, "createBatchStateSetter");
+const createBatchStateGetter = /* @__PURE__ */ __name((form) => {
+  return (pattern, payload) => {
+    if ((0, import_externals.isQuery)(pattern)) {
+      return pattern.take(payload);
+    } else if ((0, import_externals.isGeneralField)(pattern)) {
+      return pattern.getState(payload);
+    } else {
+      return form.query(pattern).take((field) => {
+        return field.getState(payload);
+      });
+    }
+  };
+}, "createBatchStateGetter");
+const triggerFormInitialValuesChange = /* @__PURE__ */ __name((form, change) => {
+  if (Array.isArray(change.object) && change.key === "length") return;
+  if ((0, import_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(import_types.LifeCycleTypes.ON_FORM_INITIAL_VALUES_CHANGE);
+    }
+  }
+}, "triggerFormInitialValuesChange");
+const triggerFormValuesChange = /* @__PURE__ */ __name((form, change) => {
+  if (Array.isArray(change.object) && change.key === "length") return;
+  if (((0, import_reactive.contains)(form.values, change.object) || form.values === change.value) && form.initialized) {
+    form.notify(import_types.LifeCycleTypes.ON_FORM_VALUES_CHANGE);
+  }
+}, "triggerFormValuesChange");
+const setValidating = /* @__PURE__ */ __name((target, validating) => {
+  clearTimeout(target.requests.validate);
+  if (validating) {
+    target.requests.validate = setTimeout(() => {
+      (0, import_reactive.batch)(() => {
+        target.validating = validating;
+        notify(target, import_types.LifeCycleTypes.ON_FORM_VALIDATING, import_types.LifeCycleTypes.ON_FIELD_VALIDATING);
+      });
+    }, import_constants.RESPONSE_REQUEST_DURATION);
+    notify(target, import_types.LifeCycleTypes.ON_FORM_VALIDATE_START, import_types.LifeCycleTypes.ON_FIELD_VALIDATE_START);
+  } else {
+    if (target.validating !== validating) {
+      target.validating = validating;
+    }
+    notify(target, import_types.LifeCycleTypes.ON_FORM_VALIDATE_END, import_types.LifeCycleTypes.ON_FIELD_VALIDATE_END);
+  }
+}, "setValidating");
+const setSubmitting = /* @__PURE__ */ __name((target, submitting) => {
+  clearTimeout(target.requests.submit);
+  if (submitting) {
+    target.requests.submit = setTimeout(() => {
+      (0, import_reactive.batch)(() => {
+        target.submitting = submitting;
+        notify(target, import_types.LifeCycleTypes.ON_FORM_SUBMITTING, import_types.LifeCycleTypes.ON_FIELD_SUBMITTING);
+      });
+    }, import_constants.RESPONSE_REQUEST_DURATION);
+    notify(target, import_types.LifeCycleTypes.ON_FORM_SUBMIT_START, import_types.LifeCycleTypes.ON_FIELD_SUBMIT_START);
+  } else {
+    if (target.submitting !== submitting) {
+      target.submitting = submitting;
+    }
+    notify(target, import_types.LifeCycleTypes.ON_FORM_SUBMIT_END, import_types.LifeCycleTypes.ON_FIELD_SUBMIT_END);
+  }
+}, "setSubmitting");
+const setLoading = /* @__PURE__ */ __name((target, loading) => {
+  clearTimeout(target.requests.loading);
+  if (loading) {
+    target.requests.loading = setTimeout(() => {
+      (0, import_reactive.batch)(() => {
+        target.loading = loading;
+        notify(target, import_types.LifeCycleTypes.ON_FORM_LOADING, import_types.LifeCycleTypes.ON_FIELD_LOADING);
+      });
+    }, import_constants.RESPONSE_REQUEST_DURATION);
+  } else if (target.loading !== loading) {
+    target.loading = loading;
+  }
+}, "setLoading");
+const batchSubmit = /* @__PURE__ */ __name(async (target, onSubmit) => {
+  const getValues = /* @__PURE__ */ __name((target2) => {
+    if ((0, import_externals.isForm)(target2)) {
+      return (0, import_reactive.toJS)(target2.values);
+    }
+    return (0, import_reactive.toJS)(target2.value);
+  }, "getValues");
+  target.setSubmitting(true);
+  try {
+    notify(target, import_types.LifeCycleTypes.ON_FORM_SUBMIT_VALIDATE_START, import_types.LifeCycleTypes.ON_FIELD_SUBMIT_VALIDATE_START);
+    await target.validate();
+    notify(target, import_types.LifeCycleTypes.ON_FORM_SUBMIT_VALIDATE_SUCCESS, import_types.LifeCycleTypes.ON_FIELD_SUBMIT_VALIDATE_SUCCESS);
+  } catch (e) {
+    notify(target, import_types.LifeCycleTypes.ON_FORM_SUBMIT_VALIDATE_FAILED, import_types.LifeCycleTypes.ON_FIELD_SUBMIT_VALIDATE_FAILED);
+  }
+  notify(target, import_types.LifeCycleTypes.ON_FORM_SUBMIT_VALIDATE_END, import_types.LifeCycleTypes.ON_FIELD_SUBMIT_VALIDATE_END);
+  let results;
+  try {
+    if (target.invalid) {
+      throw target.errors;
+    }
+    if ((0, import_shared.isFn)(onSubmit)) {
+      results = await onSubmit(getValues(target));
+    } else {
+      results = getValues(target);
+    }
+    notify(target, import_types.LifeCycleTypes.ON_FORM_SUBMIT_SUCCESS, import_types.LifeCycleTypes.ON_FIELD_SUBMIT_SUCCESS);
+  } catch (e) {
+    target.setSubmitting(false);
+    notify(target, import_types.LifeCycleTypes.ON_FORM_SUBMIT_FAILED, import_types.LifeCycleTypes.ON_FIELD_SUBMIT_FAILED);
+    notify(target, import_types.LifeCycleTypes.ON_FORM_SUBMIT, import_types.LifeCycleTypes.ON_FIELD_SUBMIT);
+    throw e;
+  }
+  target.setSubmitting(false);
+  notify(target, import_types.LifeCycleTypes.ON_FORM_SUBMIT, import_types.LifeCycleTypes.ON_FIELD_SUBMIT);
+  return results;
+}, "batchSubmit");
+const shouldValidate = /* @__PURE__ */ __name((field) => {
+  const validatePattern = field.props.validatePattern ?? field.form.props.validatePattern ?? ["editable"];
+  const validateDisplay = field.props.validateDisplay ?? field.form.props.validateDisplay ?? ["visible"];
+  return validatePattern.includes(field.pattern) && validateDisplay.includes(field.display);
+}, "shouldValidate");
+const batchValidate = /* @__PURE__ */ __name(async (target, pattern, triggerType) => {
+  if ((0, import_externals.isForm)(target)) target.setValidating(true);
+  else {
+    if (!shouldValidate(target)) return;
+  }
+  const tasks = [];
+  target.query(pattern).forEach((field) => {
+    if (!(0, import_externals.isVoidField)(field)) {
+      tasks.push(validateSelf(field, triggerType, field === target));
+    }
+  });
+  await Promise.all(tasks);
+  if ((0, import_externals.isForm)(target)) target.setValidating(false);
+  if (target.invalid) {
+    notify(target, import_types.LifeCycleTypes.ON_FORM_VALIDATE_FAILED, import_types.LifeCycleTypes.ON_FIELD_VALIDATE_FAILED);
+    throw target.errors;
+  }
+  notify(target, import_types.LifeCycleTypes.ON_FORM_VALIDATE_SUCCESS, import_types.LifeCycleTypes.ON_FIELD_VALIDATE_SUCCESS);
+}, "batchValidate");
+const batchReset = /* @__PURE__ */ __name(async (target, pattern, options) => {
+  const tasks = [];
+  target.query(pattern).forEach((field) => {
+    if (!(0, import_externals.isVoidField)(field)) {
+      tasks.push(resetSelf(field, options, target === field));
+    }
+  });
+  if ((0, import_externals.isForm)(target)) {
+    target.modified = false;
+  }
+  notify(target, import_types.LifeCycleTypes.ON_FORM_RESET, import_types.LifeCycleTypes.ON_FIELD_RESET);
+  await Promise.all(tasks);
+}, "batchReset");
+const validateSelf = import_reactive.batch.bound(async (target, triggerType, noEmit = false) => {
+  const start = /* @__PURE__ */ __name(() => {
+    setValidating(target, true);
+  }, "start");
+  const end = /* @__PURE__ */ __name(() => {
+    setValidating(target, false);
+    if (noEmit) return;
+    if (target.selfValid) {
+      target.notify(import_types.LifeCycleTypes.ON_FIELD_VALIDATE_SUCCESS);
+    } else {
+      target.notify(import_types.LifeCycleTypes.ON_FIELD_VALIDATE_FAILED);
+    }
+  }, "end");
+  if (!shouldValidate(target)) return {};
+  start();
+  if (!triggerType) {
+    const allTriggerTypes = (0, import_validator.parseValidatorDescriptions)(target.validator).reduce(
+      (types, desc) => types.indexOf(desc.triggerType) > -1 ? types : types.concat(desc.triggerType),
+      []
+    );
+    const results2 = {};
+    for (let i = 0; i < allTriggerTypes.length; i++) {
+      const payload = await validateToFeedbacks(target, allTriggerTypes[i]);
+      (0, import_shared.each)(payload, (result, key) => {
+        results2[key] = results2[key] || [];
+        results2[key] = results2[key].concat(result);
+      });
+    }
+    end();
+    return results2;
+  }
+  const results = await validateToFeedbacks(target, triggerType);
+  end();
+  return results;
+});
+const resetSelf = import_reactive.batch.bound(async (target, options, noEmit = false) => {
+  const typedDefaultValue = getTypedDefaultValue(target);
+  target.modified = false;
+  target.selfModified = false;
+  target.visited = false;
+  target.feedbacks = [];
+  target.inputValue = typedDefaultValue;
+  target.inputValues = [];
+  target.caches = {};
+  if (!(0, import_shared.isUndef)(target.value)) {
+    if (options == null ? void 0 : options.forceClear) {
+      target.value = typedDefaultValue;
+    } else {
+      const initialValue = target.initialValue;
+      target.value = (0, import_reactive.toJS)(!(0, import_shared.isUndef)(initialValue) ? initialValue : typedDefaultValue);
+    }
+  }
+  if (!noEmit) {
+    target.notify(import_types.LifeCycleTypes.ON_FIELD_RESET);
+  }
+  if (options == null ? void 0 : options.validate) {
+    return await validateSelf(target);
+  }
+});
+const modifySelf = /* @__PURE__ */ __name((target) => {
+  if (target.selfModified) return;
+  target.selfModified = true;
+  target.modified = true;
+  let parent = target.parent;
+  while (parent) {
+    if ((0, import_externals.isDataField)(parent)) {
+      if (parent.modified) return;
+      parent.modified = true;
+    }
+    parent = parent.parent;
+  }
+  target.form.modified = true;
+}, "modifySelf");
+const getValidFormValues = /* @__PURE__ */ __name((values) => {
+  if ((0, import_reactive.isObservable)(values)) return values;
+  return (0, import_shared.clone)(values || {});
+}, "getValidFormValues");
+const getValidFieldDefaultValue = /* @__PURE__ */ __name((value, initialValue) => {
+  if (allowAssignDefaultValue(value, initialValue)) return (0, import_shared.clone)(initialValue);
+  return value;
+}, "getValidFieldDefaultValue");
+const allowAssignDefaultValue = /* @__PURE__ */ __name((target, source) => {
+  const isValidTarget = !(0, import_shared.isUndef)(target);
+  const isValidSource = !(0, import_shared.isUndef)(source);
+  if (!isValidTarget) {
+    return isValidSource;
+  }
+  if (typeof target === typeof source) {
+    if (target === "") return false;
+    if (target === 0) return false;
+  }
+  const isEmptyTarget = target !== null && (0, import_shared.isEmpty)(target, true);
+  const isEmptySource = source !== null && (0, import_shared.isEmpty)(source, true);
+  if (isEmptyTarget) {
+    return !isEmptySource;
+  }
+  return false;
+}, "allowAssignDefaultValue");
+const createReactions = /* @__PURE__ */ __name((field) => {
+  const reactions = (0, import_shared.toArr)(field.props.reactions);
+  field.form.addEffects(field, () => {
+    reactions.forEach((reaction2) => {
+      if ((0, import_shared.isFn)(reaction2)) {
+        field.disposers.push(
+          (0, import_reactive.autorun)(
+            import_reactive.batch.scope.bound(() => {
+              if (field.destroyed) return;
+              reaction2(field);
+            })
+          )
+        );
+      }
+    });
+  });
+}, "createReactions");
+const createReaction = /* @__PURE__ */ __name((tracker, scheduler) => {
+  return (0, import_reactive.reaction)(tracker, import_reactive.untracked.bound(scheduler));
+}, "createReaction");
+const initializeStart = /* @__PURE__ */ __name(() => {
+  import_constants.GlobalState.initializing = true;
+}, "initializeStart");
+const initializeEnd = /* @__PURE__ */ __name(() => {
+  import_reactive.batch.endpoint(() => {
+    import_constants.GlobalState.initializing = false;
+  });
+}, "initializeEnd");
+const getArrayParent = /* @__PURE__ */ __name((field, index = field.index) => {
+  if (index > -1) {
+    let parent = field.parent;
+    while (parent) {
+      if ((0, import_externals.isArrayField)(parent)) return parent;
+      if (parent === field.form) return;
+      parent = parent.parent;
+    }
+  }
+}, "getArrayParent");
+const getObjectParent = /* @__PURE__ */ __name((field) => {
+  let parent = field.parent;
+  while (parent) {
+    if ((0, import_externals.isArrayField)(parent)) return;
+    if ((0, import_externals.isObjectField)(parent)) return parent;
+    if (parent === field.form) return;
+    parent = parent.parent;
+  }
+}, "getObjectParent");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  allowAssignDefaultValue,
+  batchReset,
+  batchSubmit,
+  batchValidate,
+  buildDataPath,
+  buildFieldPath,
+  cleanupArrayChildren,
+  cleanupObjectChildren,
+  createBatchStateGetter,
+  createBatchStateSetter,
+  createChildrenFeedbackFilter,
+  createReaction,
+  createReactions,
+  createStateGetter,
+  createStateSetter,
+  deserialize,
+  destroy,
+  exchangeArrayState,
+  getArrayParent,
+  getObjectParent,
+  getTypedDefaultValue,
+  getValidFieldDefaultValue,
+  getValidFormValues,
+  getValuesFromEvent,
+  initFieldUpdate,
+  initializeEnd,
+  initializeStart,
+  isHTMLInputEvent,
+  locateNode,
+  matchFeedback,
+  modifySelf,
+  patchFieldStates,
+  patchFormValues,
+  queryFeedbackMessages,
+  queryFeedbacks,
+  resetSelf,
+  serialize,
+  setLoading,
+  setSubmitting,
+  setValidating,
+  setValidatorRule,
+  spliceArrayState,
+  subscribeUpdate,
+  triggerFormInitialValuesChange,
+  triggerFormValuesChange,
+  updateFeedback,
+  validateSelf,
+  validateToFeedbacks
+});