Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

12.7 KB
Raw Blame
import { EditorSelection } from '@codemirror/state';
import { EditorView } from '@codemirror/view';
import type { Editor } from '@tiptap/core';
import type { Node as PmNode } from '@tiptap/pm/model';
import type { EditorView as ProseMirrorView } from '@tiptap/pm/view';
import type * as Y from 'yjs';
import { editorToolbarOverlapPx } from '@/lib/editor-toolbar-overlap';
import { getEditorForDoc } from './active-editor';
import { visibleEditorScrollContainer } from './editor-cache';
import { getMarkdownSourceViewForDoc } from './full-page-cm-views';
import { type LandingHandle, startLanding, type TargetMetrics } from './landing-controller';
import {
  createApproxResolver,
  type ModeSwitchPositionResolver,
  type ResolvedPosition,
} from './mode-switch-position-resolver';
import { flashSourceLanding } from './plugins/landing-flash-source';
import { registerLandingScrollOwner } from './scroll-restore-coordination';
import {
  clearPendingSourceNavigation,
  clearPendingWysiwygNavigation,
  createNavigationPin,
  peekPendingSourceNavigation,
  rememberPendingSourceNavigation,
  rememberPendingWysiwygNavigation,
  resolveNavigationPin,
  type SelectionOffsetNavigation,
} from './source-editor-navigation';
import type { EditorModeValue } from './use-editor-mode';
import { getEditorView } from './utils/get-editor-view';
import { getSharedMarkdownManager } from './utils/md-singleton';
import { VIEW_IN_SOURCE_EVENT, type ViewInSourceDetail } from './view-in-source-event';

let sharedResolver: ModeSwitchPositionResolver | null = null;
function getSharedResolver(): ModeSwitchPositionResolver {
  sharedResolver ??= createApproxResolver(getSharedMarkdownManager());
  return sharedResolver;
}

export function buildSourceLandingNav(
  doc: PmNode,
  pos: number,
  ytext: Y.Text,
  resolver: ModeSwitchPositionResolver,
  intent: 'toggle' | 'jump' = 'toggle',
): SelectionOffsetNavigation | null {
  const anchor = resolver.captureFromWysiwyg(doc, pos, { refine: intent === 'jump' });
  if (!anchor) return null;
  const resolved = resolver.resolveInSource(anchor, { source: ytext.toString(), doc });
  const pin = resolved
    ? createNavigationPin(ytext, resolved.blockStart, resolved.blockEnd)
    : undefined;
  return { kind: 'selection-offset', intent, anchor, pin };
}

export function requestViewInSource(params: {
  editor: Editor;
  docName: string;
  ytext: Y.Text;
  pmPosition?: number;
}): void {
  const { editor, docName, ytext } = params;
  const view = getEditorView(editor);
  if (!view) return;
  const pos = params.pmPosition ?? view.state.selection.from;
  const nav = buildSourceLandingNav(view.state.doc, pos, ytext, getSharedResolver(), 'jump');
  if (nav) rememberPendingSourceNavigation(docName, nav);
  window.dispatchEvent(
    new CustomEvent<ViewInSourceDetail>(VIEW_IN_SOURCE_EVENT, { detail: { docName } }),
  );
}

export function buildWysiwygLandingNav(
  source: string,
  fullOffset: number,
  ytext: Y.Text,
  resolver: ModeSwitchPositionResolver,
  pmDoc: PmNode | undefined,
): SelectionOffsetNavigation | null {
  const anchor = resolver.captureFromSource(source, fullOffset);
  if (!anchor) return null;
  const sourceRange = pmDoc ? resolver.resolveInSource(anchor, { source, doc: pmDoc }) : null;
  const pin = sourceRange
    ? createNavigationPin(ytext, sourceRange.blockStart, sourceRange.blockEnd)
    : undefined;
  return { kind: 'selection-offset', anchor, pin };
}

export function resolveWysiwygLandingTarget(
  navigation: SelectionOffsetNavigation,
  ctx: { source: string; pmDoc: PmNode; ydoc: Y.Doc; resolver: ModeSwitchPositionResolver },
): ResolvedPosition | null {
  const { source, pmDoc, ydoc, resolver } = ctx;
  if (navigation.pin) {
    const live = resolveNavigationPin(navigation.pin, ydoc);
    if (live === null) {
      const resolved = resolver.resolveInWysiwyg(navigation.anchor, { source, doc: pmDoc });
      return resolved ? { ...resolved, point: resolved.blockStart, confidence: 'clamped' } : null;
    }
    const liveAnchor = resolver.captureFromSource(source, live);
    if (liveAnchor) return resolver.resolveInWysiwyg(liveAnchor, { source, doc: pmDoc });
  }
  return resolver.resolveInWysiwyg(navigation.anchor, { source, doc: pmDoc });
}

