Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

32.7 KB
Raw Blame
import {
  DndContext,
  type DragEndEvent,
  DragOverlay,
  type DragStartEvent,
  KeyboardSensor,
  PointerSensor,
  useDroppable,
  useSensor,
  useSensors,
} from '@dnd-kit/core';
import { arrayMove, sortableKeyboardCoordinates } from '@dnd-kit/sortable';
import { useLingui } from '@lingui/react/macro';
import {
  type CSSProperties,
  Fragment,
  type ReactNode,
  type UIEvent,
  useEffect,
  useEffectEvent,
  useLayoutEffect,
  useRef,
  useState,
  useSyncExternalStore,
} from 'react';
import { docNameForNavigationTarget } from '@/components/navigation-targets';
import { ResizableHandle, ResizablePanel, ResizablePanelGroup } from '@/components/ui/resizable';
import {
  Select,
  SelectContent,
  SelectItem,
  SelectTrigger,
  SelectValue,
} from '@/components/ui/select';
import { useDocumentContext } from '@/editor/DocumentContext';
import type { EditorPaneState, PaneSide } from '@/editor/editor-panes';
import { openSidebarDropPayload } from '@/editor/sidebar-drop';
import {
  getNoteWindowDeletedDoc,
  subscribeNoteWindowDeleted,
} from '@/lib/note-window-deleted-store';
import { isNoteWindow } from '@/lib/note-window-mode';
import { paneVisibilityStore } from '@/lib/pane-visibility-store';
import { hasSidebarDragType, parseSidebarDragPayload } from '@/lib/sidebar-drag';
import { useFileSidebarSide } from '@/lib/sidebar-side-store';
import { useSingleFileMode } from '@/lib/single-file-mode';
import { cn } from '@/lib/utils';
import { EditorTabs } from './EditorTabs';
import {
  type EditorTabDragData,
  editorWorkspaceCollisionDetection,
  findEditorTabElement,
  isEditorTabDragData,
  isEditorTabDropData,
  TAB_KEYBOARD_DRAG_CODES,
  TAB_SELECTED_SURFACE_CLASS,
} from './editor-tabs-chrome';
import { FileListToggle } from './FileListToggle';
import { NoteWindowDeletedState } from './NoteWindowDeletedState';

const MIN_EDITOR_PANE_WIDTH = 300;

export interface EditorWorkspaceActivityBindings {
  activityHosts: ReadonlyMap<string, HTMLElement>;
  parkingHost: HTMLElement | null;
  visibleDocNames: ReadonlySet<string>;
}

export interface EditorWorkspacePaneRenderContext {
  pane: EditorPaneState;
  isFocused: boolean;
  activityDocName: string | null;
  activityMount: ReactNode;
}

interface EditorWorkspaceProps {
  renderHeader: (tabs: ReactNode) => ReactNode;
  renderPane: (context: EditorWorkspacePaneRenderContext) => ReactNode;
  renderActivityPool?: (bindings: EditorWorkspaceActivityBindings) => ReactNode;
}

interface TabDropPlacement {
  indicatorIndex: number;
  pane: EditorPaneState;
  targetIndex: number;
  targetOrder: readonly string[];
}

type TabDropEvent = Pick<DragEndEvent, 'active' | 'over'> & Partial<Pick<DragEndEvent, 'delta'>>;

function activityDocNameForPane(pane: EditorPaneState): string | null {
  if (pane.activeTarget?.kind === 'large-file') return null;
  return pane.activeTarget ? docNameForNavigationTarget(pane.activeTarget) : null;
}

function PaneStripDropTarget({
  children,
  index,
  isFocused,
  isLast,
  paneId,
  projected,
  selected,
  size,
}: {
  children: ReactNode;
  index: number;
  isFocused: boolean;
  isLast: boolean;
  paneId: string;
  projected: boolean;
  selected: boolean;
  size: number;
}) {
  const { setNodeRef } = useDroppable({
    id: `editor-pane-strip:${paneId}`,
    data: { kind: 'pane-strip', paneId, index },
  });
  return (
    <div
      ref={setNodeRef}
      data-editor-pane-tab-group={paneId}
      data-editor-pane-focused={isFocused || undefined}
      data-editor-pane-selected={projected && selected ? '' : undefined}
      aria-hidden={projected && !selected ? true : undefined}
      inert={projected && !selected}
      className={cn(
        'relative h-full min-w-0 shrink basis-0',
        isLast && '[&>*]:pe-[var(--editor-header-trailing-width,0px)]',
      )}
      style={{ flexGrow: size }}
    >
      {children}
    </div>
  );
}

