@servicetitan/startup 31.5.0 → 31.6.0

package/src/cli/commands/{tests.ts → test/runners/jest.ts}

@@ -1,22 +1,11 @@
-import { Config } from '@jest/types';
 import { runCLI } from '@jest/core';
-import { getJestConfigCLI, logErrors } from '../../utils';
-import { Command } from '.';
-
-/**
- * Named as tests to exclude it from the Jest pattern
- */
-export class Tests implements Command {
-    readonly greedy = true;
-
-    constructor(private args: Config.Argv) {}
+import { Config } from '@jest/types';
+import { getJestConfigCLI } from '../../../../utils';
 
-    description() {
-        return 'run tests';
-    }
+export class Jest {
+    constructor(private readonly args: Config.Argv) {}
 
-    @logErrors
-    async execute() {
+    async run() {
         const jestConfig = getJestConfigCLI(this.args);
         const {
             results: { success },

package/src/cli/commands/test/runners/vitest.ts

@@ -0,0 +1,70 @@
+import { configDefaults, coverageConfigDefaults, mergeConfig, ViteUserConfig } from 'vitest/config';
+import { startVitest, parseCLI, resolveConfig } from 'vitest/node';
+import { getVitestConfiguration, log } from '../../../../utils';
+
+type VitestConfig = NonNullable<ViteUserConfig['test']>;
+
+export class Vitest {
+    async run() {
+        const cliOptions = getCliOptions();
+        const userConfig = await getUserConfig();
+
+        // startVitest sets process.exitCode to 1 when tests fail
+        const vitest = await startVitest('test', cliOptions.filter, cliOptions.options, userConfig);
+        await vitest.close();
+    }
+}
+
+const RUNNER_OPTION = '--runner';
+
+function excludeRunnerOption(args: string[]) {
+    return args.reduce<string[]>((result, item, index) => {
+        if (!item.startsWith(RUNNER_OPTION) && (index === 0 || args[index - 1] !== RUNNER_OPTION)) {
+            result.push(item);
+        }
+        return result;
+    }, []);
+}
+
+function getCliOptions() {
+    // parseCLI requires the first element to be "vitest"
+    const result = parseCLI(['vitest', ...excludeRunnerOption(process.argv.slice(3))]);
+
+    /* istanbul ignore next: debug only */
+    log.debug('vitest:cliOptions', () => JSON.stringify(result, null, 2));
+
+    return result;
+}
+
+function getDefaultConfig(): VitestConfig {
+    return {
+        coverage: {
+            exclude: [
+                ...coverageConfigDefaults.exclude,
+                '**/__mocks__/**',
+                '**/*.stories.*',
+                '\\.yalc',
+            ],
+            include: ['**/*.{ts,tsx}'],
+            reporter: ['html-spa', 'text', 'json', 'cobertura', 'lcov'],
+        },
+        environment: 'jsdom',
+        exclude: [...configDefaults.exclude, '\\.yalc'],
+        restoreMocks: true,
+        server: { deps: { inline: ['@servicetitan/anvil2'] } }, // fixes css parser errors
+    };
+}
+
+async function getUserConfig(): Promise<ViteUserConfig> {
+    const { viteConfig } = await resolveConfig();
+
+    const result = mergeConfig(
+        mergeConfig(getDefaultConfig(), getVitestConfiguration()),
+        viteConfig.test ?? {}
+    );
+
+    /* istanbul ignore next: debug only */
+    log.debug('vitest:userConfig', () => JSON.stringify(result, null, 2));
+
+    return { test: result };
+}

package/src/cli/commands/test/tests.ts

@@ -0,0 +1,34 @@
+import { Config } from '@jest/types';
+import { getConfiguration, logErrors } from '../../../utils';
+import { Command } from '../types';
+import { Jest, Vitest } from './runners';
+
+type Args = Config.Argv & {
+    runner?: 'jest' | 'vitest';
+};
+
+/**
+ * This class is named "Tests" instead of "Test" because the corresponding
+ * "test.ts" would be interpreted as a test file.
+ */
+export class Tests implements Command {
+    readonly greedy = true;
+
+    constructor(private readonly args: Args) {}
+
+    description() {
+        return 'run tests';
+    }
+
+    @logErrors
+    async execute() {
+        const { runner = getConfiguration().testRunner ?? 'jest', ...restArgs } = this.args;
+        if (runner === 'jest') {
+            await new Jest(restArgs).run();
+        } else if (runner === 'vitest') {
+            await new Vitest().run();
+        } else {
+            throw new Error(`unrecognized runner "${runner}"`);
+        }
+    }
+}

package/src/cli/utils/__tests__/bundle.test.ts

@@ -34,7 +34,7 @@ jest.mock('../../../webpack', () => ({ createWebpackConfig: jest.fn() }));
 describe('[startup] Cli Utils', () => {
     const pkg = createPackage({});
     const createWebpackResult = { stats: { all: true } };
-    let compiler: Partial<ReturnType<typeof webpack>>;
+    let compiler: Partial<NonNullable<ReturnType<typeof webpack>>>;
 
     beforeEach(() => {
         jest.resetAllMocks();

package/src/cli/utils/bundle.ts

@@ -57,6 +57,7 @@ export async function bundle(options: Options = {}) {
     const customConfig = readWebpackConfig({ ...options, fallback });
     const webpackOptions = getWebpackOptions(options, customConfig);
 
+    /* istanbul ignore next: debug only */
     log.debug('custom-webpack-config', () => stringifyConfig(customConfig));
 
     if (isWebComponent()) {
@@ -135,7 +136,7 @@ function readConfig(relativePath?: string): Record<string, any> | undefined {
 }
 
 async function run(config: Configuration) {
-    const compiler = webpack(config);
+    const compiler = createWebpackCompiler(config);
 
     const stats = await new Promise<webpack.Stats>((resolve, reject) => {
         compiler.run((error, stats) => {
@@ -155,7 +156,7 @@ async function run(config: Configuration) {
 }
 
 async function runServe({ devServer = {}, ...config }: Configuration) {
-    const compiler = webpack(config);
+    const compiler = createWebpackCompiler(config);
     const host = devServer.host ?? 'localhost';
     const port = await getPortPromise({
         port: Number(devServer.port) || 8080,
@@ -175,7 +176,7 @@ async function runServe({ devServer = {}, ...config }: Configuration) {
 }
 
 async function runWatch(config: Configuration) {
-    const compiler = webpack(config);
+    const compiler = createWebpackCompiler(config);
     return new Promise<void>((_0, reject) => {
         const watching = compiler.watch({}, e => {
             if (e) {
@@ -186,3 +187,7 @@ async function runWatch(config: Configuration) {
         });
     });
 }
+
+function createWebpackCompiler(config: Configuration) {
+    return webpack(config)!; // webpack only potentially returns null when given a callback argument
+}

package/src/cli/utils/set-node-options.ts

@@ -1,5 +1,5 @@
 import os from 'os';
-import { CommandName, NodeConfiguration, getConfigurationSafe } from '../../utils';
+import { CommandName, getConfigurationSafe } from '../../utils';
 import { Command } from '../commands';
 
 const MAX_OLD_SPACE_SIZE_OPTION = 'max_old_space_size';
@@ -13,7 +13,7 @@ const MIN_REMAINING_MEMORY_MB = 512;
  */
 export function setNodeOptions(commandName: CommandName, command: Command) {
     const cliConfig = getConfigurationSafe();
-    const cmdConfig: NodeConfiguration = cliConfig[commandName];
+    const cmdConfig = cliConfig[commandName];
 
     const cliNodeOptions = cliConfig.NODE_OPTIONS ?? [];
     const cmdNodeOptions = cmdConfig?.NODE_OPTIONS ?? [];

package/src/index.ts

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

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

@@ -8,6 +8,7 @@ import {
     getJestConfiguration,
     getReviewConfiguration,
     getStylelintConfiguration,
+    getVitestConfiguration,
     getWebComponentBranchConfigs,
     getWebComponentConfiguration,
     hasHeadlessBundle,
@@ -43,8 +44,8 @@ describe('[startup] Utils', () => {
 
     afterEach(() => jest.resetAllMocks());
 
-    describe(`${getConfiguration.name}`, () => {
-        let locationOrJson: string | Record<string, any> | undefined;
+    describe(getConfiguration.name, () => {
+        let locationOrJson: Parameters<typeof getConfiguration>[0];
 
         beforeEach(() => (locationOrJson = undefined));
 
@@ -94,7 +95,7 @@ describe('[startup] Utils', () => {
         });
     });
 
-    describe(`${getConfigurationSafe.name}`, () => {
+    describe(getConfigurationSafe.name, () => {
         let locationOrJson: string | Record<string, any> | undefined;
 
         beforeEach(() => (locationOrJson = undefined));
@@ -141,7 +142,7 @@ describe('[startup] Utils', () => {
         });
     });
 
-    describe(`${getESLintConfiguration.name}`, () => {
+    describe(getESLintConfiguration.name, () => {
         const subject = () => getESLintConfiguration();
 
         itReturns(subject, {});
@@ -157,7 +158,7 @@ describe('[startup] Utils', () => {
         });
     });
 
-    describe(`${getJestConfiguration.name}`, () => {
+    describe(getJestConfiguration.name, () => {
         const subject = () => getJestConfiguration();
 
         itReturns(subject, {});
@@ -171,9 +172,29 @@ describe('[startup] Utils', () => {
                 expect(subject()).toEqual(content.cli.test);
             });
         });
+
+        describe('with "cli.jest"', () => {
+            const content = { cli: { jest: { baz: 'qux' } } };
+
+            beforeEach(() => mockPackageJson(content));
+
+            test('returns "cli.jest"', () => {
+                expect(subject()).toEqual(content.cli.jest);
+            });
+        });
+
+        describe('with both "cli.test" and "cli.jest"', () => {
+            const content = { cli: { test: { foo: 'bar' }, jest: { baz: 'qux' } } };
+
+            beforeEach(() => mockPackageJson(content));
+
+            test('returns "cli.jest"', () => {
+                expect(subject()).toEqual(content.cli.jest);
+            });
+        });
     });
 
-    describe(`${getReviewConfiguration.name}`, () => {
+    describe(getReviewConfiguration.name, () => {
         const subject = () => getReviewConfiguration();
 
         itReturns(subject, {});
@@ -189,7 +210,7 @@ describe('[startup] Utils', () => {
         });
     });
 
-    describe(`${getStylelintConfiguration.name}`, () => {
+    describe(getStylelintConfiguration.name, () => {
         const subject = () => getStylelintConfiguration();
 
         itReturns(subject, {});
@@ -205,7 +226,23 @@ describe('[startup] Utils', () => {
         });
     });
 
-    describe(`${getWebComponentConfiguration.name}`, () => {
+    describe(getVitestConfiguration.name, () => {
+        const subject = () => getVitestConfiguration();
+
+        itReturns(subject, {});
+
+        describe('with "cli.vitest"', () => {
+            const content = { cli: { vitest: { foo: 'bar' } } };
+
+            beforeEach(() => mockPackageJson(content));
+
+            test('return "cli.vitest"', () => {
+                expect(subject()).toEqual(content.cli.vitest);
+            });
+        });
+    });
+
+    describe(getWebComponentConfiguration.name, () => {
         let locationOrJson: string | Record<string, any> | undefined;
 
         beforeEach(() => (locationOrJson = undefined));
@@ -317,7 +354,7 @@ describe('[startup] Utils', () => {
         });
     });
 
-    describe(`${getWebComponentBranchConfigs.name}`, () => {
+    describe(getWebComponentBranchConfigs.name, () => {
         const subject = () => getWebComponentBranchConfigs();
 
         itReturns(subject, undefined);
@@ -333,7 +370,7 @@ describe('[startup] Utils', () => {
         });
     });
 
-    describe(`${hasHeadlessBundle.name}`, () => {
+    describe(hasHeadlessBundle.name, () => {
         const subject = () => hasHeadlessBundle();
 
         itReturns(subject, false);
@@ -410,7 +447,7 @@ describe('[startup] Utils', () => {
         });
     });
 
-    describe(`${isLegacy.name}`, () => {
+    describe(isLegacy.name, () => {
         const trigger = { cli: { legacy: true } };
         let location: string | undefined;
 

package/src/utils/__tests__/get-jest-config.test.ts

@@ -3,7 +3,7 @@ import path from 'path';
 import { getJestConfiguration } from '../get-configuration';
 import { getDestinationFolders } from '../get-destination-folders';
 
-import { getJestConfig, getJestConfigCLI } from '../get-jest-config';
+import { getJestConfigCLI } from '../get-jest-config';
 
 jest.mock('../get-destination-folders');
 jest.mock('../get-configuration', () => ({
@@ -14,20 +14,21 @@ jest.mock('../get-configuration', () => ({
 describe('[startup] Utils', () => {
     const destinationFolders = ['dist'];
     const defaultConfig: Record<string, any> = {
-        verbose: true,
-        testEnvironment: 'jsdom',
-        testRunner: 'jest-circus/runner',
-        transformIgnorePatterns: ['node_modules/(?!(@servicetitan|@react-hook|nanoid|axios)/)'],
-        modulePathIgnorePatterns: ['<rootDir>/.*/__mocks__'],
-        moduleNameMapper: {
-            '\\.(css|scss|less|png|svg|jpg|jpeg|gif|woff|woff2|eot|ttf|otf)$': 'identity-obj-proxy',
-        },
-        testPathIgnorePatterns: ['\\.yalc', ...destinationFolders],
-        setupFiles: [expect.stringContaining(path.join('jest', 'setup.js'))],
+        collectCoverageFrom: ['**/*.{ts,tsx}'],
         coveragePathIgnorePatterns: ['^.+\\.d\\.ts$'],
         coverageReporters: ['html-spa', 'text', 'json', 'cobertura', 'lcov'],
-        collectCoverageFrom: ['**/*.{ts,tsx}'],
+        moduleNameMapper: {
+            '\\.(css|scss|less|png|svg|svg\\?\\w+|jpg|jpeg|gif|woff|woff2|eot|ttf|otf)$':
+                'identity-obj-proxy',
+        },
+        modulePathIgnorePatterns: ['<rootDir>/.*/__mocks__'],
         preset: expect.stringMatching(/startup[\\\/]+jest/),
+        setupFiles: [expect.stringContaining(path.join('jest', 'setup.js'))],
+        testEnvironment: 'jsdom',
+        testPathIgnorePatterns: ['\\.yalc', ...destinationFolders],
+        testRunner: 'jest-circus/runner',
+        transformIgnorePatterns: ['node_modules/(?!(@servicetitan|@react-hook|nanoid|axios)/)'],
+        verbose: true,
     };
 
     beforeEach(() => {
@@ -35,62 +36,15 @@ describe('[startup] Utils', () => {
         jest.mocked(getJestConfiguration).mockReturnValue({});
     });
 
-    describe(`${getJestConfig.name}`, () => {
-        const subject = () => getJestConfig();
-
-        test('returns default config', () => {
-            expect(subject()).toEqual(defaultConfig);
-        });
-
-        describe.each(['coveragePathIgnorePatterns', 'setupFiles', 'testPathIgnorePatterns'])(
-            'with custom "%s"',
-            (
-                option: keyof Pick<
-                    typeof defaultConfig,
-                    'coveragePathIgnorePatterns' | 'setupFiles' | 'testPathIgnorePatterns'
-                >
-            ) => {
-                const customValue = ['foo', 'bar'];
-
-                beforeEach(() => {
-                    jest.mocked(getJestConfiguration).mockReturnValue({ [option]: customValue });
-                });
-
-                test(`appends custom value to "${option}"`, () => {
-                    expect(subject()).toEqual(
-                        expect.objectContaining({
-                            [option]: [...defaultConfig[option], ...customValue],
-                        })
-                    );
-                });
-            }
-        );
-
-        describe('with other custom options', () => {
-            const customOptions = { resetMocks: true, testEnvironment: 'node' };
-
-            beforeEach(() => jest.mocked(getJestConfiguration).mockReturnValue(customOptions));
-
-            test('merges custom options with default config', () => {
-                expect(subject()).toEqual({ ...defaultConfig, ...customOptions });
-            });
-        });
-    });
-
     describe(`${getJestConfigCLI.name}`, () => {
         // eslint-disable-next-line @typescript-eslint/naming-convention
         const args: Config.Argv = { _: [], $0: '', runInBand: true };
-        const globals = { foo: 'bar' };
 
         const subject = () => getJestConfigCLI(args);
 
-        beforeEach(() => {
-            jest.mocked(getJestConfiguration).mockReturnValue({ globals });
-        });
-
-        const stringified = ['collectCoverageFrom', 'moduleNameMapper', 'transform'].reduce(
+        const stringified = ['collectCoverageFrom', 'moduleNameMapper'].reduce(
             (result, key) => ({ ...result, [key]: JSON.stringify(defaultConfig[key]) }),
-            { globals: JSON.stringify(globals) }
+            {}
         );
 
         test(`merges command line args with default config and stringifies "${Object.keys(
@@ -102,5 +56,25 @@ describe('[startup] Utils', () => {
                 ...stringified,
             });
         });
+
+        test('stringifies globals config', () => {
+            const globals = { foo: 'bar' };
+
+            jest.mocked(getJestConfiguration).mockReturnValue({ globals });
+
+            expect(subject()).toEqual(
+                expect.objectContaining({ globals: JSON.stringify(globals) })
+            );
+        });
+
+        test('stringifies transform config', () => {
+            const transform = { '\\.css$': 'some-css-transformer' };
+
+            jest.mocked(getJestConfiguration).mockReturnValue({ transform });
+
+            expect(subject()).toEqual(
+                expect.objectContaining({ transform: JSON.stringify(transform) })
+            );
+        });
     });
 });

package/src/utils/get-configuration.ts

@@ -4,6 +4,7 @@ import { ESLint } from 'eslint';
 import fs from 'fs';
 import path from 'path';
 import { LinterOptions } from 'stylelint';
+import { ViteUserConfig } from 'vitest/config';
 import { Configuration as WebpackDevServerConfiguration } from 'webpack-dev-server';
 
 import { ReviewConfiguration } from '../cli/commands/review';
@@ -81,6 +82,8 @@ export enum CommandName {
 }
 /* eslint-enable @typescript-eslint/naming-convention */
 
+export type VitestConfiguration = ViteUserConfig['test'];
+
 export interface WebComponentBranchConfigs {
     publishTag?: string;
     uploadSourcemaps?: boolean;
@@ -96,15 +99,18 @@ interface WebComponentOptions {
 }
 
 type Configuration = {
+    'jest'?: JestConfiguration;
     'legacy'?: boolean;
     'lint'?: { eslint: ESLintConfiguration; stylelint: StylelintConfiguration };
     'review'?: ReviewConfiguration;
     'swc-compile-package'?: Parameters<typeof swcDir>[0];
-    'test'?: JestConfiguration;
+    'test'?: JestConfiguration; // for backward-compatibility
+    'testRunner'?: string;
+    'vitest'?: VitestConfiguration;
     'web-component'?: boolean | string | WebComponentOptions;
     'webpack'?: false | WebpackConfiguration;
 } & {
-    [key in CommandName]: NodeConfiguration;
+    [key in CommandName]?: NodeConfiguration;
 } & NodeConfiguration;
 
 type LocationOrJson = string | Record<string, any>;
@@ -130,7 +136,8 @@ export function getESLintConfiguration() {
 }
 
 export function getJestConfiguration() {
-    return getConfiguration().test ?? {};
+    const configuration = getConfiguration();
+    return configuration.jest ?? configuration.test ?? {};
 }
 
 export function getReviewConfiguration() {
@@ -141,6 +148,10 @@ export function getStylelintConfiguration() {
     return getConfiguration().lint?.stylelint ?? {};
 }
 
+export function getVitestConfiguration() {
+    return getConfiguration().vitest ?? {};
+}
+
 export function getWebpackConfiguration(locationOrJson?: LocationOrJson) {
     const { webpack } = getConfiguration(locationOrJson);
     return typeof webpack === 'object' ? webpack : {};

package/src/utils/get-jest-config.ts

@@ -1,10 +1,10 @@
-import path from 'path';
 import { Config } from '@jest/types';
-import { JestConfiguration, getJestConfiguration } from './get-configuration';
+import path from 'path';
+import { getJestConfiguration } from './get-configuration';
 import { getDestinationFolders } from './get-destination-folders';
 import { toArray } from './to-array';
 
-const getJestConfigBase = ({
+function getDefaultJestConfiguration({
     coveragePathIgnorePatterns = [],
     setupFiles = [],
     testPathIgnorePatterns = [],
@@ -12,68 +12,60 @@ const getJestConfigBase = ({
     coveragePathIgnorePatterns?: string[];
     setupFiles?: string[];
     testPathIgnorePatterns?: string[];
-}) => {
+}) {
     const moduleNameMapper = {
-        '\\.(css|scss|less|png|svg|jpg|jpeg|gif|woff|woff2|eot|ttf|otf)$': 'identity-obj-proxy',
+        '\\.(css|scss|less|png|svg|svg\\?\\w+|jpg|jpeg|gif|woff|woff2|eot|ttf|otf)$':
+            'identity-obj-proxy',
     };
 
     return {
-        verbose: true,
-        testEnvironment: 'jsdom',
-        testRunner: 'jest-circus/runner',
-        transformIgnorePatterns: ['node_modules/(?!(@servicetitan|@react-hook|nanoid|axios)/)'],
-        modulePathIgnorePatterns: ['<rootDir>/.*/__mocks__'],
+        collectCoverageFrom: ['**/*.{ts,tsx}'],
+        coveragePathIgnorePatterns: ['^.+\\.d\\.ts$', ...coveragePathIgnorePatterns],
+        coverageReporters: ['html-spa', 'text', 'json', 'cobertura', 'lcov'],
         moduleNameMapper,
+        modulePathIgnorePatterns: ['<rootDir>/.*/__mocks__'],
+        preset: path.join(__dirname, '../../jest'),
+        setupFiles: [path.join(__dirname, '../../jest/setup.js'), ...toArray(setupFiles)],
+        testEnvironment: 'jsdom',
         testPathIgnorePatterns: [
             '\\.yalc',
             ...getDestinationFolders(),
             ...toArray(testPathIgnorePatterns),
         ],
-        setupFiles: [path.join(__dirname, '../../jest/setup.js'), ...toArray(setupFiles)],
-        coveragePathIgnorePatterns: ['^.+\\.d\\.ts$', ...coveragePathIgnorePatterns],
-        coverageReporters: ['html-spa', 'text', 'json', 'cobertura', 'lcov'],
-        collectCoverageFrom: ['**/*.{ts,tsx}'],
-        preset: path.join(__dirname, '../../jest'),
-    };
-};
-
-/**
- * Get Jest clean config for running tests. This config could be used to export Jest configuration into the
- * Jest config files.
- */
-export const getJestConfig = (): JestConfiguration => {
-    const { coveragePathIgnorePatterns, setupFiles, testPathIgnorePatterns, ...config } =
-        getJestConfiguration() as Record<string, any>;
-    return {
-        ...getJestConfigBase({
-            coveragePathIgnorePatterns,
-            setupFiles,
-            testPathIgnorePatterns,
-        }),
-        ...config,
+        testRunner: 'jest-circus/runner',
+        transformIgnorePatterns: ['node_modules/(?!(@servicetitan|@react-hook|nanoid|axios)/)'],
+        verbose: true,
     };
-};
+}
 
 /**
  * Get Jest config for running it using jest CLI (see jest runCLI function)
  */
-export const getJestConfigCLI = (args: Config.Argv): Config.Argv => {
-    const { coveragePathIgnorePatterns, setupFiles, testPathIgnorePatterns, globals, ...config } = {
+export function getJestConfigCLI(args: Config.Argv): Config.Argv {
+    const { coveragePathIgnorePatterns, setupFiles, testPathIgnorePatterns, ...config } = {
         ...getJestConfiguration(),
         ...args,
     };
 
-    const { collectCoverageFrom, moduleNameMapper, ...rest } = getJestConfigBase({
-        coveragePathIgnorePatterns,
-        setupFiles,
-        testPathIgnorePatterns,
+    return stringifyForCLI({
+        ...getDefaultJestConfiguration({
+            coveragePathIgnorePatterns,
+            setupFiles,
+            testPathIgnorePatterns,
+        }),
+        ...config,
     });
+}
 
-    return {
-        collectCoverageFrom: JSON.stringify(collectCoverageFrom),
-        globals: JSON.stringify(globals),
-        moduleNameMapper: JSON.stringify(moduleNameMapper),
-        ...rest,
-        ...config,
-    };
-};
+function stringifyForCLI(config: any): Config.Argv {
+    return ['collectCoverageFrom', 'globals', 'moduleNameMapper', 'transform'].reduce(
+        (result, key) => {
+            const value = result[key];
+            if (value && typeof value !== 'string') {
+                result[key] = JSON.stringify(result[key]);
+            }
+            return result;
+        },
+        config
+    );
+}

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

@@ -34,8 +34,8 @@ jest.mock('mini-css-extract-plugin', () =>
 );
 jest.mock('moment-locales-webpack-plugin', () => jest.fn());
 jest.mock('webpack', () => ({
-    ...jest.requireActual('webpack'),
     DefinePlugin: jest.fn(),
+    IgnorePlugin: jest.fn(),
 }));
 jest.mock('webpack-assets-manifest', () => ({ WebpackAssetsManifest: jest.fn() }));
 jest.mock('webpack-remove-empty-scripts', () => jest.fn());

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

@@ -28,8 +28,8 @@ jest.mock('mini-css-extract-plugin', () =>
 );
 jest.mock('moment-locales-webpack-plugin', () => jest.fn());
 jest.mock('webpack', () => ({
-    ...jest.requireActual('webpack'),
     DefinePlugin: jest.fn(),
+    IgnorePlugin: jest.fn(),
 }));
 jest.mock('webpack-assets-manifest', () => ({ WebpackAssetsManifest: jest.fn() }));
 jest.mock('webpack-virtual-modules', () => jest.fn());