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

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

@@ -0,0 +1,437 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { toAction } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore, MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { extname, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { EditorPane } from '../../../browser/parts/editor/editorPane.js';
+import { createEditorOpenError, DEFAULT_EDITOR_ASSOCIATION, isEditorOpenError, EditorResourceAccessor } from '../../../common/editor.js';
+import { SELECT_KERNEL_ID } from './controller/coreActions.js';
+import { INotebookEditorService } from './services/notebookEditorService.js';
+import { NotebooKernelActionViewItem } from './viewParts/notebookKernelView.js';
+import { NOTEBOOK_EDITOR_ID, NotebookWorkingCopyTypeIdentifier } from '../common/notebookCommon.js';
+import { NotebookEditorInput } from '../common/notebookEditorInput.js';
+import { NotebookPerfMarks } from '../common/notebookPerformance.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IEditorProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { InstallRecommendedExtensionAction } from '../../extensions/browser/extensionsActions.js';
+import { INotebookService } from '../common/notebookService.js';
+import { IExtensionsWorkbenchService } from '../../extensions/common/extensions.js';
+import { IWorkingCopyBackupService } from '../../../services/workingCopy/common/workingCopyBackup.js';
+import { streamToBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { INotebookEditorWorkerService } from '../common/services/notebookWorkerService.js';
+var NotebookEditor_1;
+const NOTEBOOK_EDITOR_VIEW_STATE_PREFERENCE_KEY = 'NotebookEditorViewState';
+let NotebookEditor = class NotebookEditor extends EditorPane {
+    static { NotebookEditor_1 = this; }
+    static { this.ID = NOTEBOOK_EDITOR_ID; }
+    get onDidFocus() { return this._onDidFocusWidget.event; }
+    get onDidBlur() { return this._onDidBlurWidget.event; }
+    constructor(telemetryService, themeService, _instantiationService, storageService, _editorService, _editorGroupService, _notebookWidgetService, _contextKeyService, _fileService, configurationService, _editorProgressService, _notebookService, _extensionsWorkbenchService, _workingCopyBackupService, logService, _notebookEditorWorkerService) {
+        super(NotebookEditor_1.ID, telemetryService, themeService, storageService);
+        this._instantiationService = _instantiationService;
+        this._editorService = _editorService;
+        this._editorGroupService = _editorGroupService;
+        this._notebookWidgetService = _notebookWidgetService;
+        this._contextKeyService = _contextKeyService;
+        this._fileService = _fileService;
+        this._editorProgressService = _editorProgressService;
+        this._notebookService = _notebookService;
+        this._extensionsWorkbenchService = _extensionsWorkbenchService;
+        this._workingCopyBackupService = _workingCopyBackupService;
+        this.logService = logService;
+        this._notebookEditorWorkerService = _notebookEditorWorkerService;
+        this._groupListener = this._register(( new DisposableStore()));
+        this._widgetDisposableStore = this._register(( new DisposableStore()));
+        this._widget = { value: undefined };
+        this._inputListener = this._register(( new MutableDisposable()));
+        this._onDidFocusWidget = this._register(( new Emitter()));
+        this._onDidBlurWidget = this._register(( new Emitter()));
+        this._onDidChangeModel = this._register(( new Emitter()));
+        this.onDidChangeModel = this._onDidChangeModel.event;
+        this._onDidChangeSelection = this._register(( new Emitter()));
+        this.onDidChangeSelection = this._onDidChangeSelection.event;
+        this._editorMemento = this.getEditorMemento(_editorGroupService, configurationService, NOTEBOOK_EDITOR_VIEW_STATE_PREFERENCE_KEY);
+        this._register(this._fileService.onDidChangeFileSystemProviderCapabilities(e => this._onDidChangeFileSystemProvider(e.scheme)));
+        this._register(this._fileService.onDidChangeFileSystemProviderRegistrations(e => this._onDidChangeFileSystemProvider(e.scheme)));
+    }
+    _onDidChangeFileSystemProvider(scheme) {
+        if (this.input instanceof NotebookEditorInput && this.input.resource?.scheme === scheme) {
+            this._updateReadonly(this.input);
+        }
+    }
+    _onDidChangeInputCapabilities(input) {
+        if (this.input === input) {
+            this._updateReadonly(input);
+        }
+    }
+    _updateReadonly(input) {
+        this._widget.value?.setOptions({ isReadOnly: !!input.isReadonly() });
+    }
+    get textModel() {
+        return this._widget.value?.textModel;
+    }
+    get minimumWidth() { return 220; }
+    get maximumWidth() { return Number.POSITIVE_INFINITY; }
+    set minimumWidth(value) { }
+    set maximumWidth(value) { }
+    get scopedContextKeyService() {
+        return this._widget.value?.scopedContextKeyService;
+    }
+    createEditor(parent) {
+        this._rootElement = dom.append(parent, dom.$('.notebook-editor'));
+        this._rootElement.id = `notebook-editor-element-${generateUuid()}`;
+    }
+    getActionViewItem(action) {
+        if (action.id === SELECT_KERNEL_ID) {
+            return this._instantiationService.createInstance(NotebooKernelActionViewItem, action, this);
+        }
+        return undefined;
+    }
+    getControl() {
+        return this._widget.value;
+    }
+    setEditorVisible(visible, group) {
+        super.setEditorVisible(visible, group);
+        if (group) {
+            this._groupListener.clear();
+            this._groupListener.add(group.onWillCloseEditor(e => this._saveEditorViewState(e.editor)));
+            this._groupListener.add(group.onDidModelChange(() => {
+                if (this._editorGroupService.activeGroup !== group) {
+                    this._widget?.value?.updateEditorFocus();
+                }
+            }));
+        }
+        if (!visible) {
+            this._saveEditorViewState(this.input);
+            if (this.input && this._widget.value) {
+                this._widget.value.onWillHide();
+            }
+        }
+    }
+    focus() {
+        super.focus();
+        this._widget.value?.focus();
+    }
+    hasFocus() {
+        const value = this._widget.value;
+        if (!value) {
+            return false;
+        }
+        return !!value && (dom.isAncestorOfActiveElement(value.getDomNode() || dom.isAncestorOfActiveElement(value.getOverflowContainerDomNode())));
+    }
+    async setInput(input, options, context, token, noRetry) {
+        try {
+            let perfMarksCaptured = false;
+            const fileOpenMonitor = timeout(10000);
+            fileOpenMonitor.then(() => {
+                perfMarksCaptured = true;
+                this._handlePerfMark(perf, input);
+            });
+            const perf = ( new NotebookPerfMarks());
+            perf.mark('startTime');
+            const group = this.group;
+            this._inputListener.value = input.onDidChangeCapabilities(() => this._onDidChangeInputCapabilities(input));
+            this._widgetDisposableStore.clear();
+            this._widget.value?.onWillHide();
+            this._widget = this._instantiationService.invokeFunction(this._notebookWidgetService.retrieveWidget, group, input, undefined, this._pagePosition?.dimension);
+            if (this._rootElement && this._widget.value.getDomNode()) {
+                this._rootElement.setAttribute('aria-flowto', this._widget.value.getDomNode().id || '');
+                dom.setParentFlowTo(this._widget.value.getDomNode(), this._rootElement);
+            }
+            this._widgetDisposableStore.add(this._widget.value.onDidChangeModel(() => this._onDidChangeModel.fire()));
+            this._widgetDisposableStore.add(this._widget.value.onDidChangeActiveCell(() => this._onDidChangeSelection.fire({ reason: 2  })));
+            if (this._pagePosition) {
+                this._widget.value.layout(this._pagePosition.dimension, this._rootElement, this._pagePosition.position);
+            }
+            await super.setInput(input, options, context, token);
+            const model = await input.resolve(options, perf);
+            perf.mark('inputLoaded');
+            if (token.isCancellationRequested) {
+                return undefined;
+            }
+            if (!this._widget.value) {
+                if (noRetry) {
+                    return undefined;
+                }
+                return this.setInput(input, options, context, token, true);
+            }
+            if (model === null) {
+                const knownProvider = this._notebookService.getViewTypeProvider(input.viewType);
+                if (!knownProvider) {
+                    throw new Error(localizeWithPath('vs/workbench/contrib/notebook/browser/notebookEditor', 'fail.noEditor', "Cannot open resource with notebook editor type '{0}', please check if you have the right extension installed and enabled.", input.viewType));
+                }
+                await this._extensionsWorkbenchService.whenInitialized;
+                const extensionInfo = this._extensionsWorkbenchService.local.find(e => e.identifier.id === knownProvider);
+                throw createEditorOpenError(new Error(localizeWithPath('vs/workbench/contrib/notebook/browser/notebookEditor', 'fail.noEditor.extensionMissing', "Cannot open resource with notebook editor type '{0}', please check if you have the right extension installed and enabled.", input.viewType)), [
+                    toAction({
+                        id: 'workbench.notebook.action.installOrEnableMissing', label: extensionInfo
+                            ? localizeWithPath('vs/workbench/contrib/notebook/browser/notebookEditor', 'notebookOpenEnableMissingViewType', "Enable extension for '{0}'", input.viewType)
+                            : localizeWithPath('vs/workbench/contrib/notebook/browser/notebookEditor', 'notebookOpenInstallMissingViewType', "Install extension for '{0}'", input.viewType),
+                        run: async () => {
+                            const d = this._notebookService.onAddViewType(viewType => {
+                                if (viewType === input.viewType) {
+                                    this._editorService.openEditor({ resource: input.resource });
+                                    d.dispose();
+                                }
+                            });
+                            const extensionInfo = this._extensionsWorkbenchService.local.find(e => e.identifier.id === knownProvider);
+                            try {
+                                if (extensionInfo) {
+                                    await this._extensionsWorkbenchService.setEnablement(extensionInfo, extensionInfo.enablementState === 7  ? 9  : 8 );
+                                }
+                                else {
+                                    await this._instantiationService.createInstance(InstallRecommendedExtensionAction, knownProvider).run();
+                                }
+                            }
+                            catch (ex) {
+                                this.logService.error(`Failed to install or enable extension ${knownProvider}`, ex);
+                                d.dispose();
+                            }
+                        }
+                    }),
+                    toAction({
+                        id: 'workbench.notebook.action.openAsText', label: localizeWithPath('vs/workbench/contrib/notebook/browser/notebookEditor', 'notebookOpenAsText', "Open As Text"), run: async () => {
+                            const backup = await this._workingCopyBackupService.resolve({ resource: input.resource, typeId: NotebookWorkingCopyTypeIdentifier.create(input.viewType) });
+                            if (backup) {
+                                const contents = await streamToBuffer(backup.value);
+                                this._editorService.openEditor({ resource: undefined, contents: contents.toString() });
+                            }
+                            else {
+                                this._editorService.openEditor({ resource: input.resource, options: { override: DEFAULT_EDITOR_ASSOCIATION.id, pinned: true } });
+                            }
+                        }
+                    })
+                ], { allowDialog: true });
+            }
+            this._widgetDisposableStore.add(model.notebook.onDidChangeContent(() => this._onDidChangeSelection.fire({ reason: 3  })));
+            const viewState = options?.viewState ?? this._loadNotebookEditorViewState(input);
+            this._widget.value.setParentContextKeyService(this._contextKeyService);
+            this._widget.value.setEditorProgressService(this._editorProgressService);
+            await this._widget.value.setModel(model.notebook, viewState, perf);
+            const isReadOnly = !!input.isReadonly();
+            await this._widget.value.setOptions({ ...options, isReadOnly });
+            this._widgetDisposableStore.add(this._widget.value.onDidFocusWidget(() => this._onDidFocusWidget.fire()));
+            this._widgetDisposableStore.add(this._widget.value.onDidBlurWidget(() => this._onDidBlurWidget.fire()));
+            this._widgetDisposableStore.add(this._editorGroupService.createEditorDropTarget(this._widget.value.getDomNode(), {
+                containsGroup: (group) => this.group?.id === group.id
+            }));
+            perf.mark('editorLoaded');
+            fileOpenMonitor.cancel();
+            if (perfMarksCaptured) {
+                return;
+            }
+            this._handlePerfMark(perf, input);
+            this._handlePromptRecommendations(model.notebook);
+        }
+        catch (e) {
+            this.logService.warn('NotebookEditorWidget#setInput failed', e);
+            if (isEditorOpenError(e)) {
+                throw e;
+            }
+            const error = createEditorOpenError(e instanceof Error ? e : ( new Error((e ? e.message : ''))), [
+                toAction({
+                    id: 'workbench.notebook.action.openInTextEditor', label: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/notebookEditor',
+                    'notebookOpenInTextEditor',
+                    "Open in Text Editor"
+                )), run: async () => {
+                        const activeEditorPane = this._editorService.activeEditorPane;
+                        if (!activeEditorPane) {
+                            return;
+                        }
+                        const activeEditorResource = EditorResourceAccessor.getCanonicalUri(activeEditorPane.input);
+                        if (!activeEditorResource) {
+                            return;
+                        }
+                        if (( activeEditorResource.toString()) === input.resource?.toString()) {
+                            return this._editorService.openEditor({
+                                resource: activeEditorResource,
+                                options: {
+                                    override: DEFAULT_EDITOR_ASSOCIATION.id,
+                                    pinned: true
+                                }
+                            });
+                        }
+                        return;
+                    }
+                })
+            ], { allowDialog: true });
+            throw error;
+        }
+    }
+    _handlePerfMark(perf, input) {
+        const perfMarks = perf.value;
+        const startTime = perfMarks['startTime'];
+        const extensionActivated = perfMarks['extensionActivated'];
+        const inputLoaded = perfMarks['inputLoaded'];
+        const customMarkdownLoaded = perfMarks['customMarkdownLoaded'];
+        const editorLoaded = perfMarks['editorLoaded'];
+        let extensionActivationTimespan = -1;
+        let inputLoadingTimespan = -1;
+        let webviewCommLoadingTimespan = -1;
+        let customMarkdownLoadingTimespan = -1;
+        let editorLoadingTimespan = -1;
+        if (startTime !== undefined && extensionActivated !== undefined) {
+            extensionActivationTimespan = extensionActivated - startTime;
+            if (inputLoaded !== undefined) {
+                inputLoadingTimespan = inputLoaded - extensionActivated;
+                webviewCommLoadingTimespan = inputLoaded - extensionActivated;
+            }
+            if (customMarkdownLoaded !== undefined) {
+                customMarkdownLoadingTimespan = customMarkdownLoaded - startTime;
+            }
+            if (editorLoaded !== undefined) {
+                editorLoadingTimespan = editorLoaded - startTime;
+            }
+        }
+        this.telemetryService.publicLog2('notebook/editorOpenPerf', {
+            scheme: input.resource.scheme,
+            ext: extname(input.resource),
+            viewType: input.viewType,
+            extensionActivated: extensionActivationTimespan,
+            inputLoaded: inputLoadingTimespan,
+            webviewCommLoaded: webviewCommLoadingTimespan,
+            customMarkdownLoaded: customMarkdownLoadingTimespan,
+            editorLoaded: editorLoadingTimespan
+        });
+    }
+    _handlePromptRecommendations(model) {
+        this._notebookEditorWorkerService.canPromptRecommendation(model.uri).then(shouldPrompt => {
+            this.telemetryService.publicLog2('notebook/shouldPromptRecommendation', {
+                shouldPrompt: shouldPrompt
+            });
+        });
+    }
+    clearInput() {
+        this._inputListener.clear();
+        if (this._widget.value) {
+            this._saveEditorViewState(this.input);
+            this._widget.value.onWillHide();
+        }
+        super.clearInput();
+    }
+    setOptions(options) {
+        this._widget.value?.setOptions(options);
+        super.setOptions(options);
+    }
+    saveState() {
+        this._saveEditorViewState(this.input);
+        super.saveState();
+    }
+    getViewState() {
+        const input = this.input;
+        if (!(input instanceof NotebookEditorInput)) {
+            return undefined;
+        }
+        this._saveEditorViewState(input);
+        return this._loadNotebookEditorViewState(input);
+    }
+    getSelection() {
+        if (this._widget.value) {
+            const activeCell = this._widget.value.getActiveCell();
+            if (activeCell) {
+                const cellUri = activeCell.uri;
+                return ( new NotebookEditorSelection(cellUri, activeCell.getSelections()));
+            }
+        }
+        return undefined;
+    }
+    _saveEditorViewState(input) {
+        if (this.group && this._widget.value && input instanceof NotebookEditorInput) {
+            if (this._widget.value.isDisposed) {
+                return;
+            }
+            const state = this._widget.value.getEditorViewState();
+            this._editorMemento.saveEditorState(this.group, input.resource, state);
+        }
+    }
+    _loadNotebookEditorViewState(input) {
+        let result;
+        if (this.group) {
+            result = this._editorMemento.loadEditorState(this.group, input.resource);
+        }
+        if (result) {
+            return result;
+        }
+        for (const group of this._editorGroupService.getGroups(1 )) {
+            if (group.activeEditorPane !== this && group.activeEditorPane instanceof NotebookEditor_1 && group.activeEditor?.matches(input)) {
+                return group.activeEditorPane._widget.value?.getEditorViewState();
+            }
+        }
+        return;
+    }
+    layout(dimension, position) {
+        this._rootElement.classList.toggle('mid-width', dimension.width < 1000 && dimension.width >= 600);
+        this._rootElement.classList.toggle('narrow-width', dimension.width < 600);
+        this._pagePosition = { dimension, position };
+        if (!this._widget.value || !(this._input instanceof NotebookEditorInput)) {
+            return;
+        }
+        if (( this._input.resource.toString()) !== this.textModel?.uri.toString() && this._widget.value?.hasModel()) {
+            return;
+        }
+        this._widget.value.layout(dimension, this._rootElement, position);
+    }
+};
+NotebookEditor = NotebookEditor_1 = ( __decorate([
+    ( __param(0, ITelemetryService)),
+    ( __param(1, IThemeService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, IEditorService)),
+    ( __param(5, IEditorGroupsService)),
+    ( __param(6, INotebookEditorService)),
+    ( __param(7, IContextKeyService)),
+    ( __param(8, IFileService)),
+    ( __param(9, ITextResourceConfigurationService)),
+    ( __param(10, IEditorProgressService)),
+    ( __param(11, INotebookService)),
+    ( __param(12, IExtensionsWorkbenchService)),
+    ( __param(13, IWorkingCopyBackupService)),
+    ( __param(14, ILogService)),
+    ( __param(15, INotebookEditorWorkerService))
+], NotebookEditor));
+class NotebookEditorSelection {
+    constructor(cellUri, selections) {
+        this.cellUri = cellUri;
+        this.selections = selections;
+    }
+    compare(other) {
+        if (!(other instanceof NotebookEditorSelection)) {
+            return 3 ;
+        }
+        if (isEqual(this.cellUri, other.cellUri)) {
+            return 1 ;
+        }
+        return 3 ;
+    }
+    restore(options) {
+        const notebookOptions = {
+            cellOptions: {
+                resource: this.cellUri,
+                options: {
+                    selection: this.selections[0]
+                }
+            }
+        };
+        Object.assign(notebookOptions, options);
+        return notebookOptions;
+    }
+    log() {
+        return this.cellUri.fragment;
+    }
+}
+export { NotebookEditor };

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