function PaneEdgeDropTarget({
  drag,
  paneId,
  side,
}: {
  drag: EditorTabDragData | null;
  paneId: string;
  side: PaneSide;
}) {
  const { isOver, setNodeRef } = useDroppable({
    id: `editor-pane-edge:${paneId}:${side}`,
    data: { kind: 'pane-edge', paneId, side },
    disabled: drag?.splittable !== true,
  });
  return (
    <div
      ref={setNodeRef}
      aria-hidden="true"
      data-pane-edge={side}
      data-editor-pane-id={paneId}
      data-pane-drop-side={isOver ? side : undefined}
      // oxlint-disable-next-line ok/no-physical-direction-utility -- `side` is the split model's own physical left/right, not a reading-direction edge — this strip has to land on the pane side the pointer is actually over. Whether panes themselves mirror under RTL is still open; mapping to start/end now would pre-commit that answer while looking like a no-op, since the two are identical in LTR.
      className={cn(
        'pointer-events-none absolute inset-y-0 z-30 w-12 opacity-0',
        side === 'left' ? 'left-0' : 'right-0',
        isOver && 'bg-primary/15 opacity-100 ring-2 ring-primary ring-inset',
      )}
    />
  );
}

function PaneBoundaryDropTarget({
  drag,
  leftPaneId,
  rightPaneId,
}: {
  drag: EditorTabDragData | null;
  leftPaneId: string;
  rightPaneId: string;
}) {
  const { isOver: isLeftHalfOver, setNodeRef: setLeftHalfNodeRef } = useDroppable({
    id: `editor-pane-edge:${leftPaneId}:right`,
    data: { kind: 'pane-edge', paneId: leftPaneId, side: 'right' },
    disabled: drag?.splittable !== true,
  });
  const { isOver: isRightHalfOver, setNodeRef: setRightHalfNodeRef } = useDroppable({
    id: `editor-pane-edge:${rightPaneId}:left`,
    data: { kind: 'pane-edge', paneId: rightPaneId, side: 'left' },
    disabled: drag?.splittable !== true,
  });
  const side = isLeftHalfOver ? 'right' : isRightHalfOver ? 'left' : null;

  return (
    <>
      <div
        ref={setLeftHalfNodeRef}
        aria-hidden="true"
        data-pane-edge="right"
        data-pane-edge-pane-id={leftPaneId}
        className="pointer-events-none absolute inset-y-0 right-1/2 w-12"
      />
      <div
        ref={setRightHalfNodeRef}
        aria-hidden="true"
        data-pane-edge="left"
        data-pane-edge-pane-id={rightPaneId}
        className="pointer-events-none absolute inset-y-0 left-1/2 w-12"
      />
      <div
        aria-hidden="true"
        data-pane-boundary-drop=""
        data-pane-boundary-left={leftPaneId}
        data-pane-boundary-right={rightPaneId}
        data-pane-drop-side={side ?? undefined}
        className={cn(
          'pointer-events-none absolute inset-y-0 left-1/2 z-30 w-24 -translate-x-1/2 opacity-0',
          side && 'bg-primary/15 opacity-100 ring-2 ring-primary ring-inset',
        )}
      />
    </>
  );
}

function PaneActivityMount({
  docName,
  onActivityMount,
  onPaneFocus,
  paneId,
}: {
  docName: string;
  onActivityMount: (paneId: string, element: HTMLElement | null) => void;
  onPaneFocus: (paneId: string) => void;
  paneId: string;
}) {
  const activityMountRef = useRef<HTMLDivElement>(null);
  const notifyActivityMount = useEffectEvent(onActivityMount);
  const notifyPaneFocus = useEffectEvent(onPaneFocus);

  useLayoutEffect(() => {
    const mount = activityMountRef.current;
    if (!mount) return;
    const focus = () => notifyPaneFocus(paneId);
    mount.addEventListener('pointerdown', focus, true);
    mount.addEventListener('focusin', focus, true);
    notifyActivityMount(paneId, mount);
    return () => {
      mount.removeEventListener('pointerdown', focus, true);
      mount.removeEventListener('focusin', focus, true);
      notifyActivityMount(paneId, null);
    };
  }, [paneId]);

  return (
    <div
      ref={activityMountRef}
      data-editor-activity-mount={paneId}
      data-doc-name={docName}
      className="absolute inset-0"
    />
  );
}

