@servicetitan/startup 36.4.0 → 37.0.0

package/src/cli/commands/build.ts

@@ -1,5 +1,5 @@
 import { getPackages, logErrors, PackageType } from '../../utils';
-import { checkArgs, compile, lernaExec, ProcessTree, typeCheck } from '../utils';
+import { checkArgs, compile, getBundleCommand, lernaExec, ProcessTree, typeCheck } from '../utils';
 import { kendoUILicense } from './kendo-ui-license';
 import type { entry } from './registry/build';
 import { Command } from './types';
@@ -20,8 +20,6 @@ export class Build 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,
@@ -40,6 +38,7 @@ export class Build 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);
@@ -78,7 +77,7 @@ export class Build extends Command<typeof entry> {
                     return Promise.resolve();
                 }
                 return lernaExec({
-                    cmd,
+                    'cmd': bundleCmd,
                     'scope': bundleScope,
                     'parallel': true,
                     'stream': true,
@@ -101,14 +100,14 @@ export class Build extends Command<typeof entry> {
                 }
 
                 return lernaExec({
-                    cmd,
+                    'cmd': bundleCmd,
                     'scope': bundleScope,
                     'stream': true,
                     '--': [
                         ...[this.args.config ? `--config "${this.args.config}"` : undefined],
                         ...[this.args.codeCoverage ? '--code-coverage' : undefined],
                         ...[this.args.stat ? '--stat' : undefined],
-                        ...[useVite && this.args.preview ? '--preview' : undefined],
+                        ...[this.args.preview ? '--preview' : undefined],
                     ].filter(item => !!item) as string[],
                 });
             },

package/src/cli/commands/bundle-vite.ts

@@ -3,6 +3,7 @@ import { BuildContextOptions, getBuildName, stringifyConfig } from '../../core';
 import {
     hasHeadlessBundle,
     isExposeSharedDependencies,
+    isViteDevServerDisabled,
     isWebComponent,
     log,
     logErrors,
@@ -24,6 +25,7 @@ export class BundleVite extends Command<typeof entry> {
         const options: BuildContextOptions = {
             name: getBuildName(),
             isProduction,
+            buildStat: this.args.stat,
         };
 
         if (this.args.printConfig) {
@@ -61,6 +63,17 @@ async function buildAndServe(
 ): Promise<void> {
     const config = await createViteConfig(options);
     if (watch) {
+        if (isViteDevServerDisabled()) {
+            /*
+             * Create a development build with no HTTP server, using Vite's watcher to rebuild
+             * on change. `vite build` forces NODE_ENV to production regardless of `mode`, because
+             * Vite treats the two as independent. Set NODE_ENV directly to get a development
+             * build; `mode` alone does not change it.
+             */
+            process.env.NODE_ENV = 'development';
+            await build({ ...config, build: { ...config.build, watch: {} } });
+            return;
+        }
         await serve(config);
         return;
     }

package/src/cli/commands/registry/build.ts

@@ -5,6 +5,11 @@ export const entry = defineEntry({
     description: 'Build project for production',
     greedy: true,
     options: {
+        bundler: {
+            choices: ['vite', 'webpack'] as const,
+            description: 'Bundler',
+            defaultDescription: 'webpack',
+        },
         cdnPath: { string: true, description: 'Base url for application assets' },
         codeCoverage: { boolean: true, description: 'Instrument code for coverage analysis?' },
         config: { string: true, hidden: true, description: 'Use specified configuration' },
@@ -13,6 +18,6 @@ export const entry = defineEntry({
         scope: { array: true, string: true, description: 'Packages to build' },
         stat: { boolean: true, description: 'Generate bundle report?' },
         useTsc: { boolean: true, description: 'Use tsc to compile packages?' },
-        useVite: { boolean: true, description: 'Use Vite to bundle packages?' },
+        useVite: { boolean: true, hidden: true, description: 'Deprecated: use --bundler=vite' },
     },
 } satisfies CommandEntry);

package/src/cli/commands/registry/command-registry.ts

@@ -64,7 +64,6 @@ function makeEntry<K extends CommandName, T extends CommandEntry>(
  */
 export const commandRegistry = {
     ...makeEntry(CommandName.build, build),
-    ...makeEntry(CommandName['bundle-package'], bundleWebpack, { path: 'bundle-webpack' }),
     ...makeEntry(CommandName['bundle-vite'], bundleVite),
     ...makeEntry(CommandName['bundle-webpack'], bundleWebpack),
     ...makeEntry(CommandName.clean, clean),

package/src/cli/commands/registry/start.ts

@@ -5,11 +5,16 @@ export const entry = defineEntry({
     description: 'Run project in development mode',
     greedy: true,
     options: {
+        bundler: {
+            choices: ['vite', 'webpack'] as const,
+            description: 'Bundler',
+            defaultDescription: 'webpack',
+        },
         codeCoverage: { boolean: true, description: 'Instrument code for coverage analysis?' },
         config: { string: true, hidden: true, description: 'Use specified configuration' },
         ignore: { array: true, string: true, description: 'Packages to skip' },
         scope: { array: true, string: true, description: 'Packages to run and watch' },
         useTsc: { boolean: true, description: 'Use tsc to compile packages?' },
-        useVite: { boolean: true, description: 'Use Vite to bundle packages?' },
+        useVite: { boolean: true, hidden: true, description: 'Deprecated: use --bundler=vite' },
     },
 } satisfies CommandEntry);

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

@@ -0,0 +1,127 @@
+import chalk from 'chalk';
+import { execSync } from 'node:child_process';
+import { expectCalls, MockPackageManager } from '../../__mocks__';
+import { FixCategory, PackageError } from '../../types';
+import { mockProject } from '../__mocks__';
+import { RequireCompatibleTypescript } from '../require-compatible-typescript';
+
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
+
+const STARTUP = '@servicetitan/startup';
+const TYPESCRIPT = 'typescript';
+const REQUIRED_VERSION = '6.0.3';
+const OLDER_VERSION = '5.9.3';
+
+describe(`[startup] Review ${RequireCompatibleTypescript.name}`, () => {
+    const id = 'require-compatible-typescript';
+    const rule = new RequireCompatibleTypescript();
+    const mockPackageManager = new MockPackageManager();
+
+    let requiredVersion: string | undefined;
+    let actualVersion: string | undefined;
+
+    beforeAll(() => {
+        jest.spyOn(mockPackageManager, 'getDeclaredVersion').mockImplementation(
+            ({ declaredBy, dependency }) =>
+                declaredBy === STARTUP && dependency === TYPESCRIPT ? requiredVersion : undefined
+        );
+        jest.spyOn(mockPackageManager, 'getResolvedVersion').mockImplementation(({ dependency }) =>
+            dependency === TYPESCRIPT ? actualVersion : undefined
+        );
+    });
+
+    beforeEach(() => {
+        requiredVersion = REQUIRED_VERSION;
+        actualVersion = undefined;
+        mockPackageManager.command = 'npm';
+        jest.clearAllMocks();
+    });
+
+    const project = () => mockProject({ packageManager: mockPackageManager as any });
+
+    const subject = () => rule.run(project());
+
+    const fixSubject = () => rule.fix!(subject()!);
+
+    function itReturnsNothing() {
+        test('returns nothing', () => {
+            expect(subject()).toBeUndefined();
+        });
+    }
+
+    function itReturnsError() {
+        test('returns error', () => {
+            expect(subject()).toEqual({
+                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: mockPackageManager.lockFileName,
+                data: { actualVersion, requiredVersion },
+            } satisfies PackageError);
+        });
+    }
+
+    itReturnsNothing();
+
+    describe('when startup is not a dependency', () => {
+        beforeEach(() => {
+            requiredVersion = undefined;
+            actualVersion = REQUIRED_VERSION;
+        });
+
+        itReturnsNothing();
+    });
+
+    describe('when top-level typescript is older than startup requires', () => {
+        beforeEach(() => (actualVersion = OLDER_VERSION));
+
+        itReturnsError();
+
+        test('fixes error', () => {
+            fixSubject();
+
+            expectCalls(
+                ...[
+                    `npm pkg set dependencies["${TYPESCRIPT}"]="${REQUIRED_VERSION}"`,
+                    'npx @servicetitan/install --fix --quiet',
+                    `npm pkg delete dependencies["${TYPESCRIPT}"]`,
+                ].map(command => [execSync, command, { stdio: 'inherit' }])
+            );
+        });
+
+        describe('when package manager is pnpm', () => {
+            beforeEach(() => (mockPackageManager.command = 'pnpm'));
+
+            itReturnsNothing();
+        });
+    });
+
+    describe('when top-level typescript equals the version startup requires', () => {
+        beforeEach(() => (actualVersion = REQUIRED_VERSION));
+
+        itReturnsNothing();
+    });
+
+    describe('when top-level typescript is newer than startup requires', () => {
+        beforeEach(() => (actualVersion = '6.1.0'));
+
+        itReturnsNothing();
+    });
+
+    describe('when startup declares typescript as a range', () => {
+        beforeEach(() => (requiredVersion = '^6.0.0'));
+
+        describe('when top-level typescript is below the range floor', () => {
+            beforeEach(() => (actualVersion = OLDER_VERSION));
+
+            itReturnsError();
+        });
+
+        describe('when top-level typescript is at the range floor', () => {
+            beforeEach(() => (actualVersion = '6.0.0'));
+
+            itReturnsNothing();
+        });
+    });
+});

package/src/cli/commands/review/rules/index.ts

@@ -6,6 +6,7 @@ import { NoTypescriptEntryPoint } from './no-typescript-entry-point';
 import { PreferOpenEndedPeerDependencies } from './prefer-open-ended-peer-dependencies';
 import { RequireAllReactDependencies } from './require-all-react-dependencies';
 import { RequireCompatibleLaunchDarklySdk } from './require-compatible-launch-darkly-sdk';
+import { RequireCompatibleTypescript } from './require-compatible-typescript';
 import { RequireExplicitSideEffects } from './require-explicit-side-effects';
 import { RequireNpmrc } from './require-npmrc';
 import { RequireOneAnvilUikitContribVersion } from './require-one-anvil-uikit-contrib-version';
@@ -24,6 +25,7 @@ export const rules: PackageRule[] = [
     new RequireOneUikitVersion(),
     new RequireProjectVersionInRootNodeModules(),
     new RequireCompatibleLaunchDarklySdk(),
+    new RequireCompatibleTypescript(),
     new NoDeprecatedContentBase(),
     new NoDirectPeerDependencies(),
     new NoDeprecatedStartupInstall(),

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/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}`
+                );
+            });
+        });
+    });
+});