@bendyline/docblocks-react 2.6.1 → 2.7.0

package/dist/chunk-I44HKDQX.js

@@ -0,0 +1,314 @@
+// src/Speech/useGenerateNarration.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useEditorContext } from "@bendyline/squisq-editor-react";
+import {
+  buildNarrationSavePlan,
+  executeNarrationSave
+} from "@bendyline/squisq-editor-react/teleprompter";
+
+// src/Speech/speakable-text.ts
+var MAX_SEGMENT_CHARACTERS = 4e3;
+var FENCE = /^(?<indent> {0,3})(?<marker>`{3,}|~{3,})[^\n]*\n[\s\S]*?^\k<indent>\k<marker>[ \t]*$/gmu;
+function stripFencedCode(markdown) {
+  return markdown.replace(FENCE, "");
+}
+function ensureSentenceEnd(text) {
+  const trimmed = text.trimEnd();
+  if (!trimmed) return trimmed;
+  return /[.!?…:;]["'”’)\]]*$/u.test(trimmed) ? trimmed : `${trimmed}.`;
+}
+function splitLongText(text, start, max = MAX_SEGMENT_CHARACTERS) {
+  const pieces = [];
+  let offset = 0;
+  while (offset < text.length) {
+    let end = Math.min(text.length, offset + max);
+    if (end < text.length) {
+      const window = text.slice(offset, end);
+      const sentence = Math.max(
+        window.lastIndexOf(". "),
+        window.lastIndexOf("! "),
+        window.lastIndexOf("? "),
+        window.lastIndexOf("\n")
+      );
+      const space = window.lastIndexOf(" ");
+      const cut = sentence > max / 4 ? sentence + 1 : space > max / 4 ? space : window.length;
+      end = offset + cut;
+    }
+    const piece = text.slice(offset, end);
+    const leading = piece.length - piece.trimStart().length;
+    const trimmed = piece.trim();
+    if (trimmed) {
+      pieces.push({
+        text: trimmed,
+        start: start + offset + leading,
+        end: start + offset + leading + trimmed.length
+      });
+    }
+    offset = end;
+  }
+  return pieces;
+}
+async function planSpeech(markdown) {
+  const [{ parseMarkdown }, { markdownToDoc }, { buildNarrationScript }] = await Promise.all([
+    import("@bendyline/squisq/markdown"),
+    import("@bendyline/squisq/doc"),
+    import("@bendyline/squisq/narration")
+  ]);
+  const doc = markdownToDoc(parseMarkdown(stripFencedCode(markdown)));
+  const script = buildNarrationScript(doc);
+  const segments = [];
+  for (const block of script.blocks) {
+    const text = script.sourceText.slice(block.charStart, block.charEnd);
+    let bodyStart = block.charStart;
+    const heading = block.heading?.trim();
+    if (heading && text.startsWith(heading)) {
+      segments.push({
+        text: ensureSentenceEnd(heading),
+        blockId: block.blockId,
+        kind: "heading",
+        sourceStart: block.charStart,
+        sourceEnd: block.charStart + heading.length
+      });
+      bodyStart = block.charStart + heading.length;
+    }
+    const lines = /[^\n]+/gu;
+    const body = script.sourceText.slice(bodyStart, block.charEnd);
+    for (const line of body.matchAll(lines)) {
+      for (const piece of splitLongText(line[0], bodyStart + line.index)) {
+        segments.push({
+          text: ensureSentenceEnd(piece.text),
+          blockId: block.blockId,
+          kind: "body",
+          sourceStart: piece.start,
+          sourceEnd: piece.end
+        });
+      }
+    }
+  }
+  return { sourceText: script.sourceText, segments, doc, script };
+}
+
+// src/Speech/tts-narration.ts
+function spokenSpanForChunk(chunk, segment, elapsed) {
+  const length = segment.sourceEnd - segment.sourceStart;
+  const sourceOffset = (offset) => segment.sourceStart + Math.min(offset, length);
+  return {
+    sourceStart: sourceOffset(chunk.textStart),
+    sourceEnd: sourceOffset(chunk.textEnd),
+    startSec: elapsed,
+    endSec: elapsed + chunk.durationSec,
+    ...chunk.wordTimings !== void 0 ? {
+      wordTimings: chunk.wordTimings.map((word) => ({
+        textStart: sourceOffset(word.textStart),
+        textEnd: sourceOffset(word.textEnd),
+        startSec: elapsed + word.startSec,
+        endSec: elapsed + word.endSec
+      })).filter((word) => word.textEnd > word.textStart)
+    } : {}
+  };
+}
+function buildTtsAlignment(script, spans, durationSec) {
+  const ordered = [...spans].sort((a, b) => a.sourceStart - b.sourceStart);
+  const spanOf = new Array(script.tokens.length).fill(-1);
+  let cursor = 0;
+  for (const [tokenIndex, token] of script.tokens.entries()) {
+    while (cursor < ordered.length && ordered[cursor].sourceEnd <= token.charOffset) cursor += 1;
+    const span = ordered[cursor];
+    if (span && token.charOffset >= span.sourceStart) spanOf[tokenIndex] = cursor;
+  }
+  const totals = new Array(ordered.length).fill(0);
+  for (const [tokenIndex, token] of script.tokens.entries()) {
+    const span = spanOf[tokenIndex];
+    if (span >= 0) totals[span] += Math.max(1, token.syllables);
+  }
+  const consumed = new Array(ordered.length).fill(0);
+  const modelWords = ordered.flatMap((span) => span.wordTimings ?? []);
+  const modelTimes = [];
+  let modelCursor = 0;
+  for (const token of script.tokens) {
+    while (modelCursor < modelWords.length && modelWords[modelCursor].textEnd <= token.charOffset)
+      modelCursor++;
+    const word = modelWords[modelCursor];
+    modelTimes.push(word && word.textStart < token.charEnd ? word.startSec : void 0);
+  }
+  const nextModelTimes = [];
+  let nextTime = durationSec;
+  for (let i = modelTimes.length - 1; i >= 0; i--) {
+    nextTime = modelTimes[i] ?? nextTime;
+    nextModelTimes[i] = nextTime;
+  }
+  const words = [];
+  let lastTime = 0;
+  for (const [tokenIndex, token] of script.tokens.entries()) {
+    const index = spanOf[tokenIndex];
+    const modelTime = modelTimes[tokenIndex];
+    const before = index >= 0 ? consumed[index] : 0;
+    if (index >= 0) consumed[index] = before + Math.max(1, token.syllables);
+    if (modelTime !== void 0) {
+      lastTime = Math.max(lastTime, modelTime);
+      words.push({ tokenIndex, tSec: lastTime, interpolated: false });
+      continue;
+    }
+    if (index < 0) {
+      const next = ordered.find((candidate) => candidate.sourceStart > token.charOffset);
+      lastTime = Math.max(
+        lastTime,
+        Math.min(next?.startSec ?? durationSec, nextModelTimes[tokenIndex])
+      );
+      words.push({ tokenIndex, tSec: lastTime, interpolated: true });
+      continue;
+    }
+    const span = ordered[index];
+    const t = span.startSec + (span.endSec - span.startSec) * (before / Math.max(1, totals[index]));
+    lastTime = Math.max(lastTime, Math.min(t, nextModelTimes[tokenIndex]));
+    words.push({ tokenIndex, tSec: lastTime, interpolated: true });
+  }
+  const blocks = [];
+  for (const [blockIndex, block] of script.blocks.entries()) {
+    const first = words[block.tokenStart];
+    blocks.push({
+      blockId: block.blockId,
+      ...block.heading !== void 0 ? { heading: block.heading } : {},
+      blockIndex,
+      charStart: block.charStart,
+      charEnd: block.charEnd,
+      startSec: blockIndex === 0 ? 0 : first?.tSec ?? 0,
+      endSec: durationSec
+    });
+  }
+  for (let i = 0; i < blocks.length - 1; i += 1) {
+    const current = blocks[i];
+    const next = blocks[i + 1];
+    blocks[i] = { ...current, endSec: Math.max(current.startSec, next.startSec) };
+  }
+  return { words, blocks, detectedSyllables: 0, cost: 0 };
+}
+
+// src/Speech/useGenerateNarration.ts
+var TTS_NARRATION_GENERATOR = { name: "docblocks-kokoro", method: "tts" };
+function hasDocumentNarration(markdown) {
+  return /\{\[audio\b[^\]]*\banchor=document\b[^\]]*\]\}/u.test(markdown);
+}
+function useGenerateNarration(speech) {
+  const {
+    markdownSource,
+    setMarkdownSource,
+    mediaProvider,
+    workspaceContainer,
+    bumpMediaRevision
+  } = useEditorContext();
+  const [state, setState] = useState({ phase: "idle" });
+  const sourceRef = useRef(markdownSource);
+  sourceRef.current = markdownSource;
+  const run = useRef(null);
+  const cancel = useCallback(() => {
+    if (run.current) {
+      run.current.cancelled = true;
+      run.current.handle?.cancel();
+      run.current = null;
+    }
+    setState({ phase: "idle" });
+  }, []);
+  useEffect(
+    () => () => {
+      if (run.current) {
+        run.current.cancelled = true;
+        run.current.handle?.cancel();
+      }
+    },
+    []
+  );
+  const generate = useCallback(() => {
+    const synthesize = speech.synthesize;
+    if (!synthesize || !mediaProvider || run.current) return;
+    const current = { cancelled: false, handle: null };
+    run.current = current;
+    setState({ phase: "generating", done: 0, total: 1 });
+    void (async () => {
+      const [plan, { createAudioFileEncoder }] = await Promise.all([
+        planSpeech(sourceRef.current),
+        import("@bendyline/squisq-video-react/encoder")
+      ]);
+      if (current.cancelled) return;
+      if (plan.segments.length === 0) throw new Error("There is nothing to narrate yet.");
+      const encoder = await createAudioFileEncoder({
+        format: "opus-webm",
+        sampleRate: 24e3,
+        channels: 1
+      });
+      try {
+        const spans = [];
+        let elapsed = 0;
+        let appending = Promise.resolve();
+        for (const [index, segment] of plan.segments.entries()) {
+          if (current.cancelled) return;
+          setState({ phase: "generating", done: index, total: plan.segments.length });
+          const handle = synthesize({ text: segment.text }, (event) => {
+            if (event.kind !== "chunk" || current.cancelled) return;
+            const { chunk } = event;
+            spans.push(spokenSpanForChunk(chunk, segment, elapsed));
+            elapsed += chunk.durationSec;
+            const samples = new Float32Array(chunk.pcm);
+            appending = appending.then(() => encoder.append([samples]));
+          });
+          current.handle = handle;
+          const result = await handle.done;
+          if (current.cancelled) return;
+          if (!result.ok) throw new Error(result.error.message);
+        }
+        await appending;
+        if (current.cancelled) return;
+        setState({ phase: "saving" });
+        const audio = await encoder.finish();
+        const savePlan = buildNarrationSavePlan({
+          script: plan.script,
+          alignment: buildTtsAlignment(plan.script, spans, elapsed),
+          durationSec: elapsed,
+          // Squisq's recorder extensions carry the dot (".webm").
+          audioExt: `.${encoder.extension}`,
+          cameraExt: null,
+          generator: TTS_NARRATION_GENERATOR
+        });
+        await executeNarrationSave(
+          savePlan,
+          { audioBlob: audio, audioMime: encoder.mimeType, cameraBlob: null, cameraMime: null },
+          {
+            mediaProvider,
+            container: workspaceContainer,
+            getMarkdownSource: () => sourceRef.current,
+            setMarkdownSource,
+            bumpMediaRevision
+          }
+        );
+        if (current.cancelled) return;
+        run.current = null;
+        setState({ phase: "done", durationSec: elapsed });
+      } finally {
+        if (current.cancelled) await encoder.cancel().catch(() => void 0);
+      }
+    })().catch((error) => {
+      if (current.cancelled) return;
+      run.current = null;
+      setState({
+        phase: "error",
+        message: error instanceof Error ? error.message : "Generating narration failed."
+      });
+    });
+  }, [bumpMediaRevision, mediaProvider, setMarkdownSource, speech, workspaceContainer]);
+  const reset = useCallback(() => {
+    if (!run.current) setState({ phase: "idle" });
+  }, []);
+  return {
+    state,
+    available: Boolean(speech.synthesize && mediaProvider),
+    generate,
+    cancel,
+    reset
+  };
+}
+
+export {
+  planSpeech,
+  hasDocumentNarration,
+  useGenerateNarration
+};

package/dist/chunk-K4I3NJFL.js

@@ -0,0 +1,49 @@
+// src/Ai/ai-status.ts
+import { useEffect, useState } from "react";
+function useAiStatus(ai) {
+  const [status, setStatus] = useState(null);
+  useEffect(() => {
+    let active = true;
+    const unsubscribe = ai.onStatus((next) => {
+      if (active) setStatus(next);
+    });
+    void ai.status().then(
+      (initial) => {
+        if (active) setStatus((current) => current ?? initial);
+      },
+      () => {
+        if (active) {
+          setStatus({
+            kind: "error",
+            error: { code: "unknown", message: "AI status is unavailable." },
+            retryable: true
+          });
+        }
+      }
+    );
+    return () => {
+      active = false;
+      unsubscribe();
+    };
+  }, [ai]);
+  return status;
+}
+function unavailableSentence(status) {
+  if (!status) return "Checking AI connection\u2026";
+  if (status.kind === "connecting") return "AI is getting ready\u2026";
+  if (status.kind === "error") return status.error.message;
+  if (status.kind === "ready" && !status.model) return "Add a model in Settings to use AI.";
+  if (status.kind === "unavailable") {
+    if (status.reason === "opt-out") return "Turn on AI features in Settings.";
+    if (status.reason === "disconnected") return "Built-in AI is starting\u2026";
+    if (status.reason === "not-installed") return "Built-in AI is not available in this build.";
+    if (status.reason === "not-running") return "Built-in AI is restarting\u2026";
+    return "AI is not available in this build.";
+  }
+  return "";
+}
+
+export {
+  useAiStatus,
+  unavailableSentence
+};

package/dist/chunk-KBDZDFPU.js

@@ -0,0 +1,61 @@
+// src/Speech/speech-input-provider.ts
+function toReadiness(readiness) {
+  return {
+    state: readiness.state,
+    ...readiness.reason ? { reason: readiness.reason } : {}
+  };
+}
+function abortable(promise, signal) {
+  if (signal.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(new DOMException("Aborted", "AbortError"));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+function createSpeechInputProvider(speech, options) {
+  const transcribe = speech.transcribe;
+  return {
+    id: "docblocks-dictation",
+    label: "Dictation",
+    async status() {
+      if (!transcribe) return { state: "unavailable" };
+      return toReadiness((await speech.status()).stt);
+    },
+    onStatus(listener) {
+      return speech.onStatus((status) => listener(toReadiness(status.stt)));
+    },
+    async prepare(signal) {
+      const result = await abortable(speech.prepare("stt"), signal);
+      if (!result.ok) throw new Error(result.error.message);
+    },
+    requestSetup: options.onRequestSetup,
+    async transcribe(wav, { prompt, language, signal }) {
+      if (!transcribe) throw new Error("Dictation is not available.");
+      const result = await abortable(
+        transcribe({
+          audio: wav,
+          mimeType: "audio/wav",
+          ...prompt ? { prompt } : {},
+          ...language ? { language } : {}
+        }),
+        signal
+      );
+      if (!result.ok) throw new Error(result.error.message);
+      return { text: result.value.text };
+    }
+  };
+}
+
+export {
+  createSpeechInputProvider
+};

package/dist/{chunk-FNSRCCBC.js → chunk-KWG6UP5O.js}

@@ -1,12 +1,3 @@
-// src/Export/image-save.ts
-function createImageSaveOutput(adapter) {
-  return async (blob, filename) => {
-    const target = await adapter.pickTarget(filename, null);
-    if (!target) return false;
-    return await adapter.saveBlob(blob, filename, target) !== null;
-  };
-}
-
 // src/Export/export-destination.ts
 function updateExportTargetExtension(targetPath, suggestedFilename) {
   const nextExtension = extensionOf(suggestedFilename);
@@ -36,6 +27,5 @@ function firstSuffixIndex(value) {
 }
 
 export {
-  createImageSaveOutput,
   updateExportTargetExtension
 };