@moluoxixi/vite-config 0.0.37

package/dist/index.js

@@ -0,0 +1,815 @@
+import "./chunk-T5FUYGUC.js";
+import {
+  definePwaAddonOptions
+} from "./chunk-2BMF52EY.js";
+import {
+  defineReactAddonOptions
+} from "./chunk-PBJLIQ2R.js";
+import {
+  defineTailwindCssAddonOptions
+} from "./chunk-HKGBYIAA.js";
+import {
+  defineUnoCssAddonOptions
+} from "./chunk-7CLRGPQQ.js";
+import {
+  defineViteSsgAddonOptions
+} from "./chunk-YMSTBWUP.js";
+import {
+  defineVitestAddonOptions
+} from "./chunk-UXLJ2PKX.js";
+import {
+  defineVueRouterAddonOptions
+} from "./chunk-WYQMKXD6.js";
+import {
+  defineVueAddonOptions
+} from "./chunk-M2ZFVZSN.js";
+import {
+  defineAutoImportAddonOptions
+} from "./chunk-GUIZM2YS.js";
+import {
+  defineComponentsAddonOptions
+} from "./chunk-NQPL76JU.js";
+import {
+  defineDevtoolsAddonOptions
+} from "./chunk-OEBLHHRC.js";
+import {
+  defineI18nAddonOptions
+} from "./chunk-IBJFH5NC.js";
+import {
+  defineVueLayoutsAddonOptions
+} from "./chunk-GKIEBF73.js";
+import {
+  defineMarkdownAddonOptions
+} from "./chunk-CG74BJ6T.js";
+
+// src/config/app.ts
+import { defineConfig, mergeConfig as mergeConfig3 } from "vite";
+
+// src/config/base/index.ts
+import path2 from "path";
+import process2 from "process";
+import { mergeConfig as mergeConfig2 } from "vite";
+
+// src/config/base/addons/index.ts
+import { mergeConfig } from "vite";
+
+// src/config/base/addons/runtime.ts
+import path from "path";
+import process from "process";
+import { detectDependencies } from "@moluoxixi/core";
+function defineFeature(feature) {
+  return feature;
+}
+function getPackageName(specifier) {
+  const parts = specifier.split("/");
+  if (specifier.startsWith("@")) {
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return parts[0];
+}
+function isAddonPayload(option) {
+  return typeof option === "object" && option !== null && !Array.isArray(option) || typeof option === "string";
+}
+function inspectFeature(ctx, feature, option) {
+  const requires = feature.requires || [];
+  const matchedTriggers = feature.triggers.filter(ctx.hasAddonDep);
+  const missingRequires = requires.filter((dep) => !ctx.hasAddonDep(dep));
+  if (option === false) {
+    return {
+      enabled: false,
+      matchedTriggers,
+      missingRequires: [],
+      name: feature.name,
+      reason: "explicit-disabled",
+      requires,
+      triggers: feature.triggers
+    };
+  }
+  if (option === true || isAddonPayload(option)) {
+    return {
+      enabled: true,
+      matchedTriggers,
+      missingRequires,
+      name: feature.name,
+      reason: "explicit-enabled",
+      requires,
+      triggers: feature.triggers
+    };
+  }
+  if (matchedTriggers.length > 0) {
+    return {
+      enabled: true,
+      matchedTriggers,
+      missingRequires,
+      name: feature.name,
+      reason: "dependency-detected",
+      requires,
+      triggers: feature.triggers
+    };
+  }
+  return {
+    enabled: false,
+    matchedTriggers,
+    missingRequires: [],
+    name: feature.name,
+    reason: "dependency-missing",
+    requires,
+    triggers: feature.triggers
+  };
+}
+function createAddonContext(options = {}) {
+  const rootValue = options.viteConfig?.root;
+  const root = path.resolve(typeof rootValue === "string" ? rootValue : process.cwd());
+  const { addonDeps, deps, runtimeDeps } = detectDependencies(root);
+  const importCache = /* @__PURE__ */ new Map();
+  const hasAddonDep = (name) => Boolean(addonDeps[name]);
+  const hasDep = (name) => Boolean(deps[name]);
+  const hasRuntimeDep = (name) => Boolean(runtimeDeps[name]);
+  const requireDeps = (owner, requiredDeps) => {
+    const missing = requiredDeps.filter((dep) => !hasAddonDep(dep));
+    if (missing.length > 0) {
+      throw new Error(`[ViteConfig] ${owner} requires missing package(s): ${missing.join(", ")}. Checked ${path.resolve(root, "package.json")}`);
+    }
+  };
+  const importRequired = async (owner, specifier) => {
+    const packageName = getPackageName(specifier);
+    requireDeps(owner, [packageName]);
+    if (!importCache.has(specifier)) {
+      importCache.set(
+        specifier,
+        import(specifier).catch((cause) => {
+          throw new Error(`[ViteConfig] ${owner} failed to load ${specifier}. Install ${packageName} for project root ${root}.`, { cause });
+        })
+      );
+    }
+    return await importCache.get(specifier);
+  };
+  return {
+    addonDeps,
+    deps,
+    hasAddonDep,
+    hasAnyAddonDep: (names) => names.some(hasAddonDep),
+    hasAnyDep: (names) => names.some(hasDep),
+    hasAnyRuntimeDep: (names) => names.some(hasRuntimeDep),
+    hasDep,
+    hasRuntimeDep,
+    importRequired,
+    requireDeps,
+    resolvePath: (...segments) => path.resolve(root, ...segments),
+    root,
+    runtimeDeps
+  };
+}
+async function resolveFeatureConfig(ctx, feature, option) {
+  const options = isAddonPayload(option) ? option : void 0;
+  try {
+    ctx.requireDeps(feature.name, feature.requires || []);
+    const state = feature.createState ? feature.createState(ctx, options) : void 0;
+    return await feature.setup(ctx, options, state);
+  } catch (cause) {
+    if (cause instanceof Error && cause.message.startsWith("[ViteConfig]")) {
+      throw cause;
+    }
+    throw new Error(`[ViteConfig] failed to resolve addon ${feature.name}`, { cause });
+  }
+}
+
+// src/config/base/addons/shared.ts
+import { defu } from "defu";
+var HTTP_URL_PATTERN = /^https?:\/\//;
+var MARKDOWN_PATTERN = /\.md$/;
+var VUE_I18N_PATTERN = /vue-i18n/;
+var VUE_PATTERN = /\.vue$/;
+var JS_TS_PATTERN = /\.[jt]sx?$/;
+var MARKDOWN_PLUGIN_NAMES = ["unplugin-vue-markdown", "vite-plugin-md", "vite-plugin-vue-markdown"];
+var SVELTE_PATTERN = /\.svelte$/;
+var VUE_QUERY_PATTERN = /\.vue\?vue/;
+function mergeAddonOptions(options, defaultOptions) {
+  return defu(options, defaultOptions);
+}
+async function callDefaultFactory(ctx, owner, specifier, options) {
+  const mod = await ctx.importRequired(owner, specifier);
+  if (typeof mod.default !== "function") {
+    throw new TypeError(`[ViteConfig] ${owner} expected ${specifier} to expose a default plugin factory`);
+  }
+  return mod.default(options);
+}
+function hasMarkdownAddon(ctx) {
+  return ctx.hasAnyAddonDep(MARKDOWN_PLUGIN_NAMES);
+}
+function createVueIncludePatterns(ctx) {
+  const include = [];
+  if (ctx.hasAddonDep("vue")) {
+    include.push(VUE_PATTERN);
+  }
+  if (hasMarkdownAddon(ctx)) {
+    include.push(MARKDOWN_PATTERN);
+  }
+  return include;
+}
+function createSourceIncludePatterns(ctx) {
+  const include = [JS_TS_PATTERN];
+  if (ctx.hasAddonDep("vue")) {
+    include.push(VUE_PATTERN, VUE_QUERY_PATTERN);
+  }
+  if (ctx.hasAddonDep("svelte")) {
+    include.push(SVELTE_PATTERN);
+  }
+  if (hasMarkdownAddon(ctx)) {
+    include.push(MARKDOWN_PATTERN);
+  }
+  return include;
+}
+
+// src/config/base/addons/auto-import.ts
+function applyPresetImports(ctx, state) {
+  const presets = [
+    "vue",
+    "react",
+    "vue-i18n",
+    "@vueuse/core",
+    "@vueuse/math",
+    "@vueuse/head",
+    "vitest",
+    "pinia",
+    "preact",
+    "quasar",
+    "react-router",
+    "react-router-dom",
+    "rxjs",
+    "solid-js",
+    "svelte"
+  ];
+  for (const preset of presets) {
+    if (ctx.hasAddonDep(preset)) {
+      state.imports.push(preset);
+    }
+  }
+  if (!ctx.hasAddonDep("unplugin-vue-router") && ctx.hasAddonDep("vue-router")) {
+    state.imports.push("vue-router");
+  }
+}
+async function applyVueRouterAutoImports(ctx, state) {
+  if (!ctx.hasAddonDep("unplugin-vue-router")) {
+    return;
+  }
+  const { VueRouterAutoImports } = await ctx.importRequired("autoImport:vueRouterAutoImports", "unplugin-vue-router");
+  state.imports.push(VueRouterAutoImports);
+  state.imports.push({ "vue-router/auto": ["useLink"] });
+}
+async function applyUnheadAutoImports(ctx, state) {
+  if (!ctx.hasAddonDep("@unhead/vue")) {
+    return;
+  }
+  const { unheadVueComposablesImports } = await ctx.importRequired("autoImport:unheadAutoImports", "@unhead/vue");
+  state.imports.push(unheadVueComposablesImports);
+}
+async function applyElementPlusResolver(ctx, state) {
+  if (!ctx.hasAddonDep("element-plus")) {
+    return;
+  }
+  ctx.requireDeps("autoImport:elementPlusResolver", ["unplugin-vue-components"]);
+  const { ElementPlusResolver } = await ctx.importRequired("autoImport:elementPlusResolver", "unplugin-vue-components/resolvers");
+  state.resolvers.push(ElementPlusResolver());
+}
+var autoImportFeature = defineFeature({
+  name: "autoImport",
+  order: 50,
+  requires: ["unplugin-auto-import"],
+  triggers: ["unplugin-auto-import"],
+  createState(ctx) {
+    const state = {
+      imports: [],
+      include: createSourceIncludePatterns(ctx),
+      resolvers: []
+    };
+    applyPresetImports(ctx, state);
+    return state;
+  },
+  async setup(ctx, options, state) {
+    await applyVueRouterAutoImports(ctx, state);
+    await applyUnheadAutoImports(ctx, state);
+    await applyElementPlusResolver(ctx, state);
+    const { default: AutoImport } = await ctx.importRequired("autoImport", "unplugin-auto-import/vite");
+    const defaultOptions = {
+      dirs: ["src/composables", "src/stores", "src/utils"],
+      dts: ctx.resolvePath("src/typings/auto-imports.d.ts"),
+      imports: state.imports,
+      include: state.include,
+      ...state.resolvers.length > 0 ? { resolvers: state.resolvers } : {},
+      vueTemplate: ctx.hasAddonDep("vue")
+    };
+    const autoImportOptions = mergeAddonOptions(options, defaultOptions);
+    return {
+      plugins: [
+        AutoImport(autoImportOptions)
+      ]
+    };
+  }
+});
+
+// src/config/base/addons/components.ts
+async function applyElementPlusResolver2(ctx, state) {
+  if (!ctx.hasAddonDep("element-plus")) {
+    return;
+  }
+  ctx.requireDeps("components:elementPlusResolver", ["unplugin-vue-components"]);
+  const { ElementPlusResolver } = await ctx.importRequired("components:elementPlusResolver", "unplugin-vue-components/resolvers");
+  state.resolvers.push(ElementPlusResolver());
+}
+var componentsFeature = defineFeature({
+  name: "components",
+  order: 55,
+  requires: ["unplugin-vue-components"],
+  triggers: ["unplugin-vue-components"],
+  createState(ctx) {
+    const extensions = [];
+    if (ctx.hasAddonDep("vue")) {
+      extensions.push("vue");
+    }
+    if (ctx.hasAddonDep("svelte")) {
+      extensions.push("svelte");
+    }
+    if (hasMarkdownAddon(ctx)) {
+      extensions.push("md");
+    }
+    return {
+      extensions,
+      include: createSourceIncludePatterns(ctx),
+      resolvers: []
+    };
+  },
+  async setup(ctx, options, state) {
+    await applyElementPlusResolver2(ctx, state);
+    const { default: Components } = await ctx.importRequired("components", "unplugin-vue-components/vite");
+    const defaultOptions = {
+      dts: ctx.resolvePath("src/typings/components.d.ts"),
+      extensions: state.extensions,
+      include: state.include,
+      ...state.resolvers.length > 0 ? { resolvers: state.resolvers } : {}
+    };
+    const componentOptions = mergeAddonOptions(options, defaultOptions);
+    return {
+      plugins: [
+        Components(componentOptions)
+      ]
+    };
+  }
+});
+
+// src/config/base/addons/devtools.ts
+var devtoolsFeature = defineFeature({
+  name: "devtools",
+  order: 70,
+  requires: ["vite-plugin-vue-devtools"],
+  triggers: ["vite-plugin-vue-devtools"],
+  async setup(ctx, options) {
+    return {
+      plugins: [
+        await callDefaultFactory(ctx, "devtools", "vite-plugin-vue-devtools", options)
+      ]
+    };
+  }
+});
+
+// src/config/base/addons/i18n.ts
+var i18nFeature = defineFeature({
+  name: "i18n",
+  order: 60,
+  requires: ["@intlify/unplugin-vue-i18n"],
+  triggers: ["@intlify/unplugin-vue-i18n"],
+  async setup(ctx, options) {
+    const { default: VueI18n } = await ctx.importRequired("i18n", "@intlify/unplugin-vue-i18n/vite");
+    const defaultOptions = {
+      compositionOnly: true,
+      fullInstall: true,
+      include: [ctx.resolvePath("locales/**")],
+      runtimeOnly: true
+    };
+    return {
+      plugins: [
+        VueI18n(mergeAddonOptions(options, defaultOptions))
+      ]
+    };
+  }
+});
+
+// src/config/base/addons/markdown.ts
+var markdownFeature = defineFeature({
+  name: "markdown",
+  order: 90,
+  requires: ["unplugin-vue-markdown", "@shikijs/markdown-it", "markdown-it-link-attributes"],
+  triggers: ["unplugin-vue-markdown", "vite-plugin-vue-markdown", "vite-plugin-md"],
+  async setup(ctx, options) {
+    const { default: Markdown } = await ctx.importRequired("markdown", "unplugin-vue-markdown/vite");
+    const { default: Shiki } = await ctx.importRequired("markdown:shiki", "@shikijs/markdown-it");
+    const { default: LinkAttributes } = await ctx.importRequired("markdown:linkAttributes", "markdown-it-link-attributes");
+    const defaultOptions = {
+      async markdownItSetup(md) {
+        md.use(LinkAttributes, {
+          attrs: {
+            rel: "noopener",
+            target: "_blank"
+          },
+          matcher: (link) => HTTP_URL_PATTERN.test(link)
+        });
+        md.use(await Shiki({
+          defaultColor: false,
+          themes: {
+            dark: "vitesse-dark",
+            light: "vitesse-light"
+          }
+        }));
+      },
+      headEnabled: true,
+      wrapperClasses: "prose prose-sm m-auto text-left"
+    };
+    return {
+      plugins: [
+        Markdown(mergeAddonOptions(options, defaultOptions))
+      ]
+    };
+  }
+});
+
+// src/config/base/addons/pwa.ts
+import { defu as defu2 } from "defu";
+var defaultPwaOptions = {
+  registerType: "autoUpdate"
+};
+var pwaFeature = defineFeature({
+  name: "pwa",
+  order: 80,
+  requires: ["vite-plugin-pwa"],
+  triggers: ["vite-plugin-pwa"],
+  async setup(ctx, options) {
+    const { VitePWA } = await ctx.importRequired("pwa", "vite-plugin-pwa");
+    return {
+      plugins: [
+        VitePWA(defu2(options, defaultPwaOptions))
+      ]
+    };
+  }
+});
+
+// src/config/base/addons/react.ts
+var reactFeature = defineFeature({
+  name: "react",
+  order: 20,
+  requires: ["@vitejs/plugin-react"],
+  triggers: ["react", "@vitejs/plugin-react"],
+  async setup(ctx, options) {
+    return {
+      plugins: [
+        await callDefaultFactory(ctx, "react", "@vitejs/plugin-react", options)
+      ]
+    };
+  }
+});
+
+// src/config/base/addons/tailwindcss.ts
+var tailwindcssFeature = defineFeature({
+  name: "tailwindcss",
+  order: 35,
+  triggers: ["@tailwindcss/vite", "@tailwindcss/postcss"],
+  async setup(ctx, options) {
+    if (ctx.hasAddonDep("@tailwindcss/vite")) {
+      const plugins = await callDefaultFactory(ctx, "tailwindcss", "@tailwindcss/vite", options);
+      return {
+        plugins
+      };
+    }
+    if (ctx.hasAddonDep("@tailwindcss/postcss")) {
+      const { default: tailwindPostcss } = await ctx.importRequired("tailwindcss:postcss", "@tailwindcss/postcss");
+      return {
+        css: {
+          postcss: {
+            plugins: [tailwindPostcss(options)]
+          }
+        }
+      };
+    }
+    throw new Error("[ViteConfig] tailwindcss requires @tailwindcss/vite or @tailwindcss/postcss. Install one Tailwind CSS integration package for the target project.");
+  }
+});
+
+// src/config/base/addons/unocss.ts
+import fs from "fs";
+var UNO_CONFIG_FILES = [
+  "uno.config.ts",
+  "uno.config.mts",
+  "uno.config.cts",
+  "uno.config.js",
+  "uno.config.mjs",
+  "uno.config.cjs",
+  "unocss.config.ts",
+  "unocss.config.mts",
+  "unocss.config.cts",
+  "unocss.config.js",
+  "unocss.config.mjs",
+  "unocss.config.cjs"
+];
+function resolveUnoConfigFile(ctx) {
+  const configFile = UNO_CONFIG_FILES.map((file) => ctx.resolvePath(file)).find((file) => fs.existsSync(file));
+  return configFile || false;
+}
+var unocssFeature = defineFeature({
+  name: "unocss",
+  order: 30,
+  requires: ["unocss"],
+  triggers: ["unocss"],
+  async setup(ctx, options) {
+    const defaultOptions = {
+      configFile: resolveUnoConfigFile(ctx)
+    };
+    return {
+      plugins: [
+        await callDefaultFactory(
+          ctx,
+          "unocss",
+          "unocss/vite",
+          typeof options === "string" ? options : mergeAddonOptions(options, defaultOptions)
+        )
+      ]
+    };
+  }
+});
+
+// src/config/base/addons/vite-ssg.ts
+import { defu as defu3 } from "defu";
+var viteSsgFeature = defineFeature({
+  name: "viteSsg",
+  order: 110,
+  requires: ["vite-ssg"],
+  triggers: ["vite-ssg"],
+  async setup(ctx, options) {
+    const noExternal = [];
+    if (ctx.hasAddonDep("vue-i18n")) {
+      noExternal.push(VUE_I18N_PATTERN);
+    }
+    const defaultOptions = {
+      ssgOptions: {
+        beastiesOptions: {
+          reduceInlineStyles: false
+        },
+        formatting: "minify",
+        script: "async"
+      }
+    };
+    const resolvedOptions = mergeAddonOptions(options, defaultOptions);
+    if (!ctx.hasAddonDep("vite-ssg-sitemap")) {
+      return noExternal.length > 0 ? defu3({ ssr: { noExternal } }, resolvedOptions) : resolvedOptions;
+    }
+    const { default: generateSitemap } = await ctx.importRequired("viteSsg:sitemap", "vite-ssg-sitemap");
+    const ssgOptions = resolvedOptions.ssgOptions;
+    const userOnFinished = ssgOptions?.onFinished;
+    return defu3({
+      ssgOptions: {
+        ...ssgOptions,
+        async onFinished() {
+          await userOnFinished?.();
+          await generateSitemap();
+        }
+      },
+      ...noExternal.length > 0 ? { ssr: { noExternal } } : {}
+    }, resolvedOptions);
+  }
+});
+
+// src/config/base/addons/vitest.ts
+import { defu as defu4 } from "defu";
+var vitestFeature = defineFeature({
+  name: "vitest",
+  order: 100,
+  triggers: ["vitest"],
+  setup(_ctx, options) {
+    const defaultOptions = {
+      environment: "jsdom",
+      include: ["test/**/*.test.ts"]
+    };
+    return {
+      test: defu4(options, defaultOptions)
+    };
+  }
+});
+
+// src/config/base/addons/vue.ts
+var vueFeature = defineFeature({
+  name: "vue",
+  order: 10,
+  requires: ["@vitejs/plugin-vue"],
+  triggers: ["vue", "@vitejs/plugin-vue"],
+  async setup(ctx, options) {
+    const { default: vue } = await ctx.importRequired("vue", "@vitejs/plugin-vue");
+    const defaultOptions = {
+      include: createVueIncludePatterns(ctx)
+    };
+    const vuePlugin = vue(mergeAddonOptions(options, defaultOptions));
+    if (ctx.hasAddonDep("unplugin-vue-macros")) {
+      const { default: VueMacros } = await ctx.importRequired("vue:macros", "unplugin-vue-macros/vite");
+      return {
+        plugins: [
+          VueMacros({
+            plugins: {
+              vue: vuePlugin
+            }
+          })
+        ]
+      };
+    }
+    return { plugins: [vuePlugin] };
+  }
+});
+
+// src/config/base/addons/vue-layouts.ts
+var vueLayoutsFeature = defineFeature({
+  name: "vueLayouts",
+  order: 45,
+  requires: ["vite-plugin-vue-layouts"],
+  triggers: ["vite-plugin-vue-layouts"],
+  async setup(ctx, options) {
+    return {
+      plugins: [
+        await callDefaultFactory(ctx, "vueLayouts", "vite-plugin-vue-layouts", options)
+      ]
+    };
+  }
+});
+
+// src/config/base/addons/vue-router.ts
+var vueRouterFeature = defineFeature({
+  name: "vueRouter",
+  order: 40,
+  requires: ["unplugin-vue-router"],
+  triggers: ["unplugin-vue-router"],
+  async setup(ctx, options) {
+    const extensions = [];
+    if (ctx.hasAddonDep("vue")) {
+      extensions.push(".vue");
+    }
+    if (hasMarkdownAddon(ctx)) {
+      extensions.push(".md");
+    }
+    const defaultOptions = {
+      dts: ctx.resolvePath("src/typings/route-map.d.ts"),
+      extensions,
+      root: ctx.root,
+      routesFolder: ctx.resolvePath("src/pages")
+    };
+    return {
+      plugins: [
+        await callDefaultFactory(
+          ctx,
+          "vueRouter",
+          "unplugin-vue-router/vite",
+          mergeAddonOptions(options, defaultOptions)
+        )
+      ]
+    };
+  }
+});
+
+// src/config/base/addons/registry.ts
+var features = [
+  vueFeature,
+  reactFeature,
+  unocssFeature,
+  tailwindcssFeature,
+  vueRouterFeature,
+  vueLayoutsFeature,
+  autoImportFeature,
+  componentsFeature,
+  i18nFeature,
+  devtoolsFeature,
+  pwaFeature,
+  markdownFeature,
+  vitestFeature,
+  viteSsgFeature
+];
+var viteFeatures = features.sort((a, b) => a.order - b.order);
+
+// src/config/base/addons/index.ts
+function inspectViteFeatures(options = {}) {
+  const ctx = createAddonContext(options);
+  return {
+    features: viteFeatures.map((feature) => inspectFeature(ctx, feature, options[feature.name])),
+    root: ctx.root
+  };
+}
+async function getAddonsConfig(options = {}) {
+  const ctx = createAddonContext(options);
+  let combinedConfig = {};
+  for (const feature of viteFeatures) {
+    const inspection = inspectFeature(ctx, feature, options[feature.name]);
+    if (!inspection.enabled) {
+      continue;
+    }
+    const option = options[feature.name];
+    const configFragment = await resolveFeatureConfig(ctx, feature, option);
+    combinedConfig = mergeConfig(combinedConfig, configFragment);
+  }
+  return combinedConfig;
+}
+
+// src/config/base/index.ts
+async function getBaseConfig(options = {}) {
+  const root = typeof options.viteConfig?.root === "string" ? options.viteConfig.root : process2.cwd();
+  const addonsConfig = await getAddonsConfig(options);
+  const rootConfig = {
+    resolve: {
+      alias: {
+        "@": path2.resolve(root, "src")
+      }
+    }
+  };
+  return mergeConfig2(rootConfig, addonsConfig);
+}
+
+// src/config/app.ts
+function createAppConfig(config = {}) {
+  return defineConfig(async (env) => {
+    const userOptions = typeof config === "function" ? await config(env) : config;
+    const baseConfig = await getBaseConfig(userOptions);
+    const viteConfigExt = userOptions.viteConfig || {};
+    return mergeConfig3(baseConfig, viteConfigExt);
+  });
+}
+
+// src/config/lib.ts
+import path3 from "path";
+import process3 from "process";
+import { detectDependencies as detectDependencies2 } from "@moluoxixi/core";
+import { defineConfig as defineConfig2, mergeConfig as mergeConfig4 } from "vite";
+function createDependencyExternal(dependencies) {
+  const uniqueDeps = Array.from(new Set(dependencies));
+  return (id) => uniqueDeps.some((dep) => id === dep || id.startsWith(`${dep}/`));
+}
+function resolveEntryPath(root, entry) {
+  return path3.isAbsolute(entry) ? entry : path3.resolve(root, entry);
+}
+function resolveLibEntry(root, entry) {
+  if (typeof entry === "string") {
+    return resolveEntryPath(root, entry);
+  }
+  if (Array.isArray(entry)) {
+    return entry.map((item) => resolveEntryPath(root, item));
+  }
+  return Object.fromEntries(
+    Object.entries(entry).map(([name, item]) => [name, resolveEntryPath(root, item)])
+  );
+}
+function createLibConfig(config = {}) {
+  return defineConfig2(async (env) => {
+    const userOptions = typeof config === "function" ? await config(env) : config;
+    const viteConfigExt = userOptions.viteConfig || {};
+    const root = typeof viteConfigExt.root === "string" ? viteConfigExt.root : process3.cwd();
+    const normalizedOptions = {
+      ...userOptions,
+      viteConfig: {
+        ...viteConfigExt,
+        root
+      }
+    };
+    const baseConfig = await getBaseConfig(normalizedOptions);
+    const { dependencies, optionalDependencies, peerDependencies } = detectDependencies2(root);
+    const libEntry = resolveLibEntry(root, userOptions.entry ?? "src/index.ts");
+    const external = createDependencyExternal([
+      ...Object.keys(dependencies),
+      ...Object.keys(optionalDependencies),
+      ...Object.keys(peerDependencies)
+    ]);
+    const libConfig = {
+      build: {
+        lib: {
+          entry: libEntry,
+          formats: ["es", "cjs"],
+          fileName: "index"
+        },
+        rollupOptions: {
+          external
+        }
+      }
+    };
+    return mergeConfig4(mergeConfig4(baseConfig, libConfig), viteConfigExt);
+  });
+}
+export {
+  createAppConfig,
+  createLibConfig,
+  defineAutoImportAddonOptions,
+  defineComponentsAddonOptions,
+  defineDevtoolsAddonOptions,
+  defineI18nAddonOptions,
+  defineMarkdownAddonOptions,
+  definePwaAddonOptions,
+  defineReactAddonOptions,
+  defineTailwindCssAddonOptions,
+  defineUnoCssAddonOptions,
+  defineViteSsgAddonOptions,
+  defineVitestAddonOptions,
+  defineVueAddonOptions,
+  defineVueLayoutsAddonOptions,
+  defineVueRouterAddonOptions,
+  getBaseConfig,
+  inspectViteFeatures
+};