fe-stack 0.0.15 → 0.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fe-stack",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "description": "共享的配置文件集合，用于 Vite、Tailwind、Biome、Prettier 和 TypeScript",
   "type": "module",
   "exports": {

package/vite-plugin-rollup-dts.d.ts

@@ -20,6 +20,18 @@ export interface RollupDtsPluginOptions {
   entries?: Entry[];
   /** tsconfig.json 文件路径，默认为 './tsconfig.json' */
   tsconfigPath?: string;
+  /**
+   * 共享类型入口配置（多入口时使用）
+   * 指定一个共享类型的入口，会被 API Extractor 单独处理
+   * 其他入口会自动 import 这个共享类型文件
+   * @example { input: './dist/types.d.ts', output: './dist/shared.d.ts' }
+   */
+  sharedTypes?: {
+    /** 共享类型的 .d.ts 入口文件路径 */
+    input: string;
+    /** 合并后的输出路径 */
+    output: string;
+  } | null;
 }
 
 /**

package/vite-plugin-rollup-dts.js

@@ -94,8 +94,195 @@ function getEntriesFromConfig(config) {
   }));
 }
 
+/**
+ * 使用 API Extractor 处理单个入口
+ */
+function rollupEntry(entry, projectFolder, tsconfigPath) {
+  const mainEntryPointFilePath = path.resolve(
+    projectFolder,
+    entry.mainEntryPoint,
+  );
+
+  if (!fs.existsSync(mainEntryPointFilePath)) {
+    console.warn(
+      `[rollup-dts] ⚠️  Skipping ${entry.name}: ${entry.mainEntryPoint} not found`,
+    );
+    return { success: false, skipped: true };
+  }
+
+  console.log(`[rollup-dts] 📦 Rolling up types for: ${entry.name}`);
+
+  const config = {
+    ...baseConfig,
+    compiler: {
+      tsconfigFilePath: `<projectFolder>/${tsconfigPath}`,
+    },
+    mainEntryPointFilePath: `<projectFolder>/${entry.mainEntryPoint}`,
+    dtsRollup: {
+      enabled: true,
+      untrimmedFilePath: `<projectFolder>/${entry.output}`,
+    },
+  };
+
+  const safeName = entry.name.replace(/\//g, '-');
+  const tempConfigPath = path.resolve(
+    projectFolder,
+    `api-extractor.${safeName}.tmp.json`,
+  );
+  fs.writeFileSync(tempConfigPath, JSON.stringify(config, null, 2));
+
+  let success = false;
+  try {
+    const extractorConfig = ExtractorConfig.loadFileAndPrepare(tempConfigPath);
+    const extractorResult = Extractor.invoke(extractorConfig, {
+      localBuild: true,
+      showVerboseMessages: false,
+    });
+
+    if (extractorResult.succeeded) {
+      console.log(
+        `[rollup-dts] ✅ ${entry.name}: types rolled up successfully`,
+      );
+      success = true;
+    } else {
+      console.warn(
+        `[rollup-dts] ⚠️  ${entry.name}: API Extractor completed with warnings/errors`,
+      );
+      if (fs.existsSync(path.resolve(projectFolder, entry.output))) {
+        success = true;
+      }
+    }
+  } catch (error) {
+    console.warn(
+      `[rollup-dts] ⚠️  ${entry.name}: Error during rollup, keeping original .d.ts files`,
+    );
+    console.warn(`   ${error instanceof Error ? error.message : error}`);
+  } finally {
+    if (fs.existsSync(tempConfigPath)) {
+      fs.unlinkSync(tempConfigPath);
+    }
+  }
+
+  return { success, skipped: false };
+}
+
+/**
+ * 从 .d.ts 文件中提取导出的类型名称
+ */
+function extractExportedTypeNames(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const names = [];
+
+  // 匹配 export declare interface/type/enum/class/namespace Name
+  const regex =
+    /export\s+(?:declare\s+)?(?:interface|type|enum|class|namespace)\s+(\w+)/g;
+  let match;
+  // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
+  while ((match = regex.exec(content)) !== null) {
+    names.push(match[1]);
+  }
+
+  return names;
+}
+
+/**
+ * 在入口文件中添加对共享类型的 import，并移除重复的类型定义
+ */
+function addSharedTypeImports(entryOutputPath, sharedTypesOutput, typeNames) {
+  if (!fs.existsSync(entryOutputPath) || typeNames.length === 0) return;
+
+  let content = fs.readFileSync(entryOutputPath, 'utf-8');
+
+  // 检查文件中使用了哪些共享类型
+  const usedTypes = typeNames.filter((name) => {
+    // 检查是否在文件中使用了这个类型
+    const useRegex = new RegExp(`\\b${name}\\b`);
+    return useRegex.test(content);
+  });
+
+  if (usedTypes.length === 0) return;
+
+  // 移除文件中重复的类型定义（这些类型已经在 shared.d.ts 中定义了）
+  for (const typeName of usedTypes) {
+    // 使用更可靠的方式：按行处理，找到类型定义的开始和结束
+    const lines = content.split('\n');
+    const newLines = [];
+    let skipUntilClosingBrace = false;
+    let braceCount = 0;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // 检查是否是要移除的类型定义的开始
+      const typeDefStart = new RegExp(
+        `^export\\s+declare\\s+(?:interface|type|enum|class|namespace)\\s+${typeName}\\b`,
+      );
+
+      if (typeDefStart.test(line) && !skipUntilClosingBrace) {
+        // 检查是否是单行定义（type alias）
+        if (line.includes('=') && line.includes(';')) {
+          // 单行 type alias，直接跳过
+          continue;
+        }
+
+        // 多行定义，开始跳过
+        skipUntilClosingBrace = true;
+        braceCount =
+          (line.match(/{/g) || []).length - (line.match(/}/g) || []).length;
+
+        // 如果这一行就闭合了
+        if (braceCount <= 0 && line.includes('}')) {
+          skipUntilClosingBrace = false;
+        }
+        continue;
+      }
+
+      if (skipUntilClosingBrace) {
+        braceCount +=
+          (line.match(/{/g) || []).length - (line.match(/}/g) || []).length;
+        if (braceCount <= 0) {
+          skipUntilClosingBrace = false;
+        }
+        continue;
+      }
+
+      newLines.push(line);
+    }
+
+    content = newLines.join('\n');
+  }
+
+  // 清理多余的空行
+  content = content.replace(/\n{3,}/g, '\n\n').trim();
+
+  // 计算相对路径
+  const outputDir = path.dirname(entryOutputPath);
+  const sharedFilePath = path.resolve(process.cwd(), sharedTypesOutput);
+  let relativePath = path
+    .relative(outputDir, sharedFilePath)
+    .replace(/\\/g, '/');
+
+  if (!relativePath.startsWith('.')) {
+    relativePath = './' + relativePath;
+  }
+
+  // 添加 import 和 re-export 语句
+  const importStatement = `import type { ${usedTypes.join(', ')} } from '${relativePath}';\nexport type { ${usedTypes.join(', ')} } from '${relativePath}';\n\n`;
+  content = importStatement + content;
+
+  fs.writeFileSync(entryOutputPath, content, 'utf-8');
+  console.log(
+    `[rollup-dts] 🔗 Added shared type imports to ${path.basename(entryOutputPath)}: ${usedTypes.join(', ')}`,
+  );
+}
+
 export function rollupDtsPlugin(options = {}) {
-  const { tsconfigPath = './tsconfig.json' } = options;
+  const {
+    tsconfigPath = './tsconfig.json',
+    sharedTypes = null, // { input: './dist/types.d.ts', output: './dist/shared.d.ts' }
+  } = options;
   let resolvedConfig;
   let entries = [];
 
@@ -118,83 +305,63 @@ export function rollupDtsPlugin(options = {}) {
 
       const projectFolder = process.cwd();
       const results = [];
+      const keepFiles = [];
 
       console.log('\n[rollup-dts] Starting to bundle declaration files...');
 
-      for (const entry of entries) {
-        const mainEntryPointFilePath = path.resolve(
-          projectFolder,
-          entry.mainEntryPoint,
-        );
-
-        if (!fs.existsSync(mainEntryPointFilePath)) {
-          console.warn(
-            `[rollup-dts] ⚠️  Skipping ${entry.name}: ${entry.mainEntryPoint} not found`,
+      // 第一步：如果有共享类型配置，先处理共享类型
+      let sharedTypeNames = [];
+      if (sharedTypes) {
+        console.log('[rollup-dts] 📦 Processing shared types first...');
+        const sharedEntry = {
+          name: 'shared',
+          mainEntryPoint: sharedTypes.input,
+          output: sharedTypes.output,
+        };
+        const result = rollupEntry(sharedEntry, projectFolder, tsconfigPath);
+        if (result.success) {
+          keepFiles.push(path.resolve(projectFolder, sharedTypes.output));
+          // 提取共享类型文件中导出的类型名称
+          sharedTypeNames = extractExportedTypeNames(
+            path.resolve(projectFolder, sharedTypes.output),
+          );
+          console.log(
+            `[rollup-dts] 📝 Shared types exported: ${sharedTypeNames.join(', ') || 'none'}`,
           );
+        }
+      }
+
+      // 第二步：处理所有入口
+      for (const entry of entries) {
+        // 跳过共享类型入口（如果它也在 entries 中）
+        if (sharedTypes && entry.mainEntryPoint === sharedTypes.input) {
           continue;
         }
 
-        console.log(`[rollup-dts] 📦 Rolling up types for: ${entry.name}`);
-
-        const config = {
-          ...baseConfig,
-          compiler: {
-            tsconfigFilePath: `<projectFolder>/${tsconfigPath}`,
-          },
-          mainEntryPointFilePath: `<projectFolder>/${entry.mainEntryPoint}`,
-          dtsRollup: {
-            enabled: true,
-            untrimmedFilePath: `<projectFolder>/${entry.output}`,
-          },
-        };
+        const result = rollupEntry(entry, projectFolder, tsconfigPath);
+        results.push({ entry, ...result });
 
-        // 用安全的文件名（将 / 替换为 -）
-        const safeName = entry.name.replace(/\//g, '-');
-        const tempConfigPath = path.resolve(
-          projectFolder,
-          `api-extractor.${safeName}.tmp.json`,
-        );
-        fs.writeFileSync(tempConfigPath, JSON.stringify(config, null, 2));
-
-        let success = false;
-        try {
-          const extractorConfig =
-            ExtractorConfig.loadFileAndPrepare(tempConfigPath);
-          const extractorResult = Extractor.invoke(extractorConfig, {
-            localBuild: true,
-            showVerboseMessages: false,
-          });
+        if (result.success) {
+          keepFiles.push(path.resolve(projectFolder, entry.output));
+        }
+      }
 
-          if (extractorResult.succeeded) {
-            console.log(
-              `[rollup-dts] ✅ ${entry.name}: types rolled up successfully`,
-            );
-            success = true;
-          } else {
-            console.warn(
-              `[rollup-dts] ⚠️  ${entry.name}: API Extractor completed with warnings/errors`,
+      // 第三步：为每个入口添加共享类型的 import
+      if (sharedTypes && sharedTypeNames.length > 0) {
+        console.log('[rollup-dts] 🔗 Adding shared type imports...');
+        for (const { entry, success } of results) {
+          if (success) {
+            addSharedTypeImports(
+              path.resolve(projectFolder, entry.output),
+              sharedTypes.output,
+              sharedTypeNames,
             );
-            if (fs.existsSync(path.resolve(projectFolder, entry.output))) {
-              success = true;
-            }
-          }
-        } catch (error) {
-          console.warn(
-            `[rollup-dts] ⚠️  ${entry.name}: Error during rollup, keeping original .d.ts files`,
-          );
-          console.warn(`   ${error instanceof Error ? error.message : error}`);
-        } finally {
-          if (fs.existsSync(tempConfigPath)) {
-            fs.unlinkSync(tempConfigPath);
           }
         }
-
-        results.push({ entry, success });
       }
 
-      // Determine which directories to keep
+      // 第四步：清理中间文件
       const dirsToKeep = new Set();
-
       for (const { entry, success } of results) {
         if (!success) {
           const entryDir = path.dirname(
@@ -207,15 +374,11 @@ export function rollupDtsPlugin(options = {}) {
         }
       }
 
-      // Clean up only if all entries succeeded
       if (dirsToKeep.size === 0) {
         console.log('[rollup-dts] 🧹 Cleaning up intermediate files...');
         const outDir = resolvedConfig?.build?.outDir || 'dist';
         const distDir = path.resolve(projectFolder, outDir);
-        cleanupIntermediateFiles(
-          distDir,
-          entries.map((e) => path.resolve(projectFolder, e.output)),
-        );
+        cleanupIntermediateFiles(distDir, keepFiles);
       } else {
         console.log(
           '[rollup-dts] ⚠️  Some entries failed, keeping intermediate files',
@@ -223,8 +386,15 @@ export function rollupDtsPlugin(options = {}) {
       }
 
       console.log('[rollup-dts] 📊 Summary:');
-      for (const { entry, success } of results) {
-        console.log(`   ${success ? '✅' : '❌'} ${entry.name}`);
+      if (sharedTypes) {
+        console.log(`   ✅ shared (${sharedTypeNames.length} types)`);
+      }
+      for (const { entry, success, skipped } of results) {
+        if (skipped) {
+          console.log(`   ⏭️  ${entry.name} (skipped)`);
+        } else {
+          console.log(`   ${success ? '✅' : '❌'} ${entry.name}`);
+        }
       }
     },
   };

package/vite.config.base.js

@@ -11,9 +11,12 @@ import { rollupDtsPlugin } from './vite-plugin-rollup-dts.js';
 /**
  * @typedef {import('vite').UserConfig} UserConfig
  * @typedef {import('vite-plugin-dts').PluginOptions} DtsPluginOptions
+ * @typedef {Object} RollupDtsOptions
+ * @property {string} [tsconfigPath] - tsconfig.json 路径
+ * @property {{ input: string, output: string }} [sharedTypes] - 共享类型配置
  * @typedef {Object} CreateBaseConfigOptions
  * @property {'app' | 'lib'} [mode] - 构建模式：'app' 为 Vue 应用，'lib' 为库打包
- * @property {Partial<DtsPluginOptions>} [dtsConfig] - vite-plugin-dts 配置（仅 lib 模式），会与默认配置合并
+ * @property {Partial<DtsPluginOptions> & RollupDtsOptions} [dtsConfig] - vite-plugin-dts 配置（仅 lib 模式），会与默认配置合并
  * @property {UserConfig} [viteConfig] - 额外的 Vite 配置，会与基础配置合并
  */
 
@@ -67,6 +70,9 @@ export function createBaseConfig(dirname, options = {}) {
 
   // Lib mode: 提供默认配置
   if (mode === 'lib') {
+    // 提取 rollupDts 专用配置
+    const { sharedTypes, tsconfigPath, ...dtsOnlyConfig } = dtsConfig;
+
     baseConfig.build = {
       copyPublicDir: false,
       lib: {
@@ -81,12 +87,17 @@ export function createBaseConfig(dirname, options = {}) {
       dts({
         include: ['src/**/*.ts'],
         root: dirname,
-        ...dtsConfig,
+        ...dtsOnlyConfig,
         rollupTypes: false,
       }),
     );
     if (dtsConfig.rollupTypes) {
-      baseConfig.plugins.push(rollupDtsPlugin());
+      baseConfig.plugins.push(
+        rollupDtsPlugin({
+          tsconfigPath,
+          sharedTypes,
+        }),
+      );
     }
   }