laxy-verify 1.2.2 → 1.3.0

package/dist/audit/broken-links.js

@@ -1,86 +1,97 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.auditBrokenLinks = auditBrokenLinks;
-const TIMEOUT_MS = 5000;
-const VALID_OK_STATUS = [200, 201, 202, 203, 204, 301, 302, 303, 307, 308];
-function isSuccessStatus(n) {
-    return VALID_OK_STATUS.includes(n);
-}
-async function auditBrokenLinks(crawlResult, baseUrl, abortSignal) {
-    const origin = new URL(baseUrl).origin;
-    const allUrls = [];
-    for (const page of crawlResult.pages) {
-        for (const href of page.internalLinks) {
-            try {
-                const url = new URL(href, baseUrl).href;
-                if (!allUrls.includes(url))
-                    allUrls.push(url);
-            }
-            catch {
-                // skip malformed URLs
-            }
-        }
-    }
-    const uniqueUrls = allUrls;
-    const brokenLinks = [];
-    await Promise.all(uniqueUrls.map(async (url) => {
-        if (abortSignal?.aborted)
-            return;
-        try {
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
-            let status = 0;
-            let statusText = "";
-            try {
-                const res = await fetch(url, {
-                    method: "HEAD",
-                    redirect: "follow",
-                    signal: controller.signal,
-                });
-                status = res.status;
-                statusText = res.statusText;
-            }
-            catch {
-                // Fall back to GET if HEAD is not allowed
-                const controller2 = new AbortController();
-                const timer2 = setTimeout(() => controller2.abort(), TIMEOUT_MS);
-                try {
-                    const res = await fetch(url, {
-                        method: "GET",
-                        redirect: "follow",
-                        signal: controller2.signal,
-                    });
-                    status = res.status;
-                    statusText = res.statusText;
-                }
-                catch {
-                    status = 0;
-                    statusText = "timeout or network error";
-                }
-                clearTimeout(timer2);
-            }
-            clearTimeout(timer);
-            if (!isSuccessStatus(status)) {
-                const severity = status >= 500 ? "critical" : "high";
-                let path = url;
-                try {
-                    path = new URL(url).pathname;
-                }
-                catch { }
-                brokenLinks.push({ url, path, status, statusText, severity });
-            }
-        }
-        catch {
-            // skip
-        }
-    }));
-    const summary = brokenLinks.length === 0
-        ? `All ${uniqueUrls.length} links OK`
-        : `${brokenLinks.length} broken link(s) found`;
-    return {
-        brokenLinks,
-        checkedCount: uniqueUrls.length,
-        hasBrokenLinks: brokenLinks.length > 0,
-        summary,
-    };
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditBrokenLinks = auditBrokenLinks;
+const TIMEOUT_MS = 5000;
+const VALID_OK_STATUS = [200, 201, 202, 203, 204, 301, 302, 303, 307, 308];
+function isSuccessStatus(n) {
+    return VALID_OK_STATUS.includes(n);
+}
+async function auditBrokenLinks(crawlResult, baseUrl, options = {}) {
+    const allUrls = [];
+    if (crawlResult) {
+        for (const page of crawlResult.pages) {
+            for (const href of page.internalLinks) {
+                try {
+                    const url = new URL(href, baseUrl).href;
+                    if (!allUrls.includes(url))
+                        allUrls.push(url);
+                }
+                catch {
+                    // skip malformed URLs
+                }
+            }
+        }
+    }
+    for (const route of options.extraRoutes ?? []) {
+        try {
+            const url = new URL(route, baseUrl).href;
+            if (!allUrls.includes(url))
+                allUrls.push(url);
+        }
+        catch {
+            // skip malformed routes
+        }
+    }
+    const uniqueUrls = allUrls;
+    const brokenLinks = [];
+    await Promise.all(uniqueUrls.map(async (url) => {
+        if (options.abortSignal?.aborted)
+            return;
+        try {
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+            let status = 0;
+            let statusText = "";
+            try {
+                const res = await fetch(url, {
+                    method: "HEAD",
+                    redirect: "follow",
+                    signal: controller.signal,
+                });
+                status = res.status;
+                statusText = res.statusText;
+            }
+            catch {
+                // Fall back to GET if HEAD is not allowed
+                const controller2 = new AbortController();
+                const timer2 = setTimeout(() => controller2.abort(), TIMEOUT_MS);
+                try {
+                    const res = await fetch(url, {
+                        method: "GET",
+                        redirect: "follow",
+                        signal: controller2.signal,
+                    });
+                    status = res.status;
+                    statusText = res.statusText;
+                }
+                catch {
+                    status = 0;
+                    statusText = "timeout or network error";
+                }
+                clearTimeout(timer2);
+            }
+            clearTimeout(timer);
+            if (!isSuccessStatus(status)) {
+                const severity = status >= 500 ? "critical" : "high";
+                let path = url;
+                try {
+                    path = new URL(url).pathname;
+                }
+                catch { }
+                brokenLinks.push({ url, path, status, statusText, severity });
+            }
+        }
+        catch {
+            // skip
+        }
+    }));
+    const summary = brokenLinks.length === 0
+        ? `All ${uniqueUrls.length} links OK`
+        : `${brokenLinks.length} broken link(s) found`;
+    return {
+        brokenLinks,
+        checkedCount: uniqueUrls.length,
+        hasBrokenLinks: brokenLinks.length > 0,
+        summary,
+    };
+}

package/dist/badge.d.ts

@@ -1 +1,2 @@
-export declare function generateBadge(grade: string): string;
+export declare function generateBadge(grade: string): string;
+export declare function generateDynamicBadgeMarkdown(repoId: string, apiUrl: string): string;

package/dist/badge.js

@@ -1,14 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateBadge = generateBadge;
-function generateBadge(grade) {
-    const gradeLower = grade.toLowerCase();
-    const colors = {
-        gold: "yellow",
-        silver: "brightgreen",
-        bronze: "blue",
-        unverified: "lightgrey",
-    };
-    const color = colors[gradeLower] ?? "lightgrey";
-    return `![Laxy Verify: ${grade}](https://img.shields.io/badge/laxy_verify-${gradeLower}-${color})`;
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateBadge = generateBadge;
+exports.generateDynamicBadgeMarkdown = generateDynamicBadgeMarkdown;
+function generateBadge(grade) {
+    const gradeLower = grade.toLowerCase();
+    const colors = {
+        gold: "yellow",
+        silver: "brightgreen",
+        bronze: "blue",
+        unverified: "lightgrey",
+    };
+    const color = colors[gradeLower] ?? "lightgrey";
+    return `![Laxy Verify: ${grade}](https://img.shields.io/badge/laxy_verify-${gradeLower}-${color})`;
+}
+function generateDynamicBadgeMarkdown(repoId, apiUrl) {
+    return `[![Laxy Verify](${apiUrl}/api/badge/${repoId})](${apiUrl})`;
+}

package/dist/bundle-size.d.ts

@@ -0,0 +1,14 @@
+export interface BundleSizeResult {
+    framework: "next" | "vite" | "unknown";
+    firstLoadJsKb: number | null;
+    largestChunkKb: number | null;
+    largestChunkName: string | null;
+    totalAssetsKb: number | null;
+    advisory: string;
+    chunks: Array<{
+        name: string;
+        sizeKb: number;
+    }>;
+    skipped: boolean;
+}
+export declare function runBundleSize(projectDir: string): Promise<BundleSizeResult>;

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,
+    };
+}