@servicetitan/startup 31.0.0 → 31.1.0

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

@@ -1,195 +0,0 @@
-/**
- * @jest-environment node
- */
-import chokidar from 'chokidar';
-import fs, { Stats } from 'fs';
-
-import { getFolders, log } from '../../../utils';
-import * as sassModule from '../compile-sass';
-
-import { styleExtensions } from '../style-extensions';
-import { tcm } from '../tcm';
-
-jest.mock('../../../utils', () => ({
-    ...jest.requireActual('../../../utils'),
-    getFolders: jest.fn(),
-    log: { debug: jest.fn(), error: jest.fn(), info: jest.fn() }, // suppress test output
-}));
-
-/**
- * Note: These tests don't use memfs because the typed-css-modules package
- * uses node: URLs to import the fs modules, which bypasses the memfs filesystem
- * (as of memfs ~4.6.0).
- */
-
-describe('[startup] Cli Utils', () => {
-    const source = fs.mkdtempSync('src');
-
-    beforeEach(() => {
-        jest.resetAllMocks();
-        jest.mocked(getFolders).mockReturnValue({ source, destination: 'dist' });
-        fs.readdirSync(source).forEach(file => fs.rmSync(`${source}/${file}`));
-    });
-
-    afterAll(() => fs.rmSync(source, { recursive: true }));
-
-    function mockStylesModule(module: string, id = 'foo') {
-        const content = `.${id} { display: none; }`;
-        fs.writeFileSync(`${source}/${module}`, content);
-    }
-
-    function expectTypeDefinitions(module: string, id = 'foo') {
-        expect(fs.readFileSync(`${source}/${module}.d.ts`, 'utf8')).toContain(
-            `export const ${id}: string;`
-        );
-    }
-
-    describe(`${tcm.name}`, () => {
-        const subject = async () => tcm(options);
-        let options: Parameters<typeof tcm>[0];
-
-        beforeEach(() => {
-            options = undefined;
-        });
-
-        describe.each(styleExtensions)('with %s module', extension => {
-            const module = `foo.module.${extension}`;
-
-            beforeEach(() => mockStylesModule(module));
-
-            test(`generates Typescript definitions for ${extension} module`, async () => {
-                await subject();
-
-                expectTypeDefinitions(module);
-            });
-        });
-
-        describe('when an error occurs', () => {
-            beforeEach(() => {
-                mockStylesModule('foo.module.scss');
-                jest.spyOn(sassModule, 'compileSass').mockImplementation(() => {
-                    throw new Error('Oops!');
-                });
-            });
-
-            test('logs error', async () => {
-                await subject();
-
-                expect(log.error).toHaveBeenCalledWith(expect.stringContaining('Oops!'));
-            });
-        });
-
-        describe(`watch mode`, () => {
-            type Listener = (path: string) => Promise<void>;
-            let watchSpy: jest.SpyInstance;
-            let fsWatcher: Partial<ReturnType<typeof chokidar.watch>>;
-
-            beforeEach(() => {
-                options = { watch: true };
-                fsWatcher = { on: jest.fn() };
-                watchSpy = jest.spyOn(chokidar, 'watch').mockReturnValue(fsWatcher as any);
-                fs.writeFileSync(`${source}/foo.bar`, '');
-            });
-
-            test('watches for new and changed style modules', async () => {
-                await subject();
-
-                expect(watchSpy).toHaveBeenCalledWith(source, {
-                    ignored: expect.any(Function),
-                    ignoreInitial: true,
-                });
-                expect(fsWatcher.on).toHaveBeenCalledWith('add', expect.any(Function));
-                expect(fsWatcher.on).toHaveBeenCalledWith('change', expect.any(Function));
-            });
-
-            function getListener(name: string) {
-                const { calls } = jest.mocked(fsWatcher.on)!.mock;
-                return calls.find(([event]) => event === name)![1] as Listener;
-            }
-
-            describe('"ignored" filter', () => {
-                const styleExtensions = ['.module.css', '.module.scss', '.module.less'];
-                let ignored: (path: string, stats?: Partial<Stats>) => boolean;
-                let filePath: string;
-                let stats: Partial<Stats> | undefined;
-
-                beforeEach(async () => {
-                    await tcm(options);
-                    const { calls } = watchSpy.mock;
-                    ignored = calls[0][1].ignored;
-                    stats = { isFile: () => true };
-                });
-
-                const subject = () => ignored(filePath, stats);
-
-                function itReturns(value: boolean) {
-                    test(`returns ${value}`, () => expect(subject()).toBe(value));
-                }
-
-                describe.each(styleExtensions)('when path ends with %s', ext => {
-                    beforeEach(() => (filePath = `foo${ext}`));
-
-                    itReturns(false);
-                });
-
-                describe.each(styleExtensions)('when path contains %s', ext => {
-                    beforeEach(() => (filePath = `foo${ext}.d.ts`));
-
-                    itReturns(true);
-                });
-
-                describe.each(['', '.scss', '.tsx'])('when path ends with "%s"', ext => {
-                    beforeEach(() => (filePath = `foo${ext}`));
-
-                    itReturns(true);
-
-                    describe('when stats is undefined', () => {
-                        beforeEach(() => (stats = undefined));
-
-                        itReturns(false);
-                    });
-
-                    describe('when stats.isFile returns false', () => {
-                        beforeEach(() => (stats = { isFile: () => false }));
-
-                        itReturns(false);
-                    });
-                });
-            });
-
-            describe('when module is added', () => {
-                const module = 'bar.module.scss';
-
-                const setup = async () => {
-                    await subject();
-                    mockStylesModule(module, 'bar');
-                    await getListener('add')(`${source}/${module}`);
-                };
-
-                test('generates Typescript definitions for new module', async () => {
-                    await setup();
-
-                    expectTypeDefinitions(module, 'bar');
-                });
-            });
-
-            describe('when module is changed', () => {
-                const module = 'baz.module.less';
-
-                const setup = async () => {
-                    mockStylesModule(module, 'foo');
-                    await subject();
-
-                    mockStylesModule(module, 'baz');
-                    await getListener('change')(`${source}/${module}`);
-                };
-
-                test('generates Typescript definitions for changed module', async () => {
-                    await setup();
-
-                    expectTypeDefinitions(module, 'baz');
-                });
-            });
-        });
-    });
-});

