use-voice-control 0.1.0 → 0.1.2

package/speech/utils/audio-utils.js

@@ -0,0 +1,82 @@
+//see also: https://github.com/colmeye/js-mediarecorder-to-wav/blob/main/wave-worker.js
+
+// 16000
+export async function resampleAudio(audioBuffer, targetSampleRate) {
+  const offlineCtx = new OfflineAudioContext(1, targetSampleRate * audioBuffer.duration, targetSampleRate);
+  const source = offlineCtx.createBufferSource();
+  source.buffer = audioBuffer;
+  source.connect(offlineCtx.destination);
+  source.start(0);
+  return await offlineCtx.startRendering();
+}
+// const floatArray = resampledBuffer.getChannelData(0);
+
+/**
+ * Applies gain to an audio buffer to increase or decrease volume
+ * @param {AudioBuffer} audioBuffer - The audio buffer to adjust
+ * @param {number} gain - Gain factor (e.g., 1.5 for 50% louder)
+ * @returns {AudioBuffer} - The adjusted audio buffer
+ */
+export function applyAudioGain(audioBuffer, gain = 1.5) {
+    // Create a copy to avoid modifying the original
+    const audioContext = new AudioContext();
+    const newBuffer = audioContext.createBuffer(
+        audioBuffer.numberOfChannels,
+        audioBuffer.length,
+        audioBuffer.sampleRate
+    );
+
+    // Apply gain to each channel
+    for (let i = 0; i < audioBuffer.numberOfChannels; i++) {
+        const channelData = audioBuffer.getChannelData(i);
+        const newChannelData = newBuffer.getChannelData(i);
+        for (let j = 0; j < channelData.length; j++) {
+            // Apply gain and clamp to [-1, 1]
+            newChannelData[j] = Math.max(-1, Math.min(1, channelData[j] * gain));
+        }
+    }
+    
+    return newBuffer;
+}
+
+export function convertAudioBufferToWav(audioBuffer) {
+    const numOfChannels = audioBuffer.numberOfChannels;
+    const length = audioBuffer.length * numOfChannels * 2; // 2 bytes per sample
+    const sampleRate = audioBuffer.sampleRate;
+    const buffer = new ArrayBuffer(44 + length);
+    const view = new DataView(buffer);
+
+    writeString(view, 0, 'RIFF');
+    view.setUint32(4, 36 + length, true);
+    writeString(view, 8, 'WAVE');
+    
+    writeString(view, 12, 'fmt ');
+    view.setUint32(16, 16, true); // subchunk1 size
+    view.setUint16(20, 1, true); // PCM format
+    view.setUint16(22, numOfChannels, true);
+    view.setUint32(24, sampleRate, true);
+    view.setUint32(28, sampleRate * numOfChannels * 2, true); // byte rate
+    view.setUint16(32, numOfChannels * 2, true); // block align
+    view.setUint16(34, 16, true); // bits per sample
+    
+    writeString(view, 36, 'data');
+    view.setUint32(40, length, true);
+    
+    let offset = 44;
+    for (let i = 0; i < audioBuffer.numberOfChannels; i++) {
+        const channelData = audioBuffer.getChannelData(i);
+        for (let j = 0; j < channelData.length; j++) {
+            const sample = Math.max(-1, Math.min(1, channelData[j]));
+            view.setInt16(offset, sample * 0x7FFF, true);
+            offset += 2;
+        }
+    }
+    
+    return buffer;
+}
+
+function writeString(view, offset, string) {
+    for (let i = 0; i < string.length; i++) {
+        view.setUint8(offset + i, string.charCodeAt(i));
+    }
+}

package/speech/utils/phonemize.js

