Inferred,

Configured,

External,

AutoImportProvider,

Auxiliary,

const result: Mutable<FileStats> = {

js: 0,

jsSize: 0,

jsx: 0,

jsxSize: 0,

ts: 0,

tsSize: 0,

tsx: 0,

tsxSize: 0,

dts: 0,

dtsSize: 0,

deferred: 0,

deferredSize: 0,

};

for (const info of infos) {

const fileSize = includeSizes ? info.textStorage.getTelemetryFileSize() : 0;

switch (info.scriptKind) {

case ScriptKind.JS:

result.js += 1;

result.jsSize! += fileSize;

break;

case ScriptKind.JSX:

result.jsx += 1;

result.jsxSize! += fileSize;

break;

case ScriptKind.TS:

if (isDeclarationFileName(info.fileName)) {

result.dts += 1;

result.dtsSize! += fileSize;

}

else {

result.ts += 1;

result.tsSize! += fileSize;

}

break;

case ScriptKind.TSX:

result.tsx += 1;

result.tsxSize! += fileSize;

break;

case ScriptKind.Deferred:

result.deferred += 1;

result.deferredSize! += fileSize;

break;

}

}

return result;

project: Project;

languageService: LanguageService;

languageServiceHost: LanguageServiceHost;

serverHost: ServerHost;

session?: Session<unknown>;

config: any;

create(createInfo: PluginCreateInfo): LanguageService;

getExternalFiles?(proj: Project, updateLevel: ProgramUpdateLevel): string[];

onConfigurationChanged?(config: any): void;

pluginConfigEntry: PluginImport;

resolvedModule: T | undefined;

errorLogs: string[] | undefined;

private rootFilesMap = new Map<Path, ProjectRootFile>();

private program: Program | undefined;

private externalFiles: SortedReadonlyArray<string> | undefined;

private missingFilesMap: Map<Path, FileWatcher> | undefined;

private generatedFilesMap: GeneratedFileWatcherMap | undefined;

/** @internal */

protected readonly plugins: PluginModuleWithName[] = [];

/**

cachedUnresolvedImportsPerFile = new Map<Path, readonly string[]>();

/** @internal */

lastCachedUnresolvedImportsList: SortedReadonlyArray<string> | undefined;

/** @internal */

private hasAddedorRemovedFiles = false;

/** @internal */

private hasAddedOrRemovedSymlinks = false;

/** @internal */

lastFileExceededProgramSize: string | undefined;

// wrapper over the real language service that will suppress all semantic operations

protected languageService: LanguageService;

public languageServiceEnabled: boolean;

readonly trace?: (s: string) => void;

readonly realpath?: (path: string) => string;

/** @internal */

hasInvalidatedResolutions?: HasInvalidatedResolutions | undefined;

/** @internal */

hasInvalidatedLibResolutions: HasInvalidatedLibResolutions | undefined;

/** @internal */

resolutionCache: ResolutionCache;

private builderState: BuilderState | undefined;

/**

private updatedFileNames: Set<string> | undefined;

/**

private lastReportedFileNames: Map<string, boolean> | undefined;

/**

private lastReportedVersion = 0;

/**

projectProgramVersion = 0;

/**

projectStateVersion = 0;

protected projectErrors: Diagnostic[] | undefined;

protected isInitialLoadPending: () => boolean = returnFalse;

/** @internal */

dirty = false;

/** @internal */

typingFiles: SortedReadonlyArray<string> = emptyArray;

/** @internal */

private typingWatchers: TypingWatchers | undefined;

/** @internal */

originalConfiguredProjects: Set<NormalizedPath> | undefined;

/** @internal */

packageJsonWatches: Set<PackageJsonWatcher> | undefined;

/** @internal */

noDtsResolutionProject?: AuxiliaryProject | undefined;

/** @internal */

getResolvedProjectReferenceToRedirect(_fileName: string): ResolvedProjectReference | undefined {

return undefined;

}

/** @internal */ useSourceOfProjectReferenceRedirect?(): boolean;

/** @internal */ getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined;

