@docusaurus/core 2.0.0-beta.15 → 2.0.0-beta.16

package/lib/commands/serve.js

@@ -44,13 +44,14 @@ async function serve(siteDir, cliOptions) {
             res.end();
             return;
         }
-        // Remove baseUrl before calling serveHandler
-        // Reason: /baseUrl/ should serve /build/index.html, not /build/baseUrl/index.html (does not exist)
+        // Remove baseUrl before calling serveHandler, because /baseUrl/ should
+        // serve /build/index.html, not /build/baseUrl/index.html (does not exist)
         req.url = (_b = req.url) === null || _b === void 0 ? void 0 : _b.replace(baseUrl, '/');
         (0, serve_handler_1.default)(req, res, {
             cleanUrls: true,
             public: dir,
             trailingSlash,
+            directoryListing: false,
         });
     });
     logger_1.default.success `Serving path=${cliOptions.dir} directory at path=${servingUrl + baseUrl}.`;

package/lib/commands/start.js

@@ -12,7 +12,7 @@ const logger_1 = (0, tslib_1.__importDefault)(require("@docusaurus/logger"));
 const chokidar_1 = (0, tslib_1.__importDefault)(require("chokidar"));
 const html_webpack_plugin_1 = (0, tslib_1.__importDefault)(require("html-webpack-plugin"));
 const path_1 = (0, tslib_1.__importDefault)(require("path"));
-const lodash_1 = require("lodash");
+const lodash_1 = (0, tslib_1.__importDefault)(require("lodash"));
 const openBrowser_1 = (0, tslib_1.__importDefault)(require("react-dev-utils/openBrowser"));
 const WebpackDevServerUtils_1 = require("react-dev-utils/WebpackDevServerUtils");
 const evalSourceMapMiddleware_1 = (0, tslib_1.__importDefault)(require("react-dev-utils/evalSourceMapMiddleware"));
