SystemSh0cker/monaco-editor
1
0
Fork 0
mirror of https://github.com/microsoft/monaco-editor.git synced 2025-12-22 17:25:39 +01:00
Code Issues Projects Releases Packages Activity

Use the global monaco only in the AMD case (see https://github.com/microsoft/monaco-editor/issues/1974)

Browse source
This commit is contained in:
Alex Dima 2020-09-07 12:24:21 +02:00
parent 47ee25bf88
commit 28d4512f33
No known key found for this signature in database
GPG key ID: 6E58D7B045760DA0
17 changed files with 321 additions and 235 deletions
Download patch file Download diff file Expand all files Collapse all files

2
README.md
View file

@ -9,7 +9,7 @@ JSON language plugin for the Monaco Editor. It provides the following features w
* Syntax highlighting * Syntax highlighting
* Color decorators for all properties matching a schema containing `format: "color-hex"'` (non-standard schema extension) * 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. 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) Internally the JSON plugin uses the [vscode-json-languageservice](https://github.com/Microsoft/vscode-json-languageservice)

18
src/monaco.d.ts → monaco.d.ts vendored
View file

@ -3,7 +3,8 @@
* Licensed under the MIT License. See License.txt in the project root for license information. * 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 { export interface DiagnosticsOptions {
/** /**
* If set, the validator will be enabled and perform syntax validation as well as schema based validation. * 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; readonly enableSchemaRequest?: boolean;
} }
export interface ModeConfiguration { export interface ModeConfiguration {
/** /**
* Defines whether the built-in documentFormattingEdit provider is enabled. * Defines whether the built-in documentFormattingEdit provider is enabled.
*/ */
readonly documentFormattingEdits?: boolean; readonly documentFormattingEdits?: boolean;
/** /**
* Defines whether the built-in documentRangeFormattingEdit provider is enabled. * Defines whether the built-in documentRangeFormattingEdit provider is enabled.
*/ */
readonly documentRangeFormattingEdits?: boolean; readonly documentRangeFormattingEdits?: boolean;
/** /**
* Defines whether the built-in completionItemProvider is enabled. * Defines whether the built-in completionItemProvider is enabled.
*/ */
readonly completionItems?: boolean; readonly completionItems?: boolean;
/** /**
* Defines whether the built-in hoverProvider is enabled. * Defines whether the built-in hoverProvider is enabled.
*/ */
readonly hovers?: boolean; readonly hovers?: boolean;
/** /**
* Defines whether the built-in documentSymbolProvider is enabled. * Defines whether the built-in documentSymbolProvider is enabled.
*/ */
readonly documentSymbols?: boolean; readonly documentSymbols?: boolean;
/** /**
* Defines whether the built-in tokens provider is enabled. * Defines whether the built-in tokens provider is enabled.
*/ */
readonly tokens?: boolean; readonly tokens?: boolean;
/** /**
* Defines whether the built-in color provider is enabled. * Defines whether the built-in color provider is enabled.
*/ */
readonly colors?: boolean; readonly colors?: boolean;
/** /**
* Defines whether the built-in foldingRange provider is enabled. * Defines whether the built-in foldingRange provider is enabled.
*/ */
readonly foldingRanges?: boolean; readonly foldingRanges?: boolean;
/** /**
* Defines whether the built-in diagnostic provider is enabled. * Defines whether the built-in diagnostic provider is enabled.
*/ */
readonly diagnostics?: boolean; readonly diagnostics?: boolean;
/** /**
* Defines whether the built-in selection range provider is enabled. * Defines whether the built-in selection range provider is enabled.
*/ */
readonly selectionRanges?: boolean; readonly selectionRanges?: boolean;
} }
export interface LanguageServiceDefaults { export interface LanguageServiceDefaults {
readonly languageId: string;
readonly onDidChange: IEvent<LanguageServiceDefaults>; readonly onDidChange: IEvent<LanguageServiceDefaults>;
readonly diagnosticsOptions: DiagnosticsOptions; readonly diagnosticsOptions: DiagnosticsOptions;
readonly modeConfiguration: ModeConfiguration; readonly modeConfiguration: ModeConfiguration;
setDiagnosticsOptions(options: DiagnosticsOptions): void; setDiagnosticsOptions(options: DiagnosticsOptions): void;
setModeConfiguration(modeConfiguration: ModeConfiguration): void; setModeConfiguration(modeConfiguration: ModeConfiguration): void;
} }
export const jsonDefaults: LanguageServiceDefaults;
export var jsonDefaults: LanguageServiceDefaults;
} }

54
package-lock.json generated
View file

