@docusaurus/core 0.0.0-4799 → 0.0.0-4800

package/lib/server/plugins/index.js

@@ -17,6 +17,10 @@ const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
 const lodash_1 = tslib_1.__importDefault(require("lodash"));
 const translations_1 = require("../translations/translations");
 const routeConfig_1 = require("./routeConfig");
+/**
+ * Initializes the plugins, runs `loadContent`, `translateContent`,
+ * `contentLoaded`, and `translateThemeConfig`.
+ */
 async function loadPlugins(context) {
     // 1. Plugin Lifecycle - Initialization/Constructor.
     const plugins = await (0, init_1.initPlugins)(context);
@@ -29,18 +33,18 @@ async function loadPlugins(context) {
         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 contentLoadedTranslatedPlugins = await Promise.all(loadedPlugins.map(async (plugin) => {
+        const translationFiles = (await plugin?.getTranslationFiles?.({
+            content: plugin.content,
         })) ?? [];
         const localizedTranslationFiles = await Promise.all(translationFiles.map((translationFile) => (0, translations_1.localizePluginTranslationFile)({
             locale: context.i18n.currentLocale,
             siteDir: context.siteDir,
             translationFile,
-            plugin: contentLoadedPlugin,
+            plugin,
         })));
         return {
-            ...contentLoadedPlugin,
+            ...plugin,
             translationFiles: localizedTranslationFiles,
         };
     }));
@@ -109,9 +113,6 @@ async function loadPlugins(context) {
         });
     }));
     // 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;
@@ -126,23 +127,21 @@ async function loadPlugins(context) {
     // routes are always placed last.
     (0, routeConfig_1.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);
-    }
+    const themeConfigTranslated = contentLoadedTranslatedPlugins.reduce((currentThemeConfig, plugin) => {
+        const translatedThemeConfigSlice = plugin.translateThemeConfig?.({
+            themeConfig: currentThemeConfig,
+            translationFiles: plugin.translationFiles,
+        });
+        return {
+            ...currentThemeConfig,
+            ...translatedThemeConfigSlice,
+        };
+    }, context.siteConfig.themeConfig);
     return {
         plugins: loadedPlugins,
         pluginsRouteConfigs,
         globalData,
-        themeConfigTranslated: translateThemeConfig(context.siteConfig.themeConfig),
+        themeConfigTranslated,
     };
 }
 exports.loadPlugins = loadPlugins;

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

@@ -4,19 +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[]>;
+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,71 +6,15 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initPlugins = 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 siteMetadata_1 = require("../siteMetadata");
 const pluginIds_1 = require("./pluginIds");
 const utils_validation_1 = require("@docusaurus/utils-validation");
 const configs_1 = require("./configs");
