@ctzy-web-client/plugin-component-vue 1.0.0 → 1.0.1

package/es/filter-panel/use-filter-panel-item.mjs

@@ -0,0 +1,52 @@
+import { inject, computed, unref, onMounted, onBeforeUnmount } from 'vue';
+import { filterPanelKey } from 'web-base-client-vue';
+
+const useFilterPanelItem = (props) => {
+  const filterPanelContext = inject(filterPanelKey);
+  const filterPanel = computed(() => filterPanelContext.filterPanel);
+  const column = computed(() => {
+    if (!unref(filterPanel)) {
+      return null;
+    }
+    return unref(filterPanel).getColumn(props.prop);
+  });
+  const value = computed({
+    get: () => {
+      if (!unref(column)) {
+        return null;
+      }
+      return unref(filterPanel).getFilterParam(unref(column));
+    },
+    set: (v) => {
+      if (!unref(column)) {
+        return;
+      }
+      unref(filterPanel).setFilterParam(unref(column), v);
+    }
+  });
+  const allowClose = computed(() => {
+    var _a;
+    return props.close || !!((_a = unref(column)) == null ? void 0 : _a.closable);
+  });
+  const closeHandle = () => {
+    if (!unref(column)) {
+      return;
+    }
+    unref(filterPanel).closeColumn(unref(column));
+    unref(filterPanel).dataTable.refresh();
+  };
+  onMounted(() => {
+    unref(filterPanel).changeOriginFilterParams();
+  });
+  onBeforeUnmount(() => {
+    unref(filterPanel).changeOriginFilterParams();
+  });
+  return {
+    value,
+    column,
+    allowClose,
+    closeHandle
+  };
+};
+
+export { useFilterPanelItem };

package/es/filter-panel/use-filter-panel.mjs