@ -17,9 +17,9 @@
"dev": true "dev": true
}, },
"jsonc-parser": { "jsonc-parser": {
"version": "2.2.0", "version": "2.3.0",
"resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-2.2.0.tgz", "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-2.3.0.tgz",
"integrity": "sha512-4fLQxW1j/5fWj6p78vAlAafoCKtuBm6ghv+Ij5W2DrDx0qE+ZdEl2c6Ko1mgJNF5ftX1iEWQQ4Ap7+3GlhjkOA==", "integrity": "sha512-b0EBt8SWFNnixVdvoR2ZtEGa9ZqLhbJnOjezn+WP+8kspFm+PFYDN8Z4Bc7pRlDjvuVcADSUkroIuTWWn/YiIA==",
"dev": true "dev": true
}, },
"monaco-editor-core": { "monaco-editor-core": {
@ -35,9 +35,9 @@
"dev": true "dev": true
}, },
"monaco-plugin-helpers": { "monaco-plugin-helpers": {
"version": "1.0.2", "version": "1.0.3",
"resolved": "https://registry.npmjs.org/monaco-plugin-helpers/-/monaco-plugin-helpers-1.0.2.tgz", "resolved": "https://registry.npmjs.org/monaco-plugin-helpers/-/monaco-plugin-helpers-1.0.3.tgz",
"integrity": "sha512-7kUx8dtd5qVNVgUARBRhnM8oftPglYwlINfigC4yGUiuzqtIN22u1tly8umiOCIPR0eFiBLjt6aN23oZh2QJgg==", "integrity": "sha512-6AYI3ONAy8ki74qG2JqtFrLdiJHQlgeO5l4Rwr0OMyIpGXhc94y5rZuFxOtgGkxgSrZfHSwOt/MulUNZ/mOQOw==",
"dev": true, "dev": true,
"requires": { "requires": {
"typescript": "^2.7.2" "typescript": "^2.7.2"
@ -64,9 +64,9 @@
"dev": true "dev": true
}, },
"source-map-support": { "source-map-support": {
"version": "0.5.16", "version": "0.5.19",
"resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.16.tgz", "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.19.tgz",
"integrity": "sha512-efyLRJDr68D9hBBNIPWFjhpFzURh+KJykQwvMyW5UiZzYwoF6l4YMMDIJJEyFWxWCqfyxLzz6tSfUFR+kXXsVQ==", "integrity": "sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw==",
"dev": true, "dev": true,
"requires": { "requires": {
"buffer-from": "^1.0.0", "buffer-from": "^1.0.0",
@ -74,9 +74,9 @@
} }
}, },
"terser": { "terser": {
"version": "4.6.3", "version": "5.3.0",
"resolved": "https://registry.npmjs.org/terser/-/terser-4.6.3.tgz", "resolved": "https://registry.npmjs.org/terser/-/terser-5.3.0.tgz",
"integrity": "sha512-Lw+ieAXmY69d09IIc/yqeBqXpEQIpDGZqT34ui1QWXIUpR2RjbqEkT8X7Lgex19hslSqcWM5iMN2kM11eMsESQ==", "integrity": "sha512-XTT3D3AwxC54KywJijmY2mxZ8nJiEjBHVYzq8l9OaYuRFWeQNBwvipuzzYEP4e+/AVcd1hqG/CqgsdIRyT45Fg==",
"dev": true, "dev": true,
"requires": { "requires": {
"commander": "^2.20.0", "commander": "^2.20.0",
@ -85,9 +85,9 @@
} }
}, },
"typescript": { "typescript": {
"version": "3.7.5", "version": "4.0.2",
"resolved": "https://registry.npmjs.org/typescript/-/typescript-3.7.5.tgz", "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.0.2.tgz",
"integrity": "sha512-/P5lkRXkWHNAbcJIiHPfRoKqyd7bsyCma1hZNUGfn20qm64T6ZBlrzprymeu918H+mB/0rIg2gGK/BXkhhYgBw==", "integrity": "sha512-e4ERvRV2wb+rRZ/IQeb3jm2VxBsirQLpQhdxplZ2MEzGvDkkMmPglecnNDfSUBivMjP93vRbngYYDQqQ/78bcQ==",
"dev": true "dev": true
}, },
"vscode-json-languageservice": { "vscode-json-languageservice": {
@ -104,27 +104,27 @@
} }
}, },
"vscode-languageserver-textdocument": { "vscode-languageserver-textdocument": {
"version": "1.0.0-next.5", "version": "1.0.1",
"resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.0-next.5.tgz", "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.1.tgz",
"integrity": "sha512-1jp/zAidN/bF/sqPimhBX1orH5G4rzRw63k75TesukJDuxm8yW79ECStWbDSy41BHGOwSGN4M69QFvhancSr5A==", "integrity": "sha512-UIcJDjX7IFkck7cSkNNyzIz5FyvpQfY7sdzVy+wkKN/BLaD4DQ0ppXQrKePomCxTS7RrolK1I0pey0bG9eh8dA==",
"dev": true "dev": true
}, },
"vscode-languageserver-types": { "vscode-languageserver-types": {
"version": "3.15.0-next.9", "version": "3.15.1",
"resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.15.0-next.9.tgz", "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.15.1.tgz",
"integrity": "sha512-Rl/8qJ6932nrHCdPn+9y0x08uLVQaSLRG+U4JzhyKpWU4eJbVaDRoAcz1Llj7CErJGbPr6kdBvShPy5fRfR+Uw==", "integrity": "sha512-+a9MPUQrNGRrGU630OGbYVQ+11iOIovjCkqxajPa9w57Sd5ruK8WQNsslzpa0x/QJqC8kRc2DUxWjIFwoNm4ZQ==",
"dev": true "dev": true
}, },
"vscode-nls": { "vscode-nls": {
"version": "4.1.1", "version": "4.1.2",
"resolved": "https://registry.npmjs.org/vscode-nls/-/vscode-nls-4.1.1.tgz", "resolved": "https://registry.npmjs.org/vscode-nls/-/vscode-nls-4.1.2.tgz",
"integrity": "sha512-4R+2UoUUU/LdnMnFjePxfLqNhBS8lrAFyX7pjb2ud/lqDkrUavFUTcG7wR0HBZFakae0Q6KLBFjMS6W93F403A==", "integrity": "sha512-7bOHxPsfyuCqmP+hZXscLhiHwe7CSuFE4hyhbs22xPIhQ4jv99FcR4eBzfYYVLP356HNFpdvz63FFb/xw6T4Iw==",
"dev": true "dev": true
}, },
"vscode-uri": { "vscode-uri": {
"version": "2.1.1", "version": "2.1.2",
"resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-2.1.1.tgz", "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-2.1.2.tgz",
"integrity": "sha512-eY9jmGoEnVf8VE8xr5znSah7Qt1P/xsCdErz+g8HYZtJ7bZqKH5E3d+6oVNm1AC/c6IHUDokbmVXKOi4qPAC9A==", "integrity": "sha512-8TEXQxlldWAuIODdukIb+TR5s+9Ds40eSJrw+1iDDA9IFORPjMELarNQE3myz5XIkWWpdprmJjm1/SxMlWOC8A==",
"dev": true "dev": true
} }
} }

12
package.json
View file

@ -3,9 +3,9 @@
"version": "2.9.0", "version": "2.9.0",
"description": "JSON plugin for the Monaco Editor", "description": "JSON plugin for the Monaco Editor",
"scripts": { "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", "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-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" "install-service-local": "npm install ../vscode-json-languageservice -f -D && npm install ../vscode-languageserver-node/types -f -D"
}, },
@ -18,14 +18,16 @@
"bugs": { "bugs": {
"url": "https://github.com/Microsoft/monaco-json/issues" "url": "https://github.com/Microsoft/monaco-json/issues"
}, },
"module": "./release/esm/monaco.contribution.js",
"typings": "./release/esm/monaco.contribution.d.ts",
"devDependencies": { "devDependencies": {
"jsonc-parser": "^2.2.0", "jsonc-parser": "^2.2.0",
"monaco-editor-core": "0.20.0", "monaco-editor-core": "0.20.0",
"monaco-languages": "1.10.0", "monaco-languages": "1.10.0",
"monaco-plugin-helpers": "^1.0.2", "monaco-plugin-helpers": "^1.0.3",
"requirejs": "^2.3.6", "requirejs": "^2.3.6",
"typescript": "3.7.5", "typescript": "4.0.2",
"terser": "^4.6.3", "terser": "^5.3.0",
"vscode-json-languageservice": "3.4.11" "vscode-json-languageservice": "3.4.11"
} }
} }

6
scripts/bundle.js
View file

