@codingame/monaco-vscode-notebook-service-override 1.85.1

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

@@ -0,0 +1,511 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { ResourceTextEdit, IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { trimTrailingWhitespace } from 'monaco-editor/esm/vs/editor/common/commands/trimTrailingWhitespaceCommand.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { IEditorWorkerService } from 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
+import { ILanguageFeaturesService } from 'monaco-editor/esm/vs/editor/common/services/languageFeatures.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { applyCodeAction, ApplyCodeActionReason, getCodeActions } from 'monaco-editor/esm/vs/editor/contrib/codeAction/browser/codeAction.js';
+import { CodeActionKind, CodeActionTriggerSource } from 'monaco-editor/esm/vs/editor/contrib/codeAction/common/types.js';
+import { getDocumentFormattingEditsUntilResult } from 'monaco-editor/esm/vs/editor/contrib/format/browser/format.js';
+import { SnippetController2 } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetController2.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { IWorkspaceTrustManagementService } from 'monaco-editor/esm/vs/platform/workspace/common/workspaceTrust.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+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';
+import { IWorkingCopyFileService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService';
+
+let FormatOnSaveParticipant = class FormatOnSaveParticipant {
+    constructor(editorWorkerService, languageFeaturesService, textModelService, bulkEditService, configurationService) {
+        this.editorWorkerService = editorWorkerService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.textModelService = textModelService;
+        this.bulkEditService = bulkEditService;
+        this.configurationService = configurationService;
+    }
+    async participate(workingCopy, context, progress, token) {
+        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
+            return;
+        }
+        if (context.reason === 2 ) {
+            return undefined;
+        }
+        const enabled = this.configurationService.getValue(NotebookSetting.formatOnSave);
+        if (!enabled) {
+            return undefined;
+        }
+        const notebook = workingCopy.model.notebookModel;
+        progress.report({ message: ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+            'notebookFormatSave.formatting',
+            "Formatting"
+        )) });
+        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(
+                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+                'formatNotebook',
+                "Format Notebook"
+            )), code: 'undoredo.formatNotebook', });
+        }
+        finally {
+            progress.report({ increment: 100 });
+            disposable.dispose();
+        }
+    }
+};
+FormatOnSaveParticipant = ( __decorate([
+    ( __param(0, IEditorWorkerService)),
+    ( __param(1, ILanguageFeaturesService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IBulkEditService)),
+    ( __param(4, IConfigurationService))
+], FormatOnSaveParticipant));
+let TrimWhitespaceParticipant = class TrimWhitespaceParticipant {
+    constructor(configurationService, editorService, textModelService, bulkEditService) {
+        this.configurationService = configurationService;
+        this.editorService = editorService;
+        this.textModelService = textModelService;
+        this.bulkEditService = bulkEditService;
+    }
+    async participate(workingCopy, context, progress, _token) {
+        if (this.configurationService.getValue('files.trimTrailingWhitespace')) {
+            await this.doTrimTrailingWhitespace(workingCopy, context.reason === 2 , progress);
+        }
+    }
+    async doTrimTrailingWhitespace(workingCopy, isAutoSaved, progress) {
+        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
+            return;
+        }
+        const disposable = ( new DisposableStore());
+        const notebook = workingCopy.model.notebookModel;
+        const activeCellEditor = getActiveCellCodeEditor(this.editorService);
+        let cursors = [];
+        let prevSelection = [];
+        try {
+            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+                if (cell.cellKind !== CellKind.Code) {
+                    return [];
+                }
+                const ref = await this.textModelService.createModelReference(cell.uri);
+                disposable.add(ref);
+                const model = ref.object.textEditorModel;
+                const isActiveCell = (activeCellEditor && ( cell.uri.toString()) === activeCellEditor.getModel()?.uri.toString());
+                if (isActiveCell) {
+                    prevSelection = activeCellEditor.getSelections() ?? [];
+                    if (isAutoSaved) {
+                        cursors = ( prevSelection.map(s => s.getPosition()));
+                        const snippetsRange = SnippetController2.get(activeCellEditor)?.getSessionEnclosingRange();
+                        if (snippetsRange) {
+                            for (let lineNumber = snippetsRange.startLineNumber; lineNumber <= snippetsRange.endLineNumber; lineNumber++) {
+                                cursors.push(( new Position(lineNumber, model.getLineMaxColumn(lineNumber))));
+                            }
+                        }
+                    }
+                }
+                const ops = trimTrailingWhitespace(model, cursors);
+                if (!ops.length) {
+                    return [];
+                }
+                return ( ops.map(op => ( new ResourceTextEdit(model.uri, { ...op, text: op.text || '' }, model.getVersionId()))));
+            })));
+            const filteredEdits = allCellEdits.flat().filter(edit => edit !== undefined);
+            await this.bulkEditService.apply(filteredEdits, { label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+                'trimNotebookWhitespace',
+                "Notebook Trim Trailing Whitespace"
+            )), code: 'undoredo.notebookTrimTrailingWhitespace' });
+        }
+        finally {
+            progress.report({ increment: 100 });
+            disposable.dispose();
+        }
+    }
+};
+TrimWhitespaceParticipant = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IBulkEditService))
+], TrimWhitespaceParticipant));
+let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant {
+    constructor(configurationService, editorService, bulkEditService) {
+        this.configurationService = configurationService;
+        this.editorService = editorService;
+        this.bulkEditService = bulkEditService;
+    }
+    async participate(workingCopy, context, progress, _token) {
+        if (this.configurationService.getValue('files.trimFinalNewlines')) {
+            await this.doTrimFinalNewLines(workingCopy, context.reason === 2 , progress);
+        }
+    }
+    findLastNonEmptyLine(textBuffer) {
+        for (let lineNumber = textBuffer.getLineCount(); lineNumber >= 1; lineNumber--) {
+            const lineLength = textBuffer.getLineLength(lineNumber);
+            if (lineLength) {
+                return lineNumber;
+            }
+        }
+        return 0;
+    }
+    async doTrimFinalNewLines(workingCopy, isAutoSaved, progress) {
+        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
+            return;
+        }
+        const disposable = ( new DisposableStore());
+        const notebook = workingCopy.model.notebookModel;
+        const activeCellEditor = getActiveCellCodeEditor(this.editorService);
+        try {
+            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+                if (cell.cellKind !== CellKind.Code) {
+                    return;
+                }
+                let cannotTouchLineNumber = 0;
+                const isActiveCell = (activeCellEditor && ( cell.uri.toString()) === activeCellEditor.getModel()?.uri.toString());
+                if (isAutoSaved && isActiveCell) {
+                    const selections = activeCellEditor.getSelections() ?? [];
+                    for (const sel of selections) {
+                        cannotTouchLineNumber = Math.max(cannotTouchLineNumber, sel.selectionStartLineNumber);
+                    }
+                }
+                const textBuffer = cell.textBuffer;
+                const lastNonEmptyLine = this.findLastNonEmptyLine(textBuffer);
+                const deleteFromLineNumber = Math.max(lastNonEmptyLine + 1, cannotTouchLineNumber + 1);
+                const deletionRange = ( new Range(
+                    deleteFromLineNumber,
+                    1,
+                    textBuffer.getLineCount(),
+                    textBuffer.getLineLastNonWhitespaceColumn(textBuffer.getLineCount())
+                ));
+                if (deletionRange.isEmpty()) {
+                    return;
+                }
+                return ( new ResourceTextEdit(
+                    cell.uri,
+                    { range: deletionRange, text: '' },
+                    cell.textModel?.getVersionId()
+                ));
+            })));
+            const filteredEdits = allCellEdits.flat().filter(edit => edit !== undefined);
+            await this.bulkEditService.apply(filteredEdits, { label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+                'trimNotebookNewlines',
+                "Trim Final New Lines"
+            )), code: 'undoredo.trimFinalNewLines' });
+        }
+        finally {
+            progress.report({ increment: 100 });
+            disposable.dispose();
+        }
+    }
+};
+TrimFinalNewLinesParticipant = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, IBulkEditService))
+], TrimFinalNewLinesParticipant));
+let FinalNewLineParticipant = class FinalNewLineParticipant {
+    constructor(configurationService, bulkEditService, editorService) {
+        this.configurationService = configurationService;
+        this.bulkEditService = bulkEditService;
+        this.editorService = editorService;
+    }
+    async participate(workingCopy, context, progress, _token) {
+        if (this.configurationService.getValue(NotebookSetting.insertFinalNewline)) {
+            await this.doInsertFinalNewLine(workingCopy, context.reason === 2 , progress);
+        }
+    }
+    async doInsertFinalNewLine(workingCopy, isAutoSaved, progress) {
+        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
+            return;
+        }
+        const disposable = ( new DisposableStore());
+        const notebook = workingCopy.model.notebookModel;
+        const activeCellEditor = getActiveCellCodeEditor(this.editorService);
+        let selections;
+        if (activeCellEditor) {
+            selections = activeCellEditor.getSelections() ?? [];
+        }
+        try {
+            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+                if (cell.cellKind !== CellKind.Code) {
+                    return;
+                }
+                const lineCount = cell.textBuffer.getLineCount();
+                const lastLineIsEmptyOrWhitespace = cell.textBuffer.getLineFirstNonWhitespaceColumn(lineCount) === 0;
+                if (!lineCount || lastLineIsEmptyOrWhitespace) {
+                    return;
+                }
+                return ( new ResourceTextEdit(cell.uri, { range: ( new Range(
+                    lineCount + 1,
+                    cell.textBuffer.getLineLength(lineCount),
+                    lineCount + 1,
+                    cell.textBuffer.getLineLength(lineCount)
+                )), text: cell.textBuffer.getEOL() }, cell.textModel?.getVersionId()));
+            })));
+            const filteredEdits = allCellEdits.filter(edit => edit !== undefined);
+            await this.bulkEditService.apply(filteredEdits, { label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+                'insertFinalNewLine',
+                "Insert Final New Line"
+            )), code: 'undoredo.insertFinalNewLine' });
+            if (activeCellEditor && selections) {
+                activeCellEditor.setSelections(selections);
+            }
+        }
+        finally {
+            progress.report({ increment: 100 });
+            disposable.dispose();
+        }
+    }
+};
+FinalNewLineParticipant = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IBulkEditService)),
+    ( __param(2, IEditorService))
+], FinalNewLineParticipant));
+let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
+    constructor(configurationService, logService, workspaceTrustManagementService, languageFeaturesService, 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;
+        }
+        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
+            return;
+        }
+        let saveTrigger = '';
+        if (context.reason === 2 ) {
+            return undefined;
+        }
+        else if (context.reason === 1 ) {
+            saveTrigger = 'explicit';
+        }
+        else {
+            return undefined;
+        }
+        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);
+        const includedActions = allCodeActions
+            .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 (!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 1;
+                }
+                return 0;
+            });
+        }
+        progress.report({ message: ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+            'notebookSaveParticipants.notebookCodeActions',
+            "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.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(
+            'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+            'notebookSaveParticipants.cellCodeActions',
+            "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);
+            })));
+        }
+        catch {
+            this.logService.error('Failed to apply code action on save');
+        }
+        finally {
+            progress.report({ increment: 100 });
+            disposable.dispose();
+        }
+    }
+    createCodeActionsOnSave(settingItems) {
+        const kinds = ( settingItems.map(x => ( new CodeActionKind(x))));
+        return kinds.filter(kind => {
+            return kinds.every(otherKind => otherKind.equals(kind) || !otherKind.contains(kind));
+        });
+    }
+    async applyOnSaveActions(model, codeActionsOnSave, excludes, progress, token) {
+        const getActionProgress = new (class {
+            constructor() {
+                this._names = ( new Set());
+            }
+            _report() {
+                progress.report({
+                    message: ( localizeWithPath(
+                        'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+                        { key: 'codeaction.get2', comment: ['[configure]({1}) is a link. Only translate `configure`. Do not change brackets and parentheses or {1}'] },
+                        "Getting code actions from '{0}' ([configure]({1})).",
+                        ( [...this._names].map(name => `'${name}'`)).join(', '),
+                        'command:workbench.action.openSettings?%5B%22editor.codeActionsOnSave%22%5D'
+                    ))
+                });
+            }
+            report(provider) {
+                if (provider.displayName && !( this._names.has(provider.displayName))) {
+                    this._names.add(provider.displayName);
+                    this._report();
+                }
+            }
+        });
+        for (const codeActionKind of codeActionsOnSave) {
+            const actionsToRun = await this.getActionsToRun(model, codeActionKind, excludes, getActionProgress, token);
+            if (token.isCancellationRequested) {
+                actionsToRun.dispose();
+                return;
+            }
+            try {
+                for (const action of actionsToRun.validActions) {
+                    const codeActionEdits = action.action.edit?.edits;
+                    let breakFlag = false;
+                    if (!action.action.kind?.startsWith('notebook')) {
+                        for (const edit of codeActionEdits ?? []) {
+                            const workspaceTextEdit = edit;
+                            if (workspaceTextEdit.resource && isEqual(workspaceTextEdit.resource, model.uri)) {
+                                continue;
+                            }
+                            else {
+                                breakFlag = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (breakFlag) {
+                        this.logService.warn('Failed to apply code action on save, applied to multiple resources.');
+                        continue;
+                    }
+                    progress.report({ message: ( localizeWithPath(
+                        'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+                        'codeAction.apply',
+                        "Applying code action '{0}'.",
+                        action.action.title
+                    )) });
+                    await this.instantiationService.invokeFunction(applyCodeAction, action, ApplyCodeActionReason.OnSave, {}, token);
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+                }
+            }
+            catch {
+            }
+            finally {
+                actionsToRun.dispose();
+            }
+        }
+    }
+    getActionsToRun(model, codeActionKind, excludes, progress, token) {
+        return getCodeActions(this.languageFeaturesService.codeActionProvider, model, model.getFullModelRange(), {
+            type: 1 ,
+            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);
+    const activeCodeEditor = notebookEditor?.activeCodeEditor;
+    return activeCodeEditor;
+}
+let SaveParticipantsContribution = class SaveParticipantsContribution extends Disposable {
+    constructor(instantiationService, workingCopyFileService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.workingCopyFileService = workingCopyFileService;
+        this.registerSaveParticipants();
+    }
+    registerSaveParticipants() {
+        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(TrimWhitespaceParticipant)));
+        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(CodeActionOnSaveParticipant)));
+        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(FormatOnSaveParticipant)));
+        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(FinalNewLineParticipant)));
+        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(TrimFinalNewLinesParticipant)));
+    }
+};
+SaveParticipantsContribution = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkingCopyFileService))
+], SaveParticipantsContribution));
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(SaveParticipantsContribution, 3 );
+
+export { SaveParticipantsContribution };

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

