@fmdeui/fmui 1.0.1

package/es/packages/router/backEnd.mjs

@@ -0,0 +1,93 @@
+import pinia from '../stores/inpinia.mjs';
+import { useUserInfo } from '../stores/userInfo.mjs';
+import { useRequestOldRoutes } from '../stores/requestOldRoutes.mjs';
+import { Session } from '../utils/storage.mjs';
+import { NextLoading } from '../utils/loading.mjs';
+import { useRoutesList } from '../stores/routesList.mjs';
+import { useTagsViewRoutes } from '../stores/tagsViewRoutes.mjs';
+import { dynamicRoutes, notFoundAndNoPower } from './route.mjs';
+import { formatTwoStageRoutes, formatFlatteningRoutes } from './utils.mjs';
+import { router } from './createRouter.mjs';
+import '../api/index.mjs';
+import { useSysApi } from '../api/sys/index.mjs';
+
+const import_meta = {};
+let dynamicViewsModules = {};
+function setDynamicViewsModules(modules) {
+  dynamicViewsModules = modules;
+}
+function initDynamicViewsModules() {
+  try {
+    const layouModules = import_meta.glob("../layout/routerView/*.{vue,tsx}");
+    const viewsModules = import_meta.glob("../views/**/*.{vue,tsx}");
+    dynamicViewsModules = Object.assign({}, { ...layouModules }, { ...viewsModules });
+  } catch (error) {
+    dynamicViewsModules = {};
+  }
+}
+initDynamicViewsModules();
+async function initBackEndControlRoutes() {
+  if (window.nextLoading === void 0) NextLoading.start();
+  if (!Session.get("token")) return false;
+  await useUserInfo().setUserInfos();
+  await useUserInfo().setConstList();
+  await useUserInfo().setDictList();
+  const res = await getBackEndControlRoutes();
+  if (res == void 0 || res.length <= 0) return Promise.resolve(true);
+  useRequestOldRoutes().setRequestOldRoutes(res);
+  dynamicRoutes[0].children = await backEndComponent(res);
+  await setAddRoute();
+  setFilterMenuAndCacheTagsViewRoutes();
+}
+async function setFilterMenuAndCacheTagsViewRoutes() {
+  const storesRoutesList = useRoutesList(pinia);
+  storesRoutesList.setRoutesList(dynamicRoutes[0].children);
+  setCacheTagsViewRoutes();
+}
+function setCacheTagsViewRoutes() {
+  const storesTagsView = useTagsViewRoutes(pinia);
+  storesTagsView.setTagsViewRoutes(formatTwoStageRoutes(formatFlatteningRoutes(dynamicRoutes))[0].children);
+}
+function setFilterRouteEnd() {
+  let filterRouteEnd = formatTwoStageRoutes(formatFlatteningRoutes(dynamicRoutes));
+  filterRouteEnd[0].children = [...filterRouteEnd[0].children, ...notFoundAndNoPower];
+  return filterRouteEnd;
+}
+async function setAddRoute() {
+  await setFilterRouteEnd().forEach((route) => {
+    router.addRoute(route);
+  });
+}
+async function getBackEndControlRoutes() {
+  var res = await useSysApi().getMenuTree();
+  let resData = res.data.result;
+  return resData;
+}
+async function setBackEndControlRefreshRoutes() {
+  await getBackEndControlRoutes();
+}
+function backEndComponent(routes) {
+  if (!routes) return;
+  return routes.map((item) => {
+    if (!item.path) item.path = "";
+    if (item.component) item.component = dynamicImport(dynamicViewsModules, item.component);
+    item.children && backEndComponent(item.children);
+    return item;
+  });
+}
+function dynamicImport(dynamicViewsModules2, component) {
+  const keys = Object.keys(dynamicViewsModules2);
+  const matchKeys = keys.filter((key) => {
+    const k = key.replace(/..\/views|../, "");
+    return k.startsWith(`${component}`) || k.startsWith(`/${component}`);
+  });
+  if ((matchKeys == null ? void 0 : matchKeys.length) === 1) {
+    const matchKey = matchKeys[0];
+    return dynamicViewsModules2[matchKey];
+  }
+  if ((matchKeys == null ? void 0 : matchKeys.length) > 1) {
+    return false;
+  }
+}
+
+export { backEndComponent, dynamicImport, getBackEndControlRoutes, initBackEndControlRoutes, setAddRoute, setBackEndControlRefreshRoutes, setCacheTagsViewRoutes, setDynamicViewsModules, setFilterMenuAndCacheTagsViewRoutes, setFilterRouteEnd };

