ele-admin-plus 1.2.2-beta.5 → 1.3.1-beta.1

package/lib/ele-pro-form/util.d.ts

@@ -0,0 +1,116 @@
+import { SetupContext } from 'vue';
+import { FormRules } from 'element-plus';
+import { ProFormItemProps, ProFormItemKey } from './types';
+
+export { get as getValue, set as setValue, merge as mergeValue } from 'lodash-es';
+/**
+ * 展示类型组件
+ */
+export declare const viewTypes: string[];
+/**
+ * 容器类型组件
+ */
+export declare const containerTypes: string[];
+/**
+ * 内置的组件类型
+ */
+export declare const defaultTypes: string[];
+/**
+ * 选择类型的组件类型
+ */
+export declare const selectTypes: string[];
+/**
+ * 上传类型的组件类型
+ */
+export declare const uploadTypes: string[];
+/**
+ * 支持 options 配置下拉选项数据的组件类型
+ */
+export declare const optionsTypes: string[];
+/**
+ * 表单验证规则使用 blur 触发的组件类型
+ */
+export declare const blurTypes: string[];
+/**
+ * 表单数据类型为字符串的组件类型
+ */
+export declare const stringTypes: string[];
+/**
+ * 表单数据类型为数字的组件类型
+ */
+export declare const numberTypes: string[];
+/**
+ * 表单数据类型为数组的组件类型
+ */
+export declare const arrayTypes: string[];
+/**
+ * 获取验证规则值类型
+ * @param type 组件类型
+ */
+export declare function getRuleType(type?: string): "string" | "number" | "array";
+/**
+ * 获取验证规则触发类型
+ * @param type 组件类型
+ */
+export declare function getRuleTrigger(type?: string): "change" | "blur";
+/**
+ * 获取验证规则提示文本
+ * @param type 组件类型
+ * @param label 表单项标题
+ * @param requiredMessage 必填校验信息
+ * @param placeholder 组件占位文本
+ */
+export declare function getRuleMessage(type?: string, label?: string, requiredMessage?: string, placeholder?: string): string;
+/**
+ * 判断表单项是否展示
+ * @param item 表单项
+ * @param form 表单数据
+ * @param items 表单项数据
+ * @param searchExpand 搜索表单展开状态
+ */
+export declare function isShowItem(item: ProFormItemProps, form: Record<string, any>, items: ProFormItemProps[], searchExpand?: boolean): any;
+/**
+ * 子组件渲染器属性
+ */
+export interface ChildrenRenderProps {
+    /** 表单项配置 */
+    item: ProFormItemProps;
+    /** 表单数据 */
+    model: Record<string, any>;
+    /** 验证规则 */
+    rules?: FormRules;
+    /** 全部的表单项 */
+    formItems?: ProFormItemProps[];
+    /** 搜索表单展开状态 */
+    searchExpand?: boolean;
+    /** 编辑模式 */
+    editable?: boolean;
+    /** 编辑模式禁用子级排序 */
+    sortDisabled?: boolean;
+    /** 编辑模式父级拖拽容器是否可点击选中 */
+    containerSelectable?: boolean;
+    /** 编辑模式选中的表单项 */
+    activeItemKey?: ProFormItemProps['key'];
+    /** 插槽 */
+    slots: any;
+}
+/**
+ * 子组件渲染器事件
+ */
+export type ChildrenRenderEmits = {
+    updateItemValue: (prop: string, value: unknown) => boolean;
+    updateItemsData: (items: ProFormItemProps[], parentItem?: ProFormItemProps) => boolean;
+    'update:activeItemKey': (activeKey?: ProFormItemKey) => boolean;
+};
+/**
+ * 自定义容器组件时子组件渲染器
+ * @param props 属性
+ * @param context 上下文
+ */
+export declare function ChildrenRender(props: ChildrenRenderProps, { emit }: SetupContext<ChildrenRenderEmits>): import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>;
+/**
+ * 编辑模式拖拽排序分组名称
+ */
+export declare const sortableGroupName = "ProFormBuilderBodySortGroup";

package/lib/ele-pro-form-builder/components/body-form.cjs

