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

Run prettier

Browse source
This commit is contained in:
Alex Dima 2020-09-07 16:29:09 +02:00
parent ff1d221031
commit d089cc232d
No known key found for this signature in database
GPG key ID: 6E58D7B045760DA0
19 changed files with 2441 additions and 2045 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.vscode/settings.json vendored
View file

@ -6,4 +6,4 @@
"**/release": true, "**/release": true,
"**/out": true "**/out": true
} }
} }

42
LICENSE.md
View file

@ -1,21 +1,21 @@
The MIT License (MIT) The MIT License (MIT)
Copyright (c) Microsoft Corporation Copyright (c) Microsoft Corporation
Permission is hereby granted, free of charge, to any person obtaining a copy Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions: furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software. copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. SOFTWARE.

64
README.md
View file

@ -1,31 +1,33 @@
# Monaco HTML # Monaco HTML
HTML language plugin for the Monaco Editor. It provides the following features when editing HTML files: HTML language plugin for the Monaco Editor. It provides the following features when editing HTML files:
* Code completion
* Formatting - Code completion
* Document Highlights - Formatting
* Link detection - Document Highlights
* Syntax highlighting - Link detection
- Syntax highlighting
Internally the HTML plugin uses the [vscode-html-languageservice](https://github.com/Microsoft/vscode-html-languageservice)
node module, providing the implementation of the functionally listed above. The same module is also used Internally the HTML plugin uses the [vscode-html-languageservice](https://github.com/Microsoft/vscode-html-languageservice)
in [Visual Studio Code](https://github.com/Microsoft/vscode) to power the HTML editing experience. node module, providing the implementation of the functionally listed above. The same module is also used
in [Visual Studio Code](https://github.com/Microsoft/vscode) to power the HTML editing experience.
## Issues
## Issues
Please file issues concering `monaco-html` in the [`monaco-editor` repository](https://github.com/Microsoft/monaco-editor/issues).
Please file issues concering `monaco-html` in the [`monaco-editor` repository](https://github.com/Microsoft/monaco-editor/issues).
## Installing
## Installing
This npm module is bundled and distributed in the [monaco-editor](https://www.npmjs.com/package/monaco-editor) npm module.
This npm module is bundled and distributed in the [monaco-editor](https://www.npmjs.com/package/monaco-editor) npm module.
## Development
## Development
* `git clone https://github.com/Microsoft/monaco-html`
* `cd monaco-html` - `git clone https://github.com/Microsoft/monaco-html`
* `npm install .` - `cd monaco-html`
* `npm run watch` - `npm install .`
* open `$/monaco-html/test/index.html` in your favorite browser. - `npm run watch`
- open `$/monaco-html/test/index.html` in your favorite browser.
## License
[MIT](https://github.com/Microsoft/monaco-html/blob/master/LICENSE.md) ## License
[MIT](https://github.com/Microsoft/monaco-html/blob/master/LICENSE.md)

1572
package-lock.json generated
View file

File diff suppressed because it is too large Load diff

73
package.json
View file

@ -1,36 +1,41 @@
{ {
"name": "monaco-html", "name": "monaco-html",
"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",
"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 ./src/monaco.d.ts ./release/monaco.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 ."
}, },
"author": "Microsoft Corporation", "author": "Microsoft Corporation",
"license": "MIT", "license": "MIT",
"repository": { "repository": {
"type": "git", "type": "git",
"url": "https://github.com/Microsoft/monaco-html" "url": "https://github.com/Microsoft/monaco-html"
}, },
"bugs": { "bugs": {
"url": "https://github.com/Microsoft/monaco-editor/issues" "url": "https://github.com/Microsoft/monaco-editor/issues"
}, },
"devDependencies": { "devDependencies": {
"husky": "^4.2.5", "husky": "^4.2.5",
"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.2",
"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": "^3.7.5",
"terser": "^4.6.3", "terser": "^4.6.3",
"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"
} },
"husky": {
"hooks": {
"pre-commit": "pretty-quick --staged"
}
}
} }

116
scripts/bundle.js
View file

@ -1,7 +1,7 @@
const requirejs = require('requirejs'); const requirejs = require('requirejs');
const path = require('path'); const path = require('path');
const fs = require('fs'); const fs = require('fs');
const terser = require("terser"); const terser = require('terser');
const helpers = require('monaco-plugin-helpers'); const helpers = require('monaco-plugin-helpers');
const REPO_ROOT = path.resolve(__dirname, '..'); const REPO_ROOT = path.resolve(__dirname, '..');
@ -25,49 +25,75 @@ bundleOne('htmlMode');
bundleOne('htmlWorker'); bundleOne('htmlWorker');
function bundleOne(moduleId, exclude) { function bundleOne(moduleId, exclude) {
requirejs.optimize({ requirejs.optimize(
baseUrl: 'out/amd/', {
name: 'vs/language/html/' + moduleId, baseUrl: 'out/amd/',
out: 'release/dev/' + moduleId + '.js', name: 'vs/language/html/' + moduleId,
exclude: exclude, out: 'release/dev/' + moduleId + '.js',
paths: { exclude: exclude,
'vs/language/html': REPO_ROOT + '/out/amd' paths: {
'vs/language/html': REPO_ROOT + '/out/amd'
},
optimize: 'none',
packages: [
{
name: 'vscode-html-languageservice',
location: path.join(
REPO_ROOT,
'node_modules/vscode-html-languageservice/lib/umd'
),
main: 'htmlLanguageService'
},
{
name: 'vscode-languageserver-types',
location: path.join(
REPO_ROOT,
'node_modules/vscode-languageserver-types/lib/umd'
),
main: 'main'
},
{
name: 'vscode-languageserver-textdocument',
location: path.join(
REPO_ROOT,
'node_modules/vscode-languageserver-textdocument/lib/umd'
),
main: 'main'
},
{
name: 'vscode-uri',
location: path.join(REPO_ROOT, 'node_modules/vscode-uri/lib/umd'),
main: 'index'
},
{
name: 'vscode-nls',
location: path.join(REPO_ROOT, '/out/amd/fillers'),
main: 'vscode-nls'
}
]
}, },
optimize: 'none', function (buildResponse) {
packages: [{ const devFilePath = path.join(
name: 'vscode-html-languageservice', REPO_ROOT,
location: path.join(REPO_ROOT, 'node_modules/vscode-html-languageservice/lib/umd'), 'release/dev/' + moduleId + '.js'
main: 'htmlLanguageService' );
}, { const minFilePath = path.join(
name: 'vscode-languageserver-types', REPO_ROOT,
location: path.join(REPO_ROOT, 'node_modules/vscode-languageserver-types/lib/umd'), 'release/min/' + moduleId + '.js'
main: 'main' );
}, { const fileContents = fs.readFileSync(devFilePath).toString();
name: 'vscode-languageserver-textdocument', console.log();
location: path.join(REPO_ROOT, 'node_modules/vscode-languageserver-textdocument/lib/umd'), console.log(`Minifying ${devFilePath}...`);
main: 'main' const result = terser.minify(fileContents, {
}, { output: {
name: 'vscode-uri', comments: 'some'
location: path.join(REPO_ROOT, 'node_modules/vscode-uri/lib/umd'), }
main: 'index' });
}, { console.log(`Done.`);
name: 'vscode-nls', try {
location: path.join(REPO_ROOT, '/out/amd/fillers'), fs.mkdirSync(path.join(REPO_ROOT, 'release/min'));
main: 'vscode-nls' } catch (err) {}
}] fs.writeFileSync(minFilePath, BUNDLED_FILE_HEADER + result.code);
}, function (buildResponse) { }
const devFilePath = path.join(REPO_ROOT, 'release/dev/' + moduleId + '.js'); );
const minFilePath = path.join(REPO_ROOT, 'release/min/' + moduleId + '.js');
const fileContents = fs.readFileSync(devFilePath).toString();
console.log();
console.log(`Minifying ${devFilePath}...`);
const result = terser.minify(fileContents, {
output: {
comments: 'some'
}
});
console.log(`Done.`);
try { fs.mkdirSync(path.join(REPO_ROOT, 'release/min')) } catch (err) { }
fs.writeFileSync(minFilePath, BUNDLED_FILE_HEADER + result.code);
})
} }

14
scripts/release.js
View file

@ -12,19 +12,13 @@ helpers.packageESM({
repoRoot: REPO_ROOT, repoRoot: REPO_ROOT,
esmSource: 'out/esm', esmSource: 'out/esm',
esmDestination: 'release/esm', esmDestination: 'release/esm',
entryPoints: [ entryPoints: ['monaco.contribution.js', 'htmlMode.js', 'html.worker.js'],
'monaco.contribution.js',
'htmlMode.js',
'html.worker.js'
],
resolveAlias: { resolveAlias: {
'vscode-nls': path.join(REPO_ROOT, "out/esm/fillers/vscode-nls.js") 'vscode-nls': path.join(REPO_ROOT, 'out/esm/fillers/vscode-nls.js')
}, },
resolveSkip: [ resolveSkip: ['monaco-editor-core'],
'monaco-editor-core'
],
destinationFolderSimplification: { destinationFolderSimplification: {
'node_modules': '_deps', node_modules: '_deps',
'vscode-languageserver-types/lib/esm': 'vscode-languageserver-types', 'vscode-languageserver-types/lib/esm': 'vscode-languageserver-types',
'vscode-uri/lib/esm': 'vscode-uri', 'vscode-uri/lib/esm': 'vscode-uri',
'vscode-html-languageservice/lib/esm': 'vscode-html-languageservice' 'vscode-html-languageservice/lib/esm': 'vscode-html-languageservice'

14
src/fillers/vscode-nls.ts
View file

@ -20,7 +20,7 @@ export interface LoadFunc {
} }
function format(message: string, args: any[]): string { function format(message: string, args: any[]): string {
let result:string; let result: string;
if (args.length === 0) { if (args.length === 0) {
result = message; result = message;
@ -33,14 +33,18 @@ function format(message: string, args: any[]): string {
return result; return result;
} }
function localize(key: string | LocalizeInfo, message: string, ...args: any[]): string { function localize(
key: string | LocalizeInfo,
message: string,
...args: any[]
): string {
return format(message, args); return format(message, args);
} }
export function loadMessageBundle(file?: string): LocalizeFunc { export function loadMessageBundle(file?: string): LocalizeFunc {
return localize; return localize;
} }
export function config(opt?: Options | string): LoadFunc { export function config(opt?: Options | string): LoadFunc {
return loadMessageBundle; return loadMessageBundle;
} }

2
src/html.worker.ts
View file

@ -10,6 +10,6 @@ import { HTMLWorker } from './htmlWorker';
self.onmessage = () => { self.onmessage = () => {
// ignore the first message // ignore the first message
worker.initialize((ctx, createData) => { worker.initialize((ctx, createData) => {
return new HTMLWorker(ctx, createData) return new HTMLWorker(ctx, createData);
}); });
}; };

309
src/htmlMode.ts
View file

@ -1,114 +1,195 @@
/*--------------------------------------------------------------------------------------------- /*---------------------------------------------------------------------------------------------
* 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'; 'use strict';
import { WorkerManager } from './workerManager'; import { WorkerManager } from './workerManager';
import { HTMLWorker } from './htmlWorker'; import { HTMLWorker } from './htmlWorker';
import { LanguageServiceDefaultsImpl } from './monaco.contribution'; import { LanguageServiceDefaultsImpl } from './monaco.contribution';
import * as languageFeatures from './languageFeatures'; import * as languageFeatures from './languageFeatures';
import Uri = monaco.Uri; import Uri = monaco.Uri;
import IDisposable = monaco.IDisposable; import IDisposable = monaco.IDisposable;
export function setupMode1(defaults: LanguageServiceDefaultsImpl): void { export function setupMode1(defaults: LanguageServiceDefaultsImpl): void {
const client = new WorkerManager(defaults);
const client = new WorkerManager(defaults);
const worker: languageFeatures.WorkerAccessor = (
const worker: languageFeatures.WorkerAccessor = (...uris: Uri[]): Promise<HTMLWorker> => { ...uris: Uri[]
return client.getLanguageServiceWorker(...uris); ): Promise<HTMLWorker> => {
}; return client.getLanguageServiceWorker(...uris);
};
let languageId = defaults.languageId;
let languageId = defaults.languageId;
// all modes
monaco.languages.registerCompletionItemProvider(languageId, new languageFeatures.CompletionAdapter(worker)); // all modes
monaco.languages.registerHoverProvider(languageId, new languageFeatures.HoverAdapter(worker)); monaco.languages.registerCompletionItemProvider(
languageId,
monaco.languages.registerDocumentHighlightProvider(languageId, new languageFeatures.DocumentHighlightAdapter(worker)); new languageFeatures.CompletionAdapter(worker)
monaco.languages.registerLinkProvider(languageId, new languageFeatures.DocumentLinkAdapter(worker)); );
monaco.languages.registerFoldingRangeProvider(languageId, new languageFeatures.FoldingRangeAdapter(worker)); monaco.languages.registerHoverProvider(
monaco.languages.registerDocumentSymbolProvider(languageId, new languageFeatures.DocumentSymbolAdapter(worker)); languageId,
monaco.languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker)); new languageFeatures.HoverAdapter(worker)
monaco.languages.registerRenameProvider(languageId, new languageFeatures.RenameAdapter(worker)); );
// only html monaco.languages.registerDocumentHighlightProvider(
if (languageId === 'html') { languageId,
monaco.languages.registerDocumentFormattingEditProvider(languageId, new languageFeatures.DocumentFormattingEditProvider(worker)); new languageFeatures.DocumentHighlightAdapter(worker)
monaco.languages.registerDocumentRangeFormattingEditProvider(languageId, new languageFeatures.DocumentRangeFormattingEditProvider(worker)); );
new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults); monaco.languages.registerLinkProvider(
} languageId,
new languageFeatures.DocumentLinkAdapter(worker)
} );
monaco.languages.registerFoldingRangeProvider(
export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable { languageId,
new languageFeatures.FoldingRangeAdapter(worker)
const disposables: IDisposable[] = []; );
const providers: IDisposable[] = []; monaco.languages.registerDocumentSymbolProvider(
languageId,
const client = new WorkerManager(defaults); new languageFeatures.DocumentSymbolAdapter(worker)
disposables.push(client); );
monaco.languages.registerSelectionRangeProvider(
const worker: languageFeatures.WorkerAccessor = (...uris: Uri[]): Promise<HTMLWorker> => { languageId,
return client.getLanguageServiceWorker(...uris); new languageFeatures.SelectionRangeAdapter(worker)
}; );
monaco.languages.registerRenameProvider(
languageId,
function registerProviders(): void { new languageFeatures.RenameAdapter(worker)
const { languageId, modeConfiguration } = defaults; );
disposeAll(providers); // only html
if (languageId === 'html') {
if (modeConfiguration.completionItems) { monaco.languages.registerDocumentFormattingEditProvider(
providers.push(monaco.languages.registerCompletionItemProvider(languageId, new languageFeatures.CompletionAdapter(worker))); languageId,
} new languageFeatures.DocumentFormattingEditProvider(worker)
if (modeConfiguration.hovers) { );
providers.push(monaco.languages.registerHoverProvider(languageId, new languageFeatures.HoverAdapter(worker))); monaco.languages.registerDocumentRangeFormattingEditProvider(
} languageId,
if (modeConfiguration.documentHighlights) { new languageFeatures.DocumentRangeFormattingEditProvider(worker)
providers.push(monaco.languages.registerDocumentHighlightProvider(languageId, new languageFeatures.DocumentHighlightAdapter(worker))); );
} new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults);
if (modeConfiguration.links) { }
providers.push(monaco.languages.registerLinkProvider(languageId, new languageFeatures.DocumentLinkAdapter(worker))); }
}
if (modeConfiguration.documentSymbols) { export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
providers.push(monaco.languages.registerDocumentSymbolProvider(languageId, new languageFeatures.DocumentSymbolAdapter(worker))); const disposables: IDisposable[] = [];
} const providers: IDisposable[] = [];
if (modeConfiguration.rename) {
providers.push(monaco.languages.registerRenameProvider(languageId, new languageFeatures.RenameAdapter(worker))); const client = new WorkerManager(defaults);
} disposables.push(client);
if (modeConfiguration.foldingRanges) {
providers.push(monaco.languages.registerFoldingRangeProvider(languageId, new languageFeatures.FoldingRangeAdapter(worker))); const worker: languageFeatures.WorkerAccessor = (
} ...uris: Uri[]
if (modeConfiguration.selectionRanges) { ): Promise<HTMLWorker> => {
providers.push(monaco.languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker))); return client.getLanguageServiceWorker(...uris);
} };
if (modeConfiguration.documentFormattingEdits) {
providers.push(monaco.languages.registerDocumentFormattingEditProvider(languageId, new languageFeatures.DocumentFormattingEditProvider(worker))); function registerProviders(): void {
} const { languageId, modeConfiguration } = defaults;
if (modeConfiguration.documentRangeFormattingEdits) {
providers.push(monaco.languages.registerDocumentRangeFormattingEditProvider(languageId, new languageFeatures.DocumentRangeFormattingEditProvider(worker))); disposeAll(providers);
}
if (modeConfiguration.diagnostics) { if (modeConfiguration.completionItems) {
providers.push(new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults)); providers.push(
} monaco.languages.registerCompletionItemProvider(
} languageId,
new languageFeatures.CompletionAdapter(worker)
registerProviders(); )
);
}
disposables.push(asDisposable(providers)); if (modeConfiguration.hovers) {
providers.push(
return asDisposable(disposables); monaco.languages.registerHoverProvider(
} languageId,
new languageFeatures.HoverAdapter(worker)
function asDisposable(disposables: IDisposable[]): IDisposable { )
return { dispose: () => disposeAll(disposables) }; );
} }
if (modeConfiguration.documentHighlights) {
function disposeAll(disposables: IDisposable[]) { providers.push(
while (disposables.length) { monaco.languages.registerDocumentHighlightProvider(
disposables.pop().dispose(); languageId,
} new languageFeatures.DocumentHighlightAdapter(worker)
} )
);
}
if (modeConfiguration.links) {
providers.push(
monaco.languages.registerLinkProvider(
languageId,
new languageFeatures.DocumentLinkAdapter(worker)
)
);
}
if (modeConfiguration.documentSymbols) {
providers.push(
monaco.languages.registerDocumentSymbolProvider(
languageId,
new languageFeatures.DocumentSymbolAdapter(worker)
)
);
}
if (modeConfiguration.rename) {
providers.push(
monaco.languages.registerRenameProvider(
languageId,
new languageFeatures.RenameAdapter(worker)
)
);
}
if (modeConfiguration.foldingRanges) {
providers.push(
monaco.languages.registerFoldingRangeProvider(
languageId,
new languageFeatures.FoldingRangeAdapter(worker)
)
);
}
if (modeConfiguration.selectionRanges) {
providers.push(
monaco.languages.registerSelectionRangeProvider(
languageId,
new languageFeatures.SelectionRangeAdapter(worker)
)
);
}
if (modeConfiguration.documentFormattingEdits) {
providers.push(
monaco.languages.registerDocumentFormattingEditProvider(
languageId,
new languageFeatures.DocumentFormattingEditProvider(worker)
)
);
}
if (modeConfiguration.documentRangeFormattingEdits) {
providers.push(
monaco.languages.registerDocumentRangeFormattingEditProvider(
languageId,
new languageFeatures.DocumentRangeFormattingEditProvider(worker)
)
);
}
if (modeConfiguration.diagnostics) {
providers.push(
new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults)
);
}
}
registerProviders();
disposables.push(asDisposable(providers));
return asDisposable(disposables);
}
function asDisposable(disposables: IDisposable[]): IDisposable {
return { dispose: () => disposeAll(disposables) };
}
function disposeAll(disposables: IDisposable[]) {
while (disposables.length) {
disposables.pop().dispose();
}
}

247
src/htmlWorker.ts
View file

@ -1,96 +1,151 @@
/*--------------------------------------------------------------------------------------------- /*---------------------------------------------------------------------------------------------
* 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'; 'use strict';
import IWorkerContext = monaco.worker.IWorkerContext; import IWorkerContext = monaco.worker.IWorkerContext;
import * as htmlService from 'vscode-html-languageservice'; import * as htmlService from 'vscode-html-languageservice';
export class HTMLWorker { export class HTMLWorker {
private _ctx: IWorkerContext;
private _ctx: IWorkerContext; private _languageService: htmlService.LanguageService;
private _languageService: htmlService.LanguageService; private _languageSettings: monaco.languages.html.Options;
private _languageSettings: monaco.languages.html.Options; private _languageId: string;
private _languageId: string;
constructor(ctx: IWorkerContext, createData: ICreateData) {
constructor(ctx: IWorkerContext, createData: ICreateData) { this._ctx = ctx;
this._ctx = ctx; this._languageSettings = createData.languageSettings;
this._languageSettings = createData.languageSettings; this._languageId = createData.languageId;
this._languageId = createData.languageId; this._languageService = htmlService.getLanguageService();
this._languageService = htmlService.getLanguageService(); }
}
async doValidation(uri: string): Promise<htmlService.Diagnostic[]> {
async doValidation(uri: string): Promise<htmlService.Diagnostic[]> { // not yet suported
// not yet suported return Promise.resolve([]);
return Promise.resolve([]); }
} async doComplete(
async doComplete(uri: string, position: htmlService.Position): Promise<htmlService.CompletionList> { uri: string,
let document = this._getTextDocument(uri); position: htmlService.Position
let htmlDocument = this._languageService.parseHTMLDocument(document); ): Promise<htmlService.CompletionList> {
return Promise.resolve(this._languageService.doComplete(document, position, htmlDocument, this._languageSettings && this._languageSettings.suggest)); let document = this._getTextDocument(uri);
} let htmlDocument = this._languageService.parseHTMLDocument(document);
async format(uri: string, range: htmlService.Range, options: htmlService.FormattingOptions): Promise<htmlService.TextEdit[]> { return Promise.resolve(
let document = this._getTextDocument(uri); this._languageService.doComplete(
let textEdits = this._languageService.format(document, range, this._languageSettings && this._languageSettings.format); document,
return Promise.resolve(textEdits); position,
} htmlDocument,
async doHover(uri: string, position: htmlService.Position): Promise<htmlService.Hover> { this._languageSettings && this._languageSettings.suggest
let document = this._getTextDocument(uri); )
let htmlDocument = this._languageService.parseHTMLDocument(document); );
let hover = this._languageService.doHover(document, position, htmlDocument); }
return Promise.resolve(hover); async format(
} uri: string,
async findDocumentHighlights(uri: string, position: htmlService.Position): Promise<htmlService.DocumentHighlight[]> { range: htmlService.Range,
let document = this._getTextDocument(uri); options: htmlService.FormattingOptions
let htmlDocument = this._languageService.parseHTMLDocument(document); ): Promise<htmlService.TextEdit[]> {
let highlights = this._languageService.findDocumentHighlights(document, position, htmlDocument); let document = this._getTextDocument(uri);
return Promise.resolve(highlights); let textEdits = this._languageService.format(
} document,
async findDocumentLinks(uri: string): Promise<htmlService.DocumentLink[]> { range,
let document = this._getTextDocument(uri); this._languageSettings && this._languageSettings.format
let links = this._languageService.findDocumentLinks(document, null); );
return Promise.resolve(links); return Promise.resolve(textEdits);
} }
async findDocumentSymbols(uri: string): Promise<htmlService.SymbolInformation[]> { async doHover(
let document = this._getTextDocument(uri); uri: string,
let htmlDocument = this._languageService.parseHTMLDocument(document); position: htmlService.Position
let symbols = this._languageService.findDocumentSymbols(document, htmlDocument); ): Promise<htmlService.Hover> {
return Promise.resolve(symbols); let document = this._getTextDocument(uri);
} let htmlDocument = this._languageService.parseHTMLDocument(document);
async getFoldingRanges(uri: string, context?: { rangeLimit?: number; }): Promise<htmlService.FoldingRange[]> { let hover = this._languageService.doHover(document, position, htmlDocument);
let document = this._getTextDocument(uri); return Promise.resolve(hover);
let ranges = this._languageService.getFoldingRanges(document, context); }
return Promise.resolve(ranges); async findDocumentHighlights(
} uri: string,
async getSelectionRanges(uri: string, positions: htmlService.Position[]): Promise<htmlService.SelectionRange[]> { position: htmlService.Position
let document = this._getTextDocument(uri); ): Promise<htmlService.DocumentHighlight[]> {
let ranges = this._languageService.getSelectionRanges(document, positions); let document = this._getTextDocument(uri);
return Promise.resolve(ranges); let htmlDocument = this._languageService.parseHTMLDocument(document);
} let highlights = this._languageService.findDocumentHighlights(
async doRename(uri: string, position: htmlService.Position, newName: string): Promise<htmlService.WorkspaceEdit> { document,
let document = this._getTextDocument(uri); position,
let htmlDocument = this._languageService.parseHTMLDocument(document); htmlDocument
let renames = this._languageService.doRename(document, position, newName, htmlDocument); );
return Promise.resolve(renames); return Promise.resolve(highlights);
} }
private _getTextDocument(uri: string): htmlService.TextDocument { async findDocumentLinks(uri: string): Promise<htmlService.DocumentLink[]> {
let models = this._ctx.getMirrorModels(); let document = this._getTextDocument(uri);
for (let model of models) { let links = this._languageService.findDocumentLinks(document, null);
if (model.uri.toString() === uri) { return Promise.resolve(links);
return htmlService.TextDocument.create(uri, this._languageId, model.version, model.getValue()); }
} async findDocumentSymbols(
} uri: string
return null; ): Promise<htmlService.SymbolInformation[]> {
} let document = this._getTextDocument(uri);
} let htmlDocument = this._languageService.parseHTMLDocument(document);
let symbols = this._languageService.findDocumentSymbols(
export interface ICreateData { document,
languageId: string; htmlDocument
languageSettings: monaco.languages.html.Options; );
} return Promise.resolve(symbols);
}
export function create(ctx: IWorkerContext, createData: ICreateData): HTMLWorker { async getFoldingRanges(
return new HTMLWorker(ctx, createData); uri: string,
} context?: { rangeLimit?: number }
): Promise<htmlService.FoldingRange[]> {
let document = this._getTextDocument(uri);
let ranges = this._languageService.getFoldingRanges(document, context);
return Promise.resolve(ranges);
}
async getSelectionRanges(
uri: string,
positions: htmlService.Position[]
): Promise<htmlService.SelectionRange[]> {
let document = this._getTextDocument(uri);
let ranges = this._languageService.getSelectionRanges(document, positions);
return Promise.resolve(ranges);
}
async doRename(
uri: string,
position: htmlService.Position,
newName: string
): Promise<htmlService.WorkspaceEdit> {
let document = this._getTextDocument(uri);
let htmlDocument = this._languageService.parseHTMLDocument(document);
let renames = this._languageService.doRename(
document,
position,
newName,
htmlDocument
);
return Promise.resolve(renames);
}
private _getTextDocument(uri: string): htmlService.TextDocument {
let models = this._ctx.getMirrorModels();
for (let model of models) {
if (model.uri.toString() === uri) {
return htmlService.TextDocument.create(
uri,
this._languageId,
model.version,
model.getValue()
);
}
}
return null;
}
}
export interface ICreateData {
languageId: string;
languageSettings: monaco.languages.html.Options;
}
export function create(
ctx: IWorkerContext,
createData: ICreateData
): HTMLWorker {
return new HTMLWorker(ctx, createData);
}

1344
src/languageFeatures.ts
View file

File diff suppressed because it is too large Load diff

289
src/monaco.contribution.ts
View file

@ -1,133 +1,156 @@
/*--------------------------------------------------------------------------------------------- /*---------------------------------------------------------------------------------------------
* 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'; 'use strict';
import * as mode from './htmlMode'; import * as mode from './htmlMode';
import Emitter = monaco.Emitter; import Emitter = monaco.Emitter;
import IEvent = monaco.IEvent; import IEvent = monaco.IEvent;
// --- HTML configuration and defaults --------- // --- HTML configuration and defaults ---------
export class LanguageServiceDefaultsImpl implements monaco.languages.html.LanguageServiceDefaults { export class LanguageServiceDefaultsImpl
implements monaco.languages.html.LanguageServiceDefaults {
private _onDidChange = new Emitter<monaco.languages.html.LanguageServiceDefaults>(); private _onDidChange = new Emitter<
private _options: monaco.languages.html.Options; monaco.languages.html.LanguageServiceDefaults
private _modeConfiguration: monaco.languages.html.ModeConfiguration; >();
private _languageId: string; private _options: monaco.languages.html.Options;
private _modeConfiguration: monaco.languages.html.ModeConfiguration;
constructor(languageId: string, options: monaco.languages.html.Options, modeConfiguration: monaco.languages.html.ModeConfiguration) { private _languageId: string;
this._languageId = languageId;
this.setOptions(options); constructor(
this.setModeConfiguration(modeConfiguration); languageId: string,
} options: monaco.languages.html.Options,
modeConfiguration: monaco.languages.html.ModeConfiguration
get onDidChange(): IEvent<monaco.languages.html.LanguageServiceDefaults> { ) {
return this._onDidChange.event; this._languageId = languageId;
} this.setOptions(options);
this.setModeConfiguration(modeConfiguration);
get languageId(): string { }
return this._languageId;
} get onDidChange(): IEvent<monaco.languages.html.LanguageServiceDefaults> {
return this._onDidChange.event;
get options(): monaco.languages.html.Options { }
return this._options;
} get languageId(): string {
return this._languageId;
get modeConfiguration(): monaco.languages.html.ModeConfiguration { }
return this._modeConfiguration;
} get options(): monaco.languages.html.Options {
return this._options;
setOptions(options: monaco.languages.html.Options): void { }
this._options = options || Object.create(null);
this._onDidChange.fire(this); get modeConfiguration(): monaco.languages.html.ModeConfiguration {
} return this._modeConfiguration;
}
setModeConfiguration(modeConfiguration: monaco.languages.html.ModeConfiguration): void {
this._modeConfiguration = modeConfiguration || Object.create(null); setOptions(options: monaco.languages.html.Options): void {
this._onDidChange.fire(this); this._options = options || Object.create(null);
}; this._onDidChange.fire(this);
} }
const formatDefaults: Required<monaco.languages.html.HTMLFormatConfiguration> = { setModeConfiguration(
tabSize: 4, modeConfiguration: monaco.languages.html.ModeConfiguration
insertSpaces: false, ): void {
wrapLineLength: 120, this._modeConfiguration = modeConfiguration || Object.create(null);
unformatted: 'default": "a, abbr, acronym, b, bdo, big, br, button, cite, code, dfn, em, i, img, input, kbd, label, map, object, q, samp, select, small, span, strong, sub, sup, textarea, tt, var', this._onDidChange.fire(this);
contentUnformatted: 'pre', }
indentInnerHtml: false, }
preserveNewLines: true,
maxPreserveNewLines: null, const formatDefaults: Required<monaco.languages.html.HTMLFormatConfiguration> = {
indentHandlebars: false, tabSize: 4,
endWithNewline: false, insertSpaces: false,
extraLiners: 'head, body, /html', wrapLineLength: 120,
wrapAttributes: 'auto' unformatted:
}; 'default": "a, abbr, acronym, b, bdo, big, br, button, cite, code, dfn, em, i, img, input, kbd, label, map, object, q, samp, select, small, span, strong, sub, sup, textarea, tt, var',
contentUnformatted: 'pre',
const htmlOptionsDefault: Required<monaco.languages.html.Options> = { indentInnerHtml: false,
format: formatDefaults, preserveNewLines: true,
suggest: { html5: true, angular1: true, ionic: true } maxPreserveNewLines: null,
} indentHandlebars: false,
endWithNewline: false,
const handlebarOptionsDefault: Required<monaco.languages.html.Options> = { extraLiners: 'head, body, /html',
format: formatDefaults, wrapAttributes: 'auto'
suggest: { html5: true } };
}
const htmlOptionsDefault: Required<monaco.languages.html.Options> = {
const razorOptionsDefault: Required<monaco.languages.html.Options> = { format: formatDefaults,
format: formatDefaults, suggest: { html5: true, angular1: true, ionic: true }
suggest: { html5: true, razor: true } };
}
const handlebarOptionsDefault: Required<monaco.languages.html.Options> = {
function getConfigurationDefault(languageId: string): Required<monaco.languages.html.ModeConfiguration> { format: formatDefaults,
return { suggest: { html5: true }
completionItems: true, };
hovers: true,
documentSymbols: true, const razorOptionsDefault: Required<monaco.languages.html.Options> = {
links: true, format: formatDefaults,
documentHighlights: true, suggest: { html5: true, razor: true }
rename: true, };
colors: true,
foldingRanges: true, function getConfigurationDefault(
selectionRanges: true, languageId: string
diagnostics: languageId === htmlLanguageId, // turned off for Razor and Handlebar ): Required<monaco.languages.html.ModeConfiguration> {
documentFormattingEdits: languageId === htmlLanguageId, // turned off for Razor and Handlebar return {
documentRangeFormattingEdits: languageId === htmlLanguageId // turned off for Razor and Handlebar completionItems: true,
}; hovers: true,
} documentSymbols: true,
links: true,
const htmlLanguageId = 'html'; documentHighlights: true,
const handlebarsLanguageId = 'handlebars'; rename: true,
const razorLanguageId = 'razor'; colors: true,
foldingRanges: true,
const htmlDefaults = new LanguageServiceDefaultsImpl(htmlLanguageId, htmlOptionsDefault, getConfigurationDefault(htmlLanguageId)); selectionRanges: true,
const handlebarDefaults = new LanguageServiceDefaultsImpl(handlebarsLanguageId, handlebarOptionsDefault, getConfigurationDefault(handlebarsLanguageId)); diagnostics: languageId === htmlLanguageId, // turned off for Razor and Handlebar
const razorDefaults = new LanguageServiceDefaultsImpl(razorLanguageId, razorOptionsDefault, getConfigurationDefault(razorLanguageId)); documentFormattingEdits: languageId === htmlLanguageId, // turned off for Razor and Handlebar
documentRangeFormattingEdits: languageId === htmlLanguageId // turned off for Razor and Handlebar
// Export API };
function createAPI(): typeof monaco.languages.html { }
return {
htmlDefaults: htmlDefaults, const htmlLanguageId = 'html';
razorDefaults: razorDefaults, const handlebarsLanguageId = 'handlebars';
handlebarDefaults: handlebarDefaults const razorLanguageId = 'razor';
}
} const htmlDefaults = new LanguageServiceDefaultsImpl(
monaco.languages.html = createAPI(); htmlLanguageId,
htmlOptionsDefault,
// --- Registration to monaco editor --- getConfigurationDefault(htmlLanguageId)
);
function getMode(): Promise<typeof mode> { const handlebarDefaults = new LanguageServiceDefaultsImpl(
return import('./htmlMode'); handlebarsLanguageId,
} handlebarOptionsDefault,
getConfigurationDefault(handlebarsLanguageId)
monaco.languages.onLanguage(htmlLanguageId, () => { );
getMode().then(mode => mode.setupMode(htmlDefaults)); const razorDefaults = new LanguageServiceDefaultsImpl(
}); razorLanguageId,
monaco.languages.onLanguage(handlebarsLanguageId, () => { razorOptionsDefault,
getMode().then(mode => mode.setupMode(handlebarDefaults)); getConfigurationDefault(razorLanguageId)
}); );
monaco.languages.onLanguage(razorLanguageId, () => {
getMode().then(mode => mode.setupMode(razorDefaults)); // Export API
}); function createAPI(): typeof monaco.languages.html {
return {
htmlDefaults: htmlDefaults,
razorDefaults: razorDefaults,
handlebarDefaults: handlebarDefaults
};
}
monaco.languages.html = createAPI();
// --- Registration to monaco editor ---
function getMode(): Promise<typeof mode> {
return import('./htmlMode');
}
monaco.languages.onLanguage(htmlLanguageId, () => {
getMode().then((mode) => mode.setupMode(htmlDefaults));
});
monaco.languages.onLanguage(handlebarsLanguageId, () => {
getMode().then((mode) => mode.setupMode(handlebarDefaults));
});
monaco.languages.onLanguage(razorLanguageId, () => {
getMode().then((mode) => mode.setupMode(razorDefaults));
});

9
src/monaco.d.ts vendored
View file

@ -16,7 +16,11 @@ declare module monaco.languages.html {
readonly indentHandlebars: boolean; readonly indentHandlebars: boolean;
readonly endWithNewline: boolean; readonly endWithNewline: boolean;
readonly extraLiners: string; readonly extraLiners: string;
readonly wrapAttributes: 'auto' | 'force' | 'force-aligned' | 'force-expand-multiline'; readonly wrapAttributes:
| 'auto'
| 'force'
| 'force-aligned'
| 'force-expand-multiline';
} }
export interface CompletionConfiguration { export interface CompletionConfiguration {
@ -94,7 +98,6 @@ declare module monaco.languages.html {
* 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 {
@ -106,4 +109,4 @@ declare module monaco.languages.html {
export var htmlDefaults: LanguageServiceDefaults; export var htmlDefaults: LanguageServiceDefaults;
export var handlebarDefaults: LanguageServiceDefaults; export var handlebarDefaults: LanguageServiceDefaults;
export var razorDefaults: LanguageServiceDefaults; export var razorDefaults: LanguageServiceDefaults;
} }

26
src/tsconfig.esm.json
View file

@ -1,15 +1,15 @@
{ {
"compilerOptions": { "compilerOptions": {
"module": "esnext", "module": "esnext",
"moduleResolution": "node", "moduleResolution": "node",
"outDir": "../out/esm", "outDir": "../out/esm",
"target": "es5", "target": "es5",
"lib": [ "lib": [
"dom", "dom",
"es5", "es5",
"es2015.collection", "es2015.collection",
"es2015.promise", "es2015.promise",
"es2015.iterable" "es2015.iterable"
] ]
} }
} }

26
src/tsconfig.json
View file

@ -1,15 +1,15 @@
{ {
"compilerOptions": { "compilerOptions": {
"module": "amd", "module": "amd",
"moduleResolution": "node", "moduleResolution": "node",
"outDir": "../out/amd", "outDir": "../out/amd",
"target": "es5", "target": "es5",
"lib": [ "lib": [
"dom", "dom",
"es5", "es5",
"es2015.collection", "es2015.collection",
"es2015.promise", "es2015.promise",
"es2015.iterable" "es2015.iterable"
] ]
} }
} }

2
src/typings/refs.d.ts vendored
View file

@ -2,4 +2,4 @@
* 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'/> /// <reference path='../../node_modules/monaco-editor-core/monaco.d.ts'/>

181
src/workerManager.ts
View file

@ -1,89 +1,92 @@
/*--------------------------------------------------------------------------------------------- /*---------------------------------------------------------------------------------------------
* 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'; 'use strict';
import { LanguageServiceDefaultsImpl } from './monaco.contribution'; import { LanguageServiceDefaultsImpl } from './monaco.contribution';
import { HTMLWorker } from './htmlWorker'; import { HTMLWorker } from './htmlWorker';
import IDisposable = monaco.IDisposable; import IDisposable = monaco.IDisposable;
import Uri = monaco.Uri; 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: LanguageServiceDefaultsImpl; 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: monaco.editor.MonacoWebWorker<HTMLWorker>; private _client: Promise<HTMLWorker>;
private _client: Promise<HTMLWorker>;
constructor(defaults: LanguageServiceDefaultsImpl) {
constructor(defaults: LanguageServiceDefaultsImpl) { 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); this._lastUsedTime = 0;
this._lastUsedTime = 0; this._configChangeListener = this._defaults.onDidChange(() =>
this._configChangeListener = this._defaults.onDidChange(() => this._stopWorker()); this._stopWorker()
} );
}
private _stopWorker(): void {
if (this._worker) { private _stopWorker(): void {
this._worker.dispose(); if (this._worker) {
this._worker = null; this._worker.dispose();
} this._worker = null;
this._client = null; }
} this._client = null;
}
dispose(): void {
clearInterval(this._idleCheckInterval); dispose(): void {
this._configChangeListener.dispose(); clearInterval(this._idleCheckInterval);
this._stopWorker(); this._configChangeListener.dispose();
} this._stopWorker();
}
private _checkIfIdle(): void {
if (!this._worker) { private _checkIfIdle(): void {
return; if (!this._worker) {
} return;
let timePassedSinceLastUsed = Date.now() - this._lastUsedTime; }
if (timePassedSinceLastUsed > STOP_WHEN_IDLE_FOR) { let timePassedSinceLastUsed = Date.now() - this._lastUsedTime;
this._stopWorker(); if (timePassedSinceLastUsed > STOP_WHEN_IDLE_FOR) {
} this._stopWorker();
} }
}
private _getClient(): Promise<HTMLWorker> {
this._lastUsedTime = Date.now(); private _getClient(): Promise<HTMLWorker> {
this._lastUsedTime = Date.now();
if (!this._client) {
this._worker = monaco.editor.createWebWorker<HTMLWorker>({ if (!this._client) {
this._worker = monaco.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',
// passed in to the create() method // passed in to the create() method
createData: { createData: {
languageSettings: this._defaults.options, languageSettings: this._defaults.options,
languageId: this._defaults.languageId languageId: this._defaults.languageId
}, },
label: this._defaults.languageId label: this._defaults.languageId
}); });
this._client = <Promise<HTMLWorker>>this._worker.getProxy(); this._client = <Promise<HTMLWorker>>this._worker.getProxy();
} }
return this._client; return this._client;
} }
getLanguageServiceWorker(...resources: Uri[]): Promise<HTMLWorker> { getLanguageServiceWorker(...resources: Uri[]): Promise<HTMLWorker> {
let _client: HTMLWorker; let _client: HTMLWorker;
return this._getClient().then((client) => { return this._getClient()
_client = client .then((client) => {
}).then(_ => { _client = client;
return this._worker.withSyncedResources(resources) })
}).then(_ => _client); .then((_) => {
} return this._worker.withSyncedResources(resources);
} })
.then((_) => _client);
}
}

154
test/index.html
View file

@ -1,73 +1,81 @@
<!DOCTYPE html> <!DOCTYPE html>
<html> <html>
<head> <head>
<meta http-equiv="X-UA-Compatible" content="IE=edge" /> <meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" /> <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<link rel="stylesheet" data-name="vs/editor/editor.main" href="../node_modules/monaco-editor-core/dev/vs/editor/editor.main.css"> <link
</head> rel="stylesheet"
<body> data-name="vs/editor/editor.main"
href="../node_modules/monaco-editor-core/dev/vs/editor/editor.main.css"
<h2>Monaco Editor HTML test page</h2> />
<div id="container" style="width:800px;height:600px;border:1px solid grey"></div> </head>
<body>
<script> <h2>Monaco Editor HTML test page</h2>
// Loading basic-languages to get the html language definition <div
var paths = { id="container"
'vs/basic-languages': '../node_modules/monaco-languages/release/dev', style="width: 800px; height: 600px; border: 1px solid grey"
'vs/language/html': '../release/dev', ></div>
'vs': '../node_modules/monaco-editor-core/dev/vs'
}; <script>
if (document.location.protocol === 'http:') { // Loading basic-languages to get the html language definition
// Add support for running local http server var paths = {
let testIndex = document.location.pathname.indexOf('/test/'); 'vs/basic-languages': '../node_modules/monaco-languages/release/dev',
if (testIndex !== -1) { 'vs/language/html': '../release/dev',
let prefix = document.location.pathname.substr(0, testIndex); vs: '../node_modules/monaco-editor-core/dev/vs'
paths['vs/language/html'] = prefix + '/release/dev'; };
} if (document.location.protocol === 'http:') {
} // Add support for running local http server
var require = { let testIndex = document.location.pathname.indexOf('/test/');
paths: paths if (testIndex !== -1) {
}; let prefix = document.location.pathname.substr(0, testIndex);
</script> paths['vs/language/html'] = prefix + '/release/dev';
<script src="../node_modules/monaco-editor-core/dev/vs/loader.js"></script> }
<script src="../node_modules/monaco-editor-core/dev/vs/editor/editor.main.nls.js"></script> }
<script src="../node_modules/monaco-editor-core/dev/vs/editor/editor.main.js"></script> var require = {
paths: paths
<script> };
require([ </script>
'vs/basic-languages/monaco.contribution', <script src="../node_modules/monaco-editor-core/dev/vs/loader.js"></script>
'vs/language/html/monaco.contribution' <script src="../node_modules/monaco-editor-core/dev/vs/editor/editor.main.nls.js"></script>
], function() { <script src="../node_modules/monaco-editor-core/dev/vs/editor/editor.main.js"></script>
var editor = monaco.editor.create(document.getElementById('container'), {
value: [ <script>
'<!DOCTYPE HTML>', require([
'<!--', 'vs/basic-languages/monaco.contribution',
' Comments are overrated', 'vs/language/html/monaco.contribution'
'-->', ], function () {
'<html>', var editor = monaco.editor.create(
'<head>', document.getElementById('container'),
' <title>HTML Sample</title>', {
' <meta http-equiv="X-UA-Compatible" content="IE=edge">', value: [
' <style type="text/css">', '<!DOCTYPE HTML>',
' h1 {', '<!--',
' color: #CCA3A3;', ' Comments are overrated',
' }', '-->',
' </style>', '<html>',
' <script type="text/javascript">', '<head>',
' window.alert("I am a sample...");', ' <title>HTML Sample</title>',
' var x = 3;', ' <meta http-equiv="X-UA-Compatible" content="IE=edge">',
' </'+'script>', ' <style type="text/css">',
'</head>', ' h1 {',
'<body>', ' color: #CCA3A3;',
' <h1>Heading No.1</h1>', ' }',
' <input disabled type="button" value="Click me" />', ' </style>',
'</body>', ' <script type="text/javascript">',
'</html>' ' window.alert("I am a sample...");',
].join('\n'), ' var x = 3;',
language: 'html' ' </' + 'script>',
}); '</head>',
}); '<body>',
</script> ' <h1>Heading No.1</h1>',
' <input disabled type="button" value="Click me" />',
</body> '</body>',
</html> '</html>'
].join('\n'),
language: 'html'
}
);
});
</script>
</body>
</html>