zidane-ui 9.1.1 → 9.1.4

package/src/chat/rich-composer/use-draft-mirror.ts

@@ -1,398 +0,0 @@
-/**
- * The composer's shared per-session draft (daemon mode) and the buffer kept
- * per session across switches.
- *
- * The composer's text (+ shell flag) and staged attachments are a shared
- * per-session draft. Publish on every local change; apply remote
- * `drafts:changed` / `drafts:attachments` unconditionally (the daemon
- * excludes the origin window, so our own edits never echo back — the
- * value-equality guards below only break the apply→publish round trip and
- * skip no-op applies). In-process the channels are silent and `drafts.set`
- * is a main-side no-op — inert.
- *
- * `draftSyncSessionRef` gates publishing until the session's `drafts.get`
- * backfill resolves. A switch clears the buffer (the outgoing one is stashed
- * per session), so no draft leaks across sessions; only a send from the
- * new-chat screen carries it over.
- */
-import type { Editor } from '@tiptap/react';
-import { useEffect, useLayoutEffect, useRef, useState, type RefObject } from 'react';
-
-import { useComposerHost } from '../composer/ComposerHostProvider';
-import type { ComposerMode } from '../headless/composer-modes';
-import type { ComposerAttachment as ChatAttachment, PromptAttachment, SharedDraft } from '../headless/composer/host';
-import {
-  attachmentsWireKey,
-  chatAttachmentsToWire,
-  draftsEqual,
-  draftTextToDocJson,
-  draftWireText,
-  sessionSwitchAction,
-  shouldApplyRemoteDraft,
-  wireToChatAttachments,
-  type DraftSnapshot,
-} from '../headless/composer/draft-sync';
-import type { JsonNode } from '../headless/composer/editor-markdown';
-import type { useStagedAttachments } from './use-staged-attachments';
-
-/** The app's session id (the desktop app's session key). */
-type SessionKey = string;
-
-/** A session with no shared draft (no `ComposerHost.drafts`). */
-const NO_DRAFT: SharedDraft = { text: '' };
-
-/** Local edits settle this long before the shared draft is published. */
-const DRAFT_PUBLISH_MS = 120;
-/** Stash key for the new-chat screen's buffer (no session id yet). */
-const NEW_CHAT_DRAFT_KEY = '__new__';
-
-interface StashedDraft {
-  /** `null` when the buffer was a search query, not a draft. */
-  doc: JsonNode | null;
-  shell: boolean;
-  attachments: ChatAttachment[];
-}
-
-/**
- * Canonical draft wire form (WYSIWYG — see `draftWireText`). The publish
- * effect, the pre-apply comparison, and the post-apply baseline MUST all read
- * the buffer through this one function — any disagreement re-publishes remote
- * applies and feeds the cross-window draft loop this exists to prevent. NOT
- * the submit serialization: drafts sync what the user SEES; submit keeps
- * markdown block gaps.
- */
-export function serializeDraftText(ed: Editor): string {
-  return draftWireText(ed.getJSON() as JsonNode);
-}
-
-type StagedAttachments = Pick<
-  ReturnType<typeof useStagedAttachments>,
-  'attachments' | 'exitingIds' | 'setAttachments' | 'replace'
->;
-
-export interface DraftMirrorOptions {
-  editor: Editor | null;
-  /** The live editor, for callbacks that outlive a render. */
-  editorRef: RefObject<Editor | null>;
-  modeRef: RefObject<ComposerMode>;
-  composerMode: ComposerMode;
-  activeSessionId: SessionKey | null;
-  staged: StagedAttachments;
-  applyMode(next: ComposerMode): void;
-  /** The session switched away: the "history N/M" indicator belongs to the old one. */
-  resetHistoryStatus(): void;
-}
-
-export interface DraftMirror {
-  /** Put a draft in the buffer as the shared draft's value (not published back). */
-  applyDraft(text: string, shell: boolean): void;
-  /** A send from the new-chat screen is in flight (`true`): the switch to the session it creates keeps the buffer. */
-  promoteNewChat(on: boolean): void;
-  /** The active session's buffer was sent: nothing to restore on the way back. */
-  dropStash(): void;
-}
-
-export function useDraftMirror(options: DraftMirrorOptions): DraftMirror {
-  const { editor, editorRef, modeRef, composerMode, activeSessionId, staged } = options;
-  const drafts = useComposerHost().drafts;
-  // Read by callbacks registered once (IPC listeners, the switch effect's cleanup): current as of the last commit.
-  const latest = useRef(options);
-  useLayoutEffect(() => {
-    latest.current = options;
-  });
-
-  const lastSyncedDraftRef = useRef<DraftSnapshot | null>(null);
-  const lastSyncedAttachmentsRef = useRef<string | null>(null);
-  const draftSyncSessionRef = useRef<string | null>(null);
-  const prevSessionRef = useRef(activeSessionId);
-  // The Chatbox outlives session switches: each session's unsent buffer is stashed here meanwhile.
-  const stashedDraftsRef = useRef(new Map<string, StashedDraft>());
-  const promoteNewChatRef = useRef(false);
-
-  const [mirror] = useState(() => {
-    const liveEditor = () => {
-      const ed = editorRef.current;
-      return ed && !ed.isDestroyed ? ed : null;
-    };
-    const applyDraft = (text: string, shell: boolean) => {
-      const ed = liveEditor();
-
-      // Search mode owns the buffer as the QUERY — a draft apply here
-      // would clobber it. The draft change is dropped (rare conflict).
-      if (!ed || modeRef.current === 'search') {
-        return;
-      }
-
-      const next: DraftSnapshot = { text, shell };
-      const current: DraftSnapshot = {
-        text: serializeDraftText(ed),
-        shell: modeRef.current === 'shell',
-      };
-
-      if (!shouldApplyRemoteDraft(current, next)) {
-        lastSyncedDraftRef.current = next;
-        return;
-      }
-
-      latest.current.applyMode(shell ? 'shell' : 'normal');
-      ed.commands.setContent(draftTextToDocJson(text), { emitUpdate: true });
-      /*
-       * Baseline = what the buffer NOW serializes to, not the raw remote
-       * text. `draftTextToDocJson` makes the round trip an identity, but
-       * reading it back from the editor keeps the echo guard airtight
-       * even if apply-side and publish-side serialization ever drift.
-       * A raw-text baseline would let each remote keystroke re-publish a
-       * mutated copy of the draft.
-       */
-      lastSyncedDraftRef.current = { text: serializeDraftText(ed), shell };
-    };
-    const applyAttachments = (wire: PromptAttachment[]) => {
-      const key = attachmentsWireKey(wire);
-
-      if (key === lastSyncedAttachmentsRef.current) {
-        return;
-      }
-
-      lastSyncedAttachmentsRef.current = key;
-      latest.current.staged.replace(wireToChatAttachments(wire));
-    };
-    return {
-      liveEditor,
-      applyAttachments,
-      api: {
-        applyDraft,
-        promoteNewChat: (on: boolean) => {
-          promoteNewChatRef.current = on;
-        },
-        dropStash: () => {
-          stashedDraftsRef.current.delete(latest.current.activeSessionId ?? NEW_CHAT_DRAFT_KEY);
-        },
-      } satisfies DraftMirror,
-    };
-  });
-
-  useEffect(() => {
-    const unsubDraft = drafts?.onChanged?.((signal) => {
-      if (signal.sessionId === latest.current.activeSessionId) {
-        mirror.api.applyDraft(signal.text, signal.shell ?? false);
-      }
-    });
-    const unsubAttachments = drafts?.onAttachmentsChanged?.((signal) => {
-      if (signal.sessionId === latest.current.activeSessionId) {
-        mirror.applyAttachments(signal.attachments);
-      }
-    });
-    return () => {
-      unsubDraft?.();
-      unsubAttachments?.();
-    };
-  }, [drafts, mirror]);
-
-  /*
-   * Session switch: close the publish gate, swap the buffer for the
-   * target session's, backfill the shared draft, then reopen. The
-   * cleanup stashes the outgoing buffer; it runs before the pending
-   * publish flush below and before this setup clears the editor. A
-   * non-empty shared draft wins over the local stash; in-process
-   * `drafts.get` answers `{ text: '' }`, so the stash restores.
-   */
-  useEffect(() => {
-    draftSyncSessionRef.current = null;
-    lastSyncedDraftRef.current = null;
-    lastSyncedAttachmentsRef.current = null;
-
-    const sessionId = activeSessionId;
-    const stashKey = sessionId ?? NEW_CHAT_DRAFT_KEY;
-    const stashes = stashedDraftsRef.current;
-    const action = sessionSwitchAction(prevSessionRef.current, sessionId, promoteNewChatRef.current);
-    const prevKey = prevSessionRef.current ?? NEW_CHAT_DRAFT_KEY;
-    prevSessionRef.current = sessionId;
-    promoteNewChatRef.current = false;
-    let stash = action === 'clear' ? stashes.get(stashKey) : undefined;
-
-    if (action === 'keep') {
-      stashes.delete(prevKey);
-    } else {
-      mirror.liveEditor()?.commands.clearContent(false);
-      latest.current.staged.replace([]);
-      latest.current.resetHistoryStatus();
-    }
-
-    const restoreStash = (text: boolean, files: boolean) => {
-      const restoring = stash;
-
-      if (!restoring) {
-        return;
-      }
-
-      stash = undefined;
-      stashes.delete(stashKey);
-      const ed = mirror.liveEditor();
-
-      // Something typed (or a mode armed) before the backfill resolved wins.
-      if (text && restoring.doc && ed && ed.isEmpty && modeRef.current === 'normal') {
-        latest.current.applyMode(restoring.shell ? 'shell' : 'normal');
-        ed.commands.setContent(restoring.doc, { emitUpdate: true });
-      }
-
-      if (files && restoring.attachments.length > 0) {
-        latest.current.staged.setAttachments((current) => (current.length === 0 ? restoring.attachments : current));
-      }
-    };
-
-    let cancelled = false;
-
-    if (!sessionId) {
-      restoreStash(true, true);
-    } else {
-      void (drafts ? drafts.get(sessionId) : Promise.resolve(NO_DRAFT))
-
-        .then((draft) => {
-          if (cancelled || latest.current.activeSessionId !== sessionId) {
-            return;
-          }
-
-          const remoteFiles = draft.attachments !== undefined && draft.attachments.length > 0;
-
-          if (draft.text) {
-            mirror.api.applyDraft(draft.text, draft.shell ?? false);
-          }
-
-          if (remoteFiles) {
-            mirror.applyAttachments(draft.attachments ?? []);
-          }
-
-          restoreStash(!draft.text, !remoteFiles);
-          draftSyncSessionRef.current = sessionId;
-        })
-        .catch(() => {
-          if (!cancelled && latest.current.activeSessionId === sessionId) {
-            restoreStash(true, true);
-            draftSyncSessionRef.current = sessionId;
-          }
-        });
-    }
-
-    return () => {
-      cancelled = true;
-      const ed = mirror.liveEditor();
-
-      if (!ed) {
-        return;
-      }
-
-      const { attachments, exitingIds } = latest.current.staged;
-      const kept = attachments.filter((att) => !exitingIds.has(att.id));
-      const searching = modeRef.current === 'search';
-
-      if ((searching || ed.isEmpty) && kept.length === 0) {
-        // Left before the backfill landed: the unrestored stash stays for next time.
-        if (!stash) {
-          stashes.delete(stashKey);
-        }
-
-        return;
-      }
-
-      stashes.set(stashKey, {
-        doc: searching || ed.isEmpty ? null : (ed.getJSON() as JsonNode),
-        // eslint-disable-next-line react-hooks/exhaustive-deps -- stable handles (refs, built-once sources and host); the effect keys on what it re-runs for
-        shell: modeRef.current === 'shell',
-        attachments: kept,
-      });
-    };
-  }, [activeSessionId, drafts, mirror, modeRef]);
-
-  /*
-   * `useEditor` rebuilds the editor when its extensions change (the
-   * extensions' completion triggers arrive after mount), and the new one
-   * starts empty: put the synced draft back before the publish below reads
-   * it, or the empty buffer would replace the shared draft in every window.
-   */
-  const shownEditor = useRef(editor);
-  useEffect(() => {
-    const previous = shownEditor.current;
-    shownEditor.current = editor;
-    const last = lastSyncedDraftRef.current;
-    const rebuilt = editor && !editor.isDestroyed && previous && previous !== editor;
-    if (!rebuilt || !last?.text || !editor.isEmpty || modeRef.current === 'search') return;
-    latest.current.applyMode(last.shell ? 'shell' : 'normal');
-    editor.commands.setContent(draftTextToDocJson(last.text), { emitUpdate: false });
-  }, [editor, modeRef]);
-
-  /*
-   * Publish the text draft after local edits settle (120 ms): serialising
-   * the whole document and an IPC per keystroke cost the typing frame on
-   * long drafts. The publish reads the editor when it fires, never a stale
-   * copy, and a session switch (or unmount) flushes it at once. Skipped
-   * while the buffer is a search query.
-   */
-  const draftPublish = useRef<{ timer: ReturnType<typeof setTimeout>; run: () => void } | null>(null);
-  useEffect(() => {
-    const sessionId = activeSessionId;
-
-    if (!sessionId) {
-      return undefined;
-    }
-
-    const run = () => {
-      draftPublish.current = null;
-      if (draftSyncSessionRef.current !== sessionId || modeRef.current === 'search') return;
-      const ed = mirror.liveEditor();
-      const text = ed ? serializeDraftText(ed) : '';
-      const next: DraftSnapshot = { text, shell: modeRef.current === 'shell' };
-      const last = lastSyncedDraftRef.current;
-
-      if (last && draftsEqual(last, next)) {
-        return;
-      }
-
-      lastSyncedDraftRef.current = next;
-      void drafts?.set(sessionId, next.text, next.shell).catch(() => undefined);
-    };
-    const schedule = () => {
-      // The gate is read per edit: it opens asynchronously, once the session's draft has hydrated.
-      if (draftSyncSessionRef.current !== sessionId || modeRef.current === 'search') return;
-      if (draftPublish.current) clearTimeout(draftPublish.current.timer);
-      draftPublish.current = { timer: setTimeout(run, DRAFT_PUBLISH_MS), run };
-    };
-    schedule();
-    // Per edit, without re-rendering the composer (the render only tracks emptiness).
-    if (!editor || editor.isDestroyed) return undefined;
-    editor.on('update', schedule);
-    return () => {
-      editor.off('update', schedule);
-    };
-  }, [editor, composerMode, activeSessionId, drafts, mirror, modeRef]);
-  useEffect(
-    () => () => {
-      const pending = draftPublish.current;
-      if (!pending) return;
-      clearTimeout(pending.timer);
-      pending.run();
-    },
-    [activeSessionId],
-  );
-
-  /* Publish staged attachments on change — same gate + echo guard. */
-  const { attachments } = staged;
-  useEffect(() => {
-    const sessionId = activeSessionId;
-
-    if (!sessionId || draftSyncSessionRef.current !== sessionId) {
-      return;
-    }
-
-    const wire = chatAttachmentsToWire(attachments);
-    const key = attachmentsWireKey(wire);
-
-    if (key === lastSyncedAttachmentsRef.current) {
-      return;
-    }
-
-    lastSyncedAttachmentsRef.current = key;
-    void drafts?.setAttachments?.(sessionId, wire).catch(() => undefined);
-  }, [attachments, activeSessionId, drafts]);
-
-  return mirror.api;
-}

