@servicetitan/startup 34.3.0-beta.2 → 35.0.0

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

@@ -1,112 +0,0 @@
-import { build, createServer, preview as previewServer } from 'vite';
-import { CreateBuildContextInput, getName, stringifyConfig } from '../../core';
-import {
-    hasHeadlessBundle,
-    isExposeSharedDependencies,
-    isWebComponent,
-    log,
-    logErrors,
-    validateSharedDependenciesConsistency,
-    validateSharedDependenciesMigration,
-} from '../../utils';
-import { buildSharedDeps } from '../../vite/build-shared-deps';
-import { createViteConfig } from '../../vite/create-vite-config';
-import { Command, CommandOptions } from './types';
-
-const options = {
-    codeCoverage: { boolean: true, hidden: true },
-    exposedDependencies: { boolean: true, hidden: true },
-    preview: { boolean: true, hidden: true },
-    printConfig: { boolean: true, hidden: true },
-    stat: { boolean: true, hidden: true },
-    useWatchConfig: { boolean: true, hidden: true },
-    watch: { boolean: true, hidden: true },
-} satisfies CommandOptions;
-
-export class BundleVite extends Command<typeof options> {
-    static readonly options = options;
-    @logErrors
-    async execute() {
-        validateSharedDependenciesConsistency();
-        validateSharedDependenciesMigration();
-
-        const { preview = false, useWatchConfig = false, watch = false } = this.args;
-        const isProduction = !(watch || useWatchConfig);
-
-        const baseInput: CreateBuildContextInput = {
-            name: getName(),
-            isProduction,
-        };
-
-        if (this.args.printConfig) {
-            const config = await createViteConfig(baseInput);
-            log.text(stringifyConfig(config));
-            return;
-        }
-
-        if (this.args.exposedDependencies) {
-            if (watch) {
-                throw new Error('cannot bundle exposed dependencies in watch mode');
-            }
-            if (!isExposeSharedDependencies()) {
-                return;
-            }
-            await buildSharedDeps(baseInput);
-            return;
-        }
-
-        if (isWebComponent()) {
-            if (watch) {
-                /*
-                 * Start dev servers sequentially to avoid I/O contention during startup.
-                 * Full first — it serves metadata.json and the standalone MFE dev page.
-                 */
-                await buildAndServe(baseInput, { watch, preview });
-                await buildAndServe({ ...baseInput, light: true }, { watch });
-                if (hasHeadlessBundle()) {
-                    await buildAndServe({ ...baseInput, headless: true }, { watch });
-                }
-            } else {
-                // TODO: test if sequential is faster
-                await Promise.all([
-                    buildAndServe(baseInput, { watch, preview }),
-                    buildAndServe({ ...baseInput, light: true }, { watch }),
-                    hasHeadlessBundle() &&
-                        buildAndServe({ ...baseInput, headless: true }, { watch }),
-                ]);
-            }
-
-            return;
-        }
-
-        await buildAndServe(baseInput, { watch, preview });
-    }
-}
-
-async function buildAndServe(
-    input: CreateBuildContextInput,
-    { watch, preview = false }: { watch: boolean; preview?: boolean }
-): Promise<void> {
-    const config = await createViteConfig(input);
-
-    // TODO: look into isDevServerDisabled webpack's counterpart
-    if (watch) {
-        await serve(config);
-    } else {
-        await build(config);
-
-        if (preview) {
-            await serve({ ...config, preview: { port: config.server?.port, open: true } }, true);
-        }
-    }
-}
-
-async function serve(config: import('vite').InlineConfig, preview = false) {
-    const server = preview ? await previewServer(config) : await createServer(config);
-    if ('listen' in server) {
-        await server.listen();
-    }
-    server.printUrls();
-    server.bindCLIShortcuts({ print: true });
-    return server;
-}

package/src/core/check-resource/index.ts

@@ -1 +0,0 @@
-export { checkResource } from './check-resource';

package/src/core/context.ts

