cnhis-design-vue 3.1.14-beta.2 → 3.1.14-beta.5

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

@@ -0,0 +1,225 @@
+import { isObject } from '@vueuse/core';
+import { isArray, pick } from 'lodash-es';
+import { useFormValidator, useTypeNormalize } from '../../../../packages/form-render';
+import { fieldKeyEscape, createLinebarId, arrayed, transformDateFormat } from '../utils/index.js';
+
+function useFieldListAdaptor(collector, uuid) {
+  const { createValidatorSchema } = useFormValidator();
+  const createStandardSchema = (item) => {
+    const result = {
+      name: item.val_key,
+      type: "string",
+      title: item.alias || item.name,
+      "x-component": item.html_type,
+      "x-component-props": {
+        placeholder: item.placeholder,
+        clearable: item.is_empty === "0",
+        ...item.componentProps || {}
+      },
+      "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,
+          id: `${uuid}-${item.val_key}`,
+          ...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"], {
+      prefix: item.prefix,
+      suffix: item.suffix
+    });
+    return schema;
+  };
+  const createSelectSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      urlConfig: item.urlConfig,
+      options: item.option,
+      multiple: item.multi_select === "0",
+      maxTagCount: +item.multi_select_value
+    });
+    return schema;
+  };
+  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 createCascaderSchema = (item) => {
+    var _a;
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      urlConfig: item.urlConfig,
+      deep: (_a = item.wordbook) == null ? void 0 : _a.level_num,
+      options: item.option
+    });
+    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["x-decorator-props"].showLabel = false;
+    Object.assign(schema["x-component-props"], {
+      title: item.alias || item.name,
+      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),
+      max: validate == null ? void 0 : validate.max_value,
+      min: validate == null ? void 0 : validate.min_value
+    });
+    return schema;
+  };
+  const createSliderSchema = (item) => {
+    const schema = createStandardSchema(item);
+    Object.assign(schema["x-component-props"], {
+      step: Number(item.step_length),
+      max: +item.max_length,
+      min: +item.min_length,
+      option: item.option
+    });
+    return schema;
+  };
+  const createCustomSchema = (item) => {
+    const schema = createStandardSchema(item);
+    item.fieldType && (schema.type = item.fieldType);
+    Object.assign(schema["x-component-props"], {
+      fieldItem: item
+    });
+    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
+      }
+    };
+  };
+  const createComplexSchema = (item) => {
+    const schema = createStandardSchema(item);
+    const properties = Array.isArray(item.properties) ? schemaAdaptor(item.properties) : {};
+    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 creatorMap = /* @__PURE__ */ new Map([
+    ["LINEBAR", createLinebarSchema],
+    ["INPUT", createInputSchema],
+    ["INPUT_NUMBER", createInputNumberSchema],
+    ["SELECT", createSelectSchema],
+    ["DATE", createDateSchema],
+    ["SEARCH_CASCADE", createCascaderSchema],
+    ["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 { normalize } = useTypeNormalize();
+  function schemaAdaptor(fieldList) {
+    let prevLinebar = null;
+    return fieldList.reduce((fin, cur, idx) => {
+      var _a;
+      normalize(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) {
+      schema["x-index"] = idx;
+      return schema;
+    }
+    function createFieldName(fieldItem) {
+      if (isArray(fieldItem.suffixConfig)) {
+        return fieldKeyEscape([fieldItem, ...fieldItem.suffixConfig]);
+      }
+      return fieldItem.val_key;
+    }
+  }
+  return { schemaAdaptor };
+}
+
+export { useFieldListAdaptor };

package/es/packages/form-render/src/hooks/useFieldVisitor.d.ts

@@ -0,0 +1,4 @@
+import { FieldItem, FieldVisitor } from '../types';
+export declare function useFieldVisitor(): {
+    traverse: (fieldList: FieldItem[], visitorMap?: FieldVisitor, key?: string) => FieldItem[];
+};

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

@@ -0,0 +1,41 @@
+import { arrayed } from '../utils/index.js';
+import { isFunction } from '@vueuse/core';
+
+function useFieldVisitor() {
+  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 visitor = visitorMap[field[key]];
+      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));
+        }
+      });
+      fin.push(...before, current, ...after);
+      return fin;
+    }, []);
+  }
+  return { traverse };
+}
+
+export { useFieldVisitor };

