@wow-two-beta/ui-vue 0.0.2

package/dist/foundation/speech/index.js

@@ -0,0 +1,573 @@
+import { t as toError } from "../../chunks/ToError-CyTBsmLO.js";
+import { shallowRef, onMounted, onScopeDispose, watch, toValue } from "vue";
+import { u as useLocale } from "../../chunks/LocaleContext-B3UXrI6p.js";
+function speechSynthesisWith(member) {
+  try {
+    const candidate = globalThis.speechSynthesis;
+    if (typeof candidate !== "object" || candidate === null) return void 0;
+    const api = candidate;
+    if (typeof api[member] !== "function") return void 0;
+    return api;
+  } catch {
+    return void 0;
+  }
+}
+function utteranceConstructor() {
+  try {
+    const candidate = globalThis.SpeechSynthesisUtterance;
+    return typeof candidate === "function" ? candidate : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function speechRecognitionConstructor() {
+  try {
+    const scope = globalThis;
+    const candidate = scope.SpeechRecognition ?? scope.webkitSpeechRecognition;
+    return typeof candidate === "function" ? candidate : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function canSpeak() {
+  return speechSynthesisWith("speak") !== void 0 && utteranceConstructor() !== void 0;
+}
+function canRecognizeSpeech() {
+  return speechRecognitionConstructor() !== void 0;
+}
+function getSpeechSupport() {
+  return { synthesis: canSpeak(), recognition: canRecognizeSpeech() };
+}
+const CancellationCodes = /* @__PURE__ */ new Set(["canceled", "cancelled", "interrupted"]);
+function errorCodeOf(event) {
+  if (event === null || typeof event !== "object" && typeof event !== "function") return void 0;
+  try {
+    const code = event["error"];
+    return typeof code === "string" ? code : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function toSpeakFailure(event) {
+  const code = errorCodeOf(event);
+  if (code !== void 0 && CancellationCodes.has(code)) return { status: "cancelled" };
+  const error = new Error(`speech synthesis failed: ${code ?? "unknown"}`, { cause: event });
+  return { status: "failed", error };
+}
+let cancels = 0;
+function cancelGeneration() {
+  return cancels;
+}
+function cancelSpeech() {
+  const synth = speechSynthesisWith("cancel");
+  if (synth === void 0) return false;
+  cancels += 1;
+  try {
+    synth.cancel();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pauseSpeech() {
+  const synth = speechSynthesisWith("pause");
+  if (synth === void 0) return false;
+  try {
+    synth.pause();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resumeSpeech() {
+  const synth = speechSynthesisWith("resume");
+  if (synth === void 0) return false;
+  try {
+    synth.resume();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isSpeaking() {
+  const synth = speechSynthesisWith("speak");
+  if (synth === void 0) return false;
+  try {
+    return synth.speaking === true;
+  } catch {
+    return false;
+  }
+}
+function isSpeechPaused() {
+  const synth = speechSynthesisWith("speak");
+  if (synth === void 0) return false;
+  try {
+    return synth.paused === true;
+  } catch {
+    return false;
+  }
+}
+const inFlight = /* @__PURE__ */ new Set();
+function clamp(value, min, max) {
+  if (value === void 0 || !Number.isFinite(value)) return void 0;
+  return Math.min(max, Math.max(min, value));
+}
+function configure(utterance, options) {
+  if (options === void 0) return;
+  try {
+    if (options.voice !== void 0) utterance.voice = options.voice;
+    if (options.lang !== void 0) utterance.lang = options.lang;
+    const rate = clamp(options.rate, 0.1, 10);
+    if (rate !== void 0) utterance.rate = rate;
+    const pitch = clamp(options.pitch, 0, 2);
+    if (pitch !== void 0) utterance.pitch = pitch;
+    const volume = clamp(options.volume, 0, 1);
+    if (volume !== void 0) utterance.volume = volume;
+  } catch {
+  }
+}
+function toHandle(spoken, controls) {
+  return {
+    spoken,
+    cancel: controls.cancel,
+    pause: controls.pause,
+    resume: controls.resume,
+    then: (onFulfilled, onRejected) => spoken.then(onFulfilled, onRejected)
+  };
+}
+function inertControls() {
+  const noop = () => {
+  };
+  return { cancel: noop, pause: noop, resume: noop };
+}
+function speak(text, options) {
+  const synth = speechSynthesisWith("speak");
+  const Utterance = utteranceConstructor();
+  if (synth === void 0 || Utterance === void 0) {
+    return toHandle(Promise.resolve({ status: "unsupported" }), inertControls());
+  }
+  let settle;
+  const spoken = new Promise((resolve) => {
+    settle = resolve;
+  });
+  let settled = false;
+  let utterance;
+  const finish = (result) => {
+    if (settled) return;
+    settled = true;
+    if (utterance !== void 0) inFlight.delete(utterance);
+    settle(result);
+  };
+  try {
+    utterance = new Utterance(text);
+  } catch (cause) {
+    return toHandle(Promise.resolve({ status: "failed", error: toError(cause) }), inertControls());
+  }
+  configure(utterance, options);
+  const generation = cancelGeneration();
+  const wasCancelled = () => cancelGeneration() !== generation;
+  utterance.onend = () => {
+    finish(wasCancelled() ? { status: "cancelled" } : { status: "spoken" });
+  };
+  utterance.onerror = (event) => {
+    finish(wasCancelled() ? { status: "cancelled" } : toSpeakFailure(event));
+  };
+  inFlight.add(utterance);
+  try {
+    synth.speak(utterance);
+  } catch (cause) {
+    finish({ status: "failed", error: toError(cause) });
+  }
+  return toHandle(spoken, {
+    cancel: () => {
+      cancelSpeech();
+    },
+    pause: () => {
+      pauseSpeech();
+    },
+    resume: () => {
+      resumeSpeech();
+    }
+  });
+}
+const DefaultVoicesTimeoutMs = 1e3;
+const NoVoices$1 = [];
+function readVoices(synth) {
+  try {
+    const voices = synth.getVoices();
+    return Array.isArray(voices) ? voices : NoVoices$1;
+  } catch {
+    return NoVoices$1;
+  }
+}
+function listVoicesSync() {
+  const synth = speechSynthesisWith("getVoices");
+  return synth === void 0 ? NoVoices$1 : readVoices(synth);
+}
+function onVoicesChanged(listener) {
+  const noop = () => {
+  };
+  const synth = speechSynthesisWith("getVoices");
+  if (synth === void 0) return noop;
+  try {
+    if (typeof synth.addEventListener === "function") {
+      synth.addEventListener("voiceschanged", listener);
+      return () => {
+        try {
+          synth.removeEventListener("voiceschanged", listener);
+        } catch {
+        }
+      };
+    }
+    const previous = synth.onvoiceschanged;
+    synth.onvoiceschanged = function(event) {
+      if (typeof previous === "function") previous.call(this, event);
+      listener();
+    };
+    return () => {
+      synth.onvoiceschanged = previous;
+    };
+  } catch {
+    return noop;
+  }
+}
+function listVoices(options) {
+  const synth = speechSynthesisWith("getVoices");
+  if (synth === void 0) return Promise.resolve(NoVoices$1);
+  const immediate = readVoices(synth);
+  if (immediate.length > 0) return Promise.resolve(immediate);
+  return new Promise((resolve) => {
+    let settled = false;
+    const settle = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      unsubscribe();
+      resolve(readVoices(synth));
+    };
+    const unsubscribe = onVoicesChanged(() => {
+      if (readVoices(synth).length === 0) return;
+      settle();
+    });
+    const timer = setTimeout(settle, options?.timeoutMs ?? DefaultVoicesTimeoutMs);
+  });
+}
+function normalizeTag(tag) {
+  return tag.trim().toLowerCase().replace(/_/g, "-");
+}
+function primarySubtag(tag) {
+  return normalizeTag(tag).split("-")[0] ?? "";
+}
+function defaultFirst(voices) {
+  return [...voices].sort((left, right) => Number(right.default === true) - Number(left.default === true));
+}
+function voicesForLang(voices, lang) {
+  const wanted = normalizeTag(lang);
+  if (wanted === "") return NoVoices$1;
+  const wantedPrimary = primarySubtag(wanted);
+  const exact = [];
+  const related = [];
+  for (const voice of voices) {
+    const tag = typeof voice.lang === "string" ? normalizeTag(voice.lang) : "";
+    if (tag === "") continue;
+    if (tag === wanted) exact.push(voice);
+    else if (primarySubtag(tag) === wantedPrimary) related.push(voice);
+  }
+  return [...defaultFirst(exact), ...defaultFirst(related)];
+}
+async function findVoice(lang, options) {
+  const voices = await listVoices(options);
+  return voicesForLang(voices, lang).at(0);
+}
+const NoVoices = [];
+function useSpeechSynthesis() {
+  const { locale } = useLocale();
+  const voices = shallowRef(NoVoices);
+  const speaking = shallowRef(false);
+  const paused = shallowRef(false);
+  const supported = shallowRef(false);
+  let disposed = false;
+  let inFlight2 = 0;
+  const speak$1 = async (text, options) => {
+    inFlight2 += 1;
+    if (!disposed) {
+      speaking.value = true;
+      paused.value = false;
+    }
+    const result = await speak(text, { ...options, lang: options?.lang ?? locale.value });
+    inFlight2 = Math.max(0, inFlight2 - 1);
+    if (!disposed && inFlight2 === 0) {
+      speaking.value = false;
+      paused.value = false;
+    }
+    return result;
+  };
+  const cancel = () => {
+    cancelSpeech();
+    if (!disposed) paused.value = false;
+  };
+  const pause = () => {
+    if (pauseSpeech() && !disposed) paused.value = true;
+  };
+  const resume = () => {
+    if (resumeSpeech() && !disposed) paused.value = false;
+  };
+  let unsubscribe;
+  onMounted(() => {
+    supported.value = canSpeak();
+    const apply = (next) => {
+      if (!disposed) voices.value = next;
+    };
+    void listVoices().then(apply);
+    unsubscribe = onVoicesChanged(() => {
+      apply(listVoicesSync());
+    });
+  });
+  onScopeDispose(() => {
+    disposed = true;
+    unsubscribe?.();
+    unsubscribe = void 0;
+    if (inFlight2 > 0) cancelSpeech();
+  });
+  return { supported, voices, speaking, paused, speak: speak$1, cancel, pause, resume };
+}
+const StatusByCode = {
+  "not-allowed": "denied",
+  "service-not-allowed": "denied",
+  "audio-capture": "unavailable",
+  "no-speech": "no-speech",
+  network: "network",
+  aborted: "aborted",
+  "language-not-supported": "language-unsupported"
+};
+function stringMember(value, key) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return void 0;
+  try {
+    const member = value[key];
+    return typeof member === "string" ? member : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function toSpeechRecognitionFailure(event) {
+  const code = stringMember(event, "error");
+  const detail = stringMember(event, "message");
+  const status = code === void 0 ? "failed" : StatusByCode[code] ?? "failed";
+  const message = detail === void 0 || detail === "" ? `speech recognition error: ${code ?? "unknown"}` : `speech recognition error: ${code ?? "unknown"} — ${detail}`;
+  return { status, error: new Error(message, { cause: event }) };
+}
+function report(callback, argument) {
+  if (callback === void 0) return;
+  try {
+    callback(argument);
+  } catch {
+  }
+}
+function inertRecognizer(start) {
+  const noop = () => {
+  };
+  return { supported: false, listening: false, start, stop: noop, abort: noop };
+}
+function createSpeechRecognizer(options) {
+  const Recognition = speechRecognitionConstructor();
+  if (Recognition === void 0) return inertRecognizer(() => ({ status: "unsupported" }));
+  let instance;
+  try {
+    instance = new Recognition();
+  } catch (cause) {
+    const error = toError(cause);
+    return inertRecognizer(() => ({ status: "failed", error }));
+  }
+  try {
+    if (options?.lang !== void 0) instance.lang = options.lang;
+    instance.continuous = options?.continuous ?? false;
+    instance.interimResults = options?.interimResults ?? false;
+    if (options?.maxAlternatives !== void 0) instance.maxAlternatives = options.maxAlternatives;
+  } catch {
+  }
+  let state = "idle";
+  const emitResults = (event) => {
+    try {
+      const results = event.results;
+      const length = typeof results?.length === "number" ? results.length : 0;
+      const first = Number.isInteger(event.resultIndex) ? Math.max(0, event.resultIndex) : 0;
+      let interim = "";
+      for (let index = first; index < length; index += 1) {
+        const result = results[index];
+        if (result === void 0) continue;
+        const alternative = result[0];
+        if (alternative === void 0) continue;
+        const transcript = typeof alternative.transcript === "string" ? alternative.transcript : "";
+        const confidence = typeof alternative.confidence === "number" ? alternative.confidence : 0;
+        const isFinal = result.isFinal === true;
+        report(options?.onResult, { transcript, isFinal, confidence });
+        if (isFinal) report(options?.onFinal, transcript);
+        else if (transcript !== "") interim = interim === "" ? transcript : `${interim} ${transcript}`;
+      }
+      if (interim !== "") report(options?.onInterim, interim);
+    } catch {
+    }
+  };
+  try {
+    instance.onstart = () => {
+      state = "listening";
+      report(options?.onStart, void 0);
+    };
+    instance.onend = () => {
+      state = "idle";
+      report(options?.onEnd, void 0);
+    };
+    instance.onerror = (event) => {
+      report(options?.onError, toSpeechRecognitionFailure(event));
+    };
+    instance.onresult = emitResults;
+  } catch {
+  }
+  return {
+    supported: true,
+    get listening() {
+      return state === "listening";
+    },
+    start: () => {
+      if (state !== "idle") return { status: "already-started" };
+      try {
+        instance.start();
+        state = "starting";
+        return { status: "started" };
+      } catch (cause) {
+        state = "idle";
+        return { status: "failed", error: toError(cause) };
+      }
+    },
+    stop: () => {
+      if (state === "idle") return;
+      try {
+        instance.stop();
+      } catch {
+      }
+    },
+    abort: () => {
+      if (state === "idle") return;
+      state = "idle";
+      try {
+        instance.abort();
+      } catch {
+      }
+    }
+  };
+}
+function appendPhrase(previous, phrase) {
+  const next = phrase.trim();
+  if (next === "") return previous;
+  return previous === "" ? next : `${previous} ${next}`;
+}
+function useSpeechRecognition(options) {
+  const { locale } = useLocale();
+  const transcript = shallowRef("");
+  const interimTranscript = shallowRef("");
+  const listening = shallowRef(false);
+  const error = shallowRef(null);
+  const supported = shallowRef(false);
+  let disposed = false;
+  let recognizer = null;
+  function getRecognizer() {
+    if (recognizer !== null) return recognizer;
+    const created = createSpeechRecognizer({
+      lang: toValue(options)?.lang ?? locale.value,
+      continuous: toValue(options)?.continuous,
+      // Interim results default ON here, unlike the bare recognizer: a composable exposing `interimTranscript`
+      // that is permanently empty is a worse default than one that costs a few extra updates.
+      interimResults: toValue(options)?.interimResults ?? true,
+      maxAlternatives: toValue(options)?.maxAlternatives,
+      onStart: () => {
+        if (!disposed) {
+          listening.value = true;
+          error.value = null;
+        }
+        toValue(options)?.onStart?.();
+      },
+      onEnd: () => {
+        if (!disposed) {
+          listening.value = false;
+          interimTranscript.value = "";
+        }
+        toValue(options)?.onEnd?.();
+      },
+      onError: (failure) => {
+        if (!disposed) error.value = failure;
+        toValue(options)?.onError?.(failure);
+      },
+      onResult: (result) => {
+        if (!disposed) {
+          if (result.isFinal) {
+            transcript.value = appendPhrase(transcript.value, result.transcript);
+            interimTranscript.value = "";
+          } else {
+            interimTranscript.value = result.transcript;
+          }
+        }
+        toValue(options)?.onResult?.(result);
+      },
+      onFinal: (text) => {
+        toValue(options)?.onFinal?.(text);
+      },
+      onInterim: (text) => {
+        toValue(options)?.onInterim?.(text);
+      }
+    });
+    recognizer = created;
+    return created;
+  }
+  const start = () => getRecognizer().start();
+  const stop = () => {
+    recognizer?.stop();
+  };
+  const abort = () => {
+    recognizer?.abort();
+  };
+  const reset = () => {
+    transcript.value = "";
+    interimTranscript.value = "";
+    error.value = null;
+  };
+  onMounted(() => {
+    supported.value = canRecognizeSpeech();
+  });
+  watch(
+    [
+      () => toValue(options)?.lang ?? locale.value,
+      () => toValue(options)?.continuous ?? false,
+      () => toValue(options)?.interimResults ?? true
+    ],
+    () => {
+      recognizer?.abort();
+      recognizer = null;
+    }
+  );
+  onScopeDispose(() => {
+    disposed = true;
+    recognizer?.abort();
+    recognizer = null;
+  });
+  return { supported, listening, transcript, interimTranscript, error, start, stop, abort, reset };
+}
+export {
+  DefaultVoicesTimeoutMs,
+  canRecognizeSpeech,
+  canSpeak,
+  cancelSpeech,
+  createSpeechRecognizer,
+  findVoice,
+  getSpeechSupport,
+  isSpeaking,
+  isSpeechPaused,
+  listVoices,
+  listVoicesSync,
+  pauseSpeech,
+  resumeSpeech,
+  speak,
+  useSpeechRecognition,
+  useSpeechSynthesis,
+  voicesForLang
+};
+//# sourceMappingURL=index.js.map