add mode configuration

src/htmlMode.ts

@@ -10,8 +10,9 @@ import { LanguageServiceDefaultsImpl } from './monaco.contribution';
 import * as languageFeatures from './languageFeatures';
 
 import Uri = monaco.Uri;
+import IDisposable = monaco.IDisposable;
 
-export function setupMode(defaults: LanguageServiceDefaultsImpl): void {
+export function setupMode1(defaults: LanguageServiceDefaultsImpl): void {
 
 	const client = new WorkerManager(defaults);
 
@@ -40,3 +41,74 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): void {
 	}
 
 }
+
+export function setupMode(defaults: LanguageServiceDefaultsImpl): IDisposable {
+
+	const disposables: IDisposable[] = [];
+	const providers: IDisposable[] = [];
+
+	const client = new WorkerManager(defaults);
+	disposables.push(client);
+
+	const worker: languageFeatures.WorkerAccessor = (...uris: Uri[]): Promise<HTMLWorker> => {
+		return client.getLanguageServiceWorker(...uris);
+	};
+
+
+	function registerProviders(): void {
+		const { languageId, modeConfiguration } = defaults;
+
+		disposeAll(providers);
+
+		if (modeConfiguration.completionItems) {
+			providers.push(monaco.languages.registerCompletionItemProvider(languageId, new languageFeatures.CompletionAdapter(worker)));
+		}
+		if (modeConfiguration.hovers) {
+			providers.push(monaco.languages.registerHoverProvider(languageId, new languageFeatures.HoverAdapter(worker)));
+		}
+		if (modeConfiguration.documentHighlights) {
+			providers.push(monaco.languages.registerDocumentHighlightProvider(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();
+	}
+}

src/monaco.contribution.ts

@@ -15,11 +15,13 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.html.Langua
 
 	private _onDidChange = new Emitter<monaco.languages.html.LanguageServiceDefaults>();
 	private _options: monaco.languages.html.Options;
+	private _modeConfiguration: monaco.languages.html.ModeConfiguration;
 	private _languageId: string;
 
-	constructor(languageId: string, options: monaco.languages.html.Options) {
+	constructor(languageId: string, options: monaco.languages.html.Options, modeConfiguration: monaco.languages.html.ModeConfiguration) {
 		this._languageId = languageId;
 		this.setOptions(options);
+		this.setModeConfiguration(modeConfiguration);
 	}
 
 	get onDidChange(): IEvent<monaco.languages.html.LanguageServiceDefaults> {
@@ -34,13 +36,22 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.html.Langua
 		return this._options;
 	}
 
+	get modeConfiguration(): monaco.languages.html.ModeConfiguration {
+		return this._modeConfiguration;
+	}
+
 	setOptions(options: monaco.languages.html.Options): void {
 		this._options = options || Object.create(null);
 		this._onDidChange.fire(this);
 	}
+
+	setModeConfiguration(modeConfiguration: monaco.languages.html.ModeConfiguration): void {
+		this._modeConfiguration = modeConfiguration || Object.create(null);
+		this._onDidChange.fire(this);
+	};
 }
 
-const formatDefaults: monaco.languages.html.HTMLFormatConfiguration = {
+const formatDefaults: Required<monaco.languages.html.HTMLFormatConfiguration> = {
 	tabSize: 4,
 	insertSpaces: false,
 	wrapLineLength: 120,
@@ -55,28 +66,58 @@ const formatDefaults: monaco.languages.html.HTMLFormatConfiguration = {
 	wrapAttributes: 'auto'
 };
 
-const htmlOptionsDefault: monaco.languages.html.Options = {
+const htmlOptionsDefault: Required<monaco.languages.html.Options> = {
 	format: formatDefaults,
 	suggest: { html5: true, angular1: true, ionic: true }
 }
 
-const handlebarOptionsDefault: monaco.languages.html.Options = {
+const handlebarOptionsDefault: Required<monaco.languages.html.Options> = {
 	format: formatDefaults,
 	suggest: { html5: true }
 }
 
-const razorOptionsDefault: monaco.languages.html.Options = {
+const razorOptionsDefault: Required<monaco.languages.html.Options> = {
 	format: formatDefaults,
 	suggest: { html5: true, razor: true }
 }
 
+const htmlModeConfigurationDefault: Required<monaco.languages.html.ModeConfiguration> = {
+	completionItems: true,
+	hovers: true,
+	documentSymbols: true,
+	links: true,
+	documentHighlights: true,
+	rename: true,
+	colors: true,
+	foldingRanges: true,
+	diagnostics: true,
+	selectionRanges: true,
+	documentFormattingEdits: true,
+	documentRangeFormattingEdits: true
+}
+
+const othersModeConfigurationDefault: Required<monaco.languages.html.ModeConfiguration> = {
+	completionItems: true,
+	hovers: true,
+	documentSymbols: true,
+	links: true,
+	documentHighlights: true,
+	rename: true,
+	colors: true,
+	foldingRanges: true,
+	selectionRanges: true,
+	diagnostics: false,  // turned off for Razor and Handlebar
+	documentFormattingEdits: false, // turned off for Razor and Handlebar
+	documentRangeFormattingEdits: false // turned off for Razor and Handlebar
+}
+
 const htmlLanguageId = 'html';
 const handlebarsLanguageId = 'handlebars';
 const razorLanguageId = 'razor';
 
-const htmlDefaults = new LanguageServiceDefaultsImpl(htmlLanguageId, htmlOptionsDefault);
+const htmlDefaults = new LanguageServiceDefaultsImpl(htmlLanguageId, htmlOptionsDefault, htmlModeConfigurationDefault);
-const handlebarDefaults = new LanguageServiceDefaultsImpl(handlebarsLanguageId, handlebarOptionsDefault);
+const handlebarDefaults = new LanguageServiceDefaultsImpl(handlebarsLanguageId, handlebarOptionsDefault, othersModeConfigurationDefault);
-const razorDefaults = new LanguageServiceDefaultsImpl(razorLanguageId, razorOptionsDefault);
+const razorDefaults = new LanguageServiceDefaultsImpl(razorLanguageId, razorOptionsDefault, othersModeConfigurationDefault);
 
 // Export API
 function createAPI(): typeof monaco.languages.html {

src/monaco.d.ts

@@ -4,43 +4,106 @@
  *--------------------------------------------------------------------------------------------*/
 
 declare module monaco.languages.html {
-    export interface HTMLFormatConfiguration {
+	export interface HTMLFormatConfiguration {
-        readonly tabSize: number;
+		readonly tabSize: number;
-        readonly insertSpaces: boolean;
+		readonly insertSpaces: boolean;
-        readonly wrapLineLength: number;
+		readonly wrapLineLength: number;
-        readonly unformatted: string;
+		readonly unformatted: string;
-        readonly contentUnformatted: string;
+		readonly contentUnformatted: string;
-        readonly indentInnerHtml: boolean;
+		readonly indentInnerHtml: boolean;
-        readonly preserveNewLines: boolean;
+		readonly preserveNewLines: boolean;
-        readonly maxPreserveNewLines: number;
+		readonly maxPreserveNewLines: number;
-        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 {
-        [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.
-         */
+		 */
-        readonly format?: HTMLFormatConfiguration;
+		readonly format?: HTMLFormatConfiguration;
-        /**
+		/**
-         * A list of known schemas and/or associations of schemas to file names.
+		 * A list of known schemas and/or associations of schemas to file names.
-         */
+		 */
-        readonly suggest?: CompletionConfiguration;
+		readonly suggest?: CompletionConfiguration;
-    }
+	}
-
+
-    export interface LanguageServiceDefaults {
+	export interface ModeConfiguration {
-        readonly onDidChange: IEvent<LanguageServiceDefaults>;
+		/**
-        readonly options: Options;
+		 * Defines whether the built-in completionItemProvider is enabled.
-        setOptions(options: Options): void;
+		 */
-    }
+		readonly completionItems?: boolean;
-
+
-    export var htmlDefaults: LanguageServiceDefaults;
+		/**
-    export var handlebarDefaults: LanguageServiceDefaults;
+		 * Defines whether the built-in hoverProvider is enabled.
-    export var razorDefaults: LanguageServiceDefaults;
+		 */
+		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 onDidChange: IEvent<LanguageServiceDefaults>;
+		readonly options: Options;
+		setOptions(options: Options): void;
+	}
+
+	export var htmlDefaults: LanguageServiceDefaults;
+	export var handlebarDefaults: LanguageServiceDefaults;
+	export var razorDefaults: LanguageServiceDefaults;
 }