@fmdevui/fm-dev 1.0.4 → 1.0.6

package/lib/packages/core/api/utils/request.js

@@ -0,0 +1,190 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var axios = require('axios');
+require('../../utils/index.js');
+var elementPlus = require('element-plus');
+var index = require('../../utils/const/index.js');
+var index$1 = require('../../utils/storage/index.js');
+
+const abortControllerMap = /* @__PURE__ */ new Map();
+const service = axios.create({
+  baseURL: window.__env__.VITE_API_URL,
+  timeout: 5e4
+  // headers: { 'Content-Type': 'application/json' },
+});
+const accessTokenKey = index.PUB.accessTokenKey;
+const refreshAccessTokenKey = index.PUB.refreshAccessTokenKey;
+const getToken = () => {
+  return index$1.Local.get(accessTokenKey);
+};
+const clearTokens = () => {
+  index$1.Local.remove(accessTokenKey);
+  index$1.Local.remove(refreshAccessTokenKey);
+  index$1.Session.clear();
+};
+const clearAccessTokens = () => {
+  clearTokens();
+  window.location.reload();
+};
+const axiosInstance = axios;
+service.interceptors.request.use(
+  (config) => {
+    const controller = new AbortController();
+    config.signal = controller.signal;
+    const url = config.url || "";
+    abortControllerMap.set(url, controller);
+    const accessToken = index$1.Local.get(accessTokenKey);
+    if (accessToken) {
+      config.headers["Authorization"] = `Bearer ${accessToken}`;
+      const jwt = decryptJWT(accessToken);
+      const exp = getJWTDate(jwt.exp);
+      if (/* @__PURE__ */ new Date() >= exp) {
+        const refreshAccessToken = index$1.Local.get(refreshAccessTokenKey);
+        if (refreshAccessToken) {
+          config.headers["X-Authorization"] = `Bearer ${refreshAccessToken}`;
+        }
+      }
+      if (config.method?.toLowerCase() === "get" && config.data) {
+        let url2 = config.url + "?" + tansParams(config.data);
+        url2 = url2.slice(0, -1);
+        config.data = {};
+        config.url = url2;
+      }
+    }
+    return config;
+  },
+  (error) => {
+    return Promise.reject(error);
+  }
+);
+service.interceptors.response.use(
+  (res) => {
+    const url = res.config.url || "";
+    abortControllerMap.delete(url);
+    var status = res.status;
+    var serve = res.data;
+    if (status === 401) {
+      clearAccessTokens();
+    }
+    if (status >= 400) {
+      throw new Error(res.statusText || "Request Error.");
+    }
+    if (serve && serve.hasOwnProperty("errors") && serve.errors) {
+      throw new Error(JSON.stringify(serve.errors || "Request Error."));
+    }
+    var accessToken = res.headers[accessTokenKey];
+    var refreshAccessToken = res.headers[refreshAccessTokenKey];
+    if (accessToken === "invalid_token") {
+      clearAccessTokens();
+    } else if (refreshAccessToken && accessToken) {
+      index$1.Local.set(accessTokenKey, accessToken);
+      index$1.Local.set(refreshAccessTokenKey, refreshAccessToken);
+    }
+    if (serve.code === 401) {
+      clearAccessTokens();
+    } else if (serve.code === void 0) {
+      return Promise.resolve(res);
+    } else if (serve.code !== 200) {
+      var message;
+      if (serve.message && typeof serve.message == "object") {
+        message = JSON.stringify(serve.message);
+      } else {
+        message = serve.message;
+      }
+      elementPlus.ElMessage.error(message);
+      throw new Error(message);
+    }
+    return res;
+  },
+  (error) => {
+    if (error.response) {
+      if (error.response.status === 401) {
+        clearAccessTokens();
+      } else if (error.response.statusCode === 404) {
+        elementPlus.ElMessage.error("\u63A5\u53E3\u5F02\u5E38\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458");
+      }
+    }
+    if (error.message.indexOf("timeout") != -1) {
+      elementPlus.ElMessage.error("\u7F51\u7EDC\u8D85\u65F6");
+    } else if (error.message == "Network Error") {
+      elementPlus.ElMessage.error("\u7F51\u7EDC\u8FDE\u63A5\u9519\u8BEF");
+    } else {
+      if (error.response.data) elementPlus.ElMessage.error(error.response.statusText);
+      else elementPlus.ElMessage.error("\u63A5\u53E3\u8DEF\u5F84\u627E\u4E0D\u5230");
+    }
+    return Promise.reject(error);
+  }
+);
+const cancelRequest = (url) => {
+  const urlList = Array.isArray(url) ? url : [url];
+  for (const _url of urlList) {
+    abortControllerMap.get(_url)?.abort();
+    abortControllerMap.delete(_url);
+  }
+};
+const cancelAllRequest = () => {
+  for (const [_, controller] of abortControllerMap) {
+    controller.abort();
+  }
+  abortControllerMap.clear();
+};
+function tansParams(params) {
+  let result = "";
+  for (const propName of Object.keys(params)) {
+    const value = params[propName];
+    var part = encodeURIComponent(propName) + "=";
+    if (value !== null && value !== "" && typeof value !== "undefined") {
+      if (typeof value === "object") {
+        for (const key of Object.keys(value)) {
+          if (value[key] !== null && value[key] !== "" && typeof value[key] !== "undefined") {
+            let params2 = propName + "[" + key + "]";
+            var subPart = encodeURIComponent(params2) + "=";
+            result += subPart + encodeURIComponent(value[key]) + "&";
+          }
+        }
+      } else {
+        result += part + encodeURIComponent(value) + "&";
+      }
+    }
+  }
+  return result;
+}
+function decryptJWT(token) {
+  token = token.replace(/_/g, "/").replace(/-/g, "+");
+  var json = decodeURIComponent(escape(window.atob(token.split(".")[1])));
+  return JSON.parse(json);
+}
+function getJWTDate(timestamp) {
+  return new Date(timestamp * 1e3);
+}
+function request2(config) {
+  return new Promise((resolve, reject) => {
+    service(config).then((res) => {
+      if (res.data.type == "success") {
+        resolve(res.data.result);
+      } else {
+        elementPlus.ElMessage.success(res.data.message);
+      }
+    }).catch((res) => {
+      elementPlus.ElMessage.error(res);
+      reject(res);
+    });
+  });
+}
+
+exports.accessTokenKey = accessTokenKey;
+exports.axiosInstance = axiosInstance;
+exports.cancelAllRequest = cancelAllRequest;
+exports.cancelRequest = cancelRequest;
+exports.clearAccessTokens = clearAccessTokens;
+exports.clearTokens = clearTokens;
+exports.decryptJWT = decryptJWT;
+exports.default = service;
+exports.getJWTDate = getJWTDate;
+exports.getToken = getToken;
+exports.refreshAccessTokenKey = refreshAccessTokenKey;
+exports.request2 = request2;
+exports.service = service;
+exports.tansParams = tansParams;

