cnhis-design-vue 3.1.23-beta.15 → 3.1.23-beta.16

package/es/components/form-render/src/hooks/useFieldListAdaptor.js

@@ -1 +1,287 @@
-export { useFieldListAdaptor } from './useFieldListAdaptor2.js';
+import { arrayed } from '../../../../shared/utils/index.js';
+import { isObject } from '@vueuse/core';
+import { cloneDeep, omit, pick } from 'lodash-es';
+import '../../index.js';
+import { parseNumberFromMaybeString, formRenderLog } from '../utils/index.js';
+import { useFieldNormalize } from './useFieldNormalize.js';
+import { fieldKeyEscape, createLinebarId } from '../utils/schema.js';
+import { transformDateFormat } from '../utils/business.js';
+import { useFormValidator } from './useFormValidator.js';
+
+function useFieldListAdaptor(collector) {
+  const { createValidatorSchema } = useFormValidator();
+  const createStandardSchema = (item) => {
+    var _a;
+    const result = {
+      name: item.val_key,
+      type: (_a = item.fieldType) != null ? _a : "string",
+      title: item.alias || item.name,
+      "x-component": item.html_type,
+      default: item.default_val,
+      "x-component-props": {
+        placeholder: item.placeholder,
+        clearable: item.is_empty === "0",
+        ...item.componentProps || {},
+        onBlur(...args) {
+          var _a2, _b;
+          collector.trigger(item.val_key, "blur");
+          (_b = (_a2 = item.componentProps) == null ? void 0 : _a2.onBlur) == null ? void 0 : _b.call(_a2, ...args);
+        }
+      },
+      "x-display": item.is_show === "0" ? "hidden" : "visible",
+      "x-pattern": item.is_edit === "0" ? "disabled" : "editable"
+    };
+    if (isObject(item.reactions)) {
+      result["x-reactions"] = item.reactions;
+    }
+    if (!item.noDecorator) {
+      Object.assign(result, {
+        "x-decorator": "FORM_ITEM",
+        "x-decorator-props": {
+          span: item.elem_width,
+          showLabel: item.hide_title !== "1",
+          propertyKey: item.val_key,
+          annotation: item.annotation,
+          ...item.decoratorProps || {}
+        }
+      });
+    }
+    const rules = createValidatorSchema(item);
+    rules && (result["x-validator"] = rules);
+    item.is_null === "0" && (result.required = true);
+    return result;
+  };
+  const createInputSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      ...pick(item, ["prefix", "suffix"])
+    });
+    return schema;
+  };
+  const createSelectSchema = (item) => {
+    const schema = createStandardSchema(item);
+    if (item.urlConfig) {
+      bindUrlProps(schema, item);
+    } else if (item.autograph) {
+      bindAutoGraphProps(schema, item);
+    }
+    bindCommonProps(schema, item);
+    return schema;
+    function bindCommonProps(schema2, item2) {
+      const multiple = item2.multi_select === "0";
+      Object.assign(schema2["x-component-props"], {
+        multiple,
+        options: item2.option,
+        maxTagCount: parseNumberFromMaybeString(item2.multi_select_value),
+        ...pick(item2, ["lazyRequest", "requestCache"])
+      });
+      multiple && (schema2.type = "array");
+    }
+    function bindAutoGraphProps(schema2, item2) {
+      schema2["x-component"] = "SEARCH";
+      Object.assign(schema2["x-component-props"], {
+        ...pick(item2, ["wordbook", "autograph"])
+      });
+    }
+    function bindUrlProps(schema2, item2) {
+      Object.assign(schema2["x-component-props"], {
+        ...pick(item2, ["urlConfig"])
+      });
+    }
+  };
+  const createRadioSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      options: item.option,
+      vertical: item.__vertical
+    });
+    return schema;
+  };
+  const createDateSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      valueFormat: item.date_format,
+      type: transformDateFormat(item.date_format),
+      validate: item.validate
+    });
+    return schema;
+  };
+  const createSearchCascadeSchema = (item) => {
+    var _a;
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      urlConfig: item.urlConfig,
+      depth: (_a = item.wordbook) == null ? void 0 : _a.level_num,
+      options: item.option
+    });
+    return schema;
+  };
+  const createLevelSearchCascadeSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      ...pick(item, ["wordbook", "lazyRequest", "autograph"])
+    });
+    return schema;
+  };
+  const createSwitchSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      openDescription: item.open,
+      closeDescription: item.close
+    });
+    return schema;
+  };
+  const createCombinationSchema = (item) => {
+    const schema = createStandardSchema(item);
+    schema.type = "array";
+    if (item.jsonCombination !== false) {
+      schema["x-component"] = "JSON_COMBINATION";
+    }
+    Object.assign(schema["x-decorator-props"], {
+      showLabel: false,
+      showFeedback: false
+    });
+    Object.assign(schema["x-component-props"], {
+      title: item.alias || item.name,
+      maxGroupNum: item.maxGroupNum,
+      getProperties: () => item.children || []
+    });
+    return schema;
+  };
+  const createInputNumberSchema = (item) => {
+    const schema = createStandardSchema(item);
+    const { decimal_length, validate } = item;
+    Object.assign(schema["x-component-props"], {
+      precision: decimal_length || (validate == null ? void 0 : validate.decimal_length),
+      prefix: item.prefix,
+      suffix: item.suffix
+    });
+    return schema;
+  };
+  const createSliderSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      step: parseNumberFromMaybeString(item.step_length),
+      max: parseNumberFromMaybeString(item.max_length),
+      min: parseNumberFromMaybeString(item.min_length),
+      option: item.option
+    });
+    return schema;
+  };
+  const createCustomSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      fieldItem: omit(item, ["reactions"])
+    });
+    return schema;
+  };
+  const createLinebarSchema = (item) => {
+    return {
+      name: item.val_key,
+      type: "void",
+      title: item.alias || item.name,
+      "x-component": "LINEBAR",
+      "x-component-props": {
+        line: item.__line,
+        disabled: item.is_not_fold === "1",
+        id: createLinebarId(item.val_key),
+        show: item.is_show !== "0"
+      }
+    };
+  };
+  const createComplexSchema = (item) => {
+    const schema = createStandardSchema(item);
+    if (Array.isArray(item.properties)) {
+      formRenderLog(
+        "COMPLEX\u63A7\u4EF6\u7684properties\u5C5E\u6027\u5DF2\u7ECF\u5E9F\u5F03, \u8BF7\u4F7F\u7528children\u4F5C\u4E3A\u66FF\u4EE3, \u5728\u4E4B\u540E\u7684\u7248\u672C\u4E2Dproperties\u5C5E\u6027\u5C06\u4E0D\u518D\u652F\u6301"
+      );
+    }
+    const properties = Array.isArray(item.properties || item.children) ? schemaAdaptor(item.properties || item.children) : {};
+    schema.type = item.fieldType || "void";
+    schema.properties = properties;
+    Object.assign(schema["x-decorator-props"], { showFeedback: false });
+    Object.assign(schema["x-component-props"], pick(item, ["wrapperStyle", "display"]));
+    return schema;
+  };
+  const createLinebreaksSchema = (item) => {
+    return {
+      name: item.val_key,
+      type: "void",
+      title: item.alias || item.name,
+      "x-component": "LINE_BREAKS",
+      "x-display": item.is_show === "0" ? "hidden" : "visible"
+    };
+  };
+  const creatorMap = /* @__PURE__ */ new Map([
+    ["LINEBAR", createLinebarSchema],
+    ["LINE_BREAKS", createLinebreaksSchema],
+    ["INPUT", createInputSchema],
+    ["INPUT_NUMBER", createInputNumberSchema],
+    ["SELECT", createSelectSchema],
+    ["DATE", createDateSchema],
+    ["LEVEL_SEARCH_CASCADE", createLevelSearchCascadeSchema],
+    ["SEARCH_CASCADE", createSearchCascadeSchema],
+    ["COMBINATION", createCombinationSchema],
+    ["RADIO", createRadioSchema],
+    ["CHECKBOX", createRadioSchema],
+    ["SWITCH", createSwitchSchema],
+    ["SLIDER", createSliderSchema],
+    ["COMPLEX", createComplexSchema]
+  ]);
+  const createWidgetSchema = (item) => {
+    if (item.suffixConfig)
+      return createWidgetCombinationSchema(item);
+    const creator = creatorMap.get(item.html_type) || createCustomSchema;
+    return creator(item);
+  };
+  const createWidgetCombinationSchema = (item) => {
+    if (!item.suffixConfig)
+      return createWidgetSchema(item);
+    const suffixList = arrayed(item.suffixConfig);
+    const fieldList = [{ ...item, suffixConfig: void 0 }].concat(
+      suffixList.map((suffix) => {
+        return { ...suffix, is_show: item.is_show, alias: " " };
+      })
+    );
+    return {
+      type: "void",
+      name: fieldKeyEscape(fieldList),
+      title: item.alias || item.name,
+      "x-component": "INPUT_GROUP",
+      "x-component-props": { span: item.elem_width },
+      properties: schemaAdaptor(fieldList)
+    };
+  };
+  const { FieldNormalizeWaterfallHook } = useFieldNormalize();
+  function schemaAdaptor(fieldList) {
+    let prevLinebar = null;
+    return fieldList.reduce((fin, cur, idx) => {
+      var _a;
+      cur = FieldNormalizeWaterfallHook.call(cloneDeep(cur));
+      const obj_type = (_a = cur.validate) == null ? void 0 : _a.obj_type;
+      obj_type && collector.collect(obj_type, cur.val_key);
+      if (cur.html_type === "LINEBAR") {
+        fin[createFieldName(cur)] = bindIndex(createLinebarSchema(cur), idx);
+        prevLinebar = fin[createFieldName(cur)].properties = {};
+      } else if (prevLinebar) {
+        prevLinebar[createFieldName(cur)] = bindIndex(createWidgetSchema(cur), idx);
+      } else {
+        prevLinebar = null;
+        fin[createFieldName(cur)] = bindIndex(createWidgetSchema(cur), idx);
+      }
+      return fin;
+    }, {});
+    function bindIndex(schema, idx) {
+      return { ...schema, "x-index": idx };
+    }
+    function createFieldName(fieldItem) {
+      if (fieldItem.suffixConfig) {
+        return fieldKeyEscape([fieldItem, ...arrayed(fieldItem.suffixConfig)]);
+      }
+      return fieldItem.val_key;
+    }
+  }
+  return { schemaAdaptor };
+}
+
+export { useFieldListAdaptor };

