@pubinfo/vite 0.6.3

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+import * as vite from 'vite';
+import { UserConfig } from 'vite';
+
+declare function defineConfig(defineOptions?: UserConfig): vite.UserConfigExport;
+
+export { defineConfig };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+
+/// <reference types="@intlify/unplugin-vue-i18n/messages" />
+/// <reference types="unplugin-icons/types/vue" />
+/// <reference types="vite-plugin-vue-meta-layouts/client" />
+
+import * as vite from 'vite';
+import { UserConfig } from 'vite';
+
+declare function defineConfig(defineOptions?: UserConfig): vite.UserConfigExport;
+
+export { defineConfig };

package/dist/index.mjs

@@ -0,0 +1,623 @@
+import process from 'node:process';
+import path, { resolve as resolve$1, relative, join } from 'node:path';
+import { defineConfig as defineConfig$1, loadEnv, mergeConfig } from 'vite';
+import vue from '@vitejs/plugin-vue';
+import vueJsx from '@vitejs/plugin-vue-jsx';
+import vueLegacy from '@vitejs/plugin-legacy';
+import autoImport from 'unplugin-auto-import/vite';
+import { AntDesignVueResolver } from 'unplugin-vue-components/resolvers';
+import IconsResolver from 'unplugin-icons/resolver';
+import components from 'unplugin-vue-components/vite';
+import Unocss from 'unocss/vite';
+import { createSvgIconsPlugin } from 'vite-plugin-svg-icons';
+import vueI18n from '@intlify/unplugin-vue-i18n/vite';
+import { vitePluginFakeServer } from 'vite-plugin-fake-server';
+import Layouts from 'vite-plugin-vue-meta-layouts';
+import compression from 'vite-plugin-compression';
+import banner from 'vite-plugin-banner';
+import dayjs from 'dayjs';
+import fg from 'fast-glob';
+import { Buffer } from 'node:buffer';
+import { readFileSync, writeFileSync, readdirSync, statSync } from 'node:fs';
+import JSZip from 'jszip';
+import fse from 'fs-extra/esm';
+import consola$1, { consola } from 'consola';
+import Icons from 'unplugin-icons/vite';
+import TurboConsole from 'unplugin-turbo-console/vite';
+import VueDevTools from 'vite-plugin-vue-devtools';
+import OpenAPI from '@pubinfo/unplugin-openapi/vite';
+import EnvRuntime from 'vite-plugin-env-runtime';
+import boxen from 'boxen';
+import chalk from 'chalk';
+import { readPackageJSON } from 'pkg-types';
+import fs from 'node:fs/promises';
+
+function resolve(name) {
+  if (!name.startsWith("usePub")) {
+    return;
+  }
+  return {
+    name,
+    from: "@pubinfo/composables"
+  };
+}
+function PubInfoResolver$1() {
+  return (name) => {
+    return resolve(name);
+  };
+}
+
+function createAutoImport() {
+  return autoImport({
+    imports: [
+      "vue",
+      "vue-router",
+      "vue-i18n",
+      "vitest",
+      {
+        alova: [
+          "useRequest",
+          "invalidateCache"
+        ]
+      }
+    ],
+    dts: "./types/auto-imports.d.ts",
+    dirs: [
+      "./src/utils/composables/**",
+      "./src/composables/**/*",
+      "./src/api/modules/**/*.ts"
+    ],
+    resolvers: [
+      AntDesignVueResolver(),
+      IconsResolver({
+        prefix: "i"
+      }),
+      PubInfoResolver$1()
+    ]
+  });
+}
+
+function resolveComponent(componentName) {
+  if (!componentName.match(/^Pub[A-Z]/)) {
+    return;
+  }
+  return {
+    name: componentName,
+    as: componentName,
+    from: "@pubinfo/components"
+  };
+}
+function resolveDirective(directiveName) {
+  if (!directiveName.match(/^Pub[A-Z]/)) {
+    return;
+  }
+  return {
+    name: directiveName,
+    from: "@pubinfo/directives"
+  };
+}
+function PubInfoResolver() {
+  return [
+    {
+      type: "component",
+      resolve: async (name) => {
+        return resolveComponent(name);
+      }
+    },
+    {
+      type: "directive",
+      resolve: async (name) => {
+        return resolveDirective(name);
+      }
+    }
+  ];
+}
+
+function createComponents() {
+  return components({
+    dirs: [
+      "src/components",
+      "src/layouts/ui-kit"
+    ],
+    directives: true,
+    include: [/\.vue$/, /\.vue\?vue/, /\.tsx$/],
+    resolvers: [
+      IconsResolver(),
+      AntDesignVueResolver({
+        resolveIcons: true,
+        importStyle: false
+      }),
+      PubInfoResolver()
+    ],
+    dts: "./types/components.d.ts"
+  });
+}
+
+function createUnocss() {
+  return Unocss();
+}
+
+function createSvgIcon(isBuild) {
+  return createSvgIconsPlugin({
+    iconDirs: [path.resolve(process.cwd(), "src/assets/icons/")],
+    symbolId: "icon-[dir]-[name]",
+    svgoOptions: isBuild
+  });
+}
+
+function createI18n() {
+  const root = process.cwd();
+  const pathResolve = (pathname) => resolve$1(root, ".", pathname);
+  return vueI18n({
+    include: `${pathResolve("src")}/locales/lang/**`
+  });
+}
+
+function createMock(env, isBuild) {
+  const { VITE_BUILD_MOCK } = env;
+  return vitePluginFakeServer({
+    logger: !isBuild,
+    include: "src/mock",
+    infixName: false,
+    enableProd: isBuild && VITE_BUILD_MOCK === "true"
+  });
+}
+
+function createLayouts() {
+  return Layouts({
+    defaultLayout: "index"
+  });
+}
+
+function createCompression(env) {
+  const { VITE_BUILD_COMPRESS } = env;
+  const compressList = VITE_BUILD_COMPRESS.split(",");
+  const plugin = [];
+  if (compressList.includes("gzip")) {
+    plugin.push(
+      compression({
+        ext: ".gz",
+        deleteOriginFile: false
+      })
+    );
+  }
+  if (compressList.includes("brotli")) {
+    plugin.push(
+      compression({
+        ext: ".br",
+        algorithm: "brotliCompress",
+        deleteOriginFile: false
+      })
+    );
+  }
+  return plugin;
+}
+
+const deploymentTime = dayjs().format("YYYY-MM-DD HH:mm:ss");
+function createBanner() {
+  return banner(`
+/**
+ * \u7531 \u793E\u4F1A\u6CBB\u7406\u4E8B\u4E1A\u90E8 \u63D0\u4F9B\u6280\u672F\u652F\u6301
+ * Powered by wsy-admin
+ * ${deploymentTime}
+ */
+`);
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => {
+  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+let Ctx$2 = class Ctx {
+  constructor(options) {
+    __publicField$2(this, "root");
+    __publicField$2(this, "globs");
+    __publicField$2(this, "sourcePath");
+    __publicField$2(this, "path");
+    this.globs = options.globs;
+  }
+  setRoot(root) {
+    this.root = root;
+  }
+  searchGlob() {
+    const { root, globs } = this;
+    this.sourcePath = fg.sync(globs, {
+      cwd: root,
+      onlyFiles: true
+    });
+    this.normalizePath();
+  }
+  normalizePath() {
+    const path = [];
+    for (const f of this.sourcePath) {
+      path.push(`@use "${f}" as *;`);
+    }
+    this.path = path.join("");
+  }
+};
+function scssPreprocessor(options) {
+  const ctx = new Ctx$2(options);
+  return {
+    name: "vite-plugin-scssPreprocessor",
+    enforce: "pre",
+    config: (config) => {
+      ctx.setRoot(config.root);
+      ctx.searchGlob();
+      return {
+        css: {
+          preprocessorOptions: {
+            scss: {
+              additionalData: ctx.path
+            }
+          }
+        }
+      };
+    }
+  };
+}
+function createPreprocessor() {
+  return scssPreprocessor({
+    globs: ["src/assets/styles/resources/*.scss"]
+  });
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+let Ctx$1 = class Ctx {
+  constructor() {
+    __publicField$1(this, "root");
+    __publicField$1(this, "outDirName");
+    __publicField$1(this, "dir");
+    __publicField$1(this, "outDir");
+  }
+  setOptions(options) {
+    this.root = options.root;
+    this.outDirName = options.outDirName;
+    this.getDirPath();
+  }
+  getDirPath() {
+    const dir = resolve$1(this.root, this.outDirName);
+    const outDir = `${dir}.zip`;
+    this.dir = dir;
+    this.outDir = outDir;
+  }
+  async clean() {
+    const pathExists = await fse.pathExists(this.outDir);
+    if (pathExists) {
+      fse.remove(this.outDir);
+    }
+  }
+  async compress() {
+    const zip = new JSZip();
+    const files = this.getAllFiles(this.dir);
+    if (files && Array.isArray(files) && files.length) {
+      files.forEach((file) => {
+        const fileData = readFileSync(file, { encoding: "binary" });
+        zip.file(relative(this.dir, file), fileData, { binary: true });
+      });
+    }
+    const content = await zip.generateAsync({ type: "arraybuffer" });
+    writeFileSync(this.outDir, Buffer.from(content));
+  }
+  getAllFiles(dirPath) {
+    const files = readdirSync(dirPath);
+    const result = [];
+    for (const file of files) {
+      const filePath = join(dirPath, file);
+      if (statSync(filePath).isDirectory()) {
+        result.push(...this.getAllFiles(filePath));
+      } else {
+        result.push(filePath);
+      }
+    }
+    return result;
+  }
+};
+const ctx$1 = new Ctx$1();
+function zipPack() {
+  return {
+    name: "vite-plugin-zip",
+    apply: "build",
+    enforce: "post",
+    configResolved(configuration) {
+      const outDirName = configuration.build.outDir;
+      const root = configuration.root;
+      ctx$1.setOptions({ root, outDirName });
+    },
+    buildEnd() {
+      let isCompress = false;
+      process.on("beforeExit", async () => {
+        if (isCompress) {
+          return;
+        }
+        consola.start("\u5C06\u6587\u4EF6\u5305\u538B\u7F29\u6210zip...");
+        isCompress = true;
+        await ctx$1.clean();
+        await ctx$1.compress();
+        consola.success("\u6587\u4EF6\u538B\u7F29\u5B8C\u6210");
+        consola.success("\u6253\u5305\u6D41\u7A0B\u7ED3\u675F!");
+      });
+    }
+  };
+}
+function createZip() {
+  return zipPack();
+}
+
+function createIcons() {
+  return Icons({
+    autoInstall: false
+  });
+}
+
+function createConsole() {
+  return TurboConsole({
+    disableLaunchEditor: true
+  });
+}
+
+function createInspector(env) {
+  const { VITE_APP_INSPECTOR } = env;
+  if (VITE_APP_INSPECTOR && VITE_APP_INSPECTOR === "true") {
+    return VueDevTools();
+  } else {
+    return null;
+  }
+}
+
+function createOpenAPI() {
+  return OpenAPI();
+}
+
+function createConfig() {
+  return EnvRuntime({
+    name: "__PRODUCTION__PUBINFO__CONFIG__",
+    filename: "config.js",
+    include: [
+      "VITE_APP_TITLE",
+      "VITE_APP_API_BASEURL"
+    ]
+  });
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class Ctx {
+  constructor() {
+    __publicField(this, "options");
+  }
+  setOptions(options) {
+    this.options = options;
+  }
+  async createInfo() {
+    console.log(
+      boxen(
+        `\u6B22\u8FCE\u4F7F\u7528${chalk.bold.greenBright(" \u6280\u672F\u5E95\u5EA7\u7BA1\u7406\u7CFB\u7EDF ")}
+
+\u5982\u679C\u8981\u4FEE\u6539${chalk.yellow("config/*")} \u6216\u8005 ${chalk.yellow("scripts/*")}\u4E0B\u7684\u914D\u7F6E\u6587\u4EF6
+\u8BF7\u5148\u6267\u884C${chalk.yellow(" pnpm run stub ")}\u542F\u52A8\u6587\u4EF6\u76D1\u542C\u7F16\u8BD1
+
+${chalk.green("\u4F7F\u7528\u6587\u6863\u5730\u5740")} ${chalk.green("\u279C")} http://124.223.184.245:10000/docs
+`,
+        {
+          padding: 1,
+          margin: 1,
+          align: "center",
+          borderColor: "yellowBright",
+          borderStyle: "round"
+        }
+      )
+    );
+  }
+}
+const ctx = new Ctx();
+function appInfo() {
+  return {
+    name: "appInfo",
+    apply: "serve",
+    enforce: "pre",
+    configResolved(configuration) {
+      const root = configuration.root;
+      ctx.setOptions({
+        root
+      });
+    },
+    async buildStart() {
+      ctx.createInfo();
+    },
+    configureServer(server) {
+      const _printUrls = server.printUrls;
+      server.printUrls = () => {
+        console.log(`  ${chalk.green("\u279C")}  ${chalk.bold.bgBlueBright(` PUBINFO `)}${chalk.bold.bgYellowBright(` \u524D\u7AEF\u57FA\u7840\u6846\u67B6 `)}`);
+        _printUrls();
+      };
+    }
+  };
+}
+
+function createVitePlugins(viteEnv, isBuild = false) {
+  const vitePlugins = [
+    vue(),
+    vueJsx(),
+    vueLegacy(),
+    createAutoImport(),
+    createComponents(),
+    createUnocss(),
+    createSvgIcon(isBuild),
+    createIcons(),
+    createI18n(),
+    createMock(viteEnv, isBuild),
+    createLayouts(),
+    createBanner(),
+    createPreprocessor(),
+    createZip(),
+    createConsole(),
+    createInspector(viteEnv),
+    createOpenAPI(),
+    createConfig(),
+    appInfo()
+  ];
+  const buildPlugins = () => [
+    ...createCompression(viteEnv)
+  ];
+  if (isBuild) {
+    vitePlugins.push(...buildPlugins());
+  }
+  return vitePlugins.filter(Boolean);
+}
+
+async function createDefineSystemInfo(root) {
+  try {
+    const pkgJson = await readPackageJSON(root);
+    const { dependencies, devDependencies, version } = pkgJson;
+    const lastBuildTime = dayjs().format("YYYY-MM-DD HH:mm:ss");
+    const SYSTEM_INFO = {
+      pkg: {
+        dependencies,
+        devDependencies,
+        version
+      },
+      lastBuildTime
+    };
+    return JSON.stringify(SYSTEM_INFO);
+  } catch (error) {
+    return "";
+  }
+}
+function getServerProxy(env, isProxy, rewrite = true) {
+  if (!isProxy) {
+    return {};
+  }
+  const targetPrefix = "VITE_APP_API_";
+  const proxyKey = Object.keys(env).filter((key) => key.startsWith(targetPrefix));
+  const serverProxy = {};
+  for (const envKey of proxyKey) {
+    const url = env[envKey];
+    const { pathname } = new URL(url);
+    const pk = `${pathname}/proxy`;
+    if (pk in serverProxy) {
+      consola$1.error(`The proxy key ${chalk.bold.redBright(envKey)} \u279C ${chalk.bold.yellowBright(url)} already exists`);
+    } else {
+      serverProxy[pk] = {
+        target: url,
+        changeOrigin: rewrite,
+        rewrite: (path) => {
+          return path.replace(pk, "");
+        }
+      };
+    }
+  }
+  return serverProxy;
+}
+
+function cleanse() {
+  return {
+    name: "esbuild-plugin-cleanse",
+    setup(build) {
+      build.onLoad({ filter: /\/dist\/alova\.esm\.js$/ }, async (args) => {
+        let alovaContnet = await fs.readFile(args.path, "utf-8");
+        alovaContnet = alovaContnet.replace(/\/\* c8 ignore start \*\/[\s\S]*?\/\* c8 ignore stop \*\//g, "");
+        return {
+          contents: `${alovaContnet}`
+        };
+      });
+    }
+  };
+}
+
+function defineConfig(defineOptions = {}) {
+  return defineConfig$1(async ({ mode, command }) => {
+    const root = process.cwd();
+    const pathResolve = (pathname) => resolve$1(root, ".", pathname);
+    const env = loadEnv(mode, root);
+    const timestamp = (/* @__PURE__ */ new Date()).getTime();
+    const isBuild = command === "build";
+    const { VITE_OPEN_PROXY, VITE_BUILD_SOURCEMAP } = env;
+    const serverProxy = getServerProxy(env, !isBuild && VITE_OPEN_PROXY === "true");
+    const __SYSTEM_INFO__ = await createDefineSystemInfo(root);
+    const applicationConfig = {
+      base: "./",
+      server: {
+        open: true,
+        host: true,
+        proxy: serverProxy,
+        watch: {
+          ignored: ["!**/node_modules/@pubinfo/themes/src/system/**/*"]
+        },
+        warmup: {
+          clientFiles: [
+            "./index.html",
+            "./src/{layouts,components}/*",
+            "./src/locales/**/*"
+          ]
+        }
+      },
+      resolve: {
+        alias: [
+          {
+            find: /@\//,
+            replacement: `${pathResolve("src")}/`
+          },
+          {
+            find: /#\//,
+            replacement: `${pathResolve("types")}/`
+          }
+        ]
+      },
+      optimizeDeps: {
+        include: [
+          "ant-design-vue/es/locale/zh_CN",
+          "ant-design-vue/es/locale/en_US",
+          "@ant-design/icons-vue",
+          "dayjs",
+          "dayjs/locale/eu",
+          "dayjs/locale/zh-cn",
+          "@pubinfo/pro-components",
+          "qrcode",
+          "@pubinfo/headlessui"
+        ],
+        esbuildOptions: {
+          plugins: [
+            cleanse()
+          ]
+        }
+      },
+      build: {
+        outDir: mode === "production" ? "dist" : `dist-${mode}`,
+        sourcemap: VITE_BUILD_SOURCEMAP === "true",
+        reportCompressedSize: false,
+        chunkSizeWarningLimit: 2e3,
+        rollupOptions: {
+          output: {
+            entryFileNames: `assets/entry/[name]-[hash]-${timestamp}.js`,
+            manualChunks: {
+              vue: ["vue", "pinia", "vue-router"],
+              lodash: ["lodash-es"],
+              antd: ["ant-design-vue", "@ant-design/icons-vue"],
+              lottie: ["lottie-web"]
+            }
+          }
+        }
+      },
+      define: {
+        __SYSTEM_INFO__,
+        _DEV_: mode === "development",
+        _PROD_: mode === "production"
+      },
+      plugins: createVitePlugins(env, isBuild)
+    };
+    return mergeConfig(applicationConfig, defineOptions);
+  });
+}
+
+export { defineConfig };

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@pubinfo/vite",
+  "type": "module",
+  "version": "0.6.3",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "vite": "^5.3.2",
+    "vue": "^3.4.31",
+    "vue-i18n": "^9.13.1"
+  },
+  "dependencies": {
+    "@intlify/unplugin-vue-i18n": "^4.0.0",
+    "@pubinfo/unplugin-openapi": "^0.6.3",
+    "@vitejs/plugin-legacy": "^5.4.1",
+    "@vitejs/plugin-vue": "^5.0.5",
+    "@vitejs/plugin-vue-jsx": "^4.0.0",
+    "boxen": "^7.1.1",
+    "chalk": "^5.3.0",
+    "consola": "^3.2.3",
+    "dayjs": "^1.11.11",
+    "fast-glob": "^3.3.2",
+    "fs-extra": "^11.2.0",
+    "jszip": "^3.10.1",
+    "pkg-types": "^1.1.1",
+    "terser": "^5.31.1",
+    "unocss": "^0.61.0",
+    "unplugin-auto-import": "^0.17.6",
+    "unplugin-icons": "^0.19.0",
+    "unplugin-turbo-console": "^1.8.9",
+    "unplugin-vue-components": "^0.27.2",
+    "vite-plugin-banner": "^0.7.1",
+    "vite-plugin-compression": "^0.5.1",
+    "vite-plugin-env-runtime": "^0.3.5",
+    "vite-plugin-fake-server": "^2.1.1",
+    "vite-plugin-pages": "^0.32.3",
+    "vite-plugin-svg-icons": "^2.0.1",
+    "vite-plugin-vue-devtools": "^7.3.5",
+    "vite-plugin-vue-meta-layouts": "^0.4.3"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "esbuild": "^0.21.5",
+    "vite": "^5.3.2",
+    "vue": "^3.4.31",
+    "vue-i18n": "^9.13.1"
+  },
+  "scripts": {
+    "clean": "pnpm rimraf node_modules dist .turbo",
+    "build": "unbuild",
+    "stub": "unbuild --stub",
+    "lint": "eslint . --cache --fix"
+  }
+}