@codingame/monaco-vscode-notebook-service-override 5.2.0 → 6.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants.js

@@ -6,12 +6,13 @@ import { ResourceTextEdit, IBulkEditService } from 'vscode/vscode/vs/editor/brow
 import { trimTrailingWhitespace } from 'vscode/vscode/vs/editor/common/commands/trimTrailingWhitespaceCommand';
 import { Position } from 'vscode/vscode/vs/editor/common/core/position';
 import { Range } from 'vscode/vscode/vs/editor/common/core/range';
+import { CodeActionTriggerType } from 'vscode/vscode/vs/editor/common/languages';
 import { IEditorWorkerService } from 'vscode/vscode/vs/editor/common/services/editorWorker';
 import { ILanguageFeaturesService } from 'vscode/vscode/vs/editor/common/services/languageFeatures';
 import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
 import { applyCodeAction, ApplyCodeActionReason, getCodeActions } from 'vscode/vscode/vs/editor/contrib/codeAction/browser/codeAction';
 import { CodeActionKind, CodeActionTriggerSource } from 'vscode/vscode/vs/editor/contrib/codeAction/common/types';
-import { getDocumentFormattingEditsUntilResult } from 'vscode/vscode/vs/editor/contrib/format/browser/format';
+import { getDocumentFormattingEditsWithSelectedProvider, FormattingMode } from 'vscode/vscode/vs/editor/contrib/format/browser/format';
 import { SnippetController2 } from 'vscode/vscode/vs/editor/contrib/snippet/browser/snippetController2';
 import { localizeWithPath } from 'vscode/vscode/vs/nls';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