@@ -1,65 +0,0 @@
-import crypto from 'crypto';
-import {
-    getFolders,
-    getPackageData,
-    getPackageName,
-    isExposeSharedDependencies,
-    isLegacyRoot,
-    isWebComponent,
-    loadSharedDependencies,
-} from '../utils';
-import { BuildContext, BundlerConfig } from './types';
-export type { BuildContext } from './types';
-
-export interface CreateBuildContextInput {
-    name: string;
-    isProduction: boolean;
-    light?: boolean;
-    headless?: boolean;
-    codeCoverage?: boolean;
-    buildStat?: boolean;
-    bundlerConfig?: BundlerConfig;
-}
-
-export function getName() {
-    const packageName = getPackageName()
-        .replace(/\//g, '-')
-        .replace(/[^\w-]/g, '');
-    const hash = crypto.randomBytes(4).toString('hex');
-
-    return `${packageName}-${hash}`;
-}
-
-export function createBuildContext(input: CreateBuildContextInput): BuildContext {
-    const { source, destination } = getFolders();
-    const packageData = getPackageData();
-    const sharedDependencies = loadSharedDependencies(
-        packageData.dependencies,
-        packageData.sharedDependencies
-    );
-
-    return {
-        package: {
-            name: packageData.name,
-            version: packageData.version,
-            destination,
-            source,
-            dependencies: packageData.dependencies,
-            sharedDependencies,
-            isWebComponent: isWebComponent(),
-            isLegacyRoot: isLegacyRoot(),
-            isExposeSharedDependencies: isExposeSharedDependencies(),
-        },
-        build: {
-            name: input.name,
-            isProduction: input.isProduction,
-            light: input.light,
-            headless: input.headless,
-        },
-        options: {
-            codeCoverage: input.codeCoverage,
-            buildStat: input.buildStat,
-            bundlerConfig: input.bundlerConfig ?? {},
-        },
-    };
-}

package/src/core/defines/exposed-dependencies.ts

@@ -1,21 +0,0 @@
-import { getPackageDependencyVersion } from '../../utils';
-import { BuildContext } from '../types';
-import { getExposedDependencies } from '../utils/get-exposed-dependencies';
-
-export function defineExposedDependencies(context: BuildContext) {
-    const { isExposeSharedDependencies, sharedDependencies, dependencies } = context.package;
-    const { emitExposedDependencies } = context.options.bundlerConfig;
-
-    if (!isExposeSharedDependencies || emitExposedDependencies) {
-        return;
-    }
-
-    const exposedDependencies = getExposedDependencies(sharedDependencies, dependency =>
-        getPackageDependencyVersion(dependency, dependencies?.[dependency])
-    );
-
-    return {
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        EXPOSED_DEPENDENCIES: JSON.stringify(exposedDependencies),
-    };
-}

package/src/core/defines/exposed-instance-dependencies.ts

@@ -1,19 +0,0 @@
-import { BuildContext } from '../types';
-import { getLaunchDarklySdkVersion } from '../utils/get-launchdarkly-sdk-version';
-
-export function defineExposedInstanceDependencies(context: BuildContext) {
-    const { isExposeSharedDependencies } = context.package;
-    const { emitExposedDependencies } = context.options.bundlerConfig;
-    if (!isExposeSharedDependencies || emitExposedDependencies) {
-        return;
-    }
-
-    const instanceDependencies = {
-        launchDarkly: { version: getLaunchDarklySdkVersion() },
-    };
-
-    return {
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        EXPOSED_INSTANCE_DEPENDENCIES: JSON.stringify(instanceDependencies),
-    };
-}

package/src/core/defines/index.ts

@@ -1,3 +0,0 @@
-export { defineExposedDependencies } from './exposed-dependencies';
-export { defineExposedInstanceDependencies } from './exposed-instance-dependencies';
-export { defineWebComponentName } from './web-component-name';

package/src/core/defines/web-component-name.ts

@@ -1,15 +0,0 @@
-import { BuildContext } from '../types';
-
-export function defineWebComponentName(context: BuildContext) {
-    const { isWebComponent } = context.package;
-    const { name } = context.build;
-
-    if (!isWebComponent) {
-        return;
-    }
-
-    return {
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        WEB_COMPONENT_NAME: JSON.stringify(name),
-    };
-}

package/src/core/externals.ts

@@ -1,23 +0,0 @@
-import { BuildContext } from './types';
-
-export function getExternalsMapping(context: BuildContext): Record<string, string> | undefined {
-    if (!needsExternals(context)) {
-        return;
-    }
-
-    const { sharedDependencies, isWebComponent } = context.package;
-    const name = isWebComponent ? context.build.name : context.package.name;
-    return Object.fromEntries(
-        Object.entries(sharedDependencies).map(([dependency, variable]) => [
-            dependency,
-            `${variable}['${name}']`,
-        ])
-    );
-}
-
-function needsExternals(context: BuildContext) {
-    const { light } = context.build;
-    const { isExposeSharedDependencies } = context.package;
-    const { emitExposedDependencies } = context.options.bundlerConfig;
-    return !!light || (isExposeSharedDependencies && !emitExposedDependencies);
-}

package/src/core/get-exposed-dependencies-entry-points.ts

@@ -1,59 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { readJsonSafe } from '../utils';
-import { BuildContext } from './types';
-import { getBundleType } from './utils';
-
-interface ExposedDepsMetadata {
-    entryPointsPath: string;
-}
-
-interface EntryPoints {
-    css: string[];
-    js: string[];
-}
-
-export function getExposedDependenciesEntryPoints(context: BuildContext) {
-    const metadataPath = getExposedDependenciesMetadataPath(context);
-    const metadata = readJsonSafe<ExposedDepsMetadata>(metadataPath);
-    if (metadata?.entryPointsPath) {
-        return readJsonSafe<EntryPoints>(metadata.entryPointsPath);
-    }
-}
-
-export function getExposedDependenciesMetadataPath(context: BuildContext) {
-    return path.join(context.package.destination, 'exposed-dependencies-metadata.json');
-}
-
-export function getSharedEntryPoints(context: BuildContext): EntryPoints {
-    const dirname = getBundleType({
-        ...context,
-        options: {
-            ...context.options,
-            bundlerConfig: { ...context.options.bundlerConfig, emitExposedDependencies: true },
-        },
-    });
-    if (!dirname) {
-        return { css: [], js: [] };
-    }
-
-    const { css = [], js = [] } = getExposedDependenciesEntryPoints(context) ?? {};
-    return {
-        css: css.map(name => `${dirname}/${name}`),
-        js: js.map(name => `${dirname}/${name}`),
-    };
-}
-
-export function generateExposedDependenciesMetadata(
-    context: BuildContext,
-    getOutputPath: () => string
-) {
-    const { destination } = context.package;
-    if (!fs.existsSync(destination)) {
-        fs.mkdirSync(destination, { recursive: true });
-    }
-
-    const metadataPath = getExposedDependenciesMetadataPath(context);
-    const metadata: ExposedDepsMetadata = { entryPointsPath: getOutputPath() };
-    fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), 'utf-8');
-}

