@servicetitan/startup 36.3.0 → 36.4.0

package/src/vite/config/__tests__/base-config.test.ts

@@ -0,0 +1,309 @@
+import {
+    bundleConstants,
+    defineExposedDependencies,
+    defineExposedInstanceDependencies,
+    defineWebComponentName,
+    getBundleType,
+    getOutputPath,
+} from '../../../core';
+import { omit } from '../../../utils';
+import {
+    cssInjectorPlugin,
+    devServerRoutingPlugin,
+    externalsPlugin,
+    htmlPlugin,
+    ignoreModulesPlugin,
+    metadataPlugin,
+    styleUrlsPlugin,
+    svgrPlugin,
+    virtualModulesPlugin,
+} from '../../plugins';
+import type { ViteBuildContext } from '../../types';
+import { createBaseConfig } from '../base-config';
+
+jest.mock('../../../core', () => ({
+    ...jest.requireActual('../../../core'),
+    bundleConstants: {
+        cssModules: {
+            classnameTemplate: {
+                production: '[local]__[hash:base64:5]',
+                development: '[path][name]__[local]',
+            },
+            localsConvention: 'camelCaseOnly',
+        },
+        less: { math: 'always' },
+        mode: { production: 'production', development: 'development' },
+    },
+    getBundleType: jest.fn(),
+    getOutputPath: jest.fn(),
+    defineExposedDependencies: jest.fn(),
+    defineExposedInstanceDependencies: jest.fn(),
+    defineWebComponentName: jest.fn(),
+}));
+
+jest.mock('../../../utils', () => ({
+    omit: jest.fn((obj: any) => obj),
+}));
+
+jest.mock('../../plugins', () => ({
+    htmlPlugin: jest.fn(() => ({ name: 'html' })),
+    svgrPlugin: jest.fn(() => ({ name: 'svgr' })),
+    externalsPlugin: jest.fn(() => ({ name: 'externals' })),
+    virtualModulesPlugin: jest.fn(() => ({ name: 'virtualModules' })),
+    cssInjectorPlugin: jest.fn(() => [{ name: 'cssInjector' }]),
+    styleUrlsPlugin: jest.fn(() => ({ name: 'styleUrls' })),
+    metadataPlugin: jest.fn(() => ({ name: 'metadata' })),
+    devServerRoutingPlugin: jest.fn(() => ({ name: 'devServerRouting' })),
+    ignoreModulesPlugin: jest.fn((context: any) => ({ name: 'ignoreModules', context })),
+}));
+
+describe(createBaseConfig.name, () => {
+    let context: ViteBuildContext;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.mocked(getBundleType).mockReturnValue('full');
+        jest.mocked(getOutputPath).mockReturnValue('/output/dist');
+        jest.mocked(defineExposedDependencies).mockReturnValue({
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            EXPOSED_DEPENDENCIES: '"deps"',
+        });
+        jest.mocked(defineExposedInstanceDependencies).mockReturnValue({
+            // eslint-disable-next-line @typescript-eslint/naming-convention
+            EXPOSED_INSTANCE_DEPENDENCIES: '"instance"',
+        });
+        jest.mocked(defineWebComponentName).mockReturnValue(undefined);
+        context = {
+            build: { isProduction: false },
+            options: {},
+            package: { isWebComponent: false, destination: 'dist/bundle/full' },
+            bundlerConfig: {
+                omitDefault: [],
+                minify: {},
+                pluginOverrides: {},
+            },
+        } as unknown as ViteBuildContext;
+    });
+
+    const subject = () => createBaseConfig(context);
+
+    test('sets cache directory from bundle type', () => {
+        expect(subject().cacheDir).toBe(`node_modules/.vite/${getBundleType(context)}`);
+    });
+
+    test('sets dev server port to 8080', () => {
+        expect(subject().server!.port).toBe(8080);
+    });
+
+    test('pre-warms client files from destination', () => {
+        expect(subject().server!.warmup!.clientFiles).toEqual([
+            `${context.package.destination}/**/*.js`,
+        ]);
+    });
+
+    test('sets development mode', () => {
+        expect(subject().mode).toBe(bundleConstants.mode.development);
+    });
+
+    test('disables config file', () => {
+        expect(subject().configFile).toBe(false);
+    });
+
+    test('strips legal comments', () => {
+        expect(subject().oxc).toEqual({ legalComments: 'none' });
+    });
+
+    test('sets relative base path', () => {
+        expect(subject().base).toBe('./');
+    });
+
+    test('configures CSS modules locale convention', () => {
+        expect((subject().css!.modules as Record<string, unknown>).localsConvention).toBe(
+            bundleConstants.cssModules.localsConvention
+        );
+    });
+
+    test('uses development CSS class name template', () => {
+        expect((subject().css!.modules as Record<string, unknown>).generateScopedName).toBe(
+            bundleConstants.cssModules.classnameTemplate.development
+        );
+    });
+
+    test('configures LESS preprocessor', () => {
+        expect(subject().css!.preprocessorOptions!.less).toEqual({
+            math: bundleConstants.less.math,
+        });
+    });
+
+    test('enables CSS code splitting', () => {
+        expect(subject().build!.cssCodeSplit).toBe(true);
+    });
+
+    test('does not empty output directory', () => {
+        expect(subject().build!.emptyOutDir).toBe(false);
+    });
+
+    test('sets output directory from context', () => {
+        expect(subject().build!.outDir).toBe(getOutputPath(context));
+    });
+
+    test('enables source maps', () => {
+        expect(subject().build!.sourcemap).toBe(true);
+    });
+
+    test('maps define values to import.meta.env prefix', () => {
+        const { define } = subject();
+        const exposed = defineExposedDependencies(context)!;
+        const instance = defineExposedInstanceDependencies(context)!;
+
+        for (const [key, value] of Object.entries({ ...exposed, ...instance })) {
+            expect(define![`import.meta.env.${key}`]).toBe(value);
+        }
+    });
+
+    test('includes startup-utils in optimized dependencies', () => {
+        expect(subject().optimizeDeps!.include).toEqual(['@servicetitan/startup-utils']);
+    });
+
+    test('registers ignoreModulesPlugin for dependency pre-bundling', () => {
+        expect(subject().optimizeDeps!.rolldownOptions).toEqual({
+            plugins: [ignoreModulesPlugin(context)],
+        });
+    });
+
+    test('creates plugins from factories, passing context', () => {
+        const factories = [
+            htmlPlugin,
+            svgrPlugin,
+            externalsPlugin,
+            virtualModulesPlugin,
+            cssInjectorPlugin,
+            styleUrlsPlugin,
+            metadataPlugin,
+            devServerRoutingPlugin,
+            ignoreModulesPlugin,
+        ];
+
+        const pluginNames = (subject().plugins as any[]).map((p: any) => p.name);
+        const expectedNames = factories.flatMap(factory => {
+            const result = jest.mocked(factory).mock.results[0].value;
+            return [result].flat().map((p: any) => p.name);
+        });
+
+        expect(pluginNames).toEqual(expectedNames);
+        for (const factory of factories) {
+            expect(factory).toHaveBeenCalledWith(context);
+        }
+    });
+
+    test('excludes plugin in omitDefault', () => {
+        const pluginName = 'externals';
+        const getPluginNames = () => (subject().plugins as any[]).map((p: any) => p.name);
+
+        // Verify plugin exists before testing omission
+        expect(getPluginNames()).toContain(pluginName);
+
+        context.bundlerConfig.omitDefault.push(`plugins.${pluginName}`);
+
+        expect(getPluginNames()).not.toContain(pluginName);
+    });
+
+    describe('when web component', () => {
+        beforeEach(() => (context.package.isWebComponent = true));
+
+        test('sets dev server port to 8888', () => {
+            expect(subject().server!.port).toBe(8888);
+        });
+
+        test('disables CSS code splitting', () => {
+            expect(subject().build!.cssCodeSplit).toBe(false);
+        });
+
+        test('empties output directory', () => {
+            expect(subject().build!.emptyOutDir).toBe(true);
+        });
+    });
+
+    describe('when production', () => {
+        beforeEach(() => (context.build.isProduction = true));
+
+        test('sets production mode', () => {
+            expect(subject().mode).toBe(bundleConstants.mode.production);
+        });
+
+        test('uses production CSS class name template', () => {
+            expect((subject().css!.modules as Record<string, unknown>).generateScopedName).toBe(
+                bundleConstants.cssModules.classnameTemplate.production
+            );
+        });
+
+        describe('with process.env.CLIENT_CDN_PATH', () => {
+            const cdnPath = 'http://www.example.com/cdn';
+
+            beforeEach(() => (process.env.CLIENT_CDN_PATH = cdnPath));
+            afterEach(() => delete process.env.CLIENT_CDN_PATH);
+
+            test('sets base path to CDN path', () => {
+                expect(subject().base).toEqual(cdnPath);
+            });
+        });
+    });
+
+    describe('when port is configured', () => {
+        const customPort = 9000;
+
+        beforeEach(() => (context.bundlerConfig.port = customPort));
+
+        test('uses configured port', () => {
+            expect(subject().server!.port).toBe(customPort);
+        });
+    });
+
+    describe('when bundle type is undefined', () => {
+        beforeEach(() => jest.mocked(getBundleType).mockReturnValue(undefined));
+
+        test('falls back to host cache directory', () => {
+            expect(subject().cacheDir).toBe('node_modules/.vite/host');
+        });
+    });
+
+    describe('when plugin returns undefined', () => {
+        beforeEach(() => {
+            jest.mocked(externalsPlugin).mockReturnValue(undefined as any);
+        });
+
+        test('excludes undefined plugin', () => {
+            const pluginNames = (subject().plugins as any[]).map((p: any) => p.name);
+
+            expect(pluginNames).not.toContain('externals');
+        });
+    });
+
+    describe('when config key is in omitDefault', () => {
+        const configKey = 'server';
+
+        beforeEach(() => context.bundlerConfig.omitDefault.push('plugins.externals', configKey));
+
+        test('omits config key from output, excluding plugin keys', () => {
+            subject();
+
+            expect(omit).toHaveBeenCalledWith(expect.any(Object), [configKey]);
+        });
+    });
+
+    describe('when JS minify is configured', () => {
+        beforeEach(() => (context.bundlerConfig.minify.js = false));
+
+        test('sets build minify option', () => {
+            expect(subject().build!.minify).toBe(!!context.bundlerConfig.minify.js);
+        });
+    });
+
+    describe('when CSS minify is configured', () => {
+        beforeEach(() => (context.bundlerConfig.minify.css = false));
+
+        test('sets build cssMinify option', () => {
+            expect(subject().build!.cssMinify).toBe(!!context.bundlerConfig.minify.css);
+        });
+    });
+});

