@servicetitan/startup 34.2.1 → 34.3.0-beta.0

package/src/webpack/configs/plugins/html-tags-plugin.ts

@@ -1,28 +1,19 @@
 import HtmlWebpackTagsPlugin from 'html-webpack-tags-plugin';
-import { Context, Overrides } from '../types';
-import { getBundleType } from '../utils';
-import { getExposedDependenciesEntryPoints } from './assets-manifest-plugin';
+import { BuildContext, getSharedEntryPoints } from '../../../core';
+import { Overrides } from '../../types';
 
-export function htmlTagsPlugin(context: Context, _overrides: Overrides) {
-    const { emitExposedDependencies, isExposeSharedDependencies } = context;
+export function htmlTagsPlugin(context: BuildContext, _overrides: Overrides) {
+    const { isExposeSharedDependencies } = context.package;
+    const { emitExposedDependencies } = context.options.bundlerConfig;
     if (!isExposeSharedDependencies || emitExposedDependencies) {
         return;
     }
 
-    const sharedEntryPoints = getSharedEntryPoints(context);
+    const { css, js } = getSharedEntryPoints(context);
+    const sharedEntryPoints = [...css, ...js];
     if (!sharedEntryPoints.length) {
         return;
     }
 
     return new HtmlWebpackTagsPlugin({ tags: sharedEntryPoints, append: false });
 }
-
-function getSharedEntryPoints(context: Context) {
-    const dirname = getBundleType({ ...context, emitExposedDependencies: true });
-    if (!dirname) {
-        return [];
-    }
-
-    const { css = [], js = [] } = getExposedDependenciesEntryPoints(context) ?? {};
-    return [...css, ...js].map(name => `${dirname}/${name}`);
-}

package/src/webpack/configs/plugins/ignore-plugin/empty-module.js

@@ -0,0 +1 @@
+module.exports = {};

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

@@ -1,13 +1,55 @@
-import { IgnorePlugin } from 'webpack';
-import { Context, Overrides } from '../../types';
-import { checkResource } from './check-resource';
+import { Compiler } from 'webpack';
+import { BuildContext, checkResource } from '../../../../core';
+import { Overrides } from '../../../types';
 
-export function ignorePlugin(context: Context, _: Overrides) {
+/**
+ * TODO: backward compatibility
+ * TODO: rename things
+ * Custom plugin to replace optional peer dependencies with an empty module
+ * Follows the same pattern as IgnorePlugin by tapping into normalModuleFactory hooks
+ */
+class ReplaceOptionalDependenciesPlugin {
+    private readonly checkResource: (resource: string, context: string) => boolean;
+    private readonly emptyModulePath: string;
+
+    constructor(checkResource: (resource: string, context: string) => boolean) {
+        this.checkResource = checkResource;
+        this.emptyModulePath = require.resolve('./empty-module.js');
+    }
+
+    apply(compiler: Compiler) {
+        compiler.hooks.normalModuleFactory.tap(
+            'ReplaceOptionalDependenciesPlugin',
+            normalModuleFactory => {
+                normalModuleFactory.hooks.beforeResolve.tap(
+                    'ReplaceOptionalDependenciesPlugin',
+                    resolveData => {
+                        if (!resolveData) {
+                            return;
+                        }
+
+                        const { request, context } = resolveData;
+
+                        // Check if this module should be replaced
+                        if (this.checkResource(request, context)) {
+                            // Replace the request with the empty module path
+                            resolveData.request = this.emptyModulePath;
+                        }
+                    }
+                );
+            }
+        );
+    }
+}
+
+export function ignorePlugin(context: BuildContext, _: Overrides) {
     /**
-     * Ignore optional peer dependencies
+     * Ignore optional peer dependencies by replacing them with an empty module
      * @see {@link: file://./../../../../../../web-components/src/register.tsx}
      * @see {@link: file://./../../../../../../web-components/src/render.ts}
      * @see {@link: file://./../../../../../../ko-bridge/src/ko-binding-handlers.tsx}
      */
-    return new IgnorePlugin({ checkResource: checkResource(context) });
+    const shouldIgnore = checkResource(context);
+
+    return new ReplaceOptionalDependenciesPlugin(shouldIgnore);
 }

package/src/webpack/configs/plugins/mini-css-extract-plugin.ts

@@ -1,11 +1,16 @@
 import MiniCssExtractPlugin from 'mini-css-extract-plugin';
-import { Context, Overrides } from '../types';
+import { BuildContext } from '../../../core';
+import { Overrides } from '../../types';
 
-export function miniCssExtractPlugin(context: Context, overrides: Overrides) {
-    const { isCustomStyleRules, isExposeSharedDependencies, isProduction, isWebComponent } =
-        context;
+export function miniCssExtractPlugin(context: BuildContext, overrides: Overrides) {
+    const { isProduction } = context.build;
+    const { isExposeSharedDependencies, isWebComponent } = context.package;
+    const { isCustomStyleRules, emitExposedDependencies } = context.options.bundlerConfig;
 
-    if (!isCustomStyleRules && (isProduction || isWebComponent || isExposeSharedDependencies)) {
+    if (
+        (!isCustomStyleRules || emitExposedDependencies) &&
+        (isProduction || isWebComponent || isExposeSharedDependencies)
+    ) {
         return new MiniCssExtractPlugin({
             filename: isProduction ? '[name].[contenthash].bundle.css' : '[name].bundle.css',
             ...overrides.plugins?.MiniCssExtractPlugin,

package/src/webpack/configs/plugins/moment-locales-plugin.ts

@@ -1,9 +1,10 @@
-import { Context, Overrides } from '../types';
+import { BuildContext } from '../../../core';
+import { Overrides } from '../../types';
 
 const MomentLocalesPlugin: typeof import('moment-locales-webpack-plugin') | undefined =
     isMomentInstalled() ? require('moment-locales-webpack-plugin') : undefined;
 
-export function momentLocalesPlugin(_: Context, _overrides: Overrides) {
+export function momentLocalesPlugin(_: BuildContext, _overrides: Overrides) {
     return (
         MomentLocalesPlugin &&
         new MomentLocalesPlugin({

package/src/webpack/configs/plugins/remove-empty-scripts-plugin.ts

@@ -1,8 +1,9 @@
 import RemoveEmptyScriptsPlugin from 'webpack-remove-empty-scripts';
-import { Context, Overrides } from '../types';
+import { BuildContext } from '../../../core';
+import { Overrides } from '../../types';
 
-export function removeEmptyScriptsPlugin(context: Context, _overrides: Overrides) {
-    const { emitExposedDependencies } = context;
+export function removeEmptyScriptsPlugin(context: BuildContext, _overrides: Overrides) {
+    const { emitExposedDependencies } = context.options.bundlerConfig;
     if (!emitExposedDependencies) {
         return;
     }

package/src/webpack/configs/plugins/virtual-modules-plugin.ts

@@ -1,80 +1,28 @@
 import fs from 'fs';
 import path from 'path';
 import VirtualModulesPlugin from 'webpack-virtual-modules';
-import { Context, Overrides } from '../types';
+import { BuildContext, getDesignSystemPath, virtualModules } from '../../../core';
+import { Overrides } from '../../types';
 
-export function virtualModulesPlugin(context: Context, _: Overrides) {
-    const { destination } = context;
+export function virtualModulesPlugin(context: BuildContext, _: Overrides) {
+    const { destination } = context.package;
 
-    const modules: ConstructorParameters<typeof VirtualModulesPlugin>[0] = {};
+    const modules = virtualModules(context);
+    const webpackModules: ConstructorParameters<typeof VirtualModulesPlugin>[0] = {};
 
-    if (context.isWebComponent) {
+    if (modules.index) {
         const indexPath = path.join(process.cwd(), destination, 'index');
-        modules[indexPath] = indexCode(context);
+        webpackModules[indexPath] = modules.index;
     }
 
-    if (needsToIncludeDesignSystem(context)) {
+    if (modules.designSystem) {
         const designSystemPath = getDesignSystemPath(context);
         if (!fs.existsSync(designSystemPath)) {
-            modules[designSystemPath] = designSystemCode();
+            webpackModules[designSystemPath] = modules.designSystem;
         }
     }
 
-    return Object.keys(modules).length ? new VirtualModulesPlugin(modules) : undefined;
-}
-
-export function getDesignSystemPath({ destination }: Context) {
-    return path.join(process.cwd(), destination, 'design-system.css');
-}
-
-function designSystemCode() {
-    return [
-        `@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');
-}
-
-function indexCode(context: Context) {
-    const { embed = false, headless, isLegacyRoot, sharedDependencies } = context;
-    if (headless) {
-        return headlessIndex();
-    }
-
-    const options = `{ legacyRoot: ${isLegacyRoot}, sharedDependenciesNames: ${JSON.stringify(
-        Object.keys(sharedDependencies)
-    )} }`;
-    return [
-        ...(needsToIncludeDesignSystem(context) ? [`require('./design-system.css');`] : []),
-        `import { register } from '@servicetitan/web-components';`,
-        `import { App } from './app';`,
-        `register(App, ${embed}, ${options});`,
-    ].join('\n');
-}
-
-function needsToIncludeDesignSystem({
-    embed,
-    emitExposedDependencies,
-    headless,
-    isWebComponent,
-    packageData,
-    sharedDependencies,
-}: Context) {
-    return (
-        (!!emitExposedDependencies && !!sharedDependencies['@servicetitan/design-system']) ||
-        (isWebComponent &&
-            !headless &&
-            // Depends on design system
-            !!packageData.dependencies['@servicetitan/design-system'] &&
-            // ... and is not light bundle with private copy of design system
-            !(embed && !!sharedDependencies['@servicetitan/design-system']))
-    );
-}
-
-function headlessIndex() {
-    return [
-        "import { registerHeadless } from '@servicetitan/web-components';",
-        "import { connectedCallback, disconnectedCallback } from './headless';",
-        'registerHeadless(connectedCallback, disconnectedCallback);',
-    ].join('\n');
+    return Object.keys(webpackModules).length
+        ? new VirtualModulesPlugin(webpackModules)
+        : undefined;
 }

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

@@ -1,9 +1,10 @@
 import path from 'path';
 import { Compiler } from 'webpack';
+import { BuildContext } from '../../../core';
 import { log } from '../../../utils';
-import { Context, Overrides } from '../types';
+import { Overrides } from '../../types';
 
-export function watchRunPlugin(_context: Context, _overrides: Overrides) {
+export function watchRunPlugin(_context: BuildContext, _overrides: Overrides) {
     /* istanbul ignore next: debug only */
     if (log.debug('modified-files').enabled) {
         return new WatchRunPlugin();

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

@@ -1,4 +1,6 @@
 import { Configuration } from 'webpack';
+import { BuildContext } from '../../core';
+import { Overrides } from '../types';
 import {
     assetsManifestPlugin,
     bundleAnalyzerPlugin,
@@ -15,12 +17,11 @@ import {
     virtualModulesPlugin,
     watchRunPlugin,
 } from './plugins';
-import { Context, Overrides } from './types';
 
 type Config = Configuration['plugins'];
 type Result = Pick<Configuration, 'plugins'>;
 
-export function pluginsConfig(context: Context, overrides: Overrides): Result {
+export function pluginsConfig(context: BuildContext, overrides: Overrides): Result {
     const plugins: Config = [
         assetsManifestPlugin,
         bundleAnalyzerPlugin,

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

@@ -1,10 +1,11 @@
 import { Configuration } from 'webpack';
-import { Context, Overrides } from './types';
+import { BuildContext } from '../../core';
+import { Overrides } from '../types';
 
 type Config = Configuration['resolve'];
 type Result = Pick<Configuration, 'resolve'>;
 
-export function resolveConfig(_context: Context, _: Overrides): Result {
+export function resolveConfig(_context: BuildContext, _: Overrides): Result {
     const resolve: Config = {
         extensions: ['.js'],
     };

package/src/webpack/configs/rules/css-rules.ts

@@ -1,11 +1,12 @@
 import path from 'path';
 import { RuleSetRule } from 'webpack';
+import { BuildContext } from '../../../core';
 import { log } from '../../../utils';
 import { cssLoader, styleLoader } from '../loaders';
-import { Context } from '../types';
 
-export function cssRules(context: Context): RuleSetRule[] {
-    const { emitExposedDependencies, isExposeSharedDependencies, sharedDependencies } = context;
+export function cssRules(context: BuildContext): RuleSetRule[] {
+    const { isExposeSharedDependencies, sharedDependencies } = context.package;
+    const { emitExposedDependencies } = context.options.bundlerConfig;
     const result: RuleSetRule[] = [
         {
             test: /\.module.css$/,

package/src/webpack/configs/rules/font-rules.ts

@@ -1,7 +1,7 @@
 import { RuleSetRule } from 'webpack';
-import { Context } from '../types';
+import { BuildContext } from '../../../core';
 
-export function fontRules(_: Context): RuleSetRule[] {
+export function fontRules(_: BuildContext): RuleSetRule[] {
     return [
         {
             test: /\.(woff|woff2|eot|ttf|otf)$/i,

package/src/webpack/configs/rules/image-rules.ts

@@ -1,7 +1,7 @@
 import { RuleSetRule } from 'webpack';
-import { Context } from '../types';
+import { BuildContext } from '../../../core';
 
-export function imageRules(_: Context): RuleSetRule[] {
+export function imageRules(_: BuildContext): RuleSetRule[] {
     return [
         {
             test: /\.(png|jpg|jpeg|gif)$/i,

package/src/webpack/configs/rules/js-rules.ts

@@ -1,8 +1,10 @@
 import path from 'path';
 import { RuleSetRule } from 'webpack';
-import { Context } from '../types';
+import { BuildContext } from '../../../core';
 
-export function jsRules({ codeCoverage, destination }: Context): RuleSetRule[] {
+export function jsRules(context: BuildContext): RuleSetRule[] {
+    const { destination } = context.package;
+    const { codeCoverage } = context.options;
     const result: RuleSetRule[] = [
         {
             enforce: 'pre',

package/src/webpack/configs/rules/less-rules.ts

@@ -1,8 +1,8 @@
 import { RuleSetRule } from 'webpack';
+import { BuildContext } from '../../../core';
 import { cssLoader, lessLoader, styleLoader } from '../loaders';
-import { Context } from '../types';
 
-export function lessRules(context: Context): RuleSetRule[] {
+export function lessRules(context: BuildContext): RuleSetRule[] {
     return [
         {
             test: /\.module.less$/,

package/src/webpack/configs/rules/scss-rules.ts

@@ -1,8 +1,8 @@
 import { RuleSetRule } from 'webpack';
+import { BuildContext } from '../../../core';
 import { cssLoader, styleLoader } from '../loaders';
-import { Context } from '../types';
 
-export function scssRules(context: Context): RuleSetRule[] {
+export function scssRules(context: BuildContext): RuleSetRule[] {
     return [
         {
             test: /\.module.scss$/,

package/src/webpack/configs/rules/svg-rules.ts

@@ -1,7 +1,7 @@
 import { RuleSetRule } from 'webpack';
-import { Context } from '../types';
+import { BuildContext } from '../../../core';
 
-export function svgRules(_: Context): RuleSetRule[] {
+export function svgRules(_: BuildContext): RuleSetRule[] {
     // Using [\\\/] because Windows uses backslash as path separator
     const librariesRegEx = /node_modules[\\\/]@servicetitan[\\\/]anvil2/;
 

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

@@ -1,26 +1,30 @@
 import { RuleSetRule } from 'webpack';
+import { BuildContext } from '../../core';
+import { Overrides } from '../types';
 import { getModuleEntryPath } from '../utils';
 import { cssRules, fontRules, imageRules, jsRules, lessRules, scssRules, svgRules } from './rules';
-import { Context, Overrides } from './types';
 
 interface Result {
     rules: RuleSetRule[];
 }
 
-export function rulesConfig(context: Context, _: Overrides): Result {
+export function rulesConfig(context: BuildContext, _: Overrides): Result {
     const rules = [jsRules, imageRules, fontRules, svgRules, sharedDependenciesRules].flatMap(fn =>
         fn(context)
     );
 
-    if (!context.isCustomStyleRules) {
+    if (
+        !context.options.bundlerConfig.isCustomStyleRules ||
+        context.options.bundlerConfig.emitExposedDependencies
+    ) {
         rules.push(...[scssRules, lessRules, cssRules].flatMap(fn => fn(context)));
     }
 
     return { rules };
 }
 
-function sharedDependenciesRules(context: Context): RuleSetRule[] {
-    const { isExposeSharedDependencies, sharedDependencies } = context;
+function sharedDependenciesRules(context: BuildContext): RuleSetRule[] {
+    const { isExposeSharedDependencies, sharedDependencies } = context.package;
     if (!isExposeSharedDependencies) {
         return [];
     }

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

@@ -1,10 +1,11 @@
 import { Configuration } from 'webpack';
-import { Context, Overrides } from './types';
+import { BuildContext } from '../../core';
+import { Overrides } from '../types';
 
 type Config = Configuration['stats'];
 type Result = Pick<Configuration, 'stats'>;
 
-export function statsConfig(_context: Context, _: Overrides): Result {
+export function statsConfig(_context: BuildContext, _: Overrides): Result {
     const stats: Config = {
         all: false,
         errors: true,

package/src/webpack/configs/watch-options-config.ts

@@ -1,11 +1,11 @@
 import { Configuration } from 'webpack';
-import { Context } from './types';
+import { BuildContext } from '../../core';
 
 type Config = Configuration['watchOptions'];
 type Result = Pick<Configuration, 'watchOptions'> | undefined;
 
-export function watchOptionsConfig({ isProduction }: Context): Result {
-    if (isProduction) {
+export function watchOptionsConfig(context: BuildContext): Result {
+    if (context.build.isProduction) {
         return;
     }
 

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

@@ -1,21 +1,17 @@
+import fs from 'fs';
+import path from 'path';
 import { Configuration } from 'webpack';
 import { merge } from 'webpack-merge';
-import yargs, { Arguments } from 'yargs';
-import { hideBin } from 'yargs/helpers';
-import { webpackDevConfigFileName, webpackProdConfigFileName } from '../cli/utils';
+import { createBuildContext, getName, stringifyConfig } from '../core';
 import {
-    getFolders,
-    getPackageData,
     getWebpackConfiguration,
+    hasHeadlessBundle,
     isCustomStyleRules,
-    isExposeSharedDependencies,
-    isLegacyRoot,
     isWebComponent,
-    loadSharedDependencies,
     log,
+    validateSharedDependenciesConsistency,
 } from '../utils';
 import {
-    Context,
     amdConfig,
     cacheConfig,
     devServerConfig,
@@ -31,15 +27,31 @@ import {
     watchOptionsConfig,
 } from './configs';
 import { Options, Overrides } from './types';
-import { getCallerFile, stringifyConfig } from './utils';
+import { getCallerFile } from './utils';
+
+export const webpackDevConfigFileName = 'webpack.dev.config.js';
+export const webpackProdConfigFileName = 'webpack.prod.config.js';
 
 export function createWebpackConfig(overrides: Overrides, options: Options = {}): Configuration {
-    const context = getContext(overrides, options);
-    if (context.isWebComponent && isCalledFromCustomWebpackConfigFile()) {
+    const context = createBuildContext({
+        name: options.name ?? '',
+        isProduction: overrides.configuration?.mode !== 'development',
+        light: options.light,
+        headless: options.headless,
+        codeCoverage: options.codeCoverage,
+        buildStat: options.buildStat,
+        bundlerConfig: {
+            emitExposedDependencies: options.emitExposedDependencies,
+            minify: getWebpackConfiguration().minify,
+            isCustomStyleRules: isCustomStyleRules(),
+        },
+    });
+
+    if (context.package.isWebComponent && isCalledFromCustomWebpackConfigFile()) {
         throw new Error(WEB_COMPONENT_CONFIG_ERROR);
     }
 
-    if (options.emitExposedDependencies && !context.isExposeSharedDependencies) {
+    if (options.emitExposedDependencies && !context.package.isExposeSharedDependencies) {
         throw new Error('package does not expose shared dependencies');
     }
 
@@ -70,36 +82,6 @@ export function createWebpackConfig(overrides: Overrides, options: Options = {})
     return result;
 }
 
-function getContext({ configuration = {} }: Overrides, options: Options): Context {
-    const { source, destination } = getFolders();
-    const { minify } = getWebpackConfiguration();
-    const packageData = getPackageData();
-    const sharedDependencies = loadSharedDependencies(
-        packageData.dependencies,
-        packageData.sharedDependencies
-    );
-
-    const args = yargs(hideBin(process.argv)).argv as Arguments;
-    const emitExposedDependencies = options.emitExposedDependencies;
-
-    return {
-        codeCoverage: options.codeCoverage ?? !!args['code-coverage'],
-        destination,
-        emitExposedDependencies,
-        isCustomStyleRules: !emitExposedDependencies && isCustomStyleRules(),
-        isExposeSharedDependencies: isExposeSharedDependencies(),
-        isLegacyRoot: isLegacyRoot(),
-        isProduction: configuration.mode === 'production',
-        isWebComponent: isWebComponent(),
-        minify,
-        name: '',
-        ...options,
-        packageData,
-        sharedDependencies,
-        source,
-    };
-}
-
 function isCalledFromCustomWebpackConfigFile() {
     const callerFileName = getCallerFile();
     return [webpackDevConfigFileName, webpackProdConfigFileName].some(configFileName =>
@@ -113,3 +95,66 @@ const WEB_COMPONENT_CONFIG_ERROR = `
 `
     .replace(/\n\s*/g, ' ')
     .trim();
+
+export function createWebpackConfigs(options: {
+    buildStat?: boolean;
+    codeCoverage?: boolean;
+    config?: string;
+    emitExposedDependencies?: boolean;
+    useWatchConfig?: boolean;
+    watch?: boolean;
+}): Configuration[] {
+    validateSharedDependenciesConsistency();
+
+    const { watch, useWatchConfig } = options;
+    const mode = watch || useWatchConfig ? 'development' : 'production';
+    const fallback = watch || useWatchConfig ? webpackDevConfigFileName : webpackProdConfigFileName;
+    const customConfig = readWebpackConfig({ config: options.config, fallback });
+
+    /* istanbul ignore next: debug only */
+    log.debug('custom-webpack-config', () => stringifyConfig(customConfig));
+
+    const emitExposedDependencies =
+        options.emitExposedDependencies && customConfig
+            ? { output: customConfig.output }
+            : options.emitExposedDependencies;
+
+    const resolved: Options = {
+        buildStat: options.buildStat,
+        codeCoverage: options.codeCoverage,
+        emitExposedDependencies,
+        name: getName(),
+    };
+
+    if (isWebComponent()) {
+        const overrides: Overrides = {
+            configuration: { ...customConfig?.configuration, mode },
+            plugins: customConfig?.plugins,
+        };
+
+        const configs = [
+            createWebpackConfig(overrides, resolved),
+            createWebpackConfig(overrides, { ...resolved, light: true }),
+        ];
+        if (hasHeadlessBundle()) {
+            configs.push(createWebpackConfig(overrides, { ...resolved, headless: true }));
+        }
+        return configs;
+    }
+
+    if (customConfig && !emitExposedDependencies) {
+        return [customConfig];
+    }
+
+    return [createWebpackConfig({ configuration: { mode } }, resolved)];
+}
+
+function readWebpackConfig({ config, fallback }: { config?: string; fallback: string }) {
+    return readConfig(config) ?? readConfig(fallback);
+}
+
+function readConfig(relativePath?: string): Record<string, any> | undefined {
+    if (relativePath && fs.existsSync(relativePath)) {
+        return require(path.resolve(relativePath));
+    }
+}

package/src/webpack/types.ts

@@ -1,18 +1,14 @@
 import { Options as HtmlWebpackPluginOptions } from 'html-webpack-plugin';
 import { PluginOptions as MiniCssExtractPlugInOptions } from 'mini-css-extract-plugin';
 import { Configuration } from 'webpack';
+import { BuildIdentity, BuildOptions, BundlerConfig } from '../core';
 
-export interface ExposedDependenciesConfig {
-    output?: Configuration['output'];
-}
-export interface Options {
-    buildStat?: boolean;
-    codeCoverage?: boolean;
-    embed?: boolean;
-    emitExposedDependencies?: boolean | ExposedDependenciesConfig;
-    headless?: boolean;
-    name?: string;
-}
+export type Options = Partial<
+    Pick<BuildIdentity, 'name' | 'light' | 'headless'> &
+        Pick<BuildOptions, 'codeCoverage' | 'buildStat'>
+> & {
+    emitExposedDependencies?: BundlerConfig['emitExposedDependencies'];
+};
 
 export interface Overrides {
     configuration?: Configuration;

package/src/webpack/utils/index.ts

@@ -1,4 +1,3 @@
 export * from './get-caller-filename';
 export * from './get-module-entry-path';
 export * from './split-by-entry';
-export * from './stringify-config';

package/dist/webpack/configs/plugins/ignore-plugin/check-resource.d.ts

@@ -1,3 +0,0 @@
-import { Context } from '../../types';
-export declare function checkResource(packageContext: Context): (resource: string, context: string) => boolean;
-//# sourceMappingURL=check-resource.d.ts.map