add markdown-language-features to sqlops (#2338)

extensions/markdown-language-features/src/commands/index.ts

@@ -0,0 +1,13 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+export { OpenDocumentLinkCommand } from './openDocumentLink';
+export { OnPreviewStyleLoadErrorCommand } from './onPreviewStyleLoadError';
+export { ShowPreviewCommand, ShowPreviewToSideCommand, ShowLockedPreviewToSideCommand } from './showPreview';
+export { ShowSourceCommand } from './showSource';
+export { RefreshPreviewCommand } from './refreshPreview';
+export { ShowPreviewSecuritySelectorCommand } from './showPreviewSecuritySelector';
+export { MoveCursorToPositionCommand } from './moveCursorToPosition';
+export { ToggleLockCommand } from './toggleLock';

extensions/markdown-language-features/src/commands/moveCursorToPosition.ts

@@ -0,0 +1,22 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+
+import { Command } from '../commandManager';
+
+export class MoveCursorToPositionCommand implements Command {
+	public readonly id = '_markdown.moveCursorToPosition';
+
+	public execute(line: number, character: number) {
+		if (!vscode.window.activeTextEditor) {
+			return;
+		}
+		const position = new vscode.Position(line, character);
+		const selection = new vscode.Selection(position, position);
+		vscode.window.activeTextEditor.revealRange(selection);
+		vscode.window.activeTextEditor.selection = selection;
+	}
+}

extensions/markdown-language-features/src/commands/onPreviewStyleLoadError.ts

@@ -0,0 +1,18 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import * as nls from 'vscode-nls';
+const localize = nls.loadMessageBundle();
+
+import * as vscode from 'vscode';
+
+import { Command } from '../commandManager';
+
+export class OnPreviewStyleLoadErrorCommand implements Command {
+	public readonly id = '_markdown.onPreviewStyleLoadError';
+
+	public execute(resources: string[]) {
+		vscode.window.showWarningMessage(localize('onPreviewStyleLoadError', "Could not load 'markdown.styles': {0}", resources.join(', ')));
+	}
+}

extensions/markdown-language-features/src/commands/openDocumentLink.ts

@@ -0,0 +1,75 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import * as path from 'path';
+
+import { Command } from '../commandManager';
+import { MarkdownEngine } from '../markdownEngine';
+import { TableOfContentsProvider } from '../tableOfContentsProvider';
+import { isMarkdownFile } from '../util/file';
+
+
+export interface OpenDocumentLinkArgs {
+	path: string;
+	fragment: string;
+}
+
+export class OpenDocumentLinkCommand implements Command {
+	private static readonly id = '_markdown.openDocumentLink';
+	public readonly id = OpenDocumentLinkCommand.id;
+
+	public static createCommandUri(
+		path: string,
+		fragment: string
+	): vscode.Uri {
+		return vscode.Uri.parse(`command:${OpenDocumentLinkCommand.id}?${encodeURIComponent(JSON.stringify({ path, fragment }))}`);
+	}
+
+	public constructor(
+		private readonly engine: MarkdownEngine
+	) { }
+
+	public execute(args: OpenDocumentLinkArgs) {
+		const p = decodeURIComponent(args.path);
+		return this.tryOpen(p, args).catch(() => {
+			if (path.extname(p) === '') {
+				return this.tryOpen(p + '.md', args);
+			}
+			const resource = vscode.Uri.file(p);
+			return Promise.resolve(void 0)
+				.then(() => vscode.commands.executeCommand('vscode.open', resource))
+				.then(() => void 0);
+		});
+	}
+
+	private async tryOpen(path: string, args: OpenDocumentLinkArgs) {
+		if (vscode.window.activeTextEditor && isMarkdownFile(vscode.window.activeTextEditor.document) && vscode.window.activeTextEditor.document.uri.fsPath === path) {
+			return this.tryRevealLine(vscode.window.activeTextEditor, args.fragment);
+		} else {
+			const resource = vscode.Uri.file(path);
+			return vscode.workspace.openTextDocument(resource)
+				.then(vscode.window.showTextDocument)
+				.then(editor => this.tryRevealLine(editor, args.fragment));
+		}
+	}
+
+	private async tryRevealLine(editor: vscode.TextEditor, fragment?: string) {
+		if (editor && fragment) {
+			const toc = new TableOfContentsProvider(this.engine, editor.document);
+			const entry = await toc.lookup(fragment);
+			if (entry) {
+				return editor.revealRange(new vscode.Range(entry.line, 0, entry.line, 0), vscode.TextEditorRevealType.AtTop);
+			}
+			const lineNumberFragment = fragment.match(/^L(\d+)$/);
+			if (lineNumberFragment) {
+				const line = +lineNumberFragment[1] - 1;
+				if (!isNaN(line)) {
+					return editor.revealRange(new vscode.Range(line, 0, line, 0), vscode.TextEditorRevealType.AtTop);
+				}
+			}
+		}
+	}
+}

extensions/markdown-language-features/src/commands/refreshPreview.ts

@@ -0,0 +1,19 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Command } from '../commandManager';
+import { MarkdownPreviewManager } from '../features/previewManager';
+
+export class RefreshPreviewCommand implements Command {
+	public readonly id = 'markdown.preview.refresh';
+
+	public constructor(
+		private readonly webviewManager: MarkdownPreviewManager
+	) { }
+
+	public execute() {
+		this.webviewManager.refresh();
+	}
+}

