@servicetitan/startup 36.3.1 → 37.0.0

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

@@ -11,20 +11,19 @@ import { WebpackAssetsManifest } from 'webpack-assets-manifest';
 import RemoveEmptyScriptsPlugin from 'webpack-remove-empty-scripts';
 import VirtualModulesPlugin from 'webpack-virtual-modules';
 import yargs from 'yargs';
+import { getLaunchDarklySdkVersion } from '../../core';
 import {
     getFolders,
     getPackageData,
     getPackages,
     getTsConfig,
-    isCustomStyleRules,
     isExposeSharedDependencies,
     loadSharedDependencies,
     log,
     pick,
 } from '../../utils';
 import { miniCssPluginStyleRules } from '../__mocks__';
-import { getLaunchDarklySdkVersion } from '../configs/utils/get-launchdarkly-sdk-version';
-import { createWebpackConfig } from '../index';
+import { createWebpackConfig } from '../create-webpack-config';
 import { getModuleEntryPath } from '../utils';
 
 jest.mock('fs', () => fs);
@@ -50,11 +49,17 @@ jest.mock('../../utils', () => ({
     getPackageData: jest.fn(),
     getPackages: jest.fn(),
     getTsConfig: jest.fn(),
-    isCustomStyleRules: jest.fn(),
     isExposeSharedDependencies: jest.fn(),
     loadSharedDependencies: jest.fn(),
 }));
