Streaming API

/**
 * Create encoding transform stream
 * @param encoding - Target encoding name
 * @param options - Stream and encoding options
 * @returns Transform stream that encodes strings to buffers
 */
function encodeStream(encoding, options);

const iconv = require('iconv-lite');
const fs = require('fs');

// File encoding example
fs.createReadStream('input.txt', 'utf8')
  .pipe(iconv.encodeStream('win1251'))
  .pipe(fs.createWriteStream('output-win1251.txt'));

// HTTP response encoding
app.get('/data', (req, res) => {
  const encoder = iconv.encodeStream('iso-8859-1');
  dataStream.pipe(encoder).pipe(res);
});

// With BOM
const encoderWithBOM = iconv.encodeStream('utf16le', { addBOM: true });

/**
 * Create decoding transform stream
 * @param encoding - Source encoding name
 * @param options - Stream and encoding options
 * @returns Transform stream that decodes buffers to strings
 */
function decodeStream(encoding, options);

const iconv = require('iconv-lite');
const http = require('http');

// HTTP request decoding
http.createServer((req, res) => {
  const decoder = iconv.decodeStream('win1251');
  req.pipe(decoder);
  
  decoder.on('data', (str) => {
    console.log(str); // Decoded string chunks
  });
});

// File conversion
fs.createReadStream('input-gbk.txt')
  .pipe(iconv.decodeStream('gbk'))
  .pipe(iconv.encodeStream('utf8'))
  .pipe(fs.createWriteStream('output-utf8.txt'));

// With BOM preservation
const decoder = iconv.decodeStream('utf16le', { stripBOM: false });

/**
 * Enable streaming API with custom stream module
 * @param streamModule - Node.js stream module or compatible implementation
 */
function enableStreamingAPI(streamModule);

const iconv = require('iconv-lite');
const stream = require('stream');

// Manual streaming API activation
iconv.enableStreamingAPI(stream);

// In React Native or other environments
const stream = require('stream-browserify');
iconv.enableStreamingAPI(stream);

// Check if streaming is available
if (iconv.supportsStreams) {
  const decoder = iconv.decodeStream('utf8');
}

/**
 * Transform stream for encoding strings to buffers
 * @param conv - Encoder instance from getEncoder()
 * @param options - Stream options
 */
class IconvLiteEncoderStream extends Transform {
  constructor(conv, options);
  
  /**
   * Collect all encoded output into a single buffer
   * @param cb - Callback receiving (error, buffer)
   * @returns this for chaining
   */
  collect(cb);
}

const iconv = require('iconv-lite');

// Direct class usage
const encoder = iconv.getEncoder('utf16le');
const encoderStream = new iconv.IconvLiteEncoderStream(encoder);

// Collect output
encoderStream.collect((err, buffer) => {
  if (err) throw err;
  console.log('Encoded data:', buffer);
});

encoderStream.write('Hello ');
encoderStream.write('World');
encoderStream.end();

/**
 * Transform stream for decoding buffers to strings
 * @param conv - Decoder instance from getDecoder()
 * @param options - Stream options
 */
class IconvLiteDecoderStream extends Transform {
  constructor(conv, options);
  
  /**
   * Collect all decoded output into a single string
   * @param cb - Callback receiving (error, string)
   * @returns this for chaining
   */
  collect(cb);
}

const iconv = require('iconv-lite');

// Direct class usage
const decoder = iconv.getDecoder('gbk');
const decoderStream = new iconv.IconvLiteDecoderStream(decoder);

// Collect output
decoderStream.collect((err, str) => {
  if (err) throw err;
  console.log('Decoded text:', str);
});

decoderStream.write(buffer1);
decoderStream.write(buffer2);
decoderStream.end();

/**
 * Stream options extending basic Options
 */
const StreamOptions = {
  // Basic options
  stripBOM,
  addBOM,
  defaultEncoding,
  
  // Transform stream options
  /** Transform stream object mode */
  objectMode,
  /** Transform stream high water mark */
  highWaterMark,
  /** Transform stream decode strings option */
  decodeStrings,
  /** Transform stream encoding */
  encoding
};

// Check if streams are supported
if (!iconv.supportsStreams) {
  // Streams not available - will throw error if used
  console.log('Streaming API not available');
}

// Enable streams in browser (if stream module available)
const stream = require('stream-browserify');
iconv.enableStreamingAPI(stream);

const decoder = iconv.decodeStream('utf8');

decoder.on('error', (err) => {
  console.error('Decoding error:', err.message);
});

// Encoding errors in streams
const encoder = iconv.encodeStream('ascii');
encoder.on('error', (err) => {
  // Handle encoding errors
});

/** Boolean indicating if streaming API is currently enabled */
const supportsStreams;