laxy-verify 1.2.2 → 1.2.3

package/dist/bundle-size.js

@@ -0,0 +1,209 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBundleSize = runBundleSize;
+/**
+ * Bundle size analysis.
+ *
+ * Parses Next.js and Vite build output to report first-load JS and
+ * largest chunk sizes. Advisory-only — does not block deployment.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const DEFAULT_FIRST_LOAD_THRESHOLD_KB = 200;
+const DEFAULT_LARGEST_CHUNK_THRESHOLD_KB = 300;
+function parseNextBuildOutput(projectDir) {
+    // Next.js stores build output in .next/build-manifest.json and .next/routes-manifest.json
+    // The most reliable source is .next/build-manifest.json for pages and their chunks
+    const buildManifestPath = path.join(projectDir, ".next", "build-manifest.json");
+    if (!fs.existsSync(buildManifestPath))
+        return null;
+    try {
+        const manifest = JSON.parse(fs.readFileSync(buildManifestPath, "utf-8"));
+        // Collect all chunk files referenced in the manifest
+        const allChunks = new Set();
+        const pages = manifest.pages ?? {};
+        for (const pageChunks of Object.values(pages)) {
+            if (Array.isArray(pageChunks)) {
+                for (const chunk of pageChunks) {
+                    allChunks.add(chunk);
+                }
+            }
+        }
+        // Measure chunk sizes from .next/static
+        const chunks = [];
+        for (const chunkPath of allChunks) {
+            const fullPath = path.join(projectDir, ".next", chunkPath);
+            if (!fs.existsSync(fullPath))
+                continue;
+            try {
+                const stat = fs.statSync(fullPath);
+                const name = path.basename(chunkPath);
+                chunks.push({ name, sizeKb: Math.round(stat.size / 1024) });
+            }
+            catch {
+                // skip unreadable files
+            }
+        }
+        if (chunks.length === 0)
+            return null;
+        // Sort by size descending
+        chunks.sort((a, b) => b.sizeKb - a.sizeKb);
+        const largest = chunks[0];
+        const totalAssetsKb = chunks.reduce((sum, c) => sum + c.sizeKb, 0);
+        // First-load JS: sum of all chunks for the "/" page (usually _app + _buildManifest + page chunk)
+        const homeChunks = pages["/"] ?? pages["/index"] ?? [];
+        const sharedChunks = pages["/_app"] ?? [];
+        const firstLoadFiles = [...homeChunks, ...sharedChunks];
+        let firstLoadJsKb = 0;
+        for (const chunkPath of firstLoadFiles) {
+            const fullPath = path.join(projectDir, ".next", chunkPath);
+            try {
+                if (fs.existsSync(fullPath)) {
+                    firstLoadJsKb += Math.round(fs.statSync(fullPath).size / 1024);
+                }
+            }
+            catch {
+                // skip
+            }
+        }
+        const advisory = buildAdvisory(firstLoadJsKb, largest.sizeKb, largest.name);
+        return {
+            framework: "next",
+            firstLoadJsKb: firstLoadJsKb || null,
+            largestChunkKb: largest.sizeKb,
+            largestChunkName: largest.name,
+            totalAssetsKb,
+            advisory,
+            chunks: chunks.slice(0, 10),
+            skipped: false,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseViteBuildOutput(projectDir) {
+    // Vite outputs to dist/ by default, manifest in .vite/manifest.json or dist/.vite/manifest.json
+    const distDir = path.join(projectDir, "dist");
+    if (!fs.existsSync(distDir))
+        return null;
+    const chunks = [];
+    function walkDist(dir) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walkDist(fullPath);
+            }
+            else if (entry.isFile() && /\.(js|mjs|css)$/.test(entry.name)) {
+                try {
+                    const stat = fs.statSync(fullPath);
+                    const relativePath = path.relative(distDir, fullPath).replace(/\\/g, "/");
+                    chunks.push({ name: relativePath, sizeKb: Math.round(stat.size / 1024) });
+                }
+                catch {
+                    // skip
+                }
+            }
+        }
+    }
+    walkDist(distDir);
+    if (chunks.length === 0)
+        return null;
+    chunks.sort((a, b) => b.sizeKb - a.sizeKb);
+    const largest = chunks[0];
+    const totalAssetsKb = chunks.reduce((sum, c) => sum + c.sizeKb, 0);
+    // First-load: index.html + referenced JS
+    const indexJsChunks = chunks.filter((c) => c.name.startsWith("assets/") && c.name.includes("index"));
+    const firstLoadJsKb = indexJsChunks.length > 0
+        ? indexJsChunks.reduce((sum, c) => sum + c.sizeKb, 0)
+        : null;
+    const advisory = buildAdvisory(firstLoadJsKb, largest.sizeKb, largest.name);
+    return {
+        framework: "vite",
+        firstLoadJsKb,
+        largestChunkKb: largest.sizeKb,
+        largestChunkName: largest.name,
+        totalAssetsKb,
+        advisory,
+        chunks: chunks.slice(0, 10),
+        skipped: false,
+    };
+}
+function buildAdvisory(firstLoadKb, largestKb, largestName) {
+    const parts = [];
+    if (firstLoadKb !== null && firstLoadKb > DEFAULT_FIRST_LOAD_THRESHOLD_KB) {
+        parts.push(`first-load JS ${firstLoadKb}KB exceeds ${DEFAULT_FIRST_LOAD_THRESHOLD_KB}KB advisory threshold`);
+    }
+    if (largestKb > DEFAULT_LARGEST_CHUNK_THRESHOLD_KB) {
+        parts.push(`largest chunk ${largestName} is ${largestKb}KB (>${DEFAULT_LARGEST_CHUNK_THRESHOLD_KB}KB advisory)`);
+    }
+    if (parts.length === 0) {
+        const firstLoadNote = firstLoadKb !== null ? `first-load ${firstLoadKb}KB, ` : "";
+        return `${firstLoadNote}largest chunk ${largestName} ${largestKb}KB — within advisory thresholds`;
+    }
+    return parts.join("; ");
+}
+async function runBundleSize(projectDir) {
+    console.log("  Running bundle size analysis...");
+    const nextResult = parseNextBuildOutput(projectDir);
+    if (nextResult) {
+        console.log(`  Bundle (Next.js): ${nextResult.advisory}`);
+        return nextResult;
+    }
+    const viteResult = parseViteBuildOutput(projectDir);
+    if (viteResult) {
+        console.log(`  Bundle (Vite): ${viteResult.advisory}`);
+        return viteResult;
+    }
+    console.log("  Bundle size: skipped (no .next or dist directory found)");
+    return {
+        framework: "unknown",
+        firstLoadJsKb: null,
+        largestChunkKb: null,
+        largestChunkName: null,
+        totalAssetsKb: null,
+        advisory: "No build output found for bundle analysis",
+        chunks: [],
+        skipped: true,
+    };
+}