namespace ts.server {

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";

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;

export interface SafeList {

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

}

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

const map: Map<Map<number>> = createMap<Map<number>>();

for (const option of commandLineOptions) {

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

const optionMap = <Map<number>>option.type;

// 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 indentStyle = createMapFromTemplate({

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 <any>protocolOptions;

}

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 <any>protocolOptions;

}

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[];

}

export interface OpenConfiguredProjectResult {

configFileName?: NormalizedPath;

configFileErrors?: readonly Diagnostic[];

}

interface AssignProjectResult extends OpenConfiguredProjectResult {

defaultConfigProject: 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 enum ConfigFileWatcherStatus {

ReloadingFiles = "Reloading configured projects for files",

ReloadingInferredRootFiles = "Reloading configured projects for only inferred root files",

UpdatedCallback = "Updated the callback",

OpenFilesImpactedByConfigFileAdd = "File added to open files impacted by this config file",

OpenFilesImpactedByConfigFileRemove = "File removed from open files impacted by this config file",

RootOfInferredProjectTrue = "Open file was set as Inferred root",

RootOfInferredProjectFalse = "Open file was set as not inferred root",

}

/*@internal*/

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 existance of

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

*/

openFilesImpactedByConfigFile: Map<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

* The watcher is present only when there is no open configured project for the config file

*/

configFileWatcherForRootOfInferredProject?: FileWatcher;

}

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;

syntaxOnly?: boolean;

}

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

type OpenScriptInfoOrClosedFileInfo = ScriptInfo | OriginalFileInfo;

function isOpenScriptInfo(infoOrFileName: OpenScriptInfoOrClosedFileInfo): infoOrFileName is ScriptInfo {

return !!(infoOrFileName as ScriptInfo).containingProjects;

}

interface ScriptInfoInNodeModulesWatcher extends FileWatcher {

refCount: number;

}

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

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

}

function isScriptInfoWatchedFromNodeModules(info: ScriptInfo) {

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

}

/*@internal*/

export function updateProjectIfDirty(project: Project) {

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

}

