hy-dispatch-ui-v3 0.1.6 → 0.2.0

package/lib/components/appTable/cpns/headerItem.vue.js

@@ -0,0 +1,102 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var elementPlus = require('element-plus');
+var iconsVue = require('@element-plus/icons-vue');
+
+const _sfc_main = {
+  __name: "headerItem",
+  props: {
+    type: {
+      type: String,
+      default: "default"
+    },
+    column: {
+      type: Object,
+      default: () => ({})
+    },
+    filterModel: {
+      Object,
+      default: () => ({})
+    }
+  },
+  emits: ["search"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const columnSort = vue.computed(() => {
+      return props.column.sort;
+    });
+    function isSortActive(prop, order) {
+      return props.filterModel.sortBy === prop && props.filterModel.orderSort === order;
+    }
+    function onSortHandler(prop, order) {
+      if (props.filterModel.orderSort === "asc") {
+        if (props.filterModel.sortBy === prop) {
+          if (order) {
+            props.filterModel.orderSort = order === "asc" ? null : order;
+          } else {
+            props.filterModel.orderSort = null;
+            props.filterModel.sortBy = null;
+          }
+        } else {
+          props.filterModel.orderSort = order || "desc";
+          props.filterModel.sortBy = prop;
+        }
+      } else if (props.filterModel.orderSort === "desc") {
+        if (props.filterModel.sortBy === prop) {
+          if (order) {
+            props.filterModel.orderSort = order === "desc" ? null : order;
+          } else {
+            props.filterModel.orderSort = "asc";
+          }
+        } else {
+          props.filterModel.orderSort = order || "desc";
+          props.filterModel.sortBy = prop;
+        }
+      } else {
+        props.filterModel.orderSort = order || "desc";
+        props.filterModel.sortBy = prop;
+      }
+      emits("search");
+    }
+    return (_ctx, _cache) => {
+      return columnSort.value.show ? (vue.openBlock(), vue.createElementBlock("div", {
+        key: 0,
+        class: "w-full relative cursor-pointer",
+        onClick: ($event) => onSortHandler(columnSort.value.prop, null)
+      }, [
+        vue.createElementVNode("div", { class: "flex flex-col absolute top-1/2 -left-1 transform -translate-y-1/2 -translate-x-full" }, [
+          vue.createVNode(vue.unref(elementPlus.ElIcon), {
+            size: "8",
+            color: isSortActive(columnSort.value.prop, "asc") ? "rgba(var(--hy-theme))" : "rgba(var(--hy-auxiliary))",
+            onClick: vue.withModifiers(($event) => onSortHandler(columnSort.value.prop, "asc"), ["stop"])
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(iconsVue.ArrowUpBold))
+            ]),
+            _: 1
+            /* STABLE */
+          }, 8, ["color", "onClick"]),
+          vue.createVNode(vue.unref(elementPlus.ElIcon), {
+            size: "8",
+            color: isSortActive(columnSort.value.prop, "desc") ? "rgba(var(--hy-theme))" : "rgba(var(--hy-auxiliary))",
+            class: "-mt-0.5",
+            onClick: vue.withModifiers(($event) => onSortHandler(columnSort.value.prop, "desc"), ["stop"])
+          }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(iconsVue.ArrowDownBold))
+            ]),
+            _: 1
+            /* STABLE */
+          }, 8, ["color", "onClick"])
+        ]),
+        vue.renderSlot(_ctx.$slots, "default")
+      ], 8, ["onClick"])) : vue.renderSlot(_ctx.$slots, "default", { key: 1 });
+    };
+  }
+};
+
+exports.default = _sfc_main;

package/lib/components/appTable/cpns/virtualTable.vue.js

