@codingame/monaco-vscode-api 4.0.0 → 4.1.0

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

@@ -0,0 +1,339 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../../base/common/event.js';
+import { Disposable, toDisposable } from '../../../../../base/common/lifecycle.js';
+import { ResourceMap, LRUCache } from '../../../../../base/common/map.js';
+import { IStorageService } from '../../../../../platform/storage/common/storage.js';
+import { URI } from '../../../../../base/common/uri.js';
+import { INotebookService } from '../../common/notebookService.js';
+import { MenuId, IMenuService } from '../../../../../platform/actions/common/actions.js';
+import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.js';
+import { Schemas } from '../../../../../base/common/network.js';
+import { runWhenWindowIdle, getActiveWindow } from '../../../../../base/browser/dom.js';
+var NotebookKernelService_1;
+class KernelInfo {
+    static { this._logicClock = 0; }
+    constructor(kernel) {
+        this.notebookPriorities = ( new ResourceMap());
+        this.kernel = kernel;
+        this.score = -1;
+        this.time = KernelInfo._logicClock++;
+    }
+}
+class NotebookTextModelLikeId {
+    static str(k) {
+        return `${k.viewType}/${( k.uri.toString())}`;
+    }
+    static obj(s) {
+        const idx = s.indexOf('/');
+        return {
+            viewType: s.substring(0, idx),
+            uri: ( URI.parse(s.substring(idx + 1)))
+        };
+    }
+}
+class SourceAction extends Disposable {
+    constructor(action, model, isPrimary) {
+        super();
+        this.action = action;
+        this.model = model;
+        this.isPrimary = isPrimary;
+        this._onDidChangeState = this._register(( new Emitter()));
+        this.onDidChangeState = this._onDidChangeState.event;
+    }
+    async runAction() {
+        if (this.execution) {
+            return this.execution;
+        }
+        this.execution = this._runAction();
+        this._onDidChangeState.fire();
+        await this.execution;
+        this.execution = undefined;
+        this._onDidChangeState.fire();
+    }
+    async _runAction() {
+        try {
+            await this.action.run({
+                uri: this.model.uri,
+                $mid: 14
+            });
+        }
+        catch (error) {
+            console.warn(`Kernel source command failed: ${error}`);
+        }
+    }
+}
+let NotebookKernelService = class NotebookKernelService extends Disposable {
+    static { NotebookKernelService_1 = this; }
+    static { this._storageNotebookBinding = 'notebook.controller2NotebookBindings'; }
+    constructor(_notebookService, _storageService, _menuService, _contextKeyService) {
+        super();
+        this._notebookService = _notebookService;
+        this._storageService = _storageService;
+        this._menuService = _menuService;
+        this._contextKeyService = _contextKeyService;
+        this._kernels = ( new Map());
+        this._notebookBindings = ( new LRUCache(1000, 0.7));
+        this._onDidChangeNotebookKernelBinding = this._register(( new Emitter()));
+        this._onDidAddKernel = this._register(( new Emitter()));
+        this._onDidRemoveKernel = this._register(( new Emitter()));
+        this._onDidChangeNotebookAffinity = this._register(( new Emitter()));
+        this._onDidChangeSourceActions = this._register(( new Emitter()));
+        this._onDidNotebookVariablesChange = this._register(( new Emitter()));
+        this._kernelSources = ( new Map());
+        this._kernelSourceActionsUpdates = ( new Map());
+        this._kernelDetectionTasks = ( new Map());
+        this._onDidChangeKernelDetectionTasks = this._register(( new Emitter()));
+        this._kernelSourceActionProviders = ( new Map());
+        this.onDidChangeSelectedNotebooks = this._onDidChangeNotebookKernelBinding.event;
+        this.onDidAddKernel = this._onDidAddKernel.event;
+        this.onDidRemoveKernel = this._onDidRemoveKernel.event;
+        this.onDidChangeNotebookAffinity = this._onDidChangeNotebookAffinity.event;
+        this.onDidChangeSourceActions = this._onDidChangeSourceActions.event;
+        this.onDidChangeKernelDetectionTasks = this._onDidChangeKernelDetectionTasks.event;
+        this.onDidNotebookVariablesUpdate = this._onDidNotebookVariablesChange.event;
+        this._register(_notebookService.onDidAddNotebookDocument(this._tryAutoBindNotebook, this));
+        this._register(_notebookService.onWillRemoveNotebookDocument(notebook => {
+            const id = NotebookTextModelLikeId.str(notebook);
+            const kernelId = this._notebookBindings.get(id);
+            if (kernelId && notebook.uri.scheme === Schemas.untitled) {
+                this.selectKernelForNotebook(undefined, notebook);
+            }
+            this._kernelSourceActionsUpdates.get(id)?.dispose();
+            this._kernelSourceActionsUpdates.delete(id);
+        }));
+        try {
+            const data = JSON.parse(this._storageService.get(NotebookKernelService_1._storageNotebookBinding, 1 , '[]'));
+            this._notebookBindings.fromJSON(data);
+        }
+        catch {
+        }
+    }
+    dispose() {
+        this._kernels.clear();
+        this._kernelSources.forEach(v => {
+            v.menu.dispose();
+            v.actions.forEach(a => a[1].dispose());
+        });
+        this._kernelSourceActionsUpdates.forEach(v => {
+            v.dispose();
+        });
+        this._kernelSourceActionsUpdates.clear();
+        super.dispose();
+    }
+    _persistMementos() {
+        this._persistSoonHandle?.dispose();
+        this._persistSoonHandle = runWhenWindowIdle(getActiveWindow(), () => {
+            this._storageService.store(NotebookKernelService_1._storageNotebookBinding, JSON.stringify(this._notebookBindings), 1 , 1 );
+        }, 100);
+    }
+    static _score(kernel, notebook) {
+        if (kernel.viewType === '*') {
+            return 5;
+        }
+        else if (kernel.viewType === notebook.viewType) {
+            return 10;
+        }
+        else {
+            return 0;
+        }
+    }
+    _tryAutoBindNotebook(notebook, onlyThisKernel) {
+        const id = this._notebookBindings.get(NotebookTextModelLikeId.str(notebook));
+        if (!id) {
+            return;
+        }
+        const existingKernel = this._kernels.get(id);
+        if (!existingKernel || !NotebookKernelService_1._score(existingKernel.kernel, notebook)) {
+            return;
+        }
+        if (!onlyThisKernel || existingKernel.kernel === onlyThisKernel) {
+            this._onDidChangeNotebookKernelBinding.fire({ notebook: notebook.uri, oldKernel: undefined, newKernel: existingKernel.kernel.id });
+        }
+    }
+    notifyVariablesChange(notebookUri) {
+        this._onDidNotebookVariablesChange.fire(notebookUri);
+    }
+    registerKernel(kernel) {
+        if (( this._kernels.has(kernel.id))) {
+            throw new Error(`NOTEBOOK CONTROLLER with id '${kernel.id}' already exists`);
+        }
+        this._kernels.set(kernel.id, ( new KernelInfo(kernel)));
+        this._onDidAddKernel.fire(kernel);
+        for (const notebook of this._notebookService.getNotebookTextModels()) {
+            this._tryAutoBindNotebook(notebook, kernel);
+        }
+        return toDisposable(() => {
+            if (this._kernels.delete(kernel.id)) {
+                this._onDidRemoveKernel.fire(kernel);
+            }
+            for (const [key, candidate] of Array.from(this._notebookBindings)) {
+                if (candidate === kernel.id) {
+                    this._onDidChangeNotebookKernelBinding.fire({ notebook: NotebookTextModelLikeId.obj(key).uri, oldKernel: kernel.id, newKernel: undefined });
+                }
+            }
+        });
+    }
+    getMatchingKernel(notebook) {
+        const kernels = [];
+        for (const info of ( this._kernels.values())) {
+            const score = NotebookKernelService_1._score(info.kernel, notebook);
+            if (score) {
+                kernels.push({
+                    score,
+                    kernel: info.kernel,
+                    instanceAffinity: info.notebookPriorities.get(notebook.uri) ?? 1 ,
+                });
+            }
+        }
+        kernels
+            .sort((a, b) => b.instanceAffinity - a.instanceAffinity || a.score - b.score || a.kernel.label.localeCompare(b.kernel.label));
+        const all = ( kernels.map(obj => obj.kernel));
+        const selectedId = this._notebookBindings.get(NotebookTextModelLikeId.str(notebook));
+        const selected = selectedId ? this._kernels.get(selectedId)?.kernel : undefined;
+        const suggestions = ( kernels.filter(item => item.instanceAffinity > 1).map(item => item.kernel));
+        const hidden = ( kernels.filter(item => item.instanceAffinity < 0).map(item => item.kernel));
+        return { all, selected, suggestions, hidden };
+    }
+    getSelectedOrSuggestedKernel(notebook) {
+        const info = this.getMatchingKernel(notebook);
+        if (info.selected) {
+            return info.selected;
+        }
+        const preferred = info.all.filter(kernel => this._kernels.get(kernel.id)?.notebookPriorities.get(notebook.uri) === 2 );
+        if (preferred.length === 1) {
+            return preferred[0];
+        }
+        return info.all.length === 1 ? info.all[0] : undefined;
+    }
+    selectKernelForNotebook(kernel, notebook) {
+        const key = NotebookTextModelLikeId.str(notebook);
+        const oldKernel = this._notebookBindings.get(key);
+        if (oldKernel !== kernel?.id) {
+            if (kernel) {
+                this._notebookBindings.set(key, kernel.id);
+            }
+            else {
+                this._notebookBindings.delete(key);
+            }
+            this._onDidChangeNotebookKernelBinding.fire({ notebook: notebook.uri, oldKernel, newKernel: kernel?.id });
+            this._persistMementos();
+        }
+    }
+    preselectKernelForNotebook(kernel, notebook) {
+        const key = NotebookTextModelLikeId.str(notebook);
+        const oldKernel = this._notebookBindings.get(key);
+        if (oldKernel !== kernel?.id) {
+            this._notebookBindings.set(key, kernel.id);
+            this._persistMementos();
+        }
+    }
+    updateKernelNotebookAffinity(kernel, notebook, preference) {
+        const info = this._kernels.get(kernel.id);
+        if (!info) {
+            throw new Error(`UNKNOWN kernel '${kernel.id}'`);
+        }
+        if (preference === undefined) {
+            info.notebookPriorities.delete(notebook);
+        }
+        else {
+            info.notebookPriorities.set(notebook, preference);
+        }
+        this._onDidChangeNotebookAffinity.fire();
+    }
+    getRunningSourceActions(notebook) {
+        const id = NotebookTextModelLikeId.str(notebook);
+        const existingInfo = this._kernelSources.get(id);
+        if (existingInfo) {
+            return ( existingInfo.actions.filter(action => action[0].execution).map(action => action[0]));
+        }
+        return [];
+    }
+    getSourceActions(notebook, contextKeyService) {
+        contextKeyService = contextKeyService ?? this._contextKeyService;
+        const id = NotebookTextModelLikeId.str(notebook);
+        const existingInfo = this._kernelSources.get(id);
+        if (existingInfo) {
+            return ( existingInfo.actions.map(a => a[0]));
+        }
+        const sourceMenu = this._register(this._menuService.createMenu(MenuId.NotebookKernelSource, contextKeyService));
+        const info = { menu: sourceMenu, actions: [] };
+        const loadActionsFromMenu = (menu, document) => {
+            const groups = menu.getActions({ shouldForwardArgs: true });
+            const sourceActions = [];
+            groups.forEach(group => {
+                const isPrimary = /^primary/.test(group[0]);
+                group[1].forEach(action => {
+                    const sourceAction = ( new SourceAction(action, document, isPrimary));
+                    const stateChangeListener = sourceAction.onDidChangeState(() => {
+                        this._onDidChangeSourceActions.fire({
+                            notebook: document.uri,
+                            viewType: document.viewType,
+                        });
+                    });
+                    sourceActions.push([sourceAction, stateChangeListener]);
+                });
+            });
+            info.actions = sourceActions;
+            this._kernelSources.set(id, info);
+            this._onDidChangeSourceActions.fire({ notebook: document.uri, viewType: document.viewType });
+        };
+        this._kernelSourceActionsUpdates.get(id)?.dispose();
+        this._kernelSourceActionsUpdates.set(id, sourceMenu.onDidChange(() => {
+            loadActionsFromMenu(sourceMenu, notebook);
+        }));
+        loadActionsFromMenu(sourceMenu, notebook);
+        return ( info.actions.map(a => a[0]));
+    }
+    registerNotebookKernelDetectionTask(task) {
+        const notebookType = task.notebookType;
+        const all = this._kernelDetectionTasks.get(notebookType) ?? [];
+        all.push(task);
+        this._kernelDetectionTasks.set(notebookType, all);
+        this._onDidChangeKernelDetectionTasks.fire(notebookType);
+        return toDisposable(() => {
+            const all = this._kernelDetectionTasks.get(notebookType) ?? [];
+            const idx = all.indexOf(task);
+            if (idx >= 0) {
+                all.splice(idx, 1);
+                this._kernelDetectionTasks.set(notebookType, all);
+                this._onDidChangeKernelDetectionTasks.fire(notebookType);
+            }
+        });
+    }
+    getKernelDetectionTasks(notebook) {
+        return this._kernelDetectionTasks.get(notebook.viewType) ?? [];
+    }
+    registerKernelSourceActionProvider(viewType, provider) {
+        const providers = this._kernelSourceActionProviders.get(viewType) ?? [];
+        providers.push(provider);
+        this._kernelSourceActionProviders.set(viewType, providers);
+        this._onDidChangeSourceActions.fire({ viewType: viewType });
+        const eventEmitterDisposable = provider.onDidChangeSourceActions?.(() => {
+            this._onDidChangeSourceActions.fire({ viewType: viewType });
+        });
+        return toDisposable(() => {
+            const providers = this._kernelSourceActionProviders.get(viewType) ?? [];
+            const idx = providers.indexOf(provider);
+            if (idx >= 0) {
+                providers.splice(idx, 1);
+                this._kernelSourceActionProviders.set(viewType, providers);
+            }
+            eventEmitterDisposable?.dispose();
+        });
+    }
+    getKernelSourceActions2(notebook) {
+        const viewType = notebook.viewType;
+        const providers = this._kernelSourceActionProviders.get(viewType) ?? [];
+        const promises = ( providers.map(provider => provider.provideKernelSourceActions()));
+        return Promise.all(promises).then(actions => {
+            return actions.reduce((a, b) => a.concat(b), []);
+        });
+    }
+};
+NotebookKernelService = NotebookKernelService_1 = ( __decorate([
+    ( __param(0, INotebookService)),
+    ( __param(1, IStorageService)),
+    ( __param(2, IMenuService)),
+    ( __param(3, IContextKeyService))
+], NotebookKernelService));
+export { NotebookKernelService };

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