@@ -20,17 +21,20 @@ import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
 import { IWorkspaceTrustManagementService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust.service';
 import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { SaveReason } from 'vscode/vscode/vs/workbench/common/editor';
 import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
 import { NotebookSetting, CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { NotebookFileWorkingCopyModel } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
+import { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service';
 
 const _moduleId = "vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants";
 let FormatOnSaveParticipant = class FormatOnSaveParticipant {
-    constructor(editorWorkerService, languageFeaturesService, textModelService, bulkEditService, configurationService) {
+    constructor(editorWorkerService, languageFeaturesService, instantiationService, textModelService, bulkEditService, configurationService) {
         this.editorWorkerService = editorWorkerService;
         this.languageFeaturesService = languageFeaturesService;
+        this.instantiationService = instantiationService;
         this.textModelService = textModelService;
         this.bulkEditService = bulkEditService;
         this.configurationService = configurationService;
@@ -39,32 +43,35 @@ let FormatOnSaveParticipant = class FormatOnSaveParticipant {
         if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
             return;
         }
-        if (context.reason === 2 ) {
+        if (context.reason === SaveReason.AUTO) {
             return undefined;
         }
         const enabled = this.configurationService.getValue(NotebookSetting.formatOnSave);
         if (!enabled) {
             return undefined;
         }
-        const notebook = workingCopy.model.notebookModel;
         progress.report({ message: ( localizeWithPath(_moduleId, 0, "Formatting")) });
+        const notebook = workingCopy.model.notebookModel;
+        const formatApplied = await this.instantiationService.invokeFunction(CodeActionParticipantUtils.checkAndRunFormatCodeAction, notebook, progress, token);
         const disposable = ( (new DisposableStore()));
         try {
-            const allCellEdits = await Promise.all(( (notebook.cells.map(async (cell) => {
-                const ref = await this.textModelService.createModelReference(cell.uri);
-                disposable.add(ref);
-                const model = ref.object.textEditorModel;
-                const formatEdits = await getDocumentFormattingEditsUntilResult(this.editorWorkerService, this.languageFeaturesService, model, model.getOptions(), token);
-                const edits = [];
-                if (formatEdits) {
-                    edits.push(...( (formatEdits.map(
-                        edit => ( (new ResourceTextEdit(model.uri, edit, model.getVersionId())))
-                    ))));
-                    return edits;
-                }
-                return [];
-            }))));
-            await this.bulkEditService.apply( allCellEdits.flat(), { label: ( localizeWithPath(_moduleId, 1, "Format Notebook")), code: 'undoredo.formatNotebook', });
+            if (!formatApplied) {
+                const allCellEdits = await Promise.all(( (notebook.cells.map(async (cell) => {
+                    const ref = await this.textModelService.createModelReference(cell.uri);
+                    disposable.add(ref);
+                    const model = ref.object.textEditorModel;
+                    const formatEdits = await getDocumentFormattingEditsWithSelectedProvider(this.editorWorkerService, this.languageFeaturesService, model, FormattingMode.Silent, token);
+                    const edits = [];
+                    if (formatEdits) {
+                        edits.push(...( (formatEdits.map(
+                            edit => ( (new ResourceTextEdit(model.uri, edit, model.getVersionId())))
+                        ))));
+                        return edits;
+                    }
+                    return [];
+                }))));
+                await this.bulkEditService.apply( allCellEdits.flat(), { label: ( localizeWithPath(_moduleId, 1, "Format Notebook")), code: 'undoredo.formatNotebook', });
+            }
         }
         finally {
             progress.report({ increment: 100 });
@@ -75,9 +82,10 @@ let FormatOnSaveParticipant = class FormatOnSaveParticipant {
 FormatOnSaveParticipant = ( (__decorate([
     ( (__param(0, IEditorWorkerService))),
     ( (__param(1, ILanguageFeaturesService))),
-    ( (__param(2, ITextModelService))),
-    ( (__param(3, IBulkEditService))),
-    ( (__param(4, IConfigurationService)))
+    ( (__param(2, IInstantiationService))),
+    ( (__param(3, ITextModelService))),
+    ( (__param(4, IBulkEditService))),
+    ( (__param(5, IConfigurationService)))
 ], FormatOnSaveParticipant)));
 let TrimWhitespaceParticipant = class TrimWhitespaceParticipant {
     constructor(configurationService, editorService, textModelService, bulkEditService) {
@@ -90,7 +98,7 @@ let TrimWhitespaceParticipant = class TrimWhitespaceParticipant {
         const trimTrailingWhitespaceOption = this.configurationService.getValue('files.trimTrailingWhitespace');
         const trimInRegexAndStrings = this.configurationService.getValue('files.trimTrailingWhitespaceInRegexAndStrings');
         if (trimTrailingWhitespaceOption) {
-            await this.doTrimTrailingWhitespace(workingCopy, context.reason === 2 , trimInRegexAndStrings, progress);
+            await this.doTrimTrailingWhitespace(workingCopy, context.reason === SaveReason.AUTO, trimInRegexAndStrings, progress);
         }
     }
     async doTrimTrailingWhitespace(workingCopy, isAutoSaved, trimInRegexesAndStrings, progress) {
@@ -156,7 +164,7 @@ let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant {
     }
     async participate(workingCopy, context, progress, _token) {
         if (this.configurationService.getValue('files.trimFinalNewlines')) {
-            await this.doTrimFinalNewLines(workingCopy, context.reason === 2 , progress);
+            await this.doTrimFinalNewLines(workingCopy, context.reason === SaveReason.AUTO, progress);
         }
     }
     findLastNonEmptyLine(textBuffer) {
@@ -233,7 +241,7 @@ let InsertFinalNewLineParticipant = class InsertFinalNewLineParticipant {
     }
     async participate(workingCopy, context, progress, _token) {
         if (this.configurationService.getValue(NotebookSetting.insertFinalNewline)) {
-            await this.doInsertFinalNewLine(workingCopy, context.reason === 2 , progress);
+            await this.doInsertFinalNewLine(workingCopy, context.reason === SaveReason.AUTO, progress);
         }
     }
     async doInsertFinalNewLine(workingCopy, isAutoSaved, progress) {
@@ -284,16 +292,14 @@ InsertFinalNewLineParticipant = ( (__decorate([
     ( (__param(2, IEditorService)))
 ], InsertFinalNewLineParticipant)));
 let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
-    constructor(configurationService, logService, workspaceTrustManagementService, languageFeaturesService, textModelService, instantiationService) {
+    constructor(configurationService, logService, workspaceTrustManagementService, textModelService, instantiationService) {
         this.configurationService = configurationService;
         this.logService = logService;
         this.workspaceTrustManagementService = workspaceTrustManagementService;
-        this.languageFeaturesService = languageFeaturesService;
         this.textModelService = textModelService;
         this.instantiationService = instantiationService;
     }
     async participate(workingCopy, context, progress, token) {
-        const nbDisposable = ( (new DisposableStore()));
         const isTrusted = this.workspaceTrustManagementService.isWorkspaceTrusted();
         if (!isTrusted) {
             return;
@@ -302,10 +308,10 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
             return;
         }
         let saveTrigger = '';
-        if (context.reason === 2 ) {
+        if (context.reason === SaveReason.AUTO) {
             return undefined;
         }
-        else if (context.reason === 1 ) {
+        else if (context.reason === SaveReason.EXPLICIT) {
             saveTrigger = 'explicit';
         }
         else {
@@ -313,15 +319,9 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
         }
         const notebookModel = workingCopy.model.notebookModel;
         const setting = this.configurationService.getValue(NotebookSetting.codeActionsOnSave);
-        if (!setting) {
-            return undefined;
-        }
         const settingItems = Array.isArray(setting)
             ? setting
             : ( (Object.keys(setting))).filter(x => setting[x]);
-        if (!settingItems.length) {
-            return undefined;
-        }
         const allCodeActions = this.createCodeActionsOnSave(settingItems);
         const excludedActions = allCodeActions
             .filter(x => setting[x.value] === 'never' || setting[x.value] === false);
@@ -329,63 +329,102 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
             .filter(x => setting[x.value] === saveTrigger || setting[x.value] === true);
         const editorCodeActionsOnSave = includedActions.filter(x => !CodeActionKind.Notebook.contains(x));
         const notebookCodeActionsOnSave = includedActions.filter(x => CodeActionKind.Notebook.contains(x));
-        if (!editorCodeActionsOnSave.length && !notebookCodeActionsOnSave.length) {
-            return undefined;
+        if (notebookCodeActionsOnSave.length) {
+            const nbDisposable = ( (new DisposableStore()));
+            progress.report({ message: ( localizeWithPath(_moduleId, 5, "Running 'Notebook' code actions")) });
+            try {
+                const cell = notebookModel.cells[0];
+                const ref = await this.textModelService.createModelReference(cell.uri);
+                nbDisposable.add(ref);
+                const textEditorModel = ref.object.textEditorModel;
+                await this.instantiationService.invokeFunction(CodeActionParticipantUtils.applyOnSaveGenericCodeActions, textEditorModel, notebookCodeActionsOnSave, excludedActions, progress, token);
+            }
+            catch {
+                this.logService.error('Failed to apply notebook code action on save');
+            }
+            finally {
+                progress.report({ increment: 100 });
+                nbDisposable.dispose();
+            }
         }
-        if (!Array.isArray(setting)) {
-            editorCodeActionsOnSave.sort((a, b) => {
-                if (CodeActionKind.SourceFixAll.contains(a)) {
+        if (editorCodeActionsOnSave.length) {
+            if (!Array.isArray(setting)) {
+                editorCodeActionsOnSave.sort((a, b) => {
+                    if (CodeActionKind.SourceFixAll.contains(a)) {
+                        if (CodeActionKind.SourceFixAll.contains(b)) {
+                            return 0;
+                        }
+                        return -1;
+                    }
                     if (CodeActionKind.SourceFixAll.contains(b)) {
-                        return 0;
+                        return 1;
                     }
-                    return -1;
-                }
-                if (CodeActionKind.SourceFixAll.contains(b)) {
-                    return 1;
-                }
-                return 0;
-            });
+                    return 0;
+                });
+            }
+            const cellDisposable = ( (new DisposableStore()));
+            progress.report({ message: ( localizeWithPath(_moduleId, 6, "Running 'Cell' code actions")) });
+            try {
+                await Promise.all(( (notebookModel.cells.map(async (cell) => {
+                    const ref = await this.textModelService.createModelReference(cell.uri);
+                    cellDisposable.add(ref);
+                    const textEditorModel = ref.object.textEditorModel;
+                    await this.instantiationService.invokeFunction(CodeActionParticipantUtils.applyOnSaveGenericCodeActions, textEditorModel, editorCodeActionsOnSave, excludedActions, progress, token);
+                }))));
+            }
+            catch {
+                this.logService.error('Failed to apply code action on save');
+            }
+            finally {
+                progress.report({ increment: 100 });
+                cellDisposable.dispose();
+            }
         }
-        progress.report({ message: ( localizeWithPath(_moduleId, 5, "Running 'Notebook' code actions")) });
+    }
+    createCodeActionsOnSave(settingItems) {
+        const kinds = ( (settingItems.map(x => ( (new HierarchicalKind(x))))));
+        return kinds.filter(kind => {
+            return kinds.every(otherKind => otherKind.equals(kind) || !otherKind.contains(kind));
+        });
+    }
+};
+CodeActionOnSaveParticipant = ( (__decorate([
+    ( (__param(0, IConfigurationService))),
+    ( (__param(1, ILogService))),
+    ( (__param(2, IWorkspaceTrustManagementService))),
+    ( (__param(3, ITextModelService))),
+    ( (__param(4, IInstantiationService)))
+], CodeActionOnSaveParticipant)));
+class CodeActionParticipantUtils {
+    static async checkAndRunFormatCodeAction(accessor, notebookModel, progress, token) {
+        const instantiationService = accessor.get(IInstantiationService);
+        const textModelService = accessor.get(ITextModelService);
+        const logService = accessor.get(ILogService);
+        const configurationService = accessor.get(IConfigurationService);
+        const formatDisposable = ( (new DisposableStore()));
+        let formatResult = false;
+        progress.report({ message: ( localizeWithPath(_moduleId, 7, "Running 'Format' code actions")) });
         try {
             const cell = notebookModel.cells[0];
-            const ref = await this.textModelService.createModelReference(cell.uri);
-            nbDisposable.add(ref);
+            const ref = await textModelService.createModelReference(cell.uri);
+            formatDisposable.add(ref);
             const textEditorModel = ref.object.textEditorModel;
-            await this.applyOnSaveActions(textEditorModel, notebookCodeActionsOnSave, excludedActions, progress, token);
-        }
-        catch {
-            this.logService.error('Failed to apply notebook code action on save');
-        }
-        finally {
-            progress.report({ increment: 100 });
-            nbDisposable.dispose();
-        }
-        const disposable = ( (new DisposableStore()));
-        progress.report({ message: ( localizeWithPath(_moduleId, 6, "Running 'Cell' code actions")) });
-        try {
-            await Promise.all(( (notebookModel.cells.map(async (cell) => {
-                const ref = await this.textModelService.createModelReference(cell.uri);
-                disposable.add(ref);
-                const textEditorModel = ref.object.textEditorModel;
-                await this.applyOnSaveActions(textEditorModel, editorCodeActionsOnSave, excludedActions, progress, token);
-            }))));
+            const defaultFormatterExtId = configurationService.getValue(NotebookSetting.defaultFormatter);
+            formatResult = await instantiationService.invokeFunction(CodeActionParticipantUtils.applyOnSaveFormatCodeAction, textEditorModel, ( (new HierarchicalKind('notebook.format'))), [], defaultFormatterExtId, progress, token);
         }
         catch {
-            this.logService.error('Failed to apply code action on save');
+            logService.error('Failed to apply notebook format action on save');
         }
         finally {
             progress.report({ increment: 100 });
-            disposable.dispose();
+            formatDisposable.dispose();
         }
+        return formatResult;
     }
-    createCodeActionsOnSave(settingItems) {
-        const kinds = ( (settingItems.map(x => ( (new HierarchicalKind(x))))));
-        return kinds.filter(kind => {
-            return kinds.every(otherKind => otherKind.equals(kind) || !otherKind.contains(kind));
-        });
-    }
-    async applyOnSaveActions(model, codeActionsOnSave, excludes, progress, token) {
+    static async applyOnSaveGenericCodeActions(accessor, model, codeActionsOnSave, excludes, progress, token) {
+        const instantiationService = accessor.get(IInstantiationService);
+        const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+        const logService = accessor.get(ILogService);
         const getActionProgress = new (class {
             constructor() {
                 this._names = ( (new Set()));
@@ -394,10 +433,10 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
                 progress.report({
                     message: ( localizeWithPath(
                         _moduleId,
-                        7,
+                        8,
                         "Getting code actions from '{0}' ([configure]({1})).",
                         ( ([...this._names].map(name => `'${name}'`))).join(', '),
-                        'command:workbench.action.openSettings?%5B%22editor.codeActionsOnSave%22%5D'
+                        'command:workbench.action.openSettings?%5B%22notebook.codeActionsOnSave%22%5D'
                     ))
                 });
             }
@@ -409,7 +448,7 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
             }
         });
         for (const codeActionKind of codeActionsOnSave) {
-            const actionsToRun = await this.getActionsToRun(model, codeActionKind, excludes, getActionProgress, token);
+            const actionsToRun = await this.getActionsToRun(model, codeActionKind, excludes, languageFeaturesService, getActionProgress, token);
             if (token.isCancellationRequested) {
                 actionsToRun.dispose();
                 return;
@@ -431,11 +470,11 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
                         }
                     }
                     if (breakFlag) {
-                        this.logService.warn('Failed to apply code action on save, applied to multiple resources.');
+                        logService.warn('Failed to apply code action on save, applied to multiple resources.');
                         continue;
                     }
-                    progress.report({ message: ( localizeWithPath(_moduleId, 8, "Applying code action '{0}'.", action.action.title)) });
-                    await this.instantiationService.invokeFunction(applyCodeAction, action, ApplyCodeActionReason.OnSave, {}, token);
+                    progress.report({ message: ( localizeWithPath(_moduleId, 9, "Applying code action '{0}'.", action.action.title)) });
+                    await instantiationService.invokeFunction(applyCodeAction, action, ApplyCodeActionReason.OnSave, {}, token);
                     if (token.isCancellationRequested) {
                         return;
                     }
@@ -448,22 +487,68 @@ let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
             }
         }
     }
-    getActionsToRun(model, codeActionKind, excludes, progress, token) {
-        return getCodeActions(this.languageFeaturesService.codeActionProvider, model, model.getFullModelRange(), {
-            type: 1 ,
+    static async applyOnSaveFormatCodeAction(accessor, model, formatCodeActionOnSave, excludes, extensionId, progress, token) {
+        const instantiationService = accessor.get(IInstantiationService);
+        const languageFeaturesService = accessor.get(ILanguageFeaturesService);
+        const logService = accessor.get(ILogService);
+        const getActionProgress = new (class {
+            constructor() {
+                this._names = ( (new Set()));
+            }
+            _report() {
+                progress.report({
+                    message: ( localizeWithPath(
+                        _moduleId,
+                        8,
+                        "Getting code actions from '{0}' ([configure]({1})).",
+                        ( ([...this._names].map(name => `'${name}'`))).join(', '),
+                        'command:workbench.action.openSettings?%5B%22notebook.defaultFormatter%22%5D'
+                    ))
+                });
+            }
+            report(provider) {
+                if (provider.displayName && !( (this._names.has(provider.displayName)))) {
+                    this._names.add(provider.displayName);
+                    this._report();
+                }
+            }
+        });
+        const providedActions = await CodeActionParticipantUtils.getActionsToRun(model, formatCodeActionOnSave, excludes, languageFeaturesService, getActionProgress, token);
+        if (providedActions.validActions.length > 1 && !extensionId) {
+            logService.warn('More than one format code action is provided, the 0th one will be used. A default can be specified via `notebook.defaultFormatter` in your settings.');
+        }
+        if (token.isCancellationRequested) {
+            providedActions.dispose();
+            return false;
+        }
+        try {
+            const action = extensionId ? providedActions.validActions.find(action => action.provider?.extensionId === extensionId) : providedActions.validActions[0];
+            if (!action) {
+                return false;
+            }
+            progress.report({ message: ( localizeWithPath(_moduleId, 9, "Applying code action '{0}'.", action.action.title)) });
+            await instantiationService.invokeFunction(applyCodeAction, action, ApplyCodeActionReason.OnSave, {}, token);
+            if (token.isCancellationRequested) {
+                return false;
+            }
+        }
+        catch {
+            logService.error('Failed to apply notebook format code action on save');
+            return false;
+        }
+        finally {
+            providedActions.dispose();
+        }
+        return true;
+    }
+    static getActionsToRun(model, codeActionKind, excludes, languageFeaturesService, progress, token) {
+        return getCodeActions(languageFeaturesService.codeActionProvider, model, model.getFullModelRange(), {
+            type: CodeActionTriggerType.Invoke,
             triggerAction: CodeActionTriggerSource.OnSave,
             filter: { include: codeActionKind, excludes: excludes, includeSourceActions: true },
         }, progress, token);
     }
-};
-CodeActionOnSaveParticipant = ( (__decorate([
-    ( (__param(0, IConfigurationService))),
-    ( (__param(1, ILogService))),
-    ( (__param(2, IWorkspaceTrustManagementService))),
-    ( (__param(3, ILanguageFeaturesService))),
-    ( (__param(4, ITextModelService))),
-    ( (__param(5, IInstantiationService)))
-], CodeActionOnSaveParticipant)));
+}
 function getActiveCellCodeEditor(editorService) {
     const activePane = editorService.activeEditorPane;
     const notebookEditor = getNotebookEditorFromEditorPane(activePane);
@@ -490,6 +575,6 @@ SaveParticipantsContribution = ( (__decorate([
     ( (__param(1, IWorkingCopyFileService)))
 ], SaveParticipantsContribution)));
 const workbenchContributionsRegistry = ( (Registry.as(Extensions.Workbench)));
-workbenchContributionsRegistry.registerWorkbenchContribution(SaveParticipantsContribution, 3 );
+workbenchContributionsRegistry.registerWorkbenchContribution(SaveParticipantsContribution, LifecyclePhase.Restored);
 
-export { SaveParticipantsContribution };
+export { CodeActionParticipantUtils, SaveParticipantsContribution };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/troubleshoot/layout.js

@@ -4,6 +4,7 @@ import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommon
 import { registerAction2, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
 import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
 import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { CellStatusbarAlignment } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 
@@ -76,7 +77,7 @@ class TroubleshootController extends Disposable {
                 items: [
                     {
                         text: `index: ${i}`,
-                        alignment: 1 ,
+                        alignment: CellStatusbarAlignment.Left,
                         priority: Number.MAX_SAFE_INTEGER
                     }
                 ]

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/undoRedo/notebookUndoRedo.js

@@ -1,6 +1,6 @@
 import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
+import { registerWorkbenchContribution2, WorkbenchPhase } from 'vscode/vscode/vs/workbench/common/contributions';
 import { CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 import { getNotebookEditorFromEditorPane, CellEditState } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
@@ -53,4 +53,4 @@ let NotebookUndoRedoContribution = class NotebookUndoRedoContribution extends Di
 NotebookUndoRedoContribution = ( __decorate([
     ( __param(0, IEditorService))
 ], NotebookUndoRedoContribution));
-registerWorkbenchContribution2(NotebookUndoRedoContribution.ID, NotebookUndoRedoContribution, 2 );
+registerWorkbenchContribution2(NotebookUndoRedoContribution.ID, NotebookUndoRedoContribution, WorkbenchPhase.BlockRestore);

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/viewportWarmup/viewportWarmup.js

@@ -2,7 +2,7 @@ import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility.service';
-import { CellEditState } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { CellEditState, RenderOutputType } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
 import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
 import { outputDisplayLimit } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/viewModel/codeCellViewModel';
 import { CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
@@ -82,7 +82,7 @@ let NotebookViewportContribution = class NotebookViewportContribution extends Di
             if (!renderer) {
                 return;
             }
-            const result = { type: 1 , renderer, source: output, mimeType: pickedMimeTypeRenderer.mimeType };
+            const result = { type: RenderOutputType.Extension, renderer, source: output, mimeType: pickedMimeTypeRenderer.mimeType };
             this._notebookEditor.createOutput(viewCell, result, 0, true);
         }
     }