@playcraft/build 0.0.8 → 0.0.10

package/dist/base-builder.js

@@ -5,6 +5,8 @@ import { build as viteBuild } from 'vite';
 import { visualizer } from 'rollup-plugin-visualizer';
 import { viteSourceBuilderPlugin } from './vite/plugin-source-builder.js';
 import { loadPlayCanvasProject } from './loaders/playcanvas-loader.js';
+import { BuildAnalyzer } from './analyzers/build-analyzer.js';
+import { BuildStateManager } from './state/index.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 /**
@@ -20,12 +22,19 @@ export class BaseBuilder {
     constructor(projectDir, options) {
         this.projectDir = projectDir;
         this.options = options;
+        this.stateManager = new BuildStateManager(projectDir, options.outputDir);
         console.log(`[BaseBuilder] 初始化: projectDir=${projectDir}, outputDir=${options.outputDir}`);
     }
     /**
      * 执行基础构建
      */
     async build() {
+        // 开始构建阶段
+        this.stateManager.startStage('base-build', {
+            selectedScenes: this.options.selectedScenes,
+            analyze: this.options.analyze,
+            clean: this.options.clean,
+        });
         // 1. 检测项目类型
         const projectType = await this.detectProjectType();
         let result;
@@ -41,6 +50,16 @@ export class BaseBuilder {
         }
         // 保存构建元数据
         await this.saveBuildMetadata(result.metadata);
+        // 记录构建产物
+        await this.recordBuildOutput(result);
+        // 结束构建阶段
+        this.stateManager.endStage();
+        // 生成分析报告（如果启用）
+        if (this.options.analyze) {
+            // 只在分析模式下保存状态文件（分析报告需要用到）
+            await this.stateManager.saveState();
+            await this.generateAnalysisReport();
+        }
         return result;
     }
     /**
@@ -413,7 +432,8 @@ export class BaseBuilder {
             build: {
                 outDir: this.options.outputDir,
                 emptyOutDir: shouldEmptyOutDir,
-                write: false, // 不写入文件，仅用于触发插件
+                // 如果启用了分析报告，需要 write: true 以便 visualizer 插件能够生成报告
+                write: this.options.analyze ? true : false,
                 rollupOptions: {
                     input: {
                         // 使用虚拟入口，仅用于触发插件
@@ -446,6 +466,19 @@ export class BaseBuilder {
                     buildMode: buildMode,
                     importMap: importMap,
                 }),
+                // 打包分析报告（如果启用）
+                ...(this.options.analyze ? [
+                    visualizer({
+                        filename: this.options.analyzeReportPath
+                            ? path.join(this.options.outputDir, this.options.analyzeReportPath)
+                            : path.join(this.options.outputDir, 'base-bundle-report.html'),
+                        template: 'treemap',
+                        gzipSize: true,
+                        brotliSize: true,
+                        open: false,
+                        sourcemap: false,
+                    }),
+                ] : []),
             ],
         } : {
             // 传统模式：打包用户脚本
@@ -500,11 +533,16 @@ export class BaseBuilder {
                         gzipSize: true,
                         brotliSize: true,
                         open: false,
-                        sourcemap: false,
                     }),
                 ] : []),
             ],
         };
+        // DEBUG: 检查 analyze 配置
+        if (this.options.analyze) {
+            console.log('[BaseBuilder] analyze 已启用，报告路径:', this.options.analyzeReportPath
+                ? path.join(this.options.outputDir, this.options.analyzeReportPath)
+                : path.join(this.options.outputDir, 'base-bundle-report.html'));
+        }
         // 2. 执行 Vite 构建
         await viteBuild(viteConfig);
         // 3. 扫描生成的文件
@@ -608,4 +646,120 @@ export class BaseBuilder {
             }
         }
     }
+    /**
+     * 记录构建产物信息到状态管理器
+     */
+    async recordBuildOutput(result) {
+        console.log('[BaseBuilder] 记录构建产物信息...');
+        try {
+            // 记录 HTML 文件
+            if (result.files.html) {
+                const stat = await fs.stat(result.files.html);
+                this.stateManager.recordAsset('index.html', 'index.html', result.files.html, stat.size, 'html');
+                this.stateManager.updateAsset('index.html', 'base-build', 'index.html', 'index.html', stat.size);
+            }
+            // 记录引擎文件
+            if (result.files.engine) {
+                const stat = await fs.stat(result.files.engine);
+                const engineName = path.basename(result.files.engine);
+                this.stateManager.recordAsset('playcanvas-engine', engineName, result.files.engine, stat.size, 'script');
+                this.stateManager.updateAsset('playcanvas-engine', 'base-build', engineName, engineName, stat.size);
+            }
+            // 记录 config.json
+            if (result.files.config) {
+                const stat = await fs.stat(result.files.config);
+                this.stateManager.recordAsset('config.json', 'config.json', result.files.config, stat.size, 'json');
+                this.stateManager.updateAsset('config.json', 'base-build', 'config.json', 'config.json', stat.size);
+            }
+            // 记录其他脚本文件
+            const scriptFiles = [
+                { path: result.files.start, id: '__start__.js' },
+                { path: result.files.settings, id: '__settings__.js' },
+                { path: result.files.modules, id: '__modules__.js' },
+            ];
+            for (const { path: filePath, id } of scriptFiles) {
+                if (filePath) {
+                    try {
+                        const stat = await fs.stat(filePath);
+                        const fileName = path.basename(filePath);
+                        this.stateManager.recordAsset(id, fileName, filePath, stat.size, 'script');
+                        this.stateManager.updateAsset(id, 'base-build', fileName, fileName, stat.size);
+                    }
+                    catch (error) {
+                        // 文件可能不存在
+                    }
+                }
+            }
+            // 记录场景文件
+            for (const scenePath of result.files.scenes) {
+                try {
+                    const stat = await fs.stat(scenePath);
+                    const sceneName = path.basename(scenePath);
+                    const sceneId = `scene-${sceneName}`;
+                    this.stateManager.recordAsset(sceneId, sceneName, scenePath, stat.size, 'json');
+                    this.stateManager.updateAsset(sceneId, 'base-build', sceneName, path.relative(this.options.outputDir, scenePath), stat.size);
+                }
+                catch (error) {
+                    // 忽略错误
+                }
+            }
+            // 记录资产文件
+            for (const assetPath of result.files.assets) {
+                try {
+                    const stat = await fs.stat(assetPath);
+                    const assetName = path.basename(assetPath);
+                    const assetId = `asset-${assetName}`;
+                    // 根据文件扩展名判断类型
+                    const ext = path.extname(assetName).toLowerCase();
+                    let assetType = 'other';
+                    if (['.png', '.jpg', '.jpeg', '.webp', '.gif'].includes(ext)) {
+                        assetType = 'texture';
+                    }
+                    else if (['.mp3', '.wav', '.ogg'].includes(ext)) {
+                        assetType = 'audio';
+                    }
+                    else if (['.glb', '.gltf', '.obj', '.fbx'].includes(ext)) {
+                        assetType = 'model';
+                    }
+                    this.stateManager.recordAsset(assetId, assetName, assetPath, stat.size, assetType);
+                    this.stateManager.updateAsset(assetId, 'base-build', assetName, path.relative(this.options.outputDir, assetPath), stat.size);
+                }
+                catch (error) {
+                    // 忽略错误
+                }
+            }
+            console.log('[BaseBuilder] 构建产物信息已记录');
+        }
+        catch (error) {
+            console.error('[BaseBuilder] 记录构建产物信息失败:', error);
+        }
+    }
+    /**
+     * 生成构建分析报告
+     */
+    async generateAnalysisReport() {
+        console.log('\n[BaseBuilder] 生成构建分析报告...');
+        try {
+            const analyzer = new BuildAnalyzer(this.options.outputDir, this.options.outputDir);
+            const report = await analyzer.analyze();
+            const reportPath = await analyzer.generateHTMLReport(report);
+            // 删除 rollup-plugin-visualizer 生成的报告文件
+            const oldReportPath = path.join(this.options.outputDir, 'base-bundle-report.html');
+            try {
+                await fs.unlink(oldReportPath);
+                console.log('[BaseBuilder] 已删除旧的分析报告: base-bundle-report.html');
+            }
+            catch (error) {
+                // 文件可能不存在，忽略错误
+            }
+            console.log(`\n📊 构建分析报告:`);
+            console.log(`   文件总数: ${report.totalFiles}`);
+            console.log(`   当前总大小: ${report.totalSizeFormatted}`);
+            console.log(`   预估单 HTML 大小: ${report.estimatedHtmlSizeFormatted}`);
+            console.log(`   报告路径: ${reportPath}\n`);
+        }
+        catch (error) {
+            console.error('[BaseBuilder] 生成分析报告失败:', error);
+        }
+    }
 }