@@ -48,7 +48,7 @@ async function start(siteDir, cliOptions) {
     const openUrl = (0, utils_1.normalizeUrl)([urls.localUrlForBrowser, baseUrl]);
     logger_1.default.success `Docusaurus website is running at path=${openUrl}.`;
     // Reload files processing.
-    const reload = (0, lodash_1.debounce)(() => {
+    const reload = lodash_1.default.debounce(() => {
         loadSite()
             .then(({ baseUrl: newBaseUrl }) => {
             const newOpenUrl = (0, utils_1.normalizeUrl)([urls.localUrlForBrowser, newBaseUrl]);
@@ -86,14 +86,14 @@ async function start(siteDir, cliOptions) {
             ? cliOptions.poll
             : undefined,
     };
-    const httpsConfig = (0, utils_2.getHttpsConfig)();
+    const httpsConfig = await (0, utils_2.getHttpsConfig)();
     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)((0, client_1.default)(props), {
+    let config = (0, webpack_merge_1.default)(await (0, client_1.default)(props), {
         infrastructureLogging: {
             // Reduce log verbosity, see https://github.com/facebook/docusaurus/pull/5420#issuecomment-906613105
             level: 'warn',

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

@@ -0,0 +1,23 @@
+/**
+ * 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 { SwizzleAction, SwizzleComponentConfig } from '@docusaurus/types';
+import type { SwizzleOptions } from './common';
+export declare const SwizzleActions: SwizzleAction[];
+export declare function getAction(componentConfig: SwizzleComponentConfig, options: Pick<SwizzleOptions, 'wrap' | 'eject'>): Promise<SwizzleAction>;
+export declare type ActionParams = {
+    siteDir: string;
+    themePath: string;
+    componentName: string;
+};
+export declare type ActionResult = {
+    createdFiles: string[];
+};
+export declare function eject({ siteDir, themePath, componentName, }: ActionParams): Promise<ActionResult>;
+export declare function wrap({ siteDir, themePath, componentName: themeComponentName, typescript, importType, }: ActionParams & {
+    typescript: boolean;
+    importType?: 'original' | 'init';
+}): Promise<ActionResult>;

package/lib/commands/swizzle/actions.js

@@ -0,0 +1,102 @@
+"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.wrap = exports.eject = exports.getAction = exports.SwizzleActions = void 0;
+const tslib_1 = require("tslib");
+const logger_1 = (0, tslib_1.__importDefault)(require("@docusaurus/logger"));
+const fs_extra_1 = (0, tslib_1.__importDefault)(require("fs-extra"));
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
+const lodash_1 = (0, tslib_1.__importDefault)(require("lodash"));
+const utils_1 = require("@docusaurus/utils");
+const prompts_1 = require("./prompts");
+exports.SwizzleActions = ['wrap', 'eject'];
+async function getAction(componentConfig, options) {
+    if (options.wrap) {
+        return 'wrap';
+    }
+    if (options.eject) {
+        return 'eject';
+    }
+    return (0, prompts_1.askSwizzleAction)(componentConfig);
+}
+exports.getAction = getAction;
+async function isDir(dirPath) {
+    return ((await fs_extra_1.default.pathExists(dirPath)) && (await fs_extra_1.default.stat(dirPath)).isDirectory());
+}
+async function eject({ siteDir, themePath, componentName, }) {
+    const fromPath = path_1.default.join(themePath, componentName);
+    const isDirectory = await isDir(fromPath);
+    const globPattern = isDirectory
+        ? // do we really want to copy all components?
+            path_1.default.join(fromPath, '*')
+        : `${fromPath}.*`;
+    const globPatternPosix = (0, utils_1.posixPath)(globPattern);
+    const filesToCopy = await (0, utils_1.Globby)(globPatternPosix, {
+        ignore: ['**/*.{story,stories,test,tests}.{js,jsx,ts,tsx}'],
+    });
+    if (filesToCopy.length === 0) {
+        // This should never happen
+        throw new Error(logger_1.default.interpolate `No files to copy from path=${fromPath} with glob code=${globPatternPosix}`);
+    }
+    const toPath = isDirectory
+        ? path_1.default.join(siteDir, utils_1.THEME_PATH, componentName)
+        : path_1.default.join(siteDir, utils_1.THEME_PATH);
+    await fs_extra_1.default.ensureDir(toPath);
+    const createdFiles = await Promise.all(filesToCopy.map(async (sourceFile) => {
+        const fileName = path_1.default.basename(sourceFile);
+        const targetFile = path_1.default.join(toPath, fileName);
+        try {
+            await fs_extra_1.default.copy(sourceFile, targetFile, { overwrite: true });
+        }
+        catch (err) {
+            throw new Error(logger_1.default.interpolate `Could not copy file from ${sourceFile} to ${targetFile}`);
+        }
+        return targetFile;
+    }));
+    return { createdFiles };
+}
+exports.eject = eject;
+async function wrap({ siteDir, themePath, componentName: themeComponentName, typescript, importType = 'original', }) {
+    const isDirectory = await isDir(path_1.default.join(themePath, themeComponentName));
+    // Top/Parent/ComponentName => ComponentName
+    const componentName = lodash_1.default.last(themeComponentName.split('/'));
+    const wrapperComponentName = `${componentName}Wrapper`;
+    const wrapperFileName = `${themeComponentName}${isDirectory ? '/index' : ''}${typescript ? '.tsx' : '.js'}`;
+    await fs_extra_1.default.ensureDir(path_1.default.resolve(siteDir, utils_1.THEME_PATH));
+    const toPath = path_1.default.resolve(siteDir, utils_1.THEME_PATH, wrapperFileName);
+    const content = typescript
+        ? `import React, {ComponentProps} from 'react';
+import type ${componentName}Type from '@theme/${themeComponentName}';
+import ${componentName} from '@theme-${importType}/${themeComponentName}';
+
+type Props = ComponentProps<typeof ${componentName}Type>
+
+export default function ${wrapperComponentName}(props: Props): JSX.Element {
+  return (
+    <>
+      <${componentName} {...props} />
+    </>
+  );
+}
+`
+        : `import React from 'react';
+import ${componentName} from '@theme-${importType}/${themeComponentName}';
+
+export default function ${wrapperComponentName}(props) {
+  return (
+    <>
+      <${componentName} {...props} />
+    </>
+  );
+}
+`;
+    await fs_extra_1.default.ensureDir(path_1.default.dirname(toPath));
+    await fs_extra_1.default.writeFile(toPath, content);
+    return { createdFiles: [toPath] };
+}
+exports.wrap = wrap;

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

@@ -0,0 +1,33 @@
+/**
+ * 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 { InitializedPlugin, SwizzleAction, SwizzleActionStatus } from '@docusaurus/types';
+import type { NormalizedPluginConfig } from '../../server/plugins/init';
+export declare const SwizzleActions: SwizzleAction[];
+export declare const SwizzleActionsStatuses: SwizzleActionStatus[];
+export declare const PartiallySafeHint: string;
+export declare function actionStatusLabel(status: SwizzleActionStatus): string;
+export declare function actionStatusColor(status: SwizzleActionStatus, str: string): string;
+export declare function actionStatusSuffix(status: SwizzleActionStatus, options?: {
+    partiallySafe?: boolean;
+}): string;
+export declare type SwizzlePlugin = {
+    instance: InitializedPlugin;
+    plugin: NormalizedPluginConfig;
+};
+export declare type SwizzleContext = {
+    plugins: SwizzlePlugin[];
+};
+export declare type SwizzleOptions = {
+    typescript: boolean;
+    danger: boolean;
+    list: boolean;
+    wrap: boolean;
+    eject: boolean;
+};
+export declare function normalizeOptions(options: Partial<SwizzleOptions>): SwizzleOptions;
+export declare function findStringIgnoringCase(str: string, values: string[]): string | undefined;
+export declare function findClosestValue(str: string, values: string[], maxLevenshtein?: number): string | undefined;

package/lib/commands/swizzle/common.js

@@ -0,0 +1,57 @@
+"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.findClosestValue = exports.findStringIgnoringCase = exports.normalizeOptions = exports.actionStatusSuffix = exports.actionStatusColor = exports.actionStatusLabel = exports.PartiallySafeHint = exports.SwizzleActionsStatuses = exports.SwizzleActions = void 0;
+const tslib_1 = require("tslib");
+const leven_1 = (0, tslib_1.__importDefault)(require("leven"));
+const lodash_1 = (0, tslib_1.__importDefault)(require("lodash"));
+const logger_1 = (0, tslib_1.__importDefault)(require("@docusaurus/logger"));
+exports.SwizzleActions = ['wrap', 'eject'];
+exports.SwizzleActionsStatuses = [
+    'safe',
+    'unsafe',
+    'forbidden',
+];
+exports.PartiallySafeHint = logger_1.default.red('*');
+function actionStatusLabel(status) {
+    return lodash_1.default.capitalize(status);
+}
+exports.actionStatusLabel = actionStatusLabel;
+const SwizzleActionStatusColors = {
+    safe: logger_1.default.green,
+    unsafe: logger_1.default.yellow,
+    forbidden: logger_1.default.red,
+};
+function actionStatusColor(status, str) {
+    const colorFn = SwizzleActionStatusColors[status];
+    return colorFn(str);
+}
+exports.actionStatusColor = actionStatusColor;
+function actionStatusSuffix(status, options = {}) {
+    return ` (${actionStatusColor(status, actionStatusLabel(status))}${options.partiallySafe ? exports.PartiallySafeHint : ''})`;
+}
+exports.actionStatusSuffix = actionStatusSuffix;
+function normalizeOptions(options) {
+    var _a, _b, _c, _d, _e;
+    return {
+        typescript: (_a = options.typescript) !== null && _a !== void 0 ? _a : false,
+        danger: (_b = options.danger) !== null && _b !== void 0 ? _b : false,
+        list: (_c = options.list) !== null && _c !== void 0 ? _c : false,
+        wrap: (_d = options.wrap) !== null && _d !== void 0 ? _d : false,
+        eject: (_e = options.eject) !== null && _e !== void 0 ? _e : false,
+    };
+}
+exports.normalizeOptions = normalizeOptions;
+function findStringIgnoringCase(str, values) {
+    return values.find((v) => v.toLowerCase() === str.toLowerCase());
+}
+exports.findStringIgnoringCase = findStringIgnoringCase;
+function findClosestValue(str, values, maxLevenshtein = 3) {
+    return values.find((v) => (0, leven_1.default)(v, str) <= maxLevenshtein);
+}
+exports.findClosestValue = findClosestValue;

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

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { SwizzleAction, SwizzleActionStatus, SwizzleComponentConfig, SwizzleConfig } from '@docusaurus/types';
+export declare type ThemeComponents = {
+    themeName: string;
+    all: string[];
+    getConfig: (component: string) => SwizzleComponentConfig;
+    getDescription: (component: string) => string;
+    getActionStatus: (component: string, action: SwizzleAction) => SwizzleActionStatus;
+    isSafeAction: (component: string, action: SwizzleAction) => boolean;
+    hasAnySafeAction: (component: string) => boolean;
+    hasAllSafeAction: (component: string) => boolean;
+};
+export declare function readComponentNames(themePath: string): Promise<string[]>;
+export declare function listComponentNames(themeComponents: ThemeComponents): string;
+export declare function getThemeComponents({ themeName, themePath, swizzleConfig, }: {
+    themeName: string;
+    themePath: string;
+    swizzleConfig: SwizzleConfig;
+}): Promise<ThemeComponents>;
+export declare function getComponentName({ componentNameParam, themeComponents, list, }: {
+    componentNameParam: string | undefined;
+    themeComponents: ThemeComponents;
+    list: boolean | undefined;
+}): Promise<string>;

package/lib/commands/swizzle/components.js

@@ -0,0 +1,165 @@
+"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 logger_1 = (0, tslib_1.__importDefault)(require("@docusaurus/logger"));
+const fs_extra_1 = (0, tslib_1.__importDefault)(require("fs-extra"));
+const path_1 = (0, tslib_1.__importDefault)(require("path"));
+const lodash_1 = (0, tslib_1.__importDefault)(require("lodash"));
+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?/, '');
+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 componentFilesOrdered = lodash_1.default.orderBy(componentFiles, [(f) => f.componentName], ['asc']);
+    return componentFilesOrdered.map((f) => f.componentName);
+}
+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 allComponents = await readComponentNames(themePath);
+    function getConfig(component) {
+        var _a;
+        if (!allComponents.includes(component)) {
+            throw new Error(`Can't get component config: component doesn't exist: ${component}`);
+        }
+        return ((_a = swizzleConfig.components[component]) !== null && _a !== void 0 ? _a : FallbackSwizzleComponentConfig);
+    }
+    function getDescription(component) {
+        var _a;
+        return ((_a = getConfig(component).description) !== null && _a !== void 0 ? _a : FallbackSwizzleComponentDescription);
+    }
+    function getActionStatus(component, action) {
+        var _a;
+        return (_a = getConfig(component).actions[action]) !== null && _a !== void 0 ? _a : 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,77 @@
+"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 utils_validation_1 = require("@docusaurus/utils-validation");
+const common_1 = require("./common");
+const themes_1 = require("./themes");
+function getModuleSwizzleConfig(swizzlePlugin) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+    const getSwizzleConfig = (_d = (_b = (_a = swizzlePlugin.plugin.plugin) === null || _a === void 0 ? void 0 : _a.getSwizzleConfig) !== null && _b !== void 0 ? _b : (_c = swizzlePlugin.plugin.pluginModule) === null || _c === void 0 ? void 0 : _c.module.getSwizzleConfig) !== null && _d !== void 0 ? _d : (_f = (_e = swizzlePlugin.plugin.pluginModule) === null || _e === void 0 ? void 0 : _e.module) === null || _f === void 0 ? void 0 : _f.getSwizzleConfig;
+    if (getSwizzleConfig) {
+        return getSwizzleConfig();
+    }
+    // TODO deprecate getSwizzleComponentList later
+    const getSwizzleComponentList = (_k = (_h = (_g = swizzlePlugin.plugin.plugin) === null || _g === void 0 ? void 0 : _g.getSwizzleComponentList) !== null && _h !== void 0 ? _h : (_j = swizzlePlugin.plugin.pluginModule) === null || _j === void 0 ? void 0 : _j.module.getSwizzleComponentList) !== null && _k !== void 0 ? _k : (_m = (_l = swizzlePlugin.plugin.pluginModule) === null || _l === void 0 ? void 0 : _l.module) === null || _m === void 0 ? void 0 : _m.getSwizzleComponentList;
+    if (getSwizzleComponentList) {
+        const safeComponents = (_o = getSwizzleComponentList()) !== null && _o !== void 0 ? _o : [];
+        const safeComponentConfig = {
+            actions: {
+                eject: 'safe',
+                wrap: 'safe',
+            },
+            description: undefined,
+        };
+        return {
+            components: Object.fromEntries(safeComponents.map((comp) => [comp, safeComponentConfig])),
+        };
+    }
+    return undefined;
+}
+function normalizeSwizzleConfig(unsafeSwizzleConfig) {
+    const schema = 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(),
+    });
+    const result = schema.validate(unsafeSwizzleConfig);
+    if (result.error) {
+        throw new Error(`Swizzle config does not match expected schema: ${result.error.message}`);
+    }
+    const swizzleConfig = result.value;
+    // 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 (e) {
+            throw new Error(`Invalid Swizzle config for theme ${themeName}.\n${e.message}`);
+        }
+    }
+    return FallbackSwizzleConfig;
+}
+exports.getThemeSwizzleConfig = getThemeSwizzleConfig;

package/lib/commands/swizzle/context.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 { SwizzleContext } from './common';
+export declare function initSwizzleContext(siteDir: string): Promise<SwizzleContext>;

package/lib/commands/swizzle/context.js

@@ -0,0 +1,30 @@
+"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 tslib_1 = require("tslib");
+const module_1 = require("module");
+const server_1 = require("../../server");
+const init_1 = (0, tslib_1.__importStar)(require("../../server/plugins/init"));
+async function initSwizzleContext(siteDir) {
+    const context = await (0, server_1.loadContext)(siteDir);
+    const pluginRequire = (0, module_1.createRequire)(context.siteConfigPath);
+    const pluginConfigs = await (0, server_1.loadPluginConfigs)(context);
+    const plugins = await (0, init_1.default)({
+        pluginConfigs,
+        context,
+    });
+    const pluginsNormalized = await (0, init_1.normalizePluginConfigs)(pluginConfigs, pluginRequire);
+    return {
+        plugins: plugins.map((plugin, pluginIndex) => ({
+            plugin: pluginsNormalized[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 { SwizzleOptions } from './common';
+export default function swizzle(siteDir: string, themeNameParam: string | undefined, componentNameParam: string | undefined, optionsParam: Partial<SwizzleOptions>): Promise<void>;