@theia/notebook 1.42.1 → 1.43.0

package/src/browser/service/notebook-model-resolver-service.ts

@@ -23,6 +23,7 @@ import { NotebookModel } from '../view-model/notebook-model';
 import { NotebookService } from './notebook-service';
 import { NotebookTypeRegistry } from '../notebook-type-registry';
 import { NotebookFileSelector } from '../../common/notebook-protocol';
+import { match } from '@theia/core/lib/common/glob';
 
 export interface UntitledResource {
     untitledResource: URI | undefined
@@ -44,40 +45,21 @@ export class NotebookModelResolverService {
     protected onDidSaveNotebookEmitter = new Emitter<UriComponents>();
     readonly onDidSaveNotebook = this.onDidSaveNotebookEmitter.event;
 
-    async resolve(resource: URI, viewType?: string): Promise<NotebookModel>;
-    async resolve(resource: UntitledResource, viewType: string): Promise<NotebookModel>;
-    async resolve(arg: URI | UntitledResource, viewType: string): Promise<NotebookModel> {
-        let resource: URI;
-        // let hasAssociatedFilePath = false;
-        if (arg instanceof URI) {
-            resource = arg;
-        } else {
-            arg = arg as UntitledResource;
-            if (!arg.untitledResource) {
-                const notebookTypeInfo = this.notebookTypeRegistry.notebookTypes.find(info => info.type === viewType);
-                if (!notebookTypeInfo) {
-                    throw new Error('UNKNOWN view type: ' + viewType);
-                }
+    async resolve(resource: URI, viewType?: string): Promise<NotebookModel> {
 
-                const suffix = this.getPossibleFileEndings(notebookTypeInfo.selector ?? []) ?? '';
-                for (let counter = 1; ; counter++) {
-                    const candidate = new URI()
-                        .withScheme('untitled')
-                        .withPath(`Untitled-notebook-${counter}${suffix}`)
-                        .withQuery(viewType);
-                    if (!this.notebookService.getNotebookEditorModel(candidate)) {
-                        resource = candidate;
-                        break;
-                    }
-                }
-            } else if (arg.untitledResource.scheme === 'untitled') {
-                resource = arg.untitledResource;
+        if (!viewType) {
+            const existingViewType = this.notebookService.getNotebookEditorModel(resource)?.viewType;
+            if (existingViewType) {
+                viewType = existingViewType;
             } else {
-                resource = arg.untitledResource.withScheme('untitled');
-                // hasAssociatedFilePath = true;
+                viewType = this.findViewTypeForResource(resource);
             }
         }
 
+        if (!viewType) {
+            throw new Error(`Missing viewType for '${resource}'`);
+        }
+
         const notebookData = await this.resolveExistingNotebookData(resource, viewType!);
 
         const notebookModel = await this.notebookService.createNotebookModel(notebookData, viewType, resource);
@@ -88,6 +70,39 @@ export class NotebookModelResolverService {
         return notebookModel;
     }
 
+    async resolveUntitledResource(arg: UntitledResource, viewType: string): Promise<NotebookModel> {
+        let resource: URI;
+        // let hasAssociatedFilePath = false;
+        arg = arg as UntitledResource;
+        if (!arg.untitledResource) {
+            const notebookTypeInfo = this.notebookTypeRegistry.notebookTypes.find(info => info.type === viewType);
+            if (!notebookTypeInfo) {
+                throw new Error('UNKNOWN view type: ' + viewType);
+            }
+
+            const suffix = this.getPossibleFileEnding(notebookTypeInfo.selector ?? []) ?? '';
+            for (let counter = 1; ; counter++) {
+                const candidate = new URI()
+                    .withScheme('untitled')
+                    .withPath(`Untitled-notebook-${counter}${suffix}`)
+                    .withQuery(viewType);
+                if (!this.notebookService.getNotebookEditorModel(candidate)) {
+                    resource = candidate;
+                    break;
+                }
+            }
+        } else if (arg.untitledResource.scheme === 'untitled') {
+            resource = arg.untitledResource;
+        } else {
+            throw new Error('Invalid untitled resource: ' + arg.untitledResource.toString() + ' untitled resources with associated file path are not supported yet');
+            // TODO implement associated file path support
+            // resource = arg.untitledResource.withScheme('untitled');
+            // hasAssociatedFilePath = true;
+        }
+
+        return this.resolve(resource, viewType);
+    }
+
     protected async resolveExistingNotebookData(resource: URI, viewType: string): Promise<NotebookData> {
         if (resource.scheme === 'untitled') {
 
@@ -106,13 +121,13 @@ export class NotebookModelResolverService {
             const file = await this.fileService.readFile(resource);
 
             const dataProvider = await this.notebookService.getNotebookDataProvider(viewType);
-            const notebook = await dataProvider.serializer.dataToNotebook(file.value);
+            const notebook = await dataProvider.serializer.toNotebook(file.value);
 
             return notebook;
         }
     }
 
-    protected getPossibleFileEndings(selectors: readonly NotebookFileSelector[]): string | undefined {
+    protected getPossibleFileEnding(selectors: readonly NotebookFileSelector[]): string | undefined {
         for (const selector of selectors) {
             const ending = this.possibleFileEnding(selector);
             if (ending) {
@@ -126,16 +141,22 @@ export class NotebookModelResolverService {
 
         const pattern = /^.*(\.[a-zA-Z0-9_-]+)$/;
 
-        const candidate: string | undefined = typeof selector === 'string' ? selector : selector.filenamePattern;
+        const candidate = typeof selector === 'string' ? selector : selector.filenamePattern;
 
         if (candidate) {
-            const match = pattern.exec(candidate);
-            if (match) {
-                return match[1];
+            const matches = pattern.exec(candidate);
+            if (matches) {
+                return matches[1];
             }
         }
 
         return undefined;
     }
 
+    protected findViewTypeForResource(resource: URI): string | undefined {
+        return this.notebookTypeRegistry.notebookTypes.find(info =>
+            info.selector?.some(selector => selector.filenamePattern && match(selector.filenamePattern, resource.path.name + resource.path.ext))
+        )?.type;
+    }
+
 }

package/src/browser/service/notebook-renderer-messaging-service.ts

@@ -22,18 +22,18 @@ import { Emitter } from '@theia/core';
 import { injectable } from '@theia/core/shared/inversify';
 import { Disposable } from '@theia/core/shared/vscode-languageserver-protocol';
 
-interface MessageToSend {
+interface RendererMessage {
     editorId: string;
     rendererId: string;
     message: unknown
 };
 
-export interface ScopedRendererMessaging extends Disposable {
+export interface RendererMessaging extends Disposable {
     /**
      * Method called when a message is received. Should return a boolean
      * indicating whether a renderer received it.
      */
-    receiveMessageHandler?: (rendererId: string, message: unknown) => Promise<boolean>;
+    receiveMessage?: (rendererId: string, message: unknown) => Promise<boolean>;
 
     /**
      * Sends a message to an extension from a renderer.
@@ -44,19 +44,22 @@ export interface ScopedRendererMessaging extends Disposable {
 @injectable()
 export class NotebookRendererMessagingService implements Disposable {
 
-    private readonly postMessageEmitter = new Emitter<MessageToSend>();
-    readonly onShouldPostMessage = this.postMessageEmitter.event;
+    private readonly postMessageEmitter = new Emitter<RendererMessage>();
+    readonly onPostMessage = this.postMessageEmitter.event;
 
-    private readonly activations = new Map<string /* rendererId */, undefined | MessageToSend[]>();
-    private readonly scopedMessaging = new Map<string /* editorId */, ScopedRendererMessaging>();
+    private readonly willActivateRendererEmitter = new Emitter<string>();
+    readonly onWillActivateRenderer = this.willActivateRendererEmitter.event;
+
+    private readonly activations = new Map<string /* rendererId */, undefined | RendererMessage[]>();
+    private readonly scopedMessaging = new Map<string /* editorId */, RendererMessaging>();
 
     receiveMessage(editorId: string | undefined, rendererId: string, message: unknown): Promise<boolean> {
         if (editorId === undefined) {
-            const sends = [...this.scopedMessaging.values()].map(e => e.receiveMessageHandler?.(rendererId, message));
+            const sends = [...this.scopedMessaging.values()].map(e => e.receiveMessage?.(rendererId, message));
             return Promise.all(sends).then(values => values.some(value => !!value));
         }
 
-        return this.scopedMessaging.get(editorId)?.receiveMessageHandler?.(rendererId, message) ?? Promise.resolve(false);
+        return this.scopedMessaging.get(editorId)?.receiveMessage?.(rendererId, message) ?? Promise.resolve(false);
     }
 
     prepare(rendererId: string): void {
@@ -64,25 +67,24 @@ export class NotebookRendererMessagingService implements Disposable {
             return;
         }
 
-        const queue: MessageToSend[] = [];
+        const queue: RendererMessage[] = [];
         this.activations.set(rendererId, queue);
 
-        // activate renderer
-        // this.extensionService.activateByEvent(`onRenderer:${rendererId}`).then(() => {
-        //     for (const message of queue) {
-        //         this.postMessageEmitter.fire(message);
-        //     }
-        //     this.activations.set(rendererId, undefined);
-        // });
+        Promise.all(this.willActivateRendererEmitter.fire(rendererId)).then(() => {
+            for (const message of queue) {
+                this.postMessageEmitter.fire(message);
+            }
+            this.activations.set(rendererId, undefined);
+        });
     }
 
-    public getScoped(editorId: string): ScopedRendererMessaging {
+    public getScoped(editorId: string): RendererMessaging {
         const existing = this.scopedMessaging.get(editorId);
         if (existing) {
             return existing;
         }
 
-        const messaging: ScopedRendererMessaging = {
+        const messaging: RendererMessaging = {
             postMessage: (rendererId, message) => this.postMessage(editorId, rendererId, message),
             dispose: () => this.scopedMessaging.delete(editorId),
         };

package/src/browser/service/notebook-service.ts

@@ -17,7 +17,7 @@
 import { Disposable, DisposableCollection, Emitter, URI } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
-import { NotebookData, NotebookExtensionDescription, TransientOptions } from '../../common';
+import { NotebookData, TransientOptions } from '../../common';
 import { NotebookModel, NotebookModelFactory, NotebookModelProps } from '../view-model/notebook-model';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { MonacoTextModelService } from '@theia/monaco/lib/browser/monaco-text-model-service';
@@ -26,16 +26,15 @@ import { Deferred } from '@theia/core/lib/common/promise-util';
 
 export const NotebookProvider = Symbol('notebook provider');
 
-export interface SimpleNotebookProviderInfo {
+export interface NotebookProviderInfo {
     readonly notebookType: string,
     readonly serializer: NotebookSerializer,
-    readonly extensionData: NotebookExtensionDescription
 }
 
 export interface NotebookSerializer {
     options: TransientOptions;
-    dataToNotebook(data: BinaryBuffer): Promise<NotebookData>;
-    notebookToData(data: NotebookData): Promise<BinaryBuffer>;
+    toNotebook(data: BinaryBuffer): Promise<NotebookData>;
+    fromNotebook(data: NotebookData): Promise<BinaryBuffer>;
 }
 
 @injectable()
@@ -53,16 +52,16 @@ export class NotebookService implements Disposable {
     @inject(NotebookCellModelFactory)
     protected notebookCellModelFactory: (props: NotebookCellModelProps) => NotebookCellModel;
 
-    protected notebookSerializerEmitter = new Emitter<string>();
-    readonly onNotebookSerializer = this.notebookSerializerEmitter.event;
+    protected willUseNotebookSerializerEmitter = new Emitter<string>();
+    readonly onWillUseNotebookSerializer = this.willUseNotebookSerializerEmitter.event;
 
     protected readonly disposables = new DisposableCollection();
 
-    protected readonly notebookProviders = new Map<string, SimpleNotebookProviderInfo>();
+    protected readonly notebookProviders = new Map<string, NotebookProviderInfo>();
     protected readonly notebookModels = new Map<string, NotebookModel>();
 
-    protected readonly didAddViewTypeEmitter = new Emitter<string>();
-    readonly onDidAddViewType = this.didAddViewTypeEmitter.event;
+    protected readonly didRegisterNotebookSerializerEmitter = new Emitter<string>();
+    readonly onDidRegisterNotebookSerializer = this.didRegisterNotebookSerializerEmitter.event;
 
     protected readonly didRemoveViewTypeEmitter = new Emitter<string>();
     readonly onDidRemoveViewType = this.didRemoveViewTypeEmitter.event;
@@ -70,12 +69,8 @@ export class NotebookService implements Disposable {
     protected readonly willOpenNotebookTypeEmitter = new Emitter<string>();
     readonly onWillOpenNotebook = this.willOpenNotebookTypeEmitter.event;
 
-    protected readonly willAddNotebookDocumentEmitter = new Emitter<URI>();
-    readonly onWillAddNotebookDocument = this.willAddNotebookDocumentEmitter.event;
     protected readonly didAddNotebookDocumentEmitter = new Emitter<NotebookModel>();
     readonly onDidAddNotebookDocument = this.didAddNotebookDocumentEmitter.event;
-    protected readonly willRemoveNotebookDocumentEmitter = new Emitter<NotebookModel>();
-    readonly onWillRemoveNotebookDocument = this.willRemoveNotebookDocumentEmitter.event;
     protected readonly didRemoveNotebookDocumentEmitter = new Emitter<NotebookModel>();
     readonly onDidRemoveNotebookDocument = this.didRemoveNotebookDocumentEmitter.event;
 
@@ -92,17 +87,17 @@ export class NotebookService implements Disposable {
         this.ready.resolve();
     }
 
-    registerNotebookSerializer(notebookType: string, extensionData: NotebookExtensionDescription, serializer: NotebookSerializer): Disposable {
-        if (this.notebookProviders.has(notebookType)) {
-            throw new Error(`notebook provider for viewtype '${notebookType}' already exists`);
+    registerNotebookSerializer(viewType: string, serializer: NotebookSerializer): Disposable {
+        if (this.notebookProviders.has(viewType)) {
+            throw new Error(`notebook provider for viewtype '${viewType}' already exists`);
         }
 
-        this.notebookProviders.set(notebookType, { notebookType: notebookType, serializer, extensionData });
-        this.didAddViewTypeEmitter.fire(notebookType);
+        this.notebookProviders.set(viewType, { notebookType: viewType, serializer });
+        this.didRegisterNotebookSerializerEmitter.fire(viewType);
 
         return Disposable.create(() => {
-            this.notebookProviders.delete(notebookType);
-            this.didRemoveViewTypeEmitter.fire(notebookType);
+            this.notebookProviders.delete(viewType);
+            this.didRemoveViewTypeEmitter.fire(viewType);
         });
     }
 
@@ -112,7 +107,6 @@ export class NotebookService implements Disposable {
             throw new Error('no notebook serializer for ' + viewType);
         }
 
-        this.willAddNotebookDocumentEmitter.fire(uri);
         const model = this.notebookModelFactory({ data, uri, viewType, serializer });
         this.notebookModels.set(uri.toString(), model);
         // Resolve cell text models right after creating the notebook model
@@ -122,9 +116,8 @@ export class NotebookService implements Disposable {
         return model;
     }
 
-    async getNotebookDataProvider(viewType: string): Promise<SimpleNotebookProviderInfo> {
+    async getNotebookDataProvider(viewType: string): Promise<NotebookProviderInfo> {
         await this.ready.promise;
-        await this.notebookSerializerEmitter.sequence(async listener => listener(`onNotebookSerializer:${viewType}`));
 
         const result = await this.waitForNotebookProvider(viewType);
         if (!result) {
@@ -138,14 +131,15 @@ export class NotebookService implements Disposable {
      * It takes a few seconds for the plugin host to start so that notebook data providers can be registered.
      * This methods waits until the notebook provider is registered.
      */
-    protected async waitForNotebookProvider(type: string): Promise<SimpleNotebookProviderInfo | undefined> {
+    protected async waitForNotebookProvider(type: string): Promise<NotebookProviderInfo | undefined> {
         if (this.notebookProviders.has(type)) {
             return this.notebookProviders.get(type);
         }
-        const deferred = new Deferred<SimpleNotebookProviderInfo | undefined>();
+        await Promise.all(this.willUseNotebookSerializerEmitter.fire(type));
+        const deferred = new Deferred<NotebookProviderInfo | undefined>();
         // 20 seconds of timeout
         const timeoutDuration = 20_000;
-        const disposable = this.onDidAddViewType(viewType => {
+        const disposable = this.onDidRegisterNotebookSerializer(viewType => {
             if (viewType === type) {
                 clearTimeout(timeout);
                 disposable.dispose();

package/src/browser/view/notebook-cell-editor.tsx

@@ -17,7 +17,7 @@
 import * as React from '@theia/core/shared/react';
 import { NotebookModel } from '../view-model/notebook-model';
 import { NotebookCellModel } from '../view-model/notebook-cell-model';
-import { MonacoCodeEditor } from '@theia/monaco/lib/browser/monaco-code-editor';
+import { SimpleMonacoEditor } from '@theia/monaco/lib/browser/simple-monaco-editor';
 import { MonacoEditorServices } from '@theia/monaco/lib/browser/monaco-editor';
 import { MonacoEditorProvider } from '@theia/monaco/lib/browser/monaco-editor-provider';
 import { DisposableCollection } from '@theia/core';
@@ -40,7 +40,7 @@ const DEFAULT_EDITOR_OPTIONS = {
 
 export class CellEditor extends React.Component<CellEditorProps, {}> {
 
-    protected editor?: MonacoCodeEditor;
+    protected editor?: SimpleMonacoEditor;
     protected toDispose = new DisposableCollection();
     protected container?: HTMLDivElement;
 
@@ -64,7 +64,7 @@ export class CellEditor extends React.Component<CellEditorProps, {}> {
             const editorNode = this.container;
             const editorModel = await cell.resolveTextModel();
             const uri = cell.uri;
-            this.editor = new MonacoCodeEditor(uri,
+            this.editor = new SimpleMonacoEditor(uri,
                 editorModel,
                 editorNode,
                 monacoServices,

package/src/browser/view-model/notebook-cell-model.ts

@@ -24,11 +24,12 @@ import { MonacoEditorModel } from '@theia/monaco/lib/browser/monaco-editor-model
 import { MonacoTextModelService } from '@theia/monaco/lib/browser/monaco-text-model-service';
 import {
     CellInternalMetadataChangedEvent, CellKind, NotebookCellCollapseState, NotebookCellInternalMetadata,
-    NotebookCellMetadata, NotebookCellOutputsSplice, CellOutput, CellData, NotebookCell
+    NotebookCellMetadata, NotebookCellOutputsSplice, CellOutput, CellData, NotebookCell, CellOutputItem
 } from '../../common';
 import { NotebookCellOutputModel } from './notebook-cell-output-model';
 
 export const NotebookCellModelFactory = Symbol('NotebookModelFactory');
+export type NotebookCellModelFactory = (props: NotebookCellModelProps) => NotebookCellModel;
 
 export function createNotebookCellModelContainer(parent: interfaces.Container, props: NotebookCellModelProps,
     notebookCellContextManager: new (...args: never[]) => unknown): interfaces.Container {
@@ -69,8 +70,8 @@ export class NotebookCellModel implements NotebookCell, Disposable {
     protected readonly onDidChangeOutputsEmitter = new Emitter<NotebookCellOutputsSplice>();
     readonly onDidChangeOutputs: Event<NotebookCellOutputsSplice> = this.onDidChangeOutputsEmitter.event;
 
-    protected readonly onDidChangeOutputItemsEmitter = new Emitter<void>();
-    readonly onDidChangeOutputItems: Event<void> = this.onDidChangeOutputItemsEmitter.event;
+    protected readonly onDidChangeOutputItemsEmitter = new Emitter<CellOutput>();
+    readonly onDidChangeOutputItems: Event<CellOutput> = this.onDidChangeOutputItemsEmitter.event;
 
     protected readonly onDidChangeContentEmitter = new Emitter<'content' | 'language' | 'mime'>();
     readonly onDidChangeContent: Event<'content' | 'language' | 'mime'> = this.onDidChangeContentEmitter.event;
@@ -134,7 +135,7 @@ export class NotebookCellModel implements NotebookCell, Disposable {
         return this.htmlContext;
     }
 
-    get textBuffer(): string {
+    get text(): string {
         return this.textModel ? this.textModel.getText() : this.source;
     }
 
@@ -215,7 +216,7 @@ export class NotebookCellModel implements NotebookCell, Disposable {
                 const currentOutput = this.outputs[splice.start + i];
                 const newOutput = splice.newOutputs[i];
 
-                this.replaceOutputItems(currentOutput.outputId, newOutput);
+                this.replaceOutputData(currentOutput.outputId, newOutput);
             }
 
             this.outputs.splice(splice.start + commonLen, splice.deleteCount - commonLen, ...splice.newOutputs.slice(commonLen).map(op => new NotebookCellOutputModel(op)));
@@ -226,15 +227,31 @@ export class NotebookCellModel implements NotebookCell, Disposable {
         }
     }
 
-    replaceOutputItems(outputId: string, newOutputItem: CellOutput): boolean {
+    replaceOutputData(outputId: string, newOutputData: CellOutput): boolean {
         const output = this.outputs.find(out => out.outputId === outputId);
 
         if (!output) {
             return false;
         }
 
-        output.replaceData(newOutputItem);
-        this.onDidChangeOutputItemsEmitter.fire();
+        output.replaceData(newOutputData);
+        this.onDidChangeOutputItemsEmitter.fire(output);
+        return true;
+    }
+
+    changeOutputItems(outputId: string, append: boolean, items: CellOutputItem[]): boolean {
+        const output = this.outputs.find(out => out.outputId === outputId);
+
+        if (!output) {
+            return false;
+        }
+
+        if (append) {
+            output.appendData(items);
+        } else {
+            output.replaceData({ outputId: outputId, outputs: items, metadata: output.metadata });
+        }
+        this.onDidChangeOutputItemsEmitter.fire(output);
         return true;
     }
 
@@ -243,7 +260,7 @@ export class NotebookCellModel implements NotebookCell, Disposable {
             cellKind: this.cellKind,
             language: this.language,
             outputs: this.outputs.map(output => output.getData()),
-            source: this.textBuffer,
+            source: this.text,
             collapseState: this.props.collapseState,
             internalMetadata: this.internalMetadata,
             metadata: this.metadata

package/src/browser/view-model/notebook-cell-output-model.ts

@@ -15,7 +15,8 @@
 // *****************************************************************************
 
 import { Disposable, Emitter } from '@theia/core';
-import { CellOutput, CellOutputItem } from '../../common';
+import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+import { CellOutput, CellOutputItem, isTextStreamMime } from '../../common';
 
 export class NotebookCellOutputModel implements Disposable {
 
@@ -41,11 +42,13 @@ export class NotebookCellOutputModel implements Disposable {
 
     replaceData(rawData: CellOutput): void {
         this.rawOutput = rawData;
+        this.optimizeOutputItems();
         this.didChangeDataEmitter.fire();
     }
 
     appendData(items: CellOutputItem[]): void {
         this.rawOutput.outputs.push(...items);
+        this.optimizeOutputItems();
         this.didChangeDataEmitter.fire();
     }
 
@@ -66,4 +69,31 @@ export class NotebookCellOutputModel implements Disposable {
         };
     }
 
+    private optimizeOutputItems(): void {
+        if (this.outputs.length > 1 && this.outputs.every(item => isTextStreamMime(item.mime))) {
+            // Look for the mimes in the items, and keep track of their order.
+            // Merge the streams into one output item, per mime type.
+            const mimeOutputs = new Map<string, BinaryBuffer[]>();
+            const mimeTypes: string[] = [];
+            this.outputs.forEach(item => {
+                let items: BinaryBuffer[];
+                if (mimeOutputs.has(item.mime)) {
+                    items = mimeOutputs.get(item.mime)!;
+                } else {
+                    items = [];
+                    mimeOutputs.set(item.mime, items);
+                    mimeTypes.push(item.mime);
+                }
+                items.push(item.data);
+            });
+            this.outputs.length = 0;
+            mimeTypes.forEach(mime => {
+                this.outputs.push({
+                    mime,
+                    data: BinaryBuffer.concat(mimeOutputs.get(mime)!)
+                });
+            });
+        }
+    }
+
 }

package/src/browser/view-model/notebook-model.ts

@@ -25,9 +25,9 @@ import {
 } from '../../common';
 import { NotebookSerializer } from '../service/notebook-service';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
-import { NotebookCellModel, NotebookCellModelFactory, NotebookCellModelProps } from './notebook-cell-model';
+import { NotebookCellModel, NotebookCellModelFactory } from './notebook-cell-model';
 import { MonacoTextModelService } from '@theia/monaco/lib/browser/monaco-text-model-service';
-import { inject, injectable, interfaces } from '@theia/core/shared/inversify';
+import { inject, injectable, interfaces, postConstruct } from '@theia/core/shared/inversify';
 import { NotebookKernel } from '../service/notebook-kernel-service';
 import { UndoRedoService } from '@theia/editor/lib/browser/undo-redo-service';
 
@@ -53,24 +53,32 @@ export interface NotebookModelProps {
 @injectable()
 export class NotebookModel implements Saveable, Disposable {
 
-    private readonly onDirtyChangedEmitter = new Emitter<void>();
+    protected readonly onDirtyChangedEmitter = new Emitter<void>();
     readonly onDirtyChanged = this.onDirtyChangedEmitter.event;
 
-    private readonly onDidSaveNotebookEmitter = new Emitter<void>();
+    protected readonly onDidSaveNotebookEmitter = new Emitter<void>();
     readonly onDidSaveNotebook = this.onDidSaveNotebookEmitter.event;
 
-    private readonly onDidAddOrRemoveCellEmitter = new Emitter<NotebookModelWillAddRemoveEvent>();
+    protected readonly onDidAddOrRemoveCellEmitter = new Emitter<NotebookModelWillAddRemoveEvent>();
     readonly onDidAddOrRemoveCell = this.onDidAddOrRemoveCellEmitter.event;
 
-    private readonly onDidChangeContentEmitter = new Emitter<NotebookTextModelChangedEvent>();
+    protected readonly onDidChangeContentEmitter = new Emitter<NotebookTextModelChangedEvent>();
     readonly onDidChangeContent = this.onDidChangeContentEmitter.event;
 
     @inject(FileService)
-    private readonly fileService: FileService;
+    protected readonly fileService: FileService;
 
     @inject(UndoRedoService)
-    private readonly undoRedoService: UndoRedoService;
+    protected readonly undoRedoService: UndoRedoService;
 
+    @inject(NotebookModelProps)
+    protected props: NotebookModelProps;
+
+    @inject(MonacoTextModelService)
+    protected modelService: MonacoTextModelService;
+
+    @inject(NotebookCellModelFactory)
+    protected cellModelFactory: NotebookCellModelFactory;
     readonly autoSave: 'off' | 'afterDelay' | 'onFocusChange' | 'onWindowChange';
 
     nextHandle: number = 0;
@@ -79,7 +87,7 @@ export class NotebookModel implements Saveable, Disposable {
 
     dirty: boolean;
     selectedCell?: NotebookCellModel;
-    private dirtyCells: NotebookCellModel[] = [];
+    protected dirtyCells: NotebookCellModel[] = [];
 
     cells: NotebookCellModel[];
 
@@ -93,13 +101,12 @@ export class NotebookModel implements Saveable, Disposable {
 
     metadata: NotebookDocumentMetadata = {};
 
-    constructor(@inject(NotebookModelProps) private props: NotebookModelProps,
-        @inject(MonacoTextModelService) modelService: MonacoTextModelService,
-        @inject(NotebookCellModelFactory) private cellModelFactory: (props: NotebookCellModelProps) => NotebookCellModel) {
+    @postConstruct()
+    initialize(): void {
         this.dirty = false;
 
-        this.cells = props.data.cells.map((cell, index) => cellModelFactory({
-            uri: CellUri.generate(props.uri, index),
+        this.cells = this.props.data.cells.map((cell, index) => this.cellModelFactory({
+            uri: CellUri.generate(this.props.uri, index),
             handle: index,
             source: cell.source,
             language: cell.language,
@@ -114,7 +121,7 @@ export class NotebookModel implements Saveable, Disposable {
 
         this.metadata = this.metadata;
 
-        modelService.onDidCreate(editorModel => {
+        this.modelService.onDidCreate(editorModel => {
             const modelUri = new URI(editorModel.uri);
             if (modelUri.scheme === CellUri.scheme) {
                 const cellUri = CellUri.parse(modelUri);
@@ -142,7 +149,7 @@ export class NotebookModel implements Saveable, Disposable {
         this.dirty = false;
         this.onDirtyChangedEmitter.fire();
 
-        const serializedNotebook = await this.props.serializer.notebookToData({
+        const serializedNotebook = await this.props.serializer.fromNotebook({
             cells: this.cells.map(cell => cell.getData()),
             metadata: this.metadata
         });
@@ -216,6 +223,8 @@ export class NotebookModel implements Saveable, Disposable {
                 cellIndex = edit.index;
             } else if ('handle' in edit) {
                 cellIndex = this.getCellIndexByHandle(edit.handle);
+            } else if ('outputId' in edit) {
+                cellIndex = this.cells.findIndex(cell => cell.outputs.some(output => output.outputId === edit.outputId));
             }
 
             return {
@@ -247,6 +256,7 @@ export class NotebookModel implements Saveable, Disposable {
                     break;
                 }
                 case CellEditType.OutputItems:
+                    cell.changeOutputItems(edit.outputId, !!edit.append, edit.items);
                     break;
                 case CellEditType.Metadata:
                     this.updateNotebookMetadata(edit.metadata, computeUndoRedo);