@servicetitan/startup 31.4.0 → 31.5.0

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

@@ -1,5 +1,13 @@
+import { fs, vol } from 'memfs';
+import * as mockFS from 'fs';
+import HtmlWebpackPlugin from 'html-webpack-plugin';
+import HtmlWebpackTagsPlugin from 'html-webpack-tags-plugin';
 import MiniCssExtractPlugin from 'mini-css-extract-plugin';
-import { DefinePlugin } from 'webpack';
+import path from 'path';
+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 {
     getFolders,
     getPackageData,
@@ -9,12 +17,18 @@ import {
     isCustomStyleRules,
     isExposeSharedDependencies,
     loadSharedDependencies,
+    log,
+    pick,
 } from '../../utils';
+import { styleRules } from '../__mocks__';
 import { getLaunchDarklySdkVersion } from '../configs/utils/get-launchdarkly-sdk-version';
 import { getModuleEntryPath } from '../utils';
 
 import { createWebpackConfig } from '../index';
 
+jest.mock('fs', () => fs);
+jest.mock('html-webpack-plugin', () => jest.fn());
+jest.mock('html-webpack-tags-plugin', () => jest.fn());
 jest.mock('mini-css-extract-plugin', () =>
     Object.assign(jest.fn(), { loader: 'MiniCssExtractPlugin.loader' })
 );
@@ -23,6 +37,9 @@ jest.mock('webpack', () => ({
     ...jest.requireActual('webpack'),
     DefinePlugin: jest.fn(),
 }));
+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('../../utils', () => ({
     ...jest.requireActual('../../utils'),
@@ -56,22 +73,40 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
     };
 
     let overrides: Parameters<typeof createWebpackConfig>[0];
+    let options: Parameters<typeof createWebpackConfig>[1];
 
     function mockPlugIn(name: string) {
         return (options: Record<string, any>): any => ({ [name]: options });
     }
 
+    function volumeFromJSON(overrides: Record<string, any> = {}) {
+        return vol.fromJSON({
+            'package.json': JSON.stringify({}),
+            ...Object.fromEntries(
+                Object.entries(overrides).map(([key, value]) => [key, JSON.stringify(value)])
+            ),
+        });
+    }
+
     beforeEach(() => {
         overrides = { plugins: {} };
+        options = { name: 'app' };
 
         jest.resetAllMocks();
-        jest.mocked(MiniCssExtractPlugin).mockImplementation(mockPlugIn('MiniCssExtractPlugin'));
         jest.mocked(DefinePlugin).mockImplementation(mockPlugIn('DefinePlugin'));
+        jest.mocked(HtmlWebpackPlugin).mockImplementation(mockPlugIn('HtmlWebpackPlugin'));
+        jest.mocked(HtmlWebpackTagsPlugin).mockImplementation(mockPlugIn('HtmlWebpackTagsPlugin'));
+        jest.mocked(MiniCssExtractPlugin).mockImplementation(mockPlugIn('MiniCssExtractPlugin'));
+        jest.mocked(VirtualModulesPlugin).mockImplementation(mockPlugIn('VirtualModulesPlugin'));
+        jest.mocked(WebpackAssetsManifest).mockImplementation(mockPlugIn('WebpackAssetsManifest'));
+        jest.mocked(RemoveEmptyScriptsPlugin).mockImplementation(
+            mockPlugIn('WebpackRemoveEmptyScriptsPlugin')
+        );
 
         jest.mocked(getFolders).mockReturnValue({ source, destination });
         jest.mocked(getModuleEntryPath).mockImplementation(name => `${name}/entryPath`);
         jest.mocked(getPackageData).mockReturnValue({
-            name: '',
+            name: options.name!,
             version: '',
             dependencies,
             sharedDependencies,
@@ -82,9 +117,13 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         jest.mocked(getPackages).mockReturnValue([]);
         jest.mocked(getTsConfig).mockReturnValue(tsConfig);
         jest.mocked(loadSharedDependencies).mockReturnValue(sharedDependencies);
+
+        volumeFromJSON();
     });
 
-    const subject = () => createWebpackConfig(overrides);
+    afterEach(() => vol.reset());
+
+    const subject = () => createWebpackConfig(overrides, options);
 
     describe('when package exposes shared dependencies', () => {
         const launchDarklySdkVersion = '3.0';
@@ -94,25 +133,6 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             jest.mocked(getLaunchDarklySdkVersion).mockReturnValue(launchDarklySdkVersion);
         });
 
-        test('configures "optimization.splitChunks.cacheGroups.design-system"', () => {
-            expect(
-                (subject().optimization?.splitChunks as any).cacheGroups['design-system']
-            ).toEqual({
-                test: /[\\/]node_modules[\\/]@servicetitan[\\/](tokens|anvil-fonts|design-system)[\\/].*\.css$/,
-                name: 'design-system',
-                chunks: 'all',
-                enforce: true,
-            });
-        });
-
-        test('configures shared dependency entry points', () => {
-            expect(subject().entry).toEqual({
-                main: expect.arrayContaining(
-                    Object.keys(sharedDependencies).map(getModuleEntryPath)
-                ),
-            });
-        });
-
         test('configures shared dependencies to use expose-loader', () => {
             Object.entries(sharedDependencies).forEach(([name, value]) => {
                 expect(subject().module?.rules).toContainEqual({
@@ -124,6 +144,17 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             });
         });
 
+        test('configures "externals"', () => {
+            expect(subject().externals).toEqual(
+                Object.fromEntries(
+                    Object.entries(sharedDependencies).map(([name, value]) => [
+                        name,
+                        `${value}['${options!.name}']`,
+                    ])
+                )
+            );
+        });
+
         test('configures EXPOSE_DEPENDENCIES', () => {
             const exposedDependencies = Object.fromEntries(
                 Object.entries(sharedDependencies).map(([name, variable]) => [
@@ -153,39 +184,237 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             );
         });
 
-        test('configures "design-system.css" rules', () => {
-            expect(subject().module?.rules).toContainEqual({
-                test: /design-system\.css$/,
-                use: [MiniCssExtractPlugin.loader, 'css-loader'],
-            });
-        });
+        test('configures rule that reports fatal error when app imports design-system.css', () => {
+            const mockError = jest.spyOn(log, 'error').mockImplementation(jest.fn());
+            const mockExit = jest.spyOn(process, 'exit').mockImplementation(jest.fn() as any);
+            const rule: any = subject().module?.rules?.find(
+                rule => typeof rule === 'object' && typeof rule?.use === 'function'
+            );
 
-        test('configures anvil2 css" rules', () => {
-            expect(subject().module?.rules).toContainEqual({
-                test: /@servicetitan[\\/]anvil2[\\/].*\.css$/,
-                use: [MiniCssExtractPlugin.loader, 'css-loader'],
-            });
-        });
+            rule.use({ issuer: './foo.js' });
 
-        test('configures ".css" rule to also exclude design-system.css', () => {
-            const cssRule: any = subject().module?.rules?.find(({ test }: { test: RegExp }) =>
-                '.css'.match(test)
+            expect(rule).toEqual({ test: /[\\/]design-system.css$/, use: expect.any(Function) });
+            expect(mockError).toHaveBeenCalledWith(
+                expect.stringMatching(/do not import design-system.css/)
             );
-            expect(
-                ['design-system.css', 'foo.module.css', 'foo.css'].filter(path =>
-                    cssRule.exclude(path)
-                )
-            ).toEqual(['design-system.css', 'foo.module.css']);
+            expect(mockExit).toHaveBeenCalledWith(1);
         });
 
         describe('when package has custom style rules', () => {
             beforeEach(() => jest.mocked(isCustomStyleRules).mockReturnValue(true));
 
-            test('does not configure MiniCssExtractPlugIn plugin', () => {
+            test('does not configure MiniCssExtractPlugin plugin', () => {
                 expect(subject().plugins).not.toContainEqual(
-                    expect.objectContaining({ MiniCssExtractPlugIn: expect.anything() })
+                    expect.objectContaining({ MiniCssExtractPlugin: expect.anything() })
+                );
+            });
+
+            describe('when emitting exposed dependencies', () => {
+                beforeEach(() => (options = { emitExposedDependencies: true }));
+
+                test('configures MiniCssExtractPlugin plugin', () => {
+                    expect(subject().plugins).toContainEqual(
+                        expect.objectContaining({ MiniCssExtractPlugin: expect.anything() })
+                    );
+                });
+
+                Object.entries(styleRules).forEach(([extension, rule]) => {
+                    test(`configures "${extension}" rules`, () => {
+                        expect(subject().module?.rules).toContainEqual(rule);
+                    });
+                });
+            });
+        });
+
+        describe('when in production', () => {
+            beforeEach(() => (overrides.configuration = { mode: 'production' }));
+
+            test('configures "output.clean" to keep shared dependencies', () => {
+                expect(subject().output?.clean).toEqual({ keep: /shared/ });
+            });
+        });
+
+        describe('with bundled exposed dependencies', () => {
+            const entryPointsPath = `${destination}/bundle/shared/entrypoints.json`;
+            const entryPoints = {
+                css: ['anvil2.bundle.css', 'design-system.bundle.css'],
+                js: ['anvil2.bundle.js', 'shared.bundle.js', 'design-system..bundle.js'],
+            };
+
+            beforeEach(() => {
+                volumeFromJSON({
+                    [`${destination}/exposed-dependencies-metadata.json`]: { entryPointsPath },
+                    [entryPointsPath]: entryPoints,
+                });
+            });
+
+            test('configures HtmlWebpackTagsPlugin plug', () => {
+                expect(subject().plugins).toContainEqual(
+                    new HtmlWebpackTagsPlugin({
+                        tags: [...entryPoints.css, ...entryPoints.js].map(name => `shared/${name}`),
+                        append: false,
+                    })
+                );
+            });
+        });
+
+        describe('when emitting exposed dependencies', () => {
+            beforeEach(() => (options = { ...options, emitExposedDependencies: true }));
+
+            test('configures shared dependencies entry points', () => {
+                expect(subject().entry).toEqual(
+                    expect.objectContaining({
+                        shared: expect.arrayContaining(
+                            Object.keys(sharedDependencies).map(getModuleEntryPath)
+                        ),
+                    })
+                );
+            });
+
+            test('configures design-system.css entry point', () => {
+                const { entry, plugins } = subject();
+
+                expect(entry).toEqual(
+                    expect.objectContaining({
+                        'design-system': expect.stringMatching(/design-system.css/),
+                    })
+                );
+                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';`,
+                        ].join('\n'),
+                    })
                 );
             });
+
+            describe('when application does not share design system', () => {
+                beforeEach(() => {
+                    jest.mocked(loadSharedDependencies).mockReturnValue(
+                        pick(sharedDependencies, ['react'])
+                    );
+                });
+
+                test('omits design-system.css entry point', () => {
+                    expect((subject().entry as EntryObject)?.['design-system']).toBeUndefined();
+                });
+            });
+
+            test('configures "optimization.splitChunks.cacheGroups.anvil2"', () => {
+                expect((subject().optimization?.splitChunks as any).cacheGroups.anvil2).toEqual({
+                    test: /@servicetitan[\\/]anvil2[\\/].*\.css$/,
+                    name: 'anvil2',
+                    chunks: 'all',
+                    enforce: true,
+                });
+            });
+
+            test('configures "output.chunkLoadingGlobal"', () => {
+                expect(subject().output?.chunkLoadingGlobal).toBe(`sharedChunk${options!.name}`);
+            });
+
+            test('configures "output.path"', () => {
+                expect(subject().output?.path).toBe(
+                    path.join(process.cwd(), destination, 'bundle', 'shared')
+                );
+            });
+
+            describe('with custom "output.path"', () => {
+                const output = { path: path.resolve(process.cwd(), 'foo') };
+
+                beforeEach(() => (options = { emitExposedDependencies: { output } }));
+
+                test('use custom "output.path"', () => {
+                    expect(subject().output?.path).toBe(path.join(output.path, 'shared'));
+                });
+            });
+
+            test('configures WebpackAssetsManifest plugin', () => {
+                expect(subject().plugins).toContainEqual(
+                    new WebpackAssetsManifest({
+                        entrypoints: true,
+                        output: 'entrypoints.json',
+                        transform: expect.any(Function),
+                        done: expect.any(Function),
+                    })
+                );
+            });
+
+            test('generates exposed-dependencies-metadata.json when WebpackAssetsManifest plugin is done', () => {
+                const entryPointsPath = path.join(process.cwd(), destination, 'entrypoints.json');
+                const manifest = { getOutputPath: () => entryPointsPath };
+
+                subject();
+                const done: any = jest.mocked(WebpackAssetsManifest).mock.calls[0][0]?.done;
+                done(manifest);
+
+                const metadataPath = `${destination}/exposed-dependencies-metadata.json`;
+                const metadata = JSON.parse(mockFS.readFileSync(metadataPath, 'utf-8'));
+                expect(metadata).toEqual({ entryPointsPath });
+            });
+
+            test('configures RemoveEmptyScriptsPlugin plugin', () => {
+                expect(subject().plugins).toContainEqual(new RemoveEmptyScriptsPlugin());
+            });
+
+            test('configures "cache"', () => {
+                expect(subject().cache).toEqual({
+                    type: 'filesystem',
+                    version: expect.any(String),
+                });
+            });
+
+            describe('with package-lock.json', () => {
+                beforeEach(() => volumeFromJSON({ '../package-lock.json': {} }));
+
+                test('configures "cache.buildDependencies"', () => {
+                    expect(subject().cache).toEqual(
+                        expect.objectContaining({
+                            buildDependencies: {
+                                packageLock: [path.resolve('../package-lock.json')],
+                            },
+                        })
+                    );
+                });
+            });
+
+            test('configures "infrastructureLogging', () => {
+                expect(subject().infrastructureLogging).toEqual({ level: 'error' });
+            });
+
+            test('sets "optimization.runtimeChunk" to false', () => {
+                expect(subject().optimization?.runtimeChunk).toBe(false);
+            });
+
+            test('omits "devServer" configuration', () => {
+                expect(subject().devServer).toBeUndefined();
+            });
+
+            test('omits "externals" configuration', () => {
+                expect(subject().externals).toBeUndefined();
+            });
+
+            test('omits EXPOSED_* globals ', () => {
+                subject();
+
+                expect(DefinePlugin).not.toHaveBeenCalled();
+            });
+
+            test('omits HtmlWebpackPlugin plugin', () => {
+                subject();
+
+                expect(HtmlWebpackPlugin).not.toHaveBeenCalled();
+            });
+
+            describe('when in production', () => {
+                beforeEach(() => (overrides.configuration = { mode: 'production' }));
+
+                test('configures "output.clean" to true', () => {
+                    expect(subject().output?.clean).toBe(true);
+                });
+            });
         });
     });
 });

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

@@ -196,7 +196,6 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             expect(subject().plugins).toContainEqual(
                 new HtmlWebpackPlugin({
                     title: 'ServiceTitan',
-                    hash: true,
                     templateParameters: { splitByEntry },
                     ...overrides.plugins?.HtmlWebpackPlugin,
                     inject: false,
@@ -307,6 +306,17 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                 );
             });
 
+            test('configures "externals"', () => {
+                expect(subject().externals).toEqual(
+                    Object.fromEntries(
+                        Object.entries(sharedDependencies).map(([name, value]) => [
+                            name,
+                            `${value}['${options!.name}']`,
+                        ])
+                    )
+                );
+            });
+
             describe('when package does not share design system', () => {
                 beforeEach(() => delete sharedDependencies['@servicetitan/design-system']);
 
@@ -335,6 +345,12 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                     })
                 );
             });
+
+            test('appends "/headless" to output path', () => {
+                expect(subject().output!.path).toEqual(
+                    path.join(process.cwd(), destination, 'bundle', 'headless')
+                );
+            });
         });
 
         describe.each([webpackDevConfigFileName, webpackProdConfigFileName])(
@@ -383,6 +399,14 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             test('configures "output.uniqueName"', () => {
                 expect(subject().output?.uniqueName).toEqual(options.name);
             });
+
+            describe('when headless option is set to true', () => {
+                beforeEach(() => (options.headless = true));
+
+                test('omits optimization.runtimeChunk', () => {
+                    expect(subject().optimization?.runtimeChunk).toBeUndefined();
+                });
+            });
         });
     });
 });

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

