Global object linting (#6857)

* add more linting

* fix linting issues

src/sql/workbench/parts/notebook/browser/cellViews/output.component.ts

@@ -10,7 +10,7 @@ import { AngularDisposable } from 'sql/base/browser/lifecycle';
 import { Event } from 'vs/base/common/event';
 import { nb } from 'azdata';
 import { ICellModel } from 'sql/workbench/parts/notebook/common/models/modelInterfaces';
-import * as outputProcessor from 'sql/workbench/parts/notebook/common/models/outputProcessor';
+import * as outputProcessor from 'sql/workbench/parts/notebook/browser/models/outputProcessor';
 import { IThemeService, ITheme } from 'vs/platform/theme/common/themeService';
 import * as DOM from 'vs/base/browser/dom';
 import { ComponentHostDirective } from 'sql/workbench/parts/dashboard/browser/core/componentHost.directive';

src/sql/workbench/parts/notebook/browser/models/mimemodel.ts

@@ -0,0 +1,99 @@
+/*-----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+import { IRenderMime } from './renderMimeInterfaces';
+import { ReadonlyJSONObject } from '../../common/models/jsonext';
+import { IThemeService } from 'vs/platform/theme/common/themeService';
+
+/**
+ * The default mime model implementation.
+ */
+export class MimeModel implements IRenderMime.IMimeModel {
+	/**
+	 * Construct a new mime model.
+	 */
+	constructor(options: MimeModel.IOptions = {}) {
+		this.trusted = !!options.trusted;
+		this._data = options.data || {};
+		this._metadata = options.metadata || {};
+		this._callback = options.callback;
+		this._themeService = options.themeService;
+	}
+
+	/**
+	 * Whether the model is trusted.
+	 */
+	readonly trusted: boolean;
+
+	/**
+	 * The data associated with the model.
+	 */
+	get data(): ReadonlyJSONObject {
+		return this._data;
+	}
+
+	/**
+	 * The metadata associated with the model.
+	 */
+	get metadata(): ReadonlyJSONObject {
+		return this._metadata;
+	}
+
+	get themeService(): IThemeService {
+		return this._themeService;
+	}
+
+	/**
+	 * Set the data associated with the model.
+	 *
+	 * #### Notes
+	 * Depending on the implementation of the mime model,
+	 * this call may or may not have deferred effects,
+	 */
+	setData(options: IRenderMime.ISetDataOptions): void {
+		this._data = options.data || this._data;
+		this._metadata = options.metadata || this._metadata;
+		this._callback(options);
+	}
+
+	private _callback: (options: IRenderMime.ISetDataOptions) => void;
+	private _data: ReadonlyJSONObject;
+	private _metadata: ReadonlyJSONObject;
+	private _themeService: IThemeService;
+}
+
+/**
+ * The namespace for MimeModel class statics.
+ */
+export namespace MimeModel {
+	/**
+	 * The options used to create a mime model.
+	 */
+	export interface IOptions {
+		/**
+		 * Whether the model is trusted.  Defaults to `false`.
+		 */
+		trusted?: boolean;
+
+		/**
+		 * A callback function for when the data changes.
+		 */
+		callback?: (options: IRenderMime.ISetDataOptions) => void;
+
+		/**
+		 * The initial mime data.
+		 */
+		data?: ReadonlyJSONObject;
+
+		/**
+		 * The initial mime metadata.
+		 */
+		metadata?: ReadonlyJSONObject;
+
+		/**
+		 * Theme service used to react to theme change events
+		 */
+		themeService?: IThemeService;
+	}
+}

src/sql/workbench/parts/notebook/browser/models/notebookInput.ts

@@ -0,0 +1,413 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the Source EULA. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IEditorModel } from 'vs/platform/editor/common/editor';
+import { EditorInput, EditorModel, ConfirmResult } from 'vs/workbench/common/editor';
+import { Emitter, Event } from 'vs/base/common/event';
+import { URI } from 'vs/base/common/uri';
+import * as resources from 'vs/base/common/resources';
+import * as azdata from 'azdata';
+
+import { IStandardKernelWithProvider, getProvidersForFileName, getStandardKernelsForProvider } from 'sql/workbench/parts/notebook/common/models/notebookUtils';
+import { INotebookService, DEFAULT_NOTEBOOK_PROVIDER, IProviderInfo } from 'sql/workbench/services/notebook/common/notebookService';
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
+import { ITextModelService } from 'vs/editor/common/services/resolverService';
+import { INotebookModel, IContentManager, NotebookContentChange } from 'sql/workbench/parts/notebook/common/models/modelInterfaces';
+import { TextFileEditorModel } from 'vs/workbench/services/textfile/common/textFileEditorModel';
+import { Range } from 'vs/editor/common/core/range';
+import { UntitledEditorModel } from 'vs/workbench/common/editor/untitledEditorModel';
+import { Schemas } from 'vs/base/common/network';
+import { ITextFileService, ISaveOptions, StateChange } from 'vs/workbench/services/textfile/common/textfiles';
+import { LocalContentManager } from 'sql/workbench/services/notebook/common/localContentManager';
+import { IConnectionProfile } from 'sql/platform/connection/common/interfaces';
+import { UntitledEditorInput } from 'vs/workbench/common/editor/untitledEditorInput';
+import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { NotebookChangeType } from 'sql/workbench/parts/notebook/common/models/contracts';
+
+export type ModeViewSaveHandler = (handle: number) => Thenable<boolean>;
+
+export class NotebookEditorModel extends EditorModel {
+	private dirty: boolean;
+	private readonly _onDidChangeDirty: Emitter<void> = this._register(new Emitter<void>());
+	constructor(public readonly notebookUri: URI,
+		private textEditorModel: TextFileEditorModel | UntitledEditorModel,
+		@INotebookService private notebookService: INotebookService,
+		@ITextFileService private textFileService: ITextFileService
+	) {
+		super();
+		this._register(this.notebookService.onNotebookEditorAdd(notebook => {
+			if (notebook.id === this.notebookUri.toString()) {
+				// Hook to content change events
+				notebook.modelReady.then(() => {
+					this._register(notebook.model.kernelChanged(e => this.updateModel()));
+					this._register(notebook.model.contentChanged(e => this.updateModel(e)));
+				}, err => undefined);
+			}
+		}));
+
+		if (this.textEditorModel instanceof UntitledEditorModel) {
+			this._register(this.textEditorModel.onDidChangeDirty(e => this.setDirty(this.textEditorModel.isDirty())));
+		} else {
+			this._register(this.textEditorModel.onDidStateChange(change => {
+				this.setDirty(this.textEditorModel.isDirty());
+				if (change === StateChange.SAVED) {
+					this.sendNotebookSerializationStateChange();
+				}
+			}));
+		}
+		this.dirty = this.textEditorModel.isDirty();
+	}
+
+	public get contentString(): string {
+		let model = this.textEditorModel.textEditorModel;
+		return model.getValue();
+	}
+
+	isDirty(): boolean {
+		return this.textEditorModel.isDirty();
+	}
+
+	public setDirty(dirty: boolean): void {
+		if (this.dirty === dirty) {
+			return;
+		}
+		this.dirty = dirty;
+		this._onDidChangeDirty.fire();
+	}
+
+	/**
+	 * UntitledEditor uses TextFileService to save data from UntitledEditorInput
+	 * Titled editor uses TextFileEditorModel to save existing notebook
+	*/
+	save(options: ISaveOptions): Promise<boolean> {
+		if (this.textEditorModel instanceof TextFileEditorModel) {
+			this.textEditorModel.save(options);
+			return Promise.resolve(true);
+		}
+		else {
+			return this.textFileService.save(this.notebookUri, options);
+		}
+	}
+
+	public updateModel(contentChange?: NotebookContentChange): void {
+		if (contentChange && contentChange.changeType === NotebookChangeType.Saved) {
+			// We send the saved events out, so ignore. Otherwise we double-count this as a change
+			// and cause the text to be reapplied
+			return;
+		}
+		if (contentChange && contentChange.changeType === NotebookChangeType.TrustChanged) {
+			// This is a serializable change (in that we permanently cache trusted state, but
+			// ironically isn't cached in the JSON contents since trust doesn't persist across machines.
+			// Request serialization so trusted state is preserved but don't update the model
+			this.sendNotebookSerializationStateChange();
+		} else {
+			// For all other changes, update the backing model with the latest contents
+			let notebookModel = this.getNotebookModel();
+			if (notebookModel && this.textEditorModel && this.textEditorModel.textEditorModel) {
+				let content = JSON.stringify(notebookModel.toJSON(), undefined, '    ');
+				let model = this.textEditorModel.textEditorModel;
+				let endLine = model.getLineCount();
+				let endCol = model.getLineMaxColumn(endLine);
+
+				this.textEditorModel.textEditorModel.applyEdits([{
+					range: new Range(1, 1, endLine, endCol),
+					text: content
+				}]);
+			}
+		}
+	}
+
+	private sendNotebookSerializationStateChange(): void {
+		let notebookModel = this.getNotebookModel();
+		if (notebookModel) {
+			this.notebookService.serializeNotebookStateChange(this.notebookUri, NotebookChangeType.Saved);
+		}
+	}
+
+	isModelCreated(): boolean {
+		return this.getNotebookModel() !== undefined;
+	}
+
+	private getNotebookModel(): INotebookModel {
+		let editor = this.notebookService.findNotebookEditor(this.notebookUri);
+		if (editor) {
+			return editor.model;
+		}
+		return undefined;
+	}
+
+	get onDidChangeDirty(): Event<void> {
+		return this._onDidChangeDirty.event;
+	}
+}
+
+export class NotebookInput extends EditorInput {
+	public static ID: string = 'workbench.editorinputs.notebookInput';
+	private _providerId: string;
+	private _providers: string[];
+	private _standardKernels: IStandardKernelWithProvider[];
+	private _connectionProfile: IConnectionProfile;
+	private _defaultKernel: azdata.nb.IKernelSpec;
+	public hasBootstrapped = false;
+	// Holds the HTML content for the editor when the editor discards this input and loads another
+	private _parentContainer: HTMLElement;
+	private readonly _layoutChanged: Emitter<void> = this._register(new Emitter<void>());
+	private _model: NotebookEditorModel;
+	private _untitledEditorModel: UntitledEditorModel;
+	private _contentManager: IContentManager;
+	private _providersLoaded: Promise<void>;
+	private _dirtyListener: IDisposable;
+	private _notebookEditorOpenedTimestamp: number;
+
+	constructor(private _title: string,
+		private resource: URI,
+		private _textInput: UntitledEditorInput,
+		@ITextModelService private textModelService: ITextModelService,
+		@IInstantiationService private instantiationService: IInstantiationService,
+		@INotebookService private notebookService: INotebookService,
+		@IExtensionService private extensionService: IExtensionService
+	) {
+		super();
+		this.resource = resource;
+		this._standardKernels = [];
+		this._providersLoaded = this.assignProviders();
+		this._notebookEditorOpenedTimestamp = Date.now();
+		if (this._textInput) {
+			this.hookDirtyListener(this._textInput.onDidChangeDirty, () => this._onDidChangeDirty.fire());
+		}
+	}
+
+	public get textInput(): UntitledEditorInput {
+		return this._textInput;
+	}
+
+	public confirmSave(): Promise<ConfirmResult> {
+		return this._textInput.confirmSave();
+	}
+
+	public revert(): Promise<boolean> {
+		return this._textInput.revert();
+	}
+
+	public get notebookUri(): URI {
+		return this.resource;
+	}
+
+	public get contentManager(): IContentManager {
+		if (!this._contentManager) {
+			this._contentManager = this.instantiationService.createInstance(NotebookEditorContentManager, this);
+		}
+		return this._contentManager;
+	}
+
+	public getName(): string {
+		if (!this._title) {
+			this._title = resources.basenameOrAuthority(this.resource);
+		}
+		return this._title;
+	}
+
+	public async getProviderInfo(): Promise<IProviderInfo> {
+		await this._providersLoaded;
+		return {
+			providerId: this._providerId ? this._providerId : DEFAULT_NOTEBOOK_PROVIDER,
+			providers: this._providers ? this._providers : [DEFAULT_NOTEBOOK_PROVIDER]
+		};
+	}
+
+	public set connectionProfile(value: IConnectionProfile) {
+		this._connectionProfile = value;
+	}
+
+	public get connectionProfile(): IConnectionProfile {
+		return this._connectionProfile;
+	}
+
+	public get standardKernels(): IStandardKernelWithProvider[] {
+		return this._standardKernels;
+	}
+
+	public save(): Promise<boolean> {
+		let options: ISaveOptions = { force: false };
+		return this._model.save(options);
+	}
+
+	public set standardKernels(value: IStandardKernelWithProvider[]) {
+		value.forEach(kernel => {
+			this._standardKernels.push({
+				connectionProviderIds: kernel.connectionProviderIds,
+				name: kernel.name,
+				displayName: kernel.displayName,
+				notebookProvider: kernel.notebookProvider
+			});
+		});
+	}
+
+	public get defaultKernel(): azdata.nb.IKernelSpec {
+		return this._defaultKernel;
+	}
+
+	public set defaultKernel(kernel: azdata.nb.IKernelSpec) {
+		this._defaultKernel = kernel;
+	}
+
+	get layoutChanged(): Event<void> {
+		return this._layoutChanged.event;
+	}
+
+	public get editorOpenedTimestamp(): number {
+		return this._notebookEditorOpenedTimestamp;
+	}
+
+	doChangeLayout(): any {
+		this._layoutChanged.fire();
+	}
+
+	public getTypeId(): string {
+		return NotebookInput.ID;
+	}
+
+	getResource(): URI {
+		return this.resource;
+	}
+
+	public get untitledEditorModel(): UntitledEditorModel {
+		return this._untitledEditorModel;
+	}
+
+	public set untitledEditorModel(value: UntitledEditorModel) {
+		this._untitledEditorModel = value;
+	}
+
+	async resolve(): Promise<NotebookEditorModel> {
+		if (this._model) {
+			return Promise.resolve(this._model);
+		} else {
+			let textOrUntitledEditorModel: UntitledEditorModel | IEditorModel;
+			if (this.resource.scheme === Schemas.untitled) {
+				textOrUntitledEditorModel = this._untitledEditorModel ? this._untitledEditorModel : await this._textInput.resolve();
+			}
+			else {
+				const textEditorModelReference = await this.textModelService.createModelReference(this.resource);
+				textOrUntitledEditorModel = await textEditorModelReference.object.load();
+			}
+			this._model = this.instantiationService.createInstance(NotebookEditorModel, this.resource, textOrUntitledEditorModel);
+			this.hookDirtyListener(this._model.onDidChangeDirty, () => this._onDidChangeDirty.fire());
+			return this._model;
+		}
+	}
+
+	private hookDirtyListener(dirtyEvent: Event<void>, listener: (e: any) => void): void {
+		let disposable = dirtyEvent(listener);
+		if (this._dirtyListener) {
+			this._dirtyListener.dispose();
+		} else {
+			this._register({
+				dispose: () => {
+					if (this._dirtyListener) {
+						this._dirtyListener.dispose();
+					}
+				}
+			});
+		}
+		this._dirtyListener = disposable;
+	}
+
+	private async assignProviders(): Promise<void> {
+		await this.extensionService.whenInstalledExtensionsRegistered();
+		let providerIds: string[] = getProvidersForFileName(this._title, this.notebookService);
+		if (providerIds && providerIds.length > 0) {
+			this._providerId = providerIds.filter(provider => provider !== DEFAULT_NOTEBOOK_PROVIDER)[0];
+			this._providers = providerIds;
+			this._standardKernels = [];
+			this._providers.forEach(provider => {
+				let standardKernels = getStandardKernelsForProvider(provider, this.notebookService);
+				this._standardKernels.push(...standardKernels);
+			});
+		}
+	}
+
+	public dispose(): void {
+		this._disposeContainer();
+		super.dispose();
+	}
+
+	private _disposeContainer() {
+		if (!this._parentContainer) {
+			return;
+		}
+
+		let parentNode = this._parentContainer.parentNode;
+		if (parentNode) {
+			parentNode.removeChild(this._parentContainer);
+			this._parentContainer = null;
+		}
+	}
+
+	set container(container: HTMLElement) {
+		this._disposeContainer();
+		this._parentContainer = container;
+	}
+
+	get container(): HTMLElement {
+		return this._parentContainer;
+	}
+
+	/**
+	 * An editor that is dirty will be asked to be saved once it closes.
+	 */
+	isDirty(): boolean {
+		if (this._model) {
+			return this._model.isDirty();
+		} else if (this._textInput) {
+			return this._textInput.isDirty();
+		}
+		return false;
+	}
+
+	/**
+	 * Sets active editor with dirty value.
+	 * @param isDirty boolean value to set editor dirty
+	 */
+	setDirty(isDirty: boolean): void {
+		if (this._model) {
+			this._model.setDirty(isDirty);
+		}
+	}
+
+	updateModel(): void {
+		this._model.updateModel();
+	}
+
+	public matches(otherInput: any): boolean {
+		if (super.matches(otherInput) === true) {
+			return true;
+		}
+
+		if (otherInput instanceof NotebookInput) {
+			const otherNotebookEditorInput = <NotebookInput>otherInput;
+
+			// Compare by resource
+			return otherNotebookEditorInput.notebookUri.toString() === this.notebookUri.toString();
+		}
+		return false;
+	}
+}
+
+class NotebookEditorContentManager implements IContentManager {
+	constructor(
+		private notebookInput: NotebookInput,
+		@IInstantiationService private readonly instantiationService: IInstantiationService) {
+	}
+
+	async loadContent(): Promise<azdata.nb.INotebookContents> {
+		let notebookEditorModel = await this.notebookInput.resolve();
+		let contentManager = this.instantiationService.createInstance(LocalContentManager);
+		let contents = await contentManager.loadFromContentString(notebookEditorModel.contentString);
+		return contents;
+	}
+
+}