@@ -0,0 +1,178 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const core = require("../../utils/core");
+const util = require("../../ele-pro-form/util");
+const EleProForm = require("../../ele-pro-form/index");
+const util$1 = require("../util");
+const buildUtil = require("./build-util");
+const ComponentName = require("./component-name");
+const BuilderTools = require("./builder-tools");
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "body-form",
+  props: {
+    formProps: {},
+    currentFormItemId: {},
+    currentScreen: {},
+    componentData: {},
+    proFormComponent: {}
+  },
+  emits: ["update:currentFormItemId", "updateItems", "openTableTool", "updateFormItems"],
+  setup(__props, { emit: __emit }) {
+    const ownSlots = ["builderItemHandleContent", "builderItemTools"];
+    const props = __props;
+    const emit = __emit;
+    const proFormRef = vue.ref(null);
+    const formData = vue.reactive({});
+    const cachebuilderFormData = vue.reactive({});
+    const handleUpdateItems = (result) => {
+      emit("updateItems", result);
+    };
+    const handleUpdateCurrentFormItemId = (formItemId) => {
+      emit("update:currentFormItemId", formItemId);
+    };
+    const handleDeleteItem = (item) => {
+      if (item.key != null) {
+        handleUpdateItems({
+          deleteItemIds: [item.key],
+          addItems: [],
+          updateItems: []
+        });
+      }
+    };
+    const handleAddChildrenItem = (formItem, action) => {
+      var _a;
+      if (formItem.key != null) {
+        core.eachTree((_a = props.formProps) == null ? void 0 : _a.items, (item, cIndex, parent) => {
+          var _a2;
+          if (item.key === formItem.key) {
+            const result = buildUtil.generateAddChildData(
+              item,
+              parent,
+              cIndex,
+              action,
+              (_a2 = props.formProps) == null ? void 0 : _a2.items
+            );
+            handleUpdateItems(result);
+            return false;
+          }
+        });
+      }
+    };
+    const handleCopyItem = (item) => {
+      var _a;
+      if (item.key != null) {
+        handleUpdateItems(
+          buildUtil.generateCopyItemData(item.key, (_a = props.formProps) == null ? void 0 : _a.items)
+        );
+      }
+    };
+    const handleOpenTableTool = (item, e) => {
+      if (item.key != null) {
+        emit("openTableTool", item.key, e.currentTarget);
+      }
+    };
+    const setBuilderFormDataFieldValue = (field, value) => {
+      util.setValue(formData, field, value);
+      util.setValue(cachebuilderFormData, field, value);
+    };
+    const handleUpdateFormItems = (items) => {
+      emit("updateFormItems", items);
+    };
+    vue.watch(
+      () => props.currentFormItemId,
+      (currentFormItemId) => {
+        var _a;
+        core.eachTree((_a = props.formProps) == null ? void 0 : _a.items, (item, _cIndex, parent) => {
+          if (item.key === currentFormItemId) {
+            if (item.type && ["tabPane", "collapseItem"].includes(item.type) && parent) {
+              setBuilderFormDataFieldValue(parent.prop, item.prop);
+            }
+            return false;
+          }
+        });
+      }
+    );
+    vue.watch(
+      () => props.formProps,
+      () => {
+        var _a;
+        Object.keys(formData).forEach((k) => {
+          formData[k] = void 0;
+        });
+        util.mergeValue(
+          formData,
+          util$1.getFormInitValue((_a = props.formProps) == null ? void 0 : _a.items),
+          cachebuilderFormData
+        );
+      },
+      {
+        deep: true,
+        immediate: true
+      }
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass([
+          "ele-pro-form-builder-body",
+          { "is-pc": _ctx.currentScreen === "pc" },
+          { "is-pad": _ctx.currentScreen === "pad" },
+          { "is-phone": _ctx.currentScreen === "phone" }
+        ])
+      }, [
+        (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.proFormComponent || EleProForm), vue.mergeProps(_ctx.formProps || {}, {
+          ref_key: "proFormRef",
+          ref: proFormRef,
+          model: formData,
+          searchExpand: formData.searchExpand,
+          "onUpdate:searchExpand": _cache[0] || (_cache[0] = ($event) => formData.searchExpand = $event),
+          activeKey: _ctx.currentFormItemId,
+          editable: true,
+          footer: false,
+          validateOnRuleChange: false,
+          scrollToError: false,
+          showMessage: false,
+          class: "ele-pro-form-builder-body-form",
+          onUpdateValue: setBuilderFormDataFieldValue,
+          "onUpdate:items": handleUpdateFormItems,
+          "onUpdate:activeKey": handleUpdateCurrentFormItemId
+        }), vue.createSlots({
+          builderItemHandleContent: vue.withCtx(({ item }) => [
+            vue.createVNode(ComponentName, {
+              itemType: item.type,
+              componentData: _ctx.componentData
+            }, null, 8, ["itemType", "componentData"])
+          ]),
+          builderItemTools: vue.withCtx(({ item }) => [
+            vue.createVNode(BuilderTools, {
+              itemType: item.type,
+              onDelete: ($event) => handleDeleteItem(item),
+              onCopy: ($event) => handleCopyItem(item),
+              onAdd: ($event) => handleAddChildrenItem(item),
+              onAddTableRow: ($event) => handleAddChildrenItem(item, "addTableRow"),
+              onAddTableCol: ($event) => handleAddChildrenItem(item, "addTableCol"),
+              onOpenTableTool: (e) => handleOpenTableTool(item, e)
+            }, null, 8, ["itemType", "onDelete", "onCopy", "onAdd", "onAddTableRow", "onAddTableCol", "onOpenTableTool"])
+          ]),
+          _: 2
+        }, [
+          vue.renderList(Object.keys(_ctx.$slots).filter((k) => !ownSlots.includes(k)), (name) => {
+            return {
+              name,
+              fn: vue.withCtx((slotProps) => [
+                vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+              ])
+            };
+          })
+        ]), 1040, ["model", "searchExpand", "activeKey"])),
+        !_ctx.formProps || !_ctx.formProps.items || !_ctx.formProps.items.length ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElEmpty), {
+          key: 0,
+          imageSize: 80,
+          description: "拖拽左侧组件到此",
+          class: "ele-pro-form-builder-form-empty"
+        })) : vue.createCommentVNode("", true)
+      ], 2);
+    };
+  }
+});
+module.exports = _sfc_main;

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