@@ -0,0 +1,135 @@
+import { useProp } from 'element-plus';
+import { useService, useEventDispatcher, useValue } from 'web-base-client-vue';
+import { computed, unref, watch, nextTick, onBeforeUnmount, getCurrentInstance, withCtx, resolveComponent } from 'vue';
+import { Observable } from 'rxjs';
+import { dataModelDB } from '../utils/db.mjs';
+
+const useFilterPanel = (props, context) => {
+  var _a;
+  const dataTable = useProp("dataTable");
+  const filterPanel = computed(() => unref(dataTable).filterPanel);
+  const filterPanelTable = dataModelDB.filterPanel;
+  const currentFilterColumns = computed(() => unref(filterPanel).getAppliedColumns());
+  const userService = useService("UserService");
+  const _userID = ((_a = userService == null ? void 0 : userService.userInfo) == null ? void 0 : _a.id) || "0";
+  const searchParams = computed(() => unref(filterPanel)._filterParams);
+  const selectedColumnAttrNames = computed({
+    get: () => unref(filterPanel).getSelectedColumnAttrNames(),
+    set: (v) => {
+      const oldSelectedColumnAttrNames = selectedColumnAttrNames.value;
+      unref(filterPanel).setSelectedColumnAttrNames(v);
+      if (unref(filterPanel).ready) {
+        const existsOldAttrNames = oldSelectedColumnAttrNames.filter((attrName) => v.includes(attrName));
+        if (existsOldAttrNames.length < oldSelectedColumnAttrNames.length) {
+          unref(dataTable).refresh();
+        }
+      }
+    }
+  });
+  const closableColumns = computed(() => unref(filterPanel).getSearchClosableColumns());
+  const searchValue = computed({
+    get: () => unref(filterPanel).getSearchValue(),
+    set: (v) => unref(filterPanel).setSeachValue(v)
+  });
+  const isChange = computed(() => unref(filterPanel).isChange());
+  watch(useProp("searchAttr"), (searchAttr) => {
+    unref(filterPanel).setSearchAttr(searchAttr);
+  }, {
+    immediate: true
+  });
+  watch(useProp("searchFields"), (searchFields) => {
+    unref(filterPanel).setSearchFields(searchFields);
+  }, {
+    immediate: true
+  });
+  const handleFieldSearch = (value) => {
+    unref(filterPanel).fieldSearchValue = value;
+  };
+  const handleReset = () => {
+    unref(filterPanel).resetFilterParams();
+    context.emit("reset");
+  };
+  useEventDispatcher(filterPanel, "params-change", () => {
+    const _filterPanel = unref(filterPanel);
+    context.emit("filter", {
+      ..._filterPanel.getFilterParams(),
+      [_filterPanel.getSearchAttr()]: _filterPanel.getSearchValue()
+    });
+  });
+  const appName = useValue("AppName");
+  const selectedColumnChangeSubscription = new Observable((observer) => useEventDispatcher(filterPanel, "selected-column-change", observer.next.bind(observer))).subscribe(async () => {
+    var _a2;
+    const _appName = unref(appName);
+    const _tableName = unref(dataTable).name;
+    let result = await filterPanelTable.where("[app+tableName+userID]").equals([_appName, _tableName, _userID]).toArray();
+    let filterPanelOrder = result.length ? (_a2 = result[0].order) != null ? _a2 : [] : [];
+    const attrNames = unref(filterPanel).getSelectedColumnAttrNames();
+    attrNames.sort((a1, a2) => {
+      const index1 = filterPanelOrder.indexOf(a1);
+      const index2 = filterPanelOrder.indexOf(a2);
+      if (index1 === -1 && index2 === -1) {
+        return 1;
+      }
+      if (index1 === -1) {
+        return 1;
+      }
+      if (index2 === -1) {
+        return -1;
+      }
+      return index1 - index2;
+    });
+    filterPanelTable.put({
+      app: _appName,
+      tableName: _tableName,
+      userID: _userID,
+      order: attrNames
+    });
+  });
+  const loadFilterPanelItemOrder = () => {
+    filterPanelTable.where("[app+tableName+userID]").equals([unref(appName), unref(dataTable).name, _userID]).toArray((res) => {
+      var _a2, _b;
+      selectedColumnAttrNames.value = (_b = (_a2 = res[0]) == null ? void 0 : _a2.order) != null ? _b : [];
+      nextTick(() => {
+        unref(filterPanel).ready = true;
+        unref(filterPanel).changeOriginFilterParams();
+        unref(filterPanel).changeOriginSearchValue();
+      });
+    });
+  };
+  if (!unref(filterPanel).isInited) {
+    useEventDispatcher(filterPanel, "initCompleted", loadFilterPanelItemOrder);
+  } else {
+    loadFilterPanelItemOrder();
+  }
+  onBeforeUnmount(() => {
+    selectedColumnChangeSubscription.unsubscribe();
+  });
+  const columns = computed(() => unref(filterPanel).getColumns());
+  const instance = getCurrentInstance();
+  watch(computed(() => unref(columns).map((column) => column.componentTitle)), withCtx(() => {
+    for (const column of unref(columns)) {
+      const component = resolveComponent(column.component || "BwaMultipleMenuCondition");
+      if (!component) {
+        unref(column).componentTitle = "";
+        return;
+      }
+      unref(column).componentTitle = component.__conditionTitle__;
+    }
+  }, instance), {
+    immediate: true
+  });
+  return {
+    dataTable,
+    filterPanel,
+    currentFilterColumns,
+    searchParams,
+    selectedColumnAttrNames,
+    closableColumns,
+    handleFieldSearch,
+    searchValue,
+    isChange,
+    handleReset
+  };
+};
+
+export { useFilterPanel };

package/es/hooks/use-data/index.mjs

