ele-admin-plus 1.3.1-beta.1 → 1.4.0-beta.1

package/es/ele-pro-form-builder/components/body-header.d.ts

@@ -1,42 +1,72 @@
 import { UserComponent } from '../../ele-app/types';
-import { TemplateFormConfig } from '../types';
+import { EleProFormProps } from '../../ele-app/plus';
+import { ProFormItemTypeData, ScreenSize } from '../../ele-pro-form/types';
+import { HeaderRightToolName, ComponentGroup } from '../types';
 
-declare function __VLS_template(): {
+declare function __VLS_template(): Partial<Record<string, (_: any) => any>> & {
     headerTools?(_: {}): any;
 };
-declare const __VLS_component: import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<{
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
     /** 当前选中屏幕尺寸 */
-    currentScreen?: string;
+    currentScreen?: ScreenSize;
     /** 是否禁用撤销 */
     undoDisabled?: boolean;
     /** 是否禁用恢复 */
     redoDisabled?: boolean;
     /** 表单属性 */
-    formProps?: TemplateFormConfig;
+    formProps?: EleProFormProps;
+    /** 顶栏右侧操作按钮顺序 */
+    headerTools?: boolean | HeaderRightToolName[];
     /** 高级表单组件 */
     proFormComponent?: UserComponent;
-}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    /** JSON 编辑器组件 */
+    jsonEditerComponent?: UserComponent;
+    /** 代码查看器组件 */
+    codeViewerComponent?: UserComponent;
+    /** 组件库数据 */
+    componentData?: ComponentGroup[];
+    /** 高级表单组件类型数据 */
+    itemTypeData?: ProFormItemTypeData[];
+    /** 远程数据源请求工具 */
+    httpRequest?: any;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
     "update:currentScreen": (size?: string | undefined) => void;
     undo: () => void;
     redo: () => void;
     clear: () => void;
+    previewFormSubmit: (data: Record<string, any>) => void;
+    importData: (data: EleProFormProps) => void;
 }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
     /** 当前选中屏幕尺寸 */
-    currentScreen?: string;
+    currentScreen?: ScreenSize;
     /** 是否禁用撤销 */
     undoDisabled?: boolean;
     /** 是否禁用恢复 */
     redoDisabled?: boolean;
     /** 表单属性 */
-    formProps?: TemplateFormConfig;
+    formProps?: EleProFormProps;
+    /** 顶栏右侧操作按钮顺序 */
+    headerTools?: boolean | HeaderRightToolName[];
     /** 高级表单组件 */
     proFormComponent?: UserComponent;
-}>>> & {
+    /** JSON 编辑器组件 */
+    jsonEditerComponent?: UserComponent;
+    /** 代码查看器组件 */
+    codeViewerComponent?: UserComponent;
+    /** 组件库数据 */
+    componentData?: ComponentGroup[];
+    /** 高级表单组件类型数据 */
+    itemTypeData?: ProFormItemTypeData[];
+    /** 远程数据源请求工具 */
+    httpRequest?: any;
+}>>> & Readonly<{
     onClear?: (() => any) | undefined;
+    onImportData?: ((data: EleProFormProps) => any) | undefined;
+    onPreviewFormSubmit?: ((data: Record<string, any>) => any) | undefined;
     "onUpdate:currentScreen"?: ((size?: string | undefined) => any) | undefined;
     onUndo?: (() => any) | undefined;
     onRedo?: (() => any) | undefined;
-}, {}, {}>;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
 export default _default;
 type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

package/es/ele-pro-form-builder/components/body-header.js