@@ -0,0 +1,54 @@
+import { UserComponent } from '../../ele-app/types';
+import { ProFormItemKey } from '../../ele-pro-form/types';
+import { BuildFormItem, TemplateFormConfig, ComponentGroup, UpdateItemsResult } from '../types';
+
+declare function __VLS_template(): Partial<Record<string, (_: any) => any>>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    /** 表单属性 */
+    formProps?: TemplateFormConfig;
+    /** 选中的表单项 id */
+    currentFormItemId?: ProFormItemKey;
+    /** 当前选中屏幕尺寸 */
+    currentScreen?: string;
+    /** 组件库数据 */
+    componentData?: ComponentGroup[];
+    /** 高级表单组件 */
+    proFormComponent?: UserComponent;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:currentFormItemId": (formItemId?: string | number | symbol | undefined) => void;
+    updateItems: (result: UpdateItemsResult) => void;
+    openTableTool: (formItemId: string, el: HTMLElement) => void;
+    updateFormItems: (items: BuildFormItem[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    /** 表单属性 */
+    formProps?: TemplateFormConfig;
+    /** 选中的表单项 id */
+    currentFormItemId?: ProFormItemKey;
+    /** 当前选中屏幕尺寸 */
+    currentScreen?: string;
+    /** 组件库数据 */
+    componentData?: ComponentGroup[];
+    /** 高级表单组件 */
+    proFormComponent?: UserComponent;
+}>>> & {
+    onOpenTableTool?: ((formItemId: string, el: HTMLElement) => any) | undefined;
+    onUpdateItems?: ((result: UpdateItemsResult) => any) | undefined;
+    "onUpdate:currentFormItemId"?: ((formItemId?: string | number | symbol | undefined) => any) | undefined;
+    onUpdateFormItems?: ((items: BuildFormItem[]) => any) | undefined;
+}, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/ele-pro-form-builder/components/body-header.cjs

@@ -0,0 +1,132 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const icons = require("../../icons");
+const util = require("../util");
+const PreviewModal = require("./preview-modal");
+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__ */ vue.defineComponent({
+  __name: "body-header",
+  props: {
+    currentScreen: {},
+    undoDisabled: { type: Boolean },
+    redoDisabled: { type: Boolean },
+    formProps: {},
+    proFormComponent: {}
+  },
+  emits: ["update:currentScreen", "undo", "redo", "clear"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const previewVisible = vue.ref(false);
+    const handleUpdateScreen = (size) => {
+      emit("update:currentScreen", size);
+    };
+    const handleUndo = () => {
+      if (!props.undoDisabled) {
+        emit("undo");
+      }
+    };
+    const handleRedo = () => {
+      if (!props.redoDisabled) {
+        emit("redo");
+      }
+    };
+    const handleClear = () => {
+      emit("clear");
+    };
+    const handleOpenPreview = () => {
+      previewVisible.value = true;
+    };
+    return (_ctx, _cache) => {
+      const _component_ElButton = vue.resolveComponent("ElButton");
+      return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+        vue.createElementVNode("div", _hoisted_2, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(util.screenItems), (item) => {
+            return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElIcon), {
+              key: item.value,
+              class: vue.normalizeClass([
+                "ele-pro-form-builder-header-tool",
+                "ele-pro-form-builder-screen-icon",
+                { "is-active": item.value === _ctx.currentScreen }
+              ]),
+              onClick: ($event) => handleUpdateScreen(item.value)
+            }, {
+              default: vue.withCtx(() => [
+                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(item.icon), {
+                  style: vue.normalizeStyle(item.iconStyle)
+                }, null, 8, ["style"]))
+              ]),
+              _: 2
+            }, 1032, ["class", "onClick"]);
+          }), 128))
+        ]),
+        vue.createElementVNode("div", _hoisted_3, [
+          vue.createVNode(vue.unref(elementPlus.ElIcon), {
+            class: vue.normalizeClass([
+              "ele-pro-form-builder-header-tool",
+              "ele-pro-form-builder-header-tool-undo",
+              { "is-disabled": _ctx.undoDisabled }
+            ]),
+            title: "撤销",
+            onClick: handleUndo
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(icons.RollbackOutlined))
+            ]),
+            _: 1
+          }, 8, ["class"]),
+          vue.createVNode(vue.unref(elementPlus.ElIcon), {
+            class: vue.normalizeClass([
+              "ele-pro-form-builder-header-tool",
+              "ele-pro-form-builder-header-tool-redo",
+              { "is-disabled": _ctx.redoDisabled }
+            ]),
+            title: "恢复",
+            onClick: handleRedo
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(icons.RecoverOutlined))
+            ]),
+            _: 1
+          }, 8, ["class"])
+        ]),
+        vue.createElementVNode("div", _hoisted_4, [
+          vue.createVNode(_component_ElButton, {
+            text: true,
+            type: "danger",
+            icon: vue.unref(icons.DeleteOutlined),
+            onClick: handleClear
+          }, {
+            default: vue.withCtx(() => [
+              vue.createTextVNode(" 清空 ")
+            ]),
+            _: 1
+          }, 8, ["icon"]),
+          vue.createVNode(_component_ElButton, {
+            text: true,
+            type: "primary",
+            icon: vue.unref(icons.EyeOutlined),
+            onClick: handleOpenPreview
+          }, {
+            default: vue.withCtx(() => [
+              vue.createTextVNode(" 预览 ")
+            ]),
+            _: 1
+          }, 8, ["icon"]),
+          vue.renderSlot(_ctx.$slots, "headerTools")
+        ]),
+        vue.createVNode(PreviewModal, {
+          modelValue: previewVisible.value,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => previewVisible.value = $event),
+          formProps: _ctx.formProps,
+          proFormComponent: _ctx.proFormComponent
+        }, null, 8, ["modelValue", "formProps", "proFormComponent"])
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;

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

