How to use the stream-json/streamers/StreamArray.streamArray function in stream-json

app.get('/sitemap.xml', function(req, res) {
  res.header('Content-Type', 'application/xml');
  res.header('Content-Encoding', 'gzip');
  // if we have a cached entry send it
  if (sitemap) {
    res.send(sitemap)
    return
  }
  try {
    // this could just as easily be a db response
    const gzippedStream = fs.createReadStream(resolve(__dirname, '..', 'tests', 'mocks', 'perf-data.json'))
    .pipe(parser())
    .pipe(streamArray()) // replace with streamValues for JSONStream
    .pipe(map.obj(chunk => chunk.value))
    .pipe(new SitemapStream({ hostname: 'https://example.com/' }))
    .pipe(createGzip())

    // cache the response
    streamToPromise(gzippedStream).then(sm => sitemap = sm)
    // stream the response
    gzippedStream.pipe(res).on('error', (e) => {throw e})
  } catch (e) {
    console.error(e)
    res.status(500).end()
  }
});

public static async parseQueryResultResponseAsync(
        bodyStream: stream.Stream,
        conventions: DocumentConventions,
        fromCache: boolean,
        bodyCallback?: (body: string) => void): Promise {

        const resultsPromise = RavenCommandResponsePipeline.create()
            .collectBody(bodyCallback)
            .parseJsonAsync([
                pick({ filter: "Results" }),
                streamArray()
            ])
            .streamKeyCaseTransform("camel", "DOCUMENT_LOAD") // we don't care about the case in facets
            .collectResult((result, next) => [...result, next["value"]], [])
            .process(bodyStream);

        const includesPromise = parseDocumentIncludes(bodyStream, conventions);
        const restPromise = parseRestOfOutput(bodyStream, /^Results|Includes$/);

        const [results, includes, rest] = await Promise.all([resultsPromise, includesPromise, restPromise]);
        const rawResult = Object.assign({} as any, rest, { results, includes }) as QueryResult;
        const queryResult = conventions.objectMapper.fromObjectLiteral(rawResult, {
            typeName: QueryResult.name,
            nestedTypes: {
                indexTimestamp: "date",
                lastQueryTime: "date"
            }

export function getDocumentResultsPipeline(
    conventions: DocumentConventions): RavenCommandResponsePipeline {

    return RavenCommandResponsePipeline.create()
        .parseJsonAsync([
            pick({ filter: "Results" }),
            streamArray(),
        ])
        .streamKeyCaseTransform(conventions.entityFieldNameConvention, "DOCUMENT_LOAD");
}

public async setResponseAsync(bodyStream: stream.Stream, fromCache: boolean): Promise {
        if (!bodyStream) {
            this._throwInvalidResponse();
        }

        const responsesPromise = this._pipeline()
            .parseJsonAsync([
                ignore({ filter: /^Results\.\d+\.Result/ }),
                pick({ filter: "Results" }),
                streamArray()
            ])
            .streamKeyCaseTransform({
                defaultTransform: "camel",
                ignorePaths: [/\./],
            })
            .collectResult({
                initResult: [] as GetResponse[],
                reduceResults: (result: GetResponse[], next) => {
                    return [...result, next["value"]];
                }
            })
            .process(bodyStream);

        const responsesResultsPromise = this._pipeline()
            .parseJsonAsync([
                pick({ filter: "Results" }),