import type { Terminal as XTerm } from "@xterm/xterm"; export const MAX_WRITE_QUEUE_ITEMS = 32; export const MAX_WRITE_QUEUE_BYTES = 512 * 1024; type QueuedWrite = { bytes: number; writes: Array<(done: () => void) => void>; }; type TerminalWriteQueue = { writing: boolean; pending: QueuedWrite[]; pendingBytes: number; floodMode: boolean; onDropped?: (bytes: number) => void; }; const terminalWriteQueues = new WeakMap(); const terminalWriteQueueDropHandlers = new WeakMap void>(); const getOrCreateQueue = (term: XTerm): TerminalWriteQueue => { let queue = terminalWriteQueues.get(term); if (!queue) { queue = { writing: false, pending: [], pendingBytes: 0, floodMode: false, onDropped: terminalWriteQueueDropHandlers.get(term), }; terminalWriteQueues.set(term, queue); } return queue; }; const scheduleNextTerminalWrite = (term: XTerm, queue: TerminalWriteQueue) => { const next = queue.pending.shift(); if (!next) { queue.writing = false; queue.floodMode = false; terminalWriteQueues.delete(term); return; } queue.pendingBytes -= next.bytes; if (queue.pendingBytes < 0) queue.pendingBytes = 0; queue.writing = true; runQueuedWrite(next, () => scheduleNextTerminalWrite(term, queue)); }; const runQueuedWrite = (item: QueuedWrite, done: () => void): void => { let index = 0; let inCallback = false; let continueRequested = false; const runNext = (): void => { if (inCallback) { continueRequested = true; return; } do { continueRequested = false; const write = item.writes[index]; index += 1; if (!write) { done(); return; } inCallback = true; write(runNext); inCallback = false; } while (continueRequested); }; runNext(); }; const mergePendingWrites = (queue: TerminalWriteQueue): void => { if (queue.pending.length <= 1) return; const writes: Array<(done: () => void) => void> = []; let bytes = 0; for (const item of queue.pending) { bytes += item.bytes; writes.push(...item.writes); } queue.pending = [{ bytes, writes }]; queue.pendingBytes = bytes; queue.floodMode = true; }; export const setTerminalWriteQueueDropHandler = ( term: XTerm, onDropped?: (bytes: number) => void, ): void => { if (onDropped) { terminalWriteQueueDropHandlers.set(term, onDropped); } else { terminalWriteQueueDropHandlers.delete(term); } const queue = terminalWriteQueues.get(term); if (queue && onDropped) { queue.onDropped = onDropped; } }; export const getTerminalWriteQueueDepth = (term: XTerm): number => terminalWriteQueues.get(term)?.pending.length ?? 0; export const isTerminalWriteQueueInFloodMode = (term: XTerm): boolean => terminalWriteQueues.get(term)?.floodMode ?? false; export const enqueueTerminalWrite = ( term: XTerm, bytes: number, write: (done: () => void) => void, options: { onDropped?: (bytes: number) => void } = {}, ): void => { const queue = getOrCreateQueue(term); if (options.onDropped) { queue.onDropped = options.onDropped; } else if (!queue.onDropped) { queue.onDropped = terminalWriteQueueDropHandlers.get(term); } queue.pending.push({ bytes, writes: [write], }); queue.pendingBytes += bytes; if ( queue.floodMode || queue.pending.length >= MAX_WRITE_QUEUE_ITEMS || queue.pendingBytes > MAX_WRITE_QUEUE_BYTES ) { mergePendingWrites(queue); } if (!queue.writing) { scheduleNextTerminalWrite(term, queue); } }; /** Drop queued output frames without writing them to xterm. */ export const abortTerminalWriteQueue = ( term: XTerm, onDropped?: (bytes: number) => void, ): void => { const queue = terminalWriteQueues.get(term); if (!queue) return; let droppedBytes = queue.pendingBytes; if (queue.writing) { // The in-flight write is not counted in pendingBytes once dequeued. droppedBytes = queue.pending.reduce((sum, item) => sum + item.bytes, 0); } queue.pending = []; queue.pendingBytes = 0; queue.writing = false; queue.floodMode = false; terminalWriteQueues.delete(term); if (droppedBytes > 0) { onDropped?.(droppedBytes); } };