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

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

@@ -0,0 +1,159 @@
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { format } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IAccessibleViewService } from 'vscode/vscode/vs/workbench/contrib/accessibility/browser/accessibleView';
+import { getNotebookEditorFromEditorPane } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+
+function getAccessibilityHelpText(accessor) {
+    const keybindingService = accessor.get(IKeybindingService);
+    const content = [];
+    content.push(( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.overview',
+        'The notebook view is a collection of code and markdown cells. Code cells can be executed and will produce output directly below the cell.'
+    )));
+    content.push(descriptionForCommand('notebook.cell.edit', ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.cell.edit',
+        'The Edit Cell command ({0}) will focus on the cell input.'
+    )), ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.cell.editNoKb',
+        'The Edit Cell command will focus on the cell input and is currently not triggerable by a keybinding.'
+    )), keybindingService));
+    content.push(descriptionForCommand('notebook.cell.quitEdit', ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.cell.quitEdit',
+        'The Quit Edit command ({0}) will set focus on the cell container. The default (Escape) key may need to be pressed twice first exit the virtual cursor if active.'
+    )), ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.cell.quitEditNoKb',
+        'The Quit Edit command will set focus on the cell container and is currently not triggerable by a keybinding.'
+    )), keybindingService));
+    content.push(descriptionForCommand('notebook.cell.focusInOutput', ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.cell.focusInOutput',
+        'The Focus Output command ({0}) will set focus in the cell\'s output.'
+    )), ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.cell.focusInOutputNoKb',
+        'The Quit Edit command will set focus in the cell\'s output and is currently not triggerable by a keybinding.'
+    )), keybindingService));
+    content.push(descriptionForCommand('notebook.focusNextEditor', ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.focusNextEditor',
+        'The Focus Next Cell Editor command ({0}) will set focus in the next cell\'s editor.'
+    )), ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.focusNextEditorNoKb',
+        'The Focus Next Cell Editor command will set focus in the next cell\'s editor and is currently not triggerable by a keybinding.'
+    )), keybindingService));
+    content.push(descriptionForCommand('notebook.focusPreviousEditor', ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.focusPreviousEditor',
+        'The Focus Previous Cell Editor command ({0}) will set focus in the previous cell\'s editor.'
+    )), ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.focusPreviousEditorNoKb',
+        'The Focus Previous Cell Editor command will set focus in the previous cell\'s editor and is currently not triggerable by a keybinding.'
+    )), keybindingService));
+    content.push(( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.cellNavigation',
+        'The up and down arrows will also move focus between cells while focused on the outer cell container.'
+    )));
+    content.push(descriptionForCommand('notebook.cell.executeAndFocusContainer', ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.cell.executeAndFocusContainer',
+        'The Execute Cell command ({0}) executes the cell that currently has focus.'
+    )), ( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.cell.executeAndFocusContainerNoKb',
+        'The Execute Cell command executes the cell that currently has focus and is currently not triggerable by a keybinding.'
+    )), keybindingService));
+    content.push(( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.cell.insertCodeCellBelowAndFocusContainer',
+        'The Insert Cell Above/Below commands will create new empty code cells'
+    )));
+    content.push(( localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookAccessibility',
+        'notebook.changeCellType',
+        'The Change Cell to Code/Markdown commands are used to switch between cell types.'
+    )));
+    return content.join('\n\n');
+}
+function descriptionForCommand(commandId, msg, noKbMsg, keybindingService) {
+    const kb = keybindingService.lookupKeybinding(commandId);
+    if (kb) {
+        return format(msg, kb.getAriaLabel());
+    }
+    return format(noKbMsg, commandId);
+}
+async function runAccessibilityHelpAction(accessor, editor) {
+    const accessibleViewService = accessor.get(IAccessibleViewService);
+    const helpText = getAccessibilityHelpText(accessor);
+    accessibleViewService.show({
+        id: "notebook" ,
+        verbositySettingKey: "accessibility.verbosity.notebook" ,
+        provideContent: () => helpText,
+        onClose: () => {
+            editor.focus();
+        },
+        options: { type: "help"  }
+    });
+}
+function showAccessibleOutput(accessibleViewService, editorService) {
+    const activePane = editorService.activeEditorPane;
+    const notebookEditor = getNotebookEditorFromEditorPane(activePane);
+    const notebookViewModel = notebookEditor?.getViewModel();
+    const selections = notebookViewModel?.getSelections();
+    const notebookDocument = notebookViewModel?.notebookDocument;
+    if (!selections || !notebookDocument || !notebookEditor?.textModel) {
+        return false;
+    }
+    const viewCell = notebookViewModel.viewCells[selections[0].start];
+    let outputContent = '';
+    const decoder = ( new TextDecoder());
+    for (let i = 0; i < viewCell.outputsViewModels.length; i++) {
+        const outputViewModel = viewCell.outputsViewModels[i];
+        const outputTextModel = viewCell.model.outputs[i];
+        const [mimeTypes, pick] = outputViewModel.resolveMimeTypes(notebookEditor.textModel, undefined);
+        const mimeType = mimeTypes[pick].mimeType;
+        let buffer = outputTextModel.outputs.find(output => output.mime === mimeType);
+        if (!buffer || mimeType.startsWith('image')) {
+            buffer = outputTextModel.outputs.find(output => !output.mime.startsWith('image'));
+        }
+        let text = `${mimeType}`;
+        if (buffer) {
+            const charLimit = 100000;
+            text = decoder.decode(buffer.data.slice(0, charLimit).buffer);
+            if (buffer.data.byteLength > charLimit) {
+                text = text + '...(truncated)';
+            }
+            if (mimeType.endsWith('error')) {
+                text = text.replace(/\\u001b\[[0-9;]*m/gi, '').replaceAll('\\n', '\n');
+            }
+        }
+        const index = viewCell.outputsViewModels.length > 1
+            ? `Cell output ${i + 1} of ${viewCell.outputsViewModels.length}\n`
+            : '';
+        outputContent = outputContent.concat(`${index}${text}\n`);
+    }
+    if (!outputContent) {
+        return false;
+    }
+    accessibleViewService.show({
+        id: "notebook" ,
+        verbositySettingKey: "accessibility.verbosity.notebook" ,
+        provideContent() { return outputContent; },
+        onClose() {
+            notebookEditor?.setFocus(selections[0]);
+            activePane?.focus();
+        },
+        options: { type: "view"  }
+    });
+    return true;
+}
+
+export { getAccessibilityHelpText, runAccessibilityHelpAction, showAccessibleOutput };

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

@@ -0,0 +1,339 @@
+import * as nls from 'monaco-editor/esm/vs/nls.js';
+import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
+import { NotebookEditorPriority } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+
+const NotebookEditorContribution = ( Object.freeze({
+    type: 'type',
+    displayName: 'displayName',
+    selector: 'selector',
+    priority: 'priority',
+}));
+const NotebookRendererContribution = ( Object.freeze({
+    id: 'id',
+    displayName: 'displayName',
+    mimeTypes: 'mimeTypes',
+    entrypoint: 'entrypoint',
+    hardDependencies: 'dependencies',
+    optionalDependencies: 'optionalDependencies',
+    requiresMessaging: 'requiresMessaging',
+}));
+const NotebookPreloadContribution = ( Object.freeze({
+    type: 'type',
+    entrypoint: 'entrypoint',
+    localResourceRoots: 'localResourceRoots',
+}));
+const notebookProviderContribution = {
+    description: ( nls.localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+        'contributes.notebook.provider',
+        'Contributes notebook document provider.'
+    )),
+    type: 'array',
+    defaultSnippets: [{ body: [{ type: '', displayName: '', 'selector': [{ 'filenamePattern': '' }] }] }],
+    items: {
+        type: 'object',
+        required: [
+            NotebookEditorContribution.type,
+            NotebookEditorContribution.displayName,
+            NotebookEditorContribution.selector,
+        ],
+        properties: {
+            [NotebookEditorContribution.type]: {
+                type: 'string',
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                    'contributes.notebook.provider.viewType',
+                    'Type of the notebook.'
+                )),
+            },
+            [NotebookEditorContribution.displayName]: {
+                type: 'string',
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                    'contributes.notebook.provider.displayName',
+                    'Human readable name of the notebook.'
+                )),
+            },
+            [NotebookEditorContribution.selector]: {
+                type: 'array',
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                    'contributes.notebook.provider.selector',
+                    'Set of globs that the notebook is for.'
+                )),
+                items: {
+                    type: 'object',
+                    properties: {
+                        filenamePattern: {
+                            type: 'string',
+                            description: ( nls.localizeWithPath(
+                                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                                'contributes.notebook.provider.selector.filenamePattern',
+                                'Glob that the notebook is enabled for.'
+                            )),
+                        },
+                        excludeFileNamePattern: {
+                            type: 'string',
+                            description: ( nls.localizeWithPath(
+                                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                                'contributes.notebook.selector.provider.excludeFileNamePattern',
+                                'Glob that the notebook is disabled for.'
+                            ))
+                        }
+                    }
+                }
+            },
+            [NotebookEditorContribution.priority]: {
+                type: 'string',
+                markdownDeprecationMessage: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                    'contributes.priority',
+                    'Controls if the custom editor is enabled automatically when the user opens a file. This may be overridden by users using the `workbench.editorAssociations` setting.'
+                )),
+                enum: [
+                    NotebookEditorPriority.default,
+                    NotebookEditorPriority.option,
+                ],
+                markdownEnumDescriptions: [
+                    ( nls.localizeWithPath(
+                        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                        'contributes.priority.default',
+                        'The editor is automatically used when the user opens a resource, provided that no other default custom editors are registered for that resource.'
+                    )),
+                    ( nls.localizeWithPath(
+                        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                        'contributes.priority.option',
+                        'The editor is not automatically used when the user opens a resource, but a user can switch to the editor using the `Reopen With` command.'
+                    )),
+                ],
+                default: 'default'
+            }
+        }
+    }
+};
+const defaultRendererSnippet = ( Object.freeze({ id: '', displayName: '', mimeTypes: [''], entrypoint: '' }));
+const notebookRendererContribution = {
+    description: ( nls.localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+        'contributes.notebook.renderer',
+        'Contributes notebook output renderer provider.'
+    )),
+    type: 'array',
+    defaultSnippets: [{ body: [defaultRendererSnippet] }],
+    items: {
+        defaultSnippets: [{ body: defaultRendererSnippet }],
+        allOf: [
+            {
+                type: 'object',
+                required: [
+                    NotebookRendererContribution.id,
+                    NotebookRendererContribution.displayName,
+                ],
+                properties: {
+                    [NotebookRendererContribution.id]: {
+                        type: 'string',
+                        description: ( nls.localizeWithPath(
+                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                            'contributes.notebook.renderer.viewType',
+                            'Unique identifier of the notebook output renderer.'
+                        )),
+                    },
+                    [NotebookRendererContribution.displayName]: {
+                        type: 'string',
+                        description: ( nls.localizeWithPath(
+                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                            'contributes.notebook.renderer.displayName',
+                            'Human readable name of the notebook output renderer.'
+                        )),
+                    },
+                    [NotebookRendererContribution.hardDependencies]: {
+                        type: 'array',
+                        uniqueItems: true,
+                        items: { type: 'string' },
+                        markdownDescription: ( nls.localizeWithPath(
+                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                            'contributes.notebook.renderer.hardDependencies',
+                            'List of kernel dependencies the renderer requires. If any of the dependencies are present in the `NotebookKernel.preloads`, the renderer can be used.'
+                        )),
+                    },
+                    [NotebookRendererContribution.optionalDependencies]: {
+                        type: 'array',
+                        uniqueItems: true,
+                        items: { type: 'string' },
+                        markdownDescription: ( nls.localizeWithPath(
+                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                            'contributes.notebook.renderer.optionalDependencies',
+                            'List of soft kernel dependencies the renderer can make use of. If any of the dependencies are present in the `NotebookKernel.preloads`, the renderer will be preferred over renderers that don\'t interact with the kernel.'
+                        )),
+                    },
+                    [NotebookRendererContribution.requiresMessaging]: {
+                        default: 'never',
+                        enum: [
+                            'always',
+                            'optional',
+                            'never',
+                        ],
+                        enumDescriptions: [
+                            ( nls.localizeWithPath(
+                                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                                'contributes.notebook.renderer.requiresMessaging.always',
+                                'Messaging is required. The renderer will only be used when it\'s part of an extension that can be run in an extension host.'
+                            )),
+                            ( nls.localizeWithPath(
+                                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                                'contributes.notebook.renderer.requiresMessaging.optional',
+                                'The renderer is better with messaging available, but it\'s not requried.'
+                            )),
+                            ( nls.localizeWithPath(
+                                'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                                'contributes.notebook.renderer.requiresMessaging.never',
+                                'The renderer does not require messaging.'
+                            )),
+                        ],
+                        description: ( nls.localizeWithPath(
+                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                            'contributes.notebook.renderer.requiresMessaging',
+                            'Defines how and if the renderer needs to communicate with an extension host, via `createRendererMessaging`. Renderers with stronger messaging requirements may not work in all environments.'
+                        )),
+                    },
+                }
+            },
+            {
+                oneOf: [
+                    {
+                        required: [
+                            NotebookRendererContribution.entrypoint,
+                            NotebookRendererContribution.mimeTypes,
+                        ],
+                        properties: {
+                            [NotebookRendererContribution.mimeTypes]: {
+                                type: 'array',
+                                description: ( nls.localizeWithPath(
+                                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                                    'contributes.notebook.selector',
+                                    'Set of globs that the notebook is for.'
+                                )),
+                                items: {
+                                    type: 'string'
+                                }
+                            },
+                            [NotebookRendererContribution.entrypoint]: {
+                                description: ( nls.localizeWithPath(
+                                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                                    'contributes.notebook.renderer.entrypoint',
+                                    'File to load in the webview to render the extension.'
+                                )),
+                                type: 'string',
+                            },
+                        }
+                    },
+                    {
+                        required: [
+                            NotebookRendererContribution.entrypoint,
+                        ],
+                        properties: {
+                            [NotebookRendererContribution.entrypoint]: {
+                                description: ( nls.localizeWithPath(
+                                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                                    'contributes.notebook.renderer.entrypoint',
+                                    'File to load in the webview to render the extension.'
+                                )),
+                                type: 'object',
+                                required: ['extends', 'path'],
+                                properties: {
+                                    extends: {
+                                        type: 'string',
+                                        description: ( nls.localizeWithPath(
+                                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                                            'contributes.notebook.renderer.entrypoint.extends',
+                                            'Existing renderer that this one extends.'
+                                        )),
+                                    },
+                                    path: {
+                                        type: 'string',
+                                        description: ( nls.localizeWithPath(
+                                            'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                                            'contributes.notebook.renderer.entrypoint',
+                                            'File to load in the webview to render the extension.'
+                                        )),
+                                    },
+                                }
+                            },
+                        }
+                    }
+                ]
+            }
+        ]
+    }
+};
+const notebookPreloadContribution = {
+    description: ( nls.localizeWithPath(
+        'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+        'contributes.preload.provider',
+        'Contributes notebook preloads.'
+    )),
+    type: 'array',
+    defaultSnippets: [{ body: [{ type: '', entrypoint: '' }] }],
+    items: {
+        type: 'object',
+        required: [
+            NotebookPreloadContribution.type,
+            NotebookPreloadContribution.entrypoint
+        ],
+        properties: {
+            [NotebookPreloadContribution.type]: {
+                type: 'string',
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                    'contributes.preload.provider.viewType',
+                    'Type of the notebook.'
+                )),
+            },
+            [NotebookPreloadContribution.entrypoint]: {
+                type: 'string',
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                    'contributes.preload.entrypoint',
+                    'Path to file loaded in the webview.'
+                )),
+            },
+            [NotebookPreloadContribution.localResourceRoots]: {
+                type: 'array',
+                items: { type: 'string' },
+                description: ( nls.localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebookExtensionPoint',
+                    'contributes.preload.localResourceRoots',
+                    'Paths to additional resources that should be allowed in the webview.'
+                )),
+            },
+        }
+    }
+};
+const notebooksExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'notebooks',
+    jsonSchema: notebookProviderContribution,
+    activationEventsGenerator: (contribs, result) => {
+        for (const contrib of contribs) {
+            if (contrib.type) {
+                result.push(`onNotebookSerializer:${contrib.type}`);
+            }
+        }
+    }
+}));
+const notebookRendererExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'notebookRenderer',
+    jsonSchema: notebookRendererContribution,
+    activationEventsGenerator: (contribs, result) => {
+        for (const contrib of contribs) {
+            if (contrib.id) {
+                result.push(`onRenderer:${contrib.id}`);
+            }
+        }
+    }
+}));
+const notebookPreloadExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'notebookPreload',
+    jsonSchema: notebookPreloadContribution,
+}));
+
+export { notebookPreloadExtensionPoint, notebookRendererExtensionPoint, notebooksExtensionPoint };

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookCellStatusBarServiceImpl.js

@@ -0,0 +1,41 @@
+import { onUnexpectedExternalError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+
+class NotebookCellStatusBarService extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onDidChangeProviders = this._register(( new Emitter()));
+        this.onDidChangeProviders = this._onDidChangeProviders.event;
+        this._onDidChangeItems = this._register(( new Emitter()));
+        this.onDidChangeItems = this._onDidChangeItems.event;
+        this._providers = [];
+    }
+    registerCellStatusBarItemProvider(provider) {
+        this._providers.push(provider);
+        let changeListener;
+        if (provider.onDidChangeStatusBarItems) {
+            changeListener = provider.onDidChangeStatusBarItems(() => this._onDidChangeItems.fire());
+        }
+        this._onDidChangeProviders.fire();
+        return toDisposable(() => {
+            changeListener?.dispose();
+            const idx = this._providers.findIndex(p => p === provider);
+            this._providers.splice(idx, 1);
+        });
+    }
+    async getStatusBarItemsForCell(docUri, cellIndex, viewType, token) {
+        const providers = this._providers.filter(p => p.viewType === viewType || p.viewType === '*');
+        return await Promise.all(( providers.map(async (p) => {
+            try {
+                return (await p.provideCellStatusBarItems(docUri, cellIndex, token)) ?? { items: [] };
+            }
+            catch (e) {
+                onUnexpectedExternalError(e);
+                return { items: [] };
+            }
+        })));
+    }
+}
+
+export { NotebookCellStatusBarService };