@4399ywkf/core 4.0.85 → 5.0.1

package/dist/cli/index.js

@@ -0,0 +1,2180 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import chalk3 from "chalk";
+
+// src/cli/dev.ts
+import { rspack as rspack3 } from "@rspack/core";
+import { RspackDevServer } from "@rspack/dev-server";
+import chalk from "chalk";
+import ora from "ora";
+
+// src/config/loader.ts
+import { existsSync } from "fs";
+import { resolve, extname } from "path";
+import { pathToFileURL } from "url";
+import deepmerge from "deepmerge";
+
+// src/config/schema.ts
+var defaultConfig = {
+  appName: "app",
+  appCName: "\u5E94\u7528",
+  dev: {
+    port: 3e3,
+    host: "localhost",
+    proxy: {},
+    https: false
+  },
+  output: {
+    path: "dist",
+    publicPath: "/",
+    clean: true
+  },
+  html: {
+    title: "\u5E94\u7528",
+    template: "public/index.html",
+    favicon: "public/favicon.ico",
+    mountRoot: "root"
+  },
+  style: {
+    cssModules: true,
+    less: { enabled: true, lessOptions: { javascriptEnabled: true } },
+    sass: { enabled: true, sassOptions: {} },
+    tailwindcss: true
+  },
+  router: {
+    basename: "/",
+    conventional: false,
+    pagesDir: "src/pages",
+    exclude: [
+      /\/components?\//,
+      /\/models\//,
+      /\/utils?\//,
+      /^_/,
+      /\.d\.ts$/,
+      /\.(test|spec|e2e)\.(ts|tsx|js|jsx)$/
+    ]
+  },
+  microFrontend: {
+    enabled: false,
+    name: "app",
+    framework: "qiankun"
+  },
+  performance: {
+    rsdoctor: false,
+    splitChunks: true,
+    dropConsole: false
+  },
+  tools: {},
+  env: {
+    publicEnvFile: "config/env/.env.public",
+    envDir: "config/env"
+  },
+  alias: {},
+  plugins: []
+};
+
+// src/config/loader.ts
+var CONFIG_FILES = [
+  "ywkf.config.ts",
+  "ywkf.config.mts",
+  "ywkf.config.js",
+  "ywkf.config.mjs"
+];
+function findConfigFile(cwd) {
+  for (const file of CONFIG_FILES) {
+    const configPath = resolve(cwd, file);
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+  }
+  return null;
+}
+async function loadTsConfig(configPath) {
+  const jiti = (await import("jiti")).default;
+  const loader = jiti(configPath, {
+    interopDefault: true
+  });
+  const config = loader(configPath);
+  return config.default || config;
+}
+async function loadJsConfig(configPath) {
+  const fileUrl = pathToFileURL(configPath).href;
+  const module = await import(fileUrl);
+  return module.default || module;
+}
+async function loadConfigFile(configPath) {
+  const ext = extname(configPath);
+  if (ext === ".ts" || ext === ".mts") {
+    return loadTsConfig(configPath);
+  }
+  return loadJsConfig(configPath);
+}
+function mergeConfig(userConfig, baseConfig = defaultConfig) {
+  return deepmerge(baseConfig, userConfig, {
+    arrayMerge: (_, sourceArray) => sourceArray
+  });
+}
+async function resolveConfig(cwd) {
+  const configPath = findConfigFile(cwd);
+  if (!configPath) {
+    console.warn(
+      "\u26A0\uFE0F  \u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6 (ywkf.config.ts)\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E"
+    );
+    return {
+      config: defaultConfig,
+      configPath: null
+    };
+  }
+  try {
+    const userConfig = await loadConfigFile(configPath);
+    const config = mergeConfig(userConfig);
+    return { config, configPath };
+  } catch (error) {
+    console.error("\u274C \u914D\u7F6E\u6587\u4EF6\u52A0\u8F7D\u5931\u8D25:", error);
+    throw error;
+  }
+}
+function createPathResolver(cwd) {
+  return {
+    resolveApp: (relativePath) => resolve(cwd, relativePath),
+    cwd
+  };
+}
+
+// src/rspack/index.ts
+import { RsdoctorRspackPlugin } from "@rsdoctor/rspack-plugin";
+
+// src/rspack/dev.ts
+import { merge } from "webpack-merge";
+import { createRequire as createRequire2 } from "module";
+
+// src/rspack/base.ts
+import { rspack } from "@rspack/core";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join as join5 } from "path";
+
+// src/generator/plugin.ts
+import { watch, existsSync as existsSync5 } from "fs";
+import { join as join4 } from "path";
+
+// src/generator/generator.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/router/generator.ts
+import { existsSync as existsSync2, readdirSync, statSync, mkdirSync, writeFileSync } from "fs";
+import { join, relative } from "path";
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  "components",
+  "hooks",
+  "utils",
+  "services",
+  "models",
+  "assets",
+  "types",
+  "constants",
+  "styles"
+]);
+var CONVENTION_FILES = {
+  page: /^page\.(tsx?|jsx?)$/,
+  layout: /^layout\.(tsx?|jsx?)$/,
+  error: /^error\.(tsx?|jsx?)$/,
+  loading: /^loading\.(tsx?|jsx?)$/,
+  catchAll: /^\$\.(tsx?|jsx?)$/
+};
+var ConventionalRouteGenerator = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  generate() {
+    const { pagesDir } = this.options;
+    if (!existsSync2(pagesDir)) {
+      console.warn(`[ywkf] \u9875\u9762\u76EE\u5F55\u4E0D\u5B58\u5728: ${pagesDir}`);
+      return [];
+    }
+    return this.scanDirectory(pagesDir, "/");
+  }
+  /**
+   * 扫描目录，生成路由树
+   */
+  scanDirectory(dir, routePath) {
+    const entries = readdirSync(dir);
+    const layoutFile = entries.find((e) => CONVENTION_FILES.layout.test(e));
+    const pageFile = entries.find((e) => CONVENTION_FILES.page.test(e));
+    const errorFile = entries.find((e) => CONVENTION_FILES.error.test(e));
+    const loadingFile = entries.find((e) => CONVENTION_FILES.loading.test(e));
+    const catchAllFile = entries.find((e) => CONVENTION_FILES.catchAll.test(e));
+    const subDirs = entries.filter((e) => {
+      if (e.startsWith(".")) return false;
+      if (EXCLUDED_DIRS.has(e)) return false;
+      return statSync(join(dir, e)).isDirectory();
+    });
+    const childRoutes = [];
+    for (const subDir of subDirs) {
+      const subDirPath = join(dir, subDir);
+      if (subDir.startsWith("__")) {
+        const pathlessRoutes = this.scanDirectory(subDirPath, routePath);
+        const pathlessLayout = readdirSync(subDirPath).find(
+          (e) => CONVENTION_FILES.layout.test(e)
+        );
+        if (pathlessLayout) {
+          const pathlessChildren = this.scanDirectory(subDirPath, routePath);
+          childRoutes.push({
+            path: routePath,
+            name: this.generateRouteName(subDir.slice(2)),
+            layoutFile: relative(this.options.pagesDir, join(subDirPath, pathlessLayout)),
+            isLayout: true,
+            pathless: true,
+            children: pathlessChildren.filter(
+              (r) => r.layoutFile !== relative(this.options.pagesDir, join(subDirPath, pathlessLayout))
+            )
+          });
+        } else {
+          childRoutes.push(...pathlessRoutes);
+        }
+        continue;
+      }
+      const subRoutePath = this.resolveRoutePath(subDir, routePath);
+      childRoutes.push(...this.scanDirectory(subDirPath, subRoutePath));
+    }
+    const routeName = this.generateRouteName(routePath);
+    const relPath = (file) => relative(this.options.pagesDir, join(dir, file));
+    if (layoutFile) {
+      const layoutChildren = [];
+      if (pageFile) {
+        layoutChildren.push({
+          path: routePath,
+          file: relPath(pageFile),
+          name: routeName + "Index",
+          index: true
+        });
+      }
+      if (catchAllFile) {
+        layoutChildren.push({
+          path: "*",
+          file: relPath(catchAllFile),
+          name: routeName + "CatchAll"
+        });
+      }
+      layoutChildren.push(...childRoutes);
+      return [
+        {
+          path: routePath,
+          layoutFile: relPath(layoutFile),
+          errorFile: errorFile ? relPath(errorFile) : void 0,
+          loadingFile: loadingFile ? relPath(loadingFile) : void 0,
+          name: routeName,
+          isLayout: true,
+          children: layoutChildren
+        }
+      ];
+    }
+    const result = [];
+    if (pageFile) {
+      result.push({
+        path: routePath,
+        file: relPath(pageFile),
+        errorFile: errorFile ? relPath(errorFile) : void 0,
+        name: routeName
+      });
+    }
+    if (catchAllFile) {
+      result.push({
+        path: "*",
+        file: relPath(catchAllFile),
+        name: routeName + "CatchAll"
+      });
+    }
+    result.push(...childRoutes);
+    return result;
+  }
+  /**
+   * 解析目录名到路由路径
+   *
+   * - [id]       → :id
+   * - [id$]      → :id?
+   * - [...slug]  → *
+   * - user.profile → user/profile
+   */
+  resolveRoutePath(dirName, parentPath) {
+    let segment;
+    if (dirName.match(/^\[\.\.\.(.+)\]$/)) {
+      segment = "*";
+    } else if (dirName.match(/^\[(.+)\$\]$/)) {
+      const param = dirName.slice(1, -2);
+      segment = `:${param}?`;
+    } else if (dirName.match(/^\[(.+)\]$/)) {
+      const param = dirName.slice(1, -1);
+      segment = `:${param}`;
+    } else if (dirName.includes(".")) {
+      segment = dirName.replace(/\./g, "/");
+    } else {
+      segment = dirName;
+    }
+    return parentPath === "/" ? `/${segment}` : `${parentPath}/${segment}`;
+  }
+  /**
+   * 生成有效的 JS 标识符名称
+   */
+  generateRouteName(path) {
+    const name = path.split("/").filter(Boolean).map(
+      (s) => s.replace(/^:/, "Param").replace(/\?$/, "Optional").replace(/^\*$/, "CatchAll")
+    ).map((s) => {
+      const cleaned = s.replace(/[^a-zA-Z0-9]/g, "");
+      if (!cleaned) return "";
+      return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+    }).join("");
+    if (!name || /^\d/.test(name)) {
+      return "Page" + (name || "Root");
+    }
+    return name;
+  }
+  // ===== 代码生成 =====
+  generateCode() {
+    const routes = this.generate();
+    const lazyImports = [];
+    const errorImports = [];
+    const loadingImports = [];
+    this.collectImports(routes, lazyImports, errorImports, loadingImports);
+    return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/core \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u4FEE\u6539
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+import React, { lazy, Suspense } from "react";
+import { createBrowserRouter, type RouteObject } from "react-router";
+
+// \u61D2\u52A0\u8F7D\u9875\u9762\u7EC4\u4EF6
+${lazyImports.join("\n")}
+${errorImports.length > 0 ? "\n// \u9519\u8BEF\u8FB9\u754C\u7EC4\u4EF6\n" + errorImports.join("\n") : ""}
+${loadingImports.length > 0 ? "\n// \u52A0\u8F7D\u72B6\u6001\u7EC4\u4EF6\n" + loadingImports.join("\n") : ""}
+
+// \u9ED8\u8BA4\u52A0\u8F7D\u72B6\u6001
+const DefaultLoading = () => <div style={{ padding: 24, textAlign: "center" }}>\u52A0\u8F7D\u4E2D...</div>;
+
+// \u61D2\u52A0\u8F7D\u5305\u88C5
+function LazyRoute({
+  Component,
+  Loading = DefaultLoading,
+}: {
+  Component: React.LazyExoticComponent<React.ComponentType<unknown>>;
+  Loading?: React.ComponentType;
+}) {
+  return (
+    <Suspense fallback={<Loading />}>
+      <Component />
+    </Suspense>
+  );
+}
+
+// \u8DEF\u7531\u914D\u7F6E
+export const routes: RouteObject[] = ${this.emitRouteArray(routes)};
+
+/**
+ * \u521B\u5EFA\u8DEF\u7531\u5B9E\u4F8B
+ */
+export function createRouter(basename?: string) {
+  return createBrowserRouter(routes, { basename: basename || "/" });
+}
+
+export default routes;
+`;
+  }
+  collectImports(routes, lazyImports, errorImports, loadingImports) {
+    for (const route of routes) {
+      const name = route.name;
+      const toImportPath = (f) => f.replace(/\.(tsx?|jsx?)$/, "");
+      if (route.isLayout && route.layoutFile) {
+        lazyImports.push(
+          `const ${name}Layout = lazy(() => import("@/pages/${toImportPath(route.layoutFile)}"));`
+        );
+      }
+      if (route.file) {
+        lazyImports.push(
+          `const ${name}Page = lazy(() => import("@/pages/${toImportPath(route.file)}"));`
+        );
+      }
+      if (route.errorFile) {
+        errorImports.push(
+          `const ${name}Error = lazy(() => import("@/pages/${toImportPath(route.errorFile)}"));`
+        );
+      }
+      if (route.loadingFile) {
+        loadingImports.push(
+          `const ${name}Loading = lazy(() => import("@/pages/${toImportPath(route.loadingFile)}"));`
+        );
+      }
+      if (route.children) {
+        this.collectImports(route.children, lazyImports, errorImports, loadingImports);
+      }
+    }
+  }
+  emitRouteArray(routes, parentPath) {
+    const items = routes.map((r) => this.emitRouteObject(r, parentPath));
+    return `[
+  ${items.join(",\n  ")}
+]`;
+  }
+  emitRouteObject(route, parentPath) {
+    const parts = [];
+    const name = route.name;
+    if (route.index) {
+      parts.push("index: true");
+    } else if (route.pathless) {
+    } else if (route.path === "*") {
+      parts.push(`path: "*"`);
+    } else if (parentPath && route.path.startsWith(parentPath) && parentPath !== "/") {
+      const rel = route.path.slice(parentPath.length + 1);
+      parts.push(`path: "${rel || ""}"`);
+    } else {
+      parts.push(`path: "${route.path}"`);
+    }
+    if (route.isLayout && route.layoutFile) {
+      const loadingProp = route.loadingFile ? ` Loading={${name}Loading}` : "";
+      parts.push(`element: <LazyRoute Component={${name}Layout}${loadingProp} />`);
+    } else if (route.file) {
+      parts.push(`element: <LazyRoute Component={${name}Page} />`);
+    }
+    if (route.errorFile) {
+      parts.push(`errorElement: <LazyRoute Component={${name}Error} />`);
+    }
+    if (route.children && route.children.length > 0) {
+      const childParent = route.pathless ? parentPath : route.path;
+      parts.push(`children: ${this.emitRouteArray(route.children, childParent)}`);
+    }
+    return `{
+    ${parts.join(",\n    ")}
+  }`;
+  }
+  /**
+   * 写入路由文件
+   */
+  write() {
+    const { outputDir } = this.options;
+    const code = this.generateCode();
+    if (!existsSync2(outputDir)) {
+      mkdirSync(outputDir, { recursive: true });
+    }
+    writeFileSync(join(outputDir, "routes.tsx"), code, "utf-8");
+    console.log(`[ywkf] \u7EA6\u5B9A\u5F0F\u8DEF\u7531\u5DF2\u751F\u6210`);
+  }
+};
+
+// src/generator/templates/entry.ts
+function generateEntry(config, injections = {}) {
+  const imports = [
+    `import "@/index.css";`,
+    `import { runApp } from "./bootstrap";`,
+    ...injections.imports || []
+  ];
+  const topLevel = injections.topLevel || [];
+  const exports = injections.exports || [];
+  const hasPluginExports = exports.length > 0;
+  const startupCode = hasPluginExports ? `// \u72EC\u7ACB\u8FD0\u884C\u6A21\u5F0F
+if (shouldRunIndependently !== false) {
+  runApp();
+}` : `// \u542F\u52A8\u5E94\u7528
+runApp();`;
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/core \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u4FEE\u6539
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+${imports.join("\n")}
+
+${topLevel.length > 0 ? topLevel.join("\n") + "\n" : ""}${exports.length > 0 ? exports.join("\n") + "\n\n" : ""}${startupCode}
+`;
+}
+
+// src/generator/templates/bootstrap.ts
+function generateBootstrap(config, injections = {}) {
+  const { appName, router } = config;
+  const routerImport = router.conventional ? `import { createRouter } from "./routes";` : `import { createRouter } from "@/routes";`;
+  const imports = [
+    `import { bootstrap, type AppConfig } from "@4399ywkf/core/runtime";`,
+    routerImport,
+    ...injections.imports || []
+  ];
+  const topLevel = injections.topLevel || [];
+  const exports = injections.exports || [];
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/core \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u4FEE\u6539
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+${imports.join("\n")}
+
+/**
+ * \u5E94\u7528\u540D\u79F0
+ */
+export const APP_NAME = "${appName}";
+
+/**
+ * \u8DEF\u7531 basename
+ */
+export const BASENAME = "${router.basename || "/"}";
+
+/**
+ * \u83B7\u53D6\u7528\u6237\u81EA\u5B9A\u4E49\u914D\u7F6E\uFF08\u5982\u679C\u5B58\u5728\uFF09
+ * \u7528\u6237\u53EF\u5728 src/app.config.ts \u4E2D\u5BFC\u51FA\u914D\u7F6E\u6765\u8986\u76D6\u9ED8\u8BA4\u503C
+ */
+async function getUserConfig(): Promise<Partial<AppConfig>> {
+  try {
+    // webpackIgnore \u6CE8\u91CA\u8BA9\u6253\u5305\u5668\u8DF3\u8FC7\u6A21\u5757\u5B58\u5728\u6027\u68C0\u67E5
+    const userConfigModule = await import(/* webpackIgnore: true */ "@/app.config");
+    return userConfigModule.default || {};
+  } catch {
+    // \u6587\u4EF6\u4E0D\u5B58\u5728\u65F6\u8FD4\u56DE\u7A7A\u914D\u7F6E
+    return {};
+  }
+}
+
+/**
+ * \u521B\u5EFA\u5E94\u7528\u914D\u7F6E
+ */
+export function createAppConfig(userConfig: Partial<AppConfig> = {}): AppConfig {
+  const router = createRouter(BASENAME);
+
+  const defaultConfig: AppConfig = {
+    appName: APP_NAME,
+    router,
+    basename: BASENAME,
+    rootId: APP_NAME,
+    strictMode: true,
+    antd: {
+      enabled: true,
+    },
+    providers: [],
+    lifecycle: {
+      onMounted() {
+        console.log(\`[\${APP_NAME}] \u5E94\u7528\u5DF2\u6302\u8F7D\`);
+      },
+      onUnmount() {
+        console.log(\`[\${APP_NAME}] \u5E94\u7528\u5DF2\u5378\u8F7D\`);
+      },
+      onError(error) {
+        console.error(\`[\${APP_NAME}] \u5168\u5C40\u9519\u8BEF:\`, error);
+      },
+    },
+  };
+
+  // \u6DF1\u5EA6\u5408\u5E76\u7528\u6237\u914D\u7F6E
+  return {
+    ...defaultConfig,
+    ...userConfig,
+    antd: { ...defaultConfig.antd, ...userConfig.antd },
+    providers: [...(defaultConfig.providers || []), ...(userConfig.providers || [])],
+    lifecycle: { ...defaultConfig.lifecycle, ...userConfig.lifecycle },
+  };
+}
+
+/**
+ * \u542F\u52A8\u5E94\u7528
+ */
+export async function runApp(): Promise<void> {
+  const userConfig = await getUserConfig();
+  await bootstrap(createAppConfig(userConfig));
+}
+${topLevel.length > 0 ? "\n" + topLevel.join("\n") : ""}
+${exports.length > 0 ? "\n" + exports.join("\n") : ""}
+`;
+}
+
+// src/generator/templates/env-types.ts
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { join as join2 } from "path";
+function generateEnvTypes(cwd, config) {
+  const envVars = collectEnvVars(cwd, config);
+  const envInterface = envVars.map((key) => `    readonly ${key}: string;`).join("\n");
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/core \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u4FEE\u6539
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+/// <reference types="react" />
+/// <reference types="react-dom" />
+
+declare namespace NodeJS {
+  interface ProcessEnv {
+${envInterface}
+    readonly NODE_ENV: "development" | "production" | "test";
+  }
+}
+
+declare module "*.svg" {
+  import * as React from "react";
+  const ReactComponent: React.FunctionComponent<
+    React.SVGProps<SVGSVGElement> & { title?: string }
+  >;
+  export default ReactComponent;
+}
+
+declare module "*.png" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.jpg" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.jpeg" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.gif" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.webp" {
+  const src: string;
+  export default src;
+}
+
+declare module "*.css" {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module "*.less" {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module "*.scss" {
+  const classes: { readonly [key: string]: string };
+  export default classes;
+}
+
+declare module "*.md" {
+  const content: string;
+  export default content;
+}
+`;
+}
+function collectEnvVars(cwd, config) {
+  const envVars = /* @__PURE__ */ new Set();
+  const publicEnvPath = join2(cwd, config.env.publicEnvFile || "config/env/.env.public");
+  if (existsSync3(publicEnvPath)) {
+    const content = readFileSync(publicEnvPath, "utf-8");
+    parseEnvFile(content, envVars);
+  }
+  const devEnvPath = join2(cwd, config.env.envDir || "config/env", ".env.development");
+  if (existsSync3(devEnvPath)) {
+    const content = readFileSync(devEnvPath, "utf-8");
+    parseEnvFile(content, envVars);
+  }
+  const prodEnvPath = join2(cwd, config.env.envDir || "config/env", ".env.production");
+  if (existsSync3(prodEnvPath)) {
+    const content = readFileSync(prodEnvPath, "utf-8");
+    parseEnvFile(content, envVars);
+  }
+  return Array.from(envVars).sort();
+}
+function parseEnvFile(content, envVars) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)\s*=/);
+    if (match) {
+      envVars.add(match[1]);
+    }
+  }
+}
+
+// src/generator/templates/route-types.ts
+function generateRouteTypes() {
+  return `// \u6B64\u6587\u4EF6\u7531 @4399ywkf/core \u81EA\u52A8\u751F\u6210\uFF0C\u8BF7\u52FF\u624B\u52A8\u4FEE\u6539
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+
+import type { RouteObject } from "react-router";
+
+declare module "@ywkf/routes" {
+  export const routes: RouteObject[];
+  export function createRouter(basename?: string): ReturnType<typeof import("react-router").createBrowserRouter>;
+  export default routes;
+}
+`;
+}
+
+// src/generator/generator.ts
+var YwkfGenerator = class {
+  context;
+  pluginHooks;
+  lastGeneratedContent = /* @__PURE__ */ new Map();
+  constructor(context, pluginHooks = []) {
+    this.context = {
+      ...context,
+      outputDir: context.outputDir || join3(context.cwd, ".ywkf")
+    };
+    this.pluginHooks = pluginHooks;
+  }
+  /**
+   * 生成所有文件
+   */
+  async generate() {
+    const { outputDir } = this.context;
+    this.ensureDir(outputDir);
+    this.ensureDir(join3(outputDir, "types"));
+    this.generateConfigSnapshot();
+    this.generateRoutes();
+    this.generateBootstrapFile();
+    this.generateEntryFile();
+    this.generateTypes();
+    await this.generatePluginFiles();
+    for (const hooks of this.pluginHooks) {
+      if (hooks.afterGenerate) {
+        await hooks.afterGenerate(this.context);
+      }
+    }
+    console.log(`[ywkf] \u5DF2\u751F\u6210 .ywkf \u76EE\u5F55`);
+  }
+  /**
+   * 生成配置快照
+   */
+  generateConfigSnapshot() {
+    const { outputDir, config } = this.context;
+    const configPath = join3(outputDir, "config.json");
+    const serializableConfig = JSON.parse(
+      JSON.stringify(config, (key, value) => {
+        if (typeof value === "function") {
+          return "[Function]";
+        }
+        return value;
+      })
+    );
+    this.writeFileIfChanged(
+      configPath,
+      JSON.stringify(serializableConfig, null, 2)
+    );
+  }
+  /**
+   * 生成约定式路由
+   */
+  generateRoutes() {
+    const { cwd, outputDir, config } = this.context;
+    if (!config.router.conventional) {
+      return;
+    }
+    const pagesDir = join3(cwd, config.router.pagesDir || "src/pages");
+    const generator = new ConventionalRouteGenerator({
+      pagesDir,
+      outputDir,
+      basename: config.router.basename
+    });
+    const content = generator.generateCode();
+    const routesPath = join3(outputDir, "routes.tsx");
+    this.writeFileIfChanged(routesPath, content);
+  }
+  /**
+   * 生成启动文件
+   */
+  generateBootstrapFile() {
+    const { outputDir, config } = this.context;
+    const injections = this.collectInjections("bootstrap");
+    let content = generateBootstrap(config, injections);
+    for (const hooks of this.pluginHooks) {
+      if (hooks.modifyBootstrapCode) {
+        const result = hooks.modifyBootstrapCode(content, this.context);
+        if (result) {
+          content = result;
+        }
+      }
+    }
+    const bootstrapPath = join3(outputDir, "bootstrap.tsx");
+    this.writeFileIfChanged(bootstrapPath, content);
+  }
+  /**
+   * 生成入口文件
+   */
+  generateEntryFile() {
+    const { outputDir, config } = this.context;
+    const injections = this.collectInjections("entry");
+    let content = generateEntry(config, injections);
+    for (const hooks of this.pluginHooks) {
+      if (hooks.modifyEntryCode) {
+        const result = hooks.modifyEntryCode(content, this.context);
+        if (result) {
+          content = result;
+        }
+      }
+    }
+    const entryPath = join3(outputDir, "index.tsx");
+    this.writeFileIfChanged(entryPath, content);
+  }
+  /**
+   * 收集插件代码注入
+   */
+  collectInjections(type) {
+    const result = {
+      imports: [],
+      topLevel: [],
+      exports: []
+    };
+    const hookName = type === "entry" ? "injectEntry" : "injectBootstrap";
+    for (const hooks of this.pluginHooks) {
+      const hook = hooks[hookName];
+      if (hook) {
+        const injection = hook(this.context);
+        if (injection) {
+          result.imports?.push(...injection.imports || []);
+          result.topLevel?.push(...injection.topLevel || []);
+          result.exports?.push(...injection.exports || []);
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 生成插件附加文件
+   */
+  async generatePluginFiles() {
+    const { outputDir } = this.context;
+    for (const hooks of this.pluginHooks) {
+      if (hooks.generateFiles) {
+        const files = hooks.generateFiles(this.context);
+        if (files) {
+          for (const file of files) {
+            const filePath = join3(outputDir, file.path);
+            const dir = join3(filePath, "..");
+            this.ensureDir(dir);
+            this.writeFileIfChanged(filePath, file.content);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * 生成类型定义
+   */
+  generateTypes() {
+    const { outputDir, config, cwd } = this.context;
+    const envTypesContent = generateEnvTypes(cwd, config);
+    this.writeFileIfChanged(
+      join3(outputDir, "types", "env.d.ts"),
+      envTypesContent
+    );
+    if (config.router.conventional) {
+      const routeTypesContent = generateRouteTypes();
+      this.writeFileIfChanged(
+        join3(outputDir, "types", "routes.d.ts"),
+        routeTypesContent
+      );
+    }
+  }
+  /**
+   * 确保目录存在
+   */
+  ensureDir(dir) {
+    if (!existsSync4(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+  }
+  /**
+   * 只在内容变化时写入文件（避免触发不必要的热更新）
+   */
+  writeFileIfChanged(filePath, content) {
+    const normalizedContent = this.normalizeContent(content);
+    const lastContent = this.lastGeneratedContent.get(filePath);
+    if (lastContent === normalizedContent) {
+      return;
+    }
+    if (existsSync4(filePath)) {
+      const existingContent = readFileSync2(filePath, "utf-8");
+      if (this.normalizeContent(existingContent) === normalizedContent) {
+        this.lastGeneratedContent.set(filePath, normalizedContent);
+        return;
+      }
+    }
+    writeFileSync2(filePath, content, "utf-8");
+    this.lastGeneratedContent.set(filePath, normalizedContent);
+  }
+  /**
+   * 标准化内容（去掉时间戳等动态部分）
+   */
+  normalizeContent(content) {
+    return content.replace(/\/\/ Generated at: .+/g, "").replace(/\/\*\* Generated at: .+ \*\//g, "");
+  }
+};
+
+// src/generator/plugin.ts
+var YwkfGeneratorPlugin = class {
+  options;
+  hasGenerated = false;
+  isWatching = false;
+  generator = null;
+  pluginHooks = [];
+  initialized = false;
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * 解析插件配置为插件实例
+   */
+  async resolvePlugin(pluginConfig) {
+    try {
+      let plugin;
+      let options = {};
+      if (typeof pluginConfig === "string") {
+        const module = await import(pluginConfig);
+        plugin = module.default || module;
+      } else if (Array.isArray(pluginConfig)) {
+        const [pluginOrName, pluginOptions] = pluginConfig;
+        options = pluginOptions;
+        if (typeof pluginOrName === "string") {
+          const module = await import(pluginOrName);
+          plugin = module.default || module;
+        } else {
+          plugin = pluginOrName;
+        }
+      } else {
+        plugin = pluginConfig;
+      }
+      if (typeof plugin === "function") {
+        plugin = plugin(options);
+      }
+      return plugin;
+    } catch (error) {
+      console.error(`[ywkf] \u89E3\u6790\u63D2\u4EF6\u5931\u8D25: ${error}`);
+      return null;
+    }
+  }
+  /**
+   * 初始化插件钩子
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    const { cwd, config, isDev, pluginConfigs = [] } = this.options;
+    const context = {
+      cwd,
+      isDev,
+      isProd: !isDev,
+      config,
+      logger: {
+        info: (msg) => console.log(`[ywkf] ${msg}`),
+        warn: (msg) => console.warn(`[ywkf] ${msg}`),
+        error: (msg) => console.error(`[ywkf] ${msg}`),
+        debug: (msg) => {
+          if (process.env.DEBUG) {
+            console.log(`[ywkf:debug] ${msg}`);
+          }
+        }
+      }
+    };
+    for (const pluginConfig of pluginConfigs) {
+      const plugin = await this.resolvePlugin(pluginConfig);
+      if (plugin) {
+        const hooks = await plugin.setup(context);
+        this.pluginHooks.push(hooks);
+        console.log(`[ywkf] \u63D2\u4EF6\u5DF2\u52A0\u8F7D: ${plugin.name}`);
+      }
+    }
+    this.generator = new YwkfGenerator(
+      {
+        cwd: this.options.cwd,
+        config: this.options.config,
+        outputDir: this.options.outputDir,
+        isDev: this.options.isDev
+      },
+      this.pluginHooks
+    );
+    this.initialized = true;
+  }
+  apply(compiler) {
+    const pluginName = "YwkfGeneratorPlugin";
+    compiler.hooks.beforeCompile.tapAsync(pluginName, async (params, callback) => {
+      try {
+        await this.initialize();
+        if (!this.hasGenerated && this.generator) {
+          await this.generator.generate();
+          this.hasGenerated = true;
+        }
+        callback();
+      } catch (error) {
+        callback(error);
+      }
+    });
+    if (this.options.isDev && !this.isWatching) {
+      this.watchPages();
+    }
+  }
+  /**
+   * 监听页面目录变化
+   */
+  watchPages() {
+    const { config, cwd } = this.options;
+    const pagesDir = join4(cwd, config.router.pagesDir || "src/pages");
+    if (!existsSync5(pagesDir)) {
+      return;
+    }
+    this.isWatching = true;
+    let debounceTimer = null;
+    const watcher = watch(
+      pagesDir,
+      { recursive: true },
+      (eventType, filename) => {
+        if (!filename?.match(/\.(tsx?|jsx?)$/)) {
+          return;
+        }
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(async () => {
+          console.log(`[ywkf] \u68C0\u6D4B\u5230\u9875\u9762\u53D8\u5316: ${filename}`);
+          if (this.generator) {
+            await this.generator.generate();
+          }
+        }, 500);
+      }
+    );
+    process.on("exit", () => {
+      watcher.close();
+    });
+  }
+};
+
+// src/rspack/base.ts
+var require2 = createRequire(import.meta.url);
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var coreNodeModules = join5(__dirname, "../../node_modules");
+function createBaseConfig(config, cwd) {
+  const { resolveApp } = createPathResolver(cwd);
+  const {
+    appName,
+    appCName,
+    output,
+    html,
+    alias: userAlias,
+    microFrontend,
+    router
+  } = config;
+  const ywkfOutputDir = resolveApp(".ywkf");
+  const defaultAlias = {
+    "@": resolveApp("src"),
+    "@config": resolveApp("config"),
+    "@store": resolveApp("store"),
+    "@locales": resolveApp("locales"),
+    "@public": resolveApp("public"),
+    // 约定式路由生成的文件
+    "@ywkf/routes": join5(ywkfOutputDir, "routes.tsx"),
+    // 请求层（由 reactQueryPlugin 生成）
+    "@ywkf/request": join5(ywkfOutputDir, "request.ts"),
+    // Store 工具（由 zustandPlugin 生成）
+    "@ywkf/store": join5(ywkfOutputDir, "store.ts")
+  };
+  const alias = { ...defaultAlias, ...userAlias };
+  return {
+    // 使用 .ywkf/index.tsx 作为入口（由框架生成）
+    entry: [join5(ywkfOutputDir, "index.tsx")],
+    resolve: {
+      extensions: [".ts", ".tsx", ".jsx", ".js", ".json", ".mjs"],
+      symlinks: false,
+      alias: {
+        ...alias,
+        "process/browser.js": require2.resolve("process/browser.js"),
+        "process/browser": require2.resolve("process/browser.js"),
+        // 确保 React 系列包从用户项目的 node_modules 解析
+        react: resolveApp("node_modules/react"),
+        "react-dom": resolveApp("node_modules/react-dom"),
+        "react-router": resolveApp("node_modules/react-router")
+      },
+      fallback: {
+        path: require2.resolve("path-browserify"),
+        process: require2.resolve("process/browser.js"),
+        buffer: require2.resolve("buffer/"),
+        util: require2.resolve("util/"),
+        stream: require2.resolve("stream-browserify"),
+        crypto: require2.resolve("crypto-browserify"),
+        zlib: require2.resolve("browserify-zlib"),
+        querystring: require2.resolve("querystring-es3"),
+        url: require2.resolve("url/"),
+        assert: require2.resolve("assert/"),
+        fs: false,
+        net: false,
+        tls: false,
+        os: false,
+        https: false,
+        http: false
+      }
+    },
+    resolveLoader: {
+      modules: [coreNodeModules, "node_modules"]
+    },
+    module: {
+      rules: [
+        {
+          test: /\.m?js$/,
+          resolve: {
+            fullySpecified: false
+          }
+        },
+        {
+          test: /\.[jt]sx?$/,
+          include: [
+            resolveApp("src"),
+            resolveApp("config"),
+            resolveApp("store"),
+            resolveApp("packages"),
+            ywkfOutputDir
+            // 约定式路由生成的文件
+          ],
+          exclude: [resolveApp("node_modules")],
+          use: [
+            {
+              loader: "builtin:swc-loader",
+              options: {
+                jsc: {
+                  parser: {
+                    syntax: "typescript",
+                    tsx: true,
+                    decorators: true
+                  },
+                  transform: {
+                    react: {
+                      runtime: "automatic"
+                    }
+                  },
+                  target: "es2015"
+                },
+                sourceMaps: true
+              }
+            }
+          ]
+        },
+        {
+          test: /\.(png|jpg|jpeg|gif|webp|m3u8|exr|hdr|json|woff2)$/,
+          include: [resolveApp("public")],
+          exclude: [resolveApp("src"), resolveApp("store")],
+          type: "asset",
+          parser: {
+            dataUrlCondition: {
+              maxSize: 10 * 1024
+            }
+          }
+        },
+        {
+          test: /\.(md)$/,
+          include: [resolveApp("src")],
+          type: "asset/source"
+        },
+        {
+          test: /\.svg$/,
+          use: ["@svgr/webpack"]
+        }
+      ]
+    },
+    plugins: [
+      new rspack.ProvidePlugin({
+        process: "process/browser.js",
+        Buffer: ["buffer", "Buffer"]
+      }),
+      new rspack.DefinePlugin({
+        "process.env": JSON.stringify(process.env)
+      }),
+      new rspack.HtmlRspackPlugin({
+        template: resolveApp(html.template ?? "public/index.html"),
+        filename: "index.html",
+        inject: "body",
+        hash: true,
+        minify: process.env.NODE_ENV === "production",
+        favicon: resolveApp(html.favicon ?? "public/favicon.ico"),
+        templateParameters: {
+          title: html.title ?? appCName,
+          mountRoot: html.mountRoot ?? appName
+        }
+      }),
+      new rspack.CopyRspackPlugin({
+        patterns: [
+          {
+            from: resolveApp("public/images"),
+            to: "public/images",
+            noErrorOnMissing: true
+          }
+        ]
+      }),
+      // .ywkf 目录生成插件（传递用户配置的插件列表）
+      new YwkfGeneratorPlugin({
+        cwd,
+        config,
+        outputDir: ywkfOutputDir,
+        isDev: process.env.NODE_ENV !== "production",
+        pluginConfigs: config.plugins
+      })
+    ].filter(Boolean),
+    output: {
+      assetModuleFilename: "images/[hash][ext]",
+      library: microFrontend.enabled ? `${appCName}-[name]` : void 0,
+      chunkFilename: "[name].[contenthash].js",
+      libraryTarget: microFrontend.enabled ? "umd" : void 0,
+      globalObject: microFrontend.enabled ? "window" : void 0,
+      chunkLoadingGlobal: microFrontend.enabled ? `chunk_global_${appName}` : void 0,
+      publicPath: output.publicPath ?? "/",
+      path: resolveApp(output.path ?? "dist")
+    },
+    ignoreWarnings: [
+      {
+        module: /@testing-library\/react/,
+        message: /export 'act'/
+      }
+    ],
+    devtool: "source-map"
+  };
+}
+
+// src/rspack/dev.ts
+var require3 = createRequire2(import.meta.url);
+function convertProxyToArray(proxy) {
+  if (!proxy || Object.keys(proxy).length === 0) {
+    return void 0;
+  }
+  return Object.entries(proxy).map(([context, target]) => {
+    if (typeof target === "string") {
+      return {
+        context: [context],
+        target,
+        changeOrigin: true,
+        secure: false
+      };
+    }
+    return {
+      context: [context],
+      changeOrigin: true,
+      secure: false,
+      ...target
+    };
+  });
+}
+function createDevConfig(config, cwd) {
+  const baseConfig = createBaseConfig(config, cwd);
+  const { resolveApp } = createPathResolver(cwd);
+  const { dev: dev2, style } = config;
+  const styleRules = {
+    rules: [
+      // Less - antd
+      {
+        test: /\.less$/,
+        include: [
+          /[\\/]node_modules[\\/].*antd/,
+          /[\\/]node_modules[\\/]@4399ywkf[\\/]design/
+        ],
+        use: [
+          { loader: "style-loader" },
+          {
+            loader: "css-loader",
+            options: { sourceMap: true }
+          },
+          {
+            loader: "less-loader",
+            options: {
+              sourceMap: true,
+              lessOptions: {
+                strictMath: false,
+                math: "always",
+                javascriptEnabled: true
+              }
+            }
+          }
+        ]
+      },
+      // Less - 项目文件
+      ...style.less?.enabled !== false ? [
+        {
+          test: /\.less$/,
+          include: [resolveApp("src")],
+          exclude: [resolveApp("node_modules")],
+          oneOf: [
+            {
+              test: /\.module\.less$/,
+              use: [
+                { loader: "style-loader" },
+                {
+                  loader: "css-loader",
+                  options: {
+                    sourceMap: true,
+                    modules: {
+                      localIdentName: "[path][name]__[local]--[hash:base64:5]"
+                    },
+                    importLoaders: 2
+                  }
+                },
+                {
+                  loader: "less-loader",
+                  options: {
+                    sourceMap: true,
+                    lessOptions: {
+                      javascriptEnabled: true,
+                      math: "always",
+                      ...style.less?.lessOptions
+                    }
+                  }
+                }
+              ]
+            },
+            {
+              use: [
+                { loader: "style-loader" },
+                {
+                  loader: "css-loader",
+                  options: { sourceMap: true }
+                },
+                {
+                  loader: "less-loader",
+                  options: {
+                    sourceMap: true,
+                    lessOptions: {
+                      javascriptEnabled: true,
+                      ...style.less?.lessOptions
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      ] : [],
+      // Sass
+      ...style.sass?.enabled !== false ? [
+        {
+          test: /\.s[ac]ss$/i,
+          include: [resolveApp("src")],
+          exclude: [resolveApp("node_modules")],
+          oneOf: [
+            {
+              test: /\.module\.s[ac]ss$/,
+              use: [
+                { loader: "style-loader" },
+                {
+                  loader: "css-loader",
+                  options: {
+                    sourceMap: true,
+                    modules: {
+                      localIdentName: "[path][name]__[local]--[hash:base64:5]"
+                    },
+                    importLoaders: 2
+                  }
+                },
+                {
+                  loader: "sass-loader",
+                  options: {
+                    sourceMap: true,
+                    sassOptions: {
+                      outputStyle: "compressed",
+                      ...style.sass?.sassOptions
+                    }
+                  }
+                }
+              ]
+            },
+            {
+              use: [
+                { loader: "style-loader" },
+                {
+                  loader: "css-loader",
+                  options: { sourceMap: true }
+                },
+                {
+                  loader: "sass-loader",
+                  options: {
+                    sourceMap: true,
+                    sassOptions: {
+                      outputStyle: "compressed",
+                      ...style.sass?.sassOptions
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      ] : [],
+      // TailwindCSS
+      ...style.tailwindcss ? [
+        {
+          test: /\.css$/,
+          include: [resolveApp("src/index.css")],
+          use: [
+            "style-loader",
+            "css-loader",
+            {
+              loader: "postcss-loader",
+              options: {
+                postcssOptions: {
+                  config: resolveApp("postcss.config.js")
+                }
+              }
+            }
+          ]
+        }
+      ] : [],
+      // 其他 CSS
+      {
+        test: /\.css$/,
+        include: [resolveApp("src"), resolveApp("node_modules")],
+        exclude: style.tailwindcss ? [resolveApp("src/index.css")] : [],
+        use: [
+          { loader: "style-loader" },
+          {
+            loader: "css-loader",
+            options: { sourceMap: true }
+          }
+        ]
+      }
+    ]
+  };
+  const devConfig = {
+    mode: "development",
+    devtool: "inline-source-map",
+    output: {
+      filename: "[name].bundle.js",
+      clean: false
+    },
+    stats: "errors-only",
+    devServer: {
+      host: dev2.host,
+      port: dev2.port,
+      compress: true,
+      historyApiFallback: true,
+      hot: true,
+      allowedHosts: "all",
+      client: {
+        overlay: false,
+        progress: true
+      },
+      proxy: convertProxyToArray(dev2.proxy)
+    },
+    module: styleRules
+  };
+  return merge(baseConfig, devConfig);
+}
+
+// src/rspack/prod.ts
+import { rspack as rspack2 } from "@rspack/core";
+import { merge as merge2 } from "webpack-merge";
+function createProdConfig(config, cwd) {
+  const baseConfig = createBaseConfig(config, cwd);
+  const { resolveApp } = createPathResolver(cwd);
+  const { style, performance, output } = config;
+  const styleRules = {
+    rules: [
+      // Less - antd
+      {
+        test: /\.less$/,
+        include: [
+          /[\\/]node_modules[\\/].*antd/,
+          /[\\/]node_modules[\\/]@4399ywkf[\\/]design/
+        ],
+        use: [
+          { loader: rspack2.CssExtractRspackPlugin.loader },
+          {
+            loader: "css-loader",
+            options: { sourceMap: true }
+          },
+          {
+            loader: "less-loader",
+            options: {
+              sourceMap: true,
+              lessOptions: {
+                strictMath: false,
+                math: "always",
+                javascriptEnabled: true
+              }
+            }
+          }
+        ]
+      },
+      // Less - 项目文件
+      ...style.less?.enabled !== false ? [
+        {
+          test: /\.less$/,
+          include: [resolveApp("src")],
+          exclude: [resolveApp("node_modules")],
+          oneOf: [
+            {
+              test: /\.module\.less$/,
+              use: [
+                { loader: rspack2.CssExtractRspackPlugin.loader },
+                {
+                  loader: "css-loader",
+                  options: {
+                    sourceMap: true,
+                    modules: {
+                      localIdentName: "[path][name]__[local]--[hash:base64:5]"
+                    },
+                    importLoaders: 2
+                  }
+                },
+                {
+                  loader: "less-loader",
+                  options: {
+                    sourceMap: true,
+                    lessOptions: {
+                      javascriptEnabled: true,
+                      ...style.less?.lessOptions
+                    }
+                  }
+                }
+              ]
+            },
+            {
+              use: [
+                { loader: rspack2.CssExtractRspackPlugin.loader },
+                {
+                  loader: "css-loader",
+                  options: { sourceMap: true }
+                },
+                {
+                  loader: "less-loader",
+                  options: {
+                    sourceMap: true,
+                    lessOptions: {
+                      javascriptEnabled: true,
+                      ...style.less?.lessOptions
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      ] : [],
+      // Sass
+      ...style.sass?.enabled !== false ? [
+        {
+          test: /\.s[ac]ss$/i,
+          include: [resolveApp("src")],
+          exclude: [resolveApp("node_modules")],
+          oneOf: [
+            {
+              test: /\.module\.s[ac]ss$/,
+              use: [
+                { loader: rspack2.CssExtractRspackPlugin.loader },
+                {
+                  loader: "css-loader",
+                  options: {
+                    sourceMap: true,
+                    modules: {
+                      localIdentName: "[path][name]__[local]--[hash:base64:5]"
+                    },
+                    importLoaders: 2
+                  }
+                },
+                {
+                  loader: "sass-loader",
+                  options: {
+                    sourceMap: true,
+                    sassOptions: {
+                      outputStyle: "compressed",
+                      ...style.sass?.sassOptions
+                    }
+                  }
+                }
+              ]
+            },
+            {
+              use: [
+                { loader: rspack2.CssExtractRspackPlugin.loader },
+                {
+                  loader: "css-loader",
+                  options: { sourceMap: true }
+                },
+                {
+                  loader: "sass-loader",
+                  options: {
+                    sourceMap: true,
+                    sassOptions: {
+                      outputStyle: "compressed",
+                      ...style.sass?.sassOptions
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        }
+      ] : [],
+      // TailwindCSS
+      ...style.tailwindcss ? [
+        {
+          test: /\.css$/,
+          include: [resolveApp("src/index.css")],
+          use: [
+            { loader: rspack2.CssExtractRspackPlugin.loader },
+            "css-loader",
+            {
+              loader: "postcss-loader",
+              options: {
+                postcssOptions: {
+                  config: resolveApp("postcss.config.js")
+                }
+              }
+            }
+          ]
+        }
+      ] : [],
+      // src 目录中的其他 CSS
+      {
+        test: /\.css$/,
+        include: [resolveApp("src")],
+        exclude: style.tailwindcss ? [resolveApp("src/index.css")] : [],
+        use: [
+          { loader: rspack2.CssExtractRspackPlugin.loader },
+          {
+            loader: "css-loader",
+            options: { sourceMap: true }
+          }
+        ]
+      },
+      // node_modules CSS
+      {
+        test: /\.css$/,
+        include: [resolveApp("node_modules")],
+        use: [
+          { loader: "style-loader" },
+          {
+            loader: "css-loader",
+            options: { sourceMap: true }
+          }
+        ]
+      }
+    ]
+  };
+  const prodConfig = {
+    mode: "production",
+    devtool: "hidden-source-map",
+    output: {
+      filename: "[name].[contenthash].bundle.js",
+      chunkFilename: "[name].[contenthash].chunk.js",
+      clean: output.clean
+    },
+    module: styleRules,
+    plugins: [
+      new rspack2.CssExtractRspackPlugin({
+        filename: "[name].[contenthash:8].css",
+        chunkFilename: "[name].[contenthash:8].chunk.css"
+      })
+    ],
+    optimization: {
+      minimize: true,
+      minimizer: [
+        new rspack2.SwcJsMinimizerRspackPlugin({
+          exclude: [resolveApp("node_modules")],
+          minimizerOptions: {
+            compress: {
+              pure_funcs: performance.dropConsole ? ["console.log", "console.info", "console.debug", "console.warn"] : ["console.info", "console.debug"],
+              drop_console: false,
+              drop_debugger: true
+            }
+          }
+        }),
+        new rspack2.LightningCssMinimizerRspackPlugin()
+      ]
+    }
+  };
+  return merge2(baseConfig, prodConfig);
+}
+
+// src/rspack/index.ts
+function createRspackConfig(config, cwd, options = {}) {
+  const isDev = options.isDev ?? process.env.NODE_ENV !== "production";
+  let rspackConfig = isDev ? createDevConfig(config, cwd) : createProdConfig(config, cwd);
+  if (config.performance.rsdoctor) {
+    rspackConfig.plugins = [
+      ...rspackConfig.plugins || [],
+      new RsdoctorRspackPlugin({})
+    ];
+  }
+  if (config.tools.rspack) {
+    const userConfig = config.tools.rspack(rspackConfig, {
+      isDev,
+      isProd: !isDev
+    });
+    if (userConfig) {
+      rspackConfig = userConfig;
+    }
+  }
+  return rspackConfig;
+}
+
+// src/cli/env.ts
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve2 } from "path";
+import dotenv from "dotenv";
+function preloadEnv(cwd, mode) {
+  process.env.NODE_ENV = mode;
+  const defaultPaths = [
+    resolve2(cwd, "config/env/.env.public"),
+    resolve2(cwd, ".env.public"),
+    resolve2(cwd, ".env")
+  ];
+  for (const envPath of defaultPaths) {
+    if (existsSync6(envPath)) {
+      dotenv.config({ path: envPath });
+      break;
+    }
+  }
+  const modeEnvPaths = [
+    resolve2(cwd, `config/env/.env.${mode}`),
+    resolve2(cwd, `.env.${mode}`)
+  ];
+  for (const envPath of modeEnvPaths) {
+    if (existsSync6(envPath)) {
+      const envContent = readFileSync3(envPath, "utf-8");
+      const parsed = dotenv.parse(envContent);
+      for (const key in parsed) {
+        process.env[key] = parsed[key];
+      }
+      break;
+    }
+  }
+}
+function loadEnv(config, cwd, mode) {
+  const { env } = config;
+  const publicEnvPath = resolve2(cwd, env.publicEnvFile ?? "config/env/.env.public");
+  if (existsSync6(publicEnvPath)) {
+    dotenv.config({ path: publicEnvPath });
+  }
+  const modeEnvPath = resolve2(cwd, env.envDir ?? "config/env", `.env.${mode}`);
+  if (existsSync6(modeEnvPath)) {
+    const envContent = readFileSync3(modeEnvPath, "utf-8");
+    const parsed = dotenv.parse(envContent);
+    for (const key in parsed) {
+      process.env[key] = parsed[key];
+    }
+  }
+  process.env.NODE_ENV = mode;
+  process.env.APP_NAME = process.env.APP_NAME || config.appName;
+  process.env.APP_CNAME = process.env.APP_CNAME || config.appCName;
+  process.env.OUTPUT_PATH = process.env.OUTPUT_PATH || config.output.path;
+  process.env.PUBLIC_PATH = process.env.PUBLIC_PATH || config.output.publicPath;
+  process.env.APP_HOST = process.env.APP_HOST || config.dev.host;
+  process.env.APP_PORT = process.env.APP_PORT || String(config.dev.port);
+}
+
+// src/plugin/manager.ts
+function createLogger(pluginName) {
+  const prefix = `[${pluginName}]`;
+  return {
+    info: (msg) => console.log(`${prefix} ${msg}`),
+    warn: (msg) => console.warn(`${prefix} ${msg}`),
+    error: (msg) => console.error(`${prefix} ${msg}`),
+    debug: (msg) => {
+      if (process.env.DEBUG) {
+        console.debug(`${prefix} ${msg}`);
+      }
+    }
+  };
+}
+async function resolvePlugin(pluginConfig, cwd) {
+  let plugin;
+  let options = {};
+  if (typeof pluginConfig === "string") {
+    const module = await import(pluginConfig);
+    plugin = module.default || module;
+  } else if (Array.isArray(pluginConfig)) {
+    const [pluginOrName, pluginOptions] = pluginConfig;
+    options = pluginOptions;
+    if (typeof pluginOrName === "string") {
+      const module = await import(pluginOrName);
+      plugin = module.default || module;
+    } else {
+      plugin = pluginOrName;
+    }
+  } else {
+    plugin = pluginConfig;
+  }
+  if (typeof plugin === "function") {
+    plugin = plugin(options);
+  }
+  return { plugin, options };
+}
+var PluginManager = class {
+  plugins = /* @__PURE__ */ new Map();
+  context;
+  constructor(config, cwd, isDev) {
+    this.context = {
+      cwd,
+      isDev,
+      isProd: !isDev,
+      config,
+      logger: createLogger("PluginManager")
+    };
+  }
+  /**
+   * 加载并初始化所有插件
+   */
+  async loadPlugins(pluginConfigs) {
+    for (const pluginConfig of pluginConfigs) {
+      try {
+        const { plugin } = await resolvePlugin(pluginConfig, this.context.cwd);
+        if (this.plugins.has(plugin.name)) {
+          this.context.logger.warn(`\u63D2\u4EF6 ${plugin.name} \u5DF2\u52A0\u8F7D\uFF0C\u8DF3\u8FC7\u91CD\u590D\u52A0\u8F7D`);
+          continue;
+        }
+        const pluginContext = {
+          ...this.context,
+          logger: createLogger(plugin.name)
+        };
+        const hooks = await plugin.setup(pluginContext);
+        this.plugins.set(plugin.name, { plugin, hooks });
+        this.context.logger.info(`\u5DF2\u52A0\u8F7D\u63D2\u4EF6: ${plugin.name}`);
+      } catch (error) {
+        this.context.logger.error(
+          `\u52A0\u8F7D\u63D2\u4EF6\u5931\u8D25: ${String(pluginConfig)} - ${error}`
+        );
+      }
+    }
+  }
+  /**
+   * 执行 modifyRspackConfig 钩子
+   */
+  async applyRspackConfigHooks(config) {
+    let result = config;
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.modifyRspackConfig) {
+        try {
+          const modified = await hooks.modifyRspackConfig(result, this.context);
+          if (modified) {
+            result = modified;
+          }
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} modifyRspackConfig \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 执行 modifyRoutes 钩子
+   */
+  async applyRoutesHooks(routes) {
+    let result = routes;
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.modifyRoutes) {
+        try {
+          const modified = await hooks.modifyRoutes(result, this.context);
+          if (modified) {
+            result = modified;
+          }
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} modifyRoutes \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 执行 modifyAppConfig 钩子
+   */
+  applyAppConfigHooks(appConfig) {
+    let result = appConfig;
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.modifyAppConfig) {
+        try {
+          const modified = hooks.modifyAppConfig(result, this.context);
+          if (modified) {
+            result = modified;
+          }
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} modifyAppConfig \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * 收集所有插件的 Provider
+   */
+  collectProviders() {
+    const providers = [];
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.addProvider) {
+        try {
+          const result = hooks.addProvider(this.context);
+          if (Array.isArray(result)) {
+            providers.push(...result);
+          } else if (result) {
+            providers.push(result);
+          }
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} addProvider \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+    return providers;
+  }
+  /**
+   * 执行 beforeBuild 钩子
+   */
+  async runBeforeBuild() {
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.beforeBuild) {
+        try {
+          await hooks.beforeBuild(this.context);
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} beforeBuild \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * 执行 afterBuild 钩子
+   */
+  async runAfterBuild(stats) {
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.afterBuild) {
+        try {
+          await hooks.afterBuild(this.context, stats);
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} afterBuild \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * 执行 beforeDevServer 钩子
+   */
+  async runBeforeDevServer() {
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.beforeDevServer) {
+        try {
+          await hooks.beforeDevServer(this.context);
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} beforeDevServer \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * 执行 afterDevServer 钩子
+   */
+  async runAfterDevServer(server) {
+    for (const [name, { hooks }] of this.plugins) {
+      if (hooks.afterDevServer) {
+        try {
+          await hooks.afterDevServer(this.context, server);
+        } catch (error) {
+          this.context.logger.error(
+            `\u63D2\u4EF6 ${name} afterDevServer \u6267\u884C\u5931\u8D25: ${error}`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * 获取所有已加载的插件名称
+   */
+  getPluginNames() {
+    return Array.from(this.plugins.keys());
+  }
+  /**
+   * 获取所有已加载的插件
+   */
+  getPlugins() {
+    return Array.from(this.plugins.values()).map((p) => p.plugin);
+  }
+  /**
+   * 获取所有已加载的插件钩子
+   */
+  getPluginHooks() {
+    return Array.from(this.plugins.values()).map((p) => p.hooks);
+  }
+};
+
+// src/cli/dev.ts
+async function dev(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const spinner = ora("\u6B63\u5728\u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668...").start();
+  try {
+    preloadEnv(cwd, "development");
+    const { config, configPath } = await resolveConfig(cwd);
+    if (configPath) {
+      spinner.text = `\u5DF2\u52A0\u8F7D\u914D\u7F6E: ${configPath}`;
+    }
+    loadEnv(config, cwd, "development");
+    const pluginManager = new PluginManager(config, cwd, true);
+    if (config.plugins && config.plugins.length > 0) {
+      spinner.text = "\u52A0\u8F7D\u63D2\u4EF6...";
+      await pluginManager.loadPlugins(config.plugins);
+    }
+    await pluginManager.runBeforeDevServer();
+    let rspackConfig = createRspackConfig(config, cwd, { isDev: true });
+    rspackConfig = await pluginManager.applyRspackConfigHooks(rspackConfig);
+    const compiler = rspack3(rspackConfig);
+    const devServerOptions = rspackConfig.devServer || {};
+    const server = new RspackDevServer(devServerOptions, compiler);
+    const host = config.dev.host || "localhost";
+    const port = config.dev.port || 3e3;
+    await server.start();
+    await pluginManager.runAfterDevServer({ host, port });
+    spinner.succeed(chalk.green("\u5F00\u53D1\u670D\u52A1\u5668\u542F\u52A8\u6210\u529F!"));
+    console.log();
+    console.log(
+      `  ${chalk.bold("Local:")}   ${chalk.cyan(`http://${host}:${port}`)}`
+    );
+    const pluginNames = pluginManager.getPluginNames();
+    if (pluginNames.length > 0) {
+      console.log(`  ${chalk.bold("\u63D2\u4EF6:")}    ${chalk.dim(pluginNames.join(", "))}`);
+    }
+    console.log();
+    const signals = ["SIGINT", "SIGTERM"];
+    for (const signal of signals) {
+      process.on(signal, async () => {
+        await server.stop();
+        process.exit(0);
+      });
+    }
+  } catch (error) {
+    spinner.fail(chalk.red("\u5F00\u53D1\u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/cli/build.ts
+import { rspack as rspack4 } from "@rspack/core";
+import chalk2 from "chalk";
+import ora2 from "ora";
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+function printBuildResult(stats) {
+  const info = stats.toJson({
+    assets: true,
+    errors: true,
+    warnings: true
+  });
+  if (info.errors && info.errors.length > 0) {
+    console.log(chalk2.red("\n\u6784\u5EFA\u9519\u8BEF:"));
+    for (const error of info.errors) {
+      console.log(chalk2.red(`  ${error.message}`));
+    }
+    return;
+  }
+  if (info.warnings && info.warnings.length > 0) {
+    console.log(chalk2.yellow("\n\u6784\u5EFA\u8B66\u544A:"));
+    for (const warning of info.warnings) {
+      console.log(chalk2.yellow(`  ${warning.message}`));
+    }
+  }
+  console.log(chalk2.bold("\n\u6784\u5EFA\u4EA7\u7269:"));
+  console.log();
+  const assets = info.assets || [];
+  const sortedAssets = assets.filter((asset) => !asset.name.endsWith(".map")).sort((a, b) => b.size - a.size);
+  for (const asset of sortedAssets.slice(0, 15)) {
+    const sizeColor = asset.size > 500 * 1024 ? chalk2.yellow : chalk2.green;
+    console.log(
+      `  ${chalk2.dim(asset.name.padEnd(50))} ${sizeColor(formatSize(asset.size))}`
+    );
+  }
+  if (sortedAssets.length > 15) {
+    console.log(chalk2.dim(`  ... \u8FD8\u6709 ${sortedAssets.length - 15} \u4E2A\u6587\u4EF6`));
+  }
+  console.log();
+  console.log(
+    chalk2.green(
+      `\u2713 \u6784\u5EFA\u5B8C\u6210\uFF0C\u8017\u65F6 ${((info.time || 0) / 1e3).toFixed(2)}s`
+    )
+  );
+}
+async function build(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const spinner = ora2("\u6B63\u5728\u6784\u5EFA\u751F\u4EA7\u73AF\u5883...").start();
+  try {
+    preloadEnv(cwd, "production");
+    const { config, configPath } = await resolveConfig(cwd);
+    if (configPath) {
+      spinner.text = `\u5DF2\u52A0\u8F7D\u914D\u7F6E: ${configPath}`;
+    }
+    loadEnv(config, cwd, "production");
+    const pluginManager = new PluginManager(config, cwd, false);
+    if (config.plugins && config.plugins.length > 0) {
+      spinner.text = "\u52A0\u8F7D\u63D2\u4EF6...";
+      await pluginManager.loadPlugins(config.plugins);
+    }
+    await pluginManager.runBeforeBuild();
+    let rspackConfig = createRspackConfig(config, cwd, { isDev: false });
+    rspackConfig = await pluginManager.applyRspackConfigHooks(rspackConfig);
+    spinner.text = "\u6B63\u5728\u7F16\u8BD1...";
+    const compiler = rspack4(rspackConfig);
+    const stats = await new Promise((resolve3, reject) => {
+      compiler.run((err, stats2) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        if (!stats2) {
+          reject(new Error("\u6784\u5EFA\u5931\u8D25: \u65E0\u6CD5\u83B7\u53D6\u7EDF\u8BA1\u4FE1\u606F"));
+          return;
+        }
+        resolve3(stats2);
+      });
+    });
+    await new Promise((resolve3, reject) => {
+      compiler.close((err) => {
+        if (err) reject(err);
+        else resolve3();
+      });
+    });
+    const hasErrors = stats.hasErrors();
+    const statsInfo = stats.toJson({ errors: true });
+    await pluginManager.runAfterBuild({
+      success: !hasErrors,
+      errors: statsInfo.errors?.map((e) => e.message)
+    });
+    if (hasErrors) {
+      spinner.fail(chalk2.red("\u6784\u5EFA\u5931\u8D25"));
+      printBuildResult(stats);
+      process.exit(1);
+    }
+    spinner.succeed(chalk2.green("\u6784\u5EFA\u5B8C\u6210!"));
+    printBuildResult(stats);
+  } catch (error) {
+    spinner.fail(chalk2.red("\u6784\u5EFA\u5931\u8D25"));
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("ywkf").description("4399\u8FD0\u7EF4\u5F00\u53D1\u524D\u7AEF\u6846\u67B6 CLI").version("1.0.0");
+program.command("dev").description("\u542F\u52A8\u5F00\u53D1\u670D\u52A1\u5668").option("-p, --port <port>", "\u6307\u5B9A\u7AEF\u53E3\u53F7").option("-h, --host <host>", "\u6307\u5B9A\u4E3B\u673A").action(async (options) => {
+  if (options.port) {
+    process.env.APP_PORT = options.port;
+  }
+  if (options.host) {
+    process.env.APP_HOST = options.host;
+  }
+  await dev({ cwd: process.cwd() });
+});
+program.command("build").description("\u6784\u5EFA\u751F\u4EA7\u73AF\u5883").option("--analyze", "\u542F\u7528\u6784\u5EFA\u5206\u6790").action(async (options) => {
+  if (options.analyze) {
+    process.env.RSDOCTOR = "true";
+  }
+  await build({ cwd: process.cwd() });
+});
+program.command("start").description("\u542F\u52A8\u751F\u4EA7\u670D\u52A1\u5668\uFF08\u9700\u8981\u5148\u6267\u884C build\uFF09").action(() => {
+  console.log(chalk3.yellow("\u26A0\uFE0F  start \u547D\u4EE4\u6682\u672A\u5B9E\u73B0\uFF0C\u8BF7\u4F7F\u7528 nginx \u6216\u5176\u4ED6\u9759\u6001\u670D\u52A1\u5668"));
+});
+program.parse();
+//# sourceMappingURL=index.js.map