@servicetitan/startup 34.2.1 → 34.3.0-beta.0

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 { webpackDevConfigFileName, webpackProdConfigFileName } from '../../cli/utils';
+import { generateMetadata } from '../../core';
 import {
     getFolders,
     getPackageData,
@@ -16,7 +16,7 @@ import {
     isWebComponent,
 } from '../../utils';
 import { miniCssPluginStyleRules } from '../__mocks__';
-import { generateMetadata } from '../configs/utils';
+import { webpackDevConfigFileName, webpackProdConfigFileName } from '../create-webpack-config';
 import { createWebpackConfig } from '../index';
 import { getCallerFile, splitByEntry } from '../utils';
 
@@ -42,7 +42,7 @@ jest.mock('../../utils', () => ({
     isLegacyRoot: jest.fn(),
     isWebComponent: jest.fn(),
 }));
-jest.mock('../configs/utils/generate-metadata');
+jest.mock('../../core/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 = ({
-        embed = false,
+        light = false,
         legacyRoot = false,
         designSystem,
-    }: { embed?: boolean; legacyRoot?: boolean; designSystem?: boolean } = {}) =>
+    }: { light?: boolean; legacyRoot?: boolean; designSystem?: boolean } = {}) =>
         [
             ...(designSystem ? [`require('./design-system.css');`] : []),
             `import { register } from '@servicetitan/web-components';`,
             `import { App } from './app';`,
-            `register(App, ${embed}, { legacyRoot: ${legacyRoot}, sharedDependenciesNames: ${JSON.stringify(Object.keys(sharedDependencies))} });`,
+            `register(App, ${light}, { 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 embed option is set to true', () => {
-            beforeEach(() => (options.embed = true));
+        describe('when light option is set to true', () => {
+            beforeEach(() => (options.light = true));
 
-            test(`omits design system and registers App with embed set to true`, () => {
+            test(`omits design system and registers App with light set to true`, () => {
                 expect(subject().plugins).toContainEqual(
                     new VirtualModulesPlugin({
-                        [indexPath()]: indexCode({ designSystem: false, embed: true }),
+                        [indexPath()]: indexCode({ designSystem: false, light: true }),
                     })
                 );
             });
@@ -366,7 +366,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                     expect(subject().plugins).toContainEqual(
                         new VirtualModulesPlugin({
                             [designSystemPath()]: designSystemCode,
-                            [indexPath()]: indexCode({ designSystem: true, embed: true }),
+                            [indexPath()]: indexCode({ designSystem: true, light: true }),
                         })
                     );
                 });

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

@@ -108,6 +108,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         argv = {};
         packages = [];
         overrides = {
+            configuration: { mode: 'development' },
             plugins: {
                 HtmlWebpackPlugin: { favicon: 'foo' },
                 MiniCssExtractPlugin: { attributes: { foo: 'bar' } },
@@ -526,8 +527,8 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                 );
             });
 
-            describe('when embed option is set to true', () => {
-                beforeEach(() => setOptions({ embed: true }));
+            describe('when light option is set to true', () => {
+                beforeEach(() => setOptions({ light: true }));
 
                 test('adds "light" to reportFilename and reportTitle', () => {
                     expect(subject().plugins).toContainEqual(

package/src/webpack/configs/amd-config.ts

@@ -1,8 +1,9 @@
 import { Configuration } from 'webpack';
-import { Context, Overrides } from './types';
+import { BuildContext } from '../../core';
+import { Overrides } from '../types';
 
 type Result = Pick<Configuration, 'amd'>;
 
-export function amdConfig(_context: Context, _: Overrides): Result {
+export function amdConfig(_context: BuildContext, _: Overrides): Result {
     return { amd: false };
 }

package/src/webpack/configs/cache-config.ts

@@ -1,16 +1,17 @@
 import fs from 'fs';
 import path from 'path';
 import { Configuration } from 'webpack';
+import { BuildContext } from '../../core';
 import { findUp } from '../../utils';
-import { Context, Overrides } from './types';
+import { Overrides } from '../types';
 
 type Config = Configuration['cache'];
 type Result = Pick<Configuration, 'cache' | 'infrastructureLogging'> | undefined;
 
 const CACHE_VERSION = '1';
 
-export function cacheConfig(context: Context, _overrides: Overrides): Result {
-    const { emitExposedDependencies } = context;
+export function cacheConfig(context: BuildContext, _overrides: Overrides): Result {
+    const { emitExposedDependencies } = context.options.bundlerConfig;
     if (!emitExposedDependencies) {
         return;
     }

package/src/webpack/configs/dev-server-config.ts

@@ -1,6 +1,7 @@
 import fs from 'fs';
 import path from 'path';
 import { Configuration } from 'webpack';
+import { BuildContext } from '../../core';
 import {
     allowedWebpackDevServerOptions,
     getWebpackConfiguration,
@@ -8,14 +9,18 @@ import {
     log,
     pick,
 } from '../../utils';
+import { Overrides } from '../types';
 import { statsConfig } from './stats-config';
-import { Context, Overrides } from './types';
 
 type DevServerConfig = NonNullable<Configuration['devServer']>;
 type Result = Pick<Configuration, 'devServer'> | undefined;
 
-export function devServerConfig(context: Context, overrides: Overrides): Result {
-    if (context.isProduction || context.emitExposedDependencies || isDevServerDisabled()) {
+export function devServerConfig(context: BuildContext, overrides: Overrides): Result {
+    if (
+        context.build.isProduction ||
+        context.options.bundlerConfig.emitExposedDependencies ||
+        isDevServerDisabled()
+    ) {
         return;
     }
 

package/src/webpack/configs/devtool-config.ts

@@ -1,11 +1,12 @@
 import { Configuration } from 'webpack';
-import { Context, Overrides } from './types';
+import { BuildContext } from '../../core';
+import { Overrides } from '../types';
 
 type Config = Configuration['devtool'];
 type Result = Pick<Configuration, 'devtool'>;
 
-export function devtoolConfig(context: Context, _: Overrides): Result {
-    const { isProduction } = context;
+export function devtoolConfig(context: BuildContext, _: Overrides): Result {
+    const { isProduction } = context.build;
     let devtool: Config;
 
     if (isProduction) {

package/src/webpack/configs/entry.config.ts

@@ -1,29 +1,30 @@
 import fs from 'fs';
 import { Configuration } from 'webpack';
+import { BuildContext, getDesignSystemPath } from '../../core';
+import { Overrides } from '../types';
 import { getModuleEntryPath } from '../utils';
-import { getDesignSystemPath } from './plugins';
-import { Context, Overrides } from './types';
 
 type Config = Configuration['entry'];
 type Result = Pick<Configuration, 'entry'>;
 
-export function entryConfig(context: Context, _: Overrides): Result {
-    const entry: Config = context.emitExposedDependencies
+export function entryConfig(context: BuildContext, _: Overrides): Result {
+    const entry: Config = context.options.bundlerConfig.emitExposedDependencies
         ? getSharedEntryPoints(context)
         : getIndexEntryPoint(context);
 
     return { entry };
 }
 
-function getIndexEntryPoint({ source, destination }: Context): Config {
+function getIndexEntryPoint(context: BuildContext): Config {
+    const { source, destination } = context.package;
     const index = fs.existsSync(`./${source}/index.js`)
         ? `./${source}/index`
         : `./${destination}/index`;
     return { main: [index] };
 }
 
-function getSharedEntryPoints(context: Context): Config {
-    const { sharedDependencies } = context;
+function getSharedEntryPoints(context: BuildContext): Config {
+    const { sharedDependencies } = context.package;
     return {
         shared: Object.keys(sharedDependencies).map(getModuleEntryPath),
         ...(sharedDependencies['@servicetitan/design-system']

package/src/webpack/configs/externals-config.ts

@@ -1,26 +1,10 @@
 import { Configuration } from 'webpack';
-import { Context, Overrides } from './types';
+import { BuildContext, getExternalsMapping } from '../../core';
+import { Overrides } from '../types';
 
-type Config = Configuration['externals'];
 type Result = Pick<Configuration, 'externals'> | undefined;
 
-export function externalsConfig(context: Context, _: Overrides): Result {
-    if (!needsExternals(context)) {
-        return;
-    }
-
-    const { sharedDependencies } = context;
-    const name = context.name || context.packageData.name;
-    const externals: Config = Object.fromEntries(
-        Object.entries(sharedDependencies).map(([dependency, variable]) => [
-            dependency,
-            `${variable}['${name}']`,
-        ])
-    );
-
-    return { externals };
-}
-
-function needsExternals({ embed, emitExposedDependencies, isExposeSharedDependencies }: Context) {
-    return !!embed || (isExposeSharedDependencies && !emitExposedDependencies);
+export function externalsConfig(context: BuildContext, _: Overrides): Result {
+    const externals = getExternalsMapping(context);
+    return externals ? { externals } : undefined;
 }

package/src/webpack/configs/index.ts

@@ -11,5 +11,4 @@ export * from './plugins-config';
 export * from './resolve-config';
 export * from './rules-config';
 export * from './stats-config';
-export type * from './types';
 export * from './watch-options-config';

package/src/webpack/configs/loaders/css-loader.ts

@@ -1,7 +1,8 @@
-import { Context } from '../types';
+import { BuildContext } from '../../../core';
 import { LoaderOptions } from './types';
 
-export function cssLoader({ isProduction }: Context, { esModule }: LoaderOptions = {}) {
+export function cssLoader(context: BuildContext, { esModule }: LoaderOptions = {}) {
+    const { isProduction } = context.build;
     const loader = 'css-loader';
     return esModule
         ? {

package/src/webpack/configs/loaders/style-loader.ts

@@ -1,11 +1,11 @@
 import MiniCssExtractPlugin from 'mini-css-extract-plugin';
-import { Context } from '../types';
+import { BuildContext } from '../../../core';
 import { LoaderOptions } from './types';
 
-export function styleLoader(
-    { isProduction, isWebComponent, emitExposedDependencies }: Context,
-    { esModule }: LoaderOptions = {}
-) {
+export function styleLoader(context: BuildContext, { esModule }: LoaderOptions = {}) {
+    const { isProduction } = context.build;
+    const { isWebComponent } = context.package;
+    const { emitExposedDependencies } = context.options.bundlerConfig;
     const loader =
         isProduction || isWebComponent || emitExposedDependencies
             ? MiniCssExtractPlugin.loader

package/src/webpack/configs/module-config.ts

@@ -1,11 +1,12 @@
 import { Configuration } from 'webpack';
+import { BuildContext } from '../../core';
+import { Overrides } from '../types';
 import { rulesConfig } from './rules-config';
-import { Context, Overrides } from './types';
 
 type Config = Configuration['module'];
 type Result = Pick<Configuration, 'module'>;
 
-export function moduleConfig(context: Context, overrides: Overrides): Result {
+export function moduleConfig(context: BuildContext, overrides: Overrides): Result {
     const module: Config = { ...rulesConfig(context, overrides) };
 
     return { module };

package/src/webpack/configs/optimization-config.ts

@@ -1,14 +1,16 @@
 import CssMinimizerWebpackPlugin from 'css-minimizer-webpack-plugin';
 import TerserPlugin from 'terser-webpack-plugin';
 import { Configuration } from 'webpack';
-import { Context, Overrides } from './types';
+import { BuildContext } from '../../core';
+import { Overrides } from '../types';
 
 type Config = Configuration['optimization'];
 type ConfigWithCacheGroups = Config & { splitChunks: { cacheGroups: Record<string, any> } };
 type Result = Pick<Configuration, 'optimization'>;
 
-export function optimizationConfig(context: Context, _: Overrides): Result {
-    const { emitExposedDependencies, headless, isProduction } = context;
+export function optimizationConfig(context: BuildContext, _: Overrides): Result {
+    const { headless, isProduction } = context.build;
+    const { emitExposedDependencies } = context.options.bundlerConfig;
 
     const optimization: ConfigWithCacheGroups = {
         chunkIds: isProduction ? 'deterministic' : 'named',
@@ -30,14 +32,16 @@ export function optimizationConfig(context: Context, _: Overrides): Result {
     return { optimization };
 }
 
-function minimizeConfig(optimization: ConfigWithCacheGroups, context: Context) {
-    const { isProduction, codeCoverage } = context;
+function minimizeConfig(optimization: ConfigWithCacheGroups, context: BuildContext) {
+    const { isProduction } = context.build;
+    const { codeCoverage } = context.options;
+    const { minify } = context.options.bundlerConfig;
     if (!isProduction) {
         return;
     }
 
-    const minifyJs = context.minify?.js ?? true;
-    const minifyCss = context.minify?.css ?? true;
+    const minifyJs = minify?.js ?? true;
+    const minifyCss = minify?.css ?? true;
     optimization.minimize = !codeCoverage && (!!minifyJs || !!minifyCss);
     if (!optimization.minimize) {
         return;
@@ -59,8 +63,8 @@ function minimizeConfig(optimization: ConfigWithCacheGroups, context: Context) {
     ];
 }
 
-function sharedDependenciesConfig(optimization: ConfigWithCacheGroups, context: Context) {
-    const { emitExposedDependencies } = context;
+function sharedDependenciesConfig(optimization: ConfigWithCacheGroups, context: BuildContext) {
+    const { emitExposedDependencies } = context.options.bundlerConfig;
     if (!emitExposedDependencies) {
         return;
     }
@@ -75,8 +79,9 @@ function sharedDependenciesConfig(optimization: ConfigWithCacheGroups, context:
     });
 }
 
-function webComponentConfig(optimization: ConfigWithCacheGroups, context: Context) {
-    const { headless, isWebComponent, isProduction } = context;
+function webComponentConfig(optimization: ConfigWithCacheGroups, context: BuildContext) {
+    const { headless, isProduction } = context.build;
+    const { isWebComponent } = context.package;
     if (!isWebComponent || headless) {
         return;
     }

package/src/webpack/configs/output-config.ts

@@ -1,18 +1,20 @@
-import path from 'path';
 import { Configuration } from 'webpack';
-import { Context, Overrides } from './types';
-import { getBundleType } from './utils';
+import { BuildContext, getBundleType, getOutputPath } from '../../core';
+import { Overrides } from '../types';
 
 type Config = Configuration['output'];
 type Result = Pick<Configuration, 'output'>;
 
-export function outputConfig(context: Context, _: Overrides): Result {
-    const { emitExposedDependencies, isProduction, isWebComponent, name } = context;
+export function outputConfig(context: BuildContext, _: Overrides): Result {
+    const { name, isProduction } = context.build;
+    const { isWebComponent } = context.package;
+    const { emitExposedDependencies } = context.options.bundlerConfig;
 
     const output: Config = {
         filename: '[name].bundle.js',
         path: getOutputPath(context),
         clean: getClean(context),
+        // TODO: ask Dexter about chunkLoadingGlobal and whether it's expected that we pass empty name here
         ...(emitExposedDependencies ? { chunkLoadingGlobal: `sharedChunk${name}` } : {}),
     };
 
@@ -28,25 +30,17 @@ export function outputConfig(context: Context, _: Overrides): Result {
     return { output };
 }
 
-function getClean(context: Context): NonNullable<Config>['clean'] {
-    const { emitExposedDependencies } = context;
+function getClean(context: BuildContext): NonNullable<Config>['clean'] {
+    const { emitExposedDependencies } = context.options.bundlerConfig;
     if (emitExposedDependencies) {
         return true;
     }
-    const exposedDependenciesDir = getBundleType({ ...context, emitExposedDependencies: true });
+    const exposedDependenciesDir = getBundleType({
+        ...context,
+        options: {
+            ...context.options,
+            bundlerConfig: { ...context.options.bundlerConfig, emitExposedDependencies: true },
+        },
+    });
     return exposedDependenciesDir ? { keep: new RegExp(exposedDependenciesDir) } : true;
 }
-
-function getOutputPath(context: Context) {
-    const { destination, emitExposedDependencies } = context;
-
-    const subdir = getBundleType(context) ?? '';
-    if (typeof emitExposedDependencies === 'object') {
-        const { output } = emitExposedDependencies;
-        if (output?.path) {
-            return path.join(output.path, subdir);
-        }
-    }
-
-    return path.join(process.cwd(), destination, 'bundle', subdir);
-}

package/src/webpack/configs/plugins/assets-manifest-plugin.ts

@@ -1,21 +1,17 @@
-import fs from 'fs';
-import path from 'path';
 import { WebpackAssetsManifest } from 'webpack-assets-manifest';
-import { readJsonSafe } from '../../../utils';
-import { Context, Overrides } from '../types';
-import { generateMetadata } from '../utils';
-
-interface Metadata {
-    entryPointsPath: string;
-}
+import { BuildContext, generateExposedDependenciesMetadata, generateMetadata } from '../../../core';
+import { Overrides } from '../../types';
 
 interface EntryPoints {
     css: string[];
     js: string[];
 }
 
-export function assetsManifestPlugin(context: Context, _: Overrides) {
-    if (!(context.isWebComponent || context.emitExposedDependencies)) {
+export function assetsManifestPlugin(context: BuildContext, _: Overrides) {
+    const { isWebComponent } = context.package;
+    const { emitExposedDependencies } = context.options.bundlerConfig;
+
+    if (!(isWebComponent || emitExposedDependencies)) {
         return;
     }
 
@@ -38,8 +34,8 @@ export function assetsManifestPlugin(context: Context, _: Overrides) {
         },
         // eslint-disable-next-line @typescript-eslint/require-await
         done: async (manifest: WebpackAssetsManifest) => {
-            if (context.emitExposedDependencies) {
-                generateExposedDependenciesMetadata(context, manifest);
+            if (emitExposedDependencies) {
+                generateExposedDependenciesMetadata(context, () => manifest.getOutputPath());
             } else {
                 generateMetadata(context);
             }
@@ -53,26 +49,3 @@ function ensureDesignSystemCssIsFirst(cssAssets: string[]) {
         ? [cssAssets[offset], ...cssAssets.filter((_, index) => index !== offset)]
         : cssAssets;
 }
-
-export function getExposedDependenciesEntryPoints(context: Context) {
-    const metadataPath = getExposedDependenciesMetadataPath(context);
-    const metadata = readJsonSafe<Metadata>(metadataPath);
-    if (metadata?.entryPointsPath) {
-        return readJsonSafe<EntryPoints>(metadata.entryPointsPath);
-    }
-}
-
-function generateExposedDependenciesMetadata(context: Context, manifest: WebpackAssetsManifest) {
-    const { destination } = context;
-    if (!fs.existsSync(destination)) {
-        fs.mkdirSync(destination, { recursive: true });
-    }
-
-    const metadataPath = getExposedDependenciesMetadataPath(context);
-    const metadata: Metadata = { entryPointsPath: manifest.getOutputPath() };
-    fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), 'utf-8');
-}
-
-function getExposedDependenciesMetadataPath({ destination }: Context) {
-    return path.join(destination, 'exposed-dependencies-metadata.json');
-}

package/src/webpack/configs/plugins/bundle-analyser-plugin.ts

@@ -1,11 +1,11 @@
 import os from 'os';
 import path from 'path';
-import { Context, Overrides } from '../types';
-import { getBundleType } from '../utils';
+import { BuildContext, getBundleType } from '../../../core';
+import { Overrides } from '../../types';
 const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
 
-export function bundleAnalyzerPlugin(context: Context, _: Overrides) {
-    if (!context.buildStat) {
+export function bundleAnalyzerPlugin(context: BuildContext, _: Overrides) {
+    if (!context.options.buildStat) {
         return;
     }
 
@@ -16,14 +16,14 @@ export function bundleAnalyzerPlugin(context: Context, _: Overrides) {
     });
 }
 
-function getReportFileName(context: Context) {
+function getReportFileName(context: BuildContext) {
     const type = getBundleType(context);
     const qualifier = type ? `-${type}` : '';
-    return `${context.packageData.name}${qualifier}-bundle-${Date.now()}.html`;
+    return `${context.package.name}${qualifier}-bundle-${Date.now()}.html`;
 }
 
-function getReportTitle(context: Context) {
-    const unscopedName = context.packageData.name.replace(/^@[^/]+\//, '');
+function getReportTitle(context: BuildContext) {
+    const unscopedName = context.package.name.replace(/^@[^/]+\//, '');
     const type = getBundleType(context);
     const qualifier = type ? ` (${type})` : '';
     return `${unscopedName}${qualifier} ${formatDate(new Date())}`;

package/src/webpack/configs/plugins/define-exposed-dependencies-plugin.ts

@@ -1,21 +1,13 @@
 import { DefinePlugin } from 'webpack';
-import { getPackageDependencyVersion } from '../../../utils';
-import { Context, Overrides } from '../types';
-import { getExposedDependencies } from '../utils';
+import { BuildContext, defineExposedDependencies } from '../../../core';
+import { Overrides } from '../../types';
 
-export function defineExposedDependenciesPlugin(context: Context, _: Overrides) {
-    const { emitExposedDependencies, isExposeSharedDependencies } = context;
-    if (!isExposeSharedDependencies || emitExposedDependencies) {
+export function defineExposedDependenciesPlugin(context: BuildContext, _: Overrides) {
+    const definition = defineExposedDependencies(context);
+
+    if (!definition) {
         return;
     }
 
-    const { packageData, sharedDependencies } = context;
-    const exposedDependencies = getExposedDependencies(sharedDependencies, dependency =>
-        getPackageDependencyVersion(dependency, packageData.dependencies?.[dependency])
-    );
-
-    return new DefinePlugin({
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        EXPOSED_DEPENDENCIES: JSON.stringify(exposedDependencies),
-    });
+    return new DefinePlugin(definition);
 }

package/src/webpack/configs/plugins/define-exposed-instance-dependencies-plugin.ts

@@ -1,19 +1,13 @@
 import { DefinePlugin } from 'webpack';
-import { Context, Overrides } from '../types';
-import { getLaunchDarklySdkVersion } from '../utils/get-launchdarkly-sdk-version';
+import { BuildContext, defineExposedInstanceDependencies } from '../../../core';
+import { Overrides } from '../../types';
 
-export function defineExposedInstanceDependenciesPlugin(context: Context, _: Overrides) {
-    const { emitExposedDependencies, isExposeSharedDependencies } = context;
-    if (!isExposeSharedDependencies || emitExposedDependencies) {
+export function defineExposedInstanceDependenciesPlugin(context: BuildContext, _: Overrides) {
+    const definition = defineExposedInstanceDependencies(context);
+
+    if (!definition) {
         return;
     }
 
-    const instanceDependencies = {
-        launchDarkly: { version: getLaunchDarklySdkVersion() },
-    };
-
-    return new DefinePlugin({
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        EXPOSED_INSTANCE_DEPENDENCIES: JSON.stringify(instanceDependencies),
-    });
+    return new DefinePlugin(definition);
 }

package/src/webpack/configs/plugins/define-web-component-name-plugin.ts

@@ -1,14 +1,13 @@
 import { DefinePlugin } from 'webpack';
-import { Context, Overrides } from '../types';
+import { BuildContext, defineWebComponentName } from '../../../core';
+import { Overrides } from '../../types';
 
-export function defineWebComponentNamePlugin(context: Context, _: Overrides) {
-    const { isWebComponent, name } = context;
-    if (!isWebComponent) {
+export function defineWebComponentNamePlugin(context: BuildContext, _: Overrides) {
+    const definition = defineWebComponentName(context);
+
+    if (!definition) {
         return;
     }
 
-    return new DefinePlugin({
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        WEB_COMPONENT_NAME: JSON.stringify(name),
-    });
+    return new DefinePlugin(definition);
 }

package/src/webpack/configs/plugins/filter-warnings-plugin.ts

@@ -1,8 +1,9 @@
 const FilterWarningsPlugin = require('webpack-filter-warnings-plugin');
-import { Context, Overrides } from '../types';
+import { BuildContext } from '../../../core';
+import { Overrides } from '../../types';
 
-export function filterWarningsPlugin({ embed }: Context, _: Overrides) {
-    if (embed) {
+export function filterWarningsPlugin(context: BuildContext, _: Overrides) {
+    if (context.build.light) {
         return;
     }
 

package/src/webpack/configs/plugins/html-plugin.ts

@@ -1,15 +1,16 @@
 import deepmerge from 'deepmerge';
 import HtmlWebpackPlugin, { Options as HtmlWebpackPluginOptions } from 'html-webpack-plugin';
+import { BuildContext } from '../../../core';
+import { Overrides } from '../../types';
 import { splitByEntry } from '../../utils';
-import { Context, Overrides } from '../types';
 
-export function htmlPlugin(
-    { embed, emitExposedDependencies, headless, isWebComponent, name }: Context,
-    { plugins }: Overrides
-) {
+export function htmlPlugin(context: BuildContext, { plugins }: Overrides) {
+    const { light, headless, name } = context.build;
+    const { isWebComponent } = context.package;
+    const { emitExposedDependencies } = context.options.bundlerConfig;
     const { HtmlWebpackPlugin: htmlWebpackPluginOptions = {} } = plugins ?? {};
 
-    if (embed || headless || emitExposedDependencies) {
+    if (light || headless || emitExposedDependencies) {
         return;
     }