@docusaurus/core 0.0.0-4797 → 0.0.0-4800

package/lib/server/plugins/index.js

@@ -6,55 +6,25 @@
  * 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 init_1 = require("./init");
+const synthetic_1 = require("./synthetic");
 const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
 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`.
+ */
+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
@@ -63,18 +33,18 @@ async function loadPlugins({ pluginConfigs, 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,
         };
     }));
@@ -111,7 +81,7 @@ async function loadPlugins({ pluginConfigs, context, }) {
         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, {
+            const finalRouteConfig = (0, routeConfig_1.applyRouteTrailingSlash)(initialRouteConfig, {
                 trailingSlash: context.siteConfig.trailingSlash,
                 baseUrl: context.siteConfig.baseUrl,
             });
@@ -143,9 +113,6 @@ async function loadPlugins({ pluginConfigs, 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;
@@ -158,25 +125,23 @@ async function loadPlugins({ pluginConfigs, context, }) {
     }));
     // Sort the route config. This ensures that route with nested
     // routes are always placed last.
-    sortConfig(pluginsRouteConfigs, context.siteConfig.baseUrl);
+    (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,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,70 +6,15 @@
  * 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
@@ -86,16 +31,20 @@ function getThemeValidationFunction(normalizedPluginConfig) {
     }
     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 +89,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 = [];
@@ -38,4 +43,4 @@ async function loadPresets(context) {
     });
     return { plugins, themes };
 }
-exports.default = loadPresets;
+exports.loadPresets = loadPresets;

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

@@ -6,4 +6,5 @@
  */
 import type { RouteConfig } from '@docusaurus/types';
 import { type ApplyTrailingSlashParams } from '@docusaurus/utils-common';
-export default function applyRouteTrailingSlash(route: RouteConfig, params: ApplyTrailingSlashParams): RouteConfig;
+export declare function applyRouteTrailingSlash(route: RouteConfig, params: ApplyTrailingSlashParams): RouteConfig;
+export declare function sortConfig(routeConfigs: RouteConfig[], baseUrl?: string): void;

package/lib/server/plugins/routeConfig.js

@@ -0,0 +1,53 @@
+"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.sortConfig = exports.applyRouteTrailingSlash = void 0;
+const utils_common_1 = require("@docusaurus/utils-common");
+function applyRouteTrailingSlash(route, params) {
+    return {
+        ...route,
+        path: (0, utils_common_1.applyTrailingSlash)(route.path, params),
+        ...(route.routes && {
+            routes: route.routes.map((subroute) => applyRouteTrailingSlash(subroute, params)),
+        }),
+    };
+}
+exports.applyRouteTrailingSlash = 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;

package/lib/server/plugins/synthetic.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 { LoadedPlugin, LoadContext } from '@docusaurus/types';
+/**
+ * Make a synthetic plugin to:
+ * - Inject site client modules
+ * - Inject scripts/stylesheets
+ */
+export declare function createBootstrapPlugin({ siteDir, siteConfig, }: LoadContext): LoadedPlugin;
+/**
+ * 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;

package/lib/server/plugins/synthetic.js

@@ -0,0 +1,112 @@
+"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.createMDXFallbackPlugin = exports.createBootstrapPlugin = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const remark_admonitions_1 = tslib_1.__importDefault(require("remark-admonitions"));
+/**
+ * Make a synthetic plugin to:
+ * - Inject site client modules
+ * - Inject scripts/stylesheets
+ */
+function createBootstrapPlugin({ siteDir, siteConfig, }) {
+    const { stylesheets, scripts, clientModules: siteConfigClientModules, } = siteConfig;
+    return {
+        name: 'docusaurus-bootstrap-plugin',
+        content: null,
+        options: {
+            id: 'default',
+        },
+        version: { type: 'synthetic' },
+        path: siteDir,
+        getClientModules() {
+            return siteConfigClientModules;
+        },
+        injectHtmlTags: () => {
+            const stylesheetsTags = stylesheets.map((source) => typeof source === 'string'
+                ? `<link rel="stylesheet" href="${source}">`
+                : {
+                    tagName: 'link',
+                    attributes: {
+                        rel: 'stylesheet',
+                        ...source,
+                    },
+                });
+            const scriptsTags = scripts.map((source) => typeof source === 'string'
+                ? `<script src="${source}"></script>`
+                : {
+                    tagName: 'script',
+                    attributes: {
+                        ...source,
+                    },
+                });
+            return {
+                headTags: [...stylesheetsTags, ...scriptsTags],
+            };
+        },
+    };
+}
+exports.createBootstrapPlugin = createBootstrapPlugin;
+/**
+ * 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
+ */
+function createMDXFallbackPlugin({ siteDir, siteConfig, }) {
+    return {
+        name: 'docusaurus-mdx-fallback-plugin',
+        content: null,
+        options: {
+            id: 'default',
+        },
+        version: { type: 'synthetic' },
+        // Synthetic, the path doesn't matter much
+        path: '.',
+        configureWebpack(config, isServer, { getJSLoader }) {
+            // We need the mdx fallback loader to exclude files that were already
+            // processed by content plugins mdx loaders. This works, but a bit
+            // hacky... Not sure there's a way to handle that differently in webpack
+            function getMDXFallbackExcludedPaths() {
+                const rules = config?.module?.rules;
+                return rules.flatMap((rule) => {
+                    const isMDXRule = rule.test instanceof RegExp && rule.test.test('x.mdx');
+                    return isMDXRule ? rule.include : [];
+                });
+            }
+            const mdxLoaderOptions = {
+                staticDirs: siteConfig.staticDirectories.map((dir) => path_1.default.resolve(siteDir, dir)),
+                siteDir,
+                // External MDX files are always meant to be imported as partials
+                isMDXPartial: () => true,
+                // External MDX files might have front matter, just disable the warning
+                isMDXPartialFrontMatterWarningDisabled: true,
+                remarkPlugins: [remark_admonitions_1.default],
+            };
+            return {
+                module: {
+                    rules: [
+                        {
+                            test: /\.mdx?$/i,
+                            exclude: getMDXFallbackExcludedPaths(),
+                            use: [
+                                getJSLoader({ isServer }),
+                                {
+                                    loader: require.resolve('@docusaurus/mdx-loader'),
+                                    options: mdxLoaderOptions,
+                                },
+                            ],
+                        },
+                    ],
+                },
+            };
+        },
+    };
+}
+exports.createMDXFallbackPlugin = createMDXFallbackPlugin;

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 default 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,8 +6,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+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}`)}`;
@@ -77,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 = {};
@@ -127,26 +175,4 @@ ${indent(NotFoundRouteCode)}
         routesPaths,
     };
 }
-exports.default = 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;
-}
+exports.loadRoutes = loadRoutes;