@docusaurus/core 3.7.0 → 3.8.0

package/lib/ssg/ssgRenderer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { SSGParams } from './ssgParams';
+import type { PageCollectedData } from '../common';
+export type SSGSuccess = {
+    success: true;
+    pathname: string;
+    result: {
+        collectedData: PageCollectedData;
+        warnings: string[];
+    };
+};
+export type SSGError = {
+    success: false;
+    pathname: string;
+    error: Error;
+};
+export type SSGResult = SSGSuccess | SSGError;
+export type SSGRenderer = {
+    shutdown: () => Promise<void>;
+    renderPathnames: (pathnames: string[]) => Promise<SSGResult[]>;
+};
+export declare function loadSSGRenderer({ params, }: {
+    params: SSGParams;
+}): Promise<SSGRenderer>;

package/lib/ssg/{ssg.js → ssgRenderer.js}

@@ -6,13 +6,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadAppRenderer = loadAppRenderer;
-exports.printSSGWarnings = printSSGWarnings;
-exports.generateStaticFiles = generateStaticFiles;
+exports.loadSSGRenderer = loadSSGRenderer;
 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"));
 // TODO eval is archived / unmaintained: https://github.com/pierrec/node-eval
 //  We should internalize/modernize it
 const eval_1 = tslib_1.__importDefault(require("eval"));
@@ -20,11 +17,11 @@ const p_map_1 = tslib_1.__importDefault(require("p-map"));
 const logger_1 = tslib_1.__importStar(require("@docusaurus/logger"));
 const bundler_1 = require("@docusaurus/bundler");
 const ssgTemplate_1 = require("./ssgTemplate");
