@codingame/monaco-vscode-notebook-service-override 22.1.8 → 23.0.0

package/vscode/src/vs/workbench/contrib/replNotebook/browser/repl.contribution.js

@@ -0,0 +1,405 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { KeyChord, KeyMod, KeyCode } from '@codingame/monaco-vscode-api/vscode/vs/base/common/keyCodes';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { isFalsyOrWhitespace } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { assertType } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IBulkEditService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/bulkEditService.service';
+import { PLAINTEXT_LANGUAGE_ID } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/modesRegistry';
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AccessibleViewRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleViewRegistry';
+import { registerAction2, Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { KeybindingWeight, KeybindingsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybindingsRegistry';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { EditorPaneDescriptor } from '@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common/vscode/vs/workbench/browser/editor';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { EditorExtensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { RegisteredEditorPriority } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorResolverService';
+import { IEditorResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorResolverService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { IViewsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/views/common/viewsService.service';
+import { IWorkingCopyEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService.service';
+import { ResourceNotebookCellEdit } from '@codingame/monaco-vscode-9d2c06d1-1f89-51a5-9964-aa01fe50c198-common/vscode/vs/workbench/contrib/bulkEdit/browser/bulkCellEdits';
+import { getReplView } from '@codingame/monaco-vscode-88aa9a78-75f5-5aaa-89e9-bbdd580b3b5c-common/vscode/vs/workbench/contrib/debug/browser/repl';
+import { REPL_VIEW_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/debug/common/debug';
+import { InlineChatController } from '@codingame/monaco-vscode-a793b3ee-7ba9-5176-a019-30ec806fdd95-common/vscode/vs/workbench/contrib/inlineChat/browser/inlineChatController';
+import { IInteractiveHistoryService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/interactive/browser/interactiveHistoryService.service';
+import { NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/controller/coreActions';
+import { executeIcon } from '@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/notebook/browser/notebookIcons';
+import { ReplEditorAccessibleView } from '../../notebook/browser/replEditorAccessibleView.js';
+import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
+import { REPL_EDITOR_ID, NotebookSetting, NotebookWorkingCopyTypeIdentifier, CellKind, CellEditType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { MOST_RECENT_REPL_EDITOR, IS_COMPOSITE_NOTEBOOK, NOTEBOOK_CELL_LIST_FOCUSED, NOTEBOOK_EDITOR_FOCUSED } from '@codingame/monaco-vscode-eda30bac-0984-5b42-9362-c68996b85232-common/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+import { INotebookEditorModelResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { ReplEditor, isReplEditorControl } from '@codingame/monaco-vscode-fc28fb90-97de-5e74-89a9-4cfe44128227-common/vscode/vs/workbench/contrib/replNotebook/browser/replEditor';
+import { ReplEditorInputAccessibilityHelp, ReplEditorHistoryAccessibilityHelp } from './replEditorAccessibilityHelp.js';
+import { ReplEditorInput } from '@codingame/monaco-vscode-fc28fb90-97de-5e74-89a9-4cfe44128227-common/vscode/vs/workbench/contrib/replNotebook/browser/replEditorInput';
+
+class ReplEditorSerializer {
+    canSerialize(input) {
+        return input.typeId === ReplEditorInput.ID;
+    }
+    serialize(input) {
+        assertType(input instanceof ReplEditorInput);
+        const data = {
+            resource: input.resource,
+            preferredResource: input.preferredResource,
+            viewType: input.viewType,
+            options: input.options,
+            label: input.getName()
+        };
+        return JSON.stringify(data);
+    }
+    deserialize(instantiationService, raw) {
+        const data = parse(raw);
+        if (!data) {
+            return undefined;
+        }
+        const { resource, viewType } = data;
+        if (!data || !URI.isUri(resource) || typeof viewType !== 'string') {
+            return undefined;
+        }
+        const input = instantiationService.createInstance(ReplEditorInput, resource, data.label);
+        return input;
+    }
+}
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(ReplEditor, REPL_EDITOR_ID, 'REPL Editor'), [
+    ( new SyncDescriptor(ReplEditorInput))
+]);
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(ReplEditorInput.ID, ReplEditorSerializer);
+let ReplDocumentContribution = class ReplDocumentContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.replDocument'; }
+    constructor(notebookService, editorResolverService, notebookEditorModelResolverService, instantiationService, configurationService) {
+        super();
+        this.notebookEditorModelResolverService = notebookEditorModelResolverService;
+        this.instantiationService = instantiationService;
+        this.configurationService = configurationService;
+        this.editorInputCache = ( new ResourceMap());
+        editorResolverService.registerEditor(
+        ` `, {
+            id: 'repl',
+            label: 'repl Editor',
+            priority: RegisteredEditorPriority.option
+        }, {
+            canSupportResource: uri => notebookService.getNotebookTextModel(uri) !== undefined,
+            singlePerResource: true
+        }, {
+            createUntitledEditorInput: async ({ resource, options }) => {
+                if (resource) {
+                    const editor = this.editorInputCache.get(resource);
+                    if (editor && !editor.isDisposed()) {
+                        return { editor, options };
+                    }
+                    else if (editor) {
+                        this.editorInputCache.delete(resource);
+                    }
+                }
+                const scratchpad = this.configurationService.getValue(NotebookSetting.InteractiveWindowPromptToSave) !== true;
+                const ref = await this.notebookEditorModelResolverService.resolve({ untitledResource: resource }, 'jupyter-notebook', { scratchpad, viewType: 'repl' });
+                const notebookUri = ref.object.notebook.uri;
+                Event.once(ref.object.notebook.onWillDispose)(() => {
+                    ref.dispose();
+                });
+                const label = options?.label ?? undefined;
+                const editor = this.instantiationService.createInstance(ReplEditorInput, notebookUri, label);
+                this.editorInputCache.set(notebookUri, editor);
+                Event.once(editor.onWillDispose)(() => this.editorInputCache.delete(notebookUri));
+                return { editor, options };
+            },
+            createEditorInput: async ({ resource, options }) => {
+                if (( this.editorInputCache.has(resource))) {
+                    return { editor: this.editorInputCache.get(resource), options };
+                }
+                const label = options?.label ?? undefined;
+                const editor = this.instantiationService.createInstance(ReplEditorInput, resource, label);
+                this.editorInputCache.set(resource, editor);
+                Event.once(editor.onWillDispose)(() => this.editorInputCache.delete(resource));
+                return { editor, options };
+            }
+        });
+    }
+};
+ReplDocumentContribution = ( __decorate([
+    ( __param(0, INotebookService)),
+    ( __param(1, IEditorResolverService)),
+    ( __param(2, INotebookEditorModelResolverService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IConfigurationService))
+], ReplDocumentContribution));
+let ReplWindowWorkingCopyEditorHandler = class ReplWindowWorkingCopyEditorHandler extends Disposable {
+    static { this.ID = 'workbench.contrib.replWorkingCopyEditorHandler'; }
+    constructor(instantiationService, workingCopyEditorService, extensionService, notebookService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.workingCopyEditorService = workingCopyEditorService;
+        this.extensionService = extensionService;
+        this.notebookService = notebookService;
+        this._installHandler();
+    }
+    async handles(workingCopy) {
+        const notebookType = this._getNotebookType(workingCopy);
+        if (!notebookType) {
+            return false;
+        }
+        return !!notebookType && notebookType.viewType === 'repl' && (await this.notebookService.canResolve(notebookType.notebookType));
+    }
+    isOpen(workingCopy, editor) {
+        if (!this.handles(workingCopy)) {
+            return false;
+        }
+        return editor instanceof ReplEditorInput && isEqual(workingCopy.resource, editor.resource);
+    }
+    createEditor(workingCopy) {
+        return this.instantiationService.createInstance(ReplEditorInput, workingCopy.resource, undefined);
+    }
+    async _installHandler() {
+        await this.extensionService.whenInstalledExtensionsRegistered();
+        this._register(this.workingCopyEditorService.registerHandler(this));
+    }
+    _getNotebookType(workingCopy) {
+        return NotebookWorkingCopyTypeIdentifier.parse(workingCopy.typeId);
+    }
+};
+ReplWindowWorkingCopyEditorHandler = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkingCopyEditorService)),
+    ( __param(2, IExtensionService)),
+    ( __param(3, INotebookService))
+], ReplWindowWorkingCopyEditorHandler));
+registerWorkbenchContribution2(ReplWindowWorkingCopyEditorHandler.ID, ReplWindowWorkingCopyEditorHandler, WorkbenchPhase.BlockRestore);
+registerWorkbenchContribution2(ReplDocumentContribution.ID, ReplDocumentContribution, WorkbenchPhase.BlockRestore);
+AccessibleViewRegistry.register(( new ReplEditorInputAccessibilityHelp()));
+AccessibleViewRegistry.register(( new ReplEditorHistoryAccessibilityHelp()));
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'repl.focusLastItemExecuted',
+            title: ( localize2(10228, 'Focus Most Recent REPL Execution')),
+            category: 'REPL',
+            menu: {
+                id: MenuId.CommandPalette,
+                when: MOST_RECENT_REPL_EDITOR,
+            },
+            keybinding: [{
+                    primary: KeyChord(KeyMod.Alt | KeyCode.End, KeyMod.Alt | KeyCode.End),
+                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT,
+                    when: ( ContextKeyExpr.or(IS_COMPOSITE_NOTEBOOK, ( NOTEBOOK_CELL_LIST_FOCUSED.negate())))
+                }],
+            precondition: MOST_RECENT_REPL_EDITOR
+        });
+    }
+    async run(accessor, context) {
+        const editorService = accessor.get(IEditorService);
+        const editorControl = editorService.activeEditorPane?.getControl();
+        const contextKeyService = accessor.get(IContextKeyService);
+        let notebookEditor;
+        if (editorControl && isReplEditorControl(editorControl)) {
+            notebookEditor = editorControl.notebookEditor;
+        }
+        else {
+            const uriString = MOST_RECENT_REPL_EDITOR.getValue(contextKeyService);
+            const uri = uriString ? ( URI.parse(uriString)) : undefined;
+            if (!uri) {
+                return;
+            }
+            const replEditor = editorService.findEditors(uri)[0];
+            if (replEditor) {
+                const editor = await editorService.openEditor(replEditor.editor, replEditor.groupId);
+                const editorControl = editor?.getControl();
+                if (editorControl && isReplEditorControl(editorControl)) {
+                    notebookEditor = editorControl.notebookEditor;
+                }
+            }
+        }
+        const viewModel = notebookEditor?.getViewModel();
+        if (notebookEditor && viewModel) {
+            const lastCellIndex = viewModel.length - 1;
+            if (lastCellIndex >= 0) {
+                const cell = viewModel.viewCells[lastCellIndex];
+                notebookEditor.focusNotebookCell(cell, 'container');
+            }
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'repl.input.focus',
+            title: ( localize2(10229, 'Focus Input Editor')),
+            category: 'REPL',
+            menu: {
+                id: MenuId.CommandPalette,
+                when: MOST_RECENT_REPL_EDITOR,
+            },
+            keybinding: [{
+                    when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, NOTEBOOK_EDITOR_FOCUSED)),
+                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT,
+                    primary: KeyMod.CtrlCmd | KeyCode.DownArrow
+                }, {
+                    when: ( ContextKeyExpr.and(MOST_RECENT_REPL_EDITOR)),
+                    weight: KeybindingWeight.WorkbenchContrib + 5,
+                    primary: KeyChord(KeyMod.Alt | KeyCode.Home, KeyMod.Alt | KeyCode.Home),
+                }]
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const editorControl = editorService.activeEditorPane?.getControl();
+        const contextKeyService = accessor.get(IContextKeyService);
+        if (editorControl && isReplEditorControl(editorControl) && editorControl.notebookEditor) {
+            editorService.activeEditorPane?.focus();
+        }
+        else {
+            const uriString = MOST_RECENT_REPL_EDITOR.getValue(contextKeyService);
+            const uri = uriString ? ( URI.parse(uriString)) : undefined;
+            if (!uri) {
+                return;
+            }
+            const replEditor = editorService.findEditors(uri)[0];
+            if (replEditor) {
+                await editorService.openEditor({ resource: uri, options: { preserveFocus: false } }, replEditor.groupId);
+            }
+        }
+    }
+});
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'repl.execute',
+            title: ( localize2(10230, 'Execute REPL input')),
+            category: 'REPL',
+            keybinding: [{
+                    when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( ContextKeyExpr.equals('activeEditor', 'workbench.editor.repl')), ( NOTEBOOK_CELL_LIST_FOCUSED.negate()))),
+                    primary: KeyMod.CtrlCmd | KeyCode.Enter,
+                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
+                }, {
+                    when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( ContextKeyExpr.equals('activeEditor', 'workbench.editor.repl')), ( ContextKeyExpr.equals('config.interactiveWindow.executeWithShiftEnter', true)), ( NOTEBOOK_CELL_LIST_FOCUSED.negate()))),
+                    primary: KeyMod.Shift | KeyCode.Enter,
+                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
+                }, {
+                    when: ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( ContextKeyExpr.equals('activeEditor', 'workbench.editor.repl')), ( ContextKeyExpr.equals('config.interactiveWindow.executeWithShiftEnter', false)), ( NOTEBOOK_CELL_LIST_FOCUSED.negate()))),
+                    primary: KeyCode.Enter,
+                    weight: NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT
+                }],
+            menu: [
+                {
+                    id: MenuId.ReplInputExecute
+                }
+            ],
+            icon: executeIcon,
+            f1: false,
+            metadata: {
+                description: 'Execute the Contents of the Input Box',
+                args: [
+                    {
+                        name: 'resource',
+                        description: 'Interactive resource Uri',
+                        isOptional: true
+                    }
+                ]
+            }
+        });
+    }
+    async run(accessor, context) {
+        const editorService = accessor.get(IEditorService);
+        const bulkEditService = accessor.get(IBulkEditService);
+        const historyService = accessor.get(IInteractiveHistoryService);
+        const notebookEditorService = accessor.get(INotebookEditorService);
+        let editorControl;
+        if (context) {
+            const resourceUri = URI.revive(context);
+            const editors = editorService.findEditors(resourceUri);
+            for (const found of editors) {
+                if (found.editor.typeId === ReplEditorInput.ID) {
+                    const editor = await editorService.openEditor(found.editor, found.groupId);
+                    editorControl = editor?.getControl();
+                    break;
+                }
+            }
+        }
+        else {
+            editorControl = editorService.activeEditorPane?.getControl();
+        }
+        if (isReplEditorControl(editorControl)) {
+            executeReplInput(bulkEditService, historyService, notebookEditorService, editorControl);
+        }
+    }
+});
+async function executeReplInput(bulkEditService, historyService, notebookEditorService, editorControl) {
+    if (editorControl && editorControl.notebookEditor && editorControl.activeCodeEditor) {
+        const notebookDocument = editorControl.notebookEditor.textModel;
+        const textModel = editorControl.activeCodeEditor.getModel();
+        const activeKernel = editorControl.notebookEditor.activeKernel;
+        const language = activeKernel?.supportedLanguages[0] ?? PLAINTEXT_LANGUAGE_ID;
+        if (notebookDocument && textModel) {
+            const index = notebookDocument.length - 1;
+            const value = textModel.getValue();
+            if (isFalsyOrWhitespace(value)) {
+                return;
+            }
+            const ctrl = InlineChatController.get(editorControl.activeCodeEditor);
+            if (ctrl) {
+                ctrl.acceptSession();
+            }
+            historyService.replaceLast(notebookDocument.uri, value);
+            historyService.addToHistory(notebookDocument.uri, '');
+            textModel.setValue('');
+            notebookDocument.cells[index].resetTextBuffer(textModel.getTextBuffer());
+            const collapseState = editorControl.notebookEditor.notebookOptions.getDisplayOptions().interactiveWindowCollapseCodeCells === 'fromEditor' ?
+                {
+                    inputCollapsed: false,
+                    outputCollapsed: false
+                } :
+                undefined;
+            await bulkEditService.apply([
+                ( new ResourceNotebookCellEdit(notebookDocument.uri, {
+                    editType: CellEditType.Replace,
+                    index: index,
+                    count: 0,
+                    cells: [{
+                            cellKind: CellKind.Code,
+                            mime: undefined,
+                            language,
+                            source: value,
+                            outputs: [],
+                            metadata: {},
+                            collapseState
+                        }]
+                }))
+            ]);
+            const range = { start: index, end: index + 1 };
+            editorControl.notebookEditor.revealCellRangeInView(range);
+            await editorControl.notebookEditor.executeNotebookCells(editorControl.notebookEditor.getCellsInRange({ start: index, end: index + 1 }));
+            const editor = notebookEditorService.getNotebookEditor(editorControl.notebookEditor.getId());
+            if (editor) {
+                editor.setSelections([range]);
+                editor.setFocus(range);
+            }
+        }
+    }
+}
+AccessibleViewRegistry.register(( new ReplEditorAccessibleView()));
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+    id: 'list.find.replInputFocus',
+    weight: KeybindingWeight.WorkbenchContrib + 1,
+    when: ( ContextKeyExpr.equals('view', REPL_VIEW_ID)),
+    primary: KeyMod.CtrlCmd | KeyMod.Alt | KeyCode.KeyF,
+    secondary: [KeyCode.F3],
+    handler: (accessor) => {
+        getReplView(accessor.get(IViewsService))?.openFind();
+    }
+});
+
+export { ReplDocumentContribution };

