Jul 28, 2024 · Jun 8, 2024 · Jun 8, 2024 · Jun 8, 2024 · Jun 8, 2024 · Jun 8, 2024
diff --git a/packages/typescript-estree/src/create-program/createProjectService.ts b/packages/typescript-estree/src/create-program/createProjectService.ts
 /* eslint-disable @typescript-eslint/no-empty-function -- for TypeScript APIs*/
 importos from 'node:os';
 importpath from 'node:path';

 import debug from 'debug';
 import type * as ts from 'typescript/lib/tsserverlibrary';

 import type { ProjectServiceOptions } from '../parser-options';
 import { getParsedConfigFile } from './getParsedConfigFile';
 import { validateDefaultProjectForFilesGlob } from './validateDefaultProjectForFilesGlob';

 const DEFAULT_PROJECT_MATCHED_FILES_THRESHOLD = 8;

  if (options.defaultProject) {
    log('Enabling default project: %s', options.defaultProject);
    letconfigRead;
    letconfigFile: ts.ParsedCommandLine;

    try {
      configRead = tsserver.readConfigFile(
      configFile = getParsedConfigFile(
        tsserver,
        options.defaultProject,
 system.readFile,
 path.dirname(options.defaultProject),
      );
    } catch (error) {
      throw new Error(
        `Could not parse default project '${options.defaultProject}': ${(error as Error).message}`,
      );
    }

    if (configRead.error) {
      throw new Error(
        `Could not read default project '${options.defaultProject}': ${tsserver.formatDiagnostic(
          configRead.error,
          {
            getCurrentDirectory: system.getCurrentDirectory,
            getCanonicalFileName: fileName => fileName,
            getNewLine: () => os.EOL,
          },
        )}`,
        `Could not read default project '${options.defaultProject}': ${(error as Error).message}`,
      );
    }

    service.setCompilerOptionsForInferredProjects(
 (
  configRead.config as {
    compilerOptions: ts.server.protocol.InferredProjectCompilerOptions;
  }
 ).compilerOptions,
 // NOTE: The inferred projects API is not intended for source files when a tsconfig
 // exists.  There is no API that generates an InferredProjectCompilerOptions suggesting
 // it is meant for hard coded options passed in. Hard asserting as a work around.
 // See https://github.com/microsoft/TypeScript/blob/27bcd4cb5a98bce46c9cdd749752703ead021a4b/src/server/protocol.ts#L1904
 configFile.options as ts.server.protocol.InferredProjectCompilerOptions,
    );
  }

diff --git a/packages/typescript-estree/src/create-program/getParsedConfigFile.ts b/packages/typescript-estree/src/create-program/getParsedConfigFile.ts
 import * as fs from 'fs';
 import * as path from 'path';
 import type * as ts from 'typescript/lib/tsserverlibrary';

 import { CORE_COMPILER_OPTIONS } from './shared';

 /**
 * Utility offered by parser to help consumers parse a config file.
 *
 * @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()`
 */
 function getParsedConfigFile(
  tsserver: typeof ts,
  configFile: string,
  projectDirectory?: string,
 ): ts.ParsedCommandLine {
  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
  if (tsserver.sys === undefined) {
    throw new Error(
      '`getParsedConfigFile` is only supported in a Node-like environment.',
    );
  }

  const parsed = tsserver.getParsedCommandLineOfConfigFile(
    configFile,
    CORE_COMPILER_OPTIONS,
    {
      onUnRecoverableConfigFileDiagnostic: diag => {
        throw new Error(formatDiagnostics([diag])); // ensures that `parsed` is defined.
      },
      fileExists: fs.existsSync,
      getCurrentDirectory,
      readDirectory: tsserver.sys.readDirectory,
      readFile: file => fs.readFileSync(file, 'utf-8'),
      useCaseSensitiveFileNames: tsserver.sys.useCaseSensitiveFileNames,
    },
  );

  if (parsed?.errors.length) {
    throw new Error(formatDiagnostics(parsed.errors));
  }

  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
  return parsed!;

  function getCurrentDirectory(): string {
    return projectDirectory ? path.resolve(projectDirectory) : process.cwd();
  }

  function formatDiagnostics(diagnostics: ts.Diagnostic[]): string | undefined {
    return tsserver.formatDiagnostics(diagnostics, {
      getCanonicalFileName: f => f,
      getCurrentDirectory,
      getNewLine: () => '\n',
    });
  }
 }

 export { getParsedConfigFile };
diff --git a/packages/typescript-estree/src/create-program/useProvidedPrograms.ts b/packages/typescript-estree/src/create-program/useProvidedPrograms.ts
 import debug from 'debug';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as ts from 'typescript';

 import type { ParseSettings } from '../parseSettings';
 import { getParsedConfigFile } from './getParsedConfigFile';
 import type { ASTAndDefiniteProgram } from './shared';
 import {CORE_COMPILER_OPTIONS,getAstFromProgram } from './shared';
 import { getAstFromProgram } from './shared';

 const log = debug('typescript-eslint:typescript-estree:useProvidedProgram');

  configFile: string,
  projectDirectory?: string,
 ): ts.Program {
  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
  if (ts.sys === undefined) {
    throw new Error(
      '`createProgramFromConfigFile` is only supported in a Node-like environment.',
    );
  }

  const parsed = ts.getParsedCommandLineOfConfigFile(
    configFile,
    CORE_COMPILER_OPTIONS,
    {
      onUnRecoverableConfigFileDiagnostic: diag => {
        throw new Error(formatDiagnostics([diag])); // ensures that `parsed` is defined.
      },
      fileExists: fs.existsSync,
      getCurrentDirectory: () =>
        (projectDirectory && path.resolve(projectDirectory)) || process.cwd(),
      readDirectory: ts.sys.readDirectory,
      readFile: file => fs.readFileSync(file, 'utf-8'),
      useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
    },
  );
  // parsed is not undefined, since we throw on failure.
  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
  const result = parsed!;
  if (result.errors.length) {
    throw new Error(formatDiagnostics(result.errors));
  }
  const host = ts.createCompilerHost(result.options, true);
  return ts.createProgram(result.fileNames, result.options, host);
 }

 function formatDiagnostics(diagnostics: ts.Diagnostic[]): string | undefined {
  return ts.formatDiagnostics(diagnostics, {
    getCanonicalFileName: f => f,
    getCurrentDirectory: process.cwd,
    getNewLine: () => '\n',
  });
  const parsed = getParsedConfigFile(ts, configFile, projectDirectory);
  const host = ts.createCompilerHost(parsed.options, true);
  return ts.createProgram(parsed.fileNames, parsed.options, host);
 }

 export { useProvidedPrograms, createProgramFromConfigFile };