@@ -0,0 +1,55 @@
+import { UserComponent } from '../../ele-app/types';
+import { TemplateFormConfig } from '../types';
+
+declare function __VLS_template(): {
+    headerTools?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<__VLS_TypePropsToRuntimeProps<{
+    /** 当前选中屏幕尺寸 */
+    currentScreen?: string;
+    /** 是否禁用撤销 */
+    undoDisabled?: boolean;
+    /** 是否禁用恢复 */
+    redoDisabled?: boolean;
+    /** 表单属性 */
+    formProps?: TemplateFormConfig;
+    /** 高级表单组件 */
+    proFormComponent?: UserComponent;
+}>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:currentScreen": (size?: string | undefined) => void;
+    undo: () => void;
+    redo: () => void;
+    clear: () => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    /** 当前选中屏幕尺寸 */
+    currentScreen?: string;
+    /** 是否禁用撤销 */
+    undoDisabled?: boolean;
+    /** 是否禁用恢复 */
+    redoDisabled?: boolean;
+    /** 表单属性 */
+    formProps?: TemplateFormConfig;
+    /** 高级表单组件 */
+    proFormComponent?: UserComponent;
+}>>> & {
+    onClear?: (() => any) | undefined;
+    "onUpdate:currentScreen"?: ((size?: string | undefined) => any) | undefined;
+    onUndo?: (() => any) | undefined;
+    onRedo?: (() => any) | undefined;
+}, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/ele-pro-form-builder/components/build-util.cjs

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("../../utils/core");
+const util = require("../util");
+const tableUtil = require("./table-util");
+function generateAddChildData(triggerItem, triggerParent, triggerItemIndex, actionType, formItems, position) {
+  if (!triggerItem.type) {
+    return { addItems: [], updateItems: [], deleteItemIds: [] };
+  }
+  const parentItemId = triggerParent == null ? void 0 : triggerParent.key;
+  const afterIndex = triggerItemIndex == null ? void 0 : triggerItemIndex + 1;
+  if ([
+    "tabPane",
+    "collapseItem",
+    "col",
+    "carouselItem",
+    "descriptionsItem"
+  ].includes(triggerItem.type)) {
+    const item = util.generateChildFormItem(
+      {
+        tabPane: "tabs",
+        collapseItem: "collapse",
+        col: "row",
+        carouselItem: "carousel",
+        descriptionsItem: "descriptions"
+      }[triggerItem.type]
+    );
+    itemsGenerateNewKey(item, formItems, true);
+    return {
+      addItems: [{ item, parentItemId, index: afterIndex }],
+      updateItems: [],
+      deleteItemIds: []
+    };
+  }
+  if (triggerItem.type === "tableCell") {
+    const result = {
+      addItems: [],
+      updateItems: [],
+      deleteItemIds: []
+    };
+    core.eachTree(formItems, (trItem, _trIndex, tableItem) => {
+      if (triggerParent && trItem.key === triggerParent.key && tableItem) {
+        const { addItems, updateItems, deleteItemIds } = (actionType === "addTableCol" ? tableUtil.generateAddTableColData : tableUtil.generateAddTableRowData)(tableItem, formItems, triggerItem, position);
+        result.addItems = addItems;
+        result.updateItems = updateItems;
+        result.deleteItemIds = deleteItemIds;
+        return false;
+      }
+    });
+    return result;
+  }
+  if (triggerItem.type === "table") {
+    return (actionType === "addTableCol" ? tableUtil.generateAddTableColData : tableUtil.generateAddTableRowData)(triggerItem, formItems);
+  }
+  const child = util.generateChildFormItem(triggerItem.type);
+  itemsGenerateNewKey(child, formItems, true);
+  return {
+    addItems: [{ item: child, parentItemId: triggerItem.key }],
+    updateItems: [],
+    deleteItemIds: []
+  };
+}
+function itemsGenerateNewKey(items, formItems, overwriteProp) {
+  if (!items) {
+    return;
+  }
+  const addedKeys = [];
+  core.eachTree(Array.isArray(items) ? items : [items], (item) => {
+    const itemKey = util.generateUniqueItemKey(formItems, addedKeys);
+    addedKeys.push(itemKey);
+    item.key = itemKey;
+    if (overwriteProp) {
+      item.prop = itemKey;
+    }
+  });
+}
+function generateCopyItemData(formItemId, formItems) {
+  const result = {
+    addItems: [],
+    updateItems: [],
+    deleteItemIds: []
+  };
+  core.eachTree(formItems, (item, index, parent) => {
+    if (item.key === formItemId) {
+      const newItem = JSON.parse(JSON.stringify(item));
+      itemsGenerateNewKey(newItem, formItems, true);
+      result.addItems.push({
+        item: newItem,
+        parentItemId: parent == null ? void 0 : parent.key,
+        index: index + 1
+      });
+      return false;
+    }
+  });
+  return result;
+}
+exports.generateAddChildData = generateAddChildData;
+exports.generateCopyItemData = generateCopyItemData;
+exports.itemsGenerateNewKey = itemsGenerateNewKey;

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

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