@dcf-micro/vite-config 5.5.9

package/dist/index.d.mts

@@ -0,0 +1,103 @@
+import * as vite from 'vite';
+import { ConfigEnv, UserConfig, PluginOption } from 'vite';
+import { PluginVisualizerOptions } from 'rollup-plugin-visualizer';
+export { visualizer as viteVisualizerPlugin } from 'rollup-plugin-visualizer';
+import { PluginOptions } from 'vite-plugin-dts';
+export { default as viteDtsPlugin } from 'vite-plugin-dts';
+import { Options } from 'vite-plugin-pwa';
+export { default as viteCompressPlugin } from 'vite-plugin-compression';
+export { createHtmlPlugin as viteHtmlPlugin } from 'vite-plugin-html';
+
+interface IImportMap {
+    imports?: Record<string, string>;
+    scopes?: {
+        [scope: string]: Record<string, string>;
+    };
+}
+interface PrintPluginOptions {
+    infoMap?: Record<string, string | undefined>;
+}
+interface NitroMockPluginOptions {
+    mockServerPackage?: string;
+    port?: number;
+    verbose?: boolean;
+}
+interface ArchiverPluginOptions {
+    name?: string;
+    outputDir?: string;
+}
+interface ImportmapPluginOptions {
+    defaultProvider?: 'esm.sh' | 'jspm.io';
+    importmap?: Array<{
+        name: string;
+        range?: string;
+    }>;
+    inputMap?: IImportMap;
+}
+interface CommonPluginOptions {
+    devtools?: boolean;
+    env?: Record<string, any>;
+    injectMetadata?: boolean;
+    isBuild?: boolean;
+    mode?: string;
+    visualizer?: boolean | PluginVisualizerOptions;
+}
+interface ApplicationPluginOptions extends CommonPluginOptions {
+    archiver?: boolean;
+    archiverPluginOptions?: ArchiverPluginOptions;
+    compress?: boolean;
+    compressTypes?: ('brotli' | 'gzip')[];
+    extraAppConfig?: boolean;
+    html?: boolean;
+    i18n?: boolean;
+    importmap?: boolean;
+    importmapOptions?: ImportmapPluginOptions;
+    injectAppLoading?: boolean;
+    injectGlobalScss?: boolean;
+    license?: boolean;
+    nitroMock?: boolean;
+    nitroMockOptions?: NitroMockPluginOptions;
+    print?: boolean;
+    printInfoMap?: PrintPluginOptions['infoMap'];
+    pwa?: boolean;
+    pwaOptions?: Partial<Options>;
+    vxeTableLazyImport?: boolean;
+}
+interface LibraryPluginOptions extends CommonPluginOptions {
+    dts?: boolean | PluginOptions;
+}
+type ApplicationOptions = ApplicationPluginOptions;
+type LibraryOptions = LibraryPluginOptions;
+type DefineApplicationOptions = (config?: ConfigEnv) => Promise<{
+    application?: ApplicationOptions;
+    vite?: UserConfig;
+}>;
+type DefineLibraryOptions = (config?: ConfigEnv) => Promise<{
+    library?: LibraryOptions;
+    vite?: UserConfig;
+}>;
+type DefineConfig = DefineApplicationOptions | DefineLibraryOptions;
+
+declare function defineApplicationConfig(userConfigPromise?: DefineApplicationOptions): vite.UserConfigFnPromise;
+
+declare function defineLibraryConfig(userConfigPromise?: DefineLibraryOptions): vite.UserConfigFnPromise;
+
+declare function defineConfig(userConfigPromise?: DefineConfig, type?: 'application' | 'auto' | 'library'): vite.UserConfigFnPromise;
+
+declare const getDefaultPwaOptions: (name: string) => Partial<Options>;
+declare const defaultImportmapOptions: ImportmapPluginOptions;
+
+declare const viteArchiverPlugin: (options?: ArchiverPluginOptions) => PluginOption;
+
+declare function viteVxeTableImportsPlugin(): Promise<PluginOption>;
+
+declare function loadApplicationPlugins(options: ApplicationPluginOptions): Promise<PluginOption[]>;
+declare function loadLibraryPlugins(options: LibraryPluginOptions): Promise<PluginOption[]>;
+
+declare function loadAndConvertEnv(match?: string, confFiles?: string[]): Promise<Partial<ApplicationPluginOptions> & {
+    appTitle: string;
+    base: string;
+    port: number;
+}>;
+
+export { defaultImportmapOptions, defineApplicationConfig, defineConfig, defineLibraryConfig, getDefaultPwaOptions, loadAndConvertEnv, loadApplicationPlugins, loadLibraryPlugins, viteArchiverPlugin, viteVxeTableImportsPlugin };

package/dist/index.d.ts

