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

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+export { __decorate, __param };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-speech-service-override",
-  "version": "4.1.0",
+  "version": "4.1.2",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,6 +18,6 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.1.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.1.2"
   }
 }

package/speech.js

@@ -1,6 +1,6 @@
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 import { ISpeechService } from 'vscode/vscode/vs/workbench/contrib/speech/common/speechService';
-import { SpeechService } from 'vscode/vscode/vs/workbench/contrib/speech/browser/speechService';
+import { SpeechService } from './vscode/src/vs/workbench/contrib/speech/browser/speechService.js';
 
 function getServiceOverride() {
     return {

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

@@ -0,0 +1,273 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { firstOrDefault } from 'vscode/vscode/vs/base/common/arrays';
+import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
+import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
+import { Disposable, toDisposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
+import { IContextKeyService } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
+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';
+import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
+import { AccessibilitySignal, IAccessibilitySignalService } from 'vscode/vscode/vs/platform/accessibilitySignal/browser/accessibilitySignalService';
+import { ExtensionsRegistry } from 'vscode/vscode/vs/workbench/services/extensions/common/extensionsRegistry';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+
+const speechProvidersExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'speechProviders',
+    jsonSchema: {
+        description: ( localizeWithPath(
+            'vs/workbench/contrib/speech/browser/speechService',
+            'vscode.extension.contributes.speechProvider',
+            'Contributes a Speech Provider'
+        )),
+        type: 'array',
+        items: {
+            additionalProperties: false,
+            type: 'object',
+            defaultSnippets: [{ body: { name: '', description: '' } }],
+            required: ['name'],
+            properties: {
+                name: {
+                    description: ( localizeWithPath(
+                        'vs/workbench/contrib/speech/browser/speechService',
+                        'speechProviderName',
+                        "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."
+                    )),
+                    type: 'string'
+                }
+            }
+        }
+    }
+});
+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) {
+        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._onDidChangeHasSpeechProvider.event;
+        this.providers = ( new Map());
+        this.providerDescriptors = ( new Map());
+        this.hasSpeechProviderContext = HasSpeechProvider.bindTo(this.contextKeyService);
+        this._onDidStartSpeechToTextSession = this._register(( new Emitter()));
+        this.onDidStartSpeechToTextSession = this._onDidStartSpeechToTextSession.event;
+        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._onDidStartKeywordRecognition.event;
+        this._onDidEndKeywordRecognition = this._register(( new Emitter()));
+        this.onDidEndKeywordRecognition = this._onDidEndKeywordRecognition.event;
+        this._activeKeywordRecognitionSession = undefined;
+        this.handleAndRegisterSpeechExtensions();
+    }
+    handleAndRegisterSpeechExtensions() {
+        speechProvidersExtensionPoint.setHandler((extensions, delta) => {
+            const oldHasSpeechProvider = this.hasSpeechProvider;
+            for (const extension of delta.removed) {
+                for (const descriptor of extension.value) {
+                    this.providerDescriptors.delete(descriptor.name);
+                }
+            }
+            for (const extension of delta.added) {
+                for (const descriptor of extension.value) {
+                    this.providerDescriptors.set(descriptor.name, descriptor);
+                }
+            }
+            if (oldHasSpeechProvider !== this.hasSpeechProvider) {
+                this.handleHasSpeechProviderChange();
+            }
+        });
+    }
+    registerSpeechProvider(identifier, provider) {
+        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);
+        if (oldHasSpeechProvider !== this.hasSpeechProvider) {
+            this.handleHasSpeechProviderChange();
+        }
+        return toDisposable(() => {
+            const oldHasSpeechProvider = this.hasSpeechProvider;
+            this.providers.delete(identifier);
+            if (oldHasSpeechProvider !== this.hasSpeechProvider) {
+                this.handleHasSpeechProviderChange();
+            }
+        });
+    }
+    handleHasSpeechProviderChange() {
+        this.hasSpeechProviderContext.set(this.hasSpeechProvider);
+        this._onDidChangeHasSpeechProvider.fire();
+    }
+    get hasActiveSpeechToTextSession() { return !!this._activeSpeechToTextSession; }
+    async createSpeechToTextSession(token, context = 'speech') {
+        const provider = await this.getProvider();
+        const language = speechLanguageConfigToLanguage(this.configurationService.getValue(SPEECH_LANGUAGE_CONFIG));
+        const session = this._activeSpeechToTextSession = provider.createSpeechToTextSession(token, typeof language === 'string' ? { language } : undefined);
+        const sessionStart = Date.now();
+        let sessionRecognized = false;
+        let sessionContentLength = 0;
+        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,
+                    sessionContentLength,
+                    sessionLanguage: language
+                });
+            }
+            disposables.dispose();
+        };
+        disposables.add(token.onCancellationRequested(() => onSessionStoppedOrCanceled()));
+        if (token.isCancellationRequested) {
+            onSessionStoppedOrCanceled();
+        }
+        disposables.add(session.onDidChange(e => {
+            switch (e.status) {
+                case SpeechToTextStatus.Started:
+                    if (session === this._activeSpeechToTextSession) {
+                        this.speechToTextInProgress.set(true);
+                        this._onDidStartSpeechToTextSession.fire();
+                        this.accessibilitySignalService.playSignal(AccessibilitySignal.voiceRecordingStarted);
+                    }
+                    break;
+                case SpeechToTextStatus.Recognizing:
+                    sessionRecognized = true;
+                    break;
+                case SpeechToTextStatus.Recognized:
+                    if (typeof e.text === 'string') {
+                        sessionContentLength += e.text.length;
+                    }
+                    break;
+                case SpeechToTextStatus.Stopped:
+                    onSessionStoppedOrCanceled();
+                    break;
+            }
+        }));
+        return session;
+    }
+    async getProvider() {
+        await this.extensionService.activateByEvent('onSpeech');
+        const provider = firstOrDefault(Array.from(( this.providers.values())));
+        if (!provider) {
+            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}`);
+        }
+        return provider;
+    }
+    get hasActiveKeywordRecognition() { return !!this._activeKeywordRecognitionSession; }
+    async recognizeKeyword(token) {
+        const result = ( new DeferredPromise());
+        await this.extensionService.activateByEvent('onSpeech');
+        const disposables = ( new DisposableStore());
+        disposables.add(token.onCancellationRequested(() => {
+            disposables.dispose();
+            result.complete(KeywordRecognitionStatus.Canceled);
+        }));
+        const recognizeKeywordDisposables = disposables.add(( new DisposableStore()));
+        let activeRecognizeKeywordSession = undefined;
+        const recognizeKeyword = () => {
+            recognizeKeywordDisposables.clear();
+            const cts = ( new CancellationTokenSource(token));
+            recognizeKeywordDisposables.add(toDisposable(() => cts.dispose(true)));
+            const currentRecognizeKeywordSession = activeRecognizeKeywordSession = this.doRecognizeKeyword(cts.token).then(status => {
+                if (currentRecognizeKeywordSession === activeRecognizeKeywordSession) {
+                    result.complete(status);
+                }
+            }, error => {
+                if (currentRecognizeKeywordSession === activeRecognizeKeywordSession) {
+                    result.error(error);
+                }
+            });
+        };
+        disposables.add(this.hostService.onDidChangeFocus(focused => {
+            if (!focused && activeRecognizeKeywordSession) {
+                recognizeKeywordDisposables.clear();
+                activeRecognizeKeywordSession = undefined;
+            }
+            else if (!activeRecognizeKeywordSession) {
+                recognizeKeyword();
+            }
+        }));
+        if (this.hostService.hasFocus) {
+            recognizeKeyword();
+        }
+        let status;
+        try {
+            status = await result.p;
+        }
+        finally {
+            disposables.dispose();
+        }
+        this.telemetryService.publicLog2('keywordRecognition', {
+            keywordRecognized: status === KeywordRecognitionStatus.Recognized
+        });
+        return status;
+    }
+    async doRecognizeKeyword(token) {
+        const provider = await this.getProvider();
+        const session = this._activeKeywordRecognitionSession = provider.createKeywordRecognitionSession(token);
+        this._onDidStartKeywordRecognition.fire();
+        const disposables = ( new DisposableStore());
+        const onSessionStoppedOrCanceled = () => {
+            if (session === this._activeKeywordRecognitionSession) {
+                this._activeKeywordRecognitionSession = undefined;
+                this._onDidEndKeywordRecognition.fire();
+            }
+            disposables.dispose();
+        };
+        disposables.add(token.onCancellationRequested(() => onSessionStoppedOrCanceled()));
+        if (token.isCancellationRequested) {
+            onSessionStoppedOrCanceled();
+        }
+        disposables.add(session.onDidChange(e => {
+            if (e.status === KeywordRecognitionStatus.Stopped) {
+                onSessionStoppedOrCanceled();
+            }
+        }));
+        try {
+            return (await Event.toPromise(session.onDidChange)).status;
+        }
+        finally {
+            onSessionStoppedOrCanceled();
+        }
+    }
+};
+SpeechService = ( __decorate([
+    ( __param(0, ILogService)),
+    ( __param(1, IContextKeyService)),
+    ( __param(2, IHostService)),
+    ( __param(3, ITelemetryService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IAccessibilitySignalService)),
+    ( __param(6, IExtensionService))
+], SpeechService));
+
+export { SpeechService };