voicemix 1.0.0

package/README.md

@@ -0,0 +1,94 @@
+# VoiceMix
+
+VoiceMix is a flexible text-to-speech library that allows you to generate speech from text using different voices, languages, and customization options.
+
+## Installation
+
+```bash
+npm install voicemix dotenv
+```
+
+## Environment Setup
+
+Create a `.env` file in your project root with your API keys:
+
+```plaintext
+ELEVENLABS_API_KEY=your_elevenlabs_api_key_here
+RESEMBLE_API_KEY=your_resemble_api_key_here
+```
+
+## Usage
+
+### Basic Example
+
+```javascript
+import { VoiceMix } from 'voicemix';
+import dotenv from 'dotenv';
+dotenv.config();
+
+const voiceMix = new VoiceMix();
+
+voiceMix
+    .voice('EbhcCfMvNsbvjN6OhjpJ')
+    .say('Hello, world!')
+    .save();
+```
+
+### Advanced Usage
+
+```javascript
+const voiceMix = new VoiceMix();
+
+voiceMix
+    .useResemble()  // https://www.resemble.ai/
+    .prompt('Friendly and conversational tone') // Set voice prompt/style
+    .voice('ba875a0a') // Select specific voice
+    .lang('en-US') // Set language
+    .say('Your text here')
+    .save();
+```
+
+### Batch Processing
+
+You can process multiple lines of text using a JSON configuration:
+
+```javascript
+import { VoiceMix } from 'voicemix';
+import fs from 'fs';
+
+// Read script from JSON file
+const script = JSON.parse(fs.readFileSync('./lines.json', 'utf8'));
+const voiceMix = new VoiceMix();
+
+// Process each line
+for (const entry of script) {
+    voiceMix
+        .prompt(entry.prompt || 'Friendly and conversational tone')
+        .voice(entry.voiceId)
+        .say(entry.english)
+        .save();
+}
+```
+
+Example `lines.json`:
+```json
+[
+    {
+        "prompt": "Friendly and conversational tone",
+        "english": "Hello, how are you today?",
+        "voiceId": "EbhcCfMvNsbvjN6OhjpJ"
+    }
+]
+```
+
+## Features
+
+- Multiple voice support
+- Language selection
+- Voice prompts for style control (Resemble AI)
+- Support for different TTS engines
+- Simple chainable API
+
+## License
+
+MIT

package/demo/index.js

@@ -0,0 +1,42 @@
+import { VoiceMix } from "../index.js";
+import dotenv from "dotenv";
+import fs from 'fs';
+
+dotenv.config();
+
+// Read and parse the lines.json file
+const script = JSON.parse(fs.readFileSync('./lines.json', 'utf8'));
+const voiceMix = new VoiceMix()//.useResemble().lang('en-US');
+
+// Process each line in the script
+for (const entry of script) {
+
+    voiceMix
+        .prompt(entry.prompt || 'Friendly and conversational tone')
+        // .voice('ba875a0a') // Peter v2
+        .voice('EbhcCfMvNsbvjN6OhjpJ')
+        .say(entry.english)
+        .save();
+}
+
+// const voiceMix = new VoiceMix();
+
+
+// voiceMix.voice("dBRpMbVO8Bjs9wBZC6cb")
+// voiceMix.say(`As soon as someone picked up, he said: "Dad, it's me, listen carefully. I'm at DAF2... with Liev Thibot."`);
+// voiceMix.save();
+
+// let line = `As soon as someone picked up, he said: "Dad, it's me, listen carefully. I'm at DAF2... with Liev Thibot."`;
+
+// // line = `Pero recuerdo la sensación. Fue como si alguien hubiera sacado todo el aire de la habitación.`;
+
+// const voiceMix = new VoiceMix();
+// voiceMix.useResemble()
+//     .prompt('clears his throat before starting')
+//     // .voice('0a73c559')
+//     // .lang('es-us')
+//     // .voice('f23e8ffe')
+//     // .voice('fcf8490c')
+//     .voice('ba875a0a') // Peter v2
+//     .say(line)
+//     .save();

package/demo/lines.json

