@docusaurus/core 3.1.0 → 3.2.0

package/bin/docusaurus.mjs

@@ -8,6 +8,7 @@
 
 // @ts-check
 
+import {inspect} from 'node:util';
 import logger from '@docusaurus/logger';
 import cli from 'commander';
 import {DOCUSAURUS_VERSION} from '@docusaurus/utils';
@@ -61,8 +62,6 @@ cli
     '--no-minify',
     'build website without minimizing JS bundles (default: false)',
   )
-  // @ts-expect-error: Promise<string> is not assignable to Promise<void>... but
-  // good enough here.
   .action(build);
 
 cli
@@ -86,6 +85,10 @@ cli
     '-t, --typescript',
     'copy TypeScript theme files when possible (default: false)',
   )
+  .option(
+    '-j, --javascript',
+    'copy JavaScript theme files when possible (default: false)',
+  )
   .option('--danger', 'enable swizzle for unsafe component of themes')
   .option(
     '--config <config>',
@@ -269,9 +272,11 @@ cli.parse(process.argv);
 
 process.on('unhandledRejection', (err) => {
   console.log('');
-  // Do not use logger.error here: it does not print error causes
-  console.error(err);
-  console.log('');
+
+  // We need to use inspect with increased depth to log the full causal chain
+  // By default Node logging has depth=2
+  // see also https://github.com/nodejs/node/issues/51637
+  logger.error(inspect(err, {depth: Infinity}));
 
   logger.info`Docusaurus version: number=${DOCUSAURUS_VERSION}
 Node version: number=${process.version}`;

package/lib/client/BrokenLinksContext.js

@@ -11,10 +11,10 @@ export const createStatefulBrokenLinks = () => {
     const allLinks = new Set();
     return {
         collectAnchor: (anchor) => {
-            allAnchors.add(anchor);
+            typeof anchor !== 'undefined' && allAnchors.add(anchor);
         },
         collectLink: (link) => {
-            allLinks.add(link);
+            typeof link !== 'undefined' && allLinks.add(link);
         },
         getCollectedAnchors: () => [...allAnchors],
         getCollectedLinks: () => [...allLinks],

package/lib/client/exports/Link.js

@@ -97,11 +97,19 @@ function Link({ isNavLink, to, href, activeClassName, isActive, 'data-noBrokenLi
             }
         };
     }, [ioRef, targetLink, IOSupported, isInternal]);
+    // It is simple local anchor link targeting current page?
     const isAnchorLink = targetLink?.startsWith('#') ?? false;
-    const isRegularHtmlLink = !targetLink || !isInternal || isAnchorLink;
-    if (!isRegularHtmlLink && !noBrokenLinkCheck) {
+    // See also RR logic:
+    // https://github.com/remix-run/react-router/blob/v5/packages/react-router-dom/modules/Link.js#L47
+    const hasInternalTarget = !props.target || props.target === '_self';
+    // Should we use a regular <a> tag instead of React-Router Link component?
+    const isRegularHtmlLink = !targetLink || !isInternal || !hasInternalTarget || isAnchorLink;
+    if (!noBrokenLinkCheck && (isAnchorLink || !isRegularHtmlLink)) {
         brokenLinks.collectLink(targetLink);
     }
+    if (props.id) {
+        brokenLinks.collectAnchor(props.id);
+    }
     return isRegularHtmlLink ? (
     // eslint-disable-next-line jsx-a11y/anchor-has-content, @docusaurus/no-html-links
     <a ref={innerRef} href={targetLink} {...(targetLinkUnprefixed &&

package/lib/client/{serverRenderer.d.ts → renderToHtml.d.ts}

@@ -5,4 +5,4 @@
  * LICENSE file in the root directory of this source tree.
  */
 import type { ReactNode } from 'react';
-export declare function renderStaticApp(app: ReactNode): Promise<string>;
+export declare function renderToHtml(app: ReactNode): Promise<string>;

package/lib/client/{serverRenderer.js → renderToHtml.js}

@@ -6,7 +6,7 @@
  */
 import { renderToPipeableStream } from 'react-dom/server';
 import { Writable } from 'stream';
-export async function renderStaticApp(app) {
+export async function renderToHtml(app) {
     // Inspired from
     // https://react.dev/reference/react-dom/server/renderToPipeableStream#waiting-for-all-content-to-load-for-crawlers-and-static-generation
     // https://github.com/gatsbyjs/gatsby/blob/master/packages/gatsby/cache-dir/static-entry.js

package/lib/client/serverEntry.d.ts

@@ -4,7 +4,6 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import type { Locals } from '@slorber/static-site-generator-webpack-plugin';
-export default function render(locals: Locals & {
-    path: string;
-}): Promise<string>;
+import type { AppRenderer } from '../common';
+declare const render: AppRenderer;
+export default render;

package/lib/client/serverEntry.js

@@ -5,59 +5,15 @@
  * LICENSE file in the root directory of this source tree.
  */
 import React from 'react';
-import path from 'path';
-import fs from 'fs-extra';
-// eslint-disable-next-line no-restricted-imports
-import _ from 'lodash';
-import * as eta from 'eta';
 import { StaticRouter } from 'react-router-dom';
 import { HelmetProvider } from 'react-helmet-async';
-import { getBundles } from 'react-loadable-ssr-addon-v5-slorber';
 import Loadable from 'react-loadable';
-import { minify } from 'html-minifier-terser';
-import { renderStaticApp } from './serverRenderer';
+import { renderToHtml } from './renderToHtml';
 import preload from './preload';
 import App from './App';
 import { createStatefulBrokenLinks, BrokenLinksProvider, } from './BrokenLinksContext';
-const getCompiledSSRTemplate = _.memoize((template) => eta.compile(template.trim(), {
-    rmWhitespace: true,
-}));
-function renderSSRTemplate(ssrTemplate, data) {
-    const compiled = getCompiledSSRTemplate(ssrTemplate);
-    return compiled(data, eta.defaultConfig);
-}
-function buildSSRErrorMessage({ error, pathname, }) {
-    const parts = [
-        `Docusaurus server-side rendering could not render static page with path ${pathname} because of error: ${error.message}`,
-    ];
-    const isNotDefinedErrorRegex = /(?:window|document|localStorage|navigator|alert|location|buffer|self) is not defined/i;
-    if (isNotDefinedErrorRegex.test(error.message)) {
-        // prettier-ignore
-        parts.push(`It looks like you are using code that should run on the client-side only.
-To get around it, try using \`<BrowserOnly>\` (https://docusaurus.io/docs/docusaurus-core/#browseronly) or \`ExecutionEnvironment\` (https://docusaurus.io/docs/docusaurus-core/#executionenvironment).
-It might also require to wrap your client code in \`useEffect\` hook and/or import a third-party library dynamically (if any).`);
-    }
-    return parts.join('\n');
-}
-export default async function render(locals) {
-    try {
-        return await doRender(locals);
-    }
-    catch (errorUnknown) {
-        const error = errorUnknown;
-        const message = buildSSRErrorMessage({ error, pathname: locals.path });
-        const ssrError = new Error(message, { cause: error });
-        // It is important to log the error here because the stacktrace causal chain
-        // is not available anymore upper in the tree (this SSR runs in eval)
-        console.error(ssrError);
-        throw ssrError;
-    }
-}
-// Renderer for static-site-generator-webpack-plugin (async rendering).
-async function doRender(locals) {
-    const { routesLocation, headTags, preBodyTags, postBodyTags, onLinksCollected, onHeadTagsCollected, baseUrl, ssrTemplate, noIndex, DOCUSAURUS_VERSION, } = locals;
-    const location = routesLocation[locals.path];
-    await preload(location);
+const render = async ({ pathname }) => {
+    await preload(pathname);
     const modules = new Set();
     const routerContext = {};
     const helmetContext = {};
@@ -66,77 +22,20 @@ async function doRender(locals) {
     // @ts-expect-error: we are migrating away from react-loadable anyways
     <Loadable.Capture report={(moduleName) => modules.add(moduleName)}>
       <HelmetProvider context={helmetContext}>
-        <StaticRouter location={location} context={routerContext}>
+        <StaticRouter location={pathname} context={routerContext}>
           <BrokenLinksProvider brokenLinks={statefulBrokenLinks}>
             <App />
           </BrokenLinksProvider>
         </StaticRouter>
       </HelmetProvider>
     </Loadable.Capture>);
-    const appHtml = await renderStaticApp(app);
-    onLinksCollected({
-        staticPagePath: location,
+    const html = await renderToHtml(app);
+    const collectedData = {
+        helmet: helmetContext.helmet,
         anchors: statefulBrokenLinks.getCollectedAnchors(),
         links: statefulBrokenLinks.getCollectedLinks(),
-    });
-    const { helmet } = helmetContext;
-    const htmlAttributes = helmet.htmlAttributes.toString();
-    const bodyAttributes = helmet.bodyAttributes.toString();
-    const metaStrings = [
-        helmet.title.toString(),
-        helmet.meta.toString(),
-        helmet.link.toString(),
-        helmet.script.toString(),
-    ];
-    onHeadTagsCollected(location, helmet);
-    const metaAttributes = metaStrings.filter(Boolean);
-    const { generatedFilesDir } = locals;
-    const manifestPath = path.join(generatedFilesDir, 'client-manifest.json');
-    // Using readJSON seems to fail for users of some plugins, possibly because of
-    // the eval sandbox having a different `Buffer` instance (native one instead
-    // of polyfilled one)
-    const manifest = (await fs
-        .readFile(manifestPath, 'utf-8')
-        .then(JSON.parse));
-    // Get all required assets for this particular page based on client
-    // manifest information.
-    const modulesToBeLoaded = [...manifest.entrypoints, ...Array.from(modules)];
-    const bundles = getBundles(manifest, modulesToBeLoaded);
-    const stylesheets = (bundles.css ?? []).map((b) => b.file);
-    const scripts = (bundles.js ?? []).map((b) => b.file);
-    const renderedHtml = renderSSRTemplate(ssrTemplate, {
-        appHtml,
-        baseUrl,
-        htmlAttributes,
-        bodyAttributes,
-        headTags,
-        preBodyTags,
-        postBodyTags,
-        metaAttributes,
-        scripts,
-        stylesheets,
-        noIndex,
-        version: DOCUSAURUS_VERSION,
-    });
-    try {
-        if (process.env.SKIP_HTML_MINIFICATION === 'true') {
-            return renderedHtml;
-        }
-        // Minify html with https://github.com/DanielRuf/html-minifier-terser
-        return await minify(renderedHtml, {
-            removeComments: false,
-            removeRedundantAttributes: true,
-            removeEmptyAttributes: true,
-            removeScriptTypeAttributes: true,
-            removeStyleLinkTypeAttributes: true,
-            useShortDoctype: true,
-            minifyJS: true,
-        });
-    }
-    catch (err) {
-        // prettier-ignore
-        console.error(`Minification of page ${locals.path} failed.`);
-        console.error(err);
-        throw err;
-    }
-}
+        modules: Array.from(modules),
+    };
+    return { html, collectedData };
+};
+export default render;

package/lib/client/theme-fallback/Error/index.js

@@ -11,6 +11,7 @@ import Head from '@docusaurus/Head';
 import ErrorBoundary from '@docusaurus/ErrorBoundary';
 import { getErrorCausalChain } from '@docusaurus/utils-common';
 import Layout from '@theme/Layout';
+import { RouteContextProvider } from '../../routeContext';
 function ErrorDisplay({ error, tryAgain }) {
     return (<div style={{
             display: 'flex',
@@ -42,19 +43,32 @@ function ErrorBoundaryError({ error }) {
     const fullMessage = causalChain.map((e) => e.message).join('\n\nCause:\n');
     return <p style={{ whiteSpace: 'pre-wrap' }}>{fullMessage}</p>;
 }
+// A bit hacky: we need to add an artificial RouteContextProvider here
+// The goal is to be able to render the error inside the theme layout
+// Without this, our theme classic would crash due to lack of route context
+// See also https://github.com/facebook/docusaurus/pull/9852
+function ErrorRouteContextProvider({ children }) {
+    return (<RouteContextProvider value={{
+            plugin: { name: 'docusaurus-core-error-boundary', id: 'default' },
+        }}>
+      {children}
+    </RouteContextProvider>);
+}
 export default function Error({ error, tryAgain }) {
     // We wrap the error in its own error boundary because the layout can actually
     // throw too... Only the ErrorDisplay component is simple enough to be
     // considered safe to never throw
-    return (<ErrorBoundary 
+    return (<ErrorRouteContextProvider>
+      <ErrorBoundary 
     // Note: we display the original error here, not the error that we
     // captured in this extra error boundary
     fallback={() => <ErrorDisplay error={error} tryAgain={tryAgain}/>}>
-      <Head>
-        <title>Page Error</title>
-      </Head>
-      <Layout>
-        <ErrorDisplay error={error} tryAgain={tryAgain}/>
-      </Layout>
-    </ErrorBoundary>);
+        <Head>
+          <title>Page Error</title>
+        </Head>
+        <Layout>
+          <ErrorDisplay error={error} tryAgain={tryAgain}/>
+        </Layout>
+      </ErrorBoundary>
+    </ErrorRouteContextProvider>);
 }

package/lib/commands/build.d.ts

@@ -4,10 +4,10 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { type LoadContextOptions } from '../server';
-export type BuildCLIOptions = Pick<LoadContextOptions, 'config' | 'locale' | 'outDir'> & {
+import { type LoadContextParams } from '../server/site';
+export type BuildCLIOptions = Pick<LoadContextParams, 'config' | 'locale' | 'outDir'> & {
     bundleAnalyzer?: boolean;
     minify?: boolean;
     dev?: boolean;
 };
-export declare function build(siteDirParam?: string, cliOptions?: Partial<BuildCLIOptions>, forceTerminate?: boolean): Promise<string>;
+export declare function build(siteDirParam?: string, cliOptions?: Partial<BuildCLIOptions>, forceTerminate?: boolean): Promise<void>;

package/lib/commands/build.js

@@ -10,19 +10,19 @@ exports.build = 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 lodash_1 = tslib_1.__importDefault(require("lodash"));
 const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
 const utils_1 = require("@docusaurus/utils");
-const copy_webpack_plugin_1 = tslib_1.__importDefault(require("copy-webpack-plugin"));
-const react_loadable_ssr_addon_v5_slorber_1 = tslib_1.__importDefault(require("react-loadable-ssr-addon-v5-slorber"));
-const webpack_bundle_analyzer_1 = require("webpack-bundle-analyzer");
-const webpack_merge_1 = tslib_1.__importDefault(require("webpack-merge"));
-const server_1 = require("../server");
+const site_1 = require("../server/site");
 const brokenLinks_1 = require("../server/brokenLinks");
-const client_1 = tslib_1.__importDefault(require("../webpack/client"));
-const server_2 = tslib_1.__importDefault(require("../webpack/server"));
+const client_1 = require("../webpack/client");
+const server_1 = tslib_1.__importDefault(require("../webpack/server"));
 const utils_2 = require("../webpack/utils");
-const CleanWebpackPlugin_1 = tslib_1.__importDefault(require("../webpack/plugins/CleanWebpackPlugin"));
+const utils_3 = require("../utils");
 const i18n_1 = require("../server/i18n");
+const ssg_1 = require("../ssg");
+const templates_1 = require("../templates/templates");
+const ssr_html_template_1 = tslib_1.__importDefault(require("../templates/ssr.html.template"));
 async function build(siteDirParam = '.', cliOptions = {}, 
 // When running build, we force terminate the process to prevent async
 // operations from never returning. However, if run as part of docusaurus
@@ -41,15 +41,13 @@ forceTerminate = true) {
     ['SIGINT', 'SIGTERM'].forEach((sig) => {
         process.on(sig, () => process.exit());
     });
-    async function tryToBuildLocale({ locale, isLastLocale, }) {
+    async function tryToBuildLocale({ locale }) {
         try {
-            return await buildLocale({
+            await utils_3.PerfLogger.async(`${logger_1.default.name(locale)}`, () => buildLocale({
                 siteDir,
                 locale,
                 cliOptions,
-                forceTerminate,
-                isLastLocale,
-            });
+            }));
         }
         catch (err) {
             throw new Error(logger_1.default.interpolate `Unable to build website for locale name=${locale}.`, {
@@ -57,7 +55,28 @@ forceTerminate = true) {
             });
         }
     }
-    const context = await (0, server_1.loadContext)({
+    const locales = await utils_3.PerfLogger.async('Get locales to build', () => getLocalesToBuild({ siteDir, cliOptions }));
+    if (locales.length > 1) {
+        logger_1.default.info `Website will be built for all these locales: ${locales}`;
+    }
+    await utils_3.PerfLogger.async(`Build`, () => (0, utils_1.mapAsyncSequential)(locales, async (locale) => {
+        const isLastLocale = locales.indexOf(locale) === locales.length - 1;
+        await tryToBuildLocale({ locale });
+        if (isLastLocale) {
+            logger_1.default.info `Use code=${'npm run serve'} command to test your build locally.`;
+        }
+        // TODO do we really need this historical forceTerminate exit???
+        if (forceTerminate && isLastLocale && !cliOptions.bundleAnalyzer) {
+            process.exit(0);
+        }
+    }));
+}
+exports.build = build;
+async function getLocalesToBuild({ siteDir, cliOptions, }) {
+    if (cliOptions.locale) {
+        return [cliOptions.locale];
+    }
+    const context = await (0, site_1.loadContext)({
         siteDir,
         outDir: cliOptions.outDir,
         config: cliOptions.config,
@@ -67,140 +86,142 @@ forceTerminate = true) {
     const i18n = await (0, i18n_1.loadI18n)(context.siteConfig, {
         locale: cliOptions.locale,
     });
-    if (cliOptions.locale) {
-        return tryToBuildLocale({ locale: cliOptions.locale, isLastLocale: true });
-    }
     if (i18n.locales.length > 1) {
         logger_1.default.info `Website will be built for all these locales: ${i18n.locales}`;
     }
     // We need the default locale to always be the 1st in the list. If we build it
     // last, it would "erase" the localized sites built in sub-folders
-    const orderedLocales = [
+    return [
         i18n.defaultLocale,
         ...i18n.locales.filter((locale) => locale !== i18n.defaultLocale),
     ];
-    const results = await (0, utils_1.mapAsyncSequential)(orderedLocales, (locale) => {
-        const isLastLocale = orderedLocales.indexOf(locale) === orderedLocales.length - 1;
-        return tryToBuildLocale({ locale, isLastLocale });
-    });
-    return results[0];
 }
-exports.build = build;
-async function buildLocale({ siteDir, locale, cliOptions, forceTerminate, isLastLocale, }) {
+async function buildLocale({ siteDir, locale, cliOptions, }) {
     // Temporary workaround to unlock the ability to translate the site config
     // We'll remove it if a better official API can be designed
     // See https://github.com/facebook/docusaurus/issues/4542
     process.env.DOCUSAURUS_CURRENT_LOCALE = locale;
     logger_1.default.info `name=${`[${locale}]`} Creating an optimized production build...`;
-    const props = await (0, server_1.load)({
+    const site = await utils_3.PerfLogger.async('Load site', () => (0, site_1.loadSite)({
         siteDir,
         outDir: cliOptions.outDir,
         config: cliOptions.config,
         locale,
         localizePath: cliOptions.locale ? false : undefined,
-    });
-    // Apply user webpack config.
-    const { outDir, generatedFilesDir, plugins, siteConfig: { onBrokenLinks, onBrokenAnchors, staticDirectories: staticDirectoriesOption, }, routes, } = props;
-    const clientManifestPath = path_1.default.join(generatedFilesDir, 'client-manifest.json');
-    let clientConfig = (0, webpack_merge_1.default)(await (0, client_1.default)(props, cliOptions.minify, true), {
-        plugins: [
-            // Remove/clean build folders before building bundles.
-            new CleanWebpackPlugin_1.default({ verbose: false }),
-            // Visualize size of webpack output files with an interactive zoomable
-            // tree map.
-            cliOptions.bundleAnalyzer && new webpack_bundle_analyzer_1.BundleAnalyzerPlugin(),
-            // Generate client manifests file that will be used for server bundle.
-            new react_loadable_ssr_addon_v5_slorber_1.default({
-                filename: clientManifestPath,
-            }),
-        ].filter((x) => Boolean(x)),
-    });
-    const collectedLinks = {};
-    const headTags = {};
-    let serverConfig = await (0, server_2.default)({
-        props,
-        onLinksCollected: ({ staticPagePath, links, anchors }) => {
-            collectedLinks[staticPagePath] = { links, anchors };
-        },
-        onHeadTagsCollected: (staticPagePath, tags) => {
-            headTags[staticPagePath] = tags;
-        },
-    });
-    // The staticDirectories option can contain empty directories, or non-existent
-    // directories (e.g. user deleted `static`). Instead of issuing an error, we
-    // just silently filter them out, because user could have never configured it
-    // in the first place (the default option should always "work").
-    const staticDirectories = (await Promise.all(staticDirectoriesOption.map(async (dir) => {
-        const staticDir = path_1.default.resolve(siteDir, dir);
-        if ((await fs_extra_1.default.pathExists(staticDir)) &&
-            (await fs_extra_1.default.readdir(staticDir)).length > 0) {
-            return staticDir;
-        }
-        return '';
-    }))).filter(Boolean);
-    if (staticDirectories.length > 0) {
-        serverConfig = (0, webpack_merge_1.default)(serverConfig, {
-            plugins: [
-                new copy_webpack_plugin_1.default({
-                    patterns: staticDirectories.map((dir) => ({
-                        from: dir,
-                        to: outDir,
-                        toType: 'dir',
-                    })),
-                }),
-            ],
-        });
-    }
-    // Plugin Lifecycle - configureWebpack and configurePostCss.
-    plugins.forEach((plugin) => {
-        const { configureWebpack, configurePostCss } = plugin;
-        if (configurePostCss) {
-            clientConfig = (0, utils_2.applyConfigurePostCss)(configurePostCss.bind(plugin), clientConfig);
-        }
-        if (configureWebpack) {
-            clientConfig = (0, utils_2.applyConfigureWebpack)(configureWebpack.bind(plugin), // The plugin lifecycle may reference `this`.
-            clientConfig, false, props.siteConfig.webpack?.jsLoader, plugin.content);
-            serverConfig = (0, utils_2.applyConfigureWebpack)(configureWebpack.bind(plugin), // The plugin lifecycle may reference `this`.
-            serverConfig, true, props.siteConfig.webpack?.jsLoader, plugin.content);
-        }
-    });
-    // Make sure generated client-manifest is cleaned first so we don't reuse
-    // the one from previous builds.
-    if (await fs_extra_1.default.pathExists(clientManifestPath)) {
-        await fs_extra_1.default.unlink(clientManifestPath);
-    }
+    }));
+    const { props } = site;
+    const { outDir, plugins } = props;
+    // We can build the 2 configs in parallel
+    const [{ clientConfig, clientManifestPath }, { serverConfig, serverBundlePath }] = await utils_3.PerfLogger.async('Creating webpack configs', () => Promise.all([
+        getBuildClientConfig({
+            props,
+            cliOptions,
+        }),
+        getBuildServerConfig({
+            props,
+        }),
+    ]));
     // Run webpack to build JS bundle (client) and static html files (server).
-    await (0, utils_2.compile)([clientConfig, serverConfig]);
+    await utils_3.PerfLogger.async('Bundling with Webpack', () => (0, utils_2.compile)([clientConfig, serverConfig]));
+    const { collectedData } = await utils_3.PerfLogger.async('SSG', () => executeSSG({
+        props,
+        serverBundlePath,
+        clientManifestPath,
+    }));
     // Remove server.bundle.js because it is not needed.
-    if (typeof serverConfig.output?.filename === 'string') {
-        const serverBundle = path_1.default.join(outDir, serverConfig.output.filename);
-        if (await fs_extra_1.default.pathExists(serverBundle)) {
-            await fs_extra_1.default.unlink(serverBundle);
-        }
-    }
+    await utils_3.PerfLogger.async('Deleting server bundle', () => ensureUnlink(serverBundlePath));
     // Plugin Lifecycle - postBuild.
+    await utils_3.PerfLogger.async('postBuild()', () => executePluginsPostBuild({ plugins, props, collectedData }));
+    // TODO execute this in parallel to postBuild?
+    await utils_3.PerfLogger.async('Broken links checker', () => executeBrokenLinksCheck({ props, collectedData }));
+    logger_1.default.success `Generated static files in path=${path_1.default.relative(process.cwd(), outDir)}.`;
+    return outDir;
+}
+async function executeSSG({ props, serverBundlePath, clientManifestPath, }) {
+    const manifest = await utils_3.PerfLogger.async('Read client manifest', () => fs_extra_1.default.readJSON(clientManifestPath, 'utf-8'));
+    const ssrTemplate = await utils_3.PerfLogger.async('Compile SSR template', () => (0, templates_1.compileSSRTemplate)(props.siteConfig.ssrTemplate ?? ssr_html_template_1.default));
+    const renderer = await utils_3.PerfLogger.async('Load App renderer', () => (0, ssg_1.loadAppRenderer)({
+        serverBundlePath,
+    }));
+    const ssgResult = await utils_3.PerfLogger.async('Generate static files', () => (0, ssg_1.generateStaticFiles)({
+        pathnames: props.routesPaths,
+        renderer,
+        params: {
+            trailingSlash: props.siteConfig.trailingSlash,
+            outDir: props.outDir,
+            baseUrl: props.baseUrl,
+            manifest,
+            headTags: props.headTags,
+            preBodyTags: props.preBodyTags,
+            postBodyTags: props.postBodyTags,
+            ssrTemplate,
+            noIndex: props.siteConfig.noIndex,
+            DOCUSAURUS_VERSION: utils_1.DOCUSAURUS_VERSION,
+        },
+    }));
+    return ssgResult;
+}
+async function executePluginsPostBuild({ plugins, props, collectedData, }) {
+    const head = lodash_1.default.mapValues(collectedData, (d) => d.helmet);
     await Promise.all(plugins.map(async (plugin) => {
         if (!plugin.postBuild) {
             return;
         }
         await plugin.postBuild({
             ...props,
-            head: headTags,
+            head,
             content: plugin.content,
         });
     }));
+}
+async function executeBrokenLinksCheck({ props: { routes, siteConfig: { onBrokenLinks, onBrokenAnchors }, }, collectedData, }) {
+    const collectedLinks = lodash_1.default.mapValues(collectedData, (d) => ({
+        links: d.links,
+        anchors: d.anchors,
+    }));
     await (0, brokenLinks_1.handleBrokenLinks)({
         collectedLinks,
         routes,
         onBrokenLinks,
         onBrokenAnchors,
     });
-    logger_1.default.success `Generated static files in path=${path_1.default.relative(process.cwd(), outDir)}.`;
-    if (isLastLocale) {
-        logger_1.default.info `Use code=${'npm run serve'} command to test your build locally.`;
-    }
-    if (forceTerminate && isLastLocale && !cliOptions.bundleAnalyzer) {
-        process.exit(0);
+}
+async function getBuildClientConfig({ props, cliOptions, }) {
+    const { plugins } = props;
+    const result = await (0, client_1.createBuildClientConfig)({
+        props,
+        minify: cliOptions.minify ?? true,
+        bundleAnalyzer: cliOptions.bundleAnalyzer ?? false,
+    });
+    let { config } = result;
+    config = (0, utils_2.executePluginsConfigureWebpack)({
+        plugins,
+        config,
+        isServer: false,
+        jsLoader: props.siteConfig.webpack?.jsLoader,
+    });
+    return { clientConfig: config, clientManifestPath: result.clientManifestPath };
+}
+async function getBuildServerConfig({ props }) {
+    const { plugins } = props;
+    const result = await (0, server_1.default)({
+        props,
+    });
+    let { config } = result;
+    config = (0, utils_2.executePluginsConfigurePostCss)({
+        plugins,
+        config,
+    });
+    config = (0, utils_2.executePluginsConfigureWebpack)({
+        plugins,
+        config,
+        isServer: true,
+        jsLoader: props.siteConfig.webpack?.jsLoader,
+    });
+    return { serverConfig: config, serverBundlePath: result.serverBundlePath };
+}
+async function ensureUnlink(filepath) {
+    if (await fs_extra_1.default.pathExists(filepath)) {
+        await fs_extra_1.default.unlink(filepath);
     }
-    return outDir;
 }

package/lib/commands/deploy.d.ts

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { type LoadContextOptions } from '../server';
-export type DeployCLIOptions = Pick<LoadContextOptions, 'config' | 'locale' | 'outDir'> & {
+import { type LoadContextParams } from '../server/site';
+export type DeployCLIOptions = Pick<LoadContextParams, 'config' | 'locale' | 'outDir'> & {
     skipBuild?: boolean;
 };
 export declare function deploy(siteDirParam?: string, cliOptions?: Partial<DeployCLIOptions>): Promise<void>;