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,

protocol,

ScriptInfo,

ScriptInfoVersion,

ServerHost,

Session,

SetTypings,

ThrottledOperations,

toNormalizedPath,

TypingsCache,

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

import {

addToSeen,

arrayFrom,

arrayToMap,

AssertionLevel,

CachedDirectoryStructureHost,

canJsonReportNoInputFiles,

canWatchDirectoryOrFile,

cleanExtendedConfigCache,

clearMap,

clearSharedExtendedConfigFileWatcher,

closeFileWatcherOf,

combinePaths,

CommandLineOption,

CompilerOptions,

CompletionInfo,

ConfigFileProgramReloadLevel,

contains,

containsPath,

convertCompilerOptionsForTelemetry,

convertEnableAutoDiscoveryToEnable,

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,

getEntries,

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

export const maxProgramSizeForNonTsFiles = 20 * 1024 * 1024;

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

export interface ProjectInfoTelemetryEvent {

readonly eventName: typeof ProjectInfoTelemetryEvent;

readonly data: ProjectInfoTelemetryEventData;

export interface ProjectInfoTelemetryEventData {

export interface OpenFileInfoTelemetryEvent {

readonly eventName: typeof OpenFileInfoTelemetryEvent;

readonly data: OpenFileInfoTelemetryEventData;

export interface OpenFileInfoTelemetryEventData {

readonly info: OpenFileInfo;

export interface ProjectInfoTypeAcquisitionData {

export interface FileStats {

export interface OpenFileInfo {

readonly checkJs: boolean;

export type ProjectServiceEvent =

| OpenFileInfoTelemetryEvent;

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

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

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 {

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

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

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

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

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

export function convertScriptKindName(scriptKindName: protocol.ScriptKindName) {

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

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

return userPreferences;

export interface HostConfiguration {

export interface OpenConfiguredProjectResult {

configFileName?: NormalizedPath;

configFileErrors?: readonly Diagnostic[];

interface AssignProjectResult extends OpenConfiguredProjectResult {

retainProjects: readonly ConfiguredProject[] | ConfiguredProject | undefined;

interface FilePropertyReader<T> {

const fileNamePropertyReader: FilePropertyReader<string> = {

getFileName: x => x,

getScriptKind: (fileName, extraFileExtensions) => {

},

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 {

const noopConfigFileWatcher: FileWatcher = { close: noop };

export interface ConfigFileExistenceInfo {

export interface ProjectServiceOptions {

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

interface AncestorConfigFileInfo {

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;

export enum ProjectReferenceProjectLoadKind {

export function forEachResolvedProjectReferenceProject<T>(

): T | undefined;

export function forEachResolvedProjectReferenceProject<T>(

): T | undefined;

export function forEachResolvedProjectReferenceProject<T>(

function forEachResolvedProjectReferenceProjectWorker<T>(

function forEachPotentialProjectReference<T>(

function forEachAnyProjectReferenceKind<T>(

function callbackRefProject<T>(

function forEachReferencedProject<T>(

interface NodeModulesWatcher extends FileWatcher {

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;

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

return project.containsScriptInfo(info) &&

!project.isSourceOfProjectReferenceRedirect(info.path);

export function updateProjectIfDirty(project: Project) {

project.invalidateResolutionsOfFailedLookupLocations();

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

function setProjectOptionsUsed(project: ConfiguredProject | ExternalProject) {

export interface OpenFileArguments {

export interface ChangeFileArguments {

fileName: string;

changes: Iterator<TextChange>;

export interface WatchOptionsAndErrors {

watchOptions: WatchOptions;

errors: Diagnostic[] | undefined;

export interface ParsedConfig{

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

let nextId = 1;

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

export class ProjectService {