fe-stack 0.0.16 → 0.0.17

package/package.json

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

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

@@ -21,17 +21,12 @@ export interface RollupDtsPluginOptions {
   /** tsconfig.json 文件路径，默认为 './tsconfig.json' */
   tsconfigPath?: string;
   /**
-   * 共享类型入口配置（多入口时使用）
-   * 指定一个共享类型的入口，会被 API Extractor 单独处理
-   * 其他入口会自动 import 这个共享类型文件
-   * @example { input: './dist/types.d.ts', output: './dist/shared.d.ts' }
+   * 共享类型输出路径（多入口时使用）
+   * 插件会自动分析各入口输出，找出在所有入口中都存在的类型声明
+   * 将这些共享类型提取到指定文件，并更新各入口文件的 import
+   * @example './dist/shared.d.ts'
    */
-  sharedTypes?: {
-    /** 共享类型的 .d.ts 入口文件路径 */
-    input: string;
-    /** 合并后的输出路径 */
-    output: string;
-  } | null;
+  sharedTypesOutput?: string | null;
 }
 
 /**

package/vite-plugin-rollup-dts.js

@@ -167,121 +167,206 @@ function rollupEntry(entry, projectFolder, tsconfigPath) {
 }
 
 /**
- * 从 .d.ts 文件中提取导出的类型名称
+ * 从 .d.ts 内容中解析类型声明
+ * 返回 Map<typeName, { declaration: string, kind: string }>
  */
-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]);
+function parseTypeDeclarations(content) {
+  const declarations = new Map();
+  const lines = content.split('\n');
+
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+
+    // 匹配类型声明开始
+    const match = line.match(
+      /^export\s+declare\s+(interface|type|enum|class|namespace)\s+(\w+)/,
+    );
+
+    if (match) {
+      const kind = match[1];
+      const name = match[2];
+      const declLines = [line];
+
+      // type alias 可能是单行
+      if (kind === 'type' && line.includes('=') && line.includes(';')) {
+        declarations.set(name, { declaration: line, kind });
+        i++;
+        continue;
+      }
+
+      // 多行声明，收集直到闭合
+      let braceCount =
+        (line.match(/{/g) || []).length - (line.match(/}/g) || []).length;
+      i++;
+
+      while (i < lines.length && braceCount > 0) {
+        declLines.push(lines[i]);
+        braceCount +=
+          (lines[i].match(/{/g) || []).length -
+          (lines[i].match(/}/g) || []).length;
+        i++;
+      }
+
+      declarations.set(name, { declaration: declLines.join('\n'), kind });
+    } else {
+      i++;
+    }
   }
 