-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;
 function getOptionValidationFunction(normalizedPluginConfig) {
     if (normalizedPluginConfig.pluginModule) {
         // support both commonjs and ES modules
@@ -87,12 +31,15 @@ function getThemeValidationFunction(normalizedPluginConfig) {
     }
     return normalizedPluginConfig.plugin.validateThemeConfig;
 }
+/**
+ * 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 siteDir, since the
-    // siteDir's package.json declares the dependency on these plugins.
+    // 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 pluginConfigs = await (0, configs_1.loadPluginConfigs)(context);
-    const pluginConfigsNormalized = await normalizePluginConfigs(pluginConfigs, context.siteConfigPath);
     async function doGetPluginVersion(normalizedPluginConfig) {
         // get plugin version
         if (normalizedPluginConfig.pluginModule?.path) {
@@ -142,7 +89,7 @@ async function initPlugins(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;
 }

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

@@ -4,8 +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 { LoadContext, PluginConfig } from '@docusaurus/types';
-export declare function loadPresets(context: LoadContext): Promise<{
-    plugins: PluginConfig[];
-    themes: PluginConfig[];
-}>;
+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/plugins/presets.js

@@ -10,10 +10,14 @@ 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 = [];

package/lib/server/routes.d.ts

@@ -4,8 +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 { ChunkRegistry, RouteConfig, ChunkNames } from '@docusaurus/types';
-export declare function loadRoutes(pluginsRouteConfigs: RouteConfig[], baseUrl: string): Promise<{
+import type { ChunkRegistry, RouteConfig, ChunkNames, ReportingSeverity } from '@docusaurus/types';
+export declare function handleDuplicateRoutes(pluginsRouteConfigs: RouteConfig[], onDuplicateRoutes: ReportingSeverity): void;
+export declare function loadRoutes(pluginsRouteConfigs: RouteConfig[], baseUrl: string, onDuplicateRoutes: ReportingSeverity): Promise<{
     registry: {
         [chunkName: string]: ChunkRegistry;
     };

package/lib/server/routes.js

@@ -6,9 +6,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadRoutes = void 0;
+exports.loadRoutes = exports.handleDuplicateRoutes = void 0;
 const utils_1 = require("@docusaurus/utils");
 const querystring_1 = require("querystring");
+const utils_2 = require("./utils");
 function indent(str) {
     const spaces = '  ';
     return `${spaces}${str.replace(/\n/g, `\n${spaces}`)}`;
@@ -78,7 +79,53 @@ function getModulePath(target) {
     const queryStr = target.query ? `?${(0, querystring_1.stringify)(target.query)}` : '';
     return `${target.path}${queryStr}`;
 }
-async function loadRoutes(pluginsRouteConfigs, baseUrl) {
+function genRouteChunkNames(
+// TODO instead of passing a mutating the registry, return a registry slice?
+registry, value, prefix, name) {
+    if (!value) {
+        return null;
+    }
+    if (Array.isArray(value)) {
+        return value.map((val, index) => genRouteChunkNames(registry, val, `${index}`, name));
+    }
+    if (isModule(value)) {
+        const modulePath = getModulePath(value);
+        const chunkName = (0, utils_1.genChunkName)(modulePath, prefix, name);
+        const loader = `() => import(/* webpackChunkName: '${chunkName}' */ '${(0, utils_1.escapePath)(modulePath)}')`;
+        registry[chunkName] = { loader, modulePath };
+        return chunkName;
+    }
+    const newValue = {};
+    Object.entries(value).forEach(([key, v]) => {
+        newValue[key] = genRouteChunkNames(registry, v, key, name);
+    });
+    return newValue;
+}
+function handleDuplicateRoutes(pluginsRouteConfigs, onDuplicateRoutes) {
+    if (onDuplicateRoutes === 'ignore') {
+        return;
+    }
+    const allRoutes = (0, utils_2.getAllFinalRoutes)(pluginsRouteConfigs).map((routeConfig) => routeConfig.path);
+    const seenRoutes = new Set();
+    const duplicatePaths = allRoutes.filter((route) => {
+        if (seenRoutes.has(route)) {
+            return true;
+        }
+        seenRoutes.add(route);
+        return false;
+    });
+    if (duplicatePaths.length > 0) {
+        const finalMessage = `Duplicate routes found!
+${duplicatePaths
+            .map((duplicateRoute) => `- Attempting to create page at ${duplicateRoute}, but a page already exists at this route.`)
+            .join('\n')}
+This could lead to non-deterministic routing behavior.`;
+        (0, utils_1.reportMessage)(finalMessage, onDuplicateRoutes);
+    }
+}
+exports.handleDuplicateRoutes = handleDuplicateRoutes;
+async function loadRoutes(pluginsRouteConfigs, baseUrl, onDuplicateRoutes) {
+    handleDuplicateRoutes(pluginsRouteConfigs, onDuplicateRoutes);
     const registry = {};
     const routesPaths = [(0, utils_1.normalizeUrl)([baseUrl, '404.html'])];
     const routesChunkNames = {};
@@ -129,25 +176,3 @@ ${indent(NotFoundRouteCode)}
     };
 }
 exports.loadRoutes = loadRoutes;
-function genRouteChunkNames(
-// TODO instead of passing a mutating the registry, return a registry slice?
-registry, value, prefix, name) {
-    if (!value) {
-        return null;
-    }
-    if (Array.isArray(value)) {
-        return value.map((val, index) => genRouteChunkNames(registry, val, `${index}`, name));
-    }
-    if (isModule(value)) {
-        const modulePath = getModulePath(value);
-        const chunkName = (0, utils_1.genChunkName)(modulePath, prefix, name);
-        const loader = `() => import(/* webpackChunkName: '${chunkName}' */ '${(0, utils_1.escapePath)(modulePath)}')`;
-        registry[chunkName] = { loader, modulePath };
-        return chunkName;
-    }
-    const newValue = {};
-    Object.entries(value).forEach(([key, v]) => {
-        newValue[key] = genRouteChunkNames(registry, v, key, name);
-    });
-    return newValue;
-}

package/lib/server/siteMetadata.d.ts

@@ -4,9 +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 { LoadedPlugin, PluginVersionInformation, DocusaurusSiteMetadata } from '@docusaurus/types';
+import type { LoadedPlugin, PluginVersionInformation, SiteMetadata } from '@docusaurus/types';
 export declare function getPluginVersion(pluginPath: string, siteDir: string): Promise<PluginVersionInformation>;
 export declare function loadSiteMetadata({ plugins, siteDir, }: {
     plugins: LoadedPlugin[];
     siteDir: string;
-}): Promise<DocusaurusSiteMetadata>;
+}): Promise<SiteMetadata>;

package/lib/server/siteMetadata.js

@@ -42,7 +42,8 @@ async function getPluginVersion(pluginPath, siteDir) {
         potentialPluginPackageJsonDirectory = path_1.default.dirname(potentialPluginPackageJsonDirectory);
     }
     // In the case where a plugin is a path where no parent directory contains
-    // package.json (e.g. inline plugin), we can only classify it as local.
+    // package.json, we can only classify it as local. Could happen if one puts a
+    // script in the parent directory of the site.
     return { type: 'local' };
 }
 exports.getPluginVersion = getPluginVersion;

package/lib/server/translations/translations.js

@@ -80,11 +80,8 @@ Maybe you should remove them? ${unknownKeys}`;
     }
 }
 // should we make this configurable?