package/es/packages/router/createRouter.mjs

@@ -0,0 +1,15 @@
+import { createRouter, createWebHashHistory } from 'vue-router';
+import { notFoundAndNoPower, staticRoutes } from './route.mjs';
+
+const router = createRouter({
+  history: createWebHashHistory(),
+  /**
+   * 说明：
+   * 1、notFoundAndNoPower 默认添加 404、401 界面，防止一直提示 No match found for location with path 'xxx'
+   * 2、backEnd.ts(后端控制路由)、frontEnd.ts(前端控制路由) 中也需要加 notFoundAndNoPower 404、401 界面。
+   *    防止 404、401 不在 layout 布局中，不设置的话，404、401 界面将全屏显示
+   */
+  routes: [...notFoundAndNoPower, ...staticRoutes]
+});
+
+export { router };

package/es/packages/router/frontEnd.mjs

@@ -0,0 +1,80 @@
+import { storeToRefs } from 'pinia';
+import { formatTwoStageRoutes, formatFlatteningRoutes } from './utils.mjs';
+import { dynamicRoutes, notFoundAndNoPower } from './route.mjs';
+import pinia from '../stores/inpinia.mjs';
+import { Session } from '../utils/storage.mjs';
+import { useUserInfo } from '../stores/userInfo.mjs';
+import { useTagsViewRoutes } from '../stores/tagsViewRoutes.mjs';
+import { useRoutesList } from '../stores/routesList.mjs';
+import { NextLoading } from '../utils/loading.mjs';
+import { router } from './createRouter.mjs';
+
+async function initFrontEndControlRoutes() {
+  if (window.nextLoading === void 0) NextLoading.start();
+  if (!Session.get("token")) return false;
+  await useUserInfo(pinia).setUserInfos();
+  await setAddRoute();
+  setFilterMenuAndCacheTagsViewRoutes();
+}
+async function setAddRoute() {
+  await setFilterRouteEnd().forEach((route) => {
+    router.addRoute(route);
+  });
+}
+async function frontEndsResetRoute() {
+  await setFilterRouteEnd().forEach((route) => {
+    const routeName = route.name;
+    router.hasRoute(routeName) && router.removeRoute(routeName);
+  });
+}
+function setFilterRouteEnd() {
+  let filterRouteEnd = formatTwoStageRoutes(formatFlatteningRoutes(dynamicRoutes));
+  filterRouteEnd[0].children = [...setFilterRoute(filterRouteEnd[0].children), ...notFoundAndNoPower];
+  return filterRouteEnd;
+}
+function setFilterRoute(chil) {
+  const stores = useUserInfo(pinia);
+  const { userInfos } = storeToRefs(stores);
+  let filterRoute = [];
+  chil.forEach((route) => {
+    if (route.meta.roles) {
+      route.meta.roles.forEach((metaRoles) => {
+        userInfos.value.roles.forEach((roles) => {
+          if (metaRoles === roles) filterRoute.push({ ...route });
+        });
+      });
+    }
+  });
+  return filterRoute;
+}
+function setCacheTagsViewRoutes() {
+  const stores = useUserInfo(pinia);
+  const storesTagsView = useTagsViewRoutes(pinia);
+  const { userInfos } = storeToRefs(stores);
+  let rolesRoutes = setFilterHasRolesMenu(dynamicRoutes, userInfos.value.roles);
+  storesTagsView.setTagsViewRoutes(formatTwoStageRoutes(formatFlatteningRoutes(rolesRoutes))[0].children);
+}
+function setFilterMenuAndCacheTagsViewRoutes() {
+  const stores = useUserInfo(pinia);
+  const storesRoutesList = useRoutesList(pinia);
+  const { userInfos } = storeToRefs(stores);
+  storesRoutesList.setRoutesList(setFilterHasRolesMenu(dynamicRoutes[0].children, userInfos.value.roles));
+  setCacheTagsViewRoutes();
+}
+function hasRoles(roles, route) {
+  if (route.meta && route.meta.roles) return roles.some((role) => route.meta.roles.includes(role));
+  else return true;
+}
+function setFilterHasRolesMenu(routes, roles) {
+  const menu = [];
+  routes.forEach((route) => {
+    const item = { ...route };
+    if (hasRoles(roles, item)) {
+      if (item.children) item.children = setFilterHasRolesMenu(item.children, roles);
+      menu.push(item);
+    }
+  });
+  return menu;
+}
+
+export { frontEndsResetRoute, hasRoles, initFrontEndControlRoutes, setAddRoute, setCacheTagsViewRoutes, setFilterHasRolesMenu, setFilterMenuAndCacheTagsViewRoutes, setFilterRoute, setFilterRouteEnd };