private readonly cancellationToken: ThrottledCancellationToken;

public isNonTsProject() {

updateProjectIfDirty(this);

return allFilesAreJsOrDts(this);

}

public isJsOnlyProject() {

updateProjectIfDirty(this);

return hasOneOrMoreJsAndNoTsFiles(this);

}

public static resolveModule(moduleName: string, initialDir: string, host: ServerHost, log: (message: string) => void): {} | undefined {

return Project.importServicePluginSync({ name: moduleName }, [initialDir], host, log).resolvedModule;

}

/** @internal */

public static importServicePluginSync<T = {}>(

pluginConfigEntry: PluginImport,

searchPaths: string[],

host: ServerHost,

log: (message: string) => void,

): PluginImportResult<T> {

Debug.assertIsDefined(host.require);

let errorLogs: string[] | undefined;

let resolvedModule: T | undefined;

for (const initialDir of searchPaths) {

const resolvedPath = normalizeSlashes(host.resolvePath(combinePaths(initialDir, "node_modules")));

log(`Loading ${pluginConfigEntry.name} from ${initialDir} (resolved to ${resolvedPath})`);

const result = host.require(resolvedPath, pluginConfigEntry.name); // TODO: GH#18217

if (!result.error) {

resolvedModule = result.module as T;

break;

}

const err = result.error.stack || result.error.message || JSON.stringify(result.error);

(errorLogs ??= []).push(`Failed to load module '${pluginConfigEntry.name}' from ${resolvedPath}: ${err}`);

}

return { pluginConfigEntry, resolvedModule, errorLogs };

}

/** @internal */

public static async importServicePluginAsync<T = {}>(

pluginConfigEntry: PluginImport,

searchPaths: string[],

host: ServerHost,

log: (message: string) => void,

): Promise<PluginImportResult<T>> {

Debug.assertIsDefined(host.importPlugin);

let errorLogs: string[] | undefined;

let resolvedModule: T | undefined;

for (const initialDir of searchPaths) {

const resolvedPath = combinePaths(initialDir, "node_modules");

log(`Dynamically importing ${pluginConfigEntry.name} from ${initialDir} (resolved to ${resolvedPath})`);

let result: ModuleImportResult;

try {

result = await host.importPlugin(resolvedPath, pluginConfigEntry.name);

}

catch (e) {

result = { module: undefined, error: e };

}

if (!result.error) {

resolvedModule = result.module as T;

break;

}

const err = result.error.stack || result.error.message || JSON.stringify(result.error);

(errorLogs ??= []).push(`Failed to dynamically import module '${pluginConfigEntry.name}' from ${resolvedPath}: ${err}`);

}

return { pluginConfigEntry, resolvedModule, errorLogs };

}

/** @internal */

readonly currentDirectory: string;

/** @internal */

readonly projectName: string;

/** @internal */

public directoryStructureHost: DirectoryStructureHost;

/** @internal */

public readonly getCanonicalFileName: GetCanonicalFileName;

/** @internal */

private exportMapCache: ExportInfoMap | undefined;

/** @internal */

private changedFilesForExportMapCache: Set<Path> | undefined;

/** @internal */

private moduleSpecifierCache = createModuleSpecifierCache(this);

/** @internal */

private symlinks: SymlinkCache | undefined;

/** @internal */

autoImportProviderHost: AutoImportProviderProject | false | undefined;

/** @internal */

protected typeAcquisition: TypeAcquisition | undefined;

/** @internal */

createHash = maybeBind(this.projectService.host, this.projectService.host.createHash);

readonly jsDocParsingMode: JSDocParsingMode | undefined;

/** @internal */

