@servicetitan/startup 36.3.1 → 37.0.0

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

@@ -1,80 +1,26 @@
 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 pluginModules: ConstructorParameters<typeof VirtualModulesPlugin>[0] = {};
 
-    if (context.isWebComponent) {
+    if (modules.index) {
         const indexPath = path.join(process.cwd(), destination, 'index');
-        modules[indexPath] = indexCode(context);
+        pluginModules[indexPath] = modules.index;
     }
 
-    if (needsToIncludeDesignSystem(context)) {
+    if (modules.designSystem) {
         const designSystemPath = getDesignSystemPath(context);
         if (!fs.existsSync(designSystemPath)) {
-            modules[designSystemPath] = designSystemCode();
+            pluginModules[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(pluginModules).length ? new VirtualModulesPlugin(pluginModules) : 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,9 +1,12 @@
 import { Configuration } from 'webpack';
+import { BuildContext } from '../../core';
+import { Overrides } from '../types';
 import {
     assetsManifestPlugin,
     bundleAnalyzerPlugin,
     defineExposedDependenciesPlugin,
     defineExposedInstanceDependenciesPlugin,
+    defineProcessEnvPlugin,
     defineWebComponentNamePlugin,
     filterWarningsPlugin,
     htmlPlugin,
@@ -15,17 +18,17 @@ 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,
         defineExposedDependenciesPlugin,
         defineExposedInstanceDependenciesPlugin,
+        defineProcessEnvPlugin,
         defineWebComponentNamePlugin,
         filterWarningsPlugin,
         htmlPlugin,

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

@@ -1,11 +1,13 @@
 import path from 'path';
 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' | 'resolveLoader'>;
 
-export function resolveConfig({ packageManager }: Context, _: Overrides): Result {
+export function resolveConfig(context: BuildContext, _: Overrides): Result {
+    const { packageManager } = context.package;
     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.build;
     const result: RuleSetRule[] = [
         {
             test: /\.module.css$/,

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

@@ -1,10 +1,10 @@
 import { RuleSetRule } from 'webpack';
-import { Context } from '../types';
+import { BuildContext, FONT_EXTENSIONS, createExtensionRegExp } from '../../../core';
 
-export function fontRules(_: Context): RuleSetRule[] {
+export function fontRules(_: BuildContext): RuleSetRule[] {
     return [
         {
-            test: /\.(woff|woff2|eot|ttf|otf)$/i,
+            test: createExtensionRegExp(FONT_EXTENSIONS),
             type: 'asset/resource',
             generator: {
                 filename: 'fonts/[contenthash][ext][query]',

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

@@ -1,10 +1,10 @@
 import { RuleSetRule } from 'webpack';
-import { Context } from '../types';
+import { BuildContext, IMAGE_EXTENSIONS, createExtensionRegExp } from '../../../core';
 
-export function imageRules(_: Context): RuleSetRule[] {
+export function imageRules(_: BuildContext): RuleSetRule[] {
     return [
         {
-            test: /\.(png|jpg|jpeg|gif)$/i,
+            test: createExtensionRegExp(IMAGE_EXTENSIONS),
             type: 'asset',
             generator: {
                 filename: 'images/[contenthash][ext][query]',

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

@@ -1,8 +1,9 @@
 import { RuleSetRule } from 'webpack';
+import { BuildContext } from '../../../core';
 import { JS_RULE_EXCLUDE } from '../constants';
-import { Context } from '../types';
 
-export function jsRules({ codeCoverage }: Context): RuleSetRule[] {
+export function jsRules(context: BuildContext): RuleSetRule[] {
+    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,22 +1,8 @@
-import { getPackageManager } from '@servicetitan/install';
 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 { resolveOutputPath, stringifyConfig } from '../core';
+import { log } from '../utils';
 import {
-    getFolders,
-    getPackageData,
-    getWebpackConfiguration,
-    isCustomStyleRules,
-    isExposeSharedDependencies,
-    isLegacyRoot,
-    isWebComponent,
-    loadSharedDependencies,
-    log,
-} from '../utils';
-import {
-    Context,
     amdConfig,
     cacheConfig,
     devServerConfig,
@@ -32,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');
     }
 
@@ -60,48 +58,25 @@ export function createWebpackConfig(overrides: Overrides, options: Options = {})
         watchOptionsConfig,
     ];
 
-    const result = merge(
-        configs.reduce((result, fn) => ({ ...result, ...fn(context, overrides) }), {}),
+    const merged = merge(
+        configs.reduce<Configuration>(
+            (result, fn) => ({ ...result, ...fn(context, overrides) }),
+            {}
+        ),
         overrides.configuration ?? {}
     );
 
+    // Resolve the output path: web components force the default, hosts honor a configured path.
+    const result = merge(merged, {
+        output: { path: resolveOutputPath(context, merged.output?.path) },
+    });
+
     /* istanbul ignore next: debug only */
     log.debug('create-webpack-config', () => stringifyConfig(result));
 
     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,
-        packageManager: getPackageManager(),
-        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 resolved: Options = {
+        buildStat: options.buildStat,
+        codeCoverage: options.codeCoverage,
+        emitExposedDependencies: options.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 && !options.emitExposedDependencies) {
+        return { full: customConfig };
+    }
+
+    return {
+        full: createWebpackConfig(
+            { configuration: { mode, output: customConfig?.output } },
+            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,7 @@
+import { BuildContextOptions, createBuildContext } from '../../core';
+import { getWebpackConfiguration } from '../../utils';
+import { WebpackBuildContext } from '../types';
+
+export function createWebpackBuildContext(options: BuildContextOptions): WebpackBuildContext {
+    return { ...createBuildContext(options), 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/tsconfig/base.json

@@ -6,11 +6,11 @@
         "module": "esnext",
         "moduleResolution": "Bundler",
         "lib": ["dom", "dom.iterable", "esnext"],
+        "types": ["node", "jest"],
         "jsx": "react-jsx",
         "declaration": true,
         "declarationMap": true,
         "sourceMap": true,
-        "strict": true,
         "strictFunctionTypes": false,
         "esModuleInterop": true,
         "experimentalDecorators": true,

package/tsconfig/types.d.ts

@@ -22,3 +22,13 @@ declare module '@servicetitan/anvil2/*.svg' {
     const ReactComponent: SvgComponent;
     export default ReactComponent;
 }
+
+declare module '*.less' {
+    const content: string;
+    export default content;
+}
+
+declare module '*.css' {
+    const content: string;
+    export default content;
+}

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"}