@@ -0,0 +1,152 @@
+import { useService, HttpRequest, useGlobalConfig, filterPanelItemKey, useEventDispatcher } from 'web-base-client-vue';
+import { useProp, ElMessage } from 'element-plus';
+import { ref, inject, computed, unref, watch, onBeforeUnmount } from 'vue';
+import { Observable, debounceTime, combineLatest, filter, map, tap, from, catchError, of, mergeAll } from 'rxjs';
+import { isEqual } from 'lodash';
+
+const dataProps = {
+  dataTable: {
+    type: Object
+  },
+  itfInfo: {
+    type: Object
+  },
+  labelAttr: {
+    type: String
+  },
+  valueAttr: {
+    type: String
+  },
+  searchAttr: {
+    type: String
+  },
+  lazy: {
+    type: Boolean,
+    default: true
+  }
+};
+function useData(disabled, search) {
+  const httpRequest = useService(HttpRequest);
+  const data = ref([]);
+  const debounceDelay = useGlobalConfig("debounceDelay", 500);
+  const filterPanelItem = inject(filterPanelItemKey, null);
+  const _dataTable = useProp("dataTable");
+  const dataTable = ref(null);
+  const itfInfo = useProp("itfInfo");
+  const _labelAttr = useProp("labelAttr");
+  const labelAttr = computed(() => unref(_labelAttr) || "label");
+  const _valueAttr = useProp("valueAttr");
+  const valueAttr = computed(() => unref(_valueAttr) || "value");
+  const _searchAttr = useProp("searchAttr");
+  const searchAttr = computed(() => unref(_searchAttr) || "search");
+  const lazy = useProp("lazy");
+  const loading = ref(false);
+  const searchAttrObserable = new Observable((observer) => watch(searchAttr, (value, oldValue) => {
+    observer.next([value, oldValue]);
+  }, {
+    immediate: true
+  }));
+  const searchObserable = new Observable((observer) => watch(search, observer.next.bind(observer), {
+    immediate: true
+  })).pipe(debounceTime(unref(debounceDelay)));
+  const searchObservable = combineLatest([searchAttrObserable, searchObserable]).pipe(debounceTime(unref(debounceDelay)), filter(() => !unref(disabled)));
+  const disabledObservable = new Observable((observer) => watch(disabled, observer.next.bind(observer), {
+    immediate: true
+  }));
+  if (unref(_dataTable)) {
+    dataTable.value = unref(_dataTable).clone();
+    const loadDataSubscription = new Observable((observer) => useEventDispatcher(dataTable, "load-successfully", observer.next.bind(observer))).subscribe((res) => {
+      if (res.code != 0) {
+        data.value = [];
+        ElMessage.error(res.msg);
+        return;
+      }
+      data.value = (res.data || []).map((item) => ({
+        value: item[unref(valueAttr)],
+        label: item[unref(labelAttr)]
+      }));
+    });
+    const loadingSubscription = new Observable((observer) => watch(computed(() => unref(dataTable).locking), observer.next.bind(observer), {
+      immediate: true
+    })).subscribe((locking) => {
+      loading.value = locking;
+    });
+    const searchSubscription = searchObservable.subscribe(([[searchAttr2, oldSearchAttr], search2]) => {
+      if (oldSearchAttr) {
+        unref(dataTable).removeParam(oldSearchAttr);
+      }
+      if (searchAttr2) {
+        unref(dataTable).setParam(searchAttr2, search2);
+      }
+      unref(dataTable).refresh();
+    });
+    unref(dataTable).setParam(unref(searchAttr), "");
+    const disabledSubscription = disabledObservable.pipe(filter((disabled2) => !disabled2)).subscribe(() => {
+      unref(dataTable).refresh();
+    });
+    onBeforeUnmount(() => {
+      loadDataSubscription.unsubscribe();
+      loadingSubscription.unsubscribe();
+      searchSubscription.unsubscribe();
+      disabledSubscription.unsubscribe();
+    });
+  } else if (unref(itfInfo)) {
+    const _itfInfo = computed(() => ({
+      url: unref(itfInfo).url,
+      method: unref(itfInfo).method || "POST",
+      options: unref(itfInfo).options || {}
+    }));
+    const inputParamsOberserble = new Observable((observer) => {
+      watch(computed(() => unref(itfInfo).params), (newVal = {}, oldVall) => {
+        if (!isEqual(oldVall, newVal)) {
+          observer.next(newVal);
+        }
+      }, {
+        immediate: true
+      });
+    });
+    const paramsObserable = combineLatest([searchAttrObserable, searchObserable, inputParamsOberserble]).pipe(map(([[searchAttr2], search2, params]) => ({
+      ...params,
+      [searchAttr2]: search2
+    })));
+    let inited = false;
+    const subscription = combineLatest([paramsObserable, disabledObservable]).pipe(tap(() => {
+      loading.value = true;
+    }), debounceTime(unref(debounceDelay)), filter(([_, disabled2]) => {
+      return !inited && !unref(lazy) || !disabled2;
+    }), map(([params]) => ({
+      ...unref(_itfInfo),
+      params
+    })), map(({
+      url,
+      method,
+      params,
+      options
+    }) => from(unref(httpRequest)[method.toLowerCase()](url, params, options)).pipe(catchError(() => of({
+      code: 1,
+      msg: "\u7F51\u7EDC\u5F02\u5E38\uFF01"
+    })))), mergeAll()).subscribe((result) => {
+      try {
+        inited = true;
+        if (result.code != 0) {
+          data.value = [];
+          ElMessage.error(result.msg);
+          return;
+        }
+        data.value = (result.data || []).map((item) => ({
+          value: item[unref(valueAttr)],
+          label: item[unref(labelAttr)]
+        }));
+      } finally {
+        loading.value = false;
+      }
+    });
+    onBeforeUnmount(subscription.unsubscribe.bind(subscription));
+  }
+  return {
+    data,
+    loading
+  };
+}
+
+export { dataProps, useData };

