qidian-vue-ui 1.1.22 → 1.1.24

package/dist/components/crud/table.vue2.mjs

@@ -0,0 +1,1041 @@
+import { defineComponent, mergeDefaults, computed, reactive, useTemplateRef, ref, onMounted, createElementBlock, openBlock, withDirectives, createCommentVNode, createVNode, createBlock, mergeProps, unref, isRef, createSlots, withCtx, createTextVNode, toDisplayString, renderList, renderSlot, normalizeProps, guardReactiveProps, vShow, createElementVNode, Fragment, withModifiers, nextTick, shallowRef, triggerRef } from "vue";
+import { useVModels } from "../../node_modules/.pnpm/@vueuse_core@14.0.0_vue@3.5.22_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.mjs";
+import { easyCopy, suspectedWrapperPromise, extractSlotsWithPrefix, isEmpty, generateRandomString, to } from "qidian-shared";
+import { qdCrudTableProps } from "./props.mjs";
+import { hasPermiDirective } from "../../directive/hasPermi.mjs";
+import { hasPermiOr } from "../../utils/auth.mjs";
+import "../../_virtual/dayjs.min.mjs";
+import { useConfig } from "../config-provider/useConfig.mjs";
+import { Space, Button, Tooltip, Divider, Link } from "tdesign-vue-next";
+import { SearchIcon, RefreshIcon, UnfoldLessIcon, UnfoldMoreIcon, SettingIcon, AddIcon } from "tdesign-icons-vue-next";
+import QdServiceTable from "../service/table.vue.mjs";
+import { qdServiceTableTreeConfig } from "../service/props.mjs";
+/* empty css                    */
+/* empty css                      */
+import "../dialog/props.mjs";
+/* empty css                    */
+import _sfc_main$2 from "../dialog/form.vue.mjs";
+import QdCrudSearch from "./search.vue.mjs";
+import _sfc_main$1 from "../config-renderer/index.vue.mjs";
+import QdCard from "../card/index.vue.mjs";
+import "../../hooks/useAgentChat/index.mjs";
+import { useModal } from "../../hooks/useModal.mjs";
+import merge from "../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/merge.mjs";
+import cloneDeep from "../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/cloneDeep.mjs";
+const _hoisted_1 = {
+  class: "qd-crud-table"
+};
+const _hoisted_2 = {
+  class: "qd-crud-table__toolbar"
+};
+const _hoisted_3 = {
+  key: 0,
+  class: "qd-crud-table__toolbar-separator"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    name: "QdCrudTable"
+  },
+  __name: "table",
+  props: /* @__PURE__ */ mergeDefaults({
+    title: {},
+    permiPrefix: {},
+    search: {},
+    searchData: {},
+    form: {},
+    detail: {},
+    add: {
+      type: [Boolean, Object]
+    },
+    actions: {},
+    edit: {
+      type: [Boolean, Object]
+    },
+    view: {
+      type: [Boolean, Object]
+    },
+    del: {
+      type: [Boolean, Object]
+    },
+    rowActions: {},
+    rowKey: {},
+    selectType: {},
+    headerBg: {
+      type: Boolean
+    },
+    tree: {},
+    loadingWithData: {
+      type: Boolean
+    },
+    beforeDragSort: {
+      type: Function
+    },
+    expandedTreeNodes: {},
+    defaultExpandedTreeNodes: {},
+    treeExpandAndFoldIcon: {},
+    onAbnormalDragSort: {
+      type: Function
+    },
+    onExpandedTreeNodesChange: {
+      type: Function
+    },
+    onTreeExpandChange: {
+      type: Function
+    },
+    asyncLoading: {},
+    columnController: {},
+    columnControllerVisible: {
+      type: Boolean
+    },
+    defaultColumnControllerVisible: {
+      type: Boolean
+    },
+    columns: {},
+    displayColumns: {},
+    defaultDisplayColumns: {},
+    dragSort: {},
+    dragSortOptions: {},
+    editableCellState: {
+      type: Function
+    },
+    editableRowKeys: {},
+    expandIcon: {
+      type: Boolean
+    },
+    expandOnRowClick: {
+      type: Boolean
+    },
+    expandedRow: {},
+    expandedRowKeys: {},
+    defaultExpandedRowKeys: {},
+    filterIcon: {},
+    filterRow: {},
+    filterValue: {},
+    defaultFilterValue: {},
+    hideSortTips: {
+      type: Boolean
+    },
+    indeterminateSelectedRowKeys: {},
+    multipleSort: {
+      type: Boolean
+    },
+    reserveSelectedRowOnPaginate: {
+      type: Boolean
+    },
+    rowSelectionAllowUncheck: {
+      type: Boolean
+    },
+    rowSelectionType: {},
+    selectOnRowClick: {
+      type: Boolean
+    },
+    selectedRowKeys: {},
+    defaultSelectedRowKeys: {},
+    showSortColumnBgColor: {
+      type: Boolean
+    },
+    sort: {},
+    defaultSort: {},
+    sortIcon: {},
+    sortOnRowDraggable: {
+      type: Boolean
+    },
+    onAsyncLoadingClick: {
+      type: Function
+    },
+    onCellClick: {
+      type: Function
+    },
+    onChange: {
+      type: Function
+    },
+    onColumnChange: {
+      type: Function
+    },
+    onColumnControllerVisibleChange: {
+      type: Function
+    },
+    onDataChange: {
+      type: Function
+    },
+    onDisplayColumnsChange: {
+      type: Function
+    },
+    onDragSort: {
+      type: Function
+    },
+    onExpandChange: {
+      type: Function
+    },
+    onFilterChange: {
+      type: Function
+    },
+    onRowEdit: {
+      type: Function
+    },
+    onRowValidate: {
+      type: Function
+    },
+    onSelectChange: {
+      type: Function
+    },
+    onSortChange: {
+      type: Function
+    },
+    onValidate: {
+      type: Function
+    },
+    activeRowKeys: {},
+    defaultActiveRowKeys: {},
+    activeRowType: {},
+    allowResizeColumnWidth: {
+      type: Boolean
+    },
+    attach: {
+      type: [String, Function]
+    },
+    bordered: {
+      type: Boolean
+    },
+    bottomContent: {},
+    cellEmptyContent: {},
+    data: {},
+    disableDataPage: {
+      type: Boolean
+    },
+    disableSpaceInactiveRow: {
+      type: Boolean
+    },
+    empty: {},
+    firstFullRow: {},
+    fixedRows: {},
+    footData: {},
+    footerAffixProps: {},
+    footerAffixedBottom: {
+      type: [Boolean, Object]
+    },
+    footerSummary: {},
+    headerAffixProps: {},
+    headerAffixedTop: {
+      type: [Boolean, Object]
+    },
+    height: {},
+    horizontalScrollAffixedBottom: {
+      type: [Boolean, Object]
+    },
+    hover: {
+      type: Boolean
+    },
+    keyboardRowHover: {
+      type: Boolean
+    },
+    lastFullRow: {},
+    lazyLoad: {
+      type: Boolean
+    },
+    loading: {
+      type: Boolean
+    },
+    loadingProps: {},
+    locale: {},
+    maxHeight: {},
+    paginationAffixedBottom: {
+      type: [Boolean, Object]
+    },
+    resizable: {
+      type: Boolean
+    },
+    rowAttributes: {
+      type: [Object, Function, Array]
+    },
+    rowClassName: {
+      type: [Object, Array, String, Function]
+    },
+    rowspanAndColspan: {
+      type: Function
+    },
+    rowspanAndColspanInFooter: {
+      type: Function
+    },
+    scroll: {},
+    showHeader: {
+      type: Boolean
+    },
+    size: {},
+    stripe: {
+      type: Boolean
+    },
+    tableContentWidth: {},
+    tableLayout: {},
+    topContent: {},
+    verticalAlign: {},
+    onActiveChange: {
+      type: Function
+    },
+    onActiveRowAction: {
+      type: Function
+    },
+    onColumnResizeChange: {
+      type: Function
+    },
+    onPageChange: {
+      type: Function
+    },
+    onRowClick: {
+      type: Function
+    },
+    onRowDblclick: {
+      type: Function
+    },
+    onRowMousedown: {
+      type: Function
+    },
+    onRowMouseenter: {
+      type: Function
+    },
+    onRowMouseleave: {
+      type: Function
+    },
+    onRowMouseover: {
+      type: Function
+    },
+    onRowMouseup: {
+      type: Function
+    },
+    onScroll: {
+      type: Function
+    },
+    onScrollX: {
+      type: Function
+    },
+    onScrollY: {
+      type: Function
+    },
+    cacheKey: {
+      type: [String, Function]
+    },
+    cacheTime: {},
+    pollingInterval: {},
+    onBefore: {
+      type: Function
+    },
+    onAfter: {
+      type: Function
+    },
+    onSuccess: {
+      type: Function
+    },
+    onError: {
+      type: Function
+    },
+    service: {
+      type: Function
+    },
+    manual: {
+      type: Boolean
+    },
+    transformParams: {
+      type: Function
+    },
+    transformRes: {
+      type: Function
+    },
+    pagination: {}
+  }, qdCrudTableProps),
+  emits: ["update:searchData", "update:data", "update:selectedRowKeys", "update:activeRowKeys", "update:columnControllerVisible", "update:displayColumns", "update:expandedRowKeys", "update:filterValue", "update:sort", "update:expandedTreeNodes"],
+  setup(__props, {
+    expose: __expose,
+    emit: __emit
+  }) {
+    const vHasPermi = hasPermiDirective;
+    const props = __props;
+    const emit = __emit;
+    const {
+      searchData,
+      data,
+      selectedRowKeys,
+      activeRowKeys,
+      columnControllerVisible,
+      displayColumns,
+      expandedRowKeys,
+      filterValue,
+      sort,
+      expandedTreeNodes
+    } = useVModels(props, emit, {
+      passive: true
+    });
+    const {
+      t
+    } = useConfig("crud");
+    const {
+      msgError,
+      msgSuccess,
+      alertWarning,
+      confirm
+    } = useModal();
+    const treeIsExpand = computed(() => !!expandedTreeNodes.value?.length);
+    const dialogFormMap = reactive({});
+    const rowActionsIfRenderMap = reactive({});
+    const reProps = computed(() => {
+      const {
+        data: data2,
+        searchData: inSearchData,
+        selectedRowKeys: selectedRowKeys2,
+        activeRowKeys: activeRowKeys2,
+        columnControllerVisible: columnControllerVisible2,
+        displayColumns: displayColumns2,
+        expandedRowKeys: expandedRowKeys2,
+        filterValue: filterValue2,
+        sort: sort2,
+        expandedTreeNodes: expandedTreeNodes2,
+        transformParams,
+        search,
+        form,
+        detail,
+        add,
+        actions,
+        edit,
+        view,
+        del,
+        rowActions,
+        title,
+        columns,
+        selectType,
+        ...serviceTableOptions
+      } = props;
+      const mergedTransformParams = (params) => {
+        const merged = {
+          ...params,
+          ...searchData.value
+        };
+        if (transformParams) return transformParams(merged);
+        return merged;
+      };
+      const reAdd = mergeAction({
+        crudMode: "add",
+        permiID: "add",
+        content: t("addText"),
+        icon: () => createVNode(AddIcon, null, null)
+      }, add, form);
+      const reActions = [reAdd, ...buildActions(actions, form)].filter(Boolean);
+      const reEdit = mergeAction({
+        crudMode: "edit",
+        permiID: "edit",
+        content: t("editText"),
+        theme: "primary",
+        hover: "color"
+      }, edit, form);
+      const reView = mergeAction({
+        crudMode: "view",
+        permiID: "query",
+        content: t("viewText"),
+        theme: "primary",
+        hover: "color"
+      }, view, form);
+      const reDel = mergeAction({
+        crudMode: "del",
+        permiID: "remove",
+        content: t("deleteText"),
+        theme: "danger",
+        hover: "color",
+        selectType: "multiple"
+      }, del, form);
+      const reRowActions = [reEdit, reView, reDel, ...buildActions(rowActions, form)].filter(Boolean);
+      let reSelectType = selectType;
+      if (reDel?.selectType === "multiple") {
+        if (!reSelectType) reSelectType = "multiple";
+        const batchDel = mergeAction({
+          crudMode: "del",
+          permiID: "remove",
+          content: t("deleteText"),
+          theme: "danger",
+          variant: "outline",
+          selectType: "multiple"
+        }, del, form);
+        reActions.splice(reAdd ? 1 : 0, 0, batchDel);
+      }
+      const reColumns = columns || [];
+      const operationLength = reRowActions.length;
+      if (operationLength) {
+        const operationIdx = reColumns.findIndex((item) => item.colKey === "operation");
+        const defaultOperation = {
+          title: t("operationText"),
+          colKey: "operation",
+          align: "center",
+          fixed: "right",
+          width: 28 * operationLength + 25 * operationLength - 1 + 32
+        };
+        if (operationIdx > -1) {
+          reColumns[operationIdx] = {
+            ...defaultOperation,
+            ...reColumns[operationIdx]
+          };
+        } else {
+          reColumns.push(defaultOperation);
+        }
+      }
+      return {
+        title,
+        searchOptions: search,
+        serviceTableOptions: {
+          ...serviceTableOptions,
+          selectType: reSelectType,
+          columns: reColumns,
+          transformParams: mergedTransformParams
+        },
+        formOptions: form,
+        detailOptions: detail,
+        actions: reActions,
+        rowActions: reRowActions,
+        models: {
+          data: data2,
+          searchData: inSearchData,
+          selectedRowKeys: selectedRowKeys2,
+          activeRowKeys: activeRowKeys2,
+          columnControllerVisible: columnControllerVisible2,
+          displayColumns: displayColumns2,
+          expandedRowKeys: expandedRowKeys2,
+          filterValue: filterValue2,
+          sort: sort2,
+          expandedTreeNodes: expandedTreeNodes2
+        }
+      };
+    });
+    const tableRef = useTemplateRef("table");
+    const searchVisible = ref(true);
+    const searchRef = useTemplateRef("search");
+    let searchMode = "refresh";
+    function handleSearch() {
+      searchMode = "changeCurrent";
+    }
+    async function handleResetSearch() {
+      searchMode = "changeCurrent";
+      searchRef.value?.reset();
+      await nextTick();
+      searchRef.value?.submit();
+    }
+    function triggerSearch({
+      validateResult
+    }) {
+      if (validateResult !== true) return;
+      switch (searchMode) {
+        case "changeCurrent":
+          tableRef.value?.changeCurrent(1);
+          break;
+        default:
+          tableRef.value?.refresh();
+          break;
+      }
+    }
+    function handleRefresh() {
+      searchMode = "refresh";
+      searchRef.value?.submit();
+    }
+    function toggleSearchVisible() {
+      searchVisible.value = !searchVisible.value;
+    }
+    function toggleTreeExpandAll() {
+      if (treeIsExpand.value) tableRef.value?.foldAll();
+      else tableRef.value?.expandAll();
+    }
+    function openColumnController() {
+      columnControllerVisible.value = true;
+    }
+    function buildActions(actions, crudForm) {
+      if (!actions) return [];
+      return actions.map((item) => mergeAction({
+        variant: "outline",
+        theme: "primary",
+        hover: "color"
+      }, item, crudForm));
+    }
+    function mergeAction(defaultOptions, currentOptions, crudForm) {
+      if (currentOptions === false || !currentOptions) return;
+      const mergeOptions = merge(defaultOptions, currentOptions);
+      mergeOptions.permi = buildActionPermi(mergeOptions);
+      if (mergeOptions.crudMode !== "del") {
+        mergeOptions.form = buildActionForm(mergeOptions, crudForm);
+      }
+      return mergeOptions;
+    }
+    function getConfigRendererCtx(self, other) {
+      return {
+        tableData: data.value,
+        searchData: searchData.value,
+        selectedRowKeys: selectedRowKeys.value,
+        activeRowKeys: activeRowKeys.value,
+        self,
+        ...other
+      };
+    }
+    function actionIsCRU(crudMode) {
+      return crudMode && ["add", "edit", "view"].includes(crudMode);
+    }
+    function buildActionPermi(action) {
+      if (action.permi) return action.permi;
+      if (!props.permiPrefix || !action.permiID) return [];
+      return [`${props.permiPrefix}:${action.permiID}`];
+    }
+    function buildActionForm(action, crudForm) {
+      const IsCRU = actionIsCRU(action.crudMode);
+      if (!action.form && IsCRU) {
+        action.form = cloneDeep(crudForm);
+      }
+      const {
+        form
+      } = action;
+      if (form) {
+        if (action.crudMode === "view") form.readonly = true;
+        if (!form.onSubmit && IsCRU) {
+          form.onSubmit = async (context) => {
+            const {
+              uid,
+              service,
+              transformParams,
+              transformRes,
+              crudMode
+            } = action;
+            if (context.validateResult !== true || !service || !uid || !dialogFormMap[uid]) return false;
+            let currentParams = easyCopy(context.formData);
+            if (transformParams) {
+              const [tpErr, tpRes] = await suspectedWrapperPromise(transformParams(currentParams));
+              if (tpErr) throw tpErr;
+              currentParams = tpRes;
+            }
+            const [serviceErr, serviceRes] = await suspectedWrapperPromise(service(currentParams));
+            if (serviceErr) throw serviceErr;
+            let res;
+            if (transformRes) {
+              const [trErr, trRes] = await suspectedWrapperPromise(transformRes(serviceRes));
+              if (trErr) throw trErr;
+              res = trRes;
+            } else {
+              res = serviceRes;
+            }
+            if (typeof res === "boolean") {
+              res = {
+                success: res,
+                message: ""
+              };
+            }
+            if (!res) {
+              res = {
+                success: true,
+                message: ""
+              };
+            }
+            const message = res.message;
+            if (res.success === false) {
+              if (message) msgError(message);
+              return false;
+            }
+            msgSuccess(message || t("operationSuccessText"));
+            if (crudMode === "add") {
+              tableRef.value?.changeCurrent(1);
+            } else {
+              tableRef.value?.refresh();
+            }
+          };
+        }
+        const {
+          title
+        } = props;
+        form.wrapper = merge({}, {
+          header: `${action.content}${title ? ` ${title}` : ""}`
+        }, form.wrapper);
+      }
+      return action.form;
+    }
+    function buildActionOnClick(action, originalParams) {
+      if (action.onClick) return action.onClick;
+      if (action.crudMode === "del") {
+        const onClick2 = async () => {
+          const {
+            service,
+            transformParams,
+            transformRes
+          } = action;
+          const row = originalParams?.row;
+          if (!service || !row && action.selectType !== "multiple" || !row && !selectedRowKeys.value.length && action.selectType === "multiple") {
+            return;
+          }
+          const childrenKey = reProps.value.serviceTableOptions.tree?.childrenKey || qdServiceTableTreeConfig.childrenKey;
+          let delHasChild = false;
+          if (!row) {
+            const rowKey = reProps.value.serviceTableOptions.rowKey || qdCrudTableProps.rowKey;
+            delHasChild = selectedRowKeys.value.some((item) => {
+              const data2 = tableRef.value?.getData(item);
+              if (!data2) return false;
+              const children = data2.row[childrenKey];
+              if (isEmpty(children)) return false;
+              if (children === true) return true;
+              return children.some((child) => !selectedRowKeys.value.includes(child[rowKey]));
+            });
+          } else if (!isEmpty(row[childrenKey])) {
+            delHasChild = true;
+          }
+          if (delHasChild) {
+            alertWarning(t("deleteHasChildrenText"));
+            return;
+          }
+          confirm({
+            body: t("deleteWrapperBodyText"),
+            ...action.wrapper
+          }, async () => {
+            const params = row || selectedRowKeys.value;
+            let currentParams = row ? params[reProps.value.serviceTableOptions.rowKey || qdCrudTableProps.rowKey] : selectedRowKeys.value;
+            if (transformParams) {
+              const [tpErr, tpRes] = await suspectedWrapperPromise(transformParams(easyCopy(params)));
+              if (tpErr) throw tpErr;
+              currentParams = tpRes;
+            }
+            const [serviceErr, serviceRes] = await suspectedWrapperPromise(service(currentParams));
+            if (serviceErr) throw serviceErr;
+            let res;
+            if (transformRes) {
+              const [trErr, trRes] = await suspectedWrapperPromise(transformRes(serviceRes));
+              if (trErr) throw trErr;
+              res = trRes;
+            } else {
+              res = serviceRes;
+            }
+            if (typeof res === "boolean") {
+              res = {
+                success: res,
+                message: ""
+              };
+            }
+            if (!res) {
+              res = {
+                success: true,
+                message: ""
+              };
+            }
+            const message = res.message;
+            if (res.success === false) {
+              if (message) msgError(message);
+              return false;
+            }
+            msgSuccess(message || t("deleteSuccessText"));
+            if (!row) selectedRowKeys.value = [];
+            tableRef.value?.refresh();
+            return true;
+          });
+        };
+        return onClick2;
+      }
+      if (isEmpty(action.form) || !actionIsCRU(action.crudMode)) return;
+      const onClick = async () => {
+        if (!action.uid) action.uid = generateRandomString(16);
+        const uid = action.uid;
+        const form = shallowRef(action.form);
+        if (!dialogFormMap[uid]) {
+          dialogFormMap[uid] = {
+            visible: false,
+            data: {},
+            crudMode: action.crudMode,
+            form
+          };
+        }
+        await nextTick();
+        dialogFormMap[uid].visible = true;
+        if (!action.crudMode || !["edit", "view"].includes(action.crudMode) || !originalParams) {
+          return;
+        }
+        form.value.loading = true;
+        triggerRef(form);
+        const [err, res] = await to(getDetail(originalParams.row));
+        form.value.loading = false;
+        triggerRef(form);
+        if (err) {
+          dialogFormMap[uid].data = originalParams.row;
+          return;
+        }
+        dialogFormMap[uid].data = res;
+      };
+      return onClick;
+    }
+    function buildActionDisabled(action) {
+      if (action.disabled) return action.disabled;
+      switch (action.selectType) {
+        case "single":
+          return selectedRowKeys.value.length !== 1;
+        case "multiple":
+          return selectedRowKeys.value.length === 0;
+        default:
+          return false;
+      }
+    }
+    async function getDetail(params) {
+      const {
+        detailOptions
+      } = reProps.value;
+      if (!detailOptions) return easyCopy(params);
+      const {
+        service,
+        transformParams,
+        transformRes
+      } = detailOptions;
+      if (!service) return easyCopy(params);
+      let currentParams = params[reProps.value.serviceTableOptions.rowKey || qdCrudTableProps.rowKey];
+      if (transformParams) {
+        const [tpErr, tpRes] = await suspectedWrapperPromise(transformParams(easyCopy(params)));
+        if (tpErr) throw tpErr;
+        currentParams = tpRes;
+      }
+      const [serviceErr, serviceRes] = await suspectedWrapperPromise(service(currentParams));
+      if (serviceErr) throw serviceErr;
+      let res;
+      if (transformRes) {
+        const [trErr, trRes] = await suspectedWrapperPromise(transformRes(serviceRes));
+        if (trErr) throw trErr;
+        res = trRes;
+      } else {
+        res = serviceRes;
+      }
+      return res;
+    }
+    function setActionIfRender(compIfRender, action, cellIndex) {
+      const ifRender = compIfRender && hasPermiOr(action.permi, false);
+      if (!cellIndex) {
+        action._ifRender = ifRender;
+        return;
+      }
+      const {
+        colIndex,
+        rowIndex,
+        index
+      } = cellIndex;
+      rowActionsIfRenderMap[`${colIndex}.${rowIndex}.${index}`] = ifRender;
+    }
+    function getActionSeparator(action, cellIndex) {
+      const {
+        index,
+        colIndex,
+        rowIndex
+      } = cellIndex;
+      if (index <= 0) return false;
+      if (isEmpty(colIndex) && isEmpty(rowIndex)) {
+        if (action._ifRender === false) return false;
+        for (let i = index - 1; i >= 0; i--) {
+          const previousAction = reProps.value.actions[i];
+          if (previousAction._ifRender !== false) return true;
+        }
+        return false;
+      }
+      if (rowActionsIfRenderMap[`${colIndex}.${rowIndex}.${index}`] === false) return false;
+      for (let i = index - 1; i >= 0; i--) {
+        const previousIfRender = rowActionsIfRenderMap[`${colIndex}.${rowIndex}.${i}`];
+        if (previousIfRender !== false) return true;
+      }
+      return false;
+    }
+    const expose = {};
+    onMounted(() => {
+      Object.assign(expose, tableRef.value);
+    });
+    __expose(expose);
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", _hoisted_1, [reProps.value.searchOptions?.items?.length ? withDirectives((openBlock(), createBlock(QdCrudSearch, mergeProps({
+        key: 0,
+        ref: "search",
+        data: unref(searchData),
+        "onUpdate:data": _cache[0] || (_cache[0] = ($event) => isRef(searchData) ? searchData.value = $event : null),
+        class: [!searchVisible.value ? "qd-crud-search--hide" : ""]
+      }, reProps.value.searchOptions, {
+        "on-submit": triggerSearch
+      }), createSlots({
+        "form-footer": withCtx(() => [createVNode(unref(Space), {
+          align: "center",
+          size: "small"
+        }, {
+          default: withCtx(() => [createVNode(unref(Button), {
+            type: "submit",
+            onClick: handleSearch
+          }, {
+            default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("searchText")), 1)]),
+            _: 1
+          }), createVNode(unref(Button), {
+            variant: "outline",
+            onClick: handleResetSearch
+          }, {
+            default: withCtx(() => [createTextVNode(toDisplayString(unref(t)("resetText")), 1)]),
+            _: 1
+          })]),
+          _: 1
+        })]),
+        _: 2
+      }, [renderList(unref(extractSlotsWithPrefix)(_ctx.$slots, "search"), (item) => {
+        return {
+          name: item.filterName,
+          fn: withCtx((slotProps) => [renderSlot(_ctx.$slots, item.originalName, normalizeProps(guardReactiveProps(slotProps)), void 0, true)])
+        };
+      })]), 1040, ["data", "class"])), [[vShow, searchVisible.value]]) : createCommentVNode("", true), createVNode(unref(QdCard), {
+        class: "qd-crud-table__body"
+      }, {
+        default: withCtx(() => [createElementVNode("div", _hoisted_2, [createVNode(unref(Space), {
+          align: "center",
+          size: 0
+        }, {
+          default: withCtx(() => [renderSlot(_ctx.$slots, "actions", {}, () => [(openBlock(true), createElementBlock(Fragment, null, renderList(reProps.value.actions, (item, index) => {
+            return openBlock(), createElementBlock(Fragment, {
+              key: item.uid || index
+            }, [getActionSeparator(item, {
+              index
+            }) ? (openBlock(), createElementBlock("span", _hoisted_3)) : createCommentVNode("", true), withDirectives(createVNode(unref(_sfc_main$1), {
+              "fn-inject-ctx": "",
+              context: getConfigRendererCtx(item),
+              config: {
+                is: unref(Button),
+                ...item,
+                form: void 0,
+                onClick: buildActionOnClick(item),
+                disabled: buildActionDisabled(item)
+              },
+              onIfRenderChange: (ifRender) => setActionIfRender(ifRender, item)
+            }, null, 8, ["context", "config", "onIfRenderChange"]), [[unref(vHasPermi), item.permi]])], 64);
+          }), 128))], true)]),
+          _: 3
+        }), createVNode(unref(Space), {
+          align: "center",
+          size: "small"
+        }, {
+          default: withCtx(() => [reProps.value.searchOptions?.items?.length ? (openBlock(), createBlock(unref(Tooltip), {
+            key: 0,
+            content: searchVisible.value ? unref(t)("collapseSearchText") : unref(t)("expandSearchText")
+          }, {
+            default: withCtx(() => [createVNode(unref(Button), {
+              variant: "text",
+              shape: "square",
+              onClick: toggleSearchVisible
+            }, {
+              icon: withCtx(() => [createVNode(unref(SearchIcon))]),
+              _: 1
+            })]),
+            _: 1
+          }, 8, ["content"])) : createCommentVNode("", true), createVNode(unref(Tooltip), {
+            content: unref(t)("refreshText")
+          }, {
+            default: withCtx(() => [createVNode(unref(Button), {
+              variant: "text",
+              shape: "square",
+              onClick: handleRefresh
+            }, {
+              icon: withCtx(() => [createVNode(unref(RefreshIcon))]),
+              _: 1
+            })]),
+            _: 1
+          }, 8, ["content"]), !unref(isEmpty)(reProps.value.serviceTableOptions.tree) && !reProps.value.serviceTableOptions.tree.lazyLoad ? (openBlock(), createBlock(unref(Tooltip), {
+            key: 1,
+            content: treeIsExpand.value ? unref(t)("collapseTreeText") : unref(t)("expandTreeText")
+          }, {
+            default: withCtx(() => [createVNode(unref(Button), {
+              variant: "text",
+              shape: "square",
+              onClick: toggleTreeExpandAll
+            }, {
+              icon: withCtx(() => [treeIsExpand.value ? (openBlock(), createBlock(unref(UnfoldLessIcon), {
+                key: 0
+              })) : (openBlock(), createBlock(unref(UnfoldMoreIcon), {
+                key: 1
+              }))]),
+              _: 1
+            })]),
+            _: 1
+          }, 8, ["content"])) : createCommentVNode("", true), reProps.value.serviceTableOptions.columnController?.hideTriggerButton !== true ? (openBlock(), createBlock(unref(Tooltip), {
+            key: 2,
+            content: unref(t)("columnControllerText")
+          }, {
+            default: withCtx(() => [createVNode(unref(Button), {
+              variant: "text",
+              shape: "square",
+              onClick: openColumnController
+            }, {
+              icon: withCtx(() => [createVNode(unref(SettingIcon))]),
+              _: 1
+            })]),
+            _: 1
+          }, 8, ["content"])) : createCommentVNode("", true)]),
+          _: 1
+        })]), createVNode(unref(QdServiceTable), mergeProps({
+          ref: "table",
+          data: unref(data),
+          "onUpdate:data": _cache[2] || (_cache[2] = ($event) => isRef(data) ? data.value = $event : null),
+          "selected-row-keys": unref(selectedRowKeys),
+          "onUpdate:selectedRowKeys": _cache[3] || (_cache[3] = ($event) => isRef(selectedRowKeys) ? selectedRowKeys.value = $event : null),
+          "active-row-keys": unref(activeRowKeys),
+          "onUpdate:activeRowKeys": _cache[4] || (_cache[4] = ($event) => isRef(activeRowKeys) ? activeRowKeys.value = $event : null),
+          "column-controller-visible": unref(columnControllerVisible),
+          "onUpdate:columnControllerVisible": _cache[5] || (_cache[5] = ($event) => isRef(columnControllerVisible) ? columnControllerVisible.value = $event : null),
+          "display-columns": unref(displayColumns),
+          "onUpdate:displayColumns": _cache[6] || (_cache[6] = ($event) => isRef(displayColumns) ? displayColumns.value = $event : null),
+          "expanded-row-keys": unref(expandedRowKeys),
+          "onUpdate:expandedRowKeys": _cache[7] || (_cache[7] = ($event) => isRef(expandedRowKeys) ? expandedRowKeys.value = $event : null),
+          "filter-value": unref(filterValue),
+          "onUpdate:filterValue": _cache[8] || (_cache[8] = ($event) => isRef(filterValue) ? filterValue.value = $event : null),
+          sort: unref(sort),
+          "onUpdate:sort": _cache[9] || (_cache[9] = ($event) => isRef(sort) ? sort.value = $event : null),
+          "expanded-tree-nodes": unref(expandedTreeNodes),
+          "onUpdate:expandedTreeNodes": _cache[10] || (_cache[10] = ($event) => isRef(expandedTreeNodes) ? expandedTreeNodes.value = $event : null)
+        }, reProps.value.serviceTableOptions), createSlots({
+          operation: withCtx((slotProps) => [renderSlot(_ctx.$slots, "table-operation", normalizeProps(guardReactiveProps(slotProps)), () => [reProps.value.rowActions?.length ? (openBlock(), createBlock(unref(Space), {
+            key: 0,
+            align: "center",
+            size: 0,
+            onClick: _cache[1] || (_cache[1] = withModifiers(() => {
+            }, ["stop"]))
+          }, {
+            default: withCtx(() => [(openBlock(true), createElementBlock(Fragment, null, renderList(reProps.value.rowActions, (item, index) => {
+              return openBlock(), createElementBlock(Fragment, null, [getActionSeparator(item, {
+                colIndex: slotProps.colIndex,
+                rowIndex: slotProps.rowIndex,
+                index
+              }) ? (openBlock(), createBlock(unref(Divider), {
+                key: `${slotProps.colIndex}.${slotProps.rowIndex}.${index}.divider`,
+                layout: "vertical"
+              })) : createCommentVNode("", true), withDirectives((openBlock(), createBlock(unref(_sfc_main$1), {
+                key: `${slotProps.colIndex}.${slotProps.rowIndex}.${index}.renderer`,
+                "fn-inject-ctx": "",
+                context: getConfigRendererCtx(item, slotProps),
+                config: {
+                  is: unref(Link),
+                  ...item,
+                  onClick: buildActionOnClick(item, slotProps)
+                },
+                onIfRenderChange: (ifRender) => setActionIfRender(ifRender, item, {
+                  colIndex: slotProps.colIndex,
+                  rowIndex: slotProps.rowIndex,
+                  index
+                })
+              }, null, 8, ["context", "config", "onIfRenderChange"])), [[unref(vHasPermi), item.permi]])], 64);
+            }), 256))]),
+            _: 2
+          }, 1024)) : createCommentVNode("", true)], true)]),
+          _: 2
+        }, [renderList(unref(extractSlotsWithPrefix)(_ctx.$slots, "table"), (item) => {
+          return {
+            name: item.filterName,
+            fn: withCtx((slotProps) => [renderSlot(_ctx.$slots, item.originalName, normalizeProps(guardReactiveProps(slotProps)), void 0, true)])
+          };
+        })]), 1040, ["data", "selected-row-keys", "active-row-keys", "column-controller-visible", "display-columns", "expanded-row-keys", "filter-value", "sort", "expanded-tree-nodes"])]),
+        _: 3
+      }), (openBlock(true), createElementBlock(Fragment, null, renderList(dialogFormMap, (dialogForm, uid) => {
+        return openBlock(), createBlock(unref(_sfc_main$1), {
+          key: uid,
+          config: {
+            is: unref(_sfc_main$2),
+            ...dialogForm.form,
+            vModelVisible: "self.visible",
+            vModelData: "self.data",
+            crudMode: dialogForm.crudMode
+          },
+          context: getConfigRendererCtx(dialogForm)
+        }, null, 8, ["config", "context"]);
+      }), 128))]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};
+//# sourceMappingURL=table.vue2.mjs.map