npm - @servicetitan/startup - Versions diffs - 36.4.0 → 37.0.1 - Mend

@servicetitan/startup 36.4.0 → 37.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (457) hide show

package/src/vite/config/get-warmup-client-files.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import path from 'path';
+import { ViteBuildContext } from '../types';
+/*
+ * Returns the glob patterns the dev server warms at startup: the package's compiled
+ * output, minus the production bundle. Warming the bundle makes Vite read sourcemaps
+ * that reference sources it cannot resolve, logging "missing source files" warnings.
+ */
+export function getWarmupClientFiles(context: ViteBuildContext, outputRoot: string): string[] {
+    const { destination } = context.package;
+    const bundleDir = path.relative(process.cwd(), outputRoot);
+    return [`${destination}/**/*.js`, `!${bundleDir.replace(/\\/g, '/')}/**`];
+}

package/src/vite/index.html CHANGED Viewed

@@ -2,6 +2,7 @@
 <html lang="en">
     <head>
         <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width,initial-scale=1" />
         <title><%= it.title %></title>
         <% if (it.favicon) { %>
         <link rel="icon" href="<%= it.favicon %>" />

package/src/vite/plugins/__tests__/bundle-stat-plugin.test.ts ADDED Viewed

@@ -0,0 +1,70 @@
+import os from 'os';
+import path from 'path';
+import { analyzer, unstableRolldownAdapter } from 'vite-bundle-analyzer';
+import { bundleReportFileName, bundleReportTitle } from '../../../core';
+import { ViteBuildContext } from '../../types';
+import { bundleStatPlugin } from '../bundle-stat-plugin';
+jest.mock('vite-bundle-analyzer', () => ({
+    analyzer: jest.fn(() => ({ name: 'analyzer-plugin' })),
+    unstableRolldownAdapter: jest.fn(() => ({ name: 'bundle-stat' })),
+}));
+jest.mock('../../../core', () => ({
+    bundleReportFileName: jest.fn(() => 'report-name'),
+    bundleReportTitle: jest.fn(() => 'Report Title'),
+}));
+describe(bundleStatPlugin.name, () => {
+    let context: ViteBuildContext;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        context = { options: {} } as ViteBuildContext;
+    });
+    const subject = () => bundleStatPlugin(context);
+    test('returns undefined', () => {
+        expect(subject()).toBeUndefined();
+    });
+    describe('when buildStat is true', () => {
+        beforeEach(() => (context.options.buildStat = true));
+        test('returns a plugin with correct name', () => {
+            expect(subject()).toEqual({ name: 'bundle-stat' });
+        });
+        test('configures the analyzer for a static report', () => {
+            subject();
+            expect(analyzer).toHaveBeenCalledWith(
+                expect.objectContaining({ analyzerMode: 'static', openAnalyzer: true })
+            );
+        });
+        test('configures report title', () => {
+            subject();
+            expect(analyzer).toHaveBeenCalledWith(
+                expect.objectContaining({ reportTitle: bundleReportTitle(context) })
+            );
+        });
+        test('configures report location', () => {
+            subject();
+            const { fileName } = jest.mocked(analyzer).mock.calls[0][0] as {
+                fileName: () => string;
+            };
+            expect(fileName()).toBe(path.join(os.tmpdir(), bundleReportFileName(context)));
+        });
+        test('feeds the analyzer plugin through the rolldown adapter', () => {
+            subject();
+            expect(unstableRolldownAdapter).toHaveBeenCalledWith({ name: 'analyzer-plugin' });
+        });
+    });
+});

package/src/vite/plugins/__tests__/chain-source-maps-plugin.test.ts ADDED Viewed