export function resolveSourceLandingTarget(
  navigation: SelectionOffsetNavigation,
  ctx: { source: string; pmDoc: PmNode; ydoc: Y.Doc; resolver: ModeSwitchPositionResolver },
): ResolvedPosition | null {
  const { source, pmDoc, ydoc, resolver } = ctx;
  if (navigation.pin) {
    const live = resolveNavigationPin(navigation.pin, ydoc);
    if (live === null) {
      const resolved = resolver.resolveInSource(navigation.anchor, { source, doc: pmDoc });
      return resolved ? { ...resolved, point: resolved.blockStart, confidence: 'clamped' } : null;
    }
    const liveAnchor = resolver.captureFromSource(source, live);
    if (liveAnchor) return resolver.resolveInSource(liveAnchor, { source, doc: pmDoc });
  }
  return resolver.resolveInSource(navigation.anchor, { source, doc: pmDoc });
}

function safeCoordsAtPos(view: EditorView, pos: number): ReturnType<EditorView['coordsAtPos']> {
  try {
    return view.coordsAtPos(pos);
  } catch {
    return null;
  }
}

export function sourceTargetMetrics(
  view: EditorView,
  container: HTMLElement,
  offset: number,
): TargetMetrics | null {
  const clamped = Math.max(0, Math.min(offset, view.state.doc.length));
  const containerTop = container.getBoundingClientRect().top;
  const coords = safeCoordsAtPos(view, clamped);
  if (coords) {
    return {
      top: coords.top - containerTop + container.scrollTop,
      height: coords.bottom - coords.top,
    };
  }
  try {
    const block = view.lineBlockAt(clamped);
    const cmDocTop = view.documentTop - containerTop + container.scrollTop;
    return { top: cmDocTop + block.top, height: block.height };
  } catch {
    return null;
  }
}

function blockElementForPos(view: ProseMirrorView, pos: number): HTMLElement | null {
  if (view.isDestroyed) return null;
  try {
    const node = view.nodeDOM(pos);
    if (node instanceof HTMLElement) return node;
    const { node: domNode } = view.domAtPos(pos);
    if (domNode instanceof HTMLElement) return domNode;
    return domNode.parentElement;
  } catch {
    return null;
  }
}

export function wysiwygTargetMetrics(
  view: ProseMirrorView,
  container: HTMLElement,
  pmPos: number,
): TargetMetrics | null {
  if (view.isDestroyed) return null;
  const clamped = Math.max(0, Math.min(pmPos, view.state.doc.content.size));
  const el = blockElementForPos(view, clamped);
  if (!el) return null;
  const rect = el.getBoundingClientRect();
  const containerTop = container.getBoundingClientRect().top;
  return { top: rect.top - containerTop + container.scrollTop, height: rect.height };
}

function findScrollContainer(): HTMLElement | null {
  if (typeof document === 'undefined') return null;
  return visibleEditorScrollContainer();
}

function topmostVisiblePos(view: ProseMirrorView, container: HTMLElement): number | null {
  const rect = container.getBoundingClientRect();
  const x = rect.left + rect.width / 2;
  const toolbarOverlap = editorToolbarOverlapPx();
  for (const dy of [toolbarOverlap + 1, toolbarOverlap + 12, toolbarOverlap + 40]) {
    const found = view.posAtCoords({ left: x, top: rect.top + dy });
    if (found) return found.pos;
  }
  return null;
}

function topmostVisibleSourceOffset(view: EditorView, container: HTMLElement): number | null {
  const rect = container.getBoundingClientRect();
  const x = rect.left + rect.width / 2;
  const toolbarOverlap = editorToolbarOverlapPx();
  for (const dy of [toolbarOverlap + 1, toolbarOverlap + 12, toolbarOverlap + 40]) {
    const pos = view.posAtCoords({ x, y: rect.top + dy });
    if (pos !== null) return pos;
  }
  return null;
}

export function captureModeSwitchAnchor(params: {
  from: EditorModeValue;
  to: EditorModeValue;
  docName: string;
  ytext: Y.Text;
}): void {
  const { from, to, docName, ytext } = params;
  if (from === 'wysiwyg' && to === 'source') captureWysiwygToSource(docName, ytext);
  else if (from === 'source' && to === 'wysiwyg') captureSourceToWysiwyg(docName, ytext);
}

function captureWysiwygToSource(docName: string, ytext: Y.Text): void {
  const existing = peekPendingSourceNavigation(docName);
  if (existing && existing.kind !== 'selection-offset') return;
  const editor = getEditorForDoc(docName);
  if (!editor) return;
  const view = getEditorView(editor);
  if (!view) return;
  const container = findScrollContainer();
  if (!container) return;
  const pos = topmostVisiblePos(view, container);
  if (pos === null) return;
  const nav = buildSourceLandingNav(view.state.doc, pos, ytext, getSharedResolver());
  if (nav) rememberPendingSourceNavigation(docName, nav);
}

