@mintlify/link-rot 3.0.819 → 3.0.821

package/dist/graph.d.ts

@@ -67,9 +67,11 @@ export declare class Graph {
     private fileResolutionMap;
     private redirectMap;
     private mintIgnoreGlobs;
+    private virtualNodes;
     constructor(baseDir: string, mintIgnoreGlobs?: string[]);
     addNode(label: string): Node;
     addNodes(labels: string[]): void;
+    addVirtualNodes(labels: string[]): void;
     setRedirects(redirects: {
         source: string;
         destination: string;

package/dist/graph.js

@@ -214,6 +214,7 @@ export class Graph {
         this.fileResolutionMap = new Map();
         this.redirectMap = new Map();
         this.mintIgnoreGlobs = [];
+        this.virtualNodes = new Set();
         this.baseDir = resolve(baseDir);
         this.mintIgnoreGlobs = mintIgnoreGlobs;
     }
@@ -228,6 +229,12 @@ export class Graph {
             this.addNode(label);
         }
     }
+    addVirtualNodes(labels) {
+        for (const label of labels) {
+            this.addNode(label);
+            this.virtualNodes.add(new Node(label).toString());
+        }
+    }
     setRedirects(redirects) {
         for (const redirect of redirects) {
             this.redirectMap.set(normalizePath(redirect.source), normalizePath(redirect.destination));
@@ -343,7 +350,8 @@ export class Graph {
                 if (path.pathType === PathType.INTERNAL) {
                     const pathString = path.toString();
                     const resolvedFiles = this.fileResolutionMap.get(pathString);
-                    const hasExistingFile = resolvedFiles && [...resolvedFiles].some((file) => nodeSet.has(file));
+                    const hasExistingFile = (resolvedFiles && [...resolvedFiles].some((file) => nodeSet.has(file))) ||
+                        this.virtualNodes.has(pathString);
                     let redirectDestination = this.redirectMap.get(pathString);
                     let hasValidRedirect = redirectDestination &&
                         (nodeSet.has(`${redirectDestination}.mdx`) || nodeSet.has(redirectDestination));

package/dist/static-checking/getBrokenInternalLinks.js

@@ -14,6 +14,7 @@ import path from 'path';
 import { visit } from 'unist-util-visit';
 import { Graph, Wrapper } from '../graph.js';
 import { getLinkPaths, getPagePaths } from '../prebuild.js';
+import { getOpenApiPagePaths } from './getOpenApiPagePaths.js';
 import { getRedirects } from './getRedirects.js';
 export const decorateGraphNodeFromPageContent = (graphNode, content) => __awaiter(void 0, void 0, void 0, function* () {
     const visitLinks = () => {
@@ -69,6 +70,14 @@ export const getBrokenInternalLinks = (repoPath) => __awaiter(void 0, void 0, vo
     graph.setRedirects(redirectMappings);
     // add nodes for every link alias in the project
     graph.addAliasNodes();
+    // add virtual nodes for OpenAPI-generated pages
+    try {
+        const openApiPagePaths = yield getOpenApiPagePaths(baseDir);
+        graph.addVirtualNodes(openApiPagePaths);
+    }
+    catch (err) {
+        console.warn(`Warning: Failed to extract OpenAPI page paths: ${err}`);
+    }
     const allSitePages = getPagePaths(baseDir);
     const sitePages = allSitePages.filter((file) => !isMintIgnored(file, mintIgnoreGlobs));
     yield Promise.all(sitePages.map((filePath) => __awaiter(void 0, void 0, void 0, function* () {

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

@@ -0,0 +1,8 @@
+/**
+ * Extract virtual page paths that would be generated from OpenAPI specs.
+ * These pages don't exist as files but are valid link targets.
+ *
+ * Note: Uses api.openapi.directory from docs.json, or falls back to 'api-reference'.
+ * Per-navigation directory configs are not currently supported.
+ */
+export declare const getOpenApiPagePaths: (baseDir: string) => Promise<string[]>;

package/dist/static-checking/getOpenApiPagePaths.js

@@ -0,0 +1,68 @@
+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 { categorizeFilePaths } from '@mintlify/prebuild';
+import { generateOpenApiPagesForDocsConfig } from '@mintlify/scraping';
+import { validateDocsConfig } from '@mintlify/validation';
+import fs from 'fs-extra';
+import path from 'path';
+const DEFAULT_OUTPUT_DIR = 'api-reference';
+const getOpenApiDirectory = (baseDir) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    const docsJsonPath = path.join(baseDir, 'docs.json');
+    if (!fs.existsSync(docsJsonPath))
+        return DEFAULT_OUTPUT_DIR;
+    try {
+        const docsJson = yield fs.readJSON(docsJsonPath);
+        const result = validateDocsConfig(docsJson);
+        if (!result.success)
+            return DEFAULT_OUTPUT_DIR;
+        const openapi = (_a = result.data.api) === null || _a === void 0 ? void 0 : _a.openapi;
+        if (typeof openapi === 'object' && 'directory' in openapi && openapi.directory) {
+            return openapi.directory;
+        }
+    }
+    catch (_b) {
+        throw new Error('Unable to parse OpenAPI directory from docs.json');
+    }
+    return DEFAULT_OUTPUT_DIR;
+});
+/**
+ * Extract virtual page paths that would be generated from OpenAPI specs.
+ * These pages don't exist as files but are valid link targets.
+ *
+ * Note: Uses api.openapi.directory from docs.json, or falls back to 'api-reference'.
+ * Per-navigation directory configs are not currently supported.
+ */
+export const getOpenApiPagePaths = (baseDir) => __awaiter(void 0, void 0, void 0, function* () {
+    const pagePaths = [];
+    try {
+        const [{ openApiFiles }, outDir] = yield Promise.all([
+            categorizeFilePaths(baseDir),
+            getOpenApiDirectory(baseDir),
+        ]);
+        for (const openApiFile of openApiFiles) {
+            try {
+                const { pagesAcc } = yield generateOpenApiPagesForDocsConfig(openApiFile.spec, {
+                    openApiFilePath: openApiFile.originalFileLocation,
+                    writeFiles: false,
+                    outDir,
+                });
+                pagePaths.push(...Object.keys(pagesAcc));
+            }
+            catch (err) {
+                console.warn(`Warning: Failed to extract pages from OpenAPI spec ${openApiFile.originalFileLocation}: ${err}`);
+            }
+        }
+    }
+    catch (err) {
+        console.warn(`Warning: Failed to categorize files for OpenAPI extraction: ${err}`);
+    }
+    return [...new Set(pagePaths)];
+});