package/dist/build-state-manager.d.ts

@@ -0,0 +1,110 @@
+/**
+ * 资源类型
+ */
+export type AssetType = 'script' | 'texture' | 'audio' | 'json' | 'css' | 'html' | 'other';
+/**
+ * 资源处理记录
+ */
+export interface AssetProcessingRecord {
+    originalName: string;
+    originalPath: string;
+    originalSize: number;
+    type: AssetType;
+    processedName?: string;
+    processedSize?: number;
+    processedPath?: string;
+    compressionRate?: number;
+    minified?: boolean;
+    inlined?: boolean;
+    finalLocation?: 'inline' | 'external';
+    finalReference?: string;
+}
+/**
+ * 构建状态
+ */
+export interface BuildState {
+    version: string;
+    buildTime: string;
+    platform?: string;
+    buildMode?: string;
+    assets: {
+        [assetId: string]: AssetProcessingRecord;
+    };
+    output: {
+        totalSize: number;
+        htmlSize?: number;
+        files: {
+            [filename: string]: {
+                size: number;
+                type: string;
+            };
+        };
+    };
+}
+/**
+ * 构建状态管理器
+ *
+ * 职责：
+ * 1. 记录打包过程中每个资源的处理信息
+ * 2. 追踪资源的转换过程（原始大小 -> 处理后大小）
+ * 3. 生成 state.json 文件供分析使用
+ */
+export declare class BuildStateManager {
+    private state;
+    private stateFilePath;
+    constructor(outputDir: string, platform?: string, buildMode?: string);
+    /**
+     * 记录资源的原始信息
+     */
+    recordAsset(assetId: string, originalName: string, originalPath: string, originalSize: number, type: AssetType): void;
+    /**
+     * 更新资源的处理信息
+     */
+    updateAssetProcessing(assetId: string, processedName: string, processedSize: number, processedPath: string, options?: {
+        minified?: boolean;
+        inlined?: boolean;
+    }): void;
+    /**
+     * 更新资源的最终位置
+     */
+    updateAssetFinalLocation(assetId: string, finalLocation: 'inline' | 'external', finalReference?: string): void;
+    /**
+     * 记录输出文件
+     */
+    recordOutputFile(filename: string, size: number, type: string): void;
+    /**
+     * 获取状态
+     */
+    getState(): BuildState;
+    /**
+     * 保存状态到文件
+     */
+    save(): Promise<void>;
+    /**
+     * 从文件加载状态
+     */
+    static load(outputDir: string): Promise<BuildStateManager | null>;
+    /**
+     * 生成分析报告数据
+     */
+    generateAnalysisData(): {
+        assets: Array<{
+            name: string;
+            originalSize: number;
+            processedSize: number;
+            compressionRate: number;
+            type: AssetType;
+            finalLocation: string;
+        }>;
+        summary: {
+            totalOriginalSize: number;
+            totalProcessedSize: number;
+            totalCompressionRate: number;
+            assetCount: number;
+        };
+    };
+    /**
+     * 打印摘要
+     */
+    printSummary(): void;
+}