function captureSourceToWysiwyg(docName: string, ytext: Y.Text): void {
  const view = getMarkdownSourceViewForDoc(docName);
  if (!view) return;
  const container = findScrollContainer();
  if (!container) return;
  const offset = topmostVisibleSourceOffset(view, container);
  if (offset === null) return;
  const wysiwygEditor = getEditorForDoc(docName);
  const pmDoc = wysiwygEditor ? getEditorView(wysiwygEditor)?.state.doc : undefined;
  const nav = buildWysiwygLandingNav(ytext.toString(), offset, ytext, getSharedResolver(), pmDoc);
  if (nav) rememberPendingWysiwygNavigation(docName, nav);
}

export function startSourceLanding(params: {
  view: EditorView;
  docName: string;
  navigation: SelectionOffsetNavigation;
  ydoc: Y.Doc;
  transition?: { from: EditorModeValue; to: EditorModeValue };
}): LandingHandle | null {
  const { view, docName, navigation, ydoc, transition } = params;
  const wysiwygEditor = getEditorForDoc(docName);
  const pmDoc = wysiwygEditor ? getEditorView(wysiwygEditor)?.state.doc : undefined;
  if (!pmDoc) return null;
  const resolved = resolveSourceLandingTarget(navigation, {
    source: view.state.doc.toString(),
    pmDoc,
    ydoc,
    resolver: getSharedResolver(),
  });
  if (!resolved) return null;
  const container = findScrollContainer();
  if (!container) return null;
  const target = resolved;
  const isJump = navigation.intent === 'jump';
  const landingOffset = isJump ? target.point : target.blockStart;
  view.dispatch({ effects: EditorView.scrollIntoView(landingOffset, { y: 'start' }) });

  let cancelled = false;
  let handle: LandingHandle | null = null;
  const pendingOwner = registerLandingScrollOwner(docName, {
    yieldsToNavigation: !isJump,
    supersede: () => {
      cancelled = true;
      pendingOwner.release();
    },
  });
  const MAX_RENDER_FRAMES = 8;
  const beginWhenRendered = (attempt: number): void => {
    if (cancelled) return;
    if (safeCoordsAtPos(view, landingOffset) === null && attempt < MAX_RENDER_FRAMES) {
      requestAnimationFrame(() => beginWhenRendered(attempt + 1));
      return;
    }
    try {
      if (isJump) {
        view.dispatch({ selection: EditorSelection.cursor(landingOffset) });
        view.focus();
      }
    } finally {
      pendingOwner.release();
    }
    handle = startLanding({
      docName,
      container,
      contentColumn: view.contentDOM,
      measureTarget: () => sourceTargetMetrics(view, container, landingOffset),
      placement: isJump ? 'center' : 'top',
      intent: isJump ? 'jump' : 'toggle',
      grade: target.confidence,
      landedMode: 'source',
      transition,
      toolbarOffset: editorToolbarOverlapPx(),
      onOutcome: isJump
        ? (outcome) => {
            if (outcome.status === 'landed') {
              flashSourceLanding(view, target.blockStart, target.blockEnd, target.confidence);
            }
          }
        : undefined,
      onDiscardQueuedTarget: () => clearPendingSourceNavigation(docName),
    });
  };
  beginWhenRendered(0);
  return {
    cancel: (reason) => {
      cancelled = true;
      pendingOwner.release();
      handle?.cancel(reason);
    },
  };
}

export function startWysiwygLanding(params: {
  editor: Editor;
  docName: string;
  navigation: SelectionOffsetNavigation;
  ydoc: Y.Doc;
  transition?: { from: EditorModeValue; to: EditorModeValue };
}): LandingHandle | null {
  const { editor, docName, navigation, ydoc, transition } = params;
  const view = getEditorView(editor);
  if (!view) return null;
  const resolved = resolveWysiwygLandingTarget(navigation, {
    source: ydoc.getText('source').toString(),
    pmDoc: view.state.doc,
    ydoc,
    resolver: getSharedResolver(),
  });
  if (!resolved) return null;
  const container = findScrollContainer();
  if (!container) return null;
  const target = resolved;
  return startLanding({
    docName,
    container,
    contentColumn: view.dom,
    measureTarget: () => wysiwygTargetMetrics(view, container, target.point),
    placement: 'top',
    intent: 'toggle',
    grade: target.confidence,
    landedMode: 'wysiwyg',
    transition,
    toolbarOffset: editorToolbarOverlapPx(),
    onDiscardQueuedTarget: () => clearPendingWysiwygNavigation(docName),
  });
}