@mintlify/link-rot 3.0.590 → 3.0.592

package/dist/graph.d.ts

@@ -73,6 +73,8 @@ export declare class Graph {
         source: string;
         destination: string;
     }[]): void;
+    matchesWildcardPattern(path: string, pattern: string): boolean;
+    applyWildcardRedirect(path: string, sourcePattern: string, destinationPattern: string): string;
     addAliasNodes(): void;
     getNode(label: string): Node | undefined;
     private addEdge;

package/dist/graph.js

@@ -231,6 +231,51 @@ export class Graph {
             this.redirectMap.set(normalizePath(redirect.source), normalizePath(redirect.destination));
         }
     }
+    matchesWildcardPattern(path, pattern) {
+        // Escape special regex characters except : and *
+        const escapedPattern = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // Replace :param patterns with named capture groups
+        const paramPattern = escapedPattern.replace(/:(\w+)/g, '(?<$1>[^/]+)');
+        // Replace * wildcards with greedy capture
+        const wildcardPattern = paramPattern.replace(/\\\*/g, '(.*)');
+        // Anchor the pattern to match the full path
+        const fullPattern = `^${wildcardPattern}$`;
+        return new RegExp(fullPattern).test(path);
+    }
+    applyWildcardRedirect(path, sourcePattern, destinationPattern) {
+        // Escape special regex characters except : and *
+        const escapedPattern = sourcePattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        // Track the order of capture groups
+        const captureGroups = [];
+        // Replace :param patterns with named capture groups and track them
+        const paramPattern = escapedPattern.replace(/:(\w+)/g, (_, paramName) => {
+            captureGroups.push({ type: 'param', name: paramName });
+            return `(?<${paramName}>[^/]+)`;
+        });
+        // Replace * wildcards with capture groups and track them
+        const wildcardPattern = paramPattern.replace(/\\\*/g, () => {
+            captureGroups.push({ type: 'wildcard' });
+            return '(.*)';
+        });
+        const regex = new RegExp(`^${wildcardPattern}$`);
+        const match = path.match(regex);
+        if (!match)
+            return destinationPattern;
+        let result = destinationPattern;
+        const namedGroups = match.groups || {};
+        // Replace named parameters (e.g., :slug)
+        for (const [paramName, value] of Object.entries(namedGroups)) {
+            result = result.replace(new RegExp(`:${paramName}`, 'g'), value);
+        }
+        const allCaptures = match.slice(1);
+        let wildcardIndex = 0;
+        const wildcardCaptures = allCaptures.filter((_, index) => {
+            // Skip captures that are named parameters
+            return captureGroups[index] && captureGroups[index].type === 'wildcard';
+        });
+        result = result.replace(/\*/g, () => wildcardCaptures[wildcardIndex++] || '');
+        return result;
+    }
     /*
      * Aliases are additional paths that are valid due to redirects
      */
@@ -296,8 +341,20 @@ export class Graph {
                     const pathString = path.toString();
                     const resolvedFiles = this.fileResolutionMap.get(pathString);
                     const hasExistingFile = resolvedFiles && [...resolvedFiles].some((file) => nodeSet.has(file));
-                    const redirectDestination = this.redirectMap.get(pathString);
-                    const hasValidRedirect = redirectDestination && nodeSet.has(`${redirectDestination}.mdx`);
+                    let redirectDestination = 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 (this.matchesWildcardPattern(pathString, sourcePattern)) {
+                                redirectDestination = this.applyWildcardRedirect(pathString, sourcePattern, destinationPattern);
+                                hasValidRedirect =
+                                    nodeSet.has(`${redirectDestination}.mdx`) || nodeSet.has(redirectDestination);
+                                if (hasValidRedirect)
+                                    break;
+                            }
+                        }
+                    }
                     if (!hasExistingFile && !hasValidRedirect) {
                         brokenLinks.push(path);
                     }