-  return names;
+  return declarations;
 }
 
 /**
- * 在入口文件中添加对共享类型的 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`,
-      );
+function findSharedTypeDeclarations(outputs) {
+  if (outputs.length < 2) return new Map();
 
-      if (typeDefStart.test(line) && !skipUntilClosingBrace) {
-        // 检查是否是单行定义（type alias）
-        if (line.includes('=') && line.includes(';')) {
-          // 单行 type alias，直接跳过
-          continue;
-        }
+  // 解析所有文件的类型声明
+  const allDeclarations = outputs.map((output) => ({
+    name: output.name,
+    declarations: parseTypeDeclarations(output.content),
+  }));
 
-        // 多行定义，开始跳过
-        skipUntilClosingBrace = true;
-        braceCount =
-          (line.match(/{/g) || []).length - (line.match(/}/g) || []).length;
+  // 找出在所有文件中都出现的类型名称
+  const firstDecls = allDeclarations[0].declarations;
+  const sharedTypes = new Map();
 
-        // 如果这一行就闭合了
-        if (braceCount <= 0 && line.includes('}')) {
-          skipUntilClosingBrace = false;
-        }
+  for (const [typeName, typeInfo] of firstDecls) {
+    // 检查是否在所有其他文件中都存在
+    const existsInAll = allDeclarations
+      .slice(1)
+      .every((file) => file.declarations.has(typeName));
+
+    if (existsInAll) {
+      sharedTypes.set(typeName, typeInfo);
+    }
+  }
+
+  return sharedTypes;
+}
+
+/**
+ * 从文件内容中移除指定的类型声明
+ */
+function removeTypeDeclarations(content, typeNames) {
+  const lines = content.split('\n');
+  const newLines = [];
+
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+
+    // 检查是否是要移除的类型声明
+    const match = line.match(
+      /^export\s+declare\s+(interface|type|enum|class|namespace)\s+(\w+)/,
+    );
+
+    if (match && typeNames.includes(match[2])) {
+      const kind = match[1];
+
+      // type alias 单行
+      if (kind === 'type' && line.includes('=') && line.includes(';')) {
+        i++;
         continue;
       }
 
-      if (skipUntilClosingBrace) {
+      // 多行声明，跳过直到闭合
+      let braceCount =
+        (line.match(/{/g) || []).length - (line.match(/}/g) || []).length;
+      i++;
+
+      while (i < lines.length && braceCount > 0) {
         braceCount +=
-          (line.match(/{/g) || []).length - (line.match(/}/g) || []).length;
-        if (braceCount <= 0) {
-          skipUntilClosingBrace = false;
-        }
-        continue;
+          (lines[i].match(/{/g) || []).length -
+          (lines[i].match(/}/g) || []).length;
+        i++;
       }
-
+    } else {
       newLines.push(line);
+      i++;
     }
-
-    content = newLines.join('\n');
   }
 
-  // 清理多余的空行
-  content = content.replace(/\n{3,}/g, '\n\n').trim();
+  return newLines.join('\n').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, '/');
+/**
+ * 提取共享类型到单独文件，并更新各入口文件
+ */
+function extractSharedTypes(outputs, projectFolder, sharedTypesOutput) {
+  // 找出共享的类型声明
+  const sharedTypes = findSharedTypeDeclarations(outputs);
 
-  if (!relativePath.startsWith('.')) {
-    relativePath = './' + relativePath;
+  if (sharedTypes.size === 0) {
+    console.log('[rollup-dts] ℹ️  No shared types found across entries');
+    return { sharedTypeNames: [], sharedFilePath: null };
   }
 
-  // 添加 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');
+  const sharedTypeNames = Array.from(sharedTypes.keys());
   console.log(
-    `[rollup-dts] 🔗 Added shared type imports to ${path.basename(entryOutputPath)}: ${usedTypes.join(', ')}`,
+    `[rollup-dts] 📝 Found ${sharedTypes.size} shared types: ${sharedTypeNames.join(', ')}`,
   );
+
+  // 生成共享类型文件内容
+  const sharedContent = Array.from(sharedTypes.values())
+    .map((t) => t.declaration)
+    .join('\n\n');
+
+  const sharedFilePath = path.resolve(projectFolder, sharedTypesOutput);
+
+  // 确保目录存在
+  const sharedDir = path.dirname(sharedFilePath);
+  if (!fs.existsSync(sharedDir)) {
+    fs.mkdirSync(sharedDir, { recursive: true });
+  }
+
+  // 写入共享类型文件
+  fs.writeFileSync(sharedFilePath, sharedContent + '\n\nexport { }\n', 'utf-8');
+  console.log(`[rollup-dts] ✅ Shared types written to: ${sharedTypesOutput}`);
+
+  // 更新各入口文件
+  for (const output of outputs) {
+    // 移除共享类型声明
+    let newContent = removeTypeDeclarations(output.content, sharedTypeNames);
+
+    // 找出这个文件中实际使用的共享类型
+    const usedTypes = sharedTypeNames.filter((name) => {
+      const regex = new RegExp(`\\b${name}\\b`);
+      return regex.test(newContent);
+    });
+
+    if (usedTypes.length > 0) {
+      // 计算相对路径
+      const outputDir = path.dirname(output.path);
+      let relativePath = path
+        .relative(outputDir, sharedFilePath)
+        .replace(/\\/g, '/');
+
+      if (!relativePath.startsWith('.')) {
+        relativePath = './' + relativePath;
+      }
+
+      // 添加 import 和 re-export
+      const importExport = `import type { ${usedTypes.join(', ')} } from '${relativePath}';\nexport type { ${usedTypes.join(', ')} } from '${relativePath}';\n\n`;
+      newContent = importExport + newContent;
+
+      console.log(
+        `[rollup-dts] 🔗 Updated ${output.name}: imports ${usedTypes.join(', ')}`,
+      );
+    }
+
+    fs.writeFileSync(output.path, newContent, 'utf-8');
+  }
+
+  return { sharedTypeNames, sharedFilePath };
 }
 
 export function rollupDtsPlugin(options = {}) {
   const {
     tsconfigPath = './tsconfig.json',
-    sharedTypes = null, // { input: './dist/types.d.ts', output: './dist/shared.d.ts' }
+    sharedTypesOutput = null, // 例如: './dist/shared.d.ts'
   } = options;
   let resolvedConfig;
   let entries = [];
@@ -309,35 +394,8 @@ export function rollupDtsPlugin(options = {}) {
 
       console.log('\n[rollup-dts] Starting to bundle declaration files...');
 
-      // 第一步：如果有共享类型配置，先处理共享类型
-      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;
-        }
-
         const result = rollupEntry(entry, projectFolder, tsconfigPath);
         results.push({ entry, ...result });
 
@@ -346,21 +404,37 @@ export function rollupDtsPlugin(options = {}) {
         }
       }
 
-      // 第三步：为每个入口添加共享类型的 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,
-            );
-          }
+      // 第二步：如果有多个入口且指定了共享类型输出，提取共享类型
+      let sharedTypeNames = [];
+      if (sharedTypesOutput && results.filter((r) => r.success).length > 1) {
+        console.log('[rollup-dts] 🔍 Analyzing shared types across entries...');
+
+        // 读取所有成功的入口输出
+        const outputs = results
+          .filter((r) => r.success)
+          .map((r) => ({
+            name: r.entry.name,
+            path: path.resolve(projectFolder, r.entry.output),
+            content: fs.readFileSync(
+              path.resolve(projectFolder, r.entry.output),
+              'utf-8',
+            ),
+          }));
+
+        const { sharedTypeNames: names, sharedFilePath } = extractSharedTypes(
+          outputs,
+          projectFolder,
+          sharedTypesOutput,
+        );
+
+        sharedTypeNames = names;
+
+        if (sharedFilePath) {
+          keepFiles.push(sharedFilePath);
         }
       }
 