@ -24,14 +24,14 @@ bundleOne('monaco.contribution');
bundleOne('jsonMode'); bundleOne('jsonMode');
bundleOne('jsonWorker'); bundleOne('jsonWorker');
function bundleOne(moduleId, exclude) { function bundleOne(moduleId) {
requirejs.optimize({ requirejs.optimize({
baseUrl: 'out/amd/', baseUrl: 'out/amd/',
name: 'vs/language/json/' + moduleId, name: 'vs/language/json/' + moduleId,
out: 'release/dev/' + moduleId + '.js', out: 'release/dev/' + moduleId + '.js',
exclude: exclude,
paths: { 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', optimize: 'none',
packages: [{ packages: [{

37
scripts/dts.js Normal file
View file

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

12
src/fillers/monaco-editor-core-amd.ts Normal file
View file

@ -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 (<any>self).monaco;
});

3
src/typings/refs.d.ts → src/fillers/monaco-editor-core.ts
View file

@ -2,4 +2,5 @@
* Copyright (c) Microsoft Corporation. All rights reserved. * Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information. * Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/ *--------------------------------------------------------------------------------------------*/
/// <reference path='../../node_modules/monaco-editor-core/monaco.d.ts'/>
export * from 'monaco-editor-core';

1
src/json.worker.ts
View file

@ -2,7 +2,6 @@
* Copyright (c) Microsoft Corporation. All rights reserved. * Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information. * 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 * as worker from 'monaco-editor-core/esm/vs/editor/editor.worker';
import { JSONWorker } from './jsonWorker'; import { JSONWorker } from './jsonWorker';

33
src/jsonMode.ts
View file

@ -2,18 +2,15 @@
* Copyright (c) Microsoft Corporation. All rights reserved. * Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information. * Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/ *--------------------------------------------------------------------------------------------*/
'use strict';
import { WorkerManager } from './workerManager'; import { WorkerManager } from './workerManager';
import { JSONWorker } from './jsonWorker'; import type { JSONWorker } from './jsonWorker';
import { LanguageServiceDefaultsImpl } from './monaco.contribution'; import { LanguageServiceDefaults } from './monaco.contribution';
import * as languageFeatures from './languageFeatures'; import * as languageFeatures from './languageFeatures';
import { createTokenizationSupport } from './tokenization'; import { createTokenizationSupport } from './tokenization';
import { Uri, IDisposable, languages } from './fillers/monaco-editor-core'
import Uri = monaco.Uri; export function setupMode(defaults: LanguageServiceDefaults): IDisposable {
import IDisposable = monaco.IDisposable;
export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
const disposables: IDisposable[] = []; const disposables: IDisposable[] = [];
const providers: IDisposable[] = []; const providers: IDisposable[] = [];
@ -32,40 +29,40 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
disposeAll(providers); disposeAll(providers);
if (modeConfiguration.documentFormattingEdits) { 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) { 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) { 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) { 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) { 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) { if (modeConfiguration.tokens) {
providers.push(monaco.languages.setTokensProvider(languageId, createTokenizationSupport(true))); providers.push(languages.setTokensProvider(languageId, createTokenizationSupport(true)));
} }
if (modeConfiguration.colors) { 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) { 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) { if (modeConfiguration.diagnostics) {
providers.push(new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults)); providers.push(new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults));
} }
if (modeConfiguration.selectionRanges) { if (modeConfiguration.selectionRanges) {
providers.push(monaco.languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker))); providers.push(languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker)));
} }
} }
registerProviders(); registerProviders();
disposables.push(monaco.languages.setLanguageConfiguration(defaults.languageId, richEditConfiguration)); disposables.push(languages.setLanguageConfiguration(defaults.languageId, richEditConfiguration));
let modeConfiguration = defaults.modeConfiguration; let modeConfiguration = defaults.modeConfiguration;
defaults.onDidChange((newDefaults) => { 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, wordPattern: /(-?\d*\.\d\w*)|([^\[\{\]\}\:\"\,\s]+)/g,
comments: { comments: {

60
src/jsonWorker.ts
View file

@ -2,61 +2,33 @@
* Copyright (c) Microsoft Corporation. All rights reserved. * Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information. * 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 * as jsonService from 'vscode-json-languageservice';
import type { worker } from './fillers/monaco-editor-core'
let defaultSchemaRequestService; let defaultSchemaRequestService;
if (typeof fetch !== 'undefined') { if (typeof fetch !== 'undefined') {
defaultSchemaRequestService = function (url) { return fetch(url).then(response => response.text()) }; defaultSchemaRequestService = function (url) { return fetch(url).then(response => response.text()) };
} }
class PromiseAdapter<T> implements jsonService.Thenable<T> {
private wrapped: Promise<T>;
constructor(executor: (resolve: (value?: T | jsonService.Thenable<T>) => void, reject: (reason?: any) => void) => void) {
this.wrapped = new Promise<T>(executor);
}
public then<TResult>(onfulfilled?: (value: T) => TResult | jsonService.Thenable<TResult>, onrejected?: (reason: any) => void): jsonService.Thenable<TResult> {
let thenable: jsonService.Thenable<T> = this.wrapped;
return thenable.then(onfulfilled, onrejected);
}
public getWrapped(): monaco.Thenable<T> {
return this.wrapped;
}
public static resolve<T>(v: T | Thenable<T>): jsonService.Thenable<T> {
return <monaco.Thenable<T>>Promise.resolve(v);
}
public static reject<T>(v: T): jsonService.Thenable<T> {
return Promise.reject(<any>v);
}
public static all<T>(values: jsonService.Thenable<T>[]): jsonService.Thenable<T[]> {
return Promise.all(values);
}
}
export class JSONWorker { export class JSONWorker {
private _ctx: IWorkerContext; private _ctx: worker.IWorkerContext;
private _languageService: jsonService.LanguageService; private _languageService: jsonService.LanguageService;
private _languageSettings: jsonService.LanguageSettings; private _languageSettings: jsonService.LanguageSettings;
private _languageId: string; private _languageId: string;
constructor(ctx: IWorkerContext, createData: ICreateData) { constructor(ctx: worker.IWorkerContext, createData: ICreateData) {
this._ctx = ctx; this._ctx = ctx;
this._languageSettings = createData.languageSettings; this._languageSettings = createData.languageSettings;
this._languageId = createData.languageId; this._languageId = createData.languageId;
this._languageService = jsonService.getLanguageService({ this._languageService = jsonService.getLanguageService({
schemaRequestService: createData.enableSchemaRequest && defaultSchemaRequestService, schemaRequestService: createData.enableSchemaRequest && defaultSchemaRequestService
promiseConstructor: PromiseAdapter
}); });
this._languageService.configure(this._languageSettings); this._languageService.configure(this._languageSettings);
} }
doValidation(uri: string): Thenable<jsonService.Diagnostic[]> { async doValidation(uri: string): Promise<jsonService.Diagnostic[]> {
let document = this._getTextDocument(uri); let document = this._getTextDocument(uri);
if (document) { if (document) {
let jsonDocument = this._languageService.parseJSONDocument(document); let jsonDocument = this._languageService.parseJSONDocument(document);
@ -64,51 +36,51 @@ export class JSONWorker {
} }
return Promise.resolve([]); return Promise.resolve([]);
} }
doComplete(uri: string, position: jsonService.Position): Thenable<jsonService.CompletionList> { async doComplete(uri: string, position: jsonService.Position): Promise<jsonService.CompletionList> {
let document = this._getTextDocument(uri); let document = this._getTextDocument(uri);
let jsonDocument = this._languageService.parseJSONDocument(document); let jsonDocument = this._languageService.parseJSONDocument(document);
return this._languageService.doComplete(document, position, jsonDocument); return this._languageService.doComplete(document, position, jsonDocument);
} }
doResolve(item: jsonService.CompletionItem): Thenable<jsonService.CompletionItem> { async doResolve(item: jsonService.CompletionItem): Promise<jsonService.CompletionItem> {
return this._languageService.doResolve(item); return this._languageService.doResolve(item);
} }
doHover(uri: string, position: jsonService.Position): Thenable<jsonService.Hover> { async doHover(uri: string, position: jsonService.Position): Promise<jsonService.Hover> {
let document = this._getTextDocument(uri); let document = this._getTextDocument(uri);
let jsonDocument = this._languageService.parseJSONDocument(document); let jsonDocument = this._languageService.parseJSONDocument(document);
return this._languageService.doHover(document, position, jsonDocument); return this._languageService.doHover(document, position, jsonDocument);
} }
format(uri: string, range: jsonService.Range, options: jsonService.FormattingOptions): Thenable<jsonService.TextEdit[]> { async format(uri: string, range: jsonService.Range, options: jsonService.FormattingOptions): Promise<jsonService.TextEdit[]> {
let document = this._getTextDocument(uri); let document = this._getTextDocument(uri);
let textEdits = this._languageService.format(document, range, options); let textEdits = this._languageService.format(document, range, options);
return Promise.resolve(textEdits); return Promise.resolve(textEdits);
} }
resetSchema(uri: string): Thenable<boolean> { async resetSchema(uri: string): Promise<boolean> {
return Promise.resolve(this._languageService.resetSchema(uri)); return Promise.resolve(this._languageService.resetSchema(uri));
} }
findDocumentSymbols(uri: string): Thenable<jsonService.SymbolInformation[]> { async findDocumentSymbols(uri: string): Promise<jsonService.SymbolInformation[]> {
let document = this._getTextDocument(uri); let document = this._getTextDocument(uri);
let jsonDocument = this._languageService.parseJSONDocument(document); let jsonDocument = this._languageService.parseJSONDocument(document);
let symbols = this._languageService.findDocumentSymbols(document, jsonDocument); let symbols = this._languageService.findDocumentSymbols(document, jsonDocument);
return Promise.resolve(symbols); return Promise.resolve(symbols);
} }
findDocumentColors(uri: string): Thenable<jsonService.ColorInformation[]> { async findDocumentColors(uri: string): Promise<jsonService.ColorInformation[]> {
let document = this._getTextDocument(uri); let document = this._getTextDocument(uri);
let jsonDocument = this._languageService.parseJSONDocument(document); let jsonDocument = this._languageService.parseJSONDocument(document);
let colorSymbols = this._languageService.findDocumentColors(document, jsonDocument); let colorSymbols = this._languageService.findDocumentColors(document, jsonDocument);
return Promise.resolve(colorSymbols); return Promise.resolve(colorSymbols);
} }
getColorPresentations(uri: string, color: jsonService.Color, range: jsonService.Range): Thenable<jsonService.ColorPresentation[]> { async getColorPresentations(uri: string, color: jsonService.Color, range: jsonService.Range): Promise<jsonService.ColorPresentation[]> {
let document = this._getTextDocument(uri); let document = this._getTextDocument(uri);
let jsonDocument = this._languageService.parseJSONDocument(document); let jsonDocument = this._languageService.parseJSONDocument(document);
let colorPresentations = this._languageService.getColorPresentations(document, jsonDocument, color, range); let colorPresentations = this._languageService.getColorPresentations(document, jsonDocument, color, range);
return Promise.resolve(colorPresentations); return Promise.resolve(colorPresentations);
} }
getFoldingRanges(uri: string, context?: { rangeLimit?: number; }): Thenable<jsonService.FoldingRange[]> { async getFoldingRanges(uri: string, context?: { rangeLimit?: number; }): Promise<jsonService.FoldingRange[]> {
let document = this._getTextDocument(uri); let document = this._getTextDocument(uri);
let ranges = this._languageService.getFoldingRanges(document, context); let ranges = this._languageService.getFoldingRanges(document, context);
return Promise.resolve(ranges); return Promise.resolve(ranges);
} }
getSelectionRanges(uri: string, positions: jsonService.Position[]): Thenable<jsonService.SelectionRange[]> { async getSelectionRanges(uri: string, positions: jsonService.Position[]): Promise<jsonService.SelectionRange[]> {
let document = this._getTextDocument(uri); let document = this._getTextDocument(uri);
let jsonDocument = this._languageService.parseJSONDocument(document); let jsonDocument = this._languageService.parseJSONDocument(document);
let ranges = this._languageService.getSelectionRanges(document, positions, jsonDocument); let ranges = this._languageService.getSelectionRanges(document, positions, jsonDocument);
@ -131,6 +103,6 @@ export interface ICreateData {
enableSchemaRequest: boolean; enableSchemaRequest: boolean;
} }
export function create(ctx: IWorkerContext, createData: ICreateData): JSONWorker { export function create(ctx: worker.IWorkerContext, createData: ICreateData): JSONWorker {
return new JSONWorker(ctx, createData); return new JSONWorker(ctx, createData);
} }

133
src/languageFeatures.ts
View file

@ -2,24 +2,15 @@
* Copyright (c) Microsoft Corporation. All rights reserved. * Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information. * 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 * 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 { export interface WorkerAccessor {
(...more: Uri[]): Thenable<JSONWorker> (...more: Uri[]): Promise<JSONWorker>
} }
// --- diagnostics --- --- // --- diagnostics --- ---
@ -29,8 +20,8 @@ export class DiagnosticsAdapter {
private _disposables: IDisposable[] = []; private _disposables: IDisposable[] = [];
private _listener: { [uri: string]: IDisposable } = Object.create(null); private _listener: { [uri: string]: IDisposable } = Object.create(null);
constructor(private _languageId: string, private _worker: WorkerAccessor, defaults: LanguageServiceDefaultsImpl) { constructor(private _languageId: string, private _worker: WorkerAccessor, defaults: LanguageServiceDefaults) {
const onModelAdd = (model: monaco.editor.IModel): void => { const onModelAdd = (model: editor.IModel): void => {
let modeId = model.getModeId(); let modeId = model.getModeId();
if (modeId !== this._languageId) { if (modeId !== this._languageId) {
return; return;
@ -45,8 +36,8 @@ export class DiagnosticsAdapter {
this._doValidate(model.uri, modeId); this._doValidate(model.uri, modeId);
}; };
const onModelRemoved = (model: monaco.editor.IModel): void => { const onModelRemoved = (model: editor.IModel): void => {
monaco.editor.setModelMarkers(model, this._languageId, []); editor.setModelMarkers(model, this._languageId, []);
let uriStr = model.uri.toString(); let uriStr = model.uri.toString();
let listener = this._listener[uriStr]; let listener = this._listener[uriStr];
if (listener) { if (listener) {
@ -55,19 +46,19 @@ export class DiagnosticsAdapter {
} }
}; };
this._disposables.push(monaco.editor.onDidCreateModel(onModelAdd)); this._disposables.push(editor.onDidCreateModel(onModelAdd));
this._disposables.push(monaco.editor.onWillDisposeModel(model => { this._disposables.push(editor.onWillDisposeModel(model => {
onModelRemoved(model); onModelRemoved(model);
this._resetSchema(model.uri); this._resetSchema(model.uri);
})); }));
this._disposables.push(monaco.editor.onDidChangeModelLanguage(event => { this._disposables.push(editor.onDidChangeModelLanguage(event => {
onModelRemoved(event.model); onModelRemoved(event.model);
onModelAdd(event.model); onModelAdd(event.model);
this._resetSchema(event.model.uri); this._resetSchema(event.model.uri);
})); }));
this._disposables.push(defaults.onDidChange(_ => { this._disposables.push(defaults.onDidChange(_ => {
monaco.editor.getModels().forEach(model => { editor.getModels().forEach(model => {
if (model.getModeId() === this._languageId) { if (model.getModeId() === this._languageId) {
onModelRemoved(model); onModelRemoved(model);
onModelAdd(model); onModelAdd(model);
@ -77,14 +68,14 @@ export class DiagnosticsAdapter {
this._disposables.push({ this._disposables.push({
dispose: () => { dispose: () => {
monaco.editor.getModels().forEach(onModelRemoved); editor.getModels().forEach(onModelRemoved);
for (let key in this._listener) { for (let key in this._listener) {
this._listener[key].dispose(); this._listener[key].dispose();
} }
} }
}); });
monaco.editor.getModels().forEach(onModelAdd); editor.getModels().forEach(onModelAdd);
} }
public dispose(): void { public dispose(): void {
@ -102,9 +93,9 @@ export class DiagnosticsAdapter {
this._worker(resource).then(worker => { this._worker(resource).then(worker => {
return worker.doValidation(resource.toString()).then(diagnostics => { return worker.doValidation(resource.toString()).then(diagnostics => {
const markers = diagnostics.map(d => toDiagnostics(resource, d)); const markers = diagnostics.map(d => toDiagnostics(resource, d));
let model = monaco.editor.getModel(resource); let model = editor.getModel(resource);
if (model && model.getModeId() === languageId) { if (model && model.getModeId() === languageId) {
monaco.editor.setModelMarkers(model, languageId, markers); editor.setModelMarkers(model, languageId, markers);
} }
}); });
}).then(undefined, err => { }).then(undefined, err => {
@ -114,18 +105,18 @@ export class DiagnosticsAdapter {
} }
function toSeverity(lsSeverity: number): monaco.MarkerSeverity { function toSeverity(lsSeverity: number): MarkerSeverity {
switch (lsSeverity) { switch (lsSeverity) {
case jsonService.DiagnosticSeverity.Error: return monaco.MarkerSeverity.Error; case jsonService.DiagnosticSeverity.Error: return MarkerSeverity.Error;
case jsonService.DiagnosticSeverity.Warning: return monaco.MarkerSeverity.Warning; case jsonService.DiagnosticSeverity.Warning: return MarkerSeverity.Warning;
case jsonService.DiagnosticSeverity.Information: return monaco.MarkerSeverity.Info; case jsonService.DiagnosticSeverity.Information: return MarkerSeverity.Info;
case jsonService.DiagnosticSeverity.Hint: return monaco.MarkerSeverity.Hint; case jsonService.DiagnosticSeverity.Hint: return MarkerSeverity.Hint;
default: 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) : <string>diag.code; let code = typeof diag.code === 'number' ? String(diag.code) : <string>diag.code;
return { 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); 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 { function toCompletionItemKind(kind: number): languages.CompletionItemKind {
let mItemKind = monaco.languages.CompletionItemKind; let mItemKind = languages.CompletionItemKind;
switch (kind) { switch (kind) {
case jsonService.CompletionItemKind.Text: return mItemKind.Text; case jsonService.CompletionItemKind.Text: return mItemKind.Text;
@ -188,8 +179,8 @@ function toCompletionItemKind(kind: number): monaco.languages.CompletionItemKind
return mItemKind.Property; return mItemKind.Property;
} }
function fromCompletionItemKind(kind: monaco.languages.CompletionItemKind): jsonService.CompletionItemKind { function fromCompletionItemKind(kind: languages.CompletionItemKind): jsonService.CompletionItemKind {
let mItemKind = monaco.languages.CompletionItemKind; let mItemKind = languages.CompletionItemKind;
switch (kind) { switch (kind) {
case mItemKind.Text: return jsonService.CompletionItemKind.Text; case mItemKind.Text: return jsonService.CompletionItemKind.Text;
@ -214,7 +205,7 @@ function fromCompletionItemKind(kind: monaco.languages.CompletionItemKind): json
return jsonService.CompletionItemKind.Property; return jsonService.CompletionItemKind.Property;
} }
function toTextEdit(textEdit: jsonService.TextEdit): monaco.editor.ISingleEditOperation { function toTextEdit(textEdit: jsonService.TextEdit): editor.ISingleEditOperation {
if (!textEdit) { if (!textEdit) {
return void 0; 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) { constructor(private _worker: WorkerAccessor) {
} }
@ -233,7 +224,7 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
return [' ', ':']; return [' ', ':'];
} }
provideCompletionItems(model: monaco.editor.IReadOnlyModel, position: Position, context: monaco.languages.CompletionContext, token: CancellationToken): Thenable<monaco.languages.CompletionList> { provideCompletionItems(model: editor.IReadOnlyModel, position: Position, context: languages.CompletionContext, token: CancellationToken): Promise<languages.CompletionList> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource).then(worker => { return this._worker(resource).then(worker => {
@ -245,8 +236,8 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
const wordInfo = model.getWordUntilPosition(position); const wordInfo = model.getWordUntilPosition(position);
const wordRange = new Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn); const wordRange = new Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
let items: monaco.languages.CompletionItem[] = info.items.map(entry => { let items: languages.CompletionItem[] = info.items.map(entry => {
let item: monaco.languages.CompletionItem = { let item: languages.CompletionItem = {
label: entry.label, label: entry.label,
insertText: entry.insertText || entry.label, insertText: entry.insertText || entry.label,
sortText: entry.sortText, sortText: entry.sortText,
@ -264,7 +255,7 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit) item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit)
} }
if (entry.insertTextFormat === jsonService.InsertTextFormat.Snippet) { if (entry.insertTextFormat === jsonService.InsertTextFormat.Snippet) {
item.insertTextRules = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet; item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet;
} }
return item; return item;
}); });
@ -281,7 +272,7 @@ function isMarkupContent(thing: any): thing is jsonService.MarkupContent {
return thing && typeof thing === 'object' && typeof (<jsonService.MarkupContent>thing).kind === 'string'; return thing && typeof thing === 'object' && typeof (<jsonService.MarkupContent>thing).kind === 'string';
} }
function toMarkdownString(entry: jsonService.MarkupContent | jsonService.MarkedString): monaco.IMarkdownString { function toMarkdownString(entry: jsonService.MarkupContent | jsonService.MarkedString): IMarkdownString {
if (typeof entry === 'string') { if (typeof entry === 'string') {
return { return {
value: entry value: entry
@ -301,7 +292,7 @@ function toMarkdownString(entry: jsonService.MarkupContent | jsonService.MarkedS
return { value: '```' + entry.language + '\n' + entry.value + '\n```\n' }; 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) { if (!contents) {
return void 0; return void 0;
} }
@ -314,12 +305,12 @@ function toMarkedStringArray(contents: jsonService.MarkupContent | jsonService.M
// --- hover ------ // --- hover ------
export class HoverAdapter implements monaco.languages.HoverProvider { export class HoverAdapter implements languages.HoverProvider {
constructor(private _worker: WorkerAccessor) { constructor(private _worker: WorkerAccessor) {
} }
provideHover(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Thenable<monaco.languages.Hover> { provideHover(model: editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise<languages.Hover> {
let resource = model.uri; let resource = model.uri;
return this._worker(resource).then(worker => { return this._worker(resource).then(worker => {
@ -328,7 +319,7 @@ export class HoverAdapter implements monaco.languages.HoverProvider {
if (!info) { if (!info) {
return; return;
} }
return <monaco.languages.Hover>{ return <languages.Hover>{
range: toRange(info.range), range: toRange(info.range),
contents: toMarkedStringArray(info.contents) contents: toMarkedStringArray(info.contents)
}; };
@ -338,7 +329,7 @@ export class HoverAdapter implements monaco.languages.HoverProvider {
// --- definition ------ // --- definition ------
function toLocation(location: jsonService.Location): monaco.languages.Location { function toLocation(location: jsonService.Location): languages.Location {
return { return {
uri: Uri.parse(location.uri), uri: Uri.parse(location.uri),
range: toRange(location.range) range: toRange(location.range)
@ -348,8 +339,8 @@ function toLocation(location: jsonService.Location): monaco.languages.Location {
// --- document symbols ------ // --- document symbols ------
function toSymbolKind(kind: jsonService.SymbolKind): monaco.languages.SymbolKind { function toSymbolKind(kind: jsonService.SymbolKind): languages.SymbolKind {
let mKind = monaco.languages.SymbolKind; let mKind = languages.SymbolKind;
switch (kind) { switch (kind) {
case jsonService.SymbolKind.File: return mKind.Array; 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) { constructor(private _worker: WorkerAccessor) {
} }
public provideDocumentSymbols(model: monaco.editor.IReadOnlyModel, token: CancellationToken): Thenable<monaco.languages.DocumentSymbol[]> { public provideDocumentSymbols(model: editor.IReadOnlyModel, token: CancellationToken): Promise<languages.DocumentSymbol[]> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource).then(worker => worker.findDocumentSymbols(resource.toString())).then(items => { 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 { return {
tabSize: options.tabSize, tabSize: options.tabSize,
insertSpaces: options.insertSpaces insertSpaces: options.insertSpaces
}; };
} }
export class DocumentFormattingEditProvider implements monaco.languages.DocumentFormattingEditProvider { export class DocumentFormattingEditProvider implements languages.DocumentFormattingEditProvider {
constructor(private _worker: WorkerAccessor) { constructor(private _worker: WorkerAccessor) {
} }
public provideDocumentFormattingEdits(model: monaco.editor.IReadOnlyModel, options: monaco.languages.FormattingOptions, token: CancellationToken): Thenable<monaco.editor.ISingleEditOperation[]> { public provideDocumentFormattingEdits(model: editor.IReadOnlyModel, options: languages.FormattingOptions, token: CancellationToken): Promise<editor.ISingleEditOperation[]> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource).then(worker => { 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) { constructor(private _worker: WorkerAccessor) {
} }
public provideDocumentRangeFormattingEdits(model: monaco.editor.IReadOnlyModel, range: Range, options: monaco.languages.FormattingOptions, token: CancellationToken): Thenable<monaco.editor.ISingleEditOperation[]> { public provideDocumentRangeFormattingEdits(model: editor.IReadOnlyModel, range: Range, options: languages.FormattingOptions, token: CancellationToken): Promise<editor.ISingleEditOperation[]> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource).then(worker => { 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) { constructor(private _worker: WorkerAccessor) {
} }
public provideDocumentColors(model: monaco.editor.IReadOnlyModel, token: CancellationToken): Thenable<monaco.languages.IColorInformation[]> { public provideDocumentColors(model: editor.IReadOnlyModel, token: CancellationToken): Promise<languages.IColorInformation[]> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource).then(worker => worker.findDocumentColors(resource.toString())).then(infos => { 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<monaco.languages.IColorPresentation[]> { public provideColorPresentations(model: editor.IReadOnlyModel, info: languages.IColorInformation, token: CancellationToken): Promise<languages.IColorPresentation[]> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource).then(worker => worker.getColorPresentations(resource.toString(), info.color, fromRange(info.range))).then(presentations => { 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;
} }
return presentations.map(presentation => { return presentations.map(presentation => {
let item: monaco.languages.IColorPresentation = { let item: languages.IColorPresentation = {
label: presentation.label, label: presentation.label,
}; };
if (presentation.textEdit) { 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) { constructor(private _worker: WorkerAccessor) {
} }
public provideFoldingRanges(model: monaco.editor.IReadOnlyModel, context: monaco.languages.FoldingContext, token: CancellationToken): Thenable<monaco.languages.FoldingRange[]> { public provideFoldingRanges(model: editor.IReadOnlyModel, context: languages.FoldingContext, token: CancellationToken): Promise<languages.FoldingRange[]> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource).then(worker => worker.getFoldingRanges(resource.toString(), context)).then(ranges => { 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;
} }
return ranges.map(range => { return ranges.map(range => {
let result: monaco.languages.FoldingRange = { let result: languages.FoldingRange = {
start: range.startLine + 1, start: range.startLine + 1,
end: range.endLine + 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) { switch (kind) {
case jsonService.FoldingRangeKind.Comment: return monaco.languages.FoldingRangeKind.Comment; case jsonService.FoldingRangeKind.Comment: return languages.FoldingRangeKind.Comment;
case jsonService.FoldingRangeKind.Imports: return monaco.languages.FoldingRangeKind.Imports; case jsonService.FoldingRangeKind.Imports: return languages.FoldingRangeKind.Imports;
case jsonService.FoldingRangeKind.Region: return monaco.languages.FoldingRangeKind.Region; case jsonService.FoldingRangeKind.Region: return languages.FoldingRangeKind.Region;
} }
return void 0; return void 0;
} }
export class SelectionRangeAdapter implements monaco.languages.SelectionRangeProvider { export class SelectionRangeAdapter implements languages.SelectionRangeProvider {
constructor(private _worker: WorkerAccessor) { constructor(private _worker: WorkerAccessor) {
} }
public provideSelectionRanges(model: monaco.editor.IReadOnlyModel, positions: Position[], token: CancellationToken): Thenable<monaco.languages.SelectionRange[][]> { public provideSelectionRanges(model: editor.IReadOnlyModel, positions: Position[], token: CancellationToken): Promise<languages.SelectionRange[][]> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource).then(worker => worker.getSelectionRanges(resource.toString(), positions.map(fromPosition))).then(selectionRanges => { 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;
} }
return selectionRanges.map(selectionRange => { return selectionRanges.map(selectionRange => {
const result: monaco.languages.SelectionRange[] = []; const result: languages.SelectionRange[] = [];
while (selectionRange) { while (selectionRange) {
result.push({ range: toRange(selectionRange.range) }); result.push({ range: toRange(selectionRange.range) });
selectionRange = selectionRange.parent; selectionRange = selectionRange.parent;

138
src/monaco.contribution.ts
View file

@ -2,29 +2,120 @@
* Copyright (c) Microsoft Corporation. All rights reserved. * Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information. * Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/ *--------------------------------------------------------------------------------------------*/
'use strict';
import * as mode from './jsonMode'; import * as mode from './jsonMode';
import { Emitter, IEvent, languages } from './fillers/monaco-editor-core'
import Emitter = monaco.Emitter;
import IEvent = monaco.IEvent;
// --- JSON configuration and defaults --------- // --- 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<monaco.languages.json.LanguageServiceDefaults>(); export interface ModeConfiguration {
private _diagnosticsOptions: monaco.languages.json.DiagnosticsOptions; /**
private _modeConfiguration: monaco.languages.json.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<LanguageServiceDefaults>;
readonly diagnosticsOptions: DiagnosticsOptions;
readonly modeConfiguration: ModeConfiguration;
setDiagnosticsOptions(options: DiagnosticsOptions): void;
setModeConfiguration(modeConfiguration: ModeConfiguration): void;
}
class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
private _onDidChange = new Emitter<LanguageServiceDefaults>();
private _diagnosticsOptions: DiagnosticsOptions;
private _modeConfiguration: ModeConfiguration;
private _languageId: string; 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._languageId = languageId;
this.setDiagnosticsOptions(diagnosticsOptions); this.setDiagnosticsOptions(diagnosticsOptions);
this.setModeConfiguration(modeConfiguration); this.setModeConfiguration(modeConfiguration);
} }
get onDidChange(): IEvent<monaco.languages.json.LanguageServiceDefaults> { get onDidChange(): IEvent<LanguageServiceDefaults> {
return this._onDidChange.event; return this._onDidChange.event;
} }
@ -32,33 +123,33 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.json.Langua
return this._languageId; return this._languageId;
} }
get modeConfiguration(): monaco.languages.json.ModeConfiguration { get modeConfiguration(): ModeConfiguration {
return this._modeConfiguration; return this._modeConfiguration;
} }
get diagnosticsOptions(): monaco.languages.json.DiagnosticsOptions { get diagnosticsOptions(): DiagnosticsOptions {
return this._diagnosticsOptions; return this._diagnosticsOptions;
} }
setDiagnosticsOptions(options: monaco.languages.json.DiagnosticsOptions): void { setDiagnosticsOptions(options: DiagnosticsOptions): void {
this._diagnosticsOptions = options || Object.create(null); this._diagnosticsOptions = options || Object.create(null);
this._onDidChange.fire(this); this._onDidChange.fire(this);
} }
setModeConfiguration(modeConfiguration: monaco.languages.json.ModeConfiguration): void { setModeConfiguration(modeConfiguration: ModeConfiguration): void {
this._modeConfiguration = modeConfiguration || Object.create(null); this._modeConfiguration = modeConfiguration || Object.create(null);
this._onDidChange.fire(this); this._onDidChange.fire(this);
}; };
} }
const diagnosticDefault: Required<monaco.languages.json.DiagnosticsOptions> = { const diagnosticDefault: Required<DiagnosticsOptions> = {
validate: true, validate: true,
allowComments: true, allowComments: true,
schemas: [], schemas: [],
enableSchemaRequest: false enableSchemaRequest: false
}; };
const modeConfigurationDefault: Required<monaco.languages.json.ModeConfiguration> = { const modeConfigurationDefault: Required<ModeConfiguration> = {
documentFormattingEdits: true, documentFormattingEdits: true,
documentRangeFormattingEdits: true, documentRangeFormattingEdits: true,
completionItems: true, completionItems: true,
@ -71,15 +162,10 @@ const modeConfigurationDefault: Required<monaco.languages.json.ModeConfiguration
selectionRanges: true selectionRanges: true
} }
const jsonDefaults = new LanguageServiceDefaultsImpl('json', diagnosticDefault, modeConfigurationDefault); export const jsonDefaults: LanguageServiceDefaults = new LanguageServiceDefaultsImpl('json', diagnosticDefault, modeConfigurationDefault);
// Export API // export to the global based API
function createAPI(): typeof monaco.languages.json { (<any>languages).json = { jsonDefaults };
return {
jsonDefaults: jsonDefaults
}
}
monaco.languages.json = createAPI();
// --- Registration to monaco editor --- // --- Registration to monaco editor ---
@ -87,13 +173,13 @@ function getMode(): Promise<typeof mode> {
return import('./jsonMode'); return import('./jsonMode');
} }
monaco.languages.register({ languages.register({
id: 'json', id: 'json',
extensions: ['.json', '.bowerrc', '.jshintrc', '.jscsrc', '.eslintrc', '.babelrc', '.har'], extensions: ['.json', '.bowerrc', '.jshintrc', '.jscsrc', '.eslintrc', '.babelrc', '.har'],
aliases: ['JSON', 'json'], aliases: ['JSON', 'json'],
mimetypes: ['application/json'], mimetypes: ['application/json'],
}); });
monaco.languages.onLanguage('json', () => { languages.onLanguage('json', () => {
getMode().then(mode => mode.setupMode(jsonDefaults)); getMode().then(mode => mode.setupMode(jsonDefaults));
}); });

22
src/tokenization.ts
View file

@ -2,11 +2,11 @@
* Copyright (c) Microsoft Corporation. All rights reserved. * Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information. * Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/ *--------------------------------------------------------------------------------------------*/
'use strict';
import * as json from 'jsonc-parser'; 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 { return {
getInitialState: () => new JSONState(null, null, false), getInitialState: () => new JSONState(null, null, false),
tokenize: (line, state, offsetDelta?, stopAtOffset?) => tokenize(supportComments, line, <JSONState>state, offsetDelta, stopAtOffset) tokenize: (line, state, offsetDelta?, stopAtOffset?) => tokenize(supportComments, line, <JSONState>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_BLOCK = 'comment.block.json';
export const TOKEN_COMMENT_LINE = 'comment.line.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 scanError: json.ScanError;
public lastWasColon: boolean; 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._state = state;
this.scanError = scanError; this.scanError = scanError;
this.lastWasColon = lastWasColon; this.lastWasColon = lastWasColon;
@ -42,7 +42,7 @@ class JSONState implements monaco.languages.IState {
return new JSONState(this._state, this.scanError, this.lastWasColon); 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) { if (other === this) {
return true; return true;
} }
@ -53,16 +53,16 @@ class JSONState implements monaco.languages.IState {
this.lastWasColon === (<JSONState>other).lastWasColon; this.lastWasColon === (<JSONState>other).lastWasColon;
} }
public getStateData(): monaco.languages.IState { public getStateData(): languages.IState {
return this._state; return this._state;
} }
public setStateData(state: monaco.languages.IState): void { public setStateData(state: languages.IState): void {
this._state = state; 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 // handle multiline strings and block comments
var numberOfInsertedCharacters = 0, var numberOfInsertedCharacters = 0,
@ -81,11 +81,11 @@ function tokenize(comments: boolean, line: string, state: JSONState, offsetDelta
var scanner = json.createScanner(line), var scanner = json.createScanner(line),
kind: json.SyntaxKind, kind: json.SyntaxKind,
ret: monaco.languages.ILineTokens, ret: languages.ILineTokens,
lastWasColon = state.lastWasColon; lastWasColon = state.lastWasColon;
ret = { ret = {
tokens: <monaco.languages.IToken[]>[], tokens: <languages.IToken[]>[],
endState: state.clone() endState: state.clone()
}; };

1
src/tsconfig.esm.json
View file

@ -1,5 +1,6 @@
{ {
"compilerOptions": { "compilerOptions": {
"declaration": true,
"module": "esnext", "module": "esnext",
"moduleResolution": "node", "moduleResolution": "node",
"outDir": "../out/esm", "outDir": "../out/esm",

1
src/tsconfig.json
View file

@ -3,6 +3,7 @@
"module": "amd", "module": "amd",
"moduleResolution": "node", "moduleResolution": "node",
"outDir": "../out/amd", "outDir": "../out/amd",
"declaration": true,
"target": "es5", "target": "es5",
"lib": [ "lib": [
"dom", "dom",

17
src/workerManager.ts
View file

@ -2,27 +2,24 @@
* Copyright (c) Microsoft Corporation. All rights reserved. * Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information. * Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/ *--------------------------------------------------------------------------------------------*/
'use strict';
import { LanguageServiceDefaultsImpl } from './monaco.contribution'; import { LanguageServiceDefaults } from './monaco.contribution';
import { JSONWorker } from './jsonWorker'; import type { JSONWorker } from './jsonWorker';
import { IDisposable, Uri, editor } from './fillers/monaco-editor-core'
import IDisposable = monaco.IDisposable;
import Uri = monaco.Uri;
const STOP_WHEN_IDLE_FOR = 2 * 60 * 1000; // 2min const STOP_WHEN_IDLE_FOR = 2 * 60 * 1000; // 2min
export class WorkerManager { export class WorkerManager {
private _defaults: LanguageServiceDefaultsImpl; private _defaults: LanguageServiceDefaults;
private _idleCheckInterval: number; private _idleCheckInterval: number;
private _lastUsedTime: number; private _lastUsedTime: number;
private _configChangeListener: IDisposable; private _configChangeListener: IDisposable;
private _worker: monaco.editor.MonacoWebWorker<JSONWorker>; private _worker: editor.MonacoWebWorker<JSONWorker>;
private _client: Promise<JSONWorker>; private _client: Promise<JSONWorker>;
constructor(defaults: LanguageServiceDefaultsImpl) { constructor(defaults: LanguageServiceDefaults) {
this._defaults = defaults; this._defaults = defaults;
this._worker = null; this._worker = null;
this._idleCheckInterval = setInterval(() => this._checkIfIdle(), 30 * 1000); this._idleCheckInterval = setInterval(() => this._checkIfIdle(), 30 * 1000);
@ -58,7 +55,7 @@ export class WorkerManager {
this._lastUsedTime = Date.now(); this._lastUsedTime = Date.now();
if (!this._client) { if (!this._client) {
this._worker = monaco.editor.createWebWorker<JSONWorker>({ this._worker = editor.createWebWorker<JSONWorker>({
// module that exports the create() method and returns a `JSONWorker` instance // module that exports the create() method and returns a `JSONWorker` instance
moduleId: 'vs/language/json/jsonWorker', moduleId: 'vs/language/json/jsonWorker',