Add config to disable default formatter

src/jsonMode.ts

@@ -16,7 +16,7 @@ import IDisposable = monaco.IDisposable;
 export function setupMode(defaults: LanguageServiceDefaultsImpl): void {
 
 	const disposables: IDisposable[] = [];
-	let formattingDisposables: IDisposable[] = []
+	const providers: IDisposable[] = [];
 
 	const client = new WorkerManager(defaults);
 	disposables.push(client);
@@ -25,40 +25,61 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): void {
 		return client.getLanguageServiceWorker(...uris);
 	};
 
-	const {languageId, capabilities} = defaults;
 
-	function registerFormattingDisposables() {
-		formattingDisposables.push(monaco.languages.registerDocumentFormattingEditProvider(languageId, new languageFeatures.DocumentFormattingEditProvider(worker)));
-		formattingDisposables.push(monaco.languages.registerDocumentRangeFormattingEditProvider(languageId, new languageFeatures.DocumentRangeFormattingEditProvider(worker)));
-	}
+	function registerProviders(): void {
+		const { languageId, modeConfiguration } = defaults;
+
+		disposeAll(providers);
 
-	if (!capabilities.disableDefaultFormatter) {
-		registerFormattingDisposables()
+		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.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.documentSymbols) {
+			providers.push(monaco.languages.registerDocumentSymbolProvider(languageId, new languageFeatures.DocumentSymbolAdapter(worker)));
+		}
+		if (modeConfiguration.tokens) {
+			providers.push(monaco.languages.setTokensProvider(languageId, createTokenizationSupport(true)));
+		}
+		if (modeConfiguration.colors) {
+			providers.push(monaco.languages.registerColorProvider(languageId, new languageFeatures.DocumentColorAdapter(worker)));
+		}
+		if (modeConfiguration.foldingRanges) {
+			providers.push(monaco.languages.registerFoldingRangeProvider(languageId, new languageFeatures.FoldingRangeAdapter(worker)));
+		}
+		if (modeConfiguration.diagnostics) {
+			providers.push(new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults));
+		}
 	}
 
-	disposables.push(monaco.languages.registerCompletionItemProvider(languageId, new languageFeatures.CompletionAdapter(worker)));
-	disposables.push(monaco.languages.registerHoverProvider(languageId, new languageFeatures.HoverAdapter(worker)));
-	disposables.push(monaco.languages.registerDocumentSymbolProvider(languageId, new languageFeatures.DocumentSymbolAdapter(worker)));
-	disposables.push(new languageFeatures.DiagnosticsAdapter(languageId, worker, defaults));
-	disposables.push(monaco.languages.setTokensProvider(languageId, createTokenizationSupport(true)));
-	disposables.push(monaco.languages.setLanguageConfiguration(languageId, richEditConfiguration));
-	disposables.push(monaco.languages.registerColorProvider(languageId, new languageFeatures.DocumentColorAdapter(worker)));
-	disposables.push(monaco.languages.registerFoldingRangeProvider(languageId, new languageFeatures.FoldingRangeAdapter(worker)));
+	registerProviders();
+
+	disposables.push(monaco.languages.setLanguageConfiguration(defaults.languageId, richEditConfiguration));
 
+	let modeConfiguration = defaults.modeConfiguration;
 	defaults.onDidChange((newDefaults) => {
-		const {capabilities} = newDefaults;
-		const formattingDisabled = formattingDisposables.length === 0;
-		if (formattingDisabled != capabilities.disableDefaultFormatter) {
-			if (capabilities.disableDefaultFormatter) {
-				formattingDisposables.forEach(d => d.dispose())
-				formattingDisposables = [];
-			} else {
-				registerFormattingDisposables();
-			}
+		if (newDefaults.modeConfiguration !== modeConfiguration) {
+			modeConfiguration = newDefaults.modeConfiguration;
+			registerProviders();
 		}
-	})
+	});
+
+	disposables.push({ dispose: () => disposeAll(providers) });
 }
 