package/es/packages/form-render/src/hooks/useFormContext.d.ts

@@ -0,0 +1,10 @@
+import { ShallowReactive } from 'vue';
+import { AnyObject } from '../../../../../es/src/types';
+export declare function useFormContext(props: ShallowReactive<AnyObject>): {
+    asyncQueue: import("../../../../../es/packages/form-render").FormAsyncQueue;
+    SchemaField: import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>;
+    businessCollector: import("../../../../../es/packages/form-render").BusinessCollector;
+    changeContextCollector: import("../../../../../es/packages/form-render").ContextCollector;
+    formItemDepsCollector: import("../../../../../es/packages/form-render").FormItemDepsCollector;
+    formUUID: any;
+};

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

@@ -0,0 +1,47 @@
+import { isObject } from 'lodash-es';
+import { provide, computed, readonly } from 'vue';
+import { createSchemaField } from '@formily/vue';
+import { useAsyncQueue, useBusinessBinding, useChangeContext, useFormItemDeps } from '../../../../packages/form-render';
+import * as components from '../../../../packages/form-render/src/components/renderer';
+import { usePresetScope } from '../../../../packages/form-render/src/hooks/usePresetScope';
+import { injectOrProvide, uuidGenerator } from '../../../../packages/form-render/src/utils';
+import { InjectAsyncQueue, InjectionSchemaField, InjectionBusinessCollector, InjectionChangeContextCollector, InjectionFormItemDepsCollector, InjectionFormUUID, InjectionAnnotation } from '../../../../packages/form-render/src/constants';
+
+function useFormContext(props) {
+  const asyncQueue = injectOrProvide(InjectAsyncQueue, () => useAsyncQueue().create(props.parallelism));
+  const SchemaField = injectOrProvide(InjectionSchemaField, () => createSchemaField({
+    components: {
+      ...components,
+      ...props.components
+    },
+    scope: Object.assign({}, usePresetScope(), props.scope)
+  }).SchemaField);
+  const businessCollector = useBusinessBinding().create(props.businessFilter);
+  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))
+        return;
+      props.annotation[payload.property] = payload.value;
+    }
+  }));
+  return {
+    asyncQueue,
+    SchemaField,
+    businessCollector,
+    changeContextCollector,
+    formItemDepsCollector,
+    formUUID
+  };
+}
+
+export { useFormContext };

package/es/packages/form-render/src/hooks/useFormField.d.ts

@@ -0,0 +1,5 @@
+export declare function useFormField(): {
+    field: import("vue").Ref<import("@formily/core").GeneralField>;
+    title: import("vue").ComputedRef<any>;
+    fieldKey: import("vue").ComputedRef<string>;
+};

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

@@ -0,0 +1,13 @@
+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/packages/form-render/src/hooks/useFormItemDeps.d.ts

@@ -0,0 +1,9 @@
+import { Func } from '../../../../../es/src/types';
+export declare class FormItemDepsCollector {
+    private readonly collector;
+    setDeps(key: string, dependKey: string | string[], callback: Func): void;
+    trigger(dependKey: string, payload?: any): void;
+}
+export declare function useFormItemDeps(): {
+    create: () => FormItemDepsCollector;
+};

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

@@ -0,0 +1,28 @@
+import { isFunction } from 'lodash-es';
+import { arrayed } from '../../../../packages/form-render/src/utils';
+
+class FormItemDepsCollector {
+  constructor() {
+    this.collector = /* @__PURE__ */ new Map();
+  }
+  setDeps(key, dependKey, callback) {
+    dependKey = arrayed(dependKey);
+    dependKey.forEach((dependKey2) => {
+      const map = this.collector.get(dependKey2) || /* @__PURE__ */ new Map();
+      map.set(key, callback);
+      this.collector.set(dependKey2, map);
+    });
+  }
+  trigger(dependKey, payload) {
+    const map = this.collector.get(dependKey);
+    map && map.forEach((cb) => isFunction(cb) && cb(payload));
+  }
+}
+function useFormItemDeps() {
+  function create() {
+    return new FormItemDepsCollector();
+  }
+  return { create };
+}
+
+export { FormItemDepsCollector, useFormItemDeps };

