JavaScript quiver-stream-channel createChannel Examples

Example #1

File: node-stream.js Project: quiverjs/quiver-stream-util

export const nodeToQuiverWriteStream = nodeWrite => {
  const { readStream, writeStream } = createChannel()

  nodeWrite.on('error', err =>
    readStream.closeRead(err))

  const doPipe = async function() {
    try {
      while(true) {
        const { data, closed } = await readStream.read()
        if(closed) return nodeWrite.end()

        const ready = nodeWrite.write(data)

        if(!ready) await waitEvent(nodeWrite, 'drain')
      }

    } catch(err) {
      nodeWrite.end()
      readStream.closeRead(err)
    }
  }

  doPipe()

  return writeStream
}

Example #2

File: text.js Project: quiverjs/quiver-stream-util

export const textToStream = text => {
  const { readStream, writeStream } = createChannel()

  writeStream.write(new Buffer(text))
  writeStream.closeWrite()

  return readStream
}

Example #3

File: buffer.js Project: quiverjs/stream-convert

export var bufferToStream = buffer => {
  var { readStream, writeStream } = createChannel()

  writeStream.write(buffer)
  writeStream.closeWrite(null)

  return readStream
}

Example #4

File: text.js Project: quiverjs/stream-convert

  it('stream to text should equal original', () => {
    var { readStream, writeStream } = createChannel()

    writeStream.write(buffer1)
    writeStream.write(buffer2)
    writeStream.write(buffer3)
    writeStream.closeWrite()

    return streamToText(readStream).then(text => 
      text.should.equal(testString))
  })

Example #5

File: node-stream.js Project: quiverjs/quiver-stream-util

export const nodeToQuiverReadStream = nodeRead => {
  const { readStream, writeStream } = createChannel()

  let ended = false

  nodeRead.on('end', () => {
    if(ended) return
    ended = true
    writeStream.closeWrite()
  })

  nodeRead.on('error', err => {
    if(ended) return
    ended = true
    writeStream.closeWrite(err)
  })

  const doRead = async function() {
    while(true) {
      if(ended) return { closed: true }

      const data = nodeRead.read()
      if(data) return { data }

      await waitEvent(nodeRead, 'readable')
    }
  }

  const doPipe = async function() {
    try {
      while(true) {
        const { closed: writeClosed } = await writeStream.prepareWrite()

        // force the node read stream into flowing mode
        // because there is no way to cancel a node read stream
        if(writeClosed) return nodeRead.resume()

        const { data, closed: readClosed } = await doRead()

        if(readClosed) return

        writeStream.write(data)
      }
    } catch(err) {
      nodeRead.resume()
      writeStream.closeWrite(err)
    }
  }

  doPipe()

  return readStream
}

Example #6

File: streamable.js Project: quiverjs/stream-convert

 streamable.toStream = () => {
   var { readStream, writeStream } = createChannel()
   buffers.forEach(buffer => writeStream.write(buffer))
   pendingWrites.push(writeStream) 
   return resolve(readStream)
 }