src/sql/workbench/parts/notebook/browser/models/outputProcessor.ts

@@ -0,0 +1,111 @@
+
+/*-----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+
+import { JSONObject, isPrimitive } from '../../common/models/jsonext';
+import { MimeModel } from './mimemodel';
+import { nbformat } from '../../common/models/nbformat';
+import { nb } from 'azdata';
+
+/**
+ * A multiline string.
+ */
+export type MultilineString = string | string[];
+
+/**
+ * A mime-type keyed dictionary of data.
+ */
+export interface IMimeBundle extends JSONObject {
+	[key: string]: MultilineString | JSONObject;
+}
+
+/**
+ * Get the data from a notebook output.
+ */
+export function getData(output: nb.ICellOutput): JSONObject {
+	let bundle: IMimeBundle = {};
+	if (
+		nbformat.isExecuteResult(output) ||
+		nbformat.isDisplayData(output) ||
+		nbformat.isDisplayUpdate(output)
+	) {
+		bundle = (output as nbformat.IExecuteResult).data;
+	} else if (nbformat.isStream(output)) {
+		if (output.name === 'stderr') {
+			bundle['application/vnd.jupyter.stderr'] = output.text;
+		} else {
+			bundle['application/vnd.jupyter.stdout'] = output.text;
+		}
+	} else if (nbformat.isError(output)) {
+		let traceback = output.traceback ? output.traceback.join('\n') : undefined;
+		bundle['application/vnd.jupyter.stderr'] = undefined;
+		if (traceback && traceback !== '') {
+			bundle['application/vnd.jupyter.stderr'] = traceback;
+		} else if (output.evalue) {
+			bundle['application/vnd.jupyter.stderr'] = output.ename && output.ename !== '' ? `${output.ename}: ${output.evalue}` : `${output.evalue}`;
+		}
+	}
+	return convertBundle(bundle);
+}
+
+/**
+ * Get the metadata from an output message.
+ */
+export function getMetadata(output: nbformat.IOutput): JSONObject {
+	let value: JSONObject = Object.create(null);
+	if (nbformat.isExecuteResult(output) || nbformat.isDisplayData(output)) {
+		for (let key in output.metadata) {
+			value[key] = extract(output.metadata, key);
+		}
+	}
+	return value;
+}
+
+/**
+ * Get the bundle options given output model options.
+ */
+export function getBundleOptions(options: IOutputModelOptions): MimeModel.IOptions {
+	let data = getData(options.value);
+	let metadata = getMetadata(options.value);
+	let trusted = !!options.trusted;
+	return { data, metadata, trusted };
+}
+
+/**
+ * Extract a value from a JSONObject.
+ */
+export function extract(value: JSONObject, key: string): {} {
+	let item = value[key];
+	if (isPrimitive(item)) {
+		return item;
+	}
+	return JSON.parse(JSON.stringify(item));
+}
+
+/**
+ * Convert a mime bundle to mime data.
+ */
+function convertBundle(bundle: nbformat.IMimeBundle): JSONObject {
+	let map: JSONObject = Object.create(null);
+	for (let mimeType in bundle) {
+		map[mimeType] = extract(bundle, mimeType);
+	}
+	return map;
+}
+
+/**
+ * The options used to create a notebook output model.
+ */
+export interface IOutputModelOptions {
+	/**
+	 * The raw output value.
+	 */
+	value: nbformat.IOutput;
+
+	/**
+	 * Whether the output is trusted.  The default is false.
+	 */
+	trusted?: boolean;
+}

