import {

addToSeen,

arrayFrom,

arrayToMap,

AssertionLevel,

CachedDirectoryStructureHost,

canJsonReportNoInputFiles,

canWatchDirectoryOrFile,

cleanExtendedConfigCache,

clearMap,

clearSharedExtendedConfigFileWatcher,

closeFileWatcherOf,

combinePaths,

CommandLineOption,

CompilerOptions,

CompletionInfo,

ConfigFileProgramReloadLevel,

contains,

containsPath,

convertCompilerOptionsForTelemetry,

convertJsonOption,

createCachedDirectoryStructureHost,

createDocumentRegistryInternal,

createGetCanonicalFileName,

createMultiMap,

Debug,

Diagnostic,

directorySeparator,

DirectoryStructureHost,

DocumentPosition,

DocumentPositionMapper,

DocumentRegistry,

DocumentRegistryBucketKeyWithMode,

emptyOptions,

ensureTrailingDirectorySeparator,

ExtendedConfigCacheEntry,

FileExtensionInfo,

fileExtensionIs,

FileWatcher,

FileWatcherEventKind,

find,

flatMap,

forEach,

forEachAncestorDirectory,

forEachEntry,

forEachKey,

forEachResolvedProjectReference,

FormatCodeSettings,

getAnyExtensionFromPath,

getBaseFileName,

getDefaultFormatCodeSettings,

getDirectoryPath,

getDocumentPositionMapper,

getFileNamesFromConfigSpecs,

getFileWatcherEventKind,

getNormalizedAbsolutePath,

getSnapshotText,

getWatchFactory,

hasExtension,

hasProperty,

hasTSFileExtension,

HostCancellationToken,

identity,

IncompleteCompletionsCache,

IndentStyle,

isArray,

isIgnoredFileFromWildCardWatching,

isInsideNodeModules,

isJsonEqual,

isNodeModulesDirectory,

isRootedDiskPath,

isString,

LanguageServiceMode,

length,

map,

mapDefinedEntries,

mapDefinedIterator,

missingFileModifiedTime,

MultiMap,

noop,

normalizePath,

normalizeSlashes,

optionDeclarations,

optionsForWatch,

PackageJsonAutoImportPreference,

ParsedCommandLine,

parseJsonSourceFileConfigFileContent,

parseJsonText,

parsePackageName,

Path,

PerformanceEvent,

PluginImport,

PollingInterval,

ProjectPackageJsonInfo,

ProjectReference,

ReadMapFile,

ReadonlyCollection,

removeFileExtension,

removeIgnoredPath,

removeMinAndVersionNumbers,

ResolvedProjectReference,

resolveProjectReferencePath,

returnNoopFileWatcher,

returnTrue,

ScriptKind,

SharedExtendedConfigFileWatcher,

some,

SourceFile,

SourceFileLike,

startsWith,

Ternary,

TextChange,

toFileNameLowerCase,

toPath,

tracing,

tryAddToSet,

tryReadFile,

TsConfigSourceFile,

TypeAcquisition,

typeAcquisitionDeclarations,

unorderedRemoveItem,

updateSharedExtendedConfigFileWatcher,

updateWatchingWildcardDirectories,

UserPreferences,

version,

WatchDirectoryFlags,

WatchFactory,

WatchLogLevel,

WatchOptions,

WatchType,

WildcardDirectoryWatcher,

} from "./_namespaces/ts";

import {

ActionInvalidate,

ActionSet,

asNormalizedPath,

AutoImportProviderProject,

BeginEnablePluginResult,

BeginInstallTypes,

ConfiguredProject,

countEachFileTypes,

createPackageJsonCache,

emptyArray,

EndInstallTypes,

Errors,

ExternalProject,

getBaseConfigFileName,

hasNoTypeScriptSource,

InferredProject,

InvalidateCachedTypings,

isConfiguredProject,

isDynamicFileName,

isInferredProject,

isInferredProjectName,

ITypingsInstaller,

Logger,

LogLevel,

makeAutoImportProviderProjectName,

makeAuxiliaryProjectName,

makeInferredProjectName,

Msg,

NormalizedPath,

normalizedPathToPath,

nullTypingsInstaller,

PackageInstalledResponse,

PackageJsonCache,

Project,

ProjectFilesWithTSDiagnostics,

ProjectKind,

ProjectOptions,

ScriptInfo,

ServerHost,

Session,

SetTypings,

ThrottledOperations,

toNormalizedPath,

TypingsCache,

} from "./_namespaces/ts.server";