extensions/markdown-language-features/src/commands/showPreview.ts

@@ -0,0 +1,123 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+
+import { Command } from '../commandManager';
+import { MarkdownPreviewManager } from '../features/previewManager';
+import { TelemetryReporter } from '../telemetryReporter';
+import { PreviewSettings } from '../features/preview';
+
+
+function getViewColumn(sideBySide: boolean): vscode.ViewColumn | undefined {
+	const active = vscode.window.activeTextEditor;
+	if (!active) {
+		return vscode.ViewColumn.One;
+	}
+
+	if (!sideBySide) {
+		return active.viewColumn;
+	}
+
+	switch (active.viewColumn) {
+		case vscode.ViewColumn.One:
+			return vscode.ViewColumn.Two;
+		case vscode.ViewColumn.Two:
+			return vscode.ViewColumn.Three;
+	}
+
+	return active.viewColumn;
+}
+
+interface ShowPreviewSettings {
+	readonly sideBySide?: boolean;
+	readonly locked?: boolean;
+}
+
+async function showPreview(
+	webviewManager: MarkdownPreviewManager,
+	telemetryReporter: TelemetryReporter,
+	uri: vscode.Uri | undefined,
+	previewSettings: ShowPreviewSettings,
+): Promise<any> {
+	let resource = uri;
+	if (!(resource instanceof vscode.Uri)) {
+		if (vscode.window.activeTextEditor) {
+			// we are relaxed and don't check for markdown files
+			resource = vscode.window.activeTextEditor.document.uri;
+		}
+	}
+
+	if (!(resource instanceof vscode.Uri)) {
+		if (!vscode.window.activeTextEditor) {
+			// this is most likely toggling the preview
+			return vscode.commands.executeCommand('markdown.showSource');
+		}
+		// nothing found that could be shown or toggled
+		return;
+	}
+
+	webviewManager.preview(resource, {
+		resourceColumn: (vscode.window.activeTextEditor && vscode.window.activeTextEditor.viewColumn) || vscode.ViewColumn.One,
+		previewColumn: getViewColumn(!!previewSettings.sideBySide) || vscode.ViewColumn.Active,
+		locked: !!previewSettings.locked
+	});
+
+	telemetryReporter.sendTelemetryEvent('openPreview', {
+		where: previewSettings.sideBySide ? 'sideBySide' : 'inPlace',
+		how: (uri instanceof vscode.Uri) ? 'action' : 'pallete'
+	});
+}
+
+export class ShowPreviewCommand implements Command {
+	public readonly id = 'markdown.showPreview';
+
+	public constructor(
+		private readonly webviewManager: MarkdownPreviewManager,
+		private readonly telemetryReporter: TelemetryReporter
+	) { }
+
+	public execute(mainUri?: vscode.Uri, allUris?: vscode.Uri[], previewSettings?: PreviewSettings) {
+		for (const uri of (allUris || [mainUri])) {
+			showPreview(this.webviewManager, this.telemetryReporter, uri, {
+				sideBySide: false,
+				locked: previewSettings && previewSettings.locked
+			});
+		}
+	}
+}
+
+export class ShowPreviewToSideCommand implements Command {
+	public readonly id = 'markdown.showPreviewToSide';
+
+	public constructor(
+		private readonly webviewManager: MarkdownPreviewManager,
+		private readonly telemetryReporter: TelemetryReporter
+	) { }
+
+	public execute(uri?: vscode.Uri, previewSettings?: PreviewSettings) {
+		showPreview(this.webviewManager, this.telemetryReporter, uri, {
+			sideBySide: true,
+			locked: previewSettings && previewSettings.locked
+		});
+	}
+}
+
+
+export class ShowLockedPreviewToSideCommand implements Command {
+	public readonly id = 'markdown.showLockedPreviewToSide';
+
+	public constructor(
+		private readonly webviewManager: MarkdownPreviewManager,
+		private readonly telemetryReporter: TelemetryReporter
+	) { }
+
+	public execute(uri?: vscode.Uri) {
+		showPreview(this.webviewManager, this.telemetryReporter, uri, {
+			sideBySide: true,
+			locked: true
+		});
+	}
+}

