@servicetitan/startup 36.3.1 → 37.0.0

package/src/cli/commands/start.ts

@@ -1,7 +1,8 @@
-import { getPackages, log, logErrors, PackageType } from '../../utils';
+import { getPackages, logErrors, PackageType } from '../../utils';
 import {
     checkArgs,
     compile,
+    getBundleCommand,
     lernaExec,
     pipeStdout,
     ProcessTree,
@@ -19,7 +20,7 @@ enum StartProcesses {
     PreparePackageWatch,
     TypeCheck,
     BundleExposedDependencies,
-    BundlePackage,
+    Bundle,
 }
 
 export class Start extends Command<typeof entry> {
@@ -32,16 +33,17 @@ export class Start extends Command<typeof entry> {
         const packages = getPackages({
             scope: this.args.scope,
             ignore: this.args.ignore,
-            type: [PackageType.TSC, PackageType.Webpack],
+            type: [PackageType.TSC, PackageType.Bundle],
         });
         if (packages.length === 0) {
             return;
         }
 
         const scope = packages.map(({ name }) => name);
-        const webpackScope = packages
-            .filter(({ type }) => type === PackageType.Webpack)
+        const bundleScope = packages
+            .filter(({ type }) => type === PackageType.Bundle)
             .map(({ name }) => name);
+        const bundleCmd = getBundleCommand(this.args);
         const precompileScope = packages
             .filter(({ scripts }) => !!scripts?.precompile)
             .map(({ name }) => name);
@@ -73,23 +75,8 @@ export class Start extends Command<typeof entry> {
 
                 const onComplete = new Promise<void>(resolve => {
                     let counter = 0;
-                    let timeout: NodeJS.Timeout;
 
-                    if (!useTsc) {
-                        /*
-                         * Running the timer as a fallback
-                         * In case there are no files in the package swc will not print out completion indicator
-                         */
-                        timeout = setTimeout(() => {
-                            log.warning(
-                                'Compilation timeout exceeded. Proceeding without waiting.'
-                            );
-                            resolve();
-                            unwatch();
-                        }, 30000);
-                    }
-
-                    const unwatch = watchStdout(
+                    watchStdout(
                         process,
                         useTsc
                             ? 'Initial tsc-compile-package task completed'
@@ -99,7 +86,6 @@ export class Start extends Command<typeof entry> {
 
                             if (counter === scope.length) {
                                 resolve();
-                                clearTimeout(timeout);
                             }
                         }
                     );
@@ -136,12 +122,12 @@ export class Start extends Command<typeof entry> {
         processTree.add(
             StartProcesses.BundleExposedDependencies,
             () => {
-                if (webpackScope.length === 0) {
+                if (bundleScope.length === 0) {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    'cmd': 'startup bundle-package',
-                    'scope': webpackScope,
+                    'cmd': bundleCmd,
+                    'scope': bundleScope,
                     'parallel': true,
                     'stream': true,
                     '--': ['--exposed-dependencies', '--use-watch-config'],
@@ -150,14 +136,14 @@ export class Start extends Command<typeof entry> {
             { dependsOn: [StartProcesses.Compile, StartProcesses.PreparePackage] }
         );
         processTree.add(
-            StartProcesses.BundlePackage,
+            StartProcesses.Bundle,
             () => {
-                if (webpackScope.length === 0) {
+                if (bundleScope.length === 0) {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    'cmd': 'startup bundle-package',
-                    'scope': webpackScope,
+                    'cmd': bundleCmd,
+                    'scope': bundleScope,
                     'parallel': true,
                     'stream': true,
                     '--': [

package/src/cli/index.ts

@@ -4,10 +4,11 @@ import kebabCase from 'lodash.kebabcase';
 import path from 'path';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import { CommandName, getStartupVersion, log } from '../utils';
+import { getStartupVersion } from '../core';
+import { CommandName, log } from '../utils';
 import { commandRegistry } from './commands/registry';
 import type { CommandOptions } from './commands/types';
-import { checkStartupLocation, setNodeOptions } from './utils';
+import { checkStartupLocation, getExitCode, setNodeOptions } from './utils';
 
 const yargsInstance = yargs(hideBin(process.argv));
 
@@ -60,7 +61,7 @@ async function handleCommand(name: CommandName, argv: any) {
     if (setNodeOptions(name, entry)) {
         log.debug('run', `Running ${name} in child process with amended NODE_OPTIONS`);
         execa(process.argv[0], process.argv.slice(1), { stdio: 'inherit' }).catch(reason => {
-            process.exit(reason.exitCode);
+            process.exit(getExitCode(reason));
         });
         return;
     }

package/src/cli/tasks/swc-compile-package/__tests__/swc-compile-package.test.ts

@@ -8,7 +8,7 @@ import { SwcCompilePackage } from '../swc-compile-package';
 
 jest.mock('fs', () => fs);
 jest.mock('@swc/cli', () => ({
-    swcDir: jest.fn(),
+    swcDir: jest.fn(() => Promise.resolve()),
 }));
 
 jest.mock('../../../../utils', () => ({
@@ -191,9 +191,29 @@ describe(`[startup] ${SwcCompilePackage.name} task`, () => {
         );
     });
 
+    /*
+     * This test covers the case where swcDir resolves without calling either callback,
+     * which will happen in watch mode when no files are compiled
+     */
+    test('logs completion message', async () => {
+        await subject();
+
+        expect(log.info).toHaveBeenCalledWith(
+            expect.stringMatching('swc-compile-package task completed in 0ms')
+        );
+    });
+
     describe('in watch mode', () => {
         beforeEach(() => (watch = true));
 
+        test('logs completion message', async () => {
+            await subject();
+
+            expect(log.info).toHaveBeenCalledWith(
+                expect.stringMatching('Initial swc-compile-package task completed in 0ms')
+            );
+        });
+
         test('calls swcDir with watch=true', () => {
             subject();
 

package/src/cli/tasks/swc-compile-package/swc-cli.d.ts

@@ -18,5 +18,5 @@ declare module '@swc/cli' {
 
     type SwcOptions = NonNullable<Options['swcOptions']>;
 
-    function swcDir(options: Options): void;
+    function swcDir(options: Options): Promise<void>;
 }

package/src/cli/tasks/swc-compile-package/swc-compile-package.ts

@@ -25,17 +25,18 @@ export class SwcCompilePackage extends Task {
         /* istanbul ignore next: debug only */
         log.debug('swc-compile-package:config', () => JSON.stringify(config, null, 2));
 
+        let callbackFired = false;
+
         return new Promise((resolve, reject) => {
             swcDir({
                 ...config,
                 callbacks: {
                     onSuccess: (e: { duration: number }) => {
+                        callbackFired = true;
                         this.logCompletionResults(this.taskTimer.add(e.duration));
-                        if (!this.watch) {
-                            resolve();
-                        }
                     },
                     onFail: (e: { duration: number; reasons: Map<string, string> }) => {
+                        callbackFired = true;
                         log.text([...e.reasons.values()][0]);
                         this.logCompletionResults(this.taskTimer.add(e.duration));
                         if (!this.watch) {
@@ -43,6 +44,11 @@ export class SwcCompilePackage extends Task {
                         }
                     },
                 },
+            }).then(() => {
+                if (!callbackFired) {
+                    this.logCompletionResults(this.taskTimer.add(0));
+                }
+                resolve();
             });
         });
     }

package/src/cli/tasks/tsc-compile/tsc-compile.ts

@@ -31,7 +31,7 @@ export class TscCompile extends CliTask {
         const packages = getPackages({
             scope: this.args.scope,
             ignore: this.args.ignore,
-            type: [PackageType.TSC, PackageType.Webpack],
+            type: [PackageType.TSC, PackageType.Bundle],
         });
 
         const tsConfigs = collapsePackages(packages).map(({ location }) => getTsConfig(location));

package/src/cli/utils/__tests__/get-bundle-command.test.ts

@@ -0,0 +1,23 @@
+import { getBundleCommand } from '../get-bundle-command';
+
+describe(`[startup] ${getBundleCommand.name}`, () => {
+    let args: Parameters<typeof getBundleCommand>[0];
+
+    const subject = () => getBundleCommand(args);
+
+    describe('when bundler is vite', () => {
+        beforeEach(() => (args = { bundler: 'vite' }));
+
+        test('returns "startup bundle-vite"', () => {
+            expect(subject()).toBe('startup bundle-vite');
+        });
+    });
+
+    describe('when bundler is webpack', () => {
+        beforeEach(() => (args = { bundler: 'webpack' }));
+
+        test('returns "startup bundle-webpack"', () => {
+            expect(subject()).toBe('startup bundle-webpack');
+        });
+    });
+});

package/src/cli/utils/__tests__/get-exit-code.test.ts

@@ -0,0 +1,41 @@
+import os from 'node:os';
+import { getExitCode } from '../get-exit-code';
+
+describe(`[startup] utils:${getExitCode.name}`, () => {
+    const SIGNAL_EXIT_BASE = 128;
+    let error: { exitCode?: number; signal?: NodeJS.Signals };
+
+    beforeEach(() => {
+        error = {};
+    });
+
+    const subject = () => getExitCode(error);
+
+    test('returns 1', () => {
+        expect(subject()).toBe(1);
+    });
+
+    describe('when the child exited with a non-zero code', () => {
+        beforeEach(() => (error = { exitCode: 2 }));
+
+        test('returns that exit code', () => {
+            expect(subject()).toBe(2);
+        });
+    });
+
+    describe('when the child was killed by a signal', () => {
+        beforeEach(() => (error = { signal: 'SIGINT' }));
+
+        test(`returns ${SIGNAL_EXIT_BASE} plus the signal number`, () => {
+            expect(subject()).toBe(SIGNAL_EXIT_BASE + os.constants.signals.SIGINT);
+        });
+    });
+
+    describe('when the signal is not recognized', () => {
+        beforeEach(() => (error = { signal: 'NOTASIGNAL' as NodeJS.Signals }));
+
+        test(`returns ${SIGNAL_EXIT_BASE + 1}`, () => {
+            expect(subject()).toBe(SIGNAL_EXIT_BASE + 1);
+        });
+    });
+});

package/src/cli/utils/__tests__/resolve-bundler.test.ts

@@ -0,0 +1,64 @@
+import { getConfiguration, log } from '../../../utils';
+import { resolveBundler } from '../resolve-bundler';
+
+jest.mock('../../../utils', () => ({
+    ...jest.requireActual('../../../utils'),
+    getConfiguration: jest.fn(),
+    log: { warning: jest.fn() },
+}));
+
+describe(`[startup] ${resolveBundler.name}`, () => {
+    let args: Parameters<typeof resolveBundler>[0];
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        args = {};
+        jest.mocked(getConfiguration).mockReturnValue({} as any);
+    });
+
+    const subject = () => resolveBundler(args);
+
+    test('defaults to webpack', () => {
+        expect(subject()).toBe('webpack');
+    });
+
+    describe('with the --bundler flag', () => {
+        beforeEach(() => (args = { bundler: 'vite' }));
+
+        test('uses the flag value', () => {
+            expect(subject()).toBe(args.bundler);
+        });
+    });
+
+    describe('with cli.bundler config', () => {
+        beforeEach(() => jest.mocked(getConfiguration).mockReturnValue({ bundler: 'vite' } as any));
+
+        test('uses the configured bundler', () => {
+            expect(subject()).toBe(getConfiguration().bundler);
+        });
+
+        describe('and the --bundler flag', () => {
+            beforeEach(() => (args = { bundler: 'webpack' }));
+
+            test('the flag wins over config', () => {
+                expect(subject()).toBe(args.bundler);
+            });
+        });
+    });
+
+    describe('with the deprecated --use-vite flag', () => {
+        beforeEach(() => (args = { useVite: true }));
+
+        test('resolves to vite', () => {
+            expect(subject()).toBe('vite');
+        });
+
+        test('logs a deprecation warning', () => {
+            subject();
+
+            expect(log.warning).toHaveBeenCalledWith(
+                expect.stringContaining('--use-vite is deprecated')
+            );
+        });
+    });
+});

package/src/cli/utils/copy-files.ts

@@ -7,7 +7,7 @@ import { compileLess } from './compile-less';
 import { compileSass } from './compile-sass';
 
 const assetExtensions = ['eot', 'gif', 'jpg', 'otf', 'png', 'svg', 'ttf', 'woff', 'woff2'];
-const resourceExtensions = ['json'];
+const resourceExtensions = ['html', 'json'];
 export const styleExtensions = ['css', 'less', 'scss'];
 const styleTypeDefinitionExtensions = styleExtensions.map(ext => `${ext}.d.ts`);
 

package/src/cli/utils/get-bundle-command.ts

@@ -0,0 +1,5 @@
+import { resolveBundler } from './resolve-bundler';
+
+export function getBundleCommand(args: Parameters<typeof resolveBundler>[0]): string {
+    return resolveBundler(args) === 'vite' ? 'startup bundle-vite' : 'startup bundle-webpack';
+}

package/src/cli/utils/get-exit-code.ts

@@ -0,0 +1,17 @@
+import os from 'node:os';
+
+const SIGNAL_EXIT_BASE = 128;
+
+/**
+ * Derive this process's exit code from a failed child process result.
+ *
+ * A signal death (Ctrl-C, OOM kill) carries no exitCode, so map it to the
+ * shell's "128 + signal number" convention. Exiting with an undefined exitCode
+ * would resolve to 0, reporting a killed build as a success.
+ */
+export function getExitCode({ exitCode, signal }: { exitCode?: number; signal?: string }): number {
+    if (signal) {
+        return SIGNAL_EXIT_BASE + (os.constants.signals[signal as NodeJS.Signals] ?? 1);
+    }
+    return exitCode ?? 1;
+}

package/src/cli/utils/index.ts

@@ -1,4 +1,3 @@
-export * from './bundle';
 export * from './check-args';
 export * from './check-startup-location';
 export * from './cli-git';
@@ -17,6 +16,8 @@ export * from './compile';
  */
 export * from './constants';
 export * from './eslint';
+export * from './get-bundle-command';
+export * from './get-exit-code';
 export * from './get-module-type';
 export * from './is-module-installed';
 export * from './is-tty';
@@ -25,6 +26,7 @@ export * from './maybe-create-git-folder';
 export * from './pipe-stdout';
 export * from './process-tree';
 export * from './publish';
+export * from './resolve-bundler';
 export * from './set-node-options';
 // Don't export ./stylelint, it breaks tests using the default "jsdom" environment
 export * from './ts-config';

package/src/cli/utils/resolve-bundler.ts

@@ -0,0 +1,23 @@
+import { type Bundler, getConfiguration, log } from '../../utils';
+
+interface BundlerArgs {
+    bundler?: Bundler;
+    useVite?: boolean;
+}
+
+/*
+ * Resolves the bundler from the --bundler flag, then the deprecated --use-vite
+ * flag, then the cli.bundler package.json config, then the webpack default.
+ */
+export function resolveBundler(args: BundlerArgs): Bundler {
+    if (args.bundler) {
+        return args.bundler;
+    }
+
+    if (args.useVite) {
+        log.warning('--use-vite is deprecated. Use --bundler=vite instead.');
+        return 'vite';
+    }
+
+    return getConfiguration().bundler ?? 'webpack';
+}

package/src/core/__tests__/bundle-report.test.ts

@@ -0,0 +1,60 @@
+import { bundleReportFileName, bundleReportTitle } from '../bundle-report';
+import { getBundleType } from '../get-bundle-type';
+
+jest.mock('../get-bundle-type');
+
+const NOW = new Date(2026, 5, 9, 9, 5);
+const FORMATTED_DATE = '2026-06-09 09:05';
+
+describe('bundle-report', () => {
+    let context: Parameters<typeof bundleReportFileName>[0];
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.useFakeTimers().setSystemTime(NOW);
+        context = { package: { name: '@servicetitan/foo' } } as typeof context;
+        jest.mocked(getBundleType).mockReturnValue(undefined);
+    });
+
+    afterEach(() => jest.useRealTimers());
+
+    describe(bundleReportFileName.name, () => {
+        const subject = () => bundleReportFileName(context);
+
+        test('combines package name and timestamp', () => {
+            expect(subject()).toBe(`${context.package.name}-bundle-${NOW.getTime()}`);
+        });
+
+        describe('with a bundle type', () => {
+            const type = 'full';
+
+            beforeEach(() => jest.mocked(getBundleType).mockReturnValue(type));
+
+            test('adds type to the name', () => {
+                expect(subject()).toBe(`${context.package.name}-${type}-bundle-${NOW.getTime()}`);
+            });
+        });
+    });
+
+    describe(bundleReportTitle.name, () => {
+        const subject = () => bundleReportTitle(context);
+
+        const unscoped = (name: string) => name.replace(/^@[^/]+\//, '');
+
+        test('combines unscoped name and formatted date', () => {
+            expect(subject()).toBe(`${unscoped(context.package.name)} ${FORMATTED_DATE}`);
+        });
+
+        describe('with a bundle type', () => {
+            const type = 'full';
+
+            beforeEach(() => jest.mocked(getBundleType).mockReturnValue(type));
+
+            test('appends the type in parentheses', () => {
+                expect(subject()).toBe(
+                    `${unscoped(context.package.name)} (${type}) ${FORMATTED_DATE}`
+                );
+            });
+        });
+    });
+});

package/src/core/__tests__/create-extension-regexp.test.ts

@@ -0,0 +1,32 @@
+import { createExtensionRegExp } from '../create-extension-regexp';
+
+describe(createExtensionRegExp.name, () => {
+    let extensions: string[];
+
+    beforeEach(() => (extensions = ['png', 'gif']));
+
+    const subject = () => createExtensionRegExp(extensions);
+
+    test('regex matches all extensions', () => {
+        const regex = subject();
+        expect(extensions.every(extension => regex.test(`foo.${extension}`))).toBe(true);
+    });
+
+    test('regex does not match other extensions', () => {
+        expect(subject().test('foo.js')).toBe(false);
+    });
+
+    test('regex is case-insensitive', () => {
+        const regex = subject();
+        expect(extensions.every(extension => regex.test(`foo.${extension}`.toUpperCase()))).toBe(
+            true
+        );
+    });
+
+    test('regex only matches extension at end of string', () => {
+        const regex = subject();
+        expect(extensions.some(extension => regex.test(`${extension}/foo.js`.toUpperCase()))).toBe(
+            false
+        );
+    });
+});

package/src/core/__tests__/get-cdn-path.test.ts

@@ -0,0 +1,27 @@
+import { getCdnPath } from '../get-cdn-path';
+import { BuildContext } from '../types';
+
+describe(`[startup] ${getCdnPath.name}`, () => {
+    let context: Partial<BuildContext>;
+
+    beforeAll(() => (process.env.CLIENT_CDN_PATH = 'foo'));
+    afterAll(() => delete process.env.CLIENT_CDN_PATH);
+
+    beforeEach(() => {
+        context = { build: { name: '', isProduction: true } };
+    });
+
+    const subject = () => getCdnPath(context as any);
+
+    test('returns process.env.CLIENT_CDN_PATH', () => {
+        expect(subject()).toEqual(process.env.CLIENT_CDN_PATH);
+    });
+
+    describe('when not production', () => {
+        beforeEach(() => (context.build!.isProduction = false));
+
+        test('returns undefined', () => {
+            expect(subject()).toBeUndefined();
+        });
+    });
+});

package/src/core/__tests__/resolve-output-path.test.ts

@@ -0,0 +1,45 @@
+import path from 'path';
+import { getBundleType } from '../get-bundle-type';
+import { resolveOutputPath } from '../resolve-output-path';
+import { resolveOutputRoot } from '../resolve-output-root';
+import { BuildContext } from '../types';
+
+jest.mock('../get-bundle-type');
+
+describe(`[startup] ${resolveOutputPath.name}`, () => {
+    let context: BuildContext;
+    let outputPath: string | undefined;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.mocked(getBundleType).mockReturnValue(undefined);
+        context = { build: {}, package: { destination: 'dist' } } as BuildContext;
+        outputPath = undefined;
+    });
+
+    const subject = () => resolveOutputPath(context, outputPath);
+
+    function itReturnsResolvedRoot() {
+        test('returns resolved root', () => {
+            expect(subject()).toBe(resolveOutputRoot(context, outputPath));
+        });
+    }
+
+    itReturnsResolvedRoot();
+
+    describe('with an outputPath', () => {
+        beforeEach(() => (outputPath = '/output/dir'));
+
+        itReturnsResolvedRoot();
+    });
+
+    describe('when getBundleType returns a subdir', () => {
+        const subdir = 'full';
+
+        beforeEach(() => jest.mocked(getBundleType).mockReturnValue(subdir));
+
+        test('appends the subdir to the output root', () => {
+            expect(subject()).toBe(path.join(resolveOutputRoot(context, outputPath), subdir));
+        });
+    });
+});

package/src/core/__tests__/resolve-output-root.test.ts

@@ -0,0 +1,37 @@
+import path from 'path';
+import { resolveOutputRoot } from '../resolve-output-root';
+import { BuildContext } from '../types';
+
+describe(`[startup] ${resolveOutputRoot.name}`, () => {
+    let context: BuildContext;
+    let outputPath: string | undefined;
+
+    beforeEach(() => {
+        context = { build: {}, package: { destination: 'dist' } } as BuildContext;
+        outputPath = undefined;
+    });
+
+    const subject = () => resolveOutputRoot(context, outputPath);
+
+    function itReturnsDefaultRoot() {
+        test('returns default output root', () => {
+            expect(subject()).toBe(path.join(process.cwd(), context.package.destination, 'bundle'));
+        });
+    }
+
+    itReturnsDefaultRoot();
+
+    describe('with an outputPath', () => {
+        beforeEach(() => (outputPath = '/foo'));
+
+        test('returns the outputPath', () => {
+            expect(subject()).toBe(outputPath);
+        });
+
+        describe('when the package is an MFE', () => {
+            beforeEach(() => (context.package.isWebComponent = true));
+
+            itReturnsDefaultRoot();
+        });
+    });
+});