import * as protocol from "./protocol";

export const maxProgramSizeForNonTsFiles = 20 * 1024 * 1024;

/** @internal */

export const maxFileSize = 4 * 1024 * 1024;

export const ProjectsUpdatedInBackgroundEvent = "projectsUpdatedInBackground";

export const ProjectLoadingStartEvent = "projectLoadingStart";

export const ProjectLoadingFinishEvent = "projectLoadingFinish";

export const LargeFileReferencedEvent = "largeFileReferenced";

export const ConfigFileDiagEvent = "configFileDiag";

export const ProjectLanguageServiceStateEvent = "projectLanguageServiceState";

export const ProjectInfoTelemetryEvent = "projectInfo";

export const OpenFileInfoTelemetryEvent = "openFileInfo";

const ensureProjectForOpenFileSchedule = "*ensureProjectForOpenFiles*";

export interface ProjectsUpdatedInBackgroundEvent {

eventName: typeof ProjectsUpdatedInBackgroundEvent;

data: { openFiles: string[]; };

}

export interface ProjectLoadingStartEvent {

eventName: typeof ProjectLoadingStartEvent;

data: { project: Project; reason: string; };

}

export interface ProjectLoadingFinishEvent {

eventName: typeof ProjectLoadingFinishEvent;

data: { project: Project; };

}

export interface LargeFileReferencedEvent {

eventName: typeof LargeFileReferencedEvent;

data: { file: string; fileSize: number; maxFileSize: number; };

}

export interface ConfigFileDiagEvent {

eventName: typeof ConfigFileDiagEvent;

data: { triggerFile: string, configFileName: string, diagnostics: readonly Diagnostic[] };

}

export interface ProjectLanguageServiceStateEvent {

eventName: typeof ProjectLanguageServiceStateEvent;

data: { project: Project, languageServiceEnabled: boolean };

}

/** This will be converted to the payload of a protocol.TelemetryEvent in session.defaultEventHandler. */

export interface ProjectInfoTelemetryEvent {

readonly eventName: typeof ProjectInfoTelemetryEvent;

readonly data: ProjectInfoTelemetryEventData;

}

/* __GDPR__

"projectInfo" : {

"${include}": ["${TypeScriptCommonProperties}"],

"projectId": { "classification": "EndUserPseudonymizedInformation", "purpose": "FeatureInsight", "endpoint": "ProjectId" },

"fileStats": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

"compilerOptions": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

"extends": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

"files": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

"include": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

"exclude": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

"compileOnSave": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

"typeAcquisition": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

"configFileName": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

"projectType": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

"languageServiceEnabled": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },

"version": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }

}

*/

export interface ProjectInfoTelemetryEventData {

/** Cryptographically secure hash of project file location. */

readonly projectId: string;

/** Count of file extensions seen in the project. */

readonly fileStats: FileStats;

/**

* Any compiler options that might contain paths will be taken out.

* Enum compiler options will be converted to strings.

*/

readonly compilerOptions: CompilerOptions;

// "extends", "files", "include", or "exclude" will be undefined if an external config is used.

// Otherwise, we will use "true" if the property is present and "false" if it is missing.

readonly extends: boolean | undefined;

readonly files: boolean | undefined;

readonly include: boolean | undefined;

readonly exclude: boolean | undefined;

readonly compileOnSave: boolean;

readonly typeAcquisition: ProjectInfoTypeAcquisitionData;

readonly configFileName: "tsconfig.json" | "jsconfig.json" | "other";

readonly projectType: "external" | "configured";

readonly languageServiceEnabled: boolean;

/** TypeScript version used by the server. */

readonly version: string;

}

/**

* Info that we may send about a file that was just opened.

* Info about a file will only be sent once per session, even if the file changes in ways that might affect the info.

* Currently this is only sent for '.js' files.

*/

export interface OpenFileInfoTelemetryEvent {

readonly eventName: typeof OpenFileInfoTelemetryEvent;

readonly data: OpenFileInfoTelemetryEventData;

}

export interface OpenFileInfoTelemetryEventData {

readonly info: OpenFileInfo;

}

export interface ProjectInfoTypeAcquisitionData {

readonly enable: boolean | undefined;

// Actual values of include/exclude entries are scrubbed.

readonly include: boolean;

readonly exclude: boolean;

}