constructor(

projectName: string,

readonly projectKind: ProjectKind,

readonly projectService: ProjectService,

private documentRegistry: DocumentRegistry,

hasExplicitListOfFiles: boolean,

lastFileExceededProgramSize: string | undefined,

private compilerOptions: CompilerOptions,

public compileOnSaveEnabled: boolean,

protected watchOptions: WatchOptions | undefined,

directoryStructureHost: DirectoryStructureHost,

currentDirectory: string,

) {

this.projectName = projectName;

this.directoryStructureHost = directoryStructureHost;

this.currentDirectory = this.projectService.getNormalizedAbsolutePath(currentDirectory);

this.getCanonicalFileName = this.projectService.toCanonicalFileName;

this.jsDocParsingMode = this.projectService.jsDocParsingMode;

this.cancellationToken = new ThrottledCancellationToken(this.projectService.cancellationToken, this.projectService.throttleWaitMilliseconds);

if (!this.compilerOptions) {

this.compilerOptions = getDefaultCompilerOptions();

this.compilerOptions.allowNonTsExtensions = true;

this.compilerOptions.allowJs = true;

}

else if (hasExplicitListOfFiles || getAllowJSCompilerOption(this.compilerOptions) || this.projectService.hasDeferredExtension()) {

// If files are listed explicitly or allowJs is specified, allow all extensions

this.compilerOptions.allowNonTsExtensions = true;

}

switch (projectService.serverMode) {

case LanguageServiceMode.Semantic:

this.languageServiceEnabled = true;

break;

case LanguageServiceMode.PartialSemantic:

this.languageServiceEnabled = true;

this.compilerOptions.noResolve = true;

this.compilerOptions.types = [];

break;

case LanguageServiceMode.Syntactic:

this.languageServiceEnabled = false;

this.compilerOptions.noResolve = true;

this.compilerOptions.types = [];

break;

default:

Debug.assertNever(projectService.serverMode);

}

this.setInternalCompilerOptionsForEmittingJsFiles();

const host = this.projectService.host;

if (this.projectService.logger.loggingEnabled()) {

this.trace = s => this.writeLog(s);

}

else if (host.trace) {

this.trace = s => host.trace!(s);

}

this.realpath = maybeBind(host, host.realpath);

// Use the current directory as resolution root only if the project created using current directory string

this.resolutionCache = createResolutionCache(

this,

this.currentDirectory,

/*logChangesWhenResolvingModule*/ true,

);

this.languageService = createLanguageService(this, this.documentRegistry, this.projectService.serverMode);

if (lastFileExceededProgramSize) {

this.disableLanguageService(lastFileExceededProgramSize);

}

this.markAsDirty();

if (!isBackgroundProject(this)) {

this.projectService.pendingEnsureProjectForOpenFiles = true;

}

this.projectService.onProjectCreation(this);

}

isKnownTypesPackageName(name: string): boolean {

return this.typingsCache.isKnownTypesPackageName(name);

}

installPackage(options: InstallPackageOptions): Promise<ApplyCodeActionCommandResult> {

return this.typingsCache.installPackage({ ...options, projectName: this.projectName, projectRootPath: this.toPath(this.currentDirectory) });

}

/** @internal */

getGlobalTypingsCacheLocation() {

return this.getGlobalCache();

}

private get typingsCache(): TypingsCache {

return this.projectService.typingsCache;

}

/** @internal */

getSymlinkCache(): SymlinkCache {

if (!this.symlinks) {

this.symlinks = createSymlinkCache(this.getCurrentDirectory(), this.getCanonicalFileName);

}

if (this.program && !this.symlinks.hasProcessedResolutions()) {

this.symlinks.setSymlinksFromResolutions(

this.program.forEachResolvedModule,

this.program.forEachResolvedTypeReferenceDirective,

this.program.getAutomaticTypeDirectiveResolutions(),

);

}

return this.symlinks;

}

// Method of LanguageServiceHost

getCompilationSettings() {

return this.compilerOptions;

}

// Method to support public API

getCompilerOptions() {

return this.getCompilationSettings();

}

getNewLine() {

return this.projectService.host.newLine;

}

getProjectVersion() {

return this.projectStateVersion.toString();

}

getProjectReferences(): readonly ProjectReference[] | undefined {

return undefined;

}