src/sql/workbench/parts/notebook/browser/models/renderMimeInterfaces.ts

@@ -0,0 +1,220 @@
+
+/*-----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+import { ReadonlyJSONObject } from '../../common/models/jsonext';
+import { IThemeService } from 'vs/platform/theme/common/themeService';
+
+/**
+ * A namespace for rendermime associated interfaces.
+ */
+export namespace IRenderMime {
+	/**
+	 * A model for mime data.
+	 */
+	export interface IMimeModel {
+		/**
+		 * Whether the data in the model is trusted.
+		 */
+		readonly trusted: boolean;
+
+		/**
+		 * The data associated with the model.
+		 */
+		readonly data: ReadonlyJSONObject;
+
+		/**
+		 * The metadata associated with the model.
+		 */
+		readonly metadata: ReadonlyJSONObject;
+
+		/**
+		 * Set the data associated with the model.
+		 *
+		 * #### Notes
+		 * Calling this function may trigger an asynchronous operation
+		 * that could cause the renderer to be rendered with a new model
+		 * containing the new data.
+		 */
+		setData(options: ISetDataOptions): void;
+
+		/**
+		 * Theme service used to react to theme change events
+		 */
+		readonly themeService: IThemeService;
+	}
+
+	/**
+	 * The options used to update a mime model.
+	 */
+	export interface ISetDataOptions {
+		/**
+		 * The new data object.
+		 */
+		data?: ReadonlyJSONObject;
+
+		/**
+		 * The new metadata object.
+		 */
+		metadata?: ReadonlyJSONObject;
+	}
+
+	/**
+	 * A widget which displays the contents of a mime model.
+	 */
+	export interface IRenderer {
+		/**
+		 * Render a mime model.
+		 *
+		 * @param model - The mime model to render.
+		 *
+		 * @returns A promise which resolves when rendering is complete.
+		 *
+		 * #### Notes
+		 * This method may be called multiple times during the lifetime
+		 * of the widget to update it if and when new data is available.
+		 */
+		renderModel(model: IRenderMime.IMimeModel): Promise<void>;
+
+		/**
+		 * Node to be updated by the renderer
+		 */
+		node: HTMLElement;
+	}
+
+	/**
+	 * The interface for a renderer factory.
+	 */
+	export interface IRendererFactory {
+		/**
+		 * Whether the factory is a "safe" factory.
+		 *
+		 * #### Notes
+		 * A "safe" factory produces renderer widgets which can render
+		 * untrusted model data in a usable way. *All* renderers must
+		 * handle untrusted data safely, but some may simply failover
+		 * with a "Run cell to view output" message. A "safe" renderer
+		 * is an indication that its sanitized output will be useful.
+		 */
+		readonly safe: boolean;
+
+		/**
+		 * The mime types handled by this factory.
+		 */
+		readonly mimeTypes: ReadonlyArray<string>;
+
+		/**
+		 * The default rank of the factory.  If not given, defaults to 100.
+		 */
+		readonly defaultRank?: number;
+
+		/**
+		 * Create a renderer which displays the mime data.
+		 *
+		 * @param options - The options used to render the data.
+		 */
+		createRenderer(options: IRendererOptions): IRenderer;
+	}
+
+	/**
+	 * The options used to create a renderer.
+	 */
+	export interface IRendererOptions {
+		/**
+		 * The preferred mimeType to render.
+		 */
+		mimeType: string;
+
+		/**
+		 * The html sanitizer.
+		 */
+		sanitizer: ISanitizer;
+
+		/**
+		 * An optional url resolver.
+		 */
+		resolver?: IResolver | null;
+
+		/**
+		 * An optional link handler.
+		 */
+		linkHandler?: ILinkHandler | null;
+
+		/**
+		 * The LaTeX typesetter.
+		 */
+		latexTypesetter?: ILatexTypesetter | null;
+	}
+
+	/**
+	 * An object that handles html sanitization.
+	 */
+	export interface ISanitizer {
+		/**
+		 * Sanitize an HTML string.
+		 */
+		sanitize(dirty: string): string;
+	}
+
+	/**
+	 * An object that handles links on a node.
+	 */
+	export interface ILinkHandler {
+		/**
+		 * Add the link handler to the node.
+		 *
+		 * @param node: the node for which to handle the link.
+		 *
+		 * @param path: the path to open when the link is clicked.
+		 *
+		 * @param id: an optional element id to scroll to when the path is opened.
+		 */
+		handleLink(node: HTMLElement, path: string, id?: string): void;
+	}
+
+	/**
+	 * An object that resolves relative URLs.
+	 */
+	export interface IResolver {
+		/**
+		 * Resolve a relative url to a correct server path.
+		 */
+		resolveUrl(url: string): Promise<string>;
+
+		/**
+		 * Get the download url of a given absolute server path.
+		 */
+		getDownloadUrl(path: string): Promise<string>;
+
+		/**
+		 * Whether the URL should be handled by the resolver
+		 * or not.
+		 *
+		 * #### Notes
+		 * This is similar to the `isLocal` check in `URLExt`,
+		 * but can also perform additional checks on whether the
+		 * resolver should handle a given URL.
+		 */
+		isLocal?: (url: string) => boolean;
+	}
+
+	/**
+	 * The interface for a LaTeX typesetter.
+	 */
+	export interface ILatexTypesetter {
+		/**
+		 * Typeset a DOM element.
+		 *
+		 * @param element - the DOM element to typeset. The typesetting may
+		 *   happen synchronously or asynchronously.
+		 *
+		 * #### Notes
+		 * The application-wide rendermime object has a settable
+		 * `latexTypesetter` property which is used wherever LaTeX
+		 * typesetting is required. Extensions wishing to provide their
+		 * own typesetter may replace that on the global `lab.rendermime`.
+		 */
+		typeset(element: HTMLElement): void;
+	}
+}