export interface FileStats {

readonly js: number;

readonly jsSize?: number;

readonly jsx: number;

readonly jsxSize?: number;

readonly ts: number;

readonly tsSize?: number;

readonly tsx: number;

readonly tsxSize?: number;

readonly dts: number;

readonly dtsSize?: number;

readonly deferred: number;

readonly deferredSize?: number;

}

export interface OpenFileInfo {

readonly checkJs: boolean;

}

export type ProjectServiceEvent =

LargeFileReferencedEvent

| ProjectsUpdatedInBackgroundEvent

| ProjectLoadingStartEvent

| ProjectLoadingFinishEvent

| ConfigFileDiagEvent

| ProjectLanguageServiceStateEvent

| ProjectInfoTelemetryEvent

| OpenFileInfoTelemetryEvent;

export type ProjectServiceEventHandler = (event: ProjectServiceEvent) => void;

/** @internal */

export type PerformanceEventHandler = (event: PerformanceEvent) => void;

export interface SafeList {

[name: string]: { match: RegExp, exclude?: (string | number)[][], types?: string[] };

}

function prepareConvertersForEnumLikeCompilerOptions(commandLineOptions: CommandLineOption[]): Map<string, Map<string, number>> {

const map = new Map<string, Map<string, number>>();

for (const option of commandLineOptions) {

if (typeof option.type === "object") {

const optionMap = option.type as Map<string, number>;

// verify that map contains only numbers

optionMap.forEach(value => {

Debug.assert(typeof value === "number");

});

map.set(option.name, optionMap);

}

}

return map;

}

const compilerOptionConverters = prepareConvertersForEnumLikeCompilerOptions(optionDeclarations);

const watchOptionsConverters = prepareConvertersForEnumLikeCompilerOptions(optionsForWatch);

const indentStyle = new Map(Object.entries({

none: IndentStyle.None,

block: IndentStyle.Block,

smart: IndentStyle.Smart

}));

export interface TypesMapFile {

typesMap: SafeList;

simpleMap: { [libName: string]: string };

}

/**

* How to understand this block:

* * The 'match' property is a regexp that matches a filename.

* * If 'match' is successful, then:

* * All files from 'exclude' are removed from the project. See below.

* * All 'types' are included in ATA

* * What the heck is 'exclude' ?

* * An array of an array of strings and numbers

* * Each array is:

* * An array of strings and numbers

* * The strings are literals

* * The numbers refer to capture group indices from the 'match' regexp

* * Remember that '1' is the first group

* * These are concatenated together to form a new regexp

* * Filenames matching these regexps are excluded from the project

* This default value is tested in tsserverProjectSystem.ts; add tests there

* if you are changing this so that you can be sure your regexp works!

*/

const defaultTypeSafeList: SafeList = {

"jquery": {

// jquery files can have names like "jquery-1.10.2.min.js" (or "jquery.intellisense.js")

match: /jquery(-[\d\.]+)?(\.intellisense)?(\.min)?\.js$/i,

types: ["jquery"]

},

"WinJS": {

// e.g. c:/temp/UWApp1/lib/winjs-4.0.1/js/base.js

match: /^(.*\/winjs-[.\d]+)\/js\/base\.js$/i, // If the winjs/base.js file is found..

exclude: [["^", 1, "/.*"]], // ..then exclude all files under the winjs folder

types: ["winjs"] // And fetch the @types package for WinJS

},

"Kendo": {

// e.g. /Kendo3/wwwroot/lib/kendo/kendo.all.min.js

match: /^(.*\/kendo(-ui)?)\/kendo\.all(\.min)?\.js$/i,

exclude: [["^", 1, "/.*"]],

types: ["kendo-ui"]

},

"Office Nuget": {

// e.g. /scripts/Office/1/excel-15.debug.js

match: /^(.*\/office\/1)\/excel-\d+\.debug\.js$/i, // Office NuGet package is installed under a "1/office" folder

exclude: [["^", 1, "/.*"]], // Exclude that whole folder if the file indicated above is found in it

types: ["office"] // @types package to fetch instead

},

"References": {

match: /^(.*\/_references\.js)$/i,

exclude: [["^", 1, "$"]]

}

};

export function convertFormatOptions(protocolOptions: protocol.FormatCodeSettings): FormatCodeSettings {

if (isString(protocolOptions.indentStyle)) {

protocolOptions.indentStyle = indentStyle.get(protocolOptions.indentStyle.toLowerCase());

Debug.assert(protocolOptions.indentStyle !== undefined);

}

return protocolOptions as any;

}

