diff --git a/src/monaco.contribution.ts b/src/monaco.contribution.ts index 0e9fcfb7..c038d4b5 100644 --- a/src/monaco.contribution.ts +++ b/src/monaco.contribution.ts @@ -208,11 +208,11 @@ const javascriptDefaults = new LanguageServiceDefaultsImpl( { allowNonTsExtensions: true, allowJs: true, target: ScriptTarget.Latest }, { noSemanticValidation: true, noSyntaxValidation: false }); -function getTypeScriptWorker(): Promise { +function getTypeScriptWorker(): Promise<(...uris: monaco.Uri[]) => Promise> { return getMode().then(mode => mode.getTypeScriptWorker()); } -function getJavaScriptWorker(): Promise { +function getJavaScriptWorker(): Promise<(...uris: monaco.Uri[]) => Promise> { return getMode().then(mode => mode.getJavaScriptWorker()); } diff --git a/src/monaco.d.ts b/src/monaco.d.ts index cf16b6fd..d17315d7 100644 --- a/src/monaco.d.ts +++ b/src/monaco.d.ts @@ -49,6 +49,7 @@ declare module monaco.languages.typescript { interface CompilerOptions { allowJs?: boolean; allowSyntheticDefaultImports?: boolean; + allowUmdGlobalAccess?: boolean; allowUnreachableCode?: boolean; allowUnusedLabels?: boolean; alwaysStrict?: boolean; @@ -60,6 +61,7 @@ declare module monaco.languages.typescript { emitDeclarationOnly?: boolean; declarationDir?: string; disableSizeLimit?: boolean; + disableSourceOfProjectReferenceRedirect?: boolean; downlevelIteration?: boolean; emitBOM?: boolean; emitDecoratorMetadata?: boolean; @@ -111,8 +113,10 @@ declare module monaco.languages.typescript { sourceRoot?: string; strict?: boolean; strictFunctionTypes?: boolean; + strictBindCallApply?: boolean; strictNullChecks?: boolean; strictPropertyInitialization?: boolean; + stripInternal?: boolean; suppressExcessPropertyErrors?: boolean; suppressImplicitAnyIndexErrors?: boolean; target?: ScriptTarget; @@ -122,6 +126,7 @@ declare module monaco.languages.typescript { /** Paths used to compute primary types search locations */ typeRoots?: string[]; esModuleInterop?: boolean; + useDefineForClassFields?: boolean; [option: string]: CompilerOptionsValue | undefined; } @@ -132,7 +137,69 @@ declare module monaco.languages.typescript { diagnosticCodesToIgnore?: number[]; } + interface IExtraLib { + content: string; + version: number; + } + + interface IExtraLibs { + [path: string]: IExtraLib; + } + + /** + * A linked list of formatted diagnostic messages to be used as part of a multiline message. + * It is built from the bottom up, leaving the head to be the "main" diagnostic. + */ + interface DiagnosticMessageChain { + messageText: string; + /** Diagnostic category: warning = 0, error = 1, suggestion = 2, message = 3 */ + category: 0 | 1 | 2 | 3; + code: number; + next?: DiagnosticMessageChain[]; + } + interface Diagnostic extends DiagnosticRelatedInformation { + /** May store more in future. For now, this will simply be `true` to indicate when a diagnostic is an unused-identifier diagnostic. */ + reportsUnnecessary?: {}; + source?: string; + relatedInformation?: DiagnosticRelatedInformation[]; + } + interface DiagnosticRelatedInformation { + /** Diagnostic category: warning = 0, error = 1, suggestion = 2, message = 3 */ + category: 0 | 1 | 2 | 3; + code: number; + /** TypeScriptWorker removes this to avoid serializing circular JSON structures. */ + file: undefined; + start: number | undefined; + length: number | undefined; + messageText: string | DiagnosticMessageChain; + } + + interface EmitOutput { + outputFiles: OutputFile[]; + emitSkipped: boolean; + } + interface OutputFile { + name: string; + writeByteOrderMark: boolean; + text: string; + } + export interface LanguageServiceDefaults { + /** + * Event fired when compiler options or diagnostics options are changed. + */ + readonly onDidChange: IEvent; + + /** + * Event fired when extra libraries registered with the language service change. + */ + readonly onDidExtraLibsChange: IEvent; + + /** + * Get the current extra libs registered with the language service. + */ + getExtraLibs(): IExtraLibs; + /** * Add an additional source file to the language service. Use this * for typescript (definition) files that won't be loaded as editor @@ -153,11 +220,21 @@ declare module monaco.languages.typescript { */ setExtraLibs(libs: { content: string; filePath?: string }[]): void; + /** + * Get current TypeScript compiler options for the language service. + */ + getCompilerOptions(): CompilerOptions; + /** * Set TypeScript compiler options. */ setCompilerOptions(options: CompilerOptions): void; + /** + * Get the current diagnostics options for the language service. + */ + getDiagnosticsOptions(): DiagnosticsOptions; + /** * Configure whether syntactic and/or semantic validation should * be performed @@ -165,10 +242,7 @@ declare module monaco.languages.typescript { setDiagnosticsOptions(options: DiagnosticsOptions): void; /** - * Configure when the worker shuts down. By default that is 2mins. - * - * @param value The maximum idle time in milliseconds. Values less than one - * mean never shut down. + * No-op. */ setMaximumWorkerIdleTime(value: number): void; @@ -177,13 +251,137 @@ declare module monaco.languages.typescript { * to the worker on start or restart. */ setEagerModelSync(value: boolean): void; + + /** + * Get the current setting for whether all existing models should be eagerly sync'd + * to the worker on start or restart. + */ + getEagerModelSync(): boolean; + } + + export interface TypeScriptWorker { + /** + * Get diagnostic messages for any syntax issues in the given file. + */ + getSyntacticDiagnostics(fileName: string): Promise; + + /** + * Get diagnostic messages for any semantic issues in the given file. + */ + getSemanticDiagnostics(fileName: string): Promise; + + /** + * Get diagnostic messages for any suggestions related to the given file. + */ + getSuggestionDiagnostics(fileName: string): Promise; + + /** + * Get diagnostic messages related to the current compiler options. + * @param fileName Not used + */ + getCompilerOptionsDiagnostics(fileName: string): Promise; + + /** + * Get code completions for the given file and position. + * @returns `Promise` + */ + getCompletionsAtPosition(fileName: string, position: number): Promise; + + /** + * Get code completion details for the given file, position, and entry. + * @returns `Promise` + */ + getCompletionEntryDetails(fileName: string, position: number, entry: string): Promise; + + /** + * Get signature help items for the item at the given file and position. + * @returns `Promise` + */ + getSignatureHelpItems(fileName: string, position: number): Promise; + + /** + * Get quick info for the item at the given position in the file. + * @returns `Promise` + */ + getQuickInfoAtPosition(fileName: string, position: number): Promise; + + /** + * Get other ranges which are related to the item at the given position in the file (often used for highlighting). + * @returns `Promise | undefined>` + */ + getOccurrencesAtPosition(fileName: string, position: number): Promise | undefined>; + + /** + * Get the definition of the item at the given position in the file. + * @returns `Promise | undefined>` + */ + getDefinitionAtPosition(fileName: string, position: number): Promise | undefined>; + + /** + * Get references to the item at the given position in the file. + * @returns `Promise` + */ + getReferencesAtPosition(fileName: string, position: number): Promise; + + /** + * Get outline entries for the item at the given position in the file. + * @returns `Promise` + */ + getNavigationBarItems(fileName: string): Promise; + + /** + * Get changes which should be applied to format the given file. + * @param options `typescript.FormatCodeOptions` + * @returns `Promise` + */ + getFormattingEditsForDocument(fileName: string, options: any): Promise; + + /** + * Get changes which should be applied to format the given range in the file. + * @param options `typescript.FormatCodeOptions` + * @returns `Promise` + */ + getFormattingEditsForRange(fileName: string, start: number, end: number, options: any): Promise; + + /** + * Get formatting changes which should be applied after the given keystroke. + * @param options `typescript.FormatCodeOptions` + * @returns `Promise` + */ + getFormattingEditsAfterKeystroke(fileName: string, postion: number, ch: string, options: any): Promise; + + /** + * Get other occurrences which should be updated when renaming the item at the given file and position. + * @returns `Promise` + */ + findRenameLocations(fileName: string, positon: number, findInStrings: boolean, findInComments: boolean, providePrefixAndSuffixTextForRename: boolean): Promise; + + /** + * Get edits which should be applied to rename the item at the given file and position (or a failure reason). + * @param options `typescript.RenameInfoOptions` + * @returns `Promise` + */ + getRenameInfo(fileName: string, positon: number, options: any): Promise; + + /** + * Get transpiled output for the given file. + * @returns `typescript.EmitOutput` + */ + getEmitOutput(fileName: string): Promise; + + /** + * Get possible code fixes at the given position in the file. + * @param formatOptions `typescript.FormatCodeOptions` + * @returns `Promise>` + */ + getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: number[], formatOptions: any): Promise>; } - export var typescriptVersion: string; + export const typescriptVersion: string; - export var typescriptDefaults: LanguageServiceDefaults; - export var javascriptDefaults: LanguageServiceDefaults; + export const typescriptDefaults: LanguageServiceDefaults; + export const javascriptDefaults: LanguageServiceDefaults; - export var getTypeScriptWorker: () => Promise; - export var getJavaScriptWorker: () => Promise; + export const getTypeScriptWorker: () => Promise<(...uris: Uri[]) => Promise>; + export const getJavaScriptWorker: () => Promise<(...uris: Uri[]) => Promise>; } diff --git a/src/tsMode.ts b/src/tsMode.ts index 8842fd63..efc95412 100644 --- a/src/tsMode.ts +++ b/src/tsMode.ts @@ -11,8 +11,8 @@ import * as languageFeatures from './languageFeatures'; import Uri = monaco.Uri; -let javaScriptWorker: (first: Uri, ...more: Uri[]) => Promise; -let typeScriptWorker: (first: Uri, ...more: Uri[]) => Promise; +let javaScriptWorker: (...uris: Uri[]) => Promise; +let typeScriptWorker: (...uris: Uri[]) => Promise; export function setupTypeScript(defaults: LanguageServiceDefaultsImpl): void { typeScriptWorker = setupMode( @@ -28,7 +28,7 @@ export function setupJavaScript(defaults: LanguageServiceDefaultsImpl): void { ); } -export function getJavaScriptWorker(): Promise<(first: Uri, ...more: Uri[]) => Promise> { +export function getJavaScriptWorker(): Promise<(...uris: Uri[]) => Promise> { return new Promise((resolve, reject) => { if (!javaScriptWorker) { return reject("JavaScript not registered!"); @@ -38,7 +38,7 @@ export function getJavaScriptWorker(): Promise<(first: Uri, ...more: Uri[]) => P }); } -export function getTypeScriptWorker(): Promise<(first: Uri, ...more: Uri[]) => Promise> { +export function getTypeScriptWorker(): Promise<(...uris: Uri[]) => Promise> { return new Promise((resolve, reject) => { if (!typeScriptWorker) { return reject("TypeScript not registered!"); @@ -48,11 +48,11 @@ export function getTypeScriptWorker(): Promise<(first: Uri, ...more: Uri[]) => P }); } -function setupMode(defaults: LanguageServiceDefaultsImpl, modeId: string): (first: Uri, ...more: Uri[]) => Promise { +function setupMode(defaults: LanguageServiceDefaultsImpl, modeId: string): (...uris: Uri[]) => Promise { const client = new WorkerManager(modeId, defaults); - const worker = (first: Uri, ...more: Uri[]): Promise => { - return client.getLanguageServiceWorker(...[first].concat(more)); + const worker = (...uris: Uri[]): Promise => { + return client.getLanguageServiceWorker(...uris); }; monaco.languages.registerCompletionItemProvider(modeId, new languageFeatures.SuggestAdapter(worker)); diff --git a/src/tsWorker.ts b/src/tsWorker.ts index b3cee653..32b9a6bb 100644 --- a/src/tsWorker.ts +++ b/src/tsWorker.ts @@ -20,7 +20,7 @@ const ES6_LIB = { CONTENTS: lib_es6_dts }; -export class TypeScriptWorker implements ts.LanguageServiceHost { +export class TypeScriptWorker implements ts.LanguageServiceHost, monaco.languages.typescript.TypeScriptWorker { // --- model sync ----------------------- @@ -123,7 +123,7 @@ export class TypeScriptWorker implements ts.LanguageServiceHost { // --- language features - private static clearFiles(diagnostics: ts.Diagnostic[]) { + private static clearFiles(diagnostics: ts.Diagnostic[]): monaco.languages.typescript.Diagnostic[] { // Clear the `file` field, which cannot be JSON'yfied because it // contains cyclic data structures. diagnostics.forEach(diag => { @@ -133,30 +133,27 @@ export class TypeScriptWorker implements ts.LanguageServiceHost { related.forEach(diag2 => diag2.file = undefined); } }); + return diagnostics; } - getSyntacticDiagnostics(fileName: string): Promise { + getSyntacticDiagnostics(fileName: string): Promise { const diagnostics = this._languageService.getSyntacticDiagnostics(fileName); - TypeScriptWorker.clearFiles(diagnostics); - return Promise.resolve(diagnostics); + return Promise.resolve(TypeScriptWorker.clearFiles(diagnostics)); } - getSemanticDiagnostics(fileName: string): Promise { + getSemanticDiagnostics(fileName: string): Promise { const diagnostics = this._languageService.getSemanticDiagnostics(fileName); - TypeScriptWorker.clearFiles(diagnostics); - return Promise.resolve(diagnostics); + return Promise.resolve(TypeScriptWorker.clearFiles(diagnostics)); } - getSuggestionDiagnostics(fileName: string): Promise { + getSuggestionDiagnostics(fileName: string): Promise { const diagnostics = this._languageService.getSuggestionDiagnostics(fileName); - TypeScriptWorker.clearFiles(diagnostics); - return Promise.resolve(diagnostics); + return Promise.resolve(TypeScriptWorker.clearFiles(diagnostics)); } - getCompilerOptionsDiagnostics(fileName: string): Promise { + getCompilerOptionsDiagnostics(fileName: string): Promise { const diagnostics = this._languageService.getCompilerOptionsDiagnostics(); - TypeScriptWorker.clearFiles(diagnostics); - return Promise.resolve(diagnostics); + return Promise.resolve(TypeScriptWorker.clearFiles(diagnostics)); } getCompletionsAtPosition(fileName: string, position: number): Promise { diff --git a/src/tsconfig.esm.json b/src/tsconfig.esm.json index 54e3e2cf..03783034 100644 --- a/src/tsconfig.esm.json +++ b/src/tsconfig.esm.json @@ -2,7 +2,6 @@ "compilerOptions": { "module": "esnext", "moduleResolution": "node", - "declaration": true, "outDir": "../release/esm", "target": "es5", "lib": [ diff --git a/src/tsconfig.json b/src/tsconfig.json index 8267b103..b2a6ca66 100644 --- a/src/tsconfig.json +++ b/src/tsconfig.json @@ -3,7 +3,6 @@ "module": "amd", "moduleResolution": "node", "outDir": "../release/dev", - "declaration": true, "target": "es5", "lib": [ "dom",