package/es/index.mjs

@@ -0,0 +1,27 @@
+import { makeInstaller } from './make-installer.mjs';
+import components from './components.mjs';
+import plugins from './plugins.mjs';
+export { BwaDataForm, BwaDataFormItem } from './data-form/index.mjs';
+export { BwaDataColumnView, BwaDataTable, BwaDataTableColumn } from './data-table/index.mjs';
+export { BwaFilterPanel, BwaFilterpanelItem } from './filter-panel/index.mjs';
+export { BwaAdvanceOperation, BwaAdvanceOption, BwaAdvanceSelect } from './advance-select/index.mjs';
+export { BwaDateRange } from './date-range/index.mjs';
+export { BwaApplicationSlot, BwaBreadcrumbItem, BwaHeaderToolsItem } from './application-slot/index.mjs';
+export { BwaLayout } from './layout/index.mjs';
+export { BwaMenu } from './menu/index.mjs';
+export { BwaPanel } from './panel/index.mjs';
+export { BwaPanelTab } from './panel-tabs/index.mjs';
+export { BwaContextmenu } from './contextmenu/index.mjs';
+export { BwaBreadcrumbSelect } from './breadcrumb-select/index.mjs';
+export { BwaDataTableSetting } from './datatable-settings/index.mjs';
+export { BwaDraglist } from './drag-list/index.mjs';
+export { BwaProgress, BwaProgressItem } from './progress/index.mjs';
+export { BwaDragable, BwaDragableItem, BwaDragableOperation } from './dragable/index.mjs';
+export { useContextmenu } from './contextmenu/use-contextmenu.mjs';
+
+const install = makeInstaller([...components, ...plugins]);
+var index = {
+  install
+};
+
+export { index as default, install };

package/es/layout/index.mjs

@@ -0,0 +1,6 @@
+import { withInstall } from 'element-plus/es/utils/vue/install';
+import Layout from './layout.mjs';
+
+const BwaLayout = withInstall(Layout);
+
+export { BwaLayout, BwaLayout as default };

package/es/layout/layout.mjs

@@ -0,0 +1,86 @@
+import { defineComponent, computed, unref, resolveComponent, openBlock, createElementBlock, normalizeClass, createVNode, withCtx, renderSlot, createElementVNode } from 'vue';
+import { useRouter } from 'vue-router';
+import { useNamespace, useService } from 'web-base-client-vue';
+import { BwaMenu } from '../menu/index.mjs';
+import _export_sfc from '../_virtual/_plugin-vue_export-helper.mjs';
+
+const __default__ = defineComponent({
+  name: "BwaLayout"
+});
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  setup(__props) {
+    ;
+    const router = useRouter();
+    const ns = useNamespace("layout");
+    const menuService = useService("MenuService");
+    const isCollapsed = computed(() => {
+      var _a, _b;
+      return (_b = (_a = unref(menuService)) == null ? void 0 : _a.isCollapsed) != null ? _b : false;
+    });
+    const menus = computed(() => {
+      var _a, _b;
+      return (_b = (_a = unref(menuService)) == null ? void 0 : _a.getMenus()) != null ? _b : [];
+    });
+    const currentMenuID = computed(
+      () => {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = unref(menuService)) == null ? void 0 : _a.getCurrentMenu()) == null ? void 0 : _b.id) != null ? _c : "";
+      }
+    );
+    const handleSelect = (menu) => {
+      if (!menu) {
+        return;
+      }
+      switch (menu == null ? void 0 : menu.type) {
+        case 0:
+          unref(menuService).setCurrentMenuById(menu.id);
+          router.push(menu.path);
+          break;
+        case 1:
+          let openLink = "";
+          if (path.toLowerCase().indexOf("https://") == 0 || path.toLowerCase().indexOf("http://") == 0) {
+            openLink = path;
+          } else if (path.startsWith("//")) {
+            openLink = location.protocol + path;
+          } else {
+            openLink = path;
+          }
+          window.open(openLink);
+          break;
+      }
+    };
+    return (_ctx, _cache) => {
+      const _component_ElScrollbar = resolveComponent("ElScrollbar");
+      return openBlock(), createElementBlock("div", {
+        class: normalizeClass([unref(ns).b(), "justify-between"])
+      }, [
+        createVNode(_component_ElScrollbar, {
+          class: normalizeClass(unref(ns).e("menu-wrapper")),
+          height: "100%"
+        }, {
+          default: withCtx(() => [
+            renderSlot(_ctx.$slots, "left-panel", {}, () => [
+              createVNode(unref(BwaMenu), {
+                class: normalizeClass(unref(ns).e("menu")),
+                menus: unref(menus),
+                currentMenuID: unref(currentMenuID),
+                collapsed: unref(isCollapsed),
+                onSelect: handleSelect
+              }, null, 8, ["class", "menus", "currentMenuID", "collapsed"])
+            ]),
+            renderSlot(_ctx.$slots, "left-panel-append")
+          ]),
+          _: 3
+        }, 8, ["class"]),
+        createElementVNode("div", {
+          class: normalizeClass(unref(ns).e("main"))
+        }, [
+          renderSlot(_ctx.$slots, "default")
+        ], 2)
+      ], 2);
+    };
+  }
+});
+var Layout = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "layout.vue"]]);
+
+export { Layout as default };