package/vscode/src/vs/workbench/contrib/replNotebook/browser/replEditorAccessibilityHelp.d.ts

@@ -0,0 +1,17 @@
+import { ServicesAccessor } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IAccessibleViewImplementation } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleViewRegistry";
+import { AccessibleViewType, AccessibleContentProvider } from "@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView";
+export declare class ReplEditorInputAccessibilityHelp implements IAccessibleViewImplementation {
+    readonly priority = 105;
+    readonly name = "REPL Editor Input";
+    readonly when: import("@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey").ContextKeyExpression | undefined;
+    readonly type: AccessibleViewType;
+    getProvider(accessor: ServicesAccessor): AccessibleContentProvider | undefined;
+}
+export declare class ReplEditorHistoryAccessibilityHelp implements IAccessibleViewImplementation {
+    readonly priority = 105;
+    readonly name = "REPL Editor History";
+    readonly when: import("@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey").ContextKeyExpression | undefined;
+    readonly type: AccessibleViewType;
+    getProvider(accessor: ServicesAccessor): AccessibleContentProvider | undefined;
+}

package/vscode/src/vs/workbench/contrib/replNotebook/browser/replEditorAccessibilityHelp.js

@@ -0,0 +1,120 @@
+
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AccessibleViewType, AccessibleContentProvider, AccessibleViewProviderId } from '@codingame/monaco-vscode-api/vscode/vs/platform/accessibility/browser/accessibleView';
+import { AccessibilityVerbositySettingId } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration';
+import { ICodeEditorService } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/services/codeEditorService.service';
+import { IS_COMPOSITE_NOTEBOOK, NOTEBOOK_CELL_LIST_FOCUSED } from '@codingame/monaco-vscode-eda30bac-0984-5b42-9362-c68996b85232-common/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys';
+
+class ReplEditorInputAccessibilityHelp {
+    constructor() {
+        this.priority = 105;
+        this.name = 'REPL Editor Input';
+        this.when = ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, ( NOTEBOOK_CELL_LIST_FOCUSED.negate())));
+        this.type = AccessibleViewType.Help;
+    }
+    getProvider(accessor) {
+        return getAccessibilityHelpProvider(accessor.get(ICodeEditorService), getAccessibilityInputHelpText());
+    }
+}
+function getAccessibilityInputHelpText() {
+    return [
+        ( localize(
+        10232,
+        'You are in a REPL Editor Input box which will accept code to be executed in the REPL.'
+    )),
+        ( localize(
+        10233,
+        'The Execute command{0} will evaluate the expression in the input box.',
+        '<keybinding:repl.execute>'
+    )),
+        ( localize(
+        10234,
+        'The setting `accessibility.replEditor.readLastExecutionOutput` controls if output will be automatically read when execution completes.'
+    )),
+        ( localize(
+        10235,
+        'The setting `accessibility.replEditor.autoFocusReplExecution` controls if focus will automatically move to the REPL after executing code.'
+    )),
+        ( localize(
+        10236,
+        'The Focus Last executed command{0} will move focus to the last executed item in the REPL history.',
+        '<keybinding:repl.focusLastItemExecuted>'
+    )),
+        ( localize(
+        10237,
+        'When you run the Open Accessbility View command{0} from this input box, the output from the last execution will be shown in the accessibility view.',
+        '<keybinding:editor.action.accessibleView>'
+    )),
+        ( localize(
+        10238,
+        'The Focus Input Editor command{0} will bring the focus back to this editor.',
+        '<keybinding:repl.input.focus>'
+    )),
+    ].join('\n');
+}
+class ReplEditorHistoryAccessibilityHelp {
+    constructor() {
+        this.priority = 105;
+        this.name = 'REPL Editor History';
+        this.when = ( ContextKeyExpr.and(IS_COMPOSITE_NOTEBOOK, NOTEBOOK_CELL_LIST_FOCUSED));
+        this.type = AccessibleViewType.Help;
+    }
+    getProvider(accessor) {
+        return getAccessibilityHelpProvider(accessor.get(ICodeEditorService), getAccessibilityHistoryHelpText());
+    }
+}
+function getAccessibilityHistoryHelpText() {
+    return [
+        ( localize(
+        10239,
+        'You are in a REPL History which is a list of cells that have been executed in the REPL. Each cell has an input, an output, and the cell container.'
+    )),
+        ( localize(
+        10240,
+        'The Edit Cell command{0} will move focus to the read-only editor for the input of the cell.',
+        '<keybinding:notebook.cell.edit>'
+    )),
+        ( localize(
+        10241,
+        'The Quit Edit command{0} will move focus to the cell container, where the up and down arrows will also move focus between cells in the history.',
+        '<keybinding:notebook.cell.quitEdit>'
+    )),
+        ( localize(
+        10242,
+        'Run the Open Accessbility View command{0} while navigating the history for an accessible view of the item\'s output.',
+        '<keybinding:editor.action.accessibleView>'
+    )),
+        ( localize(
+        10243,
+        'The Focus Output command{0} will set focus on the output when focused on a previously executed item.',
+        '<keybinding:notebook.cell.focusInOutput>'
+    )),
+        ( localize(
+        10244,
+        'The Focus Input Editor command{0} will move focus to the REPL input box.',
+        '<keybinding:repl.input.focus>'
+    )),
+        ( localize(
+        10236,
+        'The Focus Last executed command{0} will move focus to the last executed item in the REPL history.',
+        '<keybinding:repl.focusLastItemExecuted>'
+    )),
+    ].join('\n');
+}
+function getAccessibilityHelpProvider(editorService, helpText) {
+    const activeEditor = editorService.getActiveCodeEditor()
+        || editorService.getFocusedCodeEditor();
+    if (!activeEditor) {
+        return;
+    }
+    return ( new AccessibleContentProvider(
+        AccessibleViewProviderId.ReplEditor,
+        { type: AccessibleViewType.Help },
+        () => helpText,
+        () => activeEditor.focus(),
+        AccessibilityVerbositySettingId.ReplEditor
+    ));
+}
+
+export { ReplEditorHistoryAccessibilityHelp, ReplEditorInputAccessibilityHelp };

