@anchrd/intel-ui 0.8.3 → 0.8.5

package/package.json

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

package/src/data/intel-data-provider/intel-data-provider.ts

@@ -1,6 +1,7 @@
 import {
   AppendKnowledgeTableRowsInput,
   AppendKnowledgeTableRowsResult,
+  ArchiveFlowInput,
   ArchiveKnowledgeNodeInput,
   CompleteFlowRunStepInput,
   CreateFlowInput,
@@ -159,6 +160,9 @@ export function createIntelDataProvider(
     const params = new URLSearchParams(
       query.parentId === undefined ? {} : { parentId: query.parentId ?? "" },
     );
+    // Same rule as `parentId`: only the asked-for case is sent. The default is the server's, and a
+    // provider that spells it out anyway would have to be changed whenever the server's is.
+    if (query.includeArchived) params.set("includeArchived", "true");
     const search = params.toString();
     return await request(`/flows${search ? `?${search}` : ""}`, FlowList);
   }
@@ -366,6 +370,13 @@ export function createIntelDataProvider(
         body: JSON.stringify(parsed),
       });
     },
+    async archiveFlow(input) {
+      const parsed = ArchiveFlowInput.parse(input);
+      return await request(`/flows/${encodeURIComponent(parsed.flowId)}/archive`, Flow, {
+        method: "POST",
+        body: JSON.stringify(parsed),
+      });
+    },
     async saveFlow(input) {
       const parsed = SaveFlowVersionInput.parse(input);
       return await request(`/flows/${encodeURIComponent(parsed.flowId)}/versions`, FlowDocument, {

package/src/data/intel-data-provider/intel-data-provider.types.ts

@@ -1,6 +1,7 @@
 import type {
   AppendKnowledgeTableRowsInput,
   AppendKnowledgeTableRowsResult,
+  ArchiveFlowInput,
   ArchiveKnowledgeNodeInput,
   CompleteFlowRunStepInput,
   CreateFlowInput,
@@ -117,6 +118,9 @@ export interface IntelDataProvider {
   getFlowRequirements(flowId: string): Promise<FlowRequirements>;
   createFlow(input: CreateFlowInput): Promise<Flow>;
   updateFlow(input: UpdateFlowInput): Promise<Flow>;
+  // Archive a flow or take it back out. An archived flow leaves the tree, stops being startable and
+  // stops resolving as another flow's callee; its versions stay untouched.
+  archiveFlow(input: ArchiveFlowInput): Promise<Flow>;
   saveFlow(input: SaveFlowVersionInput): Promise<FlowDocument>;
   // Which version each sub-flow call will take once published, and which of them publishing
   // freezes. Read before publishing, so the author agrees to the pins rather than discovering them.

package/src/i18n/en.json

@@ -72,6 +72,7 @@
   "resource.menu": "More actions for {title}",
   "resource.rename": "Rename",
   "resource.renameTitle": "Rename {title}",
+  "resource.archive": "Archive",
   "resource.conflict": "It was not changed: somebody else changed this entry first. Reload it and try again.",
   "resource.forbidden": "It was not changed: you may not change this entry.",
   "resource.failed": "The change was not saved. Reload the latest version and try again.",
@@ -114,7 +115,6 @@
   "knowledge.shareUnreadableHint": "Nothing is blocked. A run of those flows will simply stop at that step for them.",
   "knowledge.versions": "Version history",
   "knowledge.version": "Version {sequence}",
-  "knowledge.archive": "Archive",
   "view.showGraph": "Show this level as a graph",
   "view.showEditor": "Back to the editor",
   "view.showRuns": "Show this flow's runs",

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));
             }}
           >

package/src/resource-menu/resource-menu.tsx

@@ -125,6 +125,7 @@ export function ResourceMenu({
   const [sharing, setSharing] = useState(false);
   const [linksOpen, setLinksOpen] = useState(false);
   const selected = useRouterState({ select: (state) => selectedFrom(state.location.search) });
+  const pathname = useRouterState({ select: (state) => state.location.pathname });
   // ⚠️ Dragging is a pointer gesture and nothing else: no keyboard, no screen reader, no touch worth
   // the name. #27 gave moving a second, equal route through a folder picker, and that route lived in
   // the tree row's menu. With the row menu gone (#58) it lives here, or it does not exist.
@@ -189,9 +190,20 @@ export function ResourceMenu({
     },
   });
 
+  // Both records take the same conflict route as a rename: `baseUpdatedAt` from the row that was on
+  // screen, so archiving something somebody else has just changed is refused rather than silently
+  // applied to a different state than the one that was read.
   const archive = useMutation({
     mutationFn: async () => {
-      if (target.type === "flow") throw new Error("A flow cannot be archived");
+      if (target.type === "flow") {
+        await data.archiveFlow({
+          flowId: target.flow.id,
+          baseUpdatedAt: target.flow.updatedAt,
+          archived: true,
+          idempotencyKey: crypto.randomUUID(),
+        });
+        return;
+      }
       await data.archiveKnowledge({
         nodeId: target.node.id,
         baseUpdatedAt: target.node.updatedAt,
@@ -203,7 +215,14 @@ export function ResourceMenu({
       await refresh();
       // The row is gone from the tree. If it was also what the screen was showing, the screen has
       // nothing left to show either.
-      if (selected === id) await navigate({ to: "/knowledge", search: {} });
+      //
+      // ⚠️ It drops the selection where it stands rather than always landing on /knowledge: a flow
+      // archived from the flow screen would otherwise throw the reader onto another screen for no
+      // reason they could see. A flow reached through the shared tree stays on /knowledge, which is
+      // where it was being read.
+      if (selected === id) {
+        await navigate({ to: pathname === "/flows" ? "/flows" : "/knowledge", search: {} });
+      }
     },
   });
 
@@ -260,18 +279,17 @@ export function ResourceMenu({
               {i18n.t("knowledge.share")}
             </DropdownMenuItem>
           ) : null}
-          {node ? (
-            <>
-              <DropdownMenuSeparator />
-              <DropdownMenuItem
-                onSelect={() => archive.mutate()}
-                className="text-destructive focus:text-destructive"
-              >
-                <Archive aria-hidden="true" />
-                {i18n.t("knowledge.archive")}
-              </DropdownMenuItem>
-            </>
-          ) : null}
+          {/* A flow is archived like a document (issue 109). It keeps its versions and its runs; what it
+              loses is reach — it leaves the tree, cannot be started, and stops resolving as another
+              flow's callee. */}
+          <DropdownMenuSeparator />
+          <DropdownMenuItem
+            onSelect={() => archive.mutate()}
+            className="text-destructive focus:text-destructive"
+          >
+            <Archive aria-hidden="true" />
+            {i18n.t("resource.archive")}
+          </DropdownMenuItem>
         </DropdownMenuContent>
       </DropdownMenu>
       {/* The menu closes on selection, so a refusal has nowhere to live inside it. It stands over