src/sql/workbench/parts/notebook/browser/notebook.common.contribution.ts

@@ -8,7 +8,7 @@ import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors';
 import { IWorkbenchActionRegistry, Extensions } from 'vs/workbench/common/actions';
 import { SyncActionDescriptor, registerAction } from 'vs/platform/actions/common/actions';
 
-import { NotebookInput } from 'sql/workbench/parts/notebook/common/models/notebookInput';
+import { NotebookInput } from 'sql/workbench/parts/notebook/browser/models/notebookInput';
 import { NotebookEditor } from 'sql/workbench/parts/notebook/browser/notebookEditor';
 import { NewNotebookAction } from 'sql/workbench/parts/notebook/browser/notebookActions';
 import { KeyMod } from 'vs/editor/common/standalone/standaloneBase';

src/sql/workbench/parts/notebook/browser/notebookEditor.ts

@@ -11,7 +11,7 @@ import { bootstrapAngular } from 'sql/platform/bootstrap/browser/bootstrapServic
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 
 import { CancellationToken } from 'vs/base/common/cancellation';
-import { NotebookInput } from 'sql/workbench/parts/notebook/common/models/notebookInput';
+import { NotebookInput } from 'sql/workbench/parts/notebook/browser/models/notebookInput';
 import { NotebookModule } from 'sql/workbench/parts/notebook/browser/notebook.module';
 import { NOTEBOOK_SELECTOR } from 'sql/workbench/parts/notebook/browser/notebook.component';
 import { INotebookParams } from 'sql/workbench/services/notebook/common/notebookService';

