From 340c41a0166ec341edc4e80e004cbaa86d15eef0 Mon Sep 17 00:00:00 2001 From: ray_wuhao <443547225@qq.com> Date: Tue, 4 Apr 2023 15:09:53 +0800 Subject: [PATCH] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E5=8A=A0=E8=BD=BD=E5=8A=A8?= =?UTF-8?q?=E7=94=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .env.development | 2 +- .env.production | 2 +- .env.test | 2 +- CHANGELOG.md | 6 + index.html | 119 ++++++ package.json | 2 +- postcss.config.cjs | 22 +- src/App.tsx | 14 +- src/layout/components/SiderBar/index.tsx | 16 +- src/layout/index.tsx | 3 +- src/router/basic.ts | 3 +- src/router/permission.ts | 4 +- src/store/index.ts | 25 +- src/store/modules/signin.ts | 37 +- src/utils/cache.ts | 8 +- src/utils/crypto.ts | 8 + src/utils/element.ts | 28 +- src/utils/hook.ts | 2 +- src/utils/user.ts | 13 - src/utils/xlsx.ts | 34 +- vite.config.ts.timestamp-1680592192926.mjs | 462 +++++++++++++++++++++ 21 files changed, 744 insertions(+), 68 deletions(-) delete mode 100644 src/utils/user.ts create mode 100644 vite.config.ts.timestamp-1680592192926.mjs diff --git a/.env.development b/.env.development index e67e0b80..d48e91ea 100644 --- a/.env.development +++ b/.env.development @@ -1,7 +1,7 @@ #开发环境 NODE_ENV = 'development' -VITE_APP_URL = 'api/' +VITE_APP_URL = '/api' # office 服务代理地址 VITE_APP_OFFICE_PROXY_URL = '/office/' diff --git a/.env.production b/.env.production index d170e287..d4ddf677 100644 --- a/.env.production +++ b/.env.production @@ -1,7 +1,7 @@ #生产环境 NODE_ENV = 'production' -VITE_APP_URL = 'api/' +VITE_APP_URL = '/' # office 服务代理地址 VITE_APP_OFFICE_PROXY_URL = 'https://office.yka.one/' diff --git a/.env.test b/.env.test index a21549a5..91ceefa8 100644 --- a/.env.test +++ b/.env.test @@ -1,7 +1,7 @@ #测试环境 NODE_ENV = 'test' -VITE_APP_URL = 'api/' +VITE_APP_URL = 'https://testray.yka.moe/doc-json/' # office 服务代理地址 VITE_APP_OFFICE_PROXY_URL = 'https://office.yka.one/' diff --git a/CHANGELOG.md b/CHANGELOG.md index 9628b1a2..5f0ff2b5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,12 @@ ### Fixes - 修复移动端登陆页显示问题 +- 改进了一些方法逻辑的问题 +- 新增加载动画 + +### Feats + +- 修改移动端自适应配置方案(现在使用 postcss-px-to-viewport)，默认不启用 ## 3.1.5 diff --git a/index.html b/index.html index f011b8d6..7b88dac0 100644 --- a/index.html +++ b/index.html @@ -6,8 +6,127 @@ Vite + Vue + TS +
+
+
+
Ray Template
+
+ + + + + + + + + + + +
+
+
diff --git a/package.json b/package.json index bdac2ccc..740f189f 100644 --- a/package.json +++ b/package.json @@ -66,7 +66,7 @@ "husky": "^8.0.3", "lint-staged": "^13.1.0", "postcss": "^8.1.0", - "postcss-pxtorem": "^6.0.0", + "postcss-px-to-viewport": "^1.1.1", "prettier": "^2.7.1", "rollup-plugin-visualizer": "^5.8.3", "svg-sprite-loader": "^6.0.11", diff --git a/postcss.config.cjs b/postcss.config.cjs index 919b07e3..320ef306 100644 --- a/postcss.config.cjs +++ b/postcss.config.cjs @@ -11,11 +11,21 @@ module.exports = { ], grid: true, }, - 'postcss-pxtorem': { - rootValue: 16, // 根元素字体大小或根据 `input` 参数返回根元素字体大小 - unitPrecision: 5, - propList: ['font', 'font-size', 'line-height', 'letter-spacing'], // 可以从 `px` 更改为 `rem` 的属性 - selectorBlackList: [], // 要忽略并保留为 `px` 的选择器 - }, + // 'postcss-px-to-viewport': { + // /** 视窗的宽度(设计稿的宽度) */ + // viewportWidth: 1920, + // /** 视窗的高度(设计稿高度, 一般无需指定) */ + // viewportHeight: 1080, + // /** 指定 px 转换为视窗单位值的小数位数 */ + // unitPrecision: 3, + // /** 指定需要转换成的视窗单位 */ + // viewportUnit: 'vw', + // /** 指定不转换为视窗单位的类 */ + // selectorBlackList: ['.ignore'], + // /** 小于或等于 1px 不转换为视窗单位 */ + // minPixelValue: 1, + // /** 允许在媒体查询中转换 px */ + // mediaQuery: false, + // }, }, } diff --git a/src/App.tsx b/src/App.tsx index 2c772dcd..ab8ecdf2 100644 --- a/src/App.tsx +++ b/src/App.tsx @@ -5,7 +5,7 @@ import GlobalSpin from '@/spin/index' import { getCache } from '@/utils/cache' import { get } from 'lodash-es' import { useSetting } from '@/store' -import { addClass, removeClass } from '@/utils/element' +import { addClass, removeClass, addStyle } from '@/utils/element' const App = defineComponent({ name: 'App', @@ -29,7 +29,19 @@ const App = defineComponent({ body.style.setProperty('--ray-theme-primary-color', _p || primaryColor) } + /** 隐藏加载动画 */ + const hiddenLoadingAnimation = () => { + const el = document.getElementById('pre-loading-animation') + + if (el) { + addStyle(el, { + display: 'none', + }) + } + } + syncPrimaryColorToBody() + hiddenLoadingAnimation() watch( () => themeValue.value, diff --git a/src/layout/components/SiderBar/index.tsx b/src/layout/components/SiderBar/index.tsx index b7e15546..55543c3d 100644 --- a/src/layout/components/SiderBar/index.tsx +++ b/src/layout/components/SiderBar/index.tsx @@ -18,11 +18,11 @@ import SettingDrawer from './components/SettingDrawer/index' import Breadcrumb from './components/Breadcrumb/index' import { useSetting } from '@/store' +import { useSignin } from '@/store' import { localOptions } from '@/language/index' import { useAvatarOptions } from './hook' import { getCache } from '@/utils/cache' import screenfull from 'screenfull' -import { logout } from '@/utils/user' import type { IconEventMapOptions, IconEventMap } from './type' @@ -37,9 +37,11 @@ const SiderBar = defineComponent({ name: 'SiderBar', setup() { const settingStore = useSetting() + const signinStore = useSignin() const { t } = useI18n() const { updateLocale, changeSwitcher } = settingStore + const { logout } = signinStore const { drawerPlacement, breadcrumbSwitch } = storeToRefs(settingStore) const showSettings = ref(false) const person = getCache('person') @@ -145,7 +147,11 @@ const SiderBar = defineComponent({ align="center" justify="space-between" > - + {this.leftIconOptions.map((curr) => ( {{ @@ -163,7 +169,11 @@ const SiderBar = defineComponent({ ))} {this.breadcrumbSwitch ? : ''} - + {this.rightTooltipIconOptions.map((curr) => ( { - const { role } = storeToRefs(useSignin()) + const { signinCallback } = storeToRefs(useSignin()) + const role = computed(() => signinCallback.value.role) const { meta, name } = options const hidden = diff --git a/src/router/permission.ts b/src/router/permission.ts index 0fe72192..c5054a6b 100644 --- a/src/router/permission.ts +++ b/src/router/permission.ts @@ -34,6 +34,7 @@ export const permissionRouter = (router: Router) => { rootRoute: { path }, } = __APP_CFG__ + /** 如果没有权限, 则重定向至首页 */ const redirectToDashboard = (next: NavigationGuardNext) => { next(path) @@ -43,7 +44,8 @@ export const permissionRouter = (router: Router) => { beforeEach((to, from, next) => { const token = getCache('token') const route = getCache('menuKey') - const { role } = storeToRefs(useSignin()) + const { signinCallback } = storeToRefs(useSignin()) + const role = computed(() => signinCallback.value.role) const { meta } = to const hasRole = () => { diff --git a/src/store/index.ts b/src/store/index.ts index 4858b759..b16b3746 100644 --- a/src/store/index.ts +++ b/src/store/index.ts @@ -1,14 +1,33 @@ -import piniaPluginPersistedstate from 'pinia-plugin-persistedstate' +/** + * + * @author Ray + * + * @date 2023-01-03 + * + * @workspace ray-template + * + * @remark 今天也是元气满满撸代码的一天 + */ -import type { App } from 'vue' +/** + * + * 持久化存储 pinia 数据 + * 但是不能正常持久化 function 属性 + * + * 官网地址: https://prazdevs.github.io/pinia-plugin-persistedstate/zh/guide/ + */ +import piniaPluginPersistedstate from 'pinia-plugin-persistedstate' export { useSetting } from './modules/setting' // import { useSetting } from '@/store' 即可使用 export { useMenu } from './modules/menu/index' export { useSignin } from './modules/signin' -const store = createPinia() +import type { App } from 'vue' +/** 设置并且注册 pinia */ export const setupStore = (app: App) => { + const store = createPinia() + app.use(store) store.use(piniaPluginPersistedstate) diff --git a/src/store/modules/signin.ts b/src/store/modules/signin.ts index f784494f..f77574c4 100644 --- a/src/store/modules/signin.ts +++ b/src/store/modules/signin.ts @@ -12,25 +12,34 @@ /** * * 出于便捷性考虑, 将用户部分信息存于 pinia 仓库 - * * 可以存储: 头像, 权限, 以及基于你项目实际情况的一些附带信息 * - * 如果检测权限发生变动, 则会强制重新登陆 + * 使用 sessionStorage 缓存部分用户信息 */ import { isEmpty } from 'lodash-es' -import { logout } from '@/utils/user' +import { removeCache } from '@/utils/cache' export interface SigninForm extends IUnknownObjectKey { name: string pwd: string } +export interface SigninCallback extends IUnknownObjectKey { + role: string + name: string +} + export const useSignin = defineStore( 'signin', () => { const state = reactive({ - role: '', + /** + * + * 登陆返回信息(可以存放用户名、权限、头像等一些信息) + * 路由鉴权依赖该属性中的 role 属性, 如果需要更改请同步更改: router/basic.ts、router/permission.ts + */ + signinCallback: {} as SigninCallback, }) /** @@ -42,7 +51,10 @@ export const useSignin = defineStore( */ const signin = (signinForm: SigninForm) => { if (!isEmpty(signinForm)) { - state.role = 'admin' + state.signinCallback = { + role: 'admin', + name: signinForm.name, + } return 0 } else { @@ -50,14 +62,29 @@ export const useSignin = defineStore( } } + /** + * + * 退出登陆并且清空缓存数据 + * 延迟 300ms 后强制刷新当前系统 + */ + const logout = () => { + window.$message.info('账号退出中...') + removeCache('all-sessionStorage') + + setTimeout(() => window.location.reload(), 300) + } + return { ...toRefs(state), signin, + logout, } }, { persist: { key: 'piniaSigninStore', + paths: ['signinCallback'], + storage: sessionStorage, }, }, ) diff --git a/src/utils/cache.ts b/src/utils/cache.ts index e9ad865f..dada6182 100644 --- a/src/utils/cache.ts +++ b/src/utils/cache.ts @@ -18,8 +18,9 @@ export const setCache = ( /** * * @param key 需要获取目标缓存的key - * * @returns 获取缓存值 + * + * @remark 如果未匹配到目标值则返回字符串 'no' */ export const getCache = (key: string, type: CacheType = 'sessionStorage') => { const data = @@ -33,6 +34,11 @@ export const getCache = (key: string, type: CacheType = 'sessionStorage') => { /** * * @param key 需要删除的缓存值key + * + * key: + * - all: 删除所有缓存值 + * - all-sessionStorage: 删除所有 sessionStorage 缓存值 + * - all-localStorage: 删除所有 localStorage 缓存值 */ export const removeCache = ( key: string | 'all' | 'all-sessionStorage' | 'all-localStorage', diff --git a/src/utils/crypto.ts b/src/utils/crypto.ts index 78fbd1c1..cb2d112f 100644 --- a/src/utils/crypto.ts +++ b/src/utils/crypto.ts @@ -4,6 +4,14 @@ import AES from 'crypto-js/aes' import MD5 from 'crypto-js/md5' import BASE64 from 'crypto-js/enc-base64' +/** + * + * 这个玩意儿实际使用意义不大, 建议自己参考官网 demo 使用 + * 我又不想删除, 所以留在这儿了 + * + * 手动补上官网地址: http://github.com/brix/crypto-js + */ + /** * * @param message 待加密信息 diff --git a/src/utils/element.ts b/src/utils/element.ts index c63bccc6..69821f0b 100644 --- a/src/utils/element.ts +++ b/src/utils/element.ts @@ -11,17 +11,21 @@ export const getElementChildNodes = ( el: HTMLElement, target?: string[] | string, ) => { - let nodes = Array.from(el.childNodes) + if (el) { + let nodes = Array.from(el.childNodes) - if (Array.isArray(target)) { - nodes = nodes.filter((el) => target.includes(el.nodeName)) - } else { - if (target) { - nodes = nodes.filter((el) => el.nodeName === target) + if (Array.isArray(target)) { + nodes = nodes.filter((el) => target.includes(el.nodeName)) + } else { + if (target) { + nodes = nodes.filter((el) => el.nodeName === target) + } } - } - return nodes + return nodes + } else { + return [] + } } /** @@ -65,7 +69,7 @@ export const off = ( /** * * @param element Target element dom - * @param className 所需添加className，可: 'xxx xxx' | 'xxx'格式添加 + * @param className 所需添加className，可: 'xxx xxx' | 'xxx' 格式添加(参考向元素绑定 css 语法) * * @remark 添加元素className(可: 'xxx xxx' | 'xxx'格式添加) */ @@ -84,7 +88,7 @@ export const addClass = (element: HTMLElement, className: string) => { /** * * @param element Target element dom - * @param className 所需删除className，可: 'xxx xxx' | 'xxx'格式删除 + * @param className 所需删除className，可: 'xxx xxx' | 'xxx' 格式删除(参考向元素绑定 css 语法) * * @remark 删除元素className(可: 'xxx xxx' | 'xxx'格式删除) * @remark 如果输入值为 removeAllClass 则会删除该元素所有 class name @@ -113,11 +117,11 @@ export const removeClass = ( /** * * @param element Target element dom - * @param className 查询元素是否含有此className，可: 'xxx xxx' | 'xxx'格式查询 + * @param className 查询元素是否含有此className，可: 'xxx xxx' | 'xxx' 格式查询(参考向元素绑定 css 语法) * * @returns 返回boolean * - * @remark 元素是否含有某个className(可: 'xxx xxx' | 'xxx'格式查询) + * @remark 元素是否含有某个className(可: 'xxx xxx' | 'xxx' 格式查询) */ export const hasClass = (element: HTMLElement, className: string) => { const elementClassName = element.className diff --git a/src/utils/hook.ts b/src/utils/hook.ts index 37b5d772..fe23aeef 100644 --- a/src/utils/hook.ts +++ b/src/utils/hook.ts @@ -72,7 +72,7 @@ export const uuid = (length = 16, radix?: number) => { for (i = 0; i < 36; i++) { if (!arr[i]) { - r = 0 | (Math.random() * 16) + r = 0 | (Math.random() * radix) arr[i] = sad[i === 19 ? (r & 0x3) | 0x8 : r] } diff --git a/src/utils/user.ts b/src/utils/user.ts deleted file mode 100644 index df26f1c5..00000000 --- a/src/utils/user.ts +++ /dev/null @@ -1,13 +0,0 @@ -import { removeCache } from '@/utils/cache' - -/** - * - * @remark 退出登陆并且清除所有非 localStorage 里所有缓存数据 - */ -export const logout = () => { - window.$message.info('账号退出中...') - - removeCache('all-sessionStorage') - - setTimeout(() => window.location.reload(), 300) -} diff --git a/src/utils/xlsx.ts b/src/utils/xlsx.ts index be49dd9c..b7018e9a 100644 --- a/src/utils/xlsx.ts +++ b/src/utils/xlsx.ts @@ -74,25 +74,29 @@ export const exportFileToXLSX = async ( config: ExportXLSXConfig = {}, ) => { await new Promise((resolve, reject) => { - if (dataSource?.length) { - const sheetHeader = setupSheetHeader(columns ?? []) // 获取所有列(设置为 `excel` 表头) - const sheetData = utils.json_to_sheet(dataSource) // 将所有数据转换为表格数据类型 - const workBook = utils.book_new() - const filename = config.filename - ? config.filename + '.xlsx' - : dayjs().format('YYYY-MM-DD') + '导出表格.xlsx' + if (Array.isArray(dataSource)) { + if (dataSource.length) { + const sheetHeader = setupSheetHeader(columns ?? []) // 获取所有列(设置为 `excel` 表头) + const sheetData = utils.json_to_sheet(dataSource) // 将所有数据转换为表格数据类型 + const workBook = utils.book_new() + const filename = config.filename + ? config.filename + '.xlsx' + : dayjs().format('YYYY-MM-DD') + '导出表格.xlsx' - utils.book_append_sheet(workBook, sheetData, 'Data') + utils.book_append_sheet(workBook, sheetData, 'Data') - const range = utils.decode_range(sheetData['!ref'] as string) // 获取所有单元格 + const range = utils.decode_range(sheetData['!ref'] as string) // 获取所有单元格 - if (columns?.length) { - transformSheetHeader(range, sheetData, sheetHeader) + if (columns?.length) { + transformSheetHeader(range, sheetData, sheetHeader) + } + + writeFileXLSX(workBook, filename) // 输出表格 + + resolve() + } else { + resolve() } - - writeFileXLSX(workBook, filename) // 输出表格 - - resolve() } else { reject() } diff --git a/vite.config.ts.timestamp-1680592192926.mjs b/vite.config.ts.timestamp-1680592192926.mjs new file mode 100644 index 00000000..45ebcef2 --- /dev/null +++ b/vite.config.ts.timestamp-1680592192926.mjs @@ -0,0 +1,462 @@ +// vite.config.ts +import { defineConfig } from "file:///Users/daigua/Documents/ray-template/node_modules/vite/dist/node/index.js"; +import vue from "file:///Users/daigua/Documents/ray-template/node_modules/@vitejs/plugin-vue/dist/index.mjs"; + +// vite-plugin/index.ts +import path from "node:path"; +import autoImport from "file:///Users/daigua/Documents/ray-template/node_modules/unplugin-auto-import/dist/vite.js"; +import viteComponents from "file:///Users/daigua/Documents/ray-template/node_modules/unplugin-vue-components/dist/vite.mjs"; +import vueI18nPlugin from "file:///Users/daigua/Documents/ray-template/node_modules/@intlify/unplugin-vue-i18n/lib/vite.mjs"; +import { createSvgIconsPlugin } from "file:///Users/daigua/Documents/ray-template/node_modules/vite-plugin-svg-icons/dist/index.mjs"; +var __vite_injected_original_dirname = "/Users/daigua/Documents/ray-template/vite-plugin"; +var useSVGIcon = (options) => { + const defaultOptions = { + iconDirs: [path.resolve(process.cwd(), "src/icons")], + symbolId: "icon-[dir]-[name]", + inject: "body-last", + customDomId: "__svg__icons__dom__" + }; + return createSvgIconsPlugin(Object.assign({}, defaultOptions, options)); +}; +var useAutoImport = async (imp = []) => autoImport({ + include: [ + /\.[tj]sx?$/, + // .ts, .tsx, .js, .jsx + /\.vue$/, + /\.vue\?vue/, + // .vue + /\.md$/ + // .md + ], + dts: true, + imports: ["vue", "vue-router", "pinia", "@vueuse/core", "vue-i18n", ...imp] +}); +var useViteComponents = async (resolvers = [], types = []) => viteComponents({ + dts: true, + resolvers: [...resolvers], + types: [ + { + from: "vue-router", + names: ["RouterLink", "RouterView"] + }, + ...types + ] +}); +var useVueI18nPlugin = () => vueI18nPlugin({ + runtimeOnly: true, + compositionOnly: true, + forceStringify: true, + defaultSFCLang: "json", + include: [path.resolve(__vite_injected_original_dirname, "../locales/**")] +}); +var HTMLTitlePlugin = (title2) => { + return { + name: "html-transform", + transformIndexHtml: (html) => { + return html.replace(/(.*?)<\/title>/, `<title>${title2}`); + } + }; +}; +var buildOptions = (mode) => { + const outDirMap = { + test: "dist/test-dist", + development: "dist/development-dist", + production: "dist/production-dist", + report: "dist/report-dist" + }; + const dirPath = outDirMap[mode] || "dist/test-dist"; + if (mode === "production") { + return { + outDir: dirPath, + sourcemap: false, + terserOptions: { + compress: { + drop_console: true, + drop_debugger: true + } + } + }; + } else { + return { + outDir: dirPath, + sourcemap: true, + terserOptions: { + compress: { + drop_console: false, + drop_debugger: false + } + } + }; + } +}; +var mixinCSSPlugin = (options) => { + const defaultOptions = []; + if (Array.isArray(options)) { + defaultOptions.push(...options); + } + const mixisString = defaultOptions.reduce((pre, curr) => { + const temp = `@import "${curr}";`; + return pre += temp; + }, ""); + return mixisString; +}; + +// vite.config.ts +import ViteVueJSX from "file:///Users/daigua/Documents/ray-template/node_modules/@vitejs/plugin-vue-jsx/dist/index.mjs"; +import VueI18nPlugin from "file:///Users/daigua/Documents/ray-template/node_modules/@intlify/unplugin-vue-i18n/lib/vite.mjs"; +import ViteInspect from "file:///Users/daigua/Documents/ray-template/node_modules/vite-plugin-inspect/dist/index.mjs"; +import viteSvgLoader from "file:///Users/daigua/Documents/ray-template/node_modules/vite-svg-loader/index.js"; +import viteEslintPlugin from "file:///Users/daigua/Documents/ray-template/node_modules/vite-plugin-eslint/dist/index.mjs"; +import vitePluginImp from "file:///Users/daigua/Documents/ray-template/node_modules/vite-plugin-imp/dist/index.mjs"; +import { visualizer } from "file:///Users/daigua/Documents/ray-template/node_modules/rollup-plugin-visualizer/dist/plugin/index.js"; +import viteCompression from "file:///Users/daigua/Documents/ray-template/node_modules/vite-plugin-compression/dist/index.mjs"; +import { NaiveUiResolver } from "file:///Users/daigua/Documents/ray-template/node_modules/unplugin-vue-components/dist/resolvers.mjs"; + +// cfg.ts +import path2 from "node:path"; +var __vite_injected_original_dirname2 = "/Users/daigua/Documents/ray-template"; +var config = { + /** 默认主题色 */ + primaryColor: "#2d8cf0", + /** + * + * 配置根页面 + * 该项目所有重定向至首页, 都依赖该配置项 + * + * 如果修改了该项目的首页路由配置, 需要更改该配置项, 以免重定向首页操作出现错误 + */ + rootRoute: { + name: "dashboard", + path: "/dashboard" + }, + /** + * + * icon: LOGO 图标, 依赖 `RayIcon` 实现 + * title: LOGO 标题 + * url: 点击跳转地址, 如果不配置该属性, 则不会触发跳转 + * jumpType: 跳转类型（station: 项目内跳转, outsideStation: 新页面打开） + * + * 如果不设置该属性或者为空, 则不会渲染 LOGO + */ + sideBarLogo: { + icon: "ray", + title: "Ray Template", + url: "/dashboard", + jumpType: "station" + }, + /** + * + * 预处理全局需要注入的 css 文件 + * + * 预设: + * - ./src/styles/mixins.scss + * - ./src/styles/setting.scss + * - ./src/styles/theme.scss + * + * 如果需要删除或者修改, 需要同步修改目录下的 css 文件 + */ + mixinCSS: mixinCSSPlugin([ + "./src/styles/mixins.scss", + "./src/styles/setting.scss", + "./src/styles/theme.scss" + ]), + /** + * + * 版权信息 + * + * 也可以当作页底设置, 看实际业务需求 + */ + copyright: "Copyright \xA9 2022-present Ray", + /** + * + * 浏览器标题 + */ + title: HTMLTitlePlugin("ray template"), + /** + * + * 配置 HMR 特定选项（端口、主机、路径和协议） + */ + server: { + host: "0.0.0.0", + port: 9527, + open: false, + https: false, + strictPort: false, + fs: { + strict: false, + allow: [] + }, + proxy: { + "/api": { + target: "url", + changeOrigin: true, + rewrite: (path3) => path3.replace(/^\/api/, "") + }, + "/office": { + target: "https://office.yka.one/", + changeOrigin: true, + rewrite: (path3) => path3.replace(/^\/office/, "") + } + } + }, + /** + * + * 打包相关配置 + */ + buildOptions, + /** + * + * 预设别名 + * - `@`: `src` 根目录 + * - `@use-utils`: `src/utils` 根目录 + * - `@use-api`: `src/axios/api` 根目录 + * - `@use-images`: `src/assets/images` 根目录 + */ + alias: [ + { + find: "@", + replacement: path2.resolve(__vite_injected_original_dirname2, "./src") + }, + { + find: "@use-utils", + replacement: path2.resolve(__vite_injected_original_dirname2, "./src/utils") + }, + { + find: "@use-api", + replacement: path2.resolve(__vite_injected_original_dirname2, "./src/axios/api") + }, + { + find: "@use-images", + replacement: path2.resolve(__vite_injected_original_dirname2, "./src/assets/images") + } + ] +}; +var cfg_default = config; + +// package.json +var package_default = { + name: "ray-template", + private: true, + version: "3.1.6", + type: "module", + scripts: { + dev: "vite", + build: "vue-tsc --noEmit && vite build --mode production", + preview: "vite preview", + test: "vue-tsc --noEmit && vite build --mode test", + "dev-build": "vue-tsc --noEmit && vite build --mode development", + report: "vue-tsc --noEmit && vite build --mode report", + prepare: "husky install" + }, + "lint-staged": { + "src/**/*.{vue,jsx,ts,tsx,json}": [ + "prettier --write", + "eslint", + "git add" + ] + }, + dependencies: { + "@vueuse/core": "^9.1.0", + "amfe-flexible": "^2.2.1", + axios: "^1.2.0", + "crypto-js": "^4.1.1", + dayjs: "^1.11.7", + echarts: "^5.4.0", + "lodash-es": "^4.17.21", + "naive-ui": "^2.34.3", + pinia: "^2.0.17", + "pinia-plugin-persistedstate": "^2.4.0", + "print-js": "^1.6.0", + "qrcode.vue": "^3.3.4", + sass: "^1.54.3", + screenfull: "^6.0.2", + vue: "^3.2.37", + "vue-i18n": "^9.2.2", + "vue-router": "^4.1.3", + vuedraggable: "^4.1.0", + xlsx: "^0.18.5" + }, + devDependencies: { + "@babel/core": "^7.20.2", + "@babel/eslint-parser": "^7.19.1", + "@commitlint/cli": "^17.4.2", + "@commitlint/config-conventional": "^17.4.2", + "@intlify/unplugin-vue-i18n": "^0.5.0", + "@types/crypto-js": "^4.1.1", + "@types/scrollreveal": "^0.0.8", + "@typescript-eslint/eslint-plugin": "^5.42.1", + "@typescript-eslint/parser": "^5.42.1", + "@vitejs/plugin-vue": "^3.0.0", + "@vitejs/plugin-vue-jsx": "^2.0.0", + autoprefixer: "^10.4.8", + depcheck: "^1.4.3", + eslint: "^8.0.1", + "eslint-config-prettier": "^8.5.0", + "eslint-config-standard-with-typescript": "^23.0.0", + "eslint-plugin-import": "^2.25.2", + "eslint-plugin-n": "^15.0.0", + "eslint-plugin-prettier": "^4.2.1", + "eslint-plugin-promise": "^6.0.0", + "eslint-plugin-react": "^7.31.10", + "eslint-plugin-vue": "^9.7.0", + husky: "^8.0.3", + "lint-staged": "^13.1.0", + postcss: "^8.1.0", + "postcss-px-to-viewport": "^1.1.1", + prettier: "^2.7.1", + "rollup-plugin-visualizer": "^5.8.3", + "svg-sprite-loader": "^6.0.11", + typescript: "*", + "unplugin-auto-import": "^0.11.0", + "unplugin-vue-components": "^0.22.0", + vite: "^4.1.4", + "vite-plugin-compression": "^0.5.1", + "vite-plugin-eslint": "^1.8.1", + "vite-plugin-imp": "^2.3.1", + "vite-plugin-inspect": "^0.6.0", + "vite-plugin-svg-icons": "^2.0.1", + "vite-svg-loader": "^3.4.0", + "vue-tsc": "^1.0.9" + } +}; + +// vite.config.ts +var { dependencies, devDependencies, name, version } = package_default; +var { + server, + buildOptions: buildOptions2, + alias, + title, + copyright, + sideBarLogo, + mixinCSS, + rootRoute, + primaryColor +} = cfg_default; +var __APP_CFG__ = { + pkg: { dependencies, devDependencies, name, version }, + layout: { + copyright, + sideBarLogo + }, + rootRoute, + primaryColor +}; +var vite_config_default = defineConfig(async ({ mode }) => { + return { + define: { + __APP_CFG__: JSON.stringify(__APP_CFG__) + }, + resolve: { + alias + }, + plugins: [ + vue({ reactivityTransform: true }), + ViteVueJSX(), + title, + ViteInspect(), + // 仅适用于开发模式(检查 `Vite` 插件的中间状态) + VueI18nPlugin(), + await useAutoImport([ + { + "naive-ui": [ + "useDialog", + "useMessage", + "useNotification", + "useLoadingBar" + ] + } + ]), + await useViteComponents([NaiveUiResolver()]), + viteCompression(), + useVueI18nPlugin(), + viteSvgLoader({ + defaultImport: "component" + // 默认以 `componetn` 形式导入 `svg` + }), + useSVGIcon(), + viteEslintPlugin({ + lintOnStart: true, + // 构建时自动检查 + failOnWarning: true, + // 如果含有警告则构建失败 + failOnError: true, + // 如果有错误则构建失败 + cache: true, + // 缓存, 减少构建时间 + exclude: ["**/node_modules/**", "vite-env.d.ts"], + include: ["src/**/*.ts", "src/**/*.vue", "src/**/*.tsx"] + }), + vitePluginImp({ + libList: [ + { + libName: "lodash-es", + libDirectory: "", + camel2DashComponentName: false + }, + { + libName: "@vueuse", + libDirectory: "", + camel2DashComponentName: false + } + ] + }), + { + include: [ + "src/**/*.ts", + "src/**/*.tsx", + "src/**/*.vue", + "src/*.ts", + "src/*.tsx", + "src/*.vue" + ] + }, + visualizer({ + gzipSize: true, + // 搜集 `gzip` 压缩包 + brotliSize: true, + // 搜集 `brotli` 压缩包 + emitFile: false, + // 生成文件在根目录下 + filename: "visualizer.html", + open: mode === "report" ? true : false + // 以默认服务器代理打开文件 + }) + ], + optimizeDeps: { + include: ["vue", "vue-router", "pinia", "vue-i18n", "@vueuse/core"] + }, + esbuild: { + pure: ["console.log"] + }, + build: { + ...buildOptions2(mode), + rollupOptions: { + output: { + manualChunks: (id) => { + if (id.includes("node_modules")) { + return id.toString().split("node_modules/")[1].split("/")[0].toString(); + } + } + } + } + }, + css: { + preprocessorOptions: { + scss: { + additionalData: mixinCSS + } + }, + modules: { + localsConvention: "camelCaseOnly" + } + }, + server: { + ...server + } + }; +}); +export { + vite_config_default as default +}; +//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["vite.config.ts", "vite-plugin/index.ts", "cfg.ts", "package.json"],
  "sourcesContent": ["const __vite_injected_original_dirname = \"/Users/daigua/Documents/ray-template\";const __vite_injected_original_filename = \"/Users/daigua/Documents/ray-template/vite.config.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/daigua/Documents/ray-template/vite.config.ts\";import { defineConfig } from 'vite'\nimport vue from '@vitejs/plugin-vue'\n\nimport {\n  useAutoImport,\n  useViteComponents,\n  useVueI18nPlugin,\n  useSVGIcon,\n} from './vite-plugin/index'\n\nimport ViteVueJSX from '@vitejs/plugin-vue-jsx'\nimport VueI18nPlugin from '@intlify/unplugin-vue-i18n/vite'\nimport ViteInspect from 'vite-plugin-inspect'\nimport viteSvgLoader from 'vite-svg-loader'\nimport viteEslintPlugin from 'vite-plugin-eslint'\nimport vitePluginImp from 'vite-plugin-imp' // \u6309\u9700\u6253\u5305\u5DE5\u5177\nimport { visualizer } from 'rollup-plugin-visualizer' // \u6253\u5305\u4F53\u79EF\u5206\u6790\u5DE5\u5177\nimport viteCompression from 'vite-plugin-compression' // \u538B\u7F29\u6253\u5305\n\nimport { NaiveUiResolver } from 'unplugin-vue-components/resolvers' // \u6A21\u677F\u81EA\u52A8\u5BFC\u5165\u7EC4\u4EF6\u5E76\u4E14\u6309\u9700\u6253\u5305\n\nimport config from './cfg'\nimport pkg from './package.json'\n\nconst { dependencies, devDependencies, name, version } = pkg\nconst {\n  server,\n  buildOptions,\n  alias,\n  title,\n  copyright,\n  sideBarLogo,\n  mixinCSS,\n  rootRoute,\n  primaryColor,\n} = config\n\n/**\n *\n * \u5168\u5C40\u6CE8\u5165 `__APP_CFG__` \u53D8\u91CF\n *\n * \u53EF\u4EE5\u5728 `views` \u9875\u9762\u4F7F\u7528\n *\n * \u4F7F\u7528\u65B9\u6CD5 `const { pkg, layout } = __APP_CFG__`\n *\n * \u5982\u679C\u6709\u65B0\u7684\u8865\u5145, \u9700\u8981\u81EA\u5DF1\u624B\u52A8\u8865\u5145\u7C7B\u578B `src/types/cfg.ts AppConfig`\n */\nconst __APP_CFG__ = {\n  pkg: { dependencies, devDependencies, name, version },\n  layout: {\n    copyright,\n    sideBarLogo,\n  },\n  rootRoute,\n  primaryColor,\n}\n\n// https://vitejs.dev/config/\nexport default defineConfig(async ({ mode }) => {\n  return {\n    define: {\n      __APP_CFG__: JSON.stringify(__APP_CFG__),\n    },\n    resolve: {\n      alias: alias,\n    },\n    plugins: [\n      vue({ reactivityTransform: true }),\n      ViteVueJSX(),\n      title,\n      ViteInspect(), // \u4EC5\u9002\u7528\u4E8E\u5F00\u53D1\u6A21\u5F0F(\u68C0\u67E5 `Vite` \u63D2\u4EF6\u7684\u4E2D\u95F4\u72B6\u6001)\n      VueI18nPlugin(),\n      await useAutoImport([\n        {\n          'naive-ui': [\n            'useDialog',\n            'useMessage',\n            'useNotification',\n            'useLoadingBar',\n          ],\n        },\n      ]),\n      await useViteComponents([NaiveUiResolver()]),\n      viteCompression(),\n      useVueI18nPlugin(),\n      viteSvgLoader({\n        defaultImport: 'component', // \u9ED8\u8BA4\u4EE5 `componetn` \u5F62\u5F0F\u5BFC\u5165 `svg`\n      }),\n      useSVGIcon(),\n      viteEslintPlugin({\n        lintOnStart: true, // \u6784\u5EFA\u65F6\u81EA\u52A8\u68C0\u67E5\n        failOnWarning: true, // \u5982\u679C\u542B\u6709\u8B66\u544A\u5219\u6784\u5EFA\u5931\u8D25\n        failOnError: true, // \u5982\u679C\u6709\u9519\u8BEF\u5219\u6784\u5EFA\u5931\u8D25\n        cache: true, // \u7F13\u5B58, \u51CF\u5C11\u6784\u5EFA\u65F6\u95F4\n        exclude: ['**/node_modules/**', 'vite-env.d.ts'],\n        include: ['src/**/*.ts', 'src/**/*.vue', 'src/**/*.tsx'],\n      }),\n      vitePluginImp({\n        libList: [\n          {\n            libName: 'lodash-es',\n            libDirectory: '',\n            camel2DashComponentName: false,\n          },\n          {\n            libName: '@vueuse',\n            libDirectory: '',\n            camel2DashComponentName: false,\n          },\n        ],\n      }),\n      {\n        include: [\n          'src/**/*.ts',\n          'src/**/*.tsx',\n          'src/**/*.vue',\n          'src/*.ts',\n          'src/*.tsx',\n          'src/*.vue',\n        ],\n      },\n      visualizer({\n        gzipSize: true, // \u641C\u96C6 `gzip` \u538B\u7F29\u5305\n        brotliSize: true, // \u641C\u96C6 `brotli` \u538B\u7F29\u5305\n        emitFile: false, // \u751F\u6210\u6587\u4EF6\u5728\u6839\u76EE\u5F55\u4E0B\n        filename: 'visualizer.html',\n        open: mode === 'report' ? true : false, // \u4EE5\u9ED8\u8BA4\u670D\u52A1\u5668\u4EE3\u7406\u6253\u5F00\u6587\u4EF6\n      }),\n    ],\n    optimizeDeps: {\n      include: ['vue', 'vue-router', 'pinia', 'vue-i18n', '@vueuse/core'],\n    },\n    esbuild: {\n      pure: ['console.log'],\n    },\n    build: {\n      ...buildOptions(mode),\n      rollupOptions: {\n        output: {\n          manualChunks: (id) => {\n            if (id.includes('node_modules')) {\n              return id\n                .toString()\n                .split('node_modules/')[1]\n                .split('/')[0]\n                .toString()\n            }\n          },\n        },\n      },\n    },\n    css: {\n      preprocessorOptions: {\n        scss: {\n          additionalData: mixinCSS,\n        },\n      },\n      modules: {\n        localsConvention: 'camelCaseOnly',\n      },\n    },\n    server: {\n      ...server,\n    },\n  }\n})\n", "const __vite_injected_original_dirname = \"/Users/daigua/Documents/ray-template/vite-plugin\";const __vite_injected_original_filename = \"/Users/daigua/Documents/ray-template/vite-plugin/index.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/daigua/Documents/ray-template/vite-plugin/index.ts\";import path from 'node:path'\n\nimport autoImport from 'unplugin-auto-import/vite' // \u81EA\u52A8\u5BFC\u5165\nimport viteComponents from 'unplugin-vue-components/vite' // \u81EA\u52A8\u6309\u9700\u5BFC\u5165\nimport vueI18nPlugin from '@intlify/unplugin-vue-i18n/vite' // i18n\nimport { createSvgIconsPlugin } from 'vite-plugin-svg-icons' // `svg icon`\n\nimport type { ComponentResolver, TypeImport } from 'unplugin-vue-components'\nimport type { ImportsMap, PresetName } from 'unplugin-auto-import/types'\nimport type { BuildOptions } from 'vite'\nimport type { ViteSvgIconsPlugin } from 'vite-plugin-svg-icons'\n\n/**\n *\n * @param options `svg icon` \u81EA\u5B9A\u4E49\u914D\u7F6E\n *\n * \u4F7F\u7528 `svg` \u4F5C\u4E3A\u56FE\u6807\n */\nexport const useSVGIcon = (options?: ViteSvgIconsPlugin) => {\n  const defaultOptions = {\n    iconDirs: [path.resolve(process.cwd(), 'src/icons')],\n    symbolId: 'icon-[dir]-[name]',\n    inject: 'body-last',\n    customDomId: '__svg__icons__dom__',\n  }\n\n  return createSvgIconsPlugin(Object.assign({}, defaultOptions, options))\n}\n\n/**\n *\n * @param imp \u81EA\u52A8\u5BFC\u5165\u4F9D\u8D56\n * @returns auto import plugin\n *\n * \u81EA\u52A8\u5BFC\u5165\n */\nexport const useAutoImport = async (imp: (ImportsMap | PresetName)[] = []) =>\n  autoImport({\n    include: [\n      /\\.[tj]sx?$/, // .ts, .tsx, .js, .jsx\n      /\\.vue$/,\n      /\\.vue\\?vue/, // .vue\n      /\\.md$/, // .md\n    ],\n    dts: true,\n    imports: ['vue', 'vue-router', 'pinia', '@vueuse/core', 'vue-i18n', ...imp],\n  })\n\n/**\n *\n * @param resolvers \u6309\u9700\u52A0\u8F7D\u4F9D\u8D56\u9879\n * @param types \u6309\u9700\u52A0\u8F7D\u4F9D\u8D56\u7C7B\u578B\n *\n * \u6309\u9700\u52A0\u8F7D\n */\nexport const useViteComponents = async (\n  resolvers: (ComponentResolver | ComponentResolver[])[] = [],\n  types: TypeImport[] = [],\n) =>\n  viteComponents({\n    dts: true,\n    resolvers: [...resolvers],\n    types: [\n      {\n        from: 'vue-router',\n        names: ['RouterLink', 'RouterView'],\n      },\n      ...types,\n    ],\n  })\n\nexport const useVueI18nPlugin = () =>\n  vueI18nPlugin({\n    runtimeOnly: true,\n    compositionOnly: true,\n    forceStringify: true,\n    defaultSFCLang: 'json',\n    include: [path.resolve(__dirname, '../locales/**')],\n  })\n\n/**\n *\n * @param title \u6D4F\u89C8\u5668 title \u540D\u79F0\n */\nexport const HTMLTitlePlugin = (title: string) => {\n  return {\n    name: 'html-transform',\n    transformIndexHtml: (html: string) => {\n      return html.replace(/<title>(.*?)<\\/title>/, `<title>${title}</title>`)\n    },\n  }\n}\n\n/**\n *\n * @param mode \u6253\u5305\u73AF\u5883\n *\n * @remark \u6253\u5305\u8F93\u51FA\u6587\u4EF6\u914D\u7F6E\n */\nexport const buildOptions = (mode: string): BuildOptions => {\n  const outDirMap = {\n    test: 'dist/test-dist',\n    development: 'dist/development-dist',\n    production: 'dist/production-dist',\n    report: 'dist/report-dist',\n  }\n  const dirPath = outDirMap[mode] || 'dist/test-dist'\n\n  if (mode === 'production') {\n    return {\n      outDir: dirPath,\n      sourcemap: false,\n      terserOptions: {\n        compress: {\n          drop_console: true,\n          drop_debugger: true,\n        },\n      },\n    }\n  } else {\n    return {\n      outDir: dirPath,\n      sourcemap: true,\n      terserOptions: {\n        compress: {\n          drop_console: false,\n          drop_debugger: false,\n        },\n      },\n    }\n  }\n}\n\n/**\n *\n * @param options \u81EA\u5B9A\u4E49\u6253\u5305\u914D\u7F6E\u53C2\u6570\n *\n * @remark \u79FB\u9664 console debugger \u4F1A\u6709\u4E25\u91CD\u7684\u526F\u4F5C\u7528, \u5982\u679C console \u8BED\u53E5\u4E2D\u542B\u6709\u53D8\u91CF\u8F93\u51FA, \u5219\u4F1A\u963B\u6B62\u79FB\u9664\n * @remark console \u53EF\u80FD\u4F1A\u5BFC\u81F4\u5185\u5B58\u6CC4\u6F0F, \u8BF7\u6CE8\u610F\u4F7F\u7528\n */\nexport const useViteBuildPlugin = (options?: BuildOptions) => {\n  const defaultPlugin: BuildOptions = {\n    outDir: 'dist', // \u6253\u5305\u540E\u6587\u4EF6\u8F93\u51FA\u8DEF\u5F84\n    assetsDir: 'assets', // \u6307\u5B9A\u9759\u6001\u8D44\u6E90\u5B58\u653E\u8DEF\u5F84\n    assetsInlineLimit: 4096, // \u5C0F\u4E8E\u8FD9\u4E2A\u6570\u5B57(\u5B57\u8282)\u7684\u9759\u6001\u8D44\u4EA7\u6587\u4EF6\u5C06\u88AB\u5185\u8054\u4E3A(base64)\n    cssCodeSplit: true, // \u62C6\u5206css\u4EE3\u7801\n    minify: 'esbuild', // \u6307\u5B9A\u4F7F\u7528\u6DF7\u6DC6\u5668 (terser | esbuild)\n    sourcemap: false,\n    terserOptions: {\n      compress: {\n        drop_console: true, // \u6253\u5305\u540E\u79FB\u9664console\n        drop_debugger: true, // \u6253\u5305\u540E\u79FB\u9664debugger\n      },\n    },\n  }\n\n  return Object.assign({}, defaultPlugin, options)\n}\n\n/**\n *\n * @param options \u9884\u5904\u7406 css \u6587\u4EF6\n * @returns additionalData string\n *\n * @remark \u8F85\u52A9\u5904\u7406\u9700\u8981\u5168\u5C40\u6CE8\u5165\u7684 css \u6837\u5F0F\u6587\u4EF6, \u4F1A\u5728\u6784\u5EFA\u671F\u95F4\u5B8C\u6210\u6CE8\u5165\n */\nexport const mixinCSSPlugin = (options?: string[]) => {\n  const defaultOptions = []\n\n  if (Array.isArray(options)) {\n    defaultOptions.push(...options)\n  }\n\n  const mixisString = defaultOptions.reduce((pre, curr) => {\n    const temp = `@import \"${curr}\";`\n\n    return (pre += temp)\n  }, '')\n\n  return mixisString as string\n}\n", "const __vite_injected_original_dirname = \"/Users/daigua/Documents/ray-template\";const __vite_injected_original_filename = \"/Users/daigua/Documents/ray-template/cfg.ts\";const __vite_injected_original_import_meta_url = \"file:///Users/daigua/Documents/ray-template/cfg.ts\";import path from 'node:path'\n\nimport {\n  HTMLTitlePlugin,\n  buildOptions,\n  mixinCSSPlugin,\n} from './vite-plugin/index'\n\nimport type { AppConfigExport } from './src/types/cfg'\n\nconst config: AppConfigExport = {\n  /** \u9ED8\u8BA4\u4E3B\u9898\u8272 */\n  primaryColor: '#2d8cf0',\n  /**\n   *\n   * \u914D\u7F6E\u6839\u9875\u9762\n   * \u8BE5\u9879\u76EE\u6240\u6709\u91CD\u5B9A\u5411\u81F3\u9996\u9875, \u90FD\u4F9D\u8D56\u8BE5\u914D\u7F6E\u9879\n   *\n   * \u5982\u679C\u4FEE\u6539\u4E86\u8BE5\u9879\u76EE\u7684\u9996\u9875\u8DEF\u7531\u914D\u7F6E, \u9700\u8981\u66F4\u6539\u8BE5\u914D\u7F6E\u9879, \u4EE5\u514D\u91CD\u5B9A\u5411\u9996\u9875\u64CD\u4F5C\u51FA\u73B0\u9519\u8BEF\n   */\n  rootRoute: {\n    name: 'dashboard',\n    path: '/dashboard',\n  },\n  /**\n   *\n   * icon: LOGO \u56FE\u6807, \u4F9D\u8D56 `RayIcon` \u5B9E\u73B0\n   * title: LOGO \u6807\u9898\n   * url: \u70B9\u51FB\u8DF3\u8F6C\u5730\u5740, \u5982\u679C\u4E0D\u914D\u7F6E\u8BE5\u5C5E\u6027, \u5219\u4E0D\u4F1A\u89E6\u53D1\u8DF3\u8F6C\n   * jumpType: \u8DF3\u8F6C\u7C7B\u578B\uFF08station: \u9879\u76EE\u5185\u8DF3\u8F6C, outsideStation: \u65B0\u9875\u9762\u6253\u5F00\uFF09\n   *\n   * \u5982\u679C\u4E0D\u8BBE\u7F6E\u8BE5\u5C5E\u6027\u6216\u8005\u4E3A\u7A7A, \u5219\u4E0D\u4F1A\u6E32\u67D3 LOGO\n   */\n  sideBarLogo: {\n    icon: 'ray',\n    title: 'Ray Template',\n    url: '/dashboard',\n    jumpType: 'station',\n  },\n  /**\n   *\n   * \u9884\u5904\u7406\u5168\u5C40\u9700\u8981\u6CE8\u5165\u7684 css \u6587\u4EF6\n   *\n   * \u9884\u8BBE:\n   *   - ./src/styles/mixins.scss\n   *   - ./src/styles/setting.scss\n   *   - ./src/styles/theme.scss\n   *\n   * \u5982\u679C\u9700\u8981\u5220\u9664\u6216\u8005\u4FEE\u6539, \u9700\u8981\u540C\u6B65\u4FEE\u6539\u76EE\u5F55\u4E0B\u7684 css \u6587\u4EF6\n   */\n  mixinCSS: mixinCSSPlugin([\n    './src/styles/mixins.scss',\n    './src/styles/setting.scss',\n    './src/styles/theme.scss',\n  ]),\n  /**\n   *\n   * \u7248\u6743\u4FE1\u606F\n   *\n   * \u4E5F\u53EF\u4EE5\u5F53\u4F5C\u9875\u5E95\u8BBE\u7F6E, \u770B\u5B9E\u9645\u4E1A\u52A1\u9700\u6C42\n   */\n  copyright: 'Copyright \u00A9 2022-present Ray',\n  /**\n   *\n   * \u6D4F\u89C8\u5668\u6807\u9898\n   */\n  title: HTMLTitlePlugin('ray template'),\n  /**\n   *\n   * \u914D\u7F6E HMR \u7279\u5B9A\u9009\u9879\uFF08\u7AEF\u53E3\u3001\u4E3B\u673A\u3001\u8DEF\u5F84\u548C\u534F\u8BAE\uFF09\n   */\n  server: {\n    host: '0.0.0.0',\n    port: 9527,\n    open: false,\n    https: false,\n    strictPort: false,\n    fs: {\n      strict: false,\n      allow: [],\n    },\n    proxy: {\n      '/api': {\n        target: 'url',\n        changeOrigin: true,\n        rewrite: (path) => path.replace(/^\\/api/, ''),\n      },\n      '/office': {\n        target: 'https://office.yka.one/',\n        changeOrigin: true,\n        rewrite: (path) => path.replace(/^\\/office/, ''),\n      },\n    },\n  },\n  /**\n   *\n   * \u6253\u5305\u76F8\u5173\u914D\u7F6E\n   */\n  buildOptions: buildOptions,\n  /**\n   *\n   * \u9884\u8BBE\u522B\u540D\n   * - `@`: `src` \u6839\u76EE\u5F55\n   * - `@use-utils`: `src/utils` \u6839\u76EE\u5F55\n   * - `@use-api`: `src/axios/api` \u6839\u76EE\u5F55\n   * - `@use-images`: `src/assets/images` \u6839\u76EE\u5F55\n   */\n  alias: [\n    {\n      find: '@',\n      replacement: path.resolve(__dirname, './src'),\n    },\n    {\n      find: '@use-utils',\n      replacement: path.resolve(__dirname, './src/utils'),\n    },\n    {\n      find: '@use-api',\n      replacement: path.resolve(__dirname, './src/axios/api'),\n    },\n    {\n      find: '@use-images',\n      replacement: path.resolve(__dirname, './src/assets/images'),\n    },\n  ],\n}\n\nexport default config\n", "{\n  \"name\": \"ray-template\",\n  \"private\": true,\n  \"version\": \"3.1.6\",\n  \"type\": \"module\",\n  \"scripts\": {\n    \"dev\": \"vite\",\n    \"build\": \"vue-tsc --noEmit && vite build --mode production\",\n    \"preview\": \"vite preview\",\n    \"test\": \"vue-tsc --noEmit && vite build --mode test\",\n    \"dev-build\": \"vue-tsc --noEmit && vite build --mode development\",\n    \"report\": \"vue-tsc --noEmit && vite build --mode report\",\n    \"prepare\": \"husky install\"\n  },\n  \"lint-staged\": {\n    \"src/**/*.{vue,jsx,ts,tsx,json}\": [\n      \"prettier --write\",\n      \"eslint\",\n      \"git add\"\n    ]\n  },\n  \"dependencies\": {\n    \"@vueuse/core\": \"^9.1.0\",\n    \"amfe-flexible\": \"^2.2.1\",\n    \"axios\": \"^1.2.0\",\n    \"crypto-js\": \"^4.1.1\",\n    \"dayjs\": \"^1.11.7\",\n    \"echarts\": \"^5.4.0\",\n    \"lodash-es\": \"^4.17.21\",\n    \"naive-ui\": \"^2.34.3\",\n    \"pinia\": \"^2.0.17\",\n    \"pinia-plugin-persistedstate\": \"^2.4.0\",\n    \"print-js\": \"^1.6.0\",\n    \"qrcode.vue\": \"^3.3.4\",\n    \"sass\": \"^1.54.3\",\n    \"screenfull\": \"^6.0.2\",\n    \"vue\": \"^3.2.37\",\n    \"vue-i18n\": \"^9.2.2\",\n    \"vue-router\": \"^4.1.3\",\n    \"vuedraggable\": \"^4.1.0\",\n    \"xlsx\": \"^0.18.5\"\n  },\n  \"devDependencies\": {\n    \"@babel/core\": \"^7.20.2\",\n    \"@babel/eslint-parser\": \"^7.19.1\",\n    \"@commitlint/cli\": \"^17.4.2\",\n    \"@commitlint/config-conventional\": \"^17.4.2\",\n    \"@intlify/unplugin-vue-i18n\": \"^0.5.0\",\n    \"@types/crypto-js\": \"^4.1.1\",\n    \"@types/scrollreveal\": \"^0.0.8\",\n    \"@typescript-eslint/eslint-plugin\": \"^5.42.1\",\n    \"@typescript-eslint/parser\": \"^5.42.1\",\n    \"@vitejs/plugin-vue\": \"^3.0.0\",\n    \"@vitejs/plugin-vue-jsx\": \"^2.0.0\",\n    \"autoprefixer\": \"^10.4.8\",\n    \"depcheck\": \"^1.4.3\",\n    \"eslint\": \"^8.0.1\",\n    \"eslint-config-prettier\": \"^8.5.0\",\n    \"eslint-config-standard-with-typescript\": \"^23.0.0\",\n    \"eslint-plugin-import\": \"^2.25.2\",\n    \"eslint-plugin-n\": \"^15.0.0\",\n    \"eslint-plugin-prettier\": \"^4.2.1\",\n    \"eslint-plugin-promise\": \"^6.0.0\",\n    \"eslint-plugin-react\": \"^7.31.10\",\n    \"eslint-plugin-vue\": \"^9.7.0\",\n    \"husky\": \"^8.0.3\",\n    \"lint-staged\": \"^13.1.0\",\n    \"postcss\": \"^8.1.0\",\n    \"postcss-px-to-viewport\": \"^1.1.1\",\n    \"prettier\": \"^2.7.1\",\n    \"rollup-plugin-visualizer\": \"^5.8.3\",\n    \"svg-sprite-loader\": \"^6.0.11\",\n    \"typescript\": \"*\",\n    \"unplugin-auto-import\": \"^0.11.0\",\n    \"unplugin-vue-components\": \"^0.22.0\",\n    \"vite\": \"^4.1.4\",\n    \"vite-plugin-compression\": \"^0.5.1\",\n    \"vite-plugin-eslint\": \"^1.8.1\",\n    \"vite-plugin-imp\": \"^2.3.1\",\n    \"vite-plugin-inspect\": \"^0.6.0\",\n    \"vite-plugin-svg-icons\": \"^2.0.1\",\n    \"vite-svg-loader\": \"^3.4.0\",\n    \"vue-tsc\": \"^1.0.9\"\n  }\n}\n"],
  "mappings": "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",
  "names": ["title", "path", "__vite_injected_original_dirname", "path", "__vite_injected_original_dirname", "buildOptions"]
}