function WorkspacePane({
  drag,
  isFocused,
  label,
  onActivityMount,
  pane,
  renderPane,
  showOuterLeftDropTarget = false,
  showOuterRightDropTarget = false,
  showDropTargets = true,
}: {
  drag: EditorTabDragData | null;
  isFocused: boolean;
  label: string;
  onActivityMount: (paneId: string, element: HTMLElement | null) => void;
  pane: EditorPaneState;
  renderPane: EditorWorkspaceProps['renderPane'];
  showOuterLeftDropTarget?: boolean;
  showOuterRightDropTarget?: boolean;
  showDropTargets?: boolean;
}) {
  const { focusPane, openTargetInPane } = useDocumentContext();
  const [sidebarDropActive, setSidebarDropActive] = useState(false);
  const paneRef = useRef<HTMLElement | null>(null);
  const activityDocName = activityDocNameForPane(pane);

  useLayoutEffect(() => {
    const element = paneRef.current;
    if (!element) return;

    const handleSidebarDragOver = (event: DragEvent) => {
      if (!hasSidebarDragType(event.dataTransfer)) return;
      event.preventDefault();
      if (event.dataTransfer) event.dataTransfer.dropEffect = 'copy';
      setSidebarDropActive(true);
    };
    const handleSidebarDragLeave = (event: DragEvent) => {
      const relatedTarget = event.relatedTarget;
      if (relatedTarget instanceof Node && element.contains(relatedTarget)) return;
      setSidebarDropActive(false);
    };
    const clearSidebarDropActive = () => setSidebarDropActive(false);
    const handleSidebarDrop = (event: DragEvent) => {
      setSidebarDropActive(false);
      const payload = parseSidebarDragPayload(event.dataTransfer);
      if (!payload) return;
      event.preventDefault();
      event.stopPropagation();
      openSidebarDropPayload(
        payload,
        (target, options) => openTargetInPane(pane.id, target, options),
        pane.activeNewTabId !== null,
      );
    };

    element.addEventListener('dragover', handleSidebarDragOver, true);
    element.addEventListener('dragleave', handleSidebarDragLeave, true);
    element.addEventListener('drop', handleSidebarDrop, true);
    window.addEventListener('drop', clearSidebarDropActive, true);
    window.addEventListener('dragend', clearSidebarDropActive, true);
    return () => {
      element.removeEventListener('dragover', handleSidebarDragOver, true);
      element.removeEventListener('dragleave', handleSidebarDragLeave, true);
      element.removeEventListener('drop', handleSidebarDrop, true);
      window.removeEventListener('drop', clearSidebarDropActive, true);
      window.removeEventListener('dragend', clearSidebarDropActive, true);
    };
  }, [openTargetInPane, pane.activeNewTabId, pane.id]);

  return (
    <section
      ref={paneRef}
      aria-current={isFocused ? 'true' : undefined}
      aria-label={label}
      data-editor-pane-id={pane.id}
      data-editor-pane-focused={isFocused || undefined}
      data-sidebar-drop-active={sidebarDropActive || undefined}
      className={cn(
        'relative flex h-full min-h-0 min-w-0 flex-col bg-background',
        sidebarDropActive &&
          'after:pointer-events-none after:absolute after:inset-2 after:z-20 after:rounded-lg after:bg-primary/5 after:ring-2 after:ring-primary/70 after:ring-inset',
      )}
      onPointerDownCapture={() => focusPane(pane.id)}
      onFocusCapture={() => focusPane(pane.id)}
    >
      <div className="relative flex min-h-0 flex-1 flex-col">
        {renderPane({
          pane,
          isFocused,
          activityDocName,
          activityMount: activityDocName ? (
            <PaneActivityMount
              docName={activityDocName}
              onActivityMount={onActivityMount}
              onPaneFocus={focusPane}
              paneId={pane.id}
            />
          ) : null,
        })}
      </div>
      {showDropTargets && showOuterLeftDropTarget ? (
        <PaneEdgeDropTarget drag={drag} paneId={pane.id} side="left" />
      ) : null}
      {showDropTargets && showOuterRightDropTarget ? (
        <PaneEdgeDropTarget drag={drag} paneId={pane.id} side="right" />
      ) : null}
    </section>
  );
}

