@docusaurus/core 3.5.2 → 3.6.0

package/lib/server/translations/translationsExtractor.js

@@ -6,33 +6,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.globSourceCodeFilePaths = globSourceCodeFilePaths;
 exports.extractSiteSourceCodeTranslations = extractSiteSourceCodeTranslations;
-exports.extractAllSourceCodeFileTranslations = extractAllSourceCodeFileTranslations;
-exports.extractSourceCodeFileTranslations = extractSourceCodeFileTranslations;
 const tslib_1 = require("tslib");
 const path_1 = tslib_1.__importDefault(require("path"));
-const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
-const traverse_1 = tslib_1.__importDefault(require("@babel/traverse"));
-const generator_1 = tslib_1.__importDefault(require("@babel/generator"));
-const core_1 = require("@babel/core");
 const utils_1 = require("@docusaurus/utils");
-const utils_2 = require("../utils");
-// We only support extracting source code translations from these kind of files
-const TranslatableSourceCodeExtension = new Set([
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    // TODO support md/mdx too? (may be overkill)
-    // need to compile the MDX to JSX first and remove front matter
-    // '.md',
-    // '.mdx',
-]);
-function isTranslatableSourceCodePath(filePath) {
-    return TranslatableSourceCodeExtension.has(path_1.default.extname(filePath));
-}
+const babel_1 = require("@docusaurus/babel");
 function getSiteSourceCodeFilePaths(siteDir) {
     return [path_1.default.join(siteDir, utils_1.SRC_DIR_NAME)];
 }
@@ -49,10 +28,6 @@ function getPluginSourceCodeFilePaths(plugin) {
     }
     return codePaths.map((p) => path_1.default.resolve(plugin.path, p));
 }
-async function globSourceCodeFilePaths(dirPaths) {
-    const filePaths = await (0, utils_2.safeGlobby)(dirPaths);
-    return filePaths.filter(isTranslatableSourceCodePath);
-}
 async function getSourceCodeFilePaths(siteDir, plugins) {
     const sitePaths = getSiteSourceCodeFilePaths(siteDir);
     // The getPathsToWatch() generally returns the js/jsx/ts/tsx/md/mdx file paths
@@ -61,9 +36,13 @@ async function getSourceCodeFilePaths(siteDir, plugins) {
     // new lifecycle method for that???
     const pluginsPaths = plugins.flatMap(getPluginSourceCodeFilePaths);
     const allPaths = [...sitePaths, ...pluginsPaths];
-    return globSourceCodeFilePaths(allPaths);
+    return (0, utils_1.globTranslatableSourceFiles)(allPaths);
 }
-async function extractSiteSourceCodeTranslations(siteDir, plugins, babelOptions, extraSourceCodeFilePaths = []) {
+async function extractSiteSourceCodeTranslations({ siteDir, plugins, extraSourceCodeFilePaths = [], }) {
+    const babelOptions = (0, babel_1.getBabelOptions)({
+        isServer: true,
+        babelOptions: await (0, babel_1.getCustomBabelConfigFilePath)(siteDir),
+    });
     // Should we warn here if the same translation "key" is found in multiple
     // source code files?
     function toTranslationFileContent(sourceCodeFileTranslations) {
@@ -74,7 +53,7 @@ async function extractSiteSourceCodeTranslations(siteDir, plugins, babelOptions,
         ...sourceCodeFilePaths,
         ...extraSourceCodeFilePaths,
     ];
-    const sourceCodeFilesTranslations = await extractAllSourceCodeFileTranslations(allSourceCodeFilePaths, babelOptions);
+    const sourceCodeFilesTranslations = await (0, babel_1.extractAllSourceCodeFileTranslations)(allSourceCodeFilePaths, babelOptions);
     logSourceCodeFileTranslationsWarnings(sourceCodeFilesTranslations);
     return toTranslationFileContent(sourceCodeFilesTranslations);
 }
@@ -85,170 +64,3 @@ function logSourceCodeFileTranslationsWarnings(sourceCodeFilesTranslations) {
         }
     });
 }
-async function extractAllSourceCodeFileTranslations(sourceCodeFilePaths, babelOptions) {
-    return Promise.all(sourceCodeFilePaths.flatMap((sourceFilePath) => extractSourceCodeFileTranslations(sourceFilePath, babelOptions)));
-}
-async function extractSourceCodeFileTranslations(sourceCodeFilePath, babelOptions) {
-    try {
-        const code = await fs_extra_1.default.readFile(sourceCodeFilePath, 'utf8');
-        const ast = (0, core_1.parse)(code, {
-            ...babelOptions,
-            ast: true,
-            // filename is important, because babel does not process the same files
-            // according to their js/ts extensions.
-            // See https://twitter.com/NicoloRibaudo/status/1321130735605002243
-            filename: sourceCodeFilePath,
-        });
-        const translations = extractSourceCodeAstTranslations(ast, sourceCodeFilePath);
-        return translations;
-    }
-    catch (err) {
-        logger_1.default.error `Error while attempting to extract Docusaurus translations from source code file at path=${sourceCodeFilePath}.`;
-        throw err;
-    }
-}
-/*
-Need help understanding this?
-
-Useful resources:
-https://github.com/jamiebuilds/babel-handbook/blob/master/translations/en/plugin-handbook.md
-https://github.com/formatjs/formatjs/blob/main/packages/babel-plugin-formatjs/index.ts
-https://github.com/pugjs/babel-walk
- */
-function extractSourceCodeAstTranslations(ast, sourceCodeFilePath) {
-    function sourceWarningPart(node) {
-        return `File: ${sourceCodeFilePath} at line ${node.loc?.start.line ?? '?'}
-Full code: ${(0, generator_1.default)(node).code}`;
-    }
-    const translations = {};
-    const warnings = [];
-    let translateComponentName;
-    let translateFunctionName;
-    // First pass: find import declarations of Translate / translate.
-    // If not found, don't process the rest to avoid false positives
-    (0, traverse_1.default)(ast, {
-        ImportDeclaration(path) {
-            if (path.node.importKind === 'type' ||
-                path.get('source').node.value !== '@docusaurus/Translate') {
-                return;
-            }
-            const importSpecifiers = path.get('specifiers');
-            const defaultImport = importSpecifiers.find((specifier) => specifier.node.type === 'ImportDefaultSpecifier');
-            const callbackImport = importSpecifiers.find((specifier) => specifier.node.type === 'ImportSpecifier' &&
-                (specifier.get('imported')
-                    .node.name === 'translate' ||
-                    specifier.get('imported')
-                        .node.value === 'translate'));
-            translateComponentName = defaultImport?.get('local').node.name;
-            translateFunctionName = callbackImport?.get('local').node.name;
-        },
-    });
-    (0, traverse_1.default)(ast, {
-        ...(translateComponentName && {
-            JSXElement(path) {
-                if (!path
-                    .get('openingElement')
-                    .get('name')
-                    .isJSXIdentifier({ name: translateComponentName })) {
-                    return;
-                }
-                function evaluateJSXProp(propName) {
-                    const attributePath = path
-                        .get('openingElement.attributes')
-                        .find((attr) => attr.isJSXAttribute() &&
-                        attr.get('name').isJSXIdentifier({ name: propName }));
-                    if (attributePath) {
-                        const attributeValue = attributePath.get('value');
-                        const attributeValueEvaluated = attributeValue.isJSXExpressionContainer()
-                            ? attributeValue.get('expression').evaluate()
-                            : attributeValue.evaluate();
-                        if (attributeValueEvaluated.confident &&
-                            typeof attributeValueEvaluated.value === 'string') {
-                            return attributeValueEvaluated.value;
-                        }
-                        warnings.push(`<Translate> prop=${propName} should be a statically evaluable object.
-Example: <Translate id="optional id" description="optional description">Message</Translate>
-Dynamically constructed values are not allowed, because they prevent translations to be extracted.
-${sourceWarningPart(path.node)}`);
-                    }
-                    return undefined;
-                }
-                const id = evaluateJSXProp('id');
-                const description = evaluateJSXProp('description');
-                let message;
-                const childrenPath = path.get('children');
-                // Handle empty content
-                if (!childrenPath.length) {
-                    if (!id) {
-                        warnings.push(`<Translate> without children must have id prop.
-Example: <Translate id="my-id" />
-${sourceWarningPart(path.node)}`);
-                    }
-                    else {
-                        translations[id] = {
-                            message: id,
-                            ...(description && { description }),
-                        };
-                    }
-                    return;
-                }
-                // Handle single non-empty content
-                const singleChildren = childrenPath
-                    // Remove empty/useless text nodes that might be around our
-                    // translation! Makes the translation system more reliable to JSX
-                    // formatting issues
-                    .filter((children) => !(children.isJSXText() &&
-                    children.node.value.replace('\n', '').trim() === ''))
-                    .pop();
-                const isJSXText = singleChildren?.isJSXText();
-                const isJSXExpressionContainer = singleChildren?.isJSXExpressionContainer() &&
-                    singleChildren.get('expression').evaluate().confident;
-                if (isJSXText || isJSXExpressionContainer) {
-                    message = isJSXText
-                        ? singleChildren.node.value.trim().replace(/\s+/g, ' ')
-                        : String(singleChildren.get('expression').evaluate().value);
-                    translations[id ?? message] = {
-                        message,
-                        ...(description && { description }),
-                    };
-                }
-                else {
-                    warnings.push(`Translate content could not be extracted. It has to be a static string and use optional but static props, like <Translate id="my-id" description="my-description">text</Translate>.
-${sourceWarningPart(path.node)}`);
-                }
-            },
-        }),
-        ...(translateFunctionName && {
-            CallExpression(path) {
-                if (!path.get('callee').isIdentifier({ name: translateFunctionName })) {
-                    return;
-                }
-                const args = path.get('arguments');
-                if (args.length === 1 || args.length === 2) {
-                    const firstArgPath = args[0];
-                    // translate("x" + "y"); => translate("xy");
-                    const firstArgEvaluated = firstArgPath.evaluate();
-                    if (firstArgEvaluated.confident &&
-                        typeof firstArgEvaluated.value === 'object') {
-                        const { message, id, description } = firstArgEvaluated.value;
-                        translations[String(id ?? message)] = {
-                            message: String(message ?? id),
-                            ...(Boolean(description) && { description: String(description) }),
-                        };
-                    }
-                    else {
-                        warnings.push(`translate() first arg should be a statically evaluable object.
-Example: translate({message: "text",id: "optional.id",description: "optional description"}
-Dynamically constructed values are not allowed, because they prevent translations to be extracted.
-${sourceWarningPart(path.node)}`);
-                    }
-                }
-                else {
-                    warnings.push(`translate() function only takes 1 or 2 args
-${sourceWarningPart(path.node)}`);
-                }
-            },
-        }),
-    });
-    return { sourceCodeFilePath, translations, warnings };
-}

