@anchrd/intel-ui 0.8.4 → 0.8.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchrd/intel-ui",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {

package/src/knowledge-editor/knowledge-editor.tsx

@@ -9,7 +9,7 @@ import { filterSuggestionItems } from "@blocknote/core";
 import { SuggestionMenuController, useCreateBlockNote } from "@blocknote/react";
 import { useMutation, useQuery } from "@tanstack/react-query";
 import { Link2 } from "lucide-react";
-import { useEffect, useMemo, useState } from "react";
+import { useEffect, useMemo, useRef, useState } from "react";
 import { ActionSlot } from "@/app/action-slot/action-slot.tsx";
 import { BlockNoteView, defaultSlashMenuItems } from "@/blocknote-view/blocknote-view.tsx";
 import type { IntelDataProvider } from "@/data/intel-data-provider/intel-data-provider.types.ts";
@@ -34,6 +34,28 @@ function storedBlocks(content: string | null): IntelEditorPartialBlock[] | undef
   }
 }
 
+/**
+ * What the editor holds, in a form two states can be compared by.
+ *
+ * ⚠️ This is what "unsaved" is answered with, and it deliberately is not "`onChange` fired". The
+ * editor changes for reasons that are not edits — loading the content is one (`replaceBlocks`
+ * below), and BlockNote normalizing a freshly mounted document is another. Neither is anything a
+ * reader did, and a warning that appears on every open is a warning nobody reads on the one day it
+ * is true. The canvas next door draws the same line with `editsNodes`/`editsEdges`.
+ *
+ * `id`s are part of it on purpose: BlockNote keeps them stable across edits within a session, and
+ * dropping them would call two different paragraphs equal whenever their text happens to match.
+ *
+ * ⚠️ It runs on every keystroke, and it walks the whole document to do so. That is affordable
+ * because `documentLinkIds` beside it already does, and because it is what buys the case a one-way
+ * flag cannot have: typing something and taking it back leaves nothing to save. There is no early
+ * exit — checking "already dirty, skip" is exactly what would lose that case. If documents ever
+ * grow far enough for this to be felt, the answer is to compare less often, not less carefully.
+ */
+function editorSnapshot(blocks: unknown): string {
+  return JSON.stringify(blocks);
+}
+
 export function KnowledgeEditor({
   data,
   document,
@@ -57,6 +79,13 @@ export function KnowledgeEditor({
     // conditional that this repo's `exactOptionalPropertyTypes` defeats, so it hands back the
     // default-schema editor even though it built Intel's. Same upstream seam as `BlockNoteView`.
   }) as unknown as IntelEditor;
+  // The content as it stands on the server, in comparable form. Every question of "is there
+  // anything to save" is answered against this, and saving moves it forward.
+  //
+  // ⚠️ A ref, not state: it is read inside `onChange` on every keystroke and must be the current
+  // value there, not the one captured when that handler was created. Nothing renders from it — what
+  // renders is `dirty` — so there is nothing to re-render when it moves.
+  const savedSnapshot = useRef(editorSnapshot(editor.document));
   const [dirty, setDirty] = useState(false);
   const [picking, setPicking] = useState(false);
   // Which documents the text links to right now. It is recomputed from the editor rather than from
@@ -69,25 +98,37 @@ export function KnowledgeEditor({
     queryFn: () => data.resolveKnowledgeLinks({ nodeIds: linkedIds }),
     enabled: linkedIds.length > 0,
   });
+  // One place decides whether there is anything to save, so the answer cannot differ between the
+  // button, the guard and the save itself.
+  function settle(): void {
+    setDirty(editorSnapshot(editor.document) !== savedSnapshot.current);
+  }
+
   const save = useMutation({
     mutationFn: async () => {
+      const blocks = editor.document;
       const payload = BlockNoteDocument.parse({
         format: "blocknote",
         schemaVersion: 1,
-        blocks: editor.document,
-        markdown: await editor.blocksToMarkdownLossy(editor.document),
+        blocks,
+        markdown: await editor.blocksToMarkdownLossy(blocks),
       });
-      return await data.saveKnowledge({
+      const node = await data.saveKnowledge({
         nodeId: document.node.id,
         baseVersionId: document.version?.id ?? null,
         content: JSON.stringify(payload),
         mediaType: BlockNoteMediaType,
         idempotencyKey: crypto.randomUUID(),
       });
+      // ⚠️ The snapshot of what was SENT, not of what stands in the editor when the answer comes
+      // back. Saving crosses the network, and typing during it is normal — taking the state at
+      // arrival would call that typing saved and lose it at the next navigation.
+      return { node, snapshot: editorSnapshot(blocks) };
     },
-    onSuccess: (saved) => {
-      setDirty(false);
-      onSaved(saved);
+    onSuccess: ({ node, snapshot }) => {
+      savedSnapshot.current = snapshot;
+      settle();
+      onSaved(node);
     },
   });
 
@@ -95,6 +136,11 @@ export function KnowledgeEditor({
     if (!document.content || initialBlocks) return;
     const blocks = editor.tryParseMarkdownToBlocks(document.content);
     editor.replaceBlocks(editor.document, blocks);
+    // ⚠️ Loading the content IS a change to the editor, and `onChange` reports it as one. This is
+    // the line that keeps a document nobody has touched from asking to be saved: what was just
+    // loaded is by definition what is stored.
+    savedSnapshot.current = editorSnapshot(editor.document);
+    setDirty(false);
   }, [document.content, editor, initialBlocks]);
 
   function insertLink(nodeId: string): void {
@@ -105,7 +151,7 @@ export function KnowledgeEditor({
       " ",
     ]);
     setPicking(false);
-    setDirty(true);
+    settle();
     setLinkedIds(documentLinkIds(editor.document));
   }
 
@@ -135,7 +181,7 @@ export function KnowledgeEditor({
           <BlockNoteView
             editor={editor}
             onChange={() => {
-              setDirty(true);
+              settle();
               setLinkedIds(documentLinkIds(editor.document));
             }}
           >