@docusaurus/core 3.1.0 → 3.2.0

package/lib/commands/deploy.js

@@ -14,7 +14,7 @@ const os_1 = tslib_1.__importDefault(require("os"));
 const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
 const shelljs_1 = tslib_1.__importDefault(require("shelljs"));
 const utils_1 = require("@docusaurus/utils");
-const server_1 = require("../server");
+const site_1 = require("../server/site");
 const build_1 = require("./build");
 // GIT_PASS env variable should not appear in logs
 function obfuscateGitPass(str) {
@@ -36,7 +36,7 @@ function shellExecLog(cmd) {
 }
 async function deploy(siteDirParam = '.', cliOptions = {}) {
     const siteDir = await fs_extra_1.default.realpath(siteDirParam);
-    const { outDir, siteConfig, siteConfigPath } = await (0, server_1.loadContext)({
+    const { outDir, siteConfig, siteConfigPath } = await (0, site_1.loadContext)({
         siteDir,
         config: cliOptions.config,
         outDir: cliOptions.outDir,
@@ -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/external.js

@@ -9,11 +9,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.externalCommand = void 0;
 const tslib_1 = require("tslib");
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
-const server_1 = require("../server");
+const site_1 = require("../server/site");
 const init_1 = require("../server/plugins/init");
 async function externalCommand(cli) {
     const siteDir = await fs_extra_1.default.realpath('.');
-    const context = await (0, server_1.loadContext)({ siteDir });
+    const context = await (0, site_1.loadContext)({ siteDir });
     const plugins = await (0, init_1.initPlugins)(context);
     // Plugin Lifecycle - extendCli.
     plugins.forEach((plugin) => {

package/lib/commands/serve.d.ts

@@ -5,8 +5,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 import { type HostPortOptions } from '../server/getHostPort';
-import type { LoadContextOptions } from '../server';
-export type ServeCLIOptions = HostPortOptions & Pick<LoadContextOptions, 'config'> & {
+import type { LoadContextParams } from '../server/site';
+export type ServeCLIOptions = HostPortOptions & Pick<LoadContextParams, 'config'> & {
     dir?: string;
     build?: boolean;
     open?: boolean;

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,
         });

package/lib/commands/{start.d.ts → start/start.d.ts}

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { type LoadContextOptions } from '../server';
-import { type HostPortOptions } from '../server/getHostPort';
-export type StartCLIOptions = HostPortOptions & Pick<LoadContextOptions, 'locale' | 'config'> & {
+import type { LoadContextParams } from '../../server/site';
+import type { HostPortOptions } from '../../server/getHostPort';
+export type StartCLIOptions = HostPortOptions & Pick<LoadContextParams, 'locale' | 'config'> & {
     hotOnly?: boolean;
     open?: boolean;
     poll?: boolean | number;

package/lib/commands/start/start.js

@@ -0,0 +1,47 @@
+"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.start = void 0;
+const tslib_1 = require("tslib");
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
+const openBrowser_1 = tslib_1.__importDefault(require("react-dev-utils/openBrowser"));
+const watcher_1 = require("./watcher");
+const webpack_1 = require("./webpack");
+const utils_1 = require("./utils");
+async function start(siteDirParam = '.', cliOptions = {}) {
+    logger_1.default.info('Starting the development server...');
+    // 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 = cliOptions.locale;
+    const reloadableSite = await (0, utils_1.createReloadableSite)({ siteDirParam, cliOptions });
+    (0, watcher_1.setupSiteFileWatchers)({ props: reloadableSite.get().props, cliOptions }, ({ plugin }) => {
+        if (plugin) {
+            reloadableSite.reloadPlugin(plugin);
+        }
+        else {
+            reloadableSite.reload();
+        }
+    });
+    const devServer = await (0, webpack_1.createWebpackDevServer)({
+        props: reloadableSite.get().props,
+        cliOptions,
+        openUrlContext: reloadableSite.openUrlContext,
+    });
+    ['SIGINT', 'SIGTERM'].forEach((sig) => {
+        process.on(sig, () => {
+            devServer.stop();
+            process.exit();
+        });
+    });
+    await devServer.start();
+    if (cliOptions.open) {
+        (0, openBrowser_1.default)(reloadableSite.getOpenUrl());
+    }
+}
+exports.start = start;

package/lib/commands/start/utils.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 _ from 'lodash';
+import type { StartCLIOptions } from './start';
+import type { LoadedPlugin } from '@docusaurus/types';
+export type OpenUrlContext = {
+    host: string;
+    port: number;
+    getOpenUrl: ({ baseUrl }: {
+        baseUrl: string;
+    }) => string;
+};
+export declare function createOpenUrlContext({ cliOptions, }: {
+    cliOptions: StartCLIOptions;
+}): Promise<OpenUrlContext>;
+type StartParams = {
+    siteDirParam: string;
+    cliOptions: Partial<StartCLIOptions>;
+};
+export declare function createReloadableSite(startParams: StartParams): Promise<{
+    get: () => import("../../server/site").Site;
+    getOpenUrl: () => string;
+    reload: _.DebouncedFunc<() => Promise<void>>;
+    reloadPlugin: (plugin: LoadedPlugin) => Promise<void>;
+    openUrlContext: OpenUrlContext;
+}>;
+export {};

package/lib/commands/start/utils.js

@@ -0,0 +1,87 @@
+"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.createReloadableSite = exports.createOpenUrlContext = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const WebpackDevServerUtils_1 = require("react-dev-utils/WebpackDevServerUtils");
+const utils_1 = require("@docusaurus/utils");
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
+const getHostPort_1 = require("../../server/getHostPort");
+const utils_2 = require("../../utils");
+const site_1 = require("../../server/site");
+const pluginsUtils_1 = require("../../server/plugins/pluginsUtils");
+async function createOpenUrlContext({ 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 };
+}
+exports.createOpenUrlContext = createOpenUrlContext;
+async function createLoadSiteParams({ siteDirParam, cliOptions, }) {
+    const siteDir = await fs_extra_1.default.realpath(siteDirParam);
+    return {
+        siteDir,
+        config: cliOptions.config,
+        locale: cliOptions.locale,
+        localizePath: undefined, // Should this be configurable?
+    };
+}
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+async function createReloadableSite(startParams) {
+    const openUrlContext = await createOpenUrlContext(startParams);
+    const loadSiteParams = await utils_2.PerfLogger.async('createLoadSiteParams', () => createLoadSiteParams(startParams));
+    let site = await utils_2.PerfLogger.async('Load site', () => (0, site_1.loadSite)(loadSiteParams));
+    const get = () => site;
+    const getOpenUrl = () => openUrlContext.getOpenUrl({
+        baseUrl: site.props.baseUrl,
+    });
+    const printOpenUrlMessage = () => {
+        logger_1.default.success `Docusaurus website is running at: url=${getOpenUrl()}`;
+    };
+    printOpenUrlMessage();
+    const reloadBase = async () => {
+        try {
+            const oldSite = site;
+            site = await utils_2.PerfLogger.async('Reload site', () => (0, site_1.reloadSite)(site));
+            if (oldSite.props.baseUrl !== site.props.baseUrl) {
+                printOpenUrlMessage();
+            }
+        }
+        catch (e) {
+            logger_1.default.error('Site reload failure');
+            console.error(e);
+        }
+    };
+    // TODO instead of debouncing we should rather add AbortController support?
+    const reload = lodash_1.default.debounce(reloadBase, 500);
+    // TODO this could be subject to plugin reloads race conditions
+    //  In practice, it is not likely the user will hot reload 2 plugins at once
+    //  but we should still support it and probably use a task queuing system
+    const reloadPlugin = async (plugin) => {
+        try {
+            site = await utils_2.PerfLogger.async(`Reload site plugin ${(0, pluginsUtils_1.formatPluginName)(plugin)}`, () => {
+                const pluginIdentifier = { name: plugin.name, id: plugin.options.id };
+                return (0, site_1.reloadSitePlugin)(site, pluginIdentifier);
+            });
+        }
+        catch (e) {
+            logger_1.default.error(`Site plugin reload failure - Plugin ${(0, pluginsUtils_1.formatPluginName)(plugin)}`);
+            console.error(e);
+        }
+    };
+    return { get, getOpenUrl, reload, reloadPlugin, openUrlContext };
+}
+exports.createReloadableSite = createReloadableSite;

package/lib/commands/start/watcher.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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 { StartCLIOptions } from './start';
+import type { LoadedPlugin, Props } from '@docusaurus/types';
+type PollingOptions = {
+    usePolling: boolean;
+    interval: number | undefined;
+};
+export declare function createPollingOptions(cliOptions: StartCLIOptions): PollingOptions;
+export type FileWatchEventName = 'add' | 'addDir' | 'change' | 'unlink' | 'unlinkDir';
+export type FileWatchEvent = {
+    name: FileWatchEventName;
+    path: string;
+};
+type WatchParams = {
+    pathsToWatch: string[];
+    siteDir: string;
+} & PollingOptions;
+/**
+ * Watch file system paths for changes and emit events
+ * Returns an async handle to stop watching
+ */
+export declare function watch(params: WatchParams, callback: (event: FileWatchEvent) => void): () => Promise<void>;
+export declare function getSitePathsToWatch({ props }: {
+    props: Props;
+}): string[];
+export declare function getPluginPathsToWatch({ siteDir, plugin, }: {
+    siteDir: string;
+    plugin: LoadedPlugin;
+}): string[];
+export declare function setupSiteFileWatchers({ props, cliOptions, }: {
+    props: Props;
+    cliOptions: StartCLIOptions;
+}, callback: (params: {
+    plugin: LoadedPlugin | null;
+    event: FileWatchEvent;
+}) => void): void;
+export {};

package/lib/commands/start/watcher.js

@@ -0,0 +1,78 @@
+"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.setupSiteFileWatchers = exports.getPluginPathsToWatch = exports.getSitePathsToWatch = exports.watch = exports.createPollingOptions = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const chokidar_1 = tslib_1.__importDefault(require("chokidar"));
+const utils_1 = require("@docusaurus/utils");
+function createPollingOptions(cliOptions) {
+    return {
+        usePolling: !!cliOptions.poll,
+        interval: Number.isInteger(cliOptions.poll)
+            ? cliOptions.poll
+            : undefined,
+    };
+}
+exports.createPollingOptions = createPollingOptions;
+/**
+ * Watch file system paths for changes and emit events
+ * Returns an async handle to stop watching
+ */
+function watch(params, callback) {
+    const { pathsToWatch, siteDir, ...options } = params;
+    const fsWatcher = chokidar_1.default.watch(pathsToWatch, {
+        cwd: siteDir,
+        ignoreInitial: true,
+        ...options,
+    });
+    fsWatcher.on('all', (name, eventPath) => callback({ name, path: eventPath }));
+    return () => fsWatcher.close();
+}
+exports.watch = watch;
+function getSitePathsToWatch({ props }) {
+    return [
+        // TODO we should also watch all imported modules!
+        //  Use https://github.com/vercel/nft ?
+        props.siteConfigPath,
+        props.localizationDir,
+    ];
+}
+exports.getSitePathsToWatch = getSitePathsToWatch;
+function getPluginPathsToWatch({ siteDir, plugin, }) {
+    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);
+    };
+    return (plugin.getPathsToWatch?.() ?? [])
+        .filter(Boolean)
+        .map(normalizeToSiteDir);
+}
+exports.getPluginPathsToWatch = getPluginPathsToWatch;
+function setupSiteFileWatchers({ props, cliOptions, }, callback) {
+    const { siteDir } = props;
+    const pollingOptions = createPollingOptions(cliOptions);
+    // TODO on config / or local plugin updates,
+    //  the getFilePathsToWatch lifecycle code might get updated
+    //  so we should probably reset the watchers?
+    watch({
+        pathsToWatch: getSitePathsToWatch({ props }),
+        siteDir: props.siteDir,
+        ...pollingOptions,
+    }, (event) => callback({ plugin: null, event }));
+    props.plugins.forEach((plugin) => {
+        watch({
+            pathsToWatch: getPluginPathsToWatch({ plugin, siteDir }),
+            siteDir,
+            ...pollingOptions,
+        }, (event) => callback({ plugin, event }));
+    });
+}
+exports.setupSiteFileWatchers = setupSiteFileWatchers;

package/lib/commands/start/webpack.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 WebpackDevServer from 'webpack-dev-server';
+import type { StartCLIOptions } from './start';
+import type { Props } from '@docusaurus/types';
+import type { OpenUrlContext } from './utils';
+export declare function createWebpackDevServer({ props, cliOptions, openUrlContext, }: {
+    props: Props;
+    cliOptions: StartCLIOptions;
+    openUrlContext: OpenUrlContext;
+}): Promise<WebpackDevServer>;

package/lib/commands/start/webpack.js

@@ -0,0 +1,133 @@
+"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.createWebpackDevServer = void 0;
+const tslib_1 = require("tslib");
+const path_1 = tslib_1.__importDefault(require("path"));
+const webpack_merge_1 = tslib_1.__importDefault(require("webpack-merge"));
+const webpack_1 = tslib_1.__importDefault(require("webpack"));
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
+const webpack_dev_server_1 = tslib_1.__importDefault(require("webpack-dev-server"));
+const evalSourceMapMiddleware_1 = tslib_1.__importDefault(require("react-dev-utils/evalSourceMapMiddleware"));
+const watcher_1 = require("./watcher");
+const utils_1 = require("../../webpack/utils");
+const client_1 = require("../../webpack/client");
+// E2E_TEST=true docusaurus start
+// Makes "docusaurus start" exit immediately on success/error, for E2E test
+function registerWebpackE2ETestHook(compiler) {
+    compiler.hooks.done.tap('done', (stats) => {
+        const errorsWarnings = stats.toJson('errors-warnings');
+        const statsErrorMessage = (0, utils_1.formatStatsErrorMessage)(errorsWarnings);
+        if (statsErrorMessage) {
+            console.error(statsErrorMessage);
+        }
+        (0, utils_1.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);
+        }
+    });
+}
+async function createDevServerConfig({ cliOptions, props, host, port, }) {
+    const { baseUrl, siteDir, siteConfig } = props;
+    const pollingOptions = (0, watcher_1.createPollingOptions)(cliOptions);
+    const httpsConfig = await (0, utils_1.getHttpsConfig)();
+    // https://webpack.js.org/configuration/dev-server
+    return {
+        hot: cliOptions.hotOnly ? 'only' : true,
+        liveReload: false,
+        client: {
+            progress: true,
+            overlay: {
+                warnings: false,
+                errors: true,
+            },
+            webSocketURL: {
+                hostname: '0.0.0.0',
+                port: 0,
+            },
+        },
+        headers: {
+            'access-control-allow-origin': '*',
+        },
+        devMiddleware: {
+            publicPath: baseUrl,
+            // Reduce log verbosity, see https://github.com/facebook/docusaurus/pull/5420#issuecomment-906613105
+            stats: 'summary',
+        },
+        static: siteConfig.staticDirectories.map((dir) => ({
+            publicPath: baseUrl,
+            directory: path_1.default.resolve(siteDir, dir),
+            watch: {
+                // Useful options for our own monorepo using symlinks!
+                // See https://github.com/webpack/webpack/issues/11612#issuecomment-879259806
+                followSymlinks: true,
+                ignored: /node_modules\/(?!@docusaurus)/,
+                ...{ pollingOptions },
+            },
+        })),
+        ...(httpsConfig && {
+            server: typeof httpsConfig === 'object'
+                ? {
+                    type: 'https',
+                    options: httpsConfig,
+                }
+                : 'https',
+        }),
+        historyApiFallback: {
+            rewrites: [{ from: /\/*/, to: baseUrl }],
+        },
+        allowedHosts: 'all',
+        host,
+        port,
+        setupMiddlewares: (middlewares, devServer) => {
+            // This lets us fetch source contents from webpack for the error overlay.
+            middlewares.unshift((0, evalSourceMapMiddleware_1.default)(devServer));
+            return middlewares;
+        },
+    };
+}
+async function getStartClientConfig({ props, minify, poll, }) {
+    const { plugins, siteConfig } = props;
+    let { clientConfig: config } = await (0, client_1.createStartClientConfig)({
+        props,
+        minify,
+        poll,
+    });
+    config = (0, utils_1.executePluginsConfigurePostCss)({ plugins, config });
+    config = (0, utils_1.executePluginsConfigureWebpack)({
+        plugins,
+        config,
+        isServer: false,
+        jsLoader: siteConfig.webpack?.jsLoader,
+    });
+    return config;
+}
+async function createWebpackDevServer({ props, cliOptions, openUrlContext, }) {
+    const config = await getStartClientConfig({
+        props,
+        minify: cliOptions.minify ?? true,
+        poll: cliOptions.poll,
+    });
+    const compiler = (0, webpack_1.default)(config);
+    registerWebpackE2ETestHook(compiler);
+    const defaultDevServerConfig = await createDevServerConfig({
+        cliOptions,
+        props,
+        host: openUrlContext.host,
+        port: openUrlContext.port,
+    });
+    // Allow plugin authors to customize/override devServer config
+    const devServerConfig = (0, webpack_merge_1.default)([defaultDevServerConfig, config.devServer].filter(Boolean));
+    return new webpack_dev_server_1.default(devServerConfig, compiler);
+}
+exports.createWebpackDevServer = createWebpackDevServer;

package/lib/commands/swizzle/common.d.ts

@@ -23,6 +23,7 @@ export type SwizzleContext = {
 };
 export type SwizzleCLIOptions = {
     typescript: boolean;
+    javascript: boolean;
     danger: boolean;
     list: boolean;
     wrap: boolean;

package/lib/commands/swizzle/common.js

@@ -39,6 +39,7 @@ exports.actionStatusSuffix = actionStatusSuffix;
 function normalizeOptions(options) {
     return {
         typescript: options.typescript ?? false,
+        javascript: options.javascript ?? false,
         danger: options.danger ?? false,
         list: options.list ?? false,
         wrap: options.wrap ?? false,

package/lib/commands/swizzle/context.js

@@ -7,11 +7,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initSwizzleContext = void 0;
-const server_1 = require("../../server");
+const site_1 = require("../../server/site");
 const init_1 = require("../../server/plugins/init");
 const configs_1 = require("../../server/plugins/configs");
 async function initSwizzleContext(siteDir, options) {
-    const context = await (0, server_1.loadContext)({ siteDir, config: options.config });
+    const context = await (0, site_1.loadContext)({ siteDir, config: options.config });
     const plugins = await (0, init_1.initPlugins)(context);
     const pluginConfigs = await (0, configs_1.loadPluginConfigs)(context);
     return {

package/lib/commands/swizzle/index.js

@@ -10,6 +10,7 @@ exports.swizzle = void 0;
 const tslib_1 = require("tslib");
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
+const utils_1 = require("@docusaurus/utils");
 const themes_1 = require("./themes");
 const components_1 = require("./components");
 const tables_1 = require("./tables");
@@ -18,6 +19,24 @@ const actions_1 = require("./actions");
 const config_1 = require("./config");
 const prompts_1 = require("./prompts");
 const context_1 = require("./context");
+async function getLanguageForThemeName({ themeName, plugins, options, }) {
+    const plugin = (0, themes_1.getPluginByThemeName)(plugins, themeName);
+    const supportsTS = !!plugin.instance.getTypeScriptThemePath?.();
+    if (options.typescript) {
+        if (!supportsTS) {
+            throw new Error(logger_1.default.interpolate `Theme name=${plugin.instance.name} does not support the code=${'--typescript'} CLI option.`);
+        }
+        return 'typescript';
+    }
+    if (options.javascript) {
+        return 'javascript';
+    }
+    // It's only useful to prompt the user for themes that support both JS/TS
+    if (supportsTS) {
+        return (0, utils_1.askPreferredLanguage)({ exit: true });
+    }
+    return 'javascript';
+}
 async function listAllThemeComponents({ themeNames, plugins, typescript, }) {
     const themeComponentsTables = (await Promise.all(themeNames.map(async (themeName) => {
         const themePath = (0, themes_1.getThemePath)({ themeName, plugins, typescript });
@@ -61,14 +80,24 @@ If you want to swizzle it, use the code=${'--danger'} flag, or confirm that you
 async function swizzle(themeNameParam = undefined, componentNameParam = undefined, siteDirParam = '.', optionsParam = {}) {
     const siteDir = await fs_extra_1.default.realpath(siteDirParam);
     const options = (0, common_1.normalizeOptions)(optionsParam);
-    const { list, danger, typescript } = options;
+    const { list, danger } = options;
     const { plugins } = await (0, context_1.initSwizzleContext)(siteDir, options);
     const themeNames = (0, themes_1.getThemeNames)(plugins);
     if (list && !themeNameParam) {
-        await listAllThemeComponents({ themeNames, plugins, typescript });
+        await listAllThemeComponents({
+            themeNames,
+            plugins,
+            typescript: options.typescript,
+        });
     }
     const themeName = await (0, themes_1.getThemeName)({ themeNameParam, themeNames, list });
-    const themePath = (0, themes_1.getThemePath)({ themeName, plugins, typescript });
+    const language = await getLanguageForThemeName({ themeName, plugins, options });
+    const typescript = language === 'typescript';
+    const themePath = (0, themes_1.getThemePath)({
+        themeName,
+        plugins,
+        typescript,
+    });
     const swizzleConfig = (0, config_1.getThemeSwizzleConfig)(themeName, plugins);
     const themeComponents = await (0, components_1.getThemeComponents)({
         themeName,

package/lib/commands/writeHeadingIds.js

@@ -11,7 +11,7 @@ const tslib_1 = require("tslib");
 const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
 const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
 const utils_1 = require("@docusaurus/utils");
-const server_1 = require("../server");
+const site_1 = require("../server/site");
 const init_1 = require("../server/plugins/init");
 const utils_2 = require("../server/utils");
 async function transformMarkdownFile(filepath, options) {
@@ -30,7 +30,7 @@ async function transformMarkdownFile(filepath, options) {
  * transformed
  */
 async function getPathsToWatch(siteDir) {
-    const context = await (0, server_1.loadContext)({ siteDir });
+    const context = await (0, site_1.loadContext)({ siteDir });
     const plugins = await (0, init_1.initPlugins)(context);
     return plugins.flatMap((plugin) => plugin.getPathsToWatch?.() ?? []);
 }

package/lib/commands/writeTranslations.d.ts

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