+const ssgEnv_1 = require("./ssgEnv");
 const ssgUtils_1 = require("./ssgUtils");
 const ssgNodeRequire_1 = require("./ssgNodeRequire");
 async function loadAppRenderer({ serverBundlePath, }) {
     const source = await logger_1.PerfLogger.async(`Load server bundle`, () => fs_extra_1.default.readFile(serverBundlePath));
-    logger_1.PerfLogger.log(`Server bundle size = ${(source.length / 1024000).toFixed(3)} MB`);
     const filename = path_1.default.basename(serverBundlePath);
     const ssgRequire = (0, ssgNodeRequire_1.createSSGRequire)(serverBundlePath);
     const globals = {
@@ -42,7 +39,7 @@ async function loadAppRenderer({ serverBundlePath, }) {
     /* scope: */ globals, 
     /* includeGlobals: */ true));
     if (!serverEntry?.default || typeof serverEntry.default !== 'function') {
-        throw new Error(`Server bundle export from "${filename}" must be a function that renders the Docusaurus React app.`);
+        throw new Error(`Docusaurus Bug: server bundle export from "${filename}" must be a function that renders the Docusaurus React app, not ${typeof serverEntry?.default}`);
     }
     async function shutdown() {
         ssgRequire.cleanup();
@@ -52,44 +49,8 @@ async function loadAppRenderer({ serverBundlePath, }) {
         shutdown,
     };
 }
-function printSSGWarnings(results) {
-    // Escape hatch because SWC is quite aggressive to report errors
-    // See https://github.com/facebook/docusaurus/pull/10554
-    // See https://github.com/swc-project/swc/discussions/9616#discussioncomment-10846201
-    if (process.env.DOCUSAURUS_IGNORE_SSG_WARNINGS === 'true') {
-        return;
-    }
-    const ignoredWarnings = [
-        // TODO React/Docusaurus emit NULL chars, and minifier detects it
-        //  see https://github.com/facebook/docusaurus/issues/9985
-        'Unexpected null character',
-    ];
-    const keepWarning = (warning) => {
-        return !ignoredWarnings.some((iw) => warning.includes(iw));
-    };
-    const resultsWithWarnings = results
-        .map((result) => {
-        return {
-            ...result,
-            warnings: result.warnings.filter(keepWarning),
-        };
-    })
-        .filter((result) => result.warnings.length > 0);
-    if (resultsWithWarnings.length) {
-        const message = `Docusaurus static site generation process emitted warnings for ${resultsWithWarnings.length} path${resultsWithWarnings.length ? 's' : ''}
-This is non-critical and can be disabled with DOCUSAURUS_IGNORE_SSG_WARNINGS=true
-Troubleshooting guide: https://github.com/facebook/docusaurus/discussions/10580
-
-- ${resultsWithWarnings
-            .map((result) => `${logger_1.default.path(result.pathname)}:
-  - ${result.warnings.join('\n  - ')}
-`)
-            .join('\n- ')}`;
-        logger_1.default.warn(message);
-    }
-}
-async function generateStaticFiles({ pathnames, params, }) {
-    const [renderer, htmlMinifier, ssgTemplate] = await Promise.all([
+async function loadSSGRenderer({ params, }) {
+    const [appRenderer, htmlMinifier, ssgTemplate] = await Promise.all([
         logger_1.PerfLogger.async('Load App renderer', () => loadAppRenderer({
             serverBundlePath: params.serverBundlePath,
         })),
@@ -98,54 +59,49 @@ async function generateStaticFiles({ pathnames, params, }) {
         })),
         logger_1.PerfLogger.async('Compile SSG template', () => (0, ssgTemplate_1.compileSSGTemplate)(params.ssgTemplateContent)),
     ]);
-    // Note that we catch all async errors on purpose
-    // Docusaurus presents all the SSG errors to the user, not just the first one
-    const results = await (0, p_map_1.default)(pathnames, async (pathname) => generateStaticFile({
-        pathname,
-        renderer,
-        params,
-        htmlMinifier,
-        ssgTemplate,
-    }).then((result) => ({
-        pathname,
-        result,
-        error: null,
-        warnings: result.warnings,
-    }), (error) => ({
-        pathname,
-        result: null,
-        error: error,
-        warnings: [],
-    })), { concurrency: ssgUtils_1.SSGConcurrency });
-    await renderer.shutdown();
-    printSSGWarnings(results);
-    const [allSSGErrors, allSSGSuccesses] = lodash_1.default.partition(results, (result) => !!result.error);
-    if (allSSGErrors.length > 0) {
-        const message = `Docusaurus static site generation failed for ${allSSGErrors.length} path${allSSGErrors.length ? 's' : ''}:\n- ${allSSGErrors
-            .map((ssgError) => logger_1.default.path(ssgError.pathname))
-            .join('\n- ')}`;
-        // Note logging this error properly require using inspect(error,{depth})
-        // See https://github.com/nodejs/node/issues/51637
-        throw new Error(message, {
-            cause: new AggregateError(allSSGErrors.map((ssgError) => ssgError.error)),
-        });
-    }
-    const collectedData = lodash_1.default.chain(allSSGSuccesses)
-        .keyBy((success) => success.pathname)
-        .mapValues((ssgSuccess) => ssgSuccess.result.collectedData)
-        .value();
-    return { collectedData };
+    return {
+        renderPathnames: (pathnames) => {
+            return (0, p_map_1.default)(pathnames, async (pathname) => generateStaticFile({
+                pathname,
+                appRenderer,
+                params,
+                htmlMinifier,
+                ssgTemplate,
+            }), { concurrency: ssgEnv_1.SSGConcurrency });
+        },
+        shutdown: async () => {
+            await appRenderer.shutdown();
+        },
+    };
 }
-async function generateStaticFile({ pathname, renderer, params, htmlMinifier, ssgTemplate, }) {
+// We reduce the page collected data structure after the HTML file is written
+// Some data (modules, metadata.internal) is only useful to create the HTML file
+// It's not useful to aggregate that collected data in memory
+// Keep this data structure as small as possible
+// See https://github.com/facebook/docusaurus/pull/11162
+function reduceCollectedData(pageCollectedData) {
+    // We re-create the object from scratch
+    // We absolutely want to avoid TS duck typing
+    return {
+        anchors: pageCollectedData.anchors,
+        metadata: {
+            public: pageCollectedData.metadata.public,
+            helmet: pageCollectedData.metadata.helmet,
+        },
+        links: pageCollectedData.links,
+    };
+}
+async function generateStaticFile({ pathname, appRenderer, params, htmlMinifier, ssgTemplate, }) {
     try {
         // This only renders the app HTML
-        const result = await renderer.render({
+        const appRenderResult = await appRenderer.render({
             pathname,
+            v4RemoveLegacyPostBuildHeadAttribute: params.v4RemoveLegacyPostBuildHeadAttribute,
         });
         // This renders the full page HTML, including head tags...
         const fullPageHtml = (0, ssgTemplate_1.renderSSGTemplate)({
             params,
-            result,
+            result: appRenderResult,
             ssgTemplate,
         });
         const minifierResult = await htmlMinifier.minify(fullPageHtml);
@@ -154,19 +110,28 @@ async function generateStaticFile({ pathname, renderer, params, htmlMinifier, ss
             content: minifierResult.code,
             params,
         });
+        const collectedData = reduceCollectedData(appRenderResult.collectedData);
         return {
-            collectedData: result.collectedData,
-            // As of today, only the html minifier can emit SSG warnings
-            warnings: minifierResult.warnings,
+            success: true,
+            pathname,
+            result: {
+                collectedData,
+                // As of today, only the html minifier can emit SSG warnings
+                warnings: minifierResult.warnings,
+            },
         };
     }
     catch (errorUnknown) {
         const error = errorUnknown;
         const tips = getSSGErrorTips(error);
         const message = logger_1.default.interpolate `Can't render static file for pathname path=${pathname}${tips ? `\n\n${tips}` : ''}`;
-        throw new Error(message, {
-            cause: error,
-        });
+        return {
+            success: false,
+            pathname,
+            error: new Error(message, {
+                cause: error,
+            }),
+        };
     }
 }
 function getSSGErrorTips(error) {

package/lib/ssg/ssgTemplate.js

@@ -35,15 +35,14 @@ function getScriptsAndStylesheets({ modules, manifest, }) {
 }
 function renderSSGTemplate({ params, result, ssgTemplate, }) {
     const { baseUrl, headTags, preBodyTags, postBodyTags, manifest, noIndex, DOCUSAURUS_VERSION, } = params;
-    const { html: appHtml, collectedData: { modules, helmet }, } = result;
+    const { html: appHtml, collectedData: { modules, metadata }, } = result;
     const { scripts, stylesheets } = getScriptsAndStylesheets({ manifest, modules });
-    const htmlAttributes = helmet.htmlAttributes.toString();
-    const bodyAttributes = helmet.bodyAttributes.toString();
+    const { htmlAttributes, bodyAttributes } = metadata.internal;
     const metaStrings = [
-        helmet.title.toString(),
-        helmet.meta.toString(),
-        helmet.link.toString(),
-        helmet.script.toString(),
+        metadata.internal.title,
+        metadata.internal.meta,
+        metadata.internal.link,
+        metadata.internal.script,
     ];
     const metaAttributes = metaStrings.filter(Boolean);
     const data = {

package/lib/ssg/ssgUtils.d.ts

@@ -5,7 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  */
 import type { SSGParams } from './ssgParams';
-export declare const SSGConcurrency: number;
 export declare function generateHashRouterEntrypoint({ content, params, }: {
     content: string;
     params: SSGParams;

package/lib/ssg/ssgUtils.js

@@ -6,20 +6,11 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SSGConcurrency = void 0;
 exports.generateHashRouterEntrypoint = generateHashRouterEntrypoint;
 exports.writeStaticFile = writeStaticFile;
 const tslib_1 = require("tslib");
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const path_1 = tslib_1.__importDefault(require("path"));
-// Secret way to set SSR plugin concurrency option
-// Waiting for feedback before documenting this officially?
-exports.SSGConcurrency = process.env.DOCUSAURUS_SSR_CONCURRENCY
-    ? parseInt(process.env.DOCUSAURUS_SSR_CONCURRENCY, 10)
-    : // Not easy to define a reasonable option default
-        // Will still be better than Infinity
-        // See also https://github.com/sindresorhus/p-map/issues/24
-        32;
 function pathnameToFilename({ pathname, trailingSlash, }) {
     const outputFileName = pathname.replace(/^[/\\]/, ''); // Remove leading slashes for webpack-dev-server
     // Paths ending with .html are left untouched

package/lib/ssg/ssgWorkerInline.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 SSGResult } from './ssgRenderer';
+import type { SSGParams } from './ssgParams';
+export declare function executeSSGInlineTask(arg: {
+    pathnames: string[];
+    params: SSGParams;
+}): Promise<SSGResult[]>;

package/lib/ssg/ssgWorkerInline.js

@@ -0,0 +1,17 @@
+"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.executeSSGInlineTask = executeSSGInlineTask;
+const ssgRenderer_1 = require("./ssgRenderer");
+// "inline" means in the current thread, not in a worker
+async function executeSSGInlineTask(arg) {
+    const appRenderer = await (0, ssgRenderer_1.loadSSGRenderer)({ params: arg.params });
+    const ssgResults = appRenderer.renderPathnames(arg.pathnames);
+    await appRenderer.shutdown();
+    return ssgResults;
+}

package/lib/ssg/ssgWorkerThread.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 SSGResult } from './ssgRenderer.js';
+export type SSGWorkerThreadTask = {
+    id: number;
+    pathnames: string[];
+};
+export default function executeSSGWorkerThreadTask(task: SSGWorkerThreadTask): Promise<SSGResult[]>;
+export type ExecuteSSGWorkerThreadTask = typeof executeSSGWorkerThreadTask;

package/lib/ssg/ssgWorkerThread.js

@@ -0,0 +1,36 @@
+"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.default = executeSSGWorkerThreadTask;
+const tslib_1 = require("tslib");
+const node_worker_threads_1 = require("node:worker_threads");
+const logger_1 = tslib_1.__importStar(require("@docusaurus/logger"));
+const ssgRenderer_js_1 = require("./ssgRenderer.js");
+// eslint-disable-next-line no-underscore-dangle
+const workerId = process?.__tinypool_state__?.workerId;
+if (!workerId) {
+    throw new Error('SSG Worker Thread not executing in Tinypool context?');
+}
+const params = node_worker_threads_1.workerData?.[1]?.params;
+if (!params) {
+    throw new Error(`SSG Worker Thread workerData params missing`);
+}
+const WorkerLogPrefix = `SSG Worker ${logger_1.default.name(workerId)}`;
+// We only load once the SSG rendered (expensive), NOT once per worker task
+// TODO check potential memory leak?
+const appRendererPromise = logger_1.PerfLogger.async(`${WorkerLogPrefix} - Initialization`, () => (0, ssgRenderer_js_1.loadSSGRenderer)({
+    params,
+}));
+async function executeSSGWorkerThreadTask(task) {
+    const appRenderer = await appRendererPromise;
+    const ssgResults = await logger_1.PerfLogger.async(`${WorkerLogPrefix} - Task ${logger_1.default.name(task.id)} - Rendering ${logger_1.default.cyan(task.pathnames.length)} pathnames`, () => appRenderer.renderPathnames(task.pathnames));
+    // Afaik it's not needed to shutdown here,
+    // The thread pool destroys worker thread and releases worker thread memory
+    // await appRenderer.shutdown();
+    return ssgResults;
+}

package/lib/webpack/base.js

@@ -16,6 +16,7 @@ const babel_1 = require("@docusaurus/babel");
 const bundler_1 = require("@docusaurus/bundler");
 const utils_1 = require("@docusaurus/utils");
 const aliases_1 = require("./aliases");
+const BundlerCPUProfilerPlugin_1 = require("./plugins/BundlerCPUProfilerPlugin");
 const CSS_REGEX = /\.css$/i;
 const CSS_MODULE_REGEX = /\.module\.css$/i;
 exports.clientDir = path_1.default.join(__dirname, '..', 'client');
@@ -58,43 +59,72 @@ async function createBaseConfig({ props, isServer, minify, faster, configureWebp
     const CSSExtractPlugin = await (0, bundler_1.getCSSExtractPlugin)({
         currentBundler: props.currentBundler,
     });
+    // Can we share the same cache across locales?
+    // Exploring that question at https://github.com/webpack/webpack/issues/13034
+    function getCacheName() {
+        return `${name}-${mode}-${props.i18n.currentLocale}`;
+    }
+    // When the version string changes, the cache is evicted
+    function getCacheVersion() {
+        // Because Webpack does not evict the cache on alias/swizzle changes,
+        // See https://github.com/webpack/webpack/issues/13627
+        const themeAliasesHash = (0, utils_1.md5Hash)(JSON.stringify(themeAliases));
+        return `${siteMetadata.docusaurusVersion}-${themeAliasesHash}`;
+    }
+    // When one of those modules/dependencies change (including transitive
+    // deps), cache is invalidated
+    function getCacheBuildDependencies() {
+        return [
+            __filename,
+            path_1.default.join(__dirname, isServer ? 'server.js' : 'client.js'),
+            // Docusaurus config changes can affect MDX/JSX compilation, so we'd
+            // rather evict the cache.
+            // See https://github.com/questdb/questdb.io/issues/493
+            siteConfigPath,
+        ];
+    }
     function getCache() {
+        // Use default: memory cache in dev, nothing in prod
+        // See https://rspack.dev/config/cache#cache
+        const disabledPersistentCacheValue = undefined;
+        if (process.env.DOCUSAURUS_NO_PERSISTENT_CACHE) {
+            return disabledPersistentCacheValue;
+        }
         if (props.currentBundler.name === 'rspack') {
-            // TODO Rspack only supports memory cache (as of Sept 2024)
-            // TODO re-enable file persistent cache one Rspack supports it
-            //  See also https://rspack.dev/config/cache#cache
-            return undefined;
+            if (props.siteConfig.future.experimental_faster.rspackPersistentCache) {
+                // Use cache: true + experiments.cache.type: "persistent"
+                // See https://rspack.dev/config/experiments#persistent-cache
+                return true;
+            }
+            else {
+                return disabledPersistentCacheValue;
+            }
         }
         return {
             type: 'filesystem',
-            // Can we share the same cache across locales?
-            // Exploring that question at https://github.com/webpack/webpack/issues/13034
-            // name: `${name}-${mode}`,
-            name: `${name}-${mode}-${props.i18n.currentLocale}`,
-            // When version string changes, cache is evicted
-            version: [
-                siteMetadata.docusaurusVersion,
-                // Webpack does not evict the cache correctly on alias/swizzle change,
-                // so we force eviction.
-                // See https://github.com/webpack/webpack/issues/13627
-                (0, utils_1.md5Hash)(JSON.stringify(themeAliases)),
-            ].join('-'),
-            // When one of those modules/dependencies change (including transitive
-            // deps), cache is invalidated
+            name: getCacheName(),
+            version: getCacheVersion(),
             buildDependencies: {
-                config: [
-                    __filename,
-                    path_1.default.join(__dirname, isServer ? 'server.js' : 'client.js'),
-                    // Docusaurus config changes can affect MDX/JSX compilation, so we'd
-                    // rather evict the cache.
-                    // See https://github.com/questdb/questdb.io/issues/493
-                    siteConfigPath,
-                ],
+                config: getCacheBuildDependencies(),
             },
         };
     }
     function getExperiments() {
         if (props.currentBundler.name === 'rspack') {
+            const PersistentCacheAttributes = process.env
+                .DOCUSAURUS_NO_PERSISTENT_CACHE
+                ? {}
+                : {
+                    cache: {
+                        type: 'persistent',
+                        // Rspack doesn't have "cache.name" like Webpack
+                        // This is not ideal but work around is to merge name/version
+                        // See https://github.com/web-infra-dev/rspack/pull/8920#issuecomment-2658938695
+                        version: `${getCacheName()}-${getCacheVersion()}`,
+                        buildDependencies: getCacheBuildDependencies(),
+                    },
+                };
+            // TODO find a way to type this
             return {
                 // This is mostly useful in dev
                 // See https://rspack.dev/config/experiments#experimentsincremental
@@ -105,6 +135,10 @@ async function createBaseConfig({ props, isServer, minify, faster, configureWebp
                 // See https://github.com/facebook/docusaurus/issues/10646
                 // @ts-expect-error: Rspack-only, not available in Webpack typedefs
                 incremental: !isProd && !process.env.DISABLE_RSPACK_INCREMENTAL,
+                // TODO re-enable later, there's an Rspack performance issue
+                //  see https://github.com/facebook/docusaurus/pull/11178
+                parallelCodeSplitting: false,
+                ...PersistentCacheAttributes,
             };
         }
         return undefined;
@@ -162,7 +196,18 @@ async function createBaseConfig({ props, isServer, minify, faster, configureWebp
             modules: ['node_modules', path_1.default.join(siteDir, 'node_modules')],
         },
         optimization: {
-            removeAvailableModules: false,
+            // The optimization.concatenateModules is expensive
+            // - On the server, it's not useful to run it at all
+            // - On the client, it leads to a ~3% JS assets total size decrease
+            //   Let's keep it by default, but large sites may prefer faster builds
+            // See also https://github.com/facebook/docusaurus/pull/11176
+            concatenateModules: !isServer,
+            // The optimization.mergeDuplicateChunks is expensive
+            // - On the server, it's not useful to run it at all
+            // - On the client, we compared assets/js before/after and see 0 change
+            //   `du -sk js-before js-after` => the JS assets have the exact same size
+            // See also https://github.com/facebook/docusaurus/pull/11176
+            mergeDuplicateChunks: false,
             // Only minimize client bundle in production because server bundle is only
             // used for static site generation
             minimize: minimizeEnabled,
@@ -201,6 +246,7 @@ async function createBaseConfig({ props, isServer, minify, faster, configureWebp
         module: {
             rules: [
                 fileLoaderUtils.rules.images(),
+                fileLoaderUtils.rules.svgs(),
                 fileLoaderUtils.rules.fonts(),
                 fileLoaderUtils.rules.media(),
                 fileLoaderUtils.rules.otherAssets(),
@@ -252,6 +298,8 @@ async function createBaseConfig({ props, isServer, minify, faster, configureWebp
                 // for more reasoning
                 ignoreOrder: true,
             }),
-        ],
+            process.env.DOCUSAURUS_BUNDLER_CPU_PROFILE &&
+                new BundlerCPUProfilerPlugin_1.BundlerCPUProfilerPlugin(),
+        ].filter(Boolean),
     };
 }

package/lib/webpack/client.js

@@ -17,7 +17,6 @@ const html_webpack_plugin_1 = tslib_1.__importDefault(require("html-webpack-plug
 const bundler_1 = require("@docusaurus/bundler");
 const base_1 = require("./base");
 const ChunkAssetPlugin_1 = tslib_1.__importDefault(require("./plugins/ChunkAssetPlugin"));
-const CleanWebpackPlugin_1 = tslib_1.__importDefault(require("./plugins/CleanWebpackPlugin"));
 const ForceTerminatePlugin_1 = tslib_1.__importDefault(require("./plugins/ForceTerminatePlugin"));
 const StaticDirectoriesCopyPlugin_1 = require("./plugins/StaticDirectoriesCopyPlugin");
 async function createBaseClientConfig({ props, hydrate, minify, faster, configureWebpackUtils, }) {
@@ -108,8 +107,6 @@ async function createBuildClientConfig({ props, minify, faster, configureWebpack
     }), {
         plugins: [
             new ForceTerminatePlugin_1.default(),
-            // 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.
             bundleAnalyzer && new webpack_bundle_analyzer_1.BundleAnalyzerPlugin(),

package/lib/webpack/plugins/BundlerCPUProfilerPlugin.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 { Compiler } from 'webpack';
+export declare class BundlerCPUProfilerPlugin {
+    output: string;
+    constructor(output?: string);
+    apply(compiler: Compiler): void;
+}

package/lib/webpack/plugins/BundlerCPUProfilerPlugin.js

@@ -0,0 +1,41 @@
+"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.BundlerCPUProfilerPlugin = void 0;
+const tslib_1 = require("tslib");
+const node_inspector_1 = tslib_1.__importDefault(require("node:inspector"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+// Bundle CPU profiling plugin, contributed by the Rspack team
+// Can be opened in https://www.speedscope.app/
+// See also https://github.com/jerrykingxyz/docusaurus/pull/1
+// See also https://github.com/facebook/docusaurus/pull/10985
+class BundlerCPUProfilerPlugin {
+    constructor(output) {
+        this.output = output ?? './bundler-cpu-profile.json';
+    }
+    apply(compiler) {
+        const session = new node_inspector_1.default.Session();
+        session.connect();
+        session.post('Profiler.enable');
+        session.post('Profiler.start');
+        // In dev/watch mode, we restart the profiler before each compilation
+        compiler.hooks.watchRun.tapPromise(BundlerCPUProfilerPlugin.name, async () => {
+            session.post('Profiler.start');
+        });
+        compiler.hooks.done.tapPromise(BundlerCPUProfilerPlugin.name, async () => {
+            session.post('Profiler.stop', (error, param) => {
+                if (error) {
+                    console.error('Failed to generate JS CPU profile:', error);
+                    return;
+                }
+                fs_extra_1.default.writeFile(this.output, JSON.stringify(param.profile)).catch(console.error);
+            });
+        });
+    }
+}
+exports.BundlerCPUProfilerPlugin = BundlerCPUProfilerPlugin;