getScriptFileNames() {

if (!this.rootFilesMap.size) {

return ts.emptyArray;

}

let result: string[] | undefined;

this.rootFilesMap.forEach(value => {

if (this.languageServiceEnabled || (value.info && value.info.isScriptOpen())) {

// if language service is disabled - process only files that are open

(result || (result = [])).push(value.fileName);

}

});

return addRange(result, this.typingFiles) || ts.emptyArray;

}

private getOrCreateScriptInfoAndAttachToProject(fileName: string) {

const scriptInfo = this.projectService.getOrCreateScriptInfoNotOpenedByClient(

fileName,

this.currentDirectory,

this.directoryStructureHost,

/*deferredDeleteOk*/ false,

);

if (scriptInfo) {

const existingValue = this.rootFilesMap.get(scriptInfo.path);

if (existingValue && existingValue.info !== scriptInfo) {

// This was missing path earlier but now the file exists. Update the root

existingValue.info = scriptInfo;

}

scriptInfo.attachToProject(this);

}

return scriptInfo;

}

getScriptKind(fileName: string) {

const info = this.projectService.getScriptInfoForPath(this.toPath(fileName));

return (info && info.scriptKind)!; // TODO: GH#18217

}

getScriptVersion(filename: string) {

// Don't attach to the project if version is asked

const info = this.projectService.getOrCreateScriptInfoNotOpenedByClient(

filename,

this.currentDirectory,

this.directoryStructureHost,

/*deferredDeleteOk*/ false,

);

return (info && info.getLatestVersion())!; // TODO: GH#18217

}

getScriptSnapshot(filename: string): IScriptSnapshot | undefined {

const scriptInfo = this.getOrCreateScriptInfoAndAttachToProject(filename);

if (scriptInfo) {

return scriptInfo.getSnapshot();

}

}

getCancellationToken(): HostCancellationToken {

return this.cancellationToken;

}

getCurrentDirectory(): string {

return this.currentDirectory;

}

getDefaultLibFileName() {

const nodeModuleBinDir = getDirectoryPath(normalizePath(this.projectService.getExecutingFilePath()));

return combinePaths(nodeModuleBinDir, getDefaultLibFileName(this.compilerOptions));

}

useCaseSensitiveFileNames() {

return this.projectService.host.useCaseSensitiveFileNames;

}