export function EditorWorkspace({
  renderActivityPool,
  renderHeader,
  renderPane,
}: EditorWorkspaceProps) {
  const { t } = useLingui();
  const {
    focusPane,
    focusedPaneId,
    moveTabToPane,
    panes,
    reorderTabsInPane,
    resizePanes,
    splitTab,
    tabSessionLoaded,
    visibleTabIdsByPane,
  } = useDocumentContext();
  const singleFile = useSingleFileMode();
  const singleDocumentSurface = singleFile || isNoteWindow();
  const fileSidebarSide = useFileSidebarSide();
  const deletedDocName = useSyncExternalStore(
    subscribeNoteWindowDeleted,
    getNoteWindowDeletedDoc,
    () => null,
  );
  const desktopSessionRestorePending =
    !singleFile &&
    !tabSessionLoaded &&
    typeof window !== 'undefined' &&
    window.okDesktop?.config.mode === 'editor';
  const [drag, setDrag] = useState<EditorTabDragData | null>(null);
  const [dropIndicator, setDropIndicator] = useState<{
    index: number;
    paneId: string;
  } | null>(null);
  const [activityMounts, setActivityMounts] = useState<ReadonlyMap<string, HTMLElement>>(
    () => new Map(),
  );
  const [parkingHost, setParkingHost] = useState<HTMLElement | null>(null);
  const [workspaceElement, setWorkspaceElement] = useState<HTMLDivElement | null>(null);
  const [workspaceWidth, setWorkspaceWidth] = useState(0);
  const pendingGroupTabFocusRef = useRef<{ paneId: string; tabId: string } | null>(null);
  const exclusive = useSyncExternalStore(
    paneVisibilityStore.subscribe,
    paneVisibilityStore.isExclusive,
    () => false,
  );
  const focusFrameRef = useRef<number | null>(null);
  const [headerCanvas, setHeaderCanvas] = useState<HTMLDivElement | null>(null);
  const resolvedPaneLayoutRef = useRef<{
    paneKey: string;
    layout: Record<string, number>;
  } | null>(null);
  const paneKey = panes.map((pane) => pane.id).join('\u0000');
  const savedLayout = Object.fromEntries(
    panes.map((pane) => [`editor-pane:${pane.id}`, pane.size]),
  );
  const visibleDocNames = new Set<string>();
  const activityHosts = new Map<string, HTMLElement>();
  for (const pane of panes) {
    const docName = activityDocNameForPane(pane);
    if (!docName) continue;
    visibleDocNames.add(docName);
    const mount = activityMounts.get(pane.id);
    if (mount) activityHosts.set(docName, mount);
  }
  const sensors = useSensors(
    useSensor(PointerSensor, { activationConstraint: { distance: 8 } }),
    useSensor(KeyboardSensor, {
      coordinateGetter: sortableKeyboardCoordinates,
      keyboardCodes: TAB_KEYBOARD_DRAG_CODES,
    }),
  );
  const narrowForPanes = (width: number) =>
    width > 0 && width < panes.length * MIN_EDITOR_PANE_WIDTH + panes.length - 1;
  const projected =
    !singleDocumentSurface && panes.length > 1 && (exclusive || narrowForPanes(workspaceWidth));
  const canvasStyle = {
    '--editor-workspace-min-width':
      projected || panes.length === 1
        ? '100%'
        : `max(100%, ${panes.length * MIN_EDITOR_PANE_WIDTH}px)`,
  } as CSSProperties;

  const liveWorkspaceWidthRef = useRef(0);
  const syncWorkspaceWidth = useEffectEvent(() => {
    const liveWidth = liveWorkspaceWidthRef.current;
    if (Math.abs(liveWidth - workspaceWidth) <= 1) return;
    if (narrowForPanes(liveWidth) !== narrowForPanes(workspaceWidth)) setWorkspaceWidth(liveWidth);
  });
  useLayoutEffect(() => {
    syncWorkspaceWidth();
  });
  useLayoutEffect(() => {
    if (!workspaceElement) return;
    let frame: number | null = null;
    const observer = new ResizeObserver(([entry]) => {
      if (entry && entry.contentRect.width > 0) {
        const nextWidth = entry.contentRect.width;
        if (frame !== null) cancelAnimationFrame(frame);
        frame = requestAnimationFrame(() => {
          frame = null;
          liveWorkspaceWidthRef.current = nextWidth;
          syncWorkspaceWidth();
        });
      }
    });
    observer.observe(workspaceElement);
    return () => {
      observer.disconnect();
      if (frame !== null) cancelAnimationFrame(frame);
    };
  }, [workspaceElement]);

  function applyHeaderLayout(layout: Record<string, number>) {
    const groups = headerCanvas?.querySelectorAll<HTMLElement>('[data-editor-pane-tab-group]');
    groups?.forEach((group) => {
      const paneId = group.dataset.editorPaneTabGroup;
      const size = paneId ? layout[`editor-pane:${paneId}`] : undefined;
      if (size !== undefined) group.style.setProperty('flex-grow', String(size));
    });
  }

  useLayoutEffect(() => {
    const resolved = resolvedPaneLayoutRef.current;
    if (resolved?.paneKey === paneKey) applyHeaderLayout(resolved.layout);
  });

  useEffect(() => {
    return () => {
      if (focusFrameRef.current !== null) cancelAnimationFrame(focusFrameRef.current);
    };
  }, []);

  useEffect(() => {
    if (!drag) return;
    document.body.setAttribute('data-editor-tab-dragging', '');
    return () => document.body.removeAttribute('data-editor-tab-dragging');
  }, [drag]);

  if (desktopSessionRestorePending) {
    return (
      <>
        {renderHeader(null)}
        <div data-editor-workspace-pending="" className="min-h-0 flex-1 bg-background" />
      </>
    );
  }

  function registerActivityMount(paneId: string, element: HTMLElement | null) {
    setActivityMounts((current) => {
      const prior = current.get(paneId);
      if (prior === element) return current;
      const next = new Map(current);
      if (element) next.set(paneId, element);
      else next.delete(paneId);
      return next;
    });
  }

  function requestTabFocus(paneId: string, tabId: string) {
    if (focusFrameRef.current !== null) cancelAnimationFrame(focusFrameRef.current);
    focusFrameRef.current = requestAnimationFrame(() => {
      focusFrameRef.current = null;
      findEditorTabElement(document, paneId, tabId)?.focus();
    });
  }

  function visibleOrderForPane(pane: EditorPaneState): readonly string[] {
    return visibleTabIdsByPane.get(pane.id) ?? [...pane.openTabs, ...pane.newTabIds];
  }

  function moveOrReorderTab(
    active: EditorTabDragData,
    targetPane: EditorPaneState,
    targetIndex: number,
    targetOrder?: readonly string[],
  ) {
    if (active.paneId !== targetPane.id) {
      moveTabToPane(active.tabId, targetPane.id, targetIndex);
      requestTabFocus(targetPane.id, active.tabId);
      return;
    }
    if (!targetOrder) return;
    const fromIndex = targetOrder.indexOf(active.tabId);
    if (fromIndex < 0 || fromIndex === targetIndex) return;
    reorderTabsInPane(
      targetPane.id,
      arrayMove([...targetOrder], fromIndex, targetIndex),
      active.tabId,
    );
  }

  function resolveTabDropPlacement(
    event: TabDropEvent,
    active: EditorTabDragData,
  ): TabDropPlacement | null {
    const overData = event.over?.data.current;
    let paneId: string;
    let indicatorIndex: number;

    if (isEditorTabDragData(overData)) {
      paneId = overData.paneId;
      const targetPane = panes.find((pane) => pane.id === paneId);
      if (!targetPane) return null;
      const targetOrder = visibleOrderForPane(targetPane);
      const overIndex = targetOrder.indexOf(overData.tabId);
      if (overIndex < 0) return null;

      const activeIndex = active.paneId === paneId ? targetOrder.indexOf(active.tabId) : -1;
      const horizontalDelta = event.delta?.x ?? 0;
      const activeRect = event.active.rect?.current.translated;
      const overRect = event.over?.rect;
      let afterHoveredTab: boolean;
      if (activeIndex >= 0 && activeIndex !== overIndex) {
        afterHoveredTab = activeIndex < overIndex;
      } else if (activeIndex === overIndex && horizontalDelta !== 0) {
        afterHoveredTab = horizontalDelta > 0;
      } else {
        afterHoveredTab =
          activeRect !== null &&
          activeRect !== undefined &&
          overRect !== undefined &&
          activeRect.left + activeRect.width / 2 > overRect.left + overRect.width / 2;
      }
      indicatorIndex = overIndex + (afterHoveredTab ? 1 : 0);
    } else if (isEditorTabDropData(overData) && overData.kind === 'pane-strip') {
      paneId = overData.paneId;
      indicatorIndex = overData.index;
    } else {
      return null;
    }

    const pane = panes.find((candidate) => candidate.id === paneId);
    if (!pane) return null;
    const targetOrder = visibleOrderForPane(pane);
    const boundedIndicatorIndex = Math.min(Math.max(indicatorIndex, 0), targetOrder.length);
    const fromIndex = active.paneId === pane.id ? targetOrder.indexOf(active.tabId) : -1;
    const targetIndex =
      fromIndex >= 0 && boundedIndicatorIndex > fromIndex
        ? boundedIndicatorIndex - 1
        : boundedIndicatorIndex;
    if (fromIndex >= 0 && targetIndex === fromIndex) return null;

    return {
      indicatorIndex: boundedIndicatorIndex,
      pane,
      targetIndex,
      targetOrder,
    };
  }

  function updateDropIndicator(event: TabDropEvent) {
    const active = event.active.data.current;
    const placement = isEditorTabDragData(active) ? resolveTabDropPlacement(event, active) : null;
    const next = placement ? { index: placement.indicatorIndex, paneId: placement.pane.id } : null;
    setDropIndicator((current) =>
      current?.paneId === next?.paneId && current?.index === next?.index ? current : next,
    );
  }

  function handleDragStart(event: DragStartEvent) {
    const nextDrag = event.active.data.current;
    if (!isEditorTabDragData(nextDrag)) return;
    setDropIndicator(null);
    setDrag(nextDrag);
    focusPane(nextDrag.paneId);
  }

  function handleDragEnd(event: DragEndEvent) {
    const active = event.active.data.current;
    const over = event.over?.data.current;
    const placement = isEditorTabDragData(active) ? resolveTabDropPlacement(event, active) : null;
    setDropIndicator(null);
    setDrag(null);
    if (!isEditorTabDragData(active)) return;

    if (placement) {
      moveOrReorderTab(active, placement.pane, placement.targetIndex, placement.targetOrder);
      return;
    }

    if (!isEditorTabDropData(over)) return;

    if (over.kind === 'pane-edge') {
      if (!active.splittable) return;
      const newPaneId = splitTab(active.tabId, over.paneId, over.side);
      if (newPaneId) requestTabFocus(newPaneId, active.tabId);
      return;
    }
  }

  function syncHeaderScroll(event: UIEvent<HTMLDivElement>) {
    headerCanvas?.style.setProperty(
      'transform',
      `translateX(-${event.currentTarget.scrollLeft}px)`,
    );
  }

  function syncHeaderLayout(layout: Record<string, number>) {
    resolvedPaneLayoutRef.current = { paneKey, layout };
    if (!projected) applyHeaderLayout(layout);
  }

  function groupOptionLabel(paneId: string): string {
    const number = panes.findIndex((pane) => pane.id === paneId) + 1;
    return t`Pane ${number}`;
  }

  function paneLabel(paneId: string): string {
    const position = panes.findIndex((pane) => pane.id === paneId);
    return position < 0 ? t`editor pane` : t`pane ${position + 1}`;
  }

  function dragDestinationDescription(data: unknown): string | null {
    if (isEditorTabDragData(data)) return paneLabel(data.paneId);
    if (!isEditorTabDropData(data)) return null;
    if (data.kind === 'pane-edge') {
      if (data.side === 'left') {
        return t`a new pane to the left of ${paneLabel(data.paneId)}`;
      }
      return t`a new pane to the right of ${paneLabel(data.paneId)}`;
    }
    return paneLabel(data.paneId);
  }

  function holdsFileListToggle(pane: EditorPaneState, index: number): boolean {
    if (projected) return pane.id === focusedPaneId;
    return index === (fileSidebarSide === 'start' ? 0 : panes.length - 1);
  }

  function paneLeadingControl(pane: EditorPaneState, index: number): ReactNode {
    if (fileSidebarSide !== 'start' || !holdsFileListToggle(pane, index)) return undefined;
    return <FileListToggle side="start" />;
  }

  function paneTrailingControl(pane: EditorPaneState, index: number): ReactNode {
    if (fileSidebarSide !== 'end' || !holdsFileListToggle(pane, index)) return undefined;
    return <FileListToggle side="end" />;
  }

  const paneGroup = (
    <ResizablePanelGroup
      key={paneKey}
      id="editor-workspace-panes"
      orientation="horizontal"
      disabled={projected}
      defaultLayout={savedLayout}
      onLayoutChange={syncHeaderLayout}
      onLayoutChanged={(layout, meta) => {
        if (!meta.isUserInteraction || projected) return;
        resizePanes(
          new Map(panes.map((pane) => [pane.id, layout[`editor-pane:${pane.id}`] ?? pane.size])),
        );
      }}
    >
      {panes.map((pane, index) => (
        <Fragment key={pane.id}>
          {index > 0 ? (
            <ResizableHandle
              withHandle
              data-editor-pane-resize-handle=""
              data-editor-pane-projected={projected ? '' : undefined}
              data-editor-pane-before={panes[index - 1]?.id}
              data-editor-pane-after={pane.id}
            >
              <PaneBoundaryDropTarget
                drag={drag}
                leftPaneId={panes[index - 1]?.id ?? pane.id}
                rightPaneId={pane.id}
              />
            </ResizableHandle>
          ) : null}
          <ResizablePanel
            id={`editor-pane:${pane.id}`}
            data-editor-pane-panel=""
            data-editor-pane-selected={projected && pane.id === focusedPaneId ? '' : undefined}
            aria-hidden={projected && pane.id !== focusedPaneId ? true : undefined}
            inert={projected && pane.id !== focusedPaneId}
            defaultSize={`${pane.size}%`}
            minSize={projected || panes.length === 1 ? '0px' : `${MIN_EDITOR_PANE_WIDTH}px`}
          >
            <WorkspacePane
              drag={drag}
              isFocused={pane.id === focusedPaneId}
              label={paneLabel(pane.id)}
              onActivityMount={registerActivityMount}
              pane={pane}
              renderPane={renderPane}
              showOuterLeftDropTarget={index === 0}
              showOuterRightDropTarget={index === panes.length - 1}
            />
          </ResizablePanel>
        </Fragment>
      ))}
    </ResizablePanelGroup>
  );
  const headerTabs = (
    <div data-editor-header-tab-groups="" className="h-full min-w-0 flex-1 overflow-hidden">
      <div
        ref={setHeaderCanvas}
        data-editor-header-tab-canvas=""
        data-editor-pane-projected={projected ? '' : undefined}
        className="flex h-full min-w-(--editor-workspace-min-width)"
        style={canvasStyle}
      >
        {panes.map((pane, index) => (
          <Fragment key={pane.id}>
            {index > 0 && !projected ? (
              <div
                aria-hidden="true"
                data-editor-header-pane-separator=""
                className="w-px shrink-0 bg-border"
              />
            ) : null}
            <PaneStripDropTarget
              paneId={pane.id}
              index={visibleOrderForPane(pane).length}
              isFocused={pane.id === focusedPaneId}
              isLast={projected ? pane.id === focusedPaneId : index === panes.length - 1}
              projected={projected}
              selected={pane.id === focusedPaneId}
              size={pane.size}
            >
              <EditorTabs
                dropIndicatorIndex={dropIndicator?.paneId === pane.id ? dropIndicator.index : null}
                paneId={pane.id}
                onSplitComplete={requestTabFocus}
                leading={paneLeadingControl(pane, index)}
                trailing={paneTrailingControl(pane, index)}
              />
            </PaneStripDropTarget>
          </Fragment>
        ))}
      </div>
    </div>
  );

  if (singleDocumentSurface) {
    const pane = panes.find((candidate) => candidate.id === focusedPaneId) ?? panes[0];
    if (deletedDocName !== null) {
      return (
        <>
          {renderHeader(null)}
          <div data-editor-workspace="" className="relative min-h-0 flex-1 overflow-hidden">
            <NoteWindowDeletedState docName={deletedDocName} />
          </div>
        </>
      );
    }
    return (
      <>
        {renderHeader(null)}
        <div data-editor-workspace="" className="relative min-h-0 flex-1 overflow-hidden">
          {pane ? (
            <WorkspacePane
              drag={null}
              isFocused
              label={paneLabel(pane.id)}
              onActivityMount={registerActivityMount}
              pane={pane}
              renderPane={renderPane}
              showDropTargets={false}
            />
          ) : null}
          <div ref={setParkingHost} data-editor-activity-parking="" className="hidden" inert />
          {parkingHost !== null
            ? renderActivityPool?.({ activityHosts, parkingHost, visibleDocNames })
            : null}
        </div>
      </>
    );
  }

  return (
    <DndContext
      sensors={sensors}
      autoScroll={false}
      collisionDetection={editorWorkspaceCollisionDetection}
      onDragStart={handleDragStart}
      onDragMove={updateDropIndicator}
      onDragOver={updateDropIndicator}
      onDragEnd={handleDragEnd}
      onDragCancel={() => {
        setDropIndicator(null);
        setDrag(null);
      }}
      accessibility={{
        container: typeof document !== 'undefined' ? document.body : undefined,
        screenReaderInstructions: {
          draggable: t`Press Space to pick up a tab. Use the arrow keys to move it within a tab strip, then press Space or Enter to drop it. Press Shift+F10 or the Menu key to open the tab context menu for split, close, pin, and other tab actions.`,
        },
        announcements: {
          onDragStart: ({ active }) => {
            const data = active.data.current;
            return isEditorTabDragData(data)
              ? t`Picked up ${data.label} from ${paneLabel(data.paneId)}.`
              : undefined;
          },
          onDragOver: ({ active, over }) => {
            const activeData = active.data.current;
            if (!isEditorTabDragData(activeData) || !over) return undefined;
            const destination = dragDestinationDescription(over.data.current);
            return destination ? t`${activeData.label} is over ${destination}.` : undefined;
          },
          onDragEnd: ({ active, over }) => {
            const activeData = active.data.current;
            if (!isEditorTabDragData(activeData)) return undefined;
            const destination = over ? dragDestinationDescription(over.data.current) : null;
            return destination
              ? t`Moved ${activeData.label} to ${destination}.`
              : t`${activeData.label} was not moved.`;
          },
          onDragCancel: ({ active }) => {
            const activeData = active.data.current;
            return isEditorTabDragData(activeData)
              ? t`Cancelled moving ${activeData.label}.`
              : undefined;
          },
        },
      }}
    >
      {renderHeader(
        <>
          {projected ? (
            <Select
              value={focusedPaneId}
              onValueChange={(paneId) => {
                focusPane(paneId);
                const pane = panes.find((candidate) => candidate.id === paneId);
                const tabId = pane?.activeTabId ?? pane?.activeNewTabId;
                pendingGroupTabFocusRef.current = tabId ? { paneId, tabId } : null;
              }}
            >
              <SelectTrigger
                aria-label={t`Editor pane`}
                data-editor-group-selector=""
                size="sm"
                className="mx-1 my-auto w-24 shrink-0"
              >
                <SelectValue />
              </SelectTrigger>
              <SelectContent
                onCloseAutoFocus={(event) => {
                  const pending = pendingGroupTabFocusRef.current;
                  pendingGroupTabFocusRef.current = null;
                  if (!pending) return;
                  event.preventDefault();
                  requestTabFocus(pending.paneId, pending.tabId);
                }}
              >
                {panes.map((pane) => (
                  <SelectItem key={pane.id} value={pane.id}>
                    {groupOptionLabel(pane.id)}
                  </SelectItem>
                ))}
              </SelectContent>
            </Select>
          ) : null}
          {headerTabs}
        </>,
      )}
      <div
        ref={setWorkspaceElement}
        data-editor-workspace=""
        className="relative min-h-0 flex-1 overflow-x-auto overflow-y-hidden"
        onScroll={syncHeaderScroll}
      >
        <div
          data-editor-workspace-canvas=""
          data-editor-pane-projected={projected ? '' : undefined}
          className="h-full min-w-[var(--editor-workspace-min-width)]"
          style={canvasStyle}
        >
          {paneGroup}
        </div>
        <div ref={setParkingHost} data-editor-activity-parking="" className="hidden" inert />
        {parkingHost !== null
          ? renderActivityPool?.({ activityHosts, parkingHost, visibleDocNames })
          : null}
      </div>
      <DragOverlay dropAnimation={null}>
        {drag ? (
          <div
            aria-hidden="true"
            data-testid="editor-tab-drag-overlay"
            className={cn(
              'pointer-events-none flex h-7 w-44 max-w-[calc(100vw-2rem)] cursor-grabbing items-center overflow-hidden rounded-md px-3 font-medium text-1sm shadow-lg',
              TAB_SELECTED_SURFACE_CLASS,
            )}
          >
            <span className="min-w-0 truncate">{drag.label}</span>
          </div>
        ) : null}
      </DragOverlay>
    </DndContext>
  );
}