@docusaurus/core 3.1.1 → 3.2.0

package/lib/server/plugins/plugins.js

@@ -0,0 +1,188 @@
+"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.reloadPlugin = exports.loadPlugins = void 0;
+const init_1 = require("./init");
+const synthetic_1 = require("./synthetic");
+const translations_1 = require("../translations/translations");
+const routeConfig_1 = require("./routeConfig");
+const utils_1 = require("../../utils");
+const actions_1 = require("./actions");
+const pluginsUtils_1 = require("./pluginsUtils");
+async function translatePluginContent({ plugin, content, context, }) {
+    const rawTranslationFiles = (await plugin.getTranslationFiles?.({ content })) ?? [];
+    const translationFiles = await Promise.all(rawTranslationFiles.map((translationFile) => (0, translations_1.localizePluginTranslationFile)({
+        localizationDir: context.localizationDir,
+        translationFile,
+        plugin,
+    })));
+    const translatedContent = plugin.translateContent?.({ content, translationFiles }) ?? content;
+    const translatedThemeConfigSlice = plugin.translateThemeConfig?.({
+        themeConfig: context.siteConfig.themeConfig,
+        translationFiles,
+    });
+    // TODO dangerous legacy, need to be refactored!
+    // Side-effect to merge theme config translations. A plugin should only
+    // translate its own slice of theme config and should make no assumptions
+    // about other plugins' keys, so this is safe to run in parallel.
+    Object.assign(context.siteConfig.themeConfig, translatedThemeConfigSlice);
+    return translatedContent;
+}
+async function executePluginContentLoading({ plugin, context, }) {
+    return utils_1.PerfLogger.async(`Load ${(0, pluginsUtils_1.formatPluginName)(plugin)}`, async () => {
+        let content = await utils_1.PerfLogger.async('loadContent()', () => plugin.loadContent?.());
+        content = await utils_1.PerfLogger.async('translatePluginContent()', () => translatePluginContent({
+            plugin,
+            content,
+            context,
+        }));
+        const defaultCodeTranslations = (await utils_1.PerfLogger.async('getDefaultCodeTranslationMessages()', () => plugin.getDefaultCodeTranslationMessages?.())) ?? {};
+        if (!plugin.contentLoaded) {
+            return {
+                ...plugin,
+                content,
+                defaultCodeTranslations,
+                routes: [],
+                globalData: undefined,
+            };
+        }
+        const pluginActionsUtils = await (0, actions_1.createPluginActionsUtils)({
+            plugin,
+            generatedFilesDir: context.generatedFilesDir,
+            baseUrl: context.siteConfig.baseUrl,
+            trailingSlash: context.siteConfig.trailingSlash,
+        });
+        await utils_1.PerfLogger.async('contentLoaded()', () => 
+        // @ts-expect-error: should autofix with TS 5.4
+        plugin.contentLoaded({
+            content,
+            actions: pluginActionsUtils.getActions(),
+        }));
+        return {
+            ...plugin,
+            content,
+            defaultCodeTranslations,
+            routes: pluginActionsUtils.getRoutes(),
+            globalData: pluginActionsUtils.getGlobalData(),
+        };
+    });
+}
+async function executeAllPluginsContentLoading({ plugins, context, }) {
+    return utils_1.PerfLogger.async(`Load plugins content`, () => {
+        return Promise.all(plugins.map((plugin) => executePluginContentLoading({ plugin, context })));
+    });
+}
+async function executePluginAllContentLoaded({ plugin, context, allContent, }) {
+    return utils_1.PerfLogger.async(`allContentLoaded() - ${(0, pluginsUtils_1.formatPluginName)(plugin)}`, async () => {
+        if (!plugin.allContentLoaded) {
+            return { routes: [], globalData: undefined };
+        }
+        const pluginActionsUtils = await (0, actions_1.createPluginActionsUtils)({
+            plugin,
+            generatedFilesDir: context.generatedFilesDir,
+            baseUrl: context.siteConfig.baseUrl,
+            trailingSlash: context.siteConfig.trailingSlash,
+        });
+        await plugin.allContentLoaded({
+            allContent,
+            actions: pluginActionsUtils.getActions(),
+        });
+        return {
+            routes: pluginActionsUtils.getRoutes(),
+            globalData: pluginActionsUtils.getGlobalData(),
+        };
+    });
+}
+async function executeAllPluginsAllContentLoaded({ plugins, context, }) {
+    return utils_1.PerfLogger.async(`allContentLoaded()`, async () => {
+        const allContent = (0, pluginsUtils_1.aggregateAllContent)(plugins);
+        const routes = [];
+        const globalData = {};
+        await Promise.all(plugins.map(async (plugin) => {
+            var _a;
+            const { routes: pluginRoutes, globalData: pluginGlobalData } = await executePluginAllContentLoaded({
+                plugin,
+                context,
+                allContent,
+            });
+            routes.push(...pluginRoutes);
+            if (pluginGlobalData !== undefined) {
+                globalData[_a = plugin.name] ?? (globalData[_a] = {});
+                globalData[plugin.name][plugin.options.id] = pluginGlobalData;
+            }
+        }));
+        return { routes, globalData };
+    });
+}
+// This merges plugins routes and global data created from both lifecycles:
+// - contentLoaded()
+// - allContentLoaded()
+function mergeResults({ plugins, allContentLoadedResult, }) {
+    const routes = [
+        ...(0, pluginsUtils_1.aggregateRoutes)(plugins),
+        ...allContentLoadedResult.routes,
+    ];
+    (0, routeConfig_1.sortRoutes)(routes);
+    const globalData = (0, pluginsUtils_1.mergeGlobalData)((0, pluginsUtils_1.aggregateGlobalData)(plugins), allContentLoadedResult.globalData);
+    return { routes, globalData };
+}
+/**
+ * Initializes the plugins and run their lifecycle functions.
+ */
+async function loadPlugins(context) {
+    return utils_1.PerfLogger.async('Load plugins', async () => {
+        const initializedPlugins = await utils_1.PerfLogger.async('Init plugins', () => (0, init_1.initPlugins)(context));
+        // TODO probably not the ideal place to hardcode those plugins
+        initializedPlugins.push((0, synthetic_1.createBootstrapPlugin)(context), (0, synthetic_1.createMDXFallbackPlugin)(context));
+        const plugins = await executeAllPluginsContentLoading({
+            plugins: initializedPlugins,
+            context,
+        });
+        const allContentLoadedResult = await executeAllPluginsAllContentLoaded({
+            plugins,
+            context,
+        });
+        const { routes, globalData } = mergeResults({
+            plugins,
+            allContentLoadedResult,
+        });
+        return { plugins, routes, globalData };
+    });
+}
+exports.loadPlugins = loadPlugins;
+async function reloadPlugin({ pluginIdentifier, plugins: previousPlugins, context, }) {
+    return utils_1.PerfLogger.async(`Reload plugin ${(0, pluginsUtils_1.formatPluginName)(pluginIdentifier)}`, async () => {
+        const previousPlugin = (0, pluginsUtils_1.getPluginByIdentifier)({
+            plugins: previousPlugins,
+            pluginIdentifier,
+        });
+        const plugin = await executePluginContentLoading({
+            plugin: previousPlugin,
+            context,
+        });
+        /*
+      // TODO Docusaurus v4 - upgrade to Node 20, use array.with()
+      const plugins = previousPlugins.with(
+        previousPlugins.indexOf(previousPlugin),
+        plugin,
+      );
+       */
+        const plugins = [...previousPlugins];
+        plugins[previousPlugins.indexOf(previousPlugin)] = plugin;
+        const allContentLoadedResult = await executeAllPluginsAllContentLoaded({
+            plugins,
+            context,
+        });
+        const { routes, globalData } = mergeResults({
+            plugins,
+            allContentLoadedResult,
+        });
+        return { plugins, routes, globalData };
+    });
+}
+exports.reloadPlugin = reloadPlugin;

