@codingame/monaco-vscode-notebook-service-override 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/clipboard/notebookClipboard.js

@@ -1,488 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath, localize2WithPath } from 'vscode/vscode/vs/nls';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { registerWorkbenchContribution2 } from 'vscode/vscode/vs/workbench/common/contributions';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CELL_EDITABLE } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
-import { getNotebookEditorFromEditorPane, expandCellRangesWithHiddenCells, cellRangeToViewCells } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
-import { CopyAction, PasteAction, CutAction } from 'vscode/vscode/vs/editor/contrib/clipboard/browser/clipboard';
-import { IClipboardService } from 'vscode/vscode/vs/platform/clipboard/common/clipboardService';
-import { cloneNotebookCellTextModel } from 'vscode/vscode/vs/workbench/contrib/notebook/common/model/notebookCellTextModel';
-import { SelectionStateType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
-import { isNative } from 'vscode/vscode/vs/base/common/platform';
-import { registerAction2, MenuId, Action2 } from 'vscode/vscode/vs/platform/actions/common/actions';
-import { NotebookCellAction, NotebookAction, NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
-import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
-import { InputFocusedContextKey } from 'vscode/vscode/vs/platform/contextkey/common/contextkeys';
-import { UndoCommand, RedoCommand } from 'vscode/vscode/vs/editor/browser/editorExtensions';
-import { Categories } from 'vscode/vscode/vs/platform/action/common/actionCommonCategories';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
-import { showWindowLogActionId } from 'vscode/vscode/vs/workbench/services/log/common/logConstants';
-import { getWindow, getActiveElement, isAncestor } from 'vscode/vscode/vs/base/browser/dom';
-
-let _logging = false;
-function toggleLogging() {
-    _logging = !_logging;
-}
-function _log(loggerService, str) {
-    if (_logging) {
-        loggerService.info(`[NotebookClipboard]: ${str}`);
-    }
-}
-function getFocusedWebviewDelegate(accessor) {
-    const loggerService = accessor.get(ILogService);
-    const editorService = accessor.get(IEditorService);
-    const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
-    if (!editor) {
-        _log(loggerService, '[Revive Webview] No notebook editor found for active editor pane, bypass');
-        return;
-    }
-    if (!editor.hasEditorFocus()) {
-        _log(loggerService, '[Revive Webview] Notebook editor is not focused, bypass');
-        return;
-    }
-    if (!editor.hasWebviewFocus()) {
-        _log(loggerService, '[Revive Webview] Notebook editor backlayer webview is not focused, bypass');
-        return;
-    }
-    const webview = editor.getInnerWebview();
-    _log(loggerService, '[Revive Webview] Notebook editor backlayer webview is focused');
-    return webview;
-}
-function withWebview(accessor, f) {
-    const webview = getFocusedWebviewDelegate(accessor);
-    if (webview) {
-        f(webview);
-        return true;
-    }
-    return false;
-}
-const PRIORITY = 105;
-UndoCommand.addImplementation(PRIORITY, 'notebook-webview', accessor => {
-    return withWebview(accessor, webview => webview.undo());
-});
-RedoCommand.addImplementation(PRIORITY, 'notebook-webview', accessor => {
-    return withWebview(accessor, webview => webview.redo());
-});
-CopyAction?.addImplementation(PRIORITY, 'notebook-webview', accessor => {
-    return withWebview(accessor, webview => webview.copy());
-});
-PasteAction?.addImplementation(PRIORITY, 'notebook-webview', accessor => {
-    return withWebview(accessor, webview => webview.paste());
-});
-CutAction?.addImplementation(PRIORITY, 'notebook-webview', accessor => {
-    return withWebview(accessor, webview => webview.cut());
-});
-function runPasteCells(editor, activeCell, pasteCells) {
-    if (!editor.hasModel()) {
-        return false;
-    }
-    const textModel = editor.textModel;
-    if (editor.isReadOnly) {
-        return false;
-    }
-    const originalState = {
-        kind: SelectionStateType.Index,
-        focus: editor.getFocus(),
-        selections: editor.getSelections()
-    };
-    if (activeCell) {
-        const currCellIndex = editor.getCellIndex(activeCell);
-        const newFocusIndex = typeof currCellIndex === 'number' ? currCellIndex + 1 : 0;
-        textModel.applyEdits([
-            {
-                editType: 1 ,
-                index: newFocusIndex,
-                count: 0,
-                cells: ( pasteCells.items.map(cell => cloneNotebookCellTextModel(cell)))
-            }
-        ], true, originalState, () => ({
-            kind: SelectionStateType.Index,
-            focus: { start: newFocusIndex, end: newFocusIndex + 1 },
-            selections: [{ start: newFocusIndex, end: newFocusIndex + pasteCells.items.length }]
-        }), undefined, true);
-    }
-    else {
-        if (editor.getLength() !== 0) {
-            return false;
-        }
-        textModel.applyEdits([
-            {
-                editType: 1 ,
-                index: 0,
-                count: 0,
-                cells: ( pasteCells.items.map(cell => cloneNotebookCellTextModel(cell)))
-            }
-        ], true, originalState, () => ({
-            kind: SelectionStateType.Index,
-            focus: { start: 0, end: 1 },
-            selections: [{ start: 1, end: pasteCells.items.length + 1 }]
-        }), undefined, true);
-    }
-    return true;
-}
-function runCopyCells(accessor, editor, targetCell) {
-    if (!editor.hasModel()) {
-        return false;
-    }
-    if (editor.hasOutputTextSelection()) {
-        getWindow(editor.getDomNode()).document.execCommand('copy');
-        return true;
-    }
-    const clipboardService = accessor.get(IClipboardService);
-    const notebookService = accessor.get(INotebookService);
-    const selections = editor.getSelections();
-    if (targetCell) {
-        const targetCellIndex = editor.getCellIndex(targetCell);
-        const containingSelection = selections.find(selection => selection.start <= targetCellIndex && targetCellIndex < selection.end);
-        if (!containingSelection) {
-            clipboardService.writeText(targetCell.getText());
-            notebookService.setToCopy([targetCell.model], true);
-            return true;
-        }
-    }
-    const selectionRanges = expandCellRangesWithHiddenCells(editor, editor.getSelections());
-    const selectedCells = cellRangeToViewCells(editor, selectionRanges);
-    if (!selectedCells.length) {
-        return false;
-    }
-    clipboardService.writeText(( selectedCells.map(cell => cell.getText())).join('\n'));
-    notebookService.setToCopy(( selectedCells.map(cell => cell.model)), true);
-    return true;
-}
-function runCutCells(accessor, editor, targetCell) {
-    if (!editor.hasModel() || editor.isReadOnly) {
-        return false;
-    }
-    const textModel = editor.textModel;
-    const clipboardService = accessor.get(IClipboardService);
-    const notebookService = accessor.get(INotebookService);
-    const selections = editor.getSelections();
-    if (targetCell) {
-        const targetCellIndex = editor.getCellIndex(targetCell);
-        const containingSelection = selections.find(selection => selection.start <= targetCellIndex && targetCellIndex < selection.end);
-        if (!containingSelection) {
-            clipboardService.writeText(targetCell.getText());
-            const focus = editor.getFocus();
-            const newFocus = focus.end <= targetCellIndex ? focus : { start: focus.start - 1, end: focus.end - 1 };
-            const newSelections = ( selections.map(
-                selection => (selection.end <= targetCellIndex ? selection : { start: selection.start - 1, end: selection.end - 1 })
-            ));
-            textModel.applyEdits([
-                { editType: 1 , index: targetCellIndex, count: 1, cells: [] }
-            ], true, { kind: SelectionStateType.Index, focus: editor.getFocus(), selections: selections }, () => ({ kind: SelectionStateType.Index, focus: newFocus, selections: newSelections }), undefined, true);
-            notebookService.setToCopy([targetCell.model], false);
-            return true;
-        }
-    }
-    const focus = editor.getFocus();
-    const containingSelection = selections.find(selection => selection.start <= focus.start && focus.end <= selection.end);
-    if (!containingSelection) {
-        const targetCell = editor.cellAt(focus.start);
-        clipboardService.writeText(targetCell.getText());
-        const newFocus = focus.end === editor.getLength() ? { start: focus.start - 1, end: focus.end - 1 } : focus;
-        const newSelections = ( selections.map(
-            selection => (selection.end <= focus.start ? selection : { start: selection.start - 1, end: selection.end - 1 })
-        ));
-        textModel.applyEdits([
-            { editType: 1 , index: focus.start, count: 1, cells: [] }
-        ], true, { kind: SelectionStateType.Index, focus: editor.getFocus(), selections: selections }, () => ({ kind: SelectionStateType.Index, focus: newFocus, selections: newSelections }), undefined, true);
-        notebookService.setToCopy([targetCell.model], false);
-        return true;
-    }
-    const selectionRanges = expandCellRangesWithHiddenCells(editor, editor.getSelections());
-    const selectedCells = cellRangeToViewCells(editor, selectionRanges);
-    if (!selectedCells.length) {
-        return false;
-    }
-    clipboardService.writeText(( selectedCells.map(cell => cell.getText())).join('\n'));
-    const edits = ( selectionRanges.map(
-        range => ({ editType: 1 , index: range.start, count: range.end - range.start, cells: [] })
-    ));
-    const firstSelectIndex = selectionRanges[0].start;
-    const newFocusedCellIndex = firstSelectIndex < textModel.cells.length - 1
-        ? firstSelectIndex
-        : Math.max(textModel.cells.length - 2, 0);
-    textModel.applyEdits(edits, true, { kind: SelectionStateType.Index, focus: editor.getFocus(), selections: selectionRanges }, () => {
-        return {
-            kind: SelectionStateType.Index,
-            focus: { start: newFocusedCellIndex, end: newFocusedCellIndex + 1 },
-            selections: [{ start: newFocusedCellIndex, end: newFocusedCellIndex + 1 }]
-        };
-    }, undefined, true);
-    notebookService.setToCopy(( selectedCells.map(cell => cell.model)), false);
-    return true;
-}
-let NotebookClipboardContribution = class NotebookClipboardContribution extends Disposable {
-    static { this.ID = 'workbench.contrib.notebookClipboard'; }
-    constructor(_editorService) {
-        super();
-        this._editorService = _editorService;
-        const PRIORITY = 105;
-        if (CopyAction) {
-            this._register(CopyAction.addImplementation(PRIORITY, 'notebook-clipboard', accessor => {
-                return this.runCopyAction(accessor);
-            }));
-        }
-        if (PasteAction) {
-            this._register(PasteAction.addImplementation(PRIORITY, 'notebook-clipboard', accessor => {
-                return this.runPasteAction(accessor);
-            }));
-        }
-        if (CutAction) {
-            this._register(CutAction.addImplementation(PRIORITY, 'notebook-clipboard', accessor => {
-                return this.runCutAction(accessor);
-            }));
-        }
-    }
-    _getContext() {
-        const editor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
-        const activeCell = editor?.getActiveCell();
-        return {
-            editor,
-            activeCell
-        };
-    }
-    _focusInsideEmebedMonaco(editor) {
-        const windowSelection = getWindow(editor.getDomNode()).getSelection();
-        if (windowSelection?.rangeCount !== 1) {
-            return false;
-        }
-        const activeSelection = windowSelection.getRangeAt(0);
-        if (activeSelection.startContainer === activeSelection.endContainer && activeSelection.endOffset - activeSelection.startOffset === 0) {
-            return false;
-        }
-        let container = activeSelection.commonAncestorContainer;
-        const body = editor.getDomNode();
-        if (!body.contains(container)) {
-            return false;
-        }
-        while (container
-            &&
-                container !== body) {
-            if (container.classList && container.classList.contains('monaco-editor')) {
-                return true;
-            }
-            container = container.parentNode;
-        }
-        return false;
-    }
-    runCopyAction(accessor) {
-        const loggerService = accessor.get(ILogService);
-        const activeElement = getActiveElement();
-        if (activeElement instanceof HTMLElement && ['input', 'textarea'].indexOf(activeElement.tagName.toLowerCase()) >= 0) {
-            _log(loggerService, '[NotebookEditor] focus is on input or textarea element, bypass');
-            return false;
-        }
-        const { editor } = this._getContext();
-        if (!editor) {
-            _log(loggerService, '[NotebookEditor] no active notebook editor, bypass');
-            return false;
-        }
-        if (!isAncestor(activeElement, editor.getDomNode())) {
-            _log(loggerService, '[NotebookEditor] focus is outside of the notebook editor, bypass');
-            return false;
-        }
-        if (this._focusInsideEmebedMonaco(editor)) {
-            _log(loggerService, '[NotebookEditor] focus is on embed monaco editor, bypass');
-            return false;
-        }
-        _log(loggerService, '[NotebookEditor] run copy actions on notebook model');
-        return runCopyCells(accessor, editor, undefined);
-    }
-    runPasteAction(accessor) {
-        const activeElement = getActiveElement();
-        if (activeElement && ['input', 'textarea'].indexOf(activeElement.tagName.toLowerCase()) >= 0) {
-            return false;
-        }
-        const notebookService = accessor.get(INotebookService);
-        const pasteCells = notebookService.getToCopy();
-        if (!pasteCells) {
-            return false;
-        }
-        const { editor, activeCell } = this._getContext();
-        if (!editor) {
-            return false;
-        }
-        return runPasteCells(editor, activeCell, pasteCells);
-    }
-    runCutAction(accessor) {
-        const activeElement = getActiveElement();
-        if (activeElement && ['input', 'textarea'].indexOf(activeElement.tagName.toLowerCase()) >= 0) {
-            return false;
-        }
-        const { editor } = this._getContext();
-        if (!editor) {
-            return false;
-        }
-        return runCutCells(accessor, editor, undefined);
-    }
-};
-NotebookClipboardContribution = ( __decorate([
-    ( __param(0, IEditorService))
-], NotebookClipboardContribution));
-registerWorkbenchContribution2(NotebookClipboardContribution.ID, NotebookClipboardContribution, 2 );
-const COPY_CELL_COMMAND_ID = 'notebook.cell.copy';
-const CUT_CELL_COMMAND_ID = 'notebook.cell.cut';
-const PASTE_CELL_COMMAND_ID = 'notebook.cell.paste';
-const PASTE_CELL_ABOVE_COMMAND_ID = 'notebook.cell.pasteAbove';
-registerAction2(class extends NotebookCellAction {
-    constructor() {
-        super({
-            id: COPY_CELL_COMMAND_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/clipboard/notebookClipboard',
-                'notebookActions.copy',
-                "Copy Cell"
-            )),
-            menu: {
-                id: MenuId.NotebookCellTitle,
-                when: NOTEBOOK_EDITOR_FOCUSED,
-                group: "1_copy" ,
-            },
-            keybinding: isNative ? undefined : {
-                primary: 2048  | 33 ,
-                win: { primary: 2048  | 33 , secondary: [2048  | 19 ] },
-                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
-                weight: 200
-            }
-        });
-    }
-    async runWithContext(accessor, context) {
-        runCopyCells(accessor, context.notebookEditor, context.cell);
-    }
-});
-registerAction2(class extends NotebookCellAction {
-    constructor() {
-        super({
-            id: CUT_CELL_COMMAND_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/clipboard/notebookClipboard',
-                'notebookActions.cut',
-                "Cut Cell"
-            )),
-            menu: {
-                id: MenuId.NotebookCellTitle,
-                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CELL_EDITABLE)),
-                group: "1_copy" ,
-            },
-            keybinding: isNative ? undefined : {
-                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
-                primary: 2048  | 54 ,
-                win: { primary: 2048  | 54 , secondary: [1024  | 20 ] },
-                weight: 200
-            }
-        });
-    }
-    async runWithContext(accessor, context) {
-        runCutCells(accessor, context.notebookEditor, context.cell);
-    }
-});
-registerAction2(class extends NotebookAction {
-    constructor() {
-        super({
-            id: PASTE_CELL_COMMAND_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/clipboard/notebookClipboard',
-                'notebookActions.paste',
-                "Paste Cell"
-            )),
-            menu: {
-                id: MenuId.NotebookCellTitle,
-                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_EDITOR_EDITABLE)),
-                group: "1_copy" ,
-            },
-            keybinding: isNative ? undefined : {
-                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
-                primary: 2048  | 52 ,
-                win: { primary: 2048  | 52 , secondary: [1024  | 19 ] },
-                linux: { primary: 2048  | 52 , secondary: [1024  | 19 ] },
-                weight: 100
-            }
-        });
-    }
-    async runWithContext(accessor, context) {
-        const notebookService = accessor.get(INotebookService);
-        const pasteCells = notebookService.getToCopy();
-        if (!context.notebookEditor.hasModel() || context.notebookEditor.isReadOnly) {
-            return;
-        }
-        if (!pasteCells) {
-            return;
-        }
-        runPasteCells(context.notebookEditor, context.cell, pasteCells);
-    }
-});
-registerAction2(class extends NotebookCellAction {
-    constructor() {
-        super({
-            id: PASTE_CELL_ABOVE_COMMAND_ID,
-            title: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/clipboard/notebookClipboard',
-                'notebookActions.pasteAbove',
-                "Paste Cell Above"
-            )),
-            keybinding: {
-                when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),
-                primary: 2048  | 1024  | 52 ,
-                weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
-            },
-        });
-    }
-    async runWithContext(accessor, context) {
-        const notebookService = accessor.get(INotebookService);
-        const pasteCells = notebookService.getToCopy();
-        const editor = context.notebookEditor;
-        const textModel = editor.textModel;
-        if (editor.isReadOnly) {
-            return;
-        }
-        if (!pasteCells) {
-            return;
-        }
-        const originalState = {
-            kind: SelectionStateType.Index,
-            focus: editor.getFocus(),
-            selections: editor.getSelections()
-        };
-        const currCellIndex = context.notebookEditor.getCellIndex(context.cell);
-        const newFocusIndex = currCellIndex;
-        textModel.applyEdits([
-            {
-                editType: 1 ,
-                index: currCellIndex,
-                count: 0,
-                cells: ( pasteCells.items.map(cell => cloneNotebookCellTextModel(cell)))
-            }
-        ], true, originalState, () => ({
-            kind: SelectionStateType.Index,
-            focus: { start: newFocusIndex, end: newFocusIndex + 1 },
-            selections: [{ start: newFocusIndex, end: newFocusIndex + pasteCells.items.length }]
-        }), undefined, true);
-    }
-});
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: 'workbench.action.toggleNotebookClipboardLog',
-            title: ( localize2WithPath(
-                'vs/workbench/contrib/notebook/browser/contrib/clipboard/notebookClipboard',
-                'toggleNotebookClipboardLog',
-                'Toggle Notebook Clipboard Troubleshooting'
-            )),
-            category: Categories.Developer,
-            f1: true
-        });
-    }
-    run(accessor) {
-        toggleLogging();
-        if (_logging) {
-            const commandService = accessor.get(ICommandService);
-            commandService.executeCommand(showWindowLogActionId);
-        }
-    }
-});
-
-export { NotebookClipboardContribution, runCopyCells, runCutCells, runPasteCells };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/debug/notebookBreakpoints.js

