@docusaurus/core 2.0.0-beta.fc64c12e4 → 2.0.0

package/lib/commands/swizzle/components.js

@@ -0,0 +1,200 @@
+"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.getComponentName = exports.getThemeComponents = exports.listComponentNames = exports.readComponentNames = void 0;
+const tslib_1 = require("tslib");
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
+const utils_1 = require("@docusaurus/utils");
+const prompts_1 = require("./prompts");
+const common_1 = require("./common");
+const tables_1 = require("./tables");
+const actions_1 = require("./actions");
+const formatComponentName = (componentName) => componentName.replace(/[/\\]index\.[jt]sx?/, '').replace(/\.[jt]sx?/, '');
+function sortComponentNames(componentNames) {
+    return componentNames.sort(); // Algo may change?
+}
+/**
+ * Expand a list of components to include and return parent folders.
+ * If a folder is not directly a component (no Folder/index.tsx file),
+ * we still want to be able to swizzle --eject that folder.
+ * See https://github.com/facebook/docusaurus/pull/7175#issuecomment-1103757218
+ *
+ * @param componentNames the original list of component names
+ */
+function getMissingIntermediateComponentFolderNames(componentNames) {
+    function getAllIntermediatePaths(componentName) {
+        const paths = componentName.split('/');
+        return lodash_1.default.range(1, paths.length + 1).map((i) => paths.slice(0, i).join('/'));
+    }
+    const expandedComponentNames = lodash_1.default.uniq(componentNames.flatMap((componentName) => getAllIntermediatePaths(componentName)));
+    return lodash_1.default.difference(expandedComponentNames, componentNames);
+}
+const skipReadDirNames = ['__test__', '__tests__', '__mocks__', '__fixtures__'];
+async function readComponentNames(themePath) {
+    if (!(await fs_extra_1.default.pathExists(themePath))) {
+        return [];
+    }
+    async function walk(dir) {
+        const files = await Promise.all((await fs_extra_1.default.readdir(dir)).flatMap(async (file) => {
+            const fullPath = path_1.default.join(dir, file);
+            const stat = await fs_extra_1.default.stat(fullPath);
+            const isDir = stat.isDirectory();
+            return { file, fullPath, isDir };
+        }));
+        return (await Promise.all(files.map(async (file) => {
+            if (file.isDir) {
+                if (skipReadDirNames.includes(file.file)) {
+                    return [];
+                }
+                return walk(file.fullPath);
+            }
+            else if (
+            // TODO can probably be refactored
+            /(?<!\.d)\.[jt]sx?$/.test(file.fullPath) &&
+                !/(?<!\.d)\.(?:test|tests|story|stories)\.[jt]sx?$/.test(file.fullPath)) {
+                const componentName = formatComponentName((0, utils_1.posixPath)(path_1.default.relative(themePath, file.fullPath)));
+                return [{ ...file, componentName }];
+            }
+            return [];
+        }))).flat();
+    }
+    const componentFiles = await walk(themePath);
+    const componentNames = componentFiles.map((f) => f.componentName);
+    return sortComponentNames(componentNames);
+}
+exports.readComponentNames = readComponentNames;
+function listComponentNames(themeComponents) {
+    if (themeComponents.all.length === 0) {
+        return 'No component to swizzle.';
+    }
+    return `${(0, tables_1.themeComponentsTable)(themeComponents)}
+
+${(0, tables_1.helpTables)()}
+`;
+}
+exports.listComponentNames = listComponentNames;
+async function getThemeComponents({ themeName, themePath, swizzleConfig, }) {
+    const FallbackSwizzleActionStatus = 'unsafe';
+    const FallbackSwizzleComponentDescription = 'N/A';
+    const FallbackSwizzleComponentConfig = {
+        actions: {
+            wrap: FallbackSwizzleActionStatus,
+            eject: FallbackSwizzleActionStatus,
+        },
+        description: FallbackSwizzleComponentDescription,
+    };
+    const FallbackIntermediateFolderSwizzleComponentConfig = {
+        actions: {
+            // It doesn't make sense to wrap an intermediate folder
+            // because it has not any index component
+            wrap: 'forbidden',
+            eject: FallbackSwizzleActionStatus,
+        },
+        description: FallbackSwizzleComponentDescription,
+    };
+    const allInitialComponents = await readComponentNames(themePath);
+    const missingIntermediateComponentFolderNames = getMissingIntermediateComponentFolderNames(allInitialComponents);
+    const allComponents = sortComponentNames(allInitialComponents.concat(missingIntermediateComponentFolderNames));
+    function getConfig(component) {
+        if (!allComponents.includes(component)) {
+            throw new Error(`Can't get component config: component doesn't exist: ${component}`);
+        }
+        const config = swizzleConfig.components[component];
+        if (config) {
+            return config;
+        }
+        const isIntermediateFolder = missingIntermediateComponentFolderNames.includes(component);
+        if (isIntermediateFolder) {
+            return FallbackIntermediateFolderSwizzleComponentConfig;
+        }
+        return (swizzleConfig.components[component] ?? FallbackSwizzleComponentConfig);
+    }
+    function getDescription(component) {
+        return (getConfig(component).description ?? FallbackSwizzleComponentDescription);
+    }
+    function getActionStatus(component, action) {
+        return getConfig(component).actions[action] ?? FallbackSwizzleActionStatus;
+    }
+    function isSafeAction(component, action) {
+        return getActionStatus(component, action) === 'safe';
+    }
+    function hasAllSafeAction(component) {
+        return actions_1.SwizzleActions.every((action) => isSafeAction(component, action));
+    }
+    function hasAnySafeAction(component) {
+        return actions_1.SwizzleActions.some((action) => isSafeAction(component, action));
+    }
+    // Present the safest components first
+    const orderedComponents = lodash_1.default.orderBy(allComponents, [
+        hasAllSafeAction,
+        (component) => isSafeAction(component, 'wrap'),
+        (component) => isSafeAction(component, 'eject'),
+        (component) => component,
+    ], ['desc', 'desc', 'desc', 'asc']);
+    return {
+        themeName,
+        all: orderedComponents,
+        getConfig,
+        getDescription,
+        getActionStatus,
+        isSafeAction,
+        hasAnySafeAction,
+        hasAllSafeAction,
+    };
+}
+exports.getThemeComponents = getThemeComponents;
+// Returns a valid value if recovering is possible
+function handleInvalidComponentNameParam({ componentNameParam, themeComponents, }) {
+    // Trying to recover invalid value
+    // We look for potential matches that only differ in casing.
+    const differentCaseMatch = (0, common_1.findStringIgnoringCase)(componentNameParam, themeComponents.all);
+    if (differentCaseMatch) {
+        logger_1.default.warn `Component name=${componentNameParam} doesn't exist.`;
+        logger_1.default.info `name=${differentCaseMatch} will be used instead of name=${componentNameParam}.`;
+        return differentCaseMatch;
+    }
+    // No recovery value is possible: print error
+    logger_1.default.error `Component name=${componentNameParam} not found.`;
+    const suggestion = (0, common_1.findClosestValue)(componentNameParam, themeComponents.all);
+    if (suggestion) {
+        logger_1.default.info `Did you mean name=${suggestion}? ${themeComponents.hasAnySafeAction(suggestion)
+            ? `Note: this component is an unsafe internal component and can only be swizzled with code=${'--danger'} or explicit confirmation.`
+            : ''}`;
+    }
+    else {
+        logger_1.default.info(listComponentNames(themeComponents));
+    }
+    return process.exit(1);
+}
+async function handleComponentNameParam({ componentNameParam, themeComponents, }) {
+    const isValidName = themeComponents.all.includes(componentNameParam);
+    if (!isValidName) {
+        return handleInvalidComponentNameParam({
+            componentNameParam,
+            themeComponents,
+        });
+    }
+    return componentNameParam;
+}
+async function getComponentName({ componentNameParam, themeComponents, list, }) {
+    if (list) {
+        logger_1.default.info(listComponentNames(themeComponents));
+        return process.exit(0);
+    }
+    const componentName = componentNameParam
+        ? await handleComponentNameParam({
+            componentNameParam,
+            themeComponents,
+        })
+        : await (0, prompts_1.askComponentName)(themeComponents);
+    return componentName;
+}
+exports.getComponentName = getComponentName;

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

