Merge vscode 1.67 (#20883)

* Fix initial build breaks from 1.67 merge (#2514) * Update yarn lock files * Update build scripts * Fix tsconfig * Build breaks * WIP * Update yarn lock files * Misc breaks * Updates to package.json * Breaks * Update yarn * Fix breaks * Breaks * Build breaks * Breaks * Breaks * Breaks * Breaks * Breaks * Missing file * Breaks * Breaks * Breaks * Breaks * Breaks * Fix several runtime breaks (#2515) * Missing files * Runtime breaks * Fix proxy ordering issue * Remove commented code * Fix breaks with opening query editor * Fix post merge break * Updates related to setup build and other breaks (#2516) * Fix bundle build issues * Update distro * Fix distro merge and update build JS files * Disable pipeline steps * Remove stats call * Update license name * Make new RPM dependencies a warning * Fix extension manager version checks * Update JS file * Fix a few runtime breaks * Fixes * Fix runtime issues * Fix build breaks * Update notebook tests (part 1) * Fix broken tests * Linting errors * Fix hygiene * Disable lint rules * Bump distro * Turn off smoke tests * Disable integration tests * Remove failing "activate" test * Remove failed test assertion * Disable other broken test * Disable query history tests * Disable extension unit tests * Disable failing tasks
2026-02-16 18:46:40 -05:00 · 2022-10-19 19:13:18 -07:00
parent 33c6daaea1
commit 8a3d08f0de
3738 changed files with 192313 additions and 107208 deletions
--- a/extensions/json-language-features/.vscodeignore
+++ b/extensions/json-language-features/.vscodeignore
@@ -12,6 +12,7 @@ server/bin/**
 server/build/**
 server/yarn.lock
 server/.npmignore
+server/README.md
 yarn.lock
 CONTRIBUTING.md
 server/extension.webpack.config.js
--- a/extensions/json-language-features/client/src/browser/jsonClientMain.ts
+++ b/extensions/json-language-features/client/src/browser/jsonClientMain.ts
@@ -5,9 +5,8 @@

 import { ExtensionContext, Uri } from 'vscode';
 import { LanguageClientOptions } from 'vscode-languageclient';
-import { startClient, LanguageClientConstructor } from '../jsonClient';
+import { startClient, LanguageClientConstructor, SchemaRequestService } from '../jsonClient';
 import { LanguageClient } from 'vscode-languageclient/browser';
-import { RequestService } from '../requests';

 declare const Worker: {
 	new(stringUrl: string): any;
@@ -24,7 +23,7 @@ export function activate(context: ExtensionContext) {
 			return new LanguageClient(id, name, clientOptions, worker);
 		};

-		const http: RequestService = {
+		const schemaRequests: SchemaRequestService = {
 			getContent(uri: string) {
 				return fetch(uri, { mode: 'cors' })
 					.then(function (response: any) {
@@ -32,7 +31,8 @@ export function activate(context: ExtensionContext) {
 					});
 			}
 		};
-		startClient(context, newLanguageClient, { http });
+
+		startClient(context, newLanguageClient, { schemaRequests });

 	} catch (e) {
 		console.log(e);
--- a/extensions/json-language-features/client/src/jsonClient.ts
+++ b/extensions/json-language-features/client/src/jsonClient.ts
@@ -6,6 +6,8 @@ import * as nls from 'vscode-nls';

 const localize = nls.loadMessageBundle();

+export type JSONLanguageStatus = { schemas: string[] };
+
 import {
 	workspace, window, languages, commands, ExtensionContext, extensions, Uri,
 	Diagnostic, StatusBarAlignment, TextEditor, TextDocument, FormattingOptions, CancellationToken,
@@ -18,20 +20,25 @@ import {
 } from 'vscode-languageclient';

 import { hash } from './utils/hash';
-import { RequestService, joinPath } from './requests';
+import { createLanguageStatusItem } from './languageStatus';

 namespace VSCodeContentRequest {
 	export const type: RequestType<string, string, any> = new RequestType('vscode/content');
 }

 namespace SchemaContentChangeNotification {
-	export const type: NotificationType<string> = new NotificationType('json/schemaContent');
+	export const type: NotificationType<string | string[]> = new NotificationType('json/schemaContent');
 }

 namespace ForceValidateRequest {
 	export const type: RequestType<string, Diagnostic[], any> = new RequestType('json/validate');
 }

+namespace LanguageStatusRequest {
+	export const type: RequestType<string, JSONLanguageStatus, any> = new RequestType('json/languageStatus');
+}
+
+
 export interface ISchemaAssociations {
 	[pattern: string]: string[];
 }
@@ -52,7 +59,8 @@ namespace ResultLimitReachedNotification {
 interface Settings {
 	json?: {
 		schemas?: JSONSchemaSettings[];
-		format?: { enable: boolean; };
+		format?: { enable?: boolean };
+		validate?: { enable?: boolean };
 		resultLimit?: number;
 	};
 	http?: {
@@ -61,7 +69,7 @@ interface Settings {
 	};
 }

-interface JSONSchemaSettings {
+export interface JSONSchemaSettings {
 	fileMatch?: string[];
 	url?: string;
 	schema?: any;
@@ -69,6 +77,7 @@ interface JSONSchemaSettings {

 namespace SettingIds {
 	export const enableFormatter = 'json.format.enable';
+	export const enableValidation = 'json.validate.enable';
 	export const enableSchemaDownload = 'json.schemaDownload.enable';
 	export const maxItemsComputed = 'json.maxItemsComputed';
 }
@@ -88,17 +97,23 @@ export interface TelemetryReporter {
 export type LanguageClientConstructor = (name: string, description: string, clientOptions: LanguageClientOptions) => CommonLanguageClient;

 export interface Runtime {
-	http: RequestService;
-	telemetry?: TelemetryReporter
+	schemaRequests: SchemaRequestService;
+	telemetry?: TelemetryReporter;
 }

+export interface SchemaRequestService {
+	getContent(uri: string): Promise<string>;
+	clearCache?(): Promise<string[]>;
+}
+
+export const languageServerDescription = localize('jsonserver.name', 'JSON Language Server');
+
 export function startClient(context: ExtensionContext, newLanguageClient: LanguageClientConstructor, runtime: Runtime) {

 	const toDispose = context.subscriptions;

 	let rangeFormatting: Disposable | undefined = undefined;

-
 	const documentSelector = ['json', 'jsonc'];

 	const schemaResolutionErrorStatusBarItem = window.createStatusBarItem('status.json.resolveError', StatusBarAlignment.Right, 0);
@@ -109,6 +124,16 @@ export function startClient(context: ExtensionContext, newLanguageClient: Langua
 	const fileSchemaErrors = new Map<string, string>();
 	let schemaDownloadEnabled = true;

+	let isClientReady = false;
+
+	toDispose.push(commands.registerCommand('json.clearCache', async () => {
+		if (isClientReady && runtime.schemaRequests.clearCache) {
+			const cachedSchemas = await runtime.schemaRequests.clearCache();
+			await client.sendNotification(SchemaContentChangeNotification.type, cachedSchemas);
+		}
+		window.showInformationMessage(localize('json.clearCache.completed', "JSON schema cache cleared."));
+	}));
+
 	// Options to control the language client
 	const clientOptions: LanguageClientOptions = {
 		// Register the server for json documents
@@ -190,12 +215,14 @@ export function startClient(context: ExtensionContext, newLanguageClient: Langua
 	};

 	// Create the language client and start the client.
-	const client = newLanguageClient('json', localize('jsonserver.name', 'JSON Language Server'), clientOptions);
+	const client = newLanguageClient('json', languageServerDescription, clientOptions);
 	client.registerProposedFeatures();

 	const disposable = client.start();
 	toDispose.push(disposable);
 	client.onReady().then(() => {
+		isClientReady = true;
+
 		const schemaDocuments: { [uri: string]: boolean } = {};

 		// handle content request
@@ -220,7 +247,7 @@ export function startClient(context: ExtensionContext, newLanguageClient: Langua
 					 */
 					runtime.telemetry.sendTelemetryEvent('json.schema', { schemaURL: uriPath });
 				}
-				return runtime.http.getContent(uriPath).catch(e => {
+				return runtime.schemaRequests.getContent(uriPath).catch(e => {
 					return Promise.reject(new ResponseError(4, e.toString()));
 				});
 			} else {
@@ -281,9 +308,9 @@ export function startClient(context: ExtensionContext, newLanguageClient: Langua

 		client.sendNotification(SchemaAssociationNotification.type, getSchemaAssociations(context));

-		extensions.onDidChange(_ => {
+		toDispose.push(extensions.onDidChange(_ => {
 			client.sendNotification(SchemaAssociationNotification.type, getSchemaAssociations(context));
-		});
+		}));

 		// manually register / deregister format provider based on the `json.format.enable` setting avoiding issues with late registration. See #71652.
 		updateFormatterRegistration();
@@ -302,7 +329,7 @@ export function startClient(context: ExtensionContext, newLanguageClient: Langua
 		client.onNotification(ResultLimitReachedNotification.type, async message => {
 			const shouldPrompt = context.globalState.get<boolean>(StorageIds.maxItemsExceededInformation) !== false;
 			if (shouldPrompt) {
-				const ok = localize('ok', "Ok");
+				const ok = localize('ok', "OK");
 				const openSettings = localize('goToSetting', 'Open Settings');
 				const neverAgain = localize('yes never again', "Don't Show Again");
 				const pick = await window.showInformationMessage(`${message}\n${localize('configureLimit', 'Use setting \'{0}\' to configure the limit.', SettingIds.maxItemsComputed)}`, ok, openSettings, neverAgain);
@@ -314,6 +341,8 @@ export function startClient(context: ExtensionContext, newLanguageClient: Langua
 			}
 		});

+		toDispose.push(createLanguageStatusItem(documentSelector, (uri: string) => client.sendRequest(LanguageStatusRequest.type, uri)));
+
 		function updateFormatterRegistration() {
 			const formatEnabled = workspace.getConfiguration().get(SettingIds.enableFormatter);
 			if (!formatEnabled && rangeFormatting) {
@@ -376,7 +405,7 @@ function getSchemaAssociations(_context: ExtensionContext): ISchemaAssociation[]
 					if (Array.isArray(fileMatch) && typeof url === 'string') {
 						let uri: string = url;
 						if (uri[0] === '.' && uri[1] === '/') {
-							uri = joinPath(extension.extensionUri, uri).toString();
+							uri = Uri.joinPath(extension.extensionUri, uri).toString();
 						}
 						fileMatch = fileMatch.map(fm => {
 							if (fm[0] === '%') {
@@ -398,6 +427,7 @@ function getSchemaAssociations(_context: ExtensionContext): ISchemaAssociation[]
 }

 function getSettings(): Settings {
+	const configuration = workspace.getConfiguration();
 	const httpSettings = workspace.getConfiguration('http');

 	const resultLimit: number = Math.trunc(Math.max(0, Number(workspace.getConfiguration().get(SettingIds.maxItemsComputed)))) || 5000;
@@ -408,6 +438,8 @@ function getSettings(): Settings {
 			proxyStrictSSL: httpSettings.get('proxyStrictSSL')
 		},
 		json: {
+			validate: { enable: configuration.get(SettingIds.enableValidation) },
+			format: { enable: configuration.get(SettingIds.enableFormatter) },
 			schemas: [],
 			resultLimit
 		}
@@ -497,7 +529,7 @@ function getSchemaId(schema: JSONSchemaSettings, folderUri?: Uri): string | unde
 			url = schema.schema.id || `vscode://schemas/custom/${encodeURIComponent(hash(schema.schema).toString(16))}`;
 		}
 	} else if (folderUri && (url[0] === '.' || url[0] === '/')) {
-		url = joinPath(folderUri, url).toString();
+		url = Uri.joinPath(folderUri, url).toString();
 	}
 	return url;
 }
--- a/extensions/json-language-features/client/src/languageStatus.ts
+++ b/extensions/json-language-features/client/src/languageStatus.ts
@@ -0,0 +1,219 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { window, languages, Uri, LanguageStatusSeverity, Disposable, commands, QuickPickItem, extensions, workspace, Extension, WorkspaceFolder, QuickPickItemKind, ThemeIcon } from 'vscode';
+import { JSONLanguageStatus, JSONSchemaSettings } from './jsonClient';
+
+import * as nls from 'vscode-nls';
+
+const localize = nls.loadMessageBundle();
+
+type ShowSchemasInput = {
+	schemas: string[];
+	uri: string;
+};
+
+interface ShowSchemasItem extends QuickPickItem {
+	uri?: Uri;
+	buttonCommands?: (() => void)[];
+}
+
+function getExtensionSchemaAssociations() {
+	const associations: { fullUri: string; extension: Extension<any>; label: string }[] = [];
+
+	for (const extension of extensions.all) {
+		const jsonValidations = extension.packageJSON?.contributes?.jsonValidation;
+		if (Array.isArray(jsonValidations)) {
+			for (const jsonValidation of jsonValidations) {
+				let uri = jsonValidation.url;
+				if (typeof uri === 'string') {
+					if (uri[0] === '.' && uri[1] === '/') {
+						uri = Uri.joinPath(extension.extensionUri, uri).toString(false);
+					}
+					associations.push({ fullUri: uri, extension, label: jsonValidation.url });
+				}
+			}
+		}
+	}
+	return {
+		findExtension(uri: string): ShowSchemasItem | undefined {
+			for (const association of associations) {
+				if (association.fullUri === uri) {
+					return {
+						label: association.label,
+						detail: localize('schemaFromextension', 'Configured by extension: {0}', association.extension.id),
+						uri: Uri.parse(association.fullUri),
+						buttons: [{ iconPath: new ThemeIcon('extensions'), tooltip: localize('openExtension', 'Open Extension') }],
+						buttonCommands: [() => commands.executeCommand('workbench.extensions.action.showExtensionsWithIds', [[association.extension.id]])]
+					};
+				}
+			}
+			return undefined;
+		}
+	};
+}
+
+//
+
+function getSettingsSchemaAssociations(uri: string) {
+	const resourceUri = Uri.parse(uri);
+	const workspaceFolder = workspace.getWorkspaceFolder(resourceUri);
+
+	const settings = workspace.getConfiguration('json', resourceUri).inspect<JSONSchemaSettings[]>('schemas');
+
+	const associations: { fullUri: string; workspaceFolder: WorkspaceFolder | undefined; label: string }[] = [];
+
+	const folderSettingSchemas = settings?.workspaceFolderValue;
+	if (workspaceFolder && Array.isArray(folderSettingSchemas)) {
+		for (const setting of folderSettingSchemas) {
+			const uri = setting.url;
+			if (typeof uri === 'string') {
+				let fullUri = uri;
+				if (uri[0] === '.' && uri[1] === '/') {
+					fullUri = Uri.joinPath(workspaceFolder.uri, uri).toString(false);
+				}
+				associations.push({ fullUri, workspaceFolder, label: uri });
+			}
+		}
+	}
+	const userSettingSchemas = settings?.globalValue;
+	if (Array.isArray(userSettingSchemas)) {
+		for (const setting of userSettingSchemas) {
+			const uri = setting.url;
+			if (typeof uri === 'string') {
+				let fullUri = uri;
+				if (workspaceFolder && uri[0] === '.' && uri[1] === '/') {
+					fullUri = Uri.joinPath(workspaceFolder.uri, uri).toString(false);
+				}
+				associations.push({ fullUri, workspaceFolder: undefined, label: uri });
+			}
+		}
+	}
+	return {
+		findSetting(uri: string): ShowSchemasItem | undefined {
+			for (const association of associations) {
+				if (association.fullUri === uri) {
+					return {
+						label: association.label,
+						detail: association.workspaceFolder ? localize('schemaFromFolderSettings', 'Configured in workspace settings') : localize('schemaFromUserSettings', 'Configured in user settings'),
+						uri: Uri.parse(association.fullUri),
+						buttons: [{ iconPath: new ThemeIcon('gear'), tooltip: localize('openSettings', 'Open Settings') }],
+						buttonCommands: [() => commands.executeCommand(association.workspaceFolder ? 'workbench.action.openWorkspaceSettingsFile' : 'workbench.action.openSettingsJson', ['json.schemas'])]
+					};
+				}
+			}
+			return undefined;
+		}
+	};
+}
+
+function showSchemaList(input: ShowSchemasInput) {
+
+	const extensionSchemaAssocations = getExtensionSchemaAssociations();
+	const settingsSchemaAssocations = getSettingsSchemaAssociations(input.uri);
+
+	const extensionEntries = [];
+	const settingsEntries = [];
+	const otherEntries = [];
+
+	for (const schemaUri of input.schemas) {
+		const extensionEntry = extensionSchemaAssocations.findExtension(schemaUri);
+		if (extensionEntry) {
+			extensionEntries.push(extensionEntry);
+			continue;
+		}
+		const settingsEntry = settingsSchemaAssocations.findSetting(schemaUri);
+		if (settingsEntry) {
+			settingsEntries.push(settingsEntry);
+			continue;
+		}
+		otherEntries.push({ label: schemaUri, uri: Uri.parse(schemaUri) });
+	}
+
+	const items: ShowSchemasItem[] = [...extensionEntries, ...settingsEntries, ...otherEntries];
+	if (items.length === 0) {
+		items.push({
+			label: localize('schema.noSchema', 'No schema configured for this file'),
+			buttons: [{ iconPath: new ThemeIcon('gear'), tooltip: localize('openSettings', 'Open Settings') }],
+			buttonCommands: [() => commands.executeCommand('workbench.action.openSettingsJson', ['json.schemas'])]
+		});
+	}
+
+	items.push({ label: '', kind: QuickPickItemKind.Separator });
+	items.push({ label: localize('schema.showdocs', 'Learn more about JSON schema configuration...'), uri: Uri.parse('https://code.visualstudio.com/docs/languages/json#_json-schemas-and-settings') });
+
+	const quickPick = window.createQuickPick<ShowSchemasItem>();
+	quickPick.title = localize('schemaPicker.title', 'JSON Schemas used for {0}', input.uri);
+	//	quickPick.placeholder = items.length ? localize('schemaPicker.placeholder', 'Select the schema to open') : undefined;
+	quickPick.items = items;
+	quickPick.show();
+	quickPick.onDidAccept(() => {
+		const uri = quickPick.selectedItems[0].uri;
+		if (uri) {
+			commands.executeCommand('vscode.open', uri);
+			quickPick.dispose();
+		}
+	});
+	quickPick.onDidTriggerItemButton(b => {
+		const index = b.item.buttons?.indexOf(b.button);
+		if (index !== undefined && index >= 0 && b.item.buttonCommands && b.item.buttonCommands[index]) {
+			b.item.buttonCommands[index]();
+		}
+	});
+}
+
+export function createLanguageStatusItem(documentSelector: string[], statusRequest: (uri: string) => Promise<JSONLanguageStatus>): Disposable {
+	const statusItem = languages.createLanguageStatusItem('json.projectStatus', documentSelector);
+	statusItem.name = localize('statusItem.name', "JSON Validation Status");
+	statusItem.severity = LanguageStatusSeverity.Information;
+
+	const showSchemasCommand = commands.registerCommand('_json.showAssociatedSchemaList', showSchemaList);
+
+	const activeEditorListener = window.onDidChangeActiveTextEditor(() => {
+		updateLanguageStatus();
+	});
+
+	async function updateLanguageStatus() {
+		const document = window.activeTextEditor?.document;
+		if (document && documentSelector.indexOf(document.languageId) !== -1) {
+			try {
+				statusItem.text = '$(loading~spin)';
+				statusItem.detail = localize('pending.detail', 'Loading JSON info');
+				statusItem.command = undefined;
+
+				const schemas = (await statusRequest(document.uri.toString())).schemas;
+				statusItem.detail = undefined;
+				if (schemas.length === 0) {
+					statusItem.text = localize('status.noSchema.short', "No Schema Validation");
+					statusItem.detail = localize('status.noSchema', 'No JSON schema configured.');
+				} else if (schemas.length === 1) {
+					statusItem.text = localize('status.withSchema.short', "Schema Validated");
+					statusItem.detail = localize('status.singleSchema', 'JSON schema configured.');
+				} else {
+					statusItem.text = localize('status.withSchemas.short', "Schema Validated");
+					statusItem.detail = localize('status.multipleSchema', 'Multiple JSON schemas configured.');
+				}
+				statusItem.command = {
+					command: '_json.showAssociatedSchemaList',
+					title: localize('status.openSchemasLink', 'Show Schemas'),
+					arguments: [{ schemas, uri: document.uri.toString() } as ShowSchemasInput]
+				};
+			} catch (e) {
+				statusItem.text = localize('status.error', 'Unable to compute used schemas');
+				statusItem.detail = undefined;
+				statusItem.command = undefined;
+			}
+		} else {
+			statusItem.text = localize('status.notJSON', 'Not a JSON editor');
+			statusItem.detail = undefined;
+			statusItem.command = undefined;
+		}
+	}
+
+	updateLanguageStatus();
+
+	return Disposable.from(statusItem, activeEditorListener, showSchemasCommand);
+}
+
--- a/extensions/json-language-features/client/src/node/jsonClientMain.ts
+++ b/extensions/json-language-features/client/src/node/jsonClientMain.ts
@@ -3,24 +3,26 @@
 *  Licensed under the Source EULA. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

-import { ExtensionContext } from 'vscode';
-import { startClient, LanguageClientConstructor } from '../jsonClient';
+import { ExtensionContext, OutputChannel, window, workspace } from 'vscode';
+import { startClient, LanguageClientConstructor, SchemaRequestService, languageServerDescription } from '../jsonClient';
 import { ServerOptions, TransportKind, LanguageClientOptions, LanguageClient } from 'vscode-languageclient/node';

-import * as fs from 'fs';
-import { xhr, XHRResponse, getErrorStatusDescription } from 'request-light';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { xhr, XHRResponse, getErrorStatusDescription, Headers } from 'request-light';

-import TelemetryReporter from 'vscode-extension-telemetry';
-import { RequestService } from '../requests';
+import TelemetryReporter from '@vscode/extension-telemetry';
+import { JSONSchemaCache } from './schemaCache';

 let telemetry: TelemetryReporter | undefined;

 // this method is called when vs code is activated
-export function activate(context: ExtensionContext) {
-
-	const clientPackageJSON = getPackageInfo(context);
+export async function activate(context: ExtensionContext) {
+	const clientPackageJSON = await getPackageInfo(context);
 	telemetry = new TelemetryReporter(clientPackageJSON.name, clientPackageJSON.version, clientPackageJSON.aiKey);

+	const outputChannel = window.createOutputChannel(languageServerDescription);
+
 	const serverMain = `./server/${clientPackageJSON.main.indexOf('/dist/') !== -1 ? 'dist' : 'out'}/node/jsonServerMain`;
 	const serverModule = context.asAbsolutePath(serverMain);

@@ -35,10 +37,15 @@ export function activate(context: ExtensionContext) {
 	};

 	const newLanguageClient: LanguageClientConstructor = (id: string, name: string, clientOptions: LanguageClientOptions) => {
+		clientOptions.outputChannel = outputChannel;
 		return new LanguageClient(id, name, serverOptions, clientOptions);
 	};
+	const log = getLog(outputChannel);
+	context.subscriptions.push(log);

-	startClient(context, newLanguageClient, { http: getHTTPRequestService(), telemetry });
+	const schemaRequests = await getSchemaRequestService(context, log);
+
+	startClient(context, newLanguageClient, { schemaRequests, telemetry });
 }

 export function deactivate(): Promise<any> {
@@ -52,23 +59,100 @@ interface IPackageInfo {
 	main: string;
 }

-function getPackageInfo(context: ExtensionContext): IPackageInfo {
+async function getPackageInfo(context: ExtensionContext): Promise<IPackageInfo> {
 	const location = context.asAbsolutePath('./package.json');
 	try {
-		return JSON.parse(fs.readFileSync(location).toString());
+		return JSON.parse((await fs.readFile(location)).toString());
 	} catch (e) {
 		console.log(`Problems reading ${location}: ${e}`);
 		return { name: '', version: '', aiKey: '', main: '' };
 	}
 }

-function getHTTPRequestService(): RequestService {
+interface Log {
+	trace(message: string): void;
+	isTrace(): boolean;
+	dispose(): void;
+}
+
+const traceSetting = 'json.trace.server';
+function getLog(outputChannel: OutputChannel): Log {
+	let trace = workspace.getConfiguration().get(traceSetting) === 'verbose';
+	const configListener = workspace.onDidChangeConfiguration(e => {
+		if (e.affectsConfiguration(traceSetting)) {
+			trace = workspace.getConfiguration().get(traceSetting) === 'verbose';
+		}
+	});
 	return {
-		getContent(uri: string, _encoding?: string): Promise<string> {
-			const headers = { 'Accept-Encoding': 'gzip, deflate' };
-			return xhr({ url: uri, followRedirects: 5, headers }).then(response => {
-				return response.responseText;
-			}, (error: XHRResponse) => {
+		trace(message: string) {
+			if (trace) {
+				outputChannel.appendLine(message);
+			}
+		},
+		isTrace() {
+			return trace;
+		},
+		dispose: () => configListener.dispose()
+	};
+}
+
+const retryTimeoutInHours = 2 * 24; // 2 days
+
+async function getSchemaRequestService(context: ExtensionContext, log: Log): Promise<SchemaRequestService> {
+	let cache: JSONSchemaCache | undefined = undefined;
+	const globalStorage = context.globalStorageUri;
+
+	let clearCache: (() => Promise<string[]>) | undefined;
+	if (globalStorage.scheme === 'file') {
+		const schemaCacheLocation = path.join(globalStorage.fsPath, 'json-schema-cache');
+		await fs.mkdir(schemaCacheLocation, { recursive: true });
+
+		const schemaCache = new JSONSchemaCache(schemaCacheLocation, context.globalState);
+		log.trace(`[json schema cache] initial state: ${JSON.stringify(schemaCache.getCacheInfo(), null, ' ')}`);
+		cache = schemaCache;
+		clearCache = async () => {
+			const cachedSchemas = await schemaCache.clearCache();
+			log.trace(`[json schema cache] cache cleared. Previously cached schemas: ${cachedSchemas.join(', ')}`);
+			return cachedSchemas;
+		};
+	}
+
+
+	const isXHRResponse = (error: any): error is XHRResponse => typeof error?.status === 'number';
+
+	const request = async (uri: string, etag?: string): Promise<string> => {
+		const headers: Headers = { 'Accept-Encoding': 'gzip, deflate' };
+		if (etag) {
+			headers['If-None-Match'] = etag;
+		}
+		try {
+			log.trace(`[json schema cache] Requesting schema ${uri} etag ${etag}...`);
+
+			const response = await xhr({ url: uri, followRedirects: 5, headers });
+			if (cache) {
+				const etag = response.headers['etag'];
+				if (typeof etag === 'string') {
+					log.trace(`[json schema cache] Storing schema ${uri} etag ${etag} in cache`);
+					await cache.putSchema(uri, etag, response.responseText);
+				} else {
+					log.trace(`[json schema cache] Response: schema ${uri} no etag`);
+				}
+			}
+			return response.responseText;
+		} catch (error: unknown) {
+			if (isXHRResponse(error)) {
+				if (error.status === 304 && etag && cache) {
+
+					log.trace(`[json schema cache] Response: schema ${uri} unchanged etag ${etag}`);
+
+					const content = await cache.getSchema(uri, etag, true);
+					if (content) {
+						log.trace(`[json schema cache] Get schema ${uri} etag ${etag} from cache`);
+						return content;
+					}
+					return request(uri);
+				}
+
 				let status = getErrorStatusDescription(error.status);
 				if (status && error.responseText) {
 					status = `${status}\n${error.responseText.substring(0, 200)}`;
@@ -76,8 +160,28 @@ function getHTTPRequestService(): RequestService {
 				if (!status) {
 					status = error.toString();
 				}
-				return Promise.reject(status);
-			});
+				log.trace(`[json schema cache] Respond schema ${uri} error ${status}`);
+
+				throw status;
+			}
+			throw error;
 		}
 	};
+
+	return {
+		getContent: async (uri: string) => {
+			if (cache && /^https?:\/\/json\.schemastore\.org\//.test(uri)) {
+				const content = await cache.getSchemaIfUpdatedSince(uri, retryTimeoutInHours);
+				if (content) {
+					if (log.isTrace()) {
+						log.trace(`[json schema cache] Schema ${uri} from cache without request (last accessed ${cache.getLastUpdatedInHours(uri)} hours ago)`);
+					}
+
+					return content;
+				}
+			}
+			return request(uri, cache?.getETag(uri));
+		},
+		clearCache
+	};
 }
--- a/extensions/json-language-features/client/src/node/schemaCache.ts
+++ b/extensions/json-language-features/client/src/node/schemaCache.ts
@@ -0,0 +1,147 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { createHash } from 'crypto';
+import { Memento } from 'vscode';
+
+interface CacheEntry {
+	etag: string;
+	fileName: string;
+	updateTime: number;
+}
+
+interface CacheInfo {
+	[schemaUri: string]: CacheEntry;
+}
+
+const MEMENTO_KEY = 'json-schema-cache';
+
+export class JSONSchemaCache {
+	private cacheInfo: CacheInfo;
+
+	constructor(private readonly schemaCacheLocation: string, private readonly globalState: Memento) {
+		const infos = globalState.get<CacheInfo>(MEMENTO_KEY, {}) as CacheInfo;
+		const validated: CacheInfo = {};
+		for (const schemaUri in infos) {
+			const { etag, fileName, updateTime } = infos[schemaUri];
+			if (typeof etag === 'string' && typeof fileName === 'string' && typeof updateTime === 'number') {
+				validated[schemaUri] = { etag, fileName, updateTime };
+			}
+		}
+		this.cacheInfo = validated;
+	}
+
+	getETag(schemaUri: string): string | undefined {
+		return this.cacheInfo[schemaUri]?.etag;
+	}
+
+	getLastUpdatedInHours(schemaUri: string): number | undefined {
+		const updateTime = this.cacheInfo[schemaUri]?.updateTime;
+		if (updateTime !== undefined) {
+			return (new Date().getTime() - updateTime) / 1000 / 60 / 60;
+		}
+		return undefined;
+	}
+
+	async putSchema(schemaUri: string, etag: string, schemaContent: string): Promise<void> {
+		try {
+			const fileName = getCacheFileName(schemaUri);
+			await fs.writeFile(path.join(this.schemaCacheLocation, fileName), schemaContent);
+			const entry: CacheEntry = { etag, fileName, updateTime: new Date().getTime() };
+			this.cacheInfo[schemaUri] = entry;
+		} catch (e) {
+			delete this.cacheInfo[schemaUri];
+		} finally {
+			await this.updateMemento();
+		}
+	}
+
+	async getSchemaIfUpdatedSince(schemaUri: string, expirationDurationInHours: number): Promise<string | undefined> {
+		const lastUpdatedInHours = this.getLastUpdatedInHours(schemaUri);
+		if (lastUpdatedInHours !== undefined && (lastUpdatedInHours < expirationDurationInHours)) {
+			return this.loadSchemaFile(schemaUri, this.cacheInfo[schemaUri], false);
+		}
+		return undefined;
+	}
+
+	async getSchema(schemaUri: string, etag: string, etagValid: boolean): Promise<string | undefined> {
+		const cacheEntry = this.cacheInfo[schemaUri];
+		if (cacheEntry) {
+			if (cacheEntry.etag === etag) {
+				return this.loadSchemaFile(schemaUri, cacheEntry, etagValid);
+			} else {
+				this.deleteSchemaFile(schemaUri, cacheEntry);
+			}
+		}
+		return undefined;
+	}
+
+	private async loadSchemaFile(schemaUri: string, cacheEntry: CacheEntry, isUpdated: boolean): Promise<string | undefined> {
+		const cacheLocation = path.join(this.schemaCacheLocation, cacheEntry.fileName);
+		try {
+			const content = (await fs.readFile(cacheLocation)).toString();
+			if (isUpdated) {
+				cacheEntry.updateTime = new Date().getTime();
+			}
+			return content;
+		} catch (e) {
+			delete this.cacheInfo[schemaUri];
+			return undefined;
+		} finally {
+			await this.updateMemento();
+		}
+	}
+
+	private async deleteSchemaFile(schemaUri: string, cacheEntry: CacheEntry): Promise<void> {
+		const cacheLocation = path.join(this.schemaCacheLocation, cacheEntry.fileName);
+		delete this.cacheInfo[schemaUri];
+		await this.updateMemento();
+		try {
+			await fs.rm(cacheLocation);
+		} catch (e) {
+			// ignore
+		}
+	}
+
+
+	// for debugging
+	public getCacheInfo() {
+		return this.cacheInfo;
+	}
+
+	private async updateMemento() {
+		try {
+			await this.globalState.update(MEMENTO_KEY, this.cacheInfo);
+		} catch (e) {
+			// ignore
+		}
+	}
+
+	public async clearCache(): Promise<string[]> {
+		const uris = Object.keys(this.cacheInfo);
+		try {
+			const files = await fs.readdir(this.schemaCacheLocation);
+			for (const file of files) {
+				try {
+					await fs.unlink(path.join(this.schemaCacheLocation, file));
+				} catch (_e) {
+					// ignore
+				}
+			}
+		} catch (e) {
+			// ignore
+		} finally {
+
+			this.cacheInfo = {};
+			await this.updateMemento();
+		}
+		return uris;
+	}
+}
+function getCacheFileName(uri: string): string {
+	return `${createHash('MD5').update(uri).digest('hex')}.schema.json`;
+}
--- a/extensions/json-language-features/client/src/requests.ts
+++ b/extensions/json-language-features/client/src/requests.ts
@@ -1,68 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { Uri } from 'vscode';
-
-export interface RequestService {
-	getContent(uri: string, encoding?: string): Promise<string>;
-}
-
-export function getScheme(uri: string) {
-	return uri.substr(0, uri.indexOf(':'));
-}
-
-export function dirname(uri: string) {
-	const lastIndexOfSlash = uri.lastIndexOf('/');
-	return lastIndexOfSlash !== -1 ? uri.substr(0, lastIndexOfSlash) : '';
-}
-
-export function basename(uri: string) {
-	const lastIndexOfSlash = uri.lastIndexOf('/');
-	return uri.substr(lastIndexOfSlash + 1);
-}
-
-const Slash = '/'.charCodeAt(0);
-const Dot = '.'.charCodeAt(0);
-
-export function isAbsolutePath(path: string) {
-	return path.charCodeAt(0) === Slash;
-}
-
-export function resolvePath(uri: Uri, path: string): Uri {
-	if (isAbsolutePath(path)) {
-		return uri.with({ path: normalizePath(path.split('/')) });
-	}
-	return joinPath(uri, path);
-}
-
-export function normalizePath(parts: string[]): string {
-	const newParts: string[] = [];
-	for (const part of parts) {
-		if (part.length === 0 || part.length === 1 && part.charCodeAt(0) === Dot) {
-			// ignore
-		} else if (part.length === 2 && part.charCodeAt(0) === Dot && part.charCodeAt(1) === Dot) {
-			newParts.pop();
-		} else {
-			newParts.push(part);
-		}
-	}
-	if (parts.length > 1 && parts[parts.length - 1].length === 0) {
-		newParts.push('');
-	}
-	let res = newParts.join('/');
-	if (parts[0].length === 0) {
-		res = '/' + res;
-	}
-	return res;
-}
-
-
-export function joinPath(uri: Uri, ...paths: string[]): Uri {
-	const parts = uri.path.split('/');
-	for (let path of paths) {
-		parts.push(...path.split('/'));
-	}
-	return uri.with({ path: normalizePath(parts) });
-}
--- a/extensions/json-language-features/client/src/typings/ref.d.ts
+++ b/extensions/json-language-features/client/src/typings/ref.d.ts
@@ -1,7 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-/// <reference path='../../../../../src/vs/vscode.d.ts'/>
-/// <reference path="../../../../../src/vs/vscode.proposed.d.ts" />
--- a/extensions/json-language-features/client/tsconfig.json
+++ b/extensions/json-language-features/client/tsconfig.json
@@ -4,6 +4,8 @@
 		"outDir": "./out"
 	},
 	"include": [
-		"src/**/*"
+		"src/**/*",
+		"../../../src/vscode-dts/vscode.d.ts",
+		"../../../src/vscode-dts/vscode.proposed.languageStatus.d.ts",
 	]
 }
--- a/extensions/json-language-features/package.json
+++ b/extensions/json-language-features/package.json
@@ -12,11 +12,11 @@
  "icon": "icons/json.png",
  "activationEvents": [
    "onLanguage:json",
-    "onLanguage:jsonc"
+    "onLanguage:jsonc",
+    "onCommand:json.clearCache"
  ],
  "main": "./client/out/node/jsonClientMain",
  "browser": "./client/dist/browser/jsonClientMain",
-  "enableProposedApi": true,
  "capabilities": {
    "virtualWorkspaces": true,
    "untrustedWorkspaces": {
@@ -73,6 +73,12 @@
            }
          }
        },
+        "json.validate.enable": {
+          "type": "boolean",
+          "scope": "window",
+          "default": true,
+          "description": "%json.validate.enable.desc%"
+        },
        "json.format.enable": {
          "type": "boolean",
          "scope": "window",
@@ -131,16 +137,23 @@
        "fileMatch": "*.schema.json",
        "url": "http://json-schema.org/draft-07/schema#"
      }
+    ],
+    "commands": [
+      {
+        "command": "json.clearCache",
+        "title": "%json.command.clearCache%",
+        "category": "JSON"
+      }
    ]
  },
  "dependencies": {
-    "request-light": "^0.5.4",
-    "vscode-extension-telemetry": "0.4.2",
+    "@vscode/extension-telemetry": "0.5.0",
+    "request-light": "^0.5.8",
    "vscode-languageclient": "^7.0.0",
    "vscode-nls": "^5.0.0"
  },
  "devDependencies": {
-    "@types/node": "14.x"
+    "@types/node": "16.x"
  },
  "repository": {
    "type": "git",
--- a/extensions/json-language-features/package.nls.json
+++ b/extensions/json-language-features/package.nls.json
@@ -7,6 +7,7 @@
 	"json.schemas.fileMatch.item.desc": "A file pattern that can contain '*' to match against when resolving JSON files to schemas.",
 	"json.schemas.schema.desc": "The schema definition for the given URL. The schema only needs to be provided to avoid accesses to the schema URL.",
 	"json.format.enable.desc": "Enable/disable default JSON formatter",
+	"json.validate.enable.desc": "Enable/disable JSON validation.",
 	"json.tracing.desc": "Traces the communication between Azure Data Studio and the JSON language server.",
 	"json.colorDecorators.enable.desc": "Enables or disables color decorators",
 	"json.colorDecorators.enable.deprecationMessage": "The setting `json.colorDecorators.enable` has been deprecated in favor of `editor.colorDecorators`.",
@@ -14,5 +15,6 @@
 	"json.clickToRetry": "Click to retry.",
 	"json.maxItemsComputed.desc": "The maximum number of outline symbols and folding regions computed (limited for performance reasons).",
 	"json.maxItemsExceededInformation.desc": "Show notification when exceeding the maximum number of outline symbols and folding regions.",
-	"json.enableSchemaDownload.desc": "When enabled, JSON schemas can be fetched from http and https locations."
+	"json.enableSchemaDownload.desc": "When enabled, JSON schemas can be fetched from http and https locations.",
+	"json.command.clearCache": "Clear schema cache"
 }
--- a/extensions/json-language-features/server/README.md
+++ b/extensions/json-language-features/server/README.md
@@ -62,6 +62,8 @@ The server supports the following settings:
 - json
  - `format`
    - `enable`: Whether the server should register the formatting support. This option is only applicable if the client supports *dynamicRegistration* for *rangeFormatting* and `initializationOptions.provideFormatter` is not defined.
+  - `validate`
+    - `enable`: Whether the server should validate. Defaults to `true` if not set.
  - `schemas`: Configures association of file names to schema URL or schemas and/or associations of schema URL to schema content.
    - `fileMatch`: an array of file names or paths (separated by `/`). `*` can be used as a wildcard. Exclusion patterns can also be defined and start with '!'. A file matches when there is at least one matching pattern and the last matching pattern is not an exclusion pattern.
    - `url`: The URL of the schema, optional when also a schema is provided.
--- a/extensions/json-language-features/server/package.json
+++ b/extensions/json-language-features/server/package.json
@@ -13,14 +13,14 @@
  "main": "./out/node/jsonServerMain",
  "dependencies": {
    "jsonc-parser": "^3.0.0",
-    "request-light": "^0.5.4",
-    "vscode-json-languageservice": "^4.1.9",
+    "request-light": "^0.5.8",
+    "vscode-json-languageservice": "^4.2.1",
    "vscode-languageserver": "^7.0.0",
-    "vscode-uri": "^3.0.2"
+    "vscode-uri": "^3.0.3"
  },
  "devDependencies": {
-    "@types/mocha": "^8.2.0",
-    "@types/node": "14.x"
+    "@types/mocha": "^9.1.1",
+    "@types/node": "16.x"
  },
  "scripts": {
    "prepublishOnly": "npm run clean && npm run compile",
--- a/extensions/json-language-features/server/src/jsonServer.ts
+++ b/extensions/json-language-features/server/src/jsonServer.ts
@@ -12,10 +12,12 @@ import {
 import { formatError, runSafe, runSafeAsync } from './utils/runner';
 import { TextDocument, JSONDocument, JSONSchema, getLanguageService, DocumentLanguageSettings, SchemaConfiguration, ClientCapabilities, Diagnostic, Range, Position } from 'vscode-json-languageservice';
 import { getLanguageModelCache } from './languageModelCache';
-import { RequestService, basename, resolvePath } from './requests';
+import { Utils, URI } from 'vscode-uri';

 type ISchemaAssociations = Record<string, string[]>;

+type JSONLanguageStatus = { schemas: string[] };
+
 namespace SchemaAssociationNotification {
 	export const type: NotificationType<ISchemaAssociations | SchemaConfiguration[]> = new NotificationType('json/schemaAssociations');
 }
@@ -25,7 +27,7 @@ namespace VSCodeContentRequest {
 }

 namespace SchemaContentChangeNotification {
-	export const type: NotificationType<string> = new NotificationType('json/schemaContent');
+	export const type: NotificationType<string | string[]> = new NotificationType('json/schemaContent');
 }

 namespace ResultLimitReachedNotification {
@@ -36,22 +38,30 @@ namespace ForceValidateRequest {
 	export const type: RequestType<string, Diagnostic[], any> = new RequestType('json/validate');
 }

+namespace LanguageStatusRequest {
+	export const type: RequestType<string, JSONLanguageStatus, any> = new RequestType('json/languageStatus');
+}
+

 const workspaceContext = {
 	resolveRelativePath: (relativePath: string, resource: string) => {
-		const base = resource.substr(0, resource.lastIndexOf('/') + 1);
-		return resolvePath(base, relativePath);
+		const base = resource.substring(0, resource.lastIndexOf('/') + 1);
+		return Utils.resolvePath(URI.parse(base), relativePath).toString();
 	}
 };

+export interface RequestService {
+	getContent(uri: string): Promise<string>;
+}
+
 export interface RuntimeEnvironment {
 	file?: RequestService;
-	http?: RequestService
-	configureHttpRequests?(proxy: string, strictSSL: boolean): void;
+	http?: RequestService;
+	configureHttpRequests?(proxy: string | undefined, strictSSL: boolean): void;
 	readonly timer: {
 		setImmediate(callback: (...args: any[]) => void, ...args: any[]): Disposable;
 		setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): Disposable;
-	}
+	};
 }

 export function startServer(connection: Connection, runtime: RuntimeEnvironment) {
@@ -156,14 +166,15 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)

 	// The settings interface describes the server relevant settings part
 	interface Settings {
-		json: {
-			schemas: JSONSchemaSettings[];
-			format: { enable: boolean; };
+		json?: {
+			schemas?: JSONSchemaSettings[];
+			format?: { enable?: boolean };
+			validate?: { enable?: boolean };
 			resultLimit?: number;
 		};
-		http: {
-			proxy: string;
-			proxyStrictSSL: boolean;
+		http?: {
+			proxy?: string;
+			proxyStrictSSL?: boolean;
 		};
 	}

@@ -175,11 +186,11 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)


 	const limitExceededWarnings = function () {
-		const pendingWarnings: { [uri: string]: { features: { [name: string]: string }; timeout?: Disposable; } } = {};
+		const pendingWarnings: { [uri: string]: { features: { [name: string]: string }; timeout?: Disposable } } = {};

 		const showLimitedNotification = (uri: string, resultLimit: number) => {
 			const warning = pendingWarnings[uri];
-			connection.sendNotification(ResultLimitReachedNotification.type, `${basename(uri)}: For performance reasons, ${Object.keys(warning.features).join(' and ')} have been limited to ${resultLimit} items.`);
+			connection.sendNotification(ResultLimitReachedNotification.type, `${Utils.basename(URI.parse(uri))}: For performance reasons, ${Object.keys(warning.features).join(' and ')} have been limited to ${resultLimit} items.`);
 			warning.timeout = undefined;
 		};

@@ -216,22 +227,24 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
 	let jsonConfigurationSettings: JSONSchemaSettings[] | undefined = undefined;
 	let schemaAssociations: ISchemaAssociations | SchemaConfiguration[] | undefined = undefined;
 	let formatterRegistrations: Thenable<Disposable>[] | null = null;
+	let validateEnabled = true;

 	// The settings have changed. Is send on server activation as well.
 	connection.onDidChangeConfiguration((change) => {
 		let settings = <Settings>change.settings;
 		if (runtime.configureHttpRequests) {
-			runtime.configureHttpRequests(settings.http && settings.http.proxy, settings.http && settings.http.proxyStrictSSL);
+			runtime.configureHttpRequests(settings?.http?.proxy, !!settings.http?.proxyStrictSSL);
 		}
-		jsonConfigurationSettings = settings.json && settings.json.schemas;
+		jsonConfigurationSettings = settings.json?.schemas;
+		validateEnabled = !!settings.json?.validate?.enable;
 		updateConfiguration();

-		foldingRangeLimit = Math.trunc(Math.max(settings.json && settings.json.resultLimit || foldingRangeLimitDefault, 0));
-		resultLimit = Math.trunc(Math.max(settings.json && settings.json.resultLimit || Number.MAX_VALUE, 0));
+		foldingRangeLimit = Math.trunc(Math.max(settings.json?.resultLimit || foldingRangeLimitDefault, 0));
+		resultLimit = Math.trunc(Math.max(settings.json?.resultLimit || Number.MAX_VALUE, 0));

 		// dynamically enable & disable the formatter
 		if (dynamicFormatterRegistration) {
-			const enableFormatter = settings && settings.json && settings.json.format && settings.json.format.enable;
+			const enableFormatter = settings.json?.format?.enable;
 			if (enableFormatter) {
 				if (!formatterRegistrations) {
 					const documentSelector = [{ language: 'json' }, { language: 'jsonc' }];
@@ -254,8 +267,22 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
 	});

 	// A schema has changed
-	connection.onNotification(SchemaContentChangeNotification.type, uri => {
-		languageService.resetSchema(uri);
+	connection.onNotification(SchemaContentChangeNotification.type, uriOrUris => {
+		let needsRevalidation = false;
+		if (Array.isArray(uriOrUris)) {
+			for (const uri of uriOrUris) {
+				if (languageService.resetSchema(uri)) {
+					needsRevalidation = true;
+				}
+			}
+		} else {
+			needsRevalidation = languageService.resetSchema(uriOrUris);
+		}
+		if (needsRevalidation) {
+			for (const doc of documents.all()) {
+				triggerValidation(doc);
+			}
+		}
 	});

 	// Retry schema validation on all open documents
@@ -273,9 +300,19 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
 		});
 	});

+	connection.onRequest(LanguageStatusRequest.type, async uri => {
+		const document = documents.get(uri);
+		if (document) {
+			const jsonDocument = getJSONDocument(document);
+			return languageService.getLanguageStatus(document, jsonDocument);
+		} else {
+			return { schemas: [] };
+		}
+	});
+
 	function updateConfiguration() {
 		const languageSettings = {
-			validate: true,
+			validate: validateEnabled,
 			allowComments: true,
 			schemas: new Array<SchemaConfiguration>()
 		};
@@ -324,7 +361,7 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)
 		connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
 	});

-	const pendingValidationRequests: { [uri: string]: Disposable; } = {};
+	const pendingValidationRequests: { [uri: string]: Disposable } = {};
 	const validationDelayMs = 300;

 	function cleanPendingValidation(textDocument: TextDocument): void {
@@ -337,10 +374,14 @@ export function startServer(connection: Connection, runtime: RuntimeEnvironment)

 	function triggerValidation(textDocument: TextDocument): void {
 		cleanPendingValidation(textDocument);
-		pendingValidationRequests[textDocument.uri] = runtime.timer.setTimeout(() => {
-			delete pendingValidationRequests[textDocument.uri];
-			validateTextDocument(textDocument);
-		}, validationDelayMs);
+		if (validateEnabled) {
+			pendingValidationRequests[textDocument.uri] = runtime.timer.setTimeout(() => {
+				delete pendingValidationRequests[textDocument.uri];
+				validateTextDocument(textDocument);
+			}, validationDelayMs);
+		} else {
+			connection.sendDiagnostics({ uri: textDocument.uri, diagnostics: [] });
+		}
 	}

 	function validateTextDocument(textDocument: TextDocument, callback?: (diagnostics: Diagnostic[]) => void): void {
--- a/extensions/json-language-features/server/src/languageModelCache.ts
+++ b/extensions/json-language-features/server/src/languageModelCache.ts
@@ -12,7 +12,7 @@ export interface LanguageModelCache<T> {
 }

 export function getLanguageModelCache<T>(maxEntries: number, cleanupIntervalTimeInSec: number, parse: (document: TextDocument) => T): LanguageModelCache<T> {
-	let languageModels: { [uri: string]: { version: number, languageId: string, cTime: number, languageModel: T } } = {};
+	let languageModels: { [uri: string]: { version: number; languageId: string; cTime: number; languageModel: T } } = {};
 	let nModels = 0;

 	let cleanupInterval: NodeJS.Timer | undefined = undefined;
--- a/extensions/json-language-features/server/src/node/jsonServerMain.ts
+++ b/extensions/json-language-features/server/src/node/jsonServerMain.ts
@@ -5,8 +5,7 @@

 import { createConnection, Connection, Disposable } from 'vscode-languageserver/node';
 import { formatError } from '../utils/runner';
-import { RuntimeEnvironment, startServer } from '../jsonServer';
-import { RequestService } from '../requests';
+import { RequestService, RuntimeEnvironment, startServer } from '../jsonServer';

 import { xhr, XHRResponse, configure as configureHttpRequests, getErrorStatusDescription } from 'request-light';
 import { URI as Uri } from 'vscode-uri';
@@ -37,7 +36,7 @@ function getHTTPRequestService(): RequestService {

 function getFileRequestService(): RequestService {
 	return {
-		getContent(location: string, encoding?: string) {
+		getContent(location: string, encoding?: BufferEncoding) {
 			return new Promise((c, e) => {
 				const uri = Uri.parse(location);
 				fs.readFile(uri.fsPath, encoding, (err, buf) => {
--- a/extensions/json-language-features/server/src/requests.ts
+++ b/extensions/json-language-features/server/src/requests.ts
@@ -1,87 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { URI } from 'vscode-uri';
-
-export interface RequestService {
-	getContent(uri: string, encoding?: string): Promise<string>;
-}
-
-export function getScheme(uri: string) {
-	return uri.substr(0, uri.indexOf(':'));
-}
-
-export function dirname(uri: string) {
-	const lastIndexOfSlash = uri.lastIndexOf('/');
-	return lastIndexOfSlash !== -1 ? uri.substr(0, lastIndexOfSlash) : '';
-}
-
-export function basename(uri: string) {
-	const lastIndexOfSlash = uri.lastIndexOf('/');
-	return uri.substr(lastIndexOfSlash + 1);
-}
-
-
-const Slash = '/'.charCodeAt(0);
-const Dot = '.'.charCodeAt(0);
-
-export function extname(uri: string) {
-	for (let i = uri.length - 1; i >= 0; i--) {
-		const ch = uri.charCodeAt(i);
-		if (ch === Dot) {
-			if (i > 0 && uri.charCodeAt(i - 1) !== Slash) {
-				return uri.substr(i);
-			} else {
-				break;
-			}
-		} else if (ch === Slash) {
-			break;
-		}
-	}
-	return '';
-}
-
-export function isAbsolutePath(path: string) {
-	return path.charCodeAt(0) === Slash;
-}
-
-export function resolvePath(uriString: string, path: string): string {
-	if (isAbsolutePath(path)) {
-		const uri = URI.parse(uriString);
-		const parts = path.split('/');
-		return uri.with({ path: normalizePath(parts) }).toString();
-	}
-	return joinPath(uriString, path);
-}
-
-export function normalizePath(parts: string[]): string {
-	const newParts: string[] = [];
-	for (const part of parts) {
-		if (part.length === 0 || part.length === 1 && part.charCodeAt(0) === Dot) {
-			// ignore
-		} else if (part.length === 2 && part.charCodeAt(0) === Dot && part.charCodeAt(1) === Dot) {
-			newParts.pop();
-		} else {
-			newParts.push(part);
-		}
-	}
-	if (parts.length > 1 && parts[parts.length - 1].length === 0) {
-		newParts.push('');
-	}
-	let res = newParts.join('/');
-	if (parts[0].length === 0) {
-		res = '/' + res;
-	}
-	return res;
-}
-
-export function joinPath(uriString: string, ...paths: string[]): string {
-	const uri = URI.parse(uriString);
-	const parts = uri.path.split('/');
-	for (let path of paths) {
-		parts.push(...path.split('/'));
-	}
-	return uri.with({ path: normalizePath(parts) }).toString();
-}
--- a/extensions/json-language-features/server/yarn.lock
+++ b/extensions/json-language-features/server/yarn.lock
@@ -2,36 +2,36 @@
 # yarn lockfile v1


-"@types/mocha@^8.2.0":
-  version "8.2.0"
-  resolved "https://registry.yarnpkg.com/@types/mocha/-/mocha-8.2.0.tgz#3eb56d13a1de1d347ecb1957c6860c911704bc44"
-  integrity sha512-/Sge3BymXo4lKc31C8OINJgXLaw+7vL1/L1pGiBNpGrBiT8FQiaFpSYV0uhTaG4y78vcMBTMFsWaHDvuD+xGzQ==
+"@types/mocha@^9.1.1":
+  version "9.1.1"
+  resolved "https://registry.yarnpkg.com/@types/mocha/-/mocha-9.1.1.tgz#e7c4f1001eefa4b8afbd1eee27a237fee3bf29c4"
+  integrity sha512-Z61JK7DKDtdKTWwLeElSEBcWGRLY8g95ic5FoQqI9CMx0ns/Ghep3B4DfcEimiKMvtamNVULVNKEsiwV3aQmXw==

-"@types/node@14.x":
-  version "14.14.43"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.43.tgz#26bcbb0595b305400e8ceaf9a127a7f905ae49c8"
-  integrity sha512-3pwDJjp1PWacPTpH0LcfhgjvurQvrZFBrC6xxjaUEZ7ifUtT32jtjPxEMMblpqd2Mvx+k8haqQJLQxolyGN/cQ==
+"@types/node@16.x":
+  version "16.11.6"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-16.11.6.tgz#6bef7a2a0ad684cf6e90fcfe31cecabd9ce0a3ae"
+  integrity sha512-ua7PgUoeQFjmWPcoo9khiPum3Pd60k4/2ZGXt18sm2Slk0W0xZTqt5Y0Ny1NyBiN1EVQ/+FaF9NcY4Qe6rwk5w==

 jsonc-parser@^3.0.0:
  version "3.0.0"
  resolved "https://registry.yarnpkg.com/jsonc-parser/-/jsonc-parser-3.0.0.tgz#abdd785701c7e7eaca8a9ec8cf070ca51a745a22"
  integrity sha512-fQzRfAbIBnR0IQvftw9FJveWiHp72Fg20giDrHz6TdfB12UH/uue0D3hm57UB5KgAVuniLMCaS8P1IMj9NR7cA==

-request-light@^0.5.4:
-  version "0.5.4"
-  resolved "https://registry.yarnpkg.com/request-light/-/request-light-0.5.4.tgz#497a98c6d8ae49536417a5e2d7f383b934f3e38c"
-  integrity sha512-t3566CMweOFlUk7Y1DJMu5OrtpoZEb6aSTsLQVT3wtrIEJ5NhcY9G/Oqxvjllzl4a15zXfFlcr9q40LbLVQJqw==
+request-light@^0.5.8:
+  version "0.5.8"
+  resolved "https://registry.yarnpkg.com/request-light/-/request-light-0.5.8.tgz#8bf73a07242b9e7b601fac2fa5dc22a094abcc27"
+  integrity sha512-3Zjgh+8b5fhRJBQZoy+zbVKpAQGLyka0MPgW3zruTF4dFFJ8Fqcfu9YsAvi/rvdcaTeWG3MkbZv4WKxAn/84Lg==

-vscode-json-languageservice@^4.1.9:
-  version "4.1.9"
-  resolved "https://registry.yarnpkg.com/vscode-json-languageservice/-/vscode-json-languageservice-4.1.9.tgz#fb48edc69e37167c3cafd447c3fa898052d87b61"
-  integrity sha512-kxNHitUy2fCxmP6vAp0SRLrUSuecUYzzxlC+85cC3jJlFHWmvtCJOzikC+kcUnIdls9fQSB8n0yHs8Sl6taxJw==
+vscode-json-languageservice@^4.2.1:
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/vscode-json-languageservice/-/vscode-json-languageservice-4.2.1.tgz#94b6f471ece193bf4a1ef37f6ab5cce86d50a8b4"
+  integrity sha512-xGmv9QIWs2H8obGbWg+sIPI/3/pFgj/5OWBhNzs00BkYQ9UaB2F6JJaGB/2/YOZJ3BvLXQTC4Q7muqU25QgAhA==
  dependencies:
    jsonc-parser "^3.0.0"
-    vscode-languageserver-textdocument "^1.0.1"
+    vscode-languageserver-textdocument "^1.0.3"
    vscode-languageserver-types "^3.16.0"
    vscode-nls "^5.0.0"
-    vscode-uri "^3.0.2"
+    vscode-uri "^3.0.3"

 vscode-jsonrpc@6.0.0:
  version "6.0.0"
@@ -46,10 +46,10 @@ vscode-languageserver-protocol@3.16.0:
    vscode-jsonrpc "6.0.0"
    vscode-languageserver-types "3.16.0"

-vscode-languageserver-textdocument@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.1.tgz#178168e87efad6171b372add1dea34f53e5d330f"
-  integrity sha512-UIcJDjX7IFkck7cSkNNyzIz5FyvpQfY7sdzVy+wkKN/BLaD4DQ0ppXQrKePomCxTS7RrolK1I0pey0bG9eh8dA==
+vscode-languageserver-textdocument@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.3.tgz#879f2649bfa5a6e07bc8b392c23ede2dfbf43eff"
+  integrity sha512-ynEGytvgTb6HVSUwPJIAZgiHQmPCx8bZ8w5um5Lz+q5DjP0Zj8wTFhQpyg8xaMvefDytw2+HH5yzqS+FhsR28A==

 vscode-languageserver-types@3.16.0, vscode-languageserver-types@^3.16.0:
  version "3.16.0"
@@ -68,7 +68,7 @@ vscode-nls@^5.0.0:
  resolved "https://registry.yarnpkg.com/vscode-nls/-/vscode-nls-5.0.0.tgz#99f0da0bd9ea7cda44e565a74c54b1f2bc257840"
  integrity sha512-u0Lw+IYlgbEJFF6/qAqG2d1jQmJl0eyAGJHoAJqr2HT4M2BNuQYSEiSE75f52pXHSJm8AlTjnLLbBFPrdz2hpA==

-vscode-uri@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/vscode-uri/-/vscode-uri-3.0.2.tgz#ecfd1d066cb8ef4c3a208decdbab9a8c23d055d0"
-  integrity sha512-jkjy6pjU1fxUvI51P+gCsxg1u2n8LSt0W6KrCNQceaziKzff74GoWmjVG46KieVzybO1sttPQmYfrwSHey7GUA==
+vscode-uri@^3.0.3:
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/vscode-uri/-/vscode-uri-3.0.3.tgz#a95c1ce2e6f41b7549f86279d19f47951e4f4d84"
+  integrity sha512-EcswR2S8bpR7fD0YPeS7r2xXExrScVMxg4MedACaWHEtx9ftCF/qHG1xGkolzTPcEmjTavCQgbVzHUIdTMzFGA==
--- a/extensions/json-language-features/yarn.lock
+++ b/extensions/json-language-features/yarn.lock
@@ -2,10 +2,15 @@
 # yarn lockfile v1


-"@types/node@14.x":
-  version "14.14.43"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.43.tgz#26bcbb0595b305400e8ceaf9a127a7f905ae49c8"
-  integrity sha512-3pwDJjp1PWacPTpH0LcfhgjvurQvrZFBrC6xxjaUEZ7ifUtT32jtjPxEMMblpqd2Mvx+k8haqQJLQxolyGN/cQ==
+"@types/node@16.x":
+  version "16.11.6"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-16.11.6.tgz#6bef7a2a0ad684cf6e90fcfe31cecabd9ce0a3ae"
+  integrity sha512-ua7PgUoeQFjmWPcoo9khiPum3Pd60k4/2ZGXt18sm2Slk0W0xZTqt5Y0Ny1NyBiN1EVQ/+FaF9NcY4Qe6rwk5w==
+
+"@vscode/extension-telemetry@0.5.0":
+  version "0.5.0"
+  resolved "https://registry.yarnpkg.com/@vscode/extension-telemetry/-/extension-telemetry-0.5.0.tgz#8214171e550393d577fc56326fa986c6800b831b"
+  integrity sha512-27FsgeVJvC4zVw7Ar3Ub+7vJswDt8RoBFpbgBwf8Xq/B2gaT8G6a+gkw3s2pQmjWGIqyu7TRA8e9rS8/vxv6NQ==

 balanced-match@^1.0.0:
  version "1.0.0"
@@ -39,10 +44,10 @@ minimatch@^3.0.4:
  dependencies:
    brace-expansion "^1.1.7"

-request-light@^0.5.4:
-  version "0.5.4"
-  resolved "https://registry.yarnpkg.com/request-light/-/request-light-0.5.4.tgz#497a98c6d8ae49536417a5e2d7f383b934f3e38c"
-  integrity sha512-t3566CMweOFlUk7Y1DJMu5OrtpoZEb6aSTsLQVT3wtrIEJ5NhcY9G/Oqxvjllzl4a15zXfFlcr9q40LbLVQJqw==
+request-light@^0.5.8:
+  version "0.5.8"
+  resolved "https://registry.yarnpkg.com/request-light/-/request-light-0.5.8.tgz#8bf73a07242b9e7b601fac2fa5dc22a094abcc27"
+  integrity sha512-3Zjgh+8b5fhRJBQZoy+zbVKpAQGLyka0MPgW3zruTF4dFFJ8Fqcfu9YsAvi/rvdcaTeWG3MkbZv4WKxAn/84Lg==

 semver@^7.3.4:
  version "7.3.4"
@@ -51,11 +56,6 @@ semver@^7.3.4:
  dependencies:
    lru-cache "^6.0.0"

-vscode-extension-telemetry@0.4.2:
-  version "0.4.2"
-  resolved "https://registry.yarnpkg.com/vscode-extension-telemetry/-/vscode-extension-telemetry-0.4.2.tgz#6ef847a80c9cfc207eb15e3a254f235acebb65a5"
-  integrity sha512-y0f51mVoFxHIzULQNCC26TBFIKdEC7uckS3tFoK++OOOl8mU2LlOxgmbd52T/SXoXNg5aI7xqs+4V2ug5ITvKw==
-
 vscode-jsonrpc@6.0.0:
  version "6.0.0"
  resolved "https://registry.yarnpkg.com/vscode-jsonrpc/-/vscode-jsonrpc-6.0.0.tgz#108bdb09b4400705176b957ceca9e0880e9b6d4e"