@mintlify/link-rot 3.0.910 → 3.0.912

package/dist/graph.d.ts

@@ -88,6 +88,7 @@ export declare class Graph {
     getBrokenInternalLinks(options?: {
         checkAnchors?: boolean;
     }): MdxPath[];
+    getExternalPathsByNode(): Map<string, MdxPath[]>;
     getAllInternalPaths(): string[];
 }
 export {};

package/dist/graph.js

@@ -402,6 +402,16 @@ export class Graph {
         }
         return brokenLinks;
     }
+    getExternalPathsByNode() {
+        const result = new Map();
+        for (const [label, node] of Object.entries(this.nodes)) {
+            const externalPaths = node.paths.filter((p) => p.pathType === PathType.EXTERNAL);
+            if (externalPaths.length > 0) {
+                result.set(label, externalPaths);
+            }
+        }
+        return result;
+    }
     // DEBUGGING
     getAllInternalPaths() {
         return Object.values(this.nodes)

package/dist/index.d.ts

@@ -1,2 +1,4 @@
-export { getBrokenInternalLinks } from './static-checking/getBrokenInternalLinks.js';
+export { buildGraph, getBrokenInternalLinks } from './static-checking/getBrokenInternalLinks.js';
+export { getBrokenExternalLinks } from './static-checking/getBrokenExternalLinks.js';
+export type { ExternalLinkResult } from './static-checking/getBrokenExternalLinks.js';
 export { renameFilesAndUpdateLinksInContent } from './link-renaming/renameFileAndUpdateLinksInContent.js';

package/dist/index.js

@@ -1,2 +1,3 @@
-export { getBrokenInternalLinks } from './static-checking/getBrokenInternalLinks.js';
+export { buildGraph, getBrokenInternalLinks } from './static-checking/getBrokenInternalLinks.js';
+export { getBrokenExternalLinks } from './static-checking/getBrokenExternalLinks.js';
 export { renameFilesAndUpdateLinksInContent } from './link-renaming/renameFileAndUpdateLinksInContent.js';

package/dist/static-checking/getBrokenExternalLinks.d.ts

@@ -0,0 +1,11 @@
+import type { Graph } from '../graph.js';
+export type ExternalLinkResult = {
+    url: string;
+    status: number | null;
+    error?: string;
+    sources: Array<{
+        file: string;
+        originalPath: string;
+    }>;
+};
+export declare const getBrokenExternalLinks: (graph: Graph) => Promise<ExternalLinkResult[]>;

package/dist/static-checking/getBrokenExternalLinks.js

@@ -0,0 +1,92 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const CONCURRENCY = 5;
+const TIMEOUT_MS = 10000;
+const USER_AGENT = 'Mintlify-LinkChecker/1.0';
+const isHttpUrl = (url) => {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+    }
+    catch (_a) {
+        return false;
+    }
+};
+const checkExternalUrl = (url) => __awaiter(void 0, void 0, void 0, function* () {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    try {
+        const response = yield fetch(url, {
+            method: 'HEAD',
+            signal: controller.signal,
+            headers: { 'User-Agent': USER_AGENT },
+            redirect: 'follow',
+        });
+        clearTimeout(timeoutId);
+        return {
+            ok: response.status !== 404,
+            status: response.status,
+        };
+    }
+    catch (err) {
+        clearTimeout(timeoutId);
+        return {
+            ok: false,
+            status: null,
+            error: err instanceof Error ? err.message : 'unknown error',
+        };
+    }
+});
+const pMap = (items, fn, concurrency) => __awaiter(void 0, void 0, void 0, function* () {
+    const results = [];
+    let index = 0;
+    const run = () => __awaiter(void 0, void 0, void 0, function* () {
+        while (index < items.length) {
+            const currentIndex = index++;
+            results[currentIndex] = yield fn(items[currentIndex]);
+        }
+    });
+    const workers = Array.from({ length: Math.min(concurrency, items.length) }, () => run());
+    yield Promise.all(workers);
+    return results;
+});
+export const getBrokenExternalLinks = (graph) => __awaiter(void 0, void 0, void 0, function* () {
+    const urlSourceMap = new Map();
+    for (const [nodeLabel, externalPaths] of graph.getExternalPathsByNode()) {
+        for (const mdxPath of externalPaths) {
+            if (isHttpUrl(mdxPath.originalPath)) {
+                const url = mdxPath.originalPath;
+                const existing = urlSourceMap.get(url);
+                const source = { file: nodeLabel, originalPath: mdxPath.originalPath };
+                if (existing) {
+                    existing.push(source);
+                }
+                else {
+                    urlSourceMap.set(url, [source]);
+                }
+            }
+        }
+    }
+    const uniqueUrls = [...urlSourceMap.keys()];
+    const results = yield pMap(uniqueUrls, (url) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield checkExternalUrl(url);
+        if (result.ok)
+            return null;
+        const entry = {
+            url,
+            status: result.status,
+            sources: urlSourceMap.get(url),
+        };
+        if (result.error)
+            entry.error = result.error;
+        return entry;
+    }), CONCURRENCY);
+    return results.filter((r) => r !== null);
+});

package/dist/static-checking/getBrokenInternalLinks.d.ts

@@ -1,14 +1,15 @@
 import type { TableOfContentsSectionType } from '@mintlify/common';
 import type { Root } from 'mdast';