@@ -0,0 +1,564 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var elementPlus = require('element-plus');
+var iconsVue = require('@element-plus/icons-vue');
+var index = require('../js/index.js');
+var headerItem = require('./headerItem.vue.js');
+var index$2 = require('../../appIcon/index.js');
+var useLocale = require('../../../hooks/useLocale.js');
+var is = require('../../../utils/is.js');
+var index$1 = require('../../appTooltip/index.js');
+
+const _sfc_main = {
+  __name: "virtualTable",
+  props: {
+    rowKey: {
+      type: [String, Number]
+    },
+    width: {
+      type: Number
+    },
+    height: {
+      type: Number
+    },
+    data: {
+      type: Array,
+      default: () => []
+    },
+    columns: {
+      type: Array,
+      default: () => []
+    },
+    columnsEditable: {
+      type: Object,
+      default: () => ({})
+    },
+    showHeader: {
+      type: Boolean,
+      default: true
+    },
+    isShowAllSelect: {
+      type: Boolean,
+      default: true
+    },
+    filterModel: {
+      type: Object,
+      default: () => ({})
+    },
+    onRowClick: {
+      type: Function
+    },
+    onRowContextmenu: {
+      type: Function
+    }
+  },
+  emits: ["search", "select", "select-all"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { t } = useLocale.useLocale();
+    const expandedKeys = vue.ref([]);
+    const expandedMap = vue.computed(() => {
+      return expandedKeys.value.reduce((keyMap, key, index) => {
+        keyMap.set(key, index);
+        return keyMap;
+      }, /* @__PURE__ */ new Map());
+    });
+    const avgWidth = vue.computed(() => {
+      const { total, totalWidth } = props.columns.reduce(
+        ({ total: total2, totalWidth: totalWidth2 }, column) => {
+          if (props.columnsEditable[column.prop]?.checked) {
+            if (is.isNumber(column.width) && column.width > 0) {
+              totalWidth2 += column.width;
+            } else {
+              total2++;
+            }
+          }
+          return { total: total2, totalWidth: totalWidth2 };
+        },
+        { total: 0, totalWidth: 0 }
+      );
+      if (totalWidth >= props.width) return 80;
+      const avg = Math.floor((props.width - totalWidth) / total);
+      return avg < 80 ? 80 : avg;
+    });
+    const tableColumns = vue.computed(() => {
+      return props.columns.filter((column) => {
+        return props.columnsEditable[column.prop]?.checked;
+      }).map((column) => {
+        return { ...column, width: column.width || avgWidth.value };
+      });
+    });
+    const selectionColumn = vue.computed(() => {
+      return props.columns.find((item) => item.type === "selection");
+    });
+    const expandColumn = vue.computed(() => {
+      return props.columns.find((item) => item.type === "expand");
+    });
+    const isExpandTable = vue.computed(() => {
+      return expandColumn.value?.expandType === "expand";
+    });
+    const dataSource = vue.computed(() => {
+      if (!isExpandTable.value) return props.data;
+      return props.data.map((item) => ({
+        ...item,
+        children: item.children?.length ? item.children : [{ id: /* @__PURE__ */ Symbol("expandKey"), rowType: "expand" }]
+      }));
+    });
+    const dataSourceMap = vue.computed(() => {
+      return generateDataSourceMap(dataSource.value);
+    });
+    function getRowKey(row) {
+      return row[props.rowKey];
+    }
+    function generateDataSourceMap(list, dataMap = /* @__PURE__ */ new Map()) {
+      return (list || []).reduce((dataMap2, data) => {
+        if (data.children) {
+          generateDataSourceMap(data.children, dataMap2);
+        }
+        if (data?.rowType !== "expand") {
+          dataMap2.set(getRowKey(data), data);
+        }
+        return dataMap2;
+      }, dataMap);
+    }
+    function columnIndexHandler({ column, row, $index, cellIndex }) {
+      if (is.isFunction(column.index)) {
+        return column.index($index);
+      }
+      return $index + 1;
+    }
+    function onRowClickHandler(options) {
+      options = is.isArray(options)[0] ? options[0] : options;
+      if (!options) return;
+      const { rowData: row, event } = options;
+      const target = event?.target;
+      const classList = [
+        ...target?.classList || [],
+        ...target?.parentNode?.classList || [],
+        ...target?.parentNode?.parentNode?.classList || []
+      ];
+      if (classList.some((item) => item === "hy-el-table-v2__expand-icon")) {
+        return;
+      }
+      if (row.rowType === "expand") return;
+      if (!props.onRowClick) return;
+      props.onRowClick(row, void 0, event);
+    }
+    function onContextmenuHandler(options) {
+      options = is.isArray(options)[0] ? options[0] : options;
+      if (!options) return;
+      const { rowData: row, event } = options;
+      if (row.rowType === "expand") return;
+      if (!props.onRowContextmenu) return;
+      props.onRowContextmenu(row, void 0, event);
+    }
+    const isAllChecked = vue.ref(false);
+    const selectedMap = vue.ref(/* @__PURE__ */ new Map());
+    const indeterminateKeys = vue.ref(/* @__PURE__ */ new Set());
+    function isSelectable(row) {
+      const column = selectionColumn.value;
+      if (!is.isFunction(column?.selectable)) return true;
+      return column.selectable(row);
+    }
+    function switchCheckHandler(row) {
+      if (!isSelectable(row)) return;
+      toggleRowSelection(row);
+      emits("select", Array.from(selectedMap.value.values()), row);
+    }
+    function toggleRowSelection(row, selected) {
+      const key = getRowKey(row);
+      if (!dataSourceMap.value.has(key)) {
+        throw Error(`toggleRowSelection\uFF1A\u627E\u4E0D\u5230\u3010${getRowKey(row)}\u3011`);
+      }
+      const checkedNodeMap = new Map(selectedMap.value);
+      const isChecked = is.isBoolean(selected) ? selected : !checkedNodeMap.has(key);
+      const toggle = (node, checked) => {
+        const nodeKey = getRowKey(node);
+        if (isSelectable(node)) {
+          if (checked) {
+            checkedNodeMap.set(nodeKey, node);
+          } else {
+            checkedNodeMap.delete(nodeKey);
+          }
+        }
+        const children = node.children;
+        if (children) {
+          children.forEach((childNode) => {
+            toggle(childNode, checked);
+          });
+        }
+      };
+      toggle(row, isChecked);
+      const result = generateIndeterminate(dataSource.value, checkedNodeMap);
+      isAllChecked.value = result.allChecked;
+      selectedMap.value = result.checkedNodeMap;
+      indeterminateKeys.value = result.indeterminateKeys;
+    }
+    function toggleAllSelection() {
+      if (isAllChecked.value) {
+        isAllChecked.value = false;
+        selectedMap.value.clear();
+      } else {
+        let checkedNodeMap = /* @__PURE__ */ new Map();
+        isAllChecked.value = true;
+        for (let [key, value] of dataSourceMap.value) {
+          if (isSelectable(value)) {
+            checkedNodeMap.set(key, value);
+          }
+        }
+        selectedMap.value = checkedNodeMap;
+      }
+      indeterminateKeys.value.clear();
+      emits("select-all", Array.from(selectedMap.value.values()));
+    }
+    function generateIndeterminate(list, checkedNodeMap = /* @__PURE__ */ new Map()) {
+      const handler = (list2, checkedNodeMap2 = /* @__PURE__ */ new Map(), indeterminateKeys3 = /* @__PURE__ */ new Set()) => {
+        let allChecked2 = true, hasChecked = false;
+        for (let i = 0; i < list2.length; i++) {
+          const node = list2[i];
+          const nodeKey = getRowKey(node);
+          if (node.children?.length) {
+            const result = handler(node.children, checkedNodeMap2, indeterminateKeys3);
+            if (isSelectable(node)) {
+              allChecked2 = allChecked2 && result.allChecked;
+              hasChecked = hasChecked || result.hasChecked;
+              if (result.allChecked) {
+                checkedNodeMap2.set(nodeKey, node);
+              } else {
+                checkedNodeMap2.delete(nodeKey, node);
+                if (result.hasChecked) {
+                  indeterminateKeys3.add(nodeKey);
+                }
+              }
+            }
+          } else {
+            const isChecked = checkedNodeMap2.has(nodeKey);
+            allChecked2 = allChecked2 && isChecked;
+            hasChecked = hasChecked || isChecked;
+          }
+        }
+        return { allChecked: allChecked2, hasChecked };
+      };
+      const indeterminateKeys2 = /* @__PURE__ */ new Set();
+      const { allChecked } = handler(list, checkedNodeMap, indeterminateKeys2);
+      return { checkedNodeMap, indeterminateKeys: indeterminateKeys2, allChecked };
+    }
+    __expose({
+      toggleRowSelection,
+      toggleAllSelection,
+      toggleRowExpansion(row, expanded) {
+        const index = expandedMap.value.get(getRowKey(row));
+        const isExpanded = is.isBoolean(expanded) ? expanded : !is.isNumber(index);
+        if (isExpanded) {
+          if (!is.isNumber(index)) {
+            expandedKeys.value.push(getRowKey(row));
+          }
+        } else {
+          if (is.isNumber(index)) {
+            expandedKeys.value.splice(index, 1);
+          }
+        }
+      },
+      clearSelection: () => {
+        isAllChecked.value = false;
+        selectedMap.value.clear();
+        indeterminateKeys.value.clear();
+      }
+    });
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElTableV2), {
+        "expanded-row-keys": expandedKeys.value,
+        "onUpdate:expandedRowKeys": ($event) => expandedKeys.value = $event,
+        "row-key": __props.rowKey,
+        data: dataSource.value,
+        columns: tableColumns.value,
+        width: __props.width,
+        height: __props.height,
+        "header-height": __props.showHeader ? 44 : 0,
+        "expand-column-key": expandColumn.value?.key,
+        fixed: "",
+        "row-event-handlers": {
+          onClick: onRowClickHandler,
+          onContextmenu: onContextmenuHandler
+        }
+      }, {
+        "header-cell": vue.withCtx(({ column, columnIndex: $index }) => [
+          vue.createVNode(headerItem.default, {
+            type: "virtual",
+            column,
+            "filter-model": __props.filterModel,
+            onSearch: () => emits("search")
+          }, {
+            default: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, column.headerSlot, vue.normalizeProps(vue.guardReactiveProps({ column, $index })), () => [
+                column.type === "selection" ? (vue.openBlock(), vue.createElementBlock(
+                  vue.Fragment,
+                  { key: 0 },
+                  [
+                    __props.isShowAllSelect ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElCheckbox), {
+                      key: 0,
+                      "model-value": isAllChecked.value,
+                      indeterminate: !isAllChecked.value && !!selectedMap.value.size,
+                      onClick: vue.withModifiers(toggleAllSelection, ["stop"])
+                    }, null, 8, ["model-value", "indeterminate"])) : vue.createCommentVNode("v-if", true)
+                  ],
+                  64
+                  /* STABLE_FRAGMENT */
+                )) : !vue.unref(is.isEmpty)(vue.unref(index.renderHeaderHandler)(column, { column, $index })) ? (vue.openBlock(), vue.createBlock(vue.unref(index$1.AppTooltip), {
+                  key: 1,
+                  "over-line": 1,
+                  content: vue.unref(index.renderHeaderHandler)(column, { column, $index })
+                }, null, 8, ["content"])) : vue.createCommentVNode("v-if", true)
+              ])
+            ]),
+            _: 2
+            /* DYNAMIC */
+          }, 1032, ["column", "filter-model", "onSearch"])
+        ]),
+        cell: vue.withCtx(({ column, columnIndex: cellIndex, rowData: row, rowIndex: $index }) => [
+          column.type === "expand" && isExpandTable.value ? (vue.openBlock(), vue.createElementBlock(
+            vue.Fragment,
+            { key: 0 },
+            [],
+            64
+            /* STABLE_FRAGMENT */
+          )) : column.type === "selection" ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElCheckbox), {
+            key: 1,
+            "model-value": selectedMap.value.has(getRowKey(row)),
+            indeterminate: indeterminateKeys.value.has(getRowKey(row)),
+            disabled: !isSelectable(row),
+            onClick: vue.withModifiers(($event) => switchCheckHandler(row), ["stop"])
+          }, null, 8, ["model-value", "indeterminate", "disabled", "onClick"])) : column?.slot ? vue.renderSlot(_ctx.$slots, column?.slot, vue.normalizeProps(vue.mergeProps({ key: 2 }, { column, row, $index, cellIndex }))) : column.type === "index" ? (vue.openBlock(), vue.createElementBlock(
+            vue.Fragment,
+            { key: 3 },
+            [
+              vue.createTextVNode(
+                vue.toDisplayString(columnIndexHandler({ column, row, $index, cellIndex })),
+                1
+                /* TEXT */
+              )
+            ],
+            64
+            /* STABLE_FRAGMENT */
+          )) : column.type === "operator" ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 4,
+            class: "w-full flex items-center justify-between text-main",
+            onClick: vue.withModifiers(() => {
+            }, ["stop"]),
+            onContextmenu: vue.withModifiers(() => {
+            }, ["stop"])
+          }, [
+            (vue.openBlock(true), vue.createElementBlock(
+              vue.Fragment,
+              null,
+              vue.renderList(vue.unref(index.operatorFilterHandler)(
+                column,
+                { column, row, $index, cellIndex },
+                "default"
+              ), (citem, cindex) => {
+                return vue.openBlock(), vue.createBlock(vue.unref(index$1.AppTooltip), {
+                  key: cindex,
+                  "is-always": "",
+                  content: citem.label
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createElementVNode("div", {
+                      class: vue.normalizeClass(["w-[40px] h-[48px] inline-flex flex-col items-center justify-center text-xs hover:font-bold border border-transparent hover:border-theme hover:shadow-[0px_0px_5px_0px_rgba(var(--hy-theme),0.5)] rounded box-border cursor-pointer", citem.className]),
+                      onClick: ($event) => vue.unref(index.operatorClickHandler)(
+                        cindex,
+                        column,
+                        { column, row, $index, cellIndex },
+                        "default"
+                      )
+                    }, [
+                      vue.createVNode(vue.unref(index$2.AppIcon), {
+                        "svg-name": citem.svgName,
+                        "class-name": "!w-4 !h-4"
+                      }, null, 8, ["svg-name"]),
+                      citem.subLabel ? (vue.openBlock(), vue.createElementBlock(
+                        "div",
+                        {
+                          key: 0,
+                          class: "mt-1 whitespace-nowrap"
+                        },
+                        vue.toDisplayString(citem.subLabel),
+                        1
+                        /* TEXT */
+                      )) : (vue.openBlock(), vue.createElementBlock("div", {
+                        key: 1,
+                        class: "mt-1 whitespace-nowrap"
+                      }, "\xA0"))
+                    ], 10, ["onClick"])
+                  ]),
+                  _: 2
+                  /* DYNAMIC */
+                }, 1032, ["content"]);
+              }),
+              128
+              /* KEYED_FRAGMENT */
+            )),
+            vue.unref(index.operatorFilterHandler)(
+              column,
+              { column, row, $index, cellIndex },
+              "more"
+            )?.length ? (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElDropdown), {
+              key: 0,
+              ref: "operatorDropdownRef",
+              trigger: "click",
+              "popper-style": "min-width: 150px",
+              placement: "bottom",
+              onCommand: ($event) => vue.unref(index.operatorClickHandler)(
+                $event,
+                column,
+                { column, row, $index, cellIndex },
+                "more"
+              )
+            }, {
+              dropdown: vue.withCtx(() => [
+                vue.createVNode(
+                  vue.unref(elementPlus.ElDropdownMenu),
+                  null,
+                  {
+                    default: vue.withCtx(() => [
+                      (vue.openBlock(true), vue.createElementBlock(
+                        vue.Fragment,
+                        null,
+                        vue.renderList(vue.unref(index.operatorFilterHandler)(
+                          column,
+                          { column, row, $index, cellIndex },
+                          "more"
+                        ), (citem, cindex) => {
+                          return vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElDropdownItem), {
+                            key: cindex,
+                            command: cindex,
+                            disabled: vue.unref(index.operatorDisabledHandler)(citem, {
+                              column,
+                              row,
+                              $index,
+                              cellIndex
+                            })
+                          }, {
+                            default: vue.withCtx(() => [
+                              vue.createElementVNode("span", null, [
+                                vue.createElementVNode(
+                                  "span",
+                                  null,
+                                  vue.toDisplayString(citem.label),
+                                  1
+                                  /* TEXT */
+                                ),
+                                vue.unref(index.operatorDisabledHandler)(citem, {
+                                  column,
+                                  row,
+                                  $index,
+                                  cellIndex
+                                }) ? (vue.openBlock(), vue.createElementBlock(
+                                  "span",
+                                  {
+                                    key: 0,
+                                    class: "text-xs leading-1"
+                                  },
+                                  "\uFF08" + vue.toDisplayString(vue.unref(index.operatorDisableTextdHandler)(citem, {
+                                    column,
+                                    row,
+                                    $index,
+                                    cellIndex
+                                  })) + "\uFF09",
+                                  1
+                                  /* TEXT */
+                                )) : vue.createCommentVNode("v-if", true)
+                              ])
+                            ]),
+                            _: 2
+                            /* DYNAMIC */
+                          }, 1032, ["command", "disabled"]);
+                        }),
+                        128
+                        /* KEYED_FRAGMENT */
+                      ))
+                    ]),
+                    _: 2
+                    /* DYNAMIC */
+                  },
+                  1024
+                  /* DYNAMIC_SLOTS */
+                )
+              ]),
+              default: vue.withCtx(() => [
+                vue.createElementVNode("span", null, [
+                  vue.createVNode(vue.unref(index$1.AppTooltip), {
+                    "is-always": "",
+                    content: vue.unref(t)("table.moreOperations")
+                  }, {
+                    default: vue.withCtx(() => [
+                      vue.createElementVNode("div", { class: "w-[40px] h-[48px] inline-flex flex-col items-center justify-center text-main text-xs hover:font-bold border border-transparent hover:border-theme hover:shadow-[0px_0px_5px_0px_rgba(var(--hy-theme),0.5)] rounded box-border cursor-pointer" }, [
+                        vue.createElementVNode("div", { class: "w-4 h-4" }, [
+                          vue.createVNode(vue.unref(elementPlus.ElIcon), {
+                            size: "16",
+                            color: "rgba(var(--hy-main))"
+                          }, {
+                            default: vue.withCtx(() => [
+                              vue.createVNode(vue.unref(iconsVue.MoreFilled))
+                            ]),
+                            _: 1
+                            /* STABLE */
+                          })
+                        ]),
+                        vue.createElementVNode(
+                          "div",
+                          { class: "mt-1" },
+                          vue.toDisplayString(vue.unref(t)("table.more")),
+                          1
+                          /* TEXT */
+                        )
+                      ])
+                    ]),
+                    _: 1
+                    /* STABLE */
+                  }, 8, ["content"])
+                ])
+              ]),
+              _: 2
+              /* DYNAMIC */
+            }, 1032, ["onCommand"])) : vue.createCommentVNode("v-if", true)
+          ], 40, ["onClick", "onContextmenu"])) : ["default", "expand"].includes(column.type) ? (vue.openBlock(), vue.createElementBlock(
+            vue.Fragment,
+            { key: 5 },
+            [
+              !vue.unref(is.isEmpty)(
+                vue.unref(index.renderContentHandler)(column, { column, row, $index, cellIndex })
+              ) ? (vue.openBlock(), vue.createBlock(vue.unref(index$1.AppTooltip), {
+                key: 0,
+                "over-line": 2,
+                content: vue.unref(index.renderContentHandler)(column, { column, row, $index, cellIndex })
+              }, null, 8, ["content"])) : (vue.openBlock(), vue.createElementBlock("span", {
+                key: 1,
+                class: "text-auxiliary"
+              }, "- -"))
+            ],
+            64
+            /* STABLE_FRAGMENT */
+          )) : vue.createCommentVNode("v-if", true)
+        ]),
+        row: vue.withCtx(({ cells, depth, expanded, rowData: row }) => [
+          depth > 0 && isExpandTable.value ? vue.renderSlot(_ctx.$slots, expandColumn.value.slot, {
+            key: 0,
+            row,
+            expanded: expandedMap.value.has(getRowKey(row))
+          }) : (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(() => cells), { key: 1 }))
+        ]),
+        empty: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "empty")
+        ]),
+        _: 3
+        /* FORWARDED */
+      }, 8, ["expanded-row-keys", "onUpdate:expandedRowKeys", "row-key", "data", "columns", "width", "height", "header-height", "expand-column-key", "row-event-handlers"]);
+    };
+  }
+};
+
+exports.default = _sfc_main;