package/es/make-installer.mjs

@@ -0,0 +1,34 @@
+import ElementPlus from 'element-plus';
+import * as icons from '@element-plus/icons';
+import zhCn from 'element-plus/es/locale/lang/zh-cn';
+import { provideGlobalConfig } from 'web-base-client-vue';
+
+const INSTALLED_KEY = Symbol("INSTALLED_KEY");
+const makeInstaller = (components = []) => {
+  const install = (app, options) => {
+    if (app[INSTALLED_KEY]) {
+      return;
+    }
+    app[INSTALLED_KEY] = true;
+    options = {
+      ...options,
+      locale: zhCn
+    };
+    app.use(ElementPlus, options);
+    app.use({
+      install: (app2) => {
+        Object.keys(icons).forEach((key) => app2.component(icons[key].name, icons[key]));
+      }
+    });
+    components.forEach((component) => app.use(component));
+    if (options) {
+      provideGlobalConfig({
+        ...options,
+        namespace: "bwa"
+      }, app, true);
+    }
+  };
+  return install;
+};
+
+export { makeInstaller };

package/es/math/Rectangle.mjs

@@ -0,0 +1,25 @@
+class Rectangle {
+  constructor(x, y, width, height) {
+    if (width < 0) {
+      x = x - (width = -width);
+    }
+    if (height < 0) {
+      y = y - (height = -height);
+    }
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+    this.left = x;
+    this.top = y;
+    this.right = x + width;
+    this.bottom = y + height;
+    this.cx = x + width / 2;
+    this.cy = y + height / 2;
+  }
+  pointIn(x, y) {
+    return x >= this.left && x <= this.right && y >= this.top && y <= this.bottom;
+  }
+}
+
+export { Rectangle };

package/es/menu/index.mjs

@@ -0,0 +1,6 @@
+import { withInstall } from 'element-plus/es/utils/vue/install';
+import Menu from './menu.mjs';
+
+const BwaMenu = withInstall(Menu);
+
+export { BwaMenu, BwaMenu as default };

package/es/menu/menu-item.mjs

