@bendyline/docblocks-react 2.6.2 → 2.7.0

package/dist/WorkspaceSearchPanel-OUQQ5DOM.js

@@ -0,0 +1,328 @@
+import {
+  HighlightedText
+} from "./chunk-TBLZBNQF.js";
+import {
+  FilesIcon
+} from "./chunk-EA4BO6E4.js";
+
+// src/WorkspaceSearch/WorkspaceSearchPanel.tsx
+import { useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState2 } from "react";
+
+// src/WorkspaceSearch/useWorkspaceSearch.ts
+import { useEffect, useRef, useState } from "react";
+var EMPTY = { result: null, searching: false };
+var QUERY_DEBOUNCE_MS = 200;
+var INDEX_REFRESH_MS = 750;
+function useWorkspaceSearch(index, generation, query) {
+  const [state, setState] = useState(EMPTY);
+  const controllerRef = useRef(null);
+  const runRef = useRef(null);
+  const refreshTimerRef = useRef(null);
+  const { text } = query;
+  const matchCase = query.matchCase ?? false;
+  const wholeWord = query.wholeWord ?? false;
+  useEffect(() => {
+    controllerRef.current?.abort();
+    controllerRef.current = null;
+    if (!index || !text.trim()) {
+      runRef.current = null;
+      setState(EMPTY);
+      return;
+    }
+    const run = () => {
+      controllerRef.current?.abort();
+      const controller = new AbortController();
+      controllerRef.current = controller;
+      index.search({ text, matchCase, wholeWord }, { signal: controller.signal }).then(
+        (result) => {
+          if (controllerRef.current === controller) setState({ result, searching: false });
+        },
+        () => {
+          if (controllerRef.current === controller) {
+            setState((current) => ({ ...current, searching: false }));
+          }
+        }
+      );
+    };
+    runRef.current = run;
+    setState((current) => ({ ...current, searching: true }));
+    const timer = setTimeout(run, QUERY_DEBOUNCE_MS);
+    return () => clearTimeout(timer);
+  }, [index, text, matchCase, wholeWord]);
+  useEffect(() => {
+    if (!runRef.current || refreshTimerRef.current !== null) return;
+    refreshTimerRef.current = setTimeout(() => {
+      refreshTimerRef.current = null;
+      runRef.current?.();
+    }, INDEX_REFRESH_MS);
+  }, [generation]);
+  useEffect(
+    () => () => {
+      controllerRef.current?.abort();
+      if (refreshTimerRef.current !== null) clearTimeout(refreshTimerRef.current);
+    },
+    []
+  );
+  return state;
+}
+
+// src/WorkspaceSearch/WorkspaceSearchPanel.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function plural(count, noun) {
+  return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function statusText(index, status, query, result, searching) {
+  if (!index) return "Search is not available for this workspace.";
+  if (status.error) return status.error;
+  const indexing = status.pendingCount > 0 ? ` Indexing ${status.documentCount - status.pendingCount} of ${status.documentCount}\u2026` : "";
+  if (!query.trim()) {
+    return status.listed ? `Search ${plural(status.documentCount, "document")}.${indexing}` : "Listing workspace\u2026";
+  }
+  if (!result) return searching ? "Searching\u2026" : "";
+  if (result.totalDocuments === 0) return `No results.${indexing}`;
+  const found = `${plural(result.totalMatches, "result")} in ${plural(result.totalDocuments, "document")}`;
+  const shown = result.truncated && result.documents.length < result.totalDocuments ? ` (showing the first ${result.documents.length})` : result.truncated ? " (more not counted)" : "";
+  return `${found}${shown}.${indexing}`;
+}
+function folderOf(path) {
+  const slash = path.lastIndexOf("/");
+  return slash < 0 ? "" : path.slice(0, slash);
+}
+function WorkspaceSearchPanel({
+  index,
+  status,
+  hidden,
+  focusRequest,
+  onOpen,
+  onShowFiles
+}) {
+  const inputRef = useRef2(null);
+  const rowRefs = useRef2(/* @__PURE__ */ new Map());
+  const [text, setText] = useState2("");
+  const [matchCase, setMatchCase] = useState2(false);
+  const [wholeWord, setWholeWord] = useState2(false);
+  const [collapsed, setCollapsed] = useState2(/* @__PURE__ */ new Set());
+  const [focusedKey, setFocusedKey] = useState2(null);
+  const query = useMemo(() => ({ text, matchCase, wholeWord }), [text, matchCase, wholeWord]);
+  const { result, searching } = useWorkspaceSearch(index, status.generation, query);
+  useEffect2(() => {
+    if (focusRequest === 0) return;
+    inputRef.current?.focus();
+    inputRef.current?.select();
+  }, [focusRequest]);
+  useEffect2(() => {
+    setCollapsed(/* @__PURE__ */ new Set());
+  }, [text, matchCase, wholeWord]);
+  const rows = useMemo(() => {
+    const flat = [];
+    for (const [position, document] of (result?.documents ?? []).entries()) {
+      flat.push({ kind: "document", key: `d:${document.path}`, document, position });
+      if (collapsed.has(document.path)) continue;
+      document.matches.forEach(
+        (match, matchPosition) => flat.push({
+          kind: "line",
+          key: `l:${document.path}:${matchPosition}`,
+          document,
+          match,
+          position: matchPosition
+        })
+      );
+    }
+    return flat;
+  }, [result, collapsed]);
+  const tabStop = rows.some((row) => row.key === focusedKey) ? focusedKey : rows[0]?.key ?? null;
+  const focusRow = (key) => {
+    setFocusedKey(key);
+    rowRefs.current.get(key)?.focus();
+  };
+  const open = (document, match) => onOpen({ path: document.path, match, query: text, matchCase, wholeWord });
+  const toggle = (path, expand) => setCollapsed((current) => {
+    const next = new Set(current);
+    const shouldExpand = expand ?? next.has(path);
+    if (shouldExpand) next.delete(path);
+    else next.add(path);
+    return next;
+  });
+  const onTreeKeyDown = (event) => {
+    const position = rows.findIndex((row2) => row2.key === tabStop);
+    const row = rows[position];
+    if (!row) return;
+    const isExpandable = row.kind === "document" && row.document.matches.length > 0;
+    const expanded = row.kind === "document" && !collapsed.has(row.document.path);
+    switch (event.key) {
+      case "ArrowDown":
+        if (position < rows.length - 1) focusRow(rows[position + 1].key);
+        break;
+      case "ArrowUp":
+        if (position > 0) focusRow(rows[position - 1].key);
+        break;
+      case "Home":
+        focusRow(rows[0].key);
+        break;
+      case "End":
+        focusRow(rows[rows.length - 1].key);
+        break;
+      case "ArrowRight":
+        if (isExpandable && !expanded) toggle(row.document.path, true);
+        else if (isExpandable && rows[position + 1]) focusRow(rows[position + 1].key);
+        break;
+      case "ArrowLeft":
+        if (row.kind === "line") focusRow(`d:${row.document.path}`);
+        else if (isExpandable && expanded) toggle(row.document.path, false);
+        break;
+      case "Enter":
+      case " ":
+        open(row.document, row.kind === "line" ? row.match : null);
+        break;
+      default:
+        return;
+    }
+    event.preventDefault();
+  };
+  const documentCount = result?.documents.length ?? 0;
+  return /* @__PURE__ */ jsxs("section", { className: "db-search-panel", hidden, "aria-label": "Search workspace", children: [
+    /* @__PURE__ */ jsxs("div", { className: "db-explorer-toolbar", children: [
+      /* @__PURE__ */ jsx("span", { className: "db-explorer-title", children: "Search" }),
+      /* @__PURE__ */ jsx("div", { className: "db-explorer-actions", children: /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: "db-explorer-btn",
+          onClick: onShowFiles,
+          title: "Show files",
+          "aria-label": "Show files",
+          children: /* @__PURE__ */ jsx(FilesIcon, {})
+        }
+      ) })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "db-search-form", role: "search", children: [
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          ref: inputRef,
+          className: "db-search-input",
+          type: "search",
+          "aria-label": "Search workspace",
+          placeholder: "Search",
+          spellCheck: false,
+          value: text,
+          onChange: (event) => setText(event.target.value),
+          onKeyDown: (event) => {
+            if (event.key === "ArrowDown" && rows[0]) {
+              event.preventDefault();
+              focusRow(rows[0].key);
+            }
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: "db-search-toggle",
+          "aria-pressed": matchCase,
+          "aria-label": "Match case",
+          title: "Match case",
+          onClick: () => setMatchCase((value) => !value),
+          children: "Aa"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "button",
+          className: "db-search-toggle db-search-toggle--word",
+          "aria-pressed": wholeWord,
+          "aria-label": "Match whole word",
+          title: "Match whole word",
+          onClick: () => setWholeWord((value) => !value),
+          children: "ab"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("p", { className: "db-search-status", role: "status", children: statusText(index, status, text, result, searching) }),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "db-search-results",
+        role: "tree",
+        "aria-label": "Search results",
+        onKeyDown: onTreeKeyDown,
+        children: rows.map((row) => {
+          const common = {
+            ref: (element) => {
+              if (element) rowRefs.current.set(row.key, element);
+              else rowRefs.current.delete(row.key);
+            },
+            role: "treeitem",
+            tabIndex: row.key === tabStop ? 0 : -1,
+            onFocus: () => setFocusedKey(row.key)
+          };
+          if (row.kind === "document") {
+            const { document: document2 } = row;
+            const expandable = document2.matches.length > 0;
+            const expanded = expandable && !collapsed.has(document2.path);
+            return /* @__PURE__ */ jsxs(
+              "div",
+              {
+                ...common,
+                className: "db-search-document",
+                "aria-level": 1,
+                "aria-setsize": documentCount,
+                "aria-posinset": row.position + 1,
+                "aria-expanded": expandable ? expanded : void 0,
+                onClick: () => open(document2, null),
+                children: [
+                  /* @__PURE__ */ jsx(
+                    "span",
+                    {
+                      className: "db-search-chevron",
+                      "aria-hidden": "true",
+                      onClick: (event) => {
+                        event.stopPropagation();
+                        if (expandable) toggle(document2.path);
+                      },
+                      children: expandable ? expanded ? "\u25BE" : "\u25B8" : ""
+                    }
+                  ),
+                  /* @__PURE__ */ jsx("span", { className: "db-search-document-title", children: /* @__PURE__ */ jsx(HighlightedText, { text: document2.title, ranges: document2.titleRanges }) }),
+                  /* @__PURE__ */ jsx("span", { className: "db-search-document-path", children: folderOf(document2.path) }),
+                  document2.matchCount > 0 && /* @__PURE__ */ jsx(
+                    "span",
+                    {
+                      className: "db-search-count",
+                      "aria-label": plural(document2.matchCount, "match"),
+                      children: document2.matchCount
+                    }
+                  )
+                ]
+              },
+              row.key
+            );
+          }
+          const { match, document } = row;
+          return /* @__PURE__ */ jsxs(
+            "div",
+            {
+              ...common,
+              className: "db-search-line",
+              "aria-level": 2,
+              "aria-setsize": document.matches.length,
+              "aria-posinset": row.position + 1,
+              onClick: () => open(document, match),
+              children: [
+                /* @__PURE__ */ jsx("span", { className: "db-search-line-number", children: match.line }),
+                /* @__PURE__ */ jsx("span", { className: "db-search-snippet", children: /* @__PURE__ */ jsx(HighlightedText, { text: match.snippet, ranges: match.ranges }) })
+              ]
+            },
+            row.key
+          );
+        })
+      }
+    ),
+    (result?.documents ?? []).some((document) => document.moreMatches) && /* @__PURE__ */ jsx("p", { className: "db-search-more", children: "Some documents have more matches; open them to see all." })
+  ] });
+}
+export {
+  WorkspaceSearchPanel
+};

package/dist/chunk-2IYBBFQX.js

@@ -0,0 +1,201 @@
+// src/Speech/progressive-player.ts
+var ProgressivePlayer = class _ProgressivePlayer {
+  constructor(context, onChange) {
+    this.context = context;
+    this.onChange = onChange;
+    this.chunks = [];
+    this.pending = /* @__PURE__ */ new Map();
+    this.sources = /* @__PURE__ */ new Set();
+    this.bufferedDuration = 0;
+    this.playbackOffset = 0;
+    this.playbackStartedAt = 0;
+    this.playing = false;
+    this.complete = false;
+    this.disposed = false;
+    this.endTimer = null;
+  }
+  static create(onChange) {
+    const Context = globalThis.AudioContext;
+    if (!Context) return null;
+    try {
+      return new _ProgressivePlayer(new Context(), onChange);
+    } catch {
+      return null;
+    }
+  }
+  /** Call synchronously from the click that starts playback, to keep audio permission. */
+  prime() {
+    void this.context.resume().catch(() => void 0);
+  }
+  append(chunk) {
+    if (this.disposed || chunk.index < this.chunks.length || this.pending.has(chunk.index)) return;
+    const samples = new Float32Array(chunk.pcm);
+    if (samples.length === 0) return;
+    const buffer = this.context.createBuffer(1, samples.length, chunk.sampleRate);
+    buffer.copyToChannel(samples, 0);
+    this.pending.set(chunk.index, buffer);
+    while (this.pending.has(this.chunks.length)) {
+      const index = this.chunks.length;
+      const next = this.pending.get(index);
+      this.pending.delete(index);
+      const scheduled = { index, start: this.bufferedDuration, buffer: next };
+      this.chunks.push(scheduled);
+      this.bufferedDuration += next.duration;
+      if (this.playing) this.schedule(scheduled);
+    }
+    this.refreshEndTimer();
+    this.emit();
+  }
+  async play() {
+    if (this.disposed || this.bufferedDuration <= 0) return false;
+    if (this.playing) return true;
+    if (this.playbackOffset >= this.bufferedDuration - 0.02) {
+      if (!this.complete) {
+        this.emit();
+        return false;
+      }
+      this.playbackOffset = 0;
+    }
+    await this.context.resume();
+    this.stopSources();
+    this.playing = true;
+    this.playbackStartedAt = this.context.currentTime + 0.025;
+    for (const chunk of this.chunks) this.schedule(chunk);
+    this.refreshEndTimer();
+    this.emit();
+    return true;
+  }
+  pause() {
+    if (!this.playing) return;
+    this.playbackOffset = this.currentTime();
+    this.playing = false;
+    this.stopSources();
+    this.clearEndTimer();
+    this.emit();
+  }
+  seek(seconds) {
+    const wasPlaying = this.playing;
+    this.playbackOffset = Math.max(0, Math.min(this.bufferedDuration, seconds));
+    this.playing = false;
+    this.stopSources();
+    this.clearEndTimer();
+    if (wasPlaying) void this.play();
+    else this.emit();
+  }
+  /** No more chunks will arrive. */
+  finish() {
+    this.complete = true;
+    this.refreshEndTimer();
+    this.emit();
+  }
+  snapshot() {
+    const currentTime = this.currentTime();
+    return {
+      currentTime,
+      bufferedDuration: this.bufferedDuration,
+      isPlaying: this.playing,
+      waitingForAudio: !this.complete && !this.playing && this.bufferedDuration > 0 && currentTime >= this.bufferedDuration - 0.05,
+      complete: this.complete,
+      currentChunk: this.chunkAt(currentTime)
+    };
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.playing = false;
+    this.stopSources();
+    this.clearEndTimer();
+    void this.context.close().catch(() => void 0);
+  }
+  chunkAt(time) {
+    let found = null;
+    for (const chunk of this.chunks) {
+      if (chunk.start <= time + 1e-3) found = chunk.index;
+      else break;
+    }
+    return found;
+  }
+  currentTime() {
+    if (!this.playing) return this.playbackOffset;
+    return Math.min(
+      this.bufferedDuration,
+      this.playbackOffset + Math.max(0, this.context.currentTime - this.playbackStartedAt)
+    );
+  }
+  schedule(chunk) {
+    const chunkEnd = chunk.start + chunk.buffer.duration;
+    if (!this.playing || chunkEnd <= this.playbackOffset + 5e-3) return;
+    let sourceOffset = Math.max(0, this.playbackOffset - chunk.start);
+    let when = this.playbackStartedAt + Math.max(0, chunk.start - this.playbackOffset);
+    if (when < this.context.currentTime) {
+      sourceOffset += this.context.currentTime - when;
+      when = this.context.currentTime;
+    }
+    if (sourceOffset >= chunk.buffer.duration - 5e-3) return;
+    const source = this.context.createBufferSource();
+    source.buffer = chunk.buffer;
+    source.connect(this.context.destination);
+    source.addEventListener("ended", () => this.sources.delete(source), { once: true });
+    this.sources.add(source);
+    source.start(when, sourceOffset);
+  }
+  refreshEndTimer() {
+    this.clearEndTimer();
+    if (!this.playing) return;
+    const remainingMs = Math.max(20, (this.bufferedDuration - this.currentTime()) * 1e3 + 40);
+    this.endTimer = setTimeout(() => {
+      if (!this.playing) return;
+      if (this.currentTime() < this.bufferedDuration - 0.05) {
+        this.refreshEndTimer();
+        return;
+      }
+      this.playbackOffset = this.bufferedDuration;
+      this.playing = false;
+      this.stopSources();
+      this.clearEndTimer();
+      this.emit();
+    }, remainingMs);
+  }
+  stopSources() {
+    for (const source of this.sources) {
+      try {
+        source.stop();
+      } catch {
+      }
+    }
+    this.sources.clear();
+  }
+  clearEndTimer() {
+    if (this.endTimer) clearTimeout(this.endTimer);
+    this.endTimer = null;
+  }
+  emit() {
+    if (!this.disposed) this.onChange(this.snapshot());
+  }
+};
+var AutoPlayGate = class {
+  constructor() {
+    this.firstAt = null;
+    this.firstDuration = 0;
+    this.firstCharacters = 0;
+  }
+  /** Call after each appended chunk; true when it is safe to start playing. */
+  ready(snapshot, progress, nowMs) {
+    if (this.firstAt === null) {
+      this.firstAt = nowMs;
+      this.firstDuration = snapshot.bufferedDuration;
+      this.firstCharacters = progress?.completedCharacters ?? 0;
+    }
+    const elapsed = (nowMs - this.firstAt) / 1e3;
+    const audioRate = elapsed > 0.25 ? (snapshot.bufferedDuration - this.firstDuration) / elapsed : 0;
+    const characterRate = elapsed > 0.25 ? ((progress?.completedCharacters ?? 0) - this.firstCharacters) / elapsed : 0;
+    const remaining = progress && characterRate > 0 ? (progress.totalCharacters - progress.completedCharacters) / characterRate : Number.POSITIVE_INFINITY;
+    const ahead = snapshot.bufferedDuration - snapshot.currentTime;
+    return ahead >= 4 && (audioRate >= 1.15 || ahead >= remaining + 3);
+  }
+};
+
+export {
+  ProgressivePlayer,
+  AutoPlayGate
+};

package/dist/{chunk-LG6HAWCK.js → chunk-56KO2LYN.js}

@@ -1,3 +1,22 @@
+// src/components/dialog-stack.ts
+var closers = [];
+function registerDialogCloser(close) {
+  closers.push(close);
+  return () => {
+    const index = closers.indexOf(close);
+    if (index >= 0) closers.splice(index, 1);
+  };
+}
+function isTopmostDialog(close) {
+  return closers[closers.length - 1] === close;
+}
+function dismissTopmostDialog() {
+  const close = closers[closers.length - 1];
+  if (!close) return false;
+  close();
+  return true;
+}
+
 // src/components/Dialog.tsx
 import { useCallback, useEffect, useId, useRef } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
@@ -11,13 +30,23 @@ function Dialog({
   closeOnBackdrop = true,
   className,
   bodyClassName,
-  footerClassName
+  footerClassName,
+  placement = "center",
+  titleHidden = false
 }) {
   const closeButtonRef = useRef(null);
   const dialogRef = useRef(null);
   const titleId = useId();
+  const closeRef = useRef(onClose);
+  closeRef.current = onClose;
+  const registeredClose = useRef(() => closeRef.current());
+  useEffect(() => {
+    const close = registeredClose.current;
+    return registerDialogCloser(close);
+  }, []);
   useEffect(() => {
     const onKey = (e) => {
+      if (!isTopmostDialog(registeredClose.current)) return;
       if (e.key === "Escape") {
         e.preventDefault();
         onClose();
@@ -49,7 +78,7 @@ function Dialog({
   }, [onClose]);
   useEffect(() => {
     const previousFocus = document.activeElement instanceof HTMLElement ? document.activeElement : null;
-    const target = initialFocusRef?.current ?? closeButtonRef.current;
+    const target = initialFocusRef?.current ?? closeButtonRef.current ?? dialogRef.current;
     target?.focus();
     return () => {
       if (previousFocus?.isConnected) previousFocus.focus();
@@ -65,7 +94,8 @@ function Dialog({
   const panelClassName = ["db-dialog", sizeClass, className].filter(Boolean).join(" ");
   const bodyClasses = ["db-dialog-body", bodyClassName].filter(Boolean).join(" ");
   const footerClasses = ["db-dialog-footer", footerClassName].filter(Boolean).join(" ");
-  return /* @__PURE__ */ jsx("div", { className: "db-dialog-overlay", onClick: handleBackdropClick, children: /* @__PURE__ */ jsxs(
+  const overlayClassName = placement === "top" ? "db-dialog-overlay db-dialog-overlay--top" : "db-dialog-overlay";
+  return /* @__PURE__ */ jsx("div", { className: overlayClassName, onClick: handleBackdropClick, children: /* @__PURE__ */ jsxs(
     "div",
     {
       ref: dialogRef,
@@ -75,7 +105,7 @@ function Dialog({
       "aria-labelledby": titleId,
       tabIndex: -1,
       children: [
-        /* @__PURE__ */ jsxs("div", { className: "db-dialog-header", children: [
+        titleHidden ? /* @__PURE__ */ jsx("h2", { id: titleId, className: "db-visually-hidden", children: title }) : /* @__PURE__ */ jsxs("div", { className: "db-dialog-header", children: [
           /* @__PURE__ */ jsx("h2", { id: titleId, className: "db-dialog-title", children: title }),
           /* @__PURE__ */ jsx(
             "button",
@@ -105,5 +135,6 @@ var FOCUSABLE_SELECTOR = [
 ].join(",");
 
 export {
+  dismissTopmostDialog,
   Dialog
 };