package/es/components/form-render/src/hooks/useFieldNormalize.js

@@ -1 +1,65 @@
-export { useFieldNormalize } from './useFieldNormalize2.js';
+import '../../../../shared/utils/tapable/SyncHook.js';
+import '../../../../shared/utils/tapable/SyncBailHook.js';
+import SyncWaterfallHook from '../../../../shared/utils/tapable/SyncWaterfallHook.js';
+import '../../../../shared/utils/tapable/SyncLoopHook.js';
+import '../../../../shared/utils/tapable/AsyncParallelHook.js';
+import '../../../../shared/utils/tapable/AsyncParallelBailHook.js';
+import '../../../../shared/utils/tapable/AsyncSeriesHook.js';
+import '../../../../shared/utils/tapable/AsyncSeriesBailHook.js';
+import '../../../../shared/utils/tapable/AsyncSeriesLoopHook.js';
+import '../../../../shared/utils/tapable/AsyncSeriesWaterfallHook.js';
+import { FIELD_BUSINESS_TYPE } from '../constants/index.js';
+
+function useFieldNormalize() {
+  const FieldNormalizeWaterfallHook = new SyncWaterfallHook(["fieldItem"]);
+  FieldNormalizeWaterfallHook.tap("__block", (fieldItem) => {
+    if (["CHECKBOX_BLOCK", "RADIO_BLOCK"].includes(fieldItem.html_type)) {
+      fieldItem.__vertical = true;
+    }
+    return fieldItem;
+  });
+  FieldNormalizeWaterfallHook.tap("__age", (fieldItem) => {
+    if (fieldItem.html_type === "AGE") {
+      fieldItem.html_type = "INPUT_NUMBER";
+      fieldItem.reactions = {
+        target: fieldItem.val_key_unit,
+        fulfill: {
+          state: { disabled: "{{$self.disabled}}" }
+        }
+      };
+      fieldItem.suffixConfig = [
+        {
+          validate: { obj_type: FIELD_BUSINESS_TYPE.AGE_UNIT },
+          val_key: fieldItem.val_key_unit,
+          html_type: "SELECT",
+          option: fieldItem.option,
+          urlConfig: fieldItem.urlConfig
+        }
+      ];
+    }
+    return fieldItem;
+  });
+  const types = [
+    [["SEARCH", "PHONE_TYPE", "IDCARD_TYPE"], "SELECT"],
+    ["DIGITAL", "INPUT_NUMBER"],
+    ["CHECKBOX_BLOCK", "CHECKBOX"],
+    ["RADIO_BLOCK", "RADIO"],
+    [["DATE-INPUT", "DATETIME-INPUT"], "DATE"],
+    ["SWITCH_COMPONENT", "SWITCH"],
+    ["SLIDER_COMPONENT", "SLIDER"]
+  ];
+  FieldNormalizeWaterfallHook.tap("__normalize", (fieldItem) => {
+    types.some(([rule, target]) => {
+      const match = Array.isArray(rule) ? rule.includes(fieldItem.html_type) : rule === fieldItem.html_type;
+      return match && (fieldItem.html_type = target);
+    });
+    return fieldItem;
+  });
+  FieldNormalizeWaterfallHook.tap("__elem_width", (fieldItem) => {
+    fieldItem.elem_width = ~~((fieldItem.elem_width || 3) * 2);
+    return fieldItem;
+  });
+  return { FieldNormalizeWaterfallHook };
+}
+
+export { useFieldNormalize };

