@fonoster/apiserver 0.5.5 → 0.6.1

package/dist/voice/stt/Google.js

@@ -0,0 +1,99 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENGINE_NAME = exports.Google = void 0;
+const common_1 = require("@fonoster/common");
+const speech_1 = require("@google-cloud/speech");
+const z = __importStar(require("zod"));
+const AbstractSpeechToText_1 = require("./AbstractSpeechToText");
+const ENGINE_NAME = "stt.google";
+exports.ENGINE_NAME = ENGINE_NAME;
+const AUDIO_ENCODING = "LINEAR16";
+const SAMPLE_RATE_HERTZ = 16000;
+class Google extends AbstractSpeechToText_1.AbstractSpeechToText {
+    constructor(config) {
+        super(config);
+        this.engineName = ENGINE_NAME;
+        this.AUDIO_ENCODING = AUDIO_ENCODING;
+        this.SAMPLE_RATE_HERTZ = SAMPLE_RATE_HERTZ;
+        this.client = new speech_1.SpeechClient(config);
+        this.config = Object.assign(Object.assign({}, config), { config: {
+                encoding: AUDIO_ENCODING,
+                sampleRateHertz: SAMPLE_RATE_HERTZ,
+                interimResults: false,
+                languageCode: config.languageCode
+            } });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    streamTranscribe(_) {
+        // Not implemented
+        return null;
+    }
+    transcribe(stream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const recognizeStream = this.client
+                    .streamingRecognize(this.config)
+                    .on("error", (e) => reject(e))
+                    .on("data", (data) => {
+                    var _a;
+                    if ((_a = data.results[0]) === null || _a === void 0 ? void 0 : _a.alternatives[0]) {
+                        const result = {
+                            speech: data.results[0].alternatives[0].transcript,
+                            isFinal: true
+                        };
+                        resolve(result);
+                    }
+                    else {
+                        resolve({ speech: "", isFinal: true });
+                    }
+                    recognizeStream.destroy();
+                });
+                stream.pipe(recognizeStream);
+            });
+        });
+    }
+    static getConfigValidationSchema() {
+        return z.object({
+            languageCode: z.nativeEnum(common_1.VoiceLanguage)
+        });
+    }
+    static getCredentialsValidationSchema() {
+        return z.object({
+            client_email: z.string(),
+            private_key: z.string()
+        });
+    }
+}
+exports.Google = Google;

package/dist/voice/stt/SpeechToTextFactory.d.ts

@@ -0,0 +1,9 @@
+import { AbstractSpeechToText } from "./AbstractSpeechToText";
+import { SttConfig } from "./types";
+type EngineConstructor<T extends SttConfig = SttConfig> = new (options: T) => AbstractSpeechToText<string>;
+declare class SpeechToTextFactory {
+    private static engines;
+    static registerEngine<T extends SttConfig>(name: string, ctor: EngineConstructor<T>): void;
+    static getEngine<T extends SttConfig>(engineName: string, config: T): AbstractSpeechToText<string>;
+}
+export { SpeechToTextFactory };

package/dist/voice/stt/SpeechToTextFactory.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpeechToTextFactory = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const logger_1 = require("@fonoster/logger");
+const Google_1 = require("./Google");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+class SpeechToTextFactory {
+    static registerEngine(name, ctor) {
+        logger.info("registering stt engine", { name });
+        this.engines.set(name, ctor);
+    }
+    static getEngine(engineName, config) {
+        const EngineConstructor = this.engines.get(engineName);
+        if (!EngineConstructor) {
+            throw new Error(`Engine ${engineName} not found`);
+        }
+        return new EngineConstructor(config);
+    }
+}
+exports.SpeechToTextFactory = SpeechToTextFactory;
+SpeechToTextFactory.engines = new Map();
+// Register engines
+SpeechToTextFactory.registerEngine(Google_1.ENGINE_NAME, Google_1.Google);

package/dist/voice/stt/types.d.ts

@@ -0,0 +1,25 @@
+import { VoiceLanguage } from "@fonoster/common/src/tts/types";
+type SttConfig = {
+    languageCode: VoiceLanguage;
+};
+type SpeechResult = {
+    speech: string;
+    isFinal: boolean;
+};
+type StreamSpeechResult = {
+    on(events: string, callback: (result: SpeechResult) => void): void;
+    close: () => void;
+};
+type GoogleSttConfig = SttConfig & {
+    config: {
+        encoding: "LINEAR16";
+        sampleRateHertz: 16000;
+        interimResults: boolean;
+        languageCode: VoiceLanguage;
+    };
+    credentials: {
+        client_email: string;
+        private_key: string;
+    };
+};
+export { SttConfig, SpeechResult, StreamSpeechResult, GoogleSttConfig };

