@codingame/monaco-vscode-notebook-service-override 25.1.2 → 26.0.0

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

@@ -16,7 +16,9 @@ import { runWhenWindowIdle, getActiveWindow } from '@codingame/monaco-vscode-api
 
 var NotebookKernelService_1;
 class KernelInfo {
-    static { this._logicClock = 0; }
+    static {
+        this._logicClock = 0;
+    }
     constructor(kernel) {
         this.notebookPriorities = ( new ResourceMap());
         this.kernel = kernel;
@@ -29,7 +31,7 @@ class NotebookTextModelLikeId {
         return `${k.notebookType}/${( k.uri.toString())}`;
     }
     static obj(s) {
-        const idx = s.indexOf('/');
+        const idx = s.indexOf("/");
         return {
             notebookType: s.substring(0, idx),
             uri: ( URI.parse(s.substring(idx + 1)))
@@ -61,15 +63,18 @@ class SourceAction extends Disposable {
                 uri: this.model.uri,
                 $mid: MarshalledId.NotebookActionContext
             });
-        }
-        catch (error) {
+        } catch (error) {
             console.warn(`Kernel source command failed: ${error}`);
         }
     }
 }
 let NotebookKernelService = class NotebookKernelService extends Disposable {
-    static { NotebookKernelService_1 = this; }
-    static { this._storageNotebookBinding = 'notebook.controller2NotebookBindings'; }
+    static {
+        NotebookKernelService_1 = this;
+    }
+    static {
+        this._storageNotebookBinding = "notebook.controller2NotebookBindings";
+    }
     constructor(_notebookService, _storageService, _menuService, _contextKeyService) {
         super();
         this._notebookService = _notebookService;
@@ -107,11 +112,13 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
             this._kernelSourceActionsUpdates.delete(id);
         }));
         try {
-            const data = JSON.parse(this._storageService.get(NotebookKernelService_1._storageNotebookBinding, StorageScope.WORKSPACE, '[]'));
+            const data = JSON.parse(this._storageService.get(
+                NotebookKernelService_1._storageNotebookBinding,
+                StorageScope.WORKSPACE,
+                "[]"
+            ));
             this._notebookBindings.fromJSON(data);
-        }
-        catch {
-        }
+        } catch {}
     }
     dispose() {
         this._kernels.clear();
@@ -128,17 +135,20 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
     _persistMementos() {
         this._persistSoonHandle?.dispose();
         this._persistSoonHandle = runWhenWindowIdle(getActiveWindow(), () => {
-            this._storageService.store(NotebookKernelService_1._storageNotebookBinding, JSON.stringify(this._notebookBindings), StorageScope.WORKSPACE, StorageTarget.MACHINE);
+            this._storageService.store(
+                NotebookKernelService_1._storageNotebookBinding,
+                JSON.stringify(this._notebookBindings),
+                StorageScope.WORKSPACE,
+                StorageTarget.MACHINE
+            );
         }, 100);
     }
     static _score(kernel, notebook) {
-        if (kernel.viewType === '*') {
+        if (kernel.viewType === "*") {
             return 5;
-        }
-        else if (kernel.viewType === notebook.notebookType) {
+        } else if (kernel.viewType === notebook.notebookType) {
             return 10;
-        }
-        else {
+        } else {
             return 0;
         }
     }
@@ -152,7 +162,11 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
             return;
         }
         if (!onlyThisKernel || existingKernel.kernel === onlyThisKernel) {
-            this._onDidChangeNotebookKernelBinding.fire({ notebook: notebook.uri, oldKernel: undefined, newKernel: existingKernel.kernel.id });
+            this._onDidChangeNotebookKernelBinding.fire({
+                notebook: notebook.uri,
+                oldKernel: undefined,
+                newKernel: existingKernel.kernel.id
+            });
         }
     }
     notifyVariablesChange(notebookUri) {
@@ -173,7 +187,11 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
             }
             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 });
+                    this._onDidChangeNotebookKernelBinding.fire({
+                        notebook: NotebookTextModelLikeId.obj(key).uri,
+                        oldKernel: kernel.id,
+                        newKernel: undefined
+                    });
                 }
             }
         });
@@ -186,25 +204,33 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
                 kernels.push({
                     score,
                     kernel: info.kernel,
-                    instanceAffinity: info.notebookPriorities.get(notebook.uri) ?? 1 ,
+                    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));
+        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 };
+        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 );
+        const preferred = info.all.filter(
+            kernel => this._kernels.get(kernel.id)?.notebookPriorities.get(notebook.uri) === 2
+        );
         if (preferred.length === 1) {
             return preferred[0];
         }
@@ -216,11 +242,14 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
         if (oldKernel !== kernel?.id) {
             if (kernel) {
                 this._notebookBindings.set(key, kernel.id);
-            }
-            else {
+            } else {
                 this._notebookBindings.delete(key);
             }
-            this._onDidChangeNotebookKernelBinding.fire({ notebook: notebook.uri, oldKernel, newKernel: kernel?.id });
+            this._onDidChangeNotebookKernelBinding.fire({
+                notebook: notebook.uri,
+                oldKernel,
+                newKernel: kernel?.id
+            });
             this._persistMementos();
         }
     }