package/es/components/form-render/src/hooks/useFieldVisitor.js

@@ -1 +1,46 @@
-export { useFieldVisitor } from './useFieldVisitor2.js';
+import { arrayed } from '../../../../shared/utils/index.js';
+import { isFunction } from '@vueuse/core';
+
+function useFieldVisitor() {
+  function matchFieldName(matcher, target) {
+    return matcher.split("|").some((m) => m.trim() === target);
+  }
+  function traverse(fieldList, visitorMap, key = "val_key") {
+    if (!visitorMap)
+      return fieldList;
+    return fieldList.reduce((fin, field) => {
+      if (Array.isArray(field.children)) {
+        field.children = traverse(field.children, visitorMap, key);
+      }
+      if (Array.isArray(field.properties)) {
+        field.properties = traverse(field.properties, visitorMap, key);
+      }
+      if (field.suffixConfig) {
+        field.suffixConfig = traverse(arrayed(field.suffixConfig), visitorMap, key);
+      }
+      const visitorKey = Object.keys(visitorMap).find((matcher) => {
+        return matchFieldName(matcher, field[key]);
+      });
+      const visitor = visitorKey && visitorMap[visitorKey];
+      let current = field;
+      const before = [];
+      const after = [];
+      isFunction(visitor) && visitor({
+        field,
+        replace(field2) {
+          current = field2;
+        },
+        insertBefore(field2) {
+          before.push(...arrayed(field2));
+        },
+        insertAfter(field2) {
+          after.push(...arrayed(field2));
+        }
+      });
+      return fin.concat([...before, current, ...after]);
+    }, []);
+  }
+  return { traverse };
+}
+
+export { useFieldVisitor };

