@bendyline/docblocks-react 2.4.0 → 2.6.0

package/dist/proofing/index.d.ts

@@ -0,0 +1,112 @@
+import { ProofingIgnoreStore, ProofingProvider } from '@bendyline/squisq-editor-react';
+
+/**
+ * The app-level proofing dictionary — words the user accepted through
+ * "Add to dictionary" that should stay accepted everywhere on this device.
+ *
+ * This is deliberately separate from a document's own
+ * `squisq-proof-dictionary` frontmatter, which travels with the file. A name
+ * the user writes in every document belongs here; a term specific to one
+ * document belongs in that document.
+ *
+ * Surfaces without durable web storage (the VS Code webview uses the host's
+ * state API rather than `localStorage`) pass no store, and only the per-document
+ * frontmatter dictionary applies.
+ */
+/** Where accepted words are remembered between sessions. */
+interface ProofingDictionaryStore {
+    /** Every accepted word, in no particular order. */
+    read(): readonly string[];
+    /** Remember one more accepted word. Duplicates are harmless. */
+    append(word: string): void;
+}
+/**
+ * Browser-local app dictionary, shared by every workspace on this device.
+ *
+ * Used by the site and by the Electron renderer, whose `app://` origin keeps
+ * `localStorage` stable across launches and updates.
+ */
+declare function createLocalProofingDictionary(): ProofingDictionaryStore;
+
+/**
+ * Browser-local persistence for dismissed ("Ignore") proofing findings.
+ *
+ * Squisq deliberately never writes dismissals into the document — they are
+ * one person's editing preference, and a file travelling through git must not
+ * carry them to everyone else. So the engine's state is handed to the host,
+ * scoped per document, and DocBlocks keeps it beside its other browser-local
+ * preferences.
+ *
+ * The stored payload is the engine's OPAQUE export: it holds context hashes as
+ * integers above 2^53, so it is only ever moved as a string and handed back
+ * verbatim. Nothing here parses it.
+ *
+ * Entries are keyed by workspace **and** path, matching `last-state` and
+ * `pinned-documents`: the same relative path means different documents in
+ * different workspaces, and dismissals must not leak between them.
+ */
+
+interface ProofingIgnoreStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+/** Composite key for one document. `\u0000` cannot occur in either half. */
+declare function proofingIgnoreKey(workspaceId: string, documentPath: string): string;
+/**
+ * Create the store DocBlocks hands to Squisq.
+ *
+ * `resolveWorkspaceId` is read at call time rather than captured, because the
+ * active workspace changes underneath a mounted shell. A store created while
+ * no workspace is active simply does not persist: an unsaved scratch buffer
+ * keeping its dismissals only for the session is the documented behavior.
+ */
+declare function createLocalProofingIgnoreStore(resolveWorkspaceId: () => string | null, storageOverride?: ProofingIgnoreStorage | null): ProofingIgnoreStore;
+
+/**
+ * Host wiring for Squisq's proofing capability — grammar and spellcheck by
+ * [harper.js](https://github.com/Automattic/harper), Apache-2.0, running
+ * entirely offline in a Web Worker.
+ *
+ * Every DocBlocks surface serves the same engine from its own origin, because
+ * there is no CDN fallback and nothing may leave the device: the site
+ * publishes it beside the PWA precache, the Electron renderer inside
+ * `app.asar`, the VS Code webview inside the VSIX. Only two things differ per
+ * surface — where the WASM lives and where an accepted word is remembered —
+ * so those are the parameters here and everything else is shared.
+ *
+ * Nothing is downloaded by creating a provider. Squisq loads the engine
+ * lazily, on the first markdown document with checking effective, so the
+ * shell paints and the document opens whether or not the ~30 MiB binary pair
+ * has arrived. A failed load is retried on the next use rather than cached.
+ */
+
+interface DocBlocksProofingOptions {
+    /**
+     * URL of harper's full WASM binary as this surface publishes it. May be
+     * root- or base-relative; the engine absolutizes it against the page before
+     * handing it to the worker that does the fetching.
+     *
+     * The build must publish `harper_wasm_slim_bg.wasm` in the same directory:
+     * the engine derives that sibling by substituting the file name and loads
+     * both. See `scripts/vite-harper-wasm.ts`.
+     */
+    wasmUrl: string;
+    /**
+     * Where "Add to dictionary" persists app-wide. Omit for surfaces without
+     * durable storage — a document's own `squisq-proof-dictionary` frontmatter
+     * still applies either way.
+     */
+    dictionary?: ProofingDictionaryStore | null;
+}
+/**
+ * Create the proofing provider a DocBlocks surface passes to its shell.
+ *
+ * Hold the result in module scope rather than creating one per render. The
+ * shell remounts the editor on every document switch, and a host-owned
+ * instance keeps the warm engine (a cold WASM setup costs seconds) alive
+ * across those remounts; a provider the editor owns would be disposed and
+ * rebuilt each time.
+ */
+declare function createDocBlocksProofingProvider(options: DocBlocksProofingOptions): ProofingProvider;
+
+export { type DocBlocksProofingOptions, type ProofingDictionaryStore, type ProofingIgnoreStorage, createDocBlocksProofingProvider, createLocalProofingDictionary, createLocalProofingIgnoreStore, proofingIgnoreKey };

