@docusaurus/core 0.0.0-5823 → 0.0.0-5827

package/lib/commands/start.js

@@ -14,7 +14,6 @@ const lodash_1 = tslib_1.__importDefault(require("lodash"));
 const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
 const utils_1 = require("@docusaurus/utils");
 const chokidar_1 = tslib_1.__importDefault(require("chokidar"));
-const html_webpack_plugin_1 = tslib_1.__importDefault(require("html-webpack-plugin"));
 const openBrowser_1 = tslib_1.__importDefault(require("react-dev-utils/openBrowser"));
 const WebpackDevServerUtils_1 = require("react-dev-utils/WebpackDevServerUtils");
 const evalSourceMapMiddleware_1 = tslib_1.__importDefault(require("react-dev-utils/evalSourceMapMiddleware"));
@@ -22,9 +21,10 @@ const webpack_1 = tslib_1.__importDefault(require("webpack"));
 const webpack_dev_server_1 = tslib_1.__importDefault(require("webpack-dev-server"));
 const webpack_merge_1 = tslib_1.__importDefault(require("webpack-merge"));
 const server_1 = require("../server");
-const client_1 = tslib_1.__importDefault(require("../webpack/client"));
+const client_1 = require("../webpack/client");
 const utils_2 = require("../webpack/utils");
 const getHostPort_1 = require("../server/getHostPort");
+const utils_3 = require("../utils");
 async function start(siteDirParam = '.', cliOptions = {}) {
     // Temporary workaround to unlock the ability to translate the site config
     // We'll remove it if a better official API can be designed
@@ -32,30 +32,27 @@ async function start(siteDirParam = '.', cliOptions = {}) {
     process.env.DOCUSAURUS_CURRENT_LOCALE = cliOptions.locale;
     const siteDir = await fs_extra_1.default.realpath(siteDirParam);
     logger_1.default.info('Starting the development server...');
-    function loadSite() {
-        return (0, server_1.load)({
+    async function loadSite() {
+        utils_3.PerfLogger.start('Loading site');
+        const result = await (0, server_1.load)({
             siteDir,
             config: cliOptions.config,
             locale: cliOptions.locale,
             localizePath: undefined, // Should this be configurable?
         });
+        utils_3.PerfLogger.end('Loading site');
+        return result;
     }
     // Process all related files as a prop.
     const props = await loadSite();
-    const protocol = process.env.HTTPS === 'true' ? 'https' : 'http';
-    const { host, port } = await (0, getHostPort_1.getHostPort)(cliOptions);
-    if (port === null) {
-        process.exit();
-    }
-    const { baseUrl, headTags, preBodyTags, postBodyTags } = props;
-    const urls = (0, WebpackDevServerUtils_1.prepareUrls)(protocol, host, port);
-    const openUrl = (0, utils_1.normalizeUrl)([urls.localUrlForBrowser, baseUrl]);
+    const { host, port, getOpenUrl } = await createUrlUtils({ cliOptions });
+    const openUrl = getOpenUrl({ baseUrl: props.baseUrl });
     logger_1.default.success `Docusaurus website is running at: url=${openUrl}`;
     // Reload files processing.
     const reload = lodash_1.default.debounce(() => {
         loadSite()
             .then(({ baseUrl: newBaseUrl }) => {
-            const newOpenUrl = (0, utils_1.normalizeUrl)([urls.localUrlForBrowser, newBaseUrl]);
+            const newOpenUrl = getOpenUrl({ baseUrl: newBaseUrl });
             if (newOpenUrl !== openUrl) {
                 logger_1.default.success `Docusaurus website is running at: url=${newOpenUrl}`;
             }
@@ -64,84 +61,96 @@ async function start(siteDirParam = '.', cliOptions = {}) {
             logger_1.default.error(err.stack);
         });
     }, 500);
-    const { siteConfig, plugins, localizationDir } = props;
-    const normalizeToSiteDir = (filepath) => {
-        if (filepath && path_1.default.isAbsolute(filepath)) {
-            return (0, utils_1.posixPath)(path_1.default.relative(siteDir, filepath));
+    // TODO this is historically not optimized!
+    //  When any site file changes, we reload absolutely everything :/
+    //  At least we should try to reload only one plugin individually?
+    setupFileWatchers({
+        props,
+        cliOptions,
+        onFileChange: () => {
+            reload();
+        },
+    });
+    const config = await getStartClientConfig({
+        props,
+        minify: cliOptions.minify ?? true,
+        poll: cliOptions.poll,
+    });
+    const compiler = (0, webpack_1.default)(config);
+    registerE2ETestHook(compiler);
+    const defaultDevServerConfig = await createDevServerConfig({
+        cliOptions,
+        props,
+        host,
+        port,
+    });
+    // Allow plugin authors to customize/override devServer config
+    const devServerConfig = (0, webpack_merge_1.default)([defaultDevServerConfig, config.devServer].filter(Boolean));
+    const devServer = new webpack_dev_server_1.default(devServerConfig, compiler);
+    devServer.startCallback(() => {
+        if (cliOptions.open) {
+            (0, openBrowser_1.default)(openUrl);
         }
-        return (0, utils_1.posixPath)(filepath);
-    };
-    const pluginPaths = plugins
-        .flatMap((plugin) => plugin.getPathsToWatch?.() ?? [])
-        .filter(Boolean)
-        .map(normalizeToSiteDir);
-    const pathsToWatch = [...pluginPaths, props.siteConfigPath, localizationDir];
-    const pollingOptions = {
+    });
+    ['SIGINT', 'SIGTERM'].forEach((sig) => {
+        process.on(sig, () => {
+            devServer.stop();
+            process.exit();
+        });
+    });
+}
+exports.start = start;
+function createPollingOptions({ cliOptions }) {
+    return {
         usePolling: !!cliOptions.poll,
         interval: Number.isInteger(cliOptions.poll)
             ? cliOptions.poll
             : undefined,
     };
-    const httpsConfig = await (0, utils_2.getHttpsConfig)();
+}
+function setupFileWatchers({ props, cliOptions, onFileChange, }) {
+    const { siteDir } = props;
+    const pathsToWatch = getPathsToWatch({ props });
+    const pollingOptions = createPollingOptions({ cliOptions });
     const fsWatcher = chokidar_1.default.watch(pathsToWatch, {
         cwd: siteDir,
         ignoreInitial: true,
         ...{ pollingOptions },
     });
-    ['add', 'change', 'unlink', 'addDir', 'unlinkDir'].forEach((event) => fsWatcher.on(event, reload));
-    let config = (0, webpack_merge_1.default)(await (0, client_1.default)(props, cliOptions.minify, false), {
-        watchOptions: {
-            ignored: /node_modules\/(?!@docusaurus)/,
-            poll: cliOptions.poll,
-        },
-        infrastructureLogging: {
-            // Reduce log verbosity, see https://github.com/facebook/docusaurus/pull/5420#issuecomment-906613105
-            level: 'warn',
-        },
-        plugins: [
-            // Generates an `index.html` file with the <script> injected.
-            new html_webpack_plugin_1.default({
-                template: path_1.default.join(__dirname, '../webpack/templates/index.html.template.ejs'),
-                // So we can define the position where the scripts are injected.
-                inject: false,
-                filename: 'index.html',
-                title: siteConfig.title,
-                headTags,
-                preBodyTags,
-                postBodyTags,
-            }),
-        ],
-    });
-    // Plugin Lifecycle - configureWebpack and configurePostCss.
-    plugins.forEach((plugin) => {
-        const { configureWebpack, configurePostCss } = plugin;
-        if (configurePostCss) {
-            config = (0, utils_2.applyConfigurePostCss)(configurePostCss.bind(plugin), config);
-        }
-        if (configureWebpack) {
-            config = (0, utils_2.applyConfigureWebpack)(configureWebpack.bind(plugin), // The plugin lifecycle may reference `this`.
-            config, false, props.siteConfig.webpack?.jsLoader, plugin.content);
-        }
-    });
-    const compiler = (0, webpack_1.default)(config);
-    compiler.hooks.done.tap('done', (stats) => {
-        const errorsWarnings = stats.toJson('errors-warnings');
-        const statsErrorMessage = (0, utils_2.formatStatsErrorMessage)(errorsWarnings);
-        if (statsErrorMessage) {
-            console.error(statsErrorMessage);
-        }
-        (0, utils_2.printStatsWarnings)(errorsWarnings);
-        if (process.env.E2E_TEST) {
-            if (stats.hasErrors()) {
-                logger_1.default.error('E2E_TEST: Project has compiler errors.');
-                process.exit(1);
-            }
-            logger_1.default.success('E2E_TEST: Project can compile.');
-            process.exit(0);
+    ['add', 'change', 'unlink', 'addDir', 'unlinkDir'].forEach((event) => fsWatcher.on(event, onFileChange));
+}
+function getPathsToWatch({ props }) {
+    const { siteDir, siteConfigPath, plugins, localizationDir } = props;
+    const normalizeToSiteDir = (filepath) => {
+        if (filepath && path_1.default.isAbsolute(filepath)) {
+            return (0, utils_1.posixPath)(path_1.default.relative(siteDir, filepath));
         }
-    });
+        return (0, utils_1.posixPath)(filepath);
+    };
+    const pluginsPaths = plugins
+        .flatMap((plugin) => plugin.getPathsToWatch?.() ?? [])
+        .filter(Boolean)
+        .map(normalizeToSiteDir);
+    return [...pluginsPaths, siteConfigPath, localizationDir];
+}
+async function createUrlUtils({ cliOptions }) {
+    const protocol = process.env.HTTPS === 'true' ? 'https' : 'http';
+    const { host, port } = await (0, getHostPort_1.getHostPort)(cliOptions);
+    if (port === null) {
+        return process.exit();
+    }
+    const getOpenUrl = ({ baseUrl }) => {
+        const urls = (0, WebpackDevServerUtils_1.prepareUrls)(protocol, host, port);
+        return (0, utils_1.normalizeUrl)([urls.localUrlForBrowser, baseUrl]);
+    };
+    return { host, port, getOpenUrl };
+}
+async function createDevServerConfig({ cliOptions, props, host, port, }) {
+    const { baseUrl, siteDir, siteConfig } = props;
+    const pollingOptions = createPollingOptions({ cliOptions });
+    const httpsConfig = await (0, utils_2.getHttpsConfig)();
     // https://webpack.js.org/configuration/dev-server
-    const defaultDevServerConfig = {
+    return {
         hot: cliOptions.hotOnly ? 'only' : true,
         liveReload: false,
         client: {
@@ -194,19 +203,40 @@ async function start(siteDirParam = '.', cliOptions = {}) {
             return middlewares;
         },
     };
-    // Allow plugin authors to customize/override devServer config
-    const devServerConfig = (0, webpack_merge_1.default)([defaultDevServerConfig, config.devServer].filter(Boolean));
-    const devServer = new webpack_dev_server_1.default(devServerConfig, compiler);
-    devServer.startCallback(() => {
-        if (cliOptions.open) {
-            (0, openBrowser_1.default)(openUrl);
+}
+// E2E_TEST=true docusaurus start
+// Makes "docusaurus start" exit immediately on success/error, for E2E test
+function registerE2ETestHook(compiler) {
+    compiler.hooks.done.tap('done', (stats) => {
+        const errorsWarnings = stats.toJson('errors-warnings');
+        const statsErrorMessage = (0, utils_2.formatStatsErrorMessage)(errorsWarnings);
+        if (statsErrorMessage) {
+            console.error(statsErrorMessage);
+        }
+        (0, utils_2.printStatsWarnings)(errorsWarnings);
+        if (process.env.E2E_TEST) {
+            if (stats.hasErrors()) {
+                logger_1.default.error('E2E_TEST: Project has compiler errors.');
+                process.exit(1);
+            }
+            logger_1.default.success('E2E_TEST: Project can compile.');
+            process.exit(0);
         }
     });
-    ['SIGINT', 'SIGTERM'].forEach((sig) => {
-        process.on(sig, () => {
-            devServer.stop();
-            process.exit();
-        });
+}
+async function getStartClientConfig({ props, minify, poll, }) {
+    const { plugins, siteConfig } = props;
+    let { clientConfig: config } = await (0, client_1.createStartClientConfig)({
+        props,
+        minify,
+        poll,
+    });
+    config = (0, utils_2.executePluginsConfigurePostCss)({ plugins, config });
+    config = (0, utils_2.executePluginsConfigureWebpack)({
+        plugins,
+        config,
+        isServer: false,
+        jsLoader: siteConfig.webpack?.jsLoader,
     });
+    return config;
 }
-exports.start = start;

package/lib/ssg.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 { AppRenderer, SiteCollectedData } from './common';
+import type { Manifest } from 'react-loadable-ssr-addon-v5-slorber';
+import type { SSRTemplateCompiled } from './templates/templates';
+export type SSGParams = {
+    trailingSlash: boolean | undefined;
+    manifest: Manifest;
+    headTags: string;
+    preBodyTags: string;
+    postBodyTags: string;
+    outDir: string;
+    baseUrl: string;
+    noIndex: boolean;
+    DOCUSAURUS_VERSION: string;
+    ssrTemplate: SSRTemplateCompiled;
+};
+export declare function loadAppRenderer({ serverBundlePath, }: {
+    serverBundlePath: string;
+}): Promise<AppRenderer>;
+export declare function generateStaticFiles({ pathnames, renderer, params, }: {
+    pathnames: string[];
+    renderer: AppRenderer;
+    params: SSGParams;
+}): Promise<{
+    collectedData: SiteCollectedData;
+}>;

package/lib/ssg.js

@@ -0,0 +1,172 @@
+"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.generateStaticFiles = exports.loadAppRenderer = void 0;
+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"));
+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;
+async function loadAppRenderer({ serverBundlePath, }) {
+    console.log(`SSG - Load server bundle`);
+    utils_1.PerfLogger.start(`SSG - Load server bundle`);
+    const source = await fs_extra_1.default.readFile(serverBundlePath);
+    utils_1.PerfLogger.end(`SSG - Load server bundle`);
+    utils_1.PerfLogger.log(`SSG - Server bundle size = ${(source.length / 1024000).toFixed(3)} MB`);
+    const filename = path_1.default.basename(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
+        // has any importance for this plugin, just using an empty string to
+        // avoid the error. See https://github.com/facebook/docusaurus/issues/4922
+        __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),
+    };
+    utils_1.PerfLogger.start(`SSG - Evaluate server bundle`);
+    const serverEntry = (0, eval_1.default)(source, 
+    /* filename: */ filename, 
+    /* scope: */ globals, 
+    /* includeGlobals: */ true);
+    utils_1.PerfLogger.end(`SSG - Evaluate server bundle`);
+    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;
+}
+exports.loadAppRenderer = loadAppRenderer;
+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;
+    }
+    // Legacy retro-compatible behavior
+    if (typeof trailingSlash === 'undefined') {
+        return path_1.default.join(outputFileName, 'index.html');
+    }
+    // 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');
+    }
+    return `${outputFileName}.html`;
+}
+async function generateStaticFiles({ pathnames, renderer, params, }) {
+    // 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);
+    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 };
+}
+exports.generateStaticFiles = generateStaticFiles;
+async function generateStaticFile({ pathname, renderer, params, }) {
+    try {
+        // This only renders the app HTML
+        const result = await renderer({
+            pathname,
+        });
+        // This renders the full page HTML, including head tags...
+        const fullPageHtml = (0, templates_1.renderSSRTemplate)({
+            params,
+            result,
+        });
+        const content = await minifyHtml(fullPageHtml);
+        await writeStaticFile({
+            pathname,
+            content,
+            params,
+        });
+        return result;
+    }
+    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,
+        });
+    }
+}
+function getSSGErrorTips(error) {
+    const parts = [];
+    const isNotDefinedErrorRegex = /(?:window|document|localStorage|navigator|alert|location|buffer|self) is not defined/i;
+    if (isNotDefinedErrorRegex.test(error.message)) {
+        parts.push(`It looks like you are using code that should run on the client-side only.
+To get around it, try using one of:
+- ${logger_1.default.code('<BrowserOnly>')} (${logger_1.default.url('https://docusaurus.io/docs/docusaurus-core/#browseronly')})
+- ${logger_1.default.code('ExecutionEnvironment')} (${logger_1.default.url('https://docusaurus.io/docs/docusaurus-core/#executionenvironment')}).
+It might also require to wrap your client code in ${logger_1.default.code('useEffect')} hook and/or import a third-party library dynamically (if any).`);
+    }
+    return parts.join('\n');
+}
+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/templates/templates.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 { SSGParams } from '../ssg';
+import type { AppRenderResult } from '../common';
+export type SSRTemplateData = {
+    appHtml: string;
+    baseUrl: string;
+    htmlAttributes: string;
+    bodyAttributes: string;
+    headTags: string;
+    preBodyTags: string;
+    postBodyTags: string;
+    metaAttributes: string[];
+    scripts: string[];
+    stylesheets: string[];
+    noIndex: boolean;
+    version: string;
+};
+export type SSRTemplateCompiled = (data: SSRTemplateData) => string;
+export declare function compileSSRTemplate(template: string): Promise<SSRTemplateCompiled>;
+export declare function renderSSRTemplate({ params, result, }: {
+    params: SSGParams;
+    result: AppRenderResult;
+}): string;

package/lib/templates/templates.js

@@ -0,0 +1,63 @@
+"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.renderSSRTemplate = exports.compileSSRTemplate = void 0;
+const tslib_1 = require("tslib");
+const eta = tslib_1.__importStar(require("eta"));
+const react_loadable_ssr_addon_v5_slorber_1 = require("react-loadable-ssr-addon-v5-slorber");
+async function compileSSRTemplate(template) {
+    const compiledTemplate = eta.compile(template.trim(), {
+        rmWhitespace: true,
+    });
+    return (data) => compiledTemplate(data, eta.defaultConfig);
+}
+exports.compileSSRTemplate = compileSSRTemplate;
+/**
+ * Given a list of modules that were SSR an d
+ * @param modules
+ * @param manifest
+ */
+function getScriptsAndStylesheets({ modules, manifest, }) {
+    // Get all required assets for this particular page
+    // based on client manifest information.
+    const modulesToBeLoaded = [...manifest.entrypoints, ...Array.from(modules)];
+    const bundles = (0, react_loadable_ssr_addon_v5_slorber_1.getBundles)(manifest, modulesToBeLoaded);
+    const stylesheets = (bundles.css ?? []).map((b) => b.file);
+    const scripts = (bundles.js ?? []).map((b) => b.file);
+    return { scripts, stylesheets };
+}
+function renderSSRTemplate({ params, result, }) {
+    const { baseUrl, headTags, preBodyTags, postBodyTags, manifest, noIndex, DOCUSAURUS_VERSION, ssrTemplate, } = params;
+    const { html: appHtml, collectedData: { modules, helmet }, } = result;
+    const { scripts, stylesheets } = getScriptsAndStylesheets({ manifest, modules });
+    const htmlAttributes = helmet.htmlAttributes.toString();
+    const bodyAttributes = helmet.bodyAttributes.toString();
+    const metaStrings = [
+        helmet.title.toString(),
+        helmet.meta.toString(),
+        helmet.link.toString(),
+        helmet.script.toString(),
+    ];
+    const metaAttributes = metaStrings.filter(Boolean);
+    const data = {
+        appHtml,
+        baseUrl,
+        htmlAttributes,
+        bodyAttributes,
+        headTags,
+        preBodyTags,
+        postBodyTags,
+        metaAttributes,
+        scripts,
+        stylesheets,
+        noIndex,
+        version: DOCUSAURUS_VERSION,
+    };
+    return ssrTemplate(data);
+}
+exports.renderSSRTemplate = renderSSRTemplate;

package/lib/utils.d.ts

@@ -0,0 +1,8 @@
+export declare const PerfDebuggingEnabled: boolean;
+type PerfLoggerAPI = {
+    start: (label: string) => void;
+    end: (label: string) => void;
+    log: (message: string) => void;
+};
+export declare const PerfLogger: PerfLoggerAPI;
+export {};

package/lib/utils.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerfLogger = exports.PerfDebuggingEnabled = void 0;
+const tslib_1 = require("tslib");
+/**
+ * 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.
+ */
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
+// For now this is a private env variable we use internally
+// But we'll want to expose this feature officially some day
+exports.PerfDebuggingEnabled = !!process.env.DOCUSAURUS_PERF_LOGGER;
+function createPerfLogger() {
+    if (!exports.PerfDebuggingEnabled) {
+        const noop = () => { };
+        return {
+            start: noop,
+            end: noop,
+            log: noop,
+        };
+    }
+    const prefix = logger_1.default.yellow(`[PERF] `);
+    return {
+        start: (label) => console.time(prefix + label),
+        end: (label) => console.timeEnd(prefix + label),
+        log: (label) => console.log(prefix + label),
+    };
+}
+exports.PerfLogger = createPerfLogger();

package/lib/webpack/base.d.ts

@@ -8,4 +8,8 @@ import type { Configuration } from 'webpack';
 import type { Props } from '@docusaurus/types';
 export declare const clientDir: string;
 export declare function excludeJS(modulePath: string): boolean;
-export declare function createBaseConfig(props: Props, isServer: boolean, minify?: boolean): Promise<Configuration>;
+export declare function createBaseConfig({ props, isServer, minify, }: {
+    props: Props;
+    isServer: boolean;
+    minify: boolean;
+}): Promise<Configuration>;

package/lib/webpack/base.js

@@ -13,6 +13,7 @@ const path_1 = tslib_1.__importDefault(require("path"));
 const mini_css_extract_plugin_1 = tslib_1.__importDefault(require("mini-css-extract-plugin"));
 const utils_1 = require("@docusaurus/utils");
 const utils_2 = require("./utils");
+const minification_1 = require("./minification");
 const aliases_1 = require("./aliases");
 const CSS_REGEX = /\.css$/i;
 const CSS_MODULE_REGEX = /\.module\.css$/i;
@@ -32,12 +33,11 @@ function excludeJS(modulePath) {
         !LibrariesToTranspileRegex.test(modulePath));
 }
 exports.excludeJS = excludeJS;
-async function createBaseConfig(props, isServer, minify = true) {
+async function createBaseConfig({ props, isServer, minify, }) {
     const { outDir, siteDir, siteConfig, siteConfigPath, baseUrl, generatedFilesDir, routesPaths, siteMetadata, plugins, } = props;
     const totalPages = routesPaths.length;
     const isProd = process.env.NODE_ENV === 'production';
-    const minimizeEnabled = minify && isProd && !isServer;
-    const useSimpleCssMinifier = process.env.USE_SIMPLE_CSS_MINIFIER === 'true';
+    const minimizeEnabled = minify && isProd;
     const fileLoaderUtils = (0, utils_1.getFileLoaderUtils)();
     const name = isServer ? 'server' : 'client';
     const mode = isProd ? 'production' : 'development';
@@ -124,9 +124,7 @@ async function createBaseConfig(props, isServer, minify = true) {
             // Only minimize client bundle in production because server bundle is only
             // used for static site generation
             minimize: minimizeEnabled,
-            minimizer: minimizeEnabled
-                ? (0, utils_2.getMinimizer)(useSimpleCssMinifier)
-                : undefined,
+            minimizer: minimizeEnabled ? (0, minification_1.getMinimizer)() : undefined,
             splitChunks: isServer
                 ? false
                 : {