@fmdeui/fmui 1.0.1

package/lib/packages/router/backEnd.js

@@ -0,0 +1,104 @@
+'use strict';
+
+var inpinia = require('../stores/inpinia.js');
+var userInfo = require('../stores/userInfo.js');
+var requestOldRoutes = require('../stores/requestOldRoutes.js');
+var storage = require('../utils/storage.js');
+var loading = require('../utils/loading.js');
+var routesList = require('../stores/routesList.js');
+var tagsViewRoutes = require('../stores/tagsViewRoutes.js');
+var route = require('./route.js');
+var utils = require('./utils.js');
+var createRouter = require('./createRouter.js');
+require('../api/index.js');
+var index = require('../api/sys/index.js');
+
+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) loading.NextLoading.start();
+  if (!storage.Session.get("token")) return false;
+  await userInfo.useUserInfo().setUserInfos();
+  await userInfo.useUserInfo().setConstList();
+  await userInfo.useUserInfo().setDictList();
+  const res = await getBackEndControlRoutes();
+  if (res == void 0 || res.length <= 0) return Promise.resolve(true);
+  requestOldRoutes.useRequestOldRoutes().setRequestOldRoutes(res);
+  route.dynamicRoutes[0].children = await backEndComponent(res);
+  await setAddRoute();
+  setFilterMenuAndCacheTagsViewRoutes();
+}
+async function setFilterMenuAndCacheTagsViewRoutes() {
+  const storesRoutesList = routesList.useRoutesList(inpinia.default);
+  storesRoutesList.setRoutesList(route.dynamicRoutes[0].children);
+  setCacheTagsViewRoutes();
+}
+function setCacheTagsViewRoutes() {
+  const storesTagsView = tagsViewRoutes.useTagsViewRoutes(inpinia.default);
+  storesTagsView.setTagsViewRoutes(utils.formatTwoStageRoutes(utils.formatFlatteningRoutes(route.dynamicRoutes))[0].children);
+}
+function setFilterRouteEnd() {
+  let filterRouteEnd = utils.formatTwoStageRoutes(utils.formatFlatteningRoutes(route.dynamicRoutes));
+  filterRouteEnd[0].children = [...filterRouteEnd[0].children, ...route.notFoundAndNoPower];
+  return filterRouteEnd;
+}
+async function setAddRoute() {
+  await setFilterRouteEnd().forEach((route) => {
+    createRouter.router.addRoute(route);
+  });
+}
+async function getBackEndControlRoutes() {
+  var res = await index.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;
+  }
+}
+
+exports.backEndComponent = backEndComponent;
+exports.dynamicImport = dynamicImport;
+exports.getBackEndControlRoutes = getBackEndControlRoutes;
+exports.initBackEndControlRoutes = initBackEndControlRoutes;
+exports.setAddRoute = setAddRoute;
+exports.setBackEndControlRefreshRoutes = setBackEndControlRefreshRoutes;
+exports.setCacheTagsViewRoutes = setCacheTagsViewRoutes;
+exports.setDynamicViewsModules = setDynamicViewsModules;
+exports.setFilterMenuAndCacheTagsViewRoutes = setFilterMenuAndCacheTagsViewRoutes;
+exports.setFilterRouteEnd = setFilterRouteEnd;

package/lib/packages/router/createRouter.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var vueRouter = require('vue-router');
+var route = require('./route.js');
+
+const router = vueRouter.createRouter({
+  history: vueRouter.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: [...route.notFoundAndNoPower, ...route.staticRoutes]
+});
+
+exports.router = router;