@@ -1,106 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { isEqual } from 'vscode/vscode/vs/base/common/resources';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
-import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
-import { NotebookCellsChangeType, CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-
-let NotebookBreakpoints = class NotebookBreakpoints extends Disposable {
-    constructor(_debugService, _notebookService, _editorService) {
-        super();
-        this._debugService = _debugService;
-        this._editorService = _editorService;
-        const listeners = ( new ResourceMap());
-        this._register(_notebookService.onWillAddNotebookDocument(model => {
-            listeners.set(model.uri, model.onWillAddRemoveCells(e => {
-                const debugModel = this._debugService.getModel();
-                if (!debugModel.getBreakpoints().length) {
-                    return;
-                }
-                if (e.rawEvent.kind !== NotebookCellsChangeType.ModelChange) {
-                    return;
-                }
-                for (const change of e.rawEvent.changes) {
-                    const [start, deleteCount] = change;
-                    if (deleteCount > 0) {
-                        const deleted = model.cells.slice(start, start + deleteCount);
-                        for (const deletedCell of deleted) {
-                            const cellBps = debugModel.getBreakpoints({ uri: deletedCell.uri });
-                            cellBps.forEach(cellBp => this._debugService.removeBreakpoints(cellBp.getId()));
-                        }
-                    }
-                }
-            }));
-        }));
-        this._register(_notebookService.onWillRemoveNotebookDocument(model => {
-            this.updateBreakpoints(model);
-            listeners.get(model.uri)?.dispose();
-            listeners.delete(model.uri);
-        }));
-        this._register(this._debugService.getModel().onDidChangeBreakpoints(e => {
-            const newCellBp = e?.added?.find(bp => 'uri' in bp && bp.uri.scheme === Schemas.vscodeNotebookCell);
-            if (newCellBp) {
-                const parsed = CellUri.parse(newCellBp.uri);
-                if (!parsed) {
-                    return;
-                }
-                const editor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
-                if (!editor || !editor.hasModel() || ( editor.textModel.uri.toString()) !== ( parsed.notebook.toString())) {
-                    return;
-                }
-                const cell = editor.getCellByHandle(parsed.handle);
-                if (!cell) {
-                    return;
-                }
-                editor.focusElement(cell);
-            }
-        }));
-    }
-    updateBreakpoints(model) {
-        const bps = this._debugService.getModel().getBreakpoints();
-        if (!bps.length || !model.cells.length) {
-            return;
-        }
-        const idxMap = ( new ResourceMap());
-        model.cells.forEach((cell, i) => {
-            idxMap.set(cell.uri, i);
-        });
-        bps.forEach(bp => {
-            const idx = idxMap.get(bp.uri);
-            if (typeof idx !== 'number') {
-                return;
-            }
-            const notebook = CellUri.parse(bp.uri)?.notebook;
-            if (!notebook) {
-                return;
-            }
-            const newUri = CellUri.generate(notebook, idx);
-            if (isEqual(newUri, bp.uri)) {
-                return;
-            }
-            this._debugService.removeBreakpoints(bp.getId());
-            this._debugService.addBreakpoints(newUri, [
-                {
-                    column: bp.column,
-                    condition: bp.condition,
-                    enabled: bp.enabled,
-                    hitCondition: bp.hitCondition,
-                    logMessage: bp.logMessage,
-                    lineNumber: bp.lineNumber
-                }
-            ]);
-        });
-    }
-};
-NotebookBreakpoints = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, INotebookService)),
-    ( __param(2, IEditorService))
-], NotebookBreakpoints));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookBreakpoints, 3 );

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/debug/notebookCellPausing.js