export function convertCompilerOptions(protocolOptions: protocol.ExternalProjectCompilerOptions): CompilerOptions & protocol.CompileOnSaveMixin {

compilerOptionConverters.forEach((mappedValues, id) => {

const propertyValue = protocolOptions[id];

if (isString(propertyValue)) {

protocolOptions[id] = mappedValues.get(propertyValue.toLowerCase());

}

});

return protocolOptions as any;

}

export function convertWatchOptions(protocolOptions: protocol.ExternalProjectCompilerOptions, currentDirectory?: string): WatchOptionsAndErrors | undefined {

let watchOptions: WatchOptions | undefined;

let errors: Diagnostic[] | undefined;

optionsForWatch.forEach(option => {

const propertyValue = protocolOptions[option.name];

if (propertyValue === undefined) return;

const mappedValues = watchOptionsConverters.get(option.name);

(watchOptions || (watchOptions = {}))[option.name] = mappedValues ?

isString(propertyValue) ? mappedValues.get(propertyValue.toLowerCase()) : propertyValue :

convertJsonOption(option, propertyValue, currentDirectory || "", errors || (errors = []));

});

return watchOptions && { watchOptions, errors };

}

export function convertTypeAcquisition(protocolOptions: protocol.InferredProjectCompilerOptions): TypeAcquisition | undefined {

let result: TypeAcquisition | undefined;

typeAcquisitionDeclarations.forEach((option) => {

const propertyValue = protocolOptions[option.name];

if (propertyValue === undefined) return;

(result || (result = {}))[option.name] = propertyValue;

});

return result;

}

export function tryConvertScriptKindName(scriptKindName: protocol.ScriptKindName | ScriptKind): ScriptKind {

return isString(scriptKindName) ? convertScriptKindName(scriptKindName) : scriptKindName;

}

export function convertScriptKindName(scriptKindName: protocol.ScriptKindName) {

switch (scriptKindName) {

case "JS":

return ScriptKind.JS;

case "JSX":

return ScriptKind.JSX;

case "TS":

return ScriptKind.TS;

case "TSX":

return ScriptKind.TSX;

default:

return ScriptKind.Unknown;

}

}

/** @internal */

export function convertUserPreferences(preferences: protocol.UserPreferences): UserPreferences {

const { lazyConfiguredProjectsFromExternalProject, ...userPreferences } = preferences;

return userPreferences;

}

export interface HostConfiguration {

formatCodeOptions: FormatCodeSettings;

preferences: protocol.UserPreferences;

hostInfo: string;

extraFileExtensions?: FileExtensionInfo[];

watchOptions?: WatchOptions;

}

export interface OpenConfiguredProjectResult {

configFileName?: NormalizedPath;

configFileErrors?: readonly Diagnostic[];

}

interface AssignProjectResult extends OpenConfiguredProjectResult {

retainProjects: readonly ConfiguredProject[] | ConfiguredProject | undefined;

}

interface FilePropertyReader<T> {

getFileName(f: T): string;

getScriptKind(f: T, extraFileExtensions?: FileExtensionInfo[]): ScriptKind;

hasMixedContent(f: T, extraFileExtensions: FileExtensionInfo[] | undefined): boolean;

}

const fileNamePropertyReader: FilePropertyReader<string> = {

getFileName: x => x,

getScriptKind: (fileName, extraFileExtensions) => {

let result: ScriptKind | undefined;

if (extraFileExtensions) {

const fileExtension = getAnyExtensionFromPath(fileName);

if (fileExtension) {

some(extraFileExtensions, info => {

if (info.extension === fileExtension) {

result = info.scriptKind;

return true;

}

return false;

});

}

}

return result!; // TODO: GH#18217

},

hasMixedContent: (fileName, extraFileExtensions) => some(extraFileExtensions, ext => ext.isMixedContent && fileExtensionIs(fileName, ext.extension)),

};

const externalFilePropertyReader: FilePropertyReader<protocol.ExternalFile> = {

getFileName: x => x.fileName,

getScriptKind: x => tryConvertScriptKindName(x.scriptKind!), // TODO: GH#18217

hasMixedContent: x => !!x.hasMixedContent,

};

function findProjectByName<T extends Project>(projectName: string, projects: T[]): T | undefined {

for (const proj of projects) {

if (proj.getProjectName() === projectName) {

return proj;

}

}

}

const noopConfigFileWatcher: FileWatcher = { close: noop };

/** @internal */

