npm - @codingame/monaco-vscode-language-detection-worker-service-override - Versions diffs - 25.1.2 → 26.0.0 - Mend

@codingame/monaco-vscode-language-detection-worker-service-override 25.1.2 → 26.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-language-detection-worker-service-override",
-  "version": "25.1.2",
+  "version": "26.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - language-detection-worker service-override",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "25.1.2",
+    "@codingame/monaco-vscode-api": "26.0.0",
     "@vscode/vscode-languagedetection": "npm:@codingame/vscode-languagedetection@1.0.23"
   },
   "main": "index.js",

package/vscode/src/vs/workbench/contrib/languageDetection/browser/languageDetection.contribution.js CHANGED Viewed

@@ -25,11 +25,22 @@ import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/netw
 import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
 var LanguageDetectionStatusContribution_1;
-const detectLanguageCommandId = 'editor.detectLanguage';
+const detectLanguageCommandId = "editor.detectLanguage";
 let LanguageDetectionStatusContribution = class LanguageDetectionStatusContribution {
-    static { LanguageDetectionStatusContribution_1 = this; }
-    static { this._id = 'status.languageDetectionStatus'; }
-    constructor(_languageDetectionService, _statusBarService, _configurationService, _editorService, _languageService, _keybindingService) {
+    static {
+        LanguageDetectionStatusContribution_1 = this;
+    }
+    static {
+        this._id = "status.languageDetectionStatus";
+    }
+    constructor(
+        _languageDetectionService,
+        _statusBarService,
+        _configurationService,
+        _editorService,
+        _languageService,
+        _keybindingService
+    ) {
         this._languageDetectionService = _languageDetectionService;
         this._statusBarService = _statusBarService;
         this._configurationService = _configurationService;
@@ -63,63 +74,65 @@ let LanguageDetectionStatusContribution = class LanguageDetectionStatusContribut
         const editorModel = editor?.getModel();
         const editorUri = editorModel?.uri;
         const existingId = editorModel?.getLanguageId();
-        const enablementConfig = this._configurationService.getValue('workbench.editor.languageDetectionHints');
-        const enabled = typeof enablementConfig === 'object' && enablementConfig?.untitledEditors;
+        const enablementConfig = this._configurationService.getValue("workbench.editor.languageDetectionHints");
+        const enabled = typeof enablementConfig === "object" && enablementConfig?.untitledEditors;
         const disableLightbulb = !enabled || editorUri?.scheme !== Schemas.untitled || !existingId;
         if (disableLightbulb || !editorUri) {
             this._combinedEntry?.dispose();
             this._combinedEntry = undefined;
-        }
-        else {
+        } else {
             const lang = await this._languageDetectionService.detectLanguage(editorUri);
-            const skip = { 'jsonc': 'json' };
+            const skip = {
+                "jsonc": "json"
+            };
             const existing = editorModel.getLanguageId();
             if (lang && lang !== existing && skip[existing] !== lang) {
                 const detectedName = this._languageService.getLanguageName(lang) || lang;
-                let tooltip = ( localize(8503, "Accept Detected Language: {0}", detectedName));
-                const keybinding = this._keybindingService.lookupKeybinding(detectLanguageCommandId);
-                const label = keybinding?.getLabel();
-                if (label) {
-                    tooltip += ` (${label})`;
-                }
+                const tooltip = this._keybindingService.appendKeybinding(( localize(8810, "Accept Detected Language: {0}", detectedName)), detectLanguageCommandId);
                 const props = {
-                    name: ( localize(8504, "Language Detection")),
-                    ariaLabel: ( localize(8505, "Change to Detected Language: {0}", lang)),
+                    name: ( localize(8811, "Language Detection")),
+                    ariaLabel: ( localize(8812, "Change to Detected Language: {0}", lang)),
                     tooltip,
                     command: detectLanguageCommandId,
-                    text: '$(lightbulb-autofix)',
+                    text: "$(lightbulb-autofix)"
                 };
                 if (!this._combinedEntry) {
-                    this._combinedEntry = this._statusBarService.addEntry(props, LanguageDetectionStatusContribution_1._id, StatusbarAlignment.RIGHT, { location: { id: 'status.editor.mode', priority: 100.1 }, alignment: StatusbarAlignment.RIGHT, compact: true });
-                }
-                else {
+                    this._combinedEntry = this._statusBarService.addEntry(
+                        props,
+                        LanguageDetectionStatusContribution_1._id,
+                        StatusbarAlignment.RIGHT,
+                        {
+                            location: {
+                                id: "status.editor.mode",
+                                priority: 100.1
+                            },
+                            alignment: StatusbarAlignment.RIGHT,
+                            compact: true
+                        }
+                    );
+                } else {
                     this._combinedEntry.update(props);
                 }
-            }
-            else {
+            } else {
                 this._combinedEntry?.dispose();
                 this._combinedEntry = undefined;
             }
         }
     }
 };
-LanguageDetectionStatusContribution = LanguageDetectionStatusContribution_1 = ( __decorate([
-    ( __param(0, ILanguageDetectionService)),
-    ( __param(1, IStatusbarService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, ILanguageService)),
-    ( __param(5, IKeybindingService))
-], LanguageDetectionStatusContribution));
+LanguageDetectionStatusContribution = LanguageDetectionStatusContribution_1 = ( __decorate([( __param(0, ILanguageDetectionService)), ( __param(1, IStatusbarService)), ( __param(2, IConfigurationService)), ( __param(3, IEditorService)), ( __param(4, ILanguageService)), ( __param(5, IKeybindingService))], LanguageDetectionStatusContribution));
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(LanguageDetectionStatusContribution, LifecyclePhase.Restored);
 registerAction2(class extends Action2 {
     constructor() {
         super({
             id: detectLanguageCommandId,
-            title: ( localize2(8506, "Detect Language from Content")),
+            title: ( localize2(8813, "Detect Language from Content")),
             f1: true,
             precondition: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.toNegated()), EditorContextKeys.editorTextFocus)),
-            keybinding: { primary: KeyCode.KeyD | KeyMod.Alt | KeyMod.Shift, weight: KeybindingWeight.WorkbenchContrib }
+            keybinding: {
+                primary: KeyCode.KeyD | KeyMod.Alt | KeyMod.Shift,
+                weight: KeybindingWeight.WorkbenchContrib
+            }
         });
     }
     async run(accessor) {
@@ -132,9 +145,8 @@ registerAction2(class extends Action2 {
             const lang = await languageDetectionService.detectLanguage(editorUri);
             if (lang) {
                 editor.getModel()?.setLanguage(lang, LanguageDetectionLanguageEventSource);
-            }
-            else {
-                notificationService.warn(( localize(8507, "Unable to detect editor language")));
+            } else {
+                notificationService.warn(( localize(8814, "Unable to detect editor language")));
             }
         }
     }

package/vscode/src/vs/workbench/services/languageDetection/browser/languageDetectionWebWorker.js CHANGED Viewed

@@ -8,10 +8,18 @@ function create(workerServer) {
     return ( new LanguageDetectionWorker(workerServer));
 }
 class LanguageDetectionWorker {
-    static { this.expectedRelativeConfidence = 0.2; }
-    static { this.positiveConfidenceCorrectionBucket1 = 0.05; }
-    static { this.positiveConfidenceCorrectionBucket2 = 0.025; }
-    static { this.negativeConfidenceCorrection = 0.5; }
+    static {
+        this.expectedRelativeConfidence = 0.2;
+    }
+    static {
+        this.positiveConfidenceCorrectionBucket1 = 0.05;
+    }
+    static {
+        this.positiveConfidenceCorrectionBucket2 = 0.025;
+    }
+    static {
+        this.negativeConfidenceCorrection = 0.5;
+    }
     constructor(workerServer) {
         this._requestHandlerBrand = undefined;
         this._workerTextModelSyncServer = ( new WorkerTextModelSyncServer());
@@ -76,8 +84,7 @@ class LanguageDetectionWorker {
                 try {
                     const modelJSON = await response.json();
                     return modelJSON;
-                }
-                catch (e) {
+                } catch (e) {
                     const message = `Failed to parse model JSON.`;
                     throw ( new Error(message));
                 }
@@ -92,31 +99,31 @@ class LanguageDetectionWorker {
     }
     adjustLanguageConfidence(modelResult) {
         switch (modelResult.languageId) {
-            case 'js':
-            case 'html':
-            case 'json':
-            case 'ts':
-            case 'css':
-            case 'py':
-            case 'xml':
-            case 'php':
-                modelResult.confidence += LanguageDetectionWorker.positiveConfidenceCorrectionBucket1;
-                break;
-            case 'cpp':
-            case 'sh':
-            case 'java':
-            case 'cs':
-            case 'c':
-                modelResult.confidence += LanguageDetectionWorker.positiveConfidenceCorrectionBucket2;
-                break;
-            case 'bat':
-            case 'ini':
-            case 'makefile':
-            case 'sql':
-            case 'csv':
-            case 'toml':
-                modelResult.confidence -= LanguageDetectionWorker.negativeConfidenceCorrection;
-                break;
+        case "js":
+        case "html":
+        case "json":
+        case "ts":
+        case "css":
+        case "py":
+        case "xml":
+        case "php":
+            modelResult.confidence += LanguageDetectionWorker.positiveConfidenceCorrectionBucket1;
+            break;
+        case "cpp":
+        case "sh":
+        case "java":
+        case "cs":
+        case "c":
+            modelResult.confidence += LanguageDetectionWorker.positiveConfidenceCorrectionBucket2;
+            break;
+        case "bat":
+        case "ini":
+        case "makefile":
+        case "sql":
+        case "csv":
+        case "toml":
+            modelResult.confidence -= LanguageDetectionWorker.negativeConfidenceCorrection;
+            break;
         }
         return modelResult;
     }
@@ -127,8 +134,7 @@ class LanguageDetectionWorker {
         let modelOperations;
         try {
             modelOperations = await this.getModelOperations();
-        }
-        catch (e) {
+        } catch (e) {
             console.log(e);
             this._loadFailed = true;
             return;
@@ -136,13 +142,10 @@ class LanguageDetectionWorker {
         let modelResults;
         try {
             modelResults = await modelOperations.runModel(content);
-        }
-        catch (e) {
+        } catch (e) {
             console.warn(e);
         }
-        if (!modelResults
-            || modelResults.length === 0
-            || modelResults[0].confidence < LanguageDetectionWorker.expectedRelativeConfidence) {
+        if (!modelResults || modelResults.length === 0 || modelResults[0].confidence < LanguageDetectionWorker.expectedRelativeConfidence) {
             return;
         }
         const firstModelResult = this.adjustLanguageConfidence(modelResults[0]);
@@ -165,8 +168,7 @@ class LanguageDetectionWorker {
                     continue;
                 }
                 return;
-            }
-            else {
+            } else {
                 if (current.confidence > LanguageDetectionWorker.expectedRelativeConfidence) {
                     possibleLanguages.push(current);
                     continue;

package/vscode/src/vs/workbench/services/languageDetection/browser/languageDetectionWorkerServiceImpl.js CHANGED Viewed

@@ -29,13 +29,37 @@ const TOP_LANG_COUNTS = 12;
 const regexpModuleLocation = `${nodeModulesPath}/vscode-regexp-languagedetection`;
 const moduleLocation = `${nodeModulesPath}/@vscode/vscode-languagedetection`;
 let LanguageDetectionService = class LanguageDetectionService extends Disposable {
-    static { LanguageDetectionService_1 = this; }
-    static { this.enablementSettingKey = 'workbench.editor.languageDetection'; }
-    static { this.historyBasedEnablementConfig = 'workbench.editor.historyBasedLanguageDetection'; }
-    static { this.preferHistoryConfig = 'workbench.editor.preferHistoryBasedLanguageDetection'; }
-    static { this.workspaceOpenedLanguagesStorageKey = 'workbench.editor.languageDetectionOpenedLanguages.workspace'; }
-    static { this.globalOpenedLanguagesStorageKey = 'workbench.editor.languageDetectionOpenedLanguages.global'; }
-    constructor(_environmentService, languageService, _configurationService, _diagnosticsService, _workspaceContextService, modelService, _editorService, telemetryService, storageService, _logService, webWorkerService) {
+    static {
+        LanguageDetectionService_1 = this;
+    }
+    static {
+        this.enablementSettingKey = "workbench.editor.languageDetection";
+    }
+    static {
+        this.historyBasedEnablementConfig = "workbench.editor.historyBasedLanguageDetection";
+    }
+    static {
+        this.preferHistoryConfig = "workbench.editor.preferHistoryBasedLanguageDetection";
+    }
+    static {
+        this.workspaceOpenedLanguagesStorageKey = "workbench.editor.languageDetectionOpenedLanguages.workspace";
+    }
+    static {
+        this.globalOpenedLanguagesStorageKey = "workbench.editor.languageDetectionOpenedLanguages.global";
+    }
+    constructor(
+        _environmentService,
+        languageService,
+        _configurationService,
+        _diagnosticsService,
+        _workspaceContextService,
+        modelService,
+        _editorService,
+        telemetryService,
+        storageService,
+        _logService,
+        webWorkerService
+    ) {
         super();
         this._environmentService = _environmentService;
         this._configurationService = _configurationService;
@@ -82,7 +106,9 @@ let LanguageDetectionService = class LanguageDetectionService extends Disposable
         this.dirtyBiases = true;
     }
     isEnabledForLanguage(languageId) {
-        return !!languageId && this._configurationService.getValue(LanguageDetectionService_1.enablementSettingKey, { overrideIdentifier: languageId });
+        return !!languageId && this._configurationService.getValue(LanguageDetectionService_1.enablementSettingKey, {
+            overrideIdentifier: languageId
+        });
     }
     getLanguageBiases() {
         if (!this.dirtyBiases) {
@@ -93,11 +119,14 @@ let LanguageDetectionService = class LanguageDetectionService extends Disposable
         this.workspaceLanguageIds.forEach(lang => biases[lang] = (biases[lang] ?? 0) + 5);
         [...( this.historicalWorkspaceOpenedLanguageIds.keys())].forEach(lang => biases[lang] = (biases[lang] ?? 0) + 3);
         [...( this.historicalGlobalOpenedLanguageIds.keys())].forEach(lang => biases[lang] = (biases[lang] ?? 0) + 1);
-        this._logService.trace('Session Languages:', JSON.stringify([...this.sessionOpenedLanguageIds]));
-        this._logService.trace('Workspace Languages:', JSON.stringify([...this.workspaceLanguageIds]));
-        this._logService.trace('Historical Workspace Opened Languages:', JSON.stringify([...( this.historicalWorkspaceOpenedLanguageIds.keys())]));
-        this._logService.trace('Historical Globally Opened Languages:', JSON.stringify([...( this.historicalGlobalOpenedLanguageIds.keys())]));
-        this._logService.trace('Computed Language Detection Biases:', JSON.stringify(biases));
+        this._logService.trace("Session Languages:", JSON.stringify([...this.sessionOpenedLanguageIds]));
+        this._logService.trace("Workspace Languages:", JSON.stringify([...this.workspaceLanguageIds]));
+        this._logService.trace(
+            "Historical Workspace Opened Languages:",
+            JSON.stringify([...( this.historicalWorkspaceOpenedLanguageIds.keys())])
+        );
+        this._logService.trace("Historical Globally Opened Languages:", JSON.stringify([...( this.historicalGlobalOpenedLanguageIds.keys())]));
+        this._logService.trace("Computed Language Detection Biases:", JSON.stringify(biases));
         this.dirtyBiases = false;
         this.langBiases = biases;
         return biases;
@@ -113,17 +142,23 @@ let LanguageDetectionService = class LanguageDetectionService extends Disposable
     }
     initEditorOpenedListeners(storageService) {
         try {
-            const globalLangHistoryData = JSON.parse(storageService.get(LanguageDetectionService_1.globalOpenedLanguagesStorageKey, StorageScope.PROFILE, '[]'));
+            const globalLangHistoryData = JSON.parse(storageService.get(
+                LanguageDetectionService_1.globalOpenedLanguagesStorageKey,
+                StorageScope.PROFILE,
+                "[]"
+            ));
             this.historicalGlobalOpenedLanguageIds.fromJSON(globalLangHistoryData);
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
         }
         try {
-            const workspaceLangHistoryData = JSON.parse(storageService.get(LanguageDetectionService_1.workspaceOpenedLanguagesStorageKey, StorageScope.WORKSPACE, '[]'));
+            const workspaceLangHistoryData = JSON.parse(storageService.get(
+                LanguageDetectionService_1.workspaceOpenedLanguagesStorageKey,
+                StorageScope.WORKSPACE,
+                "[]"
+            ));
             this.historicalWorkspaceOpenedLanguageIds.fromJSON(workspaceLangHistoryData);
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
         }
         this._register(this._editorService.onDidActiveEditorChange(() => {
@@ -132,28 +167,35 @@ let LanguageDetectionService = class LanguageDetectionService extends Disposable
                 this.sessionOpenedLanguageIds.add(activeLanguage);
                 this.historicalGlobalOpenedLanguageIds.set(activeLanguage, true);
                 this.historicalWorkspaceOpenedLanguageIds.set(activeLanguage, true);
-                storageService.store(LanguageDetectionService_1.globalOpenedLanguagesStorageKey, JSON.stringify(this.historicalGlobalOpenedLanguageIds.toJSON()), StorageScope.PROFILE, StorageTarget.MACHINE);
-                storageService.store(LanguageDetectionService_1.workspaceOpenedLanguagesStorageKey, JSON.stringify(this.historicalWorkspaceOpenedLanguageIds.toJSON()), StorageScope.WORKSPACE, StorageTarget.MACHINE);
+                storageService.store(
+                    LanguageDetectionService_1.globalOpenedLanguagesStorageKey,
+                    JSON.stringify(this.historicalGlobalOpenedLanguageIds.toJSON()),
+                    StorageScope.PROFILE,
+                    StorageTarget.MACHINE
+                );
+                storageService.store(
+                    LanguageDetectionService_1.workspaceOpenedLanguagesStorageKey,
+                    JSON.stringify(this.historicalWorkspaceOpenedLanguageIds.toJSON()),
+                    StorageScope.WORKSPACE,
+                    StorageTarget.MACHINE
+                );
                 this.dirtyBiases = true;
             }
         }));
     }
 };
-LanguageDetectionService = LanguageDetectionService_1 = ( __decorate([
-    ( __param(0, IWorkbenchEnvironmentService)),
-    ( __param(1, ILanguageService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IDiagnosticsService)),
-    ( __param(4, IWorkspaceContextService)),
-    ( __param(5, IModelService)),
-    ( __param(6, IEditorService)),
-    ( __param(7, ITelemetryService)),
-    ( __param(8, IStorageService)),
-    ( __param(9, ILogService)),
-    ( __param(10, IWebWorkerService))
-], LanguageDetectionService));
+LanguageDetectionService = LanguageDetectionService_1 = ( __decorate([( __param(0, IWorkbenchEnvironmentService)), ( __param(1, ILanguageService)), ( __param(2, IConfigurationService)), ( __param(3, IDiagnosticsService)), ( __param(4, IWorkspaceContextService)), ( __param(5, IModelService)), ( __param(6, IEditorService)), ( __param(7, ITelemetryService)), ( __param(8, IStorageService)), ( __param(9, ILogService)), ( __param(10, IWebWorkerService))], LanguageDetectionService));
 class LanguageDetectionWorkerClient extends Disposable {
-    constructor(_modelService, _languageService, _telemetryService, _webWorkerService, _indexJsUri, _modelJsonUri, _weightsUri, _regexpModelUri) {
+    constructor(
+        _modelService,
+        _languageService,
+        _telemetryService,
+        _webWorkerService,
+        _indexJsUri,
+        _modelJsonUri,
+        _weightsUri,
+        _regexpModelUri
+    ) {
         super();
         this._modelService = _modelService;
         this._languageService = _languageService;
@@ -168,26 +210,29 @@ class LanguageDetectionWorkerClient extends Disposable {
         if (!this.worker) {
             const workerClient = this._register(this._webWorkerService.createWorkerClient(( new WebWorkerDescriptor({
                 esmModuleLocation: ( FileAccess.asBrowserUri(
-                    'vs/workbench/services/languageDetection/browser/languageDetectionWebWorkerMain.js'
+                    "vs/workbench/services/languageDetection/browser/languageDetectionWebWorkerMain.js"
                 )),
-                label: 'LanguageDetectionWorker'
+                label: "LanguageDetectionWorker"
             }))));
             LanguageDetectionWorkerHost.setChannel(workerClient, {
                 $getIndexJsUri: async () => this.getIndexJsUri(),
-                $getLanguageId: async (languageIdOrExt) => this.getLanguageId(languageIdOrExt),
+                $getLanguageId: async languageIdOrExt => this.getLanguageId(languageIdOrExt),
                 $sendTelemetryEvent: async (languages, confidences, timeSpent) => this.sendTelemetryEvent(languages, confidences, timeSpent),
                 $getRegexpModelUri: async () => this.getRegexpModelUri(),
                 $getModelJsonUri: async () => this.getModelJsonUri(),
-                $getWeightsUri: async () => this.getWeightsUri(),
+                $getWeightsUri: async () => this.getWeightsUri()
             });
             const workerTextModelSyncClient = this._register(WorkerTextModelSyncClient.create(workerClient, this._modelService));
-            this.worker = { workerClient, workerTextModelSyncClient };
+            this.worker = {
+                workerClient,
+                workerTextModelSyncClient
+            };
         }
         return this.worker;
     }
     _guessLanguageIdByUri(uri) {
         const guess = this._languageService.guessLanguageIdByFilepathOrFirstLine(uri);
-        if (guess && guess !== 'unknown') {
+        if (guess && guess !== "unknown") {
             return guess;
         }
         return undefined;
@@ -203,7 +248,7 @@ class LanguageDetectionWorkerClient extends Disposable {
             return languageIdOrExt;
         }
         const guessed = this._guessLanguageIdByUri(URI.file(`file.${languageIdOrExt}`));
-        if (!guessed || guessed === 'unknown') {
+        if (!guessed || guessed === "unknown") {
             return undefined;
         }
         return guessed;
@@ -219,8 +264,8 @@ class LanguageDetectionWorkerClient extends Disposable {
     }
     async sendTelemetryEvent(languages, confidences, timeSpent) {
         this._telemetryService.publicLog2(LanguageDetectionStatsId, {
-            languages: languages.join(','),
-            confidences: confidences.join(','),
+            languages: languages.join(","),
+            confidences: confidences.join(","),
             timeSpent
         });
     }
@@ -230,14 +275,17 @@ class LanguageDetectionWorkerClient extends Disposable {
         if (quickGuess) {
             return quickGuess;
         }
-        const { workerClient, workerTextModelSyncClient } = this._getOrCreateLanguageDetectionWorker();
+        const {
+            workerClient,
+            workerTextModelSyncClient
+        } = this._getOrCreateLanguageDetectionWorker();
         workerTextModelSyncClient.ensureSyncedResources([resource]);
         const modelId = await workerClient.proxy.$detectLanguage(( resource.toString()), langBiases, preferHistory, supportedLangs);
         const languageId = this.getLanguageId(modelId);
-        const LanguageDetectionStatsId = 'automaticlanguagedetection.perf';
+        const LanguageDetectionStatsId = "automaticlanguagedetection.perf";
         this._telemetryService.publicLog2(LanguageDetectionStatsId, {
             timeSpent: Date.now() - startTime,
-            detection: languageId || 'unknown',
+            detection: languageId || "unknown"
         });
         return languageId;
     }