ele-admin-plus 1.2.2-beta.5 → 1.3.0-beta.3

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

@@ -0,0 +1,112 @@
+import type { VNode } from 'vue';
+import type { ElFormItemProps, ElRowProps, ElColProps } from '../ele-app/el';
+import type { UserComponent } from '../ele-app/types';
+
+/**
+ * 表单项 key
+ */
+export type ProFormItemKey = keyof any;
+
+/**
+ * 表单项数据
+ */
+export interface ProFormItemProps {
+  /** 表单项 key */
+  key?: ProFormItemKey;
+  /** 字段名 */
+  prop?: string;
+  /** 标题 */
+  label?: string;
+  /** 是否为必填项 */
+  required?: boolean;
+  /** 必填校验信息 */
+  requiredMessage?: string;
+  /** ElFormItem 属性 */
+  itemProps?: ElFormItemProps;
+  /** ElFormItem 插槽 */
+  itemSlots?: Record<string, string>;
+  /** 组件类型 */
+  type?: string;
+  /** 组件属性 */
+  props?: Record<string, any>;
+  /** 组件插槽 */
+  slots?: Record<string, string>;
+  /** ElCol 属性 */
+  colProps?: ElColProps;
+  /** 容器组件是否栅格布局 */
+  grid?: boolean | ElColProps;
+  /** 容器组件栅格布局 ElRow 属性 */
+  rowProps?: ElRowProps;
+  /** 自定义组件类型时标识表单项类型 */
+  itemType?: 'default' | 'view' | 'container';
+  /** 显示条件 */
+  vIf?: any;
+  /** 容器组件编辑模式是否可拖拽排序 */
+  containerDraggable?: boolean;
+  /** 初始值 */
+  initValue?: any;
+  /** 子级 */
+  children?: ProFormItemProps[];
+}
+
+/**
+ * 获取表单项类型组件属性的方法参数
+ */
+export interface ProFormItemPropsFunctionParams {
+  /** 表单项数据 */
+  item: ProFormItemProps;
+  /** 表单项对应的绑定值 */
+  modelValue: any;
+  /** 更新绑定值的方法 */
+  updateModelValue: (value: any) => void;
+  /** 判断表单项是否展示的方法 */
+  isShowFormItem: (item: ProFormItemProps) => boolean;
+  /** 渲染表单项子级的方法 */
+  renderChildren: (
+    item: ProFormItemProps,
+    sortDisabled?: boolean,
+    containerSelectable?: boolean
+  ) => string | VNode | Array<string | VNode> | undefined;
+}
+
+/**
+ * 表单项类型数据
+ */
+export interface ProFormItemTypeData {
+  /** 组件类型 */
+  type: string;
+  /** 组件 */
+  component: UserComponent;
+  /** 是否是容器组件 */
+  isContainer?: boolean;
+  /** 容器组件在编辑模式下是否禁用拖拽功能 */
+  sortDisabled?: boolean;
+  /** 容器组件在编辑模式下是否可选中 */
+  containerSelectable?: boolean;
+  /** 是否渲染 label 属性为文本内容 */
+  renderLabelText?: boolean;
+  /** 组件的默认属性 */
+  defaultProps?: (
+    params: ProFormItemPropsFunctionParams
+  ) => Record<string, any>;
+  /** 组件的保留属性 */
+  reservedProps?: (
+    params: ProFormItemPropsFunctionParams
+  ) => Record<string, any>;
+  /** 组件的保留插槽 */
+  reservedSlots?: (
+    params: ProFormItemPropsFunctionParams
+  ) => ProFormItemRenderSlots;
+  /** 必填校验触发方式 */
+  requiredTrigger?: string;
+}
+
+/**
+ * 渲染表单项组件时的插槽数据
+ */
+export type ProFormItemRenderSlots = Record<
+  string,
+  (
+    slotProps?: Record<string, any>
+  ) => string | VNode | Array<string | VNode> | undefined
+>;