package/lib/server/plugins/pluginsUtils.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 { AllContent, GlobalData, InitializedPlugin, LoadedPlugin, PluginIdentifier, RouteConfig } from '@docusaurus/types';
+export declare function getPluginByIdentifier<P extends InitializedPlugin>({ plugins, pluginIdentifier, }: {
+    pluginIdentifier: PluginIdentifier;
+    plugins: P[];
+}): P;
+export declare function aggregateAllContent(loadedPlugins: LoadedPlugin[]): AllContent;
+export declare function aggregateRoutes(loadedPlugins: LoadedPlugin[]): RouteConfig[];
+export declare function aggregateGlobalData(loadedPlugins: LoadedPlugin[]): GlobalData;
+export declare function mergeGlobalData(...globalDataList: GlobalData[]): GlobalData;
+export declare function formatPluginName(plugin: InitializedPlugin | PluginIdentifier): string;

package/lib/server/plugins/pluginsUtils.js

@@ -0,0 +1,75 @@
+"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.formatPluginName = exports.mergeGlobalData = exports.aggregateGlobalData = exports.aggregateRoutes = exports.aggregateAllContent = exports.getPluginByIdentifier = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
+function getPluginByIdentifier({ plugins, pluginIdentifier, }) {
+    const plugin = plugins.find((p) => p.name === pluginIdentifier.name && p.options.id === pluginIdentifier.id);
+    if (!plugin) {
+        throw new Error(logger_1.default.interpolate `Plugin not found for identifier ${formatPluginName(pluginIdentifier)}`);
+    }
+    return plugin;
+}
+exports.getPluginByIdentifier = getPluginByIdentifier;
+function aggregateAllContent(loadedPlugins) {
+    return lodash_1.default.chain(loadedPlugins)
+        .groupBy((item) => item.name)
+        .mapValues((nameItems) => lodash_1.default.chain(nameItems)
+        .groupBy((item) => item.options.id)
+        .mapValues((idItems) => idItems[0].content)
+        .value())
+        .value();
+}
+exports.aggregateAllContent = aggregateAllContent;
+function aggregateRoutes(loadedPlugins) {
+    return loadedPlugins.flatMap((p) => p.routes);
+}
+exports.aggregateRoutes = aggregateRoutes;
+function aggregateGlobalData(loadedPlugins) {
+    const globalData = {};
+    loadedPlugins.forEach((plugin) => {
+        var _a;
+        if (plugin.globalData !== undefined) {
+            globalData[_a = plugin.name] ?? (globalData[_a] = {});
+            globalData[plugin.name][plugin.options.id] = plugin.globalData;
+        }
+    });
+    return globalData;
+}
+exports.aggregateGlobalData = aggregateGlobalData;
+function mergeGlobalData(...globalDataList) {
+    const result = {};
+    const allPluginIdentifiers = globalDataList.flatMap((gd) => Object.keys(gd).flatMap((name) => Object.keys(gd[name]).map((id) => ({ name, id }))));
+    allPluginIdentifiers.forEach(({ name, id }) => {
+        const allData = globalDataList
+            .map((gd) => gd?.[name]?.[id])
+            .filter((d) => typeof d !== 'undefined');
+        const mergedData = allData.length === 1 ? allData[0] : Object.assign({}, ...allData);
+        result[name] ?? (result[name] = {});
+        result[name][id] = mergedData;
+    });
+    return result;
+}
+exports.mergeGlobalData = mergeGlobalData;
+// This is primarily useful for colored logging purpose
+// Do not rely on this for logic
+function formatPluginName(plugin) {
+    let formattedName = plugin.name;
+    // Hacky way to reduce string size for logging purpose
+    formattedName = formattedName.replace('docusaurus-plugin-content-', '');
+    formattedName = formattedName.replace('docusaurus-plugin-', '');
+    formattedName = formattedName.replace('docusaurus-theme-', '');
+    formattedName = formattedName.replace('-plugin', '');
+    formattedName = logger_1.default.name(formattedName);
+    const id = 'id' in plugin ? plugin.id : plugin.options.id;
+    const formattedId = logger_1.default.subdue(id);
+    return `${formattedName}@${formattedId}`;
+}
+exports.formatPluginName = formatPluginName;

