@docusaurus/core 3.1.0 → 3.2.0

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/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/i18n.js

@@ -14,13 +14,31 @@ function getDefaultLocaleLabel(locale) {
     const languageName = new Intl.DisplayNames(locale, { type: 'language' }).of(locale);
     return (languageName.charAt(0).toLocaleUpperCase(locale) + languageName.substring(1));
 }
+function getDefaultCalendar(localeStr) {
+    const locale = new Intl.Locale(localeStr);
+    // If the locale name includes -u-ca-xxx the calendar will be defined
+    if (locale.calendar) {
+        return locale.calendar;
+    }
+    // Not well-supported but server code can infer a calendar from the locale
+    // See https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Global_Objects/Intl/Locale/getCalendars
+    // See https://caniuse.com/mdn-javascript_builtins_intl_locale_getcalendars
+    const calendars = 
+    // @ts-expect-error: new std method (Bun/JSC/WebKit)
+    locale.getCalendars?.() ??
+        // @ts-expect-error: non-std attribute (V8/Chromium/Node)
+        locale.calendars;
+    if (calendars instanceof Array && calendars[0]) {
+        return calendars[0];
+    }
+    return 'gregory';
+}
 function getDefaultLocaleConfig(locale) {
     return {
         label: getDefaultLocaleLabel(locale),
         direction: (0, rtl_detect_1.getLangDir)(locale),
         htmlLang: locale,
-        // If the locale name includes -u-ca-xxx the calendar will be defined
-        calendar: new Intl.Locale(locale).calendar ?? 'gregory',
+        calendar: getDefaultCalendar(locale),
         path: locale,
     };
 }

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

@@ -0,0 +1,19 @@
+/**
+ * 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 { InitializedPlugin, PluginContentLoadedActions, RouteConfig } from '@docusaurus/types';
+type PluginActionUtils = {
+    getRoutes: () => RouteConfig[];
+    getGlobalData: () => unknown;
+    getActions: () => PluginContentLoadedActions;
+};
+export declare function createPluginActionsUtils({ plugin, generatedFilesDir, baseUrl, trailingSlash, }: {
+    plugin: InitializedPlugin;
+    generatedFilesDir: string;
+    baseUrl: string;
+    trailingSlash: boolean | undefined;
+}): Promise<PluginActionUtils>;
+export {};

package/lib/server/plugins/actions.js

@@ -0,0 +1,62 @@
+"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.createPluginActionsUtils = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const utils_1 = require("@docusaurus/utils");
+const routeConfig_1 = require("./routeConfig");
+// TODO refactor historical action system and make this side-effect-free
+//  If the function were pure, we could more easily compare previous/next values
+//  on site reloads, and bail-out of the reload process earlier
+//  Particularly, createData() modules should rather be declarative
+async function createPluginActionsUtils({ plugin, generatedFilesDir, baseUrl, trailingSlash, }) {
+    const pluginId = plugin.options.id;
+    // Plugins data files are namespaced by pluginName/pluginId
+    const dataDir = path_1.default.join(generatedFilesDir, plugin.name, pluginId);
+    const pluginRouteContext = {
+        name: plugin.name,
+        id: pluginId,
+    };
+    const pluginRouteContextModulePath = path_1.default.join(dataDir, `${(0, utils_1.docuHash)('pluginRouteContextModule')}.json`);
+    // TODO not ideal place to generate that file
+    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, {
+                baseUrl,
+                trailingSlash,
+            });
+            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;
+        },
+    };
+    return {
+        // Some variables are mutable, so we expose a getter instead of the value
+        getRoutes: () => routes,
+        getGlobalData: () => globalData,
+        getActions: () => actions,
+    };
+}
+exports.createPluginActionsUtils = createPluginActionsUtils;

package/lib/server/plugins/init.js

@@ -40,10 +40,10 @@ async function initPlugins(context) {
     // we are using `require.resolve` on those module names.
     const pluginRequire = (0, module_1.createRequire)(context.siteConfigPath);
     const pluginConfigs = await (0, configs_1.loadPluginConfigs)(context);
-    async function doGetPluginVersion(normalizedPluginConfig) {
+    async function doLoadPluginVersion(normalizedPluginConfig) {
         if (normalizedPluginConfig.pluginModule?.path) {
             const pluginPath = pluginRequire.resolve(normalizedPluginConfig.pluginModule.path);
-            return (0, siteMetadata_1.getPluginVersion)(pluginPath, context.siteDir);
+            return (0, siteMetadata_1.loadPluginVersion)(pluginPath, context.siteDir);
         }
         return { type: 'local' };
     }
@@ -73,7 +73,7 @@ async function initPlugins(context) {
         };
     }
     async function initializePlugin(normalizedPluginConfig) {
-        const pluginVersion = await doGetPluginVersion(normalizedPluginConfig);
+        const pluginVersion = await doLoadPluginVersion(normalizedPluginConfig);
         const pluginOptions = doValidatePluginOptions(normalizedPluginConfig);
         // Side-effect: merge the normalized theme config in the original one
         context.siteConfig.themeConfig = {

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

@@ -0,0 +1,21 @@
+/**
+ * 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 { LoadContext, RouteConfig, GlobalData, PluginIdentifier, LoadedPlugin } from '@docusaurus/types';
+export type LoadPluginsResult = {
+    plugins: LoadedPlugin[];
+    routes: RouteConfig[];
+    globalData: GlobalData;
+};
+/**
+ * Initializes the plugins and run their lifecycle functions.
+ */
+export declare function loadPlugins(context: LoadContext): Promise<LoadPluginsResult>;
+export declare function reloadPlugin({ pluginIdentifier, plugins: previousPlugins, context, }: {
+    pluginIdentifier: PluginIdentifier;
+    plugins: LoadedPlugin[];
+    context: LoadContext;
+}): Promise<LoadPluginsResult>;

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[];