Class ChunkedMessageStream

packages/bot-slack/src/chunked-message-stream.ts:53–180

const DEFAULT_LIMIT = 3500;

export class ChunkedMessageStream {
  private buffer = "";
  /** Sorted positions where a chunk ends (= where the next chunk begins). */
  private boundaries: number[] = [];
  private streams: MessageStream[] = [];
  /** Serialises new-chunk creation so async postPlaceholder calls don't race. */
  private setupPromise: Promise<void> = Promise.resolve();
  private finished = false;

  private readonly limit: number;
  private readonly minIntervalMs: number | undefined;
  private readonly postPlaceholder: (text: string) => Promise<string>;
  private readonly updateAt: (ts: string, text: string) => Promise<void>;
  private readonly transform: (text: string) => string;

  constructor(config: ChunkedMessageStreamConfig) {
    this.limit = config.limit ?? DEFAULT_LIMIT;
    this.minIntervalMs = config.minIntervalMs;
    this.postPlaceholder = config.postPlaceholder;
    this.updateAt = config.updateAt;
    this.transform = config.transform ?? ((t) => t);
  }

  append(fullText: string): void {
    if (this.finished) return;
    if (fullText === this.buffer) return;
    this.buffer = fullText;
    this.refreezeBoundaries();
    // Make sure we have one Slack message per chunk, then dispatch.
    this.setupPromise = this.setupPromise.then(() =>
      this.ensureStreamsAndDispatch(),
    );
  }

  async finish(): Promise<void> {
    this.finished = true;
    // Drain any pending setup, then a final dispatch, then finish each stream.
    this.setupPromise = this.setupPromise.then(() =>
      this.ensureStreamsAndDispatch(),
    );
    await this.setupPromise;
    for (const s of this.streams) await s.finish();
  }

  /** Returns the number of Slack messages this stream has posted so far. */
  get chunkCount(): number {
    return this.streams.length;
  }

  /**
   * Walk forward from the last frozen boundary, freezing new ones whenever
   * the active chunk's length exceeds the soft limit. Once frozen, a
   * boundary doesn't move.
   *
   * Special case (block-keeps-whole): if the chosen boundary lands INSIDE
   * an open fenced code block, we try to move the boundary BACK to the
   * position right before the fence opener, so the *whole* block lives in
   * the next Slack message rather than being split. The previous chunk