bundle-cop-vercel-plugin 0.1.0

package/dist/index.js

@@ -0,0 +1,616 @@
+// src/index.ts
+import { join as join5 } from "path";
+
+// src/budgets.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+var SIZE_RE = /^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb)?$/i;
+function parseSize(input) {
+  const match = input.trim().match(SIZE_RE);
+  if (!match) {
+    throw new Error(`Invalid size: ${input}`);
+  }
+  const value = Number(match[1]);
+  const unit = (match[2] || "b").toLowerCase();
+  switch (unit) {
+    case "b":
+      return value;
+    case "kb":
+      return Math.round(value * 1024);
+    case "mb":
+      return Math.round(value * 1024 * 1024);
+    case "gb":
+      return Math.round(value * 1024 * 1024 * 1024);
+    default:
+      throw new Error(`Invalid size unit: ${unit}`);
+  }
+}
+function loadConfig(projectDir) {
+  const path = join(projectDir, "bundle-cop.config.json");
+  if (!existsSync(path)) {
+    return {
+      budgets: [],
+      ignore: [],
+      githubComment: true,
+      suggestions: true
+    };
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    console.warn("[bundle-cop] Failed to parse bundle-cop.config.json:", error);
+    return { budgets: [], suggestions: true, githubComment: true };
+  }
+}
+function checkBudgets(report, config) {
+  const budgets = config.budgets ?? [];
+  return budgets.map((rule) => {
+    const maxBytes = parseSize(rule.maxSize);
+    const matching = report.chunks.filter((chunk) => {
+      if (rule.path === "/*" || rule.path === "/") return true;
+      const route = chunk.route || "";
+      return route === rule.path || route.startsWith(rule.path.replace(/\/$/, ""));
+    });
+    const actualBytes = matching.length > 0 ? matching.reduce((sum, c) => sum + c.size, 0) : report.totalBytes;
+    return {
+      path: rule.path,
+      maxBytes,
+      actualBytes,
+      enforce: rule.enforce,
+      exceeded: actualBytes > maxBytes
+    };
+  });
+}
+function enforceBudgets(results) {
+  const errors = results.filter((r) => r.exceeded && r.enforce === "error");
+  for (const warn of results.filter((r) => r.exceeded && r.enforce === "warn")) {
+    console.warn(
+      `[bundle-cop] Budget warn ${warn.path}: ${formatBytes(warn.actualBytes)} > ${formatBytes(warn.maxBytes)}`
+    );
+  }
+  if (errors.length === 0) return;
+  const details = errors.map(
+    (e) => `${e.path}: ${formatBytes(e.actualBytes)} exceeds ${formatBytes(e.maxBytes)}`
+  ).join("; ");
+  throw new Error(`[bundle-cop] Budget exceeded \u2014 ${details}`);
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} kB`;
+  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+
+// src/find-next-dir.ts
+import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { join as join2 } from "path";
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "coverage",
+  ".turbo",
+  ".vercel"
+]);
+function findNextDir(startDir, preferredDir) {
+  if (preferredDir && existsSync2(preferredDir)) {
+    return preferredDir;
+  }
+  const direct = join2(startDir, ".next");
+  if (existsSync2(direct)) {
+    return direct;
+  }
+  let current = startDir;
+  for (let i = 0; i < 5; i++) {
+    const found = walkForNext(current, 4);
+    if (found) return found;
+    const parent = join2(current, "..");
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function walkForNext(dir, depth) {
+  if (depth < 0) return null;
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return null;
+  }
+  const nested = join2(dir, ".next");
+  if (existsSync2(nested)) return nested;
+  for (const entry of entries) {
+    if (SKIP_DIRS.has(entry) || entry.startsWith(".")) continue;
+    const full = join2(dir, entry);
+    try {
+      if (!statSync(full).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const found = walkForNext(full, depth - 1);
+    if (found) return found;
+  }
+  return null;
+}
+
+// src/parser.ts
+import {
+  existsSync as existsSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync2,
+  statSync as statSync2
+} from "fs";
+import { join as join3, relative } from "path";
+
+// src/attribution.ts
+function isUserFile(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  if (!normalized) return false;
+  if (normalized.includes("node_modules/")) return false;
+  if (normalized.includes("/.next/")) return false;
+  if (normalized.startsWith(".next/")) return false;
+  return true;
+}
+function toPath(entry) {
+  if (typeof entry === "string") return entry;
+  return entry.path || entry.name || "";
+}
+function toName(entry) {
+  if (typeof entry === "string") return entry;
+  return entry.name || entry.path || "";
+}
+function findCulprit(module) {
+  const raw = module.issuerPath ?? [];
+  const chain = raw.map(toName).filter(Boolean);
+  for (let i = raw.length - 1; i >= 0; i--) {
+    const path = toPath(raw[i]);
+    if (isUserFile(path)) {
+      return { culpritFile: path, chain };
+    }
+  }
+  if (isUserFile(module.name)) {
+    return { culpritFile: module.name, chain };
+  }
+  return { culpritFile: "unknown", chain };
+}
+var ALTERNATIVES = {
+  moment: "date-fns (save ~270kb) -> npm i date-fns",
+  lodash: "lodash-es + tree-shake or individual imports",
+  "react-icons": "import directly: react-icons/fa/FaIcon",
+  "date-fns": "use subpath imports: date-fns/format"
+};
+function suggestAlternative(moduleName) {
+  const normalized = moduleName.replace(/\\/g, "/").toLowerCase();
+  for (const [key, suggestion] of Object.entries(ALTERNATIVES)) {
+    if (normalized === key || normalized.includes(`node_modules/${key}/`) || normalized.startsWith(`${key}/`) || normalized.includes(`/${key}/`)) {
+      return suggestion;
+    }
+  }
+  return null;
+}
+
+// src/parser.ts
+var KNOWN_HEAVY = [
+  "moment",
+  "lodash",
+  "lodash-es",
+  "date-fns",
+  "react-icons",
+  "rxjs",
+  "antd",
+  "chart.js",
+  "recharts"
+];
+async function parseStats(options) {
+  const {
+    nextDir,
+    projectDir,
+    commitSha = null,
+    withSuggestions = true
+  } = options;
+  const fromDiagnostics = tryParseDiagnostics(nextDir, withSuggestions);
+  if (fromDiagnostics && fromDiagnostics.modules.length > 0) {
+    return finalize(fromDiagnostics, commitSha);
+  }
+  const fromAnalyze = tryParseAnalyzeClient(nextDir, withSuggestions);
+  if (fromAnalyze && fromAnalyze.modules.length > 0) {
+    return finalize(fromAnalyze, commitSha);
+  }
+  const fromChunks = parseChunkFallback(nextDir);
+  const fromRouteStats = parseRouteBundleStats(nextDir);
+  const chunks = fromRouteStats.chunks.length > 0 ? fromRouteStats.chunks : fromChunks.chunks;
+  const totalBytes = fromRouteStats.totalBytes || fromChunks.totalBytes || chunks.reduce((s, c) => s + c.size, 0);
+  const modules = enrichWithKnownPackages({
+    nextDir,
+    projectDir: projectDir || join3(nextDir, ".."),
+    withSuggestions
+  });
+  return finalize(
+    {
+      totalBytes,
+      modules: sortBySize(modules),
+      chunks: sortBySize(chunks)
+    },
+    commitSha
+  );
+}
+function finalize(partial, commitSha) {
+  return {
+    version: 1,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    commitSha,
+    ...partial
+  };
+}
+function tryParseDiagnostics(nextDir, withSuggestions) {
+  const dir = join3(nextDir, "diagnostics", "analyze");
+  if (!existsSync3(dir)) return null;
+  const modules = [];
+  const chunks = [];
+  for (const file of listJsonFiles(dir)) {
+    try {
+      const data = JSON.parse(readFileSync2(file, "utf8"));
+      absorbStats(data, modules, chunks, withSuggestions);
+    } catch {
+    }
+  }
+  if (modules.length === 0 && chunks.length === 0) return null;
+  const totalBytes = chunks.reduce((s, c) => s + c.size, 0) || modules.reduce((s, m) => s + m.size, 0);
+  return { totalBytes, modules: sortBySize(modules), chunks: sortBySize(chunks) };
+}
+function tryParseAnalyzeClient(nextDir, withSuggestions) {
+  const clientPath = join3(nextDir, "analyze", "client.json");
+  if (!existsSync3(clientPath)) return null;
+  try {
+    const data = JSON.parse(readFileSync2(clientPath, "utf8"));
+    const modules = [];
+    const chunks = [];
+    absorbStats(data, modules, chunks, withSuggestions);
+    const totalBytes = chunks.reduce((s, c) => s + c.size, 0) || modules.reduce((s, m) => s + m.size, 0);
+    return {
+      totalBytes,
+      modules: sortBySize(modules),
+      chunks: sortBySize(chunks)
+    };
+  } catch {
+    return null;
+  }
+}
+function parseRouteBundleStats(nextDir) {
+  const path = join3(nextDir, "diagnostics", "route-bundle-stats.json");
+  if (!existsSync3(path)) {
+    return { totalBytes: 0, modules: [], chunks: [] };
+  }
+  try {
+    const rows = JSON.parse(readFileSync2(path, "utf8"));
+    const chunks = rows.map((row) => ({
+      name: row.route || "unknown",
+      size: Number(row.firstLoadUncompressedJsBytes || 0),
+      route: row.route
+    }));
+    const totalBytes = Math.max(...chunks.map((c) => c.size), 0);
+    return { totalBytes, modules: [], chunks: sortBySize(chunks) };
+  } catch {
+    return { totalBytes: 0, modules: [], chunks: [] };
+  }
+}
+function parseChunkFallback(nextDir) {
+  const chunksDir = join3(nextDir, "static", "chunks");
+  const chunks = [];
+  if (existsSync3(chunksDir)) {
+    for (const file of walkFiles(chunksDir)) {
+      if (!file.endsWith(".js")) continue;
+      try {
+        const size = statSync2(file).size;
+        const name = file.slice(chunksDir.length + 1);
+        chunks.push({ name, size, route: guessRoute(name) });
+      } catch {
+      }
+    }
+  }
+  for (const manifestName of ["build-manifest.json", "app-build-manifest.json"]) {
+    const manifestPath = join3(nextDir, manifestName);
+    if (!existsSync3(manifestPath)) continue;
+    try {
+      const manifest = JSON.parse(readFileSync2(manifestPath, "utf8"));
+      for (const [route, files] of Object.entries(manifest.pages ?? {})) {
+        for (const file of files) {
+          const abs = join3(nextDir, file.replace(/^\//, ""));
+          if (!existsSync3(abs)) continue;
+          const size = statSync2(abs).size;
+          if (!chunks.some((c) => c.name === file)) {
+            chunks.push({ name: file, size, route });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const totalBytes = chunks.reduce((s, c) => s + c.size, 0);
+  return { totalBytes, modules: [], chunks: sortBySize(chunks) };
+}
+function enrichWithKnownPackages(opts) {
+  const chunksDir = join3(opts.nextDir, "static", "chunks");
+  const serverDir = join3(opts.nextDir, "server");
+  const scanDirs = [chunksDir, serverDir].filter((d) => existsSync3(d));
+  if (scanDirs.length === 0) return [];
+  const present = /* @__PURE__ */ new Set();
+  for (const dir of scanDirs) {
+    for (const file of walkFiles(dir)) {
+      if (!file.endsWith(".js")) continue;
+      let text = "";
+      try {
+        const buf = readFileSync2(file);
+        text = buf.subarray(0, Math.min(buf.length, 2e6)).toString("utf8");
+      } catch {
+        continue;
+      }
+      for (const pkg of KNOWN_HEAVY) {
+        if (text.includes(`node_modules/${pkg}`) || text.includes(`/${pkg}/`) || text.includes(`"${pkg}"`) || text.includes(`'${pkg}'`)) {
+          present.add(pkg);
+        }
+      }
+    }
+  }
+  const modules = [];
+  for (const pkg of present) {
+    const size = estimatePackageChunkSize(scanDirs, pkg);
+    const culpritFile = findImportCulprit(opts.projectDir, pkg) || "unknown";
+    modules.push({
+      name: pkg,
+      size: size || 50 * 1024,
+      culpritFile,
+      chain: [pkg, culpritFile],
+      issuerPath: [pkg, culpritFile],
+      suggestion: opts.withSuggestions ? suggestAlternative(pkg) : null
+    });
+  }
+  return modules;
+}
+function estimatePackageChunkSize(dirs, pkg) {
+  let best = 0;
+  for (const dir of dirs) {
+    for (const file of walkFiles(dir)) {
+      if (!file.endsWith(".js")) continue;
+      try {
+        const buf = readFileSync2(file);
+        const text = buf.subarray(0, Math.min(buf.length, 5e5)).toString("utf8");
+        if (text.includes(pkg)) {
+          best = Math.max(best, statSync2(file).size);
+        }
+      } catch {
+      }
+    }
+  }
+  return best;
+}
+function findImportCulprit(projectDir, pkg) {
+  const roots = ["app", "pages", "src", "components"];
+  for (const root of roots) {
+    const dir = join3(projectDir, root);
+    if (!existsSync3(dir)) continue;
+    const hit = searchImport(dir, pkg, projectDir, 6);
+    if (hit) return hit;
+  }
+  return null;
+}
+function searchImport(dir, pkg, projectDir, depth) {
+  if (depth < 0) return null;
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (entry === "node_modules" || entry.startsWith(".")) continue;
+    const full = join3(dir, entry);
+    let st;
+    try {
+      st = statSync2(full);
+    } catch {
+      continue;
+    }
+    if (st.isDirectory()) {
+      const found = searchImport(full, pkg, projectDir, depth - 1);
+      if (found) return found;
+      continue;
+    }
+    if (!/\.(tsx?|jsx?|mjs|cjs)$/.test(entry)) continue;
+    try {
+      const text = readFileSync2(full, "utf8");
+      if (text.includes(`from '${pkg}'`) || text.includes(`from "${pkg}"`) || text.includes(`require('${pkg}')`) || text.includes(`require("${pkg}")`) || text.includes(`from '${pkg}/`) || text.includes(`from "${pkg}/`)) {
+        return relative(projectDir, full).replace(/\\/g, "/");
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function absorbStats(data, modules, chunks, withSuggestions) {
+  if (!data || typeof data !== "object") return;
+  const root = data;
+  if (Array.isArray(root.chunks)) {
+    for (const chunk of root.chunks) {
+      chunks.push({
+        name: String(chunk.name ?? chunk.id ?? "chunk"),
+        size: Number(chunk.size ?? chunk.parsedSize ?? 0),
+        route: typeof chunk.route === "string" ? chunk.route : void 0
+      });
+    }
+  }
+  const moduleList = [];
+  collectModules(root.modules, moduleList);
+  collectModules(root.tree, moduleList);
+  for (const mod of moduleList) {
+    const size = Number(mod.size ?? mod.gzipSize ?? 0);
+    if (!mod.name || size <= 0) continue;
+    const { culpritFile, chain } = findCulprit(mod);
+    modules.push({
+      name: mod.name,
+      size,
+      issuerPath: chain,
+      culpritFile,
+      chain,
+      suggestion: withSuggestions ? suggestAlternative(mod.name) : null
+    });
+  }
+}
+function collectModules(node, out) {
+  if (!node) return;
+  if (Array.isArray(node)) {
+    for (const item of node) collectModules(item, out);
+    return;
+  }
+  if (typeof node !== "object") return;
+  const obj = node;
+  if (typeof obj.name === "string" && (obj.size != null || obj.gzipSize != null)) {
+    out.push(obj);
+  }
+  if (Array.isArray(obj.children)) collectModules(obj.children, out);
+  if (Array.isArray(obj.modules)) collectModules(obj.modules, out);
+}
+function listJsonFiles(dir) {
+  return walkFiles(dir).filter((f) => f.endsWith(".json"));
+}
+function walkFiles(dir) {
+  const out = [];
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    return out;
+  }
+  for (const entry of entries) {
+    const full = join3(dir, entry);
+    try {
+      const st = statSync2(full);
+      if (st.isDirectory()) out.push(...walkFiles(full));
+      else out.push(full);
+    } catch {
+    }
+  }
+  return out;
+}
+function guessRoute(chunkName) {
+  const match = chunkName.match(/(?:^|\/)app(\/.*)\/(?:page|layout|route)/);
+  if (match?.[1]) return match[1] || "/";
+  return void 0;
+}
+function sortBySize(items) {
+  return [...items].sort((a, b) => b.size - a.size);
+}
+
+// src/uploader.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname, join as join4 } from "path";
+function writeLocalReport(projectDir, report) {
+  const outPaths = [
+    join4(projectDir, "bundle-report.json"),
+    join4(projectDir, ".vercel", "output", "static", "bundle-report.json")
+  ];
+  let primary = outPaths[0];
+  for (const outPath of outPaths) {
+    try {
+      mkdirSync(dirname(outPath), { recursive: true });
+      writeFileSync(outPath, JSON.stringify(report, null, 2));
+      primary = outPath;
+    } catch (error) {
+      console.warn(`[bundle-cop] Could not write ${outPath}:`, error);
+    }
+  }
+  return primary;
+}
+async function uploadReport(report) {
+  const token = process.env.BLOB_READ_WRITE_TOKEN;
+  const sha = report.commitSha || process.env.VERCEL_GIT_COMMIT_SHA || process.env.GITHUB_SHA || "local";
+  if (!token) {
+    console.warn(
+      "[bundle-cop] BLOB_READ_WRITE_TOKEN not set \u2014 skipping Blob upload"
+    );
+    return null;
+  }
+  try {
+    const { put } = await import("@vercel/blob");
+    const pathname = `bundle-reports/${sha}.json`;
+    const result = await put(pathname, JSON.stringify(report), {
+      access: "private",
+      contentType: "application/json",
+      addRandomSuffix: false,
+      allowOverwrite: true,
+      token
+    });
+    console.log(`[bundle-cop] Uploaded report to Blob: ${pathname}`);
+    return result.url;
+  } catch (error) {
+    console.warn("[bundle-cop] Blob upload failed:", error);
+    return null;
+  }
+}
+
+// src/index.ts
+async function runBundleCop(ctx) {
+  const nextDir = findNextDir(ctx.projectDir, ctx.distDir) || join5(ctx.projectDir, ".next");
+  const config = loadConfig(ctx.projectDir);
+  const report = await parseStats({
+    nextDir,
+    projectDir: ctx.projectDir,
+    commitSha: process.env.VERCEL_GIT_COMMIT_SHA || process.env.GITHUB_SHA || null,
+    withSuggestions: config.suggestions !== false
+  });
+  const budgetResults = checkBudgets(report, config);
+  report.budgetResults = budgetResults;
+  writeLocalReport(ctx.projectDir, report);
+  await uploadReport(report);
+  enforceBudgets(budgetResults);
+  console.log(
+    `[bundle-cop] Report total=${report.totalBytes}B modules=${report.modules.length} chunks=${report.chunks.length}`
+  );
+  return report;
+}
+var adapter = {
+  name: "bundle-cop",
+  async modifyConfig(config, ctx) {
+    if (ctx.phase !== "phase-production-build") {
+      return config;
+    }
+    if (!process.env.BUNDLE_COP_ANALYZE) {
+      process.env.BUNDLE_COP_ANALYZE = "1";
+    }
+    const experimental = typeof config.experimental === "object" && config.experimental ? { ...config.experimental } : {};
+    return {
+      ...config,
+      experimental
+    };
+  },
+  async onBuildComplete(ctx) {
+    const started = Date.now();
+    try {
+      await runBundleCop({
+        projectDir: ctx.projectDir || ctx.repoRoot,
+        distDir: ctx.distDir
+      });
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("[bundle-cop] Budget exceeded")) {
+        throw error;
+      }
+      console.warn("[bundle-cop] onBuildComplete error:", error);
+    } finally {
+      console.log(`[bundle-cop] finished in ${Date.now() - started}ms`);
+    }
+  }
+};
+var index_default = adapter;
+export {
+  adapter,
+  checkBudgets,
+  index_default as default,
+  findCulprit,
+  findNextDir,
+  formatBytes,
+  loadConfig,
+  parseSize,
+  parseStats,
+  runBundleCop,
+  suggestAlternative
+};