package/dist/voice/stt/types.js

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

package/dist/voice/transcribeOnConnection.d.ts

@@ -0,0 +1,4 @@
+import { Stream } from "stream";
+import { AudioStream } from "@fonoster/streams";
+declare function transcribeOnConnection(stream: Stream): (_: any, res: AudioStream) => Promise<void>;
+export { transcribeOnConnection };

package/dist/voice/transcribeOnConnection.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transcribeOnConnection = transcribeOnConnection;
+const logger_1 = require("@fonoster/logger");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+function transcribeOnConnection(stream) {
+    return (_, res) => __awaiter(this, void 0, void 0, function* () {
+        logger.verbose("starting instance of audio stream for transcription");
+        res
+            .onData((data) => {
+            stream.emit("data", data);
+        })
+            .onError((err) => {
+            logger.error("stream error:", err);
+        });
+    });
+}

package/dist/voice/tts/AbstractTextToSpeech.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod";
+import { SynthOptions, TtsConfig } from "./types";
+declare abstract class AbstractTextToSpeech<E, T extends TtsConfig = TtsConfig, S extends SynthOptions = SynthOptions> {
+    abstract readonly engineName: E;
+    protected abstract OUTPUT_FORMAT: "wav" | "sln16";
+    protected abstract CACHING_FIELDS: string[];
+    config: T;
+    constructor(config: T);
+    protected createFilename(text: string, options: SynthOptions): string;
+    protected fileExists(filename: string): boolean;
+    protected getFilenameWithoutExtension(filename: string): string;
+    protected getFullPathToFile(filename: string): string;
+    abstract synthesize(text: string, options: S): Promise<string>;
+    static getConfigValidationSchema(): z.Schema;
+    static getCredentialsValidationSchema(): z.Schema;
+    getName(): E;
+}
+export { AbstractTextToSpeech };