@@ -0,0 +1,10 @@
+/**
+ * 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 { SwizzleConfig } from '@docusaurus/types';
+import type { SwizzlePlugin } from './common';
+export declare function normalizeSwizzleConfig(unsafeSwizzleConfig: unknown): SwizzleConfig;
+export declare function getThemeSwizzleConfig(themeName: string, plugins: SwizzlePlugin[]): SwizzleConfig;

package/lib/commands/swizzle/config.js

@@ -0,0 +1,84 @@
+"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.getThemeSwizzleConfig = exports.normalizeSwizzleConfig = void 0;
+const tslib_1 = require("tslib");
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
+const utils_validation_1 = require("@docusaurus/utils-validation");
+const common_1 = require("./common");
+const themes_1 = require("./themes");
+function getModuleSwizzleConfig(swizzlePlugin) {
+    const getSwizzleConfig = swizzlePlugin.plugin.plugin.getSwizzleConfig ??
+        swizzlePlugin.plugin.pluginModule?.module.getSwizzleConfig;
+    if (getSwizzleConfig) {
+        return getSwizzleConfig();
+    }
+    // TODO deprecate getSwizzleComponentList later
+    const getSwizzleComponentList = swizzlePlugin.plugin.plugin.getSwizzleComponentList ??
+        swizzlePlugin.plugin.pluginModule?.module.getSwizzleComponentList;
+    if (getSwizzleComponentList) {
+        const safeComponents = getSwizzleComponentList() ?? [];
+        const safeComponentConfig = {
+            actions: {
+                eject: 'safe',
+                wrap: 'safe',
+            },
+            description: undefined,
+        };
+        return {
+            components: Object.fromEntries(safeComponents.map((comp) => [comp, safeComponentConfig])),
+        };
+    }
+    return undefined;
+}
+const SwizzleConfigSchema = utils_validation_1.Joi.object({
+    components: utils_validation_1.Joi.object()
+        .pattern(utils_validation_1.Joi.string(), utils_validation_1.Joi.object({
+        actions: utils_validation_1.Joi.object().pattern(utils_validation_1.Joi.string().valid(...common_1.SwizzleActions), utils_validation_1.Joi.string().valid(...common_1.SwizzleActionsStatuses)),
+        description: utils_validation_1.Joi.string(),
+    }))
+        .required(),
+});
+function validateSwizzleConfig(unsafeSwizzleConfig) {
+    const result = SwizzleConfigSchema.validate(unsafeSwizzleConfig);
+    if (result.error) {
+        throw new Error(`Swizzle config does not match expected schema: ${result.error.message}`);
+    }
+    return result.value;
+}
+function normalizeSwizzleConfig(unsafeSwizzleConfig) {
+    const swizzleConfig = validateSwizzleConfig(unsafeSwizzleConfig);
+    // Ensure all components always declare all actions
+    Object.values(swizzleConfig.components).forEach((componentConfig) => {
+        common_1.SwizzleActions.forEach((action) => {
+            if (!componentConfig.actions[action]) {
+                componentConfig.actions[action] = 'unsafe';
+            }
+        });
+    });
+    return swizzleConfig;
+}
+exports.normalizeSwizzleConfig = normalizeSwizzleConfig;
+const FallbackSwizzleConfig = {
+    components: {},
+};
+function getThemeSwizzleConfig(themeName, plugins) {
+    const plugin = (0, themes_1.getPluginByThemeName)(plugins, themeName);
+    const config = getModuleSwizzleConfig(plugin);
+    if (config) {
+        try {
+            return normalizeSwizzleConfig(config);
+        }
+        catch (err) {
+            logger_1.default.error `Invalid Swizzle config for theme name=${themeName}.`;
+            throw err;
+        }
+    }
+    return FallbackSwizzleConfig;
+}
+exports.getThemeSwizzleConfig = getThemeSwizzleConfig;

package/lib/{server/client-modules/index.d.ts → commands/swizzle/context.d.ts}

@@ -4,5 +4,5 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { Plugin } from '@docusaurus/types';
-export default function loadClientModules(plugins: Plugin<unknown>[]): string[];
+import type { SwizzleContext } from './common';
+export declare function initSwizzleContext(siteDir: string): Promise<SwizzleContext>;

package/lib/commands/swizzle/context.js

@@ -0,0 +1,24 @@
+"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.initSwizzleContext = void 0;
+const server_1 = require("../../server");
+const init_1 = require("../../server/plugins/init");
+const configs_1 = require("../../server/plugins/configs");
+async function initSwizzleContext(siteDir) {
+    const context = await (0, server_1.loadContext)({ siteDir });
+    const plugins = await (0, init_1.initPlugins)(context);
+    const pluginConfigs = await (0, configs_1.loadPluginConfigs)(context);
+    return {
+        plugins: plugins.map((plugin, pluginIndex) => ({
+            plugin: pluginConfigs[pluginIndex],
+            instance: plugin,
+        })),
+    };
+}
+exports.initSwizzleContext = initSwizzleContext;

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

@@ -0,0 +1,8 @@
+/**
+ * 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 { SwizzleCLIOptions } from './common';
+export declare function swizzle(themeNameParam?: string | undefined, componentNameParam?: string | undefined, siteDirParam?: string, optionsParam?: Partial<SwizzleCLIOptions>): Promise<void>;

package/lib/commands/swizzle/index.js

@@ -0,0 +1,119 @@
+"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.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 themes_1 = require("./themes");
+const components_1 = require("./components");
+const tables_1 = require("./tables");
+const common_1 = require("./common");
+const actions_1 = require("./actions");
+const config_1 = require("./config");
+const prompts_1 = require("./prompts");
+const context_1 = require("./context");
+async function listAllThemeComponents({ themeNames, plugins, typescript, }) {
+    const themeComponentsTables = (await Promise.all(themeNames.map(async (themeName) => {
+        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,
+            themePath,
+            swizzleConfig,
+        });
+        return (0, tables_1.themeComponentsTable)(themeComponents);
+    }))).join('\n\n');
+    logger_1.default.info(`All theme components available to swizzle:
+
+${themeComponentsTables}
+
+${(0, tables_1.helpTables)()}
+    `);
+    return process.exit(0);
+}
+async function ensureActionSafety({ componentName, componentConfig, action, danger, }) {
+    const actionStatus = componentConfig.actions[action];
+    if (actionStatus === 'forbidden') {
+        logger_1.default.error `
+Swizzle action name=${action} is forbidden for component name=${componentName}
+`;
+        return process.exit(1);
+    }
+    if (actionStatus === 'unsafe' && !danger) {
+        logger_1.default.warn `
+Swizzle action name=${action} is unsafe to perform on name=${componentName}.
+It is more likely to be affected by breaking changes in the future
+If you want to swizzle it, use the code=${'--danger'} flag, or confirm that you understand the risks.
+`;
+        const swizzleDangerousComponent = await (0, prompts_1.askSwizzleDangerousComponent)();
+        if (!swizzleDangerousComponent) {
+            return process.exit(1);
+        }
+    }
+    return undefined;
+}
+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 { plugins } = await (0, context_1.initSwizzleContext)(siteDir);
+    const themeNames = (0, themes_1.getThemeNames)(plugins);
+    if (list && !themeNameParam) {
+        await listAllThemeComponents({ themeNames, plugins, typescript });
+    }
+    const themeName = await (0, themes_1.getThemeName)({ themeNameParam, themeNames, list });
+    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,
+        themePath,
+        swizzleConfig,
+    });
+    const componentName = await (0, components_1.getComponentName)({
+        componentNameParam,
+        themeComponents,
+        list,
+    });
+    const componentConfig = themeComponents.getConfig(componentName);
+    const action = await (0, actions_1.getAction)(componentConfig, options);
+    await ensureActionSafety({ componentName, componentConfig, action, danger });
+    async function executeAction() {
+        switch (action) {
+            case 'wrap': {
+                const result = await (0, actions_1.wrap)({
+                    siteDir,
+                    themePath,
+                    componentName,
+                    typescript,
+                });
+                logger_1.default.success `
+Created wrapper of name=${componentName} from name=${themeName} in path=${result.createdFiles}
+`;
+                return result;
+            }
+            case 'eject': {
+                const result = await (0, actions_1.eject)({
+                    siteDir,
+                    themePath,
+                    componentName,
+                    typescript,
+                });
+                logger_1.default.success `
+Ejected name=${componentName} from name=${themeName} to path=${result.createdFiles}
+`;
+                return result;
+            }
+            default:
+                throw new Error(`Unexpected action ${action}`);
+        }
+    }
+    await executeAction();
+    return process.exit(0);
+}
+exports.swizzle = swizzle;

package/lib/commands/swizzle/prompts.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 { ThemeComponents } from './components';
+import type { SwizzleAction, SwizzleComponentConfig } from '@docusaurus/types';
+export declare function askThemeName(themeNames: string[]): Promise<string>;
+export declare function askComponentName(themeComponents: ThemeComponents): Promise<string>;
+export declare function askSwizzleDangerousComponent(): Promise<boolean>;
+export declare function askSwizzleAction(componentConfig: SwizzleComponentConfig): Promise<SwizzleAction>;

package/lib/commands/swizzle/prompts.js

@@ -0,0 +1,110 @@
+"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.askSwizzleAction = exports.askSwizzleDangerousComponent = exports.askComponentName = exports.askThemeName = void 0;
+const tslib_1 = require("tslib");
+const logger_1 = tslib_1.__importDefault(require("@docusaurus/logger"));
+const prompts_1 = tslib_1.__importDefault(require("prompts"));
+const common_1 = require("./common");
+const ExitTitle = logger_1.default.yellow('[Exit]');
+async function askThemeName(themeNames) {
+    const { themeName } = (await (0, prompts_1.default)({
+        type: 'select',
+        name: 'themeName',
+        message: 'Select a theme to swizzle:',
+        choices: themeNames
+            .map((theme) => ({ title: theme, value: theme }))
+            .concat({ title: ExitTitle, value: '[Exit]' }),
+    }));
+    if (!themeName || themeName === '[Exit]') {
+        process.exit(0);
+    }
+    return themeName;
+}
+exports.askThemeName = askThemeName;
+async function askComponentName(themeComponents) {
+    function formatComponentName(componentName) {
+        const anySafe = themeComponents.hasAnySafeAction(componentName);
+        const allSafe = themeComponents.hasAllSafeAction(componentName);
+        const safestStatus = anySafe ? 'safe' : 'unsafe'; // Not 100% accurate but good enough for now.
+        const partiallySafe = anySafe && !allSafe;
+        return `${componentName}${(0, common_1.actionStatusSuffix)(safestStatus, {
+            partiallySafe,
+        })}`;
+    }
+    const { componentName } = (await (0, prompts_1.default)({
+        type: 'autocomplete',
+        name: 'componentName',
+        message: `
+Select or type the component to swizzle.
+${common_1.PartiallySafeHint} = not safe for all swizzle actions
+`,
+        // This doesn't work well in small-height terminals (like IDE)
+        // limit: 30,
+        // This does not work well and messes up with terminal scroll position
+        // limit: Number.POSITIVE_INFINITY,
+        choices: themeComponents.all
+            .map((compName) => ({
+            title: formatComponentName(compName),
+            value: compName,
+        }))
+            .concat({ title: ExitTitle, value: '[Exit]' }),
+        async suggest(input, choices) {
+            return choices.filter((choice) => choice.title.toLowerCase().includes(input.toLowerCase()));
+        },
+    }));
+    logger_1.default.newLine();
+    if (!componentName || componentName === '[Exit]') {
+        return process.exit(0);
+    }
+    return componentName;
+}
+exports.askComponentName = askComponentName;
+async function askSwizzleDangerousComponent() {
+    const { switchToDanger } = (await (0, prompts_1.default)({
+        type: 'select',
+        name: 'switchToDanger',
+        message: `Do you really want to swizzle this unsafe internal component?`,
+        choices: [
+            { title: logger_1.default.green('NO: cancel and stay safe'), value: false },
+            {
+                title: logger_1.default.red('YES: I know what I am doing!'),
+                value: true,
+            },
+            { title: ExitTitle, value: '[Exit]' },
+        ],
+    }));
+    if (typeof switchToDanger === 'undefined' || switchToDanger === '[Exit]') {
+        return process.exit(0);
+    }
+    return !!switchToDanger;
+}
+exports.askSwizzleDangerousComponent = askSwizzleDangerousComponent;
+async function askSwizzleAction(componentConfig) {
+    const { action } = (await (0, prompts_1.default)({
+        type: 'select',
+        name: 'action',
+        message: `Which swizzle action do you want to do?`,
+        choices: [
+            {
+                title: `${logger_1.default.bold('Wrap')}${(0, common_1.actionStatusSuffix)(componentConfig.actions.wrap)}`,
+                value: 'wrap',
+            },
+            {
+                title: `${logger_1.default.bold('Eject')}${(0, common_1.actionStatusSuffix)(componentConfig.actions.eject)}`,
+                value: 'eject',
+            },
+            { title: ExitTitle, value: '[Exit]' },
+        ],
+    }));
+    if (typeof action === 'undefined' || action === '[Exit]') {
+        return process.exit(0);
+    }
+    return action;
+}
+exports.askSwizzleAction = askSwizzleAction;

package/lib/{client/exports/context.d.ts → commands/swizzle/tables.d.ts}

@@ -4,7 +4,6 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import React from 'react';
-import { DocusaurusContext } from '@docusaurus/types';
-declare const _default: React.Context<DocusaurusContext | null>;
-export default _default;
+import type { ThemeComponents } from './components';
+export declare function helpTables(): string;
+export declare function themeComponentsTable(themeComponents: ThemeComponents): string;