@codingame/monaco-vscode-speech-service-override 11.1.2 → 12.0.1

package/index.d.ts

@@ -1 +1,2 @@
-export { default } from 'vscode/service-override/speech';
+import type { IEditorOverrideServices } from "vscode/vscode/vs/editor/standalone/browser/standaloneServices";
+export default function getServiceOverride(): IEditorOverrideServices;

package/index.js

@@ -1 +1,13 @@
-export { default } from './speech.js';
+
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { ISpeechService } from 'vscode/vscode/vs/workbench/contrib/speech/common/speechService.service';
+import { SpeechService } from './vscode/src/vs/workbench/contrib/speech/browser/speechService.js';
+import 'vscode/vscode/vs/platform/instantiation/common/extensions';
+
+function getServiceOverride() {
+    return {
+        [ISpeechService.toString()]: new SyncDescriptor(SpeechService, [], true)
+    };
+}
+
+export { getServiceOverride as default };

package/package.json

@@ -1,6 +1,8 @@
 {
   "name": "@codingame/monaco-vscode-speech-service-override",
-  "version": "11.1.2",
+  "version": "12.0.1",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - speech service-override",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -12,8 +14,11 @@
     "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
   },
   "type": "module",
-  "private": false,
-  "description": "VSCode public API plugged on the monaco editor - speech service-override",
+  "dependencies": {
+    "vscode": "npm:@codingame/monaco-vscode-api@12.0.1"
+  },
+  "peerDependencies": {},
+  "peerDependenciesMeta": {},
   "main": "index.js",
   "module": "index.js",
   "types": "index.d.ts",
@@ -22,10 +27,12 @@
       "default": "./index.js"
     },
     "./vscode/*": {
-      "default": "./vscode/src/*.js"
+      "default": "./vscode/src/*.js",
+      "types": "./vscode/src/*.d.ts"
+    },
+    "./*": {
+      "default": "./*.js",
+      "types": "./*.d.ts"
     }
-  },
-  "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@11.1.2"
   }
 }

package/vscode/src/vs/workbench/contrib/speech/browser/speechService.d.ts

@@ -0,0 +1,59 @@
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IContextKeyService } from "vscode/vscode/vs/platform/contextkey/common/contextkey.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IHostService } from "vscode/vscode/vs/workbench/services/host/browser/host.service";
+import { ISpeechProvider, ISpeechToTextSession, KeywordRecognitionStatus, ITextToSpeechSession } from "vscode/vscode/vs/workbench/contrib/speech/common/speechService";
+import { ISpeechService } from "vscode/vscode/vs/workbench/contrib/speech/common/speechService.service";
+import { ITelemetryService } from "vscode/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IExtensionService } from "vscode/vscode/vs/workbench/services/extensions/common/extensions.service";
+export interface ISpeechProviderDescriptor {
+    readonly name: string;
+    readonly description?: string;
+}
+export declare class SpeechService extends Disposable implements ISpeechService {
+    private readonly logService;
+    private readonly contextKeyService;
+    private readonly hostService;
+    private readonly telemetryService;
+    private readonly configurationService;
+    private readonly extensionService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidChangeHasSpeechProvider;
+    readonly onDidChangeHasSpeechProvider: Event<void>;
+    get hasSpeechProvider(): boolean;
+    private readonly providers;
+    private readonly providerDescriptors;
+    private readonly hasSpeechProviderContext;
+    constructor(logService: ILogService, contextKeyService: IContextKeyService, hostService: IHostService, telemetryService: ITelemetryService, configurationService: IConfigurationService, extensionService: IExtensionService);
+    private handleAndRegisterSpeechExtensions;
+    registerSpeechProvider(identifier: string, provider: ISpeechProvider): IDisposable;
+    private handleHasSpeechProviderChange;
+    private readonly _onDidStartSpeechToTextSession;
+    readonly onDidStartSpeechToTextSession: Event<void>;
+    private readonly _onDidEndSpeechToTextSession;
+    readonly onDidEndSpeechToTextSession: Event<void>;
+    private activeSpeechToTextSessions;
+    get hasActiveSpeechToTextSession(): boolean;
+    private readonly speechToTextInProgress;
+    createSpeechToTextSession(token: CancellationToken, context?: string): Promise<ISpeechToTextSession>;
+    private getProvider;
+    private readonly _onDidStartTextToSpeechSession;
+    readonly onDidStartTextToSpeechSession: Event<void>;
+    private readonly _onDidEndTextToSpeechSession;
+    readonly onDidEndTextToSpeechSession: Event<void>;
+    private activeTextToSpeechSessions;
+    get hasActiveTextToSpeechSession(): boolean;
+    private readonly textToSpeechInProgress;
+    createTextToSpeechSession(token: CancellationToken, context?: string): Promise<ITextToSpeechSession>;
+    private readonly _onDidStartKeywordRecognition;
+    readonly onDidStartKeywordRecognition: Event<void>;
+    private readonly _onDidEndKeywordRecognition;
+    readonly onDidEndKeywordRecognition: Event<void>;
+    private activeKeywordRecognitionSessions;
+    get hasActiveKeywordRecognition(): boolean;
+    recognizeKeyword(token: CancellationToken): Promise<KeywordRecognitionStatus>;
+    private doRecognizeKeyword;
+}

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } from 'vscode/vscode/vs/nls';
 import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
 import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
