@signalcore/ui 0.1.0 → 1.0.0-beta.1

package/dist/voice/webSpeech.js

@@ -1,258 +0,0 @@
-import { approach, openMeter } from "./meter.js";
-import { pushable } from "./pushable.js";
-import { VoiceError } from "./voice.js";
-/** The recognizer the browser offers, if any. */
-function recognizerOf() {
-    if (typeof window === "undefined")
-        return null;
-    const w = window;
-    return w.SpeechRecognition ?? w.webkitSpeechRecognition ?? null;
-}
-/** The voice the browser speaks with, if it has one. */
-function synthesisOf() {
-    if (typeof window === "undefined" || !("speechSynthesis" in window))
-        return null;
-    return window.speechSynthesis;
-}
-/** `es_ES` (Android) and `es-es` are `es-es`. */
-const tagOf = (lang) => lang.toLowerCase().replace("_", "-");
-/**
- * The voice to speak a language with: one of the exact region (`es-ES`), else one of the same
- * language, the browser's default for it first. Nothing when the browser has none yet (the list
- * loads late); the utterance's `lang` then lets the browser choose.
- */
-export function voiceFor(voices, lang) {
-    const wanted = tagOf(lang);
-    const language = wanted.split("-")[0];
-    const same = voices.filter((voice) => tagOf(voice.lang).split("-")[0] === language);
-    return (same.find((voice) => tagOf(voice.lang) === wanted) ?? same.find((v) => v.default) ?? same[0]);
-}
-/** What the voice's loudness is at least while it speaks, so the orb is alive between words. */
-const SPEAKING_FLOOR = 0.2;
-/** How much of a word's push is left a frame later. */
-const PULSE_DECAY = 0.9;
-/** The usual length of a spoken word, in characters, when the browser does not say. */
-const WORD = 5;
-const round = (level) => Math.round(level * 100) / 100;
-/**
- * The first way to talk and listen: the browser's own speech recognition and speech synthesis,
- * with nothing to install and nothing sent to us. Quality is the browser's (the voice, how well
- * it hears accents), which is why a provider's transport can come behind the same `Voice`.
- *
- * - **Listening.** One recognizer session at a time, continuous with interim results. While it
- *   runs, the microphone's real loudness comes from an `AnalyserNode` (see `meter`).
- * - **Speaking.** `speechSynthesis` with a voice picked for the language. Speaking closes the
- *   microphone first, so the agent does not hear itself.
- * - **The level while speaking is an estimate.** `speechSynthesis` exposes no audio stream to
- *   measure, so the loudness is made up from what it does say: every `boundary` event (a word
- *   starts) pushes it up in proportion to the word, and it falls back between words, over a
- *   floor so a voice whose engine sends no boundaries still moves. It follows the rhythm of the
- *   speech, not its volume.
- */
-export function webSpeechVoice({ lang, meter = true }) {
-    let state = "idle";
-    let level = 0;
-    /** Where the level really is; `level` is this to two decimals, so it does not flood the page. */
-    let exact = 0;
-    /** The push of the last word, 0 to 1, falling each frame. */
-    let pulse = 0;
-    /** The session the microphone belongs to now; a stopped one is let go at once. */
-    let recognizer;
-    let input;
-    /** Ends the speech under way (once); undefined when nothing is being said. */
-    let finishSpeech;
-    let frame;
-    const listeners = new Set();
-    const emit = () => {
-        for (const listener of listeners)
-            listener();
-    };
-    /** One step of the level toward the loudness of the moment; goes on while there is any. */
-    const tick = () => {
-        frame = undefined;
-        const goal = state === "listening"
-            ? (input?.read() ?? 0)
-            : state === "speaking"
-                ? SPEAKING_FLOOR + pulse * (1 - SPEAKING_FLOOR)
-                : 0;
-        pulse *= PULSE_DECAY;
-        exact = approach(exact, goal);
-        // Smoothing only gets near a goal; call it there once it is too close to see.
-        if (Math.abs(goal - exact) < 0.005)
-            exact = goal;
-        const next = round(exact);
-        if (next !== level) {
-            level = next;
-            emit();
-        }
-        if (state === "listening" || state === "speaking")
-            frame = requestAnimationFrame(tick);
-    };
-    const become = (next) => {
-        if (state === next)
-            return;
-        state = next;
-        if (next === "idle") {
-            exact = 0;
-            level = 0;
-        }
-        else {
-            frame ??= requestAnimationFrame(tick);
-        }
-        emit();
-    };
-    const closeMeter = () => {
-        input?.close();
-        input = undefined;
-    };
-    /** Lets go of the microphone now. What was already heard may still arrive, then the end. */
-    const stopListening = () => {
-        const session = recognizer;
-        recognizer = undefined;
-        session?.stop();
-        closeMeter();
-        if (state === "listening")
-            become("idle");
-    };
-    const listen = () => {
-        const Recognition = recognizerOf();
-        // Someone else's session ends first: there is one microphone.
-        stopListening();
-        if (!Recognition) {
-            const unsupported = pushable(() => undefined);
-            unsupported.fail(new VoiceError("unsupported"));
-            return unsupported.iterable;
-        }
-        const session = new Recognition();
-        const heard = pushable(() => {
-            if (recognizer === session)
-                stopListening();
-        });
-        session.lang = lang;
-        session.continuous = true;
-        session.interimResults = true;
-        session.onstart = () => {
-            if (recognizer !== session)
-                return;
-            become("listening");
-            if (!meter)
-                return;
-            void openMeter().then((opened) => {
-                if (!opened)
-                    return;
-                // The session may be over by the time the microphone opens.
-                if (recognizer === session)
-                    input = opened;
-                else
-                    opened.close();
-            });
-        };
-        session.onresult = (event) => {
-            let interim = "";
-            for (let i = event.resultIndex; i < event.results.length; i++) {
-                const result = event.results[i];
-                if (!result)
-                    continue;
-                const text = result[0].transcript.trim();
-                if (!result.isFinal)
-                    interim += result[0].transcript;
-                else if (text !== "")
-                    heard.push({ text, final: true });
-            }
-            if (interim.trim() !== "")
-                heard.push({ text: interim.trim(), final: false });
-        };
-        session.onerror = ({ error }) => {
-            // Silence and a stop we asked for are not failures: the end that follows says so.
-            if (error === "no-speech" || error === "aborted")
-                return;
-            const denied = error === "not-allowed" || error === "service-not-allowed";
-            heard.fail(new VoiceError(denied ? "denied" : "failed", error));
-        };
-        session.onend = () => {
-            // The browser ended it by itself (a long silence); if we stopped it, it is let go already.
-            if (recognizer === session) {
-                recognizer = undefined;
-                closeMeter();
-                if (state === "listening")
-                    become("idle");
-            }
-            heard.end();
-        };
-        recognizer = session;
-        try {
-            session.start();
-        }
-        catch (reason) {
-            recognizer = undefined;
-            heard.fail(new VoiceError("failed", reason instanceof Error ? reason.message : "start"));
-        }
-        return heard.iterable;
-    };
-    const stopSpeaking = () => {
-        if (!finishSpeech)
-            return;
-        synthesisOf()?.cancel();
-        finishSpeech();
-    };
-    const speak = (text) => {
-        const synthesis = synthesisOf();
-        if (!synthesis)
-            return Promise.reject(new VoiceError("unsupported"));
-        stopSpeaking();
-        stopListening();
-        return new Promise((resolve) => {
-            const saying = new SpeechSynthesisUtterance(text);
-            saying.lang = lang;
-            const chosen = voiceFor(synthesis.getVoices(), lang);
-            if (chosen)
-                saying.voice = chosen;
-            saying.onboundary = (event) => {
-                // Not every browser says how long the word is.
-                const length = event.charLength > 0 ? event.charLength : WORD;
-                pulse = Math.min(1, length / WORD);
-            };
-            const done = () => {
-                // Cancelling sends its own end after we already finished; and a newer speech is not ours.
-                if (finishSpeech !== done)
-                    return;
-                finishSpeech = undefined;
-                saying.onend = null;
-                saying.onerror = null;
-                pulse = 0;
-                if (state === "speaking")
-                    become("idle");
-                resolve();
-            };
-            saying.onend = done;
-            saying.onerror = done;
-            // `done` refers to the utterance, so while it is kept the utterance is too: browsers may
-            // drop one nothing refers to before it ends, and then never say that it did.
-            finishSpeech = done;
-            pulse = 0;
-            become("speaking");
-            synthesis.speak(saying);
-        });
-    };
-    return {
-        get supported() {
-            return recognizerOf() !== null && synthesisOf() !== null;
-        },
-        get state() {
-            return state;
-        },
-        get level() {
-            return level;
-        },
-        subscribe: (listener) => {
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-        listen,
-        stopListening,
-        speak,
-        stopSpeaking,
-    };
-}