package/src/cli/utils/style-extensions.ts

@@ -1 +0,0 @@
-export const styleExtensions = ['css', 'less', 'scss'];

package/src/cli/utils/tcm.ts

@@ -1,66 +0,0 @@
-import { glob } from 'glob';
-import chokidar from 'chokidar';
-import DtsCreator from 'typed-css-modules';
-
-import { getFolders, log } from '../../utils';
-import { compileLess } from './compile-less';
-import { compileSass } from './compile-sass';
-import { styleExtensions } from './style-extensions';
-
-interface RunOptions {
-    watch?: boolean;
-}
-
-async function compile(filePath: string) {
-    if (filePath.endsWith('.less')) {
-        return compileLess(filePath);
-    }
-    if (filePath.endsWith('.scss')) {
-        return compileSass(filePath);
-    }
-}
-
-export async function tcm({ watch }: RunOptions = {}) {
-    const source = getFolders().source.replace(/\\/g, '/');
-    const filesPattern = `${source}/**/*.module.{${styleExtensions.join()}}`;
-    const creator = new DtsCreator({ camelCase: true, namedExports: true });
-
-    const generateDefinitions = async (file: string) => {
-        try {
-            const css = await compile(file);
-            const content = await creator.create(file, css, !!watch);
-            await content.writeFile();
-        } catch (error) {
-            log.error(String(error));
-        }
-    };
-
-    if (!watch) {
-        log.info(`Generating types for ${filesPattern}`);
-        const files = await glob(filesPattern);
-        await Promise.all(files.map(generateDefinitions));
-        return;
-    }
-
-    log.info(`Watching to generate types for ${filesPattern}`);
-
-    watchFiles(source, async (path: string) => {
-        log.debug('tcm', `Compiling ${path}`);
-        await generateDefinitions(path);
-    });
-
-    /* istanbul ignore next: not executed in test environment */
-    if (process.env.NODE_ENV !== 'test') {
-        await new Promise<void>(() => {});
-    }
-}
-
-function watchFiles(source: string, callback: (path: string) => Promise<void>) {
-    const stylesRegex = new RegExp(`\\.module\\.(${styleExtensions.join('|')})$`);
-    const watcher = chokidar.watch(source, {
-        ignored: (path, stats) => !!stats?.isFile() && !stylesRegex.test(path),
-        ignoreInitial: true,
-    });
-    watcher.on('add', callback);
-    watcher.on('change', callback);
-}

package/src/webpack/configs/cache-config.ts

@@ -1,25 +0,0 @@
-import { Configuration } from 'webpack';
-import { getPackageName, log } from '../../utils';
-import { featureCohort } from '../utils';
-import { Context, Overrides } from './types';
-
-type Result = Pick<Configuration, 'cache'> | undefined;
-
-export function cacheConfig(context: Context, _: Overrides): Result {
-    const { embed, isProduction, isWebComponent } = context;
-    if (isProduction) {
-        return;
-    }
-
-    return featureCohort([2, 5], () => {
-        const packageName = getPackageName();
-        log.info('Persistent cache is active');
-        return {
-            cache: {
-                type: 'filesystem',
-                name: isWebComponent ? `${packageName}__${embed ? 'light' : 'full'}` : packageName,
-                profile: true,
-            },
-        };
-    });
-}

package/src/webpack/utils/feature-cohort.ts

@@ -1,19 +0,0 @@
-import { sync as username } from 'username';
-
-import { log } from '../../utils';
-
-import { hashMod } from './hash-mod';
-
-/**
- * Allows to enable feature for part of the auditory based on stable trait (username).
- */
-export function featureCohort<T>([limit, total]: [number, number], fn: () => T): T | undefined {
-    if (limit >= total) {
-        log.warning('featureCohort: feature always active');
-    }
-    const mod = hashMod(total);
-    const cohort = mod(username() ?? '');
-    if (cohort < limit) {
-        return fn();
-    }
-}

package/src/webpack/utils/hash-mod.ts

@@ -1,32 +0,0 @@
-/*
- * salvaged from https://github.com/segment-boneyard/hash-mod
- * 1. recent code from repo never got into npm registry
- * 2. no types in DefinitelyTyped
- */
-
-/**
- * Returns a `hashMod` function that will return an integer hash of a string
- * modded by `buckets`.
- *
- * @param {Number} buckets
- * @return {Function}
- */
-export function hashMod(buckets: number) {
-    return function (string: string) {
-        return integerHash(string) % buckets;
-    };
-}
-
-/**
- * Return the integer hash of a `string`.
- *
- * http://stackoverflow.com/questions/2624192/good-hash-function-for-strings
- *
- * @param {String} string
- * @returns {Number}
- */
-function integerHash(string: string) {
-    return (string + '').split('').reduce(function (memo, item) {
-        return (memo * 31 * item.charCodeAt(0)) % 982451653;
-    }, 7);
-}