@docusaurus/core 2.0.0-beta.18 → 2.0.0-beta.19

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

@@ -0,0 +1,51 @@
+/**
+ * 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, PluginModule, PluginOptions } from '@docusaurus/types';
+declare type ImportedPluginModule = PluginModule & {
+    default?: PluginModule;
+};
+export declare type NormalizedPluginConfig = {
+    /**
+     * The default export of the plugin module, or alternatively, what's provided
+     * in the config file as inline plugins. Note that if a file is like:
+     *
+     * ```ts
+     * export default plugin() {...}
+     * export validateOptions() {...}
+     * ```
+     *
+     * Then the static methods may not exist here. `pluginModule.module` will
+     * always take priority.
+     */
+    plugin: PluginModule;
+    /** Options as they are provided in the config, not validated yet. */
+    options: PluginOptions;
+    /** Only available when a string is provided in config. */
+    pluginModule?: {
+        /**
+         * Raw module name as provided in the config. Shorthands have been resolved,
+         * so at least it's directly `require.resolve`able.
+         */
+        path: string;
+        /** Whatever gets imported with `require`. */
+        module: ImportedPluginModule;
+    };
+    /**
+     * Different from `pluginModule.path`, this one is always an absolute path,
+     * used to resolve relative paths returned from lifecycles. If it's an inline
+     * plugin, it will be path to the config file.
+     */
+    entryPath: string;
+};
+/**
+ * Reads the site config's `presets`, `themes`, and `plugins`, imports them, and
+ * normalizes the return value. Plugin configs are ordered, mostly for theme
+ * alias shadowing. Site themes have the highest priority, and preset plugins
+ * are the lowest.
+ */
+export declare function loadPluginConfigs(context: LoadContext): Promise<NormalizedPluginConfig[]>;
+export {};

package/lib/server/plugins/configs.js

@@ -0,0 +1,101 @@
+"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.loadPluginConfigs = void 0;
+const tslib_1 = require("tslib");
+const module_1 = require("module");
+const import_fresh_1 = tslib_1.__importDefault(require("import-fresh"));
+const presets_1 = require("./presets");
+const moduleShorthand_1 = require("./moduleShorthand");
+async function normalizePluginConfig(pluginConfig, configPath, pluginRequire) {
+    // plugins: ["./plugin"]
+    if (typeof pluginConfig === 'string') {
+        const pluginModuleImport = pluginConfig;
+        const pluginPath = pluginRequire.resolve(pluginModuleImport);
+        const pluginModule = (0, import_fresh_1.default)(pluginPath);
+        return {
+            plugin: pluginModule?.default ?? pluginModule,
+            options: {},
+            pluginModule: {
+                path: pluginModuleImport,
+                module: pluginModule,
+            },
+            entryPath: pluginPath,
+        };
+    }
+    // plugins: [() => {...}]
+    if (typeof pluginConfig === 'function') {
+        return {
+            plugin: pluginConfig,
+            options: {},
+            entryPath: configPath,
+        };
+    }
+    // plugins: [
+    //   ["./plugin",options],
+    // ]
+    if (typeof pluginConfig[0] === 'string') {
+        const pluginModuleImport = pluginConfig[0];
+        const pluginPath = pluginRequire.resolve(pluginModuleImport);
+        const pluginModule = (0, import_fresh_1.default)(pluginPath);
+        return {
+            plugin: pluginModule?.default ?? pluginModule,
+            options: pluginConfig[1],
+            pluginModule: {
+                path: pluginModuleImport,
+                module: pluginModule,
+            },
+            entryPath: pluginPath,
+        };
+    }
+    // plugins: [
+    //   [() => {...}, options],
+    // ]
+    return {
+        plugin: pluginConfig[0],
+        options: pluginConfig[1],
+        entryPath: configPath,
+    };
+}
+/**
+ * Reads the site config's `presets`, `themes`, and `plugins`, imports them, and
+ * normalizes the return value. Plugin configs are ordered, mostly for theme
+ * alias shadowing. Site themes have the highest priority, and preset plugins
+ * are the lowest.
+ */
+async function loadPluginConfigs(context) {
+    const preset = await (0, presets_1.loadPresets)(context);
+    const { siteConfig, siteConfigPath } = context;
+    const pluginRequire = (0, module_1.createRequire)(siteConfigPath);
+    function normalizeShorthand(pluginConfig, pluginType) {
+        if (typeof pluginConfig === 'string') {
+            return (0, moduleShorthand_1.resolveModuleName)(pluginConfig, pluginRequire, pluginType);
+        }
+        else if (Array.isArray(pluginConfig) &&
+            typeof pluginConfig[0] === 'string') {
+            return [
+                (0, moduleShorthand_1.resolveModuleName)(pluginConfig[0], pluginRequire, pluginType),
+                pluginConfig[1] ?? {},
+            ];
+        }
+        return pluginConfig;
+    }
+    preset.plugins = preset.plugins.map((plugin) => normalizeShorthand(plugin, 'plugin'));
+    preset.themes = preset.themes.map((theme) => normalizeShorthand(theme, 'theme'));
+    const standalonePlugins = siteConfig.plugins.map((plugin) => normalizeShorthand(plugin, 'plugin'));
+    const standaloneThemes = siteConfig.themes.map((theme) => normalizeShorthand(theme, 'theme'));
+    const pluginConfigs = [
+        ...preset.plugins,
+        ...preset.themes,
+        // Site config should be the highest priority.
+        ...standalonePlugins,
+        ...standaloneThemes,
+    ].filter((x) => Boolean(x));
+    return Promise.all(pluginConfigs.map((pluginConfig) => normalizePluginConfig(pluginConfig, context.siteConfigPath, pluginRequire)));
+}
+exports.loadPluginConfigs = loadPluginConfigs;

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

