From 28d4512f33c7a661a0e95d38058047f8c334ec9d Mon Sep 17 00:00:00 2001 From: Alex Dima Date: Mon, 7 Sep 2020 12:24:21 +0200 Subject: [PATCH] Use the global `monaco` only in the AMD case (see https://github.com/microsoft/monaco-editor/issues/1974) --- README.md | 2 +- src/monaco.d.ts => monaco.d.ts | 18 +-- package-lock.json | 54 +++---- package.json | 12 +- scripts/bundle.js | 6 +- scripts/dts.js | 37 +++++ src/fillers/monaco-editor-core-amd.ts | 12 ++ .../monaco-editor-core.ts} | 3 +- src/json.worker.ts | 1 - src/jsonMode.ts | 33 ++--- src/jsonWorker.ts | 60 ++------ src/languageFeatures.ts | 133 ++++++++--------- src/monaco.contribution.ts | 138 ++++++++++++++---- src/tokenization.ts | 24 +-- src/tsconfig.esm.json | 3 +- src/tsconfig.json | 3 +- src/workerManager.ts | 17 +-- 17 files changed, 321 insertions(+), 235 deletions(-) rename src/monaco.d.ts => monaco.d.ts (95%) create mode 100644 scripts/dts.js create mode 100644 src/fillers/monaco-editor-core-amd.ts rename src/{typings/refs.d.ts => fillers/monaco-editor-core.ts} (82%) diff --git a/README.md b/README.md index c9ae0f7c..516d0e82 100644 --- a/README.md +++ b/README.md @@ -9,7 +9,7 @@ JSON language plugin for the Monaco Editor. It provides the following features w * Syntax highlighting * Color decorators for all properties matching a schema containing `format: "color-hex"'` (non-standard schema extension) -Schemas can be provided by configuration. See [here](https://github.com/Microsoft/monaco-json/blob/master/src/monaco.d.ts) +Schemas can be provided by configuration. See [here](https://github.com/Microsoft/monaco-json/blob/master/monaco.d.ts) for the API that the JSON plugin offers to configure the JSON language support. Internally the JSON plugin uses the [vscode-json-languageservice](https://github.com/Microsoft/vscode-json-languageservice) diff --git a/src/monaco.d.ts b/monaco.d.ts similarity index 95% rename from src/monaco.d.ts rename to monaco.d.ts index 236b3dbf..d84bc268 100644 --- a/src/monaco.d.ts +++ b/monaco.d.ts @@ -3,7 +3,8 @@ * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -declare module monaco.languages.json { +declare namespace monaco.languages.json { + export interface DiagnosticsOptions { /** * If set, the validator will be enabled and perform syntax validation as well as schema based validation. @@ -35,67 +36,56 @@ declare module monaco.languages.json { */ readonly enableSchemaRequest?: boolean; } - export interface ModeConfiguration { /** * Defines whether the built-in documentFormattingEdit provider is enabled. */ readonly documentFormattingEdits?: boolean; - /** * Defines whether the built-in documentRangeFormattingEdit provider is enabled. */ readonly documentRangeFormattingEdits?: boolean; - /** * Defines whether the built-in completionItemProvider is enabled. */ readonly completionItems?: boolean; - /** * Defines whether the built-in hoverProvider is enabled. */ readonly hovers?: boolean; - /** * Defines whether the built-in documentSymbolProvider is enabled. */ readonly documentSymbols?: boolean; - /** * Defines whether the built-in tokens provider is enabled. */ readonly tokens?: boolean; - /** * Defines whether the built-in color provider is enabled. */ readonly colors?: boolean; - /** * Defines whether the built-in foldingRange provider is enabled. */ readonly foldingRanges?: boolean; - /** * Defines whether the built-in diagnostic provider is enabled. */ readonly diagnostics?: boolean; - /** * Defines whether the built-in selection range provider is enabled. */ readonly selectionRanges?: boolean; - } - export interface LanguageServiceDefaults { + readonly languageId: string; readonly onDidChange: IEvent; readonly diagnosticsOptions: DiagnosticsOptions; readonly modeConfiguration: ModeConfiguration; setDiagnosticsOptions(options: DiagnosticsOptions): void; setModeConfiguration(modeConfiguration: ModeConfiguration): void; } + export const jsonDefaults: LanguageServiceDefaults; - export var jsonDefaults: LanguageServiceDefaults; } diff --git a/package-lock.json b/package-lock.json index 21b571e8..f690f5db 100644 --- a/package-lock.json +++ b/package-lock.json @@ -17,9 +17,9 @@ "dev": true }, "jsonc-parser": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-2.2.0.tgz", - "integrity": "sha512-4fLQxW1j/5fWj6p78vAlAafoCKtuBm6ghv+Ij5W2DrDx0qE+ZdEl2c6Ko1mgJNF5ftX1iEWQQ4Ap7+3GlhjkOA==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-2.3.0.tgz", + "integrity": "sha512-b0EBt8SWFNnixVdvoR2ZtEGa9ZqLhbJnOjezn+WP+8kspFm+PFYDN8Z4Bc7pRlDjvuVcADSUkroIuTWWn/YiIA==", "dev": true }, "monaco-editor-core": { @@ -35,9 +35,9 @@ "dev": true }, "monaco-plugin-helpers": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/monaco-plugin-helpers/-/monaco-plugin-helpers-1.0.2.tgz", - "integrity": "sha512-7kUx8dtd5qVNVgUARBRhnM8oftPglYwlINfigC4yGUiuzqtIN22u1tly8umiOCIPR0eFiBLjt6aN23oZh2QJgg==", + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/monaco-plugin-helpers/-/monaco-plugin-helpers-1.0.3.tgz", + "integrity": "sha512-6AYI3ONAy8ki74qG2JqtFrLdiJHQlgeO5l4Rwr0OMyIpGXhc94y5rZuFxOtgGkxgSrZfHSwOt/MulUNZ/mOQOw==", "dev": true, "requires": { "typescript": "^2.7.2" @@ -64,9 +64,9 @@ "dev": true }, "source-map-support": { - "version": "0.5.16", - "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.16.tgz", - "integrity": "sha512-efyLRJDr68D9hBBNIPWFjhpFzURh+KJykQwvMyW5UiZzYwoF6l4YMMDIJJEyFWxWCqfyxLzz6tSfUFR+kXXsVQ==", + "version": "0.5.19", + "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.19.tgz", + "integrity": "sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==", "dev": true, "requires": { "buffer-from": "^1.0.0", @@ -74,9 +74,9 @@ } }, "terser": { - "version": "4.6.3", - "resolved": "https://registry.npmjs.org/terser/-/terser-4.6.3.tgz", - "integrity": "sha512-Lw+ieAXmY69d09IIc/yqeBqXpEQIpDGZqT34ui1QWXIUpR2RjbqEkT8X7Lgex19hslSqcWM5iMN2kM11eMsESQ==", + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.3.0.tgz", + "integrity": "sha512-XTT3D3AwxC54KywJijmY2mxZ8nJiEjBHVYzq8l9OaYuRFWeQNBwvipuzzYEP4e+/AVcd1hqG/CqgsdIRyT45Fg==", "dev": true, "requires": { "commander": "^2.20.0", @@ -85,9 +85,9 @@ } }, "typescript": { - "version": "3.7.5", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.7.5.tgz", - "integrity": "sha512-/P5lkRXkWHNAbcJIiHPfRoKqyd7bsyCma1hZNUGfn20qm64T6ZBlrzprymeu918H+mB/0rIg2gGK/BXkhhYgBw==", + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.0.2.tgz", + "integrity": "sha512-e4ERvRV2wb+rRZ/IQeb3jm2VxBsirQLpQhdxplZ2MEzGvDkkMmPglecnNDfSUBivMjP93vRbngYYDQqQ/78bcQ==", "dev": true }, "vscode-json-languageservice": { @@ -104,27 +104,27 @@ } }, "vscode-languageserver-textdocument": { - "version": "1.0.0-next.5", - "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.0-next.5.tgz", - "integrity": "sha512-1jp/zAidN/bF/sqPimhBX1orH5G4rzRw63k75TesukJDuxm8yW79ECStWbDSy41BHGOwSGN4M69QFvhancSr5A==", + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.1.tgz", + "integrity": "sha512-UIcJDjX7IFkck7cSkNNyzIz5FyvpQfY7sdzVy+wkKN/BLaD4DQ0ppXQrKePomCxTS7RrolK1I0pey0bG9eh8dA==", "dev": true }, "vscode-languageserver-types": { - "version": "3.15.0-next.9", - "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.15.0-next.9.tgz", - "integrity": "sha512-Rl/8qJ6932nrHCdPn+9y0x08uLVQaSLRG+U4JzhyKpWU4eJbVaDRoAcz1Llj7CErJGbPr6kdBvShPy5fRfR+Uw==", + "version": "3.15.1", + "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.15.1.tgz", + "integrity": "sha512-+a9MPUQrNGRrGU630OGbYVQ+11iOIovjCkqxajPa9w57Sd5ruK8WQNsslzpa0x/QJqC8kRc2DUxWjIFwoNm4ZQ==", "dev": true }, "vscode-nls": { - "version": "4.1.1", - "resolved": "https://registry.npmjs.org/vscode-nls/-/vscode-nls-4.1.1.tgz", - "integrity": "sha512-4R+2UoUUU/LdnMnFjePxfLqNhBS8lrAFyX7pjb2ud/lqDkrUavFUTcG7wR0HBZFakae0Q6KLBFjMS6W93F403A==", + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/vscode-nls/-/vscode-nls-4.1.2.tgz", + "integrity": "sha512-7bOHxPsfyuCqmP+hZXscLhiHwe7CSuFE4hyhbs22xPIhQ4jv99FcR4eBzfYYVLP356HNFpdvz63FFb/xw6T4Iw==", "dev": true }, "vscode-uri": { - "version": "2.1.1", - "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-2.1.1.tgz", - "integrity": "sha512-eY9jmGoEnVf8VE8xr5znSah7Qt1P/xsCdErz+g8HYZtJ7bZqKH5E3d+6oVNm1AC/c6IHUDokbmVXKOi4qPAC9A==", + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-2.1.2.tgz", + "integrity": "sha512-8TEXQxlldWAuIODdukIb+TR5s+9Ds40eSJrw+1iDDA9IFORPjMELarNQE3myz5XIkWWpdprmJjm1/SxMlWOC8A==", "dev": true } } diff --git a/package.json b/package.json index 1e74c5b9..16e3e6a4 100644 --- a/package.json +++ b/package.json @@ -3,9 +3,9 @@ "version": "2.9.0", "description": "JSON plugin for the Monaco Editor", "scripts": { - "compile": "mrmdir ./out && tsc -p ./src/tsconfig.json && tsc -p ./src/tsconfig.esm.json", + "compile": "mrmdir ./out && tsc -p ./src/tsconfig.json && tsc -p ./src/tsconfig.esm.json && node ./scripts/dts", "watch": "tsc -p ./src --watch", - "prepublishOnly": "mrmdir ./release && npm run compile && node ./scripts/release.js && node ./scripts/bundle && mcopy ./src/monaco.d.ts ./release/monaco.d.ts", + "prepublishOnly": "mrmdir ./release && npm run compile && node ./scripts/release.js && node ./scripts/bundle && mcopy ./monaco.d.ts ./release/monaco.d.ts && mcopy ./out/esm/monaco.contribution.d.ts ./release/esm/monaco.contribution.d.ts && mcopy ./out/esm/fillers/monaco-editor-core.d.ts ./release/esm/fillers/monaco-editor-core.d.ts", "install-service-next": "npm install vscode-json-languageservice@next -f -D && npm install vscode-languageserver-types@next -f -D", "install-service-local": "npm install ../vscode-json-languageservice -f -D && npm install ../vscode-languageserver-node/types -f -D" }, @@ -18,14 +18,16 @@ "bugs": { "url": "https://github.com/Microsoft/monaco-json/issues" }, + "module": "./release/esm/monaco.contribution.js", + "typings": "./release/esm/monaco.contribution.d.ts", "devDependencies": { "jsonc-parser": "^2.2.0", "monaco-editor-core": "0.20.0", "monaco-languages": "1.10.0", - "monaco-plugin-helpers": "^1.0.2", + "monaco-plugin-helpers": "^1.0.3", "requirejs": "^2.3.6", - "typescript": "3.7.5", - "terser": "^4.6.3", + "typescript": "4.0.2", + "terser": "^5.3.0", "vscode-json-languageservice": "3.4.11" } } diff --git a/scripts/bundle.js b/scripts/bundle.js index 155a93ad..20179055 100644 --- a/scripts/bundle.js +++ b/scripts/bundle.js @@ -24,14 +24,14 @@ bundleOne('monaco.contribution'); bundleOne('jsonMode'); bundleOne('jsonWorker'); -function bundleOne(moduleId, exclude) { +function bundleOne(moduleId) { requirejs.optimize({ baseUrl: 'out/amd/', name: 'vs/language/json/' + moduleId, out: 'release/dev/' + moduleId + '.js', - exclude: exclude, paths: { - 'vs/language/json': REPO_ROOT + '/out/amd' + 'vs/language/json': REPO_ROOT + '/out/amd', + 'vs/language/json/fillers/monaco-editor-core': REPO_ROOT + '/out/amd/fillers/monaco-editor-core-amd', }, optimize: 'none', packages: [{ diff --git a/scripts/dts.js b/scripts/dts.js new file mode 100644 index 00000000..bcb06084 --- /dev/null +++ b/scripts/dts.js @@ -0,0 +1,37 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +const path = require('path'); +const fs = require('fs'); + +const REPO_ROOT = path.join(__dirname, '../'); +const SRC_PATH = path.join(REPO_ROOT, 'out/amd/monaco.contribution.d.ts'); +const DST_PATH = path.join(REPO_ROOT, 'monaco.d.ts'); + +const lines = fs.readFileSync(SRC_PATH).toString().split(/\r\n|\r|\n/); +let result = [ + `/*---------------------------------------------------------------------------------------------`, + ` * Copyright (c) Microsoft Corporation. All rights reserved.`, + ` * Licensed under the MIT License. See License.txt in the project root for license information.`, + ` *--------------------------------------------------------------------------------------------*/`, + ``, + `declare namespace monaco.languages.json {`, + `` +]; +for (let line of lines) { + if (/^import/.test(line)) { + continue; + } + line = line.replace(/ /g, '\t'); + line = line.replace(/export declare/g, 'export'); + if (line.length > 0) { + line = `\t${line}`; + } + result.push(line); +} +result.push(`}`); +result.push(``); + +fs.writeFileSync(DST_PATH, result.join('\n')); diff --git a/src/fillers/monaco-editor-core-amd.ts b/src/fillers/monaco-editor-core-amd.ts new file mode 100644 index 00000000..bbc7e81a --- /dev/null +++ b/src/fillers/monaco-editor-core-amd.ts @@ -0,0 +1,12 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +// Resolves with the global monaco API + +declare var define; + +define([], function() { + return (self).monaco; +}); diff --git a/src/typings/refs.d.ts b/src/fillers/monaco-editor-core.ts similarity index 82% rename from src/typings/refs.d.ts rename to src/fillers/monaco-editor-core.ts index 8c3ed26d..cd996aa7 100644 --- a/src/typings/refs.d.ts +++ b/src/fillers/monaco-editor-core.ts @@ -2,4 +2,5 @@ * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -/// \ No newline at end of file + +export * from 'monaco-editor-core'; diff --git a/src/json.worker.ts b/src/json.worker.ts index aab645c9..e5bf0460 100644 --- a/src/json.worker.ts +++ b/src/json.worker.ts @@ -2,7 +2,6 @@ * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -'use strict'; import * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker'; import { JSONWorker } from './jsonWorker'; diff --git a/src/jsonMode.ts b/src/jsonMode.ts index 2a9d9137..f24dec70 100644 --- a/src/jsonMode.ts +++ b/src/jsonMode.ts @@ -2,18 +2,15 @@ * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -'use strict'; import { WorkerManager } from './workerManager'; -import { JSONWorker } from './jsonWorker'; -import { LanguageServiceDefaultsImpl } from './monaco.contribution'; +import type { JSONWorker } from './jsonWorker'; +import { LanguageServiceDefaults } from './monaco.contribution'; import * as languageFeatures from './languageFeatures'; import { createTokenizationSupport } from './tokenization'; +import { Uri, IDisposable, languages } from './fillers/monaco-editor-core' -import Uri = monaco.Uri; -import IDisposable = monaco.IDisposable; - -export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable { +export function setupMode(defaults: LanguageServiceDefaults): IDisposable { const disposables: IDisposable[] = []; const providers: IDisposable[] = []; @@ -32,40 +29,40 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable { disposeAll(providers); if (modeConfiguration.documentFormattingEdits) { - providers.push(monaco.languages.registerDocumentFormattingEditProvider(languageId, new languageFeatures.DocumentFormattingEditProvider(worker))); + providers.push(languages.registerDocumentFormattingEditProvider(languageId, new languageFeatures.DocumentFormattingEditProvider(worker))); } if (modeConfiguration.documentRangeFormattingEdits) { - providers.push(monaco.languages.registerDocumentRangeFormattingEditProvider(languageId, new languageFeatures.DocumentRangeFormattingEditProvider(worker))); + providers.push(languages.registerDocumentRangeFormattingEditProvider(languageId, new languageFeatures.DocumentRangeFormattingEditProvider(worker))); } if (modeConfiguration.completionItems) { - providers.push(monaco.languages.registerCompletionItemProvider(languageId, new languageFeatures.CompletionAdapter(worker))); + providers.push(languages.registerCompletionItemProvider(languageId, new languageFeatures.CompletionAdapter(worker))); } if (modeConfiguration.hovers) { - providers.push(monaco.languages.registerHoverProvider(languageId, new languageFeatures.HoverAdapter(worker))); + providers.push(languages.registerHoverProvider(languageId, new languageFeatures.HoverAdapter(worker))); } if (modeConfiguration.documentSymbols) { - providers.push(monaco.languages.registerDocumentSymbolProvider(languageId, new languageFeatures.DocumentSymbolAdapter(worker))); + providers.push(languages.registerDocumentSymbolProvider(languageId, new languageFeatures.DocumentSymbolAdapter(worker))); } if (modeConfiguration.tokens) { - providers.push(monaco.languages.setTokensProvider(languageId, createTokenizationSupport(true))); + providers.push(languages.setTokensProvider(languageId, createTokenizationSupport(true))); } if (modeConfiguration.colors) { - providers.push(monaco.languages.registerColorProvider(languageId, new languageFeatures.DocumentColorAdapter(worker))); + providers.push(languages.registerColorProvider(languageId, new languageFeatures.DocumentColorAdapter(worker))); } if (modeConfiguration.foldingRanges) { - providers.push(monaco.languages.registerFoldingRangeProvider(languageId, new languageFeatures.FoldingRangeAdapter(worker))); + providers.push(languages.registerFoldingRangeProvider(languageId, new languageFeatures.FoldingRangeAdapter(worker))); } if (modeConfiguration.diagnostics) { providers.push(new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults)); } if (modeConfiguration.selectionRanges) { - providers.push(monaco.languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker))); + providers.push(languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker))); } } registerProviders(); - disposables.push(monaco.languages.setLanguageConfiguration(defaults.languageId, richEditConfiguration)); + disposables.push(languages.setLanguageConfiguration(defaults.languageId, richEditConfiguration)); let modeConfiguration = defaults.modeConfiguration; defaults.onDidChange((newDefaults) => { @@ -90,7 +87,7 @@ function disposeAll(disposables: IDisposable[]) { } } -const richEditConfiguration: monaco.languages.LanguageConfiguration = { +const richEditConfiguration: languages.LanguageConfiguration = { wordPattern: /(-?\d*\.\d\w*)|([^\[\{\]\}\:\"\,\s]+)/g, comments: { diff --git a/src/jsonWorker.ts b/src/jsonWorker.ts index c1bb2335..51d677ff 100644 --- a/src/jsonWorker.ts +++ b/src/jsonWorker.ts @@ -2,61 +2,33 @@ * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -'use strict'; - -import Thenable = monaco.Thenable; -import IWorkerContext = monaco.worker.IWorkerContext; import * as jsonService from 'vscode-json-languageservice'; +import type { worker } from './fillers/monaco-editor-core' let defaultSchemaRequestService; if (typeof fetch !== 'undefined') { defaultSchemaRequestService = function (url) { return fetch(url).then(response => response.text()) }; } -class PromiseAdapter implements jsonService.Thenable { - private wrapped: Promise; - - constructor(executor: (resolve: (value?: T | jsonService.Thenable) => void, reject: (reason?: any) => void) => void) { - this.wrapped = new Promise(executor); - } - public then(onfulfilled?: (value: T) => TResult | jsonService.Thenable, onrejected?: (reason: any) => void): jsonService.Thenable { - let thenable: jsonService.Thenable = this.wrapped; - return thenable.then(onfulfilled, onrejected); - } - public getWrapped(): monaco.Thenable { - return this.wrapped; - } - public static resolve(v: T | Thenable): jsonService.Thenable { - return >Promise.resolve(v); - } - public static reject(v: T): jsonService.Thenable { - return Promise.reject(v); - } - public static all(values: jsonService.Thenable[]): jsonService.Thenable { - return Promise.all(values); - } -} - export class JSONWorker { - private _ctx: IWorkerContext; + private _ctx: worker.IWorkerContext; private _languageService: jsonService.LanguageService; private _languageSettings: jsonService.LanguageSettings; private _languageId: string; - constructor(ctx: IWorkerContext, createData: ICreateData) { + constructor(ctx: worker.IWorkerContext, createData: ICreateData) { this._ctx = ctx; this._languageSettings = createData.languageSettings; this._languageId = createData.languageId; this._languageService = jsonService.getLanguageService({ - schemaRequestService: createData.enableSchemaRequest && defaultSchemaRequestService, - promiseConstructor: PromiseAdapter + schemaRequestService: createData.enableSchemaRequest && defaultSchemaRequestService }); this._languageService.configure(this._languageSettings); } - doValidation(uri: string): Thenable { + async doValidation(uri: string): Promise { let document = this._getTextDocument(uri); if (document) { let jsonDocument = this._languageService.parseJSONDocument(document); @@ -64,51 +36,51 @@ export class JSONWorker { } return Promise.resolve([]); } - doComplete(uri: string, position: jsonService.Position): Thenable { + async doComplete(uri: string, position: jsonService.Position): Promise { let document = this._getTextDocument(uri); let jsonDocument = this._languageService.parseJSONDocument(document); return this._languageService.doComplete(document, position, jsonDocument); } - doResolve(item: jsonService.CompletionItem): Thenable { + async doResolve(item: jsonService.CompletionItem): Promise { return this._languageService.doResolve(item); } - doHover(uri: string, position: jsonService.Position): Thenable { + async doHover(uri: string, position: jsonService.Position): Promise { let document = this._getTextDocument(uri); let jsonDocument = this._languageService.parseJSONDocument(document); return this._languageService.doHover(document, position, jsonDocument); } - format(uri: string, range: jsonService.Range, options: jsonService.FormattingOptions): Thenable { + async format(uri: string, range: jsonService.Range, options: jsonService.FormattingOptions): Promise { let document = this._getTextDocument(uri); let textEdits = this._languageService.format(document, range, options); return Promise.resolve(textEdits); } - resetSchema(uri: string): Thenable { + async resetSchema(uri: string): Promise { return Promise.resolve(this._languageService.resetSchema(uri)); } - findDocumentSymbols(uri: string): Thenable { + async findDocumentSymbols(uri: string): Promise { let document = this._getTextDocument(uri); let jsonDocument = this._languageService.parseJSONDocument(document); let symbols = this._languageService.findDocumentSymbols(document, jsonDocument); return Promise.resolve(symbols); } - findDocumentColors(uri: string): Thenable { + async findDocumentColors(uri: string): Promise { let document = this._getTextDocument(uri); let jsonDocument = this._languageService.parseJSONDocument(document); let colorSymbols = this._languageService.findDocumentColors(document, jsonDocument); return Promise.resolve(colorSymbols); } - getColorPresentations(uri: string, color: jsonService.Color, range: jsonService.Range): Thenable { + async getColorPresentations(uri: string, color: jsonService.Color, range: jsonService.Range): Promise { let document = this._getTextDocument(uri); let jsonDocument = this._languageService.parseJSONDocument(document); let colorPresentations = this._languageService.getColorPresentations(document, jsonDocument, color, range); return Promise.resolve(colorPresentations); } - getFoldingRanges(uri: string, context?: { rangeLimit?: number; }): Thenable { + async getFoldingRanges(uri: string, context?: { rangeLimit?: number; }): Promise { let document = this._getTextDocument(uri); let ranges = this._languageService.getFoldingRanges(document, context); return Promise.resolve(ranges); } - getSelectionRanges(uri: string, positions: jsonService.Position[]): Thenable { + async getSelectionRanges(uri: string, positions: jsonService.Position[]): Promise { let document = this._getTextDocument(uri); let jsonDocument = this._languageService.parseJSONDocument(document); let ranges = this._languageService.getSelectionRanges(document, positions, jsonDocument); @@ -131,6 +103,6 @@ export interface ICreateData { enableSchemaRequest: boolean; } -export function create(ctx: IWorkerContext, createData: ICreateData): JSONWorker { +export function create(ctx: worker.IWorkerContext, createData: ICreateData): JSONWorker { return new JSONWorker(ctx, createData); } diff --git a/src/languageFeatures.ts b/src/languageFeatures.ts index 92326a9d..2946e7ab 100644 --- a/src/languageFeatures.ts +++ b/src/languageFeatures.ts @@ -2,24 +2,15 @@ * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -'use strict'; - -import { LanguageServiceDefaultsImpl } from './monaco.contribution'; -import { JSONWorker } from './jsonWorker'; +import { LanguageServiceDefaults } from './monaco.contribution'; +import type { JSONWorker } from './jsonWorker'; +import { Uri, Position, Range, IRange, CancellationToken, IDisposable, editor, languages, MarkerSeverity, IMarkdownString } from './fillers/monaco-editor-core' import * as jsonService from 'vscode-json-languageservice'; -import Uri = monaco.Uri; -import Position = monaco.Position; -import Range = monaco.Range; -import IRange = monaco.IRange; -import Thenable = monaco.Thenable; -import CancellationToken = monaco.CancellationToken; -import IDisposable = monaco.IDisposable; - export interface WorkerAccessor { - (...more: Uri[]): Thenable + (...more: Uri[]): Promise } // --- diagnostics --- --- @@ -29,8 +20,8 @@ export class DiagnosticsAdapter { private _disposables: IDisposable[] = []; private _listener: { [uri: string]: IDisposable } = Object.create(null); - constructor(private _languageId: string, private _worker: WorkerAccessor, defaults: LanguageServiceDefaultsImpl) { - const onModelAdd = (model: monaco.editor.IModel): void => { + constructor(private _languageId: string, private _worker: WorkerAccessor, defaults: LanguageServiceDefaults) { + const onModelAdd = (model: editor.IModel): void => { let modeId = model.getModeId(); if (modeId !== this._languageId) { return; @@ -45,8 +36,8 @@ export class DiagnosticsAdapter { this._doValidate(model.uri, modeId); }; - const onModelRemoved = (model: monaco.editor.IModel): void => { - monaco.editor.setModelMarkers(model, this._languageId, []); + const onModelRemoved = (model: editor.IModel): void => { + editor.setModelMarkers(model, this._languageId, []); let uriStr = model.uri.toString(); let listener = this._listener[uriStr]; if (listener) { @@ -55,19 +46,19 @@ export class DiagnosticsAdapter { } }; - this._disposables.push(monaco.editor.onDidCreateModel(onModelAdd)); - this._disposables.push(monaco.editor.onWillDisposeModel(model => { + this._disposables.push(editor.onDidCreateModel(onModelAdd)); + this._disposables.push(editor.onWillDisposeModel(model => { onModelRemoved(model); this._resetSchema(model.uri); })); - this._disposables.push(monaco.editor.onDidChangeModelLanguage(event => { + this._disposables.push(editor.onDidChangeModelLanguage(event => { onModelRemoved(event.model); onModelAdd(event.model); this._resetSchema(event.model.uri); })); this._disposables.push(defaults.onDidChange(_ => { - monaco.editor.getModels().forEach(model => { + editor.getModels().forEach(model => { if (model.getModeId() === this._languageId) { onModelRemoved(model); onModelAdd(model); @@ -77,14 +68,14 @@ export class DiagnosticsAdapter { this._disposables.push({ dispose: () => { - monaco.editor.getModels().forEach(onModelRemoved); + editor.getModels().forEach(onModelRemoved); for (let key in this._listener) { this._listener[key].dispose(); } } }); - monaco.editor.getModels().forEach(onModelAdd); + editor.getModels().forEach(onModelAdd); } public dispose(): void { @@ -102,9 +93,9 @@ export class DiagnosticsAdapter { this._worker(resource).then(worker => { return worker.doValidation(resource.toString()).then(diagnostics => { const markers = diagnostics.map(d => toDiagnostics(resource, d)); - let model = monaco.editor.getModel(resource); + let model = editor.getModel(resource); if (model && model.getModeId() === languageId) { - monaco.editor.setModelMarkers(model, languageId, markers); + editor.setModelMarkers(model, languageId, markers); } }); }).then(undefined, err => { @@ -114,18 +105,18 @@ export class DiagnosticsAdapter { } -function toSeverity(lsSeverity: number): monaco.MarkerSeverity { +function toSeverity(lsSeverity: number): MarkerSeverity { switch (lsSeverity) { - case jsonService.DiagnosticSeverity.Error: return monaco.MarkerSeverity.Error; - case jsonService.DiagnosticSeverity.Warning: return monaco.MarkerSeverity.Warning; - case jsonService.DiagnosticSeverity.Information: return monaco.MarkerSeverity.Info; - case jsonService.DiagnosticSeverity.Hint: return monaco.MarkerSeverity.Hint; + case jsonService.DiagnosticSeverity.Error: return MarkerSeverity.Error; + case jsonService.DiagnosticSeverity.Warning: return MarkerSeverity.Warning; + case jsonService.DiagnosticSeverity.Information: return MarkerSeverity.Info; + case jsonService.DiagnosticSeverity.Hint: return MarkerSeverity.Hint; default: - return monaco.MarkerSeverity.Info; + return MarkerSeverity.Info; } } -function toDiagnostics(resource: Uri, diag: jsonService.Diagnostic): monaco.editor.IMarkerData { +function toDiagnostics(resource: Uri, diag: jsonService.Diagnostic): editor.IMarkerData { let code = typeof diag.code === 'number' ? String(diag.code) : diag.code; return { @@ -162,8 +153,8 @@ function toRange(range: jsonService.Range): Range { return new Range(range.start.line + 1, range.start.character + 1, range.end.line + 1, range.end.character + 1); } -function toCompletionItemKind(kind: number): monaco.languages.CompletionItemKind { - let mItemKind = monaco.languages.CompletionItemKind; +function toCompletionItemKind(kind: number): languages.CompletionItemKind { + let mItemKind = languages.CompletionItemKind; switch (kind) { case jsonService.CompletionItemKind.Text: return mItemKind.Text; @@ -188,8 +179,8 @@ function toCompletionItemKind(kind: number): monaco.languages.CompletionItemKind return mItemKind.Property; } -function fromCompletionItemKind(kind: monaco.languages.CompletionItemKind): jsonService.CompletionItemKind { - let mItemKind = monaco.languages.CompletionItemKind; +function fromCompletionItemKind(kind: languages.CompletionItemKind): jsonService.CompletionItemKind { + let mItemKind = languages.CompletionItemKind; switch (kind) { case mItemKind.Text: return jsonService.CompletionItemKind.Text; @@ -214,7 +205,7 @@ function fromCompletionItemKind(kind: monaco.languages.CompletionItemKind): json return jsonService.CompletionItemKind.Property; } -function toTextEdit(textEdit: jsonService.TextEdit): monaco.editor.ISingleEditOperation { +function toTextEdit(textEdit: jsonService.TextEdit): editor.ISingleEditOperation { if (!textEdit) { return void 0; } @@ -224,7 +215,7 @@ function toTextEdit(textEdit: jsonService.TextEdit): monaco.editor.ISingleEditOp } } -export class CompletionAdapter implements monaco.languages.CompletionItemProvider { +export class CompletionAdapter implements languages.CompletionItemProvider { constructor(private _worker: WorkerAccessor) { } @@ -233,7 +224,7 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide return [' ', ':']; } - provideCompletionItems(model: monaco.editor.IReadOnlyModel, position: Position, context: monaco.languages.CompletionContext, token: CancellationToken): Thenable { + provideCompletionItems(model: editor.IReadOnlyModel, position: Position, context: languages.CompletionContext, token: CancellationToken): Promise { const resource = model.uri; return this._worker(resource).then(worker => { @@ -245,8 +236,8 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide const wordInfo = model.getWordUntilPosition(position); const wordRange = new Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn); - let items: monaco.languages.CompletionItem[] = info.items.map(entry => { - let item: monaco.languages.CompletionItem = { + let items: languages.CompletionItem[] = info.items.map(entry => { + let item: languages.CompletionItem = { label: entry.label, insertText: entry.insertText || entry.label, sortText: entry.sortText, @@ -264,7 +255,7 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit) } if (entry.insertTextFormat === jsonService.InsertTextFormat.Snippet) { - item.insertTextRules = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet; + item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet; } return item; }); @@ -281,7 +272,7 @@ function isMarkupContent(thing: any): thing is jsonService.MarkupContent { return thing && typeof thing === 'object' && typeof (thing).kind === 'string'; } -function toMarkdownString(entry: jsonService.MarkupContent | jsonService.MarkedString): monaco.IMarkdownString { +function toMarkdownString(entry: jsonService.MarkupContent | jsonService.MarkedString): IMarkdownString { if (typeof entry === 'string') { return { value: entry @@ -301,7 +292,7 @@ function toMarkdownString(entry: jsonService.MarkupContent | jsonService.MarkedS return { value: '```' + entry.language + '\n' + entry.value + '\n```\n' }; } -function toMarkedStringArray(contents: jsonService.MarkupContent | jsonService.MarkedString | jsonService.MarkedString[]): monaco.IMarkdownString[] { +function toMarkedStringArray(contents: jsonService.MarkupContent | jsonService.MarkedString | jsonService.MarkedString[]): IMarkdownString[] { if (!contents) { return void 0; } @@ -314,12 +305,12 @@ function toMarkedStringArray(contents: jsonService.MarkupContent | jsonService.M // --- hover ------ -export class HoverAdapter implements monaco.languages.HoverProvider { +export class HoverAdapter implements languages.HoverProvider { constructor(private _worker: WorkerAccessor) { } - provideHover(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Thenable { + provideHover(model: editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise { let resource = model.uri; return this._worker(resource).then(worker => { @@ -328,7 +319,7 @@ export class HoverAdapter implements monaco.languages.HoverProvider { if (!info) { return; } - return { + return { range: toRange(info.range), contents: toMarkedStringArray(info.contents) }; @@ -338,7 +329,7 @@ export class HoverAdapter implements monaco.languages.HoverProvider { // --- definition ------ -function toLocation(location: jsonService.Location): monaco.languages.Location { +function toLocation(location: jsonService.Location): languages.Location { return { uri: Uri.parse(location.uri), range: toRange(location.range) @@ -348,8 +339,8 @@ function toLocation(location: jsonService.Location): monaco.languages.Location { // --- document symbols ------ -function toSymbolKind(kind: jsonService.SymbolKind): monaco.languages.SymbolKind { - let mKind = monaco.languages.SymbolKind; +function toSymbolKind(kind: jsonService.SymbolKind): languages.SymbolKind { + let mKind = languages.SymbolKind; switch (kind) { case jsonService.SymbolKind.File: return mKind.Array; @@ -375,12 +366,12 @@ function toSymbolKind(kind: jsonService.SymbolKind): monaco.languages.SymbolKind } -export class DocumentSymbolAdapter implements monaco.languages.DocumentSymbolProvider { +export class DocumentSymbolAdapter implements languages.DocumentSymbolProvider { constructor(private _worker: WorkerAccessor) { } - public provideDocumentSymbols(model: monaco.editor.IReadOnlyModel, token: CancellationToken): Thenable { + public provideDocumentSymbols(model: editor.IReadOnlyModel, token: CancellationToken): Promise { const resource = model.uri; return this._worker(resource).then(worker => worker.findDocumentSymbols(resource.toString())).then(items => { @@ -401,19 +392,19 @@ export class DocumentSymbolAdapter implements monaco.languages.DocumentSymbolPro } -function fromFormattingOptions(options: monaco.languages.FormattingOptions): jsonService.FormattingOptions { +function fromFormattingOptions(options: languages.FormattingOptions): jsonService.FormattingOptions { return { tabSize: options.tabSize, insertSpaces: options.insertSpaces }; } -export class DocumentFormattingEditProvider implements monaco.languages.DocumentFormattingEditProvider { +export class DocumentFormattingEditProvider implements languages.DocumentFormattingEditProvider { constructor(private _worker: WorkerAccessor) { } - public provideDocumentFormattingEdits(model: monaco.editor.IReadOnlyModel, options: monaco.languages.FormattingOptions, token: CancellationToken): Thenable { + public provideDocumentFormattingEdits(model: editor.IReadOnlyModel, options: languages.FormattingOptions, token: CancellationToken): Promise { const resource = model.uri; return this._worker(resource).then(worker => { @@ -427,12 +418,12 @@ export class DocumentFormattingEditProvider implements monaco.languages.Document } } -export class DocumentRangeFormattingEditProvider implements monaco.languages.DocumentRangeFormattingEditProvider { +export class DocumentRangeFormattingEditProvider implements languages.DocumentRangeFormattingEditProvider { constructor(private _worker: WorkerAccessor) { } - public provideDocumentRangeFormattingEdits(model: monaco.editor.IReadOnlyModel, range: Range, options: monaco.languages.FormattingOptions, token: CancellationToken): Thenable { + public provideDocumentRangeFormattingEdits(model: editor.IReadOnlyModel, range: Range, options: languages.FormattingOptions, token: CancellationToken): Promise { const resource = model.uri; return this._worker(resource).then(worker => { @@ -446,12 +437,12 @@ export class DocumentRangeFormattingEditProvider implements monaco.languages.Doc } } -export class DocumentColorAdapter implements monaco.languages.DocumentColorProvider { +export class DocumentColorAdapter implements languages.DocumentColorProvider { constructor(private _worker: WorkerAccessor) { } - public provideDocumentColors(model: monaco.editor.IReadOnlyModel, token: CancellationToken): Thenable { + public provideDocumentColors(model: editor.IReadOnlyModel, token: CancellationToken): Promise { const resource = model.uri; return this._worker(resource).then(worker => worker.findDocumentColors(resource.toString())).then(infos => { @@ -465,7 +456,7 @@ export class DocumentColorAdapter implements monaco.languages.DocumentColorProvi }); } - public provideColorPresentations(model: monaco.editor.IReadOnlyModel, info: monaco.languages.IColorInformation, token: CancellationToken): Thenable { + public provideColorPresentations(model: editor.IReadOnlyModel, info: languages.IColorInformation, token: CancellationToken): Promise { const resource = model.uri; return this._worker(resource).then(worker => worker.getColorPresentations(resource.toString(), info.color, fromRange(info.range))).then(presentations => { @@ -473,7 +464,7 @@ export class DocumentColorAdapter implements monaco.languages.DocumentColorProvi return; } return presentations.map(presentation => { - let item: monaco.languages.IColorPresentation = { + let item: languages.IColorPresentation = { label: presentation.label, }; if (presentation.textEdit) { @@ -488,12 +479,12 @@ export class DocumentColorAdapter implements monaco.languages.DocumentColorProvi } } -export class FoldingRangeAdapter implements monaco.languages.FoldingRangeProvider { +export class FoldingRangeAdapter implements languages.FoldingRangeProvider { constructor(private _worker: WorkerAccessor) { } - public provideFoldingRanges(model: monaco.editor.IReadOnlyModel, context: monaco.languages.FoldingContext, token: CancellationToken): Thenable { + public provideFoldingRanges(model: editor.IReadOnlyModel, context: languages.FoldingContext, token: CancellationToken): Promise { const resource = model.uri; return this._worker(resource).then(worker => worker.getFoldingRanges(resource.toString(), context)).then(ranges => { @@ -501,7 +492,7 @@ export class FoldingRangeAdapter implements monaco.languages.FoldingRangeProvide return; } return ranges.map(range => { - let result: monaco.languages.FoldingRange = { + let result: languages.FoldingRange = { start: range.startLine + 1, end: range.endLine + 1 }; @@ -515,21 +506,21 @@ export class FoldingRangeAdapter implements monaco.languages.FoldingRangeProvide } -function toFoldingRangeKind(kind: jsonService.FoldingRangeKind): monaco.languages.FoldingRangeKind { +function toFoldingRangeKind(kind: jsonService.FoldingRangeKind): languages.FoldingRangeKind { switch (kind) { - case jsonService.FoldingRangeKind.Comment: return monaco.languages.FoldingRangeKind.Comment; - case jsonService.FoldingRangeKind.Imports: return monaco.languages.FoldingRangeKind.Imports; - case jsonService.FoldingRangeKind.Region: return monaco.languages.FoldingRangeKind.Region; + case jsonService.FoldingRangeKind.Comment: return languages.FoldingRangeKind.Comment; + case jsonService.FoldingRangeKind.Imports: return languages.FoldingRangeKind.Imports; + case jsonService.FoldingRangeKind.Region: return languages.FoldingRangeKind.Region; } return void 0; } -export class SelectionRangeAdapter implements monaco.languages.SelectionRangeProvider { +export class SelectionRangeAdapter implements languages.SelectionRangeProvider { constructor(private _worker: WorkerAccessor) { } - public provideSelectionRanges(model: monaco.editor.IReadOnlyModel, positions: Position[], token: CancellationToken): Thenable { + public provideSelectionRanges(model: editor.IReadOnlyModel, positions: Position[], token: CancellationToken): Promise { const resource = model.uri; return this._worker(resource).then(worker => worker.getSelectionRanges(resource.toString(), positions.map(fromPosition))).then(selectionRanges => { @@ -537,7 +528,7 @@ export class SelectionRangeAdapter implements monaco.languages.SelectionRangePro return; } return selectionRanges.map(selectionRange => { - const result: monaco.languages.SelectionRange[] = []; + const result: languages.SelectionRange[] = []; while (selectionRange) { result.push({ range: toRange(selectionRange.range) }); selectionRange = selectionRange.parent; diff --git a/src/monaco.contribution.ts b/src/monaco.contribution.ts index 4bab1ba6..6167958b 100644 --- a/src/monaco.contribution.ts +++ b/src/monaco.contribution.ts @@ -2,29 +2,120 @@ * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -'use strict'; import * as mode from './jsonMode'; - -import Emitter = monaco.Emitter; -import IEvent = monaco.IEvent; +import { Emitter, IEvent, languages } from './fillers/monaco-editor-core' // --- JSON configuration and defaults --------- -export class LanguageServiceDefaultsImpl implements monaco.languages.json.LanguageServiceDefaults { +export interface DiagnosticsOptions { + /** + * If set, the validator will be enabled and perform syntax validation as well as schema based validation. + */ + readonly validate?: boolean; + /** + * If set, comments are tolerated. If set to false, syntax errors will be emitted for comments. + */ + readonly allowComments?: boolean; + /** + * A list of known schemas and/or associations of schemas to file names. + */ + readonly schemas?: { + /** + * The URI of the schema, which is also the identifier of the schema. + */ + readonly uri: string; + /** + * A list of file names that are associated to the schema. The '*' wildcard can be used. For example '*.schema.json', 'package.json' + */ + readonly fileMatch?: string[]; + /** + * The schema for the given URI. + */ + readonly schema?: any; + }[]; + /** + * If set, the schema service would load schema content on-demand with 'fetch' if available + */ + readonly enableSchemaRequest?: boolean; +} - private _onDidChange = new Emitter(); - private _diagnosticsOptions: monaco.languages.json.DiagnosticsOptions; - private _modeConfiguration: monaco.languages.json.ModeConfiguration; +export interface ModeConfiguration { + /** + * Defines whether the built-in documentFormattingEdit provider is enabled. + */ + readonly documentFormattingEdits?: boolean; + + /** + * Defines whether the built-in documentRangeFormattingEdit provider is enabled. + */ + readonly documentRangeFormattingEdits?: boolean; + + /** + * Defines whether the built-in completionItemProvider is enabled. + */ + readonly completionItems?: boolean; + + /** + * Defines whether the built-in hoverProvider is enabled. + */ + readonly hovers?: boolean; + + /** + * Defines whether the built-in documentSymbolProvider is enabled. + */ + readonly documentSymbols?: boolean; + + /** + * Defines whether the built-in tokens provider is enabled. + */ + readonly tokens?: boolean; + + /** + * Defines whether the built-in color provider is enabled. + */ + readonly colors?: boolean; + + /** + * Defines whether the built-in foldingRange provider is enabled. + */ + readonly foldingRanges?: boolean; + + /** + * Defines whether the built-in diagnostic provider is enabled. + */ + readonly diagnostics?: boolean; + + /** + * Defines whether the built-in selection range provider is enabled. + */ + readonly selectionRanges?: boolean; + +} + +export interface LanguageServiceDefaults { + readonly languageId: string; + readonly onDidChange: IEvent; + readonly diagnosticsOptions: DiagnosticsOptions; + readonly modeConfiguration: ModeConfiguration; + setDiagnosticsOptions(options: DiagnosticsOptions): void; + setModeConfiguration(modeConfiguration: ModeConfiguration): void; +} + +class LanguageServiceDefaultsImpl implements LanguageServiceDefaults { + + private _onDidChange = new Emitter(); + private _diagnosticsOptions: DiagnosticsOptions; + private _modeConfiguration: ModeConfiguration; private _languageId: string; - constructor(languageId: string, diagnosticsOptions: monaco.languages.json.DiagnosticsOptions, modeConfiguration: monaco.languages.json.ModeConfiguration) { + constructor(languageId: string, diagnosticsOptions: DiagnosticsOptions, modeConfiguration: ModeConfiguration) { this._languageId = languageId; this.setDiagnosticsOptions(diagnosticsOptions); this.setModeConfiguration(modeConfiguration); } - get onDidChange(): IEvent { + get onDidChange(): IEvent { return this._onDidChange.event; } @@ -32,33 +123,33 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.json.Langua return this._languageId; } - get modeConfiguration(): monaco.languages.json.ModeConfiguration { + get modeConfiguration(): ModeConfiguration { return this._modeConfiguration; } - get diagnosticsOptions(): monaco.languages.json.DiagnosticsOptions { + get diagnosticsOptions(): DiagnosticsOptions { return this._diagnosticsOptions; } - setDiagnosticsOptions(options: monaco.languages.json.DiagnosticsOptions): void { + setDiagnosticsOptions(options: DiagnosticsOptions): void { this._diagnosticsOptions = options || Object.create(null); this._onDidChange.fire(this); } - setModeConfiguration(modeConfiguration: monaco.languages.json.ModeConfiguration): void { + setModeConfiguration(modeConfiguration: ModeConfiguration): void { this._modeConfiguration = modeConfiguration || Object.create(null); this._onDidChange.fire(this); }; } -const diagnosticDefault: Required = { +const diagnosticDefault: Required = { validate: true, allowComments: true, schemas: [], enableSchemaRequest: false }; -const modeConfigurationDefault: Required = { +const modeConfigurationDefault: Required = { documentFormattingEdits: true, documentRangeFormattingEdits: true, completionItems: true, @@ -71,15 +162,10 @@ const modeConfigurationDefault: Requiredlanguages).json = { jsonDefaults }; // --- Registration to monaco editor --- @@ -87,13 +173,13 @@ function getMode(): Promise { return import('./jsonMode'); } -monaco.languages.register({ +languages.register({ id: 'json', extensions: ['.json', '.bowerrc', '.jshintrc', '.jscsrc', '.eslintrc', '.babelrc', '.har'], aliases: ['JSON', 'json'], mimetypes: ['application/json'], }); -monaco.languages.onLanguage('json', () => { +languages.onLanguage('json', () => { getMode().then(mode => mode.setupMode(jsonDefaults)); }); diff --git a/src/tokenization.ts b/src/tokenization.ts index cb4ec52c..db2d972c 100644 --- a/src/tokenization.ts +++ b/src/tokenization.ts @@ -2,11 +2,11 @@ * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -'use strict'; import * as json from 'jsonc-parser'; +import { languages } from './fillers/monaco-editor-core' -export function createTokenizationSupport(supportComments: boolean): monaco.languages.TokensProvider { +export function createTokenizationSupport(supportComments: boolean): languages.TokensProvider { return { getInitialState: () => new JSONState(null, null, false), tokenize: (line, state, offsetDelta?, stopAtOffset?) => tokenize(supportComments, line, state, offsetDelta, stopAtOffset) @@ -25,14 +25,14 @@ export const TOKEN_PROPERTY_NAME = 'string.key.json'; export const TOKEN_COMMENT_BLOCK = 'comment.block.json'; export const TOKEN_COMMENT_LINE = 'comment.line.json'; -class JSONState implements monaco.languages.IState { +class JSONState implements languages.IState { - private _state: monaco.languages.IState; + private _state: languages.IState; public scanError: json.ScanError; public lastWasColon: boolean; - constructor(state: monaco.languages.IState, scanError: json.ScanError, lastWasColon: boolean) { + constructor(state: languages.IState, scanError: json.ScanError, lastWasColon: boolean) { this._state = state; this.scanError = scanError; this.lastWasColon = lastWasColon; @@ -42,7 +42,7 @@ class JSONState implements monaco.languages.IState { return new JSONState(this._state, this.scanError, this.lastWasColon); } - public equals(other: monaco.languages.IState): boolean { + public equals(other: languages.IState): boolean { if (other === this) { return true; } @@ -53,16 +53,16 @@ class JSONState implements monaco.languages.IState { this.lastWasColon === (other).lastWasColon; } - public getStateData(): monaco.languages.IState { + public getStateData(): languages.IState { return this._state; } - public setStateData(state: monaco.languages.IState): void { + public setStateData(state: languages.IState): void { this._state = state; } } -function tokenize(comments: boolean, line: string, state: JSONState, offsetDelta: number = 0, stopAtOffset?: number): monaco.languages.ILineTokens { +function tokenize(comments: boolean, line: string, state: JSONState, offsetDelta: number = 0, stopAtOffset?: number): languages.ILineTokens { // handle multiline strings and block comments var numberOfInsertedCharacters = 0, @@ -81,11 +81,11 @@ function tokenize(comments: boolean, line: string, state: JSONState, offsetDelta var scanner = json.createScanner(line), kind: json.SyntaxKind, - ret: monaco.languages.ILineTokens, + ret: languages.ILineTokens, lastWasColon = state.lastWasColon; ret = { - tokens: [], + tokens: [], endState: state.clone() }; @@ -177,4 +177,4 @@ function tokenize(comments: boolean, line: string, state: JSONState, offsetDelta } return ret; -} \ No newline at end of file +} diff --git a/src/tsconfig.esm.json b/src/tsconfig.esm.json index 33cf660c..779a13ce 100644 --- a/src/tsconfig.esm.json +++ b/src/tsconfig.esm.json @@ -1,5 +1,6 @@ { "compilerOptions": { + "declaration": true, "module": "esnext", "moduleResolution": "node", "outDir": "../out/esm", @@ -12,4 +13,4 @@ "es2015.iterable" ] } -} \ No newline at end of file +} diff --git a/src/tsconfig.json b/src/tsconfig.json index c1f28c19..5daa1b31 100644 --- a/src/tsconfig.json +++ b/src/tsconfig.json @@ -3,6 +3,7 @@ "module": "amd", "moduleResolution": "node", "outDir": "../out/amd", + "declaration": true, "target": "es5", "lib": [ "dom", @@ -12,4 +13,4 @@ "es2015.iterable" ] } -} \ No newline at end of file +} diff --git a/src/workerManager.ts b/src/workerManager.ts index dff3cf71..fd4030ef 100644 --- a/src/workerManager.ts +++ b/src/workerManager.ts @@ -2,27 +2,24 @@ * Copyright (c) Microsoft Corporation. All rights reserved. * Licensed under the MIT License. See License.txt in the project root for license information. *--------------------------------------------------------------------------------------------*/ -'use strict'; -import { LanguageServiceDefaultsImpl } from './monaco.contribution'; -import { JSONWorker } from './jsonWorker'; - -import IDisposable = monaco.IDisposable; -import Uri = monaco.Uri; +import { LanguageServiceDefaults } from './monaco.contribution'; +import type { JSONWorker } from './jsonWorker'; +import { IDisposable, Uri, editor } from './fillers/monaco-editor-core' const STOP_WHEN_IDLE_FOR = 2 * 60 * 1000; // 2min export class WorkerManager { - private _defaults: LanguageServiceDefaultsImpl; + private _defaults: LanguageServiceDefaults; private _idleCheckInterval: number; private _lastUsedTime: number; private _configChangeListener: IDisposable; - private _worker: monaco.editor.MonacoWebWorker; + private _worker: editor.MonacoWebWorker; private _client: Promise; - constructor(defaults: LanguageServiceDefaultsImpl) { + constructor(defaults: LanguageServiceDefaults) { this._defaults = defaults; this._worker = null; this._idleCheckInterval = setInterval(() => this._checkIfIdle(), 30 * 1000); @@ -58,7 +55,7 @@ export class WorkerManager { this._lastUsedTime = Date.now(); if (!this._client) { - this._worker = monaco.editor.createWebWorker({ + this._worker = editor.createWebWorker({ // module that exports the create() method and returns a `JSONWorker` instance moduleId: 'vs/language/json/jsonWorker',