@@ -0,0 +1,168 @@
+import { Disposable, DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { Categories } from 'monaco-editor/esm/vs/platform/action/common/actionCommonCategories.js';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { registerNotebookContribution } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+
+class TroubleshootController extends Disposable {
+    static { this.id = 'workbench.notebook.troubleshoot'; }
+    constructor(_notebookEditor) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._localStore = this._register(( new DisposableStore()));
+        this._cellStateListeners = [];
+        this._enabled = false;
+        this._cellStatusItems = [];
+        this._register(this._notebookEditor.onDidChangeModel(() => {
+            this._update();
+        }));
+        this._update();
+    }
+    toggle() {
+        this._enabled = !this._enabled;
+        this._update();
+    }
+    _update() {
+        this._localStore.clear();
+        this._cellStateListeners.forEach(listener => listener.dispose());
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        this._updateListener();
+    }
+    _log(cell, e) {
+        if (this._enabled) {
+            const oldHeight = this._notebookEditor.getViewHeight(cell);
+            console.log(`cell#${cell.handle}`, e, `${oldHeight} -> ${cell.layoutInfo.totalHeight}`);
+        }
+    }
+    _updateListener() {
+        if (!this._notebookEditor.hasModel()) {
+            return;
+        }
+        for (let i = 0; i < this._notebookEditor.getLength(); i++) {
+            const cell = this._notebookEditor.cellAt(i);
+            this._cellStateListeners.push(cell.onDidChangeLayout(e => {
+                this._log(cell, e);
+            }));
+        }
+        this._localStore.add(this._notebookEditor.onDidChangeViewCells(e => {
+            [...e.splices].reverse().forEach(splice => {
+                const [start, deleted, newCells] = splice;
+                const deletedCells = this._cellStateListeners.splice(start, deleted, ...( newCells.map(cell => {
+                    return cell.onDidChangeLayout((e) => {
+                        this._log(cell, e);
+                    });
+                })));
+                dispose(deletedCells);
+            });
+        }));
+        const vm = this._notebookEditor.getViewModel();
+        let items = [];
+        if (this._enabled) {
+            items = this._getItemsForCells();
+        }
+        this._cellStatusItems = vm.deltaCellStatusBarItems(this._cellStatusItems, items);
+    }
+    _getItemsForCells() {
+        const items = [];
+        for (let i = 0; i < this._notebookEditor.getLength(); i++) {
+            items.push({
+                handle: i,
+                items: [
+                    {
+                        text: `index: ${i}`,
+                        alignment: 1 ,
+                        priority: Number.MAX_SAFE_INTEGER
+                    }
+                ]
+            });
+        }
+        return items;
+    }
+    dispose() {
+        dispose(this._cellStateListeners);
+        super.dispose();
+    }
+}
+registerNotebookContribution(TroubleshootController.id, TroubleshootController);
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.toggleLayoutTroubleshoot',
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/troubleshoot/layout',
+                    'workbench.notebook.toggleLayoutTroubleshoot',
+                    "Toggle Layout Troubleshoot"
+                )),
+                original: 'Toggle Notebook Layout Troubleshoot'
+            },
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!editor) {
+            return;
+        }
+        const controller = editor.getContribution(TroubleshootController.id);
+        controller?.toggle();
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.inspectLayout',
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/troubleshoot/layout',
+                    'workbench.notebook.inspectLayout',
+                    "Inspect Notebook Layout"
+                )),
+                original: 'Inspect Notebook Layout'
+            },
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!editor || !editor.hasModel()) {
+            return;
+        }
+        for (let i = 0; i < editor.getLength(); i++) {
+            const cell = editor.cellAt(i);
+            console.log(`cell#${cell.handle}`, cell.layoutInfo);
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.clearNotebookEdtitorTypeCache',
+            title: {
+                value: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/troubleshoot/layout',
+                    'workbench.notebook.clearNotebookEdtitorTypeCache',
+                    "Clear Notebook Editor Type Cache"
+                )),
+                original: 'Clear Notebook Editor Cache'
+            },
+            category: Categories.Developer,
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const notebookService = accessor.get(INotebookService);
+        notebookService.clearEditorCache();
+    }
+});
+
+export { TroubleshootController };