@@ -4,14 +4,15 @@
  * 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, PluginConfig, RouteConfig, GlobalData, ThemeConfig, LoadedPlugin } from '@docusaurus/types';
-export declare function sortConfig(routeConfigs: RouteConfig[], baseUrl?: string): void;
-export declare function loadPlugins({ pluginConfigs, context, }: {
-    pluginConfigs: PluginConfig[];
-    context: LoadContext;
-}): Promise<{
+import type { LoadContext, RouteConfig, GlobalData, LoadedPlugin } from '@docusaurus/types';
+/**
+ * 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<{
     plugins: LoadedPlugin[];
     pluginsRouteConfigs: RouteConfig[];
     globalData: GlobalData;
-    themeConfigTranslated: ThemeConfig;
 }>;

package/lib/server/plugins/index.js

@@ -6,77 +6,50 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadPlugins = exports.sortConfig = void 0;
+exports.loadPlugins = void 0;
 const tslib_1 = require("tslib");
 const utils_1 = require("@docusaurus/utils");
-const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const path_1 = tslib_1.__importDefault(require("path"));
-const init_1 = tslib_1.__importDefault(require("./init"));
-const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
+const init_1 = require("./init");
+const synthetic_1 = require("./synthetic");
 const lodash_1 = tslib_1.__importDefault(require("lodash"));
 const translations_1 = require("../translations/translations");
-const applyRouteTrailingSlash_1 = tslib_1.__importDefault(require("./applyRouteTrailingSlash"));
-function sortConfig(routeConfigs, baseUrl = '/') {
-    // Sort the route config. This ensures that route with nested
-    // routes is always placed last.
-    routeConfigs.sort((a, b) => {
-        // Root route should get placed last.
-        if (a.path === baseUrl && b.path !== baseUrl) {
-            return 1;
-        }
-        if (a.path !== baseUrl && b.path === baseUrl) {
-            return -1;
-        }
-        if (a.routes && !b.routes) {
-            return 1;
-        }
-        if (!a.routes && b.routes) {
-            return -1;
-        }
-        // Higher priority get placed first.
-        if (a.priority || b.priority) {
-            const priorityA = a.priority || 0;
-            const priorityB = b.priority || 0;
-            const score = priorityB - priorityA;
-            if (score !== 0) {
-                return score;
-            }
-        }
-        return a.path.localeCompare(b.path);
-    });
-    routeConfigs.forEach((routeConfig) => {
-        routeConfig.routes?.sort((a, b) => a.path.localeCompare(b.path));
-    });
-}
-exports.sortConfig = sortConfig;
-async function loadPlugins({ pluginConfigs, context, }) {
+const routeConfig_1 = require("./routeConfig");
+/**
+ * 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) {
     // 1. Plugin Lifecycle - Initialization/Constructor.
-    const plugins = await (0, init_1.default)({
-        pluginConfigs,
-        context,
-    });
+    const plugins = await (0, init_1.initPlugins)(context);
+    plugins.push((0, synthetic_1.createBootstrapPlugin)(context), (0, synthetic_1.createMDXFallbackPlugin)(context));
     // 2. Plugin Lifecycle - loadContent.
     // Currently plugins run lifecycle methods in parallel and are not
     // order-dependent. We could change this in future if there are plugins which
     // need to run in certain order or depend on others for data.
+    // This would also translate theme config and content upfront, given the
+    // translation files that the plugin declares.
     const loadedPlugins = await Promise.all(plugins.map(async (plugin) => {
         const content = await plugin.loadContent?.();
-        return { ...plugin, content };
-    }));
-    const contentLoadedTranslatedPlugins = await Promise.all(loadedPlugins.map(async (contentLoadedPlugin) => {
-        const translationFiles = (await contentLoadedPlugin?.getTranslationFiles?.({
-            content: contentLoadedPlugin.content,
-        })) ?? [];
-        const localizedTranslationFiles = await Promise.all(translationFiles.map((translationFile) => (0, translations_1.localizePluginTranslationFile)({
+        const rawTranslationFiles = (await plugin?.getTranslationFiles?.({ content })) ?? [];
+        const translationFiles = await Promise.all(rawTranslationFiles.map((translationFile) => (0, translations_1.localizePluginTranslationFile)({
             locale: context.i18n.currentLocale,
             siteDir: context.siteDir,
             translationFile,
-            plugin: contentLoadedPlugin,
+            plugin,
         })));
-        return {
-            ...contentLoadedPlugin,
-            translationFiles: localizedTranslationFiles,
-        };
+        const translatedContent = plugin.translateContent?.({ content, translationFiles }) ?? content;
+        const translatedThemeConfigSlice = plugin.translateThemeConfig?.({
+            themeConfig: context.siteConfig.themeConfig,
+            translationFiles,
+        });
+        // 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 };
     }));
     const allContent = lodash_1.default.chain(loadedPlugins)
         .groupBy((item) => item.name)
@@ -88,95 +61,47 @@ async function loadPlugins({ pluginConfigs, context, }) {
     // 3. Plugin Lifecycle - contentLoaded.
     const pluginsRouteConfigs = [];
     const globalData = {};
-    await Promise.all(contentLoadedTranslatedPlugins.map(async ({ content, translationFiles, ...plugin }) => {
+    await Promise.all(loadedPlugins.map(async ({ content, ...plugin }) => {
         if (!plugin.contentLoaded) {
             return;
         }
         const pluginId = plugin.options.id;
-        // plugins data files are namespaced by pluginName/pluginId
-        const dataDirRoot = path_1.default.join(context.generatedFilesDir, plugin.name);
-        const dataDir = path_1.default.join(dataDirRoot, pluginId);
-        const createData = async (name, data) => {
-            const modulePath = path_1.default.join(dataDir, name);
-            await fs_extra_1.default.ensureDir(path_1.default.dirname(modulePath));
-            await (0, utils_1.generate)(dataDir, name, data);
-            return modulePath;
-        };
-        // TODO this would be better to do all that in the codegen phase
-        // TODO handle context for nested routes
+        // 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 = {
-            plugin: { name: plugin.name, id: pluginId },
-            data: undefined, // TODO allow plugins to provide context data
-        };
-        const pluginRouteContextModulePath = await createData(`${(0, utils_1.docuHash)('pluginRouteContextModule')}.json`, JSON.stringify(pluginRouteContext, null, 2));
-        const addRoute = (initialRouteConfig) => {
-            // Trailing slash behavior is handled in a generic way for all plugins
-            const finalRouteConfig = (0, applyRouteTrailingSlash_1.default)(initialRouteConfig, {
-                trailingSlash: context.siteConfig.trailingSlash,
-                baseUrl: context.siteConfig.baseUrl,
-            });
-            pluginsRouteConfigs.push({
-                ...finalRouteConfig,
-                modules: {
-                    ...finalRouteConfig.modules,
-                    __routeContextModule: pluginRouteContextModulePath,
-                },
-            });
-        };
-        // the plugins global data are namespaced to avoid data conflicts:
-        // - by plugin name
-        // - by plugin id (allow using multiple instances of the same plugin)
-        const setGlobalData = (data) => {
-            globalData[plugin.name] = globalData[plugin.name] ?? {};
-            globalData[plugin.name][pluginId] = data;
+            name: plugin.name,
+            id: pluginId,
         };
+        await (0, utils_1.generate)('/', pluginRouteContextModulePath, JSON.stringify(pluginRouteContext, null, 2));
         const actions = {
-            addRoute,
-            createData,
-            setGlobalData,
+            addRoute(initialRouteConfig) {
+                // Trailing slash behavior is handled generically for all plugins
+                const finalRouteConfig = (0, routeConfig_1.applyRouteTrailingSlash)(initialRouteConfig, context.siteConfig);
+                pluginsRouteConfigs.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) {
+                var _a;
+                globalData[_a = plugin.name] ?? (globalData[_a] = {});
+                globalData[plugin.name][pluginId] = data;
+            },
         };
-        const translatedContent = plugin.translateContent?.({ content, translationFiles }) ?? content;
-        await plugin.contentLoaded({
-            content: translatedContent,
-            actions,
-            allContent,
-        });
-    }));
-    // 4. Plugin Lifecycle - routesLoaded.
-    // Currently plugins run lifecycle methods in parallel and are not
-    // order-dependent. We could change this in future if there are plugins which
-    // need to run in certain order or depend on others for data.
-    await Promise.all(contentLoadedTranslatedPlugins.map(async (plugin) => {
-        if (!plugin.routesLoaded) {
-            return;
-        }
-        // TODO remove this deprecated lifecycle soon
-        // deprecated since alpha-60
-        // TODO, 1 user reported usage of this lifecycle! https://github.com/facebook/docusaurus/issues/3918
-        logger_1.default.error `Plugin code=${'routesLoaded'} lifecycle is deprecated. If you think we should keep this lifecycle, please report here: path=${'https://github.com/facebook/docusaurus/issues/3918'}`;
-        await plugin.routesLoaded(pluginsRouteConfigs);
+        await plugin.contentLoaded({ content, actions, allContent });
     }));
     // Sort the route config. This ensures that route with nested
     // routes are always placed last.
-    sortConfig(pluginsRouteConfigs, context.siteConfig.baseUrl);
-    // Apply each plugin one after the other to translate the theme config
-    function translateThemeConfig(untranslatedThemeConfig) {
-        return contentLoadedTranslatedPlugins.reduce((currentThemeConfig, plugin) => {
-            const translatedThemeConfigSlice = plugin.translateThemeConfig?.({
-                themeConfig: currentThemeConfig,
-                translationFiles: plugin.translationFiles,
-            });
-            return {
-                ...currentThemeConfig,
-                ...translatedThemeConfigSlice,
-            };
-        }, untranslatedThemeConfig);
-    }
-    return {
-        plugins: loadedPlugins,
-        pluginsRouteConfigs,
-        globalData,
-        themeConfigTranslated: translateThemeConfig(context.siteConfig.themeConfig),
-    };
+    (0, routeConfig_1.sortConfig)(pluginsRouteConfigs, context.siteConfig.baseUrl);
+    return { plugins: loadedPlugins, pluginsRouteConfigs, globalData };
 }
 exports.loadPlugins = loadPlugins;

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

@@ -4,22 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import type { ImportedPluginModule, LoadContext, PluginModule, PluginConfig, PluginOptions, InitializedPlugin } from '@docusaurus/types';
-export declare type NormalizedPluginConfig = {
-    plugin: PluginModule;
-    options: PluginOptions;
-    pluginModule?: {
-        path: string;
-        module: ImportedPluginModule;
-    };
-    /**
-     * Different from pluginModule.path, this one is always an absolute path used
-     * to resolve relative paths returned from lifecycles
-     */
-    entryPath: string;
-};
-export declare function normalizePluginConfigs(pluginConfigs: PluginConfig[], configPath: string): Promise<NormalizedPluginConfig[]>;
-export default function initPlugins({ pluginConfigs, context, }: {
-    pluginConfigs: PluginConfig[];
-    context: LoadContext;
-}): Promise<InitializedPlugin[]>;
+import type { LoadContext, InitializedPlugin } from '@docusaurus/types';
+/**
+ * Runs the plugin constructors and returns their return values. It would load
+ * plugin configs from `plugins`, `themes`, and `presets`.
+ */
+export declare function initPlugins(context: LoadContext): Promise<InitializedPlugin[]>;

