Merge from vscode 4d91d96e5e121b38d33508cdef17868bab255eae

2026-02-16 10:58:30 -05:00 · 2020-06-18 04:32:54 +00:00
parent a971aee5bd
commit 5e7071e466
1002 changed files with 24201 additions and 13193 deletions
--- a/src/vs/workbench/contrib/notebook/browser/notebookServiceImpl.ts
+++ b/src/vs/workbench/contrib/notebook/browser/notebookServiceImpl.ts
@@ -5,13 +5,12 @@

 import * as nls from 'vs/nls';
 import { Disposable, IDisposable, DisposableStore } from 'vs/base/common/lifecycle';
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { URI, UriComponents } from 'vs/base/common/uri';
-import { notebookProviderExtensionPoint, notebookRendererExtensionPoint } from 'vs/workbench/contrib/notebook/browser/extensionPoint';
-import { NotebookProviderInfo } from 'vs/workbench/contrib/notebook/common/notebookProvider';
+import { notebookProviderExtensionPoint, notebookRendererExtensionPoint, INotebookEditorContribution } from 'vs/workbench/contrib/notebook/browser/extensionPoint';
+import { NotebookProviderInfo, NotebookEditorDescriptor } from 'vs/workbench/contrib/notebook/common/notebookProvider';
 import { NotebookExtensionDescription } from 'vs/workbench/api/common/extHost.protocol';
 import { Emitter, Event } from 'vs/base/common/event';
-import { INotebookTextModel, INotebookRendererInfo, NotebookDocumentMetadata, ICellDto2, INotebookKernelInfo, CellOutputKind, ITransformedDisplayOutputDto, IDisplayOutput, ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER, NOTEBOOK_DISPLAY_ORDER, sortMimeTypes, IOrderedMimeType, mimeTypeSupportedByCore, IOutputRenderRequestOutputInfo, IOutputRenderRequestCellInfo, NotebookCellOutputsSplice, ICellEditOperation, CellEditType, ICellInsertEdit, IOutputRenderResponse, IProcessedOutput, BUILTIN_RENDERER_ID } from 'vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookTextModel, INotebookRendererInfo, NotebookDocumentMetadata, ICellDto2, INotebookKernelInfo, CellOutputKind, ITransformedDisplayOutputDto, IDisplayOutput, ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER, NOTEBOOK_DISPLAY_ORDER, sortMimeTypes, IOrderedMimeType, mimeTypeSupportedByCore, IOutputRenderRequestOutputInfo, IOutputRenderRequestCellInfo, NotebookCellOutputsSplice, ICellEditOperation, CellEditType, ICellInsertEdit, IOutputRenderResponse, IProcessedOutput, BUILTIN_RENDERER_ID, NotebookEditorPriority } from 'vs/workbench/contrib/notebook/common/notebookCommon';
 import { IExtensionService } from 'vs/workbench/services/extensions/common/extensions';
 import { NotebookOutputRendererInfo } from 'vs/workbench/contrib/notebook/common/notebookOutputRenderer';
 import { Iterable } from 'vs/base/common/iterator';
@@ -19,42 +18,95 @@ import { NotebookTextModel } from 'vs/workbench/contrib/notebook/common/model/no
 import { CancellationToken } from 'vs/base/common/cancellation';
 import { IEditorService, ICustomEditorViewTypesHandler, ICustomEditorInfo } from 'vs/workbench/services/editor/common/editorService';
 import { NotebookCellTextModel } from 'vs/workbench/contrib/notebook/common/model/notebookCellTextModel';
-import { NotebookEditorModelManager } from 'vs/workbench/contrib/notebook/common/notebookEditorModel';
 import { INotebookService, IMainNotebookController } from 'vs/workbench/contrib/notebook/common/notebookService';
 import * as glob from 'vs/base/common/glob';
-import { basename } from 'vs/base/common/resources';
+import { basename } from 'vs/base/common/path';
 import { INotebookEditor } from 'vs/workbench/contrib/notebook/browser/notebookBrowser';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IAccessibilityService } from 'vs/platform/accessibility/common/accessibility';
