feat: Vite + vue 3 💚 (#10047)

Fixes https://github.com/chatwoot/chatwoot/issues/8436
Fixes https://github.com/chatwoot/chatwoot/issues/9767
Fixes https://github.com/chatwoot/chatwoot/issues/10156
Fixes https://github.com/chatwoot/chatwoot/issues/6031
Fixes https://github.com/chatwoot/chatwoot/issues/5696
Fixes https://github.com/chatwoot/chatwoot/issues/9250
Fixes https://github.com/chatwoot/chatwoot/issues/9762

---------

Co-authored-by: Pranav <pranavrajs@gmail.com>
Co-authored-by: Sivin Varghese <64252451+iamsivin@users.noreply.github.com>

app/javascript/dashboard/components/widgets/WootWriter/utils/mp3ConversionUtils.js

@@ -1,14 +1,77 @@
-import lamejs from 'lamejs';
+import lamejs from '@breezystack/lamejs';
+
+const writeString = (view, offset, string) => {
+  for (let i = 0; i < string.length; i++) {
+    view.setUint8(offset + i, string.charCodeAt(i));
+  }
+};
+
+const bufferToWav = async (buffer, numChannels, sampleRate) => {
+  const length = buffer.length * numChannels * 2;
+  const wav = new ArrayBuffer(44 + length);
+  const view = new DataView(wav);
+
+  // WAV Header
+  writeString(view, 0, 'RIFF');
+  view.setUint32(4, 36 + length, true);
+  writeString(view, 8, 'WAVE');
+  writeString(view, 12, 'fmt ');
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, numChannels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * numChannels * 2, true);
+  view.setUint16(32, numChannels * 2, true);
+  view.setUint16(34, 16, true);
+  writeString(view, 36, 'data');
+  view.setUint32(40, length, true);
+
+  // WAV Data
+  const offset = 44;
+  for (let i = 0; i < buffer.length; i++) {
+    for (let channel = 0; channel < numChannels; channel++) {
+      const sample = Math.max(
+        -1,
+        Math.min(1, buffer.getChannelData(channel)[i])
+      );
+      view.setInt16(
+        offset + (i * numChannels + channel) * 2,
+        sample * 0x7fff,
+        true
+      );
+    }
+  }
+
+  return new Blob([wav], { type: 'audio/wav' });
+};
+
+const decodeAudioData = async audioBlob => {
+  const audioContext = new (window.AudioContext || window.webkitAudioContext)();
+  const arrayBuffer = await audioBlob.arrayBuffer();
+  const audioData = await audioContext.decodeAudioData(arrayBuffer);
+  return audioData;
+};
+
+export const convertToWav = async audioBlob => {
+  const audioBuffer = await decodeAudioData(audioBlob);
+  return bufferToWav(
+    audioBuffer,
+    audioBuffer.numberOfChannels,
+    audioBuffer.sampleRate
+  );
+};
+
 /**
- * Encodes a mono channel audio stream to MP3 format.
+ * Encodes audio samples to MP3 format.
  * @param {number} channels - Number of audio channels.
  * @param {number} sampleRate - Sample rate in Hz.
  * @param {Int16Array} samples - Audio samples to be encoded.
+ * @param {number} bitrate - MP3 bitrate (default: 128)
  * @returns {Blob} - The MP3 encoded audio as a Blob.
  */
-export const encodeToMP3 = (channels, sampleRate, samples) => {
+export const encodeToMP3 = (channels, sampleRate, samples, bitrate = 128) => {
   const outputBuffer = [];
-  const encoder = new lamejs.Mp3Encoder(channels, sampleRate, 128);
+  const encoder = new lamejs.Mp3Encoder(channels, sampleRate, bitrate);
   const maxSamplesPerFrame = 1152;
 
   for (let offset = 0; offset < samples.length; offset += maxSamplesPerFrame) {
@@ -30,24 +93,51 @@ export const encodeToMP3 = (channels, sampleRate, samples) => {
 };
 
 /**
- * Converts a WAV audio Blob to an MP3 format Blob.
- * @param {Blob} blob - The audio data in WAV format as a Blob.
+ * Converts an audio Blob to an MP3 format Blob.
+ * @param {Blob} audioBlob - The audio data as a Blob.
+ * @param {number} bitrate - MP3 bitrate (default: 128)
  * @returns {Promise<Blob>} - A Blob containing the MP3 encoded audio.
  */
-export const convertWavToMp3 = async blob => {
+export const convertToMp3 = async (audioBlob, bitrate = 128) => {
   try {
-    const audioBuffer = await blob.arrayBuffer();
-    const wavHeader = lamejs.WavHeader.readHeader(new DataView(audioBuffer));
+    const audioBuffer = await decodeAudioData(audioBlob);
     const samples = new Int16Array(
-      audioBuffer,
-      wavHeader.dataOffset,
-      wavHeader.dataLen / 2
+      audioBuffer.length * audioBuffer.numberOfChannels
+    );
+    let offset = 0;
+    for (let i = 0; i < audioBuffer.length; i += 1) {
+      for (
+        let channel = 0;
+        channel < audioBuffer.numberOfChannels;
+        channel += 1
+      ) {
+        const sample = Math.max(
+          -1,
+          Math.min(1, audioBuffer.getChannelData(channel)[i])
+        );
+        samples[offset] = sample < 0 ? sample * 0x8000 : sample * 0x7fff;
+        offset += 1;
+      }
+    }
+    return encodeToMP3(
+      audioBuffer.numberOfChannels,
+      audioBuffer.sampleRate,
+      samples,
+      bitrate
     );
-
-    return encodeToMP3(wavHeader.channels, wavHeader.sampleRate, samples);
   } catch (error) {
-    // eslint-disable-next-line
-    console.log('Failed to convert WAV to MP3:', error);
-    throw new Error('Conversion from WAV to MP3 failed.');
+    throw new Error('Conversion to MP3 failed.');
   }
 };
+
+export const convertAudio = async (inputBlob, outputFormat, bitrate = 128) => {
+  let audio;
+  if (outputFormat === 'audio/wav') {
+    audio = await convertToWav(inputBlob);
+  } else if (outputFormat === 'audio/mp3') {
+    audio = await convertToMp3(inputBlob, bitrate);
+  } else {
+    throw new Error('Unsupported output format');
+  }
+  return audio;
+};