package/lib/packages/router/frontEnd.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var pinia = require('pinia');
+var utils = require('./utils.js');
+var route = require('./route.js');
+var inpinia = require('../stores/inpinia.js');
+var storage = require('../utils/storage.js');
+var userInfo = require('../stores/userInfo.js');
+var tagsViewRoutes = require('../stores/tagsViewRoutes.js');
+var routesList = require('../stores/routesList.js');
+var loading = require('../utils/loading.js');
+var createRouter = require('./createRouter.js');
+
+async function initFrontEndControlRoutes() {
+  if (window.nextLoading === void 0) loading.NextLoading.start();
+  if (!storage.Session.get("token")) return false;
+  await userInfo.useUserInfo(inpinia.default).setUserInfos();
+  await setAddRoute();
+  setFilterMenuAndCacheTagsViewRoutes();
+}
+async function setAddRoute() {
+  await setFilterRouteEnd().forEach((route) => {
+    createRouter.router.addRoute(route);
+  });
+}
+async function frontEndsResetRoute() {
+  await setFilterRouteEnd().forEach((route) => {
+    const routeName = route.name;
+    createRouter.router.hasRoute(routeName) && createRouter.router.removeRoute(routeName);
+  });
+}
+function setFilterRouteEnd() {
+  let filterRouteEnd = utils.formatTwoStageRoutes(utils.formatFlatteningRoutes(route.dynamicRoutes));
+  filterRouteEnd[0].children = [...setFilterRoute(filterRouteEnd[0].children), ...route.notFoundAndNoPower];
+  return filterRouteEnd;
+}
+function setFilterRoute(chil) {
+  const stores = userInfo.useUserInfo(inpinia.default);
+  const { userInfos } = pinia.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 = userInfo.useUserInfo(inpinia.default);
+  const storesTagsView = tagsViewRoutes.useTagsViewRoutes(inpinia.default);
+  const { userInfos } = pinia.storeToRefs(stores);
+  let rolesRoutes = setFilterHasRolesMenu(route.dynamicRoutes, userInfos.value.roles);
+  storesTagsView.setTagsViewRoutes(utils.formatTwoStageRoutes(utils.formatFlatteningRoutes(rolesRoutes))[0].children);
+}
+function setFilterMenuAndCacheTagsViewRoutes() {
+  const stores = userInfo.useUserInfo(inpinia.default);
+  const storesRoutesList = routesList.useRoutesList(inpinia.default);
+  const { userInfos } = pinia.storeToRefs(stores);
+  storesRoutesList.setRoutesList(setFilterHasRolesMenu(route.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;
+}
+
+exports.frontEndsResetRoute = frontEndsResetRoute;
+exports.hasRoles = hasRoles;
+exports.initFrontEndControlRoutes = initFrontEndControlRoutes;
+exports.setAddRoute = setAddRoute;
+exports.setCacheTagsViewRoutes = setCacheTagsViewRoutes;
+exports.setFilterHasRolesMenu = setFilterHasRolesMenu;
+exports.setFilterMenuAndCacheTagsViewRoutes = setFilterMenuAndCacheTagsViewRoutes;
+exports.setFilterRoute = setFilterRoute;
+exports.setFilterRouteEnd = setFilterRouteEnd;

package/lib/packages/router/index.js

@@ -0,0 +1,72 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var pinia = require('pinia');
+var routesList = require('../stores/routesList.js');
+var themeConfig$1 = require('../stores/themeConfig.js');
+var storage = require('../utils/storage.js');
+var route = require('./route.js');
+var frontEnd = require('./frontEnd.js');
+var backEnd = require('./backEnd.js');
+var request = require('../utils/request.js');
+var createRouter = require('./createRouter.js');
+var NProgress = require('nprogress');
+require('../../node_modules/.pnpm/nprogress@0.2.0/node_modules/nprogress/nprogress.css.js');
+var inpinia = require('../stores/inpinia.js');
+
+const storesThemeConfig = themeConfig$1.useThemeConfig(inpinia.default);
+const { themeConfig } = pinia.storeToRefs(storesThemeConfig);
+const { isRequestRoutes } = themeConfig.value;
+const routeStores = routesList.useRoutesList();
+createRouter.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 : storage.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(storage.Local.get("tid"));
+      if (!isNaN(tenantid) && tenantid > 99999) routeLocation += `&tid=${tenantid}`;
+      storage.Session.clear();
+      NProgress.done();
+      return routeLocation;
+    } else if (token && to.path === "/login") {
+      NProgress.done();
+      return "/dashboard/home";
+    } else {
+      const storesRoutesList = routesList.useRoutesList(inpinia.default);
+      const { routesList: routesList$1 } = pinia.storeToRefs(storesRoutesList);
+      if (routesList$1.value.length === 0) {
+        if (isRequestRoutes) {
+          const isNoPower = await backEnd.initBackEndControlRoutes();
+          if (isNoPower) request.clearTokens();
+          return { path: to.path, query: to.query };
+        } else {
+          await frontEnd.initFrontEndControlRoutes();
+          return { path: to.path, query: to.query };
+        }
+      } else {
+        return;
+      }
+    }
+  }
+});
+createRouter.router.afterEach(() => {
+  NProgress.done();
+});
+function initRouter() {
+  return createRouter.router;
+}
+
+exports.configureRoutes = route.configureRoutes;
+exports.setPathPrefix = route.setPathPrefix;
+exports.initFrontEndControlRoutes = frontEnd.initFrontEndControlRoutes;
+exports.initBackEndControlRoutes = backEnd.initBackEndControlRoutes;
+exports.setDynamicViewsModules = backEnd.setDynamicViewsModules;
+exports.default = createRouter.router;
+exports.initRouter = initRouter;