@@ -0,0 +1,29 @@
+class EditorContributionRegistry {
+    static { this.INSTANCE = ( new EditorContributionRegistry()); }
+    constructor() {
+        this.editorContributions = [];
+    }
+    registerEditorContribution(id, ctor) {
+        this.editorContributions.push({ id, ctor: ctor });
+    }
+    getEditorContributions() {
+        return this.editorContributions.slice(0);
+    }
+}
+function registerNotebookContribution(id, ctor) {
+    EditorContributionRegistry.INSTANCE.registerEditorContribution(id, ctor);
+}
+var NotebookEditorExtensionsRegistry;
+( (function(NotebookEditorExtensionsRegistry) {
+    function getEditorContributions() {
+        return EditorContributionRegistry.INSTANCE.getEditorContributions();
+    }
+    NotebookEditorExtensionsRegistry.getEditorContributions = getEditorContributions;
+    function getSomeEditorContributions(ids) {
+        return EditorContributionRegistry.INSTANCE.getEditorContributions().filter(c => ids.indexOf(c.id) >= 0);
+    }
+    NotebookEditorExtensionsRegistry.getSomeEditorContributions = getSomeEditorContributions;
+})(
+    NotebookEditorExtensionsRegistry || (NotebookEditorExtensionsRegistry = {})
+));
+export { NotebookEditorExtensionsRegistry, registerNotebookContribution };