@thaleslaray/n8n-nodes-elevenlabs
Version:
Nó n8n para integração com a API da ElevenLabs incluindo Speech-to-Text, Text-to-Speech e Conversational AI
334 lines (333 loc) • 15.1 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.ElevenLabsSoundEffects = void 0;
const n8n_workflow_1 = require("n8n-workflow");
const utils_1 = require("../../utils");
class ElevenLabsSoundEffects {
constructor() {
this.description = {
displayName: 'ElevenLabs Sound Effects',
name: 'elevenLabsSoundEffects',
icon: 'file:../../elevenlabs.svg',
group: ['transform'],
version: 1,
subtitle: '={{$parameter["operation"]}}',
description: 'Adicione efeitos sonoros a arquivos de áudio usando a API da ElevenLabs',
defaults: {
name: 'ElevenLabs Sound Effects',
},
inputs: ['main'],
outputs: ['main'],
credentials: [
{
name: 'elevenLabsApi',
required: true,
},
],
properties: [
{
displayName: 'Operação',
name: 'operation',
type: 'options',
noDataExpression: true,
options: [
{
name: 'Adicionar Efeitos Sonoros',
value: 'addSoundEffects',
description: 'Adicionar efeitos sonoros a um áudio',
action: 'Add sound effects to audio',
},
],
default: 'addSoundEffects',
},
{
displayName: 'Fonte do Áudio',
name: 'audioSource',
type: 'options',
options: [
{
name: 'Arquivo Binário',
value: 'binaryFile',
},
{
name: 'URL',
value: 'url',
},
],
default: 'binaryFile',
description: 'Fonte do arquivo de áudio para processamento',
},
{
displayName: 'Campo Binário',
name: 'binaryPropertyName',
type: 'string',
default: 'data',
required: true,
displayOptions: {
show: {
audioSource: ['binaryFile'],
},
},
description: 'Nome do campo binário que contém o arquivo de áudio',
},
{
displayName: 'URL do Áudio',
name: 'audioUrl',
type: 'string',
default: '',
required: true,
displayOptions: {
show: {
audioSource: ['url'],
},
},
description: 'URL do arquivo de áudio para processamento',
},
{
displayName: 'Efeitos',
name: 'effects',
type: 'fixedCollection',
typeOptions: {
multipleValues: true,
sortable: true,
},
placeholder: 'Adicionar Efeito',
default: {},
options: [
{
name: 'effectsValues',
displayName: 'Efeitos',
values: [
{
displayName: 'Tipo de Efeito',
name: 'effectType',
type: 'options',
options: [
{
name: 'Ambiente',
value: 'ambience',
},
{
name: 'Eco',
value: 'echo',
},
{
name: 'Reverberação',
value: 'reverb',
},
{
name: 'Ruído de Fundo',
value: 'background',
},
{
name: 'Filtro de Passa-Alta',
value: 'highpass',
},
{
name: 'Filtro de Passa-Baixa',
value: 'lowpass',
},
{
name: 'Personalizado',
value: 'custom',
},
],
default: 'ambience',
description: 'Tipo de efeito a ser aplicado',
},
{
displayName: 'Nome do Efeito Personalizado',
name: 'customEffectName',
type: 'string',
displayOptions: {
show: {
effectType: ['custom'],
},
},
default: '',
description: 'Nome do efeito personalizado',
placeholder: 'ex: airport, concert_hall, etc.',
},
{
displayName: 'Intensidade',
name: 'intensity',
type: 'number',
typeOptions: {
minValue: 0,
maxValue: 1,
numberPrecision: 2,
},
default: 0.5,
description: 'Intensidade do efeito (0-1)',
},
{
displayName: 'Tempo de Início (segundos)',
name: 'startTime',
type: 'number',
typeOptions: {
numberPrecision: 2,
},
default: 0,
description: 'Tempo em segundos quando o efeito começa a ser aplicado',
},
{
displayName: 'Tempo de Finalização (segundos)',
name: 'endTime',
type: 'number',
typeOptions: {
numberPrecision: 2,
},
default: 0,
description: 'Tempo em segundos quando o efeito para de ser aplicado (0 = até o final)',
},
],
},
],
},
{
displayName: 'Nome do Campo Binário de Saída',
name: 'outputBinaryPropertyName',
type: 'string',
default: 'data',
required: true,
description: 'Nome do campo binário onde o áudio processado será armazenado',
},
{
displayName: 'Opções Avançadas',
name: 'advancedOptions',
type: 'collection',
placeholder: 'Adicionar Opção',
default: {},
options: [
{
displayName: 'Formato de Saída',
name: 'outputFormat',
type: 'options',
options: [
{
name: 'MP3',
value: 'mp3_44100_128',
},
{
name: 'FLAC',
value: 'flac',
},
{
name: 'WAV',
value: 'pcm_16000',
},
{
name: 'PCM 16-bit 22.05kHz',
value: 'pcm_22050',
},
{
name: 'PCM 16-bit 24kHz',
value: 'pcm_24000',
},
{
name: 'PCM 16-bit 44.1kHz',
value: 'pcm_44100',
},
],
default: 'mp3_44100_128',
description: 'Formato do arquivo de áudio gerado',
},
],
},
],
};
}
async execute() {
var _a;
const items = this.getInputData();
const returnData = [];
for (let i = 0; i < items.length; i++) {
try {
const audioSource = this.getNodeParameter('audioSource', i);
const outputBinaryPropertyName = this.getNodeParameter('outputBinaryPropertyName', i);
const effectsCollection = this.getNodeParameter('effects.effectsValues', i, []);
const advancedOptions = this.getNodeParameter('advancedOptions', i);
if (effectsCollection.length === 0) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Você precisa adicionar pelo menos um efeito');
}
const effects = effectsCollection.map((effect) => {
const effectConfig = {
effect: effect.effectType === 'custom' ? effect.customEffectName : effect.effectType,
intensity: effect.intensity,
};
if (effect.startTime > 0) {
effectConfig.start_time = effect.startTime;
}
if (effect.endTime > 0) {
effectConfig.end_time = effect.endTime;
}
return effectConfig;
});
const formData = {
effects,
};
if (advancedOptions.outputFormat !== undefined) {
formData.output_format = advancedOptions.outputFormat;
}
const options = await utils_1.createBaseOptions.call(this, 'sound-effects', 'POST', undefined, formData);
options.json = false;
options.encoding = null;
options.headers['Accept'] = '*/*';
if (audioSource === 'binaryFile') {
const binaryPropertyName = this.getNodeParameter('binaryPropertyName', i);
const binaryData = (_a = items[i].binary) === null || _a === void 0 ? void 0 : _a[binaryPropertyName];
if (!binaryData) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Nenhum dado binário encontrado');
}
const buffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
options.formData.audio = {
value: buffer,
options: {
filename: binaryData.fileName || 'audio.mp3',
contentType: binaryData.mimeType,
},
};
}
else {
const audioUrl = this.getNodeParameter('audioUrl', i);
options.formData.audio_url = audioUrl;
}
const response = await this.helpers.request(options);
let mimeType = 'audio/mpeg';
let fileExtension = 'mp3';
if (advancedOptions.outputFormat) {
if (advancedOptions.outputFormat === 'flac') {
mimeType = 'audio/flac';
fileExtension = 'flac';
}
else if (advancedOptions.outputFormat.startsWith('pcm_')) {
mimeType = 'audio/wav';
fileExtension = 'wav';
}
}
const filename = `audio_effects_${Date.now()}.${fileExtension}`;
const newItem = {
json: {
success: true,
effects: effectsCollection,
...advancedOptions,
},
binary: {},
pairedItem: { item: i },
};
newItem.binary[outputBinaryPropertyName] = await this.helpers.prepareBinaryData(response, filename, mimeType);
returnData.push(newItem);
}
catch (error) {
const errorResult = utils_1.handleApiError.call(this, error, i);
if (errorResult) {
returnData.push(errorResult);
continue;
}
throw error;
}
}
return [returnData];
}
}
exports.ElevenLabsSoundEffects = ElevenLabsSoundEffects;