@servicetitan/startup 30.3.1 → 31.1.0

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

@@ -17,12 +17,11 @@ import {
 } from '../../utils';
 import { webComponentStyleRules } from '../__mocks__';
 import { generateMetadata } from '../configs/utils';
-import { featureCohort, getCallerFile, splitByEntry } from '../utils';
+import { getCallerFile, splitByEntry } from '../utils';
 
 import { createWebpackConfig } from '../index';
 
 jest.mock('fs', () => fs);
-jest.mock('fork-ts-checker-webpack-plugin', () => jest.fn());
 jest.mock('html-webpack-plugin', () => jest.fn());
 jest.mock('mini-css-extract-plugin', () =>
     Object.assign(jest.fn(), { loader: 'MiniCssExtractPlugin.loader' })
@@ -46,7 +45,6 @@ jest.mock('../../utils', () => ({
 jest.mock('../configs/utils/generate-metadata');
 jest.mock('../utils', () => ({
     ...jest.requireActual('../utils'),
-    featureCohort: jest.fn(),
     getCallerFile: jest.fn(),
 }));
 
@@ -57,14 +55,14 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
     const packageVersion = '1.0.0';
     const packageJson = 'package.json';
     const tsConfig = 'tsconfig.build.json';
-    const designSystemPath = () => path.join(process.cwd(), `${source}/design-system.css`);
+    const designSystemPath = () => path.join(process.cwd(), `${destination}/design-system.css`);
     const designSystemCode = [
         `@import '~@servicetitan/tokens/core/tokens.css';`,
         `@import '~@servicetitan/anvil-fonts/dist/css/anvil-fonts.css';`,
         `@import '~@servicetitan/design-system/dist/system.min.css';`,
     ].join('\n');
 
-    const indexPath = () => path.join(process.cwd(), `${source}/index.ts`);
+    const indexPath = () => path.join(process.cwd(), `${destination}/index`);
     const indexCode = ({
         embed = false,
         legacyRoot = false,
@@ -264,7 +262,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             beforeEach(() => {
                 vol.fromJSON({
                     [packageJson]: JSON.stringify({ name: packageName }),
-                    [`${source}/design-system.css`]: '',
+                    [`${destination}/design-system.css`]: '',
                 });
             });
 
@@ -323,6 +321,22 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             });
         });
 
+        describe('when headless option is set to true', () => {
+            beforeEach(() => (options.headless = true));
+
+            test(`omits design system and registers headless`, () => {
+                expect(subject().plugins).toContainEqual(
+                    new VirtualModulesPlugin({
+                        [indexPath()]: [
+                            "import { registerHeadless } from '@servicetitan/web-components';",
+                            "import { connectedCallback, disconnectedCallback } from './headless';",
+                            'registerHeadless(connectedCallback, disconnectedCallback);',
+                        ].join('\n'),
+                    })
+                );
+            });
+        });
+
         describe.each([webpackDevConfigFileName, webpackProdConfigFileName])(
             'when invoked from "%s"',
             configFileName => {
@@ -334,39 +348,13 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             }
         );
 
-        describe('when featureCohort is active', () => {
-            beforeEach(() => {
-                jest.mocked(featureCohort).mockImplementation((_: number[], fn: Function) => fn());
-            });
-
-            test('configures "cache"', () => {
-                expect(subject().cache).toEqual({
-                    type: 'filesystem',
-                    name: `${packageName}__full`,
-                    profile: true,
-                });
-            });
-
-            describe('when embed option is set to true', () => {
-                beforeEach(() => (options.embed = true));
-
-                test('changes "cache.name" suffix to "__light"', () => {
-                    expect(subject().cache).toEqual(
-                        expect.objectContaining({
-                            name: `${packageName}__light`,
-                        })
-                    );
-                });
-            });
-        });
-
         describe('when mode is production', () => {
             beforeEach(() =>
                 Object.assign((overrides.configuration ??= {}), { mode: 'production' })
             );
 
             test('configures "devtool"', () => {
-                expect(subject().devtool).toBe(false);
+                expect(subject().devtool).toBe('source-map');
             });
 
             test('configures "optimization.splitChunks.cacheGroups"', () => {

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

@@ -1,5 +1,4 @@
 import CssMinimizerWebpackPlugin from 'css-minimizer-webpack-plugin';
-import ForkTsCheckerWebpackPlugin from 'fork-ts-checker-webpack-plugin';
 import HtmlWebpackPlugin from 'html-webpack-plugin';
 import MiniCssExtractPlugin from 'mini-css-extract-plugin';
 import { fs, vol } from 'memfs';
@@ -15,7 +14,6 @@ import { argv } from 'yargs';
 
 import {
     Package,
-    PackageType,
     WebpackConfiguration,
     getConfiguration,
     getFolders,
@@ -30,15 +28,13 @@ import {
     loadSharedDependencies,
     log,
 } from '../../utils';
-import { createPackage } from '../../__mocks__';
 import { fileRules, productionStyleRules, styleRules } from '../__mocks__';
-import { featureCohort, splitByEntry } from '../utils';
+import { splitByEntry } from '../utils';
 
 import { createWebpackConfig } from '../index';
 
 jest.mock('fs', () => fs);
 jest.mock('css-minimizer-webpack-plugin', () => jest.fn());
-jest.mock('fork-ts-checker-webpack-plugin', () => jest.fn());
 jest.mock('html-webpack-plugin', () => jest.fn());
 jest.mock('mini-css-extract-plugin', () =>
     Object.assign(jest.fn(), { loader: 'MiniCssExtractPlugin.loader' })
@@ -71,10 +67,6 @@ jest.mock('../../utils', () => ({
     loadSharedDependencies: jest.fn(),
     log: { debug: jest.fn(), info: jest.fn(), warning: jest.fn() },
 }));
-jest.mock('../utils', () => ({
-    ...jest.requireActual('../utils'),
-    featureCohort: jest.fn(),
-}));
 
 describe(`[startup] ${createWebpackConfig.name}`, () => {
     const source = 'src';
@@ -110,7 +102,6 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         packages = [];
         overrides = {
             plugins: {
-                ForkTsCheckerWebpackPlugin: { logger: 'webpack-infrastructure' },
                 HtmlWebpackPlugin: { favicon: 'foo' },
                 MiniCssExtractPlugin: { attributes: { foo: 'bar' } },
             },
@@ -126,9 +117,6 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         jest.mocked(MiniCssExtractPlugin).mockImplementation(mockPlugIn('MiniCssExtractPlugin'));
         jest.mocked(BundleAnalyzerPlugin).mockImplementation(mockPlugIn('BundleAnalyzerPlugin'));
         jest.mocked(FilterWarningsPlugin).mockImplementation(mockPlugIn('FilterWarningsPlugin'));
-        jest.mocked(ForkTsCheckerWebpackPlugin).mockImplementation(
-            mockPlugIn('ForkTsCheckerWebpackPlugin')
-        );
         jest.mocked(HtmlWebpackPlugin).mockImplementation(mockPlugIn('HtmlWebpackPlugin'));
         jest.mocked(IgnorePlugin).mockImplementation(mockPlugIn('IgnorePlugin'));
         jest.mocked(MomentLocalesPlugin).mockImplementation(mockPlugIn('MomentLocalesPlugin'));
@@ -164,11 +152,11 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
     const subject = () => createWebpackConfig(overrides, options);
 
     test('configures "entry"', () => {
-        expect(subject().entry).toEqual({ main: [`./${source}/index`] });
+        expect(subject().entry).toEqual({ main: [`./${destination}/index`] });
     });
 
     test('configures "resolve"', () => {
-        expect(subject().resolve).toEqual({ extensions: ['.js', '.jsx', '.ts', '.tsx'] });
+        expect(subject().resolve).toEqual({ extensions: ['.js'] });
     });
 
     test('configures "devtool"', () => {
@@ -180,9 +168,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
     });
 
     test('configures "output.path"', () => {
-        expect(subject().output!.path).toEqual(
-            expect.stringContaining(path.join(destination, 'bundle'))
-        );
+        expect(subject().output!.path).toEqual(path.join(process.cwd(), destination, 'bundle'));
     });
 
     test('configures "optimization"', () => {
@@ -322,23 +308,9 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         });
     });
 
-    test('configures "watchOptions"', () => {
-        expect(subject().watchOptions).toEqual({});
-    });
-
-    describe('with subordinate TSC packages', () => {
-        beforeEach(() => {
-            packages = [
-                createPackage({ name: 'bar', type: PackageType.TSC }),
-                createPackage({ name: 'baz', type: PackageType.Webpack }),
-            ];
-        });
-
-        test('configures "watchOptions" to ignore TSC source files', () => {
-            const ignored = packages
-                .filter(({ type }) => type === PackageType.TSC)
-                .map(({ location }) => path.join(location, getFolders(location).source));
-            expect(subject().watchOptions).toEqual({ ignored });
+    test('configures "watchOptions" to ignore source folder', () => {
+        expect(subject().watchOptions).toEqual({
+            ignored: ['**/node_modules'],
         });
     });
 
@@ -359,85 +331,38 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
     });
 
     function itConfiguresCodeCoverage() {
-        test('configures ".tsx" rules to use coverage-istanbul-loader', () => {
+        test('configures ".js" rules to use coverage-istanbul-loader', () => {
             expect(subject().module?.rules).toEqual(
                 expect.arrayContaining([
                     expect.objectContaining({
-                        test: /\.tsx?$/,
-                        use: expect.arrayContaining(['@jsdevtools/coverage-istanbul-loader']),
+                        enforce: 'post',
+                        test: /\.js$/,
+                        include: [path.resolve(destination)],
+                        exclude: /node_modules/,
+                        use: expect.objectContaining({
+                            loader: '@jsdevtools/coverage-istanbul-loader',
+                            options: {
+                                compact: false,
+                                produceSourceMap: true,
+                            },
+                        }),
                     }),
                 ])
             );
         });
     }
-    function itConfiguresESBuildLoader() {
-        test('configures ".tsx" rules to use esbuild-loader', () => {
-            expect(subject().module?.rules).toContainEqual({
-                test: /\.tsx?$/,
-                exclude: /node_modules/,
-                use: [{ loader: 'esbuild-loader', options: { target: 'es2018' } }],
-            });
-        });
-    }
-    function itConfiguresSwcLoader() {
-        test('configures ".tsx" rules to use swc-loader', () => {
-            expect(subject().module?.rules).toContainEqual({
-                test: /\.tsx?$/,
-                exclude: /node_modules/,
-                use: [
-                    {
-                        loader: 'swc-loader',
-                        options: {
-                            jsc: {
-                                parser: { syntax: 'typescript', tsx: true, decorators: true },
-                                target: 'es2018',
-                                transform: { legacyDecorator: true, decoratorMetadata: true },
-                            },
-                        },
-                    },
-                ],
-            });
-        });
-    }
-    function itConfiguresReactToLoadAutomatically() {
-        test('configures React to load automatically', () => {
-            expect(subject().plugins).toContainEqual(new ProvidePlugin({ React: 'react' }));
-        });
-    }
+
     describe('with --code-coverage command line argument', () => {
         beforeEach(() => Object.assign(argv, { 'code-coverage': true }));
         itConfiguresCodeCoverage();
     });
-    describe('with codeCoverage option', () => {
+
+    describe('when codeCoverage is turned on', () => {
         beforeEach(() => {
             options = { codeCoverage: true };
         });
         itConfiguresCodeCoverage();
     });
-    describe('with --esbuild command line argument', () => {
-        beforeEach(() => Object.assign(argv, { esbuild: true }));
-        itConfiguresESBuildLoader();
-        itConfiguresReactToLoadAutomatically();
-    });
-    describe('with esbuild option', () => {
-        beforeEach(() => {
-            options = { esbuild: true };
-        });
-        itConfiguresESBuildLoader();
-        itConfiguresReactToLoadAutomatically();
-    });
-    describe('with experimental-bundlers option', () => {
-        beforeEach(() => {
-            options = { experimentalBundlers: true };
-        });
-        itConfiguresSwcLoader();
-        itConfiguresReactToLoadAutomatically();
-    });
-    describe('with --experimental-bundlers command line argument', () => {
-        beforeEach(() => Object.assign(argv, { 'experimental-bundlers': true }));
-        itConfiguresSwcLoader();
-        itConfiguresReactToLoadAutomatically();
-    });
 
     test('configures ".css" rule to exclude .module.css files', () => {
         const cssRule: any = subject().module?.rules?.find(({ test: regexp }: { test: RegExp }) =>
@@ -454,26 +379,6 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         );
     });
 
-    test('configures ForkTsCheckerWebpackPlugin plugin', () => {
-        expect(subject().plugins).toContainEqual(
-            new ForkTsCheckerWebpackPlugin({
-                typescript: {
-                    configFile: tsConfig,
-                    configOverwrite: {
-                        exclude: [
-                            '**/__tests__/**/*',
-                            '**/__mocks__/**/*',
-                            '**/*.test.*',
-                            '**/*.stories.tsx',
-                        ],
-                        references: [],
-                    },
-                },
-                ...overrides.plugins?.ForkTsCheckerWebpackPlugin,
-            })
-        );
-    });
-
     test('configures FilterWarningsPlugin plugin', () => {
         expect(subject().plugins).toContainEqual(
             new FilterWarningsPlugin({
@@ -560,6 +465,27 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                     );
                 });
             });
+
+            describe('headless option is true', () => {
+                beforeEach(() => setOptions({ headless: true }));
+
+                test('configures "output.path"', () => {
+                    expect(subject().output!.path).toEqual(
+                        path.join(process.cwd(), destination, 'bundle', 'headless')
+                    );
+                });
+
+                describe('when mode is "production"', () => {
+                    beforeEach(() => {
+                        overrides.configuration ??= {};
+                        Object.assign(overrides.configuration, { mode: 'production' });
+                    });
+
+                    test('omits optimization.runtimeChunk', () => {
+                        expect(subject().optimization?.runtimeChunk).toBeUndefined();
+                    });
+                });
+            });
         });
     });
 
@@ -576,40 +502,14 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                 )
             );
         });
-    });
-
-    describe('when featureCohort is active', () => {
-        beforeEach(() => {
-            jest.mocked(featureCohort).mockImplementation((_: number[], fn: Function) => fn());
-        });
-
-        test('configures "cache"', () => {
-            expect(subject().cache).toEqual({
-                type: 'filesystem',
-                name: packageName,
-                profile: true,
-            });
-        });
 
         describe('when package is web component', () => {
             beforeEach(() => jest.mocked(isWebComponent).mockReturnValue(true));
 
-            function itAppendsSuffixToPackageName(suffix: string) {
-                test(`appends "${suffix}" to package name`, () => {
-                    expect(subject().cache).toEqual(
-                        expect.objectContaining({
-                            name: `${packageName}${suffix}`,
-                        })
-                    );
-                });
-            }
-
-            itAppendsSuffixToPackageName('__full');
-
-            describe('when embed option is set to true', () => {
-                beforeEach(() => setOptions({ embed: true }));
-
-                itAppendsSuffixToPackageName('__light');
+            test('configures "output.path"', () => {
+                expect(subject().output!.path).toEqual(
+                    path.join(process.cwd(), destination, 'bundle', 'light')
+                );
             });
         });
     });
@@ -663,9 +563,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             ]);
         });
 
-        describe('when minification is turned off', () => {
-            beforeEach(() => (configuration = { webpack: { minify: { css: false, js: false } } }));
-
+        function itTurnsOffMinimizer() {
             test('changes "optimization.minimize" to false', () => {
                 expect(subject().optimization?.minimize).toBe(false);
             });
@@ -673,6 +571,18 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             test('omits "optimization.minimizer"', () => {
                 expect(subject().optimization?.minimizer).toBeUndefined();
             });
+        }
+
+        describe('when minification is turned off', () => {
+            beforeEach(() => (configuration = { webpack: { minify: { css: false, js: false } } }));
+
+            itTurnsOffMinimizer();
+        });
+
+        describe('when codeCoverage is turned on', () => {
+            beforeEach(() => (options = { codeCoverage: true }));
+
+            itTurnsOffMinimizer();
         });
 
         describe('with CSS minification options', () => {

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

@@ -2,11 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { Configuration } from 'webpack';
 import {
-    PackageType,
     allowedWebpackDevServerOptions,
-    getFolders,
-    getPackageName,
-    getPackages,
     getWebpackConfiguration,
     isDevServerDisabled,
     log,
@@ -16,19 +12,13 @@ import { statsConfig } from './stats-config';
 import { Context, Overrides } from './types';
 
 type DevServerConfig = NonNullable<Configuration['devServer']>;
-type WatchOptionsConfig = NonNullable<Configuration['watchOptions']>;
-type Result = Pick<Configuration, 'devServer' | 'watchOptions'> | undefined;
+type Result = Pick<Configuration, 'devServer'> | undefined;
 
 export function devServerConfig(context: Context, overrides: Overrides): Result {
-    if (context.isProduction) {
+    if (context.isProduction || isDevServerDisabled()) {
         return;
     }
 
-    const watchOptions = watchOptionsConfig();
-    if (isDevServerDisabled()) {
-        return { watchOptions };
-    }
-
     const devServer = {
         hot: false,
         port: 8080,
@@ -42,8 +32,8 @@ export function devServerConfig(context: Context, overrides: Overrides): Result
     };
 
     /* istanbul ignore next: debug only */
-    log.debug('dev-server-config', () => JSON.stringify({ devServer, watchOptions }, null, 2));
-    return { devServer, watchOptions };
+    log.debug('dev-server-config', () => JSON.stringify({ devServer }, null, 2));
+    return { devServer };
 }
 
 function getDevServerConfig() {
@@ -75,19 +65,6 @@ function getDevServerConfig() {
     return { ...result, ...webpack.devServer } as Partial<DevServerConfig>;
 }
 
-function watchOptionsConfig(): WatchOptionsConfig {
-    const ignored = getPackages({ scope: getPackageName() })
-        .filter(({ type }) => type === PackageType.TSC)
-        .map(({ location }) => path.join(location, getFolders(location).source));
-
-    /*
-     * NOTE: Don't return empty ignored array. It triggered a bug that caused
-     * webpack to ignore all files
-     */
-
-    return ignored.length ? { ignored } : {};
-}
-
 const CONTENT_BASE_DEPRECATION_WARNING = `
     DEPRECATION WARNING: webpack.contentBase in package.json is deprecated.
     Use webpack.static instead.

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

@@ -5,11 +5,11 @@ type Config = Configuration['devtool'];
 type Result = Pick<Configuration, 'devtool'>;
 
 export function devtoolConfig(context: Context, _: Overrides): Result {
-    const { isProduction, isWebComponent } = context;
+    const { isProduction } = context;
     let devtool: Config;
 
     if (isProduction) {
-        devtool = isWebComponent ? false : 'source-map';
+        devtool = 'source-map';
     } else {
         devtool = 'cheap-module-source-map';
     }

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

@@ -1,3 +1,4 @@
+import fs from 'fs';
 import { Configuration } from 'webpack';
 import { getModuleEntryPath } from '../utils';
 import { Context, Overrides } from './types';
@@ -6,9 +7,13 @@ type Config = Configuration['entry'];
 type Result = Pick<Configuration, 'entry'>;
 
 export function entryConfig(context: Context, _: Overrides): Result {
-    const { isExposeSharedDependencies, sharedDependencies, source } = context;
+    const { destination, isExposeSharedDependencies, sharedDependencies, source } = context;
 
-    const entry: Config = { main: [`./${source}/index`] };
+    const index = fs.existsSync(`./${source}/index.js`)
+        ? `./${source}/index`
+        : `./${destination}/index`;
+
+    const entry: Config = { main: [index] };
 
     if (isExposeSharedDependencies) {
         (entry.main as string[]).push(...Object.keys(sharedDependencies).map(getModuleEntryPath));

package/src/webpack/configs/index.ts

@@ -1,5 +1,4 @@
 export * from './amd-config';
-export * from './cache-config';
 export * from './dev-server-config';
 export * from './devtool-config';
 export * from './entry.config';
@@ -10,4 +9,5 @@ export * from './output-config';
 export * from './plugins-config';
 export * from './resolve-config';
 export * from './stats-config';
-export * from './types';
+export type * from './types';
+export * from './watch-options-config';

package/src/webpack/configs/loaders/index.ts

@@ -1,4 +1,4 @@
 export * from './css-loader';
 export * from './less-loader';
 export * from './style-loader';
-export * from './types';
+export type * from './types';

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

@@ -8,7 +8,7 @@ type ConfigWithCacheGroups = Config & { splitChunks: { cacheGroups: Record<strin
 type Result = Pick<Configuration, 'optimization'>;
 
 export function optimizationConfig(context: Context, _: Overrides): Result {
-    const { isProduction } = context;
+    const { headless, isProduction } = context;
 
     const optimization: ConfigWithCacheGroups = {
         chunkIds: isProduction ? 'deterministic' : 'named',
@@ -17,7 +17,7 @@ export function optimizationConfig(context: Context, _: Overrides): Result {
         splitChunks: { cacheGroups: {} },
     };
 
-    if (isProduction) {
+    if (!headless && isProduction) {
         optimization.runtimeChunk = 'single';
     }
 
@@ -29,14 +29,14 @@ export function optimizationConfig(context: Context, _: Overrides): Result {
 }
 
 function minimizeConfig(optimization: ConfigWithCacheGroups, context: Context) {
-    const { isProduction } = context;
+    const { isProduction, codeCoverage } = context;
     if (!isProduction) {
         return;
     }
 
     const minifyJs = context.minify?.js ?? true;
     const minifyCss = context.minify?.css ?? true;
-    optimization.minimize = !!minifyJs || !!minifyCss;
+    optimization.minimize = !codeCoverage && (!!minifyJs || !!minifyCss);
     if (!optimization.minimize) {
         return;
     }
@@ -58,8 +58,8 @@ function minimizeConfig(optimization: ConfigWithCacheGroups, context: Context) {
 }
 
 function sharedDependenciesConfig(optimization: ConfigWithCacheGroups, context: Context) {
-    const { isExposeSharedDependencies } = context;
-    if (!isExposeSharedDependencies) {
+    const { headless, isExposeSharedDependencies } = context;
+    if (!isExposeSharedDependencies || headless) {
         return;
     }
 
@@ -80,8 +80,8 @@ function sharedDependenciesConfig(optimization: ConfigWithCacheGroups, context:
 }
 
 function webComponentConfig(optimization: ConfigWithCacheGroups, context: Context) {
-    const { isWebComponent, isProduction } = context;
-    if (!isWebComponent) {
+    const { headless, isWebComponent, isProduction } = context;
+    if (!isWebComponent || headless) {
         return;
     }
 

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

@@ -6,12 +6,14 @@ type Config = Configuration['output'];
 type Result = Pick<Configuration, 'output'>;
 
 export function outputConfig(context: Context, _: Overrides): Result {
-    const { destination, embed, isProduction, isWebComponent, name } = context;
+    const { destination, embed, headless, isProduction, isWebComponent, name } = context;
+
+    const bundleDir = headless ? 'headless' : embed ? 'light' : 'full';
 
     const output: Config = {
         filename: '[name].bundle.js',
         path: isWebComponent
-            ? path.join(process.cwd(), `${destination}/bundle/${embed ? 'light' : 'full'}`)
+            ? path.join(process.cwd(), `${destination}/bundle/${bundleDir}`)
             : path.join(process.cwd(), `${destination}/bundle`),
     };
 

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

@@ -3,10 +3,13 @@ import HtmlWebpackPlugin, { Options as HtmlWebpackPluginOptions } from 'html-web
 import { splitByEntry } from '../../utils';
 import { Context, Overrides } from '../types';
 
-export function htmlPlugin({ embed, isWebComponent, name }: Context, { plugins }: Overrides) {
+export function htmlPlugin(
+    { embed, headless, isWebComponent, name }: Context,
+    { plugins }: Overrides
+) {
     const { HtmlWebpackPlugin: htmlWebpackPluginOptions = {} } = plugins ?? {};
 
-    if (embed) {
+    if (embed || headless) {
         return;
     }
 

package/src/webpack/configs/plugins/index.ts

@@ -8,7 +8,5 @@ export * from './html-plugin';
 export * from './ignore-plugin';
 export * from './mini-css-extract-plugin';
 export * from './moment-locales-plugin';
-export * from './provide-react-plugin';
-export * from './ts-checker-plugin';
 export * from './virtual-modules-plugin';
 export * from './watch-run-plugin';