@bendyline/docblocks-react 2.6.2 → 2.7.1

package/dist/QuickOpenDialog-2KK4SEBU.js

@@ -0,0 +1,356 @@
+import {
+  HighlightedText
+} from "./chunk-TBLZBNQF.js";
+import {
+  displayFileName
+} from "./chunk-ARATARVJ.js";
+import {
+  Dialog
+} from "./chunk-56KO2LYN.js";
+
+// src/QuickOpen/QuickOpenDialog.tsx
+import { useEffect, useId, useMemo, useRef, useState } from "react";
+import { tryParseWorkspacePath } from "@bendyline/docblocks/filesystem";
+
+// src/QuickOpen/quick-open-ranking.ts
+import { fuzzyMatch, fuzzyTokens } from "@bendyline/docblocks/workspace-index";
+var DEFAULT_LIMIT = 50;
+var EMPTY_QUERY_LIMIT = 20;
+var RECENCY_HORIZON = 50;
+var RECENCY_WEIGHT = 0.25;
+var PINNED_WEIGHT = 0.05;
+var DOCUMENT_WEIGHT = 0.03;
+function splitPath(path) {
+  const slash = path.lastIndexOf("/");
+  return slash < 0 ? { folder: "", base: path } : { folder: path.slice(0, slash), base: path.slice(slash + 1) };
+}
+function stemOf(name) {
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function item(candidate, ranges) {
+  return {
+    key: `${candidate.workspaceId}\0${candidate.path}`,
+    workspaceId: candidate.workspaceId,
+    workspaceName: candidate.workspaceName,
+    path: candidate.path,
+    name: candidate.name,
+    folder: candidate.folder,
+    title: candidate.title,
+    nameRanges: ranges?.nameRanges ?? [],
+    folderRanges: ranges?.folderRanges ?? [],
+    titleRanges: ranges?.titleRanges ?? [],
+    recent: candidate.recentRank >= 0,
+    pinned: candidate.pinned
+  };
+}
+function buildCandidates(input) {
+  const titles = new Map(
+    input.documents.map((document2) => [document2.path, document2.title])
+  );
+  const recentRank = new Map(input.recent.map((path, rank) => [path, rank]));
+  const pinnedHere = new Set(
+    input.pins.filter((pin) => pin.workspaceId === input.workspaceId).map((pin) => pin.path)
+  );
+  const candidates = input.files.map((file) => {
+    const { folder } = splitPath(file.path);
+    const name = displayFileName(file.name);
+    const title = titles.get(file.path) ?? null;
+    return {
+      workspaceId: input.workspaceId,
+      workspaceName: null,
+      path: file.path,
+      name,
+      folder,
+      title: title && title !== stemOf(file.name) && title !== name ? title : null,
+      isDocument: file.kind !== "other",
+      recentRank: recentRank.get(file.path) ?? -1,
+      pinned: pinnedHere.has(file.path)
+    };
+  });
+  for (const pin of input.pins) {
+    if (pin.workspaceId === input.workspaceId) continue;
+    const { folder, base } = splitPath(pin.path);
+    candidates.push({
+      workspaceId: pin.workspaceId,
+      workspaceName: pin.workspaceName,
+      path: pin.path,
+      name: displayFileName(base),
+      folder,
+      title: null,
+      isDocument: true,
+      recentRank: -1,
+      pinned: true
+    });
+  }
+  return candidates;
+}
+function emptyQuery(input, candidates) {
+  const byPath = new Map(
+    candidates.filter((candidate) => candidate.workspaceId === input.workspaceId).map((candidate) => [candidate.path, candidate])
+  );
+  const shown = /* @__PURE__ */ new Set();
+  const items = [];
+  const add = (candidate) => {
+    if (!candidate) return;
+    const key = `${candidate.workspaceId}\0${candidate.path}`;
+    const active = candidate.workspaceId === input.workspaceId && candidate.path === input.activePath;
+    if (shown.has(key) || active) return;
+    shown.add(key);
+    items.push(item(candidate));
+  };
+  for (const path of input.recent) add(byPath.get(path));
+  for (const candidate of candidates) if (candidate.pinned) add(candidate);
+  const lastModified = new Map(input.files.map((file) => [file.path, file.lastModified]));
+  const modified = [...byPath.values()].sort(
+    (left, right) => compareCodeUnits(lastModified.get(right.path) ?? "", lastModified.get(left.path) ?? "") || compareCodeUnits(left.path, right.path)
+  );
+  for (const candidate of modified) {
+    if (items.length >= EMPTY_QUERY_LIMIT) break;
+    add(candidate);
+  }
+  return items;
+}
+var FIELD_WEIGHTS = { name: 1, title: 0.9, folder: 0.6, path: 1 };
+function bestField(token, candidate) {
+  const fields = token.includes("/") ? [["path", candidate.folder ? `${candidate.folder}/${candidate.name}` : candidate.name]] : [
+    ["name", candidate.name],
+    ["title", candidate.title],
+    ["folder", candidate.folder]
+  ];
+  let best = null;
+  for (const [field, text] of fields) {
+    if (!text) continue;
+    const match = fuzzyMatch(token, text);
+    if (!match) continue;
+    const score = match.score * FIELD_WEIGHTS[field];
+    if (!best || score > best.score) best = { score, field, ranges: match.ranges };
+  }
+  return best;
+}
+function mergeRanges(ranges) {
+  const sorted = [...ranges].sort((left, right) => left[0] - right[0]);
+  const merged = [];
+  for (const [start, end] of sorted) {
+    const last = merged[merged.length - 1];
+    if (last && start <= last[1]) last[1] = Math.max(last[1], end);
+    else merged.push([start, end]);
+  }
+  return merged;
+}
+function rankQuickOpen(input) {
+  const candidates = buildCandidates(input);
+  const tokens = fuzzyTokens(input.query);
+  if (tokens.length === 0) return emptyQuery(input, candidates);
+  const perfect = tokens.reduce(
+    (total, token) => total + (fuzzyMatch(token, token)?.score ?? 0),
+    0
+  );
+  const scored = [];
+  for (const candidate of candidates) {
+    let score = 0;
+    const ranges = {
+      name: [],
+      title: [],
+      folder: []
+    };
+    let matched = true;
+    for (const token of tokens) {
+      const best = bestField(token, candidate);
+      if (!best) {
+        matched = false;
+        break;
+      }
+      score += best.score;
+      if (best.field === "path") {
+        const offset = candidate.folder ? candidate.folder.length + 1 : 0;
+        for (const [start, end] of best.ranges) {
+          if (end <= candidate.folder.length) ranges.folder.push([start, end]);
+          else if (start >= offset) ranges.name.push([start - offset, end - offset]);
+          else {
+            ranges.folder.push([start, candidate.folder.length]);
+            ranges.name.push([0, end - offset]);
+          }
+        }
+      } else {
+        ranges[best.field].push(...best.ranges);
+      }
+    }
+    if (!matched) continue;
+    if (candidate.recentRank >= 0 && candidate.recentRank < RECENCY_HORIZON) {
+      score += perfect * RECENCY_WEIGHT * (1 - candidate.recentRank / RECENCY_HORIZON);
+    }
+    if (candidate.pinned) score += perfect * PINNED_WEIGHT;
+    if (candidate.isDocument) score += perfect * DOCUMENT_WEIGHT;
+    scored.push({
+      score,
+      item: item(candidate, {
+        nameRanges: mergeRanges(ranges.name),
+        titleRanges: mergeRanges(ranges.title),
+        folderRanges: mergeRanges(ranges.folder)
+      })
+    });
+  }
+  scored.sort(
+    (left, right) => right.score - left.score || left.item.path.length - right.item.path.length || compareCodeUnits(left.item.path, right.item.path)
+  );
+  return scored.slice(0, input.limit ?? DEFAULT_LIMIT).map((entry) => entry.item);
+}
+
+// src/QuickOpen/QuickOpenDialog.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var PAGE = 10;
+function statusMessage(status, query, count) {
+  if (status.error) return status.error;
+  if (!status.listed) return "Listing workspace\u2026";
+  if (query.trim() && count === 0) return "No matching documents";
+  if (status.truncated) return "Large workspace: some files are not listed.";
+  return null;
+}
+function QuickOpenDialog({
+  index,
+  status,
+  workspaceId,
+  activePath,
+  recent,
+  pins,
+  focusRequest,
+  onOpen,
+  onClose
+}) {
+  const inputRef = useRef(null);
+  const listId = useId();
+  const optionPrefix = useId();
+  const [query, setQuery] = useState("");
+  const [active, setActive] = useState(0);
+  const canonicalActive = activePath === null ? null : tryParseWorkspacePath(activePath);
+  const items = useMemo(
+    () => rankQuickOpen({
+      query,
+      workspaceId,
+      files: index?.getFiles() ?? [],
+      documents: index?.getDocuments() ?? [],
+      recent,
+      pins,
+      activePath: canonicalActive
+    }),
+    // `status.generation` stands in for the index's contents.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [query, workspaceId, index, status.generation, recent, pins, canonicalActive]
+  );
+  useEffect(() => {
+    const first = items[0];
+    const skipActive = items.length > 1 && first?.workspaceId === workspaceId && first.path === canonicalActive;
+    setActive(skipActive ? 1 : 0);
+  }, [query]);
+  useEffect(() => {
+    inputRef.current?.focus();
+    inputRef.current?.select();
+  }, [focusRequest]);
+  const activeIndex = Math.min(active, Math.max(0, items.length - 1));
+  const activeId = items.length > 0 ? `${optionPrefix}-${activeIndex}` : void 0;
+  useEffect(() => {
+    if (activeId) document.getElementById(activeId)?.scrollIntoView({ block: "nearest" });
+  }, [activeId]);
+  const move = (delta) => {
+    if (items.length === 0) return;
+    setActive(Math.max(0, Math.min(items.length - 1, activeIndex + delta)));
+  };
+  const onKeyDown = (event) => {
+    switch (event.key) {
+      case "ArrowDown":
+        event.preventDefault();
+        move(1);
+        break;
+      case "ArrowUp":
+        event.preventDefault();
+        move(-1);
+        break;
+      case "PageDown":
+        event.preventDefault();
+        move(PAGE);
+        break;
+      case "PageUp":
+        event.preventDefault();
+        move(-PAGE);
+        break;
+      case "Enter": {
+        event.preventDefault();
+        const chosen = items[activeIndex];
+        if (chosen) onOpen(chosen);
+        break;
+      }
+      default:
+        break;
+    }
+  };
+  const message = statusMessage(status, query, items.length);
+  return /* @__PURE__ */ jsxs(
+    Dialog,
+    {
+      title: "Go to document",
+      onClose,
+      size: "wide",
+      placement: "top",
+      titleHidden: true,
+      initialFocusRef: inputRef,
+      className: "db-quick-open",
+      bodyClassName: "db-quick-open-body",
+      children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            ref: inputRef,
+            className: "db-quick-open-input",
+            type: "text",
+            role: "combobox",
+            "aria-label": "Go to document",
+            "aria-expanded": items.length > 0,
+            "aria-controls": listId,
+            "aria-activedescendant": activeId,
+            "aria-autocomplete": "list",
+            autoComplete: "off",
+            spellCheck: false,
+            placeholder: "Search documents by name or title",
+            value: query,
+            onChange: (event) => setQuery(event.target.value),
+            onKeyDown
+          }
+        ),
+        /* @__PURE__ */ jsx("ul", { id: listId, role: "listbox", "aria-label": "Documents", className: "db-quick-open-list", children: items.map((item2, position) => /* @__PURE__ */ jsxs(
+          "li",
+          {
+            id: `${optionPrefix}-${position}`,
+            role: "option",
+            "aria-selected": position === activeIndex,
+            className: position === activeIndex ? "db-quick-open-option db-quick-open-option--active" : "db-quick-open-option",
+            onMouseDown: (event) => event.preventDefault(),
+            onMouseMove: () => {
+              if (position !== activeIndex) setActive(position);
+            },
+            onClick: () => onOpen(item2),
+            children: [
+              /* @__PURE__ */ jsx("span", { className: "db-quick-open-name", children: /* @__PURE__ */ jsx(HighlightedText, { text: item2.name, ranges: item2.nameRanges }) }),
+              item2.title && /* @__PURE__ */ jsx("span", { className: "db-quick-open-title", children: /* @__PURE__ */ jsx(HighlightedText, { text: item2.title, ranges: item2.titleRanges }) }),
+              /* @__PURE__ */ jsxs("span", { className: "db-quick-open-folder", children: [
+                item2.workspaceName && /* @__PURE__ */ jsxs(Fragment, { children: [
+                  item2.workspaceName,
+                  " \xB7 "
+                ] }),
+                /* @__PURE__ */ jsx(HighlightedText, { text: item2.folder, ranges: item2.folderRanges })
+              ] })
+            ]
+          },
+          item2.key
+        )) }),
+        /* @__PURE__ */ jsx("p", { className: "db-quick-open-status", role: "status", children: message })
+      ]
+    }
+  );
+}
+export {
+  QuickOpenDialog
+};