package/next-adapter.cjs

@@ -0,0 +1,9 @@
+'use strict'
+
+/**
+ * Next.js loads adapters via `import(pathToFileURL(require.resolve(...)))`
+ * and then `interopDefault`. Exporting the adapter object as `module.exports`
+ * (not a namespace with `.default`) makes `onBuildComplete` available.
+ */
+const mod = require('./dist/index.cjs')
+module.exports = mod.adapter || mod.default || mod

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "bundle-cop-vercel-plugin",
+  "version": "0.1.0",
+  "description": "Next.js adapter that attributes bundle cost to source files and enforces budgets",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    },
+    "./adapter": {
+      "types": "./dist/index.d.ts",
+      "require": "./next-adapter.cjs",
+      "import": "./next-adapter.cjs",
+      "default": "./next-adapter.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "next-adapter.cjs",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "pnpm run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "next": ">=15"
+  },
+  "dependencies": {
+    "@vercel/blob": "^2.8.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "next": "^16.3.3",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "nextjs",
+    "vercel",
+    "bundle",
+    "webpack",
+    "turbopack",
+    "adapter",
+    "budget"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eboxnadeem/bundle-cop.git",
+    "directory": "packages/vercel-plugin"
+  },
+  "bugs": {
+    "url": "https://github.com/eboxnadeem/bundle-cop/issues"
+  },
+  "homepage": "https://github.com/eboxnadeem/bundle-cop#readme"
+}