@servicetitan/startup 36.4.0 → 37.0.0

package/src/utils/get-configuration.ts

@@ -1,21 +1,25 @@
-import { Config } from '@jest/types';
-import { swcDir } from '@swc/cli';
-import { ESLint } from 'eslint';
+import type { Config } from '@jest/types';
+import type { swcDir } from '@swc/cli';
+import type { ESLint } from 'eslint';
 import fs from 'fs';
 import path from 'path';
-import { LinterOptions } from 'stylelint';
-import svgr from 'vite-plugin-svgr';
-import { ViteUserConfig } from 'vitest/config';
-import { Configuration as WebpackDevServerConfiguration } from 'webpack-dev-server';
-import { ReviewConfiguration } from '../cli/commands/review';
+import type { LinterOptions } from 'stylelint';
+import type svgr from 'vite-plugin-svgr';
+import type { ViteUserConfig } from 'vitest/config';
+import type { Configuration as WebpackDevServerConfiguration } from 'webpack-dev-server';
+import type { ReviewConfiguration } from '../cli/commands/review';
 import { getFolders } from './get-folders';
+import { getPackageName } from './get-package-name';
 import { log } from './log';
 import { readJson, readJsonSafe } from './read-json';
+import { LocationOrJson } from './types';
 
 type VitePluginSvgrOptions = NonNullable<Parameters<typeof svgr>[0]>;
 
 type ElementType<T> = T extends readonly (infer ElementType)[] ? ElementType : never;
 