@@ -0,0 +1,21 @@
+[
+      
+      {
+        "speaker": "@PeterCabot",
+        "spanish": "La abuela Maggie hizo todo lo posible para mantener las cosas normales, pero nada era normal.",
+        "english": "Grandma Maggie did everything she could to keep things normal, but nothing was normal.",
+        "prompt": "Appreciative but resigned tone"
+      },
+      {
+        "speaker": "@PeterCabot",
+        "spanish": "Mis padres se habían ido y no importaba cuánto lo deseara, no iban a volver.",
+        "english": "My parents were gone and no matter how much I wished it, they weren't coming back.",
+        "prompt": ""
+      },
+      {
+        "speaker": "@PeterCabot",
+        "spanish": "Después del funeral, estaba en mi habitación, jugando con el camión rojo que mamá me había regalado para mi cumpleaños.",
+        "english": "After the funeral, I was in my room, playing with the red truck that Mom had given me for my birthday.",
+        "prompt": ""
+      }
+    ]

package/demo/package-lock.json

@@ -0,0 +1,28 @@
+{
+  "name": "demo",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "demo",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "dotenv": "^16.5.0"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.5.0",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.5.0.tgz",
+      "integrity": "sha512-m/C+AwOAr9/W1UOIZUo232ejMNnJAJtYQjUbHoNTBNTJSvqzzDh7vnrei3o3r3m9blf6ZoDkvcw0VmozNRFJxg==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    }
+  }
+}

package/demo/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "demo",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "dotenv": "^16.5.0"
+  }
+}

package/errors.js

@@ -0,0 +1,48 @@
+export class VoiceMixError extends Error {
+    constructor(message, details = {}) {
+        super(message);
+        this.name = 'VoiceMixError';
+        this.details = details;
+    }
+}
+
+export class ProviderError extends VoiceMixError {
+    constructor(message, provider, details = {}) {
+        super(message, details);
+        this.name = 'ProviderError';
+        this.provider = provider;
+    }
+}
+
+export class ValidationError extends VoiceMixError {
+    constructor(message, field, details = {}) {
+        super(message, details);
+        this.name = 'ValidationError';
+        this.field = field;
+    }
+}
+
+export function formatError(error) {
+    if (error instanceof VoiceMixError) {
+        let message = `${error.name}: ${error.message}`;
+        
+        if (error instanceof ProviderError) {
+            message += `\nProvider: ${error.provider}`;
+        }
+        
+        if (error instanceof ValidationError) {
+            message += `\nField: ${error.field}`;
+        }
+        
+        if (Object.keys(error.details).length > 0) {
+            message += '\nDetails:';
+            for (const [key, value] of Object.entries(error.details)) {
+                message += `\n  ${key}: ${value}`;
+            }
+        }
+        
+        return message;
+    }
+    
+    return error.message || 'An unknown error occurred';
+} 

package/index.js