package/es/components/form-render/src/hooks/useFormContext.js

@@ -1 +1,68 @@
-export { useFormContext } from './useFormContext2.js';
+import { uuidGenerator } from '../../../../shared/utils/index.js';
+import { isObject } from '@vue/shared';
+import { cloneDeep } from 'lodash-es';
+import { provide, computed, readonly } from 'vue';
+import { createSchemaField } from '@formily/vue';
+import '../../index.js';
+import * as index from '../components/renderer/index.js';
+import { useFormRenderLifeCycle } from './useFormRenderLifeCycle.js';
+import { usePresetScope } from './usePresetScope.js';
+import { injectOrProvide, presetRequestHandler } from '../utils/index.js';
+import { InjectionBusinessCollector, InjectionChangeContextCollector, InjectionFormItemDepsCollector, InjectionFormUUID, InjectionAnnotation, InjectAsyncQueue, InjectionSchemaField } from '../constants/index.js';
+import { useBusinessBinding } from './useBusinessBinding.js';
+import { useChangeContext } from './useChangeContext.js';
+import { useFormItemDeps } from './useFormItemDeps.js';
+import { useAsyncQueue } from './useAsyncQueue.js';
+
+function useFormContext(props, formModel) {
+  const { callLifeCycle } = useFormRenderLifeCycle(props);
+  const asyncQueue = injectOrProvide(
+    InjectAsyncQueue,
+    () => useAsyncQueue().create(props.parallelism, {
+      beforeRequest(...args) {
+        return callLifeCycle("beforeRequest", cloneDeep(args)) || args[1];
+      },
+      afterRequest(...args) {
+        return callLifeCycle("afterRequest", cloneDeep(args)) || presetRequestHandler(args[1]);
+      }
+    })
+  );
+  const SchemaField = injectOrProvide(
+    InjectionSchemaField,
+    () => createSchemaField({
+      components: { ...index, ...props.components },
+      scope: Object.assign({}, usePresetScope(), props.scope)
+    }).SchemaField
+  );
+  const businessCollector = useBusinessBinding().create(formModel, props.businessFormatter);
+  provide(InjectionBusinessCollector, businessCollector);
+  const changeContextCollector = useChangeContext().create();
+  provide(InjectionChangeContextCollector, changeContextCollector);
+  const formItemDepsCollector = useFormItemDeps().create();
+  provide(InjectionFormItemDepsCollector, formItemDepsCollector);
+  const formUUID = props.uuid || uuidGenerator();
+  provide(InjectionFormUUID, formUUID);
+  provide(
+    InjectionAnnotation,
+    computed({
+      get() {
+        return props.annotation ? readonly(props.annotation) : null;
+      },
+      set(payload) {
+        if (!isObject(props.annotation) || !isObject(payload))
+          return;
+        props.annotation[payload.property] = payload.value;
+      }
+    })
+  );
+  return {
+    asyncQueue,
+    SchemaField,
+    businessCollector,
+    changeContextCollector,
+    formItemDepsCollector,
+    formUUID
+  };
+}
+
+export { useFormContext };

