@mintlify/link-rot 3.0.892 → 3.0.894

package/dist/graph.d.ts

@@ -43,6 +43,7 @@ export declare class Node {
     relativeDir: string;
     filename: string;
     edges: Edge[];
+    headingSlugs: Set<string> | null;
     constructor(label: string, paths?: MdxPath[]);
     toString(): string;
     equals(other: Node): boolean;
@@ -83,6 +84,7 @@ export declare class Graph {
     private addEdge;
     addEdgesBetweenNodes(): void;
     precomputeFileResolutions(): void;
+    private getHeadingSlugsForPath;
     getBrokenInternalLinks(): MdxPath[];
     getAllInternalPaths(): string[];
 }

package/dist/graph.js

@@ -150,6 +150,7 @@ export class Node {
         this.label = label;
         this.paths = paths;
         this.edges = [];
+        this.headingSlugs = null;
         this.relativeDir = normalizePath(dirname(label));
         this.filename = basename(label);
         this.label = join(this.relativeDir, this.filename);
@@ -339,6 +340,26 @@ export class Graph {
             });
         });
     }
+    getHeadingSlugsForPath(pathString, nodeSet) {
+        var _a;
+        const resolvedFiles = this.fileResolutionMap.get(pathString);
+        if (resolvedFiles) {
+            for (const file of resolvedFiles) {
+                if (nodeSet.has(file)) {
+                    const node = this.nodes[file];
+                    if (node && node.headingSlugs !== null)
+                        return node.headingSlugs;
+                }
+            }
+        }
+        const directNode = this.nodes[pathString];
+        if (directNode && directNode.headingSlugs !== null)
+            return directNode.headingSlugs;
+        const indexNode = (_a = this.nodes[`${pathString}/index.mdx`]) !== null && _a !== void 0 ? _a : this.nodes[`${pathString}/index.md`];
+        if (indexNode && indexNode.headingSlugs !== null)
+            return indexNode.headingSlugs;
+        return undefined;
+    }
     getBrokenInternalLinks() {
         if (this.fileResolutionMap.size === 0) {
             this.precomputeFileResolutions();
@@ -369,6 +390,13 @@ export class Graph {
                     if (!hasExistingFile && !hasValidRedirect) {
                         brokenLinks.push(path);
                     }
+                    else if (path.anchorLink) {
+                        const anchor = path.anchorLink.slice(1);
+                        const headingSlugs = this.getHeadingSlugsForPath(pathString, nodeSet);
+                        if (headingSlugs && !headingSlugs.has(anchor)) {
+                            brokenLinks.push(path);
+                        }
+                    }
                 }
             }
         }

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

@@ -1,4 +1,6 @@
+import type { TableOfContentsSectionType } from '@mintlify/common';
 import { Node } from '../graph.js';
+export declare const flattenTableOfContentsSlugs: (sections: TableOfContentsSectionType[]) => Set<string>;
 export declare const decorateGraphNodeFromPageContent: (graphNode: Node, content: string) => Promise<void>;
 /**
  * Get all broken internal links used in the site

package/dist/static-checking/getBrokenInternalLinks.js

@@ -7,16 +7,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { coreRemark, isMintIgnored } from '@mintlify/common';
+import { coreRemark, isMintIgnored, remarkComponentIds, remarkExtractTableOfContents, } from '@mintlify/common';
 import { getMintIgnore } from '@mintlify/prebuild';
 import fs from 'fs-extra';
 import path from 'path';
 import { visit } from 'unist-util-visit';
 import { Graph, Wrapper } from '../graph.js';
 import { getLinkPaths, getPagePaths } from '../prebuild.js';
+import { getNavigationHrefs } from './getNavigationHrefs.js';
 import { getOpenApiPagePaths } from './getOpenApiPagePaths.js';
 import { getRedirects } from './getRedirects.js';
+export const flattenTableOfContentsSlugs = (sections) => {
+    const slugs = new Set();
+    for (const section of sections) {
+        slugs.add(section.slug);
+        for (const slug of flattenTableOfContentsSlugs(section.children)) {
+            slugs.add(slug);
+        }
+    }
+    return slugs;
+};
 export const decorateGraphNodeFromPageContent = (graphNode, content) => __awaiter(void 0, void 0, void 0, function* () {
+    const mdxExtracts = {};
     const visitLinks = () => {
         return (tree) => {
             visit(tree, (node) => {
@@ -49,8 +61,15 @@ export const decorateGraphNodeFromPageContent = (graphNode, content) => __awaite
             return tree;
         };
     };
-    yield coreRemark().use(visitLinks).process(content);
-    return;
+    const processor = coreRemark()
+        .use(visitLinks)
+        .use(remarkComponentIds)
+        .use(remarkExtractTableOfContents, mdxExtracts);
+    const tree = processor.parse(content);
+    yield processor.run(tree);
+    graphNode.headingSlugs = mdxExtracts.tableOfContents
+        ? flattenTableOfContentsSlugs(mdxExtracts.tableOfContents)
+        : new Set();
 });
 /**
  * Get all broken internal links used in the site
@@ -78,6 +97,14 @@ export const getBrokenInternalLinks = (repoPath) => __awaiter(void 0, void 0, vo
     catch (err) {
         console.warn(`Warning: Failed to extract OpenAPI page paths: ${err}`);
     }
+    const navResult = yield getNavigationHrefs(baseDir);
+    if (navResult) {
+        const configNode = graph.addNode(navResult.configFile);
+        for (const href of navResult.hrefs) {
+            const normalized = href === '/' || href === '' ? '/index' : href.replace(/^\/#/, '/index#');
+            configNode.addPath(normalized);
+        }
+    }
     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/getNavigationHrefs.d.ts

@@ -0,0 +1,4 @@
+export declare const getNavigationHrefs: (baseDir: string) => Promise<{
+    hrefs: string[];
+    configFile: string;
+} | undefined>;

package/dist/static-checking/getNavigationHrefs.js

@@ -0,0 +1,41 @@
+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 fs from 'fs-extra';
+import path from 'path';
+const collectHrefs = (obj) => {
+    if (typeof obj !== 'object' || obj === null)
+        return [];
+    if (Array.isArray(obj))
+        return obj.flatMap(collectHrefs);
+    const record = obj;
+    const hrefs = [];
+    if (typeof record.href === 'string') {
+        hrefs.push(record.href);
+    }
+    for (const value of Object.values(record)) {
+        hrefs.push(...collectHrefs(value));
+    }
+    return hrefs;
+};
+export const getNavigationHrefs = (baseDir) => __awaiter(void 0, void 0, void 0, function* () {
+    let configJson;
+    let configFile;
+    if (fs.existsSync(path.join(baseDir, 'docs.json'))) {
+        configJson = yield fs.readJSON(path.join(baseDir, 'docs.json'));
+        configFile = 'docs.json';
+    }
+    else if (fs.existsSync(path.join(baseDir, 'mint.json'))) {
+        configJson = yield fs.readJSON(path.join(baseDir, 'mint.json'));
+        configFile = 'mint.json';
+    }
+    if (!(configJson === null || configJson === void 0 ? void 0 : configJson.navigation) || !configFile)
+        return undefined;
+    return { hrefs: collectHrefs(configJson.navigation), configFile };
+});