package/es/packages/router/index.mjs

@@ -0,0 +1,63 @@
+import { storeToRefs } from 'pinia';
+import { useRoutesList } from '../stores/routesList.mjs';
+import { useThemeConfig } from '../stores/themeConfig.mjs';
+import { Session, Local } from '../utils/storage.mjs';
+export { configureRoutes, setPathPrefix } from './route.mjs';
+import { initFrontEndControlRoutes } from './frontEnd.mjs';
+import { initBackEndControlRoutes } from './backEnd.mjs';
+export { setDynamicViewsModules } from './backEnd.mjs';
+import { clearTokens } from '../utils/request.mjs';
+import { router } from './createRouter.mjs';
+import NProgress from 'nprogress';
+import '../../node_modules/.pnpm/nprogress@0.2.0/node_modules/nprogress/nprogress.css.mjs';
+import pinia from '../stores/inpinia.mjs';
+
+const storesThemeConfig = useThemeConfig(pinia);
+const { themeConfig } = storeToRefs(storesThemeConfig);
+const { isRequestRoutes } = themeConfig.value;
+const routeStores = useRoutesList();
+router.beforeEach(async (to, from) => {
+  NProgress.configure({ showSpinner: false });
+  routeStores.setCurrentRoute(to);
+  if (to.meta.title) NProgress.start();
+  const token = window.location.hash.startsWith("#/login") && to.query.token ? void 0 : Session.get("token");
+  if (to.meta.isPublic && !token) {
+    NProgress.done();
+    return;
+  } else {
+    if (!token) {
+      var routeLocation = `/login?redirect=${to.path}&params=${JSON.stringify(to.query ? to.query : to.params)}`;
+      var tenantid = Number(Local.get("tid"));
+      if (!isNaN(tenantid) && tenantid > 99999) routeLocation += `&tid=${tenantid}`;
+      Session.clear();
+      NProgress.done();
+      return routeLocation;
+    } else if (token && to.path === "/login") {
+      NProgress.done();
+      return "/dashboard/home";
+    } else {
+      const storesRoutesList = useRoutesList(pinia);
+      const { routesList } = storeToRefs(storesRoutesList);
+      if (routesList.value.length === 0) {
+        if (isRequestRoutes) {
+          const isNoPower = await initBackEndControlRoutes();
+          if (isNoPower) clearTokens();
+          return { path: to.path, query: to.query };
+        } else {
+          await initFrontEndControlRoutes();
+          return { path: to.path, query: to.query };
+        }
+      } else {
+        return;
+      }
+    }
+  }
+});
+router.afterEach(() => {
+  NProgress.done();
+});
+function initRouter() {
+  return router;
+}
+
+export { router as default, initBackEndControlRoutes, initFrontEndControlRoutes, initRouter };

package/es/packages/router/route.mjs