package/src/core/index.ts

@@ -1,8 +0,0 @@
-export * from './check-resource';
-export * from './context';
-export * from './defines';
-export * from './externals';
-export * from './get-exposed-dependencies-entry-points';
-export type * from './types';
-export * from './utils';
-export * from './virtual-modules';

package/src/core/types.ts

@@ -1,59 +0,0 @@
-import { MinifyOptions } from '../utils';
-
-export interface BuildContext {
-    package: PackageContext;
-    build: BuildIdentity;
-    options: BuildOptions;
-}
-
-export interface PackageContext {
-    name: string;
-    version: string;
-    destination: string;
-    source: string;
-    dependencies: Record<string, string>;
-    sharedDependencies: Record<string, string>;
-    isWebComponent: boolean;
-    isLegacyRoot: boolean;
-    isExposeSharedDependencies: boolean;
-}
-
-export interface BuildIdentity {
-    name: string;
-    isProduction: boolean;
-    light?: boolean;
-    headless?: boolean;
-}
-
-export interface BuildOptions {
-    codeCoverage?: boolean;
-    buildStat?: boolean;
-    bundlerConfig: BundlerConfig;
-}
-
-export interface BundlerConfig {
-    isCustomStyleRules?: boolean;
-    minify?: MinifyOptions;
-    emitExposedDependencies?: boolean | { output?: { path?: string } };
-}
-
-// Re-export types that were on the old Context and are used by both bundlers
-export interface EntryPoint {
-    css?: string[];
-    js?: string[];
-}
-
-export interface EntryPoints {
-    full?: EntryPoint;
-    light?: EntryPoint;
-    headless?: EntryPoint;
-}
-
-export interface Metadata {
-    name: string;
-    version: string;
-    bundledWith: Record<string, string | undefined>;
-    sharedDependencies: Record<string, string>;
-    dependencies: Record<string, string>;
-    entrypoints: EntryPoints;
-}

package/src/core/utils/get-bundle-type.ts