package/dist/proofing/index.js

@@ -0,0 +1,50 @@
+import {
+  createLocalProofingIgnoreStore,
+  proofingIgnoreKey
+} from "../chunk-DUKTAKB4.js";
+
+// src/Proofing/public-api.ts
+import { createHarperProofingProvider } from "@bendyline/squisq-editor-react/proofing";
+
+// src/Proofing/proofing-dictionary.ts
+var STORAGE_KEY = "docblocks:proofingDictionary";
+function readWords() {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((word) => typeof word === "string");
+  } catch {
+    return [];
+  }
+}
+function createLocalProofingDictionary() {
+  return {
+    read: readWords,
+    append(word) {
+      try {
+        const words = new Set(readWords());
+        words.add(word);
+        localStorage.setItem(STORAGE_KEY, JSON.stringify([...words]));
+      } catch {
+      }
+    }
+  };
+}
+
+// src/Proofing/public-api.ts
+function createDocBlocksProofingProvider(options) {
+  const { wasmUrl, dictionary } = options;
+  return createHarperProofingProvider({
+    wasmUrl,
+    initialWords: dictionary?.read() ?? [],
+    onDictionaryWord: dictionary ? (word) => dictionary.append(word) : void 0
+  });
+}
+export {
+  createDocBlocksProofingProvider,
+  createLocalProofingDictionary,
+  createLocalProofingIgnoreStore,
+  proofingIgnoreKey
+};

package/dist/settings/index.d.ts