export interface ConfigFileExistenceInfo {

/**

* Cached value of existence of config file

* It is true if there is configured project open for this file.

* It can be either true or false if this is the config file that is being watched by inferred project

* to decide when to update the structure so that it knows about updating the project for its files

* (config file may include the inferred project files after the change and hence may be wont need to be in inferred project)

*/

exists: boolean;

/**

* openFilesImpactedByConfigFiles is a map of open files that would be impacted by this config file

* because these are the paths being looked up for their default configured project location

* The value in the map is true if the open file is root of the inferred project

* It is false when the open file that would still be impacted by existence of

* this config file but it is not the root of inferred project

*/

openFilesImpactedByConfigFile?: Map<Path, boolean>;

/**

* The file watcher watching the config file because there is open script info that is root of

* inferred project and will be impacted by change in the status of the config file

* or

* Configured project for this config file is open

* or

* Configured project references this config file

*/

watcher?: FileWatcher;

/**

* Cached parsed command line and other related information like watched directories etc

*/

config?: ParsedConfig;

}

export interface ProjectServiceOptions {

host: ServerHost;

logger: Logger;

cancellationToken: HostCancellationToken;

useSingleInferredProject: boolean;

useInferredProjectPerProjectRoot: boolean;

typingsInstaller: ITypingsInstaller;

eventHandler?: ProjectServiceEventHandler;

suppressDiagnosticEvents?: boolean;

throttleWaitMilliseconds?: number;

globalPlugins?: readonly string[];

pluginProbeLocations?: readonly string[];

allowLocalPluginLoads?: boolean;

typesMapLocation?: string;

serverMode?: LanguageServiceMode;

session: Session<unknown> | undefined;

}

interface OriginalFileInfo { fileName: NormalizedPath; path: Path; }

interface AncestorConfigFileInfo {

/** config file name */

fileName: string;

/** path of open file so we can look at correct root */

path: Path;

configFileInfo: true;

}

type OpenScriptInfoOrClosedFileInfo = ScriptInfo | OriginalFileInfo;

type OpenScriptInfoOrClosedOrConfigFileInfo = OpenScriptInfoOrClosedFileInfo | AncestorConfigFileInfo;

function isOpenScriptInfo(infoOrFileNameOrConfig: OpenScriptInfoOrClosedOrConfigFileInfo): infoOrFileNameOrConfig is ScriptInfo {

return !!(infoOrFileNameOrConfig as ScriptInfo).containingProjects;

}

function isAncestorConfigFileInfo(infoOrFileNameOrConfig: OpenScriptInfoOrClosedOrConfigFileInfo): infoOrFileNameOrConfig is AncestorConfigFileInfo {

return !!(infoOrFileNameOrConfig as AncestorConfigFileInfo).configFileInfo;

}

/**

* Kind of operation to perform to get project reference project

*

* @internal

*/

export enum ProjectReferenceProjectLoadKind {

/** Find existing project for project reference */

Find,

/** Find existing project or create one for the project reference */

FindCreate,

/** Find existing project or create and load it for the project reference */

FindCreateLoad

}

/** @internal */

export function forEachResolvedProjectReferenceProject<T>(

project: ConfiguredProject,

fileName: string | undefined,

cb: (child: ConfiguredProject) => T | undefined,

projectReferenceProjectLoadKind: ProjectReferenceProjectLoadKind.Find | ProjectReferenceProjectLoadKind.FindCreate,

): T | undefined;

/** @internal */

export function forEachResolvedProjectReferenceProject<T>(

project: ConfiguredProject,

fileName: string | undefined,

cb: (child: ConfiguredProject) => T | undefined,

projectReferenceProjectLoadKind: ProjectReferenceProjectLoadKind,

reason: string

): T | undefined;