+export type Bundler = 'vite' | 'webpack';
+
 export const allowedWebpackDevServerOptions = ['headers', 'port', 'proxy', 'static'] as const;
 
 export interface MinifyJSOptions {
@@ -65,7 +69,6 @@ export interface NodeConfiguration {
 /* eslint-disable @typescript-eslint/naming-convention */
 export enum CommandName {
     'build' = 'build',
-    'bundle-package' = 'bundle-package',
     'bundle-vite' = 'bundle-vite',
     'bundle-webpack' = 'bundle-webpack',
     'clean' = 'clean',
@@ -124,6 +127,7 @@ export interface ViteBundlerConfig {
 
 export interface VitePackageJsonOverride extends ViteBundlerConfig {
     config?: Omit<import('vite').UserConfig, 'plugins'>;
+    devServer?: false;
 }
 
 export interface WebComponentBranchConfigs {
@@ -141,6 +145,7 @@ interface WebComponentOptions {
 }
 
 type Configuration = {
+    'bundler'?: Bundler;
     'jest'?: JestConfiguration;
     'legacy'?: boolean;
     'lint'?: { eslint: ESLintConfiguration; stylelint: StylelintConfiguration };
@@ -148,6 +153,7 @@ type Configuration = {
     'swc-compile-package'?: Parameters<typeof swcDir>[0];
     'test'?: JestConfiguration; // for backward-compatibility
     'testRunner'?: string;
+    'expose-process-env'?: string[];
     'expose-shared-dependencies'?: boolean;
     'shared-dependencies'?: Record<string, string>;
     'vite'?: false | VitePackageJsonOverride;
@@ -158,8 +164,6 @@ type Configuration = {
     [key in CommandName]?: NodeConfiguration;
 } & NodeConfiguration;
 
-type LocationOrJson = string | Record<string, any>;
-
 export function getConfiguration(locationOrJson: LocationOrJson = './'): Configuration {
     const json =
         typeof locationOrJson === 'string'
@@ -193,6 +197,10 @@ export function getStylelintConfiguration() {
     return getConfiguration().lint?.stylelint ?? {};
 }
 
+export function getExposeProcessEnv(): string[] {
+    return getConfiguration()['expose-process-env'] ?? [];
+}
+
 export function getViteConfiguration(): VitePackageJsonOverride {
     const { vite } = getConfiguration();
     return typeof vite === 'object' ? vite : {};
@@ -255,10 +263,9 @@ export function getSwcCompilePackageConfiguration() {
 }
 
 export function isBundle(locationOrJson?: LocationOrJson) {
-    return (
-        getConfiguration(locationOrJson).webpack !== false &&
-        getConfiguration(locationOrJson).vite !== false
-    );
+    const { webpack, vite } = getConfiguration(locationOrJson);
+    assertBundlersAgree(webpack, vite, locationOrJson);
+    return webpack !== false && vite !== false;
 }
 
 export function isDevServerDisabled() {
@@ -266,6 +273,10 @@ export function isDevServerDisabled() {
     return webpackConfiguration.devServer === false;
 }
 
+export function isViteDevServerDisabled() {
+    return getViteConfiguration().devServer === false;
+}
+
 export function isExposeSharedDependencies() {
     return (
         (getConfiguration()['expose-shared-dependencies'] ??
@@ -288,3 +299,27 @@ export function isStyleCheckDisabled() {
 export function isWebComponent(locationOrJson: LocationOrJson = './') {
     return !!getWebComponentConfiguration(locationOrJson);
 }
+
+/*
+ * Require that Vite and Webpack configurations agree whether package is a bundle.
+ */
+function assertBundlersAgree(
+    webpack: Configuration['webpack'],
+    vite: Configuration['vite'],
+    locationOrJson?: LocationOrJson
+) {
+    if (webpack === undefined || vite === undefined || !!webpack === !!vite) {
+        return;
+    }
+
+    const mismatch =
+        webpack === false
+            ? { falsy: 'cli.webpack', truthy: 'cli.vite' }
+            : { falsy: 'cli.vite', truthy: 'cli.webpack' };
+
+    throw new Error(
+        `package ${getPackageName(locationOrJson)} has conflicting webpack ` +
+            `and vite configurations: ${mismatch.falsy} is false but ` +
+            `${mismatch.truthy} is not`
+    );
+}

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

@@ -1,6 +1,12 @@
 import path from 'path';
 import { readJson } from './read-json';
+import { LocationOrJson } from './types';
 
-export function getPackageName(location = './'): string {
-    return readJson(path.join(location, 'package.json')).name;
+export function getPackageName(locationOrJson: LocationOrJson = './'): string {
+    const json =
+        typeof locationOrJson === 'string'
+            ? readJson(path.join(locationOrJson, 'package.json'))
+            : locationOrJson;
+
+    return json?.name ?? '';
 }

package/src/utils/index.ts

@@ -22,4 +22,5 @@ export * from './pick';
 export * from './prettify';
 export * from './read-json';
 export * from './to-array';
+export type * from './types';
 export * from './validate-shared-dependencies';

package/src/utils/types.ts

@@ -0,0 +1 @@
+export type LocationOrJson = string | Record<string, any>;

package/src/utils/validate-shared-dependencies.ts

@@ -1,7 +1,21 @@
-import { getConfiguration, getWebpackConfiguration } from './get-configuration';
+import {
+    getConfiguration,
+    getWebpackConfiguration,
+    isExposeSharedDependencies,
+    isWebComponent,
+} from './get-configuration';
+import { getPackageName } from './get-package-name';
 
 export function validateSharedDependencies() {
     const config = getConfiguration();
+
+    if (isWebComponent() && isExposeSharedDependencies()) {
+        throw new Error(
+            'cli.expose-shared-dependencies only applies to host applications.' +
+                `Remove it from ${getPackageName()}.`
+        );
+    }
+
     const webpackSharedDependencies = getWebpackConfiguration()['shared-dependencies'];
     const topLevelSharedDependencies = config['shared-dependencies'];
 

package/src/vite/__tests__/build-shared-dependencies.test.ts

@@ -1,6 +1,6 @@
-import { build } from 'vite';
+import { build, type InlineConfig } from 'vite';
 import type { BuildContext } from '../../core';
-import { bundleConstants, createBuildContext, getOutputPath } from '../../core';
+import { bundleConstants, createBuildContext, resolveOutputPath } from '../../core';
 import { buildSharedDependencies } from '../build-shared-dependencies';
 import { createViteConfig } from '../config';
 import { sharedDependenciesPlugin } from '../plugins/shared-dependencies-plugin';
@@ -9,11 +9,11 @@ jest.mock('vite', () => ({
     build: jest.fn(),
 }));
 jest.mock('../../core', () => ({
+    ...jest.requireActual('../../core'),
     bundleConstants: {
         mode: { production: 'production', development: 'development' },
     },
     createBuildContext: jest.fn(),
-    getOutputPath: jest.fn(),
 }));
 jest.mock('../config', () => ({
     createViteConfig: jest.fn(),
@@ -23,6 +23,7 @@ jest.mock('../plugins/shared-dependencies-plugin', () => ({
 }));
 
 describe(buildSharedDependencies.name, () => {
+    const viteConfig: any = {};
     let options: any;
     let context: BuildContext;
 
@@ -33,12 +34,11 @@ describe(buildSharedDependencies.name, () => {
             build: { isProduction: false },
             package: {
                 sharedDependencies: { react: 'globalReact' },
-                destination: '/output/pkg',
+                destination: 'dist',
             },
         } as any;
-        jest.mocked(createViteConfig).mockResolvedValue({});
+        jest.mocked(createViteConfig).mockResolvedValue(viteConfig);
         jest.mocked(createBuildContext).mockReturnValue(context);
-        jest.mocked(getOutputPath).mockReturnValue('/output/pkg/bundle');
     });
 
     const subject = () => buildSharedDependencies(options);
@@ -48,7 +48,6 @@ describe(buildSharedDependencies.name, () => {
 
         expect(createBuildContext).toHaveBeenCalledWith({
             ...options,
-            outputBasePath: undefined,
             emitExposedDependencies: true,
         });
     });
@@ -77,7 +76,9 @@ describe(buildSharedDependencies.name, () => {
 
         expect(build).toHaveBeenCalledWith(
             expect.objectContaining({
-                build: expect.objectContaining({ outDir: getOutputPath(context) }),
+                build: expect.objectContaining({
+                    outDir: resolveOutputPath(context, viteConfig.build?.outDir),
+                }),
             })
         );
     });
@@ -97,7 +98,7 @@ describe(buildSharedDependencies.name, () => {
     });
 
     describe('when user config sets oxc options', () => {
-        const oxc = {
+        const oxc: InlineConfig['oxc'] = {
             minify: { compress: true },
             target: 'es2020',
             legalComments: 'inline',
@@ -137,24 +138,10 @@ describe(buildSharedDependencies.name, () => {
     });
 
     describe('when user config has custom outDir', () => {
-        const customOutDir = '/custom/out';
-        const customOutputPath = '/custom/out/bundle';
+        const outDir = '/foo';
 
         beforeEach(() => {
-            jest.mocked(createViteConfig).mockResolvedValue({
-                build: { outDir: customOutDir },
-            });
-            jest.mocked(getOutputPath).mockReturnValue(customOutputPath);
-        });
-
-        test('passes custom output path to build context', async () => {
-            await subject();
-
-            expect(createBuildContext).toHaveBeenCalledWith({
-                ...options,
-                outputBasePath: customOutDir,
-                emitExposedDependencies: true,
-            });
+            jest.mocked(createViteConfig).mockResolvedValue({ build: { outDir } });
         });
 
         test('builds with custom output directory', async () => {
@@ -162,7 +149,7 @@ describe(buildSharedDependencies.name, () => {
 
             expect(build).toHaveBeenCalledWith(
                 expect.objectContaining({
-                    build: expect.objectContaining({ outDir: customOutputPath }),
+                    build: expect.objectContaining({ outDir }),
                 })
             );
         });

package/src/vite/__tests__/validate-shared-dependencies.test.ts

@@ -1,34 +1,45 @@
 import { fs, vol } from 'memfs';
+import { validateSharedDependencies } from '../../utils/validate-shared-dependencies';
 import { validateViteSharedDependencies } from '../validate-shared-dependencies';
 
 jest.mock('fs', () => fs);
+jest.mock('../../utils/validate-shared-dependencies');
 
-describe('validateViteSharedDependencies', () => {
-    function mockPackageJson(content: Record<string, any> = {}) {
-        vol.fromJSON({ 'package.json': JSON.stringify(content) });
-    }
+describe(`[startup] ${validateViteSharedDependencies.name}`, () => {
+    let cli: Record<string, any>;
 
+    beforeEach(() => {
+        jest.clearAllMocks();
+        cli = {};
+    });
     afterEach(() => vol.reset());
 
-    test('passes when neither is set', () => {
-        mockPackageJson();
-        expect(() => validateViteSharedDependencies()).not.toThrow();
-    });
+    const subject = () => {
+        vol.fromJSON({ 'package.json': JSON.stringify({ cli }) });
+        return validateViteSharedDependencies();
+    };
+
+    function itThrows(message: RegExp) {
+        test('throws', () => {
+            expect(subject).toThrow(message);
+        });
+    }
+
+    test('delegates to validateSharedDependencies', () => {
+        subject();
 
-    test('passes when only cli top level is set', () => {
-        mockPackageJson({ cli: { 'expose-shared-dependencies': true } });
-        expect(() => validateViteSharedDependencies()).not.toThrow();
+        expect(validateSharedDependencies).toHaveBeenCalled();
     });
 
-    test('throws when webpack shared-dependencies is set but top level is not', () => {
-        mockPackageJson({ cli: { webpack: { 'shared-dependencies': { defaults: '' } } } });
-        expect(() => validateViteSharedDependencies()).toThrow(/Move your shared-dependencies/);
+    describe('with cli.webpack.shared-dependencies', () => {
+        beforeEach(() => (cli.webpack = { 'shared-dependencies': { defaults: '' } }));
+
+        itThrows(/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(() => validateViteSharedDependencies()).toThrow(
-            /Move your expose-shared-dependencies/
-        );
+    describe('with cli.webpack.expose-shared-dependencies', () => {
+        beforeEach(() => (cli.webpack = { 'expose-shared-dependencies': true }));
+
+        itThrows(/Move your expose-shared-dependencies/);
     });
 });

package/src/vite/build-shared-dependencies.ts

@@ -4,18 +4,14 @@ import {
     BuildContextOptions,
     bundleConstants,
     createBuildContext,
-    getOutputPath,
+    resolveOutputPath,
 } from '../core';
 import { createViteConfig } from './config';
 import { sharedDependenciesPlugin } from './plugins/shared-dependencies-plugin';
 
 export async function buildSharedDependencies(options: BuildContextOptions) {
     const config = await createViteConfig(options);
-    const context = createBuildContext({
-        ...options,
-        outputBasePath: config.build?.outDir,
-        emitExposedDependencies: true,
-    });
+    const context = createBuildContext({ ...options, emitExposedDependencies: true });
 
     await build({
         configFile: false,
@@ -26,7 +22,7 @@ export async function buildSharedDependencies(options: BuildContextOptions) {
         mode: getMode(context),
         plugins: [getSharedDependenciesPlugin(context)],
         build: {
-            outDir: getOutputPath(context),
+            outDir: resolveOutputPath(context, config.build?.outDir),
             minify: config.build?.minify,
             cssMinify: config.build?.cssMinify,
             terserOptions: config.build?.terserOptions,

package/src/vite/config/__tests__/asset-file-names.test.ts

@@ -0,0 +1,40 @@
+import { assetFileNames } from '../asset-file-names';
+
+describe(assetFileNames.name, () => {
+    let asset: Parameters<typeof assetFileNames>[0];
+
+    beforeEach(() => (asset = { names: [] }));
+
+    const subject = () => assetFileNames(asset);
+
+    test('returns assets/[name]-[hash][extname]', () => {
+        expect(subject()).toBe('assets/[name]-[hash][extname]');
+    });
+
+    [
+        {
+            name: 'fonts/[name]-[hash][extname]',
+            extensions: ['woff', 'woff2', 'eot', 'ttf', 'otf'],
+        },
+        {
+            name: 'images/[name]-[hash][extname]',
+            extensions: ['png', 'jpg', 'jpeg', 'gif', 'svg'],
+        },
+    ].forEach(({ extensions, name }) => {
+        describe.each(extensions)('with .%s', extension => {
+            beforeEach(() => (asset = { names: [`foo.${extension}`] }));
+
+            test(`returns ${name}`, () => {
+                expect(subject()).toBe(name);
+            });
+        });
+    });
+
+    describe('when asset has multiple names', () => {
+        beforeEach(() => (asset = { names: [`foo.png`, 'bar.ttf'] }));
+
+        test('uses first name', () => {
+            expect(subject()).toEqual('images/[name]-[hash][extname]');
+        });
+    });
+});

package/src/vite/config/__tests__/base-config.test.ts

@@ -4,22 +4,31 @@ import {
     defineExposedInstanceDependencies,
     defineWebComponentName,
     getBundleType,
-    getOutputPath,
 } from '../../../core';
 import { omit } from '../../../utils';
 import {
+    bundleStatPlugin,
+    chainSourceMapsPlugin,
+    cleanPlugin,
     cssInjectorPlugin,
+    designSystemGuardPlugin,
     devServerRoutingPlugin,
     externalsPlugin,
     htmlPlugin,
     ignoreModulesPlugin,
+    istanbulPlugin,
+    magicCommentsPlugin,
     metadataPlugin,
+    momentLocalesPlugin,
     styleUrlsPlugin,
     svgrPlugin,
     virtualModulesPlugin,
 } from '../../plugins';
 import type { ViteBuildContext } from '../../types';
+import { assetFileNames } from '../asset-file-names';
 import { createBaseConfig } from '../base-config';
+import { getCodeSplitting } from '../code-splitting';
+import { createFilteringLogger } from '../create-filtering-logger';
 
 jest.mock('../../../core', () => ({
     ...jest.requireActual('../../../core'),
@@ -35,7 +44,6 @@ jest.mock('../../../core', () => ({
         mode: { production: 'production', development: 'development' },
     },
     getBundleType: jest.fn(),
-    getOutputPath: jest.fn(),
     defineExposedDependencies: jest.fn(),
     defineExposedInstanceDependencies: jest.fn(),
     defineWebComponentName: jest.fn(),
@@ -45,25 +53,41 @@ jest.mock('../../../utils', () => ({
     omit: jest.fn((obj: any) => obj),
 }));
 
+jest.mock('../create-filtering-logger', () => ({
+    createFilteringLogger: jest.fn(() => ({ name: 'filteringLogger' })),
+}));
+
+jest.mock('../code-splitting', () => ({
+    getCodeSplitting: jest.fn(),
+}));
+
 jest.mock('../../plugins', () => ({
-    htmlPlugin: jest.fn(() => ({ name: 'html' })),
-    svgrPlugin: jest.fn(() => ({ name: 'svgr' })),
-    externalsPlugin: jest.fn(() => ({ name: 'externals' })),
-    virtualModulesPlugin: jest.fn(() => ({ name: 'virtualModules' })),
+    bundleStatPlugin: jest.fn(() => ({ name: 'bundleStat' })),
+    chainSourceMapsPlugin: jest.fn(() => ({ name: 'chainSourceMaps' })),
+    cleanPlugin: jest.fn(() => ({ name: 'clean' })),
     cssInjectorPlugin: jest.fn(() => [{ name: 'cssInjector' }]),
-    styleUrlsPlugin: jest.fn(() => ({ name: 'styleUrls' })),
-    metadataPlugin: jest.fn(() => ({ name: 'metadata' })),
+    designSystemGuardPlugin: jest.fn(() => ({ name: 'designSystemGuard' })),
     devServerRoutingPlugin: jest.fn(() => ({ name: 'devServerRouting' })),
+    externalsPlugin: jest.fn(() => ({ name: 'externals' })),
+    htmlPlugin: jest.fn(() => ({ name: 'html' })),
     ignoreModulesPlugin: jest.fn((context: any) => ({ name: 'ignoreModules', context })),
+    istanbulPlugin: jest.fn(() => ({ name: 'istanbul' })),
+    magicCommentsPlugin: jest.fn(() => ({ name: 'magicComments' })),
+    metadataPlugin: jest.fn(() => ({ name: 'metadata' })),
+    momentLocalesPlugin: jest.fn(() => ({ name: 'momentLocales' })),
+    styleUrlsPlugin: jest.fn(() => ({ name: 'styleUrls' })),
+    svgrPlugin: jest.fn(() => ({ name: 'svgr' })),
+    virtualModulesPlugin: jest.fn(() => ({ name: 'virtualModules' })),
 }));
 
 describe(createBaseConfig.name, () => {
+    const codeSplitting = { groups: [{ name: 'vendor', test: /node_modules/ }] };
     let context: ViteBuildContext;
 
     beforeEach(() => {
         jest.clearAllMocks();
+        jest.mocked(getCodeSplitting).mockReturnValue(codeSplitting);
         jest.mocked(getBundleType).mockReturnValue('full');
-        jest.mocked(getOutputPath).mockReturnValue('/output/dist');
         jest.mocked(defineExposedDependencies).mockReturnValue({
             // eslint-disable-next-line @typescript-eslint/naming-convention
             EXPOSED_DEPENDENCIES: '"deps"',
@@ -95,12 +119,6 @@ describe(createBaseConfig.name, () => {
         expect(subject().server!.port).toBe(8080);
     });
 
-    test('pre-warms client files from destination', () => {
-        expect(subject().server!.warmup!.clientFiles).toEqual([
-            `${context.package.destination}/**/*.js`,
-        ]);
-    });
-
     test('sets development mode', () => {
         expect(subject().mode).toBe(bundleConstants.mode.development);
     });
@@ -109,6 +127,12 @@ describe(createBaseConfig.name, () => {
         expect(subject().configFile).toBe(false);
     });
 
+    test('filters noisy warnings through a custom logger', () => {
+        expect(subject().customLogger).toBe(
+            jest.mocked(createFilteringLogger).mock.results[0].value
+        );
+    });
+
     test('strips legal comments', () => {
         expect(subject().oxc).toEqual({ legalComments: 'none' });
     });
@@ -139,16 +163,26 @@ describe(createBaseConfig.name, () => {
         expect(subject().build!.cssCodeSplit).toBe(true);
     });
 
-    test('does not empty output directory', () => {
-        expect(subject().build!.emptyOutDir).toBe(false);
+    test('enables source maps', () => {
+        expect(subject().build!.sourcemap).toBe(true);
     });
 
-    test('sets output directory from context', () => {
-        expect(subject().build!.outDir).toBe(getOutputPath(context));
+    test('routes assets through assetFileNames', () => {
+        expect(subject().build!.rolldownOptions!.output).toEqual(
+            expect.objectContaining({ assetFileNames })
+        );
     });
 
-    test('enables source maps', () => {
-        expect(subject().build!.sourcemap).toBe(true);
+    test('registers chainSourceMaps plugin', () => {
+        expect(subject().build!.rolldownOptions!.plugins).toEqual([chainSourceMapsPlugin()]);
+    });
+
+    test('configures code splitting from getCodeSplitting', () => {
+        expect(subject().build!.rolldownOptions!.output).toEqual(
+            expect.objectContaining({
+                codeSplitting: getCodeSplitting(context),
+            })
+        );
     });
 
     test('maps define values to import.meta.env prefix', () => {
@@ -161,6 +195,30 @@ describe(createBaseConfig.name, () => {
         }
     });
 
+    describe('when exposeProcessEnv lists a variable', () => {
+        const variable = 'API_URL';
+        const value = 'https://api.example.com';
+
+        beforeEach(() => {
+            context.package.exposeProcessEnv = [variable];
+            process.env[variable] = value;
+        });
+
+        afterEach(() => delete process.env[variable]);
+
+        test('defines process.env.NAME with the value', () => {
+            expect(subject().define![`process.env.${variable}`]).toBe(JSON.stringify(value));
+        });
+
+        describe('when variable is not set', () => {
+            beforeEach(() => delete process.env[variable]);
+
+            test('defines process.env.NAME as undefined', () => {
+                expect(subject().define![`process.env.${variable}`]).toBe('undefined');
+            });
+        });
+    });
+
     test('includes startup-utils in optimized dependencies', () => {
         expect(subject().optimizeDeps!.include).toEqual(['@servicetitan/startup-utils']);
     });
@@ -173,15 +231,21 @@ describe(createBaseConfig.name, () => {
 
     test('creates plugins from factories, passing context', () => {
         const factories = [
-            htmlPlugin,
-            svgrPlugin,
-            externalsPlugin,
-            virtualModulesPlugin,
+            bundleStatPlugin,
+            cleanPlugin,
             cssInjectorPlugin,
-            styleUrlsPlugin,
-            metadataPlugin,
+            designSystemGuardPlugin,
             devServerRoutingPlugin,
+            externalsPlugin,
+            htmlPlugin,
             ignoreModulesPlugin,
+            istanbulPlugin,
+            magicCommentsPlugin,
+            metadataPlugin,
+            momentLocalesPlugin,
+            styleUrlsPlugin,
+            svgrPlugin,
+            virtualModulesPlugin,
         ];
 
         const pluginNames = (subject().plugins as any[]).map((p: any) => p.name);
@@ -218,10 +282,6 @@ describe(createBaseConfig.name, () => {
         test('disables CSS code splitting', () => {
             expect(subject().build!.cssCodeSplit).toBe(false);
         });
-
-        test('empties output directory', () => {
-            expect(subject().build!.emptyOutDir).toBe(true);
-        });
     });
 
     describe('when production', () => {
@@ -306,4 +366,12 @@ describe(createBaseConfig.name, () => {
             expect(subject().build!.cssMinify).toBe(!!context.bundlerConfig.minify.css);
         });
     });
+
+    describe('when code coverage is enabled', () => {
+        beforeEach(() => (context.options.codeCoverage = true));
+
+        test('disables minify', () => {
+            expect(subject().build!.minify).toBe(false);
+        });
+    });
 });