package/lib/packages/core/auth/index.js

@@ -0,0 +1,41 @@
+'use strict';
+
+require('../stores/index.js');
+var index = require('../utils/array/index.js');
+var vue = require('vue');
+var userInfo = require('../stores/userInfo.js');
+
+function auth(value) {
+  const stores = userInfo.useUserInfo();
+  return stores.userInfos.authApiList.some((v) => v === value);
+}
+function auths(value) {
+  let flag = false;
+  const stores = userInfo.useUserInfo();
+  stores.userInfos.authApiList.map((val) => {
+    value.map((v) => {
+      if (val === v) flag = true;
+    });
+  });
+  return flag;
+}
+function authAll(value) {
+  const stores = userInfo.useUserInfo();
+  return index.judgementSameArr(value, stores.userInfos.authApiList);
+}
+function hAuth(el, value) {
+  return vue.withDirectives(el, [[vue.resolveDirective("auth"), value]]);
+}
+function hAuths(el, value) {
+  return vue.withDirectives(el, [[vue.resolveDirective("auths"), value]]);
+}
+function hAuthAll(el, value) {
+  return vue.withDirectives(el, [[vue.resolveDirective("auth-all"), value]]);
+}
+
+exports.auth = auth;
+exports.authAll = authAll;
+exports.auths = auths;
+exports.hAuth = hAuth;
+exports.hAuthAll = hAuthAll;
+exports.hAuths = hAuths;