-import { Node } from '../graph.js';
+import { Graph, Node } from '../graph.js';
 export declare const flattenTableOfContentsSlugs: (sections: TableOfContentsSectionType[]) => Set<string>;
 export declare const extractComponentAnchorIds: (tree: Root) => Set<string>;
-export declare const decorateGraphNodeFromPageContent: (graphNode: Node, content: string) => Promise<void>;
-/**
- * Get all broken internal links used in the site
- * Files matching .mintignore patterns are excluded from valid link targets,
- * so links pointing to ignored files will be reported as broken.
- */
+export declare const decorateGraphNodeFromPageContent: (graphNode: Node, content: string, options?: {
+    checkSnippets?: boolean;
+}) => Promise<void>;
+export declare const buildGraph: (repoPath?: string, options?: {
+    checkSnippets?: boolean;
+}) => Promise<Graph>;
 export declare const getBrokenInternalLinks: (repoPath?: string, options?: {
     checkAnchors?: boolean;
+    checkSnippets?: boolean;
 }) => Promise<import("../graph.js").MdxPath[]>;

package/dist/static-checking/getBrokenInternalLinks.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { cleanHeadingId, COMPONENTS_WITH_CLEANED_ID, COMPONENTS_WITHOUT_ID, coreRemark, generateParamFieldId, isMintIgnored, remarkComponentIds, remarkExtractTableOfContents, } from '@mintlify/common';
+import { cleanHeadingId, COMPONENTS_WITH_CLEANED_ID, COMPONENTS_WITHOUT_ID, coreRemark, extractImportSources, generateParamFieldId, isMintIgnored, remarkComponentIds, remarkExtractTableOfContents, } from '@mintlify/common';
 import { getMintIgnore } from '@mintlify/prebuild';
 import fs from 'fs-extra';
 import path from 'path';
@@ -56,16 +56,18 @@ export const extractComponentAnchorIds = (tree) => {
     });
     return ids;
 };
-export const decorateGraphNodeFromPageContent = (graphNode, content) => __awaiter(void 0, void 0, void 0, function* () {
+export const decorateGraphNodeFromPageContent = (graphNode, content, options) => __awaiter(void 0, void 0, void 0, function* () {
     const mdxExtracts = {};
     const visitLinks = () => {
         return (tree) => {
+            if (options === null || options === void 0 ? void 0 : options.checkSnippets) {
+                for (const source of extractImportSources(tree)) {
+                    graphNode.addPath(source);
+                }
+            }
             visit(tree, (node) => {
                 var _a, _b;
-                if (
-                // ![]() format
-                node.type === 'link' ||
-                    node.type === 'image') {
+                if (node.type === 'link' || node.type === 'image') {
                     graphNode.addPath(node.url, Wrapper.MD);
                     return;
                 }
@@ -102,25 +104,16 @@ export const decorateGraphNodeFromPageContent = (graphNode, content) => __awaite
     const componentIds = extractComponentAnchorIds(tree);
     graphNode.headingSlugs = new Set([...tocSlugs, ...componentIds]);
 });
-/**
- * Get all broken internal links used in the site
- * Files matching .mintignore patterns are excluded from valid link targets,
- * so links pointing to ignored files will be reported as broken.
- */
-export const getBrokenInternalLinks = (repoPath, options) => __awaiter(void 0, void 0, void 0, function* () {
+export const buildGraph = (repoPath, options) => __awaiter(void 0, void 0, void 0, function* () {
     const baseDir = repoPath ? repoPath : process.cwd();
     const mintIgnoreGlobs = yield getMintIgnore(baseDir);
     const graph = new Graph(baseDir, mintIgnoreGlobs);
-    // add nodes for every page or media path in project (excluding mintignore'd files)
     const allFilenames = getLinkPaths(baseDir);
     const filenames = allFilenames.filter((file) => !isMintIgnored(file, mintIgnoreGlobs));
     graph.addNodes(filenames);
-    // pull redirects from docs.json or mint.json if either exist
     const redirectMappings = yield getRedirects(baseDir);
     graph.setRedirects(redirectMappings);
-    // add nodes for every link alias in the project
     graph.addAliasNodes();
-    // add virtual nodes for OpenAPI-generated pages
     try {
         const openApiPagePaths = yield getOpenApiPagePaths(baseDir);
         graph.addVirtualNodes(openApiPagePaths);
@@ -143,14 +136,21 @@ export const getBrokenInternalLinks = (repoPath, options) => __awaiter(void 0, v
         if (fileNode) {
             const fileContent = fs.readFileSync(path.join(baseDir, filePath)).toString();
             try {
-                yield decorateGraphNodeFromPageContent(fileNode, fileContent);
+                yield decorateGraphNodeFromPageContent(fileNode, fileContent, {
+                    checkSnippets: options === null || options === void 0 ? void 0 : options.checkSnippets,
+                });
             }
             catch (err) {
                 throw new Error(`Syntax error - Unable to parse ${filePath} - ${err}`);
             }
         }
     })));
-    // Precompute file resolutions before checking for broken links
+    return graph;
+});
+export const getBrokenInternalLinks = (repoPath, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const graph = yield buildGraph(repoPath, {
+        checkSnippets: options === null || options === void 0 ? void 0 : options.checkSnippets,
+    });
     graph.precomputeFileResolutions();
     return graph.getBrokenInternalLinks(options);
 });