@codingame/monaco-vscode-speech-service-override 4.5.1 → 5.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-speech-service-override",
-  "version": "4.5.1",
+  "version": "5.0.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -26,6 +26,6 @@
     }
   },
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.5.1"
+    "vscode": "npm:@codingame/monaco-vscode-api@5.0.0"
   }
 }

package/vscode/src/vs/workbench/contrib/speech/browser/speechService.js

@@ -11,19 +11,14 @@ import { DeferredPromise } from 'vscode/vscode/vs/base/common/async';
 import { HasSpeechProvider, SpeechToTextInProgress, speechLanguageConfigToLanguage, SPEECH_LANGUAGE_CONFIG, SpeechToTextStatus, KeywordRecognitionStatus } from 'vscode/vscode/vs/workbench/contrib/speech/common/speechService';
 import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry.service';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
-import { AccessibilitySignal } from 'vscode/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
-import { IAccessibilitySignalService } from 'vscode/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService.service';
 import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
 import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions.service';
 
+const _moduleId = "vs/workbench/contrib/speech/browser/speechService";
 const speechProvidersExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'speechProviders',
     jsonSchema: {
-        description: ( localizeWithPath(
-            'vs/workbench/contrib/speech/browser/speechService',
-            'vscode.extension.contributes.speechProvider',
-            'Contributes a Speech Provider'
-        )),
+        description: ( localizeWithPath(_moduleId, 0, 'Contributes a Speech Provider')),
         type: 'array',
         items: {
             additionalProperties: false,
@@ -32,19 +27,11 @@ const speechProvidersExtensionPoint = ExtensionsRegistry.registerExtensionPoint(
             required: ['name'],
             properties: {
                 name: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/speech/browser/speechService',
-                        'speechProviderName',
-                        "Unique name for this Speech Provider."
-                    )),
+                    description: ( localizeWithPath(_moduleId, 1, "Unique name for this Speech Provider.")),
                     type: 'string'
                 },
                 description: {
-                    description: ( localizeWithPath(
-                        'vs/workbench/contrib/speech/browser/speechService',
-                        'speechProviderDescription',
-                        "A description of this Speech Provider, shown in the UI."
-                    )),
+                    description: ( localizeWithPath(_moduleId, 2, "A description of this Speech Provider, shown in the UI.")),
                     type: 'string'
                 }
             }