diff --git a/packages/typescript-estree/tests/lib/createProjectService.test.ts b/packages/typescript-estree/tests/lib/createProjectService.test.ts
 import debug from 'debug';
 import * as ts from 'typescript';

 import { createProjectService } from '../../src/create-program/createProjectService';

 const mockReadConfigFile = jest.fn();
 const mockGetParsedConfigFile = jest.fn();
 const mockSetCompilerOptionsForInferredProjects = jest.fn();
 const mockSetHostConfiguration = jest.fn();

 jest.mock('../../src/create-program/getParsedConfigFile', () => ({
  getParsedConfigFile: mockGetParsedConfigFile,
 }));

 jest.mock('typescript/lib/tsserverlibrary', () => ({
  ...jest.requireActual('typescript/lib/tsserverlibrary'),
  readConfigFile: mockReadConfigFile,
  server: {
    ...jest.requireActual('typescript/lib/tsserverlibrary').server,
    ProjectService: class {
  },
 }));

 const {
  createProjectService,
  // eslint-disable-next-line @typescript-eslint/no-require-imports
 } = require('../../src/create-program/createProjectService');

 describe('createProjectService', () => {
  afterEach(() => {
    jest.resetAllMocks();
    expect(settings.allowDefaultProject).toBeUndefined();
  });

  it('throws an error when options.defaultProject is set and readConfigFile returns an error', () => {
    mockReadConfigFile.mockReturnValue({
      error: {
        category: ts.DiagnosticCategory.Error,
        code: 1234,
        file: ts.createSourceFile('./tsconfig.json', '', {
          languageVersion: ts.ScriptTarget.Latest,
        }),
        start: 0,
        length: 0,
        messageText: 'Oh no!',
      } satisfies ts.Diagnostic,
  it('throws an error when options.defaultProject is set and getParsedConfigFile throws a diagnostic error', () => {
    mockGetParsedConfigFile.mockImplementation(() => {
      throw new Error('./tsconfig.json(1,1): error TS1234: Oh no!');
    });

    expect(() =>
    );
  });

  it('throws an error when options.defaultProject is set and readConfigFile throws an error', () => {
    mockReadConfigFile.mockImplementation(() => {
      throw new Error('Oh no!');
  it('throws an error when options.defaultProject is set and getParsedConfigFile throws an environment error', () => {
    mockGetParsedConfigFile.mockImplementation(() => {
      throw new Error(
        '`getParsedConfigFile` is only supported in a Node-like environment.',
      );
    });

    expect(() =>
        },
        undefined,
      ),
    ).toThrow("Could not parse default project './tsconfig.json': Oh no!");
    ).toThrow(
      "Could not read default project './tsconfig.json': `getParsedConfigFile` is only supported in a Node-like environment.",
    );
  });

  it('uses the default projects compiler options when options.defaultProject is set andreadConfigFile succeeds', () => {
  it('uses the default projects compiler options when options.defaultProject is set andgetParsedConfigFile succeeds', () => {
    const compilerOptions = { strict: true };
 mockReadConfigFile.mockReturnValue({config: {compilerOptions } });
 mockGetParsedConfigFile.mockReturnValue({options:compilerOptions });

    const { service } = createProjectService(
      {
diff --git a/packages/typescript-estree/tests/lib/getParsedConfigFile.test.ts b/packages/typescript-estree/tests/lib/getParsedConfigFile.test.ts
 import path from 'node:path';

 import * as ts from 'typescript';

 import { getParsedConfigFile } from '../../src/create-program/getParsedConfigFile';

 const mockGetParsedCommandLineOfConfigFile = jest.fn();

 const mockTsserver: typeof ts = {
  sys: {} as ts.System,
  formatDiagnostics: ts.formatDiagnostics,
  getParsedCommandLineOfConfigFile: mockGetParsedCommandLineOfConfigFile,
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
 } as any;

 describe('getParsedConfigFile', () => {
  afterEach(() => {
    jest.resetAllMocks();
  });

  it('throws an error when tsserver.sys is undefined', () => {
    expect(() =>
      getParsedConfigFile({} as typeof ts, './tsconfig.json'),
    ).toThrow(
      '`getParsedConfigFile` is only supported in a Node-like environment.',
    );
  });

  it('uses the cwd as the default project directory', () => {
    getParsedConfigFile(mockTsserver, './tsconfig.json');
    expect(mockGetParsedCommandLineOfConfigFile).toHaveBeenCalledTimes(1);
    const [_configFileName, _optionsToExtend, host] =
      mockGetParsedCommandLineOfConfigFile.mock.calls[0];
    expect(host.getCurrentDirectory()).toBe(process.cwd());
  });

  it('resolves a relative project directory when passed', () => {
    getParsedConfigFile(
      mockTsserver,
      './tsconfig.json',
      path.relative('./', path.dirname(__filename)),
    );
    expect(mockGetParsedCommandLineOfConfigFile).toHaveBeenCalledTimes(1);
    const [_configFileName, _optionsToExtend, host] =
      mockGetParsedCommandLineOfConfigFile.mock.calls[0];
    expect(host.getCurrentDirectory()).toBe(path.dirname(__filename));
  });

  it('resolves an absolute project directory when passed', () => {
    getParsedConfigFile(mockTsserver, './tsconfig.json', __dirname);
    expect(mockGetParsedCommandLineOfConfigFile).toHaveBeenCalledTimes(1);
    const [_configFileName, _optionsToExtend, host] =
      mockGetParsedCommandLineOfConfigFile.mock.calls[0];
    expect(host.getCurrentDirectory()).toBe(__dirname);
  });

  it('throws a diagnostic error when getParsedCommandLineOfConfigFile returns an error', () => {
    mockGetParsedCommandLineOfConfigFile.mockReturnValue({
      errors: [
        {
          category: ts.DiagnosticCategory.Error,
          code: 1234,
          file: ts.createSourceFile('./tsconfig.json', '', {
            languageVersion: ts.ScriptTarget.Latest,
          }),
          start: 0,
          length: 0,
          messageText: 'Oh no!',
        },
      ] satisfies ts.Diagnostic[],
    });
    expect(() => getParsedConfigFile(mockTsserver, './tsconfig.json')).toThrow(
      /.+ error TS1234: Oh no!/,
    );
  });

  it('throws a diagnostic error when getParsedCommandLineOfConfigFile throws an error', () => {
    mockGetParsedCommandLineOfConfigFile.mockImplementation(
      (
        ...[_configFileName, _optionsToExtend, host]: Parameters<
          typeof ts.getParsedCommandLineOfConfigFile
        >
      ) => {
        return host.onUnRecoverableConfigFileDiagnostic({
          category: ts.DiagnosticCategory.Error,
          code: 1234,
          file: ts.createSourceFile('./tsconfig.json', '', {
            languageVersion: ts.ScriptTarget.Latest,
          }),
          start: 0,
          length: 0,
          messageText: 'Oh no!',
        } satisfies ts.Diagnostic);
      },
    );
    expect(() => getParsedConfigFile(mockTsserver, './tsconfig.json')).toThrow(
      /.+ error TS1234: Oh no!/,
    );
  });

  it('uses compiler options when parsing a config file succeeds', () => {
    const parsedConfigFile = {
      options: { strict: true },
      raw: { compilerOptions: { strict: true } },
      errors: [],
    };
    mockGetParsedCommandLineOfConfigFile.mockReturnValue(parsedConfigFile);
    expect(getParsedConfigFile(mockTsserver, 'tsconfig.json')).toEqual(
      expect.objectContaining(parsedConfigFile),
    );
  });
 });
Original file line number	Diff line number	Diff line change
		@@ -1,10 +1,11 @@
		/* eslint-disable @typescript-eslint/no-empty-function -- for TypeScript APIs*/
		importos from 'node:os';
		importpath from 'node:path';

		import debug from 'debug';
		import type * as ts from 'typescript/lib/tsserverlibrary';

		import type { ProjectServiceOptions } from '../parser-options';
		import { getParsedConfigFile } from './getParsedConfigFile';
		import { validateDefaultProjectForFilesGlob } from './validateDefaultProjectForFilesGlob';

		const DEFAULT_PROJECT_MATCHED_FILES_THRESHOLD = 8;
Expand DownExpand Up		@@ -123,38 +124,26 @@ export function createProjectService(

		if (options.defaultProject) {
		log('Enabling default project: %s', options.defaultProject);
		letconfigRead;
		letconfigFile: ts.ParsedCommandLine;

		try {
		configRead = tsserver.readConfigFile(
		configFile = getParsedConfigFile(
		tsserver,
		options.defaultProject,
		system.readFile,
		path.dirname(options.defaultProject),
		);
		} catch (error) {
		throw new Error(
		`Could not parse default project '${options.defaultProject}': ${(error as Error).message}`,
		);
		}

		if (configRead.error) {
		throw new Error(
		`Could not read default project '${options.defaultProject}': ${tsserver.formatDiagnostic(
		configRead.error,
		{
		getCurrentDirectory: system.getCurrentDirectory,
		getCanonicalFileName: fileName => fileName,
		getNewLine: () => os.EOL,
		},
		)}`,
		`Could not read default project '${options.defaultProject}': ${(error as Error).message}`,
		);
		}

		service.setCompilerOptionsForInferredProjects(
		(
		configRead.config as {
		compilerOptions: ts.server.protocol.InferredProjectCompilerOptions;
		}
		).compilerOptions,
		// NOTE: The inferred projects API is not intended for source files when a tsconfig
		// exists. There is no API that generates an InferredProjectCompilerOptions suggesting
		// it is meant for hard coded options passed in. Hard asserting as a work around.
		// See https://github.com/microsoft/TypeScript/blob/27bcd4cb5a98bce46c9cdd749752703ead021a4b/src/server/protocol.ts#L1904
		configFile.options as ts.server.protocol.InferredProjectCompilerOptions,
		);
		}

Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,60 @@
		import * as fs from 'fs';
		import * as path from 'path';
		import type * as ts from 'typescript/lib/tsserverlibrary';

		import { CORE_COMPILER_OPTIONS } from './shared';

		/**
		* Utility offered by parser to help consumers parse a config file.
		*
		* @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()`
		*/
		function getParsedConfigFile(
		tsserver: typeof ts,
		configFile: string,
		projectDirectory?: string,
		): ts.ParsedCommandLine {
higherorderfunctor marked this conversation as resolved. Show resolvedHide resolved
		// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
		if (tsserver.sys === undefined) {
		throw new Error(
		'`getParsedConfigFile` is only supported in a Node-like environment.',
		);
		}

		const parsed = tsserver.getParsedCommandLineOfConfigFile(
		configFile,
		CORE_COMPILER_OPTIONS,
		{
		onUnRecoverableConfigFileDiagnostic: diag => {
		throw new Error(formatDiagnostics([diag])); // ensures that `parsed` is defined.
		},
		fileExists: fs.existsSync,
		getCurrentDirectory,
		readDirectory: tsserver.sys.readDirectory,
		readFile: file => fs.readFileSync(file, 'utf-8'),
		useCaseSensitiveFileNames: tsserver.sys.useCaseSensitiveFileNames,
		},
		);

		if (parsed?.errors.length) {
		throw new Error(formatDiagnostics(parsed.errors));
		}

		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
		return parsed!;

		function getCurrentDirectory(): string {
		return projectDirectory ? path.resolve(projectDirectory) : process.cwd();
		}

		function formatDiagnostics(diagnostics: ts.Diagnostic[]): string \| undefined {
		return tsserver.formatDiagnostics(diagnostics, {
		getCanonicalFileName: f => f,
		getCurrentDirectory,
		getNewLine: () => '\n',
		});
		}
		}

		export { getParsedConfigFile };
Original file line number	Diff line number	Diff line change
		@@ -1,11 +1,11 @@
		import debug from 'debug';
		import * as fs from 'fs';
		import * as path from 'path';
		import * as ts from 'typescript';

		import type { ParseSettings } from '../parseSettings';
		import { getParsedConfigFile } from './getParsedConfigFile';
		import type { ASTAndDefiniteProgram } from './shared';
		import {CORE_COMPILER_OPTIONS,getAstFromProgram } from './shared';
		import { getAstFromProgram } from './shared';

		const log = debug('typescript-eslint:typescript-estree:useProvidedProgram');

Expand DownExpand Up		@@ -60,44 +60,9 @@ function createProgramFromConfigFile(
		configFile: string,
		projectDirectory?: string,
		): ts.Program {
		// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
		if (ts.sys === undefined) {
		throw new Error(
		'`createProgramFromConfigFile` is only supported in a Node-like environment.',
		);
		}

		const parsed = ts.getParsedCommandLineOfConfigFile(
		configFile,
		CORE_COMPILER_OPTIONS,
		{
		onUnRecoverableConfigFileDiagnostic: diag => {
		throw new Error(formatDiagnostics([diag])); // ensures that `parsed` is defined.
		},
		fileExists: fs.existsSync,
		getCurrentDirectory: () =>
		(projectDirectory && path.resolve(projectDirectory)) \|\| process.cwd(),
		readDirectory: ts.sys.readDirectory,
		readFile: file => fs.readFileSync(file, 'utf-8'),
		useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
		},
		);
		// parsed is not undefined, since we throw on failure.
		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
		const result = parsed!;
		if (result.errors.length) {
		throw new Error(formatDiagnostics(result.errors));
		}
		const host = ts.createCompilerHost(result.options, true);
		return ts.createProgram(result.fileNames, result.options, host);
		}

		function formatDiagnostics(diagnostics: ts.Diagnostic[]): string \| undefined {
		return ts.formatDiagnostics(diagnostics, {
		getCanonicalFileName: f => f,
		getCurrentDirectory: process.cwd,
		getNewLine: () => '\n',
		});
		const parsed = getParsedConfigFile(ts, configFile, projectDirectory);
		const host = ts.createCompilerHost(parsed.options, true);
		return ts.createProgram(parsed.fileNames, parsed.options, host);
		}

		export { useProvidedPrograms, createProgramFromConfigFile };
Original file line number	Diff line number	Diff line change
		@@ -1,15 +1,16 @@
		import debug from 'debug';
higherorderfunctor marked this conversation as resolved. Show resolvedHide resolved
		import * as ts from 'typescript';

		import { createProjectService } from '../../src/create-program/createProjectService';

		const mockReadConfigFile = jest.fn();
		const mockGetParsedConfigFile = jest.fn();
		const mockSetCompilerOptionsForInferredProjects = jest.fn();
		const mockSetHostConfiguration = jest.fn();

		jest.mock('../../src/create-program/getParsedConfigFile', () => ({
		getParsedConfigFile: mockGetParsedConfigFile,
		}));

		jest.mock('typescript/lib/tsserverlibrary', () => ({
		...jest.requireActual('typescript/lib/tsserverlibrary'),
		readConfigFile: mockReadConfigFile,
		server: {
		...jest.requireActual('typescript/lib/tsserverlibrary').server,
		ProjectService: class {
Expand All		@@ -33,6 +34,11 @@ jest.mock('typescript/lib/tsserverlibrary', () => ({
		},
		}));

		const {
		createProjectService,
		// eslint-disable-next-line @typescript-eslint/no-require-imports
		} = require('../../src/create-program/createProjectService');

		describe('createProjectService', () => {
		afterEach(() => {
		jest.resetAllMocks();
Expand All		@@ -51,18 +57,9 @@ describe('createProjectService', () => {
		expect(settings.allowDefaultProject).toBeUndefined();
		});

		it('throws an error when options.defaultProject is set and readConfigFile returns an error', () => {
		mockReadConfigFile.mockReturnValue({
		error: {
		category: ts.DiagnosticCategory.Error,
		code: 1234,
		file: ts.createSourceFile('./tsconfig.json', '', {
		languageVersion: ts.ScriptTarget.Latest,
		}),
		start: 0,
		length: 0,
		messageText: 'Oh no!',
		} satisfies ts.Diagnostic,
		it('throws an error when options.defaultProject is set and getParsedConfigFile throws a diagnostic error', () => {
		mockGetParsedConfigFile.mockImplementation(() => {
		throw new Error('./tsconfig.json(1,1): error TS1234: Oh no!');
		});

		expect(() =>
Expand All		@@ -78,9 +75,11 @@ describe('createProjectService', () => {
		);
		});

		it('throws an error when options.defaultProject is set and readConfigFile throws an error', () => {
		mockReadConfigFile.mockImplementation(() => {
		throw new Error('Oh no!');
		it('throws an error when options.defaultProject is set and getParsedConfigFile throws an environment error', () => {
		mockGetParsedConfigFile.mockImplementation(() => {
		throw new Error(
		'`getParsedConfigFile` is only supported in a Node-like environment.',
		);
		});

		expect(() =>
Expand All		@@ -91,12 +90,14 @@ describe('createProjectService', () => {
		},
		undefined,
		),
		).toThrow("Could not parse default project './tsconfig.json': Oh no!");
		).toThrow(
		"Could not read default project './tsconfig.json': `getParsedConfigFile` is only supported in a Node-like environment.",
		);
		});

		it('uses the default projects compiler options when options.defaultProject is set andreadConfigFile succeeds', () => {
		it('uses the default projects compiler options when options.defaultProject is set andgetParsedConfigFile succeeds', () => {
		const compilerOptions = { strict: true };
		mockReadConfigFile.mockReturnValue({config: {compilerOptions } });
		mockGetParsedConfigFile.mockReturnValue({options:compilerOptions });

		const { service } = createProjectService(
		{
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,112 @@
		import path from 'node:path';

		import * as ts from 'typescript';

		import { getParsedConfigFile } from '../../src/create-program/getParsedConfigFile';

		const mockGetParsedCommandLineOfConfigFile = jest.fn();

		const mockTsserver: typeof ts = {
		sys: {} as ts.System,
		formatDiagnostics: ts.formatDiagnostics,
		getParsedCommandLineOfConfigFile: mockGetParsedCommandLineOfConfigFile,
		// eslint-disable-next-line @typescript-eslint/no-explicit-any
		} as any;

		describe('getParsedConfigFile', () => {
		afterEach(() => {
		jest.resetAllMocks();
		});

		it('throws an error when tsserver.sys is undefined', () => {
		expect(() =>
		getParsedConfigFile({} as typeof ts, './tsconfig.json'),
		).toThrow(
		'`getParsedConfigFile` is only supported in a Node-like environment.',
		);
		});

		it('uses the cwd as the default project directory', () => {
		getParsedConfigFile(mockTsserver, './tsconfig.json');
		expect(mockGetParsedCommandLineOfConfigFile).toHaveBeenCalledTimes(1);
		const [_configFileName, _optionsToExtend, host] =
		mockGetParsedCommandLineOfConfigFile.mock.calls[0];
		expect(host.getCurrentDirectory()).toBe(process.cwd());
		});

		it('resolves a relative project directory when passed', () => {
		getParsedConfigFile(
		mockTsserver,
		'./tsconfig.json',
		path.relative('./', path.dirname(__filename)),
		);
		expect(mockGetParsedCommandLineOfConfigFile).toHaveBeenCalledTimes(1);
		const [_configFileName, _optionsToExtend, host] =
		mockGetParsedCommandLineOfConfigFile.mock.calls[0];
		expect(host.getCurrentDirectory()).toBe(path.dirname(__filename));
		});

		it('resolves an absolute project directory when passed', () => {
		getParsedConfigFile(mockTsserver, './tsconfig.json', __dirname);
		expect(mockGetParsedCommandLineOfConfigFile).toHaveBeenCalledTimes(1);
		const [_configFileName, _optionsToExtend, host] =
		mockGetParsedCommandLineOfConfigFile.mock.calls[0];
		expect(host.getCurrentDirectory()).toBe(__dirname);
		});

		it('throws a diagnostic error when getParsedCommandLineOfConfigFile returns an error', () => {
		mockGetParsedCommandLineOfConfigFile.mockReturnValue({
		errors: [
		{
		category: ts.DiagnosticCategory.Error,
		code: 1234,
		file: ts.createSourceFile('./tsconfig.json', '', {
		languageVersion: ts.ScriptTarget.Latest,
		}),
		start: 0,
		length: 0,
		messageText: 'Oh no!',
		},
		] satisfies ts.Diagnostic[],
		});
		expect(() => getParsedConfigFile(mockTsserver, './tsconfig.json')).toThrow(
		/.+ error TS1234: Oh no!/,
		);
		});

		it('throws a diagnostic error when getParsedCommandLineOfConfigFile throws an error', () => {
		mockGetParsedCommandLineOfConfigFile.mockImplementation(
		(
		...[_configFileName, _optionsToExtend, host]: Parameters<
		typeof ts.getParsedCommandLineOfConfigFile
		>
		) => {
		return host.onUnRecoverableConfigFileDiagnostic({
		category: ts.DiagnosticCategory.Error,
		code: 1234,
		file: ts.createSourceFile('./tsconfig.json', '', {
		languageVersion: ts.ScriptTarget.Latest,
		}),
		start: 0,
		length: 0,
		messageText: 'Oh no!',
		} satisfies ts.Diagnostic);
		},
		);
		expect(() => getParsedConfigFile(mockTsserver, './tsconfig.json')).toThrow(
		/.+ error TS1234: Oh no!/,
		);
		});

		it('uses compiler options when parsing a config file succeeds', () => {
		const parsedConfigFile = {
		options: { strict: true },
		raw: { compilerOptions: { strict: true } },
		errors: [],
		};
		mockGetParsedCommandLineOfConfigFile.mockReturnValue(parsedConfigFile);
		expect(getParsedConfigFile(mockTsserver, 'tsconfig.json')).toEqual(
		expect.objectContaining(parsedConfigFile),
		);
		});
		});