@@ -0,0 +1,58 @@
+import { fs, vol } from 'memfs';
+import path from 'path';
+import { chainSourceMapsPlugin } from '../chain-source-maps-plugin';
+jest.mock('fs', () => fs);
+describe(chainSourceMapsPlugin.name, () => {
+    const code = 'compiled code';
+    const map = { version: 3, sources: ['../src/foo.ts'], sourcesContent: ['source'] };
+    let id: string;
+    beforeEach(() => {
+        id = '/abs/pkg/dist/foo.js';
+        vol.fromJSON({ [id]: code, [`${id}.map`]: JSON.stringify(map) });
+    });
+    afterEach(() => vol.reset());
+    const subject = () => {
+        const plugin = chainSourceMapsPlugin();
+        return (plugin.load as Function).call(plugin, id);
+    };
+    test('has correct name', () => {
+        expect(chainSourceMapsPlugin().name).toBe('chain-source-maps');
+    });
+    test('returns code with *.js.map sources as absolute paths', () => {
+        expect(subject()).toEqual({
+            code,
+            map: {
+                ...map,
+                sources: map.sources.map(source =>
+                    path.resolve(path.dirname(id), source).replace(/\\/g, '/')
+                ),
+            },
+        });
+    });
+    function itReturnsUndefined() {
+        test('returns undefined', () => {
+            expect(subject()).toBeUndefined();
+        });
+    }
+    describe('when id is not a .js file', () => {
+        beforeEach(() => (id = '/abs/pkg/src/foo.ts'));
+        itReturnsUndefined();
+    });
+    describe('when no sibling .map exists', () => {
+        beforeEach(() => vol.reset());
+        itReturnsUndefined();
+    });
+});

package/src/vite/plugins/__tests__/clean-plugin.test.ts ADDED Viewed

@@ -0,0 +1,121 @@
+import { fs, vol } from 'memfs';
+import path from 'path';
+import type { BuildContext } from '../../../core';
+import { cleanPlugin } from '../clean-plugin';
+jest.mock('fs', () => fs);
+describe('[startup] cleanPlugin', () => {
+    let context: BuildContext;
+    beforeEach(() => {
+        vol.fromJSON({});
+        context = {
+            package: { isWebComponent: false, isExposeSharedDependencies: true },
+            build: { emitExposedDependencies: false },
+        } as BuildContext;
+    });
+    afterEach(() => vol.reset());
+    const plugin = () => cleanPlugin(context);
+    test('returns a plugin named clean', () => {
+        expect(plugin().name).toBe('clean');
+    });
+    test('applies only to build', () => {
+        expect(plugin().apply).toBe('build');
+    });
+    describe('config', () => {
+        const subject = () => (plugin().config as Function)();
+        test('sets build.emptyOutDir to false', () => {
+            expect(subject().build.emptyOutDir).toBe(false);
+        });
+        describe('when package is a web component', () => {
+            beforeEach(() => (context.package.isWebComponent = true));
+            test('sets build.emptyOutDir to true', () => {
+                expect(subject().build.emptyOutDir).toBe(true);
+            });
+        });
+    });
+    describe('buildStart', () => {
+        const outDir = '/dist/bundle';
+        const outputFiles = { [`${outDir}/foo.js`]: '', [`${outDir}/bar.css`]: '' };
+        beforeEach(() => vol.fromJSON(outputFiles));
+        const subject = () => {
+            const instance = plugin();
+            (instance.configResolved as Function).call(instance, { build: { outDir } });
+            (instance.buildStart as Function).call(instance);
+        };
+        function itRemovesAllOutputFiles() {
+            test('removes all output files', () => {
+                subject();
+                expect(fs.readdirSync(outDir)).toHaveLength(0);
+            });
+        }
+        itRemovesAllOutputFiles();
+        describe('when package is a web component', () => {
+            beforeEach(() => (context.package.isWebComponent = true));
+            test('removes nothing', () => {
+                subject();
+                expect(fs.readdirSync(outDir)).toHaveLength(Object.keys(outputFiles).length);
+            });
+        });
+        describe('when the output directory does not exist', () => {
+            beforeEach(() => vol.reset());
+            test('does not throw', () => {
+                expect(subject).not.toThrow();
+            });
+        });
+        describe('with shared dependencies', () => {
+            const sharedDependency = `${outDir}/shared/react.js`;
+            beforeEach(() => vol.fromJSON({ ...outputFiles, [sharedDependency]: '' }));
+            function getAllFilesSync(dirPath: string) {
+                const entries = fs.readdirSync(dirPath, {
+                    recursive: true,
+                    withFileTypes: true,
+                }) as unknown as { parentPath: string; name: string; isFile(): boolean }[];
+                return entries
+                    .filter(entry => entry.isFile())
+                    .map(entry => path.join(entry.parentPath, entry.name));
+            }
+            test('keeps only shared dependencies', () => {
+                subject();
+                expect(getAllFilesSync(outDir)).toEqual([path.normalize(sharedDependency)]);
+            });
+            describe('when emitting exposed dependencies', () => {
+                beforeEach(() => (context.build.emitExposedDependencies = true));
+                itRemovesAllOutputFiles();
+            });
+            describe('when not exposing shared dependencies', () => {
+                beforeEach(() => (context.package.isExposeSharedDependencies = false));
+                itRemovesAllOutputFiles();
+            });
+        });
+    });
+});