src/sql/workbench/parts/notebook/browser/outputs/factories.ts

@@ -4,7 +4,7 @@
 |----------------------------------------------------------------------------*/
 
 import * as widgets from './widgets';
-import { IRenderMime } from '../../common/models/renderMimeInterfaces';
+import { IRenderMime } from '../models/renderMimeInterfaces';
 
 /**
  * A mime renderer factory for raw html.
@@ -92,4 +92,3 @@ export const standardRendererFactories: ReadonlyArray<IRenderMime.IRendererFacto
 	textRendererFactory,
 	dataResourceRendererFactory
 ];
-

src/sql/workbench/parts/notebook/browser/outputs/gridOutput.component.ts

@@ -25,7 +25,7 @@ import { IAction } from 'vs/base/common/actions';
 import { AngularDisposable } from 'sql/base/browser/lifecycle';
 import { IMimeComponent } from 'sql/workbench/parts/notebook/browser/outputs/mimeRegistry';
 import { ICellModel } from 'sql/workbench/parts/notebook/common/models/modelInterfaces';
-import { MimeModel } from 'sql/workbench/parts/notebook/common/models/mimemodel';
+import { MimeModel } from 'sql/workbench/parts/notebook/browser/models/mimemodel';
 import { GridTableState } from 'sql/workbench/parts/query/common/gridPanelState';
 import { GridTableBase } from 'sql/workbench/parts/query/browser/gridPanel';
 import { getErrorMessage } from 'vs/base/common/errors';

src/sql/workbench/parts/notebook/browser/outputs/mimeRegistry.ts

@@ -6,7 +6,7 @@ import { Type } from '@angular/core';
 
 import * as platform from 'vs/platform/registry/common/platform';
 import { ReadonlyJSONObject } from 'sql/workbench/parts/notebook/common/models/jsonext';
-import { MimeModel } from 'sql/workbench/parts/notebook/common/models/mimemodel';
+import { MimeModel } from 'sql/workbench/parts/notebook/browser/models/mimemodel';
 import * as types from 'vs/base/common/types';
 import { ICellModel } from 'sql/workbench/parts/notebook/common/models/modelInterfaces';
 
@@ -191,4 +191,4 @@ function sortedTypes(map: RankMap): string[] {
 		}
 		return p1.id - p2.id;
 	});
-}
+}

src/sql/workbench/parts/notebook/browser/outputs/mimeRenderer.component.ts

@@ -6,7 +6,7 @@
 import { IMimeComponent } from 'sql/workbench/parts/notebook/browser/outputs/mimeRegistry';
 import { AngularDisposable } from 'sql/base/browser/lifecycle';
 import { ElementRef, forwardRef, Inject, Component, OnInit, Input } from '@angular/core';
-import { MimeModel } from 'sql/workbench/parts/notebook/common/models/mimemodel';
+import { MimeModel } from 'sql/workbench/parts/notebook/browser/models/mimemodel';
 import { INotebookService } from 'sql/workbench/services/notebook/common/notebookService';
 import { RenderMimeRegistry } from 'sql/workbench/parts/notebook/browser/outputs/registry';
 import { localize } from 'vs/nls';

src/sql/workbench/parts/notebook/browser/outputs/plotlyOutput.component.ts

@@ -11,7 +11,7 @@ import * as types from 'vs/base/common/types';
 import { AngularDisposable } from 'sql/base/browser/lifecycle';
 import { IMimeComponent } from 'sql/workbench/parts/notebook/browser/outputs/mimeRegistry';
 import { ICellModel } from 'sql/workbench/parts/notebook/common/models/modelInterfaces';
-import { MimeModel } from 'sql/workbench/parts/notebook/common/models/mimemodel';
+import { MimeModel } from 'sql/workbench/parts/notebook/browser/models/mimemodel';
 import { getErrorMessage } from 'vs/base/common/errors';
 
 type ObjectType = object;

src/sql/workbench/parts/notebook/browser/outputs/registry.ts

@@ -3,8 +3,8 @@
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
-import { IRenderMime } from '../../common/models/renderMimeInterfaces';
-import { MimeModel } from '../../common/models/mimemodel';
+import { IRenderMime } from '../models/renderMimeInterfaces';
+import { MimeModel } from '../models/mimemodel';
 import { ReadonlyJSONObject } from '../../common/models/jsonext';
 import { defaultSanitizer } from './sanitizer';
 

src/sql/workbench/parts/notebook/browser/outputs/renderers.ts

@@ -4,7 +4,7 @@
 |----------------------------------------------------------------------------*/
 
 import { default as AnsiUp } from 'ansi_up';
-import { IRenderMime } from '../../common/models/renderMimeInterfaces';
+import { IRenderMime } from '../models/renderMimeInterfaces';
 import { URLExt } from '../../common/models/url';
 import { URI } from 'vs/base/common/uri';
 

src/sql/workbench/parts/notebook/browser/outputs/widgets.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as renderers from './renderers';
-import { IRenderMime } from '../../common/models/renderMimeInterfaces';
+import { IRenderMime } from '../models/renderMimeInterfaces';
 import { ReadonlyJSONObject } from '../../common/models/jsonext';
 import * as tableRenderers from 'sql/workbench/parts/notebook/browser/outputs/tableRenderers';