package/lib/packages/router/route.js

@@ -0,0 +1,150 @@
+'use strict';
+
+let pathPrefix = "/@";
+function setPathPrefix(prefix) {
+  pathPrefix = prefix;
+}
+function getPath(path) {
+  return `${pathPrefix}${path}`;
+}
+exports.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: ""
+    }
+  }
+];
+exports.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
+    }
+  }
+];
+exports.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) {
+      exports.dynamicRoutes = [...exports.dynamicRoutes, ...options.dynamicRoutes];
+    } else {
+      exports.dynamicRoutes = options.dynamicRoutes;
+    }
+  }
+  if (options.staticRoutes) {
+    if (options.merge) {
+      exports.staticRoutes = [...exports.staticRoutes, ...options.staticRoutes];
+    } else {
+      exports.staticRoutes = options.staticRoutes;
+    }
+  }
+  if (options.notFoundAndNoPower) {
+    if (options.merge) {
+      exports.notFoundAndNoPower = [...exports.notFoundAndNoPower, ...options.notFoundAndNoPower];
+    } else {
+      exports.notFoundAndNoPower = options.notFoundAndNoPower;
+    }
+  }
+  if (options.pathPrefix) {
+    setPathPrefix(options.pathPrefix);
+  }
+}
+
+exports.configureRoutes = configureRoutes;
+exports.setPathPrefix = setPathPrefix;

package/lib/packages/router/utils.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var keepAliveNames = require('../stores/keepAliveNames.js');
+var inpinia = require('../stores/inpinia.js');
+
+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 = keepAliveNames.useKeepALiveNames(inpinia.default);
+  stores.setCacheKeepAlive(cacheList);
+  return newArr;
+}
+
+exports.formatFlatteningRoutes = formatFlatteningRoutes;
+exports.formatTwoStageRoutes = formatTwoStageRoutes;

package/lib/packages/stores/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var keepAliveNames = require('./keepAliveNames.js');
+var requestOldRoutes = require('./requestOldRoutes.js');
+var routesList = require('./routesList.js');
+var tagsViewRoutes = require('./tagsViewRoutes.js');
+var themeConfig = require('./themeConfig.js');
+var userInfo = require('./userInfo.js');
+
+
+
+exports.useKeepALiveNames = keepAliveNames.useKeepALiveNames;
+exports.useRequestOldRoutes = requestOldRoutes.useRequestOldRoutes;
+exports.useRoutesList = routesList.useRoutesList;
+exports.useTagsViewRoutes = tagsViewRoutes.useTagsViewRoutes;
+exports.useThemeConfig = themeConfig.useThemeConfig;
+exports.useUserInfo = userInfo.useUserInfo;

package/lib/packages/stores/inpinia.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var pinia$1 = require('pinia');
+
+const pinia = pinia$1.createPinia();
+
+exports.default = pinia;

package/lib/packages/stores/keepAliveNames.js

@@ -0,0 +1,32 @@
+'use strict';
+
+var pinia = require('pinia');
+
+const useKeepALiveNames = pinia.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 = [];
+    }
+  }
+});
+
+exports.useKeepALiveNames = useKeepALiveNames;

package/lib/packages/stores/requestOldRoutes.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var pinia = require('pinia');
+
+const useRequestOldRoutes = pinia.defineStore("requestOldRoutes", {
+  state: () => ({
+    requestOldRoutes: []
+  }),
+  actions: {
+    async setRequestOldRoutes(routes) {
+      this.requestOldRoutes = routes;
+    }
+  }
+});
+
+exports.useRequestOldRoutes = useRequestOldRoutes;

package/lib/packages/stores/routesList.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var pinia = require('pinia');
+
+const useRoutesList = pinia.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;
+    }
+  }
+});
+
+exports.useRoutesList = useRoutesList;

package/lib/packages/stores/tagsViewRoutes.js

@@ -0,0 +1,23 @@
+'use strict';
+
+var pinia = require('pinia');
+require('../utils/index.js');
+var storage = require('../utils/storage.js');
+
+const useTagsViewRoutes = pinia.defineStore("tagsViewRoutes", {
+  state: () => ({
+    tagsViewRoutes: [],
+    isTagsViewCurrenFull: false
+  }),
+  actions: {
+    async setTagsViewRoutes(data) {
+      this.tagsViewRoutes = data;
+    },
+    setCurrenFullscreen(bool) {
+      storage.Session.set("isTagsViewCurrenFull", bool);
+      this.isTagsViewCurrenFull = bool;
+    }
+  }
+});
+
+exports.useTagsViewRoutes = useTagsViewRoutes;