+import { Memento } from 'vs/workbench/common/memento';
+import { StorageScope, IStorageService } from 'vs/platform/storage/common/storage';
+import { IExtensionPointUser } from 'vs/workbench/services/extensions/common/extensionsRegistry';
+import { generateUuid } from 'vs/base/common/uuid';

 function MODEL_ID(resource: URI): string {
 	return resource.toString();
 }

-export class NotebookProviderInfoStore {
-	private readonly contributedEditors = new Map<string, NotebookProviderInfo>();
+export class NotebookProviderInfoStore implements IDisposable {
+	private static readonly CUSTOM_EDITORS_STORAGE_ID = 'notebookEditors';
+	private static readonly CUSTOM_EDITORS_ENTRY_ID = 'editors';
+
+	private readonly _memento: Memento;
+	constructor(storageService: IStorageService) {
+		this._memento = new Memento(NotebookProviderInfoStore.CUSTOM_EDITORS_STORAGE_ID, storageService);
+
+		const mementoObject = this._memento.getMemento(StorageScope.GLOBAL);
+		for (const info of (mementoObject[NotebookProviderInfoStore.CUSTOM_EDITORS_ENTRY_ID] || []) as NotebookEditorDescriptor[]) {
+			this.add(new NotebookProviderInfo(info));
+		}
+	}
+
+	update(extensions: readonly IExtensionPointUser<INotebookEditorContribution[]>[]) {
+		this.clear();
+
+		for (const extension of extensions) {
+			for (const notebookContribution of extension.value) {
+				this.add(new NotebookProviderInfo({
+					id: notebookContribution.viewType,
+					displayName: notebookContribution.displayName,
+					selector: notebookContribution.selector || [],
+					priority: this._convertPriority(notebookContribution.priority),
+					providerDisplayName: extension.description.isBuiltin ? nls.localize('builtinProviderDisplayName', "Built-in") : extension.description.displayName || extension.description.identifier.value,
+					providerExtensionLocation: extension.description.extensionLocation
+				}));
+			}
+		}
+
+		const mementoObject = this._memento.getMemento(StorageScope.GLOBAL);
+		mementoObject[NotebookProviderInfoStore.CUSTOM_EDITORS_ENTRY_ID] = Array.from(this._contributedEditors.values());
+		this._memento.saveMemento();
+	}
+
+	private _convertPriority(priority?: string) {
+		if (!priority) {
+			return NotebookEditorPriority.default;
+		}
+
+		if (priority === NotebookEditorPriority.default) {
+			return NotebookEditorPriority.default;
+		}
+
+		return NotebookEditorPriority.option;
+
+	}
+
+	dispose(): void {
+	}
+
+	private readonly _contributedEditors = new Map<string, NotebookProviderInfo>();

 	clear() {
-		this.contributedEditors.clear();
+		this._contributedEditors.clear();
 	}

 	get(viewType: string): NotebookProviderInfo | undefined {
-		return this.contributedEditors.get(viewType);
+		return this._contributedEditors.get(viewType);
 	}

 	add(info: NotebookProviderInfo): void {
-		if (this.contributedEditors.has(info.id)) {
+		if (this._contributedEditors.has(info.id)) {
 			return;
 		}
-		this.contributedEditors.set(info.id, info);
+		this._contributedEditors.set(info.id, info);
 	}

 	getContributedNotebook(resource: URI): readonly NotebookProviderInfo[] {
-		return [...Iterable.filter(this.contributedEditors.values(), customEditor => customEditor.matches(resource))];
+		return [...Iterable.filter(this._contributedEditors.values(), customEditor => resource.scheme === 'untitled' || customEditor.matches(resource))];
 	}

 	public [Symbol.iterator](): Iterator<NotebookProviderInfo> {
-		return this.contributedEditors.values();
+		return this._contributedEditors.values();
 	}
 }

@@ -97,22 +149,26 @@ class ModelData implements IDisposable {
 	}
 }
 export class NotebookService extends Disposable implements INotebookService, ICustomEditorViewTypesHandler {
-	_serviceBrand: undefined;
+	declare readonly _serviceBrand: undefined;
 	private readonly _notebookProviders = new Map<string, { controller: IMainNotebookController, extensionData: NotebookExtensionDescription }>();
 	private readonly _notebookRenderers = new Map<string, INotebookRendererInfo>();
 	private readonly _notebookKernels = new Map<string, INotebookKernelInfo>();
-	notebookProviderInfoStore: NotebookProviderInfoStore = new NotebookProviderInfoStore();
+	notebookProviderInfoStore: NotebookProviderInfoStore;
 	notebookRenderersInfoStore: NotebookOutputRendererInfoStore = new NotebookOutputRendererInfoStore();
-	private readonly _models: { [modelId: string]: ModelData; };
+	private readonly _models = new Map<string, ModelData>();
 	private _onDidChangeActiveEditor = new Emitter<string | null>();
 	onDidChangeActiveEditor: Event<string | null> = this._onDidChangeActiveEditor.event;
 	private _onDidChangeVisibleEditors = new Emitter<string[]>();
 	onDidChangeVisibleEditors: Event<string[]> = this._onDidChangeVisibleEditors.event;
 	private readonly _onNotebookEditorAdd: Emitter<INotebookEditor> = this._register(new Emitter<INotebookEditor>());
 	public readonly onNotebookEditorAdd: Event<INotebookEditor> = this._onNotebookEditorAdd.event;
-	private readonly _onNotebookEditorRemove: Emitter<INotebookEditor> = this._register(new Emitter<INotebookEditor>());
-	public readonly onNotebookEditorRemove: Event<INotebookEditor> = this._onNotebookEditorRemove.event;
-	private readonly _notebookEditors: { [editorId: string]: INotebookEditor; };
+	private readonly _onNotebookEditorsRemove: Emitter<INotebookEditor[]> = this._register(new Emitter<INotebookEditor[]>());
+	public readonly onNotebookEditorsRemove: Event<INotebookEditor[]> = this._onNotebookEditorsRemove.event;
+	private readonly _onNotebookDocumentAdd: Emitter<URI[]> = this._register(new Emitter<URI[]>());
+	public readonly onNotebookDocumentAdd: Event<URI[]> = this._onNotebookDocumentAdd.event;
+	private readonly _onNotebookDocumentRemove: Emitter<URI[]> = this._register(new Emitter<URI[]>());
+	public readonly onNotebookDocumentRemove: Event<URI[]> = this._onNotebookDocumentRemove.event;
+	private readonly _notebookEditors = new Map<string, INotebookEditor>();

 	private readonly _onDidChangeViewTypes = new Emitter<void>();
 	onDidChangeViewTypes: Event<void> = this._onDidChangeViewTypes.event;
@@ -121,36 +177,23 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 	onDidChangeKernels: Event<void> = this._onDidChangeKernels.event;
 	private cutItems: NotebookCellTextModel[] | undefined;

-	modelManager: NotebookEditorModelManager;
 	private _displayOrder: { userOrder: string[], defaultOrder: string[] } = Object.create(null);

 	constructor(
-		@IExtensionService private readonly extensionService: IExtensionService,
-		@IEditorService private readonly editorService: IEditorService,
-		@IConfigurationService private readonly configurationService: IConfigurationService,
-		@IAccessibilityService private readonly accessibilityService: IAccessibilityService,
-		@IInstantiationService private readonly instantiationService: IInstantiationService
+		@IExtensionService private readonly _extensionService: IExtensionService,
+		@IEditorService private readonly _editorService: IEditorService,
+		@IConfigurationService private readonly _configurationService: IConfigurationService,
+		@IAccessibilityService private readonly _accessibilityService: IAccessibilityService,
+		@IStorageService private readonly _storageService: IStorageService
 	) {
 		super();

-		this._models = {};
-		this._notebookEditors = Object.create(null);
-		this.modelManager = this.instantiationService.createInstance(NotebookEditorModelManager);
+		this.notebookProviderInfoStore = new NotebookProviderInfoStore(this._storageService);
+		this._register(this.notebookProviderInfoStore);

 		notebookProviderExtensionPoint.setHandler((extensions) => {
-			this.notebookProviderInfoStore.clear();
+			this.notebookProviderInfoStore.update(extensions);

-			for (const extension of extensions) {
-				for (const notebookContribution of extension.value) {
-					this.notebookProviderInfoStore.add(new NotebookProviderInfo({
-						id: notebookContribution.viewType,
-						displayName: notebookContribution.displayName,
-						selector: notebookContribution.selector || [],
-						providerDisplayName: extension.description.isBuiltin ? nls.localize('builtinProviderDisplayName', "Built-in") : extension.description.displayName || extension.description.identifier.value,
-						providerExtensionLocation: extension.description.extensionLocation
-					}));
-				}
-			}
 			// console.log(this._notebookProviderInfoStore);
 		});

@@ -170,25 +213,25 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 			// console.log(this.notebookRenderersInfoStore);
 		});

-		this.editorService.registerCustomEditorViewTypesHandler('Notebook', this);
+		this._editorService.registerCustomEditorViewTypesHandler('Notebook', this);

 		const updateOrder = () => {
-			let userOrder = this.configurationService.getValue<string[]>('notebook.displayOrder');
+			let userOrder = this._configurationService.getValue<string[]>('notebook.displayOrder');
 			this._displayOrder = {
-				defaultOrder: this.accessibilityService.isScreenReaderOptimized() ? ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER : NOTEBOOK_DISPLAY_ORDER,
+				defaultOrder: this._accessibilityService.isScreenReaderOptimized() ? ACCESSIBLE_NOTEBOOK_DISPLAY_ORDER : NOTEBOOK_DISPLAY_ORDER,
 				userOrder: userOrder
 			};
 		};

 		updateOrder();

-		this._register(this.configurationService.onDidChangeConfiguration(e => {
+		this._register(this._configurationService.onDidChangeConfiguration(e => {
 			if (e.affectedKeys.indexOf('notebook.displayOrder') >= 0) {
 				updateOrder();
 			}
 		}));

-		this._register(this.accessibilityService.onDidChangeScreenReaderOptimized(() => {
+		this._register(this._accessibilityService.onDidChangeScreenReaderOptimized(() => {
 			updateOrder();
 		}));
 	}
@@ -203,8 +246,11 @@ export class NotebookService extends Disposable implements INotebookService, ICu

 	async canResolve(viewType: string): Promise<boolean> {
 		if (!this._notebookProviders.has(viewType)) {
+			await this._extensionService.whenInstalledExtensionsRegistered();
+			// notebook providers/kernels/renderers might use `*` as activation event.
+			await this._extensionService.activateByEvent(`*`);
 			// this awaits full activation of all matching extensions
-			await this.extensionService.activateByEvent(`onNotebookEditor:${viewType}`);
+			await this._extensionService.activateByEvent(`onNotebookEditor:${viewType}`);
 		}
 		return this._notebookProviders.has(viewType);
 	}
@@ -270,7 +316,7 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 	private _notebookKernelMatch(resource: URI, selectors: (string | glob.IRelativePattern)[]): boolean {
 		for (let i = 0; i < selectors.length; i++) {
 			const pattern = typeof selectors[i] !== 'string' ? selectors[i] : selectors[i].toString();
-			if (glob.match(pattern, basename(resource).toLowerCase())) {
+			if (glob.match(pattern, basename(resource.fsPath).toLowerCase())) {
 				return true;
 			}
 		}
@@ -291,7 +337,6 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 		}

 		const notebookModel = await provider.controller.createNotebook(viewType, uri, { metadata, languages, cells }, false, editorId);
-		await this.transformTextModelOutputs(notebookModel!);
 		if (!notebookModel) {
 			return undefined;
 		}
@@ -300,29 +345,42 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 		const modelId = MODEL_ID(uri);
 		const modelData = new ModelData(
 			notebookModel,
-			(model) => this._onWillDispose(model),
+			(model) => this._onWillDisposeDocument(model),
 		);
-		this._models[modelId] = modelData;
+		this._models.set(modelId, modelData);
+		this._onNotebookDocumentAdd.fire([notebookModel.uri]);
+		// after the document is added to the store and sent to ext host, we transform the ouputs
+		await this.transformTextModelOutputs(notebookModel!);
 		return modelData.model;
 	}

-	async resolveNotebook(viewType: string, uri: URI, forceReload: boolean, editorId?: string): Promise<NotebookTextModel | undefined> {
+	async resolveNotebook(viewType: string, uri: URI, forceReload: boolean, editorId?: string, backupId?: string): Promise<NotebookTextModel | undefined> {
 		const provider = this._notebookProviders.get(viewType);
 		if (!provider) {
 			return undefined;
 		}

-		const notebookModel = await provider.controller.createNotebook(viewType, uri, undefined, forceReload, editorId);
-		await this.transformTextModelOutputs(notebookModel!);
+		const notebookModel = await provider.controller.createNotebook(viewType, uri, undefined, forceReload, editorId, backupId);
+		if (!notebookModel) {
+			return undefined;
+		}

 		// new notebook model created
 		const modelId = MODEL_ID(uri);
 		const modelData = new ModelData(
 			notebookModel!,
-			(model) => this._onWillDispose(model),
+			(model) => this._onWillDisposeDocument(model),
 		);

-		this._models[modelId] = modelData;
+		this._models.set(modelId, modelData);
+		this._onNotebookDocumentAdd.fire([notebookModel!.uri]);
+		// after the document is added to the store and sent to ext host, we transform the ouputs
+		await this.transformTextModelOutputs(notebookModel!);
+
+		if (editorId) {
+			await provider.controller.resolveNotebookEditor(viewType, uri, editorId);
+		}
+
 		return modelData.model;
 	}

@@ -377,14 +435,14 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 			outputs.forEach((output, index) => {
 				if (output.outputKind === CellOutputKind.Rich) {
 					// TODO no string[] casting
-					const ret = this._transformMimeTypes(output, textModel.metadata.displayOrder as string[] || []);
+					const ret = this._transformMimeTypes(output, output.outputId, textModel.metadata.displayOrder as string[] || []);
 					const orderedMimeTypes = ret.orderedMimeTypes!;
 					const pickedMimeTypeIndex = ret.pickedMimeTypeIndex!;
 					output.pickedMimeTypeIndex = pickedMimeTypeIndex;
 					output.orderedMimeTypes = orderedMimeTypes;

 					if (orderedMimeTypes[pickedMimeTypeIndex!].rendererId && orderedMimeTypes[pickedMimeTypeIndex].rendererId !== BUILTIN_RENDERER_ID) {
-						outputRequest.push({ index, handlerId: orderedMimeTypes[pickedMimeTypeIndex].rendererId!, mimeType: orderedMimeTypes[pickedMimeTypeIndex].mimeType });
+						outputRequest.push({ index, handlerId: orderedMimeTypes[pickedMimeTypeIndex].rendererId!, mimeType: orderedMimeTypes[pickedMimeTypeIndex].mimeType, outputId: output.outputId });
 						renderers.add(orderedMimeTypes[pickedMimeTypeIndex].rendererId!);
 					}
 				}
@@ -411,14 +469,14 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 					const outputRequest: IOutputRenderRequestOutputInfo[] = [];
 					outputs.map((output, index) => {
 						if (output.outputKind === CellOutputKind.Rich) {
-							const ret = this._transformMimeTypes(output, textModel.metadata.displayOrder as string[] || []);
+							const ret = this._transformMimeTypes(output, output.outputId, textModel.metadata.displayOrder as string[] || []);
 							const orderedMimeTypes = ret.orderedMimeTypes!;
 							const pickedMimeTypeIndex = ret.pickedMimeTypeIndex!;
 							output.pickedMimeTypeIndex = pickedMimeTypeIndex;
 							output.orderedMimeTypes = orderedMimeTypes;

 							if (orderedMimeTypes[pickedMimeTypeIndex!].rendererId && orderedMimeTypes[pickedMimeTypeIndex].rendererId !== BUILTIN_RENDERER_ID) {
-								outputRequest.push({ index, handlerId: orderedMimeTypes[pickedMimeTypeIndex].rendererId!, mimeType: orderedMimeTypes[pickedMimeTypeIndex].mimeType, output: output });
+								outputRequest.push({ index, handlerId: orderedMimeTypes[pickedMimeTypeIndex].rendererId!, mimeType: orderedMimeTypes[pickedMimeTypeIndex].mimeType, output: output, outputId: output.outputId });
 								renderers.add(orderedMimeTypes[pickedMimeTypeIndex].rendererId!);
 							}
 						}
@@ -447,14 +505,14 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 			const outputRequest: IOutputRenderRequestOutputInfo[] = [];
 			outputs.map((output, index) => {
 				if (output.outputKind === CellOutputKind.Rich) {
-					const ret = this._transformMimeTypes(output, textModel.metadata.displayOrder as string[] || []);
+					const ret = this._transformMimeTypes(output, output.outputId, textModel.metadata.displayOrder as string[] || []);
 					const orderedMimeTypes = ret.orderedMimeTypes!;
 					const pickedMimeTypeIndex = ret.pickedMimeTypeIndex!;
 					output.pickedMimeTypeIndex = pickedMimeTypeIndex;
 					output.orderedMimeTypes = orderedMimeTypes;

 					if (orderedMimeTypes[pickedMimeTypeIndex!].rendererId && orderedMimeTypes[pickedMimeTypeIndex].rendererId !== BUILTIN_RENDERER_ID) {
-						outputRequest.push({ index, handlerId: orderedMimeTypes[pickedMimeTypeIndex].rendererId!, mimeType: orderedMimeTypes[pickedMimeTypeIndex].mimeType, output: output });
+						outputRequest.push({ index, handlerId: orderedMimeTypes[pickedMimeTypeIndex].rendererId!, mimeType: orderedMimeTypes[pickedMimeTypeIndex].mimeType, output: output, outputId: output.outputId });
 						renderers.add(orderedMimeTypes[pickedMimeTypeIndex].rendererId!);
 					}
 				}
@@ -478,6 +536,7 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 				outputs: [
 					{
 						index: 0,
+						outputId: generateUuid(),
 						handlerId: rendererId,
 						mimeType: mimeType,
 						output: output
@@ -502,7 +561,7 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 		return undefined; // {{SQL CARBON EDIT}} strict-null-checks
 	}

-	private _transformMimeTypes(output: IDisplayOutput, documentDisplayOrder: string[]): ITransformedDisplayOutputDto {
+	private _transformMimeTypes(output: IDisplayOutput, outputId: string, documentDisplayOrder: string[]): ITransformedDisplayOutputDto {
 		let mimeTypes = Object.keys(output.data);
 		let coreDisplayOrder = this._displayOrder;
 		const sorted = sortMimeTypes(mimeTypes, coreDisplayOrder?.userOrder || [], documentDisplayOrder, coreDisplayOrder?.defaultOrder || []);
@@ -547,6 +606,7 @@ export class NotebookService extends Disposable implements INotebookService, ICu

 		return {
 			outputKind: output.outputKind,
+			outputId,
 			data: output.data,
 			orderedMimeTypes: orderMimeTypes,
 			pickedMimeTypeIndex: 0
@@ -610,30 +670,37 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 	}

 	removeNotebookEditor(editor: INotebookEditor) {
-		if (delete this._notebookEditors[editor.getId()]) {
-			this._onNotebookEditorRemove.fire(editor);
+		let editorCache = this._notebookEditors.get(editor.getId());
+
+		if (editorCache) {
+			this._notebookEditors.delete(editor.getId());
+			this._onNotebookEditorsRemove.fire([editor]);
 		}
 	}

 	addNotebookEditor(editor: INotebookEditor) {
-		this._notebookEditors[editor.getId()] = editor;
+		this._notebookEditors.set(editor.getId(), editor);
 		this._onNotebookEditorAdd.fire(editor);
 	}

 	listNotebookEditors(): INotebookEditor[] {
-		return Object.keys(this._notebookEditors).map(id => this._notebookEditors[id]);
+		return [...this._notebookEditors].map(e => e[1]);
+	}
+
+	listVisibleNotebookEditors(): INotebookEditor[] {
+		return this._editorService.visibleEditorPanes
+			.filter(pane => (pane as any).isNotebookEditor)
+			.map(pane => pane.getControl() as INotebookEditor)
+			.filter(editor => !!editor)
+			.filter(editor => this._notebookEditors.has(editor.getId()));
 	}

 	listNotebookDocuments(): NotebookTextModel[] {
-		return Object.keys(this._models).map(id => this._models[id].model);
+		return [...this._models].map(e => e[1].model);
 	}

 	destoryNotebookDocument(viewType: string, notebook: INotebookTextModel): void {
-		let provider = this._notebookProviders.get(viewType);
-
-		if (provider) {
-			provider.controller.removeNotebookDocument(notebook);
-		}
+		this._onWillDisposeDocument(notebook);
 	}

 	updateActiveNotebookEditor(editor: INotebookEditor | null) {
@@ -641,7 +708,8 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 	}

 	updateVisibleNotebookEditor(editors: string[]) {
-		this._onDidChangeVisibleEditors.fire(editors);
+		const alreadyCreated = editors.filter(editorId => this._notebookEditors.has(editorId));
+		this._onDidChangeVisibleEditors.fire(alreadyCreated);
 	}

 	setToCopy(items: NotebookCellTextModel[]) {
@@ -672,6 +740,16 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 		return false;
 	}

+	async backup(viewType: string, uri: URI, token: CancellationToken): Promise<string | undefined> {
+		let provider = this._notebookProviders.get(viewType);
+
+		if (provider) {
+			return provider.controller.backup(uri, token);
+		}
+
+		return undefined; // {{SQL CARBON EDIT}} strict-null-check
+	}
+
 	onDidReceiveMessage(viewType: string, editorId: string, message: any): void {
 		let provider = this._notebookProviders.get(viewType);

@@ -680,13 +758,33 @@ export class NotebookService extends Disposable implements INotebookService, ICu
 		}
 	}

-	private _onWillDispose(model: INotebookTextModel): void {
+	private _onWillDisposeDocument(model: INotebookTextModel): void {
 		let modelId = MODEL_ID(model.uri);
-		let modelData = this._models[modelId];

-		delete this._models[modelId];
-		modelData?.dispose();
+		let modelData = this._models.get(modelId);
+		this._models.delete(modelId);

-		// this._onModelRemoved.fire(model);
+		if (modelData) {
+			// delete editors and documents
+			const willRemovedEditors: INotebookEditor[] = [];
+			this._notebookEditors.forEach(editor => {
+				if (editor.textModel === modelData!.model) {
+					willRemovedEditors.push(editor);
+				}
+			});
+
+			willRemovedEditors.forEach(e => this._notebookEditors.delete(e.getId()));
+
+			let provider = this._notebookProviders.get(modelData!.model.viewType);
+
+			if (provider) {
+				provider.controller.removeNotebookDocument(modelData!.model);
+			}
+
+
+			this._onNotebookEditorsRemove.fire(willRemovedEditors.map(e => e));
+			this._onNotebookDocumentRemove.fire([modelData.model.uri]);
+			modelData?.dispose();
+		}
 	}
 }