@@ -0,0 +1,103 @@
+import * as vite from 'vite';
+import { ConfigEnv, UserConfig, PluginOption } from 'vite';
+import { PluginVisualizerOptions } from 'rollup-plugin-visualizer';
+export { visualizer as viteVisualizerPlugin } from 'rollup-plugin-visualizer';
+import { PluginOptions } from 'vite-plugin-dts';
+export { default as viteDtsPlugin } from 'vite-plugin-dts';
+import { Options } from 'vite-plugin-pwa';
+export { default as viteCompressPlugin } from 'vite-plugin-compression';
+export { createHtmlPlugin as viteHtmlPlugin } from 'vite-plugin-html';
+
+interface IImportMap {
+    imports?: Record<string, string>;
+    scopes?: {
+        [scope: string]: Record<string, string>;
+    };
+}
+interface PrintPluginOptions {
+    infoMap?: Record<string, string | undefined>;
+}
+interface NitroMockPluginOptions {
+    mockServerPackage?: string;
+    port?: number;
+    verbose?: boolean;
+}
+interface ArchiverPluginOptions {
+    name?: string;
+    outputDir?: string;
+}
+interface ImportmapPluginOptions {
+    defaultProvider?: 'esm.sh' | 'jspm.io';
+    importmap?: Array<{
+        name: string;
+        range?: string;
+    }>;
+    inputMap?: IImportMap;
+}
+interface CommonPluginOptions {
+    devtools?: boolean;
+    env?: Record<string, any>;
+    injectMetadata?: boolean;
+    isBuild?: boolean;
+    mode?: string;
+    visualizer?: boolean | PluginVisualizerOptions;
+}
+interface ApplicationPluginOptions extends CommonPluginOptions {
+    archiver?: boolean;
+    archiverPluginOptions?: ArchiverPluginOptions;
+    compress?: boolean;
+    compressTypes?: ('brotli' | 'gzip')[];
+    extraAppConfig?: boolean;
+    html?: boolean;
+    i18n?: boolean;
+    importmap?: boolean;
+    importmapOptions?: ImportmapPluginOptions;
+    injectAppLoading?: boolean;
+    injectGlobalScss?: boolean;
+    license?: boolean;
+    nitroMock?: boolean;
+    nitroMockOptions?: NitroMockPluginOptions;
+    print?: boolean;
+    printInfoMap?: PrintPluginOptions['infoMap'];
+    pwa?: boolean;
+    pwaOptions?: Partial<Options>;
+    vxeTableLazyImport?: boolean;
+}
+interface LibraryPluginOptions extends CommonPluginOptions {
+    dts?: boolean | PluginOptions;
+}
+type ApplicationOptions = ApplicationPluginOptions;
+type LibraryOptions = LibraryPluginOptions;
+type DefineApplicationOptions = (config?: ConfigEnv) => Promise<{
+    application?: ApplicationOptions;
+    vite?: UserConfig;
+}>;
+type DefineLibraryOptions = (config?: ConfigEnv) => Promise<{
+    library?: LibraryOptions;
+    vite?: UserConfig;
+}>;
+type DefineConfig = DefineApplicationOptions | DefineLibraryOptions;
+
+declare function defineApplicationConfig(userConfigPromise?: DefineApplicationOptions): vite.UserConfigFnPromise;
+
+declare function defineLibraryConfig(userConfigPromise?: DefineLibraryOptions): vite.UserConfigFnPromise;
+
+declare function defineConfig(userConfigPromise?: DefineConfig, type?: 'application' | 'auto' | 'library'): vite.UserConfigFnPromise;
+
+declare const getDefaultPwaOptions: (name: string) => Partial<Options>;
+declare const defaultImportmapOptions: ImportmapPluginOptions;
+
+declare const viteArchiverPlugin: (options?: ArchiverPluginOptions) => PluginOption;
+
+declare function viteVxeTableImportsPlugin(): Promise<PluginOption>;
+
+declare function loadApplicationPlugins(options: ApplicationPluginOptions): Promise<PluginOption[]>;
+declare function loadLibraryPlugins(options: LibraryPluginOptions): Promise<PluginOption[]>;
+
+declare function loadAndConvertEnv(match?: string, confFiles?: string[]): Promise<Partial<ApplicationPluginOptions> & {
+    appTitle: string;
+    base: string;
+    port: number;
+}>;
+
+export { defaultImportmapOptions, defineApplicationConfig, defineConfig, defineLibraryConfig, getDefaultPwaOptions, loadAndConvertEnv, loadApplicationPlugins, loadLibraryPlugins, viteArchiverPlugin, viteVxeTableImportsPlugin };

package/dist/index.mjs

