@codingame/monaco-vscode-notebook-service-override 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/statusBarProviders.js

@@ -0,0 +1,173 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
+import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
+import { IKeybindingService } from 'vscode/vscode/vs/platform/keybinding/common/keybinding';
+import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { CHANGE_CELL_LANGUAGE, DETECT_CELL_LANGUAGE } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { INotebookCellStatusBarService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCellStatusBarService';
+import { CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { INotebookKernelService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookKernelService';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { ILanguageDetectionService } from 'vscode/vscode/vs/workbench/services/languageDetection/common/languageDetectionWorkerService';
+
+let CellStatusBarLanguagePickerProvider = class CellStatusBarLanguagePickerProvider {
+    constructor(_notebookService, _languageService) {
+        this._notebookService = _notebookService;
+        this._languageService = _languageService;
+        this.viewType = '*';
+    }
+    async provideCellStatusBarItems(uri, index, _token) {
+        const doc = this._notebookService.getNotebookTextModel(uri);
+        const cell = doc?.cells[index];
+        if (!cell) {
+            return;
+        }
+        const statusBarItems = [];
+        let displayLanguage = cell.language;
+        if (cell.cellKind === CellKind.Markup) {
+            displayLanguage = 'markdown';
+        }
+        else {
+            const registeredId = this._languageService.getLanguageIdByLanguageName(cell.language);
+            if (registeredId) {
+                displayLanguage = this._languageService.getLanguageName(displayLanguage) ?? displayLanguage;
+            }
+            else {
+                const searchTooltip = ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/statusBarProviders',
+                    'notebook.cell.status.searchLanguageExtensions',
+                    "Unknown cell language. Click to search for '{0}' extensions",
+                    cell.language
+                ));
+                statusBarItems.push({
+                    text: `$(dialog-warning)`,
+                    command: { id: 'workbench.extensions.search', arguments: [`@tag:${cell.language}`], title: 'Search Extensions' },
+                    tooltip: searchTooltip,
+                    alignment: 2 ,
+                    priority: -Number.MAX_SAFE_INTEGER + 1
+                });
+            }
+        }
+        statusBarItems.push({
+            text: displayLanguage,
+            command: CHANGE_CELL_LANGUAGE,
+            tooltip: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/statusBarProviders',
+                'notebook.cell.status.language',
+                "Select Cell Language Mode"
+            )),
+            alignment: 2 ,
+            priority: -Number.MAX_SAFE_INTEGER
+        });
+        return {
+            items: statusBarItems
+        };
+    }
+};
+CellStatusBarLanguagePickerProvider = ( __decorate([
+    ( __param(0, INotebookService)),
+    ( __param(1, ILanguageService))
+], CellStatusBarLanguagePickerProvider));
+let CellStatusBarLanguageDetectionProvider = class CellStatusBarLanguageDetectionProvider {
+    constructor(_notebookService, _notebookKernelService, _languageService, _configurationService, _languageDetectionService, _keybindingService) {
+        this._notebookService = _notebookService;
+        this._notebookKernelService = _notebookKernelService;
+        this._languageService = _languageService;
+        this._configurationService = _configurationService;
+        this._languageDetectionService = _languageDetectionService;
+        this._keybindingService = _keybindingService;
+        this.viewType = '*';
+        this.cache = ( new ResourceMap());
+    }
+    async provideCellStatusBarItems(uri, index, token) {
+        const doc = this._notebookService.getNotebookTextModel(uri);
+        const cell = doc?.cells[index];
+        if (!cell) {
+            return;
+        }
+        const enablementConfig = this._configurationService.getValue('workbench.editor.languageDetectionHints');
+        const enabled = typeof enablementConfig === 'object' && enablementConfig?.notebookEditors;
+        if (!enabled) {
+            return;
+        }
+        const cellUri = cell.uri;
+        const contentVersion = cell.textModel?.getVersionId();
+        if (!contentVersion) {
+            return;
+        }
+        const currentLanguageId = cell.cellKind === CellKind.Markup ?
+            'markdown' :
+            (this._languageService.getLanguageIdByLanguageName(cell.language) || cell.language);
+        if (!( this.cache.has(cellUri))) {
+            this.cache.set(cellUri, {
+                cellLanguage: currentLanguageId,
+                updateTimestamp: 0,
+                contentVersion: 1,
+            });
+        }
+        const cached = this.cache.get(cellUri);
+        if (cached.cellLanguage !== currentLanguageId || (cached.updateTimestamp < Date.now() - 1000 && cached.contentVersion !== contentVersion)) {
+            cached.updateTimestamp = Date.now();
+            cached.cellLanguage = currentLanguageId;
+            cached.contentVersion = contentVersion;
+            const kernel = this._notebookKernelService.getSelectedOrSuggestedKernel(doc);
+            if (kernel) {
+                const supportedLangs = [...kernel.supportedLanguages, 'markdown'];
+                cached.guess = await this._languageDetectionService.detectLanguage(cell.uri, supportedLangs);
+            }
+        }
+        const items = [];
+        if (cached.guess && currentLanguageId !== cached.guess) {
+            const detectedName = this._languageService.getLanguageName(cached.guess) || cached.guess;
+            let tooltip = ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/cellStatusBar/statusBarProviders',
+                'notebook.cell.status.autoDetectLanguage',
+                "Accept Detected Language: {0}",
+                detectedName
+            ));
+            const keybinding = this._keybindingService.lookupKeybinding(DETECT_CELL_LANGUAGE);
+            const label = keybinding?.getLabel();
+            if (label) {
+                tooltip += ` (${label})`;
+            }
+            items.push({
+                text: '$(lightbulb-autofix)',
+                command: DETECT_CELL_LANGUAGE,
+                tooltip,
+                alignment: 2 ,
+                priority: -Number.MAX_SAFE_INTEGER + 1
+            });
+        }
+        return { items };
+    }
+};
+CellStatusBarLanguageDetectionProvider = ( __decorate([
+    ( __param(0, INotebookService)),
+    ( __param(1, INotebookKernelService)),
+    ( __param(2, ILanguageService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, ILanguageDetectionService)),
+    ( __param(5, IKeybindingService))
+], CellStatusBarLanguageDetectionProvider));
+let BuiltinCellStatusBarProviders = class BuiltinCellStatusBarProviders extends Disposable {
+    constructor(instantiationService, notebookCellStatusBarService) {
+        super();
+        const builtinProviders = [
+            CellStatusBarLanguagePickerProvider,
+            CellStatusBarLanguageDetectionProvider,
+        ];
+        builtinProviders.forEach(p => {
+            this._register(notebookCellStatusBarService.registerCellStatusBarItemProvider(instantiationService.createInstance(p)));
+        });
+    }
+};
+BuiltinCellStatusBarProviders = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, INotebookCellStatusBarService))
+], BuiltinCellStatusBarProviders));
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(BuiltinCellStatusBarProviders, 3 );