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

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[]): ESMap<string, ESMap<string, number>> {

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

for (const option of commandLineOptions) {

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

const optionMap = option.type as ESMap<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(getEntries({

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*/

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?: ESMap<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;

/** @deprecated use serverMode instead */

syntaxOnly?: boolean;

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;

}

/*@internal*/

/** Kind of operation to perform to get project reference project */

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: ESMap<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: ESMap<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: Path) => 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: Path) => T | undefined

): T | undefined {

return project.getCurrentProgram() ?

project.forEachResolvedProjectReference(cb) :

project.isInitialLoadPending() ?

forEachPotentialProjectReference(project, cbPotentialProjectRef) :

forEach(project.getProjectReferences(), cbProjectRef);

}

function callbackRefProject<T>(

project: ConfiguredProject,

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

refPath: Path | 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;

}

/*@internal*/

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

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: Iterator<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: ESMap<NormalizedPath, boolean>;

parsedCommandLine?: ParsedCommandLine;

watchedDirectories?: Map<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, ScriptInfoVersion>();

// 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<ConfiguredProject> = new Map<string, ConfiguredProject>();

/*@internal*/

readonly newInferredProjectName = createProjectNameFactoryWithCounter(makeInferredProjectName);

/*@internal*/

readonly newAutoImportProviderProjectName = createProjectNameFactoryWithCounter(makeAutoImportProviderProjectName);

/**

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

*/

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

/* @internal */

readonly configFileForOpenFiles: ESMap<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: ESMap<string, any> | undefined;

public readonly typesMapLocation: string | undefined;

/** @deprecated use serverMode instead */

public readonly syntaxOnly: boolean;

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: ESMap<Path, FileWatcher> | undefined;

/*@internal*/

private incompleteCompletionsCache: IncompleteCompletionsCache | undefined;

/*@internal*/

readonly session: Session<unknown> | undefined;

private performanceEventHandler?: PerformanceEventHandler;

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.session = opts.session;

if (opts.serverMode !== undefined) {

this.serverMode = opts.serverMode;

this.syntaxOnly = this.serverMode === LanguageServiceMode.Syntactic;

}

else if (opts.syntaxOnly) {

this.serverMode = LanguageServiceMode.Syntactic;

this.syntaxOnly = true;

}

else {

this.serverMode = LanguageServiceMode.Semantic;

this.syntaxOnly = false;

}

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.packageJsonCache = createPackageJsonCache(this);

this.watchFactory = this.serverMode !== LanguageServiceMode.Semantic ?

{

watchFile: returnNoopFileWatcher,

watchDirectory: returnNoopFileWatcher,

} :

getWatchFactory(this.host, 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.checkDefined(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));

return;

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;

}

}

/*@internal*/

delayEnsureProjectForOpenFiles() {

if (!this.openFiles.size) return;

this.pendingEnsureProjectForOpenFiles = true;

this.throttledOperations.schedule(ensureProjectForOpenFileSchedule, /*delay*/ 2500, () => {

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

}

});

}