@univa/core 0.0.6 → 0.0.8

package/dist/index.js

@@ -1,336 +1,496 @@
+// src/config/index.ts
+function defineConfig(config) {
+  return config;
+}
+
 // src/plugins/index.ts
 import Uni from "@uni-helper/plugin-uni";
-import UniHelperLayouts from "@uni-helper/vite-plugin-uni-layouts";
-import UniOptimization from "@uni-ku/bundle-optimizer";
-import UnivaRoot from "@univa/root";
-import UniPolyfill from "vite-plugin-uni-polyfill";
+import VitePluginUniComponents from "@uni-helper/vite-plugin-uni-components";
+import { VitePluginUniLayouts } from "@uni-helper/vite-plugin-uni-layouts";
+import UniKuRoot from "@uni-ku/root";
+import UnoCSS from "unocss/vite";
+import AutoImport from "unplugin-auto-import/vite";
 
 // src/constant.ts
-var DTS_DIR = "./.univa";
-var COMPONENT_ASYNC_ROOT = "components-async";
+var ID = "univa";
+var UNIVA_DIR_NAME = `.${ID}`;
+var ROOT_NAME = `${ID}.root`;
 
-// src/plugins/autoImport.ts
-import AutoImport from "unplugin-auto-import/vite";
-function createAutoImportPlugin(options) {
-  const defaultAutoImportOptions = {
-    imports: [
-      "vue",
-      "pinia",
-      "uni-app",
-      {
-        from: "@univa/core/hooks",
-        imports: ["usePageContext"]
-      }
-    ],
-    dirs: [
-      "src/hooks/**",
-      "!src/hooks/**/_*/**",
-      "src/store/**",
-      "!src/store/**/_*/**",
-      "src/constants/**"
-    ],
-    vueTemplate: true,
-    dts: `${DTS_DIR}/auto-imports.d.ts`
-  };
-  const userAutoImportOptions = typeof options.autoImport === "object" ? options.autoImport : {};
-  const mergedOptions = {
-    ...defaultAutoImportOptions,
-    ...userAutoImportOptions
-  };
-  if (userAutoImportOptions.imports) {
-    const userImports = Array.isArray(userAutoImportOptions.imports) ? userAutoImportOptions.imports : [userAutoImportOptions.imports];
-    mergedOptions.imports = [...defaultAutoImportOptions.imports, ...userImports];
+// src/utils/fs.ts
+import { existsSync, mkdirSync } from "fs";
+import { join } from "path";
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
   }
-  if (userAutoImportOptions.dirs) {
-    const userDirs = Array.isArray(userAutoImportOptions.dirs) ? userAutoImportOptions.dirs : [userAutoImportOptions.dirs];
-    mergedOptions.dirs = [...defaultAutoImportOptions.dirs, ...userDirs];
+}
+function getUnivaDir(cwd) {
+  return join(cwd, UNIVA_DIR_NAME);
+}
+function ensureUnivaDir(cwd) {
+  const dir = getUnivaDir(cwd);
+  ensureDir(dir);
+  return dir;
+}
+
+// src/utils/logger.ts
+var debugMode = false;
+function setDebug(enabled) {
+  debugMode = enabled;
+}
+function log(message, ...args) {
+  if (debugMode) {
+    console.log(`[${ID}]`, message, ...args);
   }
-  return AutoImport(mergedOptions);
 }
 
-// src/plugins/components.ts
-import UniHelperComponents from "@uni-helper/vite-plugin-uni-components";
-function createComponentsPlugin(options) {
-  const defaultComponentsOptions = {
-    dirs: ["src/components", "src/components-biz"],
-    exclude: ["**/components/**/*.*"],
-    directoryAsNamespace: true,
-    globalNamespaces: ["components", "common"],
-    dts: `${DTS_DIR}/components.d.ts`
-  };
-  const userComponentsOptions = typeof options.components === "object" ? options.components : {};
-  const mergedOptions = {
-    ...defaultComponentsOptions,
-    ...userComponentsOptions
+// src/plugins/context.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+import { slash } from "@antfu/utils";
+import { loadConfig } from "c12";
+import { createJiti } from "jiti";
+
+// src/utils/merge.ts
+import { createDefu } from "defu";
+var mergeWithArrayOverride = createDefu((originObj, key, updates) => {
+  if (Array.isArray(originObj[key]) && Array.isArray(updates)) {
+    originObj[key] = updates;
+    return true;
+  }
+});
+
+// src/plugins/manifest.ts
+import { existsSync as existsSync2, readFileSync, writeFileSync } from "fs";
+import { join as join2, resolve } from "path";
+import process2 from "process";
+import { ensureManifestJsonExists } from "@uni-helper/vite-plugin-uni-manifest";
+import { watchConfig } from "c12";
+import { normalizePath } from "vite";
+function resolveOptions(userOptions) {
+  return {
+    minify: false,
+    insertFinalNewline: false,
+    cwd: process2.env.VITE_ROOT_DIR,
+    merge: true,
+    ...userOptions
   };
-  if (userComponentsOptions.dirs) {
-    const userDirs = Array.isArray(userComponentsOptions.dirs) ? userComponentsOptions.dirs : [userComponentsOptions.dirs];
-    mergedOptions.dirs = [...defaultComponentsOptions.dirs, ...userDirs];
+}
+function writeManifestJson(config = {}, opts) {
+  const path = resolveManifestJsonPath();
+  let mergeContent = {};
+  if (opts?.merge && existsSync2(path)) {
+    try {
+      const content2 = readFileSync(path, "utf-8");
+      mergeContent = JSON.parse(content2);
+    } catch (error) {
+      log(`manifest.json parse error: ${error}`);
+    }
+  }
+  const content = JSON.stringify(opts?.merge ? mergeWithArrayOverride(config, mergeContent) : config, null, opts?.minify ? 0 : 2) + (opts?.insertFinalNewline ? "\n" : "");
+  if (existsSync2(path) && readFileSync(path, "utf-8") === content) {
+    return;
   }
-  if (userComponentsOptions.exclude) {
-    const userExclude = Array.isArray(userComponentsOptions.exclude) ? userComponentsOptions.exclude : [userComponentsOptions.exclude];
-    mergedOptions.exclude = [...defaultComponentsOptions.exclude, ...userExclude];
+  writeFileSync(path, content);
+}
+function resolveManifestJsonPath() {
+  return normalizePath(
+    resolve(process2.env.UNI_INPUT_DIR || `${process2.cwd()}/src`, "manifest.json")
+  );
+}
+var ManifestContext = class {
+  options;
+  unwatch;
+  constructor(options) {
+    this.options = resolveOptions(options);
+  }
+  /**
+   * Start watching config sources and perform initial write.
+   * Must be called after construction.
+   */
+  async setup() {
+    log(`manifest cwd: ${this.options.cwd}`);
+    const { config, unwatch } = await watchConfig({
+      cwd: this.options.cwd,
+      name: "manifest",
+      rcFile: false,
+      packageJson: false,
+      onUpdate: (config2) => {
+        writeManifestJson(config2.newConfig.config, this.options);
+      }
+    });
+    writeManifestJson(config, this.options);
+    this.unwatch = unwatch;
   }
-  if (userComponentsOptions.globalNamespaces) {
-    const userGlobalNamespaces = Array.isArray(userComponentsOptions.globalNamespaces) ? userComponentsOptions.globalNamespaces : [userComponentsOptions.globalNamespaces];
-    mergedOptions.globalNamespaces = [...defaultComponentsOptions.globalNamespaces, ...userGlobalNamespaces];
+};
+function VitePluginUniManifest(userOptions = {}) {
+  let ctx;
+  return {
+    name: "vite-plugin-uni-manifest",
+    // Run before other plugins to ensure manifest.json is ready
+    enforce: "pre",
+    async configResolved() {
+      ensureManifestJsonExists();
+      ctx = new ManifestContext(userOptions);
+      await ctx.setup();
+    },
+    buildEnd: () => ctx?.unwatch()
+  };
+}
+function generateManifestConfigContent(content = {}) {
+  return `// Auto-generated by @univa/core
+export default ${JSON.stringify(content, null, 2)}
+  `;
+}
+function generateManifestConfigFile(content = {}, root) {
+  const configPath = getManifestConfigPath(root);
+  const newContent = generateManifestConfigContent(content);
+  if (existsSync2(configPath)) {
+    const existingContent = readFileSync(configPath, "utf-8");
+    if (existingContent === newContent) {
+      return;
+    }
   }
-  return UniHelperComponents(mergedOptions);
+  writeFileSync(configPath, newContent, "utf-8");
 }
-
-// src/plugins/manifest.ts
-import { VitePluginUniManifest } from "@univa/manifest";
-function createManifestPlugin(options) {
+function getManifestConfigPath(root) {
+  return join2(getUnivaDir(root), "manifest.config.ts");
+}
+function createManifestPlugin(userOptions = {}) {
   return VitePluginUniManifest({
-    rewrite: (config) => {
-      return options?.manifest || config;
-    }
+    cwd: join2(process2.env.VITE_ROOT_DIR || "", UNIVA_DIR_NAME),
+    ...userOptions
   });
 }
 
 // src/plugins/pages.ts
-import UniHelperPages from "@uni-helper/vite-plugin-uni-pages";
-function _pathToName(path, partToReplace = "", prefix = "") {
-  const parts = path.replace(/\.\w+$/, "").split("/").filter(Boolean);
-  const toPascalCase = (parts2) => {
-    return parts2.map(
-      (part) => part.split("-").map((subPart) => subPart.charAt(0).toUpperCase() + subPart.slice(1)).join("")
-    ).join("");
-  };
-  if (!partToReplace) {
-    return toPascalCase(parts);
-  }
-  const indexToReplace = parts.findIndex((part) => part.toLowerCase() === partToReplace.toLowerCase());
-  if (indexToReplace === -1) {
-    return prefix + toPascalCase(parts);
-  }
-  parts[indexToReplace] = prefix;
-  return toPascalCase(parts);
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+import { VitePluginUniPages } from "@uni-helper/vite-plugin-uni-pages";
+function getPagesConfigPath(root) {
+  return join3(getUnivaDir(root), "pages-config.ts");
 }
-function processPageName(ctx) {
-  ctx.pageMetaData.forEach((page) => {
-    if (page.name) {
+function generatePagesConfigContent(content) {
+  const { pages, subPackages, ...rest } = content;
+  void pages;
+  void subPackages;
+  return `// Auto-generated by @univa/core
+// \u6765\u6E90\uFF1Auniva.config.ts \u7684 pages \u5B57\u6BB5
+export default ${JSON.stringify(rest, null, 2)}
+`;
+}
+function generatePagesConfigFile(content, root) {
+  const pagesConfigPath = getPagesConfigPath(root);
+  const newContent = generatePagesConfigContent(content);
+  if (existsSync3(pagesConfigPath)) {
+    const existingContent = readFileSync2(pagesConfigPath, "utf-8");
+    if (existingContent === newContent) {
       return;
     }
-    page.name = _pathToName(page.path, "pages");
-  });
-  ctx.subPageMetaData.forEach((subPackage) => {
-    const root = subPackage.root;
-    const isAsyncComponent = root.startsWith(COMPONENT_ASYNC_ROOT);
-    subPackage.pages.forEach((page) => {
-      if (page.name) {
-        return;
-      }
-      if (!page.path) {
-        console.warn(`[vite-plugin-uni-pages] Page path is missing in subPackage: ${root}`);
-        return;
-      }
-      if (isAsyncComponent) {
-        page.layout = false;
-      }
-      page.name = _pathToName(`${root}/${page.path}`, "pages-sub", "Sub");
-    });
+  }
+  writeFileSync2(pagesConfigPath, newContent, "utf-8");
+}
+function createPagesPlugin(pluginOptions) {
+  const result = VitePluginUniPages({
+    dts: `${UNIVA_DIR_NAME}/uni-pages.d.ts`,
+    exclude: ["**/components/**/*.*"],
+    configSource: `${UNIVA_DIR_NAME}/pages-config.ts`,
+    ...pluginOptions
   });
+  return Array.isArray(result) ? result : [result];
 }
-function processTabBar(ctx) {
-  const tabBar = ctx.pagesGlobConfig?.tabBar;
-  if (!tabBar) {
-    return;
+
+// src/plugins/context.ts
+var APP_KU_VUE_TEMPLATE = `<!-- Auto-generated by @univa/core -->
+<template>
+  <KuRootView />
+</template>
+`;
+var UnivaContext = class {
+  _server;
+  config;
+  configPath;
+  root;
+  constructor(options) {
+    this.root = options.root;
   }
-  const tabBarMode = ctx.pagesGlobConfig?.tabBarMode || "NATIVE";
-  if (tabBarMode === "CUSTOM") {
-    tabBar.custom = true;
+  /**
+   * 确保虚拟根组件文件存在
+   *
+   * UniKuRoot 插件依赖 src 下的虚拟根组件文件（默认 App.ku.vue）。
+   * 若不存在则生成最小模板，避免插件注入 import 时解析失败。
+   *
+   * 必须在 Vite 启动前调用（Univa() 初始化阶段），
+   * 否则在 configResolved 阶段创建 src 下新文件会触发 watcher add 事件，
+   * 导致 Vite 重编译与 VitePluginUniPages 的 pages.json 写入冲突（EPERM）。
+   */
+  ensureRootComponent(fileName) {
+    const srcDir = this.config?.srcDir || "src";
+    const rootFileName = this.config?.overrides?.root?.rootFileName || fileName;
+    const rootComponentPath = join4(this.root, srcDir, rootFileName);
+    if (existsSync4(rootComponentPath)) {
+      return;
+    }
+    writeFileSync3(rootComponentPath, APP_KU_VUE_TEMPLATE, "utf-8");
+    log(`\u5DF2\u751F\u6210\u865A\u62DF\u6839\u7EC4\u4EF6\uFF1A${slash(rootComponentPath)}`);
   }
-  const rawTabBarList = [];
-  if (tabBar.list && tabBar.list.length > 0) {
-    tabBar.list = tabBar.list.map((item) => {
-      rawTabBarList.push({ ...item });
-      const filtered = { ...item };
-      if (!filtered.iconPath?.startsWith("static/")) {
-        delete filtered.iconPath;
-      }
-      if (!filtered.selectedIconPath?.startsWith("static/")) {
-        delete filtered.selectedIconPath;
-      }
-      return filtered;
-    });
+  /**
+   * 同步加载用户配置（univa.config.ts）
+   */
+  loadUserConfigSync() {
+    const jiti = createJiti(this.root);
+    const configFile = join4(this.root, `${ID}.config`);
+    try {
+      const configModule = jiti(configFile);
+      const userConfig = configModule?.default || configModule;
+      this.config = mergeWithArrayOverride({}, userConfig);
+      this.configPath = jiti.resolve(configFile);
+    } catch {
+    }
   }
-  const clonedTabBar = { ...tabBar };
-  if (clonedTabBar.list) {
-    clonedTabBar.list = rawTabBarList;
+  /**
+   * 异步加载用户配置（c12 支持更多格式与合并能力）
+   */
+  async loadUserConfigAsync() {
+    const { config: userConfig, configFile } = await loadConfig({
+      name: ID,
+      cwd: this.root,
+      defaults: this.config || {},
+      merger: mergeWithArrayOverride
+    });
+    this.config = userConfig;
+    this.configPath = configFile || "";
   }
-  return clonedTabBar;
-}
-function resolveUserPagesConfig(config) {
-  if (!config.tabBar) {
-    return config;
+  /**
+   * 设置 Vite 开发服务器
+   */
+  setupViteServer(server) {
+    if (this._server === server)
+      return;
+    this._server = server;
+    this.setupWatcher(server.watcher);
   }
-  return config;
-}
-function createPagesPlugin(options) {
-  const pages = options.pages || {};
-  const MODULE_ID_VIRTUAL = "virtual:univa-pages";
-  const RESOLVED_MODULE_ID_VIRTUAL = `\0${MODULE_ID_VIRTUAL}`;
-  const virtualData = {
-    pages: [],
-    subPackages: [],
-    tabBar: null
-  };
-  const virtualModule = () => {
-    const pages2 = `export const pages = ${virtualData.pages};`;
-    const subPackages = `export const subPackages = ${virtualData.subPackages};`;
-    const tabBar = `export const tabBar = ${JSON.stringify(virtualData.tabBar)};`;
-    return [pages2, subPackages, tabBar].join("\n");
-  };
-  const tabbarPlugin = {
-    name: "vite-plugin-univa-pages",
-    enforce: "pre",
-    resolveId(id) {
-      if (id === MODULE_ID_VIRTUAL) {
-        return RESOLVED_MODULE_ID_VIRTUAL;
+  /**
+   * 设置文件监听器
+   *
+   * 监听 univa.config.ts 变化，重新生成 .univa/pages.ts
+   */
+  setupWatcher(watcher) {
+    if (!this.configPath) {
+      return;
+    }
+    watcher.add(this.configPath);
+    watcher.on("change", async (filePath) => {
+      filePath = slash(filePath);
+      const configPath = slash(this.configPath || "");
+      if (filePath !== configPath) {
+        return;
       }
-    },
-    load(id) {
-      if (id === RESOLVED_MODULE_ID_VIRTUAL) {
-        return virtualModule();
+      await this.updateConfig();
+      this.onUpdate();
+    });
+  }
+  async updateConfig() {
+    await this.loadUserConfigAsync();
+    this.updateGeneratedFiles();
+  }
+  /**
+   * 更新生成的文件
+   *
+   * 读取 univa.config.ts 的 pages 字段（应用级配置），
+   * 生成 .univa/pages-config.ts 供 VitePluginUniPages 消费。
+   *
+   * 注意：不在此处生成 src/App.ku.vue，避免在 configResolved 阶段
+   * 创建 src 下新文件触发 watcher add 事件，导致 Vite 重编译
+   * 与 VitePluginUniPages 的 pages.json 写入冲突（EPERM）。
+   * App.ku.vue 的生成在 Univa() 初始化阶段完成。
+   */
+  updateGeneratedFiles() {
+    const pagesConfig = this.config?.pages;
+    if (pagesConfig) {
+      generatePagesConfigFile(pagesConfig, this.root);
+    }
+    const manifestConfig = this.config?.manifest;
+    if (manifestConfig) {
+      generateManifestConfigFile(manifestConfig, this.root);
+    }
+    const pagesTsPath = getPagesConfigPath(this.root);
+    const emptyContent = `// Auto-generated by @univa/core
+export default {}
+`;
+    if (!existsSync4(pagesTsPath)) {
+      writeFileSync3(pagesTsPath, emptyContent, "utf-8");
+    } else if (!pagesConfig) {
+      if (readFileSync3(pagesTsPath, "utf-8") !== emptyContent) {
+        writeFileSync3(pagesTsPath, emptyContent, "utf-8");
       }
     }
-  };
-  return [
-    tabbarPlugin,
-    UniHelperPages({
-      configSource: pages.config ? {
-        files: "vite.config",
-        rewrite: () => resolveUserPagesConfig(pages.config)
-      } : {
-        files: "pages.config"
-      },
-      subPackages: [
-        ...pages.subPackages || []
-      ],
-      exclude: [
-        ...pages?.exclude || [],
-        "**/components/**/*.*"
-      ],
-      onAfterMergePageMetaData(ctx) {
-        processPageName(ctx);
-        virtualData.tabBar = processTabBar(ctx);
-      },
-      onAfterWriteFile(ctx) {
-        virtualData.pages = ctx.resolveRoutes();
-        virtualData.subPackages = ctx.resolveSubRoutes();
-      },
-      dts: `${DTS_DIR}/pages.d.ts`
-    })
-  ];
-}
-function definePagesConfig(config) {
-  return config;
-}
+  }
+  /**
+   * 更新回调
+   * 触发 HMR
+   */
+  onUpdate() {
+    if (!this._server) {
+      return;
+    }
+    this._server.ws.send({
+      type: "full-reload"
+    });
+  }
+};
 
-// src/plugins/unocss.ts
-import { presetUni } from "@uni-helper/unocss-preset-uni";
-import presetLegacyCompat from "@unocss/preset-legacy-compat";
-import { presetIcons, transformerDirectives, transformerVariantGroup } from "unocss";
-import UnoCSS from "unocss/vite";
-function createUnocssPlugin() {
-  return UnoCSS({
-    presets: [
-      presetUniva()
-    ]
-  });
-}
-function presetUniva() {
+// src/plugins/options.ts
+var DEFAULT_DIRS = {
+  pages: "pages",
+  subPackages: ["pages-sub/*"],
+  layouts: "layouts"
+};
+var DEFAULT_IMPORTS = {
+  apis: ["vue", "uni-app", "composables/**", "stores/**", "hooks/**", "constants/**"],
+  components: ["components/**", "components-biz/**"]
+};
+function resolveOptions2(userOptions) {
+  const srcDir = userOptions.srcDir || "src";
+  const dirs = {
+    pages: userOptions.dirs?.pages ?? DEFAULT_DIRS.pages,
+    subPackages: userOptions.dirs?.subPackages ?? DEFAULT_DIRS.subPackages,
+    layouts: userOptions.dirs?.layouts ?? DEFAULT_DIRS.layouts
+  };
+  const imports = {
+    apis: userOptions.imports?.apis ?? DEFAULT_IMPORTS.apis,
+    components: userOptions.imports?.components ?? DEFAULT_IMPORTS.components
+  };
   return {
-    name: "univa-preset",
-    presets: [
-      presetUni({
-        attributify: false
-      }),
-      presetIcons({
-        scale: 1.2,
-        warn: true,
-        extraProperties: {
-          "display": "inline-block",
-          "vertical-align": "middle"
-        }
-      }),
-      // 处理低端安卓机的样式问题,eg: `rgb(255 0 0)` -> `rgb(255, 0, 0)`
-      presetLegacyCompat({
-        commaStyleColorFunction: true,
-        legacyColorSpace: true
-      })
-    ],
-    shortcuts: [
-      ["border-s", "border border-solid"],
-      ["wh-full", "w-full h-full"],
-      ["f-c-c", "flex justify-center items-center"],
-      ["f-col-c", "flex-col justify-center items-center"],
-      ["flex-items", "flex items-center"],
-      ["flex-justify", "flex justify-center"],
-      ["flex-col", "flex flex-col"]
-    ],
-    transformers: [
-      transformerDirectives(),
-      transformerVariantGroup()
-    ],
-    rules: [
-      [
-        "p-safe",
-        {
-          padding: "env(safe-area-inset-top) env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left)"
-        }
-      ],
-      ["pt-safe", { "padding-top": "env(safe-area-inset-top)" }],
-      ["pb-safe", { "padding-bottom": "env(safe-area-inset-bottom)" }]
-    ]
+    srcDir,
+    dirs,
+    imports,
+    overrides: userOptions.overrides
   };
 }
 
 // src/plugins/index.ts
-function createUnivaPlugins(options) {
-  const pluginFactory = {
-    plugins: [
-      ...createPagesPlugin(options),
-      UniHelperLayouts()
-    ],
-    register(condition, plugin) {
-      if (condition) {
-        this.plugins.push(plugin);
-      }
+var context;
+function createCorePlugin() {
+  return {
+    name: "vite-plugin-univa",
+    enforce: "pre",
+    async configResolved() {
+      await context.loadUserConfigAsync();
+      context.updateGeneratedFiles();
+    },
+    configureServer(server) {
+      context.setupViteServer(server);
     }
   };
-  pluginFactory.register(options.appRoot !== false, UnivaRoot({
+}
+function isPresetName(from) {
+  if (/[*?[\]{}]/.test(from))
+    return false;
+  if (/^@[\w.-]+\/[\w.-]+$/.test(from))
+    return true;
+  if (/[/\\]/.test(from))
+    return false;
+  return true;
+}
+function resolveApiSources(sources, srcDir) {
+  const presets = [];
+  const dirs = [];
+  for (const source of sources) {
+    if (typeof source !== "string") {
+      presets.push(source);
+    } else if (source.startsWith("!")) {
+      dirs.push(`!${srcDir}/${source.slice(1)}`);
+    } else if (isPresetName(source)) {
+      presets.push(source);
+    } else {
+      dirs.push(`${srcDir}/${source}`);
+    }
+  }
+  return { presets, dirs };
+}
+function createUnivaPlugins(resolved) {
+  const plugins = [];
+  const { srcDir } = resolved;
+  plugins.push(createCorePlugin());
+  plugins.push(...createPagesPlugin({
+    dir: `${srcDir}/${resolved.dirs.pages}`,
+    subPackages: resolved.dirs.subPackages.map((p) => `${srcDir}/${p}`),
+    ...resolved.overrides?.pages
+  }));
+  plugins.push(VitePluginUniLayouts({
+    layoutDir: `${srcDir}/${resolved.dirs.layouts}`,
+    ...resolved.overrides?.layouts
+  }));
+  plugins.push(UniKuRoot({
     enabledVirtualHost: true,
-    rootFileName: "App.univa",
     enabledGlobalRef: true,
-    autoCreateRoot: true,
+    rootFileName: ROOT_NAME,
     excludePages: [
-      `${COMPONENT_ASYNC_ROOT}/**/*.*`
-    ]
+      "components-async/**/*.*"
+    ],
+    ...resolved.overrides?.root
+  }));
+  plugins.push(VitePluginUniComponents({
+    dirs: resolved.imports.components.map((c) => `${srcDir}/${c}`),
+    dts: `${UNIVA_DIR_NAME}/components.d.ts`,
+    globalNamespaces: ["components", "common"],
+    directoryAsNamespace: true,
+    ...resolved.overrides?.components
   }));
-  pluginFactory.register(true, createManifestPlugin(options));
-  pluginFactory.register(options.components !== false, createComponentsPlugin(options));
-  pluginFactory.register(true, UniOptimization());
-  pluginFactory.register(true, Uni());
-  pluginFactory.register(true, createUnocssPlugin());
-  pluginFactory.register(options.autoImport !== false, createAutoImportPlugin(options));
-  pluginFactory.register(true, UniPolyfill());
-  return pluginFactory.plugins;
+  plugins.push(createManifestPlugin({
+    ...resolved.overrides?.manifest
+  }));
+  plugins.push(...Uni());
+  plugins.push(...UnoCSS());
+  const { presets, dirs } = resolveApiSources(resolved.imports.apis, srcDir);
+  const autoImportPlugin = AutoImport({
+    imports: presets,
+    dirs,
+    dts: `${UNIVA_DIR_NAME}/auto-imports.d.ts`,
+    ...resolved.overrides?.autoImport
+  });
+  if (Array.isArray(autoImportPlugin)) {
+    plugins.push(...autoImportPlugin);
+  } else {
+    plugins.push(autoImportPlugin);
+  }
+  return plugins;
 }
-
-// src/index.ts
-function Univa(config) {
-  return createUnivaPlugins({
-    components: config?.components ?? true,
-    autoImport: config?.autoImport ?? true,
-    appRoot: config?.appRoot ?? true,
-    pages: config?.pages,
-    manifest: config?.manifest
+function Univa() {
+  context = new UnivaContext({
+    root: process.cwd()
   });
+  ensureUnivaDir(context.root);
+  context.loadUserConfigSync();
+  setDebug(context.config?.debug ?? false);
+  context.ensureRootComponent(`${ROOT_NAME}.vue`);
+  const resolved = resolveOptions2(context.config || {});
+  log("\u5DF2\u52A0\u8F7D\u914D\u7F6E\uFF1A", context.configPath || "\u9ED8\u8BA4\u914D\u7F6E");
+  return createUnivaPlugins(resolved);
 }
+var plugins_default = Univa;
+
+// src/index.ts
+import { presetUni } from "@uni-helper/unocss-preset-uni";
+import { camelCase, kebabCase, pascalCase } from "@uni-helper/vite-plugin-uni-components";
+import { default as default2 } from "@uni-helper/vite-plugin-uni-components";
+import { VitePluginUniLayouts as VitePluginUniLayouts2 } from "@uni-helper/vite-plugin-uni-layouts";
+import { PageContext, VitePluginUniPages as VitePluginUniPages2 } from "@uni-helper/vite-plugin-uni-pages";
+import { default as default3 } from "@uni-ku/root";
+import { default as default4 } from "unplugin-auto-import/vite";
 export {
-  Univa,
-  definePagesConfig,
-  presetUniva
+  default4 as AutoImport,
+  PageContext,
+  default3 as UniKuRoot,
+  plugins_default as Univa,
+  default2 as VitePluginUniComponents,
+  VitePluginUniLayouts2 as VitePluginUniLayouts,
+  VitePluginUniPages2 as VitePluginUniPages,
+  camelCase,
+  createUnivaPlugins,
+  defineConfig,
+  kebabCase,
+  pascalCase,
+  presetUni
 };