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

package/package.json

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

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/src/vs/workbench/contrib/speech/browser/speechService.js';
+import { SpeechService } from 'vscode/vscode/vs/workbench/contrib/speech/browser/speechService';
 
 function getServiceOverride() {
     return {

package/external/tslib/tslib.es6.js

@@ -1,11 +0,0 @@
-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/vscode/src/vs/workbench/contrib/speech/browser/speechService.js

@@ -1,197 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-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, 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';
-
-let SpeechService = class SpeechService extends Disposable {
-    get hasSpeechProvider() { return this.providers.size > 0; }
-    constructor(logService, contextKeyService, hostService, telemetryService, configurationService) {
-        super();
-        this.logService = logService;
-        this.contextKeyService = contextKeyService;
-        this.hostService = hostService;
-        this.telemetryService = telemetryService;
-        this.configurationService = configurationService;
-        this._onDidRegisterSpeechProvider = this._register(( new Emitter()));
-        this.onDidRegisterSpeechProvider = this._onDidRegisterSpeechProvider.event;
-        this._onDidUnregisterSpeechProvider = this._register(( new Emitter()));
-        this.onDidUnregisterSpeechProvider = this._onDidUnregisterSpeechProvider.event;
-        this.providers = ( 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;
-    }
-    registerSpeechProvider(identifier, provider) {
-        if (( this.providers.has(identifier))) {
-            throw new Error(`Speech provider with identifier ${identifier} is already registered.`);
-        }
-        this.providers.set(identifier, provider);
-        this.hasSpeechProviderContext.set(true);
-        this._onDidRegisterSpeechProvider.fire(provider);
-        return toDisposable(() => {
-            this.providers.delete(identifier);
-            this._onDidUnregisterSpeechProvider.fire(provider);
-            if (this.providers.size === 0) {
-                this.hasSpeechProviderContext.set(false);
-            }
-        });
-    }
-    get hasActiveSpeechToTextSession() { return !!this._activeSpeechToTextSession; }
-    createSpeechToTextSession(token, context = 'speech') {
-        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}`);
-        }
-        const language = this.configurationService.getValue('accessibility.voice.speechLanguage');
-        const session = this._activeSpeechToTextSession = provider.createSpeechToTextSession(token, typeof language === 'string' ? { language } : undefined);
-        const sessionStart = Date.now();
-        let sessionRecognized = false;
-        const disposables = ( new DisposableStore());
-        const onSessionStoppedOrCanceled = () => {
-            if (session === this._activeSpeechToTextSession) {
-                this._activeSpeechToTextSession = undefined;
-                this.speechToTextInProgress.reset();
-                this._onDidEndSpeechToTextSession.fire();
-                this.telemetryService.publicLog2('speechToTextSession', {
-                    context,
-                    duration: Date.now() - sessionStart,
-                    recognized: sessionRecognized
-                });
-            }
-            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();
-                    }
-                    break;
-                case SpeechToTextStatus.Recognizing:
-                case SpeechToTextStatus.Recognized:
-                    sessionRecognized = true;
-                    break;
-                case SpeechToTextStatus.Stopped:
-                    onSessionStoppedOrCanceled();
-                    break;
-            }
-        }));
-        return session;
-    }
-    get hasActiveKeywordRecognition() { return !!this._activeKeywordRecognitionSession; }
-    async recognizeKeyword(token) {
-        const result = ( new DeferredPromise());
-        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', {
-            recognized: status === KeywordRecognitionStatus.Recognized
-        });
-        return status;
-    }
-    async doRecognizeKeyword(token) {
-        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}`);
-        }
-        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))
-], SpeechService));
-
-export { SpeechService };