package/dist/build-state-manager.js

@@ -0,0 +1,169 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { formatBytes } from './utils.js';
+/**
+ * 构建状态管理器
+ *
+ * 职责：
+ * 1. 记录打包过程中每个资源的处理信息
+ * 2. 追踪资源的转换过程（原始大小 -> 处理后大小）
+ * 3. 生成 state.json 文件供分析使用
+ */
+export class BuildStateManager {
+    constructor(outputDir, platform, buildMode) {
+        this.stateFilePath = path.join(outputDir, 'build-state.json');
+        this.state = {
+            version: '1.0.0',
+            buildTime: new Date().toISOString(),
+            platform,
+            buildMode,
+            assets: {},
+            output: {
+                totalSize: 0,
+                files: {},
+            },
+        };
+    }
+    /**
+     * 记录资源的原始信息
+     */
+    recordAsset(assetId, originalName, originalPath, originalSize, type) {
+        this.state.assets[assetId] = {
+            originalName,
+            originalPath,
+            originalSize,
+            type,
+        };
+    }
+    /**
+     * 更新资源的处理信息
+     */
+    updateAssetProcessing(assetId, processedName, processedSize, processedPath, options) {
+        const asset = this.state.assets[assetId];
+        if (!asset) {
+            console.warn(`[BuildState] 资源不存在: ${assetId}`);
+            return;
+        }
+        asset.processedName = processedName;
+        asset.processedSize = processedSize;
+        asset.processedPath = processedPath;
+        asset.minified = options?.minified;
+        asset.inlined = options?.inlined;
+        // 计算压缩率
+        if (asset.originalSize > 0) {
+            asset.compressionRate = ((asset.originalSize - processedSize) / asset.originalSize) * 100;
+        }
+    }
+    /**
+     * 更新资源的最终位置
+     */
+    updateAssetFinalLocation(assetId, finalLocation, finalReference) {
+        const asset = this.state.assets[assetId];
+        if (!asset) {
+            console.warn(`[BuildState] 资源不存在: ${assetId}`);
+            return;
+        }
+        asset.finalLocation = finalLocation;
+        asset.finalReference = finalReference;
+    }
+    /**
+     * 记录输出文件
+     */
+    recordOutputFile(filename, size, type) {
+        this.state.output.files[filename] = { size, type };
+        this.state.output.totalSize += size;
+        if (filename.endsWith('.html')) {
+            this.state.output.htmlSize = size;
+        }
+    }
+    /**
+     * 获取状态
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * 保存状态到文件
+     */
+    async save() {
+        await fs.writeFile(this.stateFilePath, JSON.stringify(this.state, null, 2), 'utf-8');
+        console.log(`[BuildState] 状态已保存: ${this.stateFilePath}`);
+    }
+    /**
+     * 从文件加载状态
+     */
+    static async load(outputDir) {
+        const stateFilePath = path.join(outputDir, 'build-state.json');
+        try {
+            const content = await fs.readFile(stateFilePath, 'utf-8');
+            const state = JSON.parse(content);
+            const manager = new BuildStateManager(outputDir);
+            manager.state = state;
+            return manager;
+        }
+        catch (error) {
+            console.warn(`[BuildState] 无法加载状态文件: ${stateFilePath}`);
+            return null;
+        }
+    }
+    /**
+     * 生成分析报告数据
+     */
+    generateAnalysisData() {
+        const assets = Object.entries(this.state.assets).map(([id, asset]) => ({
+            name: asset.processedName || asset.originalName,
+            originalSize: asset.originalSize,
+            processedSize: asset.processedSize || asset.originalSize,
+            compressionRate: asset.compressionRate || 0,
+            type: asset.type,
+            finalLocation: asset.finalLocation || 'unknown',
+        }));
+        const totalOriginalSize = assets.reduce((sum, a) => sum + a.originalSize, 0);
+        const totalProcessedSize = assets.reduce((sum, a) => sum + a.processedSize, 0);
+        const totalCompressionRate = totalOriginalSize > 0
+            ? ((totalOriginalSize - totalProcessedSize) / totalOriginalSize) * 100
+            : 0;
+        return {
+            assets,
+            summary: {
+                totalOriginalSize,
+                totalProcessedSize,
+                totalCompressionRate,
+                assetCount: assets.length,
+            },
+        };
+    }
+    /**
+     * 打印摘要
+     */
+    printSummary() {
+        const { assets, summary } = this.generateAnalysisData();
+        console.log('\n📊 构建状态摘要');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log(`资源总数: ${summary.assetCount}`);
+        console.log(`原始大小: ${formatBytes(summary.totalOriginalSize)}`);
+        console.log(`处理后大小: ${formatBytes(summary.totalProcessedSize)}`);
+        console.log(`压缩率: ${summary.totalCompressionRate.toFixed(2)}%`);
+        console.log(`最终产物大小: ${formatBytes(this.state.output.totalSize)}`);
+        if (this.state.output.htmlSize) {
+            console.log(`HTML 大小: ${formatBytes(this.state.output.htmlSize)}`);
+        }
+        // 按类型分组
+        const byType = new Map();
+        for (const asset of assets) {
+            const existing = byType.get(asset.type) || { count: 0, originalSize: 0, processedSize: 0 };
+            existing.count++;
+            existing.originalSize += asset.originalSize;
+            existing.processedSize += asset.processedSize;
+            byType.set(asset.type, existing);
+        }
+        console.log('\n按类型统计:');
+        for (const [type, stats] of byType.entries()) {
+            const rate = stats.originalSize > 0
+                ? ((stats.originalSize - stats.processedSize) / stats.originalSize) * 100
+                : 0;
+            console.log(`  ${type}: ${stats.count} 个, ${formatBytes(stats.originalSize)} → ${formatBytes(stats.processedSize)} (${rate.toFixed(1)}%)`);
+        }
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+    }
+}

package/dist/generators/config-generator.d.ts

@@ -3,6 +3,8 @@ import { PlayCraftProject } from '../loaders/playcraft-loader.js';
 export type ProjectConfig = PlayCanvasProject | PlayCraftProject;
 export interface GenerateConfigOptions {
     selectedScenes?: string[];
+    projectDir?: string;
+    stripMetadata?: boolean;
 }
 /**
  * 生成 PlayCanvas 构建产物格式的 config.json