@servicetitan/startup 36.3.1 → 37.0.0

package/src/cli/utils/bundle.ts

@@ -1,191 +0,0 @@
-import crypto from 'crypto';
-import fs from 'fs';
-import path from 'path';
-import { getPortPromise } from 'portfinder';
-import webpack, { Configuration } from 'webpack';
-import WebpackDevServer from 'webpack-dev-server';
-import {
-    getPackageName,
-    hasHeadlessBundle,
-    isDevServerDisabled,
-    isExposeSharedDependencies,
-    isWebComponent,
-    log,
-    pick,
-} from '../../utils';
-import { Overrides, createWebpackConfig } from '../../webpack';
-import { stringifyConfig } from '../../webpack/utils';
-
-interface Options {
-    buildStat?: boolean;
-    codeCoverage?: boolean;
-    config?: string;
-    emitExposedDependencies?: boolean | Pick<Configuration, 'output'>;
-    useWatchConfig?: boolean;
-    watch?: boolean;
-}
-
-function getName() {
-    const packageName = getPackageName()
-        .replace(/\//g, '-')
-        .replace(/[^\w-]/g, '');
-    const hash = crypto.randomBytes(4).toString('hex');
-
-    return `${packageName}-${hash}`;
-}
-
-export const webpackDevConfigFileName = 'webpack.dev.config.js';
-export const webpackProdConfigFileName = 'webpack.prod.config.js';
-
-export async function bundle(options: Options = {}) {
-    const { emitExposedDependencies, useWatchConfig, watch } = options;
-    if (emitExposedDependencies) {
-        if (watch) {
-            throw new Error('cannot bundle exposed dependencies in watch mode');
-        }
-        if (!isExposeSharedDependencies()) {
-            return;
-        }
-    }
-
-    log.info(`Bundling ${emitExposedDependencies ? 'exposed dependencies' : 'package'}...`);
-
-    const mode = watch || useWatchConfig ? 'development' : 'production';
-    const fallback = watch || useWatchConfig ? webpackDevConfigFileName : webpackProdConfigFileName;
-    const customConfig = readWebpackConfig({ ...options, fallback });
-    const webpackOptions = getWebpackOptions(options, customConfig);
-
-    /* istanbul ignore next: debug only */
-    log.debug('custom-webpack-config', () => stringifyConfig(customConfig));
-
-    if (isWebComponent()) {
-        return bundleWebComponent({ customConfig, mode, watch, webpackOptions });
-    }
-
-    const config =
-        customConfig && !emitExposedDependencies
-            ? customConfig
-            : createWebpackConfig({ configuration: { mode } }, webpackOptions);
-
-    if (watch) {
-        return isDevServerDisabled() ? runWatch(config) : runServe(config);
-    }
-
-    return run(config);
-}
-
-function bundleWebComponent({
-    customConfig,
-    mode,
-    watch,
-    webpackOptions,
-}: {
-    customConfig: ReturnType<typeof readWebpackConfig>;
-    mode: 'development' | 'production';
-    watch?: boolean;
-    webpackOptions: ReturnType<typeof getWebpackOptions>;
-}) {
-    const overrides: Overrides = {
-        configuration: { ...customConfig?.configuration, mode },
-        plugins: customConfig?.plugins,
-    };
-
-    const fullConfig = createWebpackConfig(overrides, webpackOptions);
-    const lightConfig = createWebpackConfig(overrides, { ...webpackOptions, embed: true });
-    const headlessConfig = hasHeadlessBundle()
-        ? createWebpackConfig(overrides, {
-              ...webpackOptions,
-              headless: true,
-          })
-        : undefined;
-
-    const promises = watch
-        ? [
-              runWatch(lightConfig),
-              isDevServerDisabled() ? runWatch(fullConfig) : runServe(fullConfig),
-              headlessConfig && runWatch(headlessConfig),
-          ]
-        : [run(lightConfig), run(fullConfig), headlessConfig && run(headlessConfig)];
-
-    return Promise.all(promises.filter(promise => !!promise));
-}
-
-function getWebpackOptions(options: Options, customConfig?: Record<string, any>) {
-    const result = {
-        name: getName(),
-        ...pick(options, ['buildStat', 'codeCoverage', 'emitExposedDependencies']),
-    };
-
-    if (result.emitExposedDependencies && customConfig) {
-        result.emitExposedDependencies = { output: customConfig.output };
-    }
-
-    return result;
-}
-
-function readWebpackConfig({ config, fallback }: Options & { fallback: string }) {
-    return readConfig(config) ?? readConfig(fallback);
-}
-
-function readConfig(relativePath?: string): Record<string, any> | undefined {
-    if (relativePath && fs.existsSync(relativePath)) {
-        return require(path.resolve(relativePath));
-    }
-}
-
-async function run(config: Configuration) {
-    const compiler = createWebpackCompiler(config);
-
-    const stats = await new Promise<webpack.Stats>((resolve, reject) => {
-        compiler.run((error, stats) => {
-            if (!stats || error) {
-                return reject(error ?? new Error('Something went wrong.'));
-            }
-
-            if (stats.hasErrors()) {
-                return reject(new Error(stats.toString('errors-only')));
-            }
-
-            compiler.close(() => resolve(stats));
-        });
-    });
-
-    process.stdout.write(stats.toString(config.stats) + '\n');
-}
-
-async function runServe({ devServer = {}, ...config }: Configuration) {
-    const compiler = createWebpackCompiler(config);
-    const host = devServer.host ?? 'localhost';
-    const port = await getPortPromise({
-        port: Number(process.env.PORT) || Number(devServer.port) || 8080,
-        host,
-    });
-
-    return new Promise<void>((_0, reject) => {
-        const server = new WebpackDevServer({ ...devServer, host, port }, compiler);
-        server.startCallback(e => {
-            if (e) {
-                server.stopCallback(() => {
-                    reject(e);
-                });
-            }
-        });
-    });
-}
-
-async function runWatch(config: Configuration) {
-    const compiler = createWebpackCompiler(config);
-    return new Promise<void>((_0, reject) => {
-        const watching = compiler.watch({}, e => {
-            if (e) {
-                watching?.close(() => {
-                    reject(e);
-                });
-            }
-        });
-    });
-}
-
-function createWebpackCompiler(config: Configuration) {
-    return webpack(config);
-}

package/src/utils/get-startup-version.ts

@@ -1,6 +0,0 @@
-import path from 'path';
-import { readJson } from './read-json';
-
-export function getStartupVersion() {
-    return readJson(path.join(__dirname, '../../package.json')).version;
-}

package/src/webpack/configs/plugins/ignore-plugin/__tests__/check-resource.test.ts

@@ -1,62 +0,0 @@
-import { Context } from '../../../types';
-import { checkResource } from '../check-resource';
-import { isOptionalPeerDependency } from '../is-optional-peer-dependency';
-import { isOptionalReactDomPeerDependency } from '../is-optional-react-dom-peer-dependency';
-
-jest.mock('../is-optional-peer-dependency');
-jest.mock('../is-optional-react-dom-peer-dependency');
-
-describe(`${checkResource.name}`, () => {
-    const context = 'node_modules/web-components/dist';
-    let packageContext: Partial<Context>;
-    let resource: string;
-
-    beforeEach(() => {
-        jest.resetAllMocks();
-
-        resource = '@servicetitan/foo';
-        packageContext = {
-            packageData: {
-                name: 'application',
-                version: '1.0.0',
-                dependencies: {},
-            },
-        };
-    });
-
-    const subject = () => checkResource(packageContext as any)(resource, context);
-
-    function itReturns(value: boolean) {
-        test(`returns ${value}`, () => expect(subject()).toBe(value));
-    }
-
-    itReturns(false);
-
-    describe('when resource is optional peer dependency', () => {
-        beforeEach(() => jest.mocked(isOptionalPeerDependency).mockReturnValue(true));
-
-        itReturns(true);
-
-        describe('when resource is package dependency', () => {
-            beforeEach(() => (packageContext.packageData!.dependencies[resource] = '*'));
-
-            itReturns(false);
-        });
-    });
-
-    describe('when resource is optional react-dom peer dependency', () => {
-        beforeEach(() => jest.mocked(isOptionalReactDomPeerDependency).mockReturnValue(true));
-
-        describe('when resource is present', () => {
-            beforeEach(() => (resource = 'fs'));
-
-            itReturns(false);
-        });
-
-        describe('when resource is not present', () => {
-            beforeEach(() => (resource = 'foo'));
-
-            itReturns(true);
-        });
-    });
-});

package/src/webpack/configs/plugins/ignore-plugin/__tests__/is-optional-peer-dependency.test.ts

@@ -1,47 +0,0 @@
-import { getPackageJson } from '../get-package-json';
-import { isOptionalPeerDependency } from '../is-optional-peer-dependency';
-
-jest.mock('../get-package-json');
-
-describe(`[startup] ${isOptionalPeerDependency.name}`, () => {
-    let resource: string;
-    let context: string;
-
-    beforeEach(() => {
-        resource = 'foo';
-        context = makeId(); // use unique context for each test because peerDependenciesMeta is memoized
-        jest.mocked(getPackageJson).mockReturnValue(undefined);
-    });
-
-    const subject = () => isOptionalPeerDependency(resource, context);
-
-    function itReturns(value: boolean) {
-        test(`returns ${value}`, () => {
-            expect(subject()).toBe(value);
-        });
-    }
-
-    itReturns(false);
-
-    describe('when resource is optional peer dependency', () => {
-        beforeEach(() => {
-            jest.mocked(getPackageJson).mockImplementation(() => ({
-                peerDependenciesMeta: {
-                    [resource]: { optional: true },
-                },
-            }));
-        });
-
-        itReturns(true);
-
-        describe('when resource is not a package name', () => {
-            beforeEach(() => (resource = './foo'));
-
-            itReturns(false);
-        });
-    });
-});
-
-function makeId() {
-    return Math.round(1e6 * Math.random()).toString(36);
-}

package/src/webpack/configs/plugins/ignore-plugin/__tests__/is-optional-react-dom-peer-dependency.test.ts

@@ -1,35 +0,0 @@
-import { isOptionalReactDomPeerDependency } from '../is-optional-react-dom-peer-dependency';
-
-describe(`${isOptionalReactDomPeerDependency.name}`, () => {
-    const subject = (...args: Parameters<typeof isOptionalReactDomPeerDependency>) =>
-        isOptionalReactDomPeerDependency(...args);
-
-    describe.each([
-        {
-            resource: 'react-dom/client',
-            contexts: [
-                '@servicetitan/web-components',
-                'uikit/packages/web-components/dist',
-                '@servicetitan/ko-bridge',
-                'uikit/packages/ko-bridge/dist',
-            ],
-        },
-    ])('with dependency "$resource"', ({ resource, contexts }) => {
-        contexts.forEach(context => {
-            test(`with context ${context}, returns true`, () => {
-                expect(subject({ context, resource })).toBe(true);
-            });
-        });
-    });
-
-    describe.each([
-        { resource: 'react-dom', contexts: ['@servicetitan/web-components'] },
-        { resource: 'react-dom/client', contexts: ['@servicetitan/foo'] },
-    ])('with dependency "$resource"', ({ resource, contexts }) => {
-        contexts.forEach(context => {
-            test(`with context ${context}, returns false`, () => {
-                expect(subject({ context, resource })).toBe(false);
-            });
-        });
-    });
-});

package/src/webpack/configs/plugins/ignore-plugin/check-resource.ts

@@ -1,29 +0,0 @@
-import { log } from '../../../../utils';
-import { Context } from '../../types';
-import { isOptionalPeerDependency } from './is-optional-peer-dependency';
-import { isOptionalReactDomPeerDependency } from './is-optional-react-dom-peer-dependency';
-
-export function checkResource(packageContext: Context) {
-    return function (resource: string, context: string) {
-        if (
-            !packageContext.packageData.dependencies[resource] &&
-            isOptionalPeerDependency(resource, context)
-        ) {
-            log.debug('check-resource', `${JSON.stringify({ resource, context })} => true`);
-            return true;
-        }
-
-        /**
-         * isOptionalReactDomPeerDependency cannot use packageContext because react-dom/client
-         * is not explicitly listed in the package.json dependencies
-         */
-        if (isOptionalReactDomPeerDependency({ resource, context })) {
-            try {
-                require.resolve(resource);
-            } catch {
-                return true;
-            }
-        }
-        return false;
-    };
-}

package/src/webpack/configs/plugins/ignore-plugin/get-package-json.ts

@@ -1,23 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { log, readJson } from '../../../../utils';
-
-const containsNodeModules = /[\\/](node_modules|\.yalc)[\\/]/;
-const isNodeModules = /(node_modules|\.yalc)/;
-
-export function getPackageJson(context: string) {
-    const fullPath = path.resolve(context);
-    if (!containsNodeModules.test(fullPath)) {
-        return;
-    }
-
-    let dirname = path.dirname(fullPath);
-    do {
-        const packageJsonFile = path.join(dirname, 'package.json');
-        if (fs.existsSync(packageJsonFile)) {
-            log.debug('get-package-json', `${context} => ${packageJsonFile}`);
-            return readJson<Record<string, any>>(packageJsonFile);
-        }
-        dirname = path.dirname(dirname);
-    } while (!isNodeModules.test(path.basename(dirname)));
-}

package/src/webpack/configs/plugins/ignore-plugin/is-optional-peer-dependency.ts

@@ -1,12 +0,0 @@
-import memoize from 'lodash.memoize';
-import { getPackageJson } from './get-package-json';
-
-export function isOptionalPeerDependency(resource: string, context: string) {
-    return (
-        /^[@a-z]/.test(resource) && getPeerDependenciesMeta(context)?.[resource]?.optional === true
-    );
-}
-
-const getPeerDependenciesMeta = memoize(function getPeerDependenciesMeta(context: string) {
-    return getPackageJson(context)?.peerDependenciesMeta;
-});

package/src/webpack/configs/plugins/ignore-plugin/is-optional-react-dom-peer-dependency.ts

@@ -1,11 +0,0 @@
-interface Dependency {
-    context: string;
-    resource: string;
-}
-
-export function isOptionalReactDomPeerDependency({ context, resource }: Dependency) {
-    return (
-        resource === 'react-dom/client' &&
-        /(@servicetitan|packages)\/(ko-bridge|web-components)/.test(context)
-    );
-}

package/src/webpack/configs/types.ts

@@ -1,40 +0,0 @@
-import { getPackageManager } from '@servicetitan/install';
-import { getPackageData, loadSharedDependencies, MinifyOptions } from '../../utils';
-import { Options } from '../types';
-export type { Overrides } from '../types';
-
-export interface Context extends Options {
-    codeCoverage?: boolean;
-    destination: string;
-    isCustomStyleRules?: boolean;
-    isExposeSharedDependencies?: boolean;
-    isLegacyRoot?: boolean;
-    isProduction?: boolean;
-    isWebComponent?: boolean;
-    minify?: MinifyOptions;
-    name: string;
-    packageData: ReturnType<typeof getPackageData>;
-    packageManager: ReturnType<typeof getPackageManager>;
-    sharedDependencies: ReturnType<typeof loadSharedDependencies>;
-    source: string;
-}
-
-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/webpack/configs/utils/get-bundle-type.ts

@@ -1,22 +0,0 @@
-import { Context } from '../types';
-
-export function getBundleType({
-    embed,
-    emitExposedDependencies,
-    headless,
-    isExposeSharedDependencies,
-    isWebComponent,
-}: Context) {
-    if (isExposeSharedDependencies && emitExposedDependencies) {
-        return 'shared';
-    }
-
-    if (isWebComponent) {
-        if (headless) {
-            return 'headless';
-        }
-        return embed ? 'light' : 'full';
-    }
-
-    return undefined;
-}

package/src/webpack/configs/utils/index.ts

@@ -1,3 +0,0 @@
-export * from './generate-metadata';
-export * from './get-bundle-type';
-export * from './get-exposed-dependencies';