Method next

lib/internal/webstreams/readablestream.js:559–603

()

      // await uses here do not trigger that failure because
      // the test that fails does not trigger those code paths.
      next() {
        // If this is the first read, delay by one microtask
        // to ensure that the controller has had an opportunity
        // to properly start and perform the initial pull.
        // TODO(@jasnell): The spec doesn't call this out so
        // need to investigate if it's a bug in our impl or
        // the spec.
        if (!started) {
          state.current = PromiseResolve();
          started = true;
        }
        if (state.current !== undefined) {
          state.current =
            PromisePrototypeThen(state.current, nextSteps, nextSteps);
          return state.current;
        }
        // No read is in flight. Mirror the buffered fast path of
        // ReadableStreamDefaultReader.read(): when data is already queued
        // in a default controller, resolve immediately without allocating
        // a read request. The result settles synchronously, so leaving
        // state.current undefined matches the state the slow path reaches
        // once its read request callbacks have settled.
        const stream = reader[kState].stream;
        if (!state.done && stream !== undefined) {
          const controller = stream[kState].controller;
          if (stream[kState].state === 'readable' &&
              isReadableStreamDefaultController(controller) &&
              controller[kState].queue.length > 0) {
            stream[kState].disturbed = true;
            const chunk = dequeueValue(controller);

            if (controller[kState].closeRequested &&
                !controller[kState].queue.length) {
              readableStreamDefaultControllerClearAlgorithms(controller);
              readableStreamClose(stream);
            } else {
              readableStreamDefaultControllerCallPullIfNeeded(controller);
            }

            return PromiseResolve({ done: false, value: chunk });
          }
        }
        state.current = nextSteps();
        return state.current;
      },

      return(error) {
        started = true;