@@ -0,0 +1,75 @@
+import { defineComponent, computed, resolveComponent, unref, openBlock, createBlock, withCtx, createElementBlock, normalizeClass, createCommentVNode, createElementVNode, toDisplayString, Fragment, renderList } from 'vue';
+import { useNamespace } from 'web-base-client-vue';
+import _export_sfc from '../_virtual/_plugin-vue_export-helper.mjs';
+
+const __default__ = defineComponent({
+  name: "BwaMenuItem"
+});
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  props: {
+    item: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const ns = useNamespace("menu");
+    const id = computed(() => {
+      if (typeof props.id !== "number" && !props.item.id) {
+        return "";
+      }
+      return props.item.id + "";
+    });
+    const children = computed(() => {
+      var _a;
+      return ((_a = props.item) == null ? void 0 : _a.children) || [];
+    });
+    return (_ctx, _cache) => {
+      const _component_ElMenuItem = resolveComponent("ElMenuItem");
+      const _component_BwaMenuItem = resolveComponent("BwaMenuItem");
+      const _component_ElSubMenu = resolveComponent("ElSubMenu");
+      return !unref(children).length ? (openBlock(), createBlock(_component_ElMenuItem, {
+        key: 0,
+        index: unref(id)
+      }, {
+        default: withCtx(() => [
+          __props.item.iconName ? (openBlock(), createElementBlock("i", {
+            key: 0,
+            class: normalizeClass(["ptp-icon", `ptp-${__props.item.iconName}`])
+          }, null, 2)) : createCommentVNode("v-if", true),
+          createElementVNode("span", {
+            class: normalizeClass(unref(ns).be("item", "content"))
+          }, toDisplayString(__props.item.title), 3)
+        ]),
+        _: 1
+      }, 8, ["index"])) : (openBlock(), createBlock(_component_ElSubMenu, {
+        key: 1,
+        index: unref(id),
+        "popper-class": unref(ns).b("sub")
+      }, {
+        title: withCtx(() => [
+          __props.item.iconName ? (openBlock(), createElementBlock("i", {
+            key: 0,
+            class: normalizeClass(["ptp-icon", `ptp-${__props.item.iconName}`])
+          }, null, 2)) : createCommentVNode("v-if", true),
+          createElementVNode("span", {
+            class: normalizeClass(unref(ns).be("item", "content"))
+          }, toDisplayString(__props.item.title), 3)
+        ]),
+        default: withCtx(() => [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(unref(children), (child) => {
+            return openBlock(), createBlock(_component_BwaMenuItem, {
+              item: child,
+              key: child.id
+            }, null, 8, ["item"]);
+          }), 128))
+        ]),
+        _: 1
+      }, 8, ["index", "popper-class"]));
+    };
+  }
+});
+var MenuItem = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "menu-item.vue"]]);
+
+export { MenuItem as default };

package/es/menu/menu.mjs

@@ -0,0 +1,60 @@
+import { defineComponent, resolveComponent, openBlock, createBlock, normalizeClass, unref, withCtx, createElementBlock, Fragment, renderList } from 'vue';
+import { useNamespace } from 'web-base-client-vue';
+import MenuItem from './menu-item.mjs';
+import _export_sfc from '../_virtual/_plugin-vue_export-helper.mjs';
+
+const __default__ = defineComponent({
+  name: "BwaMenu"
+});
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  props: {
+    currentMenuID: String,
+    menus: {
+      type: Array,
+      default: () => []
+    },
+    collapsed: { type: Boolean, default: false }
+  },
+  emits: ["select"],
+  setup(__props, { emit }) {
+    const props = __props;
+    const ns = useNamespace("menu");
+    const getMenuById = (id) => {
+      const menus = props.menus || [];
+      let list = [...menus];
+      for (let i = 0; i < list.length; i++) {
+        const item = list[i];
+        if (item.id === id) {
+          return item;
+        }
+        list = list.concat(item.children || []);
+      }
+      return null;
+    };
+    const handleSelect = (id) => {
+      emit("select", getMenuById(id));
+    };
+    return (_ctx, _cache) => {
+      const _component_ElMenu = resolveComponent("ElMenu");
+      return openBlock(), createBlock(_component_ElMenu, {
+        "default-active": __props.currentMenuID,
+        class: normalizeClass([unref(ns).b(), __props.collapsed ? unref(ns).m("collapsed") : ""]),
+        collapse: __props.collapsed,
+        onSelect: handleSelect
+      }, {
+        default: withCtx(() => [
+          (openBlock(true), createElementBlock(Fragment, null, renderList(__props.menus, (item) => {
+            return openBlock(), createBlock(MenuItem, {
+              key: item.id,
+              item
+            }, null, 8, ["item"]);
+          }), 128))
+        ]),
+        _: 1
+      }, 8, ["default-active", "class", "collapse"]);
+    };
+  }
+});
+var Menu = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "menu.vue"]]);
+
+export { Menu as default };