package/src/vite/plugins/__tests__/design-system-guard-plugin.test.ts ADDED Viewed

@@ -0,0 +1,83 @@
+import { BuildContext } from '../../../core';
+import { designSystemGuardPlugin } from '../design-system-guard-plugin';
+describe(designSystemGuardPlugin.name, () => {
+    let context: BuildContext;
+    beforeEach(() => {
+        context = {
+            package: {
+                isExposeSharedDependencies: true,
+                sharedDependencies: { '@servicetitan/design-system': '1.0.0' },
+            },
+            build: { emitExposedDependencies: false },
+        } as unknown as BuildContext;
+    });
+    const subject = () => designSystemGuardPlugin(context);
+    test('creates plugin with correct name', () => {
+        expect(subject().name).toBe('design-system-guard');
+    });
+    test('enforces pre order so it runs before built-in resolvers', () => {
+        expect(subject().enforce).toBe('pre');
+    });
+    describe('resolveId', () => {
+        let pluginContext: { error: jest.Mock };
+        let source: string;
+        let importer: string | undefined;
+        beforeEach(() => {
+            pluginContext = { error: jest.fn() };
+            source = './design-system.css';
+            importer = '/src/app.tsx';
+        });
+        const subject = () => {
+            const plugin = designSystemGuardPlugin(context);
+            return (plugin.resolveId as Function).call(pluginContext, source, importer);
+        };
+        function itReportsNoError() {
+            test('reports no error', () => {
+                subject();
+                expect(pluginContext.error).not.toHaveBeenCalled();
+            });
+        }
+        test('reports error when design-system.css is imported', () => {
+            subject();
+            expect(pluginContext.error).toHaveBeenCalledWith(
+                'do not import design-system.css in "app"; it is automatically included as a shared dependency'
+            );
+        });
+        describe('when other css is imported', () => {
+            beforeEach(() => (source = './styles.css'));
+            itReportsNoError();
+        });
+        describe('when the package does not expose shared dependencies', () => {
+            beforeEach(() => (context.package.isExposeSharedDependencies = false));
+            itReportsNoError();
+        });
+        describe('when the design system is not a shared dependency', () => {
+            beforeEach(() => (context.package.sharedDependencies = {}));
+            itReportsNoError();
+        });
+        describe('when building the shared dependencies bundle', () => {
+            beforeEach(() => (context.build.emitExposedDependencies = true));
+            itReportsNoError();
+        });
+    });
+});

package/src/vite/plugins/__tests__/html-template.test.ts CHANGED Viewed

@@ -33,6 +33,12 @@ describe('Vite host HTML template', () => {
         expect(subject()).toContain('<title>ServiceTitan</title>');
     });
