@mintlify/link-rot 3.0.1038 → 3.0.1040

package/dist/graph.d.ts

@@ -67,6 +67,7 @@ export declare class Graph {
     private edges;
     private fileResolutionMap;
     private redirectMap;
+    private configRedirects;
     private mintIgnoreGlobs;
     private virtualNodes;
     constructor(baseDir: string, mintIgnoreGlobs?: string[]);
@@ -88,6 +89,10 @@ export declare class Graph {
     getBrokenInternalLinks(options?: {
         checkAnchors?: boolean;
     }): MdxPath[];
+    getBrokenRedirects(): {
+        source: string;
+        destination: string;
+    }[];
     getExternalPathsByNode(): Map<string, MdxPath[]>;
     getAllInternalPaths(): string[];
 }

package/dist/graph.js

@@ -3,7 +3,7 @@ import { getFileListWithDirectories } from '@mintlify/prebuild';
 import { existsSync } from 'fs';
 import { parse, join, resolve, relative, dirname, basename } from 'path';
 import { sep as WINDOWS_SEPARATOR } from 'path/win32';
-import { getLinkPaths, normalizePath } from './prebuild.js';
+import { getLinkPaths, normalizePath, removeSelectors } from './prebuild.js';
 var PathType;
 (function (PathType) {
     PathType["INTERNAL"] = "internal";
@@ -216,6 +216,7 @@ export class Graph {
         this.edges = [];
         this.fileResolutionMap = new Map();
         this.redirectMap = new Map();
+        this.configRedirects = [];
         this.mintIgnoreGlobs = [];
         this.virtualNodes = new Set();
         this.baseDir = resolve(baseDir);
@@ -239,6 +240,8 @@ export class Graph {
         }
     }
     setRedirects(redirects) {
+        this.configRedirects = redirects;
+        this.redirectMap.clear();
         for (const redirect of redirects) {
             this.redirectMap.set(normalizePath(redirect.source), normalizePath(redirect.destination));
         }
@@ -404,6 +407,63 @@ export class Graph {
         }
         return brokenLinks;
     }
+    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);
+                }
+            }
+            return false;
+        };
+        const broken = [];
+        for (const { source, destination } of this.configRedirects) {
+            if (URL.canParse(destination))
+                continue;
+            if (hasWildcard(removeSelectors(destination)))
+                continue;
+            if (!resolvesToValidPath(destination, new Set())) {
+                broken.push({ source, destination });
+            }
+        }
+        return broken;
+    }
     getExternalPathsByNode() {
         const result = new Map();
         for (const [label, node] of Object.entries(this.nodes)) {

package/dist/index.d.ts

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

package/dist/index.js

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

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

@@ -0,0 +1,6 @@
+export declare const getBrokenRedirects: (repoPath?: string, options?: {
+    checkSnippets?: boolean;
+}) => Promise<{
+    source: string;
+    destination: string;
+}[]>;

package/dist/static-checking/getBrokenRedirects.js

@@ -0,0 +1,16 @@
+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());
+    });
+};
+import { buildGraph } from './getBrokenInternalLinks.js';
+export const getBrokenRedirects = (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,
+    });
+    return graph.getBrokenRedirects();
+});