@@ -0,0 +1,147 @@
+let pathPrefix = "/@";
+function setPathPrefix(prefix) {
+  pathPrefix = prefix;
+}
+function getPath(path) {
+  return `${pathPrefix}${path}`;
+}
+let dynamicRoutes = [
+  {
+    path: "/",
+    name: "/",
+    component: () => import(getPath("/layout/index.vue")),
+    redirect: "/dashboard/home",
+    meta: {
+      isKeepAlive: true
+    },
+    children: []
+  },
+  {
+    path: "/llm/aiChat",
+    name: "aiChat",
+    component: () => import(getPath("/views/aiChat/index.vue")),
+    meta: {
+      title: "AI\u5BF9\u8BDD",
+      isKeepAlive: true
+    }
+  },
+  {
+    path: "/platform/job/dashboard",
+    name: "jobDashboard",
+    component: () => import(getPath("/views/system/job/dashboard.vue")),
+    meta: {
+      title: "\u4EFB\u52A1\u770B\u677F",
+      isLink: window.__env__.VITE_API_URL + "/schedule",
+      isHide: true,
+      isKeepAlive: true,
+      isAffix: false,
+      isIframe: true,
+      icon: "ele-Clock"
+    }
+  },
+  {
+    path: "/develop/database/visual",
+    name: "databaseVisual",
+    component: () => import(getPath("/views/system/database/component/visualTable.vue")),
+    meta: {
+      title: "\u5E93\u8868\u53EF\u89C6\u5316",
+      isHide: true,
+      isKeepAlive: true,
+      isAffix: false,
+      // isIframe: true,
+      icon: "ele-View"
+    }
+  },
+  {
+    path: "/report/view/:reportConfigId/:tagsViewName?",
+    name: "sysReportView",
+    component: () => import(getPath("/views/system/reportConfig/component/reportView.vue")),
+    meta: {
+      title: "\u62A5\u8868\u67E5\u770B",
+      isHide: true,
+      isKeepAlive: true,
+      isAffix: false,
+      isIframe: false,
+      icon: ""
+    }
+  }
+];
+let notFoundAndNoPower = [
+  {
+    path: "/:path(.*)*",
+    name: "notFound",
+    component: () => import(getPath("/views/error/404.vue")),
+    meta: {
+      title: "message.staticRoutes.notFound",
+      isHide: true
+    }
+  },
+  {
+    path: "/401",
+    name: "noPower",
+    component: () => import(getPath("/views/error/401.vue")),
+    meta: {
+      title: "message.staticRoutes.noPower",
+      isHide: true
+    }
+  }
+];
+let staticRoutes = [
+  {
+    path: "/login",
+    name: "login",
+    component: () => import(getPath("/views/login/index.vue")),
+    meta: {
+      title: "Login",
+      isPublic: true
+    }
+  }
+  /**
+   * 提示：写在这里的为全屏界面，不建议写在这里
+   * 请写在 `dynamicRoutes` 路由数组中
+   */
+  // {
+  //  path: '/visualizingDemo1',
+  //  name: 'visualizingDemo1',
+  //  component: () => import('/@/views/visualizing/demo1.vue'),
+  //  meta: {
+  //      title: 'message.router.visualizingLinkDemo1',
+  //  },
+  // },
+  // {
+  //  path: '/visualizingDemo2',
+  //  name: 'visualizingDemo2',
+  //  component: () => import('/@/views/visualizing/demo2.vue'),
+  //  meta: {
+  //      title: 'message.router.visualizingLinkDemo2',
+  //  },
+  // },
+];
+function configureRoutes(options) {
+  if (options.dynamicRoutes) {
+    if (options.merge) {
+      dynamicRoutes = [...dynamicRoutes, ...options.dynamicRoutes];
+    } else {
+      dynamicRoutes = options.dynamicRoutes;
+    }
+  }
+  if (options.staticRoutes) {
+    if (options.merge) {
+      staticRoutes = [...staticRoutes, ...options.staticRoutes];
+    } else {
+      staticRoutes = options.staticRoutes;
+    }
+  }
+  if (options.notFoundAndNoPower) {
+    if (options.merge) {
+      notFoundAndNoPower = [...notFoundAndNoPower, ...options.notFoundAndNoPower];
+    } else {
+      notFoundAndNoPower = options.notFoundAndNoPower;
+    }
+  }
+  if (options.pathPrefix) {
+    setPathPrefix(options.pathPrefix);
+  }
+}
+
+export { configureRoutes, dynamicRoutes, notFoundAndNoPower, setPathPrefix, staticRoutes };

package/es/packages/router/utils.mjs

@@ -0,0 +1,37 @@
+import { useKeepALiveNames } from '../stores/keepAliveNames.mjs';
+import pinia from '../stores/inpinia.mjs';
+
+function formatFlatteningRoutes(arr) {
+  if (arr.length <= 0) return false;
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i].children) {
+      arr = arr.slice(0, i + 1).concat(arr[i].children, arr.slice(i + 1));
+    }
+  }
+  return arr;
+}
+function formatTwoStageRoutes(arr) {
+  if (arr.length <= 0) return false;
+  const newArr = [];
+  const cacheList = [];
+  arr.forEach((v) => {
+    if (v.path == null || v.path == void 0) return;
+    if (v.path === "/") {
+      newArr.push({ component: v.component, name: v.name, path: v.path, redirect: v.redirect, meta: v.meta, children: [] });
+    } else {
+      if (v.path.indexOf("/:") > -1) {
+        v.meta["isDynamic"] = true;
+        v.meta["isDynamicPath"] = v.path;
+      }
+      newArr[0].children.push({ ...v });
+      if (newArr[0].meta.isKeepAlive && v.meta.isKeepAlive) {
+        cacheList.push(v.name);
+      }
+    }
+  });
+  const stores = useKeepALiveNames(pinia);
+  stores.setCacheKeepAlive(cacheList);
+  return newArr;
+}
+
+export { formatFlatteningRoutes, formatTwoStageRoutes };