package/src/chat/rich-composer/use-editor-handover.ts

@@ -1,45 +0,0 @@
-/**
- * Carries a TipTap editor's draft, caret and focus over to the one that
- * replaces it. `useEditor` destroys the editor and builds a new one when
- * its deps change (the composer's extension providers arrive after mount):
- * the new one starts empty, and the focused node it replaces leaves the DOM,
- * so focus falls to the page and the keys typed next go nowhere.
- */
-import type { Editor, JSONContent } from '@tiptap/react';
-import { useLayoutEffect, useRef } from 'react';
-
-interface Handover {
-  doc: JSONContent;
-  from: number;
-  to: number;
-  focused: boolean;
-}
-
-/** Hands each replaced editor's state to its successor, before paint. */
-export function useEditorHandover(editor: Editor | null): void {
-  const handover = useRef<Handover | null>(null);
-  useLayoutEffect(() => {
-    if (!editor || editor.isDestroyed) return;
-    const last = handover.current;
-    handover.current = null;
-    if (last) {
-      try {
-        editor.commands.setContent(last.doc, { emitUpdate: false });
-        const end = editor.state.doc.content.size;
-        editor.commands.setTextSelection({ from: Math.min(last.from, end), to: Math.min(last.to, end) });
-      } catch {
-        // A node the new schema lacks: the draft mirror restores the synced text instead.
-      }
-      if (last.focused) editor.view.focus();
-    }
-    // Read while the view still stands: `destroy` fires before it is torn down.
-    const snapshot = () => {
-      const { from, to } = editor.state.selection;
-      handover.current = { doc: editor.getJSON(), from, to, focused: editor.view.hasFocus() };
-    };
-    editor.on('destroy', snapshot);
-    return () => {
-      editor.off('destroy', snapshot);
-    };
-  }, [editor]);
-}

