@mintlify/link-rot 3.0.1449 → 3.0.1451

package/dist/graph.d.ts

@@ -1,4 +1,5 @@
 import { ParsedPath } from 'path';
+import type { SnippetReferences } from './static-checking/getSnippetReferences.js';
 declare enum PathType {
     INTERNAL = "internal",
     EXTERNAL = "external",
@@ -78,6 +79,8 @@ export declare class Graph {
     private configRedirects;
     private mintIgnoreGlobs;
     private virtualNodes;
+    /** Snippet imports and renders of every page that parsed, keyed by file. */
+    snippetReferencesByFile: Map<string, SnippetReferences>;
     constructor(baseDir: string, mintIgnoreGlobs?: string[]);
     addNode(label: string): Node;
     addNodes(labels: string[]): void;
@@ -90,9 +93,16 @@ export declare class Graph {
     applyWildcardRedirect(path: string, sourcePattern: string, destinationPattern: string): string;
     addAliasNodes(): void;
     getNode(label: string): Node | undefined;
+    /**
+     * Files whose headings the anchor links in `files` are checked against: each candidate
+     * getHeadingSlugsForPath would try, up to the first one that parsed.
+     */
+    getAnchorTargetFiles(files: Set<string>): Set<string>;
     private addEdge;
     addEdgesBetweenNodes(): void;
     precomputeFileResolutions(): void;
+    /** Files an anchor on `pathString` may be checked against, in the order they are tried. */
+    private getHeadingSlugCandidates;
     private getHeadingSlugsForPath;
     getBrokenInternalLinks(options?: {
         checkAnchors?: boolean;

package/dist/graph.js

@@ -251,6 +251,8 @@ export class Graph {
         this.configRedirects = [];
         this.mintIgnoreGlobs = [];
         this.virtualNodes = new Set();
+        /** Snippet imports and renders of every page that parsed, keyed by file. */
+        this.snippetReferencesByFile = new Map();
         this.baseDir = resolve(baseDir);
         this.mintIgnoreGlobs = mintIgnoreGlobs;
     }
@@ -336,6 +338,34 @@ export class Graph {
     getNode(label) {
         return this.nodes[label];
     }
+    /**
+     * Files whose headings the anchor links in `files` are checked against: each candidate
+     * getHeadingSlugsForPath would try, up to the first one that parsed.
+     */
+    getAnchorTargetFiles(files) {
+        if (this.fileResolutionMap.size === 0) {
+            this.precomputeFileResolutions();
+        }
+        const nodeSet = new Set(Object.keys(this.nodes));
+        const targets = new Set();
+        for (const node of Object.values(this.nodes)) {
+            for (const path of node.paths.flatMap((path) => [path, ...path.pagePaths])) {
+                if (path.pathType !== PathType.INTERNAL || !path.anchorLink)
+                    continue;
+                if (!files.has(join(path.relativeDir, path.filename)))
+                    continue;
+                for (const label of this.getHeadingSlugCandidates(path.toString(), nodeSet)) {
+                    const candidate = this.nodes[label];
+                    if (!candidate)
+                        continue;
+                    targets.add(label);
+                    if (candidate.headingSlugs !== null)
+                        break;
+                }
+            }
+        }
+        return targets;
+    }
     addEdge(source, target, edgeType = EdgeType.CONTENT) {
         const newEdge = new Edge(source, target, edgeType);
         const existingEdge = this.edges.find((edge) => {
@@ -382,24 +412,21 @@ export class Graph {
             });
         });
     }
-    getHeadingSlugsForPath(pathString, nodeSet) {
+    /** Files an anchor on `pathString` may be checked against, in the order they are tried. */
+    getHeadingSlugCandidates(pathString, nodeSet) {
         var _a;
-        const resolvedFiles = this.fileResolutionMap.get(pathString);
-        if (resolvedFiles) {
-            for (const file of resolvedFiles) {
-                if (nodeSet.has(file)) {
-                    const node = this.nodes[file];
-                    if (node && node.headingSlugs !== null)
-                        return node.headingSlugs;
-                }
-            }
+        const resolvedFiles = [...((_a = this.fileResolutionMap.get(pathString)) !== null && _a !== void 0 ? _a : [])].filter((file) => nodeSet.has(file));
+        // join, like node labels, so the index fallback also matches on Windows
+        const indexMdx = join(pathString, 'index.mdx');
+        const indexFile = this.nodes[indexMdx] ? indexMdx : join(pathString, 'index.md');
+        return [...resolvedFiles, pathString, indexFile];
+    }
+    getHeadingSlugsForPath(pathString, nodeSet) {
+        for (const label of this.getHeadingSlugCandidates(pathString, nodeSet)) {
+            const node = this.nodes[label];
+            if (node && node.headingSlugs !== null)
+                return node.headingSlugs;
         }
-        const directNode = this.nodes[pathString];
-        if (directNode && directNode.headingSlugs !== null)
-            return directNode.headingSlugs;
-        const indexNode = (_a = this.nodes[`${pathString}/index.mdx`]) !== null && _a !== void 0 ? _a : this.nodes[`${pathString}/index.md`];
-        if (indexNode && indexNode.headingSlugs !== null)
-            return indexNode.headingSlugs;
         return undefined;
     }
     getBrokenInternalLinks(options) {

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { buildGraph, getBrokenInternalLinks } from './static-checking/getBrokenInternalLinks.js';
 export { getBrokenExternalLinks } from './static-checking/getBrokenExternalLinks.js';
 export type { ExternalLinkResult } from './static-checking/getBrokenExternalLinks.js';
+export { getFilesLinksDependOn } from './static-checking/resolveSnippetLinksFromRenderingPages.js';
 export { getBrokenRedirects } from './static-checking/getBrokenRedirects.js';
 export { renameFilesAndUpdateLinksInContent } from './link-renaming/renameFileAndUpdateLinksInContent.js';

package/dist/index.js

@@ -1,4 +1,5 @@
 export { buildGraph, getBrokenInternalLinks } from './static-checking/getBrokenInternalLinks.js';
 export { getBrokenExternalLinks } from './static-checking/getBrokenExternalLinks.js';
+export { getFilesLinksDependOn } from './static-checking/resolveSnippetLinksFromRenderingPages.js';
 export { getBrokenRedirects } from './static-checking/getBrokenRedirects.js';
 export { renameFilesAndUpdateLinksInContent } from './link-renaming/renameFileAndUpdateLinksInContent.js';

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

@@ -11,6 +11,8 @@ export declare const buildGraph: (repoPath?: string, options?: {
     checkSnippets?: boolean;
     /** SSRF-safe fetch override for hosted spec and overlay URLs; supplied by server environments. */
     fetchRemoteDocument?: (url: string) => Promise<unknown>;
+    /** Report a page that fails to parse and keep scanning; without it the first failure throws. */
+    onParseError?: (filePath: string, error: Error) => void;
 }) => Promise<Graph>;
 export declare const getBrokenInternalLinks: (repoPath?: string, options?: {
     checkAnchors?: boolean;

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, preprocessCustomHeadingIds, remarkComponentIds, remarkExtractTableOfContents, } from '@mintlify/common';
+import { cleanHeadingId, COMPONENTS_WITH_CLEANED_ID, COMPONENTS_WITHOUT_ID, coreRemark, generateParamFieldId, isMintIgnored, preprocessCustomHeadingIds, preprocessMdxFragmentCode, remarkComponentIds, remarkExtractTableOfContents, } from '@mintlify/common';
 import { getMintIgnore } from '@mintlify/prebuild';
 import fs from 'fs-extra';
 import path from 'path';
@@ -90,7 +90,9 @@ export const decorateGraphNodeFromPageContent = (graphNode, content, options) =>
             return tree;
         };
     };
-    const preprocessed = preprocessCustomHeadingIds(content);
+    // Same pre-parse escaping as prebuild, so code fences inside `<MDX>` fragments
+    // (`<project-root>`, `{id}`) aren't read as JSX and the page parses like it renders
+    const preprocessed = preprocessCustomHeadingIds(preprocessMdxFragmentCode(content));
     const processor = coreRemark()
         .use(remarkSmartypants)
         .use(visitLinks)
@@ -159,12 +161,16 @@ export const buildGraph = (repoPath, options) => __awaiter(void 0, void 0, void
                 snippetReferencesByFile.set(filePath, snippetReferences);
             }
             catch (err) {
-                throw new Error(`Syntax error - Unable to parse ${filePath} - ${err}`);
+                const parseError = new Error(`Syntax error - Unable to parse ${filePath} - ${err}`);
+                if (!(options === null || options === void 0 ? void 0 : options.onParseError))
+                    throw parseError;
+                options.onParseError(filePath, parseError);
             }
         }
     });
     yield Promise.all(Array.from({ length: Math.min(BUILD_GRAPH_CONCURRENCY, sitePages.length) }, processNext));
     resolveSnippetLinksFromRenderingPages(graph, snippetReferencesByFile);
+    graph.snippetReferencesByFile = snippetReferencesByFile;
     return graph;
 });
 export const getBrokenInternalLinks = (repoPath, options) => __awaiter(void 0, void 0, void 0, function* () {

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

@@ -1,3 +1,13 @@
 import { Graph } from '../graph.js';
 import type { SnippetReferences } from './getSnippetReferences.js';
 export declare const resolveSnippetLinksFromRenderingPages: (graph: Graph, snippetReferencesByFile: Map<string, SnippetReferences>) => void;
+/**
+ * Files that links in `files` can't be checked without: the pages their anchors point at and the
+ * snippets those pages and `files` render (nested ones too), whose headings and links are merged
+ * into the rendering page. A parse failure in any of these leaves some of those links unchecked.
+ * Paths use `/` separators.
+ */
+export declare const getFilesLinksDependOn: (graph: Graph, files: Set<string>, options: {
+    checkAnchors?: boolean;
+    checkSnippets?: boolean;
+}) => Set<string>;

package/dist/static-checking/resolveSnippetLinksFromRenderingPages.js

@@ -53,3 +53,38 @@ export const resolveSnippetLinksFromRenderingPages = (graph, snippetReferencesBy
         }
     }
 };
+/**
+ * Files that links in `files` can't be checked without: the pages their anchors point at and the
+ * snippets those pages and `files` render (nested ones too), whose headings and links are merged
+ * into the rendering page. A parse failure in any of these leaves some of those links unchecked.
+ * Paths use `/` separators.
+ */
+export const getFilesLinksDependOn = (graph, files, options) => {
+    const dependencies = new Set();
+    if (!options.checkAnchors && !options.checkSnippets)
+        return dependencies;
+    const anchorTargets = options.checkAnchors ? [...graph.getAnchorTargetFiles(files)] : [];
+    for (const file of anchorTargets)
+        dependencies.add(toKey(file));
+    const fileByKey = new Map([...graph.snippetReferencesByFile.keys()].map((file) => [toKey(file), file]));
+    const visited = new Set();
+    const visit = (key) => {
+        var _a, _b;
+        if (visited.has(key))
+            return;
+        visited.add(key);
+        const file = fileByKey.get(key);
+        const rendered = file ? ((_b = (_a = graph.snippetReferencesByFile.get(file)) === null || _a === void 0 ? void 0 : _a.rendered) !== null && _b !== void 0 ? _b : []) : [];
+        for (const source of rendered) {
+            const resolved = resolveImportPath(source, key);
+            if (!resolved)
+                continue;
+            const snippetKey = removeLeadingSlash(resolved);
+            dependencies.add(snippetKey);
+            visit(snippetKey);
+        }
+    };
+    for (const file of [...files, ...anchorTargets])
+        visit(toKey(file));
+    return dependencies;
+};