@servicetitan/startup 36.0.0 → 36.1.1-beta.1

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.build;
     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,27 @@
 import { RuleSetRule } from 'webpack';
+import { BuildContext } from '../../core';
+import { Overrides, WebpackBuildContext } 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: WebpackBuildContext, _: Overrides): Result {
     const rules = [jsRules, imageRules, fontRules, svgRules, sharedDependenciesRules].flatMap(fn =>
         fn(context)
     );
 
-    if (!context.isCustomStyleRules) {
+    if (!context.bundlerConfig['custom-style-rules'] || context.build.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,8 @@
 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 { stringifyConfig } from '../core';
+import { log } from '../utils';
 import {
-    getFolders,
-    getPackageData,
-    getWebpackConfiguration,
-    isCustomStyleRules,
-    isExposeSharedDependencies,
-    isLegacyRoot,
-    isWebComponent,
-    loadSharedDependencies,
-    log,
-} from '../utils';
-import {
-    Context,
     amdConfig,
     cacheConfig,
     devServerConfig,
@@ -31,15 +18,27 @@ import {
     watchOptionsConfig,
 } from './configs';
 import { Options, Overrides } from './types';
-import { getCallerFile, stringifyConfig } from './utils';
+import { createWebpackBuildContext, 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 = createWebpackBuildContext({
+        name: options.name ?? '',
+        isProduction: overrides.configuration?.mode !== 'development',
+        light: options.light,
+        headless: options.headless,
+        emitExposedDependencies: options.emitExposedDependencies,
+        codeCoverage: options.codeCoverage,
+        buildStat: options.buildStat,
+    });
+
+    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 +69,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 =>

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

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+import { Configuration } from 'webpack';
+import { getBuildName, stringifyConfig } from '../core';
+import { hasHeadlessBundle, isWebComponent, log } from '../utils';
+import {
+    createWebpackConfig,
+    webpackDevConfigFileName,
+    webpackProdConfigFileName,
+} from './create-webpack-config';
+import { Options, Overrides } from './types';
+
+interface WebpackConfigs {
+    full: Configuration;
+    light?: Configuration;
+    headless?: Configuration;
+}
+
+export function createWebpackConfigs(options: {
+    buildStat?: boolean;
+    codeCoverage?: boolean;
+    config?: string;
+    emitExposedDependencies?: boolean;
+    useWatchConfig?: boolean;
+    watch?: boolean;
+}): WebpackConfigs {
+    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: getBuildName(),
+    };
+
+    if (isWebComponent()) {
+        const overrides: Overrides = {
+            configuration: { ...customConfig?.configuration, mode },
+            plugins: customConfig?.plugins,
+        };
+
+        return {
+            full: createWebpackConfig(overrides, resolved),
+            light: createWebpackConfig(overrides, { ...resolved, light: true }),
+            headless: hasHeadlessBundle()
+                ? createWebpackConfig(overrides, { ...resolved, headless: true })
+                : undefined,
+        };
+    }
+
+    if (customConfig && !emitExposedDependencies) {
+        return { full: customConfig };
+    }
+
+    return { full: 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/index.ts

@@ -1,2 +1,4 @@
+export * from './bundle-webpack';
 export * from './create-webpack-config';
+export * from './create-webpack-configs';
 export type * from './types';

package/src/webpack/types.ts

@@ -1,18 +1,13 @@
 import { Options as HtmlWebpackPluginOptions } from 'html-webpack-plugin';
 import { PluginOptions as MiniCssExtractPlugInOptions } from 'mini-css-extract-plugin';
 import { Configuration } from 'webpack';
+import { BuildContext, BuildIdentity, BuildOptions } from '../core';
+import { WebpackConfiguration } from '../utils';
 
-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' | 'emitExposedDependencies'> &
+        Pick<BuildOptions, 'codeCoverage' | 'buildStat'>
+>;
 
 export interface Overrides {
     configuration?: Configuration;
@@ -21,3 +16,5 @@ export interface Overrides {
         MiniCssExtractPlugin?: MiniCssExtractPlugInOptions;
     };
 }
+
+export type WebpackBuildContext = BuildContext<WebpackConfiguration>;

package/src/webpack/utils/__tests__/split-by-entry.test.ts

@@ -0,0 +1,33 @@
+import type { Compilation, Entrypoint } from 'webpack';
+import { splitByEntry } from '../split-by-entry';
+
+describe(splitByEntry.name, () => {
+    const entryName = 'main';
+    const entryFiles = ['main.js', 'main.css'];
+
+    let compilation: Compilation;
+    let outputFiles: string[];
+
+    beforeEach(() => {
+        const entrypoint = { getFiles: () => entryFiles } as unknown as Entrypoint;
+        compilation = {
+            entrypoints: new Map([[entryName, entrypoint]]),
+        } as unknown as Compilation;
+        outputFiles = ['main.js', 'main.css', 'vendor.js', 'vendor.css'];
+    });
+
+    const subject = () => splitByEntry(compilation, entryName, outputFiles);
+
+    test('splits output files by entry membership', () => {
+        const [matched, unmatched] = subject();
+
+        expect(matched).toEqual(entryFiles);
+        expect(unmatched).toEqual(outputFiles.filter(f => !entryFiles.includes(f)));
+    });
+
+    test('throws when entry is not found', () => {
+        expect(() => splitByEntry(compilation, 'missing', outputFiles)).toThrow(
+            'entry missing not found'
+        );
+    });
+});

package/src/webpack/utils/create-webpack-build-context.ts

@@ -0,0 +1,12 @@
+import { BuildContextOptions, createBuildContext } from '../../core';
+import { getWebpackConfiguration } from '../../utils';
+import { WebpackBuildContext } from '../types';
+
+export function createWebpackBuildContext(options: BuildContextOptions): WebpackBuildContext {
+    const context = createBuildContext(options);
+
+    return {
+        ...context,
+        bundlerConfig: getWebpackConfiguration(),
+    };
+}

package/src/webpack/utils/index.ts

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

package/dist/cli/commands/bundle-package.d.ts

@@ -1,6 +0,0 @@
-import type { entry } from './registry/bundle-package';
-import { Command } from './types';
-export declare class BundlePackage extends Command<typeof entry> {
-    execute(): Promise<void>;
-}
-//# sourceMappingURL=bundle-package.d.ts.map

package/dist/cli/commands/bundle-package.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle-package.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/bundle-package.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAElC,qBAAa,aAAc,SAAQ,OAAO,CAAC,OAAO,KAAK,CAAC;IAE9C,OAAO;CAyBhB"}

package/dist/cli/commands/bundle-package.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/cli/commands/bundle-package.ts"],"sourcesContent":["import { getTsConfig, log, logErrors } from '../../utils';\nimport { bundle, getModuleType } from '../utils';\nimport type { entry } from './registry/bundle-package';\nimport { Command } from './types';\n\nexport class BundlePackage extends Command<typeof entry> {\n    @logErrors\n    async execute() {\n        const {\n            config,\n            codeCoverage,\n            exposedDependencies: emitExposedDependencies,\n            stat = false,\n            useWatchConfig,\n            watch,\n        } = this.args;\n\n        if (getModuleType(getTsConfig()) !== 'esnext') {\n            log.warning(\n                'webpack packages should set compilerOptions.module to \"esnext\" in tsconfig.json'\n            );\n        }\n\n        const options: Parameters<typeof bundle>[0] = {\n            ...(emitExposedDependencies ? {} : { config }),\n            codeCoverage,\n            emitExposedDependencies,\n            useWatchConfig,\n        };\n\n        await bundle({ buildStat: stat, ...options, watch });\n    }\n}\n"],"names":["BundlePackage","Command","execute","config","codeCoverage","exposedDependencies","emitExposedDependencies","stat","useWatchConfig","watch","args","getModuleType","getTsConfig","log","warning","options","bundle","buildStat"],"mappings":";;;;+BAKaA;;;eAAAA;;;uBAL+B;wBACN;uBAEd;;;;;;;;;;AAEjB,MAAMA,sBAAsBC,cAAO;IACtC,MACMC,UAAU;QACZ,MAAM,EACFC,MAAM,EACNC,YAAY,EACZC,qBAAqBC,uBAAuB,EAC5CC,OAAO,KAAK,EACZC,cAAc,EACdC,KAAK,EACR,GAAG,IAAI,CAACC,IAAI;QAEb,IAAIC,IAAAA,qBAAa,EAACC,IAAAA,kBAAW,SAAQ,UAAU;YAC3CC,UAAG,CAACC,OAAO,CACP;QAER;QAEA,MAAMC,UAAwC;YAC1C,GAAIT,0BAA0B,CAAC,IAAI;gBAAEH;YAAO,CAAC;YAC7CC;YACAE;YACAE;QACJ;QAEA,MAAMQ,IAAAA,cAAM,EAAC;YAAEC,WAAWV;YAAM,GAAGQ,OAAO;YAAEN;QAAM;IACtD;AACJ"}

package/dist/cli/commands/registry/bundle-package.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle-package.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/registry/bundle-package.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;CASO,CAAC"}

package/dist/cli/utils/bundle.d.ts

@@ -1,14 +0,0 @@
-import { Configuration } from 'webpack';
-interface Options {
-    buildStat?: boolean;
-    codeCoverage?: boolean;
-    config?: string;
-    emitExposedDependencies?: boolean | Pick<Configuration, 'output'>;
-    useWatchConfig?: boolean;
-    watch?: boolean;
-}
-export declare const webpackDevConfigFileName = "webpack.dev.config.js";
-export declare const webpackProdConfigFileName = "webpack.prod.config.js";
-export declare function bundle(options?: Options): Promise<void | void[]>;
-export {};
-//# sourceMappingURL=bundle.d.ts.map

package/dist/cli/utils/bundle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/bundle.ts"],"names":[],"mappings":"AAIA,OAAgB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAcjD,UAAU,OAAO;IACb,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uBAAuB,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;IAClE,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB;AAWD,eAAO,MAAM,wBAAwB,0BAA0B,CAAC;AAChE,eAAO,MAAM,yBAAyB,2BAA2B,CAAC;AAElE,wBAAsB,MAAM,CAAC,OAAO,GAAE,OAAY,0BAmCjD"}

package/dist/cli/utils/bundle.js

@@ -1,187 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get bundle () {
-        return bundle;
-    },
-    get webpackDevConfigFileName () {
-        return webpackDevConfigFileName;
-    },
-    get webpackProdConfigFileName () {
-        return webpackProdConfigFileName;
-    }
-});
-const _crypto = /*#__PURE__*/ _interop_require_default(require("crypto"));
-const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
-const _path = /*#__PURE__*/ _interop_require_default(require("path"));
-const _portfinder = require("portfinder");
-const _webpack = /*#__PURE__*/ _interop_require_default(require("webpack"));
-const _webpackdevserver = /*#__PURE__*/ _interop_require_default(require("webpack-dev-server"));
-const _utils = require("../../utils");
-const _webpack1 = require("../../webpack");
-const _utils1 = require("../../webpack/utils");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function getName() {
-    const packageName = (0, _utils.getPackageName)().replace(/\//g, '-').replace(/[^\w-]/g, '');
-    const hash = _crypto.default.randomBytes(4).toString('hex');
-    return `${packageName}-${hash}`;
-}
-const webpackDevConfigFileName = 'webpack.dev.config.js';
-const webpackProdConfigFileName = 'webpack.prod.config.js';
-async function bundle(options = {}) {
-    const { emitExposedDependencies, useWatchConfig, watch } = options;
-    if (emitExposedDependencies) {
-        if (watch) {
-            throw new Error('cannot bundle exposed dependencies in watch mode');
-        }
-        if (!(0, _utils.isExposeSharedDependencies)()) {
-            return;
-        }
-    }
-    _utils.log.info(`Bundling ${emitExposedDependencies ? 'exposed dependencies' : 'package'}...`);
-    const mode = watch || useWatchConfig ? 'development' : 'production';
-    const fallback = watch || useWatchConfig ? webpackDevConfigFileName : webpackProdConfigFileName;
-    const customConfig = readWebpackConfig({
-        ...options,
-        fallback
-    });
-    const webpackOptions = getWebpackOptions(options, customConfig);
-    /* istanbul ignore next: debug only */ _utils.log.debug('custom-webpack-config', ()=>(0, _utils1.stringifyConfig)(customConfig));
-    if ((0, _utils.isWebComponent)()) {
-        return bundleWebComponent({
-            customConfig,
-            mode,
-            watch,
-            webpackOptions
-        });
-    }
-    const config = customConfig && !emitExposedDependencies ? customConfig : (0, _webpack1.createWebpackConfig)({
-        configuration: {
-            mode
-        }
-    }, webpackOptions);
-    if (watch) {
-        return (0, _utils.isDevServerDisabled)() ? runWatch(config) : runServe(config);
-    }
-    return run(config);
-}
-function bundleWebComponent({ customConfig, mode, watch, webpackOptions }) {
-    const overrides = {
-        configuration: {
-            ...customConfig === null || customConfig === void 0 ? void 0 : customConfig.configuration,
-            mode
-        },
-        plugins: customConfig === null || customConfig === void 0 ? void 0 : customConfig.plugins
-    };
-    const fullConfig = (0, _webpack1.createWebpackConfig)(overrides, webpackOptions);
-    const lightConfig = (0, _webpack1.createWebpackConfig)(overrides, {
-        ...webpackOptions,
-        embed: true
-    });
-    const headlessConfig = (0, _utils.hasHeadlessBundle)() ? (0, _webpack1.createWebpackConfig)(overrides, {
-        ...webpackOptions,
-        headless: true
-    }) : undefined;
-    const promises = watch ? [
-        runWatch(lightConfig),
-        (0, _utils.isDevServerDisabled)() ? runWatch(fullConfig) : runServe(fullConfig),
-        headlessConfig && runWatch(headlessConfig)
-    ] : [
-        run(lightConfig),
-        run(fullConfig),
-        headlessConfig && run(headlessConfig)
-    ];
-    return Promise.all(promises.filter((promise)=>!!promise));
-}
-function getWebpackOptions(options, customConfig) {
-    const result = {
-        name: getName(),
-        ...(0, _utils.pick)(options, [
-            'buildStat',
-            'codeCoverage',
-            'emitExposedDependencies'
-        ])
-    };
-    if (result.emitExposedDependencies && customConfig) {
-        result.emitExposedDependencies = {
-            output: customConfig.output
-        };
-    }
-    return result;
-}
-function readWebpackConfig({ config, fallback }) {
-    var _readConfig;
-    return (_readConfig = readConfig(config)) !== null && _readConfig !== void 0 ? _readConfig : readConfig(fallback);
-}
-function readConfig(relativePath) {
-    if (relativePath && _fs.default.existsSync(relativePath)) {
-        return require(_path.default.resolve(relativePath));
-    }
-}
-async function run(config) {
-    const compiler = createWebpackCompiler(config);
-    const stats = await new Promise((resolve, reject)=>{
-        compiler.run((error, stats)=>{
-            if (!stats || error) {
-                return reject(error !== null && error !== void 0 ? error : new Error('Something went wrong.'));
-            }
-            if (stats.hasErrors()) {
-                return reject(new Error(stats.toString('errors-only')));
-            }
-            compiler.close(()=>resolve(stats));
-        });
-    });
-    process.stdout.write(stats.toString(config.stats) + '\n');
-}
-async function runServe({ devServer = {}, ...config }) {
-    var _devServer_host;
-    const compiler = createWebpackCompiler(config);
-    const host = (_devServer_host = devServer.host) !== null && _devServer_host !== void 0 ? _devServer_host : 'localhost';
-    const port = await (0, _portfinder.getPortPromise)({
-        port: Number(process.env.PORT) || Number(devServer.port) || 8080,
-        host
-    });
-    return new Promise((_0, reject)=>{
-        const server = new _webpackdevserver.default({
-            ...devServer,
-            host,
-            port
-        }, compiler);
-        server.startCallback((e)=>{
-            if (e) {
-                server.stopCallback(()=>{
-                    reject(e);
-                });
-            }
-        });
-    });
-}
-async function runWatch(config) {
-    const compiler = createWebpackCompiler(config);
-    return new Promise((_0, reject)=>{
-        const watching = compiler.watch({}, (e)=>{
-            if (e) {
-                watching === null || watching === void 0 ? void 0 : watching.close(()=>{
-                    reject(e);
-                });
-            }
-        });
-    });
-}
-function createWebpackCompiler(config) {
-    return (0, _webpack.default)(config);
-}
-
-//# sourceMappingURL=bundle.js.map