package/src/chat/rich-composer/use-extension-composer.ts

@@ -1,80 +0,0 @@
-/**
- * The extensions' composer edits (`ctx.composer.insert / setText / attach`)
- * in the composer they are for: the one writing to the edit's session, or,
- * for an edit that names none, the window's composer (the composer bus's
- * focus). Each edit reaches one composer (`useExtensionEffects`'s routing),
- * ahead of any app handler, so it is never applied twice.
- *
- * Files arrive as bytes (base64) or as paths. A browser cannot read a host
- * path, so only bytes are staged; an attach with no bytes did nothing.
- */
-import type { ComposerAttachment } from '../headless/composer/host';
-import type { ExtensionComposerFile, ExtensionUiEffect } from '../../extensions/headless/host';
-import { KIT_EFFECT_PRIORITY, useExtensionEffects } from '../../extensions/hooks';
-import { isFocusedComposer } from '../composer/composer-bus';
-
-/** What the composer does with each edit. */
-export interface ExtensionComposerTarget {
-  /** The session the composer writes to (`null`: a new chat). */
-  sessionId: string | null;
-  /** Its scope on the composer bus. */
-  scopeKey: string | null;
-  /** Takes edits (not read-only). */
-  enabled: boolean;
-  /** Appends text at the end of the draft. Whether it did. */
-  insert(text: string): boolean;
-  /** Replaces the draft's text, keeping its attachments. Whether it did. */
-  setText(text: string): boolean;
-  /** Stages an attachment. */
-  attach(attachment: ComposerAttachment): void;
-}
-
-let attachSeq = 0;
-
-/**
- * The attachment an extension's file becomes, or `null` for a path (a browser can't read it).
- *
- * @param file - The file `ctx.composer.attach` sent.
- */
-export function extensionFileAttachment(file: ExtensionComposerFile): ComposerAttachment | null {
-  if (!('data' in file)) return null;
-  const padding = file.data.endsWith('==') ? 2 : file.data.endsWith('=') ? 1 : 0;
-  return {
-    id: `ext-att-${++attachSeq}`,
-    name: file.name,
-    mediaType: file.mimeType,
-    size: Math.max(0, Math.floor((file.data.length * 3) / 4) - padding),
-    dataUrl: `data:${file.mimeType};base64,${file.data}`,
-  };
-}
-
-/**
- * Applies the extensions' composer edits meant for this composer.
- *
- * @param target - The composer: its session, scope, and what it does with each edit.
- */
-export function useExtensionComposerEffects(target: ExtensionComposerTarget): void {
-  useExtensionEffects(
-    (effect) => {
-      if (effect.kind !== 'composer') return false;
-      const op = effect.op;
-      if (op.op === 'insert') return target.insert(op.text);
-      if (op.op === 'setText') return target.setText(op.text);
-      let staged = 0;
-      for (const file of op.files) {
-        const attachment = extensionFileAttachment(file);
-        if (!attachment) continue;
-        target.attach(attachment);
-        staged++;
-      }
-      return staged > 0;
-    },
-    {
-      accepts: (effect: ExtensionUiEffect) =>
-        effect.kind === 'composer' &&
-        target.enabled &&
-        (effect.sessionId !== undefined ? effect.sessionId === target.sessionId : isFocusedComposer(target.scopeKey)),
-      priority: KIT_EFFECT_PRIORITY,
-    },
-  );
-}