package/dist/voice/tts/AbstractTextToSpeech.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractTextToSpeech = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const fs = __importStar(require("fs"));
+const logger_1 = require("@fonoster/logger");
+const computeFilename_1 = require("./computeFilename");
+const MethodNotImplementedError_1 = require("../MethodNotImplementedError");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+class AbstractTextToSpeech {
+    constructor(config) {
+        logger.silly("tts pathToFiles", { engine: config.pathToFiles });
+        this.config = config;
+    }
+    createFilename(text, options) {
+        return (0, computeFilename_1.computeFilename)({
+            text,
+            options,
+            cachingFields: this.CACHING_FIELDS,
+            format: this.OUTPUT_FORMAT
+        });
+    }
+    fileExists(filename) {
+        return fs.existsSync(filename);
+    }
+    getFilenameWithoutExtension(filename) {
+        return filename.replace(`.${this.OUTPUT_FORMAT}`, "");
+    }
+    getFullPathToFile(filename) {
+        return `${this.config.pathToFiles}/${filename}`;
+    }
+    static getConfigValidationSchema() {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+    static getCredentialsValidationSchema() {
+        throw new MethodNotImplementedError_1.MethodNotImplementedError();
+    }
+    getName() {
+        return this.engineName;
+    }
+}
+exports.AbstractTextToSpeech = AbstractTextToSpeech;

package/dist/voice/tts/Azure.d.ts

@@ -0,0 +1,30 @@
+import * as sdk from "microsoft-cognitiveservices-speech-sdk";
+import * as z from "zod";
+import { AbstractTextToSpeech } from "./AbstractTextToSpeech";
+import { SynthOptions, TtsConfig } from "./types";
+declare const ENGINE_NAME = "tts.azure";
+type AzureTTSConfig = TtsConfig & {
+    [key: string]: Record<string, string>;
+    credentials: {
+        subscriptionKey: string;
+        serviceRegion: string;
+    };
+};
+declare class Azure extends AbstractTextToSpeech<typeof ENGINE_NAME> {
+    config: AzureTTSConfig;
+    pathToFiles: string;
+    readonly engineName = "tts.azure";
+    protected readonly OUTPUT_FORMAT = "sln16";
+    protected readonly CACHING_FIELDS: string[];
+    constructor(config: AzureTTSConfig);
+    synthesize(text: string, options: SynthOptions): Promise<string>;
+    doSynthesize(params: {
+        text: string;
+        filename: string;
+        speechConfig: sdk.SpeechConfig;
+        isSSML?: boolean;
+    }): Promise<unknown>;
+    getConfigValidationSchema(): z.Schema;
+    getCredentialsValidationSchema(): z.Schema;
+}
+export { Azure, ENGINE_NAME };

package/dist/voice/tts/Azure.js

@@ -0,0 +1,128 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENGINE_NAME = exports.Azure = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const common_1 = require("@fonoster/common");
+const logger_1 = require("@fonoster/logger");
+const sdk = __importStar(require("microsoft-cognitiveservices-speech-sdk"));
+const z = __importStar(require("zod"));
+const AbstractTextToSpeech_1 = require("./AbstractTextToSpeech");
+const isSsml_1 = require("./isSsml");
+const ENGINE_NAME = "tts.azure";
+exports.ENGINE_NAME = ENGINE_NAME;
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+class Azure extends AbstractTextToSpeech_1.AbstractTextToSpeech {
+    constructor(config) {
+        super(config);
+        this.engineName = ENGINE_NAME;
+        this.OUTPUT_FORMAT = "sln16";
+        this.CACHING_FIELDS = ["voice"];
+        this.config = config;
+    }
+    synthesize(text, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.verbose(`synthesize [input: ${text}, isSsml=${(0, isSsml_1.isSsml)(text)} options: ${JSON.stringify(options)}]`);
+            const effectiveOptions = Object.assign(Object.assign({}, this.config), options);
+            const filename = this.createFilename(text, effectiveOptions);
+            if (this.fileExists(this.getFullPathToFile(filename))) {
+                return this.getFilenameWithoutExtension(filename);
+            }
+            const { subscriptionKey, serviceRegion } = this.config.credentials;
+            const speechConfig = sdk.SpeechConfig.fromSubscription(subscriptionKey, serviceRegion);
+            speechConfig.speechSynthesisVoiceName = options.voice;
+            speechConfig.speechSynthesisOutputFormat =
+                sdk.SpeechSynthesisOutputFormat.Riff16Khz16BitMonoPcm;
+            yield this.doSynthesize({
+                text,
+                filename: this.getFullPathToFile(filename),
+                speechConfig,
+                isSSML: (0, isSsml_1.isSsml)(text)
+            });
+            return this.getFilenameWithoutExtension(filename);
+        });
+    }
+    doSynthesize(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { text, filename, speechConfig } = params;
+            const audioConfig = sdk.AudioConfig.fromAudioFileOutput(filename);
+            const synthesizer = new sdk.SpeechSynthesizer(speechConfig, audioConfig);
+            // FIXME: Let's turn this into constants
+            const func = params.isSSML ? "speakSsmlAsync" : "speakTextAsync";
+            return new Promise((resolve, reject) => {
+                synthesizer[func](text, function (result) {
+                    if (result.reason === sdk.ResultReason.SynthesizingAudioCompleted) {
+                        resolve(filename);
+                    }
+                    else {
+                        reject(new Error("speech synthesis canceled: " + result.errorDetails));
+                    }
+                    synthesizer.close();
+                }, function (err) {
+                    synthesizer.close();
+                    reject(new Error(err));
+                });
+            });
+        });
+    }
+    getConfigValidationSchema() {
+        return z.object({
+            voice: z.nativeEnum(common_1.AzureVoice)
+        });
+    }
+    getCredentialsValidationSchema() {
+        return z.object({
+            subscriptionKey: z.string(),
+            serviceRegion: z.string()
+        });
+    }
+}
+exports.Azure = Azure;

package/dist/voice/tts/Google.d.ts

@@ -0,0 +1,25 @@
+import { TextToSpeechClient } from "@google-cloud/text-to-speech";
+import * as z from "zod";
+import { AbstractTextToSpeech } from "./AbstractTextToSpeech";
+import { SynthOptions, TtsConfig } from "./types";
+declare const ENGINE_NAME = "tts.google";
+type GoogleTtsConfig = TtsConfig & {
+    [key: string]: Record<string, string>;
+    credentials: {
+        client_email: string;
+        private_key: string;
+    };
+};
+declare class Google extends AbstractTextToSpeech<typeof ENGINE_NAME> {
+    client: TextToSpeechClient;
+    config: GoogleTtsConfig;
+    readonly engineName = "tts.google";
+    protected readonly OUTPUT_FORMAT = "sln16";
+    protected readonly CACHING_FIELDS: string[];
+    protected readonly AUDIO_ENCODING: "LINEAR16";
+    constructor(config: GoogleTtsConfig);
+    synthesize(text: string, options: SynthOptions): Promise<string>;
+    static getConfigValidationSchema(): z.Schema;
+    static getCredentialsValidationSchema(): z.Schema;
+}
+export { Google, ENGINE_NAME };