@@ -1,20 +0,0 @@
-import { BuildContext } from '../types';
-
-export function getBundleType(context: BuildContext) {
-    const { light, headless } = context.build;
-    const { isExposeSharedDependencies, isWebComponent } = context.package;
-    const { emitExposedDependencies } = context.options.bundlerConfig;
-
-    if (isExposeSharedDependencies && emitExposedDependencies) {
-        return 'shared';
-    }
-
-    if (isWebComponent) {
-        if (headless) {
-            return 'headless';
-        }
-        return light ? 'light' : 'full';
-    }
-
-    return undefined;
-}

package/src/core/utils/get-output-path.ts

@@ -1,18 +0,0 @@
-import path from 'path';
-import { BuildContext } from '../types';
-import { getBundleType } from './get-bundle-type';
-
-export function getOutputPath(context: BuildContext) {
-    const { destination } = context.package;
-    const { emitExposedDependencies } = context.options.bundlerConfig;
-
-    const subdir = getBundleType(context) ?? '';
-    if (typeof emitExposedDependencies === 'object') {
-        const { output } = emitExposedDependencies;
-        if (output?.path) {
-            return path.join(output.path, subdir);
-        }
-    }
-
-    return path.join(process.cwd(), destination, 'bundle', subdir);
-}

package/src/core/utils/index.ts

@@ -1,8 +0,0 @@
-export * from './build-metadata';
-export * from './generate-metadata';
-export * from './get-bundle-type';
-export * from './get-exposed-dependencies';
-export * from './get-launchdarkly-sdk-version';
-export * from './get-output-path';
-export * from './get-web-components-version';
-export * from './stringify-config';

package/src/core/virtual-modules.ts

@@ -1,76 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { BuildContext } from './types';
-
-export function virtualModules(context: BuildContext) {
-    const modules: { [key: string]: string | undefined; index?: string; designSystem?: string } =
-        {};
-
-    if (context.package.isWebComponent) {
-        modules.index = indexCode(context);
-    }
-
-    if (needsToIncludeDesignSystem(context)) {
-        const designSystemPath = getDesignSystemPath(context);
-        if (!fs.existsSync(designSystemPath)) {
-            modules.designSystem = designSystemCode();
-        }
-    }
-
-    return modules;
-}
-
-export function getDesignSystemPath(context: BuildContext) {
-    return path.join(process.cwd(), context.package.destination, 'design-system.css');
-}
-
-function designSystemCode() {
-    return [
-        `@import '@servicetitan/tokens/core/tokens.css';`,
-        `@import '@servicetitan/anvil-fonts/dist/css/anvil-fonts.css';`,
-        `@import '@servicetitan/design-system/dist/system.min.css';`,
-    ].join('\n');
-}
-
-function indexCode(context: BuildContext) {
-    const { light = false, headless } = context.build;
-    const { isLegacyRoot, sharedDependencies } = context.package;
-    if (headless) {
-        return headlessIndex();
-    }
-
-    const options = `{ legacyRoot: ${isLegacyRoot}, sharedDependenciesNames: ${JSON.stringify(
-        Object.keys(sharedDependencies)
-    )} }`;
-
-    return [
-        ...(needsToIncludeDesignSystem(context) ? [`import './design-system.css';`] : []),
-        `import { register } from '@servicetitan/web-components';`,
-        `import { App } from './app';`,
-        `register(App, ${light}, ${options});`,
-    ].join('\n');
-}
-
-export function needsToIncludeDesignSystem(context: BuildContext) {
-    const { light, headless } = context.build;
-    const { isWebComponent, dependencies, sharedDependencies } = context.package;
-    const { emitExposedDependencies } = context.options.bundlerConfig;
-
-    return (
-        (!!emitExposedDependencies && !!sharedDependencies['@servicetitan/design-system']) ||
-        (isWebComponent &&
-            !headless &&
-            // Depends on design system
-            !!dependencies['@servicetitan/design-system'] &&
-            // ... and is not light bundle with private copy of design system
-            !(light && !!sharedDependencies['@servicetitan/design-system']))
-    );
-}
-
-function headlessIndex() {
-    return [
-        "import { registerHeadless } from '@servicetitan/web-components';",
-        "import { connectedCallback, disconnectedCallback } from './headless';",
-        'registerHeadless(connectedCallback, disconnectedCallback);',
-    ].join('\n');
-}

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

