Implementando divisão de texto por linha com TransformStream: LineSplitTransform

LineSplitTransform é uma implementação de TransformStream que converte dados binários (Uint8Array) recebidos de um fluxo em texto e os divide por quebras de linha.

Ela processa chunks contínuos de dados e emite cada linha separadamente, o que a torna adequada para o processamento incremental de logs e arquivos de texto grandes.

Implementação

Use TextDecoder para converter a sequência de bytes em strings e, em seguida, faça a separação com a regex /\r?\n/.

Linhas incompletas ficam no buffer até o próximo chunk completar o conteúdo, e qualquer resto também é emitido no final do fluxo.

export class LineSplitTransform extends TransformStream<Uint8Array, string> {
  constructor() {
    let buffer = "";
    const decoder = new TextDecoder();
    const delimiterRegex = /\r?\n/;

    super({
      transform(chunk, ctrl) {
        buffer += decoder.decode(chunk, { stream: true });
        const lines = buffer.split(delimiterRegex);
        buffer = lines.pop() || "";

        for (const line of lines) {
          ctrl.enqueue(line);
        }
      },
      flush(ctrl) {
        buffer += decoder.decode();
        if (buffer.length > 0) {
          ctrl.enqueue(buffer);
        }
      },
    });
  }
}

Exemplo de uso

Este exemplo envia a entrada padrão para LineSplitTransform, separa os dados linha por linha e imprime cada linha no console.

import { LineSplitTransform } from './LineSplitTransform';

// Encaminhar a entrada padrão para o LineSplitTransform
process.stdin.pipeThrough(new LineSplitTransform())
  .on('data', (line: string) => {
    console.log(`Linha recebida: ${line}`);
  });

Casos de uso

• Análise em tempo real de logs e arquivos de texto
• Processamento incremental linha a linha de dados recebidos pela rede
• Implementação de protocolos de texto delimitados por quebra de linha

Resumo

Com TransformStream, fica simples implementar um mecanismo para processar dados de fluxo linha por linha.

Como arquivos grandes podem ser tratados incrementalmente sem serem carregados de uma vez na memória, essa abordagem permite um processamento de texto eficiente em memória.