@bendyline/docblocks-react 2.7.5 → 2.7.7

package/dist/{ExportToolbarControls-HOV424TO.js → ExportToolbarControls-2XY2CKGH.js}

@@ -39,6 +39,7 @@ import {
   useRef,
   useMemo
 } from "react";
+import { createPortal } from "react-dom";
 import {
   useEditorContext,
   usePreviewSettings,
@@ -66,7 +67,7 @@ function saveOpenAfterExport(value) {
 // src/Export/ExportToolbarControls.tsx
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 var ExportDialog = lazy(
-  () => import("./ExportDialog-LGWBXIWN.js").then((module) => ({ default: module.ExportDialog }))
+  () => import("./ExportDialog-EYDGTJ3S.js").then((module) => ({ default: module.ExportDialog }))
 );
 var ShareDialog = lazy(
   () => import("./ShareDialog-PF7D7ORP.js").then((module) => ({ default: module.ShareDialog }))
@@ -79,7 +80,7 @@ function loadRunExportModule() {
 var ExportCancelledError = class extends Error {
 };
 var AudioExportDialog = lazy(
-  () => import("./AudioExportDialog-IOYIEAER.js").then((module) => ({
+  () => import("./AudioExportDialog-EICCBSSE.js").then((module) => ({
     default: module.AudioExportDialog
   }))
 );
@@ -180,6 +181,8 @@ function ExportToolbarControls({
   const [exportError, setExportError] = useState(null);
   const [openAfterSave, setOpenAfterSave] = useState(loadOpenAfterExport);
   const [openError, setOpenError] = useState(null);
+  const [exportCompletion, setExportCompletion] = useState(null);
+  useEffect(() => setExportCompletion(null), [selectedFile]);
   const handleOpenAfterSaveChange = useCallback((checked) => {
     setOpenAfterSave(checked);
     saveOpenAfterExport(checked);
@@ -359,8 +362,8 @@ function ExportToolbarControls({
     [destinationAdapter]
   );
   const openSaved = useCallback(
-    async (target) => {
-      if (!openAfterSave || !destinationAdapter?.openSaved) return;
+    async (target, requested = false) => {
+      if (!requested && !openAfterSave || !destinationAdapter?.openSaved) return;
       try {
         await destinationAdapter.openSaved(target);
       } catch (caught) {
@@ -376,6 +379,7 @@ function ExportToolbarControls({
       setExportError(null);
       setOpenError(null);
       setExportNotice(null);
+      setExportCompletion(null);
       try {
         let exportTarget = destinationTarget;
         if (!fileShare && destinationAdapter?.pickBeforeSave) {
@@ -399,6 +403,12 @@ function ExportToolbarControls({
           } : saveBlob
         );
         setDialogOpen(false);
+        if (!fileShare) {
+          setExportCompletion({
+            filename: buildExportFilename(selectedFile, opts),
+            target: savedTarget
+          });
+        }
         if (result.warnings.length > 0) setExportNotice(result.warnings);
         if (savedTarget) await openSaved(savedTarget);
       } catch (caught) {
@@ -426,6 +436,7 @@ function ExportToolbarControls({
     setExportError(null);
     setOpenError(null);
     setExportNotice(null);
+    setExportCompletion(null);
     try {
       saveExportOptions(lastOptions);
       let quickTarget = null;
@@ -450,6 +461,10 @@ function ExportToolbarControls({
           savedTarget = await saveToDestination(blob, filename, quickTarget);
         } : saveBlob
       );
+      setExportCompletion({
+        filename: buildExportFilename(selectedFile, lastOptions),
+        target: savedTarget
+      });
       if (result.warnings.length > 0) setExportNotice(result.warnings);
       if (savedTarget) await openSaved(savedTarget);
     } catch (caught) {
@@ -705,6 +720,32 @@ function ExportToolbarControls({
       }
     ),
     openError && !videoModalOpen && /* @__PURE__ */ jsx(Dialog, { title: "Open saved export", onClose: () => setOpenError(null), children: /* @__PURE__ */ jsx("p", { role: "alert", children: openError }) }),
+    exportCompletion && !dialogOpen && !exportError && !openError && !exportNotice && createPortal(
+      /* @__PURE__ */ jsxs("aside", { className: "db-export-completion", "aria-label": "Export result", children: [
+        /* @__PURE__ */ jsx("p", { role: "status", children: exportCompletion.target ? `Saved ${exportCompletion.target.displayPath}` : !destinationAdapter && !saveBlob ? `Sent ${exportCompletion.filename} to your browser\u2019s downloads.` : `Exported ${exportCompletion.filename}` }),
+        /* @__PURE__ */ jsxs("div", { className: "db-export-completion-actions", children: [
+          exportCompletion.target && destinationAdapter?.openSaved && /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: "db-export-btn db-export-btn--primary",
+              onClick: () => void openSaved(exportCompletion.target, true),
+              children: "Open exported file"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              type: "button",
+              className: "db-export-btn db-export-btn--secondary",
+              onClick: () => setExportCompletion(null),
+              children: "Dismiss"
+            }
+          )
+        ] })
+      ] }),
+      document.body
+    ),
     exportNotice && !dialogOpen && !exportError && !openError && /* @__PURE__ */ jsx(
       Dialog,
       {

package/dist/{PresentationMaker-H5B44Q7P.js → PresentationMaker-VYQKNL3L.js}

@@ -1,7 +1,7 @@
 import {
   PresentationMaker
-} from "./chunk-USKX66SA.js";
-import "./chunk-CUCWCZRO.js";
+} from "./chunk-T2PA7QEF.js";
+import "./chunk-N7AKLJPY.js";
 import "./chunk-K4I3NJFL.js";
 import "./chunk-VJPGZCFS.js";
 export {

package/dist/{SpeechToolbarControl-KNI2C4JJ.js → SpeechToolbarControl-E6OSJGHL.js}

@@ -5,11 +5,11 @@ import {
   hasDocumentNarration,
   planSpeech,
   useGenerateNarration
-} from "./chunk-I44HKDQX.js";
+} from "./chunk-3TSJQESW.js";
 import {
   AutoPlayGate,
   ProgressivePlayer
-} from "./chunk-2IYBBFQX.js";
+} from "./chunk-BZRYQENB.js";
 import {
   useMenuKeyboard
 } from "./chunk-GMA4KGGO.js";
@@ -89,44 +89,144 @@ function GenerateNarrationDialog({ speech, onClose }) {
 
 // src/Speech/useReadAloud.ts
 import { useCallback, useEffect, useRef, useState } from "react";
+var RESTART_SEGMENT_SECONDS = 2;
+var POLL_MS = 250;
+var SENTENCE_BREAK = /(?<=[.!?…])\s+/u;
+function* upcomingSentences(segments, segment, offset) {
+  for (let index = segment; index < segments.length; index += 1) {
+    const text = segments[index]?.text ?? "";
+    for (const sentence of (index === segment ? text.slice(offset) : text).split(SENTENCE_BREAK)) {
+      const length = sentence.trim().length;
+      if (length > 0) yield length;
+    }
+  }
+}
+function playIfReady(current) {
+  if (current.cancelled || current.userPaused || current.synthesizing === null) return;
+  const snapshot = current.player.snapshot();
+  if (snapshot.isPlaying) return;
+  const ready = current.gate.ready(
+    snapshot.bufferedDuration - snapshot.currentTime,
+    upcomingSentences(current.segments, current.synthesizing, current.synthesizedThrough),
+    performance.now()
+  );
+  if (ready) void current.player.play();
+}
+function endSession(current) {
+  current.cancelled = true;
+  current.handle?.cancel();
+  if (current.poll) clearInterval(current.poll);
+  current.player.dispose();
+}
+function sameState(a, b) {
+  if (a.phase === "reading" && b.phase === "reading") {
+    return a.playing === b.playing && a.waiting === b.waiting && a.segment === b.segment && a.segments === b.segments;
+  }
+  return a.phase === b.phase && a.phase !== "error";
+}
+function segmentAt(current, snapshot) {
+  const caughtUp = !snapshot.isPlaying && snapshot.currentTime >= snapshot.bufferedDuration - 0.05;
+  if (caughtUp && current.synthesizing !== null) return current.synthesizing;
+  if (snapshot.currentChunk === null) return current.firstSegment;
+  return current.chunkSegments[snapshot.currentChunk] ?? current.firstSegment;
+}
 function useReadAloud(speech) {
   const [state, setState] = useState({ phase: "idle" });
   const session = useRef(null);
   const stop = useCallback(() => {
     const current = session.current;
     session.current = null;
-    if (current) {
-      current.cancelled = true;
-      current.handle?.cancel();
-      current.player.dispose();
-    }
+    if (current) endSession(current);
     setState({ phase: "idle" });
   }, []);
   useEffect(() => stop, [stop]);
+  const fail = useCallback(
+    (message) => {
+      stop();
+      setState({ phase: "error", message });
+    },
+    [stop]
+  );
+  const refresh = useCallback(() => {
+    const current = session.current;
+    if (!current) return;
+    const snapshot = current.player.snapshot();
+    if (snapshot.complete && !snapshot.isPlaying && snapshot.currentTime >= snapshot.bufferedDuration - 0.05) {
+      session.current = null;
+      endSession(current);
+      setState({ phase: "idle" });
+      return;
+    }
+    if (snapshot.isPlaying) current.started = true;
+    const next2 = current.started ? {
+      phase: "reading",
+      playing: !current.userPaused,
+      waiting: !current.userPaused && !snapshot.isPlaying,
+      segment: segmentAt(current, snapshot),
+      segments: current.segments.length
+    } : { phase: "loading" };
+    setState((previous2) => sameState(previous2, next2) ? previous2 : next2);
+  }, []);
+  const synthesizeFrom = useCallback(
+    async (current, first, synthesize) => {
+      if (!synthesize) return;
+      current.run += 1;
+      const run = current.run;
+      const stale = () => current.cancelled || current.run !== run;
+      current.handle?.cancel();
+      current.handle = null;
+      current.firstSegment = first;
+      current.synthesizing = first;
+      current.segmentStarts.clear();
+      current.chunkSegments.length = 0;
+      current.gate.restart();
+      const { player, gate, segments } = current;
+      player.reset();
+      let chunkIndex = 0;
+      for (let index = first; index < segments.length; index += 1) {
+        if (stale()) return;
+        current.synthesizing = index;
+        current.synthesizedThrough = 0;
+        const handle = synthesize({ text: segments[index]?.text ?? "" }, (event) => {
+          if (stale() || event.kind !== "chunk") return;
+          const { chunk } = event;
+          if (!current.segmentStarts.has(index)) {
+            current.segmentStarts.set(index, player.snapshot().bufferedDuration);
+          }
+          current.chunkSegments[chunkIndex] = index;
+          player.append({ ...chunk, index: chunkIndex });
+          chunkIndex += 1;
+          gate.record(
+            chunk.textEnd - current.synthesizedThrough,
+            chunk.durationSec,
+            performance.now()
+          );
+          current.synthesizedThrough = chunk.textEnd;
+          playIfReady(current);
+        });
+        current.handle = handle;
+        const result = await handle.done;
+        if (stale()) return;
+        if (!result.ok) {
+          fail(result.error.message);
+          return;
+        }
+      }
+      current.handle = null;
+      current.synthesizing = null;
+      player.finish();
+      if (!player.snapshot().isPlaying && !current.userPaused) void player.play();
+    },
+    [fail]
+  );
   const start = useCallback(
     (markdown) => {
       const synthesize = speech?.synthesize;
       if (!synthesize) return;
       stop();
-      const onChange = (snapshot) => {
-        const current2 = session.current;
-        if (!current2 || current2.player !== player) return;
-        if (snapshot.complete && !snapshot.isPlaying && snapshot.currentTime >= snapshot.bufferedDuration - 0.05) {
-          session.current = null;
-          player.dispose();
-          setState({ phase: "idle" });
-          return;
-        }
-        const segment = snapshot.currentChunk === null ? 0 : current2.chunkSegments[snapshot.currentChunk] ?? 0;
-        setState({
-          phase: "reading",
-          playing: snapshot.isPlaying,
-          waiting: snapshot.waitingForAudio,
-          segment,
-          segments: current2.segments.length
-        });
-      };
-      const player = ProgressivePlayer.create(onChange);
+      const player = ProgressivePlayer.create(() => {
+        if (session.current?.player === player) refresh();
+      });
       if (!player) {
         setState({ phase: "error", message: "Audio playback is not available." });
         return;
@@ -134,12 +234,24 @@ function useReadAloud(speech) {
       player.prime();
       const current = {
         player,
-        chunkSegments: [],
+        gate: new AutoPlayGate(),
         segments: [],
+        run: 0,
+        firstSegment: 0,
+        synthesizing: null,
+        synthesizedThrough: 0,
+        poll: null,
+        segmentStarts: /* @__PURE__ */ new Map(),
+        chunkSegments: [],
         handle: null,
+        started: false,
         cancelled: false,
         userPaused: false
       };
+      current.poll = setInterval(() => {
+        playIfReady(current);
+        if (session.current === current) refresh();
+      }, POLL_MS);
       session.current = current;
       setState({ phase: "loading" });
       void (async () => {
@@ -147,67 +259,65 @@ function useReadAloud(speech) {
         if (current.cancelled) return;
         current.segments = plan.segments;
         if (plan.segments.length === 0) {
-          stop();
-          setState({ phase: "error", message: "There is nothing to read aloud." });
+          fail("There is nothing to read aloud.");
           return;
         }
-        const totalCharacters = plan.segments.reduce((sum, s) => sum + s.text.length, 0);
-        const gate = new AutoPlayGate();
-        let spokenCharacters = 0;
-        let chunkIndex = 0;
-        for (const [segmentIndex, segment] of plan.segments.entries()) {
-          if (current.cancelled) return;
-          const handle = synthesize({ text: segment.text }, (event) => {
-            if (current.cancelled || event.kind !== "chunk") return;
-            current.chunkSegments[chunkIndex] = segmentIndex;
-            player.append({ ...event.chunk, index: chunkIndex });
-            chunkIndex += 1;
-            const snapshot = player.snapshot();
-            const progress = {
-              completedCharacters: spokenCharacters + event.chunk.textEnd,
-              totalCharacters
-            };
-            if (!snapshot.isPlaying && !current.userPaused && gate.ready(snapshot, progress, performance.now())) {
-              void player.play();
-            }
-          });
-          current.handle = handle;
-          const result = await handle.done;
-          if (current.cancelled) return;
-          if (!result.ok) {
-            stop();
-            setState({ phase: "error", message: result.error.message });
-            return;
-          }
-          spokenCharacters += segment.text.length;
-        }
-        current.handle = null;
-        player.finish();
-        if (!player.snapshot().isPlaying && !current.userPaused) void player.play();
+        await synthesizeFrom(current, 0, synthesize);
       })().catch((error) => {
         if (current.cancelled) return;
-        stop();
-        setState({
-          phase: "error",
-          message: error instanceof Error ? error.message : "Reading aloud failed."
-        });
+        fail(error instanceof Error ? error.message : "Reading aloud failed.");
       });
     },
-    [speech, stop]
+    [speech, stop, fail, refresh, synthesizeFrom]
   );
   const pause = useCallback(() => {
     const current = session.current;
     if (!current) return;
     current.userPaused = true;
     current.player.pause();
-  }, []);
+    refresh();
+  }, [refresh]);
   const resume = useCallback(() => {
     const current = session.current;
     if (!current) return;
     current.userPaused = false;
+    current.player.prime();
     void current.player.play();
-  }, []);
-  return { state, start, pause, resume, stop };
+    refresh();
+  }, [refresh]);
+  const skip = useCallback(
+    (direction) => {
+      const current = session.current;
+      if (!current || current.segments.length === 0) return;
+      current.player.prime();
+      const snapshot = current.player.snapshot();
+      const segment = segmentAt(current, snapshot);
+      const segmentStart = current.segmentStarts.get(segment);
+      const restart = direction < 0 && segmentStart !== void 0 && snapshot.currentTime - segmentStart > RESTART_SEGMENT_SECONDS;
+      const target = restart ? segment : segment + direction;
+      if (target < 0 || target >= current.segments.length) {
+        if (target < 0 && segmentStart !== void 0) current.player.seek(segmentStart);
+        refresh();
+        return;
+      }
+      const start2 = current.segmentStarts.get(target);
+      if (start2 !== void 0) {
+        current.player.seek(start2);
+      } else if (target === current.synthesizing) {
+        current.player.seek(snapshot.bufferedDuration);
+      } else {
+        void synthesizeFrom(current, target, speech?.synthesize).catch((error) => {
+          if (current.cancelled) return;
+          fail(error instanceof Error ? error.message : "Reading aloud failed.");
+        });
+      }
+      refresh();
+    },
+    [speech, fail, refresh, synthesizeFrom]
+  );
+  const previous = useCallback(() => skip(-1), [skip]);
+  const next = useCallback(() => skip(1), [skip]);
+  return { state, start, pause, resume, previous, next, stop };
 }
 
 // src/Speech/SpeechToolbarControl.tsx
@@ -286,6 +396,18 @@ function SpeechToolbarControl({
       }
     ),
     active && /* @__PURE__ */ jsxs2("div", { className: "db-speech-transport", role: "group", "aria-label": "Reading aloud", children: [
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "button",
+          className: "squisq-toolbar-button",
+          "aria-label": "Previous segment",
+          "data-tooltip": "Previous segment",
+          disabled: state.phase !== "reading",
+          onClick: () => readAloud.previous(),
+          children: /* @__PURE__ */ jsx2(PreviousGlyph, {})
+        }
+      ),
       state.phase === "reading" && state.playing ? /* @__PURE__ */ jsx2(
         "button",
         {
@@ -308,6 +430,18 @@ function SpeechToolbarControl({
           children: /* @__PURE__ */ jsx2(PlayGlyph, {})
         }
       ),
+      /* @__PURE__ */ jsx2(
+        "button",
+        {
+          type: "button",
+          className: "squisq-toolbar-button",
+          "aria-label": "Next segment",
+          "data-tooltip": "Next segment",
+          disabled: state.phase !== "reading" || state.segment >= state.segments - 1,
+          onClick: () => readAloud.next(),
+          children: /* @__PURE__ */ jsx2(NextGlyph, {})
+        }
+      ),
       /* @__PURE__ */ jsx2(
         "button",
         {
@@ -425,6 +559,18 @@ function PlayGlyph() {
 function PauseGlyph() {
   return /* @__PURE__ */ jsx2(Glyph, { children: /* @__PURE__ */ jsx2("path", { d: "M6.5 4.5v9M11.5 4.5v9" }) });
 }
+function PreviousGlyph() {
+  return /* @__PURE__ */ jsxs2(Glyph, { children: [
+    /* @__PURE__ */ jsx2("path", { d: "M5 4.5v9" }),
+    /* @__PURE__ */ jsx2("path", { d: "M13 4.5v9L6.5 9z" })
+  ] });
+}
+function NextGlyph() {
+  return /* @__PURE__ */ jsxs2(Glyph, { children: [
+    /* @__PURE__ */ jsx2("path", { d: "M13 4.5v9" }),
+    /* @__PURE__ */ jsx2("path", { d: "M5 4.5v9L11.5 9z" })
+  ] });
+}
 function StopGlyph() {
   return /* @__PURE__ */ jsx2(Glyph, { children: /* @__PURE__ */ jsx2("rect", { x: "5", y: "5", width: "8", height: "8", rx: "1" }) });
 }

package/dist/{TextFromNarration-EYOMW2IW.js → TextFromNarration-ME6FAYWO.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-6JJOGV6M.js";
 import {
   createSpeechInputProvider
-} from "./chunk-KBDZDFPU.js";
+} from "./chunk-BNKIPCXO.js";
 import {
   unavailableSentence,
   useAiStatus

package/dist/{WorkspaceSearchPanel-J6BKEZQJ.js → WorkspaceSearchPanel-MEBBTK7F.js}

@@ -1,9 +1,9 @@
+import {
+  FilesIcon
+} from "./chunk-KHQ44ZFA.js";
 import {
   HighlightedText
 } from "./chunk-TBLZBNQF.js";
-import {
-  FilesIcon
-} from "./chunk-DICE7VBJ.js";
 
 // src/WorkspaceSearch/WorkspaceSearchPanel.tsx
 import { useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState2 } from "react";

package/dist/{chunk-I44HKDQX.js → chunk-3TSJQESW.js}

@@ -12,6 +12,14 @@ var FENCE = /^(?<indent> {0,3})(?<marker>`{3,}|~{3,})[^\n]*\n[\s\S]*?^\k<indent>
 function stripFencedCode(markdown) {
   return markdown.replace(FENCE, "");
 }
+function joinSoftBreaks(node) {
+  if (typeof node !== "object" || node === null) return;
+  const { type, value, children } = node;
+  if (type === "text" && typeof value === "string") {
+    node.value = value.replace(/\n/gu, " ");
+  }
+  if (Array.isArray(children)) for (const child of children) joinSoftBreaks(child);
+}
 function ensureSentenceEnd(text) {
   const trimmed = text.trimEnd();
   if (!trimmed) return trimmed;
@@ -54,11 +62,16 @@ async function planSpeech(markdown) {
     import("@bendyline/squisq/doc"),
     import("@bendyline/squisq/narration")
   ]);
-  const doc = markdownToDoc(parseMarkdown(stripFencedCode(markdown)));
+  const source = stripFencedCode(markdown);
+  const doc = markdownToDoc(parseMarkdown(source));
   const script = buildNarrationScript(doc);
+  const joined = parseMarkdown(source);
+  joinSoftBreaks(joined);
+  const joinedText = buildNarrationScript(markdownToDoc(joined)).sourceText;
+  const spoken = joinedText.length === script.sourceText.length ? joinedText : script.sourceText;
   const segments = [];
   for (const block of script.blocks) {
-    const text = script.sourceText.slice(block.charStart, block.charEnd);
+    const text = spoken.slice(block.charStart, block.charEnd);
     let bodyStart = block.charStart;
     const heading = block.heading?.trim();
     if (heading && text.startsWith(heading)) {
@@ -72,7 +85,7 @@ async function planSpeech(markdown) {
       bodyStart = block.charStart + heading.length;
     }
     const lines = /[^\n]+/gu;
-    const body = script.sourceText.slice(bodyStart, block.charEnd);
+    const body = spoken.slice(bodyStart, block.charEnd);
     for (const line of body.matchAll(lines)) {
       for (const piece of splitLongText(line[0], bodyStart + line.index)) {
         segments.push({