@@ -0,0 +1,1100 @@
+import fs, { existsSync } from 'node:fs';
+import path, { join, relative } from 'node:path';
+import { readPackageJSON, generatorContentHash, colors, dateUtil, getPackages, findMonorepoRoot, getPackage, consola, fs as fs$1 } from '@dcf-micro/utils-node';
+import { NodePackageImporter } from 'sass';
+import { defineConfig as defineConfig$1, loadEnv as loadEnv$1, mergeConfig } from 'vite';
+import { constants } from 'zlib';
+import viteVueI18nPlugin from '@intlify/unplugin-vue-i18n/vite';
+import viteVue from '@vitejs/plugin-vue';
+import viteVueJsx from '@vitejs/plugin-vue-jsx';
+import { visualizer } from 'rollup-plugin-visualizer';
+export { visualizer as viteVisualizerPlugin } from 'rollup-plugin-visualizer';
+import viteCompressPlugin from 'vite-plugin-compression';
+export { default as viteCompressPlugin } from 'vite-plugin-compression';
+import viteDtsPlugin from 'vite-plugin-dts';
+export { default as viteDtsPlugin } from 'vite-plugin-dts';
+import { createHtmlPlugin } from 'vite-plugin-html';
+export { createHtmlPlugin as viteHtmlPlugin } from 'vite-plugin-html';
+import { VitePWA } from 'vite-plugin-pwa';
+import viteVueDevTools from 'vite-plugin-vue-devtools';
+import fsp from 'node:fs/promises';
+import archiver from 'archiver';
+import { Generator } from '@jspm/generator';
+import { load } from 'cheerio';
+import { minify } from 'html-minifier-terser';
+import { fileURLToPath } from 'node:url';
+import { readWorkspaceManifest } from '@pnpm/workspace.read-manifest';
+import { EOL } from 'node:os';
+import getPort from 'get-port';
+import { createNitro, createDevServer, prepare, build } from 'nitropack';
+import { lazyImport, VxeResolver } from 'vite-plugin-lazy-import';
+import dotenv from 'dotenv';
+
+const isDevelopment = process.env.NODE_ENV === "development";
+const getDefaultPwaOptions = (name) => ({
+  manifest: {
+    description: "Vben Admin is a modern admin dashboard template based on Vue 3. ",
+    icons: [
+      {
+        sizes: "192x192",
+        src: "https://unpkg.com/@vbenjs/static-source@0.1.7/source/pwa-icon-192.png",
+        type: "image/png"
+      },
+      {
+        sizes: "512x512",
+        src: "https://unpkg.com/@vbenjs/static-source@0.1.7/source/pwa-icon-512.png",
+        type: "image/png"
+      }
+    ],
+    name: `${name}${isDevelopment ? " dev" : ""}`,
+    short_name: `${name}${isDevelopment ? " dev" : ""}`
+  }
+});
+const defaultImportmapOptions = {
+  // 通过 Importmap CDN 方式引入,
+  // 目前只有esm.sh源兼容性好一点，jspm.io对于 esm 入口要求高
+  defaultProvider: "esm.sh",
+  importmap: [
+    { name: "vue" },
+    { name: "pinia" },
+    { name: "vue-router" },
+    // { name: 'vue-i18n' },
+    { name: "dayjs" },
+    { name: "vue-demi" }
+  ]
+};
+
+const viteArchiverPlugin = (options = {}) => {
+  return {
+    apply: "build",
+    closeBundle: {
+      handler() {
+        const { name = "dist", outputDir = "." } = options;
+        setTimeout(async () => {
+          const folderToZip = "dist";
+          const zipOutputDir = join(process.cwd(), outputDir);
+          const zipOutputPath = join(zipOutputDir, `${name}.zip`);
+          try {
+            await fsp.mkdir(zipOutputDir, { recursive: true });
+          } catch {
+          }
+          try {
+            await zipFolder(folderToZip, zipOutputPath);
+            console.log(`Folder has been zipped to: ${zipOutputPath}`);
+          } catch (error) {
+            console.error("Error zipping folder:", error);
+          }
+        }, 0);
+      },
+      order: "post"
+    },
+    enforce: "post",
+    name: "vite:archiver"
+  };
+};
+async function zipFolder(folderPath, outputPath) {
+  return new Promise((resolve, reject) => {
+    const output = fs.createWriteStream(outputPath);
+    const archive = archiver("zip", {
+      zlib: { level: 9 }
+      // 设置压缩级别为 9 以实现最高压缩率
+    });
+    output.on("close", () => {
+      console.log(
+        `ZIP file created: ${outputPath} (${archive.pointer()} total bytes)`
+      );
+      resolve();
+    });
+    archive.on("error", (err) => {
+      reject(err);
+    });
+    archive.pipe(output);
+    archive.directory(folderPath, false);
+    archive.finalize();
+  });
+}
+
+const GLOBAL_CONFIG_FILE_NAME = "_app.config.js";
+const DEFAULT_VBEN_ADMIN_PRO_APP_CONF = "_VBEN_ADMIN_PRO_APP_CONF_";
+async function viteExtraAppConfigPlugin({
+  isBuild,
+  root,
+  env
+}) {
+  let publicPath;
+  let source;
+  const { version = "" } = await readPackageJSON(root);
+  return {
+    async configResolved(config) {
+      publicPath = ensureTrailingSlash(config.base);
+      source = await getConfigSource(env);
+    },
+    async generateBundle() {
+      try {
+        this.emitFile({
+          fileName: GLOBAL_CONFIG_FILE_NAME,
+          source,
+          type: "asset"
+        });
+        console.log(colors.cyan(`\u2728configuration file is build successfully!`));
+      } catch (error) {
+        console.log(
+          colors.red(
+            `configuration file configuration file failed to package:
+${error}`
+          )
+        );
+      }
+    },
+    name: "vite:extra-app-config",
+    async transformIndexHtml(html) {
+      const hash = `v=${version}-${generatorContentHash(source, 8)}`;
+      const appConfigSrc = `${publicPath}${GLOBAL_CONFIG_FILE_NAME}?${hash}`;
+      return {
+        html,
+        tags: [{ attrs: { src: appConfigSrc }, tag: "script" }]
+      };
+    }
+  };
+}
+async function getConfigSource(env) {
+  const config = {};
+  Object.keys(env).forEach((key) => {
+    if (key.startsWith("VITE_GLOB_")) {
+      config[key] = env[key];
+    }
+  });
+  const variableName = env.VITE_APP_CONF_NAME || DEFAULT_VBEN_ADMIN_PRO_APP_CONF;
+  const windowVariable = `window.${variableName}`;
+  const source = `
+    if (!Object.prototype.hasOwnProperty.call(window, "${variableName}")) {
+      ${windowVariable}=${JSON.stringify(config)};
+      Object.freeze(${windowVariable});
+      Object.defineProperty(window, "${variableName}", {
+        configurable: false,
+        writable: false,
+      });
+    }
+  `.replaceAll(/\s/g, "");
+  return source;
+}
+function ensureTrailingSlash(path) {
+  return path.endsWith("/") ? path : `${path}/`;
+}
+
+const DEFAULT_PROVIDER = "jspm.io";
+async function getShimsUrl(provide) {
+  const version = "1.10.0";
+  const shimsSubpath = `dist/es-module-shims.js`;
+  const providerShimsMap = {
+    "esm.sh": `https://esm.sh/es-module-shims@${version}/${shimsSubpath}`,
+    // unpkg: `https://unpkg.com/es-module-shims@${version}/${shimsSubpath}`,
+    jsdelivr: `https://cdn.jsdelivr.net/npm/es-module-shims@${version}/${shimsSubpath}`,
+    // 下面两个CDN不稳定，暂时不用
+    "jspm.io": `https://ga.jspm.io/npm:es-module-shims@${version}/${shimsSubpath}`
+  };
+  return providerShimsMap[provide] || providerShimsMap[DEFAULT_PROVIDER];
+}
+let generator;
+async function viteImportMapPlugin(pluginOptions) {
+  const { importmap } = pluginOptions || {};
+  let isSSR = false;
+  let isBuild = false;
+  let installed = false;
+  let installError = null;
+  const options = Object.assign(
+    {},
+    {
+      debug: false,
+      defaultProvider: "jspm.io",
+      env: ["production", "browser", "module"],
+      importmap: []
+    },
+    pluginOptions
+  );
+  generator = new Generator({
+    ...options,
+    baseUrl: process.cwd()
+  });
+  if (options?.debug) {
+    (async () => {
+      for await (const { message, type } of generator.logStream()) {
+        console.log(`${type}: ${message}`);
+      }
+    })();
+  }
+  const imports = options.inputMap?.imports ?? {};
+  const scopes = options.inputMap?.scopes ?? {};
+  const firstLayerKeys = Object.keys(scopes);
+  const inputMapScopes = [];
+  firstLayerKeys.forEach((key) => {
+    inputMapScopes.push(...Object.keys(scopes[key] || {}));
+  });
+  const inputMapImports = Object.keys(imports);
+  const allDepNames = [
+    ...importmap?.map((item) => item.name) || [],
+    ...inputMapImports,
+    ...inputMapScopes
+  ];
+  const depNames = new Set(allDepNames);
+  const installDeps = importmap?.map((item) => ({
+    range: item.range,
+    target: item.name
+  }));
+  return [
+    {
+      async config(_, { command, isSsrBuild }) {
+        isBuild = command === "build";
+        isSSR = !!isSsrBuild;
+      },
+      enforce: "pre",
+      name: "importmap:external",
+      resolveId(id) {
+        if (isSSR || !isBuild) {
+          return null;
+        }
+        if (!depNames.has(id)) {
+          return null;
+        }
+        return { external: true, id };
+      }
+    },
+    {
+      enforce: "post",
+      name: "importmap:install",
+      async resolveId() {
+        if (isSSR || !isBuild || installed) {
+          return null;
+        }
+        try {
+          installed = true;
+          await Promise.allSettled(
+            (installDeps || []).map((dep) => generator.install(dep))
+          );
+        } catch (error) {
+          installError = error;
+          installed = false;
+        }
+        return null;
+      }
+    },
+    {
+      buildEnd() {
+        if (!installed && !isSSR) {
+          installError && console.error(installError);
+          throw new Error("Importmap installation failed.");
+        }
+      },
+      enforce: "post",
+      name: "importmap:html",
+      transformIndexHtml: {
+        async handler(html) {
+          if (isSSR || !isBuild) {
+            return html;
+          }
+          const importmapJson = generator.getMap();
+          if (!importmapJson) {
+            return html;
+          }
+          const esModuleShimsSrc = await getShimsUrl(
+            options.defaultProvider || DEFAULT_PROVIDER
+          );
+          const resultHtml = await injectShimsToHtml(
+            html,
+            esModuleShimsSrc || ""
+          );
+          html = await minify(resultHtml || html, {
+            collapseWhitespace: true,
+            minifyCSS: true,
+            minifyJS: true,
+            removeComments: false
+          });
+          return {
+            html,
+            tags: [
+              {
+                attrs: {
+                  type: "importmap"
+                },
+                injectTo: "head-prepend",
+                tag: "script",
+                children: `${JSON.stringify(importmapJson)}`
+              }
+            ]
+          };
+        },
+        order: "post"
+      }
+    }
+  ];
+}
+async function injectShimsToHtml(html, esModuleShimUrl) {
+  const $ = load(html);
+  const $script = $(`script[type='module']`);
+  if (!$script) {
+    return;
+  }
+  const entry = $script.attr("src");
+  $script.removeAttr("type");
+  $script.removeAttr("crossorigin");
+  $script.removeAttr("src");
+  $script.html(`
+if (!HTMLScriptElement.supports || !HTMLScriptElement.supports('importmap')) {
+  self.importShim = function () {
+      const promise = new Promise((resolve, reject) => {
+          document.head.appendChild(
+              Object.assign(document.createElement('script'), {
+                  src: '${esModuleShimUrl}',
+                  crossorigin: 'anonymous',
+                  async: true,
+                  onload() {
+                      if (!importShim.$proxy) {
+                          resolve(importShim);
+                      } else {
+                          reject(new Error('No globalThis.importShim found:' + esModuleShimUrl));
+                      }
+                  },
+                  onerror(error) {
+                      reject(error);
+                  },
+              }),
+          );
+      });
+      importShim.$proxy = true;
+      return promise.then((importShim) => importShim(...arguments));
+  };
+}
+
+var modules = ['${entry}'];
+typeof importShim === 'function'
+  ? modules.forEach((moduleName) => importShim(moduleName))
+  : modules.forEach((moduleName) => import(moduleName));
+ `);
+  $("body").after($script);
+  $("head").remove(`script[type='module']`);
+  return $.html();
+}
+
+async function viteInjectAppLoadingPlugin(isBuild, env = {}, loadingTemplate = "loading.html") {
+  const loadingHtml = await getLoadingRawByHtmlTemplate(loadingTemplate);
+  const { version } = await readPackageJSON(process.cwd());
+  const envRaw = isBuild ? "prod" : "dev";
+  const cacheName = `'${env.VITE_APP_NAMESPACE}-${version}-${envRaw}-preferences-theme'`;
+  const injectScript = `
+  <script data-app-loading="inject-js">
+  var theme = localStorage.getItem(${cacheName});
+  document.documentElement.classList.toggle('dark', /dark/.test(theme));
+<\/script>
+`;
+  if (!loadingHtml) {
+    return;
+  }
+  return {
+    enforce: "pre",
+    name: "vite:inject-app-loading",
+    transformIndexHtml: {
+      handler(html) {
+        const re = /<body\s*>/;
+        html = html.replace(re, `<body>${injectScript}${loadingHtml}`);
+        return html;
+      },
+      order: "pre"
+    }
+  };
+}
+async function getLoadingRawByHtmlTemplate(loadingTemplate) {
+  let appLoadingPath = join(process.cwd(), loadingTemplate);
+  if (!fs.existsSync(appLoadingPath)) {
+    const __dirname = fileURLToPath(new URL(".", import.meta.url));
+    appLoadingPath = join(__dirname, "./default-loading.html");
+  }
+  return await fsp.readFile(appLoadingPath, "utf8");
+}
+
+function resolvePackageVersion(pkgsMeta, name, value, catalog) {
+  if (value.includes("catalog:")) {
+    return catalog[name];
+  }
+  if (value.includes("workspace")) {
+    return pkgsMeta[name];
+  }
+  return value;
+}
+async function resolveMonorepoDependencies() {
+  const { packages } = await getPackages();
+  const manifest = await readWorkspaceManifest(findMonorepoRoot());
+  const catalog = manifest?.catalog || {};
+  const resultDevDependencies = {};
+  const resultDependencies = {};
+  const pkgsMeta = {};
+  for (const { packageJson } of packages) {
+    pkgsMeta[packageJson.name] = packageJson.version;
+  }
+  for (const { packageJson } of packages) {
+    const { dependencies = {}, devDependencies = {} } = packageJson;
+    for (const [key, value] of Object.entries(dependencies)) {
+      resultDependencies[key] = resolvePackageVersion(
+        pkgsMeta,
+        key,
+        value,
+        catalog
+      );
+    }
+    for (const [key, value] of Object.entries(devDependencies)) {
+      resultDevDependencies[key] = resolvePackageVersion(
+        pkgsMeta,
+        key,
+        value,
+        catalog
+      );
+    }
+  }
+  return {
+    dependencies: resultDependencies,
+    devDependencies: resultDevDependencies
+  };
+}
+async function viteMetadataPlugin(root = process.cwd()) {
+  const { author, description, homepage, license, version } = await readPackageJSON(root);
+  const buildTime = dateUtil().format("YYYY-MM-DD HH:mm:ss");
+  return {
+    async config() {
+      const { dependencies, devDependencies } = await resolveMonorepoDependencies();
+      const isAuthorObject = typeof author === "object";
+      const authorName = isAuthorObject ? author.name : author;
+      const authorEmail = isAuthorObject ? author.email : null;
+      const authorUrl = isAuthorObject ? author.url : null;
+      return {
+        define: {
+          __VBEN_ADMIN_METADATA__: JSON.stringify({
+            authorEmail,
+            authorName,
+            authorUrl,
+            buildTime,
+            dependencies,
+            description,
+            devDependencies,
+            homepage,
+            license,
+            version
+          }),
+          "import.meta.env.VITE_APP_VERSION": JSON.stringify(version)
+        }
+      };
+    },
+    enforce: "post",
+    name: "vite:inject-metadata"
+  };
+}
+
+async function viteLicensePlugin(root = process.cwd()) {
+  const { version = "" } = await readPackageJSON(root);
+  return {
+    apply: "build",
+    enforce: "post",
+    generateBundle: {
+      handler: (_options, bundle) => {
+        const date = dateUtil().format("YYYY-MM-DD ");
+        const copyrightText = `
+          /*!
+            * Version: ${version}
+            * Date Created: ${date}
+          */
+         `.trim();
+        for (const [, fileContent] of Object.entries(bundle)) {
+          if (fileContent.type === "chunk" && fileContent.isEntry) {
+            const chunkContent = fileContent;
+            const content = chunkContent.code;
+            const updatedContent = `${copyrightText}${EOL}${content}`;
+            fileContent.code = updatedContent;
+          }
+        }
+      },
+      order: "post"
+    },
+    name: "vite:license"
+  };
+}
+
+const hmrKeyRe = /^runtimeConfig\.|routeRules\./;
+const viteNitroMockPlugin = ({
+  mockServerPackage = "",
+  port = 5320,
+  verbose = true
+} = {}) => {
+  return {
+    async configureServer(server) {
+      if (!mockServerPackage) {
+        return;
+      }
+      const availablePort = await getPort({ port });
+      if (availablePort !== port) {
+        return;
+      }
+      const pkg = await getPackage(mockServerPackage);
+      if (!pkg) {
+        consola.log(
+          `Package ${mockServerPackage} not found. Skip mock server.`
+        );
+        return;
+      }
+      runNitroServer(pkg.dir, port, verbose);
+      const _printUrls = server.printUrls;
+      server.printUrls = () => {
+        _printUrls();
+        consola.log(
+          `  ${colors.green("\u279C")}  ${colors.bold("Nitro Mock Server")}: ${colors.cyan(`http://localhost:${port}/api`)}`
+        );
+      };
+    },
+    enforce: "pre",
+    name: "vite:mock-server"
+  };
+};
+async function runNitroServer(rootDir, port, verbose) {
+  let nitro;
+  const reload = async () => {
+    if (nitro) {
+      consola.info("Restarting dev server...");
+      if ("unwatch" in nitro.options._c12) {
+        await nitro.options._c12.unwatch();
+      }
+      await nitro.close();
+    }
+    nitro = await createNitro(
+      {
+        dev: true,
+        preset: "nitro-dev",
+        rootDir
+      },
+      {
+        c12: {
+          async onUpdate({ getDiff, newConfig }) {
+            const diff = getDiff();
+            if (diff.length === 0) {
+              return;
+            }
+            verbose && consola.info(
+              `Nitro config updated:
+${diff.map((entry) => `  ${entry.toString()}`).join("\n")}`
+            );
+            await (diff.every((e) => hmrKeyRe.test(e.key)) ? nitro.updateConfig(newConfig.config) : reload());
+          }
+        },
+        watch: true
+      }
+    );
+    nitro.hooks.hookOnce("restart", reload);
+    const server = createDevServer(nitro);
+    await server.listen(port, { showURL: false });
+    await prepare(nitro);
+    await build(nitro);
+    if (verbose) {
+      console.log("");
+      consola.success(colors.bold(colors.green("Nitro Mock Server started.")));
+    }
+  };
+  return await reload();
+}
+
+const vitePrintPlugin = (options = {}) => {
+  const { infoMap = {} } = options;
+  return {
+    configureServer(server) {
+      const _printUrls = server.printUrls;
+      server.printUrls = () => {
+        _printUrls();
+        for (const [key, value] of Object.entries(infoMap)) {
+          console.log(
+            `  ${colors.green("\u279C")}  ${colors.bold(key)}: ${colors.cyan(value)}`
+          );
+        }
+      };
+    },
+    enforce: "pre",
+    name: "vite:print-info"
+  };
+};
+
+async function viteVxeTableImportsPlugin() {
+  return [
+    lazyImport({
+      resolvers: [
+        VxeResolver({
+          libraryName: "vxe-table"
+        }),
+        VxeResolver({
+          libraryName: "vxe-pc-ui"
+        })
+      ]
+    })
+  ];
+}
+
+async function loadConditionPlugins(conditionPlugins) {
+  const plugins = [];
+  for (const conditionPlugin of conditionPlugins) {
+    if (conditionPlugin.condition) {
+      const realPlugins = await conditionPlugin.plugins();
+      plugins.push(...realPlugins);
+    }
+  }
+  return plugins.flat();
+}
+async function loadCommonPlugins(options) {
+  const { devtools, injectMetadata, isBuild, visualizer: visualizer$1 } = options;
+  return [
+    {
+      condition: true,
+      plugins: () => [
+        viteVue({
+          script: {
+            defineModel: true
+            // propsDestructure: true,
+          }
+        }),
+        viteVueJsx()
+      ]
+    },
+    {
+      condition: !isBuild && devtools,
+      plugins: () => [viteVueDevTools()]
+    },
+    {
+      condition: injectMetadata,
+      plugins: async () => [await viteMetadataPlugin()]
+    },
+    {
+      condition: isBuild && !!visualizer$1,
+      plugins: () => [visualizer({
+        filename: "./node_modules/.cache/visualizer/stats.html",
+        gzipSize: true,
+        open: true
+      })]
+    }
+  ];
+}
+async function loadApplicationPlugins(options) {
+  const isBuild = options.isBuild;
+  const env = options.env;
+  const {
+    archiver,
+    archiverPluginOptions,
+    compress,
+    compressTypes,
+    extraAppConfig,
+    html,
+    i18n,
+    importmap,
+    importmapOptions,
+    injectAppLoading,
+    license,
+    nitroMock,
+    nitroMockOptions,
+    print,
+    printInfoMap,
+    pwa,
+    pwaOptions,
+    vxeTableLazyImport,
+    ...commonOptions
+  } = options;
+  const commonPlugins = await loadCommonPlugins(commonOptions);
+  return await loadConditionPlugins([
+    ...commonPlugins,
+    {
+      condition: i18n,
+      plugins: async () => {
+        return [
+          viteVueI18nPlugin({
+            compositionOnly: true,
+            fullInstall: true,
+            runtimeOnly: true
+          })
+        ];
+      }
+    },
+    {
+      condition: print,
+      plugins: async () => {
+        return [await vitePrintPlugin({ infoMap: printInfoMap })];
+      }
+    },
+    {
+      condition: vxeTableLazyImport,
+      plugins: async () => {
+        return [await viteVxeTableImportsPlugin()];
+      }
+    },
+    {
+      condition: nitroMock,
+      plugins: async () => {
+        return [await viteNitroMockPlugin(nitroMockOptions)];
+      }
+    },
+    {
+      condition: injectAppLoading,
+      plugins: async () => [await viteInjectAppLoadingPlugin(!!isBuild, env)]
+    },
+    {
+      condition: license,
+      plugins: async () => [await viteLicensePlugin()]
+    },
+    {
+      condition: pwa,
+      plugins: () => VitePWA({
+        injectRegister: false,
+        workbox: {
+          globPatterns: []
+        },
+        ...pwaOptions,
+        manifest: {
+          display: "standalone",
+          start_url: "/",
+          theme_color: "#ffffff",
+          ...pwaOptions?.manifest
+        }
+      })
+    },
+    {
+      condition: isBuild && !!compress,
+      plugins: () => {
+        const compressPlugins = [];
+        if (compressTypes?.includes("brotli")) {
+          compressPlugins.push(
+            viteCompressPlugin({
+              algorithm: "brotliCompress",
+              ext: ".br",
+              threshold: 10 * 1024,
+              deleteOriginFile: false,
+              compressionOptions: {
+                params: {
+                  [constants.BROTLI_PARAM_QUALITY]: 11,
+                  [constants.BROTLI_PARAM_MODE]: constants.BROTLI_MODE_TEXT
+                }
+              }
+            })
+          );
+        }
+        if (compressTypes?.includes("gzip")) {
+          compressPlugins.push(
+            viteCompressPlugin({ deleteOriginFile: false, ext: ".gz" })
+          );
+        }
+        return compressPlugins;
+      }
+    },
+    {
+      condition: !!html,
+      plugins: () => [createHtmlPlugin({ minify: true })]
+    },
+    {
+      condition: isBuild && importmap,
+      plugins: () => {
+        return [viteImportMapPlugin(importmapOptions)];
+      }
+    },
+    {
+      condition: isBuild && extraAppConfig,
+      plugins: async () => [
+        await viteExtraAppConfigPlugin({
+          env: env || {},
+          isBuild: true,
+          root: process.cwd()
+        })
+      ]
+    },
+    {
+      condition: archiver,
+      plugins: async () => {
+        return [await viteArchiverPlugin(archiverPluginOptions)];
+      }
+    }
+  ]);
+}
+async function loadLibraryPlugins(options) {
+  const isBuild = options.isBuild;
+  const { dts, ...commonOptions } = options;
+  const commonPlugins = await loadCommonPlugins(commonOptions);
+  return await loadConditionPlugins([
+    ...commonPlugins,
+    {
+      condition: isBuild && !!dts,
+      plugins: () => [viteDtsPlugin({ logLevel: "error" })]
+    }
+  ]);
+}
+
+const getBoolean = (value) => value === "true";
+const getString = (value, fallback) => value ?? fallback;
+const getNumber = (value, fallback) => Number(value) || fallback;
+function getConfFiles() {
+  const script = process.env.npm_lifecycle_script;
+  const reg = /--mode ([\d_a-z]+)/;
+  const result = reg.exec(script);
+  let mode = "production";
+  if (result) {
+    mode = result[1];
+  }
+  return [".env", ".env.local", `.env.${mode}`, `.env.${mode}.local`];
+}
+async function loadEnv(match = "VITE_GLOB_", confFiles = getConfFiles()) {
+  let envConfig = {};
+  for (const confFile of confFiles) {
+    try {
+      const confFilePath = join(process.cwd(), confFile);
+      if (existsSync(confFilePath)) {
+        const envPath = await fs$1.readFile(confFilePath, {
+          encoding: "utf8"
+        });
+        const env = dotenv.parse(envPath);
+        envConfig = { ...envConfig, ...env };
+      }
+    } catch (error) {
+      console.error(`Error while parsing ${confFile}`, error);
+    }
+  }
+  const reg = new RegExp(`^(${match})`);
+  Object.keys(envConfig).forEach((key) => {
+    if (!reg.test(key)) {
+      Reflect.deleteProperty(envConfig, key);
+    }
+  });
+  return envConfig;
+}
+async function loadAndConvertEnv(match = "VITE_", confFiles = getConfFiles()) {
+  const envConfig = await loadEnv(match, confFiles);
+  const {
+    VITE_APP_TITLE,
+    VITE_ARCHIVER,
+    VITE_BASE,
+    VITE_COMPRESS,
+    VITE_DEVTOOLS,
+    VITE_INJECT_APP_LOADING,
+    VITE_NITRO_MOCK,
+    VITE_PORT,
+    VITE_PWA,
+    VITE_VISUALIZER
+  } = envConfig;
+  const compressTypes = (VITE_COMPRESS ?? "").split(",").filter((item) => item === "brotli" || item === "gzip");
+  return {
+    appTitle: getString(VITE_APP_TITLE, "Vben Admin"),
+    archiver: getBoolean(VITE_ARCHIVER),
+    base: getString(VITE_BASE, "/"),
+    compress: compressTypes.length > 0,
+    compressTypes,
+    devtools: getBoolean(VITE_DEVTOOLS),
+    injectAppLoading: getBoolean(VITE_INJECT_APP_LOADING),
+    nitroMock: getBoolean(VITE_NITRO_MOCK),
+    port: getNumber(VITE_PORT, 5173),
+    pwa: getBoolean(VITE_PWA),
+    visualizer: getBoolean(VITE_VISUALIZER)
+  };
+}
+
+async function getCommonConfig() {
+  return {
+    build: {
+      chunkSizeWarningLimit: 2e3,
+      reportCompressedSize: false,
+      sourcemap: false
+    }
+  };
+}
+
+function defineApplicationConfig(userConfigPromise) {
+  return defineConfig$1(async (config) => {
+    const options = await userConfigPromise?.(config);
+    const { appTitle, base, port, ...envConfig } = await loadAndConvertEnv();
+    const { command, mode } = config;
+    const { application = {}, vite = {} } = options || {};
+    const root = process.cwd();
+    const isBuild = command === "build";
+    const env = loadEnv$1(mode, root);
+    const plugins = await loadApplicationPlugins({
+      archiver: true,
+      archiverPluginOptions: {},
+      compress: isBuild,
+      compressTypes: ["brotli", "gzip"],
+      devtools: true,
+      env,
+      extraAppConfig: true,
+      html: true,
+      i18n: true,
+      importmapOptions: defaultImportmapOptions,
+      injectAppLoading: true,
+      injectMetadata: true,
+      isBuild,
+      license: true,
+      mode,
+      nitroMock: !isBuild,
+      nitroMockOptions: {},
+      print: !isBuild,
+      printInfoMap: {
+        "Vben Admin Docs": "https://doc.vben.pro"
+      },
+      pwa: true,
+      pwaOptions: getDefaultPwaOptions(appTitle),
+      vxeTableLazyImport: true,
+      ...envConfig,
+      ...application
+    });
+    const { injectGlobalScss = true } = application;
+    const applicationConfig = {
+      base,
+      build: {
+        rollupOptions: {
+          output: {
+            assetFileNames: "[ext]/[name]-[hash].[ext]",
+            chunkFileNames: "js/[name]-[hash].js",
+            entryFileNames: "jse/index-[name]-[hash].js",
+            manualChunks(id) {
+              if (id.includes("@iconify/json/json/mdi.json")) {
+                return "mdi-icons";
+              }
+              if (id.includes("node_modules/vue/") || id.includes("node_modules/@vue/")) {
+                return "vendor-vue";
+              }
+              if (id.includes("node_modules/vue-router/")) {
+                return "vendor-vue-router";
+              }
+              if (id.includes("node_modules/pinia/")) {
+                return "vendor-pinia";
+              }
+              if (id.includes("node_modules/ant-design-vue/")) {
+                return "vendor-ant-design-vue";
+              }
+              if (id.includes("node_modules/vxe-table/") || id.includes("node_modules/vxe-pc-ui/")) {
+                return "vendor-vxe-table";
+              }
+              if (id.includes("node_modules/echarts/")) {
+                return "vendor-echarts";
+              }
+              if (id.includes("node_modules/")) {
+                if (id.includes("lodash")) {
+                  return "vendor-lodash";
+                }
+                if (id.includes("dayjs")) {
+                  return "vendor-dayjs";
+                }
+                if (id.includes("axios")) {
+                  return "vendor-axios";
+                }
+              }
+            }
+          }
+        },
+        chunkSizeWarningLimit: 1500,
+        minify: "esbuild",
+        target: "es2015"
+      },
+      css: createCssOptions(injectGlobalScss),
+      esbuild: {
+        drop: isBuild ? [
+          "console",
+          "debugger"
+        ] : [],
+        legalComments: "none"
+      },
+      plugins,
+      server: {
+        host: true,
+        port,
+        warmup: {
+          // 预热文件
+          clientFiles: [
+            "./index.html",
+            "./src/bootstrap.ts",
+            "./src/{views,layouts,router,store,api,adapter}/*"
+          ]
+        }
+      }
+    };
+    const mergedCommonConfig = mergeConfig(
+      await getCommonConfig(),
+      applicationConfig
+    );
+    return mergeConfig(mergedCommonConfig, vite);
+  });
+}
+function createCssOptions(injectGlobalScss = true) {
+  const root = findMonorepoRoot();
+  return {
+    preprocessorOptions: injectGlobalScss ? {
+      scss: {
+        additionalData: (content, filepath) => {
+          const relativePath = relative(root, filepath);
+          if (relativePath.startsWith(`apps${path.sep}`)) {
+            return `@use "@vben/styles/global" as *;
+${content}`;
+          }
+          return content;
+        },
+        api: "modern",
+        importers: [new NodePackageImporter()]
+      }
+    } : {}
+  };
+}
+
+function defineLibraryConfig(userConfigPromise) {
+  return defineConfig$1(async (config) => {
+    const options = await userConfigPromise?.(config);
+    const { command, mode } = config;
+    const { library = {}, vite = {} } = options || {};
+    const root = process.cwd();
+    const isBuild = command === "build";
+    const plugins = await loadLibraryPlugins({
+      dts: false,
+      injectMetadata: true,
+      isBuild,
+      mode,
+      ...library
+    });
+    const { dependencies = {}, peerDependencies = {} } = await readPackageJSON(root);
+    const externalPackages = [
+      ...Object.keys(dependencies),
+      ...Object.keys(peerDependencies)
+    ];
+    const packageConfig = {
+      build: {
+        lib: {
+          entry: "src/index.ts",
+          fileName: () => "index.mjs",
+          formats: ["es"]
+        },
+        rollupOptions: {
+          external: (id) => {
+            return externalPackages.some(
+              (pkg) => id === pkg || id.startsWith(`${pkg}/`)
+            );
+          }
+        }
+      },
+      plugins
+    };
+    const commonConfig = await getCommonConfig();
+    const mergedConmonConfig = mergeConfig(commonConfig, packageConfig);
+    return mergeConfig(mergedConmonConfig, vite);
+  });
+}
+
+function defineConfig(userConfigPromise, type = "auto") {
+  let projectType = type;
+  if (projectType === "auto") {
+    const htmlPath = join(process.cwd(), "index.html");
+    projectType = existsSync(htmlPath) ? "application" : "library";
+  }
+  switch (projectType) {
+    case "application": {
+      return defineApplicationConfig(userConfigPromise);
+    }
+    case "library": {
+      return defineLibraryConfig(userConfigPromise);
+    }
+    default: {
+      throw new Error(`Unsupported project type: ${projectType}`);
+    }
+  }
+}
+
+export { defaultImportmapOptions, defineApplicationConfig, defineConfig, defineLibraryConfig, getDefaultPwaOptions, loadAndConvertEnv, loadApplicationPlugins, loadLibraryPlugins, viteArchiverPlugin, viteVxeTableImportsPlugin };

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@dcf-micro/vite-config",
+  "version": "5.5.9",
+  "homepage": "https://github.com/vbenjs/vue-vben-admin",
+  "bugs": "https://github.com/vbenjs/vue-vben-admin/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vbenjs/vue-vben-admin.git",
+    "directory": "internal/vite-config"
+  },
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "build": "pnpm unbuild",
+    "stub": "pnpm unbuild --stub"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.mjs"
+      }
+    }
+  },
+  "dependencies": {
+    "@pnpm/workspace.read-manifest": "catalog:",
+    "@dcf-micro/utils-node": "workspace:*",
+    "@vitejs/plugin-vue": "catalog:",
+    "@vitejs/plugin-vue-jsx": "catalog:",
+    "@intlify/unplugin-vue-i18n": "catalog:",
+    "@jspm/generator": "catalog:",
+    "archiver": "catalog:",
+    "cheerio": "catalog:",
+    "dotenv": "catalog:",
+    "get-port": "catalog:",
+    "html-minifier-terser": "catalog:",
+    "nitropack": "catalog:",
+    "resolve.exports": "catalog:",
+    "rollup-plugin-visualizer": "catalog:",
+    "sass": "catalog:",
+    "vite": "catalog:",
+    "vite-plugin-compression": "catalog:",
+    "vite-plugin-dts": "catalog:",
+    "vite-plugin-html": "catalog:",
+    "vite-plugin-lazy-import": "catalog:",
+    "vite-plugin-pwa": "catalog:",
+    "vite-plugin-vue-devtools": "catalog:"
+  },
+  "devDependencies": {
+    "@types/archiver": "catalog:",
+    "@types/html-minifier-terser": "catalog:",
+    "dayjs": "catalog:",
+    "rollup": "catalog:"
+  }
+}