@servicetitan/startup 36.3.1 → 36.4.0

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,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,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,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 { 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,28 @@ 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,
+        outputBasePath: options.outputBasePath,
+        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');
     }
 
@@ -71,37 +70,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,
-        packageManager: getPackageManager(),
-        sharedDependencies,
-        source,
-    };
-}
-
 function isCalledFromCustomWebpackConfigFile() {
     const callerFileName = getCallerFile();
     return [webpackDevConfigFileName, webpackProdConfigFileName].some(configFileName =>

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

@@ -0,0 +1,83 @@
+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 };
+    }
+
+    /*
+     * outputBasePath is wired only here, for the shared-deps build. MFE main
+     * bundles (handled above) must publish under <package>/dist/bundle/<subdir>,
+     * so a custom output.path from the user's webpack config is not honored
+     * for them.
+     */
+    return {
+        full: createWebpackConfig(
+            { configuration: { mode } },
+            { ...resolved, outputBasePath: customConfig?.output?.path }
+        ),
+    };
+}
+
+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,16 @@
 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' | 'outputBasePath'
+    > &
+        Pick<BuildOptions, 'codeCoverage' | 'buildStat'>
+>;
 
 export interface Overrides {
     configuration?: Configuration;
@@ -21,3 +19,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"}