@andresaya/edge-tts 1.8.1 → 1.9.0

package/dist/core/session.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abortReason = abortReason;
+exports.runSession = runSession;
+const errors_1 = require("./errors");
+const protocol_1 = require("./protocol");
+const CONNECTING = 0;
+const OPEN = 1;
+function abortReason(signal) {
+    if (signal.reason !== undefined)
+        return signal.reason;
+    const error = new Error('This operation was aborted');
+    error.name = 'AbortError';
+    return error;
+}
+function toBytes(data) {
+    if (data instanceof ArrayBuffer)
+        return new Uint8Array(data);
+    if (ArrayBuffer.isView(data))
+        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    return new Uint8Array(0);
+}
+function runSession(open, options) {
+    return new Promise((resolve, reject) => {
+        if (options.signal?.aborted) {
+            reject(abortReason(options.signal));
+            return;
+        }
+        const socket = open();
+        socket.binaryType = 'arraybuffer';
+        let settled = false;
+        let opened = false;
+        let timer;
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            options.signal?.removeEventListener('abort', onAbort);
+            if (error === undefined) {
+                resolve();
+                return;
+            }
+            if (socket.readyState === CONNECTING || socket.readyState === OPEN)
+                socket.close();
+            reject(error);
+        };
+        const arm = () => {
+            clearTimeout(timer);
+            timer = setTimeout(() => {
+                finish(new errors_1.EdgeTTSError('WebSocket inactivity timeout - no response from server', 'TIMEOUT'));
+            }, options.timeout);
+        };
+        const onAbort = () => finish(abortReason(options.signal));
+        options.signal?.addEventListener('abort', onAbort, { once: true });
+        arm();
+        socket.onopen = () => {
+            if (settled)
+                return;
+            opened = true;
+            arm();
+            socket.send(options.configMessage);
+            socket.send(options.ssmlMessage);
+        };
+        socket.onmessage = (event) => {
+            if (settled)
+                return;
+            arm();
+            if (typeof event.data === 'string') {
+                const frame = (0, protocol_1.parseTextFrame)(event.data);
+                if (frame.path === 'audio.metadata') {
+                    for (const boundary of (0, protocol_1.parseMetadata)(frame.body))
+                        options.onBoundary(boundary);
+                }
+                else if (frame.path === 'turn.end') {
+                    socket.close();
+                }
+                return;
+            }
+            const frame = (0, protocol_1.parseBinaryFrame)(toBytes(event.data));
+            if (frame.path === 'audio')
+                options.onAudio(frame.body);
+        };
+        socket.onerror = (event) => finish(options.toError(event, opened));
+        socket.onclose = () => finish();
+    });
+}

package/dist/core/subtitles.d.ts

@@ -0,0 +1,7 @@
+export interface Cue {
+    offset: number;
+    duration: number;
+    text: string;
+}
+export declare function toSRT(cues: Cue[]): string;
+export declare function toVTT(cues: Cue[]): string;

package/dist/core/subtitles.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSRT = toSRT;
+exports.toVTT = toVTT;
+function timestamp(ticks, separator) {
+    const total = Math.max(0, Math.round(ticks / 10_000));
+    const ms = total % 1000;
+    const s = Math.floor(total / 1000) % 60;
+    const m = Math.floor(total / 60_000) % 60;
+    const h = Math.floor(total / 3_600_000);
+    const pad = (n, width = 2) => String(n).padStart(width, '0');
+    return `${pad(h)}:${pad(m)}:${pad(s)}${separator}${pad(ms, 3)}`;
+}
+function toSRT(cues) {
+    return cues
+        .map((cue, i) => `${i + 1}\n${timestamp(cue.offset, ',')} --> ${timestamp(cue.offset + cue.duration, ',')}\n${cue.text}\n`)
+        .join('\n');
+}
+function toVTT(cues) {
+    const body = cues
+        .map(cue => `${timestamp(cue.offset, '.')} --> ${timestamp(cue.offset + cue.duration, '.')}\n${cue.text}\n`)
+        .join('\n');
+    return `WEBVTT\n\n${body}`;
+}

package/dist/core/types.d.ts

@@ -0,0 +1,53 @@
+export interface Voice {
+    Name: string;
+    ShortName: string;
+    Gender: string;
+    Locale: string;
+    FriendlyName: string;
+    LocalName: string;
+    DisplayName?: string;
+    LocaleName?: string;
+    VoiceType?: string;
+    SecondaryLocaleList?: string[];
+    VoiceTag?: {
+        TailoredScenarios: string[];
+        VoicePersonalities: string[];
+    };
+}
+export type OutputFormat = 'audio-24khz-48kbitrate-mono-mp3' | 'audio-24khz-96kbitrate-mono-mp3' | 'webm-24khz-16bit-mono-opus';
+export interface SynthesisOptions {
+    pitch?: string | number;
+    rate?: string | number;
+    volume?: string | number;
+    outputFormat?: OutputFormat | (string & {});
+    signal?: AbortSignal;
+    timeout?: number;
+}
+export interface WordBoundary {
+    type: "WordBoundary";
+    offset: number;
+    duration: number;
+    text: string;
+}
+export interface SentenceBoundary {
+    type: "SentenceBoundary";
+    offset: number;
+    duration: number;
+    text: string;
+}
+export interface EdgeTTSOptions {
+    wssUrl?: string;
+    voicesUrl?: string;
+    secMsGecVersion?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    voicesCacheTtl?: number;
+}
+export interface SynthesisResult {
+    audio: Uint8Array;
+    format: string;
+    outputFormat: string;
+    wordBoundaries: WordBoundary[];
+    sentenceBoundaries: SentenceBoundary[];
+    duration: number;
+}

