@servicetitan/startup 36.4.0 → 37.0.1

package/src/cli/commands/review/rules/require-compatible-typescript.ts

@@ -0,0 +1,64 @@
+import chalk from 'chalk';
+import { execSync } from 'node:child_process';
+import { lt, minVersion, valid } from 'semver';
+import { FixCategory, PackageError, PackageRule, Project } from '../types';
+
+const STARTUP = '@servicetitan/startup';
+const TYPESCRIPT = 'typescript';
+
+interface ErrorData {
+    actualVersion: string;
+    requiredVersion: string;
+}
+
+type RuleError = PackageError<ErrorData>;
+
+export class RequireCompatibleTypescript implements PackageRule {
+    get id() {
+        return 'require-compatible-typescript';
+    }
+
+    run({ packageManager }: Project): RuleError | undefined {
+        if (packageManager.command === 'pnpm') {
+            return;
+        }
+
+        const requiredVersion = packageManager.getDeclaredVersion({
+            workspacePackage: '',
+            declaredBy: STARTUP,
+            dependency: TYPESCRIPT,
+        });
+        const actualVersion = packageManager.getResolvedVersion({
+            workspacePackage: '',
+            dependency: TYPESCRIPT,
+        });
+        if (!(requiredVersion && actualVersion)) {
+            return;
+        }
+
+        const floor = minVersion(requiredVersion);
+        if (floor && valid(actualVersion) && lt(actualVersion, floor)) {
+            return {
+                id: this.id,
+                message: `project's top-level "${TYPESCRIPT}" is older than the version required by ${STARTUP}`,
+                details: `${chalk.yellow(actualVersion)} is older than ${requiredVersion}`,
+                fixable: FixCategory.lockFile,
+                location: packageManager.lockFileName,
+                data: { actualVersion, requiredVersion },
+            };
+        }
+    }
+
+    fix({ data }: RuleError) {
+        const { requiredVersion } = data ?? {};
+        if (!requiredVersion) {
+            return;
+        }
+
+        [
+            `npm pkg set dependencies["${TYPESCRIPT}"]="${requiredVersion}"`,
+            'npx @servicetitan/install --fix --quiet',
+            `npm pkg delete dependencies["${TYPESCRIPT}"]`,
+        ].forEach(command => execSync(command, { stdio: 'inherit' }));
+    }
+}

package/src/cli/commands/start.ts

@@ -2,6 +2,7 @@ import { getPackages, logErrors, PackageType } from '../../utils';
 import {
     checkArgs,
     compile,
+    getBundleCommand,
     lernaExec,
     pipeStdout,
     ProcessTree,
@@ -28,8 +29,6 @@ export class Start extends Command<typeof entry> {
         checkArgs(this.args, { obsolete: ['--esbuild', '--experimental-bundlers'] });
 
         const useTsc = this.args.useTsc;
-        const useVite = this.args.useVite;
-        const cmd = useVite ? 'startup bundle-vite' : 'startup bundle-package';
 
         const packages = getPackages({
             scope: this.args.scope,
@@ -44,6 +43,7 @@ export class Start extends Command<typeof entry> {
         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);
@@ -126,7 +126,7 @@ export class Start extends Command<typeof entry> {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    cmd,
+                    'cmd': bundleCmd,
                     'scope': bundleScope,
                     'parallel': true,
                     'stream': true,
@@ -142,7 +142,7 @@ export class Start extends Command<typeof entry> {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    cmd,
+                    'cmd': bundleCmd,
                     'scope': bundleScope,
                     'parallel': true,
                     'stream': true,

package/src/cli/commands/test/runners/__tests__/vitest.test.ts

@@ -3,6 +3,7 @@ import { fs, vol } from 'memfs';
 import { configDefaults, coverageConfigDefaults, mergeConfig, ViteUserConfig } from 'vitest/config';
 import { parseCLI, resolveConfig, startVitest } from 'vitest/node';
 import { getDefaultTestExcludes } from '../../../../../utils';
+import { ignoreModulesPlugin } from '../../../../../vite/plugins';
 import { Vitest } from '../vitest';
 
 /**
@@ -20,6 +21,7 @@ jest.mock('vitest/', () => ({
 }));
 
 jest.mock('fs', () => fs);
+jest.mock('../../../../../vite/plugins', () => ({ ignoreModulesPlugin: jest.fn() }));
 
 describe(`[startup] Test ${Vitest.name}`, () => {
     const defaultExcludes = getDefaultTestExcludes();
@@ -42,6 +44,7 @@ describe(`[startup] Test ${Vitest.name}`, () => {
         jest.mocked(parseCLI).mockReturnValue({ filter: [], options: {} });
         jest.mocked(resolveConfig).mockResolvedValue({ viteConfig: {} } as any);
         jest.mocked(startVitest).mockResolvedValue({ close: jest.fn() } as any);
+        jest.mocked(ignoreModulesPlugin).mockReturnValue({ name: 'ignore-modules' } as any);
 
         vol.fromJSON({ 'package.json': JSON.stringify({}) });
     });
@@ -60,7 +63,10 @@ describe(`[startup] Test ${Vitest.name}`, () => {
             {},
             {
                 test: config,
-                plugins: [expect.objectContaining({ name: 'vitest-svg-transformer' })],
+                plugins: [
+                    expect.objectContaining({ name: 'vitest-svg-transformer' }),
+                    expect.objectContaining({ name: 'ignore-modules' }),
+                ],
                 ...overrides,
             }
         );
@@ -105,6 +111,7 @@ describe(`[startup] Test ${Vitest.name}`, () => {
                                     'coverage.include',
                                     'environment',
                                     'plugins.vitest-svg-transformer',
+                                    'plugins.ignore-modules',
                                 ],
                             },
                         },

package/src/cli/commands/test/runners/vitest.ts

@@ -1,6 +1,7 @@
 import { configDefaults, coverageConfigDefaults, mergeConfig, ViteUserConfig } from 'vitest/config';
 import { parseCLI, resolveConfig, startVitest } from 'vitest/node';
 import { getDefaultTestExcludes, getVitestConfiguration, log, omit } from '../../../../utils';
+import { ignoreModulesPlugin } from '../../../../vite/plugins';
 import svgTransformer from '../../../../vitest/svg-transformer';
 
 type VitestConfig = NonNullable<ViteUserConfig['test']>;
@@ -64,9 +65,10 @@ async function getUserConfig(): Promise<ViteUserConfig> {
     /* istanbul ignore next: debug only */
     log.debug('vitest:userConfig', () => JSON.stringify(result, null, 2));
 
-    const plugins: NonNullable<ViteUserConfig['plugins']> = [svgTransformer()].filter(
-        ({ name }) => !omitDefault.includes(`plugins.${name}`)
-    );
+    const plugins: NonNullable<ViteUserConfig['plugins']> = [
+        svgTransformer(),
+        ignoreModulesPlugin({ package: { dependencies: {} } }),
+    ].filter(({ name }) => !omitDefault.includes(`plugins.${name}`));
 
     return { test: result, ...(plugins.length ? { plugins } : {}) };
 }

package/src/cli/index.ts

@@ -8,7 +8,7 @@ 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));
 
@@ -61,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/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/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

@@ -16,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';
@@ -24,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__/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();
+        });
+    });
+});