@@ -0,0 +1,198 @@
+import { phonemize as espeakng } from "https://cdn.jsdelivr.net/npm/phonemizer@1.2.1/dist/phonemizer.min.js";
+//import { phonemize as espeakng } from "phonemizer";
+
+/**
+ * Helper function to split a string on a regex, but keep the delimiters.
+ * This is required, because the JavaScript `.split()` method does not keep the delimiters,
+ * and wrapping in a capturing group causes issues with existing capturing groups (due to nesting).
+ * @param {string} text The text to split.
+ * @param {RegExp} regex The regex to split on.
+ * @returns {{match: boolean; text: string}[]} The split string.
+ */
+function split(text, regex) {
+  const result = [];
+  let prev = 0;
+  for (const match of text.matchAll(regex)) {
+    const fullMatch = match[0];
+    if (prev < match.index) {
+      result.push({ match: false, text: text.slice(prev, match.index) });
+    }
+    if (fullMatch.length > 0) {
+      result.push({ match: true, text: fullMatch });
+    }
+    prev = match.index + fullMatch.length;
+  }
+  if (prev < text.length) {
+    result.push({ match: false, text: text.slice(prev) });
+  }
+  return result;
+}
+
+/**
+ * Helper function to split numbers into phonetic equivalents
+ * @param {string} match The matched number
+ * @returns {string} The phonetic equivalent
+ */
+function split_num(match) {
+  if (match.includes(".")) {
+    return match;
+  } else if (match.includes(":")) {
+    let [h, m] = match.split(":").map(Number);
+    if (m === 0) {
+      return `${h} o'clock`;
+    } else if (m < 10) {
+      return `${h} oh ${m}`;
+    }
+    return `${h} ${m}`;
+  }
+  let year = parseInt(match.slice(0, 4), 10);
+  if (year < 1100 || year % 1000 < 10) {
+    return match;
+  }
+  let left = match.slice(0, 2);
+  let right = parseInt(match.slice(2, 4), 10);
+  let suffix = match.endsWith("s") ? "s" : "";
+  if (year % 1000 >= 100 && year % 1000 <= 999) {
+    if (right === 0) {
+      return `${left} hundred${suffix}`;
+    } else if (right < 10) {
+      return `${left} oh ${right}${suffix}`;
+    }
+  }
+  return `${left} ${right}${suffix}`;
+}
+
+/**
+ * Helper function to format monetary values
+ * @param {string} match The matched currency
+ * @returns {string} The formatted currency
+ */
+function flip_money(match) {
+  const bill = match[0] === "$" ? "dollar" : "pound";
+  if (isNaN(Number(match.slice(1)))) {
+    return `${match.slice(1)} ${bill}s`;
+  } else if (!match.includes(".")) {
+    let suffix = match.slice(1) === "1" ? "" : "s";
+    return `${match.slice(1)} ${bill}${suffix}`;
+  }
+  const [b, c] = match.slice(1).split(".");
+  const d = parseInt(c.padEnd(2, "0"), 10);
+  let coins = match[0] === "$" ? (d === 1 ? "cent" : "cents") : d === 1 ? "penny" : "pence";
+  return `${b} ${bill}${b === "1" ? "" : "s"} and ${d} ${coins}`;
+}
+
+/**
+ * Helper function to process decimal numbers
+ * @param {string} match The matched number
+ * @returns {string} The formatted number
+ */
+function point_num(match) {
+  let [a, b] = match.split(".");
+  return `${a} point ${b.split("").join(" ")}`;
+}
+
+/**
+ * Normalize text for phonemization
+ * @param {string} text The text to normalize
+ * @returns {string} The normalized text
+ */
+function normalize_text(text) {
+  return (
+    text
+      // 1. Handle quotes and brackets
+      .replace(/[‘’]/g, "'")
+      .replace(/«/g, "“")
+      .replace(/»/g, "”")
+      .replace(/[“”]/g, '"')
+      .replace(/\(/g, "«")
+      .replace(/\)/g, "»")
+
+      // 2. Replace uncommon punctuation marks
+      .replace(/、/g, ", ")
+      .replace(/。/g, ". ")
+      .replace(/！/g, "! ")
+      .replace(/，/g, ", ")
+      .replace(/：/g, ": ")
+      .replace(/；/g, "; ")
+      .replace(/？/g, "? ")
+
+      // 3. Whitespace normalization
+      .replace(/[^\S \n]/g, " ")
+      .replace(/  +/, " ")
+      .replace(/(?<=\n) +(?=\n)/g, "")
+
+      // 4. Abbreviations
+      .replace(/\bD[Rr]\.(?= [A-Z])/g, "Doctor")
+      .replace(/\b(?:Mr\.|MR\.(?= [A-Z]))/g, "Mister")
+      .replace(/\b(?:Ms\.|MS\.(?= [A-Z]))/g, "Miss")
+      .replace(/\b(?:Mrs\.|MRS\.(?= [A-Z]))/g, "Mrs")
+      .replace(/\betc\.(?! [A-Z])/gi, "etc")
+
+      // 5. Normalize casual words
+      .replace(/\b(y)eah?\b/gi, "$1e'a")
+
+      // 5. Handle numbers and currencies
+      .replace(/\d*\.\d+|\b\d{4}s?\b|(?<!:)\b(?:[1-9]|1[0-2]):[0-5]\d\b(?!:)/g, split_num)
+      .replace(/(?<=\d),(?=\d)/g, "")
+      .replace(/[$£]\d+(?:\.\d+)?(?: hundred| thousand| (?:[bm]|tr)illion)*\b|[$£]\d+\.\d\d?\b/gi, flip_money)
+      .replace(/\d*\.\d+/g, point_num)
+      .replace(/(?<=\d)-(?=\d)/g, " to ")
+      .replace(/(?<=\d)S/g, " S")
+
+      // 6. Handle possessives
+      .replace(/(?<=[BCDFGHJ-NP-TV-Z])'?s\b/g, "'S")
+      .replace(/(?<=X')S\b/g, "s")
+
+      // 7. Handle hyphenated words/letters
+      .replace(/(?:[A-Za-z]\.){2,} [a-z]/g, (m) => m.replace(/\./g, "-"))
+      .replace(/(?<=[A-Z])\.(?=[A-Z])/gi, "-")
+
+      // 8. Strip leading and trailing whitespace
+      .trim()
+  );
+}
+
+/**
+ * Escapes regular expression special characters from a string by replacing them with their escaped counterparts.
+ *
+ * @param {string} string The string to escape.
+ * @returns {string} The escaped string.
+ */
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+}
+
+const PUNCTUATION = ';:,.!?¡¿—…"«»“”(){}[]';
+const PUNCTUATION_PATTERN = new RegExp(`(\\s*[${escapeRegExp(PUNCTUATION)}]+\\s*)+`, "g");
+
+export async function phonemize(text, language = "a", norm = true) {
+  // 1. Normalize text
+  if (norm) {
+    text = normalize_text(text);
+  }
+
+  // 2. Split into chunks, to ensure we preserve punctuation
+  const sections = split(text, PUNCTUATION_PATTERN);
+
+  // 3. Convert each section to phonemes
+  const lang = language === "a" ? "en-us" : "en";
+  const ps = (await Promise.all(sections.map(async ({ match, text }) => (match ? text : (await espeakng(text, lang)).join(" "))))).join("");
+
+  // 4. Post-process phonemes
+  let processed = ps
+    // https://en.wiktionary.org/wiki/kokoro#English
+    .replace(/kəkˈoːɹoʊ/g, "kˈoʊkəɹoʊ")
+    .replace(/kəkˈɔːɹəʊ/g, "kˈəʊkəɹəʊ")
+    .replace(/ʲ/g, "j")
+    .replace(/r/g, "ɹ")
+    .replace(/x/g, "k")
+    .replace(/ɬ/g, "l")
+    .replace(/(?<=[a-zɹː])(?=hˈʌndɹɪd)/g, " ")
+    .replace(/ z(?=[;:,.!?¡¿—…"«»“” ]|$)/g, "z");
+
+  // 5. Additional post-processing for American English
+  if (language === "a") {
+    processed = processed.replace(/(?<=nˈaɪn)ti(?!ː)/g, "di");
+  }
+  return processed.trim();
+}

package/speech/utils/semantic-split.js

@@ -0,0 +1,107 @@
+export function splitTextSmart(text, maxChunkLength = 500) {
+  const paragraphChunks = text.split(/\n\s*\n/);
+  const finalChunks = [];
+
+  for (let para of paragraphChunks) {
+    if (para.length <= maxChunkLength) {
+      finalChunks.push(para.trim());
+      continue;
+    }
+
+    const sentenceRegex = /(?<=[.?!])(?=\s+["“”'a-z])/gi;
+    const sentences = para.split(sentenceRegex);
+
+    let chunk = '';
+    for (let sentence of sentences) {
+      sentence = sentence.trim();
+
+      if (sentence.length > maxChunkLength) {
+        // Sentence too long — fallback split
+        const subChunks = splitLongSentence(sentence, maxChunkLength);
+        for (let sub of subChunks) {
+          if ((chunk + ' ' + sub).length > maxChunkLength) {
+            if (chunk) finalChunks.push(chunk.trim());
+            chunk = sub;
+          } else {
+            chunk += (chunk ? ' ' : '') + sub;
+          }
+        }
+        continue;
+      }
+
+      if ((chunk + ' ' + sentence).length > maxChunkLength) {
+        if (chunk) finalChunks.push(chunk.trim());
+        chunk = sentence;
+      } else {
+        chunk += (chunk ? ' ' : '') + sentence;
+      }
+    }
+    if (chunk) finalChunks.push(chunk.trim());
+  }
+
+  return finalChunks;
+}
+
+export function splitLongSentence(sentence, maxLen) {
+  const chunks = [];
+  let current = '';
+
+  const commaParts = sentence.split(/,\s*/);
+  for (let part of commaParts) {
+    if ((current + ', ' + part).length > maxLen) {
+      if (current) chunks.push(current.trim());
+      if (part.length > maxLen) {
+        const words = part.split(/\s+/);
+        let wordChunk = '';
+        for (let word of words) {
+          if ((wordChunk + ' ' + word).length > maxLen) {
+            if (wordChunk) chunks.push(wordChunk.trim());
+            wordChunk = word;
+          } else {
+            wordChunk += (wordChunk ? ' ' : '') + word;
+          }
+        }
+        if (wordChunk) chunks.push(wordChunk.trim());
+        current = '';
+      } else {
+        current = part;
+      }
+    } else {
+      current += (current ? ', ' : '') + part;
+    }
+  }
+  if (current) chunks.push(current.trim());
+
+  return chunks;
+}
+
+
+function splitTextSmartOld(text, maxChunkLength = 500) {
+  const paragraphChunks = text.split(/\n\s*\n/); // Step 1: split on double returns
+  const finalChunks = [];
+
+  for (let para of paragraphChunks) {
+    if (para.length <= maxChunkLength) {
+      finalChunks.push(para.trim());
+      continue;
+    }
+
+    // Step 2: Further split on sentence boundaries if too long
+    const sentenceRegex = /(?<=[.?!])(?=\s+["“”'a-z])/gi;
+    const sentences = para.split(sentenceRegex);
+
+    let chunk = '';
+    for (let sentence of sentences) {
+      sentence = sentence.trim();
+      if ((chunk + ' ' + sentence).length > maxChunkLength) {
+        if (chunk) finalChunks.push(chunk.trim());
+        chunk = sentence;
+      } else {
+        chunk += (chunk ? ' ' : '') + sentence;
+      }
+    }
+    if (chunk) finalChunks.push(chunk.trim());
+  }
+
+  return finalChunks;
+}

package/speech/utils/sentence-detector.js

@@ -0,0 +1,89 @@
+
+/**
+ * Utility functions for detecting sentence boundaries in streaming text
+ */
+
+// These are common sentence ending patterns
+const SENTENCE_PATTERNS = {
+  // Basic sentence endings: period, exclamation, question mark followed by space or end
+  basicEnd: /[.!?][\s"')\]]*($|(?=\s*[A-Z]))/,
+  
+  // Dialog endings: quote followed by punctuation and space or end
+  dialogEnd: /["'][,.!?][\s"')\]]*($|(?=\s*[A-Z]))/,
+  
+  // List item or enumeration endings: semicolon, colon
+  listItemEnd: /[;:][\s]*($|(?=\s*[-•*]))/,
+  
+  // Paragraph breaks: double newline
+  paragraphBreak: /\n\s*\n/,
+  
+  // Force breaks for very long text without clear sentence boundaries
+  longText: (text) => text.length > 150
+};
+
+/**
+ * Determines if a text contains a complete sentence or should be sent for TTS
+ * @param {string} text - The text to check
+ * @param {Object} options - Configuration options
+ * @returns {boolean} - True if the text contains a complete sentence or should be spoken
+ */
+export function isCompleteSentence(text) {
+  if (!text || text.trim().length === 0) {
+    return false;
+  }
+  
+  // Check all patterns
+  return (
+    SENTENCE_PATTERNS.basicEnd.test(text) ||
+    SENTENCE_PATTERNS.dialogEnd.test(text) ||
+    SENTENCE_PATTERNS.listItemEnd.test(text) ||
+    SENTENCE_PATTERNS.paragraphBreak.test(text) ||
+    SENTENCE_PATTERNS.longText(text)
+  );
+}
+
+/**
+ * Process streaming text and return complete sentences
+ * 
+ * @param {string} accumulator - The text accumulated so far
+ * @param {string} newContent - The new content to add
+ * @returns {Object} - Object with processed results:
+ *   - sentences: Array of complete sentences to speak
+ *   - remainder: Remaining text that doesn't form a complete sentence yet
+ */
+export function processStreamingText(accumulator, newContent) {
+  const combinedText = accumulator + newContent;
+  
+  // If the text is empty, just return
+  if (!combinedText || combinedText.trim().length === 0) {
+    return { sentences: [], remainder: '' };
+  }
+  
+  // Split text by common sentence boundaries to check for multiple sentences
+  const parts = combinedText.split(/(?<=[.!?][\s"')\]])/);
+  
+  // If we only have one part and it's not a complete sentence
+  if (parts.length === 1 && !isCompleteSentence(parts[0])) {
+    return { sentences: [], remainder: combinedText };
+  }
+  
+  // Otherwise process all parts
+  const sentences = [];
+  let currentSentence = '';
+  
+  for (let i = 0; i < parts.length; i++) {
+    currentSentence += parts[i];
+    
+    // If this forms a complete sentence or is the last part that should be spoken
+    if (isCompleteSentence(currentSentence) || 
+        (i === parts.length - 1 && SENTENCE_PATTERNS.longText(currentSentence))) {
+      sentences.push(currentSentence.trim());
+      currentSentence = '';
+    }
+  }
+  
+  return { 
+    sentences,
+    remainder: currentSentence
+  };
+}

package/readme.md

@@ -1 +0,0 @@
-![logo](https://i.imgur.com/ypVzqbg.png)