package/lib/packages/core/directive/authDirective.js

@@ -0,0 +1,40 @@
+'use strict';
+
+require('../stores/index.js');
+require('../utils/index.js');
+var userInfo = require('../stores/userInfo.js');
+var index = require('../utils/array/index.js');
+
+function authDirective(app) {
+  app.directive("auth", {
+    mounted(el, binding) {
+      const stores = userInfo.useUserInfo();
+      if (!stores.userInfos.authApiList) {
+        el.parentNode.removeChild(el);
+      } else {
+        if (!stores.userInfos.authApiList.some((v) => v === binding.value)) el.parentNode.removeChild(el);
+      }
+    }
+  });
+  app.directive("auths", {
+    mounted(el, binding) {
+      let flag = false;
+      const stores = userInfo.useUserInfo();
+      stores.userInfos.authApiList.map((val) => {
+        binding.value.map((v) => {
+          if (val === v) flag = true;
+        });
+      });
+      if (!flag) el.parentNode.removeChild(el);
+    }
+  });
+  app.directive("auth-all", {
+    mounted(el, binding) {
+      const stores = userInfo.useUserInfo();
+      const flag = index.judgementSameArr(binding.value, stores.userInfos.authApiList);
+      if (!flag) el.parentNode.removeChild(el);
+    }
+  });
+}
+
+exports.authDirective = authDirective;

package/lib/packages/core/directive/customDirective.js

