only check / annotate plugin-enabled files

Author: ycmjason

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ts-migrating",
-	"version": "1.1.0",
+	"version": "1.2.0",
 	"description": "Progressively Upgrade `tsconfigs.json`",
 	"author": "Jason Yu <me@ycmjason.com>",
 	"license": "MIT",
@@ -41,13 +41,14 @@
 		"biome.config.json"
 	],
 	"scripts": {
-		"test": "vitest run",
 		"build": "tsup src/cli/main.ts src/api/mod.ts src/plugin/mod.ts --sourcemap --format esm,cjs --clean --cjsInterop --splitting",
 		"build:watch": "pnpm build --watch",
 		"check": "pnpm check:lint && pnpm check:type && pnpm test",
-		"check:type": "tsc",
 		"check:lint": "biome check .",
-		"check:lint:fix": "pnpm check:lint --write"
+		"check:lint:fix": "pnpm check:lint --write",
+		"check:type": "tsc",
+		"test": "vitest run",
+		"test:watch": "vitest"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^1.9.4",

src/api/getSemanticDiagnostics.test.ts

@@ -163,48 +163,88 @@ enum FRUITS {
   `);
 });
 
-it('should ignore ts files without any tsconfig that includes them', async () => {
-  const tmpDir = await setupTmpDir({
-    './tsconfig.json': JSON.stringify({
-      compilerOptions: {
-        target: 'ES2020',
-        module: 'commonjs',
-        outDir: './dist',
-        rootDir: './src',
-        strict: false,
-        esModuleInterop: true,
-        forceConsistentCasingInFileNames: true,
-        plugins: [
-          {
-            // ts will look up from the node_modules that the ts server is running from. e.g. ../../node_modules/ts-migrating
-            // this is why we add `ts-migrating` as dev dependency of itself.
-            name: 'ts-migrating',
-            compilerOptions: {
-              erasableSyntaxOnly: true,
+describe('ignoring files', () => {
+  it('should ignore ts files without any tsconfig that includes them', async () => {
+    const tmpDir = await setupTmpDir({
+      './tsconfig.json': JSON.stringify({
+        compilerOptions: {
+          target: 'ES2020',
+          module: 'commonjs',
+          outDir: './dist',
+          rootDir: './src',
+          strict: false,
+          esModuleInterop: true,
+          forceConsistentCasingInFileNames: true,
+          plugins: [
+            {
+              // ts will look up from the node_modules that the ts server is running from. e.g. ../../node_modules/ts-migrating
+              // this is why we add `ts-migrating` as dev dependency of itself.
+              name: 'ts-migrating',
+              compilerOptions: {
+                erasableSyntaxOnly: true,
+              },
             },
-          },
+          ],
+          skipLibCheck: true,
+        },
+        include: ['.'],
+        exclude: [
+          'node_modules',
+          'dist',
+          // excluding `ignored` directory!!!
+          'ignored',
         ],
-        skipLibCheck: true,
-      },
-      include: ['.'],
-      exclude: [
-        'node_modules',
-        'dist',
-        // excluding `ignored` directory!!!
-        'ignored',
-      ],
-    }),
-    './src/index.ts': `// @ts-migrating
+      }),
+      './src/index.ts': `// @ts-migrating
 enum FRUITS {
   APPLE,
   BANANA,
   // @ts-migrating
   KIWI,
 }
 `,
-    './ignored/index.ts': 'laksdjflkj oiwejflaskdjf',
+      './ignored/index.ts': 'laksdjflkj oiwejflaskdjf',
+    });
+
+    const diagnostics = getSemanticDiagnosticsForFile(join(tmpDir, 'ignored/index.ts'));
+    expect(diagnostics).toHaveLength(0);
   });
 
-  const diagnostics = getSemanticDiagnosticsForFile(join(tmpDir, 'ignored/index.ts'));
-  expect(diagnostics).toHaveLength(0);
+  it('should ignore projects without `ts-migrating` plugin', async () => {
+    const tmpDir = await setupTmpDir({
+      './tsconfig.json': JSON.stringify({
+        compilerOptions: {
+          target: 'ES2020',
+          module: 'commonjs',
+          outDir: './dist',
+          rootDir: './src',
+          strict: false,
+          esModuleInterop: true,
+          forceConsistentCasingInFileNames: true,
+          plugins: [
+            // no plugin!
+          ],
+          skipLibCheck: true,
+        },
+        include: ['.'],
+        exclude: [
+          'node_modules',
+          'dist',
+          // excluding `ignored` directory!!!
+          'ignored',
+        ],
+      }),
+      './src/index.ts': `// @ts-migrating
+enum FRUITS {
+  APPLE,
+  BANANA,
+  // @ts-migrating
+  KIWI,
+}
+`,
+    });
+
+    const diagnostics = getSemanticDiagnosticsForFile(join(tmpDir, 'src/index.ts'));
+    expect(diagnostics).toHaveLength(0);
+  });
 });

src/api/getSemanticDiagnostics.ts

@@ -1,17 +1,18 @@
 import path from 'node:path';
 import ts from 'typescript/lib/tsserverlibrary';
-import { createProjectService } from './typescript/createProjectService';
+import { isPluginEnabled } from './getTSInfoForFile';
+import { projectService } from './typescript/projectService';
 
