@docusaurus/core 0.0.0-5857 → 0.0.0-5860

package/lib/server/brokenLinks.js

@@ -12,7 +12,7 @@ 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");
+const routes_1 = require("./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.
@@ -127,7 +127,7 @@ function getBrokenLinksForPage({ pagePath, helper, }) {
  */
 function filterIntermediateRoutes(routesInput) {
     const routesWithout404 = routesInput.filter((route) => route.path !== '*');
-    return (0, utils_2.getAllFinalRoutes)(routesWithout404);
+    return (0, routes_1.getAllFinalRoutes)(routesWithout404);
 }
 function getBrokenLinks({ collectedLinks, routes, }) {
     const filteredRoutes = filterIntermediateRoutes(routes);

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, ...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/i18n.d.ts

@@ -5,6 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 import type { I18n, DocusaurusConfig, I18nLocaleConfig } from '@docusaurus/types';
-import type { LoadContextOptions } from './index';
+import type { LoadContextParams } from './site';
 export declare function getDefaultLocaleConfig(locale: string): I18nLocaleConfig;
-export declare function loadI18n(config: DocusaurusConfig, options: Pick<LoadContextOptions, 'locale'>): Promise<I18n>;
+export declare function loadI18n(config: DocusaurusConfig, options: Pick<LoadContextParams, 'locale'>): Promise<I18n>;

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

@@ -5,14 +5,25 @@
  * LICENSE file in the root directory of this source tree.
  */
 import type { LoadContext, RouteConfig, GlobalData, LoadedPlugin } from '@docusaurus/types';
+import type { PluginIdentifier } from '@docusaurus/types/src/plugin';
+export type LoadPluginsResult = {
+    plugins: LoadedPlugin[];
+    routes: RouteConfig[];
+    globalData: GlobalData;
+};
 /**
  * Initializes the plugins, runs `loadContent`, `translateContent`,
  * `contentLoaded`, and `translateThemeConfig`. Because `contentLoaded` is
  * side-effect-ful (it generates temp files), so is this function. This function
  * would also mutate `context.siteConfig.themeConfig` to translate it.
  */
-export declare function loadPlugins(context: LoadContext): Promise<{
+export declare function loadPlugins(context: LoadContext): Promise<LoadPluginsResult>;
+export declare function getPluginByIdentifier({ plugins, pluginIdentifier, }: {
+    pluginIdentifier: PluginIdentifier;
     plugins: LoadedPlugin[];
-    pluginsRouteConfigs: RouteConfig[];
-    globalData: GlobalData;
-}>;
+}): LoadedPlugin;
+export declare function reloadPlugin({ pluginIdentifier, plugins, context, }: {
+    pluginIdentifier: PluginIdentifier;
+    plugins: LoadedPlugin[];
+    context: LoadContext;
+}): Promise<LoadPluginsResult>;

package/lib/server/plugins/plugins.js

@@ -0,0 +1,176 @@
+"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.getPluginByIdentifier = exports.loadPlugins = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const utils_1 = require("@docusaurus/utils");
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
+const init_1 = require("./init");
+const synthetic_1 = require("./synthetic");
+const translations_1 = require("../translations/translations");
+const routeConfig_1 = require("./routeConfig");
+const utils_2 = require("../../utils");
+async function translatePlugin({ plugin, context, }) {
+    const { content } = plugin;
+    const rawTranslationFiles = (await plugin.getTranslationFiles?.({ content: plugin.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 { ...plugin, content: translatedContent };
+}
+async function executePluginLoadContent({ plugin, context, }) {
+    return utils_2.PerfLogger.async(`Plugin - loadContent - ${plugin.name}@${plugin.options.id}`, async () => {
+        const content = await plugin.loadContent?.();
+        const loadedPlugin = { ...plugin, content };
+        return translatePlugin({ plugin: loadedPlugin, context });
+    });
+}
+async function executePluginsLoadContent({ plugins, context, }) {
+    return utils_2.PerfLogger.async(`Plugins - loadContent`, () => Promise.all(plugins.map((plugin) => executePluginLoadContent({ plugin, context }))));
+}
+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();
+}
+// TODO refactor and make this side-effect-free
+//  If the function was pure, we could more easily compare previous/next values
+//  on site reloads, and bail-out of the reload process earlier
+//  createData() modules should rather be declarative
+async function executePluginContentLoaded({ plugin, context, allContent, }) {
+    return utils_2.PerfLogger.async(`Plugins - contentLoaded - ${plugin.name}@${plugin.options.id}`, async () => {
+        if (!plugin.contentLoaded) {
+            return { routes: [], globalData: undefined };
+        }
+        const pluginId = plugin.options.id;
+        // Plugins data files are namespaced by pluginName/pluginId
+        const dataDir = path_1.default.join(context.generatedFilesDir, plugin.name, pluginId);
+        const pluginRouteContextModulePath = path_1.default.join(dataDir, `${(0, utils_1.docuHash)('pluginRouteContextModule')}.json`);
+        const pluginRouteContext = {
+            name: plugin.name,
+            id: pluginId,
+        };
+        await (0, utils_1.generate)('/', pluginRouteContextModulePath, JSON.stringify(pluginRouteContext, null, 2));
+        const routes = [];
+        let globalData;
+        const actions = {
+            addRoute(initialRouteConfig) {
+                // Trailing slash behavior is handled generically for all plugins
+                const finalRouteConfig = (0, routeConfig_1.applyRouteTrailingSlash)(initialRouteConfig, context.siteConfig);
+                routes.push({
+                    ...finalRouteConfig,
+                    context: {
+                        ...(finalRouteConfig.context && { data: finalRouteConfig.context }),
+                        plugin: pluginRouteContextModulePath,
+                    },
+                });
+            },
+            async createData(name, data) {
+                const modulePath = path_1.default.join(dataDir, name);
+                await (0, utils_1.generate)(dataDir, name, data);
+                return modulePath;
+            },
+            setGlobalData(data) {
+                globalData = data;
+            },
+        };
+        await plugin.contentLoaded({
+            content: plugin.content,
+            actions,
+            allContent,
+        });
+        return { routes, globalData };
+    });
+}
+async function executePluginsContentLoaded({ plugins, context, }) {
+    return utils_2.PerfLogger.async(`Plugins - contentLoaded`, async () => {
+        const allContent = aggregateAllContent(plugins);
+        const routes = [];
+        const globalData = {};
+        await Promise.all(plugins.map(async (plugin) => {
+            var _a;
+            const { routes: pluginRoutes, globalData: pluginGlobalData } = await executePluginContentLoaded({
+                plugin,
+                context,
+                allContent,
+            });
+            routes.push(...pluginRoutes);
+            if (pluginGlobalData !== undefined) {
+                globalData[_a = plugin.name] ?? (globalData[_a] = {});
+                globalData[plugin.name][plugin.options.id] = pluginGlobalData;
+            }
+        }));
+        // Sort the route config.
+        // This ensures that route with sub routes are always placed last.
+        (0, routeConfig_1.sortRoutes)(routes, context.siteConfig.baseUrl);
+        return { routes, globalData };
+    });
+}
+/**
+ * Initializes the plugins, runs `loadContent`, `translateContent`,
+ * `contentLoaded`, and `translateThemeConfig`. Because `contentLoaded` is
+ * side-effect-ful (it generates temp files), so is this function. This function
+ * would also mutate `context.siteConfig.themeConfig` to translate it.
+ */
+async function loadPlugins(context) {
+    return utils_2.PerfLogger.async('Plugins - loadPlugins', async () => {
+        // 1. Plugin Lifecycle - Initialization/Constructor.
+        const plugins = await utils_2.PerfLogger.async('Plugins - initPlugins', () => (0, init_1.initPlugins)(context));
+        plugins.push((0, synthetic_1.createBootstrapPlugin)(context), (0, synthetic_1.createMDXFallbackPlugin)(context));
+        // 2. Plugin Lifecycle - loadContent.
+        const loadedPlugins = await executePluginsLoadContent({ plugins, context });
+        // 3. Plugin Lifecycle - contentLoaded.
+        const { routes, globalData } = await executePluginsContentLoaded({
+            plugins: loadedPlugins,
+            context,
+        });
+        return { plugins: loadedPlugins, routes, globalData };
+    });
+}
+exports.loadPlugins = loadPlugins;
+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 ${pluginIdentifier.name}@${pluginIdentifier.id}`);
+    }
+    return plugin;
+}
+exports.getPluginByIdentifier = getPluginByIdentifier;
+async function reloadPlugin({ pluginIdentifier, plugins, context, }) {
+    return utils_2.PerfLogger.async('Plugins - reloadPlugin', async () => {
+        const plugin = getPluginByIdentifier({ plugins, pluginIdentifier });
+        const reloadedPlugin = await executePluginLoadContent({ plugin, context });
+        const newPlugins = plugins.with(plugins.indexOf(plugin), reloadedPlugin);
+        // Unfortunately, due to the "AllContent" data we have to re-execute this
+        // for all plugins, not just the one to reload...
+        const { routes, globalData } = await executePluginsContentLoaded({
+            plugins: newPlugins,
+            context,
+        });
+        return { plugins: newPlugins, routes, globalData };
+    });
+}
+exports.reloadPlugin = reloadPlugin;

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/routes.d.ts

@@ -4,48 +4,7 @@
  * 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 getAllFinalRoutes(routeConfig: RouteConfig[]): RouteConfig[];
+export declare function handleDuplicateRoutes(routes: RouteConfig[], onDuplicateRoutes: ReportingSeverity): void;
+export declare function getRoutesPaths(routeConfigs: RouteConfig[], baseUrl: string): string[];