@codingame/monaco-vscode-language-detection-worker-service-override 8.0.4 → 9.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-language-detection-worker-service-override",
-  "version": "8.0.4",
+  "version": "9.0.2",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -29,7 +29,7 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@8.0.4",
-    "@vscode/vscode-languagedetection": "npm:@codingame/vscode-languagedetection@1.0.23"
+    "vscode": "npm:@codingame/monaco-vscode-api@9.0.2",
+    "@vscode/vscode-languagedetection": "1.0.21"
   }
 }

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

@@ -75,15 +75,15 @@ let LanguageDetectionStatusContribution = class LanguageDetectionStatusContribut
             const existing = editorModel.getLanguageId();
             if (lang && lang !== existing && skip[existing] !== lang) {
                 const detectedName = this._languageService.getLanguageName(lang) || lang;
-                let tooltip = ( localize(2133, "Accept Detected Language: {0}", detectedName));
+                let tooltip = ( localize(2146, "Accept Detected Language: {0}", detectedName));
                 const keybinding = this._keybindingService.lookupKeybinding(detectLanguageCommandId);
                 const label = keybinding?.getLabel();
                 if (label) {
                     tooltip += ` (${label})`;
                 }
                 const props = {
-                    name: ( localize(2134, "Language Detection")),
-                    ariaLabel: ( localize(2135, "Change to Detected Language: {0}", lang)),
+                    name: ( localize(2147, "Language Detection")),
+                    ariaLabel: ( localize(2148, "Change to Detected Language: {0}", lang)),
                     tooltip,
                     command: detectLanguageCommandId,
                     text: '$(lightbulb-autofix)',
@@ -115,7 +115,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: detectLanguageCommandId,
-            title: ( localize2(2136, "Detect Language from Content")),
+            title: ( localize2(2149, "Detect Language from Content")),
             f1: true,
             precondition: ( (ContextKeyExpr.and(
                  (NOTEBOOK_EDITOR_EDITABLE.toNegated()),
@@ -136,7 +136,7 @@ registerAction2(class extends Action2 {
                 editor.getModel()?.setLanguage(lang, LanguageDetectionLanguageEventSource);
             }
             else {
-                notificationService.warn(( localize(2137, "Unable to detect editor language")));
+                notificationService.warn(( localize(2150, "Unable to detect editor language")));
             }
         }
     }

package/vscode/src/vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker.js

@@ -1,21 +1,24 @@
 import { ModelOperations } from '@vscode/vscode-languagedetection';
 import { StopWatch } from 'vscode/vscode/vs/base/common/stopwatch';
-import { EditorSimpleWorker } from 'vscode/vscode/vs/editor/common/services/editorSimpleWorker';
+import { LanguageDetectionWorkerHost } from './languageDetectionWorker.protocol.js';
+import { WorkerTextModelSyncServer } from 'vscode/vscode/vs/editor/common/services/textModelSync/textModelSync.impl';
 
-function create(host) {
-    return ( new LanguageDetectionSimpleWorker(host, null));
+function create(workerServer) {
+    return ( new LanguageDetectionSimpleWorker(workerServer));
 }
-class LanguageDetectionSimpleWorker extends EditorSimpleWorker {
-    constructor() {
-        super(...arguments);
-        this._loadFailed = false;
-        this.modelIdToCoreId = ( new Map());
-    }
+class LanguageDetectionSimpleWorker {
     static { this.expectedRelativeConfidence = 0.2; }
     static { this.positiveConfidenceCorrectionBucket1 = 0.05; }
     static { this.positiveConfidenceCorrectionBucket2 = 0.025; }
     static { this.negativeConfidenceCorrection = 0.5; }
-    async detectLanguage(uri, langBiases, preferHistory, supportedLangs) {
+    constructor(workerServer) {
+        this._workerTextModelSyncServer = ( new WorkerTextModelSyncServer());
+        this._loadFailed = false;
+        this.modelIdToCoreId = ( new Map());
+        this._host = LanguageDetectionWorkerHost.getChannel(workerServer);
+        this._workerTextModelSyncServer.bindToServer(workerServer);
+    }
+    async $detectLanguage(uri, langBiases, preferHistory, supportedLangs) {
         const languages = [];
         const confidences = [];
         const stopWatch = ( new StopWatch());
@@ -26,7 +29,7 @@ class LanguageDetectionSimpleWorker extends EditorSimpleWorker {
         const neuralResolver = async () => {
             for await (const language of this.detectLanguagesImpl(documentTextSample)) {
                 if (!( this.modelIdToCoreId.has(language.languageId))) {
-                    this.modelIdToCoreId.set(language.languageId, await this._host.fhr('getLanguageId', [language.languageId]));
+                    this.modelIdToCoreId.set(language.languageId, await this._host.$getLanguageId(language.languageId));
                 }
                 const coreId = this.modelIdToCoreId.get(language.languageId);
                 if (coreId && (!supportedLangs?.length || supportedLangs.includes(coreId))) {
@@ -36,7 +39,7 @@ class LanguageDetectionSimpleWorker extends EditorSimpleWorker {
             }
             stopWatch.stop();
             if (languages.length) {
-                this._host.fhr('sendTelemetryEvent', [languages, confidences, stopWatch.elapsed()]);
+                this._host.$sendTelemetryEvent(languages, confidences, stopWatch.elapsed());
                 return languages[0];
             }
             return undefined;
@@ -48,7 +51,7 @@ class LanguageDetectionSimpleWorker extends EditorSimpleWorker {
         return undefined;
     }
     getTextForDetection(uri) {
-        const editorModel = this._getModel(uri);
+        const editorModel = this._workerTextModelSyncServer.getModel(uri);
         if (!editorModel) {
             return;
         }
@@ -67,7 +70,7 @@ class LanguageDetectionSimpleWorker extends EditorSimpleWorker {
         }
         this._modelOperations = ( new ModelOperations({
             modelJsonLoaderFunc: async () => {
-                const response = await fetch(await this._host.fhr('getModelJsonUri', []));
+                const response = await fetch(await this._host.$getModelJsonUri());
                 try {
                     const modelJSON = await response.json();
                     return modelJSON;
@@ -78,7 +81,7 @@ class LanguageDetectionSimpleWorker extends EditorSimpleWorker {
                 }
             },
             weightsLoaderFunc: async () => {
-                const response = await fetch(await this._host.fhr('getWeightsUri', []));
+                const response = await fetch(await this._host.$getWeightsUri());
                 const buffer = await response.arrayBuffer();
                 return buffer;
             }

package/vscode/src/vs/workbench/services/languageDetection/browser/languageDetectionWorker.protocol.js

@@ -0,0 +1,11 @@
+class LanguageDetectionWorkerHost {
+    static { this.CHANNEL_NAME = 'languageDetectionWorkerHost'; }
+    static getChannel(workerServer) {
+        return workerServer.getChannel(LanguageDetectionWorkerHost.CHANNEL_NAME);
+    }
+    static setChannel(workerClient, obj) {
+        workerClient.setChannel(LanguageDetectionWorkerHost.CHANNEL_NAME, obj);
+    }
+}
+
+export { LanguageDetectionWorkerHost };

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

@@ -2,18 +2,15 @@ import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { LanguageDetectionStatsId } from 'vscode/vscode/vs/workbench/services/languageDetection/common/languageDetectionWorkerService';
 import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { nodeModulesPath, nodeModulesAsarPath, FileAccess, Schemas } from 'vscode/vscode/vs/base/common/network';
+import { nodeModulesPath, FileAccess, Schemas } from 'vscode/vscode/vs/base/common/network';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { isWeb } from 'vscode/vscode/vs/base/common/platform';
+import 'vscode/vscode/vs/base/common/platform';
 import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
-import { SimpleWorkerClient } from 'vscode/vscode/vs/base/common/worker/simpleWorker';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
-import { EditorWorkerClient, EditorWorkerHost } from 'vscode/vscode/vs/editor/browser/services/editorWorkerService';
-import { ILanguageConfigurationService } from 'vscode/vscode/vs/editor/common/languages/languageConfigurationRegistry';
 import { IDiagnosticsService } from 'vscode/vscode/vs/platform/diagnostics/common/diagnostics.service';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
@@ -21,13 +18,15 @@ import { StorageScope, StorageTarget } from 'vscode/vscode/vs/platform/storage/c
 import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage.service';
 import { LRUCache } from 'vscode/vscode/vs/base/common/map';
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import 'vscode/vscode/vs/base/common/amd';
+import { createWebWorker } from 'vscode/vscode/vs/base/browser/defaultWorkerFactory';
+import { WorkerTextModelSyncClient } from 'vscode/vscode/vs/editor/common/services/textModelSync/textModelSync.impl';
+import { LanguageDetectionWorkerHost } from './languageDetectionWorker.protocol.js';
 
 var LanguageDetectionService_1;
 const TOP_LANG_COUNTS = 12;
 const regexpModuleLocation = `${nodeModulesPath}/vscode-regexp-languagedetection`;
-const regexpModuleLocationAsar = `${nodeModulesAsarPath}/vscode-regexp-languagedetection`;
 const moduleLocation = `${nodeModulesPath}/@vscode/vscode-languagedetection`;
-const moduleLocationAsar = `${nodeModulesAsarPath}/@vscode/vscode-languagedetection`;
 let LanguageDetectionService = class LanguageDetectionService extends Disposable {
     static { LanguageDetectionService_1 = this; }
     static { this.enablementSettingKey = 'workbench.editor.languageDetection'; }
@@ -35,7 +34,7 @@ let LanguageDetectionService = class LanguageDetectionService extends Disposable
     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, languageConfigurationService) {
+    constructor(_environmentService, languageService, _configurationService, _diagnosticsService, _workspaceContextService, modelService, _editorService, telemetryService, storageService, _logService) {
         super();
         this._environmentService = _environmentService;
         this._configurationService = _configurationService;
@@ -54,19 +53,10 @@ let LanguageDetectionService = class LanguageDetectionService extends Disposable
             modelService,
             languageService,
             telemetryService,
-            this._environmentService.isBuilt && !isWeb
-                ? ( ( FileAccess.asBrowserUri(`${moduleLocationAsar}/dist/lib/index.js`)).toString(true))
-                : ( ( FileAccess.asBrowserUri(`${moduleLocation}/dist/lib/index.js`)).toString(true)),
-            this._environmentService.isBuilt && !isWeb
-                ? ( ( FileAccess.asBrowserUri(`${moduleLocationAsar}/model/model.json`)).toString(true))
-                : ( ( FileAccess.asBrowserUri(`${moduleLocation}/model/model.json`)).toString(true)),
-            this._environmentService.isBuilt && !isWeb
-                ? ( ( FileAccess.asBrowserUri(`${moduleLocationAsar}/model/group1-shard1of1.bin`)).toString(true))
-                : ( ( FileAccess.asBrowserUri(`${moduleLocation}/model/group1-shard1of1.bin`)).toString(true)),
-            this._environmentService.isBuilt && !isWeb
-                ? ( ( FileAccess.asBrowserUri(`${regexpModuleLocationAsar}/dist/index.js`)).toString(true))
-                : ( ( FileAccess.asBrowserUri(`${regexpModuleLocation}/dist/index.js`)).toString(true)),
-            languageConfigurationService
+            ( ( FileAccess.asBrowserUri(`${moduleLocation}/dist/lib/index.js`)).toString(true)),
+            ( ( FileAccess.asBrowserUri(`${moduleLocation}/model/model.json`)).toString(true)),
+            ( ( FileAccess.asBrowserUri(`${moduleLocation}/model/group1-shard1of1.bin`)).toString(true)),
+            ( ( FileAccess.asBrowserUri(`${regexpModuleLocation}/dist/index.js`)).toString(true))
         )));
         this.initEditorOpenedListeners(storageService);
     }
@@ -157,12 +147,12 @@ LanguageDetectionService = LanguageDetectionService_1 = ( __decorate([
     ( __param(6, IEditorService)),
     ( __param(7, ITelemetryService)),
     ( __param(8, IStorageService)),
-    ( __param(9, ILogService)),
-    ( __param(10, ILanguageConfigurationService))
+    ( __param(9, ILogService))
 ], LanguageDetectionService));
-class LanguageDetectionWorkerClient extends EditorWorkerClient {
-    constructor(modelService, _languageService, _telemetryService, _indexJsUri, _modelJsonUri, _weightsUri, _regexpModelUri, languageConfigurationService) {
-        super(modelService, true, 'languageDetectionWorkerService', languageConfigurationService);
+class LanguageDetectionWorkerClient extends Disposable {
+    constructor(_modelService, _languageService, _telemetryService, _indexJsUri, _modelJsonUri, _weightsUri, _regexpModelUri) {
+        super();
+        this._modelService = _modelService;
         this._languageService = _languageService;
         this._telemetryService = _telemetryService;
         this._indexJsUri = _indexJsUri;
@@ -171,17 +161,20 @@ class LanguageDetectionWorkerClient extends EditorWorkerClient {
         this._regexpModelUri = _regexpModelUri;
     }
     _getOrCreateLanguageDetectionWorker() {
-        if (this.workerPromise) {
-            return this.workerPromise;
+        if (!this.worker) {
+            const workerClient = this._register(createWebWorker('vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker', 'LanguageDetectionWorker'));
+            LanguageDetectionWorkerHost.setChannel(workerClient, {
+                $getIndexJsUri: async () => this.getIndexJsUri(),
+                $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(),
+            });
+            const workerTextModelSyncClient = WorkerTextModelSyncClient.create(workerClient, this._modelService);
+            this.worker = { workerClient, workerTextModelSyncClient };
         }
-        this.workerPromise = ( new Promise((resolve, reject) => {
-            resolve(this._register(( new SimpleWorkerClient(
-                this._workerFactory,
-                'vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker',
-                ( new EditorWorkerHost(this))
-            ))));
-        }));
-        return this.workerPromise;
+        return this.worker;
     }
     _guessLanguageIdByUri(uri) {
         const guess = this._languageService.guessLanguageIdByFilepathOrFirstLine(uri);
@@ -190,27 +183,6 @@ class LanguageDetectionWorkerClient extends EditorWorkerClient {
         }
         return undefined;
     }
-    async _getProxy() {
-        return (await this._getOrCreateLanguageDetectionWorker()).getProxyObject();
-    }
-    async fhr(method, args) {
-        switch (method) {
-            case 'getIndexJsUri':
-                return this.getIndexJsUri();
-            case 'getModelJsonUri':
-                return this.getModelJsonUri();
-            case 'getWeightsUri':
-                return this.getWeightsUri();
-            case 'getRegexpModelUri':
-                return this.getRegexpModelUri();
-            case 'getLanguageId':
-                return this.getLanguageId(args[0]);
-            case 'sendTelemetryEvent':
-                return this.sendTelemetryEvent(args[0], args[1], args[2]);
-            default:
-                return super.fhr(method, args);
-        }
-    }
     async getIndexJsUri() {
         return this._indexJsUri;
     }
@@ -249,8 +221,9 @@ class LanguageDetectionWorkerClient extends EditorWorkerClient {
         if (quickGuess) {
             return quickGuess;
         }
-        await this._withSyncedResources([resource]);
-        const modelId = await (await this._getProxy()).detectLanguage(( resource.toString()), langBiases, preferHistory, supportedLangs);
+        const { workerClient, workerTextModelSyncClient } = this._getOrCreateLanguageDetectionWorker();
+        await workerTextModelSyncClient.ensureSyncedResources([resource]);
+        const modelId = await workerClient.proxy.$detectLanguage(( resource.toString()), langBiases, preferHistory, supportedLangs);
         const languageId = this.getLanguageId(modelId);
         const LanguageDetectionStatsId = 'automaticlanguagedetection.perf';
         this._telemetryService.publicLog2(LanguageDetectionStatsId, {