@@ -446,15 +446,6 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         itConfiguresCodeCoverage();
     });
 
-    test('configures ".css" rule to exclude .module.css files', () => {
-        const cssRule: any = subject().module?.rules?.find(({ test: regexp }: { test: RegExp }) =>
-            regexp.test('.css')
-        );
-        expect(
-            ['design-system.css', 'foo.module.css', 'foo.css'].filter(path => cssRule.exclude(path))
-        ).toEqual(['foo.module.css']);
-    });
-
     test('configures MomentLocalesPlugin plugin', () => {
         expect(subject().plugins).toContainEqual(
             new MomentLocalesPlugin({ localesToKeep: ['en-au', 'en-ca', 'en-gb'] })
@@ -473,7 +464,6 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
         expect(subject().plugins).toContainEqual(
             new HtmlWebpackPlugin({
                 title: 'ServiceTitan',
-                hash: true,
                 templateParameters: { splitByEntry },
                 ...overrides.plugins?.HtmlWebpackPlugin,
             })
@@ -547,52 +537,6 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
                     );
                 });
             });
-
-            describe('headless option is true', () => {
-                beforeEach(() => setOptions({ headless: true }));
-
-                test('configures "output.path"', () => {
-                    expect(subject().output!.path).toEqual(
-                        path.join(process.cwd(), destination, 'bundle', 'headless')
-                    );
-                });
-
-                describe('when mode is "production"', () => {
-                    beforeEach(() => {
-                        overrides.configuration ??= {};
-                        Object.assign(overrides.configuration, { mode: 'production' });
-                    });
-
-                    test('omits optimization.runtimeChunk', () => {
-                        expect(subject().optimization?.runtimeChunk).toBeUndefined();
-                    });
-                });
-            });
-        });
-    });
-
-    describe('when embed option is set to true', () => {
-        beforeEach(() => setOptions({ embed: true, name: packageName }));
-
-        test('configures "externals"', () => {
-            expect(subject().externals).toEqual(
-                Object.fromEntries(
-                    Object.entries(sharedDependencies).map(([name, value]) => [
-                        name,
-                        `${value}['${options!.name}']`,
-                    ])
-                )
-            );
-        });
-
-        describe('when package is web component', () => {
-            beforeEach(() => jest.mocked(isWebComponent).mockReturnValue(true));
-
-            test('configures "output.path"', () => {
-                expect(subject().output!.path).toEqual(
-                    path.join(process.cwd(), destination, 'bundle', 'light')
-                );
-            });
         });
     });
 