package/lib/ele-pro-form/util.cjs

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const core = require("../utils/core");
+const itemTypeData = require("./components/item-type-data");
+const renderUtil = require("./components/render-util");
+const setValue = require("../../node_modules/lodash-es/set.js");
+const getValue = require("../../node_modules/lodash-es/get.js");
+const merge_js = require("../../node_modules/lodash-es/merge.js");
+function isContainerType(item, itemTypeData$1) {
+  const typeData = item.type ? [...itemTypeData$1 || [], ...itemTypeData.defaultItemTypeData].find(
+    (d) => d.type === item.type
+  ) : void 0;
+  return (typeData == null ? void 0 : typeData.isContainer) || item.itemType === "container" || item.itemType === "view";
+}
+function getFormInitValue(items, itemTypeData2) {
+  const init = {};
+  core.eachTree(items, (item) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    if (item.initValue != null && item.initValue !== "" && item.prop) {
+      setValue(init, item.prop, item.initValue);
+      return;
+    }
+    if (item.type && item.prop) {
+      if ("tabs" === item.type) {
+        const active = ((_a = item.props) == null ? void 0 : _a.modelValue) ?? ((_c = (_b = item.children) == null ? void 0 : _b[0]) == null ? void 0 : _c.prop);
+        setValue(init, item.prop, active);
+        return;
+      }
+      if ("collapse" === item.type) {
+        const active = ((_d = item.props) == null ? void 0 : _d.modelValue) ?? (((_e = item.props) == null ? void 0 : _e.accordion) ? ((_h = (_g = (_f = item.children) == null ? void 0 : _f[0]) == null ? void 0 : _g.props) == null ? void 0 : _h.name) ?? ((_j = (_i = item.children) == null ? void 0 : _i[0]) == null ? void 0 : _j.prop) : []);
+        setValue(init, item.prop, active);
+        return;
+      }
+      if ("sliderRange" === item.type) {
+        setValue(init, item.prop, [
+          ((_k = item.props) == null ? void 0 : _k.min) ?? 0,
+          ((_l = item.props) == null ? void 0 : _l.max) ?? 100
+        ]);
+        return;
+      }
+    }
+    if (isContainerType(item, itemTypeData2) || !item.prop) {
+      return;
+    }
+    if (typeof getValue(init, item.prop) === "undefined") {
+      setValue(init, item.prop, void 0);
+    }
+  });
+  return init;
+}
+Object.defineProperty(exports, "ChildrenRender", {
+  enumerable: true,
+  get: () => renderUtil.ChildrenRender
+});
+Object.defineProperty(exports, "sortableGroupName", {
+  enumerable: true,
+  get: () => renderUtil.sortableGroupName
+});
+exports.setValue = setValue;
+exports.getValue = getValue;
+exports.mergeValue = merge_js;
+exports.getFormInitValue = getFormInitValue;
+exports.isContainerType = isContainerType;

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

@@ -0,0 +1,17 @@
+import { get as getValue, set as setValue, merge as mergeValue } from 'lodash-es';
+import { ProFormItemProps, ProFormItemTypeData } from './types';
+
+export { sortableGroupName, ChildrenRender } from './components/render-util';
+export { setValue, getValue, mergeValue };
+/**
+ * 判断表单项是否是容器类型
+ * @param item 表单项
+ * @param itemTypeData 高级表单组件类型数据
+ */
+export declare function isContainerType(item: ProFormItemProps, itemTypeData?: ProFormItemTypeData[]): boolean;
+/**
+ * 获取表单数据初始值
+ * @param items 表单项数据
+ * @param itemTypeData 高级表单组件类型数据
+ */
+export declare function getFormInitValue(items?: ProFormItemProps[], itemTypeData?: ProFormItemTypeData[]): Record<string, any>;

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