-jest.mock('../configs/utils/get-launchdarkly-sdk-version');
+/*
+ * Mock get-version (not core) because internal modules import from get-version
+ * directly. Mocking the core barrel doesn't intercept those internal imports.
+ */
+jest.mock('../../core/get-version', () => ({
+    ...jest.requireActual('../../core/get-version'),
+    getLaunchDarklySdkVersion: jest.fn(),
+}));
 jest.mock('../utils', () => ({
     ...jest.requireActual('../utils'),
     getCallerFile: jest.fn(),
@@ -91,7 +96,10 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
     }
 
     beforeEach(() => {
-        overrides = { plugins: { MiniCssExtractPlugin: { attributes: { foo: 'bar' } } } };
+        overrides = {
+            configuration: { mode: 'development' },
+            plugins: { MiniCssExtractPlugin: { attributes: { foo: 'bar' } } },
+        };
         options = { name: 'app' };
 
         jest.resetAllMocks();
@@ -120,6 +128,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         jest.mocked(getPackageManager).mockReturnValue({
             command: 'npm',
             lockFileName: 'package-lock.json',
+            getLockFilePath: jest.fn().mockReturnValue(undefined),
             getResolvedVersion: jest.fn().mockReturnValue(undefined),
             getWorkspacePackage: jest.fn().mockReturnValue(''),
         } as any);
@@ -207,7 +216,13 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         });
 
         describe('when package has custom style rules', () => {
-            beforeEach(() => jest.mocked(isCustomStyleRules).mockReturnValue(true));
+            beforeEach(() => {
+                vol.fromJSON({
+                    'package.json': JSON.stringify({
+                        cli: { webpack: { 'custom-style-rules': true } },
+                    }),
+                });
+            });
 
             test('does not configure MiniCssExtractPlugin plugin', () => {
                 expect(subject().plugins).not.toContainEqual(
@@ -258,7 +273,13 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             test('configures HtmlWebpackTagsPlugin plug', () => {
                 expect(subject().plugins).toContainEqual(
                     new HtmlWebpackTagsPlugin({
-                        tags: [...entryPoints.css, ...entryPoints.js].map(name => `shared/${name}`),
+                        tags: [
+                            ...entryPoints.css.map(name => ({
+                                path: `shared/${name}`,
+                                attributes: { crossorigin: 'anonymous' },
+                            })),
+                            ...entryPoints.js.map(name => `shared/${name}`),
+                        ],
                         append: false,
                     })
                 );
@@ -289,9 +310,9 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                 expect(plugins).toContainEqual(
                     new VirtualModulesPlugin({
                         [(entry as EntryObject)?.['design-system'] as string]: [
-                            `@import '~@servicetitan/tokens/core/tokens.css';`,
-                            `@import '~@servicetitan/anvil-fonts/dist/css/anvil-fonts.css';`,
-                            `@import '~@servicetitan/design-system/dist/system.min.css';`,
+                            `@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'),
                     })
                 );
@@ -315,6 +336,19 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                     name: 'anvil2',
                     chunks: 'all',
                     enforce: true,
+                    priority: 10,
+                });
+            });
+
+            describe('in production', () => {
+                beforeEach(() => (overrides.configuration!.mode = 'production'));
+
+                test('ranks anvil2 above the servicetitan vendor group', () => {
+                    const { cacheGroups } = subject().optimization!.splitChunks as any;
+
+                    expect(cacheGroups.anvil2.priority).toBeGreaterThan(
+                        cacheGroups.servicetitan.priority ?? 0
+                    );
                 });
             });
 
@@ -329,12 +363,12 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             });
 
             describe('with custom "output.path"', () => {
-                const output = { path: path.resolve(process.cwd(), 'foo') };
+                const outputPath = path.resolve(process.cwd(), 'foo');
 
-                beforeEach(() => (options = { emitExposedDependencies: { output } }));
+                beforeEach(() => (overrides.configuration!.output = { path: outputPath }));
 
-                test('use custom "output.path"', () => {
-                    expect(subject().output?.path).toBe(path.join(output.path, 'shared'));
+                test('uses custom "output.path"', () => {
+                    expect(subject().output?.path).toBe(path.join(outputPath, 'shared'));
                 });
             });
 
@@ -349,6 +383,42 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                 );
             });
 
+            test('WebpackAssetsManifest plugin moves design-system CSS before anvil2 CSS', () => {
+                const assets = {
+                    entrypoints: {
+                        'shared': { assets: { css: ['anvil2.bundle.css'] } },
+                        'design-system': { assets: { css: ['design-system.bundle.css'] } },
+                    },
+                };
+
+                subject();
+
+                const transform: any =
+                    jest.mocked(WebpackAssetsManifest).mock.calls[0][0]?.transform;
+                expect(transform(assets)).toEqual(
+                    expect.objectContaining({
+                        css: ['design-system.bundle.css', 'anvil2.bundle.css'],
+                    })
+                );
+            });
+
+            test('WebpackAssetsManifest plugin dedupes a chunk shared by entry points', () => {
+                const assets = {
+                    entrypoints: {
+                        'shared': { assets: { css: ['servicetitan.bundle.css'] } },
+                        'design-system': { assets: { css: ['servicetitan.bundle.css'] } },
+                    },
+                };
+
+                subject();
+
+                const transform: any =
+                    jest.mocked(WebpackAssetsManifest).mock.calls[0][0]?.transform;
+                expect(transform(assets)).toEqual(
+                    expect.objectContaining({ css: ['servicetitan.bundle.css'] })
+                );
+            });
+
             test('generates exposed-dependencies-metadata.json when WebpackAssetsManifest plugin is done', () => {
                 const entryPointsPath = path.join(process.cwd(), destination, 'entrypoints.json');
                 const manifest = { getOutputPath: () => entryPointsPath };
@@ -374,7 +444,12 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             });
 
             describe('with package-lock.json', () => {
-                beforeEach(() => volumeFromJSON({ '../package-lock.json': {} }));
+                beforeEach(() => {
+                    volumeFromJSON({ '../package-lock.json': {} });
+                    jest.mocked(getPackageManager().getLockFilePath).mockReturnValue(
+                        path.resolve('../package-lock.json')
+                    );
+                });
 
                 test('configures "cache.buildDependencies"', () => {
                     expect(subject().cache).toEqual(

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

@@ -2,11 +2,12 @@ import HtmlWebpackPlugin from 'html-webpack-plugin';
 import { fs, vol } from 'memfs';
 import MiniCssExtractPlugin from 'mini-css-extract-plugin';
 import path from 'path';
+import TerserPlugin from 'terser-webpack-plugin';
 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 { CHUNK_PATTERNS, generateMetadata } from '../../core';
 import {
     getFolders,
     getPackageData,
@@ -16,8 +17,11 @@ import {
     isWebComponent,
 } from '../../utils';
 import { miniCssPluginStyleRules } from '../__mocks__';
-import { generateMetadata } from '../configs/utils';
-import { createWebpackConfig } from '../index';
+import {
+    createWebpackConfig,
+    webpackDevConfigFileName,
+    webpackProdConfigFileName,
+} from '../create-webpack-config';
 import { getCallerFile, splitByEntry } from '../utils';
 
 jest.mock('fs', () => fs);
@@ -26,6 +30,7 @@ jest.mock('mini-css-extract-plugin', () =>
     Object.assign(jest.fn(), { loader: 'MiniCssExtractPlugin.loader' })
 );
 jest.mock('moment-locales-webpack-plugin', () => jest.fn());
+jest.mock('terser-webpack-plugin', () => jest.fn());
 jest.mock('webpack', () => ({
     DefinePlugin: jest.fn(),
     IgnorePlugin: jest.fn(),
@@ -42,7 +47,7 @@ jest.mock('../../utils', () => ({
     isLegacyRoot: jest.fn(),
     isWebComponent: jest.fn(),
 }));
-jest.mock('../configs/utils/generate-metadata');
+jest.mock('../../core/metadata/generate-metadata');
 jest.mock('../utils', () => ({
     ...jest.requireActual('../utils'),
     getCallerFile: jest.fn(),
@@ -57,22 +62,22 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
     const tsConfig = 'tsconfig.build.json';
     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';`,
+        `@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(), `${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');`] : []),
+            ...(designSystem ? [`import './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];
@@ -86,6 +91,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
 
     beforeEach(() => {
         overrides = {
+            configuration: { mode: 'development' },
             plugins: {
                 HtmlWebpackPlugin: { favicon: 'foo' },
                 MiniCssExtractPlugin: { attributes: { foo: 'bar' } },
@@ -102,6 +108,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         jest.mocked(DefinePlugin).mockImplementation(mockPlugIn('DefinePlugin'));
         jest.mocked(HtmlWebpackPlugin).mockImplementation(mockPlugIn('HtmlWebpackPlugin'));
         jest.mocked(VirtualModulesPlugin).mockImplementation(mockPlugIn('VirtualModulesPlugin'));
+        jest.mocked(TerserPlugin).mockImplementation(mockPlugIn('TerserPlugin'));
         jest.mocked(WebpackAssetsManifest).mockImplementation(mockPlugIn('WebpackAssetsManifest'));
         jest.mocked(yargs).mockImplementation(() => ({ argv: {} }) as any);
 
@@ -134,7 +141,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             },
             servicetitan: {
                 name: 'servicetitan',
-                test: /[\\/]node_modules[\\/]@servicetitan[\\/]/,
+                test: CHUNK_PATTERNS.servicetitan,
                 chunks: 'all',
             },
         };
@@ -207,7 +214,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                 entrypoints: {
                     foo: {
                         assets: {
-                            css: ['main.css', 'servicetitan.css', 'common.css'],
+                            css: ['main.css', 'servicetitan.css', 'vendor-core.css'],
                         },
                     },
                 },
@@ -217,7 +224,9 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
 
             const transform: any = jest.mocked(WebpackAssetsManifest).mock.calls[0][0]?.transform;
             expect(transform(assets)).toEqual(
-                expect.objectContaining({ css: ['servicetitan.css', 'main.css', 'common.css'] })
+                expect.objectContaining({
+                    css: ['servicetitan.css', 'main.css', 'vendor-core.css'],
+                })
             );
         });
 
@@ -331,13 +340,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 +375,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 }),
                         })
                     );
                 });
@@ -380,7 +389,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                 expect(subject().plugins).toContainEqual(
                     new VirtualModulesPlugin({
                         [indexPath()]: [
-                            "import { registerHeadless } from '@servicetitan/web-components';",
+                            "import { registerHeadless } from '@servicetitan/web-components/register-headless';",
                             "import { connectedCallback, disconnectedCallback } from './headless';",
                             'registerHeadless(connectedCallback, disconnectedCallback);',
                         ].join('\n'),
@@ -393,6 +402,44 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                     path.join(process.cwd(), destination, 'bundle', 'headless')
                 );
             });
+
+            test('omits "optimization.splitChunks.cacheGroups"', () => {
+                // @ts-expect-error because splitChunks is polymorphic
+                expect(subject().optimization?.splitChunks.cacheGroups).toEqual({});
+            });
+
+            describe('when mode is production', () => {
+                beforeEach(() =>
+                    Object.assign((overrides.configuration ??= {}), { mode: 'production' })
+                );
+
+                test('configures "optimization.splitChunks.cacheGroups"', () => {
+                    // @ts-expect-error because splitChunks is polymorphic
+                    expect(subject().optimization?.splitChunks.cacheGroups).toEqual({
+                        'servicetitan': {
+                            name: 'servicetitan',
+                            test: CHUNK_PATTERNS.servicetitan,
+                            chunks: 'all',
+                        },
+                        'vendor-core': {
+                            name: 'vendor-core',
+                            test: CHUNK_PATTERNS['vendor-core'],
+                            chunks: 'all',
+                        },
+                        'kendo': {
+                            name: 'kendo',
+                            test: CHUNK_PATTERNS.kendo,
+                            chunks: 'all',
+                        },
+                        'vendor': {
+                            name: 'vendor',
+                            test: CHUNK_PATTERNS.vendor,
+                            chunks: 'all',
+                            priority: -5,
+                        },
+                    });
+                });
+            });
         });
 
         describe.each([webpackDevConfigFileName, webpackProdConfigFileName])(
@@ -415,20 +462,26 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                 expect(subject().devtool).toBe('source-map');
             });
 
-            test('adds "common" and "kendo" to "optimization.splitChunks.cacheGroups"', () => {
+            test('adds "vendor-core", "kendo", and "vendor" to "optimization.splitChunks.cacheGroups"', () => {
                 // @ts-expect-error because splitChunks is polymorphic
                 expect(subject().optimization?.splitChunks.cacheGroups).toEqual({
                     ...baseCacheGroups,
-                    common: {
-                        name: 'common',
-                        test: /[\\/]node_modules[\\/](axios|classnames|formstate|mobx|mobx-react|mobx-utils|react|react-dom|react-router|react-router-dom)[\\/]/,
+                    'vendor-core': {
+                        name: 'vendor-core',
+                        test: CHUNK_PATTERNS['vendor-core'],
                         chunks: 'all',
                     },
-                    kendo: {
+                    'kendo': {
                         name: 'kendo',
-                        test: /[\\/]node_modules[\\/](@progress|@telerik)[\\/]/,
+                        test: CHUNK_PATTERNS.kendo,
                         chunks: 'all',
                     },
+                    'vendor': {
+                        name: 'vendor',
+                        test: CHUNK_PATTERNS.vendor,
+                        chunks: 'all',
+                        priority: -5,
+                    },
                 });
             });
 
@@ -436,6 +489,12 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                 expect(subject().output?.uniqueName).toEqual(options.name);
             });
 
+            test('enables terser compress and mangle', () => {
+                expect(subject().optimization?.minimizer).toContainEqual(
+                    new TerserPlugin({ terserOptions: { compress: true, mangle: true } })
+                );
+            });
+
             describe('when headless option is set to true', () => {
                 beforeEach(() => (options.headless = true));
 

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

@@ -6,21 +6,22 @@ import MomentLocalesPlugin from 'moment-locales-webpack-plugin';
 import os from 'os';
 import path from 'path';
 import TerserPlugin from 'terser-webpack-plugin';
-import { IgnorePlugin, ProvidePlugin } from 'webpack';
+import { DefinePlugin, IgnorePlugin, ProvidePlugin } from 'webpack';
 import WebpackDevServer from 'webpack-dev-server';
 import yargs from 'yargs';
 const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
 const FilterWarningsPlugin = require('webpack-filter-warnings-plugin');
 
 import { getPackageManager } from '@servicetitan/install';
+import { CHUNK_PATTERNS } from '../../core';
 import {
     getConfiguration,
+    getExposeProcessEnv,
     getFolders,
     getPackageData,
     getPackages,
     getTsConfig,
     getWebpackConfiguration,
-    isCustomStyleRules,
     isDevServerDisabled,
     isWebComponent,
     loadSharedDependencies,
@@ -30,10 +31,9 @@ import {
 } from '../../utils';
 import { fileRules, productionStyleRules, styleRules } from '../__mocks__';
 import { JS_RULE_EXCLUDE } from '../configs/constants';
+import { createWebpackConfig } from '../create-webpack-config';
 import { splitByEntry } from '../utils';
 
-import { createWebpackConfig } from '../index';
-
 jest.mock('fs', () => fs);
 jest.mock('css-minimizer-webpack-plugin', () => jest.fn());
 jest.mock('html-webpack-plugin', () => jest.fn());
@@ -57,12 +57,12 @@ jest.mock('@servicetitan/install', () => ({ getPackageManager: jest.fn() }));
 jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
     getConfiguration: jest.fn(),
+    getExposeProcessEnv: jest.fn(),
     getFolders: jest.fn(),
     getPackageData: jest.fn(),
     getPackages: jest.fn(),
     getTsConfig: jest.fn(),
     getWebpackConfiguration: jest.fn(),
-    isCustomStyleRules: jest.fn(),
     isDevServerDisabled: jest.fn(),
     isExposeSharedDependencies: jest.fn(),
     isWebComponent: jest.fn(),
@@ -110,6 +110,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         argv = {};
         packages = [];
         overrides = {
+            configuration: { mode: 'development' },
             plugins: {
                 HtmlWebpackPlugin: { favicon: 'foo' },
                 MiniCssExtractPlugin: { attributes: { foo: 'bar' } },
@@ -202,6 +203,26 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         expect(subject().output!.path).toEqual(path.join(process.cwd(), destination, 'bundle'));
     });
 
+    describe('with custom "output.path"', () => {
+        const output = { path: '/foo' };
+
+        beforeEach(() => (overrides.configuration!.output = output));
+
+        test('uses custom output.path', () => {
+            expect(subject().output!.path).toEqual(output.path);
+        });
+
+        describe('when package is web component', () => {
+            beforeEach(() => jest.mocked(isWebComponent).mockReturnValue(true));
+
+            test('uses default output.path', () => {
+                expect(subject().output!.path).toEqual(
+                    path.join(process.cwd(), destination, 'bundle', 'full')
+                );
+            });
+        });
+    });
+
     test('configures "optimization"', () => {
         expect(subject().optimization).toEqual({
             chunkIds: 'named',
@@ -420,7 +441,9 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
     });
 
     describe('when package has custom style rules', () => {
-        beforeEach(() => jest.mocked(isCustomStyleRules).mockReturnValue(true));
+        beforeEach(() => {
+            configuration.webpack = { 'custom-style-rules': true };
+        });
 
         Object.entries(styleRules).forEach(([extension, rule]) => {
             test(`omits "${extension}" rules`, () => {
@@ -486,10 +509,11 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         );
     });
 
-    test('configures IgnorePlugin plugin', () => {
-        expect(subject().plugins).toContainEqual(
-            new IgnorePlugin({ checkResource: expect.any(Function) })
+    test('configures IgnoreOptionalDependenciesPlugin', () => {
+        const plugin = subject().plugins?.find(
+            p => p?.constructor.name === 'IgnoreOptionalDependenciesPlugin'
         );
+        expect(plugin).toBeDefined();
     });
 
     describe('when buildStat option is set to true', () => {
@@ -508,9 +532,10 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         function reportTitle(type?: string) {
             const date = new Date();
 
-            const timestamp = `${date.getFullYear()}-${
+            const zeroPad = (n: number) => n.toString().padStart(2, '0');
+            const timestamp = `${date.getFullYear()}-${zeroPad(
                 date.getMonth() + 1
-            }-${date.getDate()} ${date.getHours()}:${date.getMinutes()}`;
+            )}-${zeroPad(date.getDate())} ${zeroPad(date.getHours())}:${zeroPad(date.getMinutes())}`;
 
             return `${packageName.replace('@servicetitan/', '')}${
                 type ? ` (${type})` : ''
@@ -540,8 +565,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(
@@ -594,6 +619,33 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             expect(subject().optimization?.runtimeChunk).toBe('single');
         });
 
+        test('configures "optimization.splitChunks.cacheGroups"', () => {
+            // @ts-expect-error because splitChunks is polymorphic
+            expect(subject().optimization?.splitChunks.cacheGroups).toEqual({
+                'servicetitan': {
+                    name: 'servicetitan',
+                    test: CHUNK_PATTERNS.servicetitan,
+                    chunks: 'all',
+                },
+                'vendor-core': {
+                    name: 'vendor-core',
+                    test: CHUNK_PATTERNS['vendor-core'],
+                    chunks: 'all',
+                },
+                'kendo': {
+                    name: 'kendo',
+                    test: CHUNK_PATTERNS.kendo,
+                    chunks: 'all',
+                },
+                'vendor': {
+                    name: 'vendor',
+                    test: CHUNK_PATTERNS.vendor,
+                    chunks: 'all',
+                    priority: -5,
+                },
+            });
+        });
+
         test('configures "optimization.minimize"', () => {
             expect(subject().optimization?.minimize).toBe(true);
         });
@@ -680,4 +732,36 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             expect(subject).toThrow('package does not expose shared dependencies');
         });
     });
+
+    describe('with "expose-process-env"', () => {
+        const variable = 'API_URL';
+        const value = 'https://api.example.com';
+
+        beforeEach(() => {
+            jest.mocked(getExposeProcessEnv).mockReturnValue([variable]);
+            process.env[variable] = value;
+        });
+
+        afterEach(() => delete process.env[variable]);
+
+        test('defines the variable via DefinePlugin', () => {
+            subject();
+
+            expect(DefinePlugin).toHaveBeenCalledWith({
+                [`process.env.${variable}`]: JSON.stringify(value),
+            });
+        });
+
+        describe('when variable is not set', () => {
+            beforeEach(() => delete process.env[variable]);
+
+            test('defines the variable as undefined', () => {
+                subject();
+
+                expect(DefinePlugin).toHaveBeenCalledWith({
+                    [`process.env.${variable}`]: 'undefined',
+                });
+            });
+        });
+    });
 });