package/lib/server/plugins/routeConfig.d.ts

@@ -8,4 +8,4 @@ import { type ApplyTrailingSlashParams } from '@docusaurus/utils-common';
 import type { RouteConfig } from '@docusaurus/types';
 /** Recursively applies trailing slash config to all nested routes. */
 export declare function applyRouteTrailingSlash(route: RouteConfig, params: ApplyTrailingSlashParams): RouteConfig;
-export declare function sortConfig(routeConfigs: RouteConfig[], baseUrl?: string): void;
+export declare function sortRoutes(routeConfigs: RouteConfig[], baseUrl?: string): void;

package/lib/server/plugins/routeConfig.js

@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortConfig = exports.applyRouteTrailingSlash = void 0;
+exports.sortRoutes = exports.applyRouteTrailingSlash = void 0;
 const utils_common_1 = require("@docusaurus/utils-common");
 /** Recursively applies trailing slash config to all nested routes. */
 function applyRouteTrailingSlash(route, params) {
@@ -19,7 +19,7 @@ function applyRouteTrailingSlash(route, params) {
     };
 }
 exports.applyRouteTrailingSlash = applyRouteTrailingSlash;
-function sortConfig(routeConfigs, baseUrl = '/') {
+function sortRoutes(routeConfigs, baseUrl = '/') {
     // Sort the route config. This ensures that route with nested
     // routes is always placed last.
     routeConfigs.sort((a, b) => {
@@ -49,8 +49,8 @@ function sortConfig(routeConfigs, baseUrl = '/') {
     });
     routeConfigs.forEach((routeConfig) => {
         if (routeConfig.routes) {
-            sortConfig(routeConfig.routes, baseUrl);
+            sortRoutes(routeConfig.routes, baseUrl);
         }
     });
 }
-exports.sortConfig = sortConfig;
+exports.sortRoutes = sortRoutes;

package/lib/server/plugins/synthetic.d.ts

@@ -4,17 +4,17 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import type { LoadedPlugin, LoadContext } from '@docusaurus/types';
+import type { LoadContext, InitializedPlugin } from '@docusaurus/types';
 /**
  * Make a synthetic plugin to:
  * - Inject site client modules
  * - Inject scripts/stylesheets
  */
-export declare function createBootstrapPlugin({ siteDir, siteConfig, }: LoadContext): LoadedPlugin;
+export declare function createBootstrapPlugin({ siteDir, siteConfig, }: LoadContext): InitializedPlugin;
 /**
  * Configure Webpack fallback mdx loader for md/mdx files out of content-plugin
  * folders. Adds a "fallback" mdx loader for mdx files that are not processed by
  * content plugins. This allows to do things such as importing repo/README.md as
  * a partial from another doc. Not ideal solution, but good enough for now
  */
-export declare function createMDXFallbackPlugin({ siteDir, siteConfig, }: LoadContext): LoadedPlugin;
+export declare function createMDXFallbackPlugin({ siteDir, siteConfig, }: LoadContext): InitializedPlugin;

package/lib/server/plugins/synthetic.js

@@ -18,7 +18,6 @@ function createBootstrapPlugin({ siteDir, siteConfig, }) {
     const { stylesheets, scripts, headTags, clientModules: siteConfigClientModules, } = siteConfig;
     return {
         name: 'docusaurus-bootstrap-plugin',
-        content: null,
         options: {
             id: 'default',
         },
@@ -61,7 +60,6 @@ exports.createBootstrapPlugin = createBootstrapPlugin;
 function createMDXFallbackPlugin({ siteDir, siteConfig, }) {
     return {
         name: 'docusaurus-mdx-fallback-plugin',
-        content: null,
         options: {
             id: 'default',
         },

package/lib/server/routes.d.ts

@@ -4,48 +4,6 @@
  * 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, ReportingSeverity } from '@docusaurus/types';
-type LoadedRoutes = {
-    /** 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;
-    };
-    /**
-     * Collect all page paths for injecting it later in the plugin lifecycle.
-     * This is useful for plugins like sitemaps, redirects etc... Only collects
-     * "actual" pages, i.e. those without subroutes, because if a route has
-     * subroutes, it is probably a wrapper.
-     */
-    routesPaths: 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;
-export declare function handleDuplicateRoutes(pluginsRouteConfigs: RouteConfig[], onDuplicateRoutes: ReportingSeverity): void;
-/**
- * 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 loadRoutes(routeConfigs: RouteConfig[], baseUrl: string, onDuplicateRoutes: ReportingSeverity): LoadedRoutes;
-export {};
+import type { RouteConfig, ReportingSeverity } from '@docusaurus/types';
+export declare function handleDuplicateRoutes(routes: RouteConfig[], onDuplicateRoutes: ReportingSeverity): void;
+export declare function getRoutesPaths(routeConfigs: RouteConfig[], baseUrl: string): string[];

package/lib/server/routes.js

@@ -6,115 +6,15 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadRoutes = exports.handleDuplicateRoutes = exports.genChunkName = void 0;
+exports.getRoutesPaths = exports.handleDuplicateRoutes = void 0;
 const tslib_1 = require("tslib");
-const querystring_1 = tslib_1.__importDefault(require("querystring"));
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
 const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
 const utils_1 = require("@docusaurus/utils");
-const utils_2 = require("./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));
-}
-function handleDuplicateRoutes(pluginsRouteConfigs, onDuplicateRoutes) {
+function handleDuplicateRoutes(routes, onDuplicateRoutes) {
     if (onDuplicateRoutes === 'ignore') {
         return;
     }
-    const allRoutes = (0, utils_2.getAllFinalRoutes)(pluginsRouteConfigs).map((routeConfig) => routeConfig.path);
+    const allRoutes = (0, utils_1.flattenRoutes)(routes).map((routeConfig) => routeConfig.path);
     const seenRoutes = new Set();
     const duplicatePaths = allRoutes.filter((route) => {
         if (seenRoutes.has(route)) {
@@ -129,77 +29,25 @@ This could lead to non-deterministic routing behavior.`;
     }
 }
 exports.handleDuplicateRoutes = handleDuplicateRoutes;
-/**
- * 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, ...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)}`);
-    }
-    if (!subroutes) {
-        res.routesPaths.push(routePath);
-    }
-    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,
-    });
-}
 /**
  * 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:
  *
- * - `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.
+ * TODO we should probably deprecate/remove "postBuild({routesPaths})
+ *  The 404 generation handling can be moved to the SSG code
+ *  We only need getAllFinalRoutes() utils IMHO
+ *  This would be a plugin lifecycle breaking change :/
+ *  Although not many plugins probably use this
+ *
  */
-function loadRoutes(routeConfigs, baseUrl, onDuplicateRoutes) {
-    handleDuplicateRoutes(routeConfigs, onDuplicateRoutes);
-    const res = {
-        // To be written by `genRouteCode`
-        routesConfig: '',
-        routesChunkNames: {},
-        registry: {},
-        routesPaths: [(0, utils_1.normalizeUrl)([baseUrl, NotFoundRoutePath])],
-    };
-    // `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;
+const NotFoundRoutePath = '/404.html';
+function getRoutesPaths(routeConfigs, baseUrl) {
+    return [
+        (0, utils_1.normalizeUrl)([baseUrl, NotFoundRoutePath]),
+        ...(0, utils_1.flattenRoutes)(routeConfigs).map((r) => r.path),
+    ];
 }
-exports.loadRoutes = loadRoutes;
+exports.getRoutesPaths = getRoutesPaths;

package/lib/server/{index.d.ts → site.d.ts}

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import type { LoadContext, Props } from '@docusaurus/types';
-export type LoadContextOptions = {
+import type { LoadContext, Props, PluginIdentifier } from '@docusaurus/types';
+export type LoadContextParams = {
     /** Usually the CWD; can be overridden with command argument. */
     siteDir: string;
     /** Custom output directory. Can be customized with `--out-dir` option */
@@ -22,17 +22,24 @@ export type LoadContextOptions = {
      */
     localizePath?: boolean;
 };
+export type LoadSiteParams = LoadContextParams;
+export type Site = {
+    props: Props;
+    params: LoadSiteParams;
+};
 /**
- * Loading context is the very first step in site building. Its options are
+ * Loading context is the very first step in site building. Its params are
  * directly acquired from CLI options. It mainly loads `siteConfig` and the i18n
  * context (which includes code translations). The `LoadContext` will be passed
  * to plugin constructors.
  */
-export declare function loadContext(options: LoadContextOptions): Promise<LoadContext>;
+export declare function loadContext(params: LoadContextParams): Promise<LoadContext>;
 /**
  * This is the crux of the Docusaurus server-side. It reads everything it needs—
  * code translations, config file, plugin modules... Plugins then use their
  * lifecycles to generate content and other data. It is side-effect-ful because
  * it generates temp files in the `.docusaurus` folder for the bundler.
  */
-export declare function load(options: LoadContextOptions): Promise<Props>;
+export declare function loadSite(params: LoadContextParams): Promise<Site>;
+export declare function reloadSite(site: Site): Promise<Site>;
+export declare function reloadSitePlugin(site: Site, pluginIdentifier: PluginIdentifier): Promise<Site>;