@@ -0,0 +1,151 @@
+'use strict';
+
+function wavesDirective(app) {
+  app.directive("waves", {
+    mounted(el, binding) {
+      el.classList.add("waves-effect");
+      binding.value && el.classList.add(`waves-${binding.value}`);
+      function setConvertStyle(obj) {
+        let style = "";
+        for (let i in obj) {
+          if (obj.hasOwnProperty(i)) style += `${i}:${obj[i]};`;
+        }
+        return style;
+      }
+      function onCurrentClick(e) {
+        let elDiv = document.createElement("div");
+        elDiv.classList.add("waves-ripple");
+        el.appendChild(elDiv);
+        let styles = {
+          left: `${e.layerX}px`,
+          top: `${e.layerY}px`,
+          opacity: 1,
+          transform: `scale(${el.clientWidth / 100 * 10})`,
+          "transition-duration": `750ms`,
+          "transition-timing-function": `cubic-bezier(0.250, 0.460, 0.450, 0.940)`
+        };
+        elDiv.setAttribute("style", setConvertStyle(styles));
+        setTimeout(() => {
+          elDiv.setAttribute(
+            "style",
+            setConvertStyle({
+              opacity: 0,
+              transform: styles.transform,
+              left: styles.left,
+              top: styles.top
+            })
+          );
+          setTimeout(() => {
+            elDiv && el.removeChild(elDiv);
+          }, 750);
+        }, 450);
+      }
+      el.addEventListener("mousedown", onCurrentClick, false);
+    },
+    unmounted(el) {
+      el.addEventListener("mousedown", () => {
+      });
+    }
+  });
+}
+function dragDirective(app) {
+  app.directive("drag", {
+    mounted(el, binding) {
+      if (!binding.value) return false;
+      const dragDom = document.querySelector(binding.value[0]);
+      const dragHeader = document.querySelector(binding.value[1]);
+      dragHeader.onmouseover = () => dragHeader.style.cursor = `move`;
+      function down(e, type) {
+        const disX = type === "pc" ? e.clientX - dragHeader.offsetLeft : e.touches[0].clientX - dragHeader.offsetLeft;
+        const disY = type === "pc" ? e.clientY - dragHeader.offsetTop : e.touches[0].clientY - dragHeader.offsetTop;
+        const screenWidth = document.body.clientWidth;
+        const screenHeight = document.documentElement.clientHeight;
+        const dragDomWidth = dragDom.offsetWidth;
+        const dragDomheight = dragDom.offsetHeight;
+        const minDragDomLeft = dragDom.offsetLeft;
+        const maxDragDomLeft = screenWidth - dragDom.offsetLeft - dragDomWidth;
+        const minDragDomTop = dragDom.offsetTop;
+        const maxDragDomTop = screenHeight - dragDom.offsetTop - dragDomheight;
+        let styL = getComputedStyle(dragDom).left;
+        let styT = getComputedStyle(dragDom).top;
+        if (styL.includes("%")) {
+          styL = +document.body.clientWidth * (+styL.replace(/\%/g, "") / 100);
+          styT = +document.body.clientHeight * (+styT.replace(/\%/g, "") / 100);
+        } else {
+          styL = +styL.replace(/\px/g, "");
+          styT = +styT.replace(/\px/g, "");
+        }
+        return {
+          disX,
+          disY,
+          minDragDomLeft,
+          maxDragDomLeft,
+          minDragDomTop,
+          maxDragDomTop,
+          styL,
+          styT
+        };
+      }
+      function move(e, type, obj) {
+        let { disX, disY, minDragDomLeft, maxDragDomLeft, minDragDomTop, maxDragDomTop, styL, styT } = obj;
+        let left = type === "pc" ? e.clientX - disX : e.touches[0].clientX - disX;
+        let top = type === "pc" ? e.clientY - disY : e.touches[0].clientY - disY;
+        if (-left > minDragDomLeft) {
+          left = -minDragDomLeft;
+        } else if (left > maxDragDomLeft) {
+          left = maxDragDomLeft;
+        }
+        if (-top > minDragDomTop) {
+          top = -minDragDomTop;
+        } else if (top > maxDragDomTop) {
+          top = maxDragDomTop;
+        }
+        dragDom.style.cssText += `;left:${left + styL}px;top:${top + styT}px;`;
+      }
+      dragHeader.onmousedown = (e) => {
+        const obj = down(e, "pc");
+        document.onmousemove = (e2) => {
+          move(e2, "pc", obj);
+        };
+        document.onmouseup = () => {
+          document.onmousemove = null;
+          document.onmouseup = null;
+        };
+      };
+      dragHeader.ontouchstart = (e) => {
+        const obj = down(e, "app");
+        document.ontouchmove = (e2) => {
+          move(e2, "app", obj);
+        };
+        document.ontouchend = () => {
+          document.ontouchmove = null;
+          document.ontouchend = null;
+        };
+      };
+    }
+  });
+}
+function reclickDirective(app) {
+  app.directive("reclick", {
+    mounted(el, time) {
+      el.addEventListener("click", () => {
+        if (!el.disabled) {
+          el.disabled = true;
+          setTimeout(
+            () => {
+              el.disabled = false;
+            },
+            time.value === void 0 ? 500 : time.value
+          );
+        }
+      });
+    },
+    unmounted(el) {
+      el.disabled = false;
+    }
+  });
+}
+
+exports.dragDirective = dragDirective;
+exports.reclickDirective = reclickDirective;
+exports.wavesDirective = wavesDirective;

package/lib/packages/core/directive/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var authDirective = require('./authDirective.js');
+var customDirective = require('./customDirective.js');
+
+function directive(app) {
+  authDirective.authDirective(app);
+  customDirective.wavesDirective(app);
+  customDirective.reclickDirective(app);
+}
+
+exports.directive = directive;

package/lib/packages/core/index.js

@@ -1,15 +1,122 @@
 'use strict';
 
 var index = require('./ui/login/index.js');