package/es/components/form-render/src/hooks/useFormField.js

@@ -1 +1,13 @@
-export { useFormField } from './useFormField2.js';
+import { useField } from '@formily/vue';
+import { computed } from 'vue';
+
+function useFormField() {
+  const field = useField();
+  return {
+    field,
+    title: computed(() => field.value.title),
+    fieldKey: computed(() => field.value.props.name.toString())
+  };
+}
+
+export { useFormField };

package/es/components/form-render/src/hooks/useFormItemDeps.js

@@ -1 +1,31 @@
-export { FormItemDepsCollector, useFormItemDeps } from './useFormItemDeps2.js';
+import { isFunction } from 'lodash-es';
+import '../utils/index.js';
+import { traverseDependKey } from '../utils/schema.js';
+
+class FormItemDepsCollector {
+  constructor() {
+    this.collector = /* @__PURE__ */ new Map();
+  }
+  setDeps(key, dependKeys, callback) {
+    traverseDependKey(dependKeys, (dependKey) => {
+      const map = this.collector.get(dependKey) || /* @__PURE__ */ new Map();
+      map.set(key, callback);
+      this.collector.set(dependKey, map);
+    });
+  }
+  getDeps(dependKey) {
+    return this.collector.get(dependKey);
+  }
+  trigger(dependKey, payload) {
+    var _a;
+    (_a = this.getDeps(dependKey)) == null ? void 0 : _a.forEach((cb) => isFunction(cb) && cb(payload));
+  }
+}
+function useFormItemDeps() {
+  function create() {
+    return new FormItemDepsCollector();
+  }
+  return { create };
+}
+
+export { FormItemDepsCollector, useFormItemDeps };