package/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -1,2 +1,5 @@
 export { EdgeTTS, type Voice, type SynthesisOptions, type WordBoundary } from './services/EdgeTTS';
 export { Constants } from './config/constants';
+export { EdgeTTSError, type EdgeTTSErrorCode } from './core/errors';
+export { toSRT, toVTT } from './core/subtitles';
+export type { EdgeTTSOptions, OutputFormat, SentenceBoundary, SynthesisResult } from './core/types';

package/dist/index.js

@@ -1,7 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Constants = exports.EdgeTTS = void 0;
+exports.toVTT = exports.toSRT = exports.EdgeTTSError = exports.Constants = exports.EdgeTTS = void 0;
 var EdgeTTS_1 = require("./services/EdgeTTS");
 Object.defineProperty(exports, "EdgeTTS", { enumerable: true, get: function () { return EdgeTTS_1.EdgeTTS; } });
 var constants_1 = require("./config/constants");
 Object.defineProperty(exports, "Constants", { enumerable: true, get: function () { return constants_1.Constants; } });
+var errors_1 = require("./core/errors");
+Object.defineProperty(exports, "EdgeTTSError", { enumerable: true, get: function () { return errors_1.EdgeTTSError; } });
+var subtitles_1 = require("./core/subtitles");
+Object.defineProperty(exports, "toSRT", { enumerable: true, get: function () { return subtitles_1.toSRT; } });
+Object.defineProperty(exports, "toVTT", { enumerable: true, get: function () { return subtitles_1.toVTT; } });

package/dist/services/EdgeTTS.d.ts

@@ -1,50 +1,28 @@
 import { Buffer } from 'buffer';
-export interface Voice {
-    Name: string;
-    ShortName: string;
-    Gender: string;
-    Locale: string;
-    FriendlyName: string;
-    LocalName: string;
-}
-export interface SynthesisOptions {
-    pitch?: string | number;
-    rate?: string | number;
-    volume?: string | number;
-    outputFormat?: string;
-}
-export interface WordBoundary {
-    type: "WordBoundary";
-    offset: number;
-    duration: number;
-    text: string;
-}
-export declare class EdgeTTS {
-    private audio_stream;
-    private audio_format;
-    private output_format;
-    private word_boundaries;
+import { EdgeTTSCore } from '../core/base';
+import type { SocketLike } from '../core/session';
+import type { EdgeTTSOptions, SynthesisOptions, SynthesisResult } from '../core/types';
+export type { Voice, SynthesisOptions, WordBoundary } from '../core/types';
+export declare class EdgeTTS extends EdgeTTSCore {
+    protected readonly defaultVoice = "en-US-AnaNeural";
     private ws;
-    normalizeVoices(data: any[]): Promise<Voice[]>;
-    getVoices(): Promise<Voice[]>;
-    getVoicesByLanguage(locale: string): Promise<Voice[]>;
-    getVoicesByGender(gender: 'Male' | 'Female'): Promise<Voice[]>;
-    private generateUUID;
+    constructor(options?: EdgeTTSOptions);
+    generateSecMsGec: (trustedClientToken: string) => Promise<string>;
+    generate(text: string, voice?: string, options?: SynthesisOptions): Promise<SynthesisResult & {
+        audio: Buffer;
+    }>;
+    protected openSocket(url: string): SocketLike;
+    protected requestVoices(url: string): Promise<any[]>;
+    protected buildSSML(text: string, voice: string, options: SynthesisOptions): string;
+    protected timestamp(): string;
+    protected socketError(event: unknown, opened: boolean): Error;
+    protected recoverHandshake(): Promise<boolean>;
+    private serverTime;
     private validatePitch;
     private validateRate;
     private validateVolume;
-    synthesize(text: string, voice?: string, options?: SynthesisOptions): Promise<void>;
-    private escapeXML;
-    private getSSML;
     private nowRFC1123;
-    private parseRFC1123;
-    private buildTTSConfigMessage;
-    synthesizeStream(text: string, voice?: string, options?: SynthesisOptions): AsyncGenerator<Uint8Array, void, unknown>;
-    private processAudioData;
-    private parseMetadata;
-    generateSecMsGec: (trustedClientToken: string) => Promise<string>;
     getDuration(): number;
-    private getFileExtension;
     getAudioInfo(): {
         size: number;
         format: string;
@@ -55,5 +33,4 @@ export declare class EdgeTTS {
     toBase64(): string;
     toBuffer(): Buffer;
     saveMetadata(outputPath: string): Promise<void>;
-    getWordBoundaries(): WordBoundary[];
 }