@docusaurus/core 2.0.0-beta.ff31de0ff → 2.0.0-rc.1

package/lib/server/plugins/moduleShorthand.js

@@ -0,0 +1,46 @@
+"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.resolveModuleName = exports.getNamePatterns = void 0;
+function getNamePatterns(moduleName, moduleType) {
+    if (moduleName.startsWith('@')) {
+        // Pure scope: `@scope` => `@scope/docusaurus-plugin`
+        if (!moduleName.includes('/')) {
+            return [`${moduleName}/docusaurus-${moduleType}`];
+        }
+        const [scope, packageName] = moduleName.split(/\/(?<rest>.*)/);
+        return [
+            `${scope}/${packageName}`,
+            `${scope}/docusaurus-${moduleType}-${packageName}`,
+        ];
+    }
+    return [
+        moduleName,
+        `@docusaurus/${moduleType}-${moduleName}`,
+        `docusaurus-${moduleType}-${moduleName}`,
+    ];
+}
+exports.getNamePatterns = getNamePatterns;
+function resolveModuleName(moduleName, moduleRequire, moduleType) {
+    const modulePatterns = getNamePatterns(moduleName, moduleType);
+    const module = modulePatterns.find((m) => {
+        try {
+            moduleRequire.resolve(m);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (!module) {
+        throw new Error(`Docusaurus was unable to resolve the "${moduleName}" ${moduleType}. Make sure one of the following packages are installed:
+${modulePatterns.map((m) => `- ${m}`).join('\n')}`);
+    }
+    return module;
+}
+exports.resolveModuleName = resolveModuleName;

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

@@ -4,5 +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 { InitPlugin } from './init';
-export declare function ensureUniquePluginInstanceIds(plugins: InitPlugin[]): void;
+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

@@ -7,17 +7,22 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureUniquePluginInstanceIds = void 0;
-const lodash_1 = require("lodash");
-const constants_1 = require("../../constants");
-// 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
+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.
+ */
 function ensureUniquePluginInstanceIds(plugins) {
-    const pluginsByName = lodash_1.groupBy(plugins, (p) => p.name);
+    const pluginsByName = lodash_1.default.groupBy(plugins, (p) => p.name);
     Object.entries(pluginsByName).forEach(([pluginName, pluginInstances]) => {
-        const pluginInstancesById = lodash_1.groupBy(pluginInstances, (p) => { var _a; return (_a = p.options.id) !== null && _a !== void 0 ? _a : constants_1.DEFAULT_PLUGIN_ID; });
+        const pluginInstancesById = lodash_1.default.groupBy(pluginInstances, (p) => p.options.id ?? utils_1.DEFAULT_PLUGIN_ID);
         Object.entries(pluginInstancesById).forEach(([pluginId, pluginInstancesWithId]) => {
             if (pluginInstancesWithId.length !== 1) {
-                throw new Error(`Plugin ${pluginName} is used ${pluginInstancesWithId.length} times with id=${pluginId}.\nTo use the same plugin multiple times on a Docusaurus site, you need to assign a unique id to each plugin instance.`);
+                throw new Error(`Plugin "${pluginName}" is used ${pluginInstancesWithId.length} times with ID "${pluginId}".\nTo use the same plugin multiple times on a Docusaurus site, you need to assign a unique ID to each plugin instance.${pluginId === utils_1.DEFAULT_PLUGIN_ID
+                    ? `\n\nThe plugin ID is "${utils_1.DEFAULT_PLUGIN_ID}" by default. It's possible that the preset you are using already includes a plugin instance, in which case you either want to disable the plugin in the preset (to use a single instance), or assign another ID to your extra plugin instance (to use multiple instances).`
+                    : ''}`);
             }
         });
     });

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/plugins/presets.js

@@ -0,0 +1,49 @@
+"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.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");
+/**
+ * Calls preset functions, aggregates each of their return values, and returns
+ * the plugin and theme configs.
+ */
+async function loadPresets(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 presetRequire = (0, module_1.createRequire)(context.siteConfigPath);
+    const { presets } = context.siteConfig;
+    const plugins = [];
+    const themes = [];
+    presets.forEach((presetItem) => {
+        let presetModuleImport;
+        let presetOptions = {};
+        if (!presetItem) {
+            return;
+        }
+        if (typeof presetItem === 'string') {
+            presetModuleImport = presetItem;
+        }
+        else {
+            [presetModuleImport, presetOptions] = presetItem;
+        }
+        const presetName = (0, moduleShorthand_1.resolveModuleName)(presetModuleImport, presetRequire, 'preset');
+        const presetModule = (0, import_fresh_1.default)(presetRequire.resolve(presetName));
+        const preset = (presetModule.default ?? presetModule)(context, presetOptions);
+        if (preset.plugins) {
+            plugins.push(...preset.plugins);
+        }
+        if (preset.themes) {
+            themes.push(...preset.themes);
+        }
+    });
+    return { plugins, themes };
+}
+exports.loadPresets = loadPresets;

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

@@ -0,0 +1,11 @@
+/**
+ * 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 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;

package/lib/server/plugins/routeConfig.js

@@ -0,0 +1,54 @@
+"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");
+/** Recursively applies trailing slash config to all nested routes. */
+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,111 @@
+"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"));
+/**
+ * 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 = {
+                admonitions: true,
+                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,
+            };
+            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,16 +4,48 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { ChunkRegistry, RouteConfig, ChunkNames } from '@docusaurus/types';
+import type { RouteConfig, RouteChunkNames, ReportingSeverity } from '@docusaurus/types';
 declare type LoadedRoutes = {
-    registry: {
-        [chunkName: string]: ChunkRegistry;
-    };
+    /** Serialized routes config that can be directly emitted into temp file. */
     routesConfig: string;
-    routesChunkNames: {
-        [routePath: string]: ChunkNames;
+    /** @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[];
 };
-export default function loadRoutes(pluginsRouteConfigs: RouteConfig[], baseUrl: string): Promise<LoadedRoutes>;
+/**
+ * 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 {};