@anchrd/intel-ui 0.7.2 → 0.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchrd/intel-ui",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {
@@ -28,7 +28,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@anchrd/intel-contract": "^0.3.0",
+    "@anchrd/intel-contract": "^0.4.0",
     "@blocknote/core": "^0.52.1",
     "@blocknote/react": "^0.52.1",
     "@blocknote/shadcn": "^0.52.1",

package/src/app/app-tree/app-tree.tsx

@@ -119,6 +119,14 @@ export function AppTree() {
   // ⚠️ The whole point of #11: one query per level, and a level only exists while its folder is
   // open. A recursive load would put an N+1 on every page of the app, because the tree is now on
   // every page.
+  // Ein aufgeklappter Flow zeigt, was er ruft — mit demselben Pfeil-Versprechen eine Ebene tiefer:
+  // ein gerufener Flow, der selbst ruft, lässt sich weiter aufklappen (#59).
+  async function flowCallRows(flowId: string): Promise<TreeEntry[]> {
+    const calls = await data.listFlowCalls(flowId);
+    const openable = new Set(calls.withCalls);
+    return calls.items.map((flow) => flowEntry(flow, openable.has(flow.id)));
+  }
+
   const parents: Level[] = [{ id: null, type: "folder" }, ...expanded];
   const levels = useQueries({
     queries: parents.map((parent) => ({
@@ -128,7 +136,7 @@ export function AppTree() {
           ? // The same row a folder's level builds for a flow, from the same function: what hangs
             // under an expanded flow differs in where the flows come from, never in what a flow row
             // is (#30).
-            (await data.listFlowCalls(parent.id)).items.map(flowEntry)
+            await flowCallRows(parent.id)
           : await data.listTreeChildren(parent.id),
     })),
   });
@@ -338,17 +346,14 @@ export function AppTree() {
     // now is that a row already on the path from the root is not rendered again.
     const entries = level.data?.filter((entry) => !ancestors.has(entry.id)) ?? [];
     if (entries.length === 0) {
-      // ⚠️ An open folder with nothing in it says nothing (#24): the missing row already is the
-      // answer, and the sentence used to repeat itself once per opened folder. The other two stay,
-      // and deliberately: the empty root is the whole of the navigation, so a blank sidebar on a
-      // fresh installation would leave a new user without any way in; and "this flow calls no other
-      // flow" is a different statement from "empty" — it is an answer, not filler.
-      const message =
-        parent.type === "flow"
-          ? i18n.t("tree.noCalls")
-          : parent.id === null
-            ? i18n.t("tree.empty")
-            : null;
+      // ⚠️ Nothing that is empty says so any more (#59). "This flow calls no other flow" used to
+      // stand here as an answer rather than filler — but a row that cannot be opened is the answer,
+      // and now no such row can be opened: the chevron only appears where there is something under
+      // it. The sentence would only ever be read by somebody who got here another way.
+      //
+      // `tree.empty` at the ROOT stays, and for a different reason that still holds: a completely
+      // blank sidebar on a fresh installation leaves a new user without any way in.
+      const message = parent.type === "folder" && parent.id === null ? i18n.t("tree.empty") : null;
       // The folder keeps its list, empty. The structure is what carries "there is nothing here" to
       // a screen reader — "list, 0 items" — which is the same answer the missing rows give a reader
       // who can see them, and neither of them is a sentence.
@@ -374,7 +379,10 @@ export function AppTree() {
     // from `parent_id`. A flow reused by three callers therefore shows up under all three, which is
     // the answer to "what do I run, and how" (ADR-0004 §3).
     const level: Level & { id: string } = { id: entry.id, type: isFolder ? "folder" : "flow" };
-    const expandable = isFolder || entry.type === "flow";
+    // ⚠️ Nicht mehr „ist von einer Art, die sich aufklappen lässt", sondern „hat etwas zum
+    // Aufklappen, das dieser Leser sehen darf" (#59). Der Unterschied ist ein Pfeil, der hält, was
+    // er verspricht — vorher stand er an jedem Ordner und jedem Flow, auch an leeren.
+    const expandable = entry.openable;
     const isOpen =
       expandable && expanded.some((open) => open.id === entry.id && open.type === level.type);
     const Icon = isOpen && isFolder ? FolderOpen : icons[entry.kind];

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

@@ -80,8 +80,12 @@ export function loginPath(returnTo?: string): string {
  * copies of this would keep returning something plausible and slowly stop agreeing on what a flow
  * row is (#30).
  */
-export function flowEntry(flow: Flow): TreeEntry {
-  return { type: "flow", id: flow.id, title: flow.title, kind: "flow", flow };
+// ⚠️ `openable` ist hier voreingestellt falsch — genauer: unbekannt. Wer die Ebene kennt, setzt es
+// (`listTreeChildren`); wer nur eine einzelne Zeile baut, weiß es nicht und behauptet deshalb das
+// Zurückhaltendere. Ein Pfeil, der zu Unrecht fehlt, kostet einen Klick auf die Zeile; einer, der
+// zu Unrecht steht, kostet Vertrauen (#59).
+export function flowEntry(flow: Flow, openable = false): TreeEntry {
+  return { type: "flow", id: flow.id, title: flow.title, kind: "flow", openable, flow };
 }
 
 export function createIntelDataProvider(
@@ -181,15 +185,20 @@ export function createIntelDataProvider(
         listKnowledge({ parentId }),
         listFlows({ parentId }),
       ]);
+      // ⚠️ Beide Seiten sagen, welche ihrer Zeilen etwas zum Aufklappen haben (#59) — für DIESEN
+      // Leser. Der Baum weiß es damit beim Zeichnen, ohne die Ebene darunter vorzuladen: Das wäre
+      // ein Ladevorgang pro Zeile statt pro Ordner.
+      const openable = new Set([...knowledge.withChildren, ...flows.withCalls]);
       const entries: TreeEntry[] = [
         ...knowledge.items.map((node) => ({
           type: "knowledge" as const,
           id: node.id,
           title: node.title,
           kind: node.kind,
+          openable: openable.has(node.id),
           node,
         })),
-        ...flows.items.map(flowEntry),
+        ...flows.items.map((flow) => flowEntry(flow, openable.has(flow.id))),
       ];
       // Folders first, then everything else by title: a document and a flow sit side by side, and
       // the icon is what tells them apart.

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

@@ -51,9 +51,19 @@ import type {
 
 // One row of the shared tree. Knowledge and Flows share the folder, not their nature (ADR-0004), so
 // this is a union that keeps each side's record whole — never a merged "node" that is a bit of both.
+// ⚠️ `openable` heißt „hat etwas zum Aufklappen, das DIESER Leser sehen darf" (#59) — nicht „ist
+// von einer Art, die sich aufklappen lässt". Der Unterschied ist der ganze Sinn: Ein Pfeil an einer
+// Zeile, unter der nichts liegt, verspricht Inhalt, den das Aufklappen nicht liefert.
 export type TreeEntry =
-  | { type: "knowledge"; id: string; title: string; kind: KnowledgeNodeKind; node: KnowledgeNode }
-  | { type: "flow"; id: string; title: string; kind: "flow"; flow: Flow };
+  | {
+      type: "knowledge";
+      id: string;
+      title: string;
+      kind: KnowledgeNodeKind;
+      openable: boolean;
+      node: KnowledgeNode;
+    }
+  | { type: "flow"; id: string; title: string; kind: "flow"; openable: boolean; flow: Flow };
 
 export interface IntelDataProvider {
   getSession(): Promise<SessionUser>;

package/src/i18n/en.json

@@ -32,7 +32,6 @@
   "tree.collapse": "Hide what is inside {title}",
   "tree.expandCalls": "Show the flows {title} calls",
   "tree.collapseCalls": "Hide the flows {title} calls",
-  "tree.noCalls": "This flow calls no other flow.",
   "tree.add": "Add to {title}",
   "tree.addRoot": "Add at the top level",
   "tree.new.folder": "New folder",

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

@@ -61,6 +61,8 @@ function entryOf(target: ResourceTarget): TreeEntry {
         id: target.node.id,
         title: target.node.title,
         kind: target.node.kind,
+        // Ein Menü verschiebt eine Zeile; ob sie sich aufklappen lässt, spielt dabei keine Rolle.
+        openable: false,
         node: target.node,
       };
 }