package/lib/server/plugins/init.js

@@ -6,73 +6,18 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizePluginConfigs = void 0;
+exports.initPlugins = void 0;
 const tslib_1 = require("tslib");
 const module_1 = require("module");
 const path_1 = tslib_1.__importDefault(require("path"));
-const import_fresh_1 = tslib_1.__importDefault(require("import-fresh"));
 const utils_1 = require("@docusaurus/utils");
-const versions_1 = require("../versions");
+const siteMetadata_1 = require("../siteMetadata");
 const pluginIds_1 = require("./pluginIds");
 const utils_validation_1 = require("@docusaurus/utils-validation");
-async function normalizePluginConfig(pluginConfig, configPath) {
-    const pluginRequire = (0, module_1.createRequire)(configPath);
-    // plugins: ['./plugin']
-    if (typeof pluginConfig === 'string') {
-        const pluginModuleImport = pluginConfig;
-        const pluginPath = pluginRequire.resolve(pluginModuleImport);
-        const pluginModule = (0, import_fresh_1.default)(pluginPath);
-        return {
-            plugin: pluginModule?.default ?? pluginModule,
-            options: {},
-            pluginModule: {
-                path: pluginModuleImport,
-                module: pluginModule,
-            },
-            entryPath: pluginPath,
-        };
-    }
-    // plugins: [function plugin() { }]
-    if (typeof pluginConfig === 'function') {
-        return {
-            plugin: pluginConfig,
-            options: {},
-            entryPath: configPath,
-        };
-    }
-    // plugins: [
-    //   ['./plugin',options],
-    // ]
-    if (typeof pluginConfig[0] === 'string') {
-        const pluginModuleImport = pluginConfig[0];
-        const pluginPath = pluginRequire.resolve(pluginModuleImport);
-        const pluginModule = (0, import_fresh_1.default)(pluginPath);
-        return {
-            plugin: pluginModule?.default ?? pluginModule,
-            options: pluginConfig[1],
-            pluginModule: {
-                path: pluginModuleImport,
-                module: pluginModule,
-            },
-            entryPath: pluginPath,
-        };
-    }
-    // plugins: [
-    //   [function plugin() { },options],
-    // ]
-    return {
-        plugin: pluginConfig[0],
-        options: pluginConfig[1],
-        entryPath: configPath,
-    };
-}
-async function normalizePluginConfigs(pluginConfigs, configPath) {
-    return Promise.all(pluginConfigs.map((pluginConfig) => normalizePluginConfig(pluginConfig, configPath)));
-}
-exports.normalizePluginConfigs = normalizePluginConfigs;
+const configs_1 = require("./configs");
 function getOptionValidationFunction(normalizedPluginConfig) {
     if (normalizedPluginConfig.pluginModule) {
-        // support both commonjs and ES modules
+        // Support both CommonJS and ES modules
         return (normalizedPluginConfig.pluginModule.module?.default?.validateOptions ??
             normalizedPluginConfig.pluginModule.module?.validateOptions);
     }
@@ -80,22 +25,25 @@ function getOptionValidationFunction(normalizedPluginConfig) {
 }
 function getThemeValidationFunction(normalizedPluginConfig) {
     if (normalizedPluginConfig.pluginModule) {
-        // support both commonjs and ES modules
+        // Support both CommonJS and ES modules
         return (normalizedPluginConfig.pluginModule.module.default?.validateThemeConfig ??
             normalizedPluginConfig.pluginModule.module.validateThemeConfig);
     }
     return normalizedPluginConfig.plugin.validateThemeConfig;
 }
-async function initPlugins({ pluginConfigs, context, }) {
-    // We need to resolve plugins from the perspective of the siteDir, since the
-    // siteDir's package.json declares the dependency on these plugins.
+/**
+ * Runs the plugin constructors and returns their return values. It would load
+ * plugin configs from `plugins`, `themes`, and `presets`.
+ */
+async function initPlugins(context) {
+    // We need to resolve plugins from the perspective of the site config, as if
+    // we are using `require.resolve` on those module names.
     const pluginRequire = (0, module_1.createRequire)(context.siteConfigPath);
-    const pluginConfigsNormalized = await normalizePluginConfigs(pluginConfigs, context.siteConfigPath);
+    const pluginConfigs = await (0, configs_1.loadPluginConfigs)(context);
     async function doGetPluginVersion(normalizedPluginConfig) {
-        // get plugin version
         if (normalizedPluginConfig.pluginModule?.path) {
             const pluginPath = pluginRequire.resolve(normalizedPluginConfig.pluginModule?.path);
-            return (0, versions_1.getPluginVersion)(pluginPath, context.siteDir);
+            return (0, siteMetadata_1.getPluginVersion)(pluginPath, context.siteDir);
         }
         return { type: 'local' };
     }
@@ -140,8 +88,8 @@ async function initPlugins({ pluginConfigs, context, }) {
             path: path_1.default.dirname(normalizedPluginConfig.entryPath),
         };
     }
-    const plugins = await Promise.all(pluginConfigsNormalized.map(initializePlugin));
+    const plugins = await Promise.all(pluginConfigs.map(initializePlugin));
     (0, pluginIds_1.ensureUniquePluginInstanceIds)(plugins);
     return plugins;
 }
-exports.default = initPlugins;
+exports.initPlugins = initPlugins;

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

@@ -5,4 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 import type { InitializedPlugin } from '@docusaurus/types';
+/**
+ * It is forbidden to have 2 plugins of the same name sharing the same ID.
+ * This is required to support multi-instance plugins without conflict.
+ */
 export declare function ensureUniquePluginInstanceIds(plugins: InitializedPlugin[]): void;

package/lib/server/plugins/pluginIds.js

@@ -10,8 +10,10 @@ exports.ensureUniquePluginInstanceIds = void 0;
 const tslib_1 = require("tslib");
 const lodash_1 = tslib_1.__importDefault(require("lodash"));
 const utils_1 = require("@docusaurus/utils");
-// It is forbidden to have 2 plugins of the same name sharing the same id
-// this is required to support multi-instance plugins without conflict
+/**
+ * It is forbidden to have 2 plugins of the same name sharing the same ID.
+ * This is required to support multi-instance plugins without conflict.
+ */
 function ensureUniquePluginInstanceIds(plugins) {
     const pluginsByName = lodash_1.default.groupBy(plugins, (p) => p.name);
     Object.entries(pluginsByName).forEach(([pluginName, pluginInstances]) => {

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

@@ -0,0 +1,12 @@
+/**
+ * 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, DocusaurusConfig } from '@docusaurus/types';
+/**
+ * Calls preset functions, aggregates each of their return values, and returns
+ * the plugin and theme configs.
+ */
+export declare function loadPresets(context: LoadContext): Promise<Pick<DocusaurusConfig, 'plugins' | 'themes'>>;

package/lib/server/{presets/index.js → plugins/presets.js}

@@ -6,13 +6,18 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPresets = void 0;
 const tslib_1 = require("tslib");
 const module_1 = require("module");
 const import_fresh_1 = tslib_1.__importDefault(require("import-fresh"));
-const moduleShorthand_1 = require("../moduleShorthand");
+const moduleShorthand_1 = require("./moduleShorthand");
+/**
+ * Calls preset functions, aggregates each of their return values, and returns
+ * the plugin and theme configs.
+ */
 async function loadPresets(context) {
-    // We need to resolve presets from the perspective of the siteDir, since the
-    // siteDir's package.json declares the dependency on these presets.
+    // We need to resolve plugins from the perspective of the site config, as if
+    // we are using `require.resolve` on those module names.
     const presetRequire = (0, module_1.createRequire)(context.siteConfigPath);
     const { presets } = context.siteConfig;
     const plugins = [];
@@ -20,6 +25,9 @@ async function loadPresets(context) {
     presets.forEach((presetItem) => {
         let presetModuleImport;
         let presetOptions = {};
+        if (!presetItem) {
+            return;
+        }
         if (typeof presetItem === 'string') {
             presetModuleImport = presetItem;
         }
@@ -30,12 +38,12 @@ async function loadPresets(context) {
         const presetModule = (0, import_fresh_1.default)(presetRequire.resolve(presetName));
         const preset = (presetModule.default ?? presetModule)(context, presetOptions);
         if (preset.plugins) {
-            plugins.push(...preset.plugins.filter(Boolean));
+            plugins.push(...preset.plugins);
         }
         if (preset.themes) {
-            themes.push(...preset.themes.filter(Boolean));
+            themes.push(...preset.themes);
         }
     });
     return { plugins, themes };
 }
-exports.default = loadPresets;
+exports.loadPresets = loadPresets;

package/lib/server/plugins/{applyRouteTrailingSlash.d.ts → routeConfig.d.ts}

@@ -6,4 +6,6 @@
  */
 import type { RouteConfig } from '@docusaurus/types';
 import { type ApplyTrailingSlashParams } from '@docusaurus/utils-common';
-export default function applyRouteTrailingSlash(route: RouteConfig, params: ApplyTrailingSlashParams): RouteConfig;
+/** 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;