package/vscode/src/vs/workbench/services/workingCopy/common/abstractFileWorkingCopyManager.d.ts

@@ -4,7 +4,7 @@ import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/fi
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IWorkingCopyBackupService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service";
-import { IFileWorkingCopy, IFileWorkingCopyModel } from "@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy";
+import { IFileWorkingCopy, IFileWorkingCopyModel } from "@codingame/monaco-vscode-6f931a91-88ea-5232-897f-a17ec3929ba5-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy";
 export interface IBaseFileWorkingCopyManager<M extends IFileWorkingCopyModel, W extends IFileWorkingCopy<M>> extends IDisposable {
     /**
      * An event for when a file working copy was created.

package/vscode/src/vs/workbench/services/workingCopy/common/fileWorkingCopyManager.d.ts

@@ -8,13 +8,13 @@ import { ISaveOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/c
 import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
 import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
 import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
-import { IStoredFileWorkingCopy, IStoredFileWorkingCopyModel, IStoredFileWorkingCopyModelFactory, IStoredFileWorkingCopyResolveOptions } from "@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy";
+import { IStoredFileWorkingCopy, IStoredFileWorkingCopyModel, IStoredFileWorkingCopyModelFactory, IStoredFileWorkingCopyResolveOptions } from "@codingame/monaco-vscode-6f931a91-88ea-5232-897f-a17ec3929ba5-common/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy";
 import { IStoredFileWorkingCopyManager, IStoredFileWorkingCopyManagerResolveOptions } from "./storedFileWorkingCopyManager.js";
 import { IUntitledFileWorkingCopy, IUntitledFileWorkingCopyModel, IUntitledFileWorkingCopyModelFactory } from "./untitledFileWorkingCopy.js";
 import { INewOrExistingUntitledFileWorkingCopyOptions, INewUntitledFileWorkingCopyOptions, INewUntitledFileWorkingCopyWithAssociatedResourceOptions, IUntitledFileWorkingCopyManager } from "./untitledFileWorkingCopyManager.js";
 import { IWorkingCopyFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
 import { IBaseFileWorkingCopyManager } from "./abstractFileWorkingCopyManager.js";
-import { IFileWorkingCopy } from "@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy";
+import { IFileWorkingCopy } from "@codingame/monaco-vscode-6f931a91-88ea-5232-897f-a17ec3929ba5-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy";
 import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { INotificationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service";