-var index$1 = require('./locales/index.js');
+require('./api/index.js');
+var index$4 = require('./directive/index.js');
+var index$5 = require('./locales/index.js');
+require('./stores/index.js');
+require('./utils/index.js');
+var index$b = require('./auth/index.js');
 require('./types/index.js');
+var index$1 = require('./api/base/index.js');
+var index$2 = require('./api/sys/index.js');
+var index$3 = require('./api/login/index.js');
+var request = require('./api/utils/request.js');
+var keepAliveNames = require('./stores/keepAliveNames.js');
+var requestOldRoutes = require('./stores/requestOldRoutes.js');
+var routesList = require('./stores/routesList.js');
+var tagsViewRoutes = require('./stores/tagsViewRoutes.js');
+var themeConfig = require('./stores/themeConfig.js');
+var userInfo = require('./stores/userInfo.js');
+var index$6 = require('./utils/array/index.js');
+var index$7 = require('./utils/watermark/index.js');
+var index$8 = require('./utils/base64/index.js');
+var index$9 = require('./utils/storage/index.js');
+var toolsValidate = require('./utils/comm/toolsValidate.js');
+var formatTime = require('./utils/comm/formatTime.js');
+var theme = require('./utils/comm/theme.js');
+var download = require('./utils/comm/download.js');
+var dataSignature = require('./utils/comm/data-signature.js');
+var uploadfileurl = require('./utils/comm/uploadfileurl.js');
+var index$a = require('./utils/const/index.js');
 
 
 
 exports.FmLogin = index.FmLogin;