@@ -239,8 +268,7 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
         }
         if (preference === undefined) {
             info.notebookPriorities.delete(notebook);
-        }
-        else {
+        } else {
             info.notebookPriorities.set(notebook, preference);
         }
         this._onDidChangeNotebookAffinity.fire();
@@ -260,10 +288,17 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
         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 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 groups = menu.getActions({
+                shouldForwardArgs: true
+            });
             const sourceActions = [];
             groups.forEach(group => {
                 const isPrimary = /^primary/.test(group[0]);
@@ -272,7 +307,7 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
                     const stateChangeListener = sourceAction.onDidChangeState(() => {
                         this._onDidChangeSourceActions.fire({
                             notebook: document.uri,
-                            viewType: document.notebookType,
+                            viewType: document.notebookType
                         });
                     });
                     sourceActions.push([sourceAction, stateChangeListener]);
@@ -280,7 +315,10 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
             });
             info.actions = sourceActions;
             this._kernelSources.set(id, info);
-            this._onDidChangeSourceActions.fire({ notebook: document.uri, viewType: document.notebookType });
+            this._onDidChangeSourceActions.fire({
+                notebook: document.uri,
+                viewType: document.notebookType
+            });
         };
         this._kernelSourceActionsUpdates.get(id)?.dispose();
         this._kernelSourceActionsUpdates.set(id, sourceMenu.onDidChange(() => {
@@ -312,9 +350,13 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
         const providers = this._kernelSourceActionProviders.get(viewType) ?? [];
         providers.push(provider);
         this._kernelSourceActionProviders.set(viewType, providers);
-        this._onDidChangeSourceActions.fire({ viewType: viewType });
+        this._onDidChangeSourceActions.fire({
+            viewType: viewType
+        });
         const eventEmitterDisposable = provider.onDidChangeSourceActions?.(() => {
-            this._onDidChangeSourceActions.fire({ viewType: viewType });
+            this._onDidChangeSourceActions.fire({
+                viewType: viewType
+            });
         });
         return toDisposable(() => {
             const providers = this._kernelSourceActionProviders.get(viewType) ?? [];
@@ -335,11 +377,6 @@ let NotebookKernelService = class NotebookKernelService extends Disposable {
         });
     }
 };
-NotebookKernelService = NotebookKernelService_1 = ( __decorate([
-    ( __param(0, INotebookService)),
-    ( __param(1, IStorageService)),
-    ( __param(2, IMenuService)),
-    ( __param(3, IContextKeyService))
-], NotebookKernelService));
+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

@@ -23,8 +23,15 @@ import Severity from '@codingame/monaco-vscode-api/vscode/vs/base/common/severit
 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 === InstallOperation.Install)))
-        .map(e => ( e.map(({ identifier }) => identifier)))));
+    const onDidInstallExtensions = Event.chain(extensionService.onDidInstallExtensions, $ => ( $.filter(e => ( e.some((
+        {
+            operation
+        }
+    ) => operation === InstallOperation.Install))).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))
@@ -38,20 +45,27 @@ function onExtensionChanged(accessor) {
         return result;
     });
 }