-const PROJECT_KIND_CONFIGURED = 1;
-const projectService = createProjectService();
 /**
- * Returns the {@link Diagnostic} of a given file. This function only check for files that has a tsconfig that includes them.
+ * Returns a list of {@link ts.Diagnostic} of a given file.
+ *
+ * This function returns `[]` if the tsconfig for the file does not list `ts-migrating` in the plugin.
  */
 export function getSemanticDiagnosticsForFile(targetFile: string): ts.Diagnostic[] {
   const file = ts.server.toNormalizedPath(path.resolve(process.cwd(), targetFile));
 
   const projects = [...projectService.configuredProjects.values()];
-  if (!projects.some(project => project.containsFile(file))) {
+  if (projects.every(project => !project.containsFile(file))) {
     // clear existing projects to avoid running out of memory
     for (const project of projects) {
       project.close();
@@ -21,16 +22,16 @@ export function getSemanticDiagnosticsForFile(targetFile: string): ts.Diagnostic
 
   projectService.openClientFile(file);
 
-  const project = projectService.getDefaultProjectForFile(file, false);
-
-  if (project?.projectKind !== PROJECT_KIND_CONFIGURED) {
-    return [];
-  }
-
+  const project = projectService.getDefaultProjectForFile(file, true);
   if (!project) {
     throw new Error('Expect project to exist');
   }
 
+  if (!isPluginEnabled(project.getCompilerOptions())) {
+    // tsconfig that this file uses does not have `ts-migrating` declared in the plugin.
+    return [];
+  }
+
   const diagnostics = project.getLanguageService().getSemanticDiagnostics(file);
 
   projectService.closeClientFile(file);

src/api/getTSInfoForFile.ts

@@ -0,0 +1,29 @@
+import path from 'node:path';
+import ts from 'typescript/lib/tsserverlibrary';
+import { getPluginsFromCompilerOptions } from './typescript/getPluginsFromCompilerOptions';
+import { projectService } from './typescript/projectService';
+
+type TSInfo = {
+  tsconfigPath: string;
+  pluginEnabled: boolean;
+};
+
+export const getTSInfoForFile = (filePath: string): TSInfo => {
+  const file = ts.server.toNormalizedPath(path.resolve(process.cwd(), filePath));
+  projectService.openClientFile(file);
+
+  const tsInfo = (() => {
+    const project = projectService.getDefaultProjectForFile(file, true);
+    const compilerOptions = project?.getCompilerOptions() ?? {};
+    return {
+      tsconfigPath: (compilerOptions.configFilePath as string) ?? '[not found]',
+      pluginEnabled: isPluginEnabled(compilerOptions),
+    };
+  })();
+
+  projectService.closeClientFile(file);
+  return tsInfo;
+};
+
+export const isPluginEnabled = (compilerOptions: ts.CompilerOptions): boolean =>
+  getPluginsFromCompilerOptions(compilerOptions).some(({ name }) => name === 'ts-migrating');

src/api/mod.ts

@@ -1,4 +1,3 @@
-import { getSemanticDiagnosticsForFile } from './getSemanticDiagnostics';
-import { isPluginDiagnostic } from './isPluginDiagnostic';
-
-export { getSemanticDiagnosticsForFile, isPluginDiagnostic };
+export { getSemanticDiagnosticsForFile } from './getSemanticDiagnostics';
+export { getTSInfoForFile } from './getTSInfoForFile';
+export { isPluginDiagnostic } from './isPluginDiagnostic';

src/api/typescript/createProjectService.ts

@@ -0,0 +1,7 @@
+import type ts from 'typescript/lib/tsserverlibrary';
+
+export const getPluginsFromCompilerOptions = (
+  compilerOptions: ts.CompilerOptions,
+): ts.PluginImport[] => {
+  return (compilerOptions.plugins ?? []) as ts.PluginImport[];
+};

src/api/typescript/getPluginsFromCompilerOptions.ts

@@ -0,0 +1,30 @@
+import ts from 'typescript/lib/tsserverlibrary';
+
+export const projectService = new ts.server.ProjectService({
+  host: {
+    ...ts.sys,
+    setTimeout,
+    clearTimeout,
+    setImmediate,
+    clearImmediate,
+    watchDirectory: () => ({ close: () => {} }),
+    watchFile: () => ({ close: () => {} }),
+  },
+  session: undefined,
+  logger: {
+    close: () => {},
+    hasLevel: () => false,
+    loggingEnabled: () => false,
+    perftrc: () => {},
+    info: () => {},
+    startGroup: () => {},
+    endGroup: () => {},
+    msg: () => {},
+    getLogFileName: () => undefined,
+  },
+  cancellationToken: ts.server.nullCancellationToken,
+  useSingleInferredProject: true,
+  useInferredProjectPerProjectRoot: true,
+  typingsInstaller: ts.server.nullTypingsInstaller,
+  allowLocalPluginLoads: true,
+});

src/api/typescript/projectService.ts

@@ -5,17 +5,10 @@ import { getLineNumberGivenPosition } from '../../api/utils/getLineNumberGivenPo
 import { DIRECTIVE } from '../../plugin/constants/DIRECTIVE';
 import { UNUSED_DIRECTIVE_DIAGNOSTIC_CODE } from '../../plugin/constants/UNUSED_DIRECTIVE_DIAGNOSTIC_CODE';
 import { ANNOTATE_WARNING } from '../constants/annotate-warning';
-import { expandTSFilePaths } from '../expandTSFilePaths';
+import { getPluginEnabledTSFilePaths } from '../ops/getPluginEnabledTSFilePaths';
 
 export const annotate = async ({ verbose }: { verbose: boolean }, ...inputPaths: string[]) => {
-  const files = expandTSFilePaths(inputPaths);
-  console.log(
-    `🔍 Annotating ${files.length} file${files.length === 1 ? '' : 's'}...${!verbose ? ' (use --verbose to see the list)' : ''}`,
-  );
-  if (verbose) {
-    console.log('Files to annotate:');
-    console.log(files.map(file => `  • ${file}`).join('\n'));
-  }
+  const files = getPluginEnabledTSFilePaths(inputPaths, { verbose });
 
   console.log(ANNOTATE_WARNING);