@bendyline/squisq-editor-react 2.11.16 → 2.11.18

package/dist/{chunk-WDQFWD7Z.js → chunk-UBFNLWCN.js}

@@ -1,10 +1,10 @@
 import {
   MarkdownEscape
-} from "./chunk-ZDWZRVAY.js";
+} from "./chunk-2XXBDECJ.js";
 import {
   markdownToTiptap,
   tiptapToMarkdown
-} from "./chunk-EN5BYZOE.js";
+} from "./chunk-DPAMJV6A.js";
 
 // src/jsonEditor/JsonEditorContext.tsx
 import { createContext, useContext, useEffect, useMemo } from "react";

package/dist/{chunk-27WOOJXR.js → chunk-WKZLBGPX.js}

@@ -1,6 +1,6 @@
 import {
   RecorderModal
-} from "./chunk-4D7QMRTZ.js";
+} from "./chunk-U6NVT3BY.js";
 
 // src/recorder/RecorderButton.tsx
 import { useCallback, useState } from "react";

package/dist/dictationSession-PN3OT5LJ.js

@@ -0,0 +1,521 @@
+import {
+  SPEECH_INPUT_SAMPLE_RATE
+} from "./chunk-DNEVUOBZ.js";
+import {
+  DEFAULT_RECORDER_DEVICE_SETTINGS,
+  buildRecorderAudioConstraints
+} from "./chunk-LRZJD5YD.js";
+import {
+  requestMicStream,
+  resolveFormat,
+  supportsMediaRecorder
+} from "./chunk-DNJ6HOES.js";
+
+// src/speech/microphoneSpeechActivity.ts
+var SAMPLE_INTERVAL_MS = 50;
+function createMicrophoneSpeechActivityMonitor(stream) {
+  if (typeof AudioContext === "undefined") return null;
+  return new WebAudioSpeechActivityMonitor(stream);
+}
+var WebAudioSpeechActivityMonitor = class {
+  constructor(stream) {
+    this.context = null;
+    this.source = null;
+    this.analyser = null;
+    this.timer = null;
+    this.samples = null;
+    this.gate = createSpeechGate();
+    this.stream = stream;
+  }
+  start(onActivity) {
+    if (this.timer !== null) return;
+    const context = new AudioContext();
+    this.context = context;
+    try {
+      const source = context.createMediaStreamSource(this.stream);
+      const analyser = context.createAnalyser();
+      analyser.fftSize = 1024;
+      analyser.smoothingTimeConstant = 0.15;
+      source.connect(analyser);
+      this.source = source;
+      this.analyser = analyser;
+      this.samples = new Float32Array(analyser.fftSize);
+      void context.resume().catch(() => void 0);
+    } catch (caught) {
+      this.stop();
+      throw caught;
+    }
+    this.timer = setInterval(() => {
+      if (!this.analyser || !this.samples) return;
+      this.analyser.getFloatTimeDomainData(this.samples);
+      const level = rootMeanSquare(this.samples);
+      onActivity(this.gate.step(level), level);
+    }, SAMPLE_INTERVAL_MS);
+  }
+  stop() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.source?.disconnect();
+    this.analyser?.disconnect();
+    this.source = null;
+    this.analyser = null;
+    this.samples = null;
+    const context = this.context;
+    this.context = null;
+    if (context) void context.close().catch(() => void 0);
+  }
+};
+function createSpeechGate() {
+  let noiseFloor = 4e-3;
+  let speaking = false;
+  return {
+    step(level) {
+      const openThreshold = Math.max(0.012, noiseFloor * 2.8);
+      const closeThreshold = Math.max(8e-3, noiseFloor * 1.8);
+      speaking = level >= (speaking ? closeThreshold : openThreshold);
+      if (!speaking) {
+        noiseFloor = Math.min(0.03, noiseFloor * 0.95 + level * 0.05);
+      }
+      return speaking;
+    }
+  };
+}
+function rootMeanSquare(samples) {
+  if (samples.length === 0) return 0;
+  let sum = 0;
+  for (const sample of samples) sum += sample * sample;
+  return Math.sqrt(sum / samples.length);
+}
+
+// src/speech/progressiveSpeechToText.ts
+var DEFAULT_SEGMENT_MS = 2500;
+var DEFAULT_SPEECH_PAUSE_MS = 350;
+var DEFAULT_MIN_SEGMENT_MS = 650;
+var DEFAULT_LONG_PAUSE_MS = 1e4;
+var MAX_RECOGNITION_PROMPT_CHARS = 1e3;
+var ProgressiveSpeechToText = class {
+  constructor(options) {
+    this.abortController = new AbortController();
+    this.activityMonitorStarted = false;
+    this.recorder = null;
+    this.chunks = [];
+    this.segmentTimer = null;
+    this.transcriptionQueue = Promise.resolve();
+    this.pending = 0;
+    this.stopPromise = null;
+    this.resolveStop = null;
+    this.finalSegmentRequested = false;
+    this.segmentStartedAt = 0;
+    this.segmentHasSpeech = false;
+    this.currentlySpeaking = false;
+    this.lastSpeechAt = null;
+    this.confirmedSilenceMs = 0;
+    this.recognitionPrompt = "";
+    this.hasTranscript = false;
+    this.longPauseNotified = false;
+    this.disposed = false;
+    this.stream = options.stream;
+    this.mimeType = options.mimeType ?? "";
+    this.segmentMs = options.segmentMs ?? DEFAULT_SEGMENT_MS;
+    this.speechPauseMs = options.speechPauseMs ?? DEFAULT_SPEECH_PAUSE_MS;
+    this.minSegmentMs = options.minSegmentMs ?? DEFAULT_MIN_SEGMENT_MS;
+    this.longPauseMs = options.longPauseMs ?? DEFAULT_LONG_PAUSE_MS;
+    this.activityMonitor = options.activityMonitor === void 0 ? createMicrophoneSpeechActivityMonitor(options.stream) : options.activityMonitor;
+    this.transcribe = options.transcribe;
+    this.onTranscript = options.onTranscript;
+    this.onError = options.onError;
+    this.onLongPause = options.onLongPause;
+    this.onAudioLevel = options.onAudioLevel;
+    this.onPendingChange = options.onPendingChange;
+  }
+  start() {
+    if (this.disposed || this.recorder) return;
+    this.startSegment();
+    this.startActivityMonitor();
+  }
+  /** Stop capture, release the microphone, and wait for queued STT work. */
+  stop() {
+    if (this.stopPromise) return this.stopPromise;
+    this.finalSegmentRequested = true;
+    this.stopActivityMonitor();
+    this.clearSegmentTimer();
+    this.stopPromise = new Promise((resolve) => {
+      this.resolveStop = resolve;
+    });
+    const recorder = this.recorder;
+    if (recorder?.state === "recording") {
+      recorder.stop();
+    } else if (!recorder) {
+      void this.finish();
+    }
+    return this.stopPromise;
+  }
+  /** Tear down without delivering any more transcription callbacks. */
+  cancel() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.abortController.abort();
+    this.stopActivityMonitor();
+    this.clearSegmentTimer();
+    const recorder = this.recorder;
+    this.recorder = null;
+    if (recorder) {
+      recorder.ondataavailable = null;
+      recorder.onstop = null;
+      recorder.onerror = null;
+      if (recorder.state !== "inactive") {
+        try {
+          recorder.stop();
+        } catch {
+        }
+      }
+    }
+    this.releaseStream();
+    this.resolveStop?.();
+    this.resolveStop = null;
+  }
+  startSegment() {
+    if (this.disposed || this.finalSegmentRequested) return;
+    const recorderOptions = this.mimeType ? { mimeType: this.mimeType } : void 0;
+    const recorder = new MediaRecorder(this.stream, recorderOptions);
+    this.recorder = recorder;
+    this.chunks = [];
+    this.segmentStartedAt = Date.now();
+    this.segmentHasSpeech = this.currentlySpeaking;
+    recorder.ondataavailable = (event) => {
+      if (!this.disposed && event.data.size > 0) this.chunks.push(event.data);
+    };
+    recorder.onerror = (event) => {
+      const error = event.error;
+      this.onError(error ?? new Error("Microphone recording failed."));
+      this.finalSegmentRequested = true;
+      this.clearSegmentTimer();
+    };
+    recorder.onstop = () => {
+      if (this.disposed || this.recorder !== recorder) return;
+      this.recorder = null;
+      const type = recorder.mimeType || this.mimeType || "audio/webm";
+      const blob = new Blob(this.chunks, { type });
+      const capturedMs = Math.max(0, Date.now() - this.segmentStartedAt);
+      this.chunks = [];
+      if (!this.finalSegmentRequested) this.startSegment();
+      if (blob.size > 0) this.enqueueTranscription(blob, type, capturedMs);
+      if (this.finalSegmentRequested) void this.finish();
+    };
+    recorder.start();
+    this.segmentTimer = setTimeout(() => {
+      this.segmentTimer = null;
+      if (!this.disposed && !this.finalSegmentRequested && recorder.state === "recording") {
+        recorder.stop();
+      }
+    }, this.segmentMs);
+  }
+  startActivityMonitor() {
+    if (!this.activityMonitor || this.activityMonitorStarted) return;
+    try {
+      this.activityMonitor.start((speaking, level) => {
+        this.onAudioLevel?.(level);
+        this.onSpeechActivity(speaking);
+      });
+      this.activityMonitorStarted = true;
+    } catch {
+      this.activityMonitor.stop();
+      this.activityMonitor = null;
+    }
+  }
+  stopActivityMonitor() {
+    this.activityMonitor?.stop();
+  }
+  onSpeechActivity(speaking) {
+    if (this.disposed || this.finalSegmentRequested) return;
+    const now = Date.now();
+    this.currentlySpeaking = speaking;
+    if (speaking) {
+      this.segmentHasSpeech = true;
+      this.lastSpeechAt = now;
+      this.longPauseNotified = false;
+      return;
+    }
+    if (this.lastSpeechAt === null) return;
+    const silenceMs = now - this.lastSpeechAt;
+    if (this.segmentHasSpeech && now - this.segmentStartedAt >= this.minSegmentMs && silenceMs >= this.speechPauseMs) {
+      this.flushCurrentSegment();
+    }
+  }
+  flushCurrentSegment() {
+    const recorder = this.recorder;
+    if (!recorder || recorder.state !== "recording") return;
+    this.clearSegmentTimer();
+    recorder.stop();
+  }
+  setPending(next) {
+    this.pending = next;
+    if (!this.disposed) this.onPendingChange?.(next);
+  }
+  enqueueTranscription(blob, mimeType, capturedMs) {
+    this.setPending(this.pending + 1);
+    this.transcriptionQueue = this.transcriptionQueue.then(async () => {
+      if (this.disposed) return;
+      try {
+        const text = normalizeSpeechTranscript(
+          await this.transcribe(
+            blob,
+            mimeType,
+            this.abortController.signal,
+            this.recognitionPrompt
+          )
+        );
+        if (this.disposed) return;
+        if (text) {
+          this.confirmedSilenceMs = 0;
+          this.hasTranscript = true;
+          this.longPauseNotified = false;
+          this.recognitionPrompt = extendRecognitionPrompt(this.recognitionPrompt, text);
+          this.onTranscript(text);
+          return;
+        }
+        this.confirmedSilenceMs += capturedMs;
+        if (!this.longPauseNotified && this.onLongPause && this.confirmedSilenceMs >= this.longPauseMs) {
+          this.longPauseNotified = true;
+          this.onLongPause(this.hasTranscript);
+        }
+      } catch (caught) {
+        if (this.disposed || this.abortController.signal.aborted) return;
+        this.onError(caught instanceof Error ? caught : new Error(String(caught)));
+      } finally {
+        this.setPending(Math.max(0, this.pending - 1));
+      }
+    });
+  }
+  async finish() {
+    this.clearSegmentTimer();
+    this.stopActivityMonitor();
+    this.releaseStream();
+    await this.transcriptionQueue;
+    if (this.disposed) return;
+    this.disposed = true;
+    this.resolveStop?.();
+    this.resolveStop = null;
+  }
+  clearSegmentTimer() {
+    if (this.segmentTimer === null) return;
+    clearTimeout(this.segmentTimer);
+    this.segmentTimer = null;
+  }
+  releaseStream() {
+    for (const track of this.stream.getTracks()) track.stop();
+  }
+};
+function normalizeSpeechTranscript(value) {
+  const text = value.trim();
+  return /^\[\s*BLANK_AUDIO\s*\]$/i.test(text) ? "" : text;
+}
+function extendRecognitionPrompt(previous, transcript) {
+  const combined = `${previous.trim()} ${transcript.trim()}`.trim();
+  if (combined.length <= MAX_RECOGNITION_PROMPT_CHARS) return combined;
+  const tail = combined.slice(-MAX_RECOGNITION_PROMPT_CHARS);
+  const firstWhitespace = tail.search(/\s/);
+  return (firstWhitespace >= 0 ? tail.slice(firstWhitespace + 1) : tail).trim();
+}
+
+// src/speech/speechAudioWav.ts
+async function microphoneTakeAsWav(blob) {
+  const encoded = await blobBytes(blob);
+  let audio;
+  try {
+    audio = await decodeAt16k(encoded);
+  } catch (caught) {
+    const detail = caught instanceof Error && caught.message ? ` (${caught.message})` : "";
+    throw new Error(`This recording could not be prepared for speech recognition${detail}`);
+  }
+  const channels = Array.from(
+    { length: audio.numberOfChannels },
+    (_, index) => audio.getChannelData(index)
+  );
+  const mono = downmixToMono(channels);
+  const samples = audio.sampleRate === SPEECH_INPUT_SAMPLE_RATE ? mono : resampleLinear(mono, audio.sampleRate, SPEECH_INPUT_SAMPLE_RATE);
+  return encodeMonoPcm16Wav([samples], SPEECH_INPUT_SAMPLE_RATE).buffer;
+}
+function blobBytes(blob) {
+  if (typeof blob.arrayBuffer === "function") return blob.arrayBuffer();
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const result = reader.result;
+      if (result instanceof ArrayBuffer) resolve(result);
+      else reject(new Error("The recording could not be read."));
+    };
+    reader.onerror = () => reject(reader.error ?? new Error("The recording could not be read."));
+    reader.readAsArrayBuffer(blob);
+  });
+}
+async function decodeAt16k(encoded) {
+  if (typeof OfflineAudioContext !== "undefined") {
+    let offline = null;
+    try {
+      offline = new OfflineAudioContext(1, 1, SPEECH_INPUT_SAMPLE_RATE);
+    } catch {
+      offline = null;
+    }
+    if (offline) return offline.decodeAudioData(encoded);
+  }
+  if (typeof AudioContext === "undefined") {
+    throw new Error("Web Audio is unavailable");
+  }
+  const context = new AudioContext();
+  try {
+    return await context.decodeAudioData(encoded);
+  } finally {
+    await context.close().catch(() => void 0);
+  }
+}
+function downmixToMono(channels) {
+  const sampleCount = channels[0]?.length ?? 0;
+  if (channels.length === 0 || sampleCount === 0) {
+    throw new Error("The microphone recording was empty.");
+  }
+  if (channels.length === 1) return channels[0];
+  if (channels.some((channel) => channel.length !== sampleCount)) {
+    throw new Error("The microphone recording channels have different lengths.");
+  }
+  const mono = new Float32Array(sampleCount);
+  for (let index = 0; index < sampleCount; index += 1) {
+    let sum = 0;
+    for (const channel of channels) sum += channel[index] ?? 0;
+    mono[index] = sum / channels.length;
+  }
+  return mono;
+}
+function resampleLinear(samples, fromRate, toRate) {
+  if (!Number.isFinite(fromRate) || fromRate <= 0 || !Number.isFinite(toRate) || toRate <= 0) {
+    throw new Error("The microphone recording has an invalid sample rate.");
+  }
+  if (fromRate === toRate) return samples;
+  const outputLength = Math.max(1, Math.round(samples.length * toRate / fromRate));
+  const output = new Float32Array(outputLength);
+  const step = fromRate / toRate;
+  for (let index = 0; index < outputLength; index += 1) {
+    const position = index * step;
+    const left = Math.floor(position);
+    const right = Math.min(left + 1, samples.length - 1);
+    const fraction = position - left;
+    const a = samples[Math.min(left, samples.length - 1)] ?? 0;
+    const b = samples[right] ?? 0;
+    output[index] = a + (b - a) * fraction;
+  }
+  return output;
+}
+function encodeMonoPcm16Wav(channels, sampleRate) {
+  const sampleCount = channels[0]?.length ?? 0;
+  if (channels.length === 0 || sampleCount === 0) {
+    throw new Error("The microphone recording was empty.");
+  }
+  if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+    throw new Error("The microphone recording has an invalid sample rate.");
+  }
+  if (channels.some((channel) => channel.length !== sampleCount)) {
+    throw new Error("The microphone recording channels have different lengths.");
+  }
+  const rate = Math.round(sampleRate);
+  const bytesPerSample = 2;
+  const dataBytes = sampleCount * bytesPerSample;
+  const buffer = new ArrayBuffer(44 + dataBytes);
+  const view = new DataView(buffer);
+  writeAscii(view, 0, "RIFF");
+  view.setUint32(4, 36 + dataBytes, true);
+  writeAscii(view, 8, "WAVE");
+  writeAscii(view, 12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, 1, true);
+  view.setUint32(24, rate, true);
+  view.setUint32(28, rate * bytesPerSample, true);
+  view.setUint16(32, bytesPerSample, true);
+  view.setUint16(34, 16, true);
+  writeAscii(view, 36, "data");
+  view.setUint32(40, dataBytes, true);
+  for (let index = 0; index < sampleCount; index += 1) {
+    let mono = 0;
+    for (const channel of channels) mono += channel[index] ?? 0;
+    mono = Math.max(-1, Math.min(1, mono / channels.length));
+    const pcm = mono < 0 ? Math.round(mono * 32768) : Math.round(mono * 32767);
+    view.setInt16(44 + index * bytesPerSample, pcm, true);
+  }
+  return new Uint8Array(buffer);
+}
+function writeAscii(view, offset, value) {
+  for (let index = 0; index < value.length; index += 1) {
+    view.setUint8(offset + index, value.charCodeAt(index));
+  }
+}
+
+// src/speech/dictationSession.ts
+function dictationAudioConstraints(settings = DEFAULT_RECORDER_DEVICE_SETTINGS) {
+  return {
+    ...buildRecorderAudioConstraints(settings),
+    echoCancellation: true,
+    noiseSuppression: true,
+    autoGainControl: true
+  };
+}
+function abortError() {
+  const error = new Error("Dictation was cancelled.");
+  error.name = "AbortError";
+  return error;
+}
+async function startDictationSession(options) {
+  const { provider, signal } = options;
+  if (!supportsMediaRecorder()) {
+    throw new Error("MediaRecorder is not defined in this environment.");
+  }
+  const ready = provider.prepare ? Promise.resolve().then(() => provider.prepare?.(signal)) : Promise.resolve();
+  ready.catch(() => void 0);
+  const stream = await requestMicStream(dictationAudioConstraints(options.deviceSettings));
+  if (signal.aborted) {
+    for (const track of stream.getTracks()) track.stop();
+    throw abortError();
+  }
+  const format = resolveFormat("audio");
+  const engine = new ProgressiveSpeechToText({
+    stream,
+    ...format.mimeType ? { mimeType: format.mimeType } : {},
+    transcribe: async (blob, _mimeType, takeSignal, prompt) => {
+      await ready;
+      const wav = await microphoneTakeAsWav(blob);
+      const result = await provider.transcribe(wav, {
+        signal: takeSignal,
+        ...prompt ? { prompt } : {}
+      });
+      return typeof result?.text === "string" ? result.text : "";
+    },
+    onTranscript: options.onTranscript,
+    onAudioLevel: options.onAudioLevel,
+    onPendingChange: options.onPendingChange,
+    onLongPause: options.onLongPause,
+    onError: (error) => {
+      engine.cancel();
+      options.onError(error);
+    }
+  });
+  ready.catch((caught) => {
+    if (signal.aborted) return;
+    engine.cancel();
+    options.onError(caught instanceof Error ? caught : new Error(String(caught)));
+  });
+  const onAbort = () => engine.cancel();
+  signal.addEventListener("abort", onAbort, { once: true });
+  engine.start();
+  return {
+    stop: () => engine.stop(),
+    cancel: () => {
+      signal.removeEventListener("abort", onAbort);
+      engine.cancel();
+    }
+  };
+}
+export {
+  dictationAudioConstraints,
+  startDictationSession
+};