@@ -1,26 +1,48 @@
-import { defineComponent, ref, resolveComponent, openBlock, createElementBlock, createElementVNode, Fragment, renderList, unref, createBlock, normalizeClass, withCtx, resolveDynamicComponent, normalizeStyle, createVNode, createTextVNode, renderSlot } from "vue";
-import { ElIcon } from "element-plus";
-import { RollbackOutlined, RecoverOutlined, DeleteOutlined, EyeOutlined } from "../../icons";
-import { screenItems } from "../util";
+import { defineComponent, ref, computed, createElementBlock, openBlock, createElementVNode, createBlock, createCommentVNode, Fragment, renderList, unref, normalizeClass, withCtx, resolveDynamicComponent, normalizeStyle, createVNode, renderSlot, createTextVNode, createSlots, normalizeProps, guardReactiveProps } from "vue";
+import { ElIcon, ElButton } from "element-plus";
+import { RollbackOutlined, RecoverOutlined, UploadOutlined, DownloadOutlined, DeleteOutlined, EyeOutlined, CodeOutlined } from "../../icons/index";
+import { defaultHeaderRightTools, screenItems } from "../util";
 import PreviewModal from "./preview-modal";
+import ImportModal from "./import-modal";
+import CodePreview from "./code-preview";
 const _hoisted_1 = { class: "ele-pro-form-builder-header" };
 const _hoisted_2 = { class: "ele-pro-form-builder-screen-radio" };
 const _hoisted_3 = { class: "ele-pro-form-builder-header-left" };
 const _hoisted_4 = { class: "ele-pro-form-builder-header-tools" };
 const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "BodyHeader" },
   __name: "body-header",
   props: {
     currentScreen: {},
     undoDisabled: { type: Boolean },
     redoDisabled: { type: Boolean },
     formProps: {},
-    proFormComponent: {}
+    headerTools: { type: [Boolean, Array] },
+    proFormComponent: { type: [String, Object, Function] },
+    jsonEditerComponent: { type: [String, Object, Function] },
+    codeViewerComponent: { type: [String, Object, Function] },
+    componentData: {},
+    itemTypeData: {},
+    httpRequest: {}
   },