-exports.getCountryCode = index$1.getCountryCode;
-exports.i18n = index$1.i18n;
-exports.iso_3166_1_CountryList = index$1.iso_3166_1_CountryList;
-exports.languageList = index$1.languageList;
-exports.mergMessage = index$1.mergMessage;
-exports.setupI18n = index$1.setupI18n;
+exports.directive = index$4.directive;
+exports.getCountryCode = index$5.getCountryCode;
+exports.i18n = index$5.i18n;
+exports.iso_3166_1_CountryList = index$5.iso_3166_1_CountryList;
+exports.languageList = index$5.languageList;
+exports.mergMessage = index$5.mergMessage;
+exports.setupI18n = index$5.setupI18n;
+exports.auth = index$b.auth;
+exports.authAll = index$b.authAll;
+exports.auths = index$b.auths;
+exports.hAuth = index$b.hAuth;
+exports.hAuthAll = index$b.hAuthAll;
+exports.hAuths = index$b.hAuths;
+exports.useBaseApi = index$1.useBaseApi;
+exports.feature = index$2.feature;
+exports.useSysApi = index$2.useSysApi;
+exports.useLoginApi = index$3.useLoginApi;
+exports.accessTokenKey = request.accessTokenKey;
+exports.axiosInstance = request.axiosInstance;
+exports.cancelAllRequest = request.cancelAllRequest;
+exports.cancelRequest = request.cancelRequest;
+exports.clearAccessTokens = request.clearAccessTokens;
+exports.clearTokens = request.clearTokens;
+exports.decryptJWT = request.decryptJWT;
+exports.getJWTDate = request.getJWTDate;
+exports.getToken = request.getToken;
+exports.refreshAccessTokenKey = request.refreshAccessTokenKey;
+exports.request2 = request.request2;
+exports.service = request.service;
+exports.tansParams = request.tansParams;
+exports.useKeepALiveNames = keepAliveNames.useKeepALiveNames;
+exports.useRequestOldRoutes = requestOldRoutes.useRequestOldRoutes;
+exports.useRoutesList = routesList.useRoutesList;
+exports.useTagsViewRoutes = tagsViewRoutes.useTagsViewRoutes;
+exports.useThemeConfig = themeConfig.useThemeConfig;
+exports.useUserInfo = userInfo.useUserInfo;
+exports.clone = index$6.clone;
+exports.isObjectValueEqual = index$6.isObjectValueEqual;
+exports.judgementSameArr = index$6.judgementSameArr;
+exports.removeDuplicate = index$6.removeDuplicate;
+exports.Watermark = index$7.Watermark;
+exports.base64ToFile = index$8.base64ToFile;
+exports.blobToFile = index$8.blobToFile;
+exports.dataURLtoBlob = index$8.dataURLtoBlob;
+exports.fileToBase64 = index$8.fileToBase64;
+exports.urlToBase64 = index$8.urlToBase64;
+exports.Local = index$9.Local;
+exports.Session = index$9.Session;
+exports.judgementIdCard = toolsValidate.judgementIdCard;
+exports.verifiyNumberInteger = toolsValidate.verifiyNumberInteger;
+exports.verifyAccount = toolsValidate.verifyAccount;
+exports.verifyAndSpace = toolsValidate.verifyAndSpace;
+exports.verifyCarNum = toolsValidate.verifyCarNum;
+exports.verifyCnAndSpace = toolsValidate.verifyCnAndSpace;
+exports.verifyEmail = toolsValidate.verifyEmail;
+exports.verifyEnAndSpace = toolsValidate.verifyEnAndSpace;
+exports.verifyFullName = toolsValidate.verifyFullName;
+exports.verifyIPAddress = toolsValidate.verifyIPAddress;
+exports.verifyIdCard = toolsValidate.verifyIdCard;
+exports.verifyNumberCnUppercase = toolsValidate.verifyNumberCnUppercase;
+exports.verifyNumberComma = toolsValidate.verifyNumberComma;
+exports.verifyNumberIntegerAndFloat = toolsValidate.verifyNumberIntegerAndFloat;
+exports.verifyNumberPercentage = toolsValidate.verifyNumberPercentage;
+exports.verifyNumberPercentageFloat = toolsValidate.verifyNumberPercentageFloat;
+exports.verifyPassword = toolsValidate.verifyPassword;
+exports.verifyPasswordPowerful = toolsValidate.verifyPasswordPowerful;
+exports.verifyPasswordStrength = toolsValidate.verifyPasswordStrength;
+exports.verifyPhone = toolsValidate.verifyPhone;
+exports.verifyPostalCode = toolsValidate.verifyPostalCode;
+exports.verifyTelPhone = toolsValidate.verifyTelPhone;
+exports.verifyTextColor = toolsValidate.verifyTextColor;
+exports.verifyUrl = toolsValidate.verifyUrl;
+exports.formatAxis = formatTime.formatAxis;
+exports.formatDate = formatTime.formatDate;
+exports.formatPast = formatTime.formatPast;
+exports.getWeek = formatTime.getWeek;
+exports.useChangeColor = theme.useChangeColor;
+exports.downloadByBase64 = download.downloadByBase64;
+exports.downloadByData = download.downloadByData;
+exports.downloadByOnlineUrl = download.downloadByOnlineUrl;
+exports.downloadByUrl = download.downloadByUrl;
+exports.downloadStreamFile = download.downloadStreamFile;
+exports.getFileName = download.getFileName;
+exports.openWindow = download.openWindow;
+exports.signatureByKSort = dataSignature.signatureByKSort;
+exports.getFileUrl = uploadfileurl.getFileUrl;
+exports.PUB = index$a.PUB;

package/lib/packages/core/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/core/stores/inpinia.js

@@ -0,0 +1,7 @@
+'use strict';
+
+var pinia$1 = require('pinia');
+
+const pinia = pinia$1.createPinia();
+
+exports.pinia = pinia;

package/lib/packages/core/stores/keepAliveNames.js

@@ -0,0 +1,31 @@
+'use strict';
+
+var pinia = require('pinia');
+
+const useKeepALiveNames = pinia.defineStore("keepALiveNames", {
+  state: () => ({
+    keepAliveNames: [],
+    cachedViews: []
+  }),
+  actions: {
+    async setCacheKeepAlive(data) {
+      this.keepAliveNames = data;
+    },
+    async addCachedView(view) {
+      if (view.meta.isKeepAlive) this.cachedViews?.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/core/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/core/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;