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

Use the global monaco only in the AMD case (see microsoft/monaco-editor#1974)

Browse source
This commit is contained in:
Alex Dima 2020-09-07 16:48:41 +02:00
parent d089cc232d
commit 1a46d23399
No known key found for this signature in database
GPG key ID: 6E58D7B045760DA0
15 changed files with 370 additions and 250 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -3,7 +3,9 @@
* 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.html { /// <reference path="node_modules/monaco-editor-core/monaco.d.ts" />
declare namespace monaco.languages.html {
export interface HTMLFormatConfiguration { export interface HTMLFormatConfiguration {
readonly tabSize: number; readonly tabSize: number;
readonly insertSpaces: boolean; readonly insertSpaces: boolean;
@ -22,11 +24,9 @@ declare module monaco.languages.html {
| 'force-aligned' | 'force-aligned'
| 'force-expand-multiline'; | 'force-expand-multiline';
} }
export interface CompletionConfiguration { export interface CompletionConfiguration {
[provider: string]: boolean; [provider: string]: boolean;
} }
export interface Options { export interface Options {
/** /**
* If set, comments are tolerated. If set to false, syntax errors will be emitted for comments. * If set, comments are tolerated. If set to false, syntax errors will be emitted for comments.
@ -37,76 +37,64 @@ declare module monaco.languages.html {
*/ */
readonly suggest?: CompletionConfiguration; readonly suggest?: CompletionConfiguration;
} }
export interface ModeConfiguration { export interface ModeConfiguration {
/** /**
* 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 definitions provider is enabled. * Defines whether the built-in definitions provider is enabled.
*/ */
readonly links?: boolean; readonly links?: boolean;
/** /**
* Defines whether the built-in references provider is enabled. * Defines whether the built-in references provider is enabled.
*/ */
readonly documentHighlights?: boolean; readonly documentHighlights?: boolean;
/** /**
* Defines whether the built-in rename provider is enabled. * Defines whether the built-in rename provider is enabled.
*/ */
readonly rename?: boolean; readonly rename?: 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;
/** /**
* 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;
} }
export interface LanguageServiceDefaults { export interface LanguageServiceDefaults {
readonly languageId: string;
readonly modeConfiguration: ModeConfiguration;
readonly onDidChange: IEvent<LanguageServiceDefaults>; readonly onDidChange: IEvent<LanguageServiceDefaults>;
readonly options: Options; readonly options: Options;
setOptions(options: Options): void; setOptions(options: Options): void;
} }
export const htmlDefaults: LanguageServiceDefaults;
export var htmlDefaults: LanguageServiceDefaults; export const handlebarDefaults: LanguageServiceDefaults;
export var handlebarDefaults: LanguageServiceDefaults; export const razorDefaults: LanguageServiceDefaults;
export var razorDefaults: LanguageServiceDefaults;
} }

24
package-lock.json generated
View file

@ -423,9 +423,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"
@ -672,9 +672,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",
@ -697,9 +697,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",
@ -708,9 +708,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-html-languageservice": { "vscode-html-languageservice": {

14
package.json
View file

@ -3,9 +3,9 @@
"version": "2.7.0", "version": "2.7.0",
"description": "HTML plugin for the Monaco Editor", "description": "HTML 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 && prettier --write ./monaco.d.ts",
"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-html-languageservice@next -f -D && npm install vscode-languageserver-types@next -f -D", "install-service-next": "npm install vscode-html-languageservice@next -f -D && npm install vscode-languageserver-types@next -f -D",
"install-service-local": "npm install ../vscode-html-languageservice -f -D && npm install ../vscode-languageserver-node/types -f -D", "install-service-local": "npm install ../vscode-html-languageservice -f -D && npm install ../vscode-languageserver-node/types -f -D",
"prettier": "prettier --write ." "prettier": "prettier --write ."
@ -19,16 +19,18 @@
"bugs": { "bugs": {
"url": "https://github.com/Microsoft/monaco-editor/issues" "url": "https://github.com/Microsoft/monaco-editor/issues"
}, },
"module": "./release/esm/monaco.contribution.js",
"typings": "./release/esm/monaco.contribution.d.ts",
"devDependencies": { "devDependencies": {
"husky": "^4.2.5", "husky": "^4.3.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",
"prettier": "^2.1.1", "prettier": "^2.1.1",
"pretty-quick": "^3.0.0", "pretty-quick": "^3.0.0",
"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-html-languageservice": "3.0.4-next.12", "vscode-html-languageservice": "3.0.4-next.12",
"vscode-languageserver-types": "3.15.0-next.9", "vscode-languageserver-types": "3.15.0-next.9",
"vscode-languageserver-textdocument": "^1.0.0-next.5" "vscode-languageserver-textdocument": "^1.0.0-next.5"

12
scripts/bundle.js
View file

@ -21,7 +21,7 @@ const BUNDLED_FILE_HEADER = [
].join('\n'); ].join('\n');
bundleOne('monaco.contribution'); bundleOne('monaco.contribution');
bundleOne('htmlMode'); bundleOne('htmlMode', ['vs/language/html/monaco.contribution']);
bundleOne('htmlWorker'); bundleOne('htmlWorker');
function bundleOne(moduleId, exclude) { function bundleOne(moduleId, exclude) {
@ -32,7 +32,9 @@ function bundleOne(moduleId, exclude) {
out: 'release/dev/' + moduleId + '.js', out: 'release/dev/' + moduleId + '.js',
exclude: exclude, exclude: exclude,
paths: { paths: {
'vs/language/html': REPO_ROOT + '/out/amd' 'vs/language/html': REPO_ROOT + '/out/amd',
'vs/language/html/fillers/monaco-editor-core':
REPO_ROOT + '/out/amd/fillers/monaco-editor-core-amd'
}, },
optimize: 'none', optimize: 'none',
packages: [ packages: [
@ -72,7 +74,7 @@ function bundleOne(moduleId, exclude) {
} }
] ]
}, },
function (buildResponse) { async function (buildResponse) {
const devFilePath = path.join( const devFilePath = path.join(
REPO_ROOT, REPO_ROOT,
'release/dev/' + moduleId + '.js' 'release/dev/' + moduleId + '.js'
@ -84,12 +86,12 @@ function bundleOne(moduleId, exclude) {
const fileContents = fs.readFileSync(devFilePath).toString(); const fileContents = fs.readFileSync(devFilePath).toString();
console.log(); console.log();
console.log(`Minifying ${devFilePath}...`); console.log(`Minifying ${devFilePath}...`);
const result = terser.minify(fileContents, { const result = await terser.minify(fileContents, {
output: { output: {
comments: 'some' comments: 'some'
} }
}); });
console.log(`Done.`); console.log(`Done minifying ${devFilePath}.`);
try { try {
fs.mkdirSync(path.join(REPO_ROOT, 'release/min')); fs.mkdirSync(path.join(REPO_ROOT, 'release/min'));
} catch (err) {} } catch (err) {}

41
scripts/dts.js Normal file
View file

@ -0,0 +1,41 @@
/*---------------------------------------------------------------------------------------------
* 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.`,
` *--------------------------------------------------------------------------------------------*/`,
``,
`/// <reference path="node_modules/monaco-editor-core/monaco.d.ts" />`,
``,
`declare namespace monaco.languages.html {`
];
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/html.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 { HTMLWorker } from './htmlWorker'; import { HTMLWorker } from './htmlWorker';

53
src/htmlMode.ts
View file

@ -2,17 +2,14 @@
* 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 { HTMLWorker } from './htmlWorker'; import type { HTMLWorker } from './htmlWorker';
import { LanguageServiceDefaultsImpl } from './monaco.contribution'; import { LanguageServiceDefaults } from './monaco.contribution';
import * as languageFeatures from './languageFeatures'; import * as languageFeatures from './languageFeatures';
import { Uri, IDisposable, languages } from './fillers/monaco-editor-core';
import Uri = monaco.Uri; export function setupMode1(defaults: LanguageServiceDefaults): void {
import IDisposable = monaco.IDisposable;
export function setupMode1(defaults: LanguageServiceDefaultsImpl): void {
const client = new WorkerManager(defaults); const client = new WorkerManager(defaults);
const worker: languageFeatures.WorkerAccessor = ( const worker: languageFeatures.WorkerAccessor = (
@ -24,47 +21,47 @@ export function setupMode1(defaults: LanguageServiceDefaultsImpl): void {
let languageId = defaults.languageId; let languageId = defaults.languageId;
// all modes // all modes
monaco.languages.registerCompletionItemProvider( languages.registerCompletionItemProvider(
languageId, languageId,
new languageFeatures.CompletionAdapter(worker) new languageFeatures.CompletionAdapter(worker)
); );
monaco.languages.registerHoverProvider( languages.registerHoverProvider(
languageId, languageId,
new languageFeatures.HoverAdapter(worker) new languageFeatures.HoverAdapter(worker)
); );
monaco.languages.registerDocumentHighlightProvider( languages.registerDocumentHighlightProvider(
languageId, languageId,
new languageFeatures.DocumentHighlightAdapter(worker) new languageFeatures.DocumentHighlightAdapter(worker)
); );
monaco.languages.registerLinkProvider( languages.registerLinkProvider(
languageId, languageId,
new languageFeatures.DocumentLinkAdapter(worker) new languageFeatures.DocumentLinkAdapter(worker)
); );
monaco.languages.registerFoldingRangeProvider( languages.registerFoldingRangeProvider(
languageId, languageId,
new languageFeatures.FoldingRangeAdapter(worker) new languageFeatures.FoldingRangeAdapter(worker)
); );
monaco.languages.registerDocumentSymbolProvider( languages.registerDocumentSymbolProvider(
languageId, languageId,
new languageFeatures.DocumentSymbolAdapter(worker) new languageFeatures.DocumentSymbolAdapter(worker)
); );
monaco.languages.registerSelectionRangeProvider( languages.registerSelectionRangeProvider(
languageId, languageId,
new languageFeatures.SelectionRangeAdapter(worker) new languageFeatures.SelectionRangeAdapter(worker)
); );
monaco.languages.registerRenameProvider( languages.registerRenameProvider(
languageId, languageId,
new languageFeatures.RenameAdapter(worker) new languageFeatures.RenameAdapter(worker)
); );
// only html // only html
if (languageId === 'html') { if (languageId === 'html') {
monaco.languages.registerDocumentFormattingEditProvider( languages.registerDocumentFormattingEditProvider(
languageId, languageId,
new languageFeatures.DocumentFormattingEditProvider(worker) new languageFeatures.DocumentFormattingEditProvider(worker)
); );
monaco.languages.registerDocumentRangeFormattingEditProvider( languages.registerDocumentRangeFormattingEditProvider(
languageId, languageId,
new languageFeatures.DocumentRangeFormattingEditProvider(worker) new languageFeatures.DocumentRangeFormattingEditProvider(worker)
); );
@ -72,7 +69,7 @@ export function setupMode1(defaults: LanguageServiceDefaultsImpl): void {
} }
} }
export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable { export function setupMode(defaults: LanguageServiceDefaults): IDisposable {
const disposables: IDisposable[] = []; const disposables: IDisposable[] = [];
const providers: IDisposable[] = []; const providers: IDisposable[] = [];
@ -92,7 +89,7 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
if (modeConfiguration.completionItems) { if (modeConfiguration.completionItems) {
providers.push( providers.push(
monaco.languages.registerCompletionItemProvider( languages.registerCompletionItemProvider(
languageId, languageId,
new languageFeatures.CompletionAdapter(worker) new languageFeatures.CompletionAdapter(worker)
) )
@ -100,7 +97,7 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
} }
if (modeConfiguration.hovers) { if (modeConfiguration.hovers) {
providers.push( providers.push(
monaco.languages.registerHoverProvider( languages.registerHoverProvider(
languageId, languageId,
new languageFeatures.HoverAdapter(worker) new languageFeatures.HoverAdapter(worker)
) )
@ -108,7 +105,7 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
} }
if (modeConfiguration.documentHighlights) { if (modeConfiguration.documentHighlights) {
providers.push( providers.push(
monaco.languages.registerDocumentHighlightProvider( languages.registerDocumentHighlightProvider(
languageId, languageId,
new languageFeatures.DocumentHighlightAdapter(worker) new languageFeatures.DocumentHighlightAdapter(worker)
) )
@ -116,7 +113,7 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
} }
if (modeConfiguration.links) { if (modeConfiguration.links) {
providers.push( providers.push(
monaco.languages.registerLinkProvider( languages.registerLinkProvider(
languageId, languageId,
new languageFeatures.DocumentLinkAdapter(worker) new languageFeatures.DocumentLinkAdapter(worker)
) )
@ -124,7 +121,7 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
} }
if (modeConfiguration.documentSymbols) { if (modeConfiguration.documentSymbols) {
providers.push( providers.push(
monaco.languages.registerDocumentSymbolProvider( languages.registerDocumentSymbolProvider(
languageId, languageId,
new languageFeatures.DocumentSymbolAdapter(worker) new languageFeatures.DocumentSymbolAdapter(worker)
) )
@ -132,7 +129,7 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
} }
if (modeConfiguration.rename) { if (modeConfiguration.rename) {
providers.push( providers.push(
monaco.languages.registerRenameProvider( languages.registerRenameProvider(
languageId, languageId,
new languageFeatures.RenameAdapter(worker) new languageFeatures.RenameAdapter(worker)
) )
@ -140,7 +137,7 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
} }
if (modeConfiguration.foldingRanges) { if (modeConfiguration.foldingRanges) {
providers.push( providers.push(
monaco.languages.registerFoldingRangeProvider( languages.registerFoldingRangeProvider(
languageId, languageId,
new languageFeatures.FoldingRangeAdapter(worker) new languageFeatures.FoldingRangeAdapter(worker)
) )
@ -148,7 +145,7 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
} }
if (modeConfiguration.selectionRanges) { if (modeConfiguration.selectionRanges) {
providers.push( providers.push(
monaco.languages.registerSelectionRangeProvider( languages.registerSelectionRangeProvider(
languageId, languageId,
new languageFeatures.SelectionRangeAdapter(worker) new languageFeatures.SelectionRangeAdapter(worker)
) )
@ -156,7 +153,7 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
} }
if (modeConfiguration.documentFormattingEdits) { if (modeConfiguration.documentFormattingEdits) {
providers.push( providers.push(
monaco.languages.registerDocumentFormattingEditProvider( languages.registerDocumentFormattingEditProvider(
languageId, languageId,
new languageFeatures.DocumentFormattingEditProvider(worker) new languageFeatures.DocumentFormattingEditProvider(worker)
) )
@ -164,7 +161,7 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
} }
if (modeConfiguration.documentRangeFormattingEdits) { if (modeConfiguration.documentRangeFormattingEdits) {
providers.push( providers.push(
monaco.languages.registerDocumentRangeFormattingEditProvider( languages.registerDocumentRangeFormattingEditProvider(
languageId, languageId,
new languageFeatures.DocumentRangeFormattingEditProvider(worker) new languageFeatures.DocumentRangeFormattingEditProvider(worker)
) )

15
src/htmlWorker.ts
View file

@ -2,19 +2,18 @@
* 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 IWorkerContext = monaco.worker.IWorkerContext;
import { worker } from './fillers/monaco-editor-core';
import * as htmlService from 'vscode-html-languageservice'; import * as htmlService from 'vscode-html-languageservice';
import type { Options } from './monaco.contribution';
export class HTMLWorker { export class HTMLWorker {
private _ctx: IWorkerContext; private _ctx: worker.IWorkerContext;
private _languageService: htmlService.LanguageService; private _languageService: htmlService.LanguageService;
private _languageSettings: monaco.languages.html.Options; private _languageSettings: Options;
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;
@ -140,11 +139,11 @@ export class HTMLWorker {
export interface ICreateData { export interface ICreateData {
languageId: string; languageId: string;
languageSettings: monaco.languages.html.Options; languageSettings: Options;
} }
export function create( export function create(
ctx: IWorkerContext, ctx: worker.IWorkerContext,
createData: ICreateData createData: ICreateData
): HTMLWorker { ): HTMLWorker {
return new HTMLWorker(ctx, createData); return new HTMLWorker(ctx, createData);

231
src/languageFeatures.ts
View file

@ -2,18 +2,21 @@
* 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 { HTMLWorker } from './htmlWorker';
import { LanguageServiceDefaults } from './monaco.contribution';
import type { HTMLWorker } from './htmlWorker';
import * as htmlService from 'vscode-html-languageservice'; import * as htmlService from 'vscode-html-languageservice';
import {
import Uri = monaco.Uri; languages,
import Position = monaco.Position; editor,
import Range = monaco.Range; Uri,
import CancellationToken = monaco.CancellationToken; Position,
import IDisposable = monaco.IDisposable; Range,
CancellationToken,
IDisposable,
MarkerSeverity,
IMarkdownString
} from './fillers/monaco-editor-core';
export interface WorkerAccessor { export interface WorkerAccessor {
(...more: Uri[]): Promise<HTMLWorker>; (...more: Uri[]): Promise<HTMLWorker>;
@ -28,9 +31,9 @@ export class DiagnosticsAdapter {
constructor( constructor(
private _languageId: string, private _languageId: string,
private _worker: WorkerAccessor, private _worker: WorkerAccessor,
defaults: LanguageServiceDefaultsImpl defaults: LanguageServiceDefaults
) { ) {
const onModelAdd = (model: monaco.editor.IModel): void => { const onModelAdd = (model: editor.IModel): void => {
const modeId = model.getModeId(); const modeId = model.getModeId();
if (modeId !== this._languageId) { if (modeId !== this._languageId) {
return; return;
@ -45,8 +48,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, []);
const uriStr = model.uri.toString(); const uriStr = model.uri.toString();
const listener = this._listener[uriStr]; const listener = this._listener[uriStr];
if (listener) { if (listener) {
@ -55,14 +58,14 @@ export class DiagnosticsAdapter {
} }
}; };
this._disposables.push(monaco.editor.onDidCreateModel(onModelAdd)); this._disposables.push(editor.onDidCreateModel(onModelAdd));
this._disposables.push( this._disposables.push(
monaco.editor.onWillDisposeModel((model) => { editor.onWillDisposeModel((model) => {
onModelRemoved(model); onModelRemoved(model);
}) })
); );
this._disposables.push( this._disposables.push(
monaco.editor.onDidChangeModelLanguage((event) => { editor.onDidChangeModelLanguage((event) => {
onModelRemoved(event.model); onModelRemoved(event.model);
onModelAdd(event.model); onModelAdd(event.model);
}) })
@ -70,7 +73,7 @@ export class DiagnosticsAdapter {
this._disposables.push( this._disposables.push(
defaults.onDidChange((_) => { 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);
@ -87,7 +90,7 @@ export class DiagnosticsAdapter {
} }
}); });
monaco.editor.getModels().forEach(onModelAdd); editor.getModels().forEach(onModelAdd);
} }
public dispose(): void { public dispose(): void {
@ -100,8 +103,8 @@ export class DiagnosticsAdapter {
.then((worker) => { .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));
monaco.editor.setModelMarkers( editor.setModelMarkers(
monaco.editor.getModel(resource), editor.getModel(resource),
languageId, languageId,
markers markers
); );
@ -113,25 +116,25 @@ export class DiagnosticsAdapter {
} }
} }
function toSeverity(lsSeverity: number): monaco.MarkerSeverity { function toSeverity(lsSeverity: number): MarkerSeverity {
switch (lsSeverity) { switch (lsSeverity) {
case htmlService.DiagnosticSeverity.Error: case htmlService.DiagnosticSeverity.Error:
return monaco.MarkerSeverity.Error; return MarkerSeverity.Error;
case htmlService.DiagnosticSeverity.Warning: case htmlService.DiagnosticSeverity.Warning:
return monaco.MarkerSeverity.Warning; return MarkerSeverity.Warning;
case htmlService.DiagnosticSeverity.Information: case htmlService.DiagnosticSeverity.Information:
return monaco.MarkerSeverity.Info; return MarkerSeverity.Info;
case htmlService.DiagnosticSeverity.Hint: case htmlService.DiagnosticSeverity.Hint:
return monaco.MarkerSeverity.Hint; return MarkerSeverity.Hint;
default: default:
return monaco.MarkerSeverity.Info; return MarkerSeverity.Info;
} }
} }
function toDiagnostics( function toDiagnostics(
resource: Uri, resource: Uri,
diag: htmlService.Diagnostic diag: htmlService.Diagnostic
): monaco.editor.IMarkerData { ): editor.IMarkerData {
const code = const code =
typeof diag.code === 'number' ? String(diag.code) : <string>diag.code; typeof diag.code === 'number' ? String(diag.code) : <string>diag.code;
@ -178,10 +181,8 @@ function toRange(range: htmlService.Range): Range {
); );
} }
function toCompletionItemKind( function toCompletionItemKind(kind: number): languages.CompletionItemKind {
kind: number const mItemKind = languages.CompletionItemKind;
): monaco.languages.CompletionItemKind {
const mItemKind = monaco.languages.CompletionItemKind;
switch (kind) { switch (kind) {
case htmlService.CompletionItemKind.Text: case htmlService.CompletionItemKind.Text:
@ -225,9 +226,9 @@ function toCompletionItemKind(
} }
function fromCompletionItemKind( function fromCompletionItemKind(
kind: monaco.languages.CompletionItemKind kind: languages.CompletionItemKind
): htmlService.CompletionItemKind { ): htmlService.CompletionItemKind {
const mItemKind = monaco.languages.CompletionItemKind; const mItemKind = languages.CompletionItemKind;
switch (kind) { switch (kind) {
case mItemKind.Text: case mItemKind.Text:
@ -272,7 +273,7 @@ function fromCompletionItemKind(
function toTextEdit( function toTextEdit(
textEdit: htmlService.TextEdit textEdit: htmlService.TextEdit
): monaco.editor.ISingleEditOperation { ): editor.ISingleEditOperation {
if (!textEdit) { if (!textEdit) {
return void 0; return void 0;
} }
@ -282,8 +283,7 @@ function toTextEdit(
}; };
} }
export class CompletionAdapter export class CompletionAdapter implements languages.CompletionItemProvider {
implements monaco.languages.CompletionItemProvider {
constructor(private _worker: WorkerAccessor) {} constructor(private _worker: WorkerAccessor) {}
public get triggerCharacters(): string[] { public get triggerCharacters(): string[] {
@ -291,11 +291,11 @@ export class CompletionAdapter
} }
provideCompletionItems( provideCompletionItems(
model: monaco.editor.IReadOnlyModel, model: editor.IReadOnlyModel,
position: Position, position: Position,
context: monaco.languages.CompletionContext, context: languages.CompletionContext,
token: CancellationToken token: CancellationToken
): Promise<monaco.languages.CompletionList> { ): Promise<languages.CompletionList> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource) return this._worker(resource)
@ -314,36 +314,32 @@ export class CompletionAdapter
wordInfo.endColumn wordInfo.endColumn
); );
const items: monaco.languages.CompletionItem[] = info.items.map( const items: languages.CompletionItem[] = info.items.map((entry) => {
(entry) => { const item: languages.CompletionItem = {
const item: monaco.languages.CompletionItem = { label: entry.label,
label: entry.label, insertText: entry.insertText || entry.label,
insertText: entry.insertText || entry.label, sortText: entry.sortText,
sortText: entry.sortText, filterText: entry.filterText,
filterText: entry.filterText, documentation: entry.documentation,
documentation: entry.documentation, detail: entry.detail,
detail: entry.detail, range: wordRange,
range: wordRange, kind: toCompletionItemKind(entry.kind)
kind: toCompletionItemKind(entry.kind) };
}; if (entry.textEdit) {
if (entry.textEdit) { item.range = toRange(entry.textEdit.range);
item.range = toRange(entry.textEdit.range); item.insertText = entry.textEdit.newText;
item.insertText = entry.textEdit.newText;
}
if (entry.additionalTextEdits) {
item.additionalTextEdits = entry.additionalTextEdits.map(
toTextEdit
);
}
if (
entry.insertTextFormat === htmlService.InsertTextFormat.Snippet
) {
item.insertTextRules =
monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
}
return item;
} }
); if (entry.additionalTextEdits) {
item.additionalTextEdits = entry.additionalTextEdits.map(
toTextEdit
);
}
if (entry.insertTextFormat === htmlService.InsertTextFormat.Snippet) {
item.insertTextRules =
languages.CompletionItemInsertTextRule.InsertAsSnippet;
}
return item;
});
return { return {
isIncomplete: info.isIncomplete, isIncomplete: info.isIncomplete,
@ -365,7 +361,7 @@ function isMarkupContent(thing: any): thing is htmlService.MarkupContent {
function toMarkdownString( function toMarkdownString(
entry: htmlService.MarkupContent | htmlService.MarkedString entry: htmlService.MarkupContent | htmlService.MarkedString
): monaco.IMarkdownString { ): IMarkdownString {
if (typeof entry === 'string') { if (typeof entry === 'string') {
return { return {
value: entry value: entry
@ -390,7 +386,7 @@ function toMarkedStringArray(
| htmlService.MarkupContent | htmlService.MarkupContent
| htmlService.MarkedString | htmlService.MarkedString
| htmlService.MarkedString[] | htmlService.MarkedString[]
): monaco.IMarkdownString[] { ): IMarkdownString[] {
if (!contents) { if (!contents) {
return void 0; return void 0;
} }
@ -400,14 +396,14 @@ function toMarkedStringArray(
return [toMarkdownString(contents)]; return [toMarkdownString(contents)];
} }
export class HoverAdapter implements monaco.languages.HoverProvider { export class HoverAdapter implements languages.HoverProvider {
constructor(private _worker: WorkerAccessor) {} constructor(private _worker: WorkerAccessor) {}
provideHover( provideHover(
model: monaco.editor.IReadOnlyModel, model: editor.IReadOnlyModel,
position: Position, position: Position,
token: CancellationToken token: CancellationToken
): Promise<monaco.languages.Hover> { ): Promise<languages.Hover> {
let resource = model.uri; let resource = model.uri;
return this._worker(resource) return this._worker(resource)
@ -418,7 +414,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)
}; };
@ -430,8 +426,8 @@ export class HoverAdapter implements monaco.languages.HoverProvider {
function toHighlighKind( function toHighlighKind(
kind: htmlService.DocumentHighlightKind kind: htmlService.DocumentHighlightKind
): monaco.languages.DocumentHighlightKind { ): languages.DocumentHighlightKind {
const mKind = monaco.languages.DocumentHighlightKind; const mKind = languages.DocumentHighlightKind;
switch (kind) { switch (kind) {
case htmlService.DocumentHighlightKind.Read: case htmlService.DocumentHighlightKind.Read:
@ -445,14 +441,14 @@ function toHighlighKind(
} }
export class DocumentHighlightAdapter export class DocumentHighlightAdapter
implements monaco.languages.DocumentHighlightProvider { implements languages.DocumentHighlightProvider {
constructor(private _worker: WorkerAccessor) {} constructor(private _worker: WorkerAccessor) {}
public provideDocumentHighlights( public provideDocumentHighlights(
model: monaco.editor.IReadOnlyModel, model: editor.IReadOnlyModel,
position: Position, position: Position,
token: CancellationToken token: CancellationToken
): Promise<monaco.languages.DocumentHighlight[]> { ): Promise<languages.DocumentHighlight[]> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource) return this._worker(resource)
@ -476,10 +472,8 @@ export class DocumentHighlightAdapter
// --- document symbols ------ // --- document symbols ------
function toSymbolKind( function toSymbolKind(kind: htmlService.SymbolKind): languages.SymbolKind {
kind: htmlService.SymbolKind let mKind = languages.SymbolKind;
): monaco.languages.SymbolKind {
let mKind = monaco.languages.SymbolKind;
switch (kind) { switch (kind) {
case htmlService.SymbolKind.File: case htmlService.SymbolKind.File:
@ -522,14 +516,13 @@ function toSymbolKind(
return mKind.Function; return mKind.Function;
} }
export class DocumentSymbolAdapter export class DocumentSymbolAdapter implements languages.DocumentSymbolProvider {
implements monaco.languages.DocumentSymbolProvider {
constructor(private _worker: WorkerAccessor) {} constructor(private _worker: WorkerAccessor) {}
public provideDocumentSymbols( public provideDocumentSymbols(
model: monaco.editor.IReadOnlyModel, model: editor.IReadOnlyModel,
token: CancellationToken token: CancellationToken
): Promise<monaco.languages.DocumentSymbol[]> { ): Promise<languages.DocumentSymbol[]> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource) return this._worker(resource)
@ -551,13 +544,13 @@ export class DocumentSymbolAdapter
} }
} }
export class DocumentLinkAdapter implements monaco.languages.LinkProvider { export class DocumentLinkAdapter implements languages.LinkProvider {
constructor(private _worker: WorkerAccessor) {} constructor(private _worker: WorkerAccessor) {}
public provideLinks( public provideLinks(
model: monaco.editor.IReadOnlyModel, model: editor.IReadOnlyModel,
token: CancellationToken token: CancellationToken
): Promise<monaco.languages.ILinksList> { ): Promise<languages.ILinksList> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource) return this._worker(resource)
@ -577,7 +570,7 @@ export class DocumentLinkAdapter implements monaco.languages.LinkProvider {
} }
function fromFormattingOptions( function fromFormattingOptions(
options: monaco.languages.FormattingOptions options: languages.FormattingOptions
): htmlService.FormattingOptions { ): htmlService.FormattingOptions {
return { return {
tabSize: options.tabSize, tabSize: options.tabSize,
@ -586,14 +579,14 @@ function fromFormattingOptions(
} }
export class DocumentFormattingEditProvider export class DocumentFormattingEditProvider
implements monaco.languages.DocumentFormattingEditProvider { implements languages.DocumentFormattingEditProvider {
constructor(private _worker: WorkerAccessor) {} constructor(private _worker: WorkerAccessor) {}
public provideDocumentFormattingEdits( public provideDocumentFormattingEdits(
model: monaco.editor.IReadOnlyModel, model: editor.IReadOnlyModel,
options: monaco.languages.FormattingOptions, options: languages.FormattingOptions,
token: CancellationToken token: CancellationToken
): Promise<monaco.editor.ISingleEditOperation[]> { ): Promise<editor.ISingleEditOperation[]> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource).then((worker) => { return this._worker(resource).then((worker) => {
@ -610,15 +603,15 @@ export class DocumentFormattingEditProvider
} }
export class DocumentRangeFormattingEditProvider export class DocumentRangeFormattingEditProvider
implements monaco.languages.DocumentRangeFormattingEditProvider { implements languages.DocumentRangeFormattingEditProvider {
constructor(private _worker: WorkerAccessor) {} constructor(private _worker: WorkerAccessor) {}
public provideDocumentRangeFormattingEdits( public provideDocumentRangeFormattingEdits(
model: monaco.editor.IReadOnlyModel, model: editor.IReadOnlyModel,
range: Range, range: Range,
options: monaco.languages.FormattingOptions, options: languages.FormattingOptions,
token: CancellationToken token: CancellationToken
): Promise<monaco.editor.ISingleEditOperation[]> { ): Promise<editor.ISingleEditOperation[]> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource).then((worker) => { return this._worker(resource).then((worker) => {
@ -638,15 +631,15 @@ export class DocumentRangeFormattingEditProvider
} }
} }
export class RenameAdapter implements monaco.languages.RenameProvider { export class RenameAdapter implements languages.RenameProvider {
constructor(private _worker: WorkerAccessor) {} constructor(private _worker: WorkerAccessor) {}
provideRenameEdits( provideRenameEdits(
model: monaco.editor.IReadOnlyModel, model: editor.IReadOnlyModel,
position: Position, position: Position,
newName: string, newName: string,
token: CancellationToken token: CancellationToken
): Promise<monaco.languages.WorkspaceEdit> { ): Promise<languages.WorkspaceEdit> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource) return this._worker(resource)
@ -665,11 +658,11 @@ export class RenameAdapter implements monaco.languages.RenameProvider {
function toWorkspaceEdit( function toWorkspaceEdit(
edit: htmlService.WorkspaceEdit edit: htmlService.WorkspaceEdit
): monaco.languages.WorkspaceEdit { ): languages.WorkspaceEdit {
if (!edit || !edit.changes) { if (!edit || !edit.changes) {
return void 0; return void 0;
} }
let resourceEdits: monaco.languages.WorkspaceTextEdit[] = []; let resourceEdits: languages.WorkspaceTextEdit[] = [];
for (let uri in edit.changes) { for (let uri in edit.changes) {
const _uri = Uri.parse(uri); const _uri = Uri.parse(uri);
for (let e of edit.changes[uri]) { for (let e of edit.changes[uri]) {
@ -687,15 +680,14 @@ function toWorkspaceEdit(
}; };
} }
export class FoldingRangeAdapter export class FoldingRangeAdapter implements languages.FoldingRangeProvider {
implements monaco.languages.FoldingRangeProvider {
constructor(private _worker: WorkerAccessor) {} constructor(private _worker: WorkerAccessor) {}
public provideFoldingRanges( public provideFoldingRanges(
model: monaco.editor.IReadOnlyModel, model: editor.IReadOnlyModel,
context: monaco.languages.FoldingContext, context: languages.FoldingContext,
token: CancellationToken token: CancellationToken
): Promise<monaco.languages.FoldingRange[]> { ): Promise<languages.FoldingRange[]> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource) return this._worker(resource)
@ -705,7 +697,7 @@ export class FoldingRangeAdapter
return; return;
} }
return ranges.map((range) => { return ranges.map((range) => {
const result: monaco.languages.FoldingRange = { const result: languages.FoldingRange = {
start: range.startLine + 1, start: range.startLine + 1,
end: range.endLine + 1 end: range.endLine + 1
}; };
@ -722,26 +714,25 @@ export class FoldingRangeAdapter
function toFoldingRangeKind( function toFoldingRangeKind(
kind: htmlService.FoldingRangeKind kind: htmlService.FoldingRangeKind
): monaco.languages.FoldingRangeKind { ): languages.FoldingRangeKind {
switch (kind) { switch (kind) {
case htmlService.FoldingRangeKind.Comment: case htmlService.FoldingRangeKind.Comment:
return monaco.languages.FoldingRangeKind.Comment; return languages.FoldingRangeKind.Comment;
case htmlService.FoldingRangeKind.Imports: case htmlService.FoldingRangeKind.Imports:
return monaco.languages.FoldingRangeKind.Imports; return languages.FoldingRangeKind.Imports;
case htmlService.FoldingRangeKind.Region: case htmlService.FoldingRangeKind.Region:
return monaco.languages.FoldingRangeKind.Region; return languages.FoldingRangeKind.Region;
} }
} }
export class SelectionRangeAdapter export class SelectionRangeAdapter implements languages.SelectionRangeProvider {
implements monaco.languages.SelectionRangeProvider {
constructor(private _worker: WorkerAccessor) {} constructor(private _worker: WorkerAccessor) {}
public provideSelectionRanges( public provideSelectionRanges(
model: monaco.editor.IReadOnlyModel, model: editor.IReadOnlyModel,
positions: Position[], positions: Position[],
token: CancellationToken token: CancellationToken
): Promise<monaco.languages.SelectionRange[][]> { ): Promise<languages.SelectionRange[][]> {
const resource = model.uri; const resource = model.uri;
return this._worker(resource) return this._worker(resource)
@ -756,7 +747,7 @@ export class SelectionRangeAdapter
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;

167
src/monaco.contribution.ts
View file

@ -2,35 +2,133 @@
* 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 './htmlMode'; import * as mode from './htmlMode';
import { languages, Emitter, IEvent } from './fillers/monaco-editor-core';
import Emitter = monaco.Emitter; export interface HTMLFormatConfiguration {
import IEvent = monaco.IEvent; readonly tabSize: number;
readonly insertSpaces: boolean;
readonly wrapLineLength: number;
readonly unformatted: string;
readonly contentUnformatted: string;
readonly indentInnerHtml: boolean;
readonly preserveNewLines: boolean;
readonly maxPreserveNewLines: number;
readonly indentHandlebars: boolean;
readonly endWithNewline: boolean;
readonly extraLiners: string;
readonly wrapAttributes:
| 'auto'
| 'force'
| 'force-aligned'
| 'force-expand-multiline';
}
export interface CompletionConfiguration {
[provider: string]: boolean;
}
export interface Options {
/**
* If set, comments are tolerated. If set to false, syntax errors will be emitted for comments.
*/
readonly format?: HTMLFormatConfiguration;
/**
* A list of known schemas and/or associations of schemas to file names.
*/
readonly suggest?: CompletionConfiguration;
}
export interface ModeConfiguration {
/**
* 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 definitions provider is enabled.
*/
readonly links?: boolean;
/**
* Defines whether the built-in references provider is enabled.
*/
readonly documentHighlights?: boolean;
/**
* Defines whether the built-in rename provider is enabled.
*/
readonly rename?: 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;
/**
* Defines whether the built-in documentFormattingEdit provider is enabled.
*/
readonly documentFormattingEdits?: boolean;
/**
* Defines whether the built-in documentRangeFormattingEdit provider is enabled.
*/
readonly documentRangeFormattingEdits?: boolean;
}
export interface LanguageServiceDefaults {
readonly languageId: string;
readonly modeConfiguration: ModeConfiguration;
readonly onDidChange: IEvent<LanguageServiceDefaults>;
readonly options: Options;
setOptions(options: Options): void;
}
// --- HTML configuration and defaults --------- // --- HTML configuration and defaults ---------
export class LanguageServiceDefaultsImpl class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
implements monaco.languages.html.LanguageServiceDefaults { private _onDidChange = new Emitter<LanguageServiceDefaults>();
private _onDidChange = new Emitter< private _options: Options;
monaco.languages.html.LanguageServiceDefaults private _modeConfiguration: ModeConfiguration;
>();
private _options: monaco.languages.html.Options;
private _modeConfiguration: monaco.languages.html.ModeConfiguration;
private _languageId: string; private _languageId: string;
constructor( constructor(
languageId: string, languageId: string,
options: monaco.languages.html.Options, options: Options,
modeConfiguration: monaco.languages.html.ModeConfiguration modeConfiguration: ModeConfiguration
) { ) {
this._languageId = languageId; this._languageId = languageId;
this.setOptions(options); this.setOptions(options);
this.setModeConfiguration(modeConfiguration); this.setModeConfiguration(modeConfiguration);
} }
get onDidChange(): IEvent<monaco.languages.html.LanguageServiceDefaults> { get onDidChange(): IEvent<LanguageServiceDefaults> {
return this._onDidChange.event; return this._onDidChange.event;
} }
@ -38,28 +136,26 @@ export class LanguageServiceDefaultsImpl
return this._languageId; return this._languageId;
} }
get options(): monaco.languages.html.Options { get options(): Options {
return this._options; return this._options;
} }
get modeConfiguration(): monaco.languages.html.ModeConfiguration { get modeConfiguration(): ModeConfiguration {
return this._modeConfiguration; return this._modeConfiguration;
} }
setOptions(options: monaco.languages.html.Options): void { setOptions(options: Options): void {
this._options = options || Object.create(null); this._options = options || Object.create(null);
this._onDidChange.fire(this); this._onDidChange.fire(this);
} }
setModeConfiguration( setModeConfiguration(modeConfiguration: ModeConfiguration): void {
modeConfiguration: monaco.languages.html.ModeConfiguration
): void {
this._modeConfiguration = modeConfiguration || Object.create(null); this._modeConfiguration = modeConfiguration || Object.create(null);
this._onDidChange.fire(this); this._onDidChange.fire(this);
} }
} }
const formatDefaults: Required<monaco.languages.html.HTMLFormatConfiguration> = { const formatDefaults: Required<HTMLFormatConfiguration> = {
tabSize: 4, tabSize: 4,
insertSpaces: false, insertSpaces: false,
wrapLineLength: 120, wrapLineLength: 120,
@ -75,24 +171,24 @@ const formatDefaults: Required<monaco.languages.html.HTMLFormatConfiguration> =
wrapAttributes: 'auto' wrapAttributes: 'auto'
}; };
const htmlOptionsDefault: Required<monaco.languages.html.Options> = { const htmlOptionsDefault: Required<Options> = {
format: formatDefaults, format: formatDefaults,
suggest: { html5: true, angular1: true, ionic: true } suggest: { html5: true, angular1: true, ionic: true }
}; };
const handlebarOptionsDefault: Required<monaco.languages.html.Options> = { const handlebarOptionsDefault: Required<Options> = {
format: formatDefaults, format: formatDefaults,
suggest: { html5: true } suggest: { html5: true }
}; };
const razorOptionsDefault: Required<monaco.languages.html.Options> = { const razorOptionsDefault: Required<Options> = {
format: formatDefaults, format: formatDefaults,
suggest: { html5: true, razor: true } suggest: { html5: true, razor: true }
}; };
function getConfigurationDefault( function getConfigurationDefault(
languageId: string languageId: string
): Required<monaco.languages.html.ModeConfiguration> { ): Required<ModeConfiguration> {
return { return {
completionItems: true, completionItems: true,
hovers: true, hovers: true,
@ -113,31 +209,24 @@ const htmlLanguageId = 'html';
const handlebarsLanguageId = 'handlebars'; const handlebarsLanguageId = 'handlebars';
const razorLanguageId = 'razor'; const razorLanguageId = 'razor';
const htmlDefaults = new LanguageServiceDefaultsImpl( export const htmlDefaults: LanguageServiceDefaults = new LanguageServiceDefaultsImpl(
htmlLanguageId, htmlLanguageId,
htmlOptionsDefault, htmlOptionsDefault,
getConfigurationDefault(htmlLanguageId) getConfigurationDefault(htmlLanguageId)
); );
const handlebarDefaults = new LanguageServiceDefaultsImpl( export const handlebarDefaults: LanguageServiceDefaults = new LanguageServiceDefaultsImpl(
handlebarsLanguageId, handlebarsLanguageId,
handlebarOptionsDefault, handlebarOptionsDefault,
getConfigurationDefault(handlebarsLanguageId) getConfigurationDefault(handlebarsLanguageId)
); );
const razorDefaults = new LanguageServiceDefaultsImpl( export const razorDefaults: LanguageServiceDefaults = new LanguageServiceDefaultsImpl(
razorLanguageId, razorLanguageId,
razorOptionsDefault, razorOptionsDefault,
getConfigurationDefault(razorLanguageId) getConfigurationDefault(razorLanguageId)
); );
// Export API // export to the global based API
function createAPI(): typeof monaco.languages.html { (<any>languages).html = { htmlDefaults, razorDefaults, handlebarDefaults };
return {
htmlDefaults: htmlDefaults,
razorDefaults: razorDefaults,
handlebarDefaults: handlebarDefaults
};
}
monaco.languages.html = createAPI();
// --- Registration to monaco editor --- // --- Registration to monaco editor ---
@ -145,12 +234,12 @@ function getMode(): Promise<typeof mode> {
return import('./htmlMode'); return import('./htmlMode');
} }
monaco.languages.onLanguage(htmlLanguageId, () => { languages.onLanguage(htmlLanguageId, () => {
getMode().then((mode) => mode.setupMode(htmlDefaults)); getMode().then((mode) => mode.setupMode(htmlDefaults));
}); });
monaco.languages.onLanguage(handlebarsLanguageId, () => { languages.onLanguage(handlebarsLanguageId, () => {
getMode().then((mode) => mode.setupMode(handlebarDefaults)); getMode().then((mode) => mode.setupMode(handlebarDefaults));
}); });
monaco.languages.onLanguage(razorLanguageId, () => { languages.onLanguage(razorLanguageId, () => {
getMode().then((mode) => mode.setupMode(razorDefaults)); getMode().then((mode) => mode.setupMode(razorDefaults));
}); });

1
src/tsconfig.esm.json
View file

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

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,26 +2,23 @@
* 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 { HTMLWorker } from './htmlWorker'; import type { HTMLWorker } from './htmlWorker';
import { Uri, IDisposable, 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<HTMLWorker>; private _worker: editor.MonacoWebWorker<HTMLWorker>;
private _client: Promise<HTMLWorker>; private _client: Promise<HTMLWorker>;
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);
@ -59,7 +56,7 @@ export class WorkerManager {
this._lastUsedTime = Date.now(); this._lastUsedTime = Date.now();
if (!this._client) { if (!this._client) {
this._worker = monaco.editor.createWebWorker<HTMLWorker>({ this._worker = editor.createWebWorker<HTMLWorker>({
// module that exports the create() method and returns a `HTMLWorker` instance // module that exports the create() method and returns a `HTMLWorker` instance
moduleId: 'vs/language/html/htmlWorker', moduleId: 'vs/language/html/htmlWorker',