@@ -16,7 +17,7 @@ import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extension
 const speechProvidersExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'speechProviders',
     jsonSchema: {
-        description: ( localize(2845, 'Contributes a Speech Provider')),
+        description: ( localize(8911, 'Contributes a Speech Provider')),
         type: 'array',
         items: {
             additionalProperties: false,
@@ -25,11 +26,11 @@ const speechProvidersExtensionPoint = ExtensionsRegistry.registerExtensionPoint(
             required: ['name'],
             properties: {
                 name: {
-                    description: ( localize(2846, "Unique name for this Speech Provider.")),
+                    description: ( localize(8912, "Unique name for this Speech Provider.")),
                     type: 'string'
                 },
                 description: {
-                    description: ( localize(2847, "A description of this Speech Provider, shown in the UI.")),
+                    description: ( localize(8913, "A description of this Speech Provider, shown in the UI.")),
                     type: 'string'
                 }
             }
@@ -46,26 +47,26 @@ let SpeechService = class SpeechService extends Disposable {
         this.telemetryService = telemetryService;
         this.configurationService = configurationService;
         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.activeSpeechToTextSessions = 0;
         this.speechToTextInProgress = SpeechToTextInProgress.bindTo(this.contextKeyService);
-        this._onDidStartTextToSpeechSession = this._register(( (new Emitter())));
+        this._onDidStartTextToSpeechSession = this._register(( new Emitter()));
         this.onDidStartTextToSpeechSession = this._onDidStartTextToSpeechSession.event;
-        this._onDidEndTextToSpeechSession = this._register(( (new Emitter())));
+        this._onDidEndTextToSpeechSession = this._register(( new Emitter()));
         this.onDidEndTextToSpeechSession = this._onDidEndTextToSpeechSession.event;
         this.activeTextToSpeechSessions = 0;
         this.textToSpeechInProgress = TextToSpeechInProgress.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.activeKeywordRecognitionSessions = 0;
         this.handleAndRegisterSpeechExtensions();
@@ -89,8 +90,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);
@@ -118,7 +119,7 @@ let SpeechService = class SpeechService extends Disposable {
         let sessionRecognized = false;
         let sessionError = false;
         let sessionContentLength = 0;
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         const onSessionStoppedOrCanceled = () => {
             this.activeSpeechToTextSessions = Math.max(0, this.activeSpeechToTextSessions - 1);
             if (!this.hasActiveSpeechToTextSession) {
@@ -167,9 +168,9 @@ let SpeechService = class SpeechService extends Disposable {
     }
     async getProvider() {
         await this.extensionService.activateByEvent('onSpeech');
-        const provider = Array.from(( (this.providers.values()))).at(0);
+        const provider = Array.from(( this.providers.values())).at(0);
         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}`);
@@ -183,7 +184,7 @@ let SpeechService = class SpeechService extends Disposable {
         const session = provider.createTextToSpeechSession(token, typeof language === 'string' ? { language } : undefined);
         const sessionStart = Date.now();
         let sessionError = false;
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         const onSessionStoppedOrCanceled = (dispose) => {
             this.activeTextToSpeechSessions = Math.max(0, this.activeTextToSpeechSessions - 1);
             if (!this.hasActiveTextToSpeechSession) {
@@ -224,17 +225,17 @@ let SpeechService = class SpeechService extends Disposable {
     }
     get hasActiveKeywordRecognition() { return this.activeKeywordRecognitionSessions > 0; }
     async recognizeKeyword(token) {
-        const result = ( (new DeferredPromise()));
-        const disposables = ( (new DisposableStore()));
+        const result = ( new DeferredPromise());
+        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) {
@@ -275,7 +276,7 @@ let SpeechService = class SpeechService extends Disposable {
         const session = provider.createKeywordRecognitionSession(token);
         this.activeKeywordRecognitionSessions++;
         this._onDidStartKeywordRecognition.fire();
-        const disposables = ( (new DisposableStore()));
+        const disposables = ( new DisposableStore());
         const onSessionStoppedOrCanceled = () => {
             this.activeKeywordRecognitionSessions = Math.max(0, this.activeKeywordRecognitionSessions - 1);
             this._onDidEndKeywordRecognition.fire();
@@ -298,13 +299,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, 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 };

package/speech.js

@@ -1,11 +0,0 @@
-import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { ISpeechService } from 'vscode/vscode/vs/workbench/contrib/speech/common/speechService.service';
-import { SpeechService } from './vscode/src/vs/workbench/contrib/speech/browser/speechService.js';
-
-function getServiceOverride() {
-    return {
-        [( ISpeechService.toString())]: new SyncDescriptor(SpeechService, [], true)
-    };
-}
-
-export { getServiceOverride as default };