package/dist/Settings-DuXk6baH.d.ts

@@ -0,0 +1,144 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { DocBlocksHostAiAPI } from '@bendyline/docblocks/host';
+import { ReactNode } from 'react';
+import { WriteCanvasSettings } from '@bendyline/squisq-editor-react';
+
+/** Appearance preferences shared by the shell and settings UI. */
+type ThemePreference = 'auto' | 'light' | 'dark';
+declare const ACCENT_COLORS: readonly ["brown", "green", "blue", "purple", "maroon", "orange", "gray"];
+type AccentColor = (typeof ACCENT_COLORS)[number];
+/**
+ * Which typeface the shell chrome uses.
+ *
+ * `system` resolves `system-ui`, so DocBlocks looks native on each platform —
+ * the right default, and what almost everyone should keep. `fixed` pins the
+ * chrome to the bundled `DocBlocks Fixed UI` face (the Roboto variable binary
+ * already shipped for the document theme of that name) so the interface renders
+ * identically everywhere.
+ *
+ * Two things want that. A user working across machines gets typography that
+ * does not shift between them. And the visual-regression suite gets a rendering
+ * it can compare across operating systems at all: under `system` the same
+ * screenshot differs on every platform, which is why those baselines are
+ * otherwise captured on one OS and compared only there.
+ */
+type InterfaceFontPreference = 'system' | 'fixed';
+declare const DEFAULT_INTERFACE_FONT: InterfaceFontPreference;
+declare function loadInterfaceFont(): InterfaceFontPreference;
+declare function saveInterfaceFont(value: InterfaceFontPreference): void;
+
+/**
+ * Stable ids for the Write-canvas font schemes offered in Settings. This list
+ * mirrors `DOCBLOCKS_WRITE_CANVAS_FONT_SCHEMES` in `@bendyline/docblocks/vscode`
+ * (the wire/persisted contract) and the `docblocks.writeCanvasFontScheme` enum
+ * in the VS Code `package.json`; a guard test keeps the three in sync.
+ */
+type WriteCanvasFontScheme = 'theme' | 'serif-sans' | 'sans-sans' | 'serif-serif' | 'pt-serif' | 'hanken' | 'playfair-pt-serif' | 'hanken-lora' | 'dm-serif-dm-sans' | 'inter';
+type WriteCanvasFontSchemeGroup = 'theme' | 'system' | 'curated';
+interface WriteCanvasFontSchemeOption {
+    id: WriteCanvasFontScheme;
+    label: string;
+    group: WriteCanvasFontSchemeGroup;
+    /** CSS font-family for headings. Omitted for `'theme'` (inherit). */
+    headerFont?: string;
+    /** CSS font-family for body text. Omitted for `'theme'` (inherit). */
+    bodyFont?: string;
+}
+/**
+ * Curated Write-canvas font schemes, in picker order. A named scheme is an
+ * explicit user preference and overrides the active theme in Write mode through
+ * the DocBlocks host stylesheet. `'theme'` sets no fonts, i.e. inherits the
+ * active theme / host as before.
+ */
+declare const WRITE_CANVAS_FONT_SCHEMES: readonly WriteCanvasFontSchemeOption[];
+declare const DEFAULT_WRITE_CANVAS_FONT_SCHEME: WriteCanvasFontScheme;
+/** Resolve a scheme id to the header/body CSS font-family strings (empty for `'theme'`). */
+declare function resolveWriteCanvasFonts(scheme: WriteCanvasFontScheme): Pick<WriteCanvasSettings, 'headerFont' | 'bodyFont'>;
+/** Persisted Write-canvas preferences. Stores the font scheme id, not resolved fonts. */
+interface WriteCanvasPreferences {
+    textSize: number;
+    lineSpacing: number;
+    fontScheme: WriteCanvasFontScheme;
+}
+
+/**
+ * Inline proofing preferences — which squiggles the editor draws.
+ *
+ * Two independent switches rather than one, because they fail
+ * differently: spell checking is language-agnostic enough to leave on
+ * everywhere, while the grammar rules harper ships are English-only and
+ * are noise in a document written in anything else. The engine itself is
+ * still all-or-nothing (harper lints once and reports a category per
+ * finding), so these filter what surfaces; turning both off is what
+ * turns proofing — and the ~30 MiB engine download — off entirely.
+ *
+ * Stored per browser/profile, never in the document: a reader's tolerance
+ * for green underlines is not content. The per-document opt-out lives in
+ * `squisq-proofing` frontmatter and is separate from this.
+ */
+interface ProofingPreferences {
+    /** Draw red squiggles under misspellings. */
+    spelling: boolean;
+    /** Draw green/blue squiggles under grammar and style findings. */
+    grammar: boolean;
+}
+declare const DEFAULT_PROOFING_PREFERENCES: Readonly<ProofingPreferences>;
+declare function loadProofingPreferences(): ProofingPreferences;
+declare function saveProofingPreferences(value: ProofingPreferences): void;
+
+interface AiSettingsControlsProps {
+    ai: DocBlocksHostAiAPI;
+}
+declare function AiSettingsControls({ ai }: AiSettingsControlsProps): react_jsx_runtime.JSX.Element | null;
+
+interface SettingsDialogProps {
+    title?: string;
+    onClose: () => void;
+    children: ReactNode;
+}
+declare function SettingsDialog({ title, onClose, children }: SettingsDialogProps): react_jsx_runtime.JSX.Element;
+interface ThemeSettingsProps {
+    value: ThemePreference;
+    onChange: (theme: ThemePreference) => void;
+    name?: string;
+}
+declare function ThemeSettings({ value, onChange, name }: ThemeSettingsProps): react_jsx_runtime.JSX.Element;
+interface InterfaceFontSettingsProps {
+    value: InterfaceFontPreference;
+    onChange: (font: InterfaceFontPreference) => void;
+    name?: string;
+}
+/**
+ * Choose the typeface for the app's own chrome, not for documents.
+ *
+ * The default follows the operating system, which is what almost everyone
+ * should keep. The bundled option exists for two reasons worth stating in the
+ * UI: identical typography across machines, and a rendering that is the same
+ * everywhere — which is what lets the visual-regression suite compare one set
+ * of baselines across operating systems at all.
+ */
+declare function InterfaceFontSettings({ value, onChange, name, }: InterfaceFontSettingsProps): react_jsx_runtime.JSX.Element;
+interface AccentColorSettingsProps {
+    value: AccentColor;
+    onChange: (color: AccentColor) => void;
+    name?: string;
+}
+declare function AccentColorSettings({ value, onChange, name, }: AccentColorSettingsProps): react_jsx_runtime.JSX.Element;
+interface ProofingSettingsControlsProps {
+    value: ProofingPreferences;
+    onChange: (settings: ProofingPreferences) => void;
+}
+/**
+ * Spelling and grammar squiggles, as two switches. Grammar is separable
+ * because harper's grammar rules are English-only — a writer working in
+ * another language wants the spell checker and none of the green
+ * underlines. With both off no checking engine is ever downloaded.
+ */
+declare function ProofingSettingsControls({ value, onChange }: ProofingSettingsControlsProps): react_jsx_runtime.JSX.Element;
+interface WriteCanvasSettingsControlsProps {
+    value: WriteCanvasPreferences;
+    onChange: (settings: WriteCanvasPreferences) => void;
+}
+declare function WriteCanvasSettingsControls({ value, onChange }: WriteCanvasSettingsControlsProps): react_jsx_runtime.JSX.Element;
+
+export { type AccentColor as A, DEFAULT_INTERFACE_FONT as D, type InterfaceFontPreference as I, type ProofingPreferences as P, SettingsDialog as S, type ThemePreference as T, WRITE_CANVAS_FONT_SCHEMES as W, AccentColorSettings as a, type AccentColorSettingsProps as b, AiSettingsControls as c, type AiSettingsControlsProps as d, DEFAULT_PROOFING_PREFERENCES as e, DEFAULT_WRITE_CANVAS_FONT_SCHEME as f, InterfaceFontSettings as g, type InterfaceFontSettingsProps as h, ProofingSettingsControls as i, type ProofingSettingsControlsProps as j, type SettingsDialogProps as k, ThemeSettings as l, type ThemeSettingsProps as m, type WriteCanvasFontScheme as n, type WriteCanvasFontSchemeGroup as o, type WriteCanvasFontSchemeOption as p, type WriteCanvasPreferences as q, WriteCanvasSettingsControls as r, type WriteCanvasSettingsControlsProps as s, loadInterfaceFont as t, loadProofingPreferences as u, resolveWriteCanvasFonts as v, saveInterfaceFont as w, saveProofingPreferences as x };