extensions/markdown-language-features/src/commands/showPreviewSecuritySelector.ts

@@ -0,0 +1,30 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { Command } from '../commandManager';
+import { PreviewSecuritySelector } from '../security';
+import { isMarkdownFile } from '../util/file';
+import { MarkdownPreviewManager } from '../features/previewManager';
+
+export class ShowPreviewSecuritySelectorCommand implements Command {
+	public readonly id = 'markdown.showPreviewSecuritySelector';
+
+	public constructor(
+		private readonly previewSecuritySelector: PreviewSecuritySelector,
+		private readonly previewManager: MarkdownPreviewManager
+	) { }
+
+	public execute(resource: string | undefined) {
+		if (this.previewManager.activePreviewResource) {
+			this.previewSecuritySelector.showSecutitySelectorForResource(this.previewManager.activePreviewResource);
+		} else if (resource) {
+			const source = vscode.Uri.parse(resource);
+			this.previewSecuritySelector.showSecutitySelectorForResource(source.query ? vscode.Uri.parse(source.query) : source);
+		} else if (vscode.window.activeTextEditor && isMarkdownFile(vscode.window.activeTextEditor.document)) {
+			this.previewSecuritySelector.showSecutitySelectorForResource(vscode.window.activeTextEditor.document.uri);
+		}
+	}
+}

extensions/markdown-language-features/src/commands/showSource.ts

@@ -0,0 +1,24 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import { Command } from '../commandManager';
+import { MarkdownPreviewManager } from '../features/previewManager';
+
+export class ShowSourceCommand implements Command {
+	public readonly id = 'markdown.showSource';
+
+	public constructor(
+		private readonly previewManager: MarkdownPreviewManager
+	) { }
+
+	public execute() {
+		if (this.previewManager.activePreviewResource) {
+			return vscode.workspace.openTextDocument(this.previewManager.activePreviewResource)
+				.then(document => vscode.window.showTextDocument(document));
+		}
+		return undefined;
+	}
+}

extensions/markdown-language-features/src/commands/toggleLock.ts

@@ -0,0 +1,19 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Command } from '../commandManager';
+import { MarkdownPreviewManager } from '../features/previewManager';
+
+export class ToggleLockCommand implements Command {
+	public readonly id = 'markdown.preview.toggleLock';
+
+	public constructor(
+		private readonly previewManager: MarkdownPreviewManager
+	) { }
+
+	public execute() {
+		this.previewManager.toggleLock();
+	}
+}