readDirectory(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[] {

return this.directoryStructureHost.readDirectory!(path, extensions, exclude, include, depth);

}

readFile(fileName: string): string | undefined {

return this.projectService.host.readFile(fileName);

}

writeFile(fileName: string, content: string): void {

return this.projectService.host.writeFile(fileName, content);

}

fileExists(file: string): boolean {

// As an optimization, don't hit the disks for files we already know don't exist

// (because we're watching for their creation).

const path = this.toPath(file);

return !this.isWatchedMissingFile(path) && this.directoryStructureHost.fileExists(file);

}

/** @internal */

resolveModuleNameLiterals(moduleLiterals: readonly StringLiteralLike[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile: SourceFile, reusedNames: readonly StringLiteralLike[] | undefined): readonly ResolvedModuleWithFailedLookupLocations[] {

return this.resolutionCache.resolveModuleNameLiterals(moduleLiterals, containingFile, redirectedReference, options, containingSourceFile, reusedNames);

}

/** @internal */

getModuleResolutionCache(): ModuleResolutionCache | undefined {

return this.resolutionCache.getModuleResolutionCache();

}

/** @internal */

resolveTypeReferenceDirectiveReferences<T extends string | FileReference>(typeDirectiveReferences: readonly T[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile: SourceFile | undefined, reusedNames: readonly T[] | undefined): readonly ResolvedTypeReferenceDirectiveWithFailedLookupLocations[] {

return this.resolutionCache.resolveTypeReferenceDirectiveReferences(

typeDirectiveReferences,

containingFile,

redirectedReference,

options,

containingSourceFile,

reusedNames,

);

}

/** @internal */

resolveLibrary(libraryName: string, resolveFrom: string, options: CompilerOptions, libFileName: string): ResolvedModuleWithFailedLookupLocations {

return this.resolutionCache.resolveLibrary(libraryName, resolveFrom, options, libFileName);

}

directoryExists(path: string): boolean {

return this.directoryStructureHost.directoryExists!(path); // TODO: GH#18217

}

getDirectories(path: string): string[] {

return this.directoryStructureHost.getDirectories!(path); // TODO: GH#18217

}

/** @internal */

getCachedDirectoryStructureHost(): CachedDirectoryStructureHost {

return undefined!; // TODO: GH#18217

}

/** @internal */

toPath(fileName: string) {

return toPath(fileName, this.currentDirectory, this.projectService.toCanonicalFileName);

}

/** @internal */

watchDirectoryOfFailedLookupLocation(directory: string, cb: DirectoryWatcherCallback, flags: WatchDirectoryFlags) {

return this.projectService.watchFactory.watchDirectory(

directory,

cb,

flags,

this.projectService.getWatchOptions(this),

WatchType.FailedLookupLocations,

this,

);

}

/** @internal */

watchAffectingFileLocation(file: string, cb: FileWatcherCallback) {

return this.projectService.watchFactory.watchFile(

file,

cb,

PollingInterval.High,

this.projectService.getWatchOptions(this),

WatchType.AffectingFileLocation,

this,

);

}

/** @internal */

clearInvalidateResolutionOfFailedLookupTimer() {

return this.projectService.throttledOperations.cancel(`${this.getProjectName()}FailedLookupInvalidation`);

}

/** @internal */

scheduleInvalidateResolutionsOfFailedLookupLocations() {

this.projectService.throttledOperations.schedule(`${this.getProjectName()}FailedLookupInvalidation`, /*delay*/ 1000, () => {

if (this.resolutionCache.invalidateResolutionsOfFailedLookupLocations()) {

this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this);

}

});

}

/** @internal */

invalidateResolutionsOfFailedLookupLocations() {

if (

this.clearInvalidateResolutionOfFailedLookupTimer() &&

this.resolutionCache.invalidateResolutionsOfFailedLookupLocations()

) {

this.markAsDirty();

this.projectService.delayEnsureProjectForOpenFiles();

}

}

/** @internal */

onInvalidatedResolution() {

this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this);

}

/** @internal */

watchTypeRootsDirectory(directory: string, cb: DirectoryWatcherCallback, flags: WatchDirectoryFlags) {

return this.projectService.watchFactory.watchDirectory(

directory,

cb,

flags,

this.projectService.getWatchOptions(this),

WatchType.TypeRoots,

this,

);

}

/** @internal */

hasChangedAutomaticTypeDirectiveNames() {

return this.resolutionCache.hasChangedAutomaticTypeDirectiveNames();

}

/** @internal */

onChangedAutomaticTypeDirectiveNames() {

this.projectService.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(this);

}

/** @internal */

getGlobalCache() {

return this.getTypeAcquisition().enable ? this.projectService.typingsInstaller.globalTypingsCacheLocation : undefined;

}

/** @internal */

globalCacheResolutionModuleName = JsTyping.nonRelativeModuleNameForTypingCache;

/** @internal */

fileIsOpen(filePath: Path) {

return this.projectService.openFiles.has(filePath);

}

/** @internal */

writeLog(s: string) {

this.projectService.logger.info(s);

}

log(s: string) {

this.writeLog(s);

}

error(s: string) {

this.projectService.logger.msg(s, Msg.Err);

}

private setInternalCompilerOptionsForEmittingJsFiles() {

if (this.projectKind === ProjectKind.Inferred || this.projectKind === ProjectKind.External) {

this.compilerOptions.noEmitForJsFiles = true;

}

}

/**

getGlobalProjectErrors(): readonly Diagnostic[] {

return filter(this.projectErrors, diagnostic => !diagnostic.file) || emptyArray;

}

/**

getAllProjectErrors(): readonly Diagnostic[] {

return this.projectErrors || emptyArray;

}

setProjectErrors(projectErrors: Diagnostic[] | undefined) {

this.projectErrors = projectErrors;

}

getLanguageService(ensureSynchronized = true): LanguageService {

if (ensureSynchronized) {

updateProjectIfDirty(this);

}

return this.languageService;