@@ -0,0 +1,183 @@
+"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 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: {},
+    itemTypeData: {},
+    httpRequest: {}
+  },
+  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,
+              void 0,
+              props.componentData
+            );
+            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 && parent.prop) {
+              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.getFormInitValue((_a = props.formProps) == null ? void 0 : _a.items, props.itemTypeData),
+          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),
+          activeItemKey: _ctx.currentFormItemId,
+          editable: true,
+          footer: false,
+          validateOnRuleChange: false,
+          scrollToError: false,
+          showMessage: false,
+          itemTypeData: _ctx.itemTypeData,
+          httpRequest: _ctx.httpRequest,
+          class: "ele-pro-form-builder-body-form",
+          onUpdateValue: setBuilderFormDataFieldValue,
+          "onUpdate:items": handleUpdateFormItems,
+          "onUpdate:activeItemKey": 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", "activeItemKey", "itemTypeData", "httpRequest"])),
+        !_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,62 @@
+import { UserComponent } from '../../ele-app/types';
+import { ProFormItemKey, ProFormItemProps, ProFormItemTypeData } from '../../ele-pro-form/types';
+import { 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;
+    /** 高级表单组件类型数据 */
+    itemTypeData?: ProFormItemTypeData[];
+    /** 远程数据源请求工具 */
+    httpRequest?: any;
+}>, {}, 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: ProFormItemProps[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    /** 表单属性 */
+    formProps?: TemplateFormConfig;
+    /** 选中的表单项 id */
+    currentFormItemId?: ProFormItemKey;
+    /** 当前选中屏幕尺寸 */
+    currentScreen?: string;
+    /** 组件库数据 */
+    componentData?: ComponentGroup[];
+    /** 高级表单组件 */
+    proFormComponent?: UserComponent;
+    /** 高级表单组件类型数据 */
+    itemTypeData?: ProFormItemTypeData[];
+    /** 远程数据源请求工具 */
+    httpRequest?: any;
+}>>> & {
+    onOpenTableTool?: ((formItemId: string, el: HTMLElement) => any) | undefined;
+    onUpdateItems?: ((result: UpdateItemsResult) => any) | undefined;
+    "onUpdate:currentFormItemId"?: ((formItemId?: string | number | symbol | undefined) => any) | undefined;
+    onUpdateFormItems?: ((items: ProFormItemProps[]) => 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,200 @@
+"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 ImportModal = require("./import-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: {},
+    headerTools: {},
+    proFormComponent: {},
+    jsonEditerComponent: {},
+    itemTypeData: {},
+    httpRequest: {}
+  },
+  emits: ["update:currentScreen", "undo", "redo", "clear", "previewFormSubmit", "importData"],
+  setup(__props, { emit: __emit }) {
+    const ownSlots = ["headerTools"];
+    const props = __props;
+    const emit = __emit;
+    const previewVisible = vue.ref(false);
+    const importVisible = vue.ref(false);
+    const isImport = 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;
+    };
+    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);
+    };
+    return (_ctx, _cache) => {
+      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.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.headerTools || [], (toolName) => {
+            return vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: toolName }, [
+              toolName === "import" ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElButton), {
+                key: 0,
+                text: true,
+                icon: vue.unref(icons.UploadOutlined),
+                onClick: handleOpenImport
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createTextVNode(" 导入 ")
+                ]),
+                _: 1
+              }, 8, ["icon"])) : toolName === "export" ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElButton), {
+                key: 1,
+                text: true,
+                icon: vue.unref(icons.DownloadOutlined),
+                onClick: handleOpenExport
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createTextVNode(" 导出 ")
+                ]),
+                _: 1
+              }, 8, ["icon"])) : toolName === "clear" ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElButton), {
+                key: 2,
+                text: true,
+                type: "danger",
+                icon: vue.unref(icons.DeleteOutlined),
+                onClick: handleClear
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createTextVNode(" 清空 ")
+                ]),
+                _: 1
+              }, 8, ["icon"])) : toolName === "preview" ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElButton), {
+                key: 3,
+                text: true,
+                type: "primary",
+                icon: vue.unref(icons.EyeOutlined),
+                onClick: handleOpenPreview
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createTextVNode(" 预览 ")
+                ]),
+                _: 1
+              }, 8, ["icon"])) : vue.createCommentVNode("", true)
+            ], 64);
+          }), 128)),
+          vue.renderSlot(_ctx.$slots, "headerTools")
+        ]),
+        _ctx.headerTools && _ctx.headerTools.includes("preview") ? (vue.openBlock(), vue.createBlock(PreviewModal, {
+          key: 0,
+          modelValue: previewVisible.value,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => previewVisible.value = $event),
+          formProps: _ctx.formProps,
+          proFormComponent: _ctx.proFormComponent,
+          itemTypeData: _ctx.itemTypeData,
+          httpRequest: _ctx.httpRequest,
+          onPreviewFormSubmit: handlePreviewFormSubmit
+        }, vue.createSlots({ _: 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 || {})))
+              ])
+            };
+          })
+        ]), 1032, ["modelValue", "formProps", "proFormComponent", "itemTypeData", "httpRequest"])) : vue.createCommentVNode("", true),
+        _ctx.headerTools && (_ctx.headerTools.includes("import") || _ctx.headerTools.includes("export")) ? (vue.openBlock(), vue.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"])) : vue.createCommentVNode("", true)
+      ]);
+    };
+  }
+});
+module.exports = _sfc_main;