@@ -0,0 +1,289 @@
+import fs from 'fs';
+import path from 'path';
+import hashFactory from 'hash-factory';
+import { ElevenLabsProvider } from './providers/elevenlabs.js';
+import { ResembleProvider } from './providers/resemble.js';
+import { ValidationError, formatError } from './errors.js';
+
+const hash = hashFactory({ words: true, alpha: true });
+const hashNow = hashFactory({ words: true, alpha: true, now: true });
+
+export class VoiceMix {
+    voices = {};
+
+    constructor(opts = {}) {
+        this.text = 'string';
+        this.ttsId = null;
+        this.format = 'mp3';
+        this.filePath = './';
+        this.fileOutput = 'speech';
+        this.filePrefix = '';
+        this.randPosfix = false;
+        this.drymode = false;
+        this.promptText = null;
+        this.xmlLang = 'en-us';
+
+        this.temperature = "0.8";
+        this.exaggeration = "0";
+        this.prosodyRate = "100%";
+        // this.prosodyPitch = "medium";
+
+        this.requestsQueue = []; // Cola para las solicitudes pendientes
+        this.isProcessing = false; // Estado para controlar si ya se está procesando un lote
+        this.batchSize = 3; // Tamaño del lote    
+
+        Object.assign(this, opts);
+
+        // Inicializar el proveedor por defecto (ElevenLabs)
+        this.provider = new ElevenLabsProvider(opts.apiKey);
+        this.providerType = 'elevenlabs';
+
+        // Asegurar que filePath sea una ruta absoluta
+        this.filePath = path.resolve(this.filePath);
+    }
+
+    useElevenLabs(apiKey) {
+        this.provider = new ElevenLabsProvider(apiKey);
+        this.providerType = 'elevenlabs';
+        return this;
+    }
+
+    useResemble(apiKey) {
+        this.provider = new ResembleProvider(apiKey);
+        this.providerType = 'resemble';
+        return this;
+    }
+
+    monolingual_v1() {
+        if (this.providerType === 'elevenlabs') {
+            this.provider.monolingual_v1();
+        }
+        return this;
+    }
+
+    multilingual_v1() {
+        if (this.providerType === 'elevenlabs') {
+            this.provider.multilingual_v1();
+        }
+        return this;
+    }
+
+    multilingual_v2() {
+        if (this.providerType === 'elevenlabs') {
+            this.provider.multilingual_v2();
+        }
+        return this;
+    }
+
+    setSampleRate(rate) {
+        if (this.providerType === 'resemble') {
+            this.provider.setSampleRate(rate);
+        }
+        return this;
+    }
+
+    setPrecision(precision) {
+        if (this.providerType === 'resemble') {
+            this.provider.setPrecision(precision);
+        }
+        return this;
+    }
+
+    setOutputFormat(format) {
+        if (this.providerType === 'resemble') {
+            this.provider.setOutputFormat(format);
+        }
+        return this;
+    }
+
+    id(id) {
+        this.ttsId = id;
+        return this;
+    }
+
+    actor(key) {
+        if (!this.voices[key]) return this;
+        this.ttsId = this.voices[key];
+        return this;
+    }
+
+    path(v) {
+        this.filePath = path.resolve(v);
+        return this;
+    }
+
+    prefix(v) {
+        this.filePrefix = v;
+        return this;
+    }
+
+    voice(id) {
+        this.ttsId = id;
+        return this;
+    }
+
+    exists() {
+        return fs.existsSync(this.fullPath());
+    }
+
+    fullPath() {
+        return path.join(this.filePath, this.fileName());
+    }
+
+    fileName() {
+        return this.fileOutput + "." + this.format;
+    }
+
+    _filename(text) {
+        text += " " + this.promptText + " " + this.xmlLang + " " + this.ttsId;
+        text += " " + this.providerType;
+        const filename = this.randPosfix ? hashNow(text) : hash(text);
+        return this.filePrefix + filename;
+    }
+
+    say(text) {
+        this.text = text;
+        return this.file(this._filename(text));
+    }
+
+    file(fileName) {
+        this.fileOutput = fileName;
+        return this;
+    }
+
+    save() {
+        if (this.drymode) return Promise.resolve(this.fileOutput);
+
+        const fileName = this.fileOutput + "." + this.format;
+
+        // Crear una instantánea de todas las variables relevantes
+        const requestSnapshot = {
+            fileName,
+            text: this.text,
+            ttsId: this.ttsId,
+            format: this.format,
+            filePath: this.filePath,
+            promptText: this.promptText,
+            xmlLang: this.xmlLang,
+            shouldAddBreakTags: this.shouldAddBreakTags,
+            temperature: this.temperature,
+            exaggeration: this.exaggeration,
+            prosodyRate: this.prosodyRate,
+            prosodyPitch: this.prosodyPitch
+        };
+
+        return new Promise((resolve, reject) => {
+            this.requestsQueue.push({
+                ...requestSnapshot,
+                resolve,
+                reject
+            });
+
+            this._processBatch();
+        });
+    }
+
+    _processBatch() {
+        if (this.isProcessing) return;
+        if (this.requestsQueue.length === 0) {
+            this.isProcessing = false;
+            return;
+        }
+
+        this.isProcessing = true;
+        const batch = this.requestsQueue.splice(0, this.batchSize);
+
+        Promise.all(batch.map(request =>
+            this._sendRequest(request)
+                .then(fileName => request.resolve(fileName))
+                .catch(error => request.reject(error))
+        )).then(() => {
+            this.isProcessing = false;
+            this._processBatch();
+        });
+    }
+
+    async _sendRequest(request) {
+        if (this.drymode) return Promise.resolve(request.fileName);
+
+        try {
+            if (!request.ttsId) {
+                throw new ValidationError('Voice ID is required', 'ttsId');
+            }
+
+            const text = this.addBreakTags(request.text, {
+                promptText: request.promptText,
+                xmlLang: request.xmlLang,
+                temperature: request.temperature,
+                exaggeration: request.exaggeration,
+                prosodyRate: request.prosodyRate,
+                prosodyPitch: request.prosodyPitch
+            });
+            console.log(text);
+
+            return await this.provider.save(
+                request.ttsId,
+                text,
+                request.format,
+                request.filePath,
+                request.fileName
+            );
+
+        } catch (error) {
+            const formattedError = formatError(error);
+            console.error(formattedError);
+            throw error;
+        }
+    }
+
+
+    lang(lang) {
+        this.xmlLang = lang;
+        return this;
+    }
+
+    addBreakTags(text, options = {}) {
+
+        if (this.providerType !== 'resemble') return text;
+
+        // Construir atributos de la etiqueta speak
+        const speakAttributes = [];
+
+        if (options.promptText) {
+            options.prosodyRate = "110%"
+            speakAttributes.push(`prompt="${options.promptText}"`);
+            // speakAttributes.push(`xml:lang="en-us"`);
+            if (options.temperature) speakAttributes.push(`temperature="${options.temperature}"`);
+            if (options.exaggeration) speakAttributes.push(`exaggeration="${options.exaggeration}"`);
+        }
+
+        // Construir atributos de prosodia
+        const prosodyAttributes = [];
+        if (options.prosodyRate) prosodyAttributes.push(`rate="${options.prosodyRate}"`);
+        if (options.prosodyPitch) prosodyAttributes.push(`pitch="${options.prosodyPitch}"`);
+
+
+        if (prosodyAttributes.length > 0) {
+            // Si solo existen atributos de prosodia, solo envolver en prosodia
+            text = `<prosody ${prosodyAttributes.join(' ')}>${text}</prosody>`;
+        }
+
+        // Solo envolver en etiqueta speak si hay atributos
+        if (speakAttributes.length > 0) {
+            text = `<speak ${speakAttributes.join(' ')}>${text}</speak>`;
+        }
+
+        if (options.xmlLang) {
+            text = `<lang xml:lang="${options.xmlLang}">${text}</lang>`;
+        }
+
+        return text;
+    }
+
+    prompt(promptText) {
+        if (this.providerType !== 'resemble') return this;
+        this.promptText = promptText;
+        return this;
+    }
+}
+

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "voicemix",
+  "type": "module",
+  "version": "1.0.0",
+  "description": "🗣️ text-to-speech tool using ElevenLabs and Resemble AI APIs.",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Martin Clasen",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.9.0",
+    "hash-factory": "^1.1.0"
+  },
+  "keywords": [
+    "text-to-speech",
+    "tts",
+    "elevenlabs",
+    "resemble-ai",
+    "voice",
+    "speech",
+    "audio",
+    "synthesis",
+    "prompt",
+    "tone",
+    "clasen"
+  ]
+}