package/lib/ssg/ssg.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 { AppRenderer, SiteCollectedData } from '../common';
+export declare function loadAppRenderer({ serverBundlePath, }: {
+    serverBundlePath: string;
+}): Promise<AppRenderer>;
+export declare function printSSGWarnings(results: {
+    pathname: string;
+    warnings: string[];
+}[]): void;
+export declare function generateStaticFiles({ pathnames, params, }: {
+    pathnames: string[];
+    params: SSGParams;
+}): Promise<{
+    collectedData: SiteCollectedData;
+}>;

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

@@ -7,31 +7,26 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadAppRenderer = loadAppRenderer;
+exports.printSSGWarnings = printSSGWarnings;
 exports.generateStaticFiles = generateStaticFiles;
-exports.generateHashRouterEntrypoint = generateHashRouterEntrypoint;
 const tslib_1 = require("tslib");
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
-const module_1 = require("module");
 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"));
 const p_map_1 = tslib_1.__importDefault(require("p-map"));
-const html_minifier_terser_1 = require("html-minifier-terser");
-const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
-const utils_1 = require("./utils");
-const templates_1 = require("./templates/templates");
-// Secret way to set SSR plugin concurrency option
-// Waiting for feedback before documenting this officially?
-const Concurrency = 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;
+const logger_1 = tslib_1.__importStar(require("@docusaurus/logger"));
+const bundler_1 = require("@docusaurus/bundler");
+const ssgTemplate_1 = require("./ssgTemplate");
+const ssgUtils_1 = require("./ssgUtils");
+const ssgNodeRequire_1 = require("./ssgNodeRequire");
 async function loadAppRenderer({ serverBundlePath, }) {
-    const source = await utils_1.PerfLogger.async(`Load server bundle`, () => fs_extra_1.default.readFile(serverBundlePath));
-    utils_1.PerfLogger.log(`Server bundle size = ${(source.length / 1024000).toFixed(3)} MB`);
+    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 = {
         // When using "new URL('file.js', import.meta.url)", Webpack will emit
         // __filename, and this plugin will throw. not sure the __filename value
@@ -40,43 +35,91 @@ async function loadAppRenderer({ serverBundlePath, }) {
         __filename: '',
         // This uses module.createRequire() instead of very old "require-like" lib
         // See also: https://github.com/pierrec/node-eval/issues/33
-        require: (0, module_1.createRequire)(serverBundlePath),
+        require: ssgRequire.require,
     };
-    const serverEntry = await utils_1.PerfLogger.async(`Evaluate server bundle`, () => (0, eval_1.default)(source, 
+    const serverEntry = await logger_1.PerfLogger.async(`Evaluate server bundle`, () => (0, eval_1.default)(source, 
     /* filename: */ filename, 
     /* 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.`);
     }
-    return serverEntry.default;
-}
-function pathnameToFilename({ pathname, trailingSlash, }) {
-    const outputFileName = pathname.replace(/^[/\\]/, ''); // Remove leading slashes for webpack-dev-server
-    // Paths ending with .html are left untouched
-    if (/\.html?$/i.test(outputFileName)) {
-        return outputFileName;
+    async function shutdown() {
+        ssgRequire.cleanup();
     }
-    // Legacy retro-compatible behavior
-    if (typeof trailingSlash === 'undefined') {
-        return path_1.default.join(outputFileName, 'index.html');
+    return {
+        render: serverEntry.default,
+        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;
     }
-    // New behavior: we can say if we prefer file/folder output
-    // Useful resource: https://github.com/slorber/trailing-slash-guide
-    if (pathname === '' || pathname.endsWith('/') || trailingSlash) {
-        return path_1.default.join(outputFileName, 'index.html');
+    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);
     }
-    return `${outputFileName}.html`;
 }
-async function generateStaticFiles({ pathnames, renderer, params, }) {
+async function generateStaticFiles({ pathnames, params, }) {
+    const [renderer, htmlMinifier, ssgTemplate] = await Promise.all([
+        logger_1.PerfLogger.async('Load App renderer', () => loadAppRenderer({
+            serverBundlePath: params.serverBundlePath,
+        })),
+        logger_1.PerfLogger.async('Load HTML minifier', () => (0, bundler_1.getHtmlMinifier)({
+            type: params.htmlMinifierType,
+        })),
+        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,
-    }).then((result) => ({ pathname, result, error: null }), (error) => ({ pathname, result: null, error: error })), { concurrency: Concurrency });
-    const [allSSGErrors, allSSGSuccesses] = lodash_1.default.partition(results, (r) => !!r.error);
+        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))
@@ -93,24 +136,29 @@ async function generateStaticFiles({ pathnames, renderer, params, }) {
         .value();
     return { collectedData };
 }
-async function generateStaticFile({ pathname, renderer, params, }) {
+async function generateStaticFile({ pathname, renderer, params, htmlMinifier, ssgTemplate, }) {
     try {
         // This only renders the app HTML
-        const result = await renderer({
+        const result = await renderer.render({
             pathname,
         });
         // This renders the full page HTML, including head tags...
-        const fullPageHtml = (0, templates_1.renderSSRTemplate)({
+        const fullPageHtml = (0, ssgTemplate_1.renderSSGTemplate)({
             params,
             result,
+            ssgTemplate,
         });
-        const content = await minifyHtml(fullPageHtml);
-        await writeStaticFile({
+        const minifierResult = await htmlMinifier.minify(fullPageHtml);
+        await (0, ssgUtils_1.writeStaticFile)({
             pathname,
-            content,
+            content: minifierResult.code,
             params,
         });
-        return result;
+        return {
+            collectedData: result.collectedData,
+            // As of today, only the html minifier can emit SSG warnings
+            warnings: minifierResult.warnings,
+        };
     }
     catch (errorUnknown) {
         const error = errorUnknown;
@@ -133,42 +181,3 @@ It might also require to wrap your client code in ${logger_1.default.code('useEf
     }
     return parts.join('\n');
 }
-async function generateHashRouterEntrypoint({ content, params, }) {
-    await writeStaticFile({
-        pathname: '/',
-        content,
-        params,
-    });
-}
-async function writeStaticFile({ content, pathname, params, }) {
-    function removeBaseUrl(p, baseUrl) {
-        return baseUrl === '/' ? p : p.replace(new RegExp(`^${baseUrl}`), '/');
-    }
-    const filename = pathnameToFilename({
-        pathname: removeBaseUrl(pathname, params.baseUrl),
-        trailingSlash: params.trailingSlash,
-    });
-    const filePath = path_1.default.join(params.outDir, filename);
-    await fs_extra_1.default.ensureDir(path_1.default.dirname(filePath));
-    await fs_extra_1.default.writeFile(filePath, content);
-}
-async function minifyHtml(html) {
-    try {
-        if (process.env.SKIP_HTML_MINIFICATION === 'true') {
-            return html;
-        }
-        // Minify html with https://github.com/DanielRuf/html-minifier-terser
-        return await (0, html_minifier_terser_1.minify)(html, {
-            removeComments: false,
-            removeRedundantAttributes: true,
-            removeEmptyAttributes: true,
-            removeScriptTypeAttributes: true,
-            removeStyleLinkTypeAttributes: true,
-            useShortDoctype: true,
-            minifyJS: true,
-        });
-    }
-    catch (err) {
-        throw new Error('HTML minification failed', { cause: err });
-    }
-}

package/lib/ssg/ssgExecutor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 { Props, RouterType } from '@docusaurus/types';
+import type { SiteCollectedData } from '../common';
+export declare function executeSSG({ props, serverBundlePath, clientManifestPath, router, }: {
+    props: Props;
+    serverBundlePath: string;
+    clientManifestPath: string;
+    router: RouterType;
+}): Promise<{
+    collectedData: SiteCollectedData;
+}>;

package/lib/ssg/ssgExecutor.js

@@ -0,0 +1,34 @@
+"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.executeSSG = executeSSG;
+const logger_1 = require("@docusaurus/logger");
+const ssgParams_1 = require("./ssgParams");
+const ssg_1 = require("./ssg");
+const ssgTemplate_1 = require("./ssgTemplate");
+const ssgUtils_1 = require("./ssgUtils");
+// TODO Docusaurus v4 - introduce SSG worker threads
+async function executeSSG({ props, serverBundlePath, clientManifestPath, router, }) {
+    const params = await (0, ssgParams_1.createSSGParams)({
+        serverBundlePath,
+        clientManifestPath,
+        props,
+    });
+    if (router === 'hash') {
+        logger_1.PerfLogger.start('Generate Hash Router entry point');
+        const content = await (0, ssgTemplate_1.renderHashRouterTemplate)({ params });
+        await (0, ssgUtils_1.generateHashRouterEntrypoint)({ content, params });
+        logger_1.PerfLogger.end('Generate Hash Router entry point');
+        return { collectedData: {} };
+    }
+    const ssgResult = await logger_1.PerfLogger.async('Generate static files', () => (0, ssg_1.generateStaticFiles)({
+        pathnames: props.routesPaths,
+        params,
+    }));
+    return ssgResult;
+}

package/lib/{server/utils.d.ts → ssg/ssgNodeRequire.d.ts}

@@ -4,5 +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 { Globby } from '@docusaurus/utils';
-export declare function safeGlobby(patterns: string[], options?: Globby.GlobbyOptions): Promise<string[]>;
+export type SSGNodeRequire = {
+    require: NodeJS.Require;
+    cleanup: () => void;
+};
+export declare function createSSGRequire(serverBundlePath: string): SSGNodeRequire;

package/lib/ssg/ssgNodeRequire.js

@@ -0,0 +1,40 @@
+"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.createSSGRequire = createSSGRequire;
+const module_1 = require("module");
+// The eval/vm.Script used for running the server bundle need a require() impl
+// This impl has to be relative to the server bundler path
+// This enables the server bundle to resolve relative paths such as:
+// - require('./assets/js/some-chunk.123456.js')
+//
+// Unfortunately, Node.js vm.Script doesn't isolate memory / require.cache
+// This means that if we build multiple Docusaurus localized sites in a row
+// The Node.js require cache will keep growing and retain in memory the JS
+// assets of the former SSG builds
+// We have to clean up the node require cache manually to avoid leaking memory!
+// See also https://x.com/sebastienlorber/status/1848399310116831702
+function createSSGRequire(serverBundlePath) {
+    const realRequire = (0, module_1.createRequire)(serverBundlePath);
+    const allRequiredIds = [];
+    const ssgRequireFunction = (id) => {
+        const module = realRequire(id);
+        allRequiredIds.push(id);
+        return module;
+    };
+    const cleanup = () => {
+        allRequiredIds.forEach((id) => {
+            delete realRequire.cache[realRequire.resolve(id)];
+        });
+    };
+    ssgRequireFunction.resolve = realRequire.resolve;
+    ssgRequireFunction.cache = realRequire.cache;
+    ssgRequireFunction.extensions = realRequire.extensions;
+    ssgRequireFunction.main = realRequire.main;
+    return { require: ssgRequireFunction, cleanup };
+}

package/lib/ssg/ssgParams.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 { Manifest } from 'react-loadable-ssr-addon-v5-slorber';
+import type { Props } from '@docusaurus/types';
+import type { HtmlMinifierType } from '@docusaurus/bundler';
+export type SSGParams = {
+    trailingSlash: boolean | undefined;
+    manifest: Manifest;
+    headTags: string;
+    preBodyTags: string;
+    postBodyTags: string;
+    outDir: string;
+    baseUrl: string;
+    noIndex: boolean;
+    DOCUSAURUS_VERSION: string;
+    htmlMinifierType: HtmlMinifierType;
+    serverBundlePath: string;
+    ssgTemplateContent: string;
+};
+export declare function createSSGParams({ props, serverBundlePath, clientManifestPath, }: {
+    props: Props;
+    serverBundlePath: string;
+    clientManifestPath: string;
+}): Promise<SSGParams>;

package/lib/ssg/ssgParams.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.createSSGParams = createSSGParams;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const utils_1 = require("@docusaurus/utils");
+const logger_1 = require("@docusaurus/logger");
+const ssgTemplate_html_1 = tslib_1.__importDefault(require("./ssgTemplate.html"));
+async function createSSGParams({ props, serverBundlePath, clientManifestPath, }) {
+    const manifest = await logger_1.PerfLogger.async('Read client manifest', () => fs_extra_1.default.readJSON(clientManifestPath, 'utf-8'));
+    const params = {
+        trailingSlash: props.siteConfig.trailingSlash,
+        outDir: props.outDir,
+        baseUrl: props.baseUrl,
+        manifest,
+        headTags: props.headTags,
+        preBodyTags: props.preBodyTags,
+        postBodyTags: props.postBodyTags,
+        ssgTemplateContent: props.siteConfig.ssrTemplate ?? ssgTemplate_html_1.default,
+        noIndex: props.siteConfig.noIndex,
+        DOCUSAURUS_VERSION: utils_1.DOCUSAURUS_VERSION,
+        serverBundlePath,
+        htmlMinifierType: props.siteConfig.future.experimental_faster
+            .swcHtmlMinimizer
+            ? 'swc'
+            : 'terser',
+    };
+    // Useless but ensures that SSG params remain serializable
+    return structuredClone(params);
+}