-  emits: ["update:currentScreen", "undo", "redo", "clear"],
+  emits: ["update:currentScreen", "undo", "redo", "clear", "previewFormSubmit", "importData"],
   setup(__props, { emit: __emit }) {
+    const ownSlots = ["headerTools"];
     const props = __props;
     const emit = __emit;
     const previewVisible = ref(false);
+    const importVisible = ref(false);
+    const isImport = ref(false);
+    const codeVisible = ref(false);
+    const headerRightToolNames = computed(() => {
+      if (typeof props.headerTools === "undefined" || props.headerTools === true) {
+        return defaultHeaderRightTools;
+      }
+      if (!props.headerTools) {
+        return [];
+      }
+      return props.headerTools;
+    });
     const handleUpdateScreen = (size) => {
       emit("update:currentScreen", size);
     };
@@ -40,8 +62,24 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
     const handleOpenPreview = () => {
       previewVisible.value = true;
     };
+    const handlePreviewFormSubmit = (data) => {
+      emit("previewFormSubmit", data);
+    };
+    const handleOpenImport = () => {
+      importVisible.value = true;
+      isImport.value = true;
+    };
+    const handleOpenExport = () => {
+      importVisible.value = true;
+      isImport.value = false;
+    };
+    const handleImportData = (data) => {
+      emit("importData", data);
+    };
+    const handleOpenCode = () => {
+      codeVisible.value = true;
+    };
     return (_ctx, _cache) => {
-      const _component_ElButton = resolveComponent("ElButton");
       return openBlock(), createElementBlock("div", _hoisted_1, [
         createElementVNode("div", _hoisted_2, [
           (openBlock(true), createElementBlock(Fragment, null, renderList(unref(screenItems), (item) => {
@@ -94,36 +132,107 @@ const _sfc_main = /* @__PURE__ */ defineComponent({
           }, 8, ["class"])
         ]),
         createElementVNode("div", _hoisted_4, [
-          createVNode(_component_ElButton, {
-            text: true,
-            type: "danger",
-            icon: unref(DeleteOutlined),
-            onClick: handleClear
-          }, {
-            default: withCtx(() => [
-              createTextVNode(" 清空 ")
-            ]),
-            _: 1
-          }, 8, ["icon"]),
-          createVNode(_component_ElButton, {
-            text: true,
-            type: "primary",
-            icon: unref(EyeOutlined),
-            onClick: handleOpenPreview
-          }, {
-            default: withCtx(() => [
-              createTextVNode(" 预览 ")
-            ]),
-            _: 1
-          }, 8, ["icon"]),
+          (openBlock(true), createElementBlock(Fragment, null, renderList(headerRightToolNames.value, (toolName) => {
+            return openBlock(), createElementBlock(Fragment, { key: toolName }, [
+              toolName === "import" ? (openBlock(), createBlock(unref(ElButton), {
+                key: 0,
+                text: true,
+                icon: unref(UploadOutlined),
+                onClick: handleOpenImport
+              }, {
+                default: withCtx(() => _cache[3] || (_cache[3] = [
+                  createTextVNode(" 导入 ")
+                ])),
+                _: 1,
+                __: [3]
+              }, 8, ["icon"])) : toolName === "export" ? (openBlock(), createBlock(unref(ElButton), {
+                key: 1,
+                text: true,
+                icon: unref(DownloadOutlined),
+                onClick: handleOpenExport
+              }, {
+                default: withCtx(() => _cache[4] || (_cache[4] = [
+                  createTextVNode(" 导出 ")
+                ])),
+                _: 1,
+                __: [4]
+              }, 8, ["icon"])) : toolName === "clear" ? (openBlock(), createBlock(unref(ElButton), {
+                key: 2,
+                text: true,
+                type: "danger",
+                icon: unref(DeleteOutlined),
+                onClick: handleClear
+              }, {
+                default: withCtx(() => _cache[5] || (_cache[5] = [
+                  createTextVNode(" 清空 ")
+                ])),
+                _: 1,
+                __: [5]
+              }, 8, ["icon"])) : toolName === "preview" ? (openBlock(), createBlock(unref(ElButton), {
+                key: 3,
+                text: true,
+                type: "primary",
+                icon: unref(EyeOutlined),
+                onClick: handleOpenPreview
+              }, {
+                default: withCtx(() => _cache[6] || (_cache[6] = [
+                  createTextVNode(" 预览 ")
+                ])),
+                _: 1,
+                __: [6]
+              }, 8, ["icon"])) : toolName === "code" ? (openBlock(), createBlock(unref(ElButton), {
+                key: 4,
+                text: true,
+                type: "primary",
+                icon: unref(CodeOutlined),
+                onClick: handleOpenCode
+              }, {
+                default: withCtx(() => _cache[7] || (_cache[7] = [
+                  createTextVNode(" 生成代码 ")
+                ])),
+                _: 1,
+                __: [7]
+              }, 8, ["icon"])) : createCommentVNode("", true)
+            ], 64);
+          }), 128)),
           renderSlot(_ctx.$slots, "headerTools")
         ]),
-        createVNode(PreviewModal, {
+        headerRightToolNames.value && headerRightToolNames.value.includes("preview") ? (openBlock(), createBlock(PreviewModal, {
+          key: 0,
           modelValue: previewVisible.value,
           "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => previewVisible.value = $event),
           formProps: _ctx.formProps,
-          proFormComponent: _ctx.proFormComponent
-        }, null, 8, ["modelValue", "formProps", "proFormComponent"])
+          proFormComponent: _ctx.proFormComponent,
+          itemTypeData: _ctx.itemTypeData,
+          httpRequest: _ctx.httpRequest,
+          onPreviewFormSubmit: handlePreviewFormSubmit
+        }, createSlots({ _: 2 }, [
+          renderList(Object.keys(_ctx.$slots).filter((k) => !ownSlots.includes(k)), (name) => {
+            return {
+              name,
+              fn: withCtx((slotProps) => [
+                renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps || {})))
+              ])
+            };
+          })
+        ]), 1032, ["modelValue", "formProps", "proFormComponent", "itemTypeData", "httpRequest"])) : createCommentVNode("", true),
+        headerRightToolNames.value && (headerRightToolNames.value.includes("import") || headerRightToolNames.value.includes("export")) ? (openBlock(), createBlock(ImportModal, {
+          key: 1,
+          modelValue: importVisible.value,
+          "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => importVisible.value = $event),
+          config: _ctx.formProps,
+          isImport: isImport.value,
+          jsonEditerComponent: _ctx.jsonEditerComponent,
+          onImportData: handleImportData
+        }, null, 8, ["modelValue", "config", "isImport", "jsonEditerComponent"])) : createCommentVNode("", true),
+        headerRightToolNames.value && headerRightToolNames.value.includes("code") ? (openBlock(), createBlock(CodePreview, {
+          key: 2,
+          modelValue: codeVisible.value,
+          "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => codeVisible.value = $event),
+          config: _ctx.formProps,
+          componentData: _ctx.componentData,
+          codeViewerComponent: _ctx.codeViewerComponent
+        }, null, 8, ["modelValue", "config", "componentData", "codeViewerComponent"])) : createCommentVNode("", true)
       ]);
     };
   }

package/es/ele-pro-form-builder/components/build-core.d.ts

@@ -0,0 +1,64 @@
+import { ProFormItemProps, ProFormItemTypeData } from '../../ele-pro-form/types';
+import { ComponentGroup } from '../types';
+
+/**
+ * 有固定子级的组件类型
+ */
+export declare const fixedChildTypes: {
+    type: string;
+    childType: string;
+}[];
+/**
+ * 生成表单项 id
+ */
+export declare function generateItemKey(): string;
+/**
+ * 生成表单项 id 并检查重复
+ * @param items 当前表单项数据
+ * @param keys 新生成还未添加的表单项 id
+ */
+export declare function generateUniqueItemKey(items?: ProFormItemProps[], keys?: string[]): string;
+/**
+ * 根据组件类型名称获取对应组件定义
+ * @param type 组件类型名称
+ * @param componentData 组件库数据
+ */
+export declare function getComponentItemByType(type: string | undefined, componentData?: ComponentGroup[]): import('../types').ComponentItem | undefined;
+/**
+ * 深度克隆对象
+ * @param data 对象
+ * @param excludeUndefined 排除未定义值
+ */
+export declare function deepCloneObject<T extends Record<string, any>>(data?: T, excludeUndefined?: boolean): T;
+/**
+ * 生成子级表单项数据
+ * @param parentType 父组件类型
+ * @param childNo 子组件编号
+ * @param childKey 子组件 id
+ * @param componentData 组件库数据
+ */
+export declare function generateChildFormItem(parentType?: string, childNo?: string, childKey?: string, componentData?: ComponentGroup[]): ProFormItemProps;
+/**
+ * 生成表单项数据
+ * @param type 组件类型或组件数据
+ * @param formItems 当前的全部表单项数据
+ * @param componentData 组件库数据
+ * @param itemTypeData 高级表单组件类型数据
+ */
+export declare function generateBuildFormItem(type: string | undefined, formItems: ProFormItemProps[] | undefined, componentData?: ComponentGroup[], itemTypeData?: ProFormItemTypeData[]): ProFormItemProps | undefined;
+/**
+ * 获取表单项的属性值和对应的属性配置表单项数据
+ * @param item 表单项
+ * @param componentData 组件库数据
+ */
+export declare function getFormDataAndItems(item: ProFormItemProps | undefined, componentData?: ComponentGroup[]): {
+    data: Record<string, any>;
+    items: ProFormItemProps[];
+};
+/**
+ * 获取数据所有属性的路径数组
+ * @param data 数据
+ * @param excludeKeys 排除的属性名
+ * @param prefix 前缀
+ */
+export declare function getPropertyPath(data: any, excludeKeys?: string[], prefix?: string): string[];

package/es/ele-pro-form-builder/components/build-core.js

@@ -0,0 +1,212 @@
+import { uuid, findTree } from "../../utils/common";
+import { isContainerType, mergeValue } from "../../ele-pro-form/util";
+import { getItemTypeData } from "../../ele-pro-form/components/render-util";
+const fixedChildTypes = [
+  { type: "tabs", childType: "tabPane" },
+  { type: "collapse", childType: "collapseItem" },
+  { type: "row", childType: "col" },
+  { type: "carousel", childType: "carouselItem" },
+  { type: "descriptions", childType: "descriptionsItem" },
+  { type: "table", childType: "tableRow" },
+  { type: "tableRow", childType: "tableCell" }
+];
+function generateItemKey() {
+  return `f${uuid(15, 36).toLowerCase()}`;
+}
+function generateUniqueItemKey(items, keys) {
+  let itemKey = generateItemKey();
+  const flag = true;
+  while (flag) {
+    if (!findTree(items, (d) => d.key === itemKey) && (!keys || !keys.includes(itemKey))) {
+      break;
+    }
+    itemKey = generateItemKey();
+  }
+  return itemKey;
+}
+function getComponentItemByType(type, componentData) {
+  if (!type || !componentData) {
+    return;
+  }
+  return componentData.map((groupItem) => groupItem.items).flat().find((item) => item.type === type);
+}
+function deepCloneObject(data, excludeUndefined) {
+  if (!data) {
+    return {};
+  }
+  const result = JSON.parse(JSON.stringify(data));
+  if (!excludeUndefined) {
+    const keys = Object.keys(data);
+    const resultKeys = Object.keys(result);
+    keys.forEach((key) => {
+      if (!resultKeys.includes(key)) {
+        result[key] = void 0;
+      }
+    });
+  }
+  return result;
+}
+function generateChildFormItem(parentType, childNo, childKey, componentData) {
+  var _a, _b;
+  let child;
+  if (parentType) {
+    const fc = fixedChildTypes.find((d) => d.type === parentType);
+    if (fc) {
+      child = { prop: "", type: fc.childType };
+    }
+  }
+  if (!child) {
+    child = { prop: "", type: "div" };
+  }
+  if (childKey) {
+    child.key = childKey;
+    child.prop = childKey;
+  }
+  const componentItem = getComponentItemByType(child.type, componentData);
+  const initialProps = (componentItem == null ? void 0 : componentItem.initialProps) ? deepCloneObject(componentItem.initialProps) : void 0;
+  if (initialProps) {
+    child.props = initialProps;
+  }
+  if (childNo && child.type) {
+    if (child.type === "collapseItem") {
+      if ((_a = child.props) == null ? void 0 : _a.title) {
+        child.props.title = child.props.title + childNo;
+      }
+    } else if (["descriptionsItem", "tabPane"].includes(child.type)) {
+      if ((_b = child.props) == null ? void 0 : _b.label) {
+        child.props.label = child.props.label + childNo;
+      }
+    } else if (child.label) {
+      child.label = child.label + childNo;
+    }
+  }
+  return child;
+}
+function generateBuildFormItem(type, formItems, componentData, itemTypeData) {
+  const componentItem = getComponentItemByType(type, componentData);
+  if (!componentItem) {
+    return;
+  }
+  const itemKey = generateUniqueItemKey(formItems);
+  const addedKeys = [itemKey];
+  const item = {
+    key: itemKey,
+    prop: itemKey,
+    label: componentItem.name,
+    type: componentItem.type,
+    required: false,
+    ...componentItem.initialData || {},
+    props: componentItem.initialProps ? deepCloneObject(componentItem.initialProps) : void 0
+  };
+  const typeData = getItemTypeData(item, itemTypeData);
+  if (!item.type || item.type === "div" || isContainerType(item, itemTypeData) && !(typeData == null ? void 0 : typeData.renderLabelText)) {
+    item.label = "";
+  }
+  if (item.type === "table") {
+    item.label = "";
+    item.children = Array.from({ length: 2 }).map(() => {
+      const trKey = generateUniqueItemKey(formItems, addedKeys);
+      addedKeys.push(trKey);
+      const childItem = generateChildFormItem(
+        item.type,
+        void 0,
+        trKey,
+        componentData
+      );
+      const children = Array.from({ length: 3 }).map(() => {
+        const tdKey = generateUniqueItemKey(formItems, addedKeys);
+        addedKeys.push(tdKey);
+        return generateChildFormItem(
+          childItem.type,
+          void 0,
+          tdKey,
+          componentData
+        );
+      });
+      childItem.children = children;
+      return childItem;
+    });
+  } else if (item.type === "steps") {
+    item.label = "";
+    if (!item.props) {
+      item.props = {};
+    }
+    item.props.items = Array.from({ length: 3 }).map((_, i) => {
+      const childNo = String(i + 1).padStart(2, "0");
+      return {
+        title: `步骤${childNo}`,
+        description: `步骤${childNo}的描述内容`
+      };
+    });
+  } else if (item.type && fixedChildTypes.some((d) => d.type === item.type)) {
+    item.label = "";
+    item.children = Array.from({
+      length: item.type === "carousel" ? 3 : 2
+    }).map((_, i) => {
+      const childKey = generateUniqueItemKey(formItems, addedKeys);
+      addedKeys.push(childKey);
+      const childNo = String(i + 1).padStart(2, "0");
+      return generateChildFormItem(item.type, childNo, childKey, componentData);
+    });
+  }
+  return item;
+}
+function getFormDataAndItems(item, componentData) {
+  const data = item ? deepCloneObject(item) : item;
+  if (!data) {
+    return { data: {}, items: [] };
+  }
+  const componentItem = getComponentItemByType(data.type, componentData);
+  return {
+    data: mergeValue(
+      {},
+      { props: (componentItem == null ? void 0 : componentItem.presetProps) || {} },
+      { props: (componentItem == null ? void 0 : componentItem.defaultProps) || {} },
+      data
+    ),
+    items: (componentItem == null ? void 0 : componentItem.configForm) || []
+  };
+}
+function getPropertyPath(data, excludeKeys, prefix) {
+  const keys = [];
+  if (data != null) {
+    if (Array.isArray(data)) {
+      data.forEach((v, i) => {
+        const path = prefix ? `${prefix}[${i}]` : String(i);
+        if (v != null && typeof v === "object") {
+          getPropertyPath(v, excludeKeys, path).forEach((k) => {
+            keys.push(k);
+          });
+        } else {
+          keys.push(path);
+        }
+      });
+    } else if (typeof data === "object") {
+      Object.keys(data).forEach((key) => {
+        if (!excludeKeys || !excludeKeys.includes(key)) {
+          const path = prefix ? `${prefix}.${key}` : key;
+          const v = data[key];
+          if (v != null && typeof v === "object") {
+            getPropertyPath(v, excludeKeys, path).forEach((k) => {
+              keys.push(k);
+            });
+          } else {
+            keys.push(path);
+          }
+        }
+      });
+    }
+  }
+  return keys;
+}
+export {
+  deepCloneObject,
+  fixedChildTypes,
+  generateBuildFormItem,
+  generateChildFormItem,
+  generateItemKey,
+  generateUniqueItemKey,
+  getComponentItemByType,
+  getFormDataAndItems,
+  getPropertyPath
+};

package/es/ele-pro-form-builder/components/build-util.d.ts

@@ -1,5 +1,5 @@
-import { ProFormItemKey } from '../../ele-pro-form/types';
-import { BuildFormItem, UpdateItemsResult, AddChildrenItemAction } from '../types';
+import { ProFormItemKey, ProFormItemProps } from '../../ele-pro-form/types';
+import { ComponentGroup, UpdateItemsResult, AddChildrenItemAction } from '../types';
 
 /**
  * 添加子级时生成需要的数据
@@ -9,19 +9,19 @@ import { BuildFormItem, UpdateItemsResult, AddChildrenItemAction } from '../type
  * @param actionType 添加类型
  * @param formItems 当前的全部表单项数据
  * @param position 触发位置的上方(左侧)或下方(右侧)添加, 默认下方(左侧)
+ * @param componentData 组件库数据
  */
-export declare function generateAddChildData(triggerItem: BuildFormItem, triggerParent: BuildFormItem | undefined, triggerItemIndex: number | undefined, actionType: AddChildrenItemAction | undefined, formItems?: BuildFormItem[], position?: -1): UpdateItemsResult;
+export declare function generateAddChildData(triggerItem: ProFormItemProps, triggerParent: ProFormItemProps | undefined, triggerItemIndex: number | undefined, actionType: AddChildrenItemAction | undefined, formItems?: ProFormItemProps[], position?: -1, componentData?: ComponentGroup[]): UpdateItemsResult;
 /**
  * 表单项数据生成新的 id
  * @param items 表单项数据
  * @param formItems 当前的全部表单项数据
  * @param overwriteProp prop 是否也重新生成
- * @param generateTypeName 是否生成类型名称到数据
  */
-export declare function itemsGenerateNewKey(items?: BuildFormItem[] | BuildFormItem, formItems?: BuildFormItem[], overwriteProp?: boolean): void;
+export declare function itemsGenerateNewKey(items?: ProFormItemProps[] | ProFormItemProps, formItems?: ProFormItemProps[], overwriteProp?: boolean): void;
 /**
  * 复制表单项时生成需要的数据
  * @param formItemId 表单项 id
  * @param formItems 当前的全部表单项数据
  */
-export declare function generateCopyItemData(formItemId: ProFormItemKey, formItems?: BuildFormItem[]): UpdateItemsResult;
+export declare function generateCopyItemData(formItemId: ProFormItemKey, formItems?: ProFormItemProps[]): UpdateItemsResult;

package/es/ele-pro-form-builder/components/build-util.js

@@ -1,7 +1,7 @@
-import { eachTree } from "../../utils/core";
-import { generateChildFormItem, generateUniqueItemKey } from "../util";
+import { eachTree } from "../../utils/common";
+import { generateChildFormItem, generateUniqueItemKey, deepCloneObject } from "./build-core";
 import { generateAddTableColData, generateAddTableRowData } from "./table-util";
-function generateAddChildData(triggerItem, triggerParent, triggerItemIndex, actionType, formItems, position) {
+function generateAddChildData(triggerItem, triggerParent, triggerItemIndex, actionType, formItems, position, componentData) {
   if (!triggerItem.type) {
     return { addItems: [], updateItems: [], deleteItemIds: [] };
   }
@@ -21,7 +21,10 @@ function generateAddChildData(triggerItem, triggerParent, triggerItemIndex, acti
         col: "row",
         carouselItem: "carousel",
         descriptionsItem: "descriptions"
-      }[triggerItem.type]
+      }[triggerItem.type],
+      void 0,
+      void 0,
+      componentData
     );
     itemsGenerateNewKey(item, formItems, true);
     return {
@@ -38,7 +41,7 @@ function generateAddChildData(triggerItem, triggerParent, triggerItemIndex, acti
     };
     eachTree(formItems, (trItem, _trIndex, tableItem) => {
       if (triggerParent && trItem.key === triggerParent.key && tableItem) {
-        const { addItems, updateItems, deleteItemIds } = (actionType === "addTableCol" ? generateAddTableColData : generateAddTableRowData)(tableItem, formItems, triggerItem, position);
+        const { addItems, updateItems, deleteItemIds } = (actionType === "addTableCol" ? generateAddTableColData : generateAddTableRowData)(tableItem, formItems, triggerItem, position, componentData);
         result.addItems = addItems;
         result.updateItems = updateItems;
         result.deleteItemIds = deleteItemIds;
@@ -48,9 +51,14 @@ function generateAddChildData(triggerItem, triggerParent, triggerItemIndex, acti
     return result;
   }
   if (triggerItem.type === "table") {
-    return (actionType === "addTableCol" ? generateAddTableColData : generateAddTableRowData)(triggerItem, formItems);
+    return (actionType === "addTableCol" ? generateAddTableColData : generateAddTableRowData)(triggerItem, formItems, void 0, void 0, componentData);
   }
-  const child = generateChildFormItem(triggerItem.type);
+  const child = generateChildFormItem(
+    triggerItem.type,
+    void 0,
+    void 0,
+    componentData
+  );
   itemsGenerateNewKey(child, formItems, true);
   return {
     addItems: [{ item: child, parentItemId: triggerItem.key }],
@@ -80,7 +88,7 @@ function generateCopyItemData(formItemId, formItems) {
   };
   eachTree(formItems, (item, index, parent) => {
     if (item.key === formItemId) {
-      const newItem = JSON.parse(JSON.stringify(item));
+      const newItem = deepCloneObject(item);
       itemsGenerateNewKey(newItem, formItems, true);
       result.addItems.push({
         item: newItem,