package/es/components/form-render/src/hooks/useFormRenderLifeCycle.js

@@ -1 +1,10 @@
-export { useFormRenderLifeCycle } from './useFormRenderLifeCycle2.js';
+import { isFunction } from 'lodash-es';
+
+function useFormRenderLifeCycle(props) {
+  function callLifeCycle(lifeCycleName, payload) {
+    return props.lifeCycle && isFunction(props.lifeCycle[lifeCycleName]) && props.lifeCycle[lifeCycleName].apply(void 0, payload || []);
+  }
+  return { callLifeCycle };
+}
+
+export { useFormRenderLifeCycle };

package/es/components/form-render/src/hooks/useFormRequest.js

@@ -1 +1,19 @@
-export { useFormRequest } from './useFormRequest2.js';
+let http = null;
+const searchRequestInfo = { method: "post", url: "", primaryKeyUrl: "" };
+function useFormRequest() {
+  function getHttpInstance() {
+    return http;
+  }
+  function registGlobHttpInstance(instance) {
+    http = instance;
+  }
+  function getSearchRequestInfo() {
+    return { ...searchRequestInfo };
+  }
+  function registGlobSearchInfo(info) {
+    Object.assign(searchRequestInfo, info);
+  }
+  return { getHttpInstance, registGlobHttpInstance, getSearchRequestInfo, registGlobSearchInfo };
+}
+
+export { useFormRequest };

package/es/components/form-render/src/hooks/useFormValidator.js

