@codingame/monaco-vscode-api 1.85.0-next.2 → 1.85.1

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/coreActions.js

@@ -0,0 +1,326 @@
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { MenuRegistry, MenuId, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { getNotebookEditorFromEditorPane, cellRangeToViewCells } from '../notebookBrowser.js';
+import { NOTEBOOK_KERNEL_COUNT, NOTEBOOK_KERNEL_SOURCE_COUNT, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_IS_ACTIVE_EDITOR, INTERACTIVE_WINDOW_IS_ACTIVE_EDITOR } from '../../common/notebookContextKeys.js';
+import { isICellRange } from '../../common/notebookRange.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.js';
+import { INotebookEditorService } from '../services/notebookEditorService.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+const SELECT_KERNEL_ID = '_notebook.selectKernel';
+const NOTEBOOK_ACTIONS_CATEGORY = { value: ( localizeWithPath(
+    'vs/workbench/contrib/notebook/browser/controller/coreActions',
+    'notebookActions.category',
+    "Notebook"
+)), original: 'Notebook' };
+const CELL_TITLE_CELL_GROUP_ID = 'inline/cell';
+const CELL_TITLE_OUTPUT_GROUP_ID = 'inline/output';
+const NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT = 100 ;
+function getContextFromActiveEditor(editorService) {
+    const editor = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+    if (!editor || !editor.hasModel()) {
+        return;
+    }
+    const activeCell = editor.getActiveCell();
+    const selectedCells = editor.getSelectionViewModels();
+    return {
+        cell: activeCell,
+        selectedCells,
+        notebookEditor: editor
+    };
+}
+function getWidgetFromUri(accessor, uri) {
+    const notebookEditorService = accessor.get(INotebookEditorService);
+    const widget = notebookEditorService.listNotebookEditors().find(widget => widget.hasModel() && ( widget.textModel.uri.toString()) === ( uri.toString()));
+    if (widget && widget.hasModel()) {
+        return widget;
+    }
+    return undefined;
+}
+function getContextFromUri(accessor, context) {
+    const uri = URI.revive(context);
+    if (uri) {
+        const widget = getWidgetFromUri(accessor, uri);
+        if (widget) {
+            return {
+                notebookEditor: widget,
+            };
+        }
+    }
+    return undefined;
+}
+function findTargetCellEditor(context, targetCell) {
+    let foundEditor = undefined;
+    for (const [, codeEditor] of context.notebookEditor.codeEditors) {
+        if (isEqual(codeEditor.getModel()?.uri, targetCell.uri)) {
+            foundEditor = codeEditor;
+            break;
+        }
+    }
+    return foundEditor;
+}
+class NotebookAction extends Action2 {
+    constructor(desc) {
+        if (desc.f1 !== false) {
+            desc.f1 = false;
+            const f1Menu = {
+                id: MenuId.CommandPalette,
+                when: ( ContextKeyExpr.or(NOTEBOOK_IS_ACTIVE_EDITOR, INTERACTIVE_WINDOW_IS_ACTIVE_EDITOR))
+            };
+            if (!desc.menu) {
+                desc.menu = [];
+            }
+            else if (!Array.isArray(desc.menu)) {
+                desc.menu = [desc.menu];
+            }
+            desc.menu = [
+                ...desc.menu,
+                f1Menu
+            ];
+        }
+        desc.category = NOTEBOOK_ACTIONS_CATEGORY;
+        super(desc);
+    }
+    async run(accessor, context, ...additionalArgs) {
+        const isFromUI = !!context;
+        const from = isFromUI ? (this.isNotebookActionContext(context) ? 'notebookToolbar' : 'editorToolbar') : undefined;
+        if (!this.isNotebookActionContext(context)) {
+            context = this.getEditorContextFromArgsOrActive(accessor, context, ...additionalArgs);
+            if (!context) {
+                return;
+            }
+        }
+        if (from !== undefined) {
+            const telemetryService = accessor.get(ITelemetryService);
+            telemetryService.publicLog2('workbenchActionExecuted', { id: this.desc.id, from: from });
+        }
+        return this.runWithContext(accessor, context);
+    }
+    isNotebookActionContext(context) {
+        return !!context && !!context.notebookEditor;
+    }
+    getEditorContextFromArgsOrActive(accessor, context, ...additionalArgs) {
+        return getContextFromActiveEditor(accessor.get(IEditorService));
+    }
+}
+class NotebookMultiCellAction extends Action2 {
+    constructor(desc) {
+        if (desc.f1 !== false) {
+            desc.f1 = false;
+            const f1Menu = {
+                id: MenuId.CommandPalette,
+                when: NOTEBOOK_IS_ACTIVE_EDITOR
+            };
+            if (!desc.menu) {
+                desc.menu = [];
+            }
+            else if (!Array.isArray(desc.menu)) {
+                desc.menu = [desc.menu];
+            }
+            desc.menu = [
+                ...desc.menu,
+                f1Menu
+            ];
+        }
+        desc.category = NOTEBOOK_ACTIONS_CATEGORY;
+        super(desc);
+    }
+    parseArgs(accessor, ...args) {
+        return undefined;
+    }
+    isCellToolbarContext(context) {
+        return !!context && !!context.notebookEditor && context.$mid === 13 ;
+    }
+    isEditorContext(context) {
+        return !!context && context.groupId !== undefined;
+    }
+    async run(accessor, ...additionalArgs) {
+        const context = additionalArgs[0];
+        const isFromCellToolbar = this.isCellToolbarContext(context);
+        const isFromEditorToolbar = this.isEditorContext(context);
+        const from = isFromCellToolbar ? 'cellToolbar' : (isFromEditorToolbar ? 'editorToolbar' : 'other');
+        const telemetryService = accessor.get(ITelemetryService);
+        if (isFromCellToolbar) {
+            telemetryService.publicLog2('workbenchActionExecuted', { id: this.desc.id, from: from });
+            return this.runWithContext(accessor, context);
+        }
+        const parsedArgs = this.parseArgs(accessor, ...additionalArgs);
+        if (parsedArgs) {
+            telemetryService.publicLog2('workbenchActionExecuted', { id: this.desc.id, from: from });
+            return this.runWithContext(accessor, parsedArgs);
+        }
+        const editor = getEditorFromArgsOrActivePane(accessor);
+        if (editor) {
+            telemetryService.publicLog2('workbenchActionExecuted', { id: this.desc.id, from: from });
+            return this.runWithContext(accessor, {
+                ui: false,
+                notebookEditor: editor,
+                selectedCells: cellRangeToViewCells(editor, editor.getSelections())
+            });
+        }
+    }
+}
+class NotebookCellAction extends NotebookAction {
+    isCellActionContext(context) {
+        return !!context && !!context.notebookEditor && !!context.cell;
+    }
+    getCellContextFromArgs(accessor, context, ...additionalArgs) {
+        return undefined;
+    }
+    async run(accessor, context, ...additionalArgs) {
+        if (this.isCellActionContext(context)) {
+            const telemetryService = accessor.get(ITelemetryService);
+            telemetryService.publicLog2('workbenchActionExecuted', { id: this.desc.id, from: 'cellToolbar' });
+            return this.runWithContext(accessor, context);
+        }
+        const contextFromArgs = this.getCellContextFromArgs(accessor, context, ...additionalArgs);
+        if (contextFromArgs) {
+            return this.runWithContext(accessor, contextFromArgs);
+        }
+        const activeEditorContext = this.getEditorContextFromArgsOrActive(accessor);
+        if (this.isCellActionContext(activeEditorContext)) {
+            return this.runWithContext(accessor, activeEditorContext);
+        }
+    }
+}
+const executeNotebookCondition = ( ContextKeyExpr.or(
+    ContextKeyExpr.greater(NOTEBOOK_KERNEL_COUNT.key, 0),
+    ContextKeyExpr.greater(NOTEBOOK_KERNEL_SOURCE_COUNT.key, 0)
+));
+function isMultiCellArgs(arg) {
+    if (arg === undefined) {
+        return false;
+    }
+    const ranges = arg.ranges;
+    if (!ranges) {
+        return false;
+    }
+    if (!Array.isArray(ranges) || ( ranges.some(range => !isICellRange(range)))) {
+        return false;
+    }
+    if (arg.document) {
+        const uri = URI.revive(arg.document);
+        if (!uri) {
+            return false;
+        }
+    }
+    return true;
+}
+function getEditorFromArgsOrActivePane(accessor, context) {
+    const editorFromUri = getContextFromUri(accessor, context)?.notebookEditor;
+    if (editorFromUri) {
+        return editorFromUri;
+    }
+    const editor = getNotebookEditorFromEditorPane(accessor.get(IEditorService).activeEditorPane);
+    if (!editor || !editor.hasModel()) {
+        return;
+    }
+    return editor;
+}
+function parseMultiCellExecutionArgs(accessor, ...args) {
+    const firstArg = args[0];
+    if (isMultiCellArgs(firstArg)) {
+        const editor = getEditorFromArgsOrActivePane(accessor, firstArg.document);
+        if (!editor) {
+            return;
+        }
+        const ranges = firstArg.ranges;
+        const selectedCells = ( ranges.map(range => editor.getCellsInRange(range).slice(0))).flat();
+        const autoReveal = firstArg.autoReveal;
+        return {
+            ui: false,
+            notebookEditor: editor,
+            selectedCells,
+            autoReveal
+        };
+    }
+    if (isICellRange(firstArg)) {
+        const secondArg = args[1];
+        const editor = getEditorFromArgsOrActivePane(accessor, secondArg);
+        if (!editor) {
+            return;
+        }
+        return {
+            ui: false,
+            notebookEditor: editor,
+            selectedCells: editor.getCellsInRange(firstArg)
+        };
+    }
+    const context = getContextFromActiveEditor(accessor.get(IEditorService));
+    return context ? {
+        ui: false,
+        notebookEditor: context.notebookEditor,
+        selectedCells: context.selectedCells ?? [],
+        cell: context.cell
+    } : undefined;
+}
+const cellExecutionArgs = [
+    {
+        isOptional: true,
+        name: 'options',
+        description: 'The cell range options',
+        schema: {
+            'type': 'object',
+            'required': ['ranges'],
+            'properties': {
+                'ranges': {
+                    'type': 'array',
+                    items: [
+                        {
+                            'type': 'object',
+                            'required': ['start', 'end'],
+                            'properties': {
+                                'start': {
+                                    'type': 'number'
+                                },
+                                'end': {
+                                    'type': 'number'
+                                }
+                            }
+                        }
+                    ]
+                },
+                'document': {
+                    'type': 'object',
+                    'description': 'The document uri',
+                },
+                'autoReveal': {
+                    'type': 'boolean',
+                    'description': 'Whether the cell should be revealed into view automatically'
+                }
+            }
+        }
+    }
+];
+MenuRegistry.appendMenuItem(MenuId.NotebookCellTitle, {
+    submenu: MenuId.NotebookCellInsert,
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/controller/coreActions',
+        'notebookMenu.insertCell',
+        "Insert Cell"
+    )),
+    group: "2_insert" ,
+    when: ( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true))
+});
+MenuRegistry.appendMenuItem(MenuId.EditorContext, {
+    submenu: MenuId.NotebookCellTitle,
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/controller/coreActions',
+        'notebookMenu.cellTitle',
+        "Notebook Cell"
+    )),
+    group: "2_insert" ,
+    when: NOTEBOOK_EDITOR_FOCUSED
+});
+MenuRegistry.appendMenuItem(MenuId.NotebookCellTitle, {
+    title: ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/controller/coreActions',
+        'miShare',
+        "Share"
+    )),
+    submenu: MenuId.EditorContextShare,
+    group: "4_share"
+});
+export { CELL_TITLE_CELL_GROUP_ID, CELL_TITLE_OUTPUT_GROUP_ID, NOTEBOOK_ACTIONS_CATEGORY, NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT, NotebookAction, NotebookCellAction, NotebookMultiCellAction, SELECT_KERNEL_ID, cellExecutionArgs, executeNotebookCondition, findTargetCellEditor, getContextFromActiveEditor, getContextFromUri, getEditorFromArgsOrActivePane, parseMultiCellExecutionArgs };