package/providers/elevenlabs.js

@@ -0,0 +1,116 @@
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+import { ProviderError } from '../errors.js';
+
+export class ElevenLabsProvider {
+    constructor(apiKey) {
+        this.apiKey = apiKey || process.env.ELEVENLABS_API_KEY;
+        this.model_id = 'eleven_multilingual_v2';
+        this.voice_settings = {
+            stability: 0.5,
+            similarity_boost: 0.5,
+            style: 0.4,
+            use_speaker_boost: true
+        };
+
+        if (!this.apiKey) {
+            throw new ProviderError('ElevenLabs API key is required', 'elevenlabs');
+        }
+    }
+
+    monolingual_v1() {
+        this.model_id = 'eleven_monolingual_v1';
+        return this;
+    }
+
+    multilingual_v1() {
+        this.model_id = 'eleven_multilingual_v1';
+        return this;
+    }
+
+    multilingual_v2() {
+        this.model_id = 'eleven_multilingual_v2';
+        return this;
+    }
+
+    _getRequestOptions(voiceId, text, format) {
+        return {
+            method: "post",
+            url: `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`,
+            headers: {
+                accept: "audio/" + (format === "mp3" ? "mpeg" : format),
+                "xi-api-key": this.apiKey,
+                "Content-Type": "application/json",
+            },
+            data: {
+                text,
+                model_id: this.model_id,
+                voice_settings: this.voice_settings,
+            },
+            responseType: "stream",
+        };
+    }
+
+    async save(voiceId, text, format, filePath, fileName) {
+        try {
+            if (!voiceId) {
+                throw new ProviderError('Voice ID is required', 'elevenlabs');
+            }
+            if (!text) {
+                throw new ProviderError('Text is required', 'elevenlabs');
+            }
+            if (!filePath || !fileName) {
+                throw new ProviderError('File path and name are required', 'elevenlabs');
+            }
+
+            const response = await axios({
+                ...this._getRequestOptions(voiceId, text, format),
+                responseType: 'stream'
+            });
+
+            if (!fs.existsSync(filePath)) {
+                fs.mkdirSync(filePath, { recursive: true });
+            }
+
+            const fullPath = path.join(filePath, fileName);
+            const writer = fs.createWriteStream(fullPath);
+            response.data.pipe(writer);
+
+            return new Promise((resolve, reject) => {
+                writer.on('finish', () => resolve(fullPath));
+                writer.on('error', (err) => {
+                    reject(new ProviderError(
+                        'Failed to write audio file',
+                        'elevenlabs',
+                        { path: fullPath, error: err.message }
+                    ));
+                });
+            });
+        } catch (error) {
+            if (error instanceof ProviderError) {
+                throw error;
+            }
+            
+            if (axios.isAxiosError(error)) {
+                const details = {
+                    status: error.response?.status,
+                    statusText: error.response?.statusText,
+                    data: error.response?.data
+                };
+                
+                throw new ProviderError(
+                    'Failed to save audio from ElevenLabs API',
+                    'elevenlabs',
+                    details
+                );
+            }
+            
+            throw new ProviderError(
+                'An unexpected error occurred while saving audio',
+                'elevenlabs',
+                { originalError: error.message }
+            );
+        }
+    }
+} 