package/src/vite/config/__tests__/create-vite-build-context.test.ts

@@ -0,0 +1,86 @@
+import type { BuildContext } from '../../../core';
+import type { VitePackageJsonOverride } from '../../../utils/get-configuration';
+import { createViteBuildContext } from '../create-vite-build-context';
+import type { ViteConfigFileOverride } from '../define-config';
+
+describe(createViteBuildContext.name, () => {
+    const context = { build: { name: 'test' } } as BuildContext;
+
+    let pkgJsonConfig: VitePackageJsonOverride;
+    let fileConfig: ViteConfigFileOverride;
+
+    beforeEach(() => {
+        pkgJsonConfig = {};
+        fileConfig = {};
+    });
+
+    const subject = () => createViteBuildContext(context, pkgJsonConfig, fileConfig);
+
+    test('includes context properties', () => {
+        expect(subject()).toEqual(expect.objectContaining(context));
+    });
+
+    test('defaults bundlerConfig to empty values', () => {
+        expect(subject().bundlerConfig).toEqual({
+            port: undefined,
+            omitDefault: [],
+            pluginOverrides: { html: {}, svgr: {} },
+            minify: {},
+        });
+    });
+
+    describe('when port is provided', () => {
+        beforeEach(() => {
+            pkgJsonConfig = { port: 3000 };
+            fileConfig = { port: 9000 };
+        });
+
+        test('file config takes precedence', () => {
+            expect(subject().bundlerConfig.port).toBe(fileConfig.port);
+        });
+    });
+
+    describe('when omitDefault is provided', () => {
+        beforeEach(() => {
+            pkgJsonConfig = { omitDefault: ['plugin-a'] };
+            fileConfig = { omitDefault: ['plugin-b'] };
+        });
+
+        test('concatenates entries from both sources', () => {
+            expect(subject().bundlerConfig.omitDefault).toEqual(['plugin-a', 'plugin-b']);
+        });
+    });
+
+    describe('when pluginOverrides is provided', () => {
+        const pkgHtml = { title: 'pkg', favicon: 'pkg.ico' };
+        const fileHtml = { title: 'file' };
+        const pkgSvgr = { include: ['**/*.svg'], exclude: ['**/ignore/**'] };
+        const fileSvgr = { include: ['**/*.icon.svg'] };
+
+        beforeEach(() => {
+            pkgJsonConfig = { pluginOverrides: { html: pkgHtml, svgr: pkgSvgr } };
+            fileConfig = { pluginOverrides: { html: fileHtml, svgr: fileSvgr } };
+        });
+
+        test('merges with file config taking precedence', () => {
+            const { pluginOverrides } = subject().bundlerConfig;
+
+            expect(pluginOverrides.html).toEqual({ ...pkgHtml, ...fileHtml });
+            expect(pluginOverrides.svgr).toEqual({ ...pkgSvgr, ...fileSvgr });
+        });
+    });
+
+    describe('when minify is provided', () => {
+        beforeEach(() => {
+            pkgJsonConfig = { minify: { css: true, js: false } };
+            fileConfig = { minify: { js: true } };
+        });
+
+        test('merges with file config taking precedence', () => {
+            expect(subject().bundlerConfig.minify).toEqual({
+                ...pkgJsonConfig.minify,
+                ...fileConfig.minify,
+            });
+        });
+    });
+});

