@servicetitan/startup 34.3.0-beta.2 → 35.0.0

package/src/cli/utils/bundle.ts

@@ -1,21 +1,44 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
 import { getPortPromise } from 'portfinder';
 import webpack, { Configuration } from 'webpack';
 import WebpackDevServer from 'webpack-dev-server';
-import { isDevServerDisabled, isExposeSharedDependencies, isWebComponent, log } from '../../utils';
-import { createWebpackConfigs } from '../../webpack';
+import {
+    getPackageName,
+    hasHeadlessBundle,
+    isDevServerDisabled,
+    isExposeSharedDependencies,
+    isWebComponent,
+    log,
+    pick,
+} from '../../utils';
+import { Overrides, createWebpackConfig } from '../../webpack';
+import { stringifyConfig } from '../../webpack/utils';
 
 interface Options {
     buildStat?: boolean;
     codeCoverage?: boolean;
     config?: string;
-    emitExposedDependencies?: boolean;
+    emitExposedDependencies?: boolean | Pick<Configuration, 'output'>;
     useWatchConfig?: boolean;
     watch?: boolean;
 }
 
-export async function bundle(options: Options = {}) {
-    const { emitExposedDependencies, watch } = options;
+function getName() {
+    const packageName = getPackageName()
+        .replace(/\//g, '-')
+        .replace(/[^\w-]/g, '');
+    const hash = crypto.randomBytes(4).toString('hex');
+
+    return `${packageName}-${hash}`;
+}
 
+export const webpackDevConfigFileName = 'webpack.dev.config.js';
+export const webpackProdConfigFileName = 'webpack.prod.config.js';
+
+export async function bundle(options: Options = {}) {
+    const { emitExposedDependencies, useWatchConfig, watch } = options;
     if (emitExposedDependencies) {
         if (watch) {
             throw new Error('cannot bundle exposed dependencies in watch mode');
@@ -27,31 +50,89 @@ export async function bundle(options: Options = {}) {
 
     log.info(`Bundling ${emitExposedDependencies ? 'exposed dependencies' : 'package'}...`);
 
-    if (isWebComponent()) {
-        const [fullConfig, lightConfig, headlessConfig] = createWebpackConfigs(options);
+    const mode = watch || useWatchConfig ? 'development' : 'production';
+    const fallback = watch || useWatchConfig ? webpackDevConfigFileName : webpackProdConfigFileName;
+    const customConfig = readWebpackConfig({ ...options, fallback });
+    const webpackOptions = getWebpackOptions(options, customConfig);
 
-        if (watch) {
-            return Promise.all([
-                isDevServerDisabled() ? runWatch(fullConfig) : runServe(fullConfig),
-                runWatch(lightConfig),
-                headlessConfig && runWatch(headlessConfig),
-            ]);
-        }
+    /* istanbul ignore next: debug only */
+    log.debug('custom-webpack-config', () => stringifyConfig(customConfig));
 
-        return Promise.all([
-            run(fullConfig),
-            run(lightConfig),
-            headlessConfig && run(headlessConfig),
-        ]);
+    if (isWebComponent()) {
+        return bundleWebComponent({ customConfig, mode, watch, webpackOptions });
     }
 
-    const [config] = createWebpackConfigs(options);
+    const config =
+        customConfig && !emitExposedDependencies
+            ? customConfig
+            : createWebpackConfig({ configuration: { mode } }, webpackOptions);
+
     if (watch) {
         return isDevServerDisabled() ? runWatch(config) : runServe(config);
     }
+
     return run(config);
 }
 
+function bundleWebComponent({
+    customConfig,
+    mode,
+    watch,
+    webpackOptions,
+}: {
+    customConfig: ReturnType<typeof readWebpackConfig>;
+    mode: 'development' | 'production';
+    watch?: boolean;
+    webpackOptions: ReturnType<typeof getWebpackOptions>;
+}) {
+    const overrides: Overrides = {
+        configuration: { ...customConfig?.configuration, mode },
+        plugins: customConfig?.plugins,
+    };
+
+    const fullConfig = createWebpackConfig(overrides, webpackOptions);
+    const lightConfig = createWebpackConfig(overrides, { ...webpackOptions, embed: true });
+    const headlessConfig = hasHeadlessBundle()
+        ? createWebpackConfig(overrides, {
+              ...webpackOptions,
+              headless: true,
+          })
+        : undefined;
+
+    const promises = watch
+        ? [
+              runWatch(lightConfig),
+              isDevServerDisabled() ? runWatch(fullConfig) : runServe(fullConfig),
+              headlessConfig && runWatch(headlessConfig),
+          ]
+        : [run(lightConfig), run(fullConfig), headlessConfig && run(headlessConfig)];
+
+    return Promise.all(promises.filter(promise => !!promise));
+}
+
+function getWebpackOptions(options: Options, customConfig?: Record<string, any>) {
+    const result = {
+        name: getName(),
+        ...pick(options, ['buildStat', 'codeCoverage', 'emitExposedDependencies']),
+    };
+
+    if (result.emitExposedDependencies && customConfig) {
+        result.emitExposedDependencies = { output: customConfig.output };
+    }
+
+    return result;
+}
+
+function readWebpackConfig({ config, fallback }: Options & { fallback: string }) {
+    return readConfig(config) ?? readConfig(fallback);
+}
+
+function readConfig(relativePath?: string): Record<string, any> | undefined {
+    if (relativePath && fs.existsSync(relativePath)) {
+        return require(path.resolve(relativePath));
+    }
+}
+
 async function run(config: Configuration) {
     const compiler = createWebpackCompiler(config);
 

package/src/cli/utils/cli-os.ts

@@ -74,7 +74,7 @@ export function runCommandOutput(
     const result = execSync(fullCommand, execSyncOptions).toString();
 
     if (!quiet) {
-        log.info('command finished', result);
+        log.info('command finished', result.trim());
     }
 
     return result;

package/src/index.ts

@@ -1,3 +1,2 @@
 export * from './utils/get-packages';
-export * from './vite/define-config';
 export * from './webpack';

package/src/storybook-config/__tests__/webpack-final.test.ts

@@ -1,6 +1,5 @@
 import type { Configuration } from 'webpack';
-import { rulesConfig } from '../../webpack/configs';
-import { Overrides } from '../../webpack/types';
+import { Overrides, rulesConfig } from '../../webpack/configs';
 import { miniCssExtractPlugin } from '../../webpack/configs/plugins';
 import { webpackFinal } from '../webpack-final';
 
@@ -92,9 +91,7 @@ describe(`[startup/storybook-config] ${webpackFinal.name}`, () => {
             subject();
 
             expect(rulesConfig).toHaveBeenCalledWith(
-                expect.objectContaining({
-                    build: expect.objectContaining({ isProduction: true }),
-                }),
+                expect.objectContaining({ isProduction: true }),
                 expect.anything()
             );
         });

package/src/storybook-config/webpack-final.ts

@@ -1,10 +1,8 @@
 import { inspect } from 'node:util';
 import type { Configuration } from 'webpack';
-import { BuildContext } from '../core';
 import { log } from '../utils';
-import { rulesConfig } from '../webpack/configs';
+import { Context, Overrides, rulesConfig } from '../webpack/configs';
 import { miniCssExtractPlugin } from '../webpack/configs/plugins';
-import { Overrides } from '../webpack/types';
 
 export function webpackFinal(config: Configuration, overrides: Overrides = {}): Configuration {
     const context = getContext(config);
@@ -24,34 +22,22 @@ export function webpackFinal(config: Configuration, overrides: Overrides = {}):
     };
 }
 
-function getContext(config: Configuration): BuildContext {
+function getContext(config: Configuration): Context {
     return {
-        package: {
-            name: '',
-            version: '',
-            destination: '',
-            source: '',
-            dependencies: {},
-            sharedDependencies: {},
-            isWebComponent: false,
-            isLegacyRoot: false,
-            isExposeSharedDependencies: false,
-        },
-        build: {
-            name: '',
-            isProduction: config.mode === 'production',
-        },
-        options: {
-            bundlerConfig: {},
-        },
+        destination: '',
+        isProduction: config.mode === 'production',
+        name: '',
+        packageData: {} as any,
+        sharedDependencies: {},
+        source: '',
     };
 }
 
-function getPlugins(context: BuildContext, overrides: Overrides) {
+function getPlugins(context: Context, overrides: Overrides) {
     return [miniCssExtractPlugin(context, overrides)].filter(plugin => !!plugin);
 }
 
-function getRules(context: BuildContext, overrides: Overrides) {
+function getRules(context: Context, overrides: Overrides) {
     const include = ['.module.css', '.module.less', '.less', '.module.scss', '.scss', '.svg'];
     const exclude = ['.css'];
 

package/src/utils/__tests__/get-configuration.test.ts

@@ -7,7 +7,6 @@ import {
     getJestConfiguration,
     getReviewConfiguration,
     getStylelintConfiguration,
-    getViteConfiguration,
     getVitestConfiguration,
     getWebComponentBranchConfigs,
     getWebComponentConfiguration,
@@ -20,8 +19,6 @@ import {
     isLegacyRoot,
     isStyleCheckDisabled,
     isWebComponent,
-    validateSharedDependenciesConsistency,
-    validateSharedDependenciesMigration,
 } from '../get-configuration';
 import { log } from '../log';
 
@@ -228,29 +225,6 @@ describe('[startup] Utils', () => {
         });
     });
 
-    describe(getViteConfiguration.name, () => {
-        const subject = () => getViteConfiguration();
-
-        itReturns(subject, {});
-
-        describe('with "cli.vite"', () => {
-            const content = {
-                cli: {
-                    vite: {
-                        omitDefault: ['plugins.svgr'],
-                        config: { server: { port: 9000 }, build: { minify: false } },
-                    },
-                },
-            };
-
-            beforeEach(() => mockPackageJson(content));
-
-            test('returns "cli.vite"', () => {
-                expect(subject()).toEqual(content.cli.vite);
-            });
-        });
-    });
-
     describe(getVitestConfiguration.name, () => {
         const subject = () => getVitestConfiguration();
 
@@ -433,10 +407,7 @@ describe('[startup] Utils', () => {
         {
             fn: isExposeSharedDependencies,
             defaultValue: false,
-            trigger: [
-                { cli: { 'expose-shared-dependencies': true } },
-                { cli: { webpack: { 'expose-shared-dependencies': true } } },
-            ],
+            trigger: { cli: { webpack: { 'expose-shared-dependencies': true } } },
         },
         {
             fn: isLegacy,
@@ -475,75 +446,6 @@ describe('[startup] Utils', () => {
         });
     });
 
-    describe(validateSharedDependenciesConsistency.name, () => {
-        test('passes when neither is set', () => {
-            expect(() => validateSharedDependenciesConsistency()).not.toThrow();
-        });
-
-        test('passes when only cli top level is set', () => {
-            mockPackageJson({ cli: { 'shared-dependencies': { defaults: '' } } });
-            expect(() => validateSharedDependenciesConsistency()).not.toThrow();
-        });
-
-        test('passes when only cli.webpack is set', () => {
-            mockPackageJson({ cli: { webpack: { 'shared-dependencies': { defaults: '' } } } });
-            expect(() => validateSharedDependenciesConsistency()).not.toThrow();
-        });
-
-        test('passes when both are set and identical', () => {
-            const deps = { defaults: '', lodash: 'SharedDependencies.Lodash' };
-            mockPackageJson({
-                cli: { 'shared-dependencies': deps, 'webpack': { 'shared-dependencies': deps } },
-            });
-            expect(() => validateSharedDependenciesConsistency()).not.toThrow();
-        });
-
-        test('throws when shared-dependencies both exist and differ', () => {
-            mockPackageJson({
-                cli: {
-                    'shared-dependencies': { defaults: '' },
-                    'webpack': { 'shared-dependencies': { defaults: '', extra: 'foo' } },
-                },
-            });
-            expect(() => validateSharedDependenciesConsistency()).toThrow(/both set but differ/);
-        });
-
-        test('throws when expose-shared-dependencies both exist and differ', () => {
-            mockPackageJson({
-                cli: {
-                    'expose-shared-dependencies': true,
-                    'webpack': { 'expose-shared-dependencies': false },
-                },
-            });
-            expect(() => validateSharedDependenciesConsistency()).toThrow(/both set but differ/);
-        });
-    });
-
-    describe(validateSharedDependenciesMigration.name, () => {
-        test('passes when neither is set', () => {
-            expect(() => validateSharedDependenciesMigration()).not.toThrow();
-        });
-
-        test('passes when only cli top level is set', () => {
-            mockPackageJson({ cli: { 'expose-shared-dependencies': true } });
-            expect(() => validateSharedDependenciesMigration()).not.toThrow();
-        });
-
-        test('throws when webpack shared-dependencies is set but top level is not', () => {
-            mockPackageJson({ cli: { webpack: { 'shared-dependencies': { defaults: '' } } } });
-            expect(() => validateSharedDependenciesMigration()).toThrow(
-                /Move your shared-dependencies/
-            );
-        });
-
-        test('throws when webpack expose-shared-dependencies is set but top level is not', () => {
-            mockPackageJson({ cli: { webpack: { 'expose-shared-dependencies': true } } });
-            expect(() => validateSharedDependenciesMigration()).toThrow(
-                /Move your expose-shared-dependencies/
-            );
-        });
-    });
-
     describe(isLegacy.name, () => {
         const trigger = { cli: { legacy: true } };
         let location: string | undefined;

package/src/utils/__tests__/get-package-data.test.ts

@@ -32,7 +32,7 @@ describe(`[startup] Utils`, () => {
             });
         });
 
-        describe(`when ${packageJson} contains sharedDependencies in cli.webpack`, () => {
+        describe(`when ${packageJson} contains sharedDependencies`, () => {
             const sharedDependencies = { react: 'SharedDependencies.React' };
 
             beforeEach(() => {
@@ -45,40 +45,6 @@ describe(`[startup] Utils`, () => {
                 expect(subject()).toEqual(expect.objectContaining({ sharedDependencies }));
             });
         });
-
-        describe(`when ${packageJson} contains sharedDependencies in cli top level`, () => {
-            const sharedDependencies = { mobx: 'SharedDependencies.MobX' };
-
-            beforeEach(() => {
-                Object.assign(packages[packageJson], {
-                    cli: { 'shared-dependencies': sharedDependencies },
-                });
-            });
-
-            test('returns sharedDependencies from cli top level', () => {
-                expect(subject()).toEqual(expect.objectContaining({ sharedDependencies }));
-            });
-        });
-
-        describe(`when ${packageJson} contains sharedDependencies in both locations`, () => {
-            const topLevel = { react: 'SharedDependencies.React' };
-            const webpack = { mobx: 'SharedDependencies.MobX' };
-
-            beforeEach(() => {
-                Object.assign(packages[packageJson], {
-                    cli: {
-                        'shared-dependencies': topLevel,
-                        'webpack': { 'shared-dependencies': webpack },
-                    },
-                });
-            });
-
-            test('prefers cli top level', () => {
-                expect(subject()).toEqual(
-                    expect.objectContaining({ sharedDependencies: topLevel })
-                );
-            });
-        });
     });
 
     describe(`${getPackageDependencyVersion.name}`, () => {

package/src/utils/get-configuration.ts

@@ -38,7 +38,6 @@ export interface WebpackConfiguration extends Omit<
     'disable-style-check'?: boolean;
     'minify'?: MinifyOptions;
     'proxy'?: WebpackDevServerConfiguration['proxy'] | string;
-    'shared-dependencies'?: Record<string, string>;
 }
 
 export interface ESLintConfiguration extends ESLint.Options {
@@ -63,7 +62,6 @@ export interface NodeConfiguration {
 export enum CommandName {
     'build' = 'build',
     'bundle-package' = 'bundle-package',
-    'bundle-vite' = 'bundle-vite',
     'clean' = 'clean',
     'convert-eslint-config' = 'convert-eslint-config',
     'eslint' = 'eslint',
@@ -78,6 +76,7 @@ export enum CommandName {
     'mfe-package-publish' = 'mfe-package-publish',
     'mfe-package-rollback' = 'mfe-package-rollback',
     'mfe-publish' = 'mfe-publish',
+    'mfe-purge-cache' = 'mfe-purge-cache',
     'prepare-package' = 'prepare-package',
     'review' = 'review',
     'start' = 'start',
@@ -93,30 +92,6 @@ export type VitestConfiguration = ViteUserConfig['test'] & {
     omitDefault?: string[];
 };
 
-export interface HtmlTemplatePluginOptions {
-    title?: string;
-    favicon?: string;
-    template?: string;
-}
-
-export interface SvgrPluginOptions {
-    include?: string | RegExp | (string | RegExp)[];
-    exclude?: string | RegExp | (string | RegExp)[];
-    svgrOptions?: Record<string, any>;
-}
-
-export interface PluginOverrides {
-    htmlTemplate?: HtmlTemplatePluginOptions;
-    svgr?: SvgrPluginOptions;
-}
-
-export interface ViteConfiguration {
-    omitDefault?: string[];
-    minify?: MinifyOptions;
-    pluginOverrides?: PluginOverrides;
-    config?: Omit<import('vite').UserConfig, 'plugins'>;
-}
-
 export interface WebComponentBranchConfigs {
     publishTag?: string;
     uploadSourcemaps?: boolean;
@@ -139,9 +114,6 @@ type Configuration = {
     'swc-compile-package'?: Parameters<typeof swcDir>[0];
     'test'?: JestConfiguration; // for backward-compatibility
     'testRunner'?: string;
-    'expose-shared-dependencies'?: boolean;
-    'shared-dependencies'?: Record<string, string>;
-    'vite'?: ViteConfiguration;
     'vitest'?: VitestConfiguration;
     'web-component'?: boolean | string | WebComponentOptions;
     'webpack'?: false | WebpackConfiguration;
@@ -184,10 +156,6 @@ export function getStylelintConfiguration() {
     return getConfiguration().lint?.stylelint ?? {};
 }
 
-export function getViteConfiguration(): ViteConfiguration {
-    return getConfiguration().vite ?? {};
-}
-
 export function getVitestConfiguration() {
     return getConfiguration().vitest ?? {};
 }
@@ -258,65 +226,7 @@ export function isDevServerDisabled() {
 }
 
 export function isExposeSharedDependencies() {
-    return (
-        (getConfiguration()['expose-shared-dependencies'] ??
-            getWebpackConfiguration()['expose-shared-dependencies']) === true
-    );
-}
-
-export function validateSharedDependenciesConsistency() {
-    const config = getConfiguration();
-    const webpackSharedDependencies = getWebpackConfiguration()['shared-dependencies'];
-    const topLevelSharedDependencies = config['shared-dependencies'];
-
-    if (
-        webpackSharedDependencies &&
-        topLevelSharedDependencies &&
-        JSON.stringify(webpackSharedDependencies) !== JSON.stringify(topLevelSharedDependencies)
-    ) {
-        throw new Error(
-            'cli.shared-dependencies and cli.webpack.shared-dependencies are both set but differ. ' +
-                'Remove cli.webpack.shared-dependencies and use cli.shared-dependencies only.'
-        );
-    }
-
-    const webpackExpose = getWebpackConfiguration()['expose-shared-dependencies'];
-    const topLevelExpose = config['expose-shared-dependencies'];
-
-    if (
-        webpackExpose !== undefined &&
-        topLevelExpose !== undefined &&
-        webpackExpose !== topLevelExpose
-    ) {
-        throw new Error(
-            'cli.expose-shared-dependencies and cli.webpack.expose-shared-dependencies are both set but differ. ' +
-                'Remove cli.webpack.expose-shared-dependencies and use cli.expose-shared-dependencies only.'
-        );
-    }
-}
-
-export function validateSharedDependenciesMigration() {
-    const config = getConfiguration();
-    const webpackSharedDependencies = getWebpackConfiguration()['shared-dependencies'];
-    const topLevelSharedDependencies = config['shared-dependencies'];
-
-    if (webpackSharedDependencies && !topLevelSharedDependencies) {
-        throw new Error(
-            'cli.webpack.shared-dependencies is set but cli.shared-dependencies is not. ' +
-                'Vite reads shared-dependencies from cli top level. ' +
-                'Move your shared-dependencies config from cli.webpack to cli.'
-        );
-    }
-
-    const webpackExpose = getWebpackConfiguration()['expose-shared-dependencies'];
-    const topLevelExpose = config['expose-shared-dependencies'];
-
-    if (webpackExpose !== undefined && topLevelExpose === undefined) {
-        throw new Error(
-            'cli.webpack.expose-shared-dependencies is set but cli.expose-shared-dependencies is not. ' +
-                'Move your expose-shared-dependencies config from cli.webpack to cli.'
-        );
-    }
+    return getWebpackConfiguration()['expose-shared-dependencies'] === true;
 }
 
 export function isLegacy(locationOrJson?: LocationOrJson) {

package/src/utils/get-package-data.ts

@@ -17,9 +17,7 @@ export function getPackageData(): PackageData {
             ...readJson('../../package.json').dependencies,
             ...packageJson.dependencies,
         },
-        sharedDependencies:
-            packageJson.cli?.['shared-dependencies'] ??
-            packageJson.cli?.webpack?.['shared-dependencies'],
+        sharedDependencies: packageJson.cli?.webpack?.['shared-dependencies'],
     };
 }
 

package/src/webpack/__tests__/create-webpack-config-shared-dependencies.test.ts

@@ -10,7 +10,6 @@ import { WebpackAssetsManifest } from 'webpack-assets-manifest';
 import RemoveEmptyScriptsPlugin from 'webpack-remove-empty-scripts';
 import VirtualModulesPlugin from 'webpack-virtual-modules';
 import yargs from 'yargs';
-import { getLaunchDarklySdkVersion } from '../../core';
 import {
     getFolders,
     getPackageData,
@@ -24,6 +23,7 @@ import {
     pick,
 } from '../../utils';
 import { miniCssPluginStyleRules } from '../__mocks__';
+import { getLaunchDarklySdkVersion } from '../configs/utils/get-launchdarkly-sdk-version';
 import { createWebpackConfig } from '../index';
 import { getModuleEntryPath } from '../utils';
 
@@ -53,7 +53,7 @@ jest.mock('../../utils', () => ({
     isExposeSharedDependencies: jest.fn(),
     loadSharedDependencies: jest.fn(),
 }));
-jest.mock('../../core/utils/get-launchdarkly-sdk-version');
+jest.mock('../configs/utils/get-launchdarkly-sdk-version');
 jest.mock('../utils', () => ({
     ...jest.requireActual('../utils'),
     getCallerFile: jest.fn(),

package/src/webpack/__tests__/create-webpack-config-web-component.test.ts

@@ -6,7 +6,7 @@ import { DefinePlugin } from 'webpack';
 import { WebpackAssetsManifest } from 'webpack-assets-manifest';
 import VirtualModulesPlugin from 'webpack-virtual-modules';
 import yargs from 'yargs';
-import { generateMetadata } from '../../core';
+import { webpackDevConfigFileName, webpackProdConfigFileName } from '../../cli/utils';
 import {
     getFolders,
     getPackageData,
@@ -16,7 +16,7 @@ import {
     isWebComponent,
 } from '../../utils';
 import { miniCssPluginStyleRules } from '../__mocks__';
-import { webpackDevConfigFileName, webpackProdConfigFileName } from '../create-webpack-config';
+import { generateMetadata } from '../configs/utils';
 import { createWebpackConfig } from '../index';
 import { getCallerFile, splitByEntry } from '../utils';
 
@@ -42,7 +42,7 @@ jest.mock('../../utils', () => ({
     isLegacyRoot: jest.fn(),
     isWebComponent: jest.fn(),
 }));
-jest.mock('../../core/utils/generate-metadata');
+jest.mock('../configs/utils/generate-metadata');
 jest.mock('../utils', () => ({
     ...jest.requireActual('../utils'),
     getCallerFile: jest.fn(),
@@ -64,15 +64,15 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
 
     const indexPath = () => path.join(process.cwd(), `${destination}/index`);
     const indexCode = ({
-        light = false,
+        embed = false,
         legacyRoot = false,
         designSystem,
-    }: { light?: boolean; legacyRoot?: boolean; designSystem?: boolean } = {}) =>
+    }: { embed?: boolean; legacyRoot?: boolean; designSystem?: boolean } = {}) =>
         [
             ...(designSystem ? [`require('./design-system.css');`] : []),
             `import { register } from '@servicetitan/web-components';`,
             `import { App } from './app';`,
-            `register(App, ${light}, { legacyRoot: ${legacyRoot}, sharedDependenciesNames: ${JSON.stringify(Object.keys(sharedDependencies))} });`,
+            `register(App, ${embed}, { legacyRoot: ${legacyRoot}, sharedDependenciesNames: ${JSON.stringify(Object.keys(sharedDependencies))} });`,
         ].join('\n');
 
     let overrides: Parameters<typeof createWebpackConfig>[0];
@@ -331,13 +331,13 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             });
         });
 
-        describe('when light option is set to true', () => {
-            beforeEach(() => (options.light = true));
+        describe('when embed option is set to true', () => {
+            beforeEach(() => (options.embed = true));
 
-            test(`omits design system and registers App with light set to true`, () => {
+            test(`omits design system and registers App with embed set to true`, () => {
                 expect(subject().plugins).toContainEqual(
                     new VirtualModulesPlugin({
-                        [indexPath()]: indexCode({ designSystem: false, light: true }),
+                        [indexPath()]: indexCode({ designSystem: false, embed: true }),
                     })
                 );
             });
@@ -366,7 +366,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                     expect(subject().plugins).toContainEqual(
                         new VirtualModulesPlugin({
                             [designSystemPath()]: designSystemCode,
-                            [indexPath()]: indexCode({ designSystem: true, light: true }),
+                            [indexPath()]: indexCode({ designSystem: true, embed: true }),
                         })
                     );
                 });