package/providers/resemble.js

@@ -0,0 +1,138 @@
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+import { ProviderError, ValidationError } from '../errors.js';
+
+export class ResembleProvider {
+    constructor(apiKey) {
+        this.apiKey = apiKey || process.env.RESEMBLE_API_KEY;
+        this.baseUrl = 'https://f.cluster.resemble.ai';
+        this.defaultSettings = {
+            sample_rate: 48000,
+            output_format: 'mp3',
+            precision: 'PCM_16'
+        };
+
+        if (!this.apiKey) {
+            throw new ProviderError('Resemble API key is required', 'resemble');
+        }
+    }
+
+    _getRequestOptions(endpoint, data) {
+        return {
+            method: 'post',
+            url: `${this.baseUrl}${endpoint}`,
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+                'Accept-Encoding': 'gzip, deflate, br'
+            },
+            data
+        };
+    }
+
+    async save(voiceId, text, format, filePath, fileName) {
+        try {
+            if (!voiceId) {
+                throw new ProviderError('Voice ID is required', 'resemble');
+            }
+            if (!text) {
+                throw new ProviderError('Text is required', 'resemble');
+            }
+            if (!filePath || !fileName) {
+                throw new ProviderError('File path and name are required', 'resemble');
+            }
+
+            const response = await axios(this._getRequestOptions('/synthesize', {
+                voice_uuid: voiceId,
+                data: text,
+                sample_rate: this.defaultSettings.sample_rate,
+                output_format: format,
+                precision: this.defaultSettings.precision
+            }));
+
+            if (!response.data.success) {
+                throw new ProviderError(
+                    response.data.issues?.join(', ') || 'Synthesis failed',
+                    'resemble',
+                    response.data
+                );
+            }
+
+            if (!fs.existsSync(filePath)) {
+                fs.mkdirSync(filePath, { recursive: true });
+            }
+
+            const fullPath = path.join(filePath, fileName);
+            const audioBuffer = Buffer.from(response.data.audio_content, 'base64');
+            
+            return new Promise((resolve, reject) => {
+                fs.writeFile(fullPath, audioBuffer, (err) => {
+                    if (err) {
+                        reject(new ProviderError(
+                            'Failed to write audio file',
+                            'resemble',
+                            { path: fullPath, error: err.message }
+                        ));
+                    } else {
+                        resolve(fullPath);
+                    }
+                });
+            });
+        } catch (error) {
+            if (error instanceof ProviderError) {
+                throw error;
+            }
+            
+            if (axios.isAxiosError(error)) {
+                const details = {
+                    status: error.response?.status,
+                    statusText: error.response?.statusText,
+                    data: error.response?.data
+                };
+                
+                throw new ProviderError(
+                    'Failed to save audio from Resemble API',
+                    'resemble',
+                    details
+                );
+            }
+            
+            throw new ProviderError(
+                'An unexpected error occurred while saving audio',
+                'resemble',
+                { originalError: error.message }
+            );
+        }
+    }
+
+    // Additional Resemble-specific methods
+    setSampleRate(rate) {
+        this.defaultSettings.sample_rate = rate;
+        return this;
+    }
+
+    setPrecision(precision) {
+        const validPrecisions = ['MULAW', 'PCM_16', 'PCM_24', 'PCM_32'];
+        if (!validPrecisions.includes(precision)) {
+            throw new ValidationError(
+                `Invalid precision. Must be one of: ${validPrecisions.join(', ')}`,
+                'precision'
+            );
+        }
+        this.defaultSettings.precision = precision;
+        return this;
+    }
+
+    setOutputFormat(format) {
+        const validFormats = ['mp3', 'wav'];
+        if (!validFormats.includes(format)) {
+            throw new ValidationError(
+                `Invalid output format. Must be one of: ${validFormats.join(', ')}`,
+                'output_format'
+            );
+        }
+        this.defaultSettings.output_format = format;
+        return this;
+    }
+}