@andresaya/edge-tts 1.3.0 → 1.3.1

package/dist/cli/edge-tts.js

@@ -6,7 +6,7 @@ const VoiceListCommand_1 = require("../commands/VoiceListCommand");
 const commander_1 = require("commander");
 const program = new commander_1.Command();
 program
-    .version('1.2.7')
+    .version('1.3.0')
     .addCommand(SynthesizeCommand_1.SynthesizeCommand)
     .addCommand(VoiceListCommand_1.VoiceListCommand);
 try {

package/dist/services/EdgeTTS.d.ts

@@ -16,6 +16,8 @@ export declare class EdgeTTS {
     private audio_format;
     private ws;
     getVoices(): Promise<Voice[]>;
+    getVoicesByLanguage(locale: string): Promise<Voice[]>;
+    getVoicesByGender(gender: 'Male' | 'Female'): Promise<Voice[]>;
     private generateUUID;
     private validatePitch;
     private validateRate;
@@ -23,8 +25,15 @@ export declare class EdgeTTS {
     synthesize(text: string, voice?: string, options?: SynthesisOptions): Promise<void>;
     private getSSML;
     private buildTTSConfigMessage;
+    synthesizeStream(text: string, voice?: string, options?: SynthesisOptions): AsyncGenerator<Uint8Array, void, unknown>;
     private processAudioData;
-    toFile(outputPath: string): Promise<string>;
+    getDuration(): number;
+    getAudioInfo(): {
+        size: number;
+        format: string;
+        estimatedDuration: number;
+    };
+    toFile(outputPath: string, format?: string): Promise<string>;
     toRaw(): string;
     toBase64(): string;
     toBuffer(): Buffer;

package/dist/services/EdgeTTS.js

@@ -37,6 +37,14 @@ class EdgeTTS {
             return voice;
         });
     }
+    async getVoicesByLanguage(locale) {
+        const voices = await this.getVoices();
+        return voices.filter(voice => voice.Locale.startsWith(locale));
+    }
+    async getVoicesByGender(gender) {
+        const voices = await this.getVoices();
+        return voices.filter(voice => voice.Gender === gender);
+    }
     generateUUID() {
         return 'xxxxxxxx-xxxx-xxxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
             const r = Math.random() * 16 | 0;
@@ -130,6 +138,77 @@ class EdgeTTS {
         return `X-Timestamp:${new Date().toISOString()}Z\r\nContent-Type:application/json; charset=utf-8\r\nPath:speech.config\r\n\r\n` +
             `{"context":{"synthesis":{"audio":{"metadataoptions":{"sentenceBoundaryEnabled":false,"wordBoundaryEnabled":true},"outputFormat":"audio-24khz-48kbitrate-mono-mp3"}}}}`;
     }
+    async *synthesizeStream(text, voice = 'en-US-AnaNeural', options = {}) {
+        this.audio_stream = [];
+        const req_id = this.generateUUID();
+        this.ws = new ws_1.default(`${constants_1.Constants.WSS_URL}?trustedclienttoken=${constants_1.Constants.TRUSTED_CLIENT_TOKEN}&ConnectionId=${req_id}`);
+        const SSML_text = this.getSSML(text, voice, options);
+        const queue = [];
+        let done = false;
+        let error = null;
+        let notify = null;
+        const push = (chunk) => {
+            queue.push(chunk);
+            if (notify) {
+                notify();
+                notify = null;
+            }
+        };
+        const timeout = setTimeout(() => {
+            if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+                this.ws.close();
+            }
+        }, 30000);
+        this.ws.on('open', () => {
+            const message = this.buildTTSConfigMessage();
+            this.ws.send(message);
+            const speechMessage = `X-RequestId:${req_id}\r\nContent-Type:application/ssml+xml\r\nX-Timestamp:${new Date().toISOString()}Z\r\nPath:ssml\r\n\r\n${SSML_text}`;
+            this.ws.send(speechMessage);
+        });
+        this.ws.on('message', (data) => {
+            const buffer = ensureBuffer(data);
+            const needle = buffer_1.Buffer.from('Path:audio\r\n');
+            const audioStartIndex = buffer.indexOf(new Uint8Array(needle));
+            if (audioStartIndex !== -1) {
+                const audioChunk = buffer.subarray(audioStartIndex + needle.length);
+                const chunk = new Uint8Array(audioChunk);
+                this.audio_stream.push(chunk);
+                push(chunk);
+            }
+            if (buffer.toString().includes('Path:turn.end')) {
+                this.ws?.close();
+            }
+        });
+        this.ws.on('error', (err) => {
+            error = err;
+            done = true;
+            if (notify) {
+                notify();
+                notify = null;
+            }
+        });
+        this.ws.on('close', () => {
+            clearTimeout(timeout);
+            done = true;
+            if (notify) {
+                notify();
+                notify = null;
+            }
+        });
+        while (!done || queue.length > 0) {
+            if (queue.length === 0) {
+                await new Promise(resolve => (notify = resolve));
+                continue;
+            }
+            const chunk = queue.shift();
+            if (chunk) {
+                yield chunk;
+            }
+        }
+        if (error) {
+            throw error;
+        }
+    }
     processAudioData(data) {
         const buffer = ensureBuffer(data);
         const needle = buffer_1.Buffer.from("Path:audio\r\n");
@@ -142,9 +221,28 @@ class EdgeTTS {
             this.ws?.close();
         }
     }
-    async toFile(outputPath) {
+    getDuration() {
+        if (this.audio_stream.length === 0) {
+            throw new Error("No audio data available");
+        }
+        // Estimate duration based on the size of the audio stream
+        const bufferSize = this.toBuffer().length;
+        const estimatedDuration = bufferSize / (24000 * 3); // 24000 Hz sample rate, 3 bytes per sample (16-bit stereo)
+        return estimatedDuration;
+    }
+    getAudioInfo() {
+        const buffer = this.toBuffer();
+        return {
+            size: buffer.length,
+            format: this.audio_format,
+            estimatedDuration: this.getDuration()
+        };
+    }
+    async toFile(outputPath, format = this.audio_format) {
+        if (!format || typeof format !== 'string')
+            format = this.audio_format;
         const audioBuffer = this.toBuffer();
-        const finalPath = `${outputPath}.${this.audio_format}`;
+        const finalPath = `${outputPath}.${format}`;
         await (0, promises_1.writeFile)(finalPath, new Uint8Array(audioBuffer));
         return finalPath;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andresaya/edge-tts",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Edge TTS is a package that allows access to the online text-to-speech service used by Microsoft Edge without the need for Microsoft Edge, Windows, or an API key.",
   "main": "dist/index.js",
   "keywords": [