+    test('renders the viewport meta tag', () => {
+        expect(subject()).toContain(
+            '<meta name="viewport" content="width=device-width,initial-scale=1" />'
+        );
+    });
     describe('with a configured title', () => {
         beforeEach(() => (context.bundlerConfig.pluginOverrides.html = { title: 'My App' }));

package/src/vite/plugins/__tests__/ignore-modules-plugin.test.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import { BuildContext, checkResource } from '../../../core';
-import { ignoreModulesPlugin, VIRTUAL_PREFIX } from '../ignore-modules-plugin';
+import { EMPTY_PREFIX, ignoreModulesPlugin, THROW_PREFIX } from '../ignore-modules-plugin';
 jest.mock('../../../core', () => ({
     checkResource: jest.fn(),
@@ -43,11 +43,25 @@ describe(ignoreModulesPlugin.name, () => {
         itReturnsUndefined();
-        describe('when checker matches the resource', () => {
-            beforeEach(() => checker.mockReturnValue(true));
+        describe('when checker returns "throw"', () => {
+            beforeEach(() => checker.mockReturnValue('throw'));
-            test('returns virtual id', () => {
-                expect(subject()).toBe(`${VIRTUAL_PREFIX}${moduleName}`);
+            test('returns throw-prefixed virtual id', () => {
+                expect(subject()).toBe(`${THROW_PREFIX}${moduleName}`);
+            });
+            describe('when importer is not provided', () => {
+                beforeEach(() => (importer = undefined));
+                itReturnsUndefined();
+            });
+        });
+        describe('when checker returns "empty"', () => {
+            beforeEach(() => checker.mockReturnValue('empty'));
+            test('returns empty-prefixed virtual id', () => {
+                expect(subject()).toBe(`${EMPTY_PREFIX}${moduleName}`);
             });
             describe('when importer is not provided', () => {
@@ -72,8 +86,8 @@ describe(ignoreModulesPlugin.name, () => {
             expect(subject()).toBeUndefined();
         });
-        describe('when id has virtual prefix', () => {
-            beforeEach(() => (id = `${VIRTUAL_PREFIX}${moduleName}`));
+        describe('when id has throw prefix', () => {
+            beforeEach(() => (id = `${THROW_PREFIX}${moduleName}`));
             test('returns module that throws MODULE_NOT_FOUND on evaluation', () => {
                 expect(subject()).toBe(
@@ -81,5 +95,13 @@ describe(ignoreModulesPlugin.name, () => {
                 );
             });
         });
+        describe('when id has empty prefix', () => {
+            beforeEach(() => (id = `${EMPTY_PREFIX}${moduleName}`));
+            test('returns module with no exports', () => {
+                expect(subject()).toBe('export {};');
+            });
+        });
     });
 });

package/src/vite/plugins/__tests__/istanbul-plugin.test.ts ADDED Viewed

@@ -0,0 +1,62 @@
+import type { ViteBuildContext } from '../../types';
+import { istanbulPlugin } from '../istanbul-plugin';
+import { importEsm } from '../utils';
+jest.mock('../utils/import-esm');
+describe(istanbulPlugin.name, () => {
+    const mockIstanbul = jest.fn(() => ({ name: 'vite-plugin-istanbul' }));
+    let context: ViteBuildContext;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.mocked(importEsm).mockResolvedValue({ default: mockIstanbul });
+        context = { options: {} } as ViteBuildContext;
+    });
+    const subject = () => istanbulPlugin(context);
+    test('returns undefined', () => {
+        expect(subject()).toBeUndefined();
+    });
+    describe('when code coverage is enabled', () => {
+        beforeEach(() => {
+            context.options.codeCoverage = true;
+        });
+        test('loads vite-plugin-istanbul', async () => {
+            await subject();
+            expect(importEsm).toHaveBeenCalledWith('vite-plugin-istanbul');
+        });
+        test('returns the istanbul plugin', async () => {
+            expect(await subject()).toEqual({ name: 'vite-plugin-istanbul' });
+        });
+        test('instruments production builds', async () => {
+            await subject();
+            expect(mockIstanbul).toHaveBeenCalledWith(
+                expect.objectContaining({ forceBuildInstrument: true })
+            );
+        });
+        test('instruments without requiring an env flag', async () => {
+            await subject();
+            expect(mockIstanbul).toHaveBeenCalledWith(
+                expect.objectContaining({ requireEnv: false })
+            );
+        });
+        test('excludes node_modules and yalc', async () => {
+            await subject();
+            expect(mockIstanbul).toHaveBeenCalledWith(
+                expect.objectContaining({ exclude: ['**/node_modules/**', '**/.yalc/**'] })
+            );
+        });
+    });
+});

package/src/vite/plugins/__tests__/moment-locales-plugin.test.ts ADDED Viewed

@@ -0,0 +1,104 @@
+import { BuildContext } from '../../../core';
+import { VIRTUAL_MOMENT, momentLocalesPlugin } from '../moment-locales-plugin';
+const LOCALES_TO_KEEP = ['en-au', 'en-ca', 'en-gb'];
+const context = {} as BuildContext;
+describe(momentLocalesPlugin.name, () => {
+    const subject = () => momentLocalesPlugin(context);
+    test('creates plugin with correct name', () => {
+        expect(subject().name).toBe('moment-locales');
+    });
+    test('enforces pre order so it runs before built-in resolvers', () => {
+        expect(subject().enforce).toBe('pre');
+    });
+    describe('resolveId', () => {
+        const importer = 'importer.ts';
+        let source: string;
+        let resolve: jest.Mock;
+        beforeEach(() => {
+            source = 'react';
+            resolve = jest.fn(() => `resolved: ${source}`);
+        });
+        const subject = () => {
+            const plugin = momentLocalesPlugin(context);
+            return (plugin.resolveId as Function).call({ resolve }, source, importer, {});
+        };
+        const itReturnsUndefined = () => {
+            test('returns undefined', () => {
+                expect(subject()).toBeUndefined();
+            });
+        };
+        itReturnsUndefined();
+        describe('when source is "moment"', () => {
+            beforeEach(() => (source = 'moment'));
+            test('returns the virtual module', () => {
+                expect(subject()).toBe(VIRTUAL_MOMENT);
+            });
+        });
+        describe('when source is a UMD moment path', () => {
+            beforeEach(() => (source = 'moment/locale/fr'));
+            test('resolves the ESM moment path', async () => {
+                await subject();
+                expect(resolve).toHaveBeenCalledWith(
+                    source.replace('/locale/', '/dist/locale/'),
+                    importer,
+                    {}
+                );
+            });
+            test('returns the resolved ESM moment path', async () => {
+                expect(await subject()).toEqual(resolve(source));
+            });
+        });
+        describe('when source is already an ESM moment path', () => {
+            beforeEach(() => (source = 'moment/dist/locale/fr'));
+            itReturnsUndefined();
+        });
+    });
+    describe('load', () => {
+        let id: string;
+        beforeEach(() => (id = 'react'));
+        const subject = () => {
+            const plugin = momentLocalesPlugin(context);
+            return (plugin.load as Function).call(plugin, id) as string | undefined;
+        };
+        test('returns undefined', () => {
+            expect(subject()).toBeUndefined();
+        });
+        describe('when id is the virtual module', () => {
+            beforeEach(() => (id = VIRTUAL_MOMENT));
+            test.each(LOCALES_TO_KEEP)('imports the ESM %s locale', locale => {
+                expect(subject()).toContain(`import 'moment/dist/locale/${locale}';`);
+            });
+            test('imports moment from the ESM build', () => {
+                expect(subject()).toContain("import moment from 'moment/dist/moment.js';");
+            });
+            test('re-exports moment as the default', () => {
+                expect(subject()).toContain('export default moment;');
+            });
+        });
+    });
+});

package/src/vite/plugins/bundle-stat-plugin.ts ADDED Viewed

@@ -0,0 +1,24 @@
+import os from 'os';
+import path from 'path';
+import type { Plugin } from 'vite';
+import { analyzer, unstableRolldownAdapter } from 'vite-bundle-analyzer';
+import { bundleReportFileName, bundleReportTitle } from '../../core';
+import { ViteBuildContext } from '../types';
+/*
+ * Writes a static bundle-size treemap to the temp directory when --stat is passed, parity with the webpack build.
+ */
+export function bundleStatPlugin(context: ViteBuildContext): Plugin | undefined {
+    if (!context.options.buildStat) {
+        return;
+    }
+    return unstableRolldownAdapter(
+        analyzer({
+            analyzerMode: 'static',
+            fileName: () => path.join(os.tmpdir(), bundleReportFileName(context)),
+            reportTitle: bundleReportTitle(context),
+            openAnalyzer: true,
+        })
+    ) as Plugin;
+}

package/src/vite/plugins/chain-source-maps-plugin.ts ADDED Viewed

@@ -0,0 +1,26 @@
+import fs from 'fs';
+import path from 'path';
+import type { Plugin } from 'rolldown';
+/*
+ * Return each compiled `.js` file's external `.js.map` (emitted by SWC) from the
+ * load hook so Rolldown chains it, making source maps resolve to the original
+ * `.ts` instead of stopping at the compiled `.js`.
+ */
+export function chainSourceMapsPlugin(): Plugin {
+    return {
+        name: 'chain-source-maps',
+        load(id) {
+            const mapPath = `${id}.map`;
+            if (id.endsWith('.js') && fs.existsSync(mapPath)) {
+                const map = JSON.parse(fs.readFileSync(mapPath, 'utf8'));
+                const dir = path.dirname(mapPath);
+                // Absolute paths let Rolldown resolve the sources; source maps require `/` separators.
+                map.sources = map.sources.map((source: string) =>
+                    path.resolve(dir, source).replace(/\\/g, '/')
+                );
+                return { code: fs.readFileSync(id, 'utf8'), map };
+            }
+        },
+    };
+}