@@ -1,13 +0,0 @@
-import { defineConfig } from '../define-config';
-
-describe('defineConfig', () => {
-    test('returns object config as-is', () => {
-        const config = { config: { build: { minify: false } } };
-        expect(defineConfig(config)).toBe(config);
-    });
-
-    test('returns function config as-is', () => {
-        const fn = () => ({ config: { build: { minify: false } } });
-        expect(defineConfig(fn)).toBe(fn);
-    });
-});

package/src/vite/__tests__/load-config-file.test.ts

@@ -1,115 +0,0 @@
-import { fs, vol } from 'memfs';
-import { loadConfigFile } from '../load-config-file';
-
-jest.mock('fs', () => fs);
-
-jest.mock('../load-config-file', () => {
-    const realPath = jest.requireActual('path') as typeof import('path');
-
-    return {
-        // eslint-disable-next-line @typescript-eslint/require-await
-        loadConfigFile: async (root: string, isProduction: boolean) => {
-            const candidates = isProduction
-                ? ['vite.prod.config.ts', 'vite.prod.config.js']
-                : ['vite.dev.config.ts', 'vite.dev.config.js'];
-
-            const configPath = candidates
-                .map((f: string) => realPath.join(root, f))
-                .find((f: string) => {
-                    try {
-                        fs.statSync(f);
-                        return true;
-                    } catch {
-                        return false;
-                    }
-                });
-
-            if (!configPath) {
-                return undefined;
-            }
-
-            const content = fs.readFileSync(configPath, 'utf-8') as string;
-
-            // Parse simple export default { ... } or export default (ctx) => ...
-            if (content.includes('=>')) {
-                // Function export
-                // eslint-disable-next-line @typescript-eslint/no-implied-eval
-                return new Function('return ' + content.replace('export default ', ''))();
-            }
-
-            // Object export — extract the object literal
-            const match = content.match(/export default\s+({[\s\S]*});?\s*$/);
-            if (match) {
-                // eslint-disable-next-line @typescript-eslint/no-implied-eval
-                return new Function('return ' + match[1])();
-            }
-
-            return undefined;
-        },
-    };
-});
-
-describe('loadConfigFile', () => {
-    afterEach(() => vol.reset());
-
-    test('returns undefined when no config file exists', async () => {
-        vol.fromJSON({ '/project/dummy': '' });
-        const result = await loadConfigFile('/project', true);
-        expect(result).toBeUndefined();
-    });
-
-    test('loads prod config file', async () => {
-        vol.fromJSON({
-            '/project/vite.prod.config.ts':
-                'export default { config: { build: { minify: false } } };',
-        });
-        const result = await loadConfigFile('/project', true);
-        expect(result).toEqual({ config: { build: { minify: false } } });
-    });
-
-    test('loads dev config when isProduction is false', async () => {
-        vol.fromJSON({
-            '/project/vite.dev.config.ts': 'export default { config: { server: { port: 3000 } } };',
-        });
-        const result = await loadConfigFile('/project', false);
-        expect(result).toEqual({ config: { server: { port: 3000 } } });
-    });
-
-    test('prefers .ts over .js', async () => {
-        vol.fromJSON({
-            '/project/vite.prod.config.ts':
-                'export default { config: { build: { minify: true } } };',
-            '/project/vite.prod.config.js':
-                'export default { config: { build: { minify: false } } };',
-        });
-        const result = await loadConfigFile('/project', true);
-        expect(result).toEqual({ config: { build: { minify: true } } });
-    });
-
-    test('falls back to .js when .ts does not exist', async () => {
-        vol.fromJSON({
-            '/project/vite.prod.config.js':
-                'export default { config: { server: { port: 9000 } } };',
-        });
-        const result = await loadConfigFile('/project', true);
-        expect(result).toEqual({ config: { server: { port: 9000 } } });
-    });
-
-    test('returns function export without calling it', async () => {
-        vol.fromJSON({
-            '/project/vite.prod.config.ts':
-                'export default (context) => ({ config: { build: { minify: true } } });',
-        });
-        const result = await loadConfigFile('/project', true);
-        expect(typeof result).toBe('function');
-    });
-
-    test('does not find prod config when looking for dev', async () => {
-        vol.fromJSON({
-            '/project/vite.prod.config.ts':
-                'export default { config: { build: { minify: false } } };',
-        });
-        const result = await loadConfigFile('/project', false);
-        expect(result).toBeUndefined();
-    });
-});