@@ -0,0 +1,109 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { onUnexpectedError } from '../../../../../base/common/errors.js';
+import { Event } from '../../../../../base/common/event.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { Severity, INotificationService } from '../../../../../platform/notification/common/notification.js';
+import { getInstalledExtensions } from '../../../extensions/common/extensionsUtils.js';
+import { IWorkbenchExtensionEnablementService } from '../../../../services/extensionManagement/common/extensionManagement.js';
+import { ILifecycleService } from '../../../../services/lifecycle/common/lifecycle.js';
+import { IExtensionManagementService } from '../../../../../platform/extensionManagement/common/extensionManagement.js';
+import { areSameExtensions } from '../../../../../platform/extensionManagement/common/extensionManagementUtil.js';
+import { IStorageService } from '../../../../../platform/storage/common/storage.js';
+import { Memento } from '../../../../common/memento.js';
+import { distinct } from '../../../../../base/common/arrays.js';
+function onExtensionChanged(accessor) {
+    const extensionService = accessor.get(IExtensionManagementService);
+    const extensionEnablementService = accessor.get(IWorkbenchExtensionEnablementService);
+    const onDidInstallExtensions = Event.chain(extensionService.onDidInstallExtensions, $ => ( $.filter(e => ( e.some(({ operation }) => operation === 2 )))
+        .map(e => ( e.map(({ identifier }) => identifier)))));
+    return Event.debounce(Event.any(Event.any(onDidInstallExtensions, ( Event.map(extensionService.onDidUninstallExtension, e => [e.identifier]))), ( Event.map(
+        extensionEnablementService.onEnablementChanged,
+        extensions => ( extensions.map(e => e.identifier))
+    ))), (result, identifiers) => {
+        result = result || (identifiers.length ? [identifiers[0]] : []);
+        for (const identifier of identifiers) {
+            if (( result.some(l => !areSameExtensions(l, identifier)))) {
+                result.push(identifier);
+            }
+        }
+        return result;
+    });
+}
+const hasRecommendedKeymapKey = 'hasRecommendedKeymap';
+let NotebookKeymapService = class NotebookKeymapService extends Disposable {
+    constructor(instantiationService, extensionEnablementService, notificationService, storageService, lifecycleService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.extensionEnablementService = extensionEnablementService;
+        this.notificationService = notificationService;
+        this.notebookKeymapMemento = ( new Memento('notebookKeymap', storageService));
+        this.notebookKeymap = this.notebookKeymapMemento.getMemento(0 , 0 );
+        this._register(lifecycleService.onDidShutdown(() => this.dispose()));
+        this._register(this.instantiationService.invokeFunction(onExtensionChanged)((identifiers => {
+            Promise.all(( identifiers.map(identifier => this.checkForOtherKeymaps(identifier))))
+                .then(undefined, onUnexpectedError);
+        })));
+    }
+    checkForOtherKeymaps(extensionIdentifier) {
+        return this.instantiationService.invokeFunction(getInstalledExtensions).then(extensions => {
+            const keymaps = extensions.filter(extension => isNotebookKeymapExtension(extension));
+            const extension = keymaps.find(extension => areSameExtensions(extension.identifier, extensionIdentifier));
+            if (extension && extension.globallyEnabled) {
+                this.notebookKeymap[hasRecommendedKeymapKey] = true;
+                this.notebookKeymapMemento.saveMemento();
+                const otherKeymaps = keymaps.filter(extension => !areSameExtensions(extension.identifier, extensionIdentifier) && extension.globallyEnabled);
+                if (otherKeymaps.length) {
+                    return this.promptForDisablingOtherKeymaps(extension, otherKeymaps);
+                }
+            }
+            return undefined;
+        });
+    }
+    promptForDisablingOtherKeymaps(newKeymap, oldKeymaps) {
+        const onPrompt = (confirmed) => {
+            if (confirmed) {
+                this.extensionEnablementService.setEnablement(( oldKeymaps.map(keymap => keymap.local)), 6 );
+            }
+        };
+        this.notificationService.prompt(Severity.Info, ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/services/notebookKeymapServiceImpl',
+            'disableOtherKeymapsConfirmation',
+            "Disable other keymaps ({0}) to avoid conflicts between keybindings?",
+            ( distinct(( oldKeymaps.map(k => k.local.manifest.displayName))).map(name => `'${name}'`)).join(', ')
+        )), [{
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/services/notebookKeymapServiceImpl',
+                    'yes',
+                    "Yes"
+                )),
+                run: () => onPrompt(true)
+            }, {
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/services/notebookKeymapServiceImpl',
+                    'no',
+                    "No"
+                )),
+                run: () => onPrompt(false)
+            }]);
+    }
+};
+NotebookKeymapService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkbenchExtensionEnablementService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IStorageService)),
+    ( __param(4, ILifecycleService))
+], NotebookKeymapService));
+function isNotebookKeymapExtension(extension) {
+    if (extension.local.manifest.extensionPack) {
+        return false;
+    }
+    const keywords = extension.local.manifest.keywords;
+    if (!keywords) {
+        return false;
+    }
+    return keywords.indexOf('notebook-keymap') !== -1;
+}
+export { NotebookKeymapService, isNotebookKeymapExtension };

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

