@servicetitan/startup 28.5.0 → 30.0.0

package/dist/webpack/configs/plugins/ignore-plugin/check-resource.js

@@ -19,7 +19,7 @@ function checkResource(packageContext) {
             try {
                 require.resolve(resource);
             }
-            catch (e) {
+            catch (_a) {
                 return true;
             }
         }

package/dist/webpack/configs/plugins/ignore-plugin/check-resource.js.map

@@ -1 +1 @@
-{"version":3,"file":"check-resource.js","sourceRoot":"","sources":["../../../../../src/webpack/configs/plugins/ignore-plugin/check-resource.ts"],"names":[],"mappings":";;AAKA,sCAuBC;AA5BD,6CAAwC;AAExC,+EAAyE;AACzE,mGAA2F;AAE3F,SAAgB,aAAa,CAAC,cAAuB;IACjD,OAAO,UAAU,QAAgB,EAAE,OAAe;QAC9C,IACI,CAAC,cAAc,CAAC,WAAW,CAAC,YAAY,CAAC,QAAQ,CAAC;YAClD,IAAA,sDAAwB,EAAC,QAAQ,EAAE,OAAO,CAAC,EAC7C,CAAC;YACC,WAAG,CAAC,KAAK,CAAC,gBAAgB,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,UAAU,CAAC,CAAC;YAChF,OAAO,IAAI,CAAC;QAChB,CAAC;QAED;;;WAGG;QACH,IAAI,IAAA,wEAAgC,EAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;YAC1D,IAAI,CAAC;gBACD,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YAC9B,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACT,OAAO,IAAI,CAAC;YAChB,CAAC;QACL,CAAC;QACD,OAAO,KAAK,CAAC;IACjB,CAAC,CAAC;AACN,CAAC"}
+{"version":3,"file":"check-resource.js","sourceRoot":"","sources":["../../../../../src/webpack/configs/plugins/ignore-plugin/check-resource.ts"],"names":[],"mappings":";;AAKA,sCAuBC;AA5BD,6CAAwC;AAExC,+EAAyE;AACzE,mGAA2F;AAE3F,SAAgB,aAAa,CAAC,cAAuB;IACjD,OAAO,UAAU,QAAgB,EAAE,OAAe;QAC9C,IACI,CAAC,cAAc,CAAC,WAAW,CAAC,YAAY,CAAC,QAAQ,CAAC;YAClD,IAAA,sDAAwB,EAAC,QAAQ,EAAE,OAAO,CAAC,EAC7C,CAAC;YACC,WAAG,CAAC,KAAK,CAAC,gBAAgB,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,UAAU,CAAC,CAAC;YAChF,OAAO,IAAI,CAAC;QAChB,CAAC;QAED;;;WAGG;QACH,IAAI,IAAA,wEAAgC,EAAC,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;YAC1D,IAAI,CAAC;gBACD,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YAC9B,CAAC;YAAC,WAAM,CAAC;gBACL,OAAO,IAAI,CAAC;YAChB,CAAC;QACL,CAAC;QACD,OAAO,KAAK,CAAC;IACjB,CAAC,CAAC;AACN,CAAC"}

package/dist/webpack/utils/hash-mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hash-mod.d.ts","sourceRoot":"","sources":["../../../src/webpack/utils/hash-mod.ts"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,YACV,MAAM,YAGlC"}
+{"version":3,"file":"hash-mod.d.ts","sourceRoot":"","sources":["../../../src/webpack/utils/hash-mod.ts"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,MAAM,IAClB,QAAQ,MAAM,YAGlC"}

package/dist/webpack/utils/testing/execute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../../../src/webpack/utils/testing/execute.ts"],"names":[],"mappings":"AAKA,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,UAE5B,MAAM;;;UAanB"}
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../../../../src/webpack/utils/testing/execute.ts"],"names":[],"mappings":"AAKA,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,IAElC,MAAM,MAAM,EACZ;;;CAA0F,SAYjG"}

package/dist/webpack/utils/testing/get-compiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-compiler.d.ts","sourceRoot":"","sources":["../../../../src/webpack/utils/testing/get-compiler.ts"],"names":[],"mappings":"AAEA,OAAO,OAAO,EAAE,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAKjD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,WACP,MAAM,+BAA8B,aAAa,sBAoCvF"}
+{"version":3,"file":"get-compiler.d.ts","sourceRoot":"","sources":["../../../../src/webpack/utils/testing/get-compiler.ts"],"names":[],"mappings":"AAEA,OAAO,OAAO,EAAE,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAKjD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,IACd,OAAO,MAAM,EAAE,kBAAkB,EAAE,SAAQ,aAAkB,sBAoC5F"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@servicetitan/startup",
-    "version": "28.5.0",
+    "version": "30.0.0",
     "description": "",
     "homepage": "https://docs.st.dev/docs/frontend/startup",
     "repository": {
@@ -8,6 +8,10 @@
         "url": "https://github.com/servicetitan/uikit.git",
         "directory": "packages/startup"
     },
+    "engines": {
+        "node": ">=20",
+        "npm": ">=9"
+    },
     "main": "./dist/index.js",
     "typings": "./dist/index.d.ts",
     "files": [
@@ -20,7 +24,7 @@
     "bin": "./bin/index.js",
     "devDependencies": {
         "@types/cpx": "~1.5.5",
-        "@types/eslint": "~8.56.3",
+        "@types/eslint": "~9.6.1",
         "@types/less": "~3.0.7",
         "@types/lodash.memoize": "^4.1.9",
         "@types/moment-locales-webpack-plugin": "~1.2.2",
@@ -28,35 +32,37 @@
         "@types/yargs": "~17.0.24"
     },
     "dependencies": {
-        "@babel/preset-env": "~7.26.7",
+        "@babel/preset-env": "~7.26.9",
         "@jest/core": "~29.7.0",
         "@jest/types": "~29.6.3",
         "@jsdevtools/coverage-istanbul-loader": "^3.0.5",
-        "@servicetitan/eslint-config": "28.5.0",
-        "@servicetitan/stylelint-config": "28.5.0",
+        "@servicetitan/eslint-config": "30.0.0",
+        "@servicetitan/stylelint-config": "30.0.0",
         "@svgr/webpack": "^8.1.0",
-        "@swc/core": "1.10.7",
+        "@swc/cli": "0.6.0",
+        "@swc/core": "1.11.13",
         "@types/debug": "^4.1.12",
         "@types/jest": "~29.5.12",
         "chalk": "~4.1.2",
         "chokidar": "~4.0.3",
-        "cpx2": "7.0.1",
+        "cpx2": "8.0.0",
         "css-loader": "~7.1.2",
-        "css-minimizer-webpack-plugin": "^7.0.0",
+        "css-minimizer-webpack-plugin": "^7.0.2",
         "debug": "^4.4.0",
         "deepmerge": "~4.3.1",
         "esbuild-loader": "~4.3.0",
-        "eslint": "~8.57.0",
+        "eslint": "~9.23.0",
         "execa": "~5.1.1",
         "fork-ts-checker-webpack-plugin": "~9.0.2",
-        "glob": "~10.4.2",
+        "glob": "~11.0.1",
         "html-webpack-plugin": "~5.6.3",
         "identity-obj-proxy": "~3.0.0",
         "jest": "~29.7.0",
         "jest-circus": "~29.7.0",
         "jest-environment-jsdom": "^29.7.0",
         "jest-fetch-mock": "~3.0.3",
-        "lerna": "~8.1.9",
+        "json5": "^2.2.3",
+        "lerna": "~8.2.1",
         "less": "~4.2.2",
         "less-loader": "~12.2.0",
         "less-plugin-npm-import": "~2.1.0",
@@ -67,22 +73,22 @@
         "moment-locales-webpack-plugin": "~1.2.0",
         "multimatch": "~5.0.0",
         "portfinder": "~1.0.32",
-        "postcss": "~8.5.2",
-        "prettier": "~3.4.2",
-        "sass": "~1.84.0",
-        "sass-loader": "~16.0.4",
+        "postcss": "~8.5.3",
+        "prettier": "~3.5.3",
+        "sass": "~1.86.0",
+        "sass-loader": "~16.0.5",
         "source-map-loader": "~5.0.0",
         "style-loader": "~4.0.0",
-        "stylelint": "~16.14.1",
+        "stylelint": "~16.17.0",
         "swc-loader": "0.2.6",
-        "terser-webpack-plugin": "^5.3.11",
-        "ts-jest": "29.2.5",
+        "terser-webpack-plugin": "^5.3.14",
+        "ts-jest": "29.2.6",
         "ts-loader": "~9.5.2",
         "ts-node": "~10.9.2",
         "typed-css-modules": "~0.9.1",
-        "typescript": "5.7.3",
+        "typescript": "5.8.2",
         "username": "~5.1.0",
-        "webpack": "~5.97.1",
+        "webpack": "~5.98.0",
         "webpack-assets-manifest": "~5.2.1",
         "webpack-bundle-analyzer": "^4.10.2",
         "webpack-dev-server": "~5.2.0",
@@ -93,14 +99,12 @@
         "xhr-mock": "~2.5.1",
         "yargs": "~17.7.2"
     },
-    "DEVELOPER_NOTES": {
-        "cpx2": "Must use 7.0.1 because later versions require glob 11.x which does not support Node 18"
-    },
+    "DEVELOPER_NOTES": {},
     "publishConfig": {
         "access": "public"
     },
     "cli": {
         "webpack": false
     },
-    "gitHead": "580ace3d4bce0472e985b1d4eb5e98e0be625f1d"
+    "gitHead": "e182cbb85cf66d62f235a9ca172fc04dc705fd0a"
 }

package/src/cli/commands/__tests__/convert-eslint-config.test.ts

@@ -0,0 +1,455 @@
+import execa from 'execa';
+import { fs, vol } from 'memfs';
+import { ConvertEslintConfig } from '../convert-eslint-config';
+
+jest.mock('fs', () => fs);
+jest.mock('execa', () => jest.fn());
+
+describe(`[startup] ${ConvertEslintConfig.name}`, () => {
+    const eslintignoreFile = '.eslintignore';
+    const eslintrcFile = '.eslintrc.json';
+    const outputFile = 'eslint.config.mjs';
+
+    beforeEach(() => {
+        vol.reset();
+        vol.fromJSON({ [eslintrcFile]: JSON.stringify({}) });
+        jest.clearAllMocks();
+    });
+
+    const subject = async () => {
+        await new ConvertEslintConfig().execute();
+        return fs.readFileSync(outputFile, 'utf-8').toString();
+    };
+
+    function itReportsError(message: string | RegExp) {
+        test(`reports error: ${message}`, async () => {
+            jest.spyOn(process.stdout, 'write').mockImplementation(jest.fn()); // suppress error output
+            expect.assertions(1);
+            try {
+                await subject();
+            } catch (error: any) {
+                expect(error.message).toMatch(message);
+            }
+        });
+    }
+
+    function mockConfig(config: Record<string, any>) {
+        vol.fromJSON({ [eslintrcFile]: JSON.stringify(config) });
+    }
+
+    describe(`when ${eslintrcFile} does not exist`, () => {
+        beforeEach(() => fs.rmSync(eslintrcFile));
+
+        itReportsError(`${eslintrcFile} not found`);
+    });
+
+    describe.each(['eslint.config.js', 'eslint.config.cjs', 'eslint.config.mjs'])(
+        'when %s already exists',
+        filename => {
+            beforeEach(() => fs.writeFileSync(filename, ''));
+
+            itReportsError(`flat config "${filename}" already exists`);
+        }
+    );
+
+    interface EmitOptions {
+        config: string;
+        import: { as: string; from: string };
+        name?: string;
+        files?: string[];
+    }
+
+    const extendsTestCases: Record<string, EmitOptions | null> = {
+        '@servicetitan/eslint-config/mono': {
+            import: { from: '@servicetitan/eslint-config/mono', as: 'mono' },
+            config: 'mono',
+        },
+        '@servicetitan/eslint-config/single': {
+            import: { as: 'single', from: '@servicetitan/eslint-config/single' },
+            config: 'single',
+        },
+        'plugin:chai-friendly/recommended': {
+            import: { as: 'pluginChaiFriendly', from: 'eslint-plugin-chai-friendly' },
+            config: 'pluginChaiFriendly.configs.recommendedFlat',
+        },
+        'plugin:cypress/recommended': {
+            import: { as: 'pluginCypress', from: 'eslint-plugin-cypress/flat' },
+            config: 'pluginCypress.configs.recommended',
+        },
+        'plugin:mocha/recommended': {
+            import: { as: 'pluginMocha', from: 'eslint-plugin-mocha' },
+            config: 'pluginMocha.configs.flat.recommended',
+        },
+        'plugin:storybook/recommended': {
+            import: { as: 'storybook', from: 'eslint-plugin-storybook' },
+            config: "storybook.configs['flat/recommended']",
+        },
+        'plugin:testing-library/react': {
+            import: { as: 'pluginTestingLibrary', from: 'eslint-plugin-testing-library' },
+            config: "pluginTestingLibrary.configs['flat/react']",
+            files: ['**/*.test.*'],
+        },
+        'prettier': null,
+    };
+
+    function itEmitsConfig(options: EmitOptions) {
+        test(`configures ${options.name ?? options.import.from}`, async () => {
+            const config = options.files?.length
+                ? `{ files: ${JSON.stringify(options.files)}, ...${options.config}}`
+                : options.config;
+
+            expect(await subject()).toMatchConfig(`
+                    import { defineConfig } from 'eslint/config';
+                    import ${options.import.as} from '${options.import.from}';
+
+                    export default defineConfig([${config}]);
+                `);
+        });
+    }
+
+    function itIgnoresConfig() {
+        test(`ignores config`, async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig } from 'eslint/config';
+
+                export default defineConfig([]);
+            `);
+        });
+    }
+
+    describe.each(Object.entries(extendsTestCases))(
+        'when config extends %s',
+        (name, emitOptions) => {
+            beforeEach(() => mockConfig({ extends: name }));
+
+            if (emitOptions === null) {
+                itIgnoresConfig();
+            } else {
+                itEmitsConfig(emitOptions);
+            }
+        }
+    );
+
+    describe('when "extends" is a string', () => {
+        const config = { extends: '@servicetitan/eslint-config/mono' };
+
+        beforeEach(() => mockConfig(config));
+
+        itEmitsConfig({ name: 'successfully', ...extendsTestCases[config.extends]! });
+    });
+
+    describe('when "extends" config is not recognized', () => {
+        const extendsArray = ['plugin:foo/recommended', 'foobar'];
+
+        beforeEach(() => mockConfig({ extends: extendsArray }));
+
+        test('emits extends in separate block', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig } from 'eslint/config';
+
+                export default defineConfig([
+                    ${JSON.stringify({ extends: extendsArray })}
+                ]);
+            `);
+        });
+    });
+
+    describe('when config contains "ignorePatterns"', () => {
+        const ignorePatterns = ['packages/api/**', ''];
+
+        beforeEach(() => mockConfig({ ignorePatterns }));
+
+        test('configures globalIgnores', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig, globalIgnores } from 'eslint/config';
+
+                export default defineConfig([globalIgnores(
+                    ${JSON.stringify(ignorePatterns.filter(glob => !!glob))}
+                )]);
+            `);
+        });
+
+        describe('when pattern is not a glob', () => {
+            const pattern = '*.scss.d.ts';
+
+            beforeEach(() => mockConfig({ ignorePatterns: [pattern] }));
+
+            test('converts ignore pattern to a glob', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig, globalIgnores } from 'eslint/config';
+
+                    export default defineConfig([globalIgnores(
+                        ${JSON.stringify([`**/${pattern}`])}
+                    )]);
+                `);
+            });
+        });
+
+        describe('when pattern has leading slash', () => {
+            beforeEach(() => mockConfig({ ignorePatterns: ['/foo', '!/foo/bar'] }));
+
+            test('removes leading slash', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig, globalIgnores } from 'eslint/config';
+
+                    export default defineConfig([globalIgnores(
+                        ${JSON.stringify(['foo', '!foo/bar'])}
+                    )]);
+                `);
+            });
+        });
+    });
+
+    describe('when config contains "parserOptions"', () => {
+        const parserOptions = { project: ['packages/*/tsconfig*.json', 'tsconfig*.json'] };
+
+        beforeEach(() => mockConfig({ parserOptions }));
+
+        test('moves parserOptions to languageOptions.parserOptions', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig } from 'eslint/config';
+
+                export default defineConfig([
+                    ${JSON.stringify({ languageOptions: { parserOptions } })}
+                ]);
+            `);
+        });
+    });
+
+    describe('when config contains "overrides"', () => {
+        const overrides = [
+            {
+                files: ['**/*.stories.ts{,x}'],
+                rules: { 'import/no-default-export': 'off' },
+            },
+            {
+                files: ['packages/utils/**/*'],
+                rules: { '@typescript-eslint/no-require-imports': 'off' },
+            },
+        ];
+
+        beforeEach(() => mockConfig({ overrides }));
+
+        test('hoists overrides to top level', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig } from 'eslint/config';
+
+                export default defineConfig([
+                    ${overrides.map(item => JSON.stringify(item)).join()}
+                ]);
+            `);
+        });
+
+        describe('when "files" pattern it not a glob', () => {
+            const pattern = '*.{test,stories}.ts{,x}';
+
+            beforeEach(() => mockConfig({ overrides: [{ files: [pattern] }] }));
+
+            test('converts pattern to a glob', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig } from 'eslint/config';
+
+                    export default defineConfig([
+                        ${JSON.stringify({ files: [`**/${pattern}`] })}
+                    ]);
+                `);
+            });
+        });
+
+        describe('when override contains parserOptions', () => {
+            const parserOptions = {
+                project: ['./apps/**/tsconfig.json', './libraries/**/tsconfig.json'],
+                projectService: true,
+            };
+
+            beforeEach(() => mockConfig({ overrides: [{ parserOptions }] }));
+
+            test('moves parserOptions to language.parserOptions', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig } from 'eslint/config';
+
+                    export default defineConfig([
+                        ${JSON.stringify({ languageOptions: { parserOptions } })}
+                    ]);
+                `);
+            });
+        });
+    });
+
+    describe('when config contains "plugins"', () => {
+        const name = 'foo-bar';
+        const camelizedName = 'fooBar';
+
+        beforeEach(() => mockConfig({ plugins: [name] }));
+
+        itEmitsConfig({
+            name: 'plugin',
+            import: { as: camelizedName, from: `eslint-plugin-${name}` },
+            config: `{ plugins: { '${name}': ${camelizedName} } }`,
+        });
+    });
+
+    describe('when config contains "rules"', () => {
+        const rules = {
+            'no-restricted-imports': [
+                'error',
+                {
+                    paths: [
+                        {
+                            name: 'lodash',
+                            message: 'Use precise path imports from lodash library.',
+                        },
+                    ],
+                },
+            ],
+        };
+
+        beforeEach(() => mockConfig({ rules }));
+
+        test('adds rules to config', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig } from 'eslint/config';
+
+                export default defineConfig([
+                    ${JSON.stringify({ rules })}
+                ]);
+            `);
+        });
+
+        describe('when "rules" contains @typescript-eslint', () => {
+            const tsRules = {
+                '@typescript-eslint/no-base-to-string': 'warn',
+                '@typescript-eslint/no-redundant-type-constituents': 'warn',
+            };
+
+            beforeEach(() => mockConfig({ rules: { ...rules, ...tsRules } }));
+
+            test('moves @typescript-eslint rules to separate config with "files"', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig } from 'eslint/config';
+
+                    export default defineConfig([
+                        ${JSON.stringify({ rules })},
+                        ${JSON.stringify({ files: ['**/*.ts{,x}'], rules: tsRules })}
+                    ]);
+                `);
+            });
+        });
+    });
+
+    describe('when config contains "settings"', () => {
+        const settings = { 'import/resolver': 'typescript' };
+
+        beforeEach(() => mockConfig({ settings }));
+
+        test('copies settings to output', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig } from 'eslint/config';
+
+                export default defineConfig([
+                    ${JSON.stringify({ settings })}
+                ]);
+            `);
+        });
+    });
+
+    describe(`when directory contains ${eslintignoreFile}`, () => {
+        const lines = [
+            'coverage/',
+            '', // NOTE: Test includes blank line
+            'docusaurus/',
+            'packages/**/dist',
+        ];
+
+        beforeEach(() => {
+            vol.fromJSON({ [eslintignoreFile]: lines.join('\n') });
+        });
+
+        test('configures globalIgnores', async () => {
+            expect(await subject()).toMatchConfig(`
+                import { defineConfig, globalIgnores } from 'eslint/config';
+
+                export default defineConfig([
+                    globalIgnores(
+                        ${JSON.stringify(lines.filter(glob => !!glob))}
+                    )
+                ]);
+            `);
+        });
+
+        describe(`when ${eslintignoreFile} is empty`, () => {
+            beforeEach(() => {
+                vol.fromJSON({ [eslintignoreFile]: '\n  \n' });
+            });
+
+            test('omits globalIgnores', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig } from 'eslint/config';
+
+                    export default defineConfig([]);
+                `);
+            });
+        });
+
+        describe('when config contains "ignorePatterns"', () => {
+            const ignorePatterns = ['packages/api/**'];
+
+            beforeEach(() => mockConfig({ ignorePatterns }));
+
+            test('prepends ignorePatterns to globalIgnores', async () => {
+                expect(await subject()).toMatchConfig(`
+                    import { defineConfig, globalIgnores } from 'eslint/config';
+
+                    export default defineConfig([
+                        globalIgnores(
+                            ${JSON.stringify([...ignorePatterns, ...lines].filter(glob => !!glob))}
+                        )
+                    ]);
+                `);
+            });
+        });
+    });
+
+    test('prettifies the output', async () => {
+        await subject();
+
+        expect(execa).toHaveBeenCalledWith('npx', ['prettier', '-w', outputFile], {
+            stdout: 'ignore',
+        });
+    });
+
+    describe('when prettier fails', () => {
+        const exitCode = 123;
+
+        beforeEach(() => {
+            jest.mocked(execa).mockRejectedValue({ exitCode });
+        });
+
+        itReportsError(/prettier failed with exit code/);
+    });
+});
+
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    namespace jest {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        interface Matchers<R, T = {}> {
+            toMatchConfig(value: string): CustomMatcherResult;
+        }
+    }
+}
+
+expect.extend({
+    toMatchConfig(actual: string, value: string) {
+        const pass = actual.replace(/\s+/g, '') === value.replace(/\s+/g, '');
+        const message = pass
+            ? () => `expected:\n${actual}\n\nnot to be:\n${unIndent(value)}`
+            : () => `expected:\n${actual}\n\nto be:\n${unIndent(value)}`;
+        return { message, pass };
+    },
+});
+
+function unIndent(text: string) {
+    const indent = /^( +)/m.exec(text.trim())?.[0].length;
+    return indent ? text.trim().replace(new RegExp(`^ {${indent}}`, 'gm'), '') : text;
+}

package/src/cli/commands/__tests__/lint.test.ts

@@ -68,8 +68,8 @@ describe(`[startup] ${Lint.name}`, () => {
         });
     }
 
-    describe('when instructed to isolate packages', () => {
-        beforeEach(() => (args.isolated = true));
+    describe('when instructed to lint packages in parallel', () => {
+        beforeEach(() => (args.parallel = true));
 
         itRunsLernaExec();