@@ -1,67 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
-import { RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { IDebugService } from 'vscode/vscode/vs/workbench/contrib/debug/common/debug';
-import { CellUri } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { CellExecutionUpdateType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionService';
-import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookExecutionStateService';
-
-let NotebookCellPausing = class NotebookCellPausing extends Disposable {
-    constructor(_debugService, _notebookExecutionStateService) {
-        super();
-        this._debugService = _debugService;
-        this._notebookExecutionStateService = _notebookExecutionStateService;
-        this._pausedCells = ( new Set());
-        this._register(_debugService.getModel().onDidChangeCallStack(() => {
-            this.onDidChangeCallStack(true);
-            this._scheduler.schedule();
-        }));
-        this._scheduler = this._register(( new RunOnceScheduler(() => this.onDidChangeCallStack(false), 2000)));
-    }
-    async onDidChangeCallStack(fallBackOnStaleCallstack) {
-        const newPausedCells = ( new Set());
-        for (const session of this._debugService.getModel().getSessions()) {
-            for (const thread of session.getAllThreads()) {
-                let callStack = thread.getCallStack();
-                if (fallBackOnStaleCallstack && !callStack.length) {
-                    callStack = thread.getStaleCallStack();
-                }
-                callStack.forEach(sf => {
-                    const parsed = CellUri.parse(sf.source.uri);
-                    if (parsed) {
-                        newPausedCells.add(( sf.source.uri.toString()));
-                        this.editIsPaused(sf.source.uri, true);
-                    }
-                });
-            }
-        }
-        for (const uri of this._pausedCells) {
-            if (!( newPausedCells.has(uri))) {
-                this.editIsPaused(( URI.parse(uri)), false);
-                this._pausedCells.delete(uri);
-            }
-        }
-        newPausedCells.forEach(cell => this._pausedCells.add(cell));
-    }
-    editIsPaused(cellUri, isPaused) {
-        const parsed = CellUri.parse(cellUri);
-        if (parsed) {
-            const exeState = this._notebookExecutionStateService.getCellExecution(cellUri);
-            if (exeState && (exeState.isPaused !== isPaused || !exeState.didPause)) {
-                exeState.update([{
-                        editType: CellExecutionUpdateType.ExecutionState,
-                        didPause: true,
-                        isPaused
-                    }]);
-            }
-        }
-    }
-};
-NotebookCellPausing = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, INotebookExecutionStateService))
-], NotebookCellPausing));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(NotebookCellPausing, 3 );