orca/src/shared/quick-open-subprocess-path-accumulator.ts

import { GrowingByteBuffer } from '@orca/process-host/growing-byte-buffer'

const QUICK_OPEN_LISTING_MAX_PATH_BYTES = 64 * 1024

export type QuickOpenPathAccumulatorResult = 'continue' | 'stopped' | 'path-too-large'

export class QuickOpenSubprocessPathAccumulator {
  private readonly field = new GrowingByteBuffer()

  constructor(
    private readonly delimiter: number,
    private readonly maxPathBytes = QUICK_OPEN_LISTING_MAX_PATH_BYTES
  ) {
    if (!Number.isInteger(delimiter) || delimiter < 0 || delimiter > 0xff) {
      throw new RangeError('Quick Open path delimiter must be one byte')
    }
    if (!Number.isSafeInteger(maxPathBytes) || maxPathBytes < 0) {
      throw new RangeError('Quick Open path limit must be a non-negative safe integer')
    }
  }

  push(
    rawChunk: Buffer | string,
    onPath: (path: string) => boolean
  ): QuickOpenPathAccumulatorResult {
    const chunk = Buffer.isBuffer(rawChunk) ? rawChunk : Buffer.from(rawChunk, 'utf8')
    let cursor = 0
    while (cursor < chunk.length) {
      const delimiter = chunk.indexOf(this.delimiter, cursor)
      const end = delimiter === -1 ? chunk.length : delimiter
      const segmentBytes = end - cursor
      if (this.field.byteLength + segmentBytes > this.maxPathBytes) {
        this.clear()
        return 'path-too-large'
      }
      if (delimiter !== -1 && this.field.byteLength === 0) {
        if (!onPath(chunk.toString('utf8', cursor, end))) {
          return 'stopped'
        }
      } else if (segmentBytes > 0) {
        // Why: copying prevents a short residual path from retaining the whole read buffer.
        this.field.append(chunk.subarray(cursor, end))
        if (delimiter !== -1 && !onPath(this.take())) {
          return 'stopped'
        }
      } else if (delimiter !== -1 && !onPath(this.take())) {
        return 'stopped'
      }
      if (delimiter === -1) {
        return 'continue'
      }
      cursor = delimiter + 1
    }
    return 'continue'
  }

  finish(): string | null {
    return this.field.byteLength > 0 ? this.take() : null
  }

  clear(): void {
    this.field.clear()
  }

  private take(): string {
    return this.field.takeString()
  }
}