@servicetitan/startup 33.1.1 → 34.0.0

package/src/cli/utils/stylelint.ts

@@ -1,9 +1,8 @@
 import path from 'path';
 import { lint } from 'stylelint';
-import { CommandArgs } from '../commands';
 import { getDestinationFolders, getStylelintConfiguration, log } from '../../utils';
 
-interface Args extends CommandArgs {
+interface Args {
     fix?: boolean;
     paths?: string[];
 }

package/src/index.ts

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

package/src/jest/svg-transformer.ts

@@ -1,5 +1,4 @@
 import type { Transformer } from '@jest/transform';
-
 import { transformSVG } from '../utils/transform-svg';
 
 const svgTransformer: Transformer = {

package/src/utils/__tests__/get-branch-configs.test.ts

@@ -1,5 +1,4 @@
 import { fs, vol } from 'memfs';
-
 import { getBranchesConfigs } from '../get-branch-configs';
 
 jest.mock('fs', () => fs);

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

@@ -1,6 +1,5 @@
 import { fs, vol } from 'memfs';
 import path from 'path';
-
 import {
     getConfiguration,
     getConfigurationSafe,

package/src/utils/__tests__/get-destination-folders.test.ts

@@ -1,7 +1,6 @@
 import { fs, vol } from 'memfs';
-import { getPackages } from '../get-packages';
-
 import { getDestinationFolders } from '../get-destination-folders';
+import { getPackages } from '../get-packages';
 
 jest.mock('fs', () => fs);
 jest.mock('../get-packages', () => ({ getPackages: jest.fn() }));

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

@@ -1,5 +1,4 @@
 import { fs, vol } from 'memfs';
-
 import { getFolders } from '..';
 
 jest.mock('fs', () => fs);

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

@@ -2,9 +2,8 @@ import { Config } from '@jest/types';
 import path from 'path';
 import { getJestConfiguration } from '../get-configuration';
 import { getDestinationFolders } from '../get-destination-folders';
-import { pick } from '../pick';
-
 import { getJestConfigCLI } from '../get-jest-config';
+import { pick } from '../pick';
 
 jest.mock('../get-destination-folders');
 jest.mock('../get-configuration', () => ({

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

@@ -1,6 +1,5 @@
-import { readJson } from '../read-json';
-
 import { getPackageData, getPackageDependencyVersion } from '../get-package-data';
+import { readJson } from '../read-json';
 
 jest.mock('../read-json', () => ({ readJson: jest.fn() }));
 

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

@@ -1,5 +1,5 @@
-import path from 'path';
 import { fs, vol } from 'memfs';
+import path from 'path';
 import { PackageType, getPackages, getPackagesGraph } from '../get-packages';
 
 jest.mock('fs', () => fs);

package/src/utils/__tests__/get-startup-version.test.ts

@@ -1,5 +1,4 @@
 import { fs, vol } from 'memfs';
-
 import { getStartupVersion } from '../get-startup-version';
 
 jest.mock('fs', () => fs);

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

@@ -1,6 +1,5 @@
 import { fs, vol } from 'memfs';
 import path from 'path';
-
 import { getTsConfig } from '../get-tsconfig';
 
 jest.mock('fs', () => fs);

package/src/utils/__tests__/load-shared-dependencies.test.ts

@@ -1,6 +1,6 @@
 import { loadSharedDependencies } from '../load-shared-dependencies';
 
-describe(`[startup] utils:${loadSharedDependencies.name}`, () => {
+describe(`[startup] ${loadSharedDependencies.name}`, () => {
     const defaultSharedDependencies = {
         '@servicetitan/design-system': 'SharedDependencies.ServiceTitan.DesignSystem',
         '@servicetitan/anvil2': 'SharedDependencies.ServiceTitan.Anvil2',

package/src/utils/__tests__/log.test.ts

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
-import { log } from '../log';
 import { createDebug } from '../debug';
+import { log } from '../log';
 
 jest.mock('../debug');
 

package/src/utils/__tests__/prettify.test.ts

@@ -0,0 +1,80 @@
+import { exec, execSync } from 'node:child_process';
+import { prettify, prettifySync } from '../prettify';
+
+jest.mock('node:child_process', () => ({
+    exec: jest.fn(),
+    execSync: jest.fn(),
+}));
+
+describe('[startup] Prettify Utils', () => {
+    const filename = '/path/to/file.ts';
+    const expectedCommand = `npx prettier -w "${filename}"`;
+
+    beforeEach(() => {
+        jest.resetAllMocks();
+    });
+
+    describe(`${prettify.name}`, () => {
+        const subject = () => prettify(filename);
+
+        beforeEach(() => {
+            jest.mocked(exec).mockImplementation(((_cmd: string, callback: any) => {
+                callback(null, '', '');
+            }) as any);
+        });
+
+        test('executes correct prettier command', async () => {
+            await subject();
+
+            expect(exec).toHaveBeenCalledWith(expectedCommand, expect.any(Function));
+        });
+
+        describe('when prettier fails', () => {
+            const exitCode = 2;
+
+            beforeEach(() => {
+                jest.mocked(exec).mockImplementation(((_cmd: string, callback: any) => {
+                    callback({ exitCode });
+                }) as any);
+            });
+
+            test('throws error with exit code', async () => {
+                await expect(subject()).rejects.toThrow(
+                    `prettier failed with exit code ${exitCode}`
+                );
+            });
+        });
+    });
+
+    describe(`${prettifySync.name}`, () => {
+        const subject = () => prettifySync(filename);
+
+        beforeEach(() => {
+            jest.mocked(execSync).mockReturnValue('');
+        });
+
+        test('executes correct prettier command', () => {
+            subject();
+
+            expect(execSync).toHaveBeenCalledWith(expectedCommand, {
+                stdio: ['pipe', 'ignore', 'pipe'],
+            });
+        });
+
+        describe('when prettier fails', () => {
+            const status = 2;
+
+            beforeEach(() => {
+                jest.mocked(execSync).mockImplementation(() => {
+                    const error = new Error('Command failed') as Error & { status: number };
+                    error.status = status;
+                    throw error;
+                });
+            });
+
+            test('throws error with exit code', () => {
+                expect(() => subject()).toThrow(`prettier failed with exit code ${status}`);
+            });
+        });
+    });
+});

package/src/utils/__tests__/read-json.test.ts

@@ -1,5 +1,4 @@
 import { fs, vol } from 'memfs';
-
 import { readJson } from '..';
 
 jest.mock('fs', () => fs);

package/src/utils/find-packages.ts

@@ -2,8 +2,8 @@ import { globSync } from 'glob';
 import multimatch from 'multimatch';
 import path from 'path';
 import { findUp } from './find-up';
-import { readJsonSafe } from './read-json';
 import { log } from './log';
+import { readJsonSafe } from './read-json';
 
 export interface ProjectPackage extends Record<string, any> {
     name: string;

package/src/utils/get-configuration.ts

@@ -6,10 +6,9 @@ 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';
-import { log } from './log';
 import { getFolders } from './get-folders';
+import { log } from './log';
 import { readJson, readJsonSafe } from './read-json';
 
 export const allowedWebpackDevServerOptions = ['headers', 'port', 'proxy', 'static'] as const;
@@ -28,11 +27,10 @@ export interface MinifyOptions {
     js?: boolean | MinifyJSOptions;
 }
 
-export interface WebpackConfiguration
-    extends Omit<
-        Pick<WebpackDevServerConfiguration, ElementType<typeof allowedWebpackDevServerOptions>>,
-        'proxy'
-    > {
+export interface WebpackConfiguration extends Omit<
+    Pick<WebpackDevServerConfiguration, ElementType<typeof allowedWebpackDevServerOptions>>,
+    'proxy'
+> {
     'contentBase'?: boolean | string | string[] | number; // deprecated 2024-07
     'custom-style-rules'?: boolean;
     'expose-shared-dependencies'?: boolean;
@@ -71,9 +69,12 @@ export enum CommandName {
     'install' = 'install',
     'kendo-ui-license' = 'kendo-ui-license',
     'lint' = 'lint',
+    'mfe-check' = 'mfe-check',
+    'mfe-generate-metadata' = 'mfe-generate-metadata',
     'mfe-list' = 'mfe-list',
     'mfe-package-clean' = 'mfe-package-clean',
     'mfe-package-publish' = 'mfe-package-publish',
+    'mfe-package-rollback' = 'mfe-package-rollback',
     'mfe-publish' = 'mfe-publish',
     'prepare-package' = 'prepare-package',
     'review' = 'review',

package/src/utils/get-destination-folders.ts

@@ -1,6 +1,5 @@
 import fs from 'fs';
 import path from 'path';
-
 import { getPackages, readJson } from '.';
 
 /**

package/src/utils/get-folders.ts

@@ -1,5 +1,4 @@
 import path from 'path';
-
 import { readJson } from './read-json';
 
 /**

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

@@ -2,8 +2,8 @@ import { Config } from '@jest/types';
 import path from 'path';
 import { getJestConfiguration } from './get-configuration';
 import { getDestinationFolders } from './get-destination-folders';
-import { toArray } from './to-array';
 import { omit } from './omit';
+import { toArray } from './to-array';
 
 function getDefaultJestConfiguration() {
     const moduleNameMapper = {

package/src/utils/index.ts

@@ -17,5 +17,6 @@ export * from './log';
 export * from './log-errors';
 export * from './omit';
 export * from './pick';
+export * from './prettify';
 export * from './read-json';
 export * from './to-array';

package/src/utils/prettify.ts

@@ -0,0 +1,36 @@
+import { exec, execSync } from 'node:child_process';
+import { promisify } from 'node:util';
+
+function getCommand(filename: string) {
+    return `npx prettier -w "${filename}"`;
+}
+
+function createError(exitCode: number) {
+    return new Error(`prettier failed with exit code ${exitCode}`);
+}
+
+/**
+ * Format a file using Prettier.
+ * @param filename - The path to the file to format
+ * @throws Error if Prettier fails
+ */
+export async function prettify(filename: string) {
+    try {
+        await promisify(exec)(getCommand(filename));
+    } catch (error: any) {
+        throw createError(error.exitCode);
+    }
+}
+
+/**
+ * Format a file using Prettier.
+ * @param filename - The path to the file to format
+ * @throws Error if Prettier fails
+ */
+export function prettifySync(filename: string) {
+    try {
+        execSync(getCommand(filename), { stdio: ['pipe', 'ignore', 'pipe'] });
+    } catch (error: any) {
+        throw createError(error.status);
+    }
+}

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

@@ -1,4 +1,5 @@
 import { fs, vol } from 'memfs';
+
 import * as mockFS from 'fs';
 import HtmlWebpackPlugin from 'html-webpack-plugin';
 import HtmlWebpackTagsPlugin from 'html-webpack-tags-plugin';
@@ -8,6 +9,7 @@ import { DefinePlugin, EntryObject } from 'webpack';
 import { WebpackAssetsManifest } from 'webpack-assets-manifest';
 import RemoveEmptyScriptsPlugin from 'webpack-remove-empty-scripts';
 import VirtualModulesPlugin from 'webpack-virtual-modules';
+import yargs from 'yargs';
 import {
     getFolders,
     getPackageData,
@@ -22,9 +24,8 @@ import {
 } from '../../utils';
 import { miniCssPluginStyleRules } from '../__mocks__';
 import { getLaunchDarklySdkVersion } from '../configs/utils/get-launchdarkly-sdk-version';
-import { getModuleEntryPath } from '../utils';
-
 import { createWebpackConfig } from '../index';
+import { getModuleEntryPath } from '../utils';
 
 jest.mock('fs', () => fs);
 jest.mock('html-webpack-plugin', () => jest.fn());
@@ -40,6 +41,8 @@ jest.mock('webpack', () => ({
 jest.mock('webpack-assets-manifest', () => ({ WebpackAssetsManifest: jest.fn() }));
 jest.mock('webpack-remove-empty-scripts', () => jest.fn());
 jest.mock('webpack-virtual-modules', () => jest.fn());
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
 
 jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
@@ -102,6 +105,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         jest.mocked(RemoveEmptyScriptsPlugin).mockImplementation(
             mockPlugIn('WebpackRemoveEmptyScriptsPlugin')
         );
+        jest.mocked(yargs).mockImplementation(() => ({ argv: {} }) as any);
 
         jest.mocked(getFolders).mockReturnValue({ source, destination });
         jest.mocked(getModuleEntryPath).mockImplementation(name => `${name}/entryPath`);

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

@@ -1,11 +1,11 @@
 import HtmlWebpackPlugin from 'html-webpack-plugin';
-import MiniCssExtractPlugin from 'mini-css-extract-plugin';
 import { fs, vol } from 'memfs';
+import MiniCssExtractPlugin from 'mini-css-extract-plugin';
 import path from 'path';
 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 {
     getFolders,
@@ -17,9 +17,8 @@ import {
 } from '../../utils';
 import { miniCssPluginStyleRules } from '../__mocks__';
 import { generateMetadata } from '../configs/utils';
-import { getCallerFile, splitByEntry } from '../utils';
-
 import { createWebpackConfig } from '../index';
+import { getCallerFile, splitByEntry } from '../utils';
 
 jest.mock('fs', () => fs);
 jest.mock('html-webpack-plugin', () => jest.fn());
@@ -33,6 +32,9 @@ jest.mock('webpack', () => ({
 }));
 jest.mock('webpack-assets-manifest', () => ({ WebpackAssetsManifest: jest.fn() }));
 jest.mock('webpack-virtual-modules', () => jest.fn());
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
+
 jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
     getFolders: jest.fn(),
@@ -103,6 +105,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         jest.mocked(HtmlWebpackPlugin).mockImplementation(mockPlugIn('HtmlWebpackPlugin'));
         jest.mocked(VirtualModulesPlugin).mockImplementation(mockPlugIn('VirtualModulesPlugin'));
         jest.mocked(WebpackAssetsManifest).mockImplementation(mockPlugIn('WebpackAssetsManifest'));
+        jest.mocked(yargs).mockImplementation(() => ({ argv: {} }) as any);
 
         jest.mocked(getCallerFile).mockReturnValue('');
         jest.mocked(getFolders).mockReturnValue({ source, destination });

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

@@ -1,16 +1,16 @@
 import CssMinimizerWebpackPlugin from 'css-minimizer-webpack-plugin';
 import HtmlWebpackPlugin from 'html-webpack-plugin';
-import MiniCssExtractPlugin from 'mini-css-extract-plugin';
 import { fs, vol } from 'memfs';
+import MiniCssExtractPlugin from 'mini-css-extract-plugin';
 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 WebpackDevServer from 'webpack-dev-server';
+import yargs from 'yargs';
 const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
 const FilterWarningsPlugin = require('webpack-filter-warnings-plugin');
-import { argv } from 'yargs';
 
 import {
     Package,
@@ -50,7 +50,9 @@ jest.mock('webpack-assets-manifest', () => ({ WebpackAssetsManifest: jest.fn() }
 jest.mock('webpack-bundle-analyzer', () => ({ BundleAnalyzerPlugin: jest.fn() }));
 jest.mock('webpack-filter-warnings-plugin', () => jest.fn());
 jest.mock('webpack-virtual-modules', () => jest.fn());
-jest.mock('yargs', () => ({ argv: {} }));
+jest.mock('yargs', () => jest.fn());
+jest.mock('yargs/helpers', () => ({ hideBin: jest.fn() }));
+
 jest.mock('../../utils', () => ({
     ...jest.requireActual('../../utils'),
     getConfiguration: jest.fn(),
@@ -93,6 +95,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
     let overrides: Parameters<typeof createWebpackConfig>[0];
     let options: Parameters<typeof createWebpackConfig>[1];
     let configuration: { webpack?: WebpackConfiguration };
+    let argv: Partial<yargs.Argv>;
 
     function mockPlugIn(name: string): any {
         return (options: Record<string, any>): any => ({ [name]: options });
@@ -104,6 +107,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
     }
 
     beforeEach(() => {
+        argv = {};
         packages = [];
         overrides = {
             plugins: {
@@ -147,7 +151,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         jest.mocked(getTsConfig).mockReturnValue(tsConfig);
         jest.mocked(loadSharedDependencies).mockReturnValue(sharedDependencies);
 
-        Object.keys(argv).forEach(key => delete (argv as any)[key]);
+        jest.mocked(yargs).mockImplementation(() => ({ argv }) as any);
 
         vol.fromJSON({ [packageJson]: JSON.stringify({ name: packageName }) });
     });

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

@@ -1,5 +1,5 @@
-import path from 'path';
 import fs from 'fs';
+import path from 'path';
 import { Configuration } from 'webpack';
 import { findUp } from '../../utils';
 import { Context, Overrides } from './types';

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

@@ -1,9 +1,9 @@
 import fs from 'fs';
 import path from 'path';
 import { WebpackAssetsManifest } from 'webpack-assets-manifest';
+import { readJsonSafe } from '../../../utils';
 import { Context, Overrides } from '../types';
 import { generateMetadata } from '../utils';
-import { readJsonSafe } from '../../../utils';
 
 interface Metadata {
     entryPointsPath: string;

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

@@ -1,8 +1,8 @@
-import path from 'path';
 import os from 'os';
-const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
+import path from 'path';
 import { Context, Overrides } from '../types';
 import { getBundleType } from '../utils';
+const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
 
 export function bundleAnalyzerPlugin(context: Context, _: Overrides) {
     if (!context.buildStat) {

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

@@ -1,6 +1,7 @@
 import { DefinePlugin } from 'webpack';
 import { getPackageDependencyVersion } from '../../../utils';
 import { Context, Overrides } from '../types';
+import { getExposedDependencies } from '../utils';
 
 export function defineExposedDependenciesPlugin(context: Context, _: Overrides) {
     const { emitExposedDependencies, isExposeSharedDependencies } = context;
@@ -9,22 +10,12 @@ export function defineExposedDependenciesPlugin(context: Context, _: Overrides)
     }
 
     const { packageData, sharedDependencies } = context;
+    const exposedDependencies = getExposedDependencies(sharedDependencies, dependency =>
+        getPackageDependencyVersion(dependency, packageData.dependencies?.[dependency])
+    );
+
     return new DefinePlugin({
         // eslint-disable-next-line @typescript-eslint/naming-convention
-        EXPOSED_DEPENDENCIES: JSON.stringify(
-            Object.entries(sharedDependencies).reduce(
-                (result, [dependency, variable]) =>
-                    Object.assign(result, {
-                        [dependency]: {
-                            version: getPackageDependencyVersion(
-                                dependency,
-                                packageData.dependencies?.[dependency]
-                            ),
-                            variable,
-                        },
-                    }),
-                {}
-            )
-        ),
+        EXPOSED_DEPENDENCIES: JSON.stringify(exposedDependencies),
     });
 }

package/src/webpack/configs/plugins/ignore-plugin/__tests__/get-package-json.test.ts

@@ -1,4 +1,4 @@
-import { vol, fs } from 'memfs';
+import { fs, vol } from 'memfs';
 import { getPackageJson } from '../get-package-json';
 
 jest.mock('fs', () => fs);

package/src/webpack/configs/plugins/ignore-plugin/__tests__/is-optional-peer-dependency.test.ts

@@ -1,5 +1,5 @@
-import { isOptionalPeerDependency } from '../is-optional-peer-dependency';
 import { getPackageJson } from '../get-package-json';
+import { isOptionalPeerDependency } from '../is-optional-peer-dependency';
 
 jest.mock('../get-package-json');
 

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

@@ -1,5 +1,4 @@
 import { IgnorePlugin } from 'webpack';
-
 import { Context, Overrides } from '../../types';
 import { checkResource } from './check-resource';
 

package/src/webpack/configs/plugins/watch-run-plugin.ts

@@ -1,6 +1,5 @@
 import path from 'path';
 import { Compiler } from 'webpack';
-
 import { log } from '../../../utils';
 import { Context, Overrides } from '../types';
 

package/src/webpack/configs/types.ts

@@ -25,6 +25,7 @@ export interface EntryPoint {
 export interface EntryPoints {
     full?: EntryPoint;
     light?: EntryPoint;
+    headless?: EntryPoint;
 }
 
 export interface Metadata {

package/src/webpack/configs/utils/__tests__/build-metadata.test.ts

@@ -0,0 +1,71 @@
+import { fs, vol } from 'memfs';
+import { getStartupVersion } from '../../../../utils/get-startup-version';
+import { buildMetadata, BuildMetadataParams } from '../build-metadata';
+import { getLaunchDarklySdkVersion } from '../get-launchdarkly-sdk-version';
+import { getWebComponentsVersion } from '../get-web-components-version';
+
+jest.mock('fs', () => fs);
+jest.mock('../../../../utils/get-startup-version');
+jest.mock('../get-launchdarkly-sdk-version');
+jest.mock('../get-web-components-version');
+
+describe(`[startup] ${buildMetadata.name}`, () => {
+    const destination = 'dist';
+    const startupVersion = '1.0';
+    const webComponentsVersion = '2.0';
+    const launchDarklySdkVersion = '3.0';
+
+    const defaultParams: BuildMetadataParams = {
+        destination,
+        name: '@servicetitan/test-package',
+        version: '1.0.0',
+        dependencies: { foo: '1.0.1' },
+        sharedDependencies: { react: 'SharedDependencies.React' },
+    };
+    let params: BuildMetadataParams;
+
+    beforeEach(() => {
+        params = { ...defaultParams };
+        vol.fromJSON({});
+        jest.mocked(getStartupVersion).mockReturnValue(startupVersion);
+        jest.mocked(getWebComponentsVersion).mockReturnValue(webComponentsVersion);
+        jest.mocked(getLaunchDarklySdkVersion).mockReturnValue(launchDarklySdkVersion);
+    });
+
+    afterEach(() => vol.reset());
+
+    const subject = () => buildMetadata(params);
+
+    test('builds metadata with correct structure', () => {
+        expect(subject()).toEqual({
+            name: params.name,
+            version: params.version,
+            bundledWith: {
+                '@servicetitan/startup': startupVersion,
+                '@servicetitan/web-components': webComponentsVersion,
+                'launchdarkly-js-client-sdk': launchDarklySdkVersion,
+            },
+            dependencies: params.dependencies,
+            sharedDependencies: params.sharedDependencies,
+            entrypoints: {},
+        });
+    });
+
+    describe('with entrypoints', () => {
+        const full = { css: ['full.css'], js: ['full.js'] };
+        const light = { css: ['light.css'], js: ['light.js'] };
+        const headless = { css: ['headless.css'], js: ['headless.js'] };
+
+        beforeEach(() => {
+            vol.fromJSON({
+                [`${destination}/bundle/full/entrypoints.json`]: JSON.stringify(full),
+                [`${destination}/bundle/light/entrypoints.json`]: JSON.stringify(light),
+                [`${destination}/bundle/headless/entrypoints.json`]: JSON.stringify(headless),
+            });
+        });
+
+        test('includes entrypoints', () => {
+            expect(subject().entrypoints).toEqual({ full, light, headless });
+        });
+    });
+});