whatwg-stream-to-async-iter/cjs/index.cjs

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.asyncIterToStream = exports.streamToAsyncIter = exports.asyncIterableToStream = exports.streamToAsyncIterable = void 0;
const tslib_1 = require("tslib");
const isIterable = (x) => x != null && typeof x === 'object' && Symbol.iterator in x;
const isAsyncIterable = (x) => x != null && typeof x === 'object' && Symbol.asyncIterator in x;
const forAwaitableIterator = (x) => isAsyncIterable(x)
    ? x[Symbol.asyncIterator]()
    : isIterable(x)
        ? x[Symbol.iterator]()
        : (() => { throw Error('Not for-awaitable. Neither Symbol.asyncIterator nor Symbol.iterator found.'); })();
function streamToAsyncIterable(stream) {
    return tslib_1.__asyncGenerator(this, arguments, function* streamToAsyncIterable_1() {
        const reader = stream.getReader();
        try {
            let { done, value } = yield tslib_1.__await(reader.read());
            while (!done) {
                yield yield tslib_1.__await(value);
                ({ done, value } = yield tslib_1.__await(reader.read()));
            }
            reader.releaseLock(); // FIXME: is this necessary?
        }
        catch (err) {
            throw err;
        }
    });
}
exports.streamToAsyncIterable = streamToAsyncIterable;
exports.streamToAsyncIter = streamToAsyncIterable;
// Older version of Cloudflare Workers do not support the `ReadableStream` constructor, 
// so we use a TransformStream instead:
function asyncIterableToStreamTS(iterable) {
    const { readable, writable } = new TransformStream();
    (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
        var e_1, _a;
        const writer = writable.getWriter();
        try {
            try {
                for (var iterable_1 = tslib_1.__asyncValues(iterable), iterable_1_1; iterable_1_1 = yield iterable_1.next(), !iterable_1_1.done;) {
                    const x = iterable_1_1.value;
                    writer.write(x);
                }
            }
            catch (e_1_1) { e_1 = { error: e_1_1 }; }
            finally {
                try {
                    if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) yield _a.call(iterable_1);
                }
                finally { if (e_1) throw e_1.error; }
            }
            writer.close();
        }
        catch (err) {
            writer.abort(err);
        }
    }))();
    return readable;
}
function asyncIterableToStreamRS(iterable) {
    let iterator;
    return new ReadableStream({
        start() {
            iterator = forAwaitableIterator(iterable);
        },
        pull(controller) {
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                const { value, done } = yield iterator.next();
                if (!done)
                    controller.enqueue(value);
                else
                    controller.close();
            });
        },
        cancel(reason) {
            var _a;
            return tslib_1.__awaiter(this, void 0, void 0, function* () {
                try {
                    yield ((_a = iterator.throw) === null || _a === void 0 ? void 0 : _a.call(iterator, reason));
                }
                catch (_b) { }
            });
        },
    });
}
const tryReadableStream = () => {
    try {
        return !!new ReadableStream({});
    }
    catch (_a) {
        return false;
    }
};
exports.asyncIterableToStream = tryReadableStream()
    ? asyncIterableToStreamRS
    : asyncIterableToStreamTS;
exports.asyncIterToStream = exports.asyncIterableToStream;