@@ -53,29 +40,28 @@ const speechProvidersExtensionPoint = ExtensionsRegistry.registerExtensionPoint(
 });
 let SpeechService = class SpeechService extends Disposable {
     get hasSpeechProvider() { return this.providerDescriptors.size > 0 || this.providers.size > 0; }
-    constructor(logService, contextKeyService, hostService, telemetryService, configurationService, accessibilitySignalService, extensionService) {
+    constructor(logService, contextKeyService, hostService, telemetryService, configurationService, extensionService) {
         super();
         this.logService = logService;
         this.contextKeyService = contextKeyService;
         this.hostService = hostService;
         this.telemetryService = telemetryService;
         this.configurationService = configurationService;
-        this.accessibilitySignalService = accessibilitySignalService;
         this.extensionService = extensionService;
-        this._onDidChangeHasSpeechProvider = this._register(( new Emitter()));
+        this._onDidChangeHasSpeechProvider = this._register(( (new Emitter())));
         this.onDidChangeHasSpeechProvider = this._onDidChangeHasSpeechProvider.event;
-        this.providers = ( new Map());
-        this.providerDescriptors = ( new Map());
+        this.providers = ( (new Map()));
+        this.providerDescriptors = ( (new Map()));
         this.hasSpeechProviderContext = HasSpeechProvider.bindTo(this.contextKeyService);
-        this._onDidStartSpeechToTextSession = this._register(( new Emitter()));
+        this._onDidStartSpeechToTextSession = this._register(( (new Emitter())));
         this.onDidStartSpeechToTextSession = this._onDidStartSpeechToTextSession.event;
-        this._onDidEndSpeechToTextSession = this._register(( new Emitter()));
+        this._onDidEndSpeechToTextSession = this._register(( (new Emitter())));
         this.onDidEndSpeechToTextSession = this._onDidEndSpeechToTextSession.event;
         this._activeSpeechToTextSession = undefined;
         this.speechToTextInProgress = SpeechToTextInProgress.bindTo(this.contextKeyService);
-        this._onDidStartKeywordRecognition = this._register(( new Emitter()));
+        this._onDidStartKeywordRecognition = this._register(( (new Emitter())));
         this.onDidStartKeywordRecognition = this._onDidStartKeywordRecognition.event;
-        this._onDidEndKeywordRecognition = this._register(( new Emitter()));
+        this._onDidEndKeywordRecognition = this._register(( (new Emitter())));
         this.onDidEndKeywordRecognition = this._onDidEndKeywordRecognition.event;
         this._activeKeywordRecognitionSession = undefined;
         this.handleAndRegisterSpeechExtensions();
@@ -99,8 +85,8 @@ let SpeechService = class SpeechService extends Disposable {
         });
     }
     registerSpeechProvider(identifier, provider) {
-        if (( this.providers.has(identifier))) {
-            throw new Error(`Speech provider with identifier ${identifier} is already registered.`);
+        if (( (this.providers.has(identifier)))) {
+            throw ( (new Error(`Speech provider with identifier ${identifier} is already registered.`)));
         }
         const oldHasSpeechProvider = this.hasSpeechProvider;
         this.providers.set(identifier, provider);
@@ -126,18 +112,19 @@ let SpeechService = class SpeechService extends Disposable {
         const session = this._activeSpeechToTextSession = provider.createSpeechToTextSession(token, typeof language === 'string' ? { language } : undefined);
         const sessionStart = Date.now();
         let sessionRecognized = false;
+        let sessionError = false;
         let sessionContentLength = 0;
-        const disposables = ( new DisposableStore());
+        const disposables = ( (new DisposableStore()));
         const onSessionStoppedOrCanceled = () => {
             if (session === this._activeSpeechToTextSession) {
                 this._activeSpeechToTextSession = undefined;
                 this.speechToTextInProgress.reset();
-                this.accessibilitySignalService.playSignal(AccessibilitySignal.voiceRecordingStopped, { allowManyInParallel: true });
                 this._onDidEndSpeechToTextSession.fire();
                 this.telemetryService.publicLog2('speechToTextSession', {
                     context,
                     sessionDuration: Date.now() - sessionStart,
                     sessionRecognized,
+                    sessionError,
                     sessionContentLength,
                     sessionLanguage: language
                 });
@@ -154,7 +141,6 @@ let SpeechService = class SpeechService extends Disposable {
                     if (session === this._activeSpeechToTextSession) {
                         this.speechToTextInProgress.set(true);
                         this._onDidStartSpeechToTextSession.fire();
-                        this.accessibilitySignalService.playSignal(AccessibilitySignal.voiceRecordingStarted);
                     }
                     break;
                 case SpeechToTextStatus.Recognizing:
@@ -168,15 +154,19 @@ let SpeechService = class SpeechService extends Disposable {
                 case SpeechToTextStatus.Stopped:
                     onSessionStoppedOrCanceled();
                     break;
+                case SpeechToTextStatus.Error:
+                    this.logService.error(`Speech provider error in speech to text session: ${e.text}`);
+                    sessionError = true;
+                    break;
             }
         }));
         return session;
     }
     async getProvider() {
         await this.extensionService.activateByEvent('onSpeech');
-        const provider = firstOrDefault(Array.from(( this.providers.values())));
+        const provider = firstOrDefault(Array.from(( (this.providers.values()))));
         if (!provider) {
-            throw new Error(`No Speech provider is registered.`);
+            throw ( (new Error(`No Speech provider is registered.`)));
         }
         else if (this.providers.size > 1) {
             this.logService.warn(`Multiple speech providers registered. Picking first one: ${provider.metadata.displayName}`);
@@ -185,18 +175,18 @@ let SpeechService = class SpeechService extends Disposable {
     }
     get hasActiveKeywordRecognition() { return !!this._activeKeywordRecognitionSession; }
     async recognizeKeyword(token) {
-        const result = ( new DeferredPromise());
+        const result = ( (new DeferredPromise()));
         await this.extensionService.activateByEvent('onSpeech');
-        const disposables = ( new DisposableStore());
+        const disposables = ( (new DisposableStore()));
         disposables.add(token.onCancellationRequested(() => {
             disposables.dispose();
             result.complete(KeywordRecognitionStatus.Canceled);
         }));
-        const recognizeKeywordDisposables = disposables.add(( new DisposableStore()));
+        const recognizeKeywordDisposables = disposables.add(( (new DisposableStore())));
         let activeRecognizeKeywordSession = undefined;
         const recognizeKeyword = () => {
             recognizeKeywordDisposables.clear();
-            const cts = ( new CancellationTokenSource(token));
+            const cts = ( (new CancellationTokenSource(token)));
             recognizeKeywordDisposables.add(toDisposable(() => cts.dispose(true)));
             const currentRecognizeKeywordSession = activeRecognizeKeywordSession = this.doRecognizeKeyword(cts.token).then(status => {
                 if (currentRecognizeKeywordSession === activeRecognizeKeywordSession) {
@@ -236,7 +226,7 @@ let SpeechService = class SpeechService extends Disposable {
         const provider = await this.getProvider();
         const session = this._activeKeywordRecognitionSession = provider.createKeywordRecognitionSession(token);
         this._onDidStartKeywordRecognition.fire();
-        const disposables = ( new DisposableStore());
+        const disposables = ( (new DisposableStore()));
         const onSessionStoppedOrCanceled = () => {
             if (session === this._activeKeywordRecognitionSession) {
                 this._activeKeywordRecognitionSession = undefined;
@@ -261,14 +251,13 @@ let SpeechService = class SpeechService extends Disposable {
         }
     }
 };
-SpeechService = ( __decorate([
-    ( __param(0, ILogService)),
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IHostService)),
-    ( __param(3, ITelemetryService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IAccessibilitySignalService)),
-    ( __param(6, IExtensionService))
-], SpeechService));
+SpeechService = ( (__decorate([
+    ( (__param(0, ILogService))),
+    ( (__param(1, IContextKeyService))),
+    ( (__param(2, IHostService))),
+    ( (__param(3, ITelemetryService))),
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, IExtensionService)))
+], SpeechService)));
 
 export { SpeechService };