@@ -41,6 +41,31 @@ interface WriteCanvasPreferences {
     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 SettingsDialogProps {
     title?: string;
     onClose: () => void;
@@ -59,10 +84,21 @@ interface AccentColorSettingsProps {
     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, AccentColorSettings, type AccentColorSettingsProps, DEFAULT_WRITE_CANVAS_FONT_SCHEME, SettingsDialog, type SettingsDialogProps, type ThemePreference, ThemeSettings, type ThemeSettingsProps, WRITE_CANVAS_FONT_SCHEMES, type WriteCanvasFontScheme, type WriteCanvasFontSchemeGroup, type WriteCanvasFontSchemeOption, type WriteCanvasPreferences, WriteCanvasSettingsControls, type WriteCanvasSettingsControlsProps, resolveWriteCanvasFonts };
+export { type AccentColor, AccentColorSettings, type AccentColorSettingsProps, DEFAULT_PROOFING_PREFERENCES, DEFAULT_WRITE_CANVAS_FONT_SCHEME, type ProofingPreferences, ProofingSettingsControls, type ProofingSettingsControlsProps, SettingsDialog, type SettingsDialogProps, type ThemePreference, ThemeSettings, type ThemeSettingsProps, WRITE_CANVAS_FONT_SCHEMES, type WriteCanvasFontScheme, type WriteCanvasFontSchemeGroup, type WriteCanvasFontSchemeOption, type WriteCanvasPreferences, WriteCanvasSettingsControls, type WriteCanvasSettingsControlsProps, loadProofingPreferences, resolveWriteCanvasFonts, saveProofingPreferences };

package/dist/settings/index.js

@@ -1,19 +1,27 @@
 import {
   AccentColorSettings,
+  DEFAULT_PROOFING_PREFERENCES,
   DEFAULT_WRITE_CANVAS_FONT_SCHEME,
+  ProofingSettingsControls,
   SettingsDialog,
   ThemeSettings,
   WRITE_CANVAS_FONT_SCHEMES,
   WriteCanvasSettingsControls,
-  resolveWriteCanvasFonts
-} from "../chunk-VRRL6VTD.js";
+  loadProofingPreferences,
+  resolveWriteCanvasFonts,
+  saveProofingPreferences
+} from "../chunk-Q6XNIKDG.js";
 import "../chunk-LG6HAWCK.js";
 export {
   AccentColorSettings,
+  DEFAULT_PROOFING_PREFERENCES,
   DEFAULT_WRITE_CANVAS_FONT_SCHEME,
+  ProofingSettingsControls,
   SettingsDialog,
   ThemeSettings,
   WRITE_CANVAS_FONT_SCHEMES,
   WriteCanvasSettingsControls,
-  resolveWriteCanvasFonts
+  loadProofingPreferences,
+  resolveWriteCanvasFonts,
+  saveProofingPreferences
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/docblocks-react",
-  "version": "2.4.0",
+  "version": "2.6.0",
   "description": "React components for DocBlocks — file explorer, workspace picker, and editor shell",
   "license": "MIT",
   "author": "Bendyline",
@@ -21,7 +21,7 @@
     "access": "public"
   },
   "engines": {
-    "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
+    "node": "^24.18.0 || >=26.0.0"
   },
   "type": "module",
   "main": "./dist/index.js",
@@ -47,6 +47,16 @@
       "import": "./dist/export/index.js",
       "default": "./dist/export/index.js"
     },
+    "./calculation": {
+      "types": "./dist/calculation/index.d.ts",
+      "import": "./dist/calculation/index.js",
+      "default": "./dist/calculation/index.js"
+    },
+    "./proofing": {
+      "types": "./dist/proofing/index.d.ts",
+      "import": "./dist/proofing/index.js",
+      "default": "./dist/proofing/index.js"
+    },
     "./settings": {
       "types": "./dist/settings/index.d.ts",
       "import": "./dist/settings/index.js",
@@ -75,16 +85,19 @@
     }
   },
   "dependencies": {
-    "@bendyline/docblocks": "2.4.0",
-    "@bendyline/squisq": "2.8.0",
-    "@bendyline/squisq-editor-react": "2.8.0",
-    "@bendyline/squisq-formats": "2.4.5",
-    "@bendyline/squisq-react": "2.8.0",
-    "@bendyline/squisq-video": "2.3.0",
-    "@bendyline/squisq-video-react": "2.4.0"
+    "@bendyline/docblocks": "2.6.0",
+    "@bendyline/squisq": "2.11.1",
+    "@bendyline/squisq-calc": "2.11.0",
+    "@bendyline/squisq-editor-react": "2.11.1",
+    "@bendyline/squisq-formats": "2.6.1",
+    "@bendyline/squisq-react": "2.11.1",
+    "@bendyline/squisq-video": "2.3.4",
+    "@bendyline/squisq-video-react": "2.4.5",
+    "qrcode": "1.5.4"
   },
   "devDependencies": {
     "@happy-dom/global-registrator": "20.9.0",
+    "@types/qrcode": "1.5.6",
     "@types/react": "18.3.28",
     "@types/react-dom": "18.3.7",
     "happy-dom": "20.9.0",