-const hasRecommendedKeymapKey = 'hasRecommendedKeymap';
+const hasRecommendedKeymapKey = "hasRecommendedKeymap";
 let NotebookKeymapService = class NotebookKeymapService extends Disposable {
-    constructor(instantiationService, extensionEnablementService, notificationService, storageService, lifecycleService) {
+    constructor(
+        instantiationService,
+        extensionEnablementService,
+        notificationService,
+        storageService,
+        lifecycleService
+    ) {
         super();
         this.instantiationService = instantiationService;
         this.extensionEnablementService = extensionEnablementService;
         this.notificationService = notificationService;
-        this.notebookKeymapMemento = ( new Memento('notebookKeymap', storageService));
+        this.notebookKeymapMemento = ( new Memento("notebookKeymap", storageService));
         this.notebookKeymap = this.notebookKeymapMemento.getMemento(StorageScope.PROFILE, StorageTarget.USER);
         this._register(lifecycleService.onDidShutdown(() => this.dispose()));
-        this._register(this.instantiationService.invokeFunction(onExtensionChanged)((identifiers => {
-            Promise.all(( identifiers.map(identifier => this.checkForOtherKeymaps(identifier))))
-                .then(undefined, onUnexpectedError);
-        })));
+        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 => {
@@ -60,7 +74,9 @@ let NotebookKeymapService = class NotebookKeymapService extends Disposable {
             if (extension && extension.globallyEnabled) {
                 this.notebookKeymap[hasRecommendedKeymapKey] = true;
                 this.notebookKeymapMemento.saveMemento();
-                const otherKeymaps = keymaps.filter(extension => !areSameExtensions(extension.identifier, extensionIdentifier) && extension.globallyEnabled);
+                const otherKeymaps = keymaps.filter(
+                    extension => !areSameExtensions(extension.identifier, extensionIdentifier) && extension.globallyEnabled
+                );
                 if (otherKeymaps.length) {
                     return this.promptForDisablingOtherKeymaps(extension, otherKeymaps);
                 }
@@ -69,31 +85,25 @@ let NotebookKeymapService = class NotebookKeymapService extends Disposable {
         });
     }
     promptForDisablingOtherKeymaps(newKeymap, oldKeymaps) {
-        const onPrompt = (confirmed) => {
+        const onPrompt = confirmed => {
             if (confirmed) {
                 this.extensionEnablementService.setEnablement(( oldKeymaps.map(keymap => keymap.local)), EnablementState.DisabledGlobally);
             }
         };
         this.notificationService.prompt(Severity.Info, ( localize(
-            9687,
+            10007,
             "Disable other keymaps ({0}) to avoid conflicts between keybindings?",
-            ( distinct(( oldKeymaps.map(k => k.local.manifest.displayName))).map(name => `'${name}'`)).join(', ')
+            ( distinct(( oldKeymaps.map(k => k.local.manifest.displayName))).map(name => `'${name}'`)).join(", ")
         )), [{
-                label: ( localize(9688, "Yes")),
-                run: () => onPrompt(true)
-            }, {
-                label: ( localize(9689, "No")),
-                run: () => onPrompt(false)
-            }]);
+            label: ( localize(10008, "Yes")),
+            run: () => onPrompt(true)
+        }, {
+            label: ( localize(10009, "No")),
+            run: () => onPrompt(false)
+        }]);
     }
 };
-NotebookKeymapService = ( __decorate([
-    ( __param(0, IInstantiationService)),
-    ( __param(1, IWorkbenchExtensionEnablementService)),
-    ( __param(2, INotificationService)),
-    ( __param(3, IStorageService)),
-    ( __param(4, ILifecycleService))
-], NotebookKeymapService));
+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;
@@ -102,7 +112,7 @@ function isNotebookKeymapExtension(extension) {
     if (!keywords) {
         return false;
     }
-    return keywords.indexOf('notebook-keymap') !== -1;
+    return keywords.indexOf("notebook-keymap") !== -1;
 }
 
 export { NotebookKeymapService, isNotebookKeymapExtension };

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

@@ -5,12 +5,17 @@ import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/l
 import { ILoggerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { windowLogGroup } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/log/common/logConstants';
 
-const logChannelId = 'notebook.rendering';
+const logChannelId = "notebook.rendering";
 let NotebookLoggingService = class NotebookLoggingService extends Disposable {
-    static { this.ID = 'notebook'; }
+    static {
+        this.ID = "notebook";
+    }
     constructor(loggerService) {
         super();
-        this._logger = this._register(loggerService.createLogger(logChannelId, { name: ( localize(9690, "Notebook")), group: windowLogGroup }));
+        this._logger = this._register(loggerService.createLogger(logChannelId, {
+            name: ( localize(10010, "Notebook")),
+            group: windowLogGroup
+        }));
     }
     trace(category, output) {
         this._logger.trace(`[${category}] ${output}`);
@@ -28,8 +33,6 @@ let NotebookLoggingService = class NotebookLoggingService extends Disposable {
         this._logger.error(`[${category}] ${output}`);
     }
 };
-NotebookLoggingService = ( __decorate([
-    ( __param(0, ILoggerService))
-], NotebookLoggingService));
+NotebookLoggingService = ( __decorate([( __param(0, ILoggerService))], NotebookLoggingService));
 
 export { NotebookLoggingService };

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

@@ -40,7 +40,7 @@ let NotebookRendererMessagingService = class NotebookRendererMessagingService ex
         }
         const messaging = {
             postMessage: (rendererId, message) => this.postMessage(editorId, rendererId, message),
-            dispose: () => this.scopedMessaging.delete(editorId),
+            dispose: () => this.scopedMessaging.delete(editorId)
         };
         this.scopedMessaging.set(editorId, messaging);
         return messaging;
@@ -50,17 +50,18 @@ let NotebookRendererMessagingService = class NotebookRendererMessagingService ex
             this.prepare(rendererId);
         }
         const activation = this.activations.get(rendererId);
-        const toSend = { rendererId, editorId, message };
+        const toSend = {
+            rendererId,
+            editorId,
+            message
+        };
         if (activation === undefined) {
             this.postMessageEmitter.fire(toSend);
-        }
-        else {
+        } else {
             activation.push(toSend);
         }
     }
 };
-NotebookRendererMessagingService = ( __decorate([
-    ( __param(0, IExtensionService))
-], NotebookRendererMessagingService));
+NotebookRendererMessagingService = ( __decorate([( __param(0, IExtensionService))], NotebookRendererMessagingService));
 
 export { NotebookRendererMessagingService };