mirror of
https://github.com/microsoft/monaco-editor.git
synced 2025-12-22 15:05:39 +01:00
Use the global monaco only in the AMD case (see https://github.com/microsoft/monaco-editor/issues/1974)
This commit is contained in:
Alex Dima
parent
47ee25bf88
commit
28d4512f33
17 changed files with 321 additions and 235 deletions
|
|
@ -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)
|
||||
|
|
|
|||
18
src/monaco.d.ts → monaco.d.ts
vendored
18
src/monaco.d.ts → monaco.d.ts
vendored
|
|
@ -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<LanguageServiceDefaults>;
|
||||
readonly diagnosticsOptions: DiagnosticsOptions;
|
||||
readonly modeConfiguration: ModeConfiguration;
|
||||
setDiagnosticsOptions(options: DiagnosticsOptions): void;
|
||||
setModeConfiguration(modeConfiguration: ModeConfiguration): void;
|
||||
}
|
||||
export const jsonDefaults: LanguageServiceDefaults;
|
||||
|
||||
export var jsonDefaults: LanguageServiceDefaults;
|
||||
}
|
||||
54
package-lock.json
generated
54
package-lock.json
generated
|
|
@ -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
|
||||
}
|
||||
}
|
||||
|
|
|
|||
12
package.json
12
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"
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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: [{
|
||||
|
|
|
|||
37
scripts/dts.js
Normal file
37
scripts/dts.js
Normal 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
12
src/fillers/monaco-editor-core-amd.ts
Normal 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;
|
||||
});
|
||||
|
|
@ -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.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
/// <reference path='../../node_modules/monaco-editor-core/monaco.d.ts'/>
|
||||
|
||||
export * from 'monaco-editor-core';
|
||||
|
|
@ -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';
|
||||
|
|
|
|||
|
|
@ -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: {
|
||||
|
|
|
|||
|
|
@ -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<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 {
|
||||
|
||||
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<jsonService.Diagnostic[]> {
|
||||
async doValidation(uri: string): Promise<jsonService.Diagnostic[]> {
|
||||
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<jsonService.CompletionList> {
|
||||
async doComplete(uri: string, position: jsonService.Position): Promise<jsonService.CompletionList> {
|
||||
let document = this._getTextDocument(uri);
|
||||
let jsonDocument = this._languageService.parseJSONDocument(document);
|
||||
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);
|
||||
}
|
||||
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 jsonDocument = this._languageService.parseJSONDocument(document);
|
||||
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 textEdits = this._languageService.format(document, range, options);
|
||||
return Promise.resolve(textEdits);
|
||||
}
|
||||
resetSchema(uri: string): Thenable<boolean> {
|
||||
async resetSchema(uri: string): Promise<boolean> {
|
||||
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 jsonDocument = this._languageService.parseJSONDocument(document);
|
||||
let symbols = this._languageService.findDocumentSymbols(document, jsonDocument);
|
||||
return Promise.resolve(symbols);
|
||||
}
|
||||
findDocumentColors(uri: string): Thenable<jsonService.ColorInformation[]> {
|
||||
async findDocumentColors(uri: string): Promise<jsonService.ColorInformation[]> {
|
||||
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<jsonService.ColorPresentation[]> {
|
||||
async getColorPresentations(uri: string, color: jsonService.Color, range: jsonService.Range): Promise<jsonService.ColorPresentation[]> {
|
||||
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<jsonService.FoldingRange[]> {
|
||||
async getFoldingRanges(uri: string, context?: { rangeLimit?: number; }): Promise<jsonService.FoldingRange[]> {
|
||||
let document = this._getTextDocument(uri);
|
||||
let ranges = this._languageService.getFoldingRanges(document, context);
|
||||
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 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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<JSONWorker>
|
||||
(...more: Uri[]): Promise<JSONWorker>
|
||||
}
|
||||
|
||||
// --- 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) : <string>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<monaco.languages.CompletionList> {
|
||||
provideCompletionItems(model: editor.IReadOnlyModel, position: Position, context: languages.CompletionContext, token: CancellationToken): Promise<languages.CompletionList> {
|
||||
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 (<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') {
|
||||
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<monaco.languages.Hover> {
|
||||
provideHover(model: editor.IReadOnlyModel, position: Position, token: CancellationToken): Promise<languages.Hover> {
|
||||
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 <monaco.languages.Hover>{
|
||||
return <languages.Hover>{
|
||||
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<monaco.languages.DocumentSymbol[]> {
|
||||
public provideDocumentSymbols(model: editor.IReadOnlyModel, token: CancellationToken): Promise<languages.DocumentSymbol[]> {
|
||||
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<monaco.editor.ISingleEditOperation[]> {
|
||||
public provideDocumentFormattingEdits(model: editor.IReadOnlyModel, options: languages.FormattingOptions, token: CancellationToken): Promise<editor.ISingleEditOperation[]> {
|
||||
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<monaco.editor.ISingleEditOperation[]> {
|
||||
public provideDocumentRangeFormattingEdits(model: editor.IReadOnlyModel, range: Range, options: languages.FormattingOptions, token: CancellationToken): Promise<editor.ISingleEditOperation[]> {
|
||||
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<monaco.languages.IColorInformation[]> {
|
||||
public provideDocumentColors(model: editor.IReadOnlyModel, token: CancellationToken): Promise<languages.IColorInformation[]> {
|
||||
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<monaco.languages.IColorPresentation[]> {
|
||||
public provideColorPresentations(model: editor.IReadOnlyModel, info: languages.IColorInformation, token: CancellationToken): Promise<languages.IColorPresentation[]> {
|
||||
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<monaco.languages.FoldingRange[]> {
|
||||
public provideFoldingRanges(model: editor.IReadOnlyModel, context: languages.FoldingContext, token: CancellationToken): Promise<languages.FoldingRange[]> {
|
||||
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<monaco.languages.SelectionRange[][]> {
|
||||
public provideSelectionRanges(model: editor.IReadOnlyModel, positions: Position[], token: CancellationToken): Promise<languages.SelectionRange[][]> {
|
||||
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;
|
||||
|
|
|
|||
|
|
@ -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<monaco.languages.json.LanguageServiceDefaults>();
|
||||
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<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;
|
||||
|
||||
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<monaco.languages.json.LanguageServiceDefaults> {
|
||||
get onDidChange(): IEvent<LanguageServiceDefaults> {
|
||||
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<monaco.languages.json.DiagnosticsOptions> = {
|
||||
const diagnosticDefault: Required<DiagnosticsOptions> = {
|
||||
validate: true,
|
||||
allowComments: true,
|
||||
schemas: [],
|
||||
enableSchemaRequest: false
|
||||
};
|
||||
|
||||
const modeConfigurationDefault: Required<monaco.languages.json.ModeConfiguration> = {
|
||||
const modeConfigurationDefault: Required<ModeConfiguration> = {
|
||||
documentFormattingEdits: true,
|
||||
documentRangeFormattingEdits: true,
|
||||
completionItems: true,
|
||||
|
|
@ -71,15 +162,10 @@ const modeConfigurationDefault: Required<monaco.languages.json.ModeConfiguration
|
|||
selectionRanges: true
|
||||
}
|
||||
|
||||
const jsonDefaults = new LanguageServiceDefaultsImpl('json', diagnosticDefault, modeConfigurationDefault);
|
||||
export const jsonDefaults: LanguageServiceDefaults = new LanguageServiceDefaultsImpl('json', diagnosticDefault, modeConfigurationDefault);
|
||||
|
||||
// Export API
|
||||
function createAPI(): typeof monaco.languages.json {
|
||||
return {
|
||||
jsonDefaults: jsonDefaults
|
||||
}
|
||||
}
|
||||
monaco.languages.json = createAPI();
|
||||
// export to the global based API
|
||||
(<any>languages).json = { jsonDefaults };
|
||||
|
||||
// --- Registration to monaco editor ---
|
||||
|
||||
|
|
@ -87,13 +173,13 @@ function getMode(): Promise<typeof mode> {
|
|||
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));
|
||||
});
|
||||
|
|
|
|||
|
|
@ -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, <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_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 === (<JSONState>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: <monaco.languages.IToken[]>[],
|
||||
tokens: <languages.IToken[]>[],
|
||||
endState: state.clone()
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
{
|
||||
"compilerOptions": {
|
||||
"declaration": true,
|
||||
"module": "esnext",
|
||||
"moduleResolution": "node",
|
||||
"outDir": "../out/esm",
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@
|
|||
"module": "amd",
|
||||
"moduleResolution": "node",
|
||||
"outDir": "../out/amd",
|
||||
"declaration": true,
|
||||
"target": "es5",
|
||||
"lib": [
|
||||
"dom",
|
||||
|
|
|
|||
|
|
@ -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<JSONWorker>;
|
||||
private _worker: editor.MonacoWebWorker<JSONWorker>;
|
||||
private _client: Promise<JSONWorker>;
|
||||
|
||||
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<JSONWorker>({
|
||||
this._worker = editor.createWebWorker<JSONWorker>({
|
||||
|
||||
// module that exports the create() method and returns a `JSONWorker` instance
|
||||
moduleId: 'vs/language/json/jsonWorker',
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue