@mintlify/link-rot 3.0.1440 → 3.0.1441

package/dist/graph.d.ts

@@ -33,10 +33,16 @@ export declare class MdxPath {
     private constructParsedPath;
     constructor(originalPath: string, relativeDir?: string, filename?: string, wrapper?: Wrapper | undefined);
     toString(): string;
-    getResolvedFiles(allFiles: string[], baseDir: string): string[];
-    resolvesTo(node: Node, allFiles: string[], baseDir: string): boolean;
+    getResolvedFiles(fileIndex: FileIndex, baseDir: string): string[];
+    resolvesTo(node: Node, fileIndex: FileIndex, baseDir: string): boolean;
     static filterMapInternalPaths(paths: string[]): string[];
 }
+export declare class FileIndex {
+    private byDirAndName;
+    constructor(allFiles: string[]);
+    private static key;
+    lookup(dir: string, name: string, base: string): string[];
+}
 export declare class Node {
     label: string;
     paths: MdxPath[];

package/dist/graph.js

@@ -119,34 +119,25 @@ export class MdxPath {
         }
         return this.path.toString();
     }
-    getResolvedFiles(allFiles, baseDir) {
-        if (this.pathType !== PathType.INTERNAL)
+    getResolvedFiles(fileIndex, baseDir) {
+        if (this.pathType !== PathType.INTERNAL || this.path instanceof URL)
             return [];
-        const parsedPath = this.path;
+        const { dir, name, base } = parse(this.toString());
         const resolvedFiles = [];
         if (existsSync(resolve(baseDir, this.toString()))) {
-            resolvedFiles.push(join(parsedPath.dir, parsedPath.base));
+            resolvedFiles.push(join(dir, base));
         }
         // there may be multiple files/folders corresponding to the node
-        for (const file of allFiles) {
-            const fileWithoutLeadingSlash = file.startsWith('/') ? file.slice(1) : file;
-            const parsedFilePath = parse(fileWithoutLeadingSlash);
-            if (parsedFilePath.dir === parsedPath.dir && parsedFilePath.name === parsedPath.name) {
-                resolvedFiles.push(fileWithoutLeadingSlash);
-            }
-            if (parsedFilePath.dir === parsedPath.dir && parsedPath.base === parsedFilePath.name) {
-                // account for edge case when there is another . in the filename
-                resolvedFiles.push(fileWithoutLeadingSlash);
-            }
-        }
+        // account for edge case when there is another . in the filename
+        resolvedFiles.push(...fileIndex.lookup(dir, name, base));
         return resolvedFiles;
     }
-    resolvesTo(node, allFiles, baseDir) {
+    resolvesTo(node, fileIndex, baseDir) {
         if (this.pathType !== PathType.INTERNAL)
             return false;
         if (this.toString() === node.toString())
             return true;
-        if (this.getResolvedFiles(allFiles, baseDir).includes(node.toString()))
+        if (this.getResolvedFiles(fileIndex, baseDir).includes(node.toString()))
             return true;
         return false;
     }
@@ -157,6 +148,31 @@ export class MdxPath {
             .map((path) => path.toString());
     }
 }
+export class FileIndex {
+    constructor(allFiles) {
+        this.byDirAndName = new Map();
+        allFiles.forEach((file, order) => {
+            const fileWithoutLeadingSlash = file.startsWith('/') ? file.slice(1) : file;
+            const { dir, name } = parse(fileWithoutLeadingSlash);
+            const key = FileIndex.key(dir, name);
+            const entry = [order, fileWithoutLeadingSlash];
+            const bucket = this.byDirAndName.get(key);
+            if (bucket)
+                bucket.push(entry);
+            else
+                this.byDirAndName.set(key, [entry]);
+        });
+    }
+    static key(dir, name) {
+        return `${dir}\0${name}`;
+    }
+    lookup(dir, name, base) {
+        var _a, _b;
+        const byName = (_a = this.byDirAndName.get(FileIndex.key(dir, name))) !== null && _a !== void 0 ? _a : [];
+        const byBase = base === name ? [] : ((_b = this.byDirAndName.get(FileIndex.key(dir, base))) !== null && _b !== void 0 ? _b : []);
+        return [...byName, ...byBase].sort(([a], [b]) => a - b).map(([, file]) => file);
+    }
+}
 /*
  * A node is a representation of a page
  * One node can contain multiple MdxPaths (corresponding to internal/external links in the page)
@@ -333,11 +349,11 @@ export class Graph {
         return newEdge;
     }
     addEdgesBetweenNodes() {
-        const allFiles = getLinkPaths(this.baseDir, this.mintIgnoreGlobs);
+        const fileIndex = new FileIndex(getLinkPaths(this.baseDir, this.mintIgnoreGlobs));
         for (const node of Object.values(this.nodes)) {
             for (const path of node.paths) {
                 if (path.pathType === PathType.INTERNAL) {
-                    const targetNode = Object.values(this.nodes).find((otherNode) => path.resolvesTo(otherNode, allFiles, this.baseDir));
+                    const targetNode = Object.values(this.nodes).find((otherNode) => path.resolvesTo(otherNode, fileIndex, this.baseDir));
                     if (targetNode) {
                         const edge = this.addEdge(node, targetNode);
                         node.addOutgoingEdge(edge);
@@ -347,14 +363,18 @@ export class Graph {
         }
     }
     precomputeFileResolutions() {
-        const allFiles = getLinkPaths(this.baseDir, this.mintIgnoreGlobs);
+        const fileIndex = new FileIndex(getLinkPaths(this.baseDir, this.mintIgnoreGlobs));
+        const resolvedKeys = new Set();
         // Build resolution map for all internal paths
         Object.values(this.nodes).forEach((node) => {
             node.paths
                 .filter((path) => path.pathType === PathType.INTERNAL)
                 .forEach((path) => {
-                const resolvedFiles = path.getResolvedFiles(allFiles, this.baseDir);
                 const pathKey = path.toString();
+                if (resolvedKeys.has(pathKey))
+                    return;
+                resolvedKeys.add(pathKey);
+                const resolvedFiles = path.getResolvedFiles(fileIndex, this.baseDir);
                 this.fileResolutionMap.set(pathKey, new Set(resolvedFiles));
             });
         });
@@ -385,6 +405,7 @@ export class Graph {
         }
         const brokenLinks = [];
         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) {
                 if (path.pathType === PathType.INTERNAL) {
@@ -392,11 +413,11 @@ export class Graph {
                     const resolvedFiles = this.fileResolutionMap.get(pathString);
                     const hasExistingFile = (resolvedFiles && [...resolvedFiles].some((file) => nodeSet.has(file))) ||
                         this.virtualNodes.has(pathString);
-                    let redirectDestination = this.redirectMap.get(pathString);
+                    let redirectDestination = hasExistingFile ? undefined : this.redirectMap.get(pathString);
                     let hasValidRedirect = redirectDestination &&
                         (nodeSet.has(`${redirectDestination}.mdx`) || nodeSet.has(redirectDestination));
-                    if (!hasValidRedirect) {
-                        for (const [sourcePattern, destinationPattern] of this.redirectMap.entries()) {
+                    if (!hasExistingFile && !hasValidRedirect) {
+                        for (const [sourcePattern, destinationPattern] of wildcardRedirects) {
                             if (this.matchesWildcardPattern(pathString, sourcePattern)) {
                                 redirectDestination = this.applyWildcardRedirect(pathString, sourcePattern, destinationPattern);
                                 hasValidRedirect =