package/dist/voice/tts/Google.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENGINE_NAME = exports.Google = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const fs = __importStar(require("fs"));
+const util = __importStar(require("util"));
+const common_1 = require("@fonoster/common");
+const logger_1 = require("@fonoster/logger");
+const text_to_speech_1 = require("@google-cloud/text-to-speech");
+const z = __importStar(require("zod"));
+const AbstractTextToSpeech_1 = require("./AbstractTextToSpeech");
+const isSsml_1 = require("./isSsml");
+const ENGINE_NAME = "tts.google";
+exports.ENGINE_NAME = ENGINE_NAME;
+const AUDIO_ENCODING = "LINEAR16";
+const SAMPLE_RATE_HERTZ = 16000;
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+class Google extends AbstractTextToSpeech_1.AbstractTextToSpeech {
+    constructor(config) {
+        super(config);
+        this.engineName = ENGINE_NAME;
+        this.OUTPUT_FORMAT = "sln16";
+        this.CACHING_FIELDS = ["voice"];
+        this.AUDIO_ENCODING = AUDIO_ENCODING;
+        this.client = new text_to_speech_1.TextToSpeechClient(config);
+        this.config = config;
+    }
+    synthesize(text, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.verbose(`synthesize [input: ${text}, isSsml=${(0, isSsml_1.isSsml)(text)} options: ${JSON.stringify(options)}]`);
+            const effectiveOptions = Object.assign(Object.assign({}, this.config), options);
+            const { voice } = effectiveOptions;
+            const lang = `${voice.split("-")[0]}-${voice.split("-")[1]}`;
+            const filename = this.createFilename(text, effectiveOptions);
+            if (this.fileExists(this.getFullPathToFile(filename))) {
+                return this.getFilenameWithoutExtension(filename);
+            }
+            const request = {
+                input: (0, isSsml_1.isSsml)(text) ? { ssml: text } : { text },
+                audioConfig: {
+                    audioEncoding: AUDIO_ENCODING,
+                    sampleRateHertz: SAMPLE_RATE_HERTZ
+                },
+                voice: {
+                    languageCode: lang,
+                    name: voice
+                }
+            };
+            const [response] = yield this.client.synthesizeSpeech(request);
+            const writeFile = util.promisify(fs.writeFile);
+            yield writeFile(this.getFullPathToFile(filename), response.audioContent, "binary");
+            return this.getFilenameWithoutExtension(filename);
+        });
+    }
+    static getConfigValidationSchema() {
+        return z.object({
+            voice: z.nativeEnum(common_1.GoogleVoice)
+        });
+    }
+    static getCredentialsValidationSchema() {
+        return z.object({
+            client_email: z.string(),
+            private_key: z.string()
+        });
+    }
+}
+exports.Google = Google;

package/dist/voice/tts/TextToSpeechFactory.d.ts

@@ -0,0 +1,9 @@
+import { AbstractTextToSpeech } from "./AbstractTextToSpeech";
+import { TtsConfig } from "./types";
+type EngineConstructor<T extends TtsConfig = TtsConfig> = new (options: T) => AbstractTextToSpeech<string>;
+declare class TextToSpeechFactory {
+    private static engines;
+    static registerEngine<T extends TtsConfig>(name: string, ctor: EngineConstructor<T>): void;
+    static getEngine<T extends TtsConfig>(engineName: string, config: T): AbstractTextToSpeech<string>;
+}
+export { TextToSpeechFactory };

package/dist/voice/tts/TextToSpeechFactory.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextToSpeechFactory = void 0;
+/*
+ * Copyright (C) 2024 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/fonoster
+ *
+ * This file is part of Fonoster
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const logger_1 = require("@fonoster/logger");
+const Azure_1 = require("./Azure");
+const Google_1 = require("./Google");
+const logger = (0, logger_1.getLogger)({ service: "apiserver", filePath: __filename });
+class TextToSpeechFactory {
+    static registerEngine(name, ctor) {
+        logger.info("registering tts engine", { name });
+        this.engines.set(name, ctor);
+    }
+    static getEngine(engineName, config) {
+        const EngineConstructor = this.engines.get(engineName);
+        if (!EngineConstructor) {
+            throw new Error(`Engine ${engineName} not found`);
+        }
+        return new EngineConstructor(config);
+    }
+}
+exports.TextToSpeechFactory = TextToSpeechFactory;
+TextToSpeechFactory.engines = new Map();
+// Register engines
+TextToSpeechFactory.registerEngine(Google_1.ENGINE_NAME, Google_1.Google);
+TextToSpeechFactory.registerEngine(Azure_1.ENGINE_NAME, Azure_1.Azure);