+function disposeAll(disposables: IDisposable[]) {
+	while (disposables.length) {
+		disposables.pop().dispose();
+	}
+}
 
 const richEditConfiguration: monaco.languages.LanguageConfiguration = {
 	wordPattern: /(-?\d*\.\d\w*)|([^\[\{\]\}\:\"\,\s]+)/g,

src/monaco.contribution.ts

@@ -16,13 +16,13 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.json.Langua
 
 	private _onDidChange = new Emitter<monaco.languages.json.LanguageServiceDefaults>();
 	private _diagnosticsOptions: monaco.languages.json.DiagnosticsOptions;
-	private _capabilities: monaco.languages.json.Capabilities;
+	private _modeConfiguration: monaco.languages.json.ModeConfiguration;
 	private _languageId: string;
 
-	constructor(languageId: string, diagnosticsOptions: monaco.languages.json.DiagnosticsOptions, capabilities: monaco.languages.json.Capabilities) {
+	constructor(languageId: string, diagnosticsOptions: monaco.languages.json.DiagnosticsOptions, modeConfiguration: monaco.languages.json.ModeConfiguration) {
 		this._languageId = languageId;
 		this.setDiagnosticsOptions(diagnosticsOptions);
-		this.setCapabilities(capabilities)
+		this.setModeConfiguration(modeConfiguration)
 	}
 
 	get onDidChange(): IEvent<monaco.languages.json.LanguageServiceDefaults> {
@@ -33,8 +33,8 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.json.Langua
 		return this._languageId;
 	}
 
-	get capabilities(): monaco.languages.json.Capabilities {
-		return this._capabilities;
+	get modeConfiguration(): monaco.languages.json.ModeConfiguration {
+		return this._modeConfiguration;
 	}
 
 	get diagnosticsOptions(): monaco.languages.json.DiagnosticsOptions {
@@ -45,8 +45,8 @@ export class LanguageServiceDefaultsImpl implements monaco.languages.json.Langua
 		this._diagnosticsOptions = options || Object.create(null);
 		this._onDidChange.fire(this);
 	}
-	setCapabilities(capabilities: monaco.languages.json.Capabilities): void {
-		this._capabilities = capabilities || Object.create(null);
+	setModeConfiguration(modeConfiguration: monaco.languages.json.ModeConfiguration): void {
+		this._modeConfiguration = modeConfiguration || Object.create(null);
 		this._onDidChange.fire(this);
 	};
 }
@@ -58,11 +58,19 @@ const diagnosticDefault: monaco.languages.json.DiagnosticsOptions = {
 	enableSchemaRequest: false
 };
 
-const capabilitiesDefault: monaco.languages.json.Capabilities = {
-	disableDefaultFormatter: false
+const providersDefault: monaco.languages.json.ModeConfiguration = {
+	documentFormattingEdits: true,
+	documentRangeFormattingEdits: true,
+	completionItems: true,
+	hovers: true,
+	documentSymbols: true,
+	tokens: true,
+	colors: true,
+	foldingRanges: true,
+	diagnostics: true
 }
 
-const jsonDefaults = new LanguageServiceDefaultsImpl('json', diagnosticDefault, capabilitiesDefault);
+const jsonDefaults = new LanguageServiceDefaultsImpl('json', diagnosticDefault, providersDefault);
 
 // Export API
 function createAPI(): typeof monaco.languages.json {
@@ -84,6 +92,7 @@ monaco.languages.register({
 	aliases: ['JSON', 'json'],
 	mimetypes: ['application/json'],
 });
+
 monaco.languages.onLanguage('json', () => {
 	getMode().then(mode => mode.setupMode(jsonDefaults));
 });

src/monaco.d.ts

@@ -33,22 +33,63 @@ declare module monaco.languages.json {
         /**
          *  If set, the schema service would load schema content on-demand with 'fetch' if available
          */
-        readonly enableSchemaRequest? : boolean;
+        readonly enableSchemaRequest?: boolean;
     }
 
-    export interface Capabilities {
+    export interface ModeConfiguration {
         /**
-         * Disable the default JSON formatter.
+         * Defines wheter the built-in documentFormattingEdit provider is enabled.
          */
-        readonly disableDefaultFormatter?: boolean;
+        readonly documentFormattingEdits?: boolean;
+
+        /**
+         * Defines wheter the built-in documentRangeFormattingEdit provider is enabled.
+         */
+        readonly documentRangeFormattingEdits?: boolean;
+
+        /**
+         * Defines wheter the built-in completionItemProvider is enabled.
+         */
+        readonly completionItems?: boolean;
+
+        /**
+         * Defines wheter the built-in hoverProvider is enabled.
+         */
+        readonly hovers?: boolean;
+
+        /**
+         * Defines wheter the built-in documentSymbolProvider is enabled.
+         */
+        readonly documentSymbols?: boolean;
+
+        /**
+         * Defines wheter the built-in tokens provider is enabled.
+         */
+        readonly tokens?: boolean;
+
+        /**
+        * Defines wheter the built-in color provider is enabled.
+        */
+        readonly colors?: boolean;
+
+        /**
+        * Defines wheter the built-in foldingRange provider is enabled.
+        */
+       readonly foldingRanges?: boolean;
+
+        /**
+        * Defines wheter the built-in diagnostic provider is enabled.
+        */
+       readonly diagnostics?: boolean;
+
     }
 
     export interface LanguageServiceDefaults {
         readonly onDidChange: IEvent<LanguageServiceDefaults>;
         readonly diagnosticsOptions: DiagnosticsOptions;
-        readonly capabilities: Capabilities;
+        readonly modeConfiguration: ModeConfiguration;
         setDiagnosticsOptions(options: DiagnosticsOptions): void;
-        setCapabilities(capabilities: Capabilities): void;
+        setModeConfiguration(modeConfiguration: ModeConfiguration): void;
     }
 
     export var jsonDefaults: LanguageServiceDefaults;