-function getTranslationsDirPath(context) {
-    return path_1.default.join(context.siteDir, utils_1.I18N_DIR_NAME);
-}
 function getTranslationsLocaleDirPath(context) {
-    return path_1.default.join(getTranslationsDirPath(context), context.locale);
+    return path_1.default.join(context.siteDir, utils_1.I18N_DIR_NAME, context.locale);
 }
 exports.getTranslationsLocaleDirPath = getTranslationsLocaleDirPath;
 function getCodeTranslationsFilePath(context) {

package/lib/webpack/aliases/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 { ThemeAliases, LoadedPlugin } from '@docusaurus/types';
+/**
+ * Order of Webpack aliases is important because one alias can shadow another.
+ * This ensures `@theme/NavbarItem` alias is after
+ * `@theme/NavbarItem/LocaleDropdown`.
+ *
+ * @see https://github.com/facebook/docusaurus/pull/3922
+ * @see https://github.com/facebook/docusaurus/issues/5382
+ */
+export declare function sortAliases(aliases: ThemeAliases): ThemeAliases;
+export declare function createAliasesForTheme(themePath: string, addOriginalAlias: boolean): Promise<ThemeAliases>;
+export declare function loadThemeAliases({ siteDir, plugins, }: {
+    siteDir: string;
+    plugins: LoadedPlugin[];
+}): Promise<ThemeAliases>;
+/**
+ * Note: a `@docusaurus` alias would also catch `@docusaurus/theme-common`, so
+ * instead of naively aliasing this to `client/exports`, we use fine-grained
+ * aliases instead.
+ */
+export declare function loadDocusaurusAliases(): Promise<{
+    [aliasName: string]: string;
+}>;

package/lib/webpack/aliases/index.js

@@ -0,0 +1,106 @@
+"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.loadDocusaurusAliases = exports.loadThemeAliases = exports.createAliasesForTheme = exports.sortAliases = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const utils_1 = require("@docusaurus/utils");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const ThemeFallbackDir = path_1.default.join(__dirname, '../../client/theme-fallback');
+/**
+ * Order of Webpack aliases is important because one alias can shadow another.
+ * This ensures `@theme/NavbarItem` alias is after
+ * `@theme/NavbarItem/LocaleDropdown`.
+ *
+ * @see https://github.com/facebook/docusaurus/pull/3922
+ * @see https://github.com/facebook/docusaurus/issues/5382
+ */
+function sortAliases(aliases) {
+    // Alphabetical order by default
+    const entries = lodash_1.default.sortBy(Object.entries(aliases), ([alias]) => alias);
+    // @theme/NavbarItem should be after @theme/NavbarItem/LocaleDropdown
+    entries.sort(([alias1], [alias2]) => 
+    // eslint-disable-next-line no-nested-ternary
+    alias1.includes(`${alias2}/`) ? -1 : alias2.includes(`${alias1}/`) ? 1 : 0);
+    return Object.fromEntries(entries);
+}
+exports.sortAliases = sortAliases;
+async function createAliasesForTheme(themePath, addOriginalAlias) {
+    if (!(await fs_extra_1.default.pathExists(themePath))) {
+        return {};
+    }
+    const themeComponentFiles = await (0, utils_1.Globby)(['**/*.{js,jsx,ts,tsx}'], {
+        cwd: themePath,
+    });
+    const aliases = {};
+    themeComponentFiles.forEach((relativeSource) => {
+        const filePath = path_1.default.join(themePath, relativeSource);
+        const fileName = (0, utils_1.fileToPath)(relativeSource);
+        const aliasName = (0, utils_1.posixPath)((0, utils_1.normalizeUrl)(['@theme', fileName]).replace(/\/$/, ''));
+        aliases[aliasName] = filePath;
+        if (addOriginalAlias) {
+            // For swizzled components to access the original.
+            const originalAliasName = (0, utils_1.posixPath)((0, utils_1.normalizeUrl)(['@theme-original', fileName]).replace(/\/$/, ''));
+            aliases[originalAliasName] = filePath;
+        }
+    });
+    return sortAliases(aliases);
+}
+exports.createAliasesForTheme = createAliasesForTheme;
+async function createThemeAliases(themePaths, userThemePaths) {
+    const aliases = {};
+    for (const themePath of themePaths) {
+        const themeAliases = await createAliasesForTheme(themePath, true);
+        Object.entries(themeAliases).forEach(([aliasKey, alias]) => {
+            // If this alias shadows a previous one, use @theme-init to preserve the
+            // initial one. @theme-init is only applied once: to the initial theme
+            // that provided this component
+            if (aliasKey in aliases) {
+                const componentName = aliasKey.substring(aliasKey.indexOf('/') + 1);
+                const initAlias = `@theme-init/${componentName}`;
+                if (!(initAlias in aliases)) {
+                    aliases[initAlias] = aliases[aliasKey];
+                }
+            }
+            aliases[aliasKey] = alias;
+        });
+    }
+    for (const themePath of userThemePaths) {
+        const userThemeAliases = await createAliasesForTheme(themePath, false);
+        Object.assign(aliases, userThemeAliases);
+    }
+    return sortAliases(aliases);
+}
+function loadThemeAliases({ siteDir, plugins, }) {
+    const pluginThemes = plugins
+        .map((plugin) => plugin.getThemePath && path_1.default.resolve(plugin.path, plugin.getThemePath()))
+        .filter((x) => Boolean(x));
+    const userTheme = path_1.default.resolve(siteDir, utils_1.THEME_PATH);
+    return createThemeAliases([ThemeFallbackDir, ...pluginThemes], [userTheme]);
+}
+exports.loadThemeAliases = loadThemeAliases;
+/**
+ * Note: a `@docusaurus` alias would also catch `@docusaurus/theme-common`, so
+ * instead of naively aliasing this to `client/exports`, we use fine-grained
+ * aliases instead.
+ */
+async function loadDocusaurusAliases() {
+    const dirPath = path_1.default.resolve(__dirname, '../../client/exports');
+    const extensions = ['.js', '.ts', '.tsx'];
+    const aliases = {};
+    (await fs_extra_1.default.readdir(dirPath))
+        .filter((fileName) => extensions.includes(path_1.default.extname(fileName)))
+        .forEach((fileName) => {
+        const fileNameWithoutExtension = path_1.default.basename(fileName, path_1.default.extname(fileName));
+        const aliasName = `@docusaurus/${fileNameWithoutExtension}`;
+        aliases[aliasName] = path_1.default.resolve(dirPath, fileName);
+    });
+    return aliases;
+}
+exports.loadDocusaurusAliases = loadDocusaurusAliases;

package/lib/webpack/base.d.ts

@@ -8,7 +8,4 @@ import type { Configuration } from 'webpack';
 import type { Props } from '@docusaurus/types';
 export declare const clientDir: string;
 export declare function excludeJS(modulePath: string): boolean;
-export declare function getDocusaurusAliases(): Promise<{
-    [aliasName: string]: string;
-}>;
 export declare function createBaseConfig(props: Props, isServer: boolean, minify?: boolean): Promise<Configuration>;

package/lib/webpack/base.js

@@ -6,13 +6,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createBaseConfig = exports.getDocusaurusAliases = exports.excludeJS = exports.clientDir = void 0;
+exports.createBaseConfig = exports.excludeJS = exports.clientDir = void 0;
 const tslib_1 = require("tslib");
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const mini_css_extract_plugin_1 = tslib_1.__importDefault(require("mini-css-extract-plugin"));
 const path_1 = tslib_1.__importDefault(require("path"));
 const utils_1 = require("./utils");
-const themes_1 = require("../server/themes");
+const aliases_1 = require("./aliases");
 const utils_2 = require("@docusaurus/utils");
 const CSS_REGEX = /\.css$/i;
 const CSS_MODULE_REGEX = /\.module\.css$/i;
@@ -32,20 +32,6 @@ function excludeJS(modulePath) {
         !LibrariesToTranspileRegex.test(modulePath));
 }
 exports.excludeJS = excludeJS;
-async function getDocusaurusAliases() {
-    const dirPath = path_1.default.resolve(__dirname, '../client/exports');
-    const extensions = ['.js', '.ts', '.tsx'];
-    const aliases = {};
-    (await fs_extra_1.default.readdir(dirPath))
-        .filter((fileName) => extensions.includes(path_1.default.extname(fileName)))
-        .forEach((fileName) => {
-        const fileNameWithoutExtension = path_1.default.basename(fileName, path_1.default.extname(fileName));
-        const aliasName = `@docusaurus/${fileNameWithoutExtension}`;
-        aliases[aliasName] = path_1.default.resolve(dirPath, fileName);
-    });
-    return aliases;
-}
-exports.getDocusaurusAliases = getDocusaurusAliases;
 async function createBaseConfig(props, isServer, minify = true) {
     const { outDir, siteDir, siteConfig, siteConfigPath, baseUrl, generatedFilesDir, routesPaths, siteMetadata, plugins, } = props;
     const totalPages = routesPaths.length;
@@ -55,7 +41,7 @@ async function createBaseConfig(props, isServer, minify = true) {
     const fileLoaderUtils = (0, utils_2.getFileLoaderUtils)();
     const name = isServer ? 'server' : 'client';
     const mode = isProd ? 'production' : 'development';
-    const themeAliases = await (0, themes_1.loadPluginsThemeAliases)({ siteDir, plugins });
+    const themeAliases = await (0, aliases_1.loadThemeAliases)({ siteDir, plugins });
     return {
         mode,
         name,
@@ -116,10 +102,7 @@ async function createBaseConfig(props, isServer, minify = true) {
             alias: {
                 '@site': siteDir,
                 '@generated': generatedFilesDir,
-                // Note: a @docusaurus alias would also catch @docusaurus/theme-common,
-                // so we use fine-grained aliases instead
-                // '@docusaurus': path.resolve(__dirname, '../client/exports'),
-                ...(await getDocusaurusAliases()),
+                ...(await (0, aliases_1.loadDocusaurusAliases)()),
                 ...themeAliases,
             },
             // This allows you to set a fallback for where Webpack should look for