package/es/packages/form-render/src/hooks/useFormRequest.d.ts

@@ -0,0 +1,7 @@
+import { Func } from '../../../../../es/src/types';
+declare type RequestInstance = Record<string, Func>;
+export declare function useFormRequest(): {
+    getHttpInstance: () => RequestInstance | null;
+    registGlobHttpInstance: (instance: RequestInstance) => void;
+};
+export {};

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

@@ -0,0 +1,12 @@
+let http = null;
+function useFormRequest() {
+  function getHttpInstance() {
+    return http;
+  }
+  function registGlobHttpInstance(instance) {
+    http = instance;
+  }
+  return { getHttpInstance, registGlobHttpInstance };
+}
+
+export { useFormRequest };

package/es/packages/form-render/src/hooks/useFormValidator.d.ts

@@ -0,0 +1,5 @@
+import { AnyObject } from '../../../../../es/src/types';
+import { FieldItem } from '../types';
+export declare function useFormValidator(): {
+    createValidatorSchema: (fieldItem: FieldItem) => AnyObject[];
+};

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

@@ -0,0 +1,42 @@
+import { arrayed } from '../utils/index.js';
+import { isFunction } from '@vueuse/core';
+
+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 }) => ({ format: "idcard", message: validate == null ? void 0 : validate.message })],
+    [
+      "regular",
+      (field) => {
+        const { validate, regular_expression, regular_error_tip } = field;
+        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" };
+  function createValidatorSchema(fieldItem) {
+    const rules = [];
+    const { validate: { vali_obj, max_length, message } = {}, validator } = fieldItem;
+    if (validator) {
+      const _validator = arrayed(validator);
+      _validator.forEach((f) => {
+        if (!isFunction(f))
+          return;
+        rules.push({ validator: (value) => f(value, fieldItem) });
+      });
+    }
+    if (max_length) {
+      rules.push({ max: max_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/packages/form-render/src/hooks/useInitialData.d.ts

@@ -0,0 +1,5 @@
+import { AnyObject } from '../../../../../es/src/types';
+import { FieldItem } from '../types';
+export declare function useInitialData(): {
+    assignInitialData: (initialData?: AnyObject, fieldList?: FieldItem[]) => AnyObject;
+};

package/es/packages/form-render/src/hooks/useInitialData.js

@@ -0,0 +1,11 @@
+function useInitialData() {
+  function assignInitialData(initialData, fieldList) {
+    return Object.assign({}, initialData, fieldList == null ? void 0 : fieldList.reduce((fin, cur) => {
+      cur.default_val != void 0 && (fin[cur.val_key] = cur.default_val);
+      return fin;
+    }, {}));
+  }
+  return { assignInitialData };
+}
+
+export { useInitialData };

package/es/packages/form-render/src/hooks/usePresetScope.d.ts

@@ -0,0 +1,6 @@
+export declare function usePresetScope(): {
+    isIdCard(value: unknown): boolean;
+    isMobile(value: unknown): boolean;
+    isEmail(value: unknown): boolean;
+    isNumber(value: unknown): boolean;
+};

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

@@ -0,0 +1,21 @@
+import { isString } from 'lodash-es';
+import { isIdCard, isMobile } from '../../../../packages/form-render/src/utils';
+
+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/packages/form-render/src/hooks/useTypeNormalize.d.ts

@@ -0,0 +1,4 @@
+import { FieldItem } from '../types';
+export declare function useTypeNormalize(): {
+    normalize: (item: FieldItem) => void;
+};

package/es/packages/form-render/src/hooks/useTypeNormalize.js

@@ -0,0 +1,45 @@
+import { FIELD_BUSINESS_TYPE } from '../../../../packages/form-render/src/constants';
+
+function useTypeNormalize() {
+  function normalizeAgeField(item) {
+    item.html_type = "INPUT_NUMBER";
+    item.suffixConfig = [
+      {
+        validate: { obj_type: FIELD_BUSINESS_TYPE.AGE_UNIT },
+        val_key: item.val_key_unit,
+        html_type: "SELECT",
+        option: item.option
+      }
+    ];
+  }
+  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"],
+    ["LINE_BREAKS", "LINEBAR"]
+  ];
+  function normalize(item) {
+    const type = item.html_type;
+    if (["CHECK_BLOCK", "RADIO_BLOCK"].includes(type)) {
+      item.__vertical = true;
+    }
+    if (["LINE_BREAKS"].includes(type)) {
+      item.__line = true;
+      item.is_show = "1";
+    }
+    if (item.html_type === "AGE") {
+      normalizeAgeField(item);
+    }
+    types.some(([rule, target]) => {
+      const match = Array.isArray(rule) ? rule.includes(type) : rule === type;
+      return match && (item.html_type = target);
+    });
+  }
+  return { normalize };
+}
+
+export { useTypeNormalize };

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

@@ -0,0 +1,99 @@
+import { AnyObject, ArrayAble } from '../../../../../es/src/types';
+import { CSSProperties, VNode } from 'vue';
+export declare type ValidateItem = Partial<{
+    obj_type: string;
+    vali_obj: string;
+    max_value: string | number;
+    min_value: string | number;
+    min_length: string | number;
+    max_length: string | number;
+    decimal_length: string | number;
+    regular_expression: any;
+    regular_error_tip: string;
+    [key: string]: any;
+}>;
+interface OptionItem {
+    text: string;
+    value: any;
+    children?: OptionItem[];
+}
+export interface Ievent {
+    event_field: string;
+    event_type: string;
+}
+interface FormRendererPayload {
+    clearable: boolean;
+    disabled: boolean;
+    fieldItem: FieldItem;
+    readOnly: boolean;
+    value: unknown;
+}
+export interface FormRenderer {
+    (payload: FormRendererPayload): ArrayAble<VNode> | any;
+}
+interface SwitchProperty {
+    value?: any;
+    describe?: string;
+}
+export declare type FieldItem = {
+    val_key: string;
+    html_type: string;
+} & Partial<{
+    annotation: boolean;
+    val_key_unit: string;
+    is_edit: string;
+    elem_width: number;
+    is_show: string | number;
+    is_null: string;
+    name: string;
+    alias: string;
+    default_val: any;
+    is_empty: string;
+    group: string;
+    hide_title: string;
+    placeholder: string;
+    validate: ValidateItem;
+    option: OptionItem[];
+    wordbook: AnyObject;
+    suFieldList: any[];
+    bindEventSetting: Ievent[];
+    open: SwitchProperty;
+    close: SwitchProperty;
+    date_format: string;
+    step_length: string | number;
+    urlConfig: Partial<{
+        url: string;
+        method: 'post' | 'get' | 'put' | 'patch' | 'delete';
+        dependKey: string | string[];
+        params: AnyObject;
+        nameKey: string;
+        valueKey: string;
+    }>;
+    suffixConfig: FieldItem[];
+    fieldType: 'string' | 'object' | 'array' | 'number' | 'void' | 'boolean' | 'datetime';
+    content: string | FormRenderer | Record<string, FormRenderer>;
+    properties: FieldItem[];
+    children: FieldItem[];
+    componentProps: AnyObject;
+    decoratorProps: AnyObject;
+    display: 'grid' | 'flex';
+    wrapperStyle: CSSProperties | Record<string, string>;
+    validator: (value: any, fieldItem: FieldItem) => void | string;
+    reactions: {
+        target?: string;
+        dependencies?: string[];
+        fulfill: {
+            state?: Partial<{
+                value: string;
+                disabled: string;
+                display: string;
+                componentProps: AnyObject;
+                decoratorProps: AnyObject;
+                selfErrors: string;
+                [key: string]: string | AnyObject;
+            }>;
+        };
+    };
+    [key: string]: any;
+}>;
+export {};

package/es/packages/form-render/src/types/fieldItem.js

@@ -0,0 +1 @@
+