package/src/vite/config/__tests__/create-vite-config.test.ts

@@ -0,0 +1,141 @@
+import { createBuildContext } from '../../../core';
+import { getViteConfiguration } from '../../../utils';
+import { createBaseConfig } from '../base-config';
+import { createViteBuildContext } from '../create-vite-build-context';
+import { createViteConfig } from '../create-vite-config';
+import { loadConfigFile } from '../load-config-file';
+import { mergeViteConfigs } from '../merge-vite-configs';
+
+jest.mock('../../../core', () => ({
+    createBuildContext: jest.fn(),
+    stringifyConfig: jest.fn(),
+}));
+jest.mock('../../../utils', () => ({
+    getViteConfiguration: jest.fn(),
+    log: { debug: jest.fn() },
+}));
+jest.mock('../base-config', () => ({
+    createBaseConfig: jest.fn(),
+}));
+jest.mock('../create-vite-build-context', () => ({
+    createViteBuildContext: jest.fn(),
+}));
+jest.mock('../load-config-file', () => ({
+    loadConfigFile: jest.fn(),
+}));
+jest.mock('../merge-vite-configs', () => ({
+    mergeViteConfigs: jest.fn(),
+}));
+
+describe(createViteConfig.name, () => {
+    const options = { name: 'test', isProduction: false };
+    const mockPkgConfig: any = { omitDefault: ['from-pkg'] };
+    const mockFileConfig: any = { omitDefault: ['from-file'] };
+    const mockViteContext: any = { bundlerConfig: {} };
+    const mockBaseConfig: any = { root: '/' };
+    const mockFinalConfig: any = { server: { port: 3000 } };
+
+    let mockContext: any;
+
+    beforeEach(() => {
+        mockContext = { build: {} };
+        jest.mocked(createBuildContext).mockReturnValue(mockContext);
+        jest.mocked(getViteConfiguration).mockReturnValue(mockPkgConfig);
+        jest.mocked(loadConfigFile).mockResolvedValue(mockFileConfig);
+        jest.mocked(createViteBuildContext).mockReturnValue(mockViteContext);
+        jest.mocked(createBaseConfig).mockReturnValue(mockBaseConfig);
+        jest.mocked(mergeViteConfigs).mockReturnValue({ ...mockFinalConfig });
+    });
+
+    const subject = () => createViteConfig(options);
+
+    const itSetsPortToZero = () => {
+        test('sets port to 0', async () => {
+            expect((await subject()).server?.port).toBe(0);
+        });
+    };
+
+    test('builds context from options', async () => {
+        await subject();
+
+        expect(createBuildContext).toHaveBeenCalledWith(options);
+    });
+
+    test('loads config file with context', async () => {
+        await subject();
+
+        expect(loadConfigFile).toHaveBeenCalledWith('./', mockContext);
+    });
+
+    test('creates vite context from all config sources', async () => {
+        await subject();
+
+        expect(createViteBuildContext).toHaveBeenCalledWith(
+            mockContext,
+            mockPkgConfig,
+            mockFileConfig
+        );
+    });
+
+    test('creates base config from vite context', async () => {
+        await subject();
+
+        expect(createBaseConfig).toHaveBeenCalledWith(mockViteContext);
+    });
+
+    test('merges base, package.json, and file configs', async () => {
+        await subject();
+
+        expect(mergeViteConfigs).toHaveBeenCalledWith(
+            mockBaseConfig,
+            mockPkgConfig,
+            mockFileConfig
+        );
+    });
+
+    test('returns merged config', async () => {
+        expect(await subject()).toEqual(expect.objectContaining(mockFinalConfig));
+    });
+
+    describe('when build is light', () => {
+        beforeEach(() => (mockContext.build.light = true));
+
+        itSetsPortToZero();
+    });
+
+    describe('when build is headless', () => {
+        beforeEach(() => (mockContext.build.headless = true));
+
+        itSetsPortToZero();
+    });
+
+    describe('when PORT env is set', () => {
+        beforeEach(() => {
+            process.env.PORT = '8080';
+            jest.mocked(mergeViteConfigs).mockReturnValue({});
+        });
+
+        afterEach(() => {
+            delete process.env.PORT;
+        });
+
+        test('uses PORT env value', async () => {
+            expect((await subject()).server?.port).toBe(8080);
+        });
+    });
+
+    describe('when build emits exposed dependencies', () => {
+        beforeEach(() => {
+            process.env.PORT = '9999';
+            mockContext.build.emitExposedDependencies = true;
+        });
+
+        afterEach(() => {
+            delete process.env.PORT;
+        });
+
+        test('does not override port', async () => {
+            expect((await subject()).server?.port).toBe(mockFinalConfig.server.port);
+        });
+    });
+});

package/src/vite/config/__tests__/define-config.test.ts

@@ -0,0 +1,23 @@
+import { defineConfig } from '../define-config';
+
+describe('[startup] defineConfig', () => {
+    let config: Parameters<typeof defineConfig>[0];
+
+    const subject = () => defineConfig(config);
+
+    describe('with an object config', () => {
+        beforeEach(() => (config = { config: { build: { minify: false } } }));
+
+        test('returns the config as-is', () => {
+            expect(subject()).toBe(config);
+        });
+    });
+
+    describe('with a function config', () => {
+        beforeEach(() => (config = () => ({ config: { build: { minify: false } } })));
+
+        test('returns the function as-is', () => {
+            expect(subject()).toBe(config);
+        });
+    });
+});