function setProjectOptionsUsed(project: ConfiguredProject | ExternalProject) {

if (project.projectKind === ProjectKind.Configured) {

(project as ConfiguredProject).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: Iterator<TextChange>;

}

export class ProjectService {

/*@internal*/

readonly typingsCache: TypingsCache;

/*@internal*/

readonly documentRegistry: DocumentRegistry;

/**

* Container of all known scripts

*/

/*@internal*/

readonly filenameToScriptInfo = createMap<ScriptInfo>();

private readonly scriptInfoInNodeModulesWatchers = createMap <ScriptInfoInNodeModulesWatcher>();

/**

* 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 = createMap<ScriptInfoVersion>();

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

private readonly allJsFilesForOpenFileTelemetry = createMap<true>();

/**

* Map to the real path of the infos

*/

/* @internal */

readonly realpathToScriptInfos: MultiMap<ScriptInfo> | undefined;

/**

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

*/

private readonly externalProjectToConfiguredProjectMap: Map<NormalizedPath[]> = createMap<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 = createMap<ConfiguredProject>();

/**

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

*/

readonly openFiles = createMap<NormalizedPath | undefined>();

/**

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

*/

private readonly openFilesWithNonRootedDiskPath = createMap<ScriptInfo>();

private compilerOptionsForInferredProjects: CompilerOptions | undefined;

private compilerOptionsForInferredProjectsPerProjectRoot = createMap<CompilerOptions>();

/**

* Project size for configured or external projects

*/

private readonly projectToSizeMap: Map<number> = createMap<number>();

/**

* This is a map of config file paths existance 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

*/

private readonly configFileExistenceInfoCache = createMap<ConfigFileExistenceInfo>();

private readonly throttledOperations: ThrottledOperations;

private readonly hostConfiguration: HostConfiguration;

private safelist: SafeList = defaultTypeSafeList;

private readonly legacySafelist = createMap<string>();

private pendingProjectUpdates = createMap<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<any> | undefined;

public readonly typesMapLocation: string | undefined;

public readonly syntaxOnly?: boolean;

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

private readonly seenProjects = createMap<true>();

/*@internal*/

readonly watchFactory: WatchFactory<WatchType, Project>;

constructor(opts: ProjectServiceOptions) {

this.host = opts.host;

this.logger = opts.logger;

this.cancellationToken = opts.cancellationToken;

this.useSingleInferredProject = opts.useSingleInferredProject;

this.useInferredProjectPerProjectRoot = opts.useInferredProjectPerProjectRoot;

this.typingsInstaller = opts.typingsInstaller || nullTypingsInstaller;

this.throttleWaitMilliseconds = opts.throttleWaitMilliseconds;

this.eventHandler = opts.eventHandler;

this.suppressDiagnosticEvents = opts.suppressDiagnosticEvents;

this.globalPlugins = opts.globalPlugins || emptyArray;

this.pluginProbeLocations = opts.pluginProbeLocations || emptyArray;

this.allowLocalPluginLoads = !!opts.allowLocalPluginLoads;

this.typesMapLocation = (opts.typesMapLocation === undefined) ? combinePaths(getDirectoryPath(this.getExecutingFilePath()), "typesMap.json") : opts.typesMapLocation;

this.syntaxOnly = opts.syntaxOnly;

Debug.assert(!!this.host.createHash, "'ServerHost.createHash' is required for ProjectService");

if (this.host.realpath) {

this.realpathToScriptInfos = createMultiMap();

}

this.currentDirectory = toNormalizedPath(this.host.getCurrentDirectory());

this.toCanonicalFileName = createGetCanonicalFileName(this.host.useCaseSensitiveFileNames);

this.globalCacheLocationDirectoryPath = this.typingsInstaller.globalTypingsCacheLocation

? ensureTrailingDirectorySeparator(this.toPath(this.typingsInstaller.globalTypingsCacheLocation))

: undefined;

this.throttledOperations = new ThrottledOperations(this.host, this.logger);

if (this.typesMapLocation) {

this.loadTypesMap();

}

else {

this.logger.info("No types map provided; using the default");

}

this.typingsInstaller.attach(this);

this.typingsCache = new TypingsCache(this.typingsInstaller);

this.hostConfiguration = {

formatCodeOptions: getDefaultFormatCodeSettings(this.host.newLine),

preferences: emptyOptions,

hostInfo: "Unknown host",

extraFileExtensions: []

};

this.documentRegistry = createDocumentRegistryInternal(this.host.useCaseSensitiveFileNames, this.currentDirectory, this);

const watchLogLevel = this.logger.hasLevel(LogLevel.verbose) ? WatchLogLevel.Verbose :

this.logger.loggingEnabled() ? WatchLogLevel.TriggerOnly : WatchLogLevel.None;

const log: (s: string) => void = watchLogLevel !== WatchLogLevel.None ? (s => this.logger.info(s)) : noop;

this.watchFactory = getWatchFactory(watchLogLevel, log, getDetailWatchInfo);

}

toPath(fileName: string) {

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

}

/*@internal*/

getExecutingFilePath() {

return this.getNormalizedAbsolutePath(this.host.getExecutingFilePath());

}

/*@internal*/

getNormalizedAbsolutePath(fileName: string) {

return getNormalizedAbsolutePath(fileName, this.host.getCurrentDirectory());

}

/*@internal*/

setDocument(key: DocumentRegistryBucketKey, path: Path, sourceFile: SourceFile) {

const info = Debug.assertDefined(this.getScriptInfoForPath(path));

info.cacheSourceFile = { key, sourceFile };

}

/*@internal*/

getDocument(key: DocumentRegistryBucketKey, path: Path): SourceFile | undefined {

const info = this.getScriptInfoForPath(path);

return info && info.cacheSourceFile && info.cacheSourceFile.key === key ? info.cacheSourceFile.sourceFile : undefined;

}

/* @internal */

ensureInferredProjectsUpToDate_TestOnly() {

this.ensureProjectStructuresUptoDate();

}

/* @internal */

getCompilerOptionsForInferredProjects() {

return this.compilerOptionsForInferredProjects;

}

/* @internal */

onUpdateLanguageServiceStateForProject(project: Project, languageServiceEnabled: boolean) {

if (!this.eventHandler) {

return;

}

const event: ProjectLanguageServiceStateEvent = {

eventName: ProjectLanguageServiceStateEvent,

data: { project, languageServiceEnabled }

};

this.eventHandler(event);

}

private loadTypesMap() {

try {

const fileContent = this.host.readFile(this.typesMapLocation!); // TODO: GH#18217

if (fileContent === undefined) {

this.logger.info(`Provided types map file "${this.typesMapLocation}" doesn't exist`);

return;

}

const raw: TypesMapFile = JSON.parse(fileContent);

// Parse the regexps

for (const k of Object.keys(raw.typesMap)) {

raw.typesMap[k].match = new RegExp(raw.typesMap[k].match as {} as string, "i");

}

// raw is now fixed and ready

this.safelist = raw.typesMap;

for (const key in raw.simpleMap) {

if (raw.simpleMap.hasOwnProperty(key)) {

this.legacySafelist.set(key, raw.simpleMap[key].toLowerCase());

}

}

}

catch (e) {

this.logger.info(`Error loading types map: ${e}`);

this.safelist = defaultTypeSafeList;

this.legacySafelist.clear();

}

}

updateTypingsForProject(response: SetTypings | InvalidateCachedTypings | PackageInstalledResponse): void;

/** @internal */

updateTypingsForProject(response: SetTypings | InvalidateCachedTypings | PackageInstalledResponse | BeginInstallTypes | EndInstallTypes): void; // eslint-disable-line @typescript-eslint/unified-signatures

updateTypingsForProject(response: SetTypings | InvalidateCachedTypings | PackageInstalledResponse | BeginInstallTypes | EndInstallTypes): void {

const project = this.findProject(response.projectName);

if (!project) {

return;

}

switch (response.kind) {

case ActionSet:

// Update the typing files and update the project

project.updateTypingFiles(this.typingsCache.updateTypingsForProject(response.projectName, response.compilerOptions, response.typeAcquisition, response.unresolvedImports, response.typings));

break;

case ActionInvalidate:

// Do not clear resolution cache, there was changes detected in typings, so enque typing request and let it get us correct results

this.typingsCache.enqueueInstallTypingsForProject(project, project.lastCachedUnresolvedImportsList, /*forceRefresh*/ true);

return;

}

this.delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(project);

}

private delayEnsureProjectForOpenFiles() {

this.pendingEnsureProjectForOpenFiles = true;

this.throttledOperations.schedule("*ensureProjectForOpenFiles*", /*delay*/ 250, () => {

if (this.pendingProjectUpdates.size !== 0) {

this.delayEnsureProjectForOpenFiles();

}

else {

if (this.pendingEnsureProjectForOpenFiles) {

this.ensureProjectForOpenFiles();

// Send the event to notify that there were background project updates

// send current list of open files

this.sendProjectsUpdatedInBackgroundEvent();

}

}

});

}

private delayUpdateProjectGraph(project: Project) {

project.markAsDirty();

const projectName = project.getProjectName();

this.pendingProjectUpdates.set(projectName, project);

this.throttledOperations.schedule(projectName, /*delay*/ 250, () => {

if (this.pendingProjectUpdates.delete(projectName)) {

updateProjectIfDirty(project);

}

});

}

/*@internal*/

hasPendingProjectUpdate(project: Project) {

return this.pendingProjectUpdates.has(project.getProjectName());

}

/* @internal */

sendProjectsUpdatedInBackgroundEvent() {

if (!this.eventHandler) {

return;

}

const event: ProjectsUpdatedInBackgroundEvent = {

eventName: ProjectsUpdatedInBackgroundEvent,

data: {

openFiles: arrayFrom(this.openFiles.keys(), path => this.getScriptInfoForPath(path as Path)!.fileName)

}

};

this.eventHandler(event);

}

/* @internal */

sendLargeFileReferencedEvent(file: string, fileSize: number) {

if (!this.eventHandler) {

return;

}

const event: LargeFileReferencedEvent = {

eventName: LargeFileReferencedEvent,

data: { file, fileSize, maxFileSize }

};

this.eventHandler(event);

}

/* @internal */

sendProjectLoadingStartEvent(project: ConfiguredProject, reason: string) {

if (!this.eventHandler) {

return;

}

project.sendLoadingProjectFinish = true;

const event: ProjectLoadingStartEvent = {

eventName: ProjectLoadingStartEvent,

data: { project, reason }

};

this.eventHandler(event);

}

/* @internal */

sendProjectLoadingFinishEvent(project: ConfiguredProject) {

if (!this.eventHandler || !project.sendLoadingProjectFinish) {

return;

}

project.sendLoadingProjectFinish = false;

const event: ProjectLoadingFinishEvent = {

eventName: ProjectLoadingFinishEvent,

data: { project }

};

this.eventHandler(event);

}

/* @internal */

delayUpdateProjectGraphAndEnsureProjectStructureForOpenFiles(project: Project) {

this.delayUpdateProjectGraph(project);

this.delayEnsureProjectForOpenFiles();

}

private delayUpdateProjectGraphs(projects: readonly Project[]) {

if (projects.length) {

for (const project of projects) {

this.delayUpdateProjectGraph(project);

}

this.delayEnsureProjectForOpenFiles();

}

}

setCompilerOptionsForInferredProjects(projectCompilerOptions: protocol.ExternalProjectCompilerOptions, projectRootPath?: string): void {

Debug.assert(projectRootPath === undefined || this.useInferredProjectPerProjectRoot, "Setting compiler options per project root path is only supported when useInferredProjectPerProjectRoot is enabled");

const compilerOptions = convertCompilerOptions(projectCompilerOptions);

// always set 'allowNonTsExtensions' for inferred projects since user cannot configure it from the outside

// previously we did not expose a way for user to change these settings and this option was enabled by default

compilerOptions.allowNonTsExtensions = true;

const canonicalProjectRootPath = projectRootPath && this.toCanonicalFileName(projectRootPath);

if (canonicalProjectRootPath) {

this.compilerOptionsForInferredProjectsPerProjectRoot.set(canonicalProjectRootPath, compilerOptions);

}

else {

this.compilerOptionsForInferredProjects = compilerOptions;

}

for (const project of this.inferredProjects) {

// Only update compiler options in the following cases:

// - Inferred projects without a projectRootPath, if the new options do not apply to

// a workspace root

// - Inferred projects with a projectRootPath, if the new options do not apply to a

// workspace root and there is no more specific set of options for that project's

// root path

// - Inferred projects with a projectRootPath, if the new options apply to that

// project root path.

if (canonicalProjectRootPath ?

project.projectRootPath === canonicalProjectRootPath :

!project.projectRootPath || !this.compilerOptionsForInferredProjectsPerProjectRoot.has(project.projectRootPath)) {

project.setCompilerOptions(compilerOptions);

project.compileOnSaveEnabled = compilerOptions.compileOnSave!;

project.markAsDirty();

this.delayUpdateProjectGraph(project);

}

}

this.delayEnsureProjectForOpenFiles();

}

findProject(projectName: string): Project | undefined {

if (projectName === undefined) {

return undefined;

}

if (isInferredProjectName(projectName)) {

return findProjectByName(projectName, this.inferredProjects);

}

return this.findExternalProjectByProjectName(projectName) || this.findConfiguredProjectByProjectName(toNormalizedPath(projectName));

}

/* @internal */

private forEachProject(cb: (project: Project) => void) {

this.externalProjects.forEach(cb);

this.configuredProjects.forEach(cb);

this.inferredProjects.forEach(cb);

}

/* @internal */

forEachEnabledProject(cb: (project: Project) => void) {

this.forEachProject(project => {

if (!project.isOrphan() && project.languageServiceEnabled) {

cb(project);

}

});

}

getDefaultProjectForFile(fileName: NormalizedPath, ensureProject: boolean): Project | undefined {

return ensureProject ? this.ensureDefaultProjectForFile(fileName) : this.tryGetDefaultProjectForFile(fileName);

}

/* @internal */

tryGetDefaultProjectForFile(fileName: NormalizedPath): Project | undefined {

const scriptInfo = this.getScriptInfoForNormalizedPath(fileName);

return scriptInfo && !scriptInfo.isOrphan() ? scriptInfo.getDefaultProject() : undefined;

}

/* @internal */

ensureDefaultProjectForFile(fileName: NormalizedPath): Project {

return this.tryGetDefaultProjectForFile(fileName) || this.doEnsureDefaultProjectForFile(fileName);

}

private doEnsureDefaultProjectForFile(fileName: NormalizedPath): Project {

this.ensureProjectStructuresUptoDate();

const scriptInfo = this.getScriptInfoForNormalizedPath(fileName);

return scriptInfo ? scriptInfo.getDefaultProject() : (this.logErrorForScriptInfoNotFound(fileName), Errors.ThrowNoProject());

}

getScriptInfoEnsuringProjectsUptoDate(uncheckedFileName: string) {

this.ensureProjectStructuresUptoDate();

return this.getScriptInfo(uncheckedFileName);

}

/**

* Ensures the project structures are upto date

* This means,

* - we go through all the projects and update them if they are dirty

* - if updates reflect some change in structure or there was pending request to ensure projects for open files

* ensure that each open script info has project

*/

private ensureProjectStructuresUptoDate() {

let hasChanges = this.pendingEnsureProjectForOpenFiles;

this.pendingProjectUpdates.clear();

const updateGraph = (project: Project) => {

hasChanges = updateProjectIfDirty(project) || hasChanges;

};

this.externalProjects.forEach(updateGraph);

this.configuredProjects.forEach(updateGraph);

this.inferredProjects.forEach(updateGraph);

if (hasChanges) {

this.ensureProjectForOpenFiles();

}

}

getFormatCodeOptions(file: NormalizedPath) {

const info = this.getScriptInfoForNormalizedPath(file);

return info && info.getFormatCodeSettings() || this.hostConfiguration.formatCodeOptions;

}

getPreferences(file: NormalizedPath): protocol.UserPreferences {

const info = this.getScriptInfoForNormalizedPath(file);

return { ...this.hostConfiguration.preferences, ...info && info.getPreferences() };

}

getHostFormatCodeOptions(): FormatCodeSettings {

return this.hostConfiguration.formatCodeOptions;

}

getHostPreferences(): protocol.UserPreferences {

return this.hostConfiguration.preferences;

}

private onSourceFileChanged(fileName: string, eventKind: FileWatcherEventKind, path: Path) {

const info = this.getScriptInfoForPath(path);

if (!info) {

this.logger.msg(`Error: got watch notification for unknown file: ${fileName}`);

}

else {

if (info.containingProjects) {

info.containingProjects.forEach(project => project.resolutionCache.removeResolutionsFromProjectReferenceRedirects(info.path));

}

if (eventKind === FileWatcherEventKind.Deleted) {

// File was deleted

this.handleDeletedFile(info);

}

else if (!info.isScriptOpen()) {

// file has been changed which might affect the set of referenced files in projects that include

// this file and set of inferred projects

info.delayReloadNonMixedContentFile();

this.delayUpdateProjectGraphs(info.containingProjects);

this.handleSourceMapProjects(info);

}

}

}

private handleSourceMapProjects(info: ScriptInfo) {

// Change in d.ts, update source projects as well

if (info.sourceMapFilePath) {

if (isString(info.sourceMapFilePath)) {

const sourceMapFileInfo = this.getScriptInfoForPath(info.sourceMapFilePath);

this.delayUpdateSourceInfoProjects(sourceMapFileInfo && sourceMapFileInfo.sourceInfos);

}

else {

this.delayUpdateSourceInfoProjects(info.sourceMapFilePath.sourceInfos);

}

}

// Change in mapInfo, update declarationProjects and source projects

this.delayUpdateSourceInfoProjects(info.sourceInfos);

if (info.declarationInfoPath) {

this.delayUpdateProjectsOfScriptInfoPath(info.declarationInfoPath);

}

}

private delayUpdateSourceInfoProjects(sourceInfos: Map<true> | undefined) {

if (sourceInfos) {

sourceInfos.forEach((_value, path) => this.delayUpdateProjectsOfScriptInfoPath(path as Path));

}

}

private delayUpdateProjectsOfScriptInfoPath(path: Path) {

const info = this.getScriptInfoForPath(path);

if (info) {

this.delayUpdateProjectGraphs(info.containingProjects);

}

}

private handleDeletedFile(info: ScriptInfo) {

this.stopWatchingScriptInfo(info);

if (!info.isScriptOpen()) {

this.deleteScriptInfo(info);

// capture list of projects since detachAllProjects will wipe out original list

const containingProjects = info.containingProjects.slice();

info.detachAllProjects();

// update projects to make sure that set of referenced files is correct

this.delayUpdateProjectGraphs(containingProjects);

this.handleSourceMapProjects(info);

info.closeSourceMapFileWatcher();

// need to recalculate source map from declaration file

if (info.declarationInfoPath) {

const declarationInfo = this.getScriptInfoForPath(info.declarationInfoPath);

if (declarationInfo) {

declarationInfo.sourceMapFilePath = undefined;

}

}

}

}

/**

* This is to watch whenever files are added or removed to the wildcard directories

*/