@djangocfg/ui-tools 2.1.469 → 2.1.470

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@djangocfg/ui-tools",
-  "version": "2.1.469",
+  "version": "2.1.470",
   "description": "Heavy React tools with lazy loading - for Electron, Vite, CRA, Next.js apps",
   "keywords": [
     "ui-tools",
@@ -334,8 +334,8 @@
     "test:watch": "vitest"
   },
   "peerDependencies": {
-    "@djangocfg/i18n": "^2.1.469",
-    "@djangocfg/ui-core": "^2.1.469",
+    "@djangocfg/i18n": "^2.1.470",
+    "@djangocfg/ui-core": "^2.1.470",
     "consola": "^3.4.2",
     "lodash-es": "^4.18.1",
     "lucide-react": "^0.545.0",
@@ -418,9 +418,9 @@
     "@maplibre/maplibre-gl-geocoder": "^1.9.4"
   },
   "devDependencies": {
-    "@djangocfg/i18n": "^2.1.469",
-    "@djangocfg/typescript-config": "^2.1.469",
-    "@djangocfg/ui-core": "^2.1.469",
+    "@djangocfg/i18n": "^2.1.470",
+    "@djangocfg/typescript-config": "^2.1.470",
+    "@djangocfg/ui-core": "^2.1.470",
     "@types/lodash-es": "^4.17.12",
     "@types/mapbox__mapbox-gl-draw": "^1.4.9",
     "@types/node": "^25.9.5",

package/src/tools/chat/README.md

@@ -90,7 +90,14 @@ ChatRoot (one-line preset)  ◄──  optionally wrapped by  ──►  ChatLau
 
 `ChatLauncher` mounts the `ChatProvider` itself — pass `transport` / `config` / `audio` / `initialSessionId` / `autoCreateSession` / `streaming` / `debug` to the launcher and use `<ChatRoot />` without props as the child. `ChatRoot` detects the ambient provider and reuses it; standalone `<ChatRoot transport={…}>` still works for non-launcher embeds. This is what makes declarative `headerSlots` (which render in the dock header) able to call `useChatContext()` and read `sessionId` / `clearMessages` / etc.
 
-`ChatProvider` also owns chat-wide UX behaviour that must hold regardless of which preset wraps it — notably **stream-end composer re-focus** (`autoFocusOnStreamEnd`, default `true`). Putting it in the provider means a hand-rolled `ChatProvider` + `MessageList` + `Composer` layout behaves identically to `ChatRoot` with no extra wiring.
+`ChatProvider` is the single owner of automatic composer focus: one settled
+focus after a chat mounts or switches session, and one after a streamed reply
+ends (`autoFocusOnMount` / `autoFocusOnStreamEnd`, both default `true`). A
+normal message, presence, telemetry, or prop update never takes focus. Direct
+user intent remains local: clicking the empty message area or the composer
+surface focuses the editor. This keeps a hand-rolled `ChatProvider` +
+`MessageList` + `Composer` layout identical to `ChatRoot` without competing
+focus effects.
 
 Module boundaries:
 

package/src/tools/chat/context/ChatProvider.tsx

@@ -242,7 +242,11 @@ export function ChatProvider({
     if (prevSessionRef.current === chat.sessionId) return;
     prevSessionRef.current = chat.sessionId;
     if (!autoFocusOnMount) return;
-    getActiveComposer()?.focus();
+    // Session switch is the provider's second and final automatic focus
+    // intent (after mount). Wait one frame for a closing dialog / editor DOM
+    // update, rather than competing with consumers through retry loops.
+    const raf = requestAnimationFrame(() => getActiveComposer()?.focus());
+    return () => cancelAnimationFrame(raf);
   }, [chat.sessionId, autoFocusOnMount]);
 
   const value = useMemo<ChatContextValue>(

package/src/tools/chat/hooks/useAutoFocusOnStreamEnd.ts

@@ -111,35 +111,16 @@ export function useAutoFocusOnMount(
   const { enabled = true, targetRef } = options;
   useEffect(() => {
     if (!enabled) return;
-    // Retry across a few frames, not a single rAF. On a `key`-remount
-    // (chat-switch) two things race our focus: (1) a custom composer's
-    // `useRegisterComposer` effect must run before `getActiveComposer()`
-    // returns the NEW handle, and (2) the click that triggered the switch
-    // leaves focus on the machine button — a one-frame focus() can fire
-    // before the editor is mounted, or get immediately clobbered. We poll
-    // a handful of frames and stop as soon as the editor actually holds
-    // focus, so the caret reliably lands in the composer without a
-    // guessed fixed delay.
-    let raf = 0;
-    let tries = 0;
-    const MAX_TRIES = 8; // ~8 frames ≈ 130ms @60fps — enough post-remount.
-    const tick = () => {
+    // One settled frame is enough: child effects register the composer before
+    // the provider's effect runs. Repeated focus polling was hostile to rich
+    // editors — an unrelated render could keep reclaiming their selection.
+    // A chat has one focus owner (ChatProvider); mounting is one deliberate
+    // focus intent, not an 8-frame retry loop.
+    const raf = requestAnimationFrame(() => {
       const target =
         (targetRef?.current as Focusable | null) ?? getActiveComposer();
       target?.focus?.();
-      tries += 1;
-      // Stop once the composer owns focus, or we run out of tries. The
-      // active-element check keeps us from stealing focus the user just
-      // moved elsewhere (e.g. opened the slash menu) after the first frame.
-      const editor = document.querySelector<HTMLElement>(
-        '.ProseMirror, textarea',
-      );
-      const settled = !!editor && document.activeElement === editor;
-      if (!settled && tries < MAX_TRIES) {
-        raf = requestAnimationFrame(tick);
-      }
-    };
-    raf = requestAnimationFrame(tick);
+    });
     return () => cancelAnimationFrame(raf);
     // Mount-only by design: the empty dep array means a host that wants
     // re-focus on chat-switch must remount the tree (the `key={id}`

package/src/tools/forms/MarkdownEditor/MarkdownEditor.tsx

@@ -510,6 +510,14 @@ export const MarkdownEditor = forwardRef<MarkdownEditorHandle, MarkdownEditorPro
     if (!editor) return;
     const current = getMarkdown(editor);
     if (current !== value) {
+      // `setContent` replaces the ProseMirror document and therefore creates a
+      // fresh selection. In a controlled chat editor an unrelated parent
+      // render can arrive while the user is typing; without preserving this
+      // selection Chromium may release focus to <body> or place the caret at
+      // document start. External content still wins, but it must never erase
+      // the user's active editing position.
+      const hadFocus = editor.isFocused;
+      const previousSelection = editor.state.selection;
       isExternalUpdate.current = true;
       editor.commands.setContent(value, { contentType: 'markdown', emitUpdate: false });
       // After the new content is written, convert a leading `/verb` text
@@ -535,6 +543,18 @@ export const MarkdownEditor = forwardRef<MarkdownEditorHandle, MarkdownEditorPro
         });
       }
       isExternalUpdate.current = false;
+
+      if (hadFocus) {
+        // SetContent / chip normalization can shorten the document. Clamp the
+        // old range to the new valid bounds, then restore it after focusing so
+        // both a collapsed caret and a text selection remain where the user
+        // left them. We intentionally do not focus an editor that was not
+        // active — a background update must not steal focus from another UI.
+        const maxPosition = editor.state.doc.content.size;
+        const from = Math.max(1, Math.min(previousSelection.from, maxPosition));
+        const to = Math.max(1, Math.min(previousSelection.to, maxPosition));
+        editor.chain().focus().setTextSelection({ from, to }).run();
+      }
     }
   }, [value, editor]);
 

package/src/tools/forms/MarkdownEditor/README.md

@@ -204,6 +204,10 @@ A bare URL serialises as the bare URL; a file path as the literal path.
   pasted text, keeping the surrounding prose.
 - **Initial `value`**: paths / URLs in the controlled markdown are
   converted after `setContent` (the same way leading `/`-commands are).
+- **External controlled update while editing**: the editor preserves the
+  current focused selection, clamped to the new document. A background parent
+  render must never send the caret to document start or steal focus from
+  another control.
 
 ### Caret / editing