package/es/packages/stores/index.mjs

@@ -0,0 +1,6 @@
+export { useKeepALiveNames } from './keepAliveNames.mjs';
+export { useRequestOldRoutes } from './requestOldRoutes.mjs';
+export { useRoutesList } from './routesList.mjs';
+export { useTagsViewRoutes } from './tagsViewRoutes.mjs';
+export { useThemeConfig } from './themeConfig.mjs';
+export { useUserInfo } from './userInfo.mjs';

package/es/packages/stores/inpinia.mjs

@@ -0,0 +1,5 @@
+import { createPinia } from 'pinia';
+
+const pinia = createPinia();
+
+export { pinia as default };

package/es/packages/stores/keepAliveNames.mjs

@@ -0,0 +1,30 @@
+import { defineStore } from 'pinia';
+
+const useKeepALiveNames = defineStore("keepALiveNames", {
+  state: () => ({
+    keepAliveNames: [],
+    cachedViews: []
+  }),
+  actions: {
+    async setCacheKeepAlive(data) {
+      this.keepAliveNames = data;
+    },
+    async addCachedView(view) {
+      var _a;
+      if (view.meta.isKeepAlive) (_a = this.cachedViews) == null ? void 0 : _a.push(view.name);
+    },
+    async delCachedView(view) {
+      const index = this.cachedViews.indexOf(view.name);
+      if (index > -1) this.cachedViews.splice(index, 1);
+    },
+    async delOthersCachedViews(view) {
+      if (view.meta.isKeepAlive) this.cachedViews = [view.name];
+      else this.cachedViews = [];
+    },
+    async delAllCachedViews() {
+      this.cachedViews = [];
+    }
+  }
+});
+
+export { useKeepALiveNames };

package/es/packages/stores/requestOldRoutes.mjs

@@ -0,0 +1,14 @@
+import { defineStore } from 'pinia';
+
+const useRequestOldRoutes = defineStore("requestOldRoutes", {
+  state: () => ({
+    requestOldRoutes: []
+  }),
+  actions: {
+    async setRequestOldRoutes(routes) {
+      this.requestOldRoutes = routes;
+    }
+  }
+});
+
+export { useRequestOldRoutes };

package/es/packages/stores/routesList.mjs

@@ -0,0 +1,26 @@
+import { defineStore } from 'pinia';
+
+const useRoutesList = defineStore("routesList", {
+  state: () => ({
+    routesList: [],
+    isColumnsMenuHover: false,
+    isColumnsNavHover: false,
+    currentRoute: null
+  }),
+  actions: {
+    setCurrentRoute(route) {
+      this.currentRoute = route;
+    },
+    async setRoutesList(data) {
+      this.routesList = data;
+    },
+    async setColumnsMenuHover(bool) {
+      this.isColumnsMenuHover = bool;
+    },
+    async setColumnsNavHover(bool) {
+      this.isColumnsNavHover = bool;
+    }
+  }
+});
+
+export { useRoutesList };

package/es/packages/stores/tagsViewRoutes.mjs

@@ -0,0 +1,21 @@
+import { defineStore } from 'pinia';
+import '../utils/index.mjs';
+import { Session } from '../utils/storage.mjs';
+
+const useTagsViewRoutes = defineStore("tagsViewRoutes", {
+  state: () => ({
+    tagsViewRoutes: [],
+    isTagsViewCurrenFull: false
+  }),
+  actions: {
+    async setTagsViewRoutes(data) {
+      this.tagsViewRoutes = data;
+    },
+    setCurrenFullscreen(bool) {
+      Session.set("isTagsViewCurrenFull", bool);
+      this.isTagsViewCurrenFull = bool;
+    }
+  }
+});
+
+export { useTagsViewRoutes };