Re: [whatwg/streams] What is the expected behaviour of .pipeThrough()? (#765)

@domenic Have not been able to, as of yet, wait for `writable` portion `close()` to be called  before `readable` begins using `.pipeThrough()`, though have been able to achieve the same utilizing a variation of your code

```
function pipeThrough(data) {
  "use strict";
  console.clear();

  const readable;

  const writable = new WritableStream({
    write(chunk) {
        readable = new ReadableStream({
          pull(c) {
            c.enqueue(chunk);
            c.close();
          }
        })
      },
      close(c) {
        console.log("done")
      }
  });

  const writer = writable.getWriter();
  writer.write(data);
  writer.close();
  return writer.closed.then(() => {
    console.log("really done");
    return readable
  });

}

pipeThrough([1, 2, 3])
  .then(reader => {
    const stream = reader.getReader();
    const fn = ({value,done}) => {
      if (done) return stream.closed.then(() => ({done}));
      console.log(value, done);
      return stream.read().then(fn)
    }
    return stream.read().then(fn)
  })
  .then(done => console.log(done));
```

Is it possible to adjust your code  at the second working technique to use `.pipeThrough()` to wait for `writable` `close()` to be called before `readable` portion is read? That is `"Writable side of transform closing"` being logged before `"Reading chunk from output"`? 

Or does the order described above not matter according to the specification?


-- 
You are receiving this because you are subscribed to this thread.
Reply to this email directly or view it on GitHub:
https://github.com/whatwg/streams/issues/765#issuecomment-323558312