@typescript-eslint/typescript-estree 8.72.1-alpha.1 → 8.72.1-alpha.10

package/dist/create-program/useProvidedPrograms.d.ts

@@ -7,5 +7,6 @@ export declare function useProvidedPrograms(programInstances: Iterable<ts.Progra
  *
  * @param configFile the path to the tsconfig.json file, relative to `projectDirectory`
  * @param projectDirectory the project directory to use as the CWD, defaults to `process.cwd()`
+ * @param jsDocParsingMode how much JSDoc to parse, defaults to TypeScript's default of parsing all JSDoc
  */
-export declare function createProgramFromConfigFile(configFile: string, projectDirectory?: string): ts.Program;
+export declare function createProgramFromConfigFile(configFile: string, projectDirectory?: string, jsDocParsingMode?: ts.JSDocParsingMode): ts.Program;

package/dist/create-program/useProvidedPrograms.js

@@ -73,10 +73,12 @@ function useProvidedPrograms(programInstances, parseSettings) {
  *
  * @param configFile the path to the tsconfig.json file, relative to `projectDirectory`
  * @param projectDirectory the project directory to use as the CWD, defaults to `process.cwd()`
+ * @param jsDocParsingMode how much JSDoc to parse, defaults to TypeScript's default of parsing all JSDoc
  */
-function createProgramFromConfigFile(configFile, projectDirectory) {
+function createProgramFromConfigFile(configFile, projectDirectory, jsDocParsingMode) {
     const parsed = (0, tsconfig_utils_1.getParsedConfigFile)(ts, configFile, projectDirectory);
     const host = ts.createCompilerHost(parsed.options, true);
+    host.jsDocParsingMode = jsDocParsingMode;
     return ts.createProgram(parsed.fileNames, parsed.options, host);
 }
 //# sourceMappingURL=useProvidedPrograms.js.map

package/dist/parseSettings/getProjectConfigFiles.d.ts

@@ -9,4 +9,4 @@ import type { ParseSettings } from './index';
  * cache file checks for rapid subsequent calls to fs.existsSync. See discussion
  * in https://github.com/typescript-eslint/typescript-eslint/issues/101.
  */
-export declare function getProjectConfigFiles(parseSettings: Pick<ParseSettings, 'filePath' | 'tsconfigMatchCache' | 'tsconfigRootDir'>, project: TSESTreeOptions['project']): string[] | null;
+export declare function getProjectConfigFiles(parseSettings: Pick<ParseSettings, 'filePath' | 'tsconfigMatchCache' | 'tsconfigRootDir'>, project: TSESTreeOptions['project'], configFileNames?: readonly string[]): string[] | null;

package/dist/parseSettings/getProjectConfigFiles.js

@@ -50,7 +50,7 @@ const log = (0, debug_1.default)('typescript-eslint:typescript-estree:parseSetti
  * cache file checks for rapid subsequent calls to fs.existsSync. See discussion
  * in https://github.com/typescript-eslint/typescript-eslint/issues/101.
  */
-function getProjectConfigFiles(parseSettings, project) {
+function getProjectConfigFiles(parseSettings, project, configFileNames = ['tsconfig.json']) {
     if (project !== true) {
         if (project == null || project === false) {
             return null;
@@ -65,9 +65,10 @@ function getProjectConfigFiles(parseSettings, project) {
     const checkedDirectories = [directory];
     do {
         log('Checking tsconfig.json path: %s', directory);
-        const tsconfigPath = path.join(directory, 'tsconfig.json');
         const cached = parseSettings.tsconfigMatchCache.get(directory) ??
-            (fs.existsSync(tsconfigPath) && tsconfigPath);
+            configFileNames
+                .map(configFileName => path.join(directory, configFileName))
+                .find(configFilePath => fs.existsSync(configFilePath));
         if (cached) {
             for (const directory of checkedDirectories) {
                 parseSettings.tsconfigMatchCache.set(directory, cached);

package/dist/parser.d.ts

@@ -1,4 +1,4 @@
-import type * as ts from 'typescript';
+import * as ts from 'typescript';
 import type { ParserServices, TSESTreeOptions } from './parser-options';
 import type { TSESTree } from './ts-estree';
 export declare function clearProgramCache(): void;

package/dist/parser.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -9,15 +42,18 @@ exports.parse = parse;
 exports.clearParseAndGenerateServicesCalls = clearParseAndGenerateServicesCalls;
 exports.parseAndGenerateServices = parseAndGenerateServices;
 const debug_1 = __importDefault(require("debug"));
+const ts = __importStar(require("typescript"));
 const ast_converter_1 = require("./ast-converter");
 const convert_1 = require("./convert");
 const createIsolatedProgram_1 = require("./create-program/createIsolatedProgram");
 const createProjectProgram_1 = require("./create-program/createProjectProgram");
 const createSourceFile_1 = require("./create-program/createSourceFile");
 const getWatchProgramsForProjects_1 = require("./create-program/getWatchProgramsForProjects");
+const shared_1 = require("./create-program/shared");
 const useProvidedPrograms_1 = require("./create-program/useProvidedPrograms");
 const createParserServices_1 = require("./createParserServices");
 const createParseSettings_1 = require("./parseSettings/createParseSettings");
+const getProjectConfigFiles_1 = require("./parseSettings/getProjectConfigFiles");
 const semantic_or_syntactic_errors_1 = require("./semantic-or-syntactic-errors");
 const useProgramFromProjectService_1 = require("./useProgramFromProjectService");
 const log = (0, debug_1.default)('typescript-eslint:typescript-estree:parser');
@@ -27,8 +63,71 @@ const log = (0, debug_1.default)('typescript-eslint:typescript-estree:parser');
  * clearProgramCache() is only intended to be used in testing to ensure the parser is clean between tests.
  */
 const existingPrograms = new Map();
+/**
+ * Tsconfigs with project references, which single runs leave to the project service.
+ */
+const configFilesWithReferences = new Set();
+/**
+ * Directories' config files as the project service finds them, which unlike
+ * `parserOptions.project: true` includes jsconfig.json files.
+ */
+const projectServiceConfigFileMatches = new Map();
 function clearProgramCache() {
     existingPrograms.clear();
+    configFilesWithReferences.clear();
+    projectServiceConfigFileMatches.clear();
+}
+/**
+ * Files don't change on disk during a single run, so the project service's
+ * bookkeeping for each opened file isn't needed. Instead, each file can come
+ * from a Program created once for its tsconfig, the same as with
+ * `parserOptions.project`. Anything less straightforward is left to the
+ * project service: default project files, extra file extensions, project
+ * references, and files not found in their tsconfig's Program.
+ */
+function useSingleRunProgramForProjectService(parseSettings) {
+    if (parseSettings.extraFileExtensions.length ||
+        parseSettings.projectService?.allowDefaultProject?.length) {
+        return undefined;
+    }
+    let configFile;
+    try {
+        [configFile] =
+            (0, getProjectConfigFiles_1.getProjectConfigFiles)({
+                ...parseSettings,
+                tsconfigMatchCache: projectServiceConfigFileMatches,
+            }, true, ['tsconfig.json', 'jsconfig.json']) ?? [];
+    }
+    catch {
+        return undefined;
+    }
+    if (!configFile) {
+        return undefined;
+    }
+    const canonicalConfigFile = (0, shared_1.getCanonicalFileName)(configFile);
+    if (configFilesWithReferences.has(canonicalConfigFile)) {
+        return undefined;
+    }
+    let program = existingPrograms.get(canonicalConfigFile);
+    if (!program) {
+        // The project service loads referenced projects from their source files,
+        // while a Program would use their built declaration files.
+        // References aren't inherited through extends, so the raw file is enough.
+        const rawConfig = ts.readConfigFile(configFile, ts.sys.readFile).config;
+        if (rawConfig?.references?.length) {
+            configFilesWithReferences.add(canonicalConfigFile);
+            return undefined;
+        }
+        log('Creating single-run Program for project service: %s', configFile);
+        program = (0, useProvidedPrograms_1.createProgramFromConfigFile)(configFile, undefined, parseSettings.jsDocParsingMode);
+        existingPrograms.set(canonicalConfigFile, program);
+    }
+    const astAndProgram = (0, shared_1.getAstFromProgram)(program, parseSettings.filePath);
+    if (astAndProgram?.ast.text !== parseSettings.codeFullText) {
+        return undefined;
+    }
+    astAndProgram.program.getTypeChecker(); // ensure parent pointers are set in source files
+    return astAndProgram;
 }
 const defaultProjectMatchedFiles = new Set();
 function clearDefaultProjectMatchedFiles() {
@@ -41,6 +140,12 @@ function clearDefaultProjectMatchedFiles() {
  */
 function getProgramAndAST(parseSettings, hasFullTypeInformation) {
     if (parseSettings.projectService) {
+        if (parseSettings.singleRun && hasFullTypeInformation) {
+            const fromSingleRunProgram = useSingleRunProgramForProjectService(parseSettings);
+            if (fromSingleRunProgram) {
+                return fromSingleRunProgram;
+            }
+        }
         const fromProjectService = (0, useProgramFromProjectService_1.useProgramFromProjectService)(parseSettings.projectService, parseSettings, hasFullTypeInformation, defaultProjectMatchedFiles);
         if (fromProjectService) {
             return fromProjectService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "8.72.1-alpha.1",
+  "version": "8.72.1-alpha.10",
   "description": "A parser that converts TypeScript source code into an ESTree compatible form",
   "files": [
     "dist",
@@ -43,10 +43,10 @@
     "syntax"
   ],
   "dependencies": {
-    "@typescript-eslint/project-service": "8.72.1-alpha.1",
-    "@typescript-eslint/tsconfig-utils": "8.72.1-alpha.1",
-    "@typescript-eslint/types": "8.72.1-alpha.1",
-    "@typescript-eslint/visitor-keys": "8.72.1-alpha.1",
+    "@typescript-eslint/project-service": "8.72.1-alpha.10",
+    "@typescript-eslint/tsconfig-utils": "8.72.1-alpha.10",
+    "@typescript-eslint/types": "8.72.1-alpha.10",
+    "@typescript-eslint/visitor-keys": "8.72.1-alpha.10",
     "debug": "^4.4.3",
     "minimatch": "^10.2.2",
     "semver": "^7.7.3",