@@ -622,7 +566,7 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             expect(subject().output?.filename).toBe('[name].[contenthash].bundle.js');
         });
 
-        test('configures "output.clean"', () => {
+        test('configures "output.clean" to true', () => {
             expect(subject().output?.clean).toBe(true);
         });
 
@@ -712,4 +656,12 @@ describe(`[startup] ${createWebpackConfig.name}`, () => {
             });
         });
     });
+
+    describe('with "emitExposedDependencies"', () => {
+        beforeEach(() => (options = { emitExposedDependencies: true }));
+
+        test('throws error', () => {
+            expect(subject).toThrow('package does not expose shared dependencies');
+        });
+    });
 });

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

@@ -0,0 +1,37 @@
+import path from 'path';
+import fs from 'fs';
+import { Configuration } from 'webpack';
+import { findUp } from '../../utils';
+import { Context, Overrides } from './types';
+
+type Config = Configuration['cache'];
+type Result = Pick<Configuration, 'cache' | 'infrastructureLogging'> | undefined;
+
+const CACHE_VERSION = '1';
+
+export function cacheConfig(context: Context, _overrides: Overrides): Result {
+    const { emitExposedDependencies } = context;
+    if (!emitExposedDependencies) {
+        return;
+    }
+
+    const packageLock = findPackageLock();
+    const cache: Config = {
+        type: 'filesystem',
+        version: CACHE_VERSION,
+        ...(packageLock ? { buildDependencies: { packageLock: [packageLock] } } : {}),
+    };
+
+    return {
+        cache,
+        // Suppress "Serializing big strings impacts deserialization performance" warnings
+        infrastructureLogging: { level: 'error' },
+    };
+}
+
+function findPackageLock() {
+    return findUp(directory => {
+        const lockFile = path.resolve(path.join(directory), 'package-lock.json');
+        return fs.existsSync(lockFile) ? lockFile : undefined;
+    });
+}

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

