@docusaurus/core 3.1.0 → 3.2.0

package/lib/commands/writeTranslations.js

@@ -10,7 +10,7 @@ exports.writeTranslations = void 0;
 const tslib_1 = require("tslib");
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const path_1 = tslib_1.__importDefault(require("path"));
-const server_1 = require("../server");
+const site_1 = require("../server/site");
 const init_1 = require("../server/plugins/init");
 const translations_1 = require("../server/translations/translations");
 const translationsExtractor_1 = require("../server/translations/translationsExtractor");
@@ -55,7 +55,7 @@ async function writePluginTranslationFiles({ localizationDir, plugin, options, }
 }
 async function writeTranslations(siteDirParam = '.', options = {}) {
     const siteDir = await fs_extra_1.default.realpath(siteDirParam);
-    const context = await (0, server_1.loadContext)({
+    const context = await (0, site_1.loadContext)({
         siteDir,
         config: options.config,
         locale: options.locale,
@@ -72,7 +72,7 @@ Available locales are: ${context.i18n.locales.join(',')}.`);
         babelOptions: await (0, utils_1.getCustomBabelConfigFilePath)(siteDir),
     });
     const extractedCodeTranslations = await (0, translationsExtractor_1.extractSiteSourceCodeTranslations)(siteDir, plugins, babelOptions, await getExtraSourceCodeFilePaths());
-    const defaultCodeMessages = await (0, translations_1.getPluginsDefaultCodeTranslationMessages)(plugins);
+    const defaultCodeMessages = await (0, translations_1.loadPluginsDefaultCodeTranslationMessages)(plugins);
     const codeTranslations = (0, translations_1.applyDefaultCodeTranslations)({
         extractedCodeTranslations,
         defaultCodeMessages,

package/lib/index.d.ts

@@ -9,7 +9,7 @@ export { clear } from './commands/clear';
 export { deploy } from './commands/deploy';
 export { externalCommand } from './commands/external';
 export { serve } from './commands/serve';
-export { start } from './commands/start';
+export { start } from './commands/start/start';
 export { swizzle } from './commands/swizzle';
 export { writeHeadingIds } from './commands/writeHeadingIds';
 export { writeTranslations } from './commands/writeTranslations';

package/lib/index.js

@@ -17,7 +17,7 @@ var external_1 = require("./commands/external");
 Object.defineProperty(exports, "externalCommand", { enumerable: true, get: function () { return external_1.externalCommand; } });
 var serve_1 = require("./commands/serve");
 Object.defineProperty(exports, "serve", { enumerable: true, get: function () { return serve_1.serve; } });
-var start_1 = require("./commands/start");
+var start_1 = require("./commands/start/start");
 Object.defineProperty(exports, "start", { enumerable: true, get: function () { return start_1.start; } });
 var swizzle_1 = require("./commands/swizzle");
 Object.defineProperty(exports, "swizzle", { enumerable: true, get: function () { return swizzle_1.swizzle; } });

package/lib/server/brokenLinks.js

@@ -12,17 +12,59 @@ const lodash_1 = tslib_1.__importDefault(require("lodash"));
 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);
+const utils_common_1 = require("@docusaurus/utils-common");
+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_common_1.addTrailingSlash)(validPathnameRoute.path));
+                validPathnames.add((0, utils_common_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;
 }
@@ -72,17 +127,29 @@ function getBrokenLinksForPage({ collectedLinks, pagePath, pageLinks, routes, })
  */
 function filterIntermediateRoutes(routesInput) {
     const routesWithout404 = routesInput.filter((route) => route.path !== '*');
-    return (0, utils_2.getAllFinalRoutes)(routesWithout404);
+    return (0, utils_1.flattenRoutes)(routesWithout404);
 }
 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/clientModules.d.ts

@@ -9,4 +9,4 @@ import type { LoadedPlugin } from '@docusaurus/types';
  * Runs the `getClientModules` lifecycle. The returned file paths are all
  * absolute.
  */
-export declare function loadClientModules(plugins: LoadedPlugin[]): string[];
+export declare function getAllClientModules(plugins: LoadedPlugin[]): string[];

package/lib/server/clientModules.js

@@ -6,15 +6,15 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadClientModules = void 0;
+exports.getAllClientModules = void 0;
 const tslib_1 = require("tslib");
 const path_1 = tslib_1.__importDefault(require("path"));
 /**
  * Runs the `getClientModules` lifecycle. The returned file paths are all
  * absolute.
  */
-function loadClientModules(plugins) {
+function getAllClientModules(plugins) {
     return plugins.flatMap((plugin) => plugin.getClientModules?.().map((p) => path_1.default.resolve(plugin.path, p)) ??
         []);
 }
-exports.loadClientModules = loadClientModules;
+exports.getAllClientModules = getAllClientModules;

package/lib/server/codegen/codegen.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { CodeTranslations, DocusaurusConfig, GlobalData, I18n, RouteConfig, SiteMetadata } from '@docusaurus/types';
+type CodegenParams = {
+    generatedFilesDir: string;
+    siteConfig: DocusaurusConfig;
+    baseUrl: string;
+    clientModules: string[];
+    globalData: GlobalData;
+    i18n: I18n;
+    codeTranslations: CodeTranslations;
+    siteMetadata: SiteMetadata;
+    routes: RouteConfig[];
+};
+export declare function generateSiteFiles(params: CodegenParams): Promise<void>;
+export {};

package/lib/server/codegen/codegen.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSiteFiles = void 0;
+const utils_1 = require("@docusaurus/utils");
+const codegenRoutes_1 = require("./codegenRoutes");
+function genWarning({ generatedFilesDir }) {
+    return (0, utils_1.generate)(generatedFilesDir, 
+    // cSpell:ignore DONT
+    'DONT-EDIT-THIS-FOLDER', `This folder stores temp files that Docusaurus' client bundler accesses.
+
+DO NOT hand-modify files in this folder because they will be overwritten in the
+next build. You can clear all build artifacts (including this folder) with the
+\`docusaurus clear\` command.
+`);
+}
+function genSiteConfig({ generatedFilesDir, siteConfig, }) {
+    return (0, utils_1.generate)(generatedFilesDir, `${utils_1.DEFAULT_CONFIG_FILE_NAME}.mjs`, `/*
+ * AUTOGENERATED - DON'T EDIT
+ * Your edits in this file will be overwritten in the next build!
+ * Modify the docusaurus.config.js file at your site's root instead.
+ */
+export default ${JSON.stringify(siteConfig, null, 2)};
+`);
+}
+function genClientModules({ generatedFilesDir, clientModules, }) {
+    return (0, utils_1.generate)(generatedFilesDir, 'client-modules.js', `export default [
+${clientModules
+        // Use `require()` because `import()` is async but client modules can have CSS
+        // and the order matters for loading CSS.
+        .map((clientModule) => `  require("${(0, utils_1.escapePath)(clientModule)}"),`)
+        .join('\n')}
+];
+`);
+}
+function genGlobalData({ generatedFilesDir, globalData, }) {
+    return (0, utils_1.generate)(generatedFilesDir, 'globalData.json', JSON.stringify(globalData, null, 2));
+}
+function genI18n({ generatedFilesDir, i18n, }) {
+    return (0, utils_1.generate)(generatedFilesDir, 'i18n.json', JSON.stringify(i18n, null, 2));
+}
+function genCodeTranslations({ generatedFilesDir, codeTranslations, }) {
+    return (0, utils_1.generate)(generatedFilesDir, 'codeTranslations.json', JSON.stringify(codeTranslations, null, 2));
+}
+function genSiteMetadata({ generatedFilesDir, siteMetadata, }) {
+    return (0, utils_1.generate)(generatedFilesDir, 'site-metadata.json', JSON.stringify(siteMetadata, null, 2));
+}
+async function generateSiteFiles(params) {
+    await Promise.all([
+        genWarning(params),
+        genClientModules(params),
+        genSiteConfig(params),
+        (0, codegenRoutes_1.generateRouteFiles)(params),
+        genGlobalData(params),
+        genSiteMetadata(params),
+        genI18n(params),
+        genCodeTranslations(params),
+    ]);
+}
+exports.generateSiteFiles = generateSiteFiles;

package/lib/server/codegen/codegenRoutes.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { RouteConfig, RouteChunkNames } from '@docusaurus/types';
+type RoutesCode = {
+    /** Serialized routes config that can be directly emitted into temp file. */
+    routesConfig: string;
+    /** @see {ChunkNames} */
+    routesChunkNames: RouteChunkNames;
+    /**
+     * A map from chunk name to module paths. Module paths would have backslash
+     * escaped already, so they can be directly printed.
+     */
+    registry: {
+        [chunkName: string]: string;
+    };
+};
+/**
+ * Generates a unique chunk name that can be used in the chunk registry.
+ *
+ * @param modulePath A path to generate chunk name from. The actual value has no
+ * semantic significance.
+ * @param prefix A prefix to append to the chunk name, to avoid name clash.
+ * @param preferredName Chunk names default to `modulePath`, and this can supply
+ * a more human-readable name.
+ * @param shortId When `true`, the chunk name would only be a hash without any
+ * other characters. Useful for bundle size. Defaults to `true` in production.
+ */
+export declare function genChunkName(modulePath: string, prefix?: string, preferredName?: string, shortId?: boolean): string;
+/**
+ * Routes are prepared into three temp files:
+ *
+ * - `routesConfig`, the route config passed to react-router. This file is kept
+ * minimal, because it can't be code-splitted.
+ * - `routesChunkNames`, a mapping from route paths (hashed) to code-splitted
+ * chunk names.
+ * - `registry`, a mapping from chunk names to options for react-loadable.
+ */
+export declare function generateRoutesCode(routeConfigs: RouteConfig[]): RoutesCode;
+type GenerateRouteFilesParams = {
+    generatedFilesDir: string;
+    routes: RouteConfig[];
+    baseUrl: string;
+};
+export declare function generateRouteFiles({ generatedFilesDir, routes, }: GenerateRouteFilesParams): Promise<void>;
+export {};

package/lib/server/codegen/codegenRoutes.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRouteFiles = exports.generateRoutesCode = exports.genChunkName = void 0;
+const tslib_1 = require("tslib");
+const querystring_1 = tslib_1.__importDefault(require("querystring"));
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const utils_1 = require("@docusaurus/utils");
+/** Indents every line of `str` by one level. */
+function indent(str) {
+    return `  ${str.replace(/\n/g, `\n  `)}`;
+}
+const chunkNameCache = new Map();
+const chunkNameCount = new Map();
+/**
+ * Generates a unique chunk name that can be used in the chunk registry.
+ *
+ * @param modulePath A path to generate chunk name from. The actual value has no
+ * semantic significance.
+ * @param prefix A prefix to append to the chunk name, to avoid name clash.
+ * @param preferredName Chunk names default to `modulePath`, and this can supply
+ * a more human-readable name.
+ * @param shortId When `true`, the chunk name would only be a hash without any
+ * other characters. Useful for bundle size. Defaults to `true` in production.
+ */
+function genChunkName(modulePath, prefix, preferredName, shortId = process.env.NODE_ENV === 'production') {
+    let chunkName = chunkNameCache.get(modulePath);
+    if (!chunkName) {
+        if (shortId) {
+            chunkName = (0, utils_1.simpleHash)(modulePath, 8);
+        }
+        else {
+            let str = modulePath;
+            if (preferredName) {
+                const shortHash = (0, utils_1.simpleHash)(modulePath, 3);
+                str = `${preferredName}${shortHash}`;
+            }
+            const name = (0, utils_1.docuHash)(str);
+            chunkName = prefix ? `${prefix}---${name}` : name;
+        }
+        const seenCount = (chunkNameCount.get(chunkName) ?? 0) + 1;
+        if (seenCount > 1) {
+            chunkName += seenCount.toString(36);
+        }
+        chunkNameCache.set(modulePath, chunkName);
+        chunkNameCount.set(chunkName, seenCount);
+    }
+    return chunkName;
+}
+exports.genChunkName = genChunkName;
+/**
+ * Takes a piece of route config, and serializes it into raw JS code. The shape
+ * is the same as react-router's `RouteConfig`. Formatting is similar to
+ * `JSON.stringify` but without all the quotes.
+ */
+function serializeRouteConfig({ routePath, routeHash, exact, subroutesCodeStrings, props, }) {
+    const parts = [
+        `path: '${routePath}'`,
+        `component: ComponentCreator('${routePath}', '${routeHash}')`,
+    ];
+    if (exact) {
+        parts.push(`exact: true`);
+    }
+    if (subroutesCodeStrings) {
+        parts.push(`routes: [
+${indent(subroutesCodeStrings.join(',\n'))}
+]`);
+    }
+    Object.entries(props).forEach(([propName, propValue]) => {
+        const isIdentifier = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u.test(propName);
+        const key = isIdentifier ? propName : JSON.stringify(propName);
+        parts.push(`${key}: ${JSON.stringify(propValue)}`);
+    });
+    return `{
+${indent(parts.join(',\n'))}
+}`;
+}
+const isModule = (value) => typeof value === 'string' ||
+    (typeof value === 'object' &&
+        // eslint-disable-next-line no-underscore-dangle
+        !!value?.__import);
+/**
+ * Takes a {@link Module} (which is nothing more than a path plus some metadata
+ * like query) and returns the string path it represents.
+ */
+function getModulePath(target) {
+    if (typeof target === 'string') {
+        return target;
+    }
+    const queryStr = target.query ? `?${querystring_1.default.stringify(target.query)}` : '';
+    return `${target.path}${queryStr}`;
+}
+function genChunkNames(routeModule, prefix, name, res) {
+    if (isModule(routeModule)) {
+        // This is a leaf node, no need to recurse
+        const modulePath = getModulePath(routeModule);
+        const chunkName = genChunkName(modulePath, prefix, name);
+        res.registry[chunkName] = (0, utils_1.escapePath)(modulePath);
+        return chunkName;
+    }
+    if (Array.isArray(routeModule)) {
+        return routeModule.map((val, index) => genChunkNames(val, `${index}`, name, res));
+    }
+    return lodash_1.default.mapValues(routeModule, (v, key) => genChunkNames(v, key, name, res));
+}
+/**
+ * This is the higher level overview of route code generation. For each route
+ * config node, it returns the node's serialized form, and mutates `registry`,
+ * `routesPaths`, and `routesChunkNames` accordingly.
+ */
+function genRouteCode(routeConfig, res) {
+    const { path: routePath, component, modules = {}, context, routes: subroutes, priority, exact, metadata, ...props } = routeConfig;
+    if (typeof routePath !== 'string' || !component) {
+        throw new Error(`Invalid route config: path must be a string and component is required.
+${JSON.stringify(routeConfig)}`);
+    }
+    const routeHash = (0, utils_1.simpleHash)(JSON.stringify(routeConfig), 3);
+    res.routesChunkNames[`${routePath}-${routeHash}`] = {
+        // Avoid clash with a prop called "component"
+        ...genChunkNames({ __comp: component }, 'component', component, res),
+        ...(context &&
+            genChunkNames({ __context: context }, 'context', routePath, res)),
+        ...genChunkNames(modules, 'module', routePath, res),
+    };
+    return serializeRouteConfig({
+        routePath: routePath.replace(/'/g, "\\'"),
+        routeHash,
+        subroutesCodeStrings: subroutes?.map((r) => genRouteCode(r, res)),
+        exact,
+        props,
+    });
+}
+/**
+ * Routes are prepared into three temp files:
+ *
+ * - `routesConfig`, the route config passed to react-router. This file is kept
+ * minimal, because it can't be code-splitted.
+ * - `routesChunkNames`, a mapping from route paths (hashed) to code-splitted
+ * chunk names.
+ * - `registry`, a mapping from chunk names to options for react-loadable.
+ */
+function generateRoutesCode(routeConfigs) {
+    const res = {
+        // To be written by `genRouteCode`
+        routesConfig: '',
+        routesChunkNames: {},
+        registry: {},
+    };
+    // `genRouteCode` would mutate `res`
+    const routeConfigSerialized = routeConfigs
+        .map((r) => genRouteCode(r, res))
+        .join(',\n');
+    res.routesConfig = `import React from 'react';
+import ComponentCreator from '@docusaurus/ComponentCreator';
+
+export default [
+${indent(routeConfigSerialized)},
+  {
+    path: '*',
+    component: ComponentCreator('*'),
+  },
+];
+`;
+    return res;
+}
+exports.generateRoutesCode = generateRoutesCode;
+const genRegistry = ({ generatedFilesDir, registry, }) => (0, utils_1.generate)(generatedFilesDir, 'registry.js', `export default {
+${Object.entries(registry)
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .map(([chunkName, modulePath]) => 
+// modulePath is already escaped by escapePath
+`  "${chunkName}": [() => import(/* webpackChunkName: "${chunkName}" */ "${modulePath}"), "${modulePath}", require.resolveWeak("${modulePath}")],`)
+    .join('\n')}};
+`);
+const genRoutesChunkNames = ({ generatedFilesDir, routesChunkNames, }) => (0, utils_1.generate)(generatedFilesDir, 'routesChunkNames.json', JSON.stringify(routesChunkNames, null, 2));
+const genRoutes = ({ generatedFilesDir, routesConfig, }) => (0, utils_1.generate)(generatedFilesDir, 'routes.js', routesConfig);
+async function generateRouteFiles({ generatedFilesDir, routes, }) {
+    const { registry, routesChunkNames, routesConfig } = generateRoutesCode(routes);
+    await Promise.all([
+        genRegistry({ generatedFilesDir, registry }),
+        genRoutesChunkNames({ generatedFilesDir, routesChunkNames }),
+        genRoutes({ generatedFilesDir, routesConfig }),
+    ]);
+}
+exports.generateRouteFiles = generateRouteFiles;

package/lib/server/configValidation.js

@@ -9,6 +9,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateConfig = exports.ConfigSchema = exports.DEFAULT_CONFIG = exports.DEFAULT_MARKDOWN_CONFIG = exports.DEFAULT_I18N_CONFIG = void 0;
 const utils_1 = require("@docusaurus/utils");
 const utils_validation_1 = require("@docusaurus/utils-validation");
+const utils_common_1 = require("@docusaurus/utils-common");
 const DEFAULT_I18N_LOCALE = 'en';
 exports.DEFAULT_I18N_CONFIG = {
     defaultLocale: DEFAULT_I18N_LOCALE,
@@ -51,12 +52,13 @@ exports.DEFAULT_CONFIG = {
     markdown: exports.DEFAULT_MARKDOWN_CONFIG,
 };
 function createPluginSchema(theme) {
-    return utils_validation_1.Joi.alternatives()
+    return (utils_validation_1.Joi.alternatives()
         .try(utils_validation_1.Joi.function(), utils_validation_1.Joi.array()
         .ordered(utils_validation_1.Joi.function().required(), utils_validation_1.Joi.object().required())
         .length(2), utils_validation_1.Joi.string(), utils_validation_1.Joi.array()
         .ordered(utils_validation_1.Joi.string().required(), utils_validation_1.Joi.object().required())
         .length(2), utils_validation_1.Joi.any().valid(false, null))
+        // @ts-expect-error: bad lib def, doesn't recognize an array of reports
         .error((errors) => {
         errors.forEach((error) => {
             const validConfigExample = theme
@@ -85,7 +87,7 @@ ${validConfigExample}
 `;
         });
         return errors;
-    });
+    }));
 }
 const PluginSchema = createPluginSchema(false);
 const ThemeSchema = createPluginSchema(true);
@@ -127,7 +129,7 @@ const SiteUrlSchema = utils_validation_1.Joi.string()
     catch {
         return helpers.error('any.invalid');
     }
-    return (0, utils_1.removeTrailingSlash)(value);
+    return (0, utils_common_1.removeTrailingSlash)(value);
 })
     .messages({
     'any.invalid': '"{#value}" does not look like a valid URL. Make sure it has a protocol; for example, "https://example.com".',
@@ -140,7 +142,7 @@ exports.ConfigSchema = utils_validation_1.Joi.object({
         .alternatives()
         .try(utils_validation_1.Joi.string().required().allow(''))
         .required()
-        .custom((value) => (0, utils_1.addLeadingSlash)((0, utils_1.addTrailingSlash)(value))),
+        .custom((value) => (0, utils_common_1.addLeadingSlash)((0, utils_common_1.addTrailingSlash)(value))),
     baseUrlIssueBanner: utils_validation_1.Joi.boolean().default(exports.DEFAULT_CONFIG.baseUrlIssueBanner),
     favicon: utils_validation_1.Joi.string().optional(),
     title: utils_validation_1.Joi.string().required(),