@plannotator/ui 0.55.0 → 0.56.0

package/hooks/useAnnotationHighlighter.ts

@@ -421,6 +421,17 @@ const excludedAncestor = (node: Node | null): HTMLElement | null => {
   return element?.closest<HTMLElement>(ANNOTATION_EXCLUDED_SELECTOR) ?? null;
 };
 
+/**
+ * The whole range sits inside one `.annotation-exclude` subtree of `container`
+ * (an Inbox action item or question card under text comments, a diagram):
+ * nothing in it can be annotated, so the selection is left to the person.
+ * An excluded element around the container itself does not count.
+ */
+export const rangeInsideExcluded = (container: HTMLElement, range: Range): boolean => {
+  const excluded = excludedAncestor(range.commonAncestorContainer);
+  return excluded !== null && excluded !== container && container.contains(excluded);
+};
+
 /**
  * Move a range's start off any `.annotation-exclude` subtree it begins inside,
  * onto the first annotatable text position the range covers.
@@ -1508,6 +1519,9 @@ export function useAnnotationHighlighter({
       trimWhitespaceOnlyBoundaryNodes(args[1] as SelectedNodeLike[])) as SelectedNodesTap);
 
     highlighterRef.current = highlighter;
+    // Whether the library's pointer-end handler is attached (`run()`), and whether this effect was cleaned up.
+    let listening = false;
+    let disposed = false;
 
     // Stored positions can resolve into chrome the reviewer could never have
     // selected; painting never enters such a subtree, so a boundary left there
@@ -1650,6 +1664,25 @@ export function useAnnotationHighlighter({
       // AROUND the document and whose end boundary is an empty <div> — the
       // exact shape that throws — so a containment bail here would hand that
       // selection straight to the serializer.
+      if (rangeInsideExcluded(container, range)) {
+        // Nothing here can be annotated (an Inbox action item or question
+        // card under text comments, a diagram): the selection is the
+        // person's to copy. The library's own pointer-end handler paints
+        // nothing for it and then removes the DOM selection anyway, so it
+        // sits this one event out (a listener removed during dispatch never
+        // runs) and listens again on the next task.
+        pendingRangeRunsRef.current = null;
+        if (listening) {
+          highlighter.stop();
+          listening = false;
+          window.setTimeout(() => {
+            if (disposed) return;
+            highlighter.run();
+            listening = true;
+          }, 0);
+        }
+        return;
+      }
       if (isBlankQuote(selection.toString()) || !isSerializableRange(range)) {
         pendingRangeRunsRef.current = null;
         selection.removeAllRanges();
@@ -1676,7 +1709,10 @@ export function useAnnotationHighlighter({
     // person chooses its Comment (takeSelection); the library painting it at
     // touchend would end the system selection and its edit menu first.
     const isTouchPrimary = window.matchMedia('(pointer: coarse)').matches;
-    if (!(isTouchPrimary && hostComposesRef.current)) highlighter.run();
+    if (!(isTouchPrimary && hostComposesRef.current)) {
+      highlighter.run();
+      listening = true;
+    }
 
     const handleMathMouseDown = (event: MouseEvent) => {
       mouseDownMathRef.current = closestMathElement(event.target as Node, containerRef.current);
@@ -1773,6 +1809,8 @@ export function useAnnotationHighlighter({
       if (!sel || sel.isCollapsed || sel.rangeCount === 0) return false;
       if (!containerRef.current?.contains(sel.anchorNode)) return false;
       const range = sel.getRangeAt(0).cloneRange();
+      // Nothing to annotate there: the system selection and its copy menu stay the person's.
+      if (rangeInsideExcluded(containerRef.current, range)) return false;
       // Same fail-closed rule as the pointer-end guard (#881): touch
       // selections settle on block boundaries just as often.
       if (isBlankQuote(sel.toString()) || !isSerializableRange(range)) return false;
@@ -1810,6 +1848,7 @@ export function useAnnotationHighlighter({
       containerRef.current?.removeEventListener('mouseup', handleMathMouseUp, true);
       container.removeEventListener('mouseup', handlePointerEndCapture, true);
       container.removeEventListener('touchend', handlePointerEndCapture, true);
+      disposed = true;
       highlighter.dispose();
     };
   }, [clearPendingSelection, enabled]);

package/hooks/useFileBrowser.ts

@@ -9,6 +9,7 @@
 
 import { useState, useCallback, useEffect, useMemo, useRef } from "react";
 import type { VaultNode } from "../types";
+import { basenameFromPath } from "@plannotator/core/source-save";
 import type { WorkspaceStatusPayload } from "@plannotator/core/workspace-status-types";
 
 export interface DirState {
@@ -200,7 +201,7 @@ export function useFileBrowser(): UseFileBrowserReturn {
   }, []);
 
   const fetchTree = useCallback(async (dirPath: string, options: { quiet?: boolean } = {}) => {
-    const name = dirPath.split("/").pop() || dirPath;
+    const name = basenameFromPath(dirPath);
 
     setDirs((prev) => {
       const exists = prev.find((d) => d.path === dirPath);
@@ -291,7 +292,7 @@ export function useFileBrowser(): UseFileBrowserReturn {
         const vaultDirs = prev.filter((d) => d.isVault);
         const regularDirs = directories.map((path) => ({
           path,
-          name: path.split("/").pop() || path,
+          name: basenameFromPath(path),
           tree: [],
           // Keep initial roots loading until their first snapshot resolves. If
           // the SSE watcher starts before /api/reference/files finishes,
@@ -313,7 +314,7 @@ export function useFileBrowser(): UseFileBrowserReturn {
   }, []);
 
   const addVaultDir = useCallback(async (vaultPath: string) => {
-    const name = vaultPath.split("/").pop() || vaultPath;
+    const name = basenameFromPath(vaultPath);
 
     // Atomically replace any existing vault dirs (handles vault path change without accumulating stale entries)
     setDirs((prev) => {