@@ -15,7 +15,7 @@ type DevServerConfig = NonNullable<Configuration['devServer']>;
 type Result = Pick<Configuration, 'devServer'> | undefined;
 
 export function devServerConfig(context: Context, overrides: Overrides): Result {
-    if (context.isProduction || isDevServerDisabled()) {
+    if (context.isProduction || context.emitExposedDependencies || isDevServerDisabled()) {
         return;
     }
 

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

@@ -1,23 +1,33 @@
 import fs from 'fs';
 import { Configuration } from 'webpack';
 import { getModuleEntryPath } from '../utils';
+import { getDesignSystemPath } from './plugins';
 import { Context, Overrides } from './types';
 
 type Config = Configuration['entry'];
 type Result = Pick<Configuration, 'entry'>;
 
 export function entryConfig(context: Context, _: Overrides): Result {
-    const { destination, isExposeSharedDependencies, sharedDependencies, source } = context;
+    const entry: Config = context.emitExposedDependencies
+        ? getSharedEntryPoints(context)
+        : getIndexEntryPoint(context);
 
+    return { entry };
+}
+
+function getIndexEntryPoint({ source, destination }: Context): Config {
     const index = fs.existsSync(`./${source}/index.js`)
         ? `./${source}/index`
         : `./${destination}/index`;
+    return { main: [index] };
+}
 
-    const entry: Config = { main: [index] };
-
-    if (isExposeSharedDependencies) {
-        (entry.main as string[]).push(...Object.keys(sharedDependencies).map(getModuleEntryPath));
-    }
-
-    return { entry };
+function getSharedEntryPoints(context: Context): Config {
+    const { sharedDependencies } = context;
+    return {
+        shared: Object.keys(sharedDependencies).map(getModuleEntryPath),
+        ...(sharedDependencies['@servicetitan/design-system']
+            ? { 'design-system': getDesignSystemPath(context) }
+            : {}),
+    };
 }

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

@@ -5,11 +5,12 @@ type Config = Configuration['externals'];
 type Result = Pick<Configuration, 'externals'> | undefined;
 
 export function externalsConfig(context: Context, _: Overrides): Result {
-    const { embed, name, sharedDependencies } = context;
-    if (!embed) {
+    if (!needsExternals(context)) {
         return;
     }
 
+    const { sharedDependencies } = context;
+    const name = context.name || context.packageData.name;
     const externals: Config = Object.fromEntries(
         Object.entries(sharedDependencies).map(([dependency, variable]) => [
             dependency,
@@ -19,3 +20,7 @@ export function externalsConfig(context: Context, _: Overrides): Result {
 
     return { externals };
 }
+
+function needsExternals({ embed, emitExposedDependencies, isExposeSharedDependencies }: Context) {
+    return !!embed || (isExposeSharedDependencies && !emitExposedDependencies);
+}

package/src/webpack/configs/index.ts

@@ -1,4 +1,5 @@
 export * from './amd-config';
+export * from './cache-config';
 export * from './dev-server-config';
 export * from './devtool-config';
 export * from './entry.config';