package/src/core/__tests__/sort-shared-css.test.ts

@@ -0,0 +1,39 @@
+import { sortSharedCss } from '../sort-shared-css';
+
+describe(`[startup] ${sortSharedCss.name}`, () => {
+    let cssFiles: string[];
+
+    beforeEach(() => {
+        cssFiles = ['foo.bundle.css', 'bar.bundle.css'];
+    });
+
+    const subject = () => sortSharedCss(cssFiles);
+
+    function itReturnsInput() {
+        test('returns input', () => {
+            expect(subject()).toBe(cssFiles);
+        });
+    }
+
+    itReturnsInput();
+
+    describe('when input contains design-system CSS', () => {
+        let otherCssFiles: string[];
+        const designSystemBundle = 'design-system.bundle.css';
+
+        beforeEach(() => {
+            otherCssFiles = [...cssFiles];
+            cssFiles = [...otherCssFiles, designSystemBundle];
+        });
+
+        test('moves design system to front', () => {
+            expect(subject()).toEqual([designSystemBundle, ...otherCssFiles]);
+        });
+
+        describe('when design-system CSS is already first', () => {
+            beforeEach(() => (cssFiles = [designSystemBundle, ...otherCssFiles]));
+
+            itReturnsInput();
+        });
+    });
+});

package/src/core/bundle-report.ts

@@ -0,0 +1,33 @@
+import { getBundleType } from './get-bundle-type';
+import { BuildContext } from './types';
+
+/*
+ * Base name (no extension) and title for the bundle-size report, shared by the webpack and Vite
+ * builds so both bundlers label their reports identically. The timestamp keeps successive reports
+ * for the same package distinct.
+ */
+export function bundleReportFileName(context: BuildContext): string {
+    const type = getBundleType(context);
+    const qualifier = type ? `-${type}` : '';
+    return `${context.package.name}${qualifier}-bundle-${Date.now()}`;
+}
+
+export function bundleReportTitle(context: BuildContext): string {
+    const unscopedName = context.package.name.replace(/^@[^/]+\//, '');
+    const type = getBundleType(context);
+    const qualifier = type ? ` (${type})` : '';
+    return `${unscopedName}${qualifier} ${formatDate(new Date())}`;
+}
+
+function formatDate(date: Date): string {
+    const yyyy = date.getFullYear();
+    const mm = zeroPad(date.getMonth() + 1);
+    const dd = zeroPad(date.getDate());
+    const HH = zeroPad(date.getHours());
+    const MM = zeroPad(date.getMinutes());
+    return `${yyyy}-${mm}-${dd} ${HH}:${MM}`;
+}
+
+function zeroPad(value: number) {
+    return value.toString().padStart(2, '0');
+}