@docusaurus/core 3.1.0 → 3.1.1

package/lib/client/BrokenLinksContext.js

@@ -11,10 +11,10 @@ export const createStatefulBrokenLinks = () => {
     const allLinks = new Set();
     return {
         collectAnchor: (anchor) => {
-            allAnchors.add(anchor);
+            typeof anchor !== 'undefined' && allAnchors.add(anchor);
         },
         collectLink: (link) => {
-            allLinks.add(link);
+            typeof link !== 'undefined' && allLinks.add(link);
         },
         getCollectedAnchors: () => [...allAnchors],
         getCollectedLinks: () => [...allLinks],

package/lib/client/exports/Link.js

@@ -97,11 +97,19 @@ function Link({ isNavLink, to, href, activeClassName, isActive, 'data-noBrokenLi
             }
         };
     }, [ioRef, targetLink, IOSupported, isInternal]);
+    // It is simple local anchor link targeting current page?
     const isAnchorLink = targetLink?.startsWith('#') ?? false;
-    const isRegularHtmlLink = !targetLink || !isInternal || isAnchorLink;
-    if (!isRegularHtmlLink && !noBrokenLinkCheck) {
+    // See also RR logic:
+    // https://github.com/remix-run/react-router/blob/v5/packages/react-router-dom/modules/Link.js#L47
+    const hasInternalTarget = !props.target || props.target === '_self';
+    // Should we use a regular <a> tag instead of React-Router Link component?
+    const isRegularHtmlLink = !targetLink || !isInternal || !hasInternalTarget || isAnchorLink;
+    if (!noBrokenLinkCheck && (isAnchorLink || !isRegularHtmlLink)) {
         brokenLinks.collectLink(targetLink);
     }
+    if (props.id) {
+        brokenLinks.collectAnchor(props.id);
+    }
     return isRegularHtmlLink ? (
     // eslint-disable-next-line jsx-a11y/anchor-has-content, @docusaurus/no-html-links
     <a ref={innerRef} href={targetLink} {...(targetLinkUnprefixed &&

package/lib/server/brokenLinks.js

@@ -13,16 +13,58 @@ const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
 const react_router_config_1 = require("react-router-config");
 const utils_1 = require("@docusaurus/utils");
 const utils_2 = require("./utils");
-function getBrokenLinksForPage({ collectedLinks, pagePath, pageLinks, routes, }) {
-    // console.log('routes:', routes);
+function matchRoutes(routeConfig, pathname) {
+    // @ts-expect-error: React router types RouteConfig with an actual React
+    // component, but we load route components with string paths.
+    // We don't actually access component here, so it's fine.
+    return (0, react_router_config_1.matchRoutes)(routeConfig, pathname);
+}
+function createBrokenLinksHelper({ collectedLinks, routes, }) {
+    const validPathnames = new Set(collectedLinks.keys());
+    // IMPORTANT: this is an optimization
+    // See https://github.com/facebook/docusaurus/issues/9754
+    // Matching against the route array can be expensive
+    // If the route is already in the valid pathnames,
+    // we can avoid matching against it
+    const remainingRoutes = (function filterRoutes() {
+        // Goal: unit tests should behave the same with this enabled or disabled
+        const disableOptimization = false;
+        if (disableOptimization) {
+            return routes;
+        }
+        // We must consider the "exact" and "strict" match attribute
+        // We can only infer pre-validated pathnames from a route from exact routes
+        const [validPathnameRoutes, otherRoutes] = lodash_1.default.partition(routes, (route) => route.exact && validPathnames.has(route.path));
+        // If a route is non-strict (non-sensitive to trailing slashes)
+        // We must pre-validate all possible paths
+        validPathnameRoutes.forEach((validPathnameRoute) => {
+            if (!validPathnameRoute.strict) {
+                validPathnames.add((0, utils_1.addTrailingSlash)(validPathnameRoute.path));
+                validPathnames.add((0, utils_1.removeTrailingSlash)(validPathnameRoute.path));
+            }
+        });
+        return otherRoutes;
+    })();
+    function isPathnameMatchingAnyRoute(pathname) {
+        if (matchRoutes(remainingRoutes, pathname).length > 0) {
+            // IMPORTANT: this is an optimization
+            // See https://github.com/facebook/docusaurus/issues/9754
+            // Large Docusaurus sites have many routes!
+            // We try to minimize calls to a possibly expensive matchRoutes function
+            validPathnames.add(pathname);
+            return true;
+        }
+        return false;
+    }
     function isPathBrokenLink(linkPath) {
-        const matchedRoutes = [linkPath.pathname, decodeURI(linkPath.pathname)]
-            // @ts-expect-error: React router types RouteConfig with an actual React
-            // component, but we load route components with string paths.
-            // We don't actually access component here, so it's fine.
-            .map((l) => (0, react_router_config_1.matchRoutes)(routes, l))
-            .flat();
-        return matchedRoutes.length === 0;
+        const pathnames = [linkPath.pathname, decodeURI(linkPath.pathname)];
+        if (pathnames.some((p) => validPathnames.has(p))) {
+            return false;
+        }
+        if (pathnames.some(isPathnameMatchingAnyRoute)) {
+            return false;
+        }
+        return true;
     }
     function isAnchorBrokenLink(linkPath) {
         const { pathname, hash } = linkPath;
@@ -30,37 +72,50 @@ function getBrokenLinksForPage({ collectedLinks, pagePath, pageLinks, routes, })
         if (hash === undefined) {
             return false;
         }
-        const targetPage = collectedLinks[pathname] || collectedLinks[decodeURI(pathname)];
+        // Link has empty hash ("#", "/page#"...): we do not report it as broken
+        // Empty hashes are used for various weird reasons, by us and other users...
+        // See for example: https://github.com/facebook/docusaurus/pull/6003
+        if (hash === '') {
+            return false;
+        }
+        const targetPage = collectedLinks.get(pathname) || collectedLinks.get(decodeURI(pathname));
         // link with anchor to a page that does not exist (or did not collect any
         // link/anchor) is considered as a broken anchor
         if (!targetPage) {
             return true;
         }
-        // it's a broken anchor if the target page exists
-        // but the anchor does not exist on that page
-        return !targetPage.anchors.includes(hash);
+        // it's a not broken anchor if the anchor exists on the target page
+        if (targetPage.anchors.has(hash) ||
+            targetPage.anchors.has(decodeURIComponent(hash))) {
+            return false;
+        }
+        return true;
     }
-    const brokenLinks = pageLinks.flatMap((link) => {
+    return {
+        collectedLinks,
+        isPathBrokenLink,
+        isAnchorBrokenLink,
+    };
+}
+function getBrokenLinksForPage({ pagePath, helper, }) {
+    const pageData = helper.collectedLinks.get(pagePath);
+    const brokenLinks = [];
+    pageData.links.forEach((link) => {
         const linkPath = (0, utils_1.parseURLPath)(link, pagePath);
-        if (isPathBrokenLink(linkPath)) {
-            return [
-                {
-                    link,
-                    resolvedLink: (0, utils_1.serializeURLPath)(linkPath),
-                    anchor: false,
-                },
-            ];
+        if (helper.isPathBrokenLink(linkPath)) {
+            brokenLinks.push({
+                link,
+                resolvedLink: (0, utils_1.serializeURLPath)(linkPath),
+                anchor: false,
+            });
         }
-        if (isAnchorBrokenLink(linkPath)) {
-            return [
-                {
-                    link,
-                    resolvedLink: (0, utils_1.serializeURLPath)(linkPath),
-                    anchor: true,
-                },
-            ];
+        else if (helper.isAnchorBrokenLink(linkPath)) {
+            brokenLinks.push({
+                link,
+                resolvedLink: (0, utils_1.serializeURLPath)(linkPath),
+                anchor: true,
+            });
         }
-        return [];
     });
     return brokenLinks;
 }
@@ -76,13 +131,25 @@ function filterIntermediateRoutes(routesInput) {
 }
 function getBrokenLinks({ collectedLinks, routes, }) {
     const filteredRoutes = filterIntermediateRoutes(routes);
-    return lodash_1.default.mapValues(collectedLinks, (pageCollectedData, pagePath) => getBrokenLinksForPage({
+    const helper = createBrokenLinksHelper({
         collectedLinks,
-        pageLinks: pageCollectedData.links,
-        pageAnchors: pageCollectedData.anchors,
-        pagePath,
         routes: filteredRoutes,
-    }));
+    });
+    const result = {};
+    collectedLinks.forEach((_unused, pagePath) => {
+        try {
+            result[pagePath] = getBrokenLinksForPage({
+                pagePath,
+                helper,
+            });
+        }
+        catch (e) {
+            throw new Error(`Unable to get broken links for page ${pagePath}.`, {
+                cause: e,
+            });
+        }
+    });
+    return result;
 }
 function brokenLinkMessage(brokenLink) {
     const showResolvedLink = brokenLink.link !== brokenLink.resolvedLink;
@@ -179,11 +246,31 @@ function reportBrokenLinks({ brokenLinks, onBrokenLinks, onBrokenAnchors, }) {
         logger_1.default.report(onBrokenAnchors)(anchorErrorMessage);
     }
 }
+// Users might use the useBrokenLinks() API in weird unexpected ways
+// JS users might call "collectLink(undefined)" for example
+// TS users might call "collectAnchor('#hash')" with/without #
+// We clean/normalize the collected data to avoid obscure errors being thrown
+// We also use optimized data structures for a faster algorithm
+function normalizeCollectedLinks(collectedLinks) {
+    const result = new Map();
+    Object.entries(collectedLinks).forEach(([pathname, pageCollectedData]) => {
+        result.set(pathname, {
+            links: new Set(pageCollectedData.links.filter(lodash_1.default.isString)),
+            anchors: new Set(pageCollectedData.anchors
+                .filter(lodash_1.default.isString)
+                .map((anchor) => (anchor.startsWith('#') ? anchor.slice(1) : anchor))),
+        });
+    });
+    return result;
+}
 async function handleBrokenLinks({ collectedLinks, onBrokenLinks, onBrokenAnchors, routes, }) {
     if (onBrokenLinks === 'ignore' && onBrokenAnchors === 'ignore') {
         return;
     }
-    const brokenLinks = getBrokenLinks({ routes, collectedLinks });
+    const brokenLinks = getBrokenLinks({
+        routes,
+        collectedLinks: normalizeCollectedLinks(collectedLinks),
+    });
     reportBrokenLinks({ brokenLinks, onBrokenLinks, onBrokenAnchors });
 }
 exports.handleBrokenLinks = handleBrokenLinks;

package/lib/server/getHostPort.js

@@ -40,7 +40,10 @@ function getProcessForPort(port) {
  */
 async function choosePort(host, defaultPort) {
     try {
-        const port = await (0, detect_port_1.default)({ port: defaultPort, hostname: host });
+        const port = await (0, detect_port_1.default)({
+            port: defaultPort,
+            ...(host !== 'localhost' && { hostname: host }),
+        });
         if (port === defaultPort) {
             return port;
         }

package/lib/server/routes.js

@@ -159,6 +159,14 @@ ${JSON.stringify(routeConfig)}`);
         props,
     });
 }
+/**
+ * Old stuff
+ * As far as I understand, this is what permits to SSG the 404.html file
+ * This is rendered through the catch-all ComponentCreator("*") route
+ * Note CDNs only understand the 404.html file by convention
+ * The extension probably permits to avoid emitting "/404/index.html"
+ */
+const NotFoundRoutePath = '/404.html';
 /**
  * Routes are prepared into three temp files:
  *
@@ -175,7 +183,7 @@ function loadRoutes(routeConfigs, baseUrl, onDuplicateRoutes) {
         routesConfig: '',
         routesChunkNames: {},
         registry: {},
-        routesPaths: [(0, utils_1.normalizeUrl)([baseUrl, '404.html'])],
+        routesPaths: [(0, utils_1.normalizeUrl)([baseUrl, NotFoundRoutePath])],
     };
     // `genRouteCode` would mutate `res`
     const routeConfigSerialized = routeConfigs

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@docusaurus/core",
   "description": "Easy to Maintain Open Source Documentation Websites",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -43,13 +43,13 @@
     "@babel/runtime": "^7.22.6",
     "@babel/runtime-corejs3": "^7.22.6",
     "@babel/traverse": "^7.22.8",
-    "@docusaurus/cssnano-preset": "3.1.0",
-    "@docusaurus/logger": "3.1.0",
-    "@docusaurus/mdx-loader": "3.1.0",
+    "@docusaurus/cssnano-preset": "3.1.1",
+    "@docusaurus/logger": "3.1.1",
+    "@docusaurus/mdx-loader": "3.1.1",
     "@docusaurus/react-loadable": "5.5.2",
-    "@docusaurus/utils": "3.1.0",
-    "@docusaurus/utils-common": "3.1.0",
-    "@docusaurus/utils-validation": "3.1.0",
+    "@docusaurus/utils": "3.1.1",
+    "@docusaurus/utils-common": "3.1.1",
+    "@docusaurus/utils-validation": "3.1.1",
     "@slorber/static-site-generator-webpack-plugin": "^4.0.7",
     "@svgr/webpack": "^6.5.1",
     "autoprefixer": "^10.4.14",
@@ -104,8 +104,8 @@
     "webpackbar": "^5.0.2"
   },
   "devDependencies": {
-    "@docusaurus/module-type-aliases": "3.1.0",
-    "@docusaurus/types": "3.1.0",
+    "@docusaurus/module-type-aliases": "3.1.1",
+    "@docusaurus/types": "3.1.1",
     "@types/detect-port": "^1.3.3",
     "@types/react-dom": "^18.2.7",
     "@types/react-router-config": "^5.0.7",
@@ -124,5 +124,5 @@
   "engines": {
     "node": ">=18.0"
   },
-  "gitHead": "a5e675821f0e8b70b591fcebf19fd60a70d55548"
+  "gitHead": "8017f6a6776ba1bd7065e630a52fe2c2654e2f1b"
 }