-      // 第四步：清理中间文件
+      // 第三步：清理中间文件
       const dirsToKeep = new Set();
       for (const { entry, success } of results) {
         if (!success) {
@@ -386,9 +460,6 @@ export function rollupDtsPlugin(options = {}) {
       }
 
       console.log('[rollup-dts] 📊 Summary:');
-      if (sharedTypes) {
-        console.log(`   ✅ shared (${sharedTypeNames.length} types)`);
-      }
       for (const { entry, success, skipped } of results) {
         if (skipped) {
           console.log(`   ⏭️  ${entry.name} (skipped)`);
@@ -396,6 +467,9 @@ export function rollupDtsPlugin(options = {}) {
           console.log(`   ${success ? '✅' : '❌'} ${entry.name}`);
         }
       }
+      if (sharedTypeNames.length > 0) {
+        console.log(`   📦 shared: ${sharedTypeNames.length} types extracted`);
+      }
     },
   };
 }

package/vite.config.base.js

@@ -13,7 +13,7 @@ import { rollupDtsPlugin } from './vite-plugin-rollup-dts.js';
  * @typedef {import('vite-plugin-dts').PluginOptions} DtsPluginOptions
  * @typedef {Object} RollupDtsOptions
  * @property {string} [tsconfigPath] - tsconfig.json 路径
- * @property {{ input: string, output: string }} [sharedTypes] - 共享类型配置
+ * @property {string} [sharedTypesOutput] - 共享类型输出路径（多入口时）
  * @typedef {Object} CreateBaseConfigOptions
  * @property {'app' | 'lib'} [mode] - 构建模式：'app' 为 Vue 应用，'lib' 为库打包
  * @property {Partial<DtsPluginOptions> & RollupDtsOptions} [dtsConfig] - vite-plugin-dts 配置（仅 lib 模式），会与默认配置合并
@@ -71,7 +71,7 @@ export function createBaseConfig(dirname, options = {}) {
   // Lib mode: 提供默认配置
   if (mode === 'lib') {
     // 提取 rollupDts 专用配置
-    const { sharedTypes, tsconfigPath, ...dtsOnlyConfig } = dtsConfig;
+    const { sharedTypesOutput, tsconfigPath, ...dtsOnlyConfig } = dtsConfig;
 
     baseConfig.build = {
       copyPublicDir: false,
@@ -95,7 +95,7 @@ export function createBaseConfig(dirname, options = {}) {
       baseConfig.plugins.push(
         rollupDtsPlugin({
           tsconfigPath,
-          sharedTypes,
+          sharedTypesOutput,
         }),
       );
     }