@esmx/core 3.0.0-rc.76 → 3.0.0-rc.78

package/dist/core.d.ts

@@ -696,4 +696,20 @@ export declare class Esmx {
      * ```
      */
     getStaticImportPaths(env: BuildEnvironment, specifier: string): Promise<readonly string[] | null>;
+    /**
+     * Generate bundle size analysis report for the build artifacts.
+     *
+     * @returns {{ text: string, json: object }} Report with text and JSON formats
+     *
+     * @example
+     * ```ts
+     * const report = esmx.generateSizeReport();
+     * console.log(report.text);
+     * console.log(`Total files: ${report.json.totalFiles}`);
+     * ```
+     */
+    generateSizeReport(): {
+        text: string;
+        json: import("./utils/file-size-stats").SizeStatsReport;
+    };
 }

package/dist/core.mjs

@@ -14,6 +14,7 @@ import {
   parsePackConfig
 } from "./pack-config.mjs";
 import { createCache } from "./utils/cache.mjs";
+import { generateSizeReport } from "./utils/file-size-stats.mjs";
 import { createClientImportMap, createImportMap } from "./utils/import-map.mjs";
 import { resolvePath } from "./utils/resolve-path.mjs";
 import { getImportPreloadInfo as getStaticImportPaths } from "./utils/static-import-lexer.mjs";
@@ -872,6 +873,24 @@ document.head.appendChild(script);
       }
     );
   }
+  /**
+   * Generate bundle size analysis report for the build artifacts.
+   *
+   * @returns {{ text: string, json: object }} Report with text and JSON formats
+   *
+   * @example
+   * ```ts
+   * const report = esmx.generateSizeReport();
+   * console.log(report.text);
+   * console.log(`Total files: ${report.json.totalFiles}`);
+   * ```
+   */
+  generateSizeReport() {
+    return generateSizeReport(
+      this.resolvePath("dist"),
+      "{client,server,node}/**/!(.*)"
+    );
+  }
 }
 async function defaultDevApp() {
   throw new Error("'devApp' function not set");

package/dist/utils/file-size-stats.d.ts

@@ -0,0 +1,29 @@
+export interface FileInfo {
+    path: string;
+    relativePath: string;
+    size: number;
+    gzipSize: number;
+    ext: string;
+}
+export interface SizeStatsReport {
+    totalFiles: number;
+    totalSize: number;
+    totalGzipSize: number;
+    compressionRatio: number;
+    files: FileInfo[];
+    byExtension: Record<string, {
+        count: number;
+        totalSize: number;
+        totalGzipSize: number;
+        avgSize: number;
+        avgGzipSize: number;
+    }>;
+}
+export declare function analyzeDirectory(dirPath: string, pattern?: string): SizeStatsReport;
+export declare function formatSize(bytes: number): string;
+export declare function generateTextReport(report: SizeStatsReport): string;
+export declare function generateJsonReport(report: SizeStatsReport): string;
+export declare function generateSizeReport(dirPath: string, pattern?: string): {
+    text: string;
+    json: SizeStatsReport;
+};

package/dist/utils/file-size-stats.mjs

@@ -0,0 +1,121 @@
+import fs from "node:fs";
+import { globSync } from "node:fs";
+import path from "node:path";
+import { gzipSync } from "node:zlib";
+function getGzipSize(filePath) {
+  try {
+    const content = fs.readFileSync(filePath);
+    const compressed = gzipSync(content, { level: 9 });
+    return compressed.length;
+  } catch (error) {
+    return fs.statSync(filePath).size;
+  }
+}
+function getAllFiles(dirPath, pattern = "**/!(.*)") {
+  const files = globSync(pattern, {
+    cwd: dirPath
+  });
+  return files.map((relativePath) => path.resolve(dirPath, relativePath)).filter((filePath) => fs.statSync(filePath).isFile());
+}
+export function analyzeDirectory(dirPath, pattern) {
+  if (!fs.existsSync(dirPath)) {
+    throw new Error(`Directory does not exist: ${dirPath}`);
+  }
+  const stat = fs.statSync(dirPath);
+  if (!stat.isDirectory()) {
+    throw new Error(`Path is not a directory: ${dirPath}`);
+  }
+  const files = getAllFiles(dirPath, pattern);
+  const fileInfos = [];
+  const byExtension = {};
+  let totalSize = 0;
+  let totalGzipSize = 0;
+  for (const filePath of files) {
+    const fileStat = fs.statSync(filePath);
+    const size = fileStat.size;
+    const gzipSize = getGzipSize(filePath);
+    const relativePath = path.relative(process.cwd(), filePath);
+    const ext = path.extname(filePath).toLowerCase() || "(no ext)";
+    const fileInfo = {
+      path: filePath,
+      relativePath,
+      size,
+      gzipSize,
+      ext
+    };
+    fileInfos.push(fileInfo);
+    totalSize += size;
+    totalGzipSize += gzipSize;
+    if (!byExtension[ext]) {
+      byExtension[ext] = {
+        count: 0,
+        totalSize: 0,
+        totalGzipSize: 0,
+        avgSize: 0,
+        avgGzipSize: 0
+      };
+    }
+    byExtension[ext].count++;
+    byExtension[ext].totalSize += size;
+    byExtension[ext].totalGzipSize += gzipSize;
+  }
+  Object.values(byExtension).forEach((group) => {
+    group.avgSize = Math.round(group.totalSize / group.count);
+    group.avgGzipSize = Math.round(group.totalGzipSize / group.count);
+  });
+  fileInfos.sort((a, b) => b.size - a.size);
+  const compressionRatio = totalSize > 0 ? (totalSize - totalGzipSize) / totalSize * 100 : 0;
+  return {
+    totalFiles: files.length,
+    totalSize,
+    totalGzipSize,
+    compressionRatio: Math.round(compressionRatio * 100) / 100,
+    files: fileInfos,
+    byExtension
+  };
+}
+export function formatSize(bytes) {
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIndex = 0;
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+  return `${size.toFixed(unitIndex === 0 ? 0 : 1)} ${units[unitIndex]}`;
+}
+export function generateTextReport(report) {
+  const lines = [];
+  lines.push("\u{1F4CA} Bundle Analysis");
+  lines.push("=".repeat(50));
+  lines.push("");
+  const maxPathLength = Math.max(
+    ...report.files.map((f) => f.relativePath.length)
+  );
+  const sizeHeader = "Size".padStart(10);
+  const gzippedHeader = "Gzipped".padStart(10);
+  const header = `File${" ".repeat(maxPathLength - 4)}  ${sizeHeader}  ${gzippedHeader}`;
+  lines.push(header);
+  lines.push("-".repeat(header.length));
+  for (const file of report.files) {
+    const paddedPath = file.relativePath.padEnd(maxPathLength);
+    const sizeStr = formatSize(file.size).padStart(10);
+    const gzipStr = formatSize(file.gzipSize).padStart(10);
+    lines.push(`${paddedPath}  ${sizeStr}  ${gzipStr}`);
+  }
+  lines.push("");
+  lines.push(
+    `Total: ${report.totalFiles} files, ${formatSize(report.totalSize)} (gzipped: ${formatSize(report.totalGzipSize)})`
+  );
+  return lines.join("\n");
+}
+export function generateJsonReport(report) {
+  return JSON.stringify(report, null, 2);
+}
+export function generateSizeReport(dirPath, pattern) {
+  const json = analyzeDirectory(dirPath, pattern);
+  return {
+    text: generateTextReport(json),
+    json
+  };
+}

package/dist/utils/file-size-stats.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/file-size-stats.test.mjs

@@ -0,0 +1,183 @@
+import fs from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { assert, describe, test } from "vitest";
+import {
+  analyzeDirectory,
+  formatSize,
+  generateSizeReport,
+  generateTextReport
+} from "./file-size-stats.mjs";
+describe("formatSize", () => {
+  test("should format bytes correctly", () => {
+    assert.equal(formatSize(0), "0 B");
+    assert.equal(formatSize(512), "512 B");
+    assert.equal(formatSize(1024), "1.0 KB");
+    assert.equal(formatSize(1536), "1.5 KB");
+    assert.equal(formatSize(1048576), "1.0 MB");
+    assert.equal(formatSize(1073741824), "1.0 GB");
+  });
+});
+describe("analyzeDirectory", () => {
+  test("should throw error for non-existent directory", () => {
+    try {
+      analyzeDirectory("/non-existent-path");
+      assert.fail("Should have thrown an error");
+    } catch (error) {
+      assert.equal(
+        error.message,
+        "Directory does not exist: /non-existent-path"
+      );
+    }
+  });
+  test("should throw error for file path", () => {
+    const tempFile = path.join(tmpdir(), "test-file.txt");
+    fs.writeFileSync(tempFile, "test content");
+    try {
+      try {
+        analyzeDirectory(tempFile);
+        assert.fail("Should have thrown an error");
+      } catch (error) {
+        assert.equal(
+          error.message,
+          `Path is not a directory: ${tempFile}`
+        );
+      }
+    } finally {
+      fs.unlinkSync(tempFile);
+    }
+  });
+  test("should analyze empty directory", () => {
+    const tempDir = fs.mkdtempSync(path.join(tmpdir(), "test-"));
+    try {
+      const report = analyzeDirectory(tempDir);
+      assert.equal(report.totalFiles, 0);
+      assert.equal(report.totalSize, 0);
+      assert.equal(report.totalGzipSize, 0);
+      assert.equal(report.compressionRatio, 0);
+      assert.deepEqual(report.files, []);
+      assert.deepEqual(report.byExtension, {});
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+  test("should analyze directory with files", () => {
+    const tempDir = fs.mkdtempSync(path.join(tmpdir(), "test-"));
+    try {
+      const jsContent = 'console.log("hello world");'.repeat(100);
+      const cssContent = "body { color: red; }".repeat(50);
+      const jsonContent = JSON.stringify({ test: "data" });
+      fs.writeFileSync(path.join(tempDir, "test.js"), jsContent);
+      fs.writeFileSync(path.join(tempDir, "style.css"), cssContent);
+      fs.writeFileSync(path.join(tempDir, "data.json"), jsonContent);
+      const subDir = path.join(tempDir, "subdir");
+      fs.mkdirSync(subDir);
+      fs.writeFileSync(path.join(subDir, "nested.js"), jsContent);
+      const report = analyzeDirectory(tempDir);
+      assert.equal(report.totalFiles, 4);
+      assert.ok(report.totalSize > 0);
+      assert.ok(report.totalGzipSize > 0);
+      assert.ok(report.compressionRatio >= 0);
+      assert.ok(report.byExtension[".js"]);
+      assert.ok(report.byExtension[".css"]);
+      assert.ok(report.byExtension[".json"]);
+      assert.equal(report.byExtension[".js"].count, 2);
+      assert.equal(report.byExtension[".css"].count, 1);
+      assert.equal(report.byExtension[".json"].count, 1);
+      assert.equal(report.files.length, 4);
+      const sizes = report.files.map((f) => f.size);
+      assert.deepEqual(
+        sizes,
+        [...sizes].sort((a, b) => b - a)
+      );
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+});
+describe("generateTextReport", () => {
+  test("should generate text report", () => {
+    const report = {
+      totalFiles: 2,
+      totalSize: 2048,
+      totalGzipSize: 1024,
+      compressionRatio: 50,
+      files: [
+        {
+          path: "/test/large.js",
+          relativePath: "large.js",
+          size: 1536,
+          gzipSize: 768,
+          ext: ".js"
+        },
+        {
+          path: "/test/small.css",
+          relativePath: "small.css",
+          size: 512,
+          gzipSize: 256,
+          ext: ".css"
+        }
+      ],
+      byExtension: {
+        ".js": {
+          count: 1,
+          totalSize: 1536,
+          totalGzipSize: 768,
+          avgSize: 1536,
+          avgGzipSize: 768
+        },
+        ".css": {
+          count: 1,
+          totalSize: 512,
+          totalGzipSize: 256,
+          avgSize: 512,
+          avgGzipSize: 256
+        }
+      }
+    };
+    const text = generateTextReport(report);
+    assert.ok(text.includes("\u{1F4CA} Bundle Analysis"));
+    assert.ok(text.includes("large.js"));
+    assert.ok(text.includes("small.css"));
+    assert.ok(text.includes("Total: 2 files"));
+  });
+});
+describe("generateSizeReport", () => {
+  test("should generate report with text and json properties", () => {
+    const tempDir = fs.mkdtempSync(path.join(tmpdir(), "test-"));
+    try {
+      fs.writeFileSync(
+        path.join(tempDir, "test.js"),
+        'console.log("test");'
+      );
+      const report = generateSizeReport(tempDir);
+      assert.ok(typeof report === "object");
+      assert.ok(typeof report.text === "string");
+      assert.ok(typeof report.json === "object");
+      assert.ok(report.text.includes("\u{1F4CA} Bundle Analysis"));
+      assert.ok(!report.text.startsWith("{"));
+      assert.ok(report.json.totalFiles !== void 0);
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+  test("should generate report with pattern filter", () => {
+    const tempDir = fs.mkdtempSync(path.join(tmpdir(), "test-"));
+    try {
+      fs.writeFileSync(
+        path.join(tempDir, "test.js"),
+        'console.log("test");'
+      );
+      fs.writeFileSync(
+        path.join(tempDir, "test.css"),
+        "body { color: red; }"
+      );
+      const report = generateSizeReport(tempDir, "*.js");
+      assert.ok(typeof report === "object");
+      assert.ok(report.json.totalFiles === 1);
+      assert.ok(report.json.files[0].ext === ".js");
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+});

package/package.json

@@ -59,7 +59,7 @@
         "build": "unbuild"
     },
     "dependencies": {
-        "@esmx/import": "3.0.0-rc.76",
+        "@esmx/import": "3.0.0-rc.78",
         "@types/serialize-javascript": "^5.0.4",
         "es-module-lexer": "^1.7.0",
         "find": "^0.3.0",
@@ -77,7 +77,7 @@
         "unbuild": "3.6.1",
         "vitest": "3.2.4"
     },
-    "version": "3.0.0-rc.76",
+    "version": "3.0.0-rc.78",
     "type": "module",
     "private": false,
     "exports": {
@@ -100,5 +100,5 @@
         "template",
         "public"
     ],
-    "gitHead": "8377e5ae2c59cc2b334272d674deb7a01b7e8fa5"
+    "gitHead": "aa44e33ab3e05817977c0fda6148abff8351651f"
 }

package/src/core.ts

@@ -22,6 +22,7 @@ import {
 import type { ImportmapMode } from './render-context';
 import type { RenderContext, RenderContextOptions } from './render-context';
 import { type CacheHandle, createCache } from './utils/cache';
+import { generateSizeReport } from './utils/file-size-stats';
 import { createClientImportMap, createImportMap } from './utils/import-map';
 import type { Middleware } from './utils/middleware';
 import { type ProjectPath, resolvePath } from './utils/resolve-path';
@@ -1079,6 +1080,24 @@ document.head.appendChild(script);
             }
         );
     }
+    /**
+     * Generate bundle size analysis report for the build artifacts.
+     *
+     * @returns {{ text: string, json: object }} Report with text and JSON formats
+     *
+     * @example
+     * ```ts
+     * const report = esmx.generateSizeReport();
+     * console.log(report.text);
+     * console.log(`Total files: ${report.json.totalFiles}`);
+     * ```
+     */
+    public generateSizeReport() {
+        return generateSizeReport(
+            this.resolvePath('dist'),
+            '{client,server,node}/**/!(.*)'
+        );
+    }
 }
 
 /**

package/src/utils/file-size-stats.test.ts

@@ -0,0 +1,212 @@
+import fs from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { assert, describe, test } from 'vitest';
+import {
+    analyzeDirectory,
+    formatSize,
+    generateSizeReport,
+    generateTextReport
+} from './file-size-stats';
+
+describe('formatSize', () => {
+    test('should format bytes correctly', () => {
+        assert.equal(formatSize(0), '0 B');
+        assert.equal(formatSize(512), '512 B');
+        assert.equal(formatSize(1024), '1.0 KB');
+        assert.equal(formatSize(1536), '1.5 KB');
+        assert.equal(formatSize(1048576), '1.0 MB');
+        assert.equal(formatSize(1073741824), '1.0 GB');
+    });
+});
+
+describe('analyzeDirectory', () => {
+    test('should throw error for non-existent directory', () => {
+        try {
+            analyzeDirectory('/non-existent-path');
+            assert.fail('Should have thrown an error');
+        } catch (error) {
+            assert.equal(
+                (error as Error).message,
+                'Directory does not exist: /non-existent-path'
+            );
+        }
+    });
+
+    test('should throw error for file path', () => {
+        const tempFile = path.join(tmpdir(), 'test-file.txt');
+        fs.writeFileSync(tempFile, 'test content');
+
+        try {
+            try {
+                analyzeDirectory(tempFile);
+                assert.fail('Should have thrown an error');
+            } catch (error) {
+                assert.equal(
+                    (error as Error).message,
+                    `Path is not a directory: ${tempFile}`
+                );
+            }
+        } finally {
+            fs.unlinkSync(tempFile);
+        }
+    });
+
+    test('should analyze empty directory', () => {
+        const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'test-'));
+
+        try {
+            const report = analyzeDirectory(tempDir);
+
+            assert.equal(report.totalFiles, 0);
+            assert.equal(report.totalSize, 0);
+            assert.equal(report.totalGzipSize, 0);
+            assert.equal(report.compressionRatio, 0);
+            assert.deepEqual(report.files, []);
+            assert.deepEqual(report.byExtension, {});
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+
+    test('should analyze directory with files', () => {
+        const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'test-'));
+
+        try {
+            const jsContent = 'console.log("hello world");'.repeat(100);
+            const cssContent = 'body { color: red; }'.repeat(50);
+            const jsonContent = JSON.stringify({ test: 'data' });
+
+            fs.writeFileSync(path.join(tempDir, 'test.js'), jsContent);
+            fs.writeFileSync(path.join(tempDir, 'style.css'), cssContent);
+            fs.writeFileSync(path.join(tempDir, 'data.json'), jsonContent);
+
+            const subDir = path.join(tempDir, 'subdir');
+            fs.mkdirSync(subDir);
+            fs.writeFileSync(path.join(subDir, 'nested.js'), jsContent);
+
+            const report = analyzeDirectory(tempDir);
+
+            assert.equal(report.totalFiles, 4);
+            assert.ok(report.totalSize > 0);
+            assert.ok(report.totalGzipSize > 0);
+            assert.ok(report.compressionRatio >= 0);
+
+            assert.ok(report.byExtension['.js']);
+            assert.ok(report.byExtension['.css']);
+            assert.ok(report.byExtension['.json']);
+
+            assert.equal(report.byExtension['.js'].count, 2);
+            assert.equal(report.byExtension['.css'].count, 1);
+            assert.equal(report.byExtension['.json'].count, 1);
+
+            assert.equal(report.files.length, 4);
+
+            const sizes = report.files.map((f) => f.size);
+            assert.deepEqual(
+                sizes,
+                [...sizes].sort((a, b) => b - a)
+            );
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe('generateTextReport', () => {
+    test('should generate text report', () => {
+        const report = {
+            totalFiles: 2,
+            totalSize: 2048,
+            totalGzipSize: 1024,
+            compressionRatio: 50,
+            files: [
+                {
+                    path: '/test/large.js',
+                    relativePath: 'large.js',
+                    size: 1536,
+                    gzipSize: 768,
+                    ext: '.js'
+                },
+                {
+                    path: '/test/small.css',
+                    relativePath: 'small.css',
+                    size: 512,
+                    gzipSize: 256,
+                    ext: '.css'
+                }
+            ],
+            byExtension: {
+                '.js': {
+                    count: 1,
+                    totalSize: 1536,
+                    totalGzipSize: 768,
+                    avgSize: 1536,
+                    avgGzipSize: 768
+                },
+                '.css': {
+                    count: 1,
+                    totalSize: 512,
+                    totalGzipSize: 256,
+                    avgSize: 512,
+                    avgGzipSize: 256
+                }
+            }
+        };
+
+        const text = generateTextReport(report);
+
+        assert.ok(text.includes('📊 Bundle Analysis'));
+        assert.ok(text.includes('large.js'));
+        assert.ok(text.includes('small.css'));
+        assert.ok(text.includes('Total: 2 files'));
+    });
+});
+
+describe('generateSizeReport', () => {
+    test('should generate report with text and json properties', () => {
+        const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'test-'));
+
+        try {
+            fs.writeFileSync(
+                path.join(tempDir, 'test.js'),
+                'console.log("test");'
+            );
+
+            const report = generateSizeReport(tempDir);
+
+            assert.ok(typeof report === 'object');
+            assert.ok(typeof report.text === 'string');
+            assert.ok(typeof report.json === 'object');
+            assert.ok(report.text.includes('📊 Bundle Analysis'));
+            assert.ok(!report.text.startsWith('{'));
+            assert.ok(report.json.totalFiles !== undefined);
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+
+    test('should generate report with pattern filter', () => {
+        const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'test-'));
+
+        try {
+            fs.writeFileSync(
+                path.join(tempDir, 'test.js'),
+                'console.log("test");'
+            );
+            fs.writeFileSync(
+                path.join(tempDir, 'test.css'),
+                'body { color: red; }'
+            );
+
+            // Test with pattern that only matches .js files
+            const report = generateSizeReport(tempDir, '*.js');
+
+            assert.ok(typeof report === 'object');
+            assert.ok(report.json.totalFiles === 1);
+            assert.ok(report.json.files[0].ext === '.js');
+        } finally {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+    });
+});

package/src/utils/file-size-stats.ts

@@ -0,0 +1,190 @@
+import fs from 'node:fs';
+import { globSync } from 'node:fs';
+import path from 'node:path';
+import { gzipSync } from 'node:zlib';
+
+export interface FileInfo {
+    path: string;
+    relativePath: string;
+    size: number;
+    gzipSize: number;
+    ext: string;
+}
+
+export interface SizeStatsReport {
+    totalFiles: number;
+    totalSize: number;
+    totalGzipSize: number;
+    compressionRatio: number;
+    files: FileInfo[];
+    byExtension: Record<
+        string,
+        {
+            count: number;
+            totalSize: number;
+            totalGzipSize: number;
+            avgSize: number;
+            avgGzipSize: number;
+        }
+    >;
+}
+
+function getGzipSize(filePath: string): number {
+    try {
+        const content = fs.readFileSync(filePath);
+        const compressed = gzipSync(content, { level: 9 });
+        return compressed.length;
+    } catch (error) {
+        return fs.statSync(filePath).size;
+    }
+}
+
+function getAllFiles(dirPath: string, pattern = '**/!(.*)'): string[] {
+    const files = globSync(pattern, {
+        cwd: dirPath
+    });
+
+    return files
+        .map((relativePath) => path.resolve(dirPath, relativePath))
+        .filter((filePath) => fs.statSync(filePath).isFile());
+}
+
+export function analyzeDirectory(
+    dirPath: string,
+    pattern?: string
+): SizeStatsReport {
+    if (!fs.existsSync(dirPath)) {
+        throw new Error(`Directory does not exist: ${dirPath}`);
+    }
+
+    const stat = fs.statSync(dirPath);
+    if (!stat.isDirectory()) {
+        throw new Error(`Path is not a directory: ${dirPath}`);
+    }
+
+    const files = getAllFiles(dirPath, pattern);
+    const fileInfos: FileInfo[] = [];
+    const byExtension: Record<
+        string,
+        {
+            count: number;
+            totalSize: number;
+            totalGzipSize: number;
+            avgSize: number;
+            avgGzipSize: number;
+        }
+    > = {};
+
+    let totalSize = 0;
+    let totalGzipSize = 0;
+
+    for (const filePath of files) {
+        const fileStat = fs.statSync(filePath);
+        const size = fileStat.size;
+        const gzipSize = getGzipSize(filePath);
+        const relativePath = path.relative(process.cwd(), filePath);
+        const ext = path.extname(filePath).toLowerCase() || '(no ext)';
+
+        const fileInfo: FileInfo = {
+            path: filePath,
+            relativePath,
+            size,
+            gzipSize,
+            ext
+        };
+
+        fileInfos.push(fileInfo);
+        totalSize += size;
+        totalGzipSize += gzipSize;
+
+        if (!byExtension[ext]) {
+            byExtension[ext] = {
+                count: 0,
+                totalSize: 0,
+                totalGzipSize: 0,
+                avgSize: 0,
+                avgGzipSize: 0
+            };
+        }
+
+        byExtension[ext].count++;
+        byExtension[ext].totalSize += size;
+        byExtension[ext].totalGzipSize += gzipSize;
+    }
+
+    Object.values(byExtension).forEach((group) => {
+        group.avgSize = Math.round(group.totalSize / group.count);
+        group.avgGzipSize = Math.round(group.totalGzipSize / group.count);
+    });
+
+    fileInfos.sort((a, b) => b.size - a.size);
+
+    const compressionRatio =
+        totalSize > 0 ? ((totalSize - totalGzipSize) / totalSize) * 100 : 0;
+
+    return {
+        totalFiles: files.length,
+        totalSize,
+        totalGzipSize,
+        compressionRatio: Math.round(compressionRatio * 100) / 100,
+        files: fileInfos,
+        byExtension
+    };
+}
+
+export function formatSize(bytes: number): string {
+    const units = ['B', 'KB', 'MB', 'GB'];
+    let size = bytes;
+    let unitIndex = 0;
+
+    while (size >= 1024 && unitIndex < units.length - 1) {
+        size /= 1024;
+        unitIndex++;
+    }
+
+    return `${size.toFixed(unitIndex === 0 ? 0 : 1)} ${units[unitIndex]}`;
+}
+
+export function generateTextReport(report: SizeStatsReport): string {
+    const lines: string[] = [];
+
+    lines.push('📊 Bundle Analysis');
+    lines.push('='.repeat(50));
+    lines.push('');
+
+    const maxPathLength = Math.max(
+        ...report.files.map((f) => f.relativePath.length)
+    );
+    const sizeHeader = 'Size'.padStart(10);
+    const gzippedHeader = 'Gzipped'.padStart(10);
+    const header = `File${' '.repeat(maxPathLength - 4)}  ${sizeHeader}  ${gzippedHeader}`;
+    lines.push(header);
+    lines.push('-'.repeat(header.length));
+
+    for (const file of report.files) {
+        const paddedPath = file.relativePath.padEnd(maxPathLength);
+        const sizeStr = formatSize(file.size).padStart(10);
+        const gzipStr = formatSize(file.gzipSize).padStart(10);
+        lines.push(`${paddedPath}  ${sizeStr}  ${gzipStr}`);
+    }
+
+    lines.push('');
+    lines.push(
+        `Total: ${report.totalFiles} files, ${formatSize(report.totalSize)} (gzipped: ${formatSize(report.totalGzipSize)})`
+    );
+
+    return lines.join('\n');
+}
+
+export function generateJsonReport(report: SizeStatsReport): string {
+    return JSON.stringify(report, null, 2);
+}
+
+export function generateSizeReport(dirPath: string, pattern?: string) {
+    const json = analyzeDirectory(dirPath, pattern);
+
+    return {
+        text: generateTextReport(json),
+        json
+    };
+}