@mintlify/link-rot 3.0.1516 → 3.0.1518

package/dist/graph.d.ts

@@ -76,6 +76,7 @@ export declare class Graph {
     private edges;
     private fileResolutionMap;
     private redirectMap;
+    private wildcardRedirects;
     private configRedirects;
     private mintIgnoreGlobs;
     private virtualNodes;
@@ -107,6 +108,12 @@ export declare class Graph {
     getBrokenInternalLinks(options?: {
         checkAnchors?: boolean;
     }): MdxPath[];
+    private getPageCandidates;
+    private isPageRoute;
+    private resolvesToValidPath;
+    private reachesPage;
+    private getExactRedirectTarget;
+    private getRedirectTarget;
     getBrokenRedirects(): {
         source: string;
         destination: string;

package/dist/graph.js

@@ -20,6 +20,7 @@ const decodeUrlComponent = (value) => {
         return value;
     }
 };
+const hasWildcard = (pattern) => /[:*]/.test(pattern);
 export var Wrapper;
 (function (Wrapper) {
     Wrapper["MD"] = "md";
@@ -244,10 +245,11 @@ export class Edge {
 export class Graph {
     constructor(baseDir, mintIgnoreGlobs = []) {
         this.baseDir = baseDir;
-        this.nodes = {};
+        this.nodes = Object.create(null);
         this.edges = [];
         this.fileResolutionMap = new Map();
         this.redirectMap = new Map();
+        this.wildcardRedirects = [];
         this.configRedirects = [];
         this.mintIgnoreGlobs = [];
         this.virtualNodes = new Set();
@@ -277,8 +279,12 @@ export class Graph {
         this.configRedirects = redirects;
         this.redirectMap.clear();
         for (const redirect of redirects) {
-            this.redirectMap.set(normalizePath(redirect.source), normalizePath(redirect.destination));
+            const source = normalizePath(redirect.source);
+            if (!this.redirectMap.has(source)) {
+                this.redirectMap.set(source, normalizePath(redirect.destination));
+            }
         }
+        this.wildcardRedirects = [...this.redirectMap].filter(([source]) => hasWildcard(source));
     }
     matchesWildcardPattern(path, pattern) {
         // Escape special regex characters except : and *
@@ -435,7 +441,6 @@ export class Graph {
         }
         const brokenLinks = new Set();
         const nodeSet = new Set(Object.values(this.nodes).map((node) => node.toString()));
-        const wildcardRedirects = [...this.redirectMap].filter(([source]) => /[:*]/.test(source));
         for (const node of Object.values(this.nodes)) {
             for (const path of node.paths.flatMap((path) => [path, ...path.pagePaths])) {
                 if (path.pathType === PathType.INTERNAL) {
@@ -443,21 +448,7 @@ export class Graph {
                     const resolvedFiles = this.fileResolutionMap.get(pathString);
                     const hasExistingFile = (resolvedFiles && [...resolvedFiles].some((file) => nodeSet.has(file))) ||
                         this.virtualNodes.has(pathString);
-                    let redirectDestination = hasExistingFile ? undefined : this.redirectMap.get(pathString);
-                    let hasValidRedirect = redirectDestination &&
-                        (nodeSet.has(`${redirectDestination}.mdx`) || nodeSet.has(redirectDestination));
-                    if (!hasExistingFile && !hasValidRedirect) {
-                        for (const [sourcePattern, destinationPattern] of wildcardRedirects) {
-                            if (this.matchesWildcardPattern(pathString, sourcePattern)) {
-                                redirectDestination = this.applyWildcardRedirect(pathString, sourcePattern, destinationPattern);
-                                hasValidRedirect =
-                                    nodeSet.has(`${redirectDestination}.mdx`) || nodeSet.has(redirectDestination);
-                                if (hasValidRedirect)
-                                    break;
-                            }
-                        }
-                    }
-                    if (!hasExistingFile && !hasValidRedirect) {
+                    if (!hasExistingFile && !this.reachesPage(pathString)) {
                         brokenLinks.add(path);
                     }
                     else if ((options === null || options === void 0 ? void 0 : options.checkAnchors) && path.anchorLink) {
@@ -476,58 +467,75 @@ export class Graph {
             (path.pagePaths.length === 0 ||
                 path.pagePaths.some((pagePath) => brokenLinks.has(pagePath))));
     }
-    getBrokenRedirects() {
-        const nodeSet = new Set(Object.values(this.nodes).map((node) => node.toString()));
-        const hasWildcard = (pattern) => /[:*]/.test(pattern);
-        const resolvesToValidPath = (rawDestination, visited) => {
-            if (URL.canParse(rawDestination))
-                return true;
-            const pathOnly = removeSelectors(rawDestination);
-            if (!pathOnly)
-                return true;
-            // Wildcard path destinations can't be validated as concrete paths — treat as valid,
-            // matching the top-level skip semantics. Checked after stripping so `:` or `*` in
-            // the fragment/query doesn't cause a false skip.
-            if (hasWildcard(pathOnly))
-                return true;
-            const normalized = normalizePath(pathOnly);
-            if (visited.has(normalized))
-                return false;
-            visited.add(normalized);
-            // normalizePath('/') yields '.' — resolve lookups against node labels (which use
-            // path.join, so `join('.', 'index.mdx') === 'index.mdx'`) rather than naive
-            // string concatenation that would produce './index.mdx' and never match.
-            const fileCandidates = normalized === '.'
-                ? ['index.mdx', 'index.md']
-                : [
-                    normalized,
-                    `${normalized}.mdx`,
-                    `${normalized}.md`,
-                    join(normalized, 'index.mdx'),
-                    join(normalized, 'index.md'),
-                ];
-            if (fileCandidates.some((candidate) => nodeSet.has(candidate)) ||
-                this.virtualNodes.has(normalized)) {
-                return true;
-            }
-            const chained = this.redirectMap.get(normalized);
-            if (chained !== undefined)
-                return resolvesToValidPath(chained, visited);
-            for (const [sourcePattern, destinationPattern] of this.redirectMap.entries()) {
-                if (hasWildcard(sourcePattern) && this.matchesWildcardPattern(normalized, sourcePattern)) {
-                    const resolved = this.applyWildcardRedirect(normalized, sourcePattern, destinationPattern);
-                    return resolvesToValidPath(resolved, visited);
-                }
-            }
+    getPageCandidates(normalized) {
+        // normalizePath('/') yields '.' — resolve lookups against node labels (which use
+        // path.join, so `join('.', 'index.mdx') === 'index.mdx'`) rather than naive
+        // string concatenation that would produce './index.mdx' and never match.
+        return normalized === '.'
+            ? ['index.mdx', 'index.md']
+            : [
+                `${normalized}.mdx`,
+                `${normalized}.md`,
+                join(normalized, 'index.mdx'),
+                join(normalized, 'index.md'),
+            ];
+    }
+    isPageRoute(normalized) {
+        return (this.getPageCandidates(normalized).some((candidate) => this.nodes[candidate]) ||
+            this.virtualNodes.has(normalized));
+    }
+    resolvesToValidPath(rawDestination, visited = new Set()) {
+        if (URL.canParse(rawDestination))
+            return true;
+        const pathOnly = removeSelectors(rawDestination);
+        if (!pathOnly)
+            return true;
+        // Wildcard path destinations can't be validated as concrete paths — treat as valid,
+        // matching the top-level skip semantics. Checked after stripping so `:` or `*` in
+        // the fragment/query doesn't cause a false skip.
+        if (hasWildcard(pathOnly))
+            return true;
+        return this.reachesPage(normalizePath(pathOnly), visited);
+    }
+    reachesPage(normalized, visited = new Set()) {
+        if (visited.has(normalized))
             return false;
-        };
+        visited.add(normalized);
+        const exact = this.getExactRedirectTarget(normalized);
+        if (exact !== undefined)
+            return this.resolvesToValidPath(exact, visited);
+        if ((normalized !== '.' && this.nodes[normalized]) || this.isPageRoute(normalized))
+            return true;
+        const redirected = this.getRedirectTarget(normalized);
+        return redirected !== undefined && this.resolvesToValidPath(redirected, visited);
+    }
+    getExactRedirectTarget(normalized) {
+        return this.redirectMap.get(normalized);
+    }
+    getRedirectTarget(normalized) {
+        const exact = this.getExactRedirectTarget(normalized);
+        if (exact !== undefined)
+            return exact;
+        for (const [sourcePattern, destinationPattern] of this.wildcardRedirects) {
+            if (this.matchesWildcardPattern(normalized, sourcePattern)) {
+                return this.applyWildcardRedirect(normalized, sourcePattern, destinationPattern);
+            }
+        }
+        return undefined;
+    }
+    getBrokenRedirects() {
         const broken = [];
+        const seenSources = new Set();
         for (const { source, destination } of this.configRedirects) {
+            const sourcePath = normalizePath(source);
+            if (seenSources.has(sourcePath))
+                continue;
+            seenSources.add(sourcePath);
             if (URL.canParse(destination))
                 continue;
             if (hasWildcard(removeSelectors(destination)))
                 continue;
-            if (!resolvesToValidPath(destination, new Set())) {
+            if (!this.resolvesToValidPath(destination)) {
                 broken.push({ source, destination });
             }
         }

package/dist/static-checking/getNavigationHrefs.js

@@ -7,7 +7,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { parseGraphqlSelector, potentiallyParseOpenApiString } from '@mintlify/common';
 import { readResolvedConfigJson } from './readConfig.js';
+const isPagePath = (entry) => typeof entry === 'string' &&
+    entry !== '' &&
+    potentiallyParseOpenApiString(entry) === undefined &&
+    parseGraphqlSelector(entry) === undefined;
 const collectHrefs = (obj) => {
     if (typeof obj !== 'object' || obj === null)
         return [];
@@ -18,6 +23,15 @@ const collectHrefs = (obj) => {
     if (typeof record.href === 'string') {
         hrefs.push(record.href);
     }
+    if (isPagePath(record.root)) {
+        hrefs.push(record.root.startsWith('/') ? record.root : `/${record.root}`);
+    }
+    if (Array.isArray(record.pages)) {
+        for (const entry of record.pages) {
+            if (isPagePath(entry))
+                hrefs.push(entry.startsWith('/') ? entry : `/${entry}`);
+        }
+    }
     for (const value of Object.values(record)) {
         hrefs.push(...collectHrefs(value));
     }