@@ -0,0 +1,26 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../../nls.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { ILoggerService } from '../../../../../platform/log/common/log.js';
+const logChannelId = 'notebook.rendering';
+let NotebookLoggingService = class NotebookLoggingService extends Disposable {
+    static { this.ID = 'notebook'; }
+    constructor(loggerService) {
+        super();
+        this._logger = this._register(loggerService.createLogger(logChannelId, { name: ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/services/notebookLoggingServiceImpl',
+            'renderChannelName',
+            "Notebook rendering"
+        )) }));
+    }
+    debug(category, output) {
+        this._logger.debug(`[${category}] ${output}`);
+    }
+    info(category, output) {
+        this._logger.info(`[${category}] ${output}`);
+    }
+};
+NotebookLoggingService = ( __decorate([
+    ( __param(0, ILoggerService))
+], NotebookLoggingService));
+export { NotebookLoggingService };

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

@@ -0,0 +1,63 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from '../../../../../base/common/event.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import { IExtensionService } from '../../../../services/extensions/common/extensions.js';
+let NotebookRendererMessagingService = class NotebookRendererMessagingService extends Disposable {
+    constructor(extensionService) {
+        super();
+        this.extensionService = extensionService;
+        this.activations = ( new Map());
+        this.scopedMessaging = ( new Map());
+        this.postMessageEmitter = this._register(( new Emitter()));
+        this.onShouldPostMessage = this.postMessageEmitter.event;
+    }
+    receiveMessage(editorId, rendererId, message) {
+        if (editorId === undefined) {
+            const sends = ( [...( this.scopedMessaging.values())].map(e => e.receiveMessageHandler?.(rendererId, message)));
+            return Promise.all(sends).then(s => ( s.some(s => !!s)));
+        }
+        return this.scopedMessaging.get(editorId)?.receiveMessageHandler?.(rendererId, message) ?? Promise.resolve(false);
+    }
+    prepare(rendererId) {
+        if (( this.activations.has(rendererId))) {
+            return;
+        }
+        const queue = [];
+        this.activations.set(rendererId, queue);
+        this.extensionService.activateByEvent(`onRenderer:${rendererId}`).then(() => {
+            for (const message of queue) {
+                this.postMessageEmitter.fire(message);
+            }
+            this.activations.set(rendererId, undefined);
+        });
+    }
+    getScoped(editorId) {
+        const existing = this.scopedMessaging.get(editorId);
+        if (existing) {
+            return existing;
+        }
+        const messaging = {
+            postMessage: (rendererId, message) => this.postMessage(editorId, rendererId, message),
+            dispose: () => this.scopedMessaging.delete(editorId),
+        };
+        this.scopedMessaging.set(editorId, messaging);
+        return messaging;
+    }
+    postMessage(editorId, rendererId, message) {
+        if (!( this.activations.has(rendererId))) {
+            this.prepare(rendererId);
+        }
+        const activation = this.activations.get(rendererId);
+        const toSend = { rendererId, editorId, message };
+        if (activation === undefined) {
+            this.postMessageEmitter.fire(toSend);
+        }
+        else {
+            activation.push(toSend);
+        }
+    }
+};
+NotebookRendererMessagingService = ( __decorate([
+    ( __param(0, IExtensionService))
+], NotebookRendererMessagingService));
+export { NotebookRendererMessagingService };