@docusaurus/core 0.0.0-5823 → 0.0.0-5828

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
@@ -269,9 +268,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/{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/commands/build.d.ts

@@ -10,4 +10,4 @@ export type BuildCLIOptions = Pick<LoadContextOptions, 'config' | 'locale' | 'ou
     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 brokenLinks_1 = require("../server/brokenLinks");
-const client_1 = tslib_1.__importDefault(require("../webpack/client"));
+const client_1 = require("../webpack/client");
 const server_2 = 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
@@ -43,13 +43,15 @@ forceTerminate = true) {
     });
     async function tryToBuildLocale({ locale, isLastLocale, }) {
         try {
-            return await buildLocale({
+            utils_3.PerfLogger.start(`Building site for locale ${locale}`);
+            await buildLocale({
                 siteDir,
                 locale,
                 cliOptions,
                 forceTerminate,
                 isLastLocale,
             });
+            utils_3.PerfLogger.end(`Building site for locale ${locale}`);
         }
         catch (err) {
             throw new Error(logger_1.default.interpolate `Unable to build website for locale name=${locale}.`, {
@@ -57,6 +59,24 @@ forceTerminate = true) {
             });
         }
     }
+    utils_3.PerfLogger.start(`Get locales to build`);
+    const locales = await getLocalesToBuild({ siteDir, cliOptions });
+    utils_3.PerfLogger.end(`Get locales to build`);
+    if (locales.length > 1) {
+        logger_1.default.info `Website will be built for all these locales: ${locales}`;
+    }
+    utils_3.PerfLogger.start(`Building ${locales.length} locales`);
+    await (0, utils_1.mapAsyncSequential)(locales, (locale) => {
+        const isLastLocale = locales.indexOf(locale) === locales.length - 1;
+        return tryToBuildLocale({ locale, isLastLocale });
+    });
+    utils_3.PerfLogger.end(`Building ${locales.length} locales`);
+}
+exports.build = build;
+async function getLocalesToBuild({ siteDir, cliOptions, }) {
+    if (cliOptions.locale) {
+        return [cliOptions.locale];
+    }
     const context = await (0, server_1.loadContext)({
         siteDir,
         outDir: cliOptions.outDir,
@@ -67,31 +87,23 @@ 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, }) {
     // 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...`;
+    utils_3.PerfLogger.start('Loading site');
     const props = await (0, server_1.load)({
         siteDir,
         outDir: cliOptions.outDir,
@@ -99,108 +111,152 @@ async function buildLocale({ siteDir, locale, cliOptions, forceTerminate, isLast
         locale,
         localizePath: cliOptions.locale ? false : undefined,
     });
+    utils_3.PerfLogger.end('Loading site');
     // 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
+    const { outDir, plugins } = props;
+    // We can build the 2 configs in parallel
+    utils_3.PerfLogger.start('Creating webpack configs');
+    const [{ clientConfig, clientManifestPath }, { serverConfig, serverBundlePath }] = await Promise.all([
+        getBuildClientConfig({
+            props,
+            cliOptions,
+        }),
+        getBuildServerConfig({
+            props,
+        }),
+    ]);
+    utils_3.PerfLogger.end('Creating webpack configs');
+    // 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);
-    }
+    // TODO do we really need this? .docusaurus folder is cleaned between builds
+    utils_3.PerfLogger.start('Deleting previous client manifest');
+    await ensureUnlink(clientManifestPath);
+    utils_3.PerfLogger.end('Deleting previous client manifest');
     // Run webpack to build JS bundle (client) and static html files (server).
+    utils_3.PerfLogger.start('Bundling');
     await (0, utils_2.compile)([clientConfig, serverConfig]);
+    utils_3.PerfLogger.end('Bundling');
+    utils_3.PerfLogger.start('Executing static site generation');
+    const { collectedData } = await executeSSG({
+        props,
+        serverBundlePath,
+        clientManifestPath,
+    });
+    utils_3.PerfLogger.end('Executing static site generation');
     // 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);
-        }
-    }
+    utils_3.PerfLogger.start('Deleting server bundle');
+    await ensureUnlink(serverBundlePath);
+    utils_3.PerfLogger.end('Deleting server bundle');
     // Plugin Lifecycle - postBuild.
+    utils_3.PerfLogger.start('Executing postBuild()');
+    await executePluginsPostBuild({ plugins, props, collectedData });
+    utils_3.PerfLogger.end('Executing postBuild()');
+    // TODO execute this in parallel to postBuild?
+    utils_3.PerfLogger.start('Executing broken links checker');
+    await executeBrokenLinksCheck({ props, collectedData });
+    utils_3.PerfLogger.end('Executing broken links checker');
+    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);
+    }
+    return outDir;
+}
+async function executeSSG({ props, serverBundlePath, clientManifestPath, }) {
+    utils_3.PerfLogger.start('Reading client manifest');
+    const manifest = await fs_extra_1.default.readJSON(clientManifestPath, 'utf-8');
+    utils_3.PerfLogger.end('Reading client manifest');
+    utils_3.PerfLogger.start('Compiling SSR template');
+    const ssrTemplate = await (0, templates_1.compileSSRTemplate)(props.siteConfig.ssrTemplate ?? ssr_html_template_1.default);
+    utils_3.PerfLogger.end('Compiling SSR template');
+    utils_3.PerfLogger.start('Loading App renderer');
+    const renderer = await (0, ssg_1.loadAppRenderer)({
+        serverBundlePath,
+    });
+    utils_3.PerfLogger.end('Loading App renderer');
+    utils_3.PerfLogger.start('Generate static files');
+    const ssgResult = await (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,
+        },
+    });
+    utils_3.PerfLogger.end('Generate static files');
+    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_2.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.js

@@ -184,7 +184,7 @@ You can also set the deploymentBranch property in docusaurus.config.js .`);
     if (!cliOptions.skipBuild) {
         // Build site, then push to deploymentBranch branch of specified repo.
         try {
-            await (0, build_1.build)(siteDir, cliOptions, false).then(runDeploy);
+            await (0, build_1.build)(siteDir, cliOptions, false).then(() => runDeploy(outDir));
         }
         catch (err) {
             logger_1.default.error('Deployment of the build output failed.');

package/lib/commands/serve.js

@@ -21,11 +21,11 @@ const getHostPort_1 = require("../server/getHostPort");
 async function serve(siteDirParam = '.', cliOptions = {}) {
     const siteDir = await fs_extra_1.default.realpath(siteDirParam);
     const buildDir = cliOptions.dir ?? utils_1.DEFAULT_BUILD_DIR_NAME;
-    let dir = path_1.default.resolve(siteDir, buildDir);
+    const outDir = path_1.default.resolve(siteDir, buildDir);
     if (cliOptions.build) {
-        dir = await (0, build_1.build)(siteDir, {
+        await (0, build_1.build)(siteDir, {
             config: cliOptions.config,
-            outDir: dir,
+            outDir,
         }, false);
     }
     const { host, port } = await (0, getHostPort_1.getHostPort)(cliOptions);
@@ -51,7 +51,7 @@ async function serve(siteDirParam = '.', cliOptions = {}) {
         req.url = req.url.replace(baseUrl, '/');
         (0, serve_handler_1.default)(req, res, {
             cleanUrls: true,
-            public: dir,
+            public: outDir,
             trailingSlash,
             directoryListing: false,
         });