@servicetitan/startup 31.0.0 → 31.2.0

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

@@ -1,9 +1,10 @@
+import { fs, vol } from 'memfs';
 import { swcDir } from '@swc/cli';
-import { getSwcCompilePackageConfiguration, log, readJson } from '../../../utils';
+import { getSwcCompilePackageConfiguration, log } from '../../../utils';
 import { SwcCompilePackage } from '../swc-compile-package';
-import { compilerOptions } from '../../../../tsconfig/base.json';
 import deepmerge from 'deepmerge';
 
+jest.mock('fs', () => fs);
 jest.mock('@swc/cli', () => ({
     swcDir: jest.fn(),
 }));
@@ -15,9 +16,7 @@ jest.mock('../../../utils', () => ({
         destination: 'dist',
     }),
     log: { info: jest.fn(), text: jest.fn() },
-    readJsonSafe: jest.fn().mockReturnValue({}),
-    readJson: jest.fn().mockReturnValue({}),
-    getSwcCompilePackageConfiguration: jest.fn().mockReturnValue({}),
+    getSwcCompilePackageConfiguration: jest.fn(),
 }));
 
 function overwriteMerge(_destinationArray: unknown[], sourceArray: unknown[]) {
@@ -25,12 +24,27 @@ function overwriteMerge(_destinationArray: unknown[], sourceArray: unknown[]) {
 }
 
 describe(`[startup] ${SwcCompilePackage.name} task`, () => {
+    function volumeFromJSON(overrides: Record<string, any> = {}) {
+        return vol.fromJSON({
+            'package.json': JSON.stringify({}),
+            'tsconfig.json': JSON.stringify({}),
+            ...Object.fromEntries(
+                Object.entries(overrides).map(([key, value]) => [key, JSON.stringify(value)])
+            ),
+        });
+    }
+
     beforeEach(() => {
         globalThis.performance.clearMarks();
         globalThis.performance.clearMeasures();
         jest.clearAllMocks();
+
+        jest.mocked(getSwcCompilePackageConfiguration).mockReturnValue({});
+        volumeFromJSON();
     });
 
+    afterEach(() => vol.reset());
+
     let watch = false;
 
     const subject = () => new SwcCompilePackage({ watch }).execute();
@@ -70,8 +84,8 @@ describe(`[startup] ${SwcCompilePackage.name} task`, () => {
                                 '**/__tests__/*',
                                 '**/*.test.*',
                                 '**/__mocks__/*',
+                                '**/*.stories.*',
                             ],
-                            copyFiles: true,
                         },
                         swcOptions: {
                             jsc: {
@@ -80,16 +94,12 @@ describe(`[startup] ${SwcCompilePackage.name} task`, () => {
                                     tsx: true,
                                     decorators: true,
                                 },
-                                target: compilerOptions.target,
                                 transform: {
-                                    legacyDecorator: compilerOptions.experimentalDecorators,
-                                    decoratorMetadata: compilerOptions.emitDecoratorMetadata,
                                     react: {
                                         runtime: 'automatic',
                                     },
                                 },
                             },
-                            sourceMaps: compilerOptions.sourceMap,
                             module: {
                                 type: 'es6',
                             },
@@ -119,10 +129,59 @@ describe(`[startup] ${SwcCompilePackage.name} task`, () => {
         itCallsSwcDir(overrides);
     });
 
+    describe('when tsconfig contains "exclude"', () => {
+        const exclude = ['**/stories.*'];
+
+        beforeEach(() => {
+            volumeFromJSON({
+                'base.json': { exclude },
+                'tsconfig.build.json': { extends: './base' },
+            });
+        });
+
+        test('uses exclude config', () => {
+            subject();
+
+            expect(swcDir).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    cliOptions: expect.objectContaining({ ignore: exclude }),
+                })
+            );
+        });
+    });
+
+    describe.each(
+        Object.entries({
+            target: 'jsc.target',
+            experimentalDecorators: 'jsc.transform.legacyDecorator',
+            emitDecoratorMetadata: 'jsc.transform.decoratorMetadata',
+            sourceMap: 'sourceMaps',
+        })
+    )('when tsconfig contains "compilerOptions.%s"', (compilerOption, swcOption) => {
+        beforeEach(() => {
+            volumeFromJSON({
+                'tsconfig.json': { compilerOptions: { [compilerOption]: 'foo' } },
+            });
+        });
+
+        test(`configures swcOptions.${swcOption}`, () => {
+            subject();
+
+            const keys = swcOption.split('.').toReversed();
+            const expected = keys.slice(1).reduce(
+                (result, key) => {
+                    return expect.objectContaining({ [key]: result });
+                },
+                expect.objectContaining({ [keys[0]]: 'foo' })
+            );
+            expect(swcDir).toHaveBeenCalledWith(expect.objectContaining({ swcOptions: expected }));
+        });
+    });
+
     describe('when package is commonjs', () => {
         beforeEach(() => {
-            jest.mocked(readJson).mockReturnValueOnce({
-                compilerOptions: { module: 'commonjs' },
+            volumeFromJSON({
+                'tsconfig.json': { compilerOptions: { module: 'commonjs' } },
             });
         });
 

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

@@ -1,19 +1,15 @@
 import { swcDir } from '@swc/cli';
 import deepmerge from 'deepmerge';
 
-import { compilerOptions as baseCompilerOptions } from '../../../tsconfig/base.json';
+import { getFolders, getSwcCompilePackageConfiguration, getTsConfig, log } from '../../utils';
+import { TSConfig } from '../utils';
 import { Task } from './task';
-import { getFolders, getSwcCompilePackageConfiguration, log, readJson } from '../../utils';
 
 interface Args {
     [key: string]: unknown;
     watch?: boolean;
 }
 
-function toLowerCase(input: string | undefined): string | undefined {
-    return input?.toLowerCase();
-}
-
 function overwriteMerge(_destinationArray: unknown[], sourceArray: unknown[]) {
     return sourceArray;
 }
@@ -25,8 +21,20 @@ export class SwcCompilePackage extends Task {
 
     async execute(): Promise<void> {
         const { source, destination } = getFolders();
-        const compilerOptions = readJson('tsconfig.json').compilerOptions ?? {};
         const packageConfig = getSwcCompilePackageConfiguration();
+        const tsConfig = new TSConfig(getTsConfig());
+        const target = tsConfig.getValue('compilerOptions.target');
+        const legacyDecorator = tsConfig.getValue('compilerOptions.experimentalDecorators');
+        const decoratorMetadata = tsConfig.getValue('compilerOptions.emitDecoratorMetadata');
+        const sourceMaps = tsConfig.getValue('compilerOptions.sourceMap');
+        const module = tsConfig.getValue<string>('compilerOptions.module')?.toLowerCase();
+        const ignore = tsConfig.getValue('exclude', [
+            '**/*.d.ts',
+            '**/__tests__/*',
+            '**/*.test.*',
+            '**/__mocks__/*',
+            '**/*.stories.*',
+        ]);
 
         return new Promise((resolve, reject) => {
             swcDir(
@@ -38,13 +46,7 @@ export class SwcCompilePackage extends Task {
                             stripLeadingPaths: true,
                             extensions: ['.ts', '.tsx'],
                             filenames: [source],
-                            ignore: [
-                                '**/*.d.ts',
-                                '**/__tests__/*',
-                                '**/*.test.*',
-                                '**/__mocks__/*',
-                            ],
-                            copyFiles: true,
+                            ignore,
                         },
                         swcOptions: {
                             jsc: {
@@ -53,20 +55,19 @@ export class SwcCompilePackage extends Task {
                                     tsx: true,
                                     decorators: true,
                                 },
-                                target: baseCompilerOptions.target,
+                                target,
                                 transform: {
-                                    legacyDecorator: baseCompilerOptions.experimentalDecorators,
-                                    decoratorMetadata: baseCompilerOptions.emitDecoratorMetadata,
+                                    legacyDecorator,
+                                    decoratorMetadata,
                                     react: {
                                         runtime: 'automatic',
                                     },
                                 },
                             },
-                            sourceMaps: baseCompilerOptions.sourceMap,
+                            sourceMaps,
                             module: {
                                 type:
-                                    toLowerCase(compilerOptions.module) === 'commonjs' ||
-                                    toLowerCase(compilerOptions.module) === 'nodenext'
+                                    module === 'commonjs' || module === 'nodenext'
                                         ? 'commonjs'
                                         : 'es6',
                             },

package/src/cli/utils/__tests__/bundle.test.ts

@@ -7,6 +7,7 @@ import {
     getConfiguration,
     getFolders,
     getPackageData,
+    hasHeadlessBundle,
     loadSharedDependencies,
 } from '../../../utils';
 import { createWebpackConfig } from '../../../webpack';
@@ -27,6 +28,7 @@ jest.mock('../../../utils', () => ({
     ...jest.requireActual('../../../utils'),
     getFolders: jest.fn(),
     getPackageData: jest.fn(),
+    hasHeadlessBundle: jest.fn(),
     loadSharedDependencies: jest.fn(),
     log: { info: jest.fn() }, // suppress test output
 }));
@@ -174,6 +176,8 @@ describe('[startup] Cli Utils', () => {
             const destination = 'dist';
             const dependencies = { foo: '1.0.1' };
             const sharedDependencies = { react: 'SharedDependencies.React' };
+            let defaultCreateOverrides: Parameters<typeof createWebpackConfig>[0];
+            let defaultCreateOptions: Parameters<typeof createWebpackConfig>[1];
 
             beforeEach(() => {
                 vol.fromJSON(webComponentFS());
@@ -184,22 +188,42 @@ describe('[startup] Cli Utils', () => {
                     dependencies,
                 });
                 jest.mocked(loadSharedDependencies).mockReturnValue(sharedDependencies);
+                defaultCreateOverrides = { configuration: { mode: 'production' } };
+                defaultCreateOptions = {
+                    buildStat: options?.buildStat,
+                    name: expectPackageName(),
+                };
             });
 
             test('builds full and "embed" packages', async () => {
-                const createOptions = { buildStat: options?.buildStat, name: expectPackageName() };
-                const overrides = { configuration: { mode: 'production' } };
-
                 await subject();
 
-                expect(createWebpackConfig).toHaveBeenCalledWith(overrides, createOptions);
-                expect(createWebpackConfig).toHaveBeenCalledWith(overrides, {
-                    ...createOptions,
+                expect(createWebpackConfig).toHaveBeenCalledWith(
+                    defaultCreateOverrides,
+                    defaultCreateOptions
+                );
+                expect(createWebpackConfig).toHaveBeenCalledWith(defaultCreateOverrides, {
+                    ...defaultCreateOptions,
                     embed: true,
                 });
                 expect(compiler.run).toHaveBeenCalledTimes(2);
             });
 
+            describe('when headless file exists', () => {
+                beforeEach(() => {
+                    jest.mocked(hasHeadlessBundle).mockReturnValue(true);
+                });
+
+                test('builds headless package', async () => {
+                    await subject();
+
+                    expect(createWebpackConfig).toHaveBeenCalledWith(defaultCreateOverrides, {
+                        ...defaultCreateOptions,
+                        headless: true,
+                    });
+                });
+            });
+
             function itUsesConfig(params: { config: () => Record<string, any>; name: string }) {
                 test(`uses ${params.name}`, async () => {
                     const { configuration, plugins } = params.config();
@@ -384,13 +408,30 @@ describe('[startup] Cli Utils', () => {
                 });
                 expect(webpack).toHaveBeenNthCalledWith(1, createWebpackResult);
                 expect(webpack).toHaveBeenNthCalledWith(2, createWebpackResult);
-                expect(compiler.watch).toHaveBeenCalled();
+                expect(compiler.watch).toHaveBeenCalledTimes(1);
                 expect(WebpackDevServer).toHaveBeenCalledWith(
                     { host: 'localhost', port: 8080 },
                     compiler
                 );
             });
 
+            describe('when headless file exists', () => {
+                beforeEach(() => {
+                    jest.mocked(hasHeadlessBundle).mockReturnValue(true);
+                });
+
+                test('runs watch on headless bundle', async () => {
+                    await subject();
+
+                    expect(createWebpackConfig).toHaveBeenCalledWith(
+                        expect.any(Object),
+                        expect.objectContaining({ headless: true })
+                    );
+                    expect(webpack).toHaveBeenNthCalledWith(3, createWebpackResult);
+                    expect(compiler.watch).toHaveBeenCalledTimes(2);
+                });
+            });
+
             describe('when webpack.devServer is set to false in package.json', () => {
                 beforeEach(() => {
                     vol.fromJSON(webComponentFS({ webpack: { devServer: false } } as any));

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

@@ -6,10 +6,10 @@ import fs from 'fs';
 import { getFolders, log } from '../../../utils';
 import * as compileSassModule from '../compile-sass';
 
-import { assetExtensions, copyFiles, styleExtensions } from '../copy-files';
+import { copyFiles, styleExtensions, supportedExtensions } from '../copy-files';
 
 jest.mock('cpx2', () => ({
-    copy: jest.fn(),
+    copySync: jest.fn(),
     watch: jest.fn(),
 }));
 jest.mock('../../../utils', () => ({
@@ -27,7 +27,7 @@ jest.mock('../../../utils', () => ({
 describe(`[startup] cli utils (${copyFiles.name})`, () => {
     const source = fs.mkdtempSync('src');
     const destination = 'dist';
-    const files = `${source}/**/*.{${[...assetExtensions, ...styleExtensions].join(',')}}`;
+    const files = `${source}/**/*.{${supportedExtensions.join()}}`;
     let options: Parameters<typeof copyFiles>[0];
 
     beforeEach(() => {
@@ -72,7 +72,7 @@ describe(`[startup] cli utils (${copyFiles.name})`, () => {
     test('copies assets and styles from source to destination', async () => {
         await subject();
 
-        expect(cpx.copy).toHaveBeenCalledWith(files, destination);
+        expect(cpx.copySync).toHaveBeenCalledWith(files, destination);
     });
 
     describe.each(styleExtensions)('with %s module', extension => {
@@ -151,7 +151,7 @@ describe(`[startup] cli utils (${copyFiles.name})`, () => {
         test('does not copy files', async () => {
             await subject();
 
-            expect(cpx.copy).not.toHaveBeenCalledWith();
+            expect(cpx.copySync).not.toHaveBeenCalledWith();
         });
     });
 });

package/src/cli/utils/bundle.ts

@@ -6,7 +6,13 @@ import { getPortPromise } from 'portfinder';
 import webpack, { Configuration } from 'webpack';
 import WebpackDevServer from 'webpack-dev-server';
 
-import { getPackageName, isDevServerDisabled, isWebComponent, log } from '../../utils';
+import {
+    getPackageName,
+    hasHeadlessBundle,
+    isDevServerDisabled,
+    isWebComponent,
+    log,
+} from '../../utils';
 import { Overrides, createWebpackConfig } from '../../webpack';
 
 interface Options {
@@ -43,10 +49,18 @@ export async function bundle(options: Options = {}) {
             plugins: config?.plugins,
         };
 
-        return Promise.all([
+        const bundles = [
             run(createWebpackConfig(webpackConfig, { embed: true, ...webpackOptions })),
             run(createWebpackConfig(webpackConfig, webpackOptions)),
-        ]);
+        ];
+
+        if (hasHeadlessBundle()) {
+            bundles.push(
+                run(createWebpackConfig(webpackConfig, { ...webpackOptions, headless: true }))
+            );
+        }
+
+        return Promise.all(bundles);
     }
 
     return run(config ?? createWebpackConfig({ configuration: { mode } }, webpackOptions));
@@ -66,12 +80,20 @@ export async function bundleWatch(options: Options = {}) {
             plugins: config?.plugins,
         };
 
-        return Promise.all([
+        const bundles = [
             runWatch(createWebpackConfig(webpackConfig, { embed: true, ...configOverrides })),
             isDevServerDisabled()
                 ? runWatch(createWebpackConfig(webpackConfig, configOverrides))
                 : runServe(createWebpackConfig(webpackConfig, configOverrides)),
-        ]);
+        ];
+
+        if (hasHeadlessBundle()) {
+            bundles.push(
+                runWatch(createWebpackConfig(webpackConfig, { ...configOverrides, headless: true }))
+            );
+        }
+
+        return Promise.all(bundles);
     }
 
     const webpackConfig =

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

@@ -7,8 +7,17 @@ import { getFolders, log } from '../../utils';
 import { compileLess } from './compile-less';
 import { compileSass } from './compile-sass';
 
-export const assetExtensions = ['eot', 'gif', 'jpg', 'otf', 'png', 'svg', 'ttf', 'woff', 'woff2'];
+const assetExtensions = ['eot', 'gif', 'jpg', 'otf', 'png', 'svg', 'ttf', 'woff', 'woff2'];
+const resourceExtensions = ['json'];
 export const styleExtensions = ['css', 'less', 'scss'];
+const styleTypeDefinitionExtensions = styleExtensions.map(ext => `${ext}.d.ts`);
+
+export const supportedExtensions = [
+    assetExtensions,
+    resourceExtensions,
+    styleExtensions,
+    styleTypeDefinitionExtensions,
+].flat();
 
 const styleModuleRegex = new RegExp(`\\.module\\.(${styleExtensions.join('|')})$`);
 
@@ -22,7 +31,7 @@ export async function copyFiles({ watch }: CopyFilesOptions) {
         return;
     }
 
-    const filesPattern = `${source}/**/*.{${[...assetExtensions, ...styleExtensions].join()}}`;
+    const filesPattern = `${source}/**/*.{${supportedExtensions.join()}}`;
     const creator = new DtsCreator({ camelCase: true, namedExports: true });
     const generateDefinitions = async (file: string) => {
         try {
@@ -35,13 +44,14 @@ export async function copyFiles({ watch }: CopyFilesOptions) {
     };
 
     if (!watch) {
-        log.info(`Copying ${filesPattern} -> ${destination}`);
-        cpx.copy(filesPattern, destination);
-
         const modulesPattern = `${source}/**/*.module.{${styleExtensions.join()}}`;
         log.info(`Generating types for ${modulesPattern}`);
         const modules = await glob(modulesPattern);
         await Promise.all(modules.map(generateDefinitions));
+
+        log.info(`Copying ${filesPattern} -> ${destination}`);
+        cpx.copySync(filesPattern, destination);
+
         return;
     }
 
@@ -49,7 +59,7 @@ export async function copyFiles({ watch }: CopyFilesOptions) {
     cpx.watch(filesPattern, destination, {
         initialCopy: false,
         // Optimization so cpx2 doesn't waste resources watching irrelevant files
-        ignore: ['__tests__', '__mocks__', '**/*.ts', '**/*.tsx'],
+        ignore: ['__tests__', '__mocks__', '*.*', ...supportedExtensions.map(ext => `!*.${ext}`)],
     })
         .on('copy', async ({ srcPath, dstPath }: { srcPath: string; dstPath: string }) => {
             log.info(`Copied ${srcPath} -> ${dstPath}`);

package/src/cli/utils/get-module-type.ts

@@ -1,21 +1,5 @@
-import path from 'path';
-
-import { readJson } from '../../utils';
+import { TSConfig } from './ts-config';
 
 export function getModuleType(configPath: string): string {
-    const config = readJson<{ compilerOptions?: { module: string }; extends?: string }>(configPath);
-
-    if (config.compilerOptions?.module) {
-        return config.compilerOptions.module.toLowerCase();
-    }
-
-    if (config.extends) {
-        return getModuleType(
-            /^\.?\.\//.test(config.extends)
-                ? path.join(path.dirname(configPath), config.extends)
-                : require.resolve(config.extends)
-        );
-    }
-
-    return 'commonjs';
+    return new TSConfig(configPath).getValue('compilerOptions.module', 'commonjs');
 }

package/src/cli/utils/index.ts

@@ -11,6 +11,6 @@ export * from './lerna-exec';
 export * from './pipe-stdout';
 export * from './process-tree';
 export * from './set-node-options';
-export * from './tcm';
+export * from './ts-config';
 export * from './type-check';
 export * from './watch-stdout';

package/src/cli/utils/ts-config.ts

@@ -0,0 +1,64 @@
+import fs from 'fs';
+import path from 'path';
+import { readJson } from '../../utils';
+
+export class TSConfig {
+    private readonly json: Map<string, any>;
+
+    constructor(private readonly configPath: string) {
+        this.json = new Map();
+    }
+
+    // Overload signatures
+    getValue<T>(key: string, defaultValue: T): NoInfer<T>;
+    getValue<T>(key: string, defaultValue?: T): T | undefined;
+
+    // Implementation signature
+    getValue<T>(key: string, defaultValue?: T) {
+        return this.getValueInternal<T>(this.configPath, key.split('.'), defaultValue);
+    }
+
+    private getValueInternal<T>(configPath: string, key: string[], defaultValue?: T): T {
+        const config = this.getJson<{ extends?: string }>(configPath);
+        const value = key.reduce<any>((result, el) => {
+            return result && typeof result === 'object' ? result[el] : undefined;
+        }, config);
+
+        if (value !== undefined) {
+            return value;
+        }
+
+        const extendsPath = this.getExtendsPath(configPath, config);
+        if (extendsPath) {
+            return this.getValueInternal(extendsPath, key, defaultValue);
+        }
+
+        return defaultValue as T;
+    }
+
+    private getExtendsPath(configPath: string, config: { extends?: string }) {
+        if (!config.extends) {
+            return;
+        }
+
+        if (!/^\.?\.\//.test(config.extends)) {
+            return require.resolve(config.extends);
+        }
+
+        const dir = path.dirname(configPath);
+        return [config.extends, `${config.extends}.json`]
+            .map(name => path.join(dir, name))
+            .find(fs.existsSync);
+    }
+
+    private getJson<T>(configPath: string): T {
+        let result: T = this.json.get(configPath);
+
+        if (!result) {
+            result = readJson<T>(configPath);
+            this.json.set(configPath, result);
+        }
+
+        return result;
+    }
+}

package/src/utils/__tests__/get-configuration.test.ts

@@ -10,6 +10,7 @@ import {
     getStylelintConfiguration,
     getWebComponentBranchConfigs,
     getWebComponentConfiguration,
+    hasHeadlessBundle,
     isBundle,
     isCustomStyleRules,
     isDevServerDisabled,
@@ -332,6 +333,25 @@ describe('[startup] Utils', () => {
         });
     });
 
+    describe(`${hasHeadlessBundle.name}`, () => {
+        const subject = () => hasHeadlessBundle();
+
+        itReturns(subject, false);
+
+        describe('when src/headless.ts exists', () => {
+            beforeEach(() =>
+                vol.fromJSON({
+                    'src/headless.ts': '',
+                    'tsconfig.json': JSON.stringify({
+                        compilerOptions: { rootDir: 'src', outDir: 'path' },
+                    }),
+                })
+            );
+
+            itReturns(subject, true);
+        });
+    });
+
     describe.each([
         {
             fn: isBundle,

package/src/utils/__tests__/log.test.ts

@@ -14,6 +14,14 @@ describe(`[startup] Utils`, () => {
             stdoutSpy = jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn());
         });
 
+        test('timestamp() returns the current time in the HH:MM:SS.SSS format', () => {
+            jest.useFakeTimers({
+                now: new Date('2024-05-14 10:40:00.050'),
+            });
+
+            expect(log.timestamp).toBe('10:40:00.050');
+        });
+
         test('text() writes default text', () => {
             log.text(message);
 

package/src/utils/get-configuration.ts

@@ -8,6 +8,7 @@ import { Configuration as WebpackDevServerConfiguration } from 'webpack-dev-serv
 
 import { ReviewConfiguration } from '../cli/commands/review';
 import { log } from './log';
+import { getFolders } from './get-folders';
 import { readJson, readJsonSafe } from './read-json';
 
 export const allowedWebpackDevServerOptions = ['headers', 'port', 'proxy', 'static'] as const;
@@ -175,6 +176,17 @@ export function getWebComponentBranchConfigs(locationOrJson: LocationOrJson = '.
     return config?.branches;
 }
 
+export function hasHeadlessBundle() {
+    let source: string;
+    try {
+        source = getFolders().source;
+    } catch {
+        return false;
+    }
+    const headlessPath = path.join(source, 'headless.ts');
+    return fs.existsSync(headlessPath);
+}
+
 export function getSwcCompilePackageConfiguration() {
     return getConfiguration()['swc-compile-package'] ?? {};
 }

package/src/utils/log.ts

@@ -10,6 +10,16 @@ class Log {
         this.debugMap = new Map<string, Debugger>();
     }
 
+    get timestamp() {
+        return new Date().toLocaleTimeString(undefined, {
+            hour12: false,
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            fractionalSecondDigits: 3,
+        });
+    }
+
     text(...text: string[]) {
         process.stdout.write(chalk(...text) + '\n');
     }