@@ -1 +1,68 @@
-export { useFormValidator } from './useFormValidator2.js';
+import { arrayed } from '../../../../shared/utils/index.js';
+import { isString } from 'lodash-es';
+import '../utils/index.js';
+import { isFunction } from '@vueuse/core';
+import { isIdCard } from '../utils/business.js';
+
+function useFormValidator() {
+  const validateMap = /* @__PURE__ */ new Map([
+    ["mobile", ({ validate }) => ({ format: "phone", message: validate == null ? void 0 : validate.message })],
+    ["integer", ({ validate }) => ({ format: "integer", message: validate == null ? void 0 : validate.message })],
+    ["number", ({ validate }) => ({ format: "number", message: validate == null ? void 0 : validate.message })],
+    [
+      "id_card",
+      ({ validate }) => ({
+        validator(value) {
+          var _a;
+          if (value == null)
+            return;
+          if (!isString(value) || !isIdCard(value))
+            return (_a = validate == null ? void 0 : validate.message) != null ? _a : "\u8BE5\u5B57\u6BB5\u4E0D\u662F\u5408\u6CD5\u7684\u8EAB\u4EFD\u8BC1\u683C\u5F0F";
+        }
+      })
+    ],
+    [
+      "regular",
+      ({ validate, regular_expression, regular_error_tip }) => {
+        const pattern = regular_expression || (validate == null ? void 0 : validate.regular_expression) || "";
+        const message = regular_error_tip || (validate == null ? void 0 : validate.regular_error_tip) || (validate == null ? void 0 : validate.message) || "\u683C\u5F0F\u9519\u8BEF";
+        return { pattern, message };
+      }
+    ]
+  ]);
+  const commonValidateConfig = { triggerType: "onBlur" };
+  const createDecimalValidator = (decimal, message) => {
+    const errorMessage = message != null ? message : `\u5C0F\u6570\u4F4D\u6570\u6700\u591A${decimal}\u4F4D`;
+    return {
+      validator(value) {
+        var _a;
+        return ((_a = String(value).split(".")[1]) == null ? void 0 : _a.length) > decimal ? errorMessage : "";
+      }
+    };
+  };
+  function createValidatorSchema(fieldItem) {
+    const rules = [];
+    const { validate: { vali_obj, max_length, message, max_value, min_value, decimal_length } = {}, validator } = fieldItem;
+    if (validator) {
+      arrayed(validator).forEach((f) => {
+        if (!isFunction(f))
+          return;
+        rules.push({ validator: (value) => f(value, fieldItem) });
+      });
+    }
+    if (max_length)
+      rules.push({ max: max_length, message });
+    if (max_value)
+      rules.push({ maximum: max_value, message });
+    if (min_value)
+      rules.push({ minimum: min_value, message });
+    if (decimal_length != null)
+      rules.push(createDecimalValidator(+decimal_length, message));
+    const ruleCreator = vali_obj && validateMap.get(vali_obj);
+    ruleCreator && rules.push(Object.assign({}, commonValidateConfig, ruleCreator(fieldItem)));
+    return rules;
+  }
+  return { createValidatorSchema };
+}
+
+export { useFormValidator };

package/es/components/form-render/src/hooks/useNuiThemeOverrides.js

@@ -1 +1,18 @@
-export { useNuiThemeOverrides } from './useNuiThemeOverrides2.js';
+function useNuiThemeOverrides() {
+  const nuiThemeOverrides = {
+    Input: { paddingMedium: "8px", paddingSmall: "8px", paddingLarge: "8px", paddingTiny: "8px" },
+    InternalSelection: { paddingSingle: "8px", paddingMultiple: "2px" },
+    Form: {
+      feedbackHeightMedium: "16px",
+      feedbackHeightLarge: "16px",
+      feedbackHeightSmall: "16px",
+      feedbackFontSizeLarge: "12px",
+      feedbackFontSizeMedium: "12px",
+      feedbackFontSizeSmall: "12px",
+      feedbackPadding: "0px"
+    }
+  };
+  return { nuiThemeOverrides };
+}
+
+export { useNuiThemeOverrides };

package/es/components/form-render/src/hooks/usePresetScope.js

@@ -1 +1,22 @@
-export { usePresetScope } from './usePresetScope2.js';
+import { isString } from 'lodash-es';
+import '../utils/index.js';
+import { isIdCard, isMobile } from '../utils/business.js';
+
+function usePresetScope() {
+  return {
+    isIdCard(value) {
+      return isString(value) && isIdCard(value);
+    },
+    isMobile(value) {
+      return isString(value) && isMobile(value);
+    },
+    isEmail(value) {
+      return isString(value) && /^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$/.test(value);
+    },
+    isNumber(value) {
+      return isString(value) && /\d+/.test(value);
+    }
+  };
+}
+
+export { usePresetScope };

package/es/components/form-render/src/types/fieldItem.d.ts

@@ -186,9 +186,13 @@ export declare type FieldItem = {
      */
     content: string | FormRenderer | Record<string, FormRenderer>;
     /**
-     * 假使控件需要发送请求, 用于控制是否只在需要的时候发送请求
+     * 用于控制是否启用请求的懒执行
      */
     lazyRequest: boolean;
+    /**
+     * 用于控制请求是否开启缓存
+     */
+    requestCache: boolean;
     /**
      * COMBINATION控件最大表单组数量
      */