export function forEachResolvedProjectReferenceProject<T>(

project: ConfiguredProject,

fileName: string | undefined,

cb: (child: ConfiguredProject) => T | undefined,

projectReferenceProjectLoadKind: ProjectReferenceProjectLoadKind,

reason?: string

): T | undefined {

const resolvedRefs = project.getCurrentProgram()?.getResolvedProjectReferences();

if (!resolvedRefs) return undefined;

let seenResolvedRefs: Map<string, ProjectReferenceProjectLoadKind> | undefined;

const possibleDefaultRef = fileName ? project.getResolvedProjectReferenceToRedirect(fileName) : undefined;

if (possibleDefaultRef) {

// Try to find the name of the file directly through resolved project references

const configFileName = toNormalizedPath(possibleDefaultRef.sourceFile.fileName);

const child = project.projectService.findConfiguredProjectByProjectName(configFileName);

if (child) {

const result = cb(child);

if (result) return result;

}

else if (projectReferenceProjectLoadKind !== ProjectReferenceProjectLoadKind.Find) {

seenResolvedRefs = new Map();

// Try to see if this project can be loaded

const result = forEachResolvedProjectReferenceProjectWorker(

resolvedRefs,

project.getCompilerOptions(),

(ref, loadKind) => possibleDefaultRef === ref ? callback(ref, loadKind) : undefined,

projectReferenceProjectLoadKind,

project.projectService,

seenResolvedRefs

);

if (result) return result;

// Cleanup seenResolvedRefs

seenResolvedRefs.clear();

}

}

return forEachResolvedProjectReferenceProjectWorker(

resolvedRefs,

project.getCompilerOptions(),

(ref, loadKind) => possibleDefaultRef !== ref ? callback(ref, loadKind) : undefined,

projectReferenceProjectLoadKind,

project.projectService,

seenResolvedRefs

);

function callback(ref: ResolvedProjectReference, loadKind: ProjectReferenceProjectLoadKind) {

const configFileName = toNormalizedPath(ref.sourceFile.fileName);

const child = project.projectService.findConfiguredProjectByProjectName(configFileName) || (

loadKind === ProjectReferenceProjectLoadKind.Find ?

undefined :

loadKind === ProjectReferenceProjectLoadKind.FindCreate ?

project.projectService.createConfiguredProject(configFileName) :

loadKind === ProjectReferenceProjectLoadKind.FindCreateLoad ?

project.projectService.createAndLoadConfiguredProject(configFileName, reason!) :

Debug.assertNever(loadKind)

);

return child && cb(child);

}

}

function forEachResolvedProjectReferenceProjectWorker<T>(

resolvedProjectReferences: readonly (ResolvedProjectReference | undefined)[],

parentOptions: CompilerOptions,

cb: (resolvedRef: ResolvedProjectReference, loadKind: ProjectReferenceProjectLoadKind) => T | undefined,

projectReferenceProjectLoadKind: ProjectReferenceProjectLoadKind,

projectService: ProjectService,

seenResolvedRefs: Map<string, ProjectReferenceProjectLoadKind> | undefined,

): T | undefined {

const loadKind = parentOptions.disableReferencedProjectLoad ? ProjectReferenceProjectLoadKind.Find : projectReferenceProjectLoadKind;

return forEach(resolvedProjectReferences, ref => {

if (!ref) return undefined;

const configFileName = toNormalizedPath(ref.sourceFile.fileName);

const canonicalPath = projectService.toCanonicalFileName(configFileName);

const seenValue = seenResolvedRefs?.get(canonicalPath);

if (seenValue !== undefined && seenValue >= loadKind) {

return undefined;

}

const result = cb(ref, loadKind);

if (result) {

return result;

}

(seenResolvedRefs || (seenResolvedRefs = new Map())).set(canonicalPath, loadKind);

return ref.references && forEachResolvedProjectReferenceProjectWorker(ref.references, ref.commandLine.options, cb, loadKind, projectService, seenResolvedRefs);

});

}

function forEachPotentialProjectReference<T>(

project: ConfiguredProject,

cb: (potentialProjectReference: NormalizedPath) => T | undefined

): T | undefined {

return project.potentialProjectReferences &&

forEachKey(project.potentialProjectReferences, cb);

}

function forEachAnyProjectReferenceKind<T>(

project: ConfiguredProject,

cb: (resolvedProjectReference: ResolvedProjectReference) => T | undefined,

cbProjectRef: (projectReference: ProjectReference) => T | undefined,

cbPotentialProjectRef: (potentialProjectReference: NormalizedPath) => T | undefined

): T | undefined {

return project.getCurrentProgram() ?

project.forEachResolvedProjectReference(cb) :

project.isInitialLoadPending() ?

forEachPotentialProjectReference(project, cbPotentialProjectRef) :

forEach(project.getProjectReferences(), cbProjectRef);

}

function callbackRefProject<T, P extends string>(

project: ConfiguredProject,

cb: (refProj: ConfiguredProject) => T | undefined,

refPath: P | undefined

) {

const refProject = refPath && project.projectService.configuredProjects.get(refPath);

return refProject && cb(refProject);

}

function forEachReferencedProject<T>(

project: ConfiguredProject,

cb: (refProj: ConfiguredProject) => T | undefined

): T | undefined {

return forEachAnyProjectReferenceKind(

project,

resolvedRef => callbackRefProject(project, cb, resolvedRef.sourceFile.path),

projectRef => callbackRefProject(project, cb, project.toPath(resolveProjectReferencePath(projectRef))),

potentialProjectRef => callbackRefProject(project, cb, potentialProjectRef)

);

}

interface NodeModulesWatcher extends FileWatcher {

/** How many watchers of this directory were for closed ScriptInfo */

refreshScriptInfoRefCount: number;

/** List of project names whose module specifier cache should be cleared when package.jsons change */

affectedModuleSpecifierCacheProjects?: Set<string>;

}

function getDetailWatchInfo(watchType: WatchType, project: Project | NormalizedPath | undefined) {

return `${isString(project) ? `Config: ${project} ` : project ? `Project: ${project.getProjectName()} ` : ""}WatchType: ${watchType}`;

}

function isScriptInfoWatchedFromNodeModules(info: ScriptInfo) {

return !info.isScriptOpen() && info.mTime !== undefined;

}

/**

* true if script info is part of project and is not in project because it is referenced from project reference source

*

* @internal

*/

export function projectContainsInfoDirectly(project: Project, info: ScriptInfo) {

return project.containsScriptInfo(info) &&

!project.isSourceOfProjectReferenceRedirect(info.path);

}

/** @internal */

export function updateProjectIfDirty(project: Project) {

project.invalidateResolutionsOfFailedLookupLocations();

return project.dirty && project.updateGraph();

}

function setProjectOptionsUsed(project: ConfiguredProject | ExternalProject) {

if (isConfiguredProject(project)) {

project.projectOptions = true;

}

}

/** @internal */

export interface OpenFileArguments {

fileName: string;

content?: string;

scriptKind?: protocol.ScriptKindName | ScriptKind;

hasMixedContent?: boolean;

projectRootPath?: string;

}

/** @internal */

export interface ChangeFileArguments {

fileName: string;

changes: Iterable<TextChange>;

}

export interface WatchOptionsAndErrors {

watchOptions: WatchOptions;

errors: Diagnostic[] | undefined;

}

/** @internal */

export interface ParsedConfig{

cachedDirectoryStructureHost: CachedDirectoryStructureHost;

/**

* The map contains

* - true if project is watching config file as well as wild cards

* - false if just config file is watched

*/

projects: Map<NormalizedPath, boolean>;

parsedCommandLine?: ParsedCommandLine;

watchedDirectories?: Map<string, WildcardDirectoryWatcher>;

/**

* true if watchedDirectories need to be updated as per parsedCommandLine's updated watched directories

*/

watchedDirectoriesStale?: boolean;

reloadLevel?: ConfigFileProgramReloadLevel.Partial | ConfigFileProgramReloadLevel.Full;

}

function createProjectNameFactoryWithCounter(nameFactory: (counter: number) => string) {

let nextId = 1;

return () => nameFactory(nextId++);

}

export class ProjectService {

/** @internal */

readonly typingsCache: TypingsCache;

/** @internal */

readonly documentRegistry: DocumentRegistry;

/**

* Container of all known scripts

*

* @internal

*/

readonly filenameToScriptInfo = new Map<string, ScriptInfo>();

private readonly nodeModulesWatchers = new Map<string, NodeModulesWatcher>();

/**

* Contains all the deleted script info's version information so that

* it does not reset when creating script info again

* (and could have potentially collided with version where contents mismatch)

*/

private readonly filenameToScriptInfoVersion = new Map<string, number>();

// Set of all '.js' files ever opened.

private readonly allJsFilesForOpenFileTelemetry = new Map<string, true>();

/**

* Map to the real path of the infos

*

* @internal

*/

readonly realpathToScriptInfos: MultiMap<Path, ScriptInfo> | undefined;

/**

* maps external project file name to list of config files that were the part of this project

*/

private readonly externalProjectToConfiguredProjectMap = new Map<string, NormalizedPath[]>();

/**

* external projects (configuration and list of root files is not controlled by tsserver)

*/

readonly externalProjects: ExternalProject[] = [];

/**

* projects built from openFileRoots

*/

readonly inferredProjects: InferredProject[] = [];

/**

* projects specified by a tsconfig.json file

*/

readonly configuredProjects: Map<string, ConfiguredProject> = new Map<string, ConfiguredProject>();

/** @internal */

readonly newInferredProjectName = createProjectNameFactoryWithCounter(makeInferredProjectName);

/** @internal */

readonly newAutoImportProviderProjectName = createProjectNameFactoryWithCounter(makeAutoImportProviderProjectName);

/** @internal */

readonly newAuxiliaryProjectName = createProjectNameFactoryWithCounter(makeAuxiliaryProjectName);

/**

* Open files: with value being project root path, and key being Path of the file that is open

*/

readonly openFiles: Map<string, NormalizedPath | undefined> = new Map<Path, NormalizedPath | undefined>();

/** @internal */

readonly configFileForOpenFiles: Map<Path, NormalizedPath | false> = new Map();

/**

* Map of open files that are opened without complete path but have projectRoot as current directory

*/

private readonly openFilesWithNonRootedDiskPath = new Map<string, ScriptInfo>();

private compilerOptionsForInferredProjects: CompilerOptions | undefined;

private compilerOptionsForInferredProjectsPerProjectRoot = new Map<string, CompilerOptions>();

private watchOptionsForInferredProjects: WatchOptionsAndErrors | undefined;

private watchOptionsForInferredProjectsPerProjectRoot = new Map<string, WatchOptionsAndErrors | false>();

private typeAcquisitionForInferredProjects: TypeAcquisition | undefined;

private typeAcquisitionForInferredProjectsPerProjectRoot = new Map<string, TypeAcquisition | undefined>();

/**

* Project size for configured or external projects

*/

private readonly projectToSizeMap = new Map<string, number>();

/**

* This is a map of config file paths existence that doesnt need query to disk

* - The entry can be present because there is inferred project that needs to watch addition of config file to directory

* In this case the exists could be true/false based on config file is present or not

* - Or it is present if we have configured project open with config file at that location

* In this case the exists property is always true

*

*

* @internal

*/

readonly configFileExistenceInfoCache = new Map<NormalizedPath, ConfigFileExistenceInfo>();

/** @internal */ readonly throttledOperations: ThrottledOperations;

private readonly hostConfiguration: HostConfiguration;

private safelist: SafeList = defaultTypeSafeList;

private readonly legacySafelist = new Map<string, string>();

private pendingProjectUpdates = new Map<string, Project>();

/** @internal */

pendingEnsureProjectForOpenFiles = false;

readonly currentDirectory: NormalizedPath;

readonly toCanonicalFileName: (f: string) => string;

public readonly host: ServerHost;

public readonly logger: Logger;

public readonly cancellationToken: HostCancellationToken;

public readonly useSingleInferredProject: boolean;

public readonly useInferredProjectPerProjectRoot: boolean;

public readonly typingsInstaller: ITypingsInstaller;

private readonly globalCacheLocationDirectoryPath: Path | undefined;

public readonly throttleWaitMilliseconds?: number;

private readonly eventHandler?: ProjectServiceEventHandler;

private readonly suppressDiagnosticEvents?: boolean;

public readonly globalPlugins: readonly string[];

public readonly pluginProbeLocations: readonly string[];

public readonly allowLocalPluginLoads: boolean;

private currentPluginConfigOverrides: Map<string, any> | undefined;

public readonly typesMapLocation: string | undefined;

public readonly serverMode: LanguageServiceMode;

/** Tracks projects that we have already sent telemetry for. */

private readonly seenProjects = new Map<string, true>();

/** @internal */

readonly watchFactory: WatchFactory<WatchType, Project | NormalizedPath>;

/** @internal */

private readonly sharedExtendedConfigFileWatchers = new Map<Path, SharedExtendedConfigFileWatcher<NormalizedPath>>();

/** @internal */

private readonly extendedConfigCache = new Map<string, ExtendedConfigCacheEntry>();

/** @internal */

readonly packageJsonCache: PackageJsonCache;

/** @internal */

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

/** @internal */

private incompleteCompletionsCache: IncompleteCompletionsCache | undefined;

/** @internal */

readonly session: Session<unknown> | undefined;

private performanceEventHandler?: PerformanceEventHandler;

private pendingPluginEnablements?: Map<Project, Promise<BeginEnablePluginResult>[]>;

private currentPluginEnablementPromise?: Promise<void>;

constructor(opts: ProjectServiceOptions) {

this.host = opts.host;

this.logger = opts.logger;

this.cancellationToken = opts.cancellationToken;

this.useSingleInferredProject = opts.useSingleInferredProject;