@reactivex/ix-es2015-cjs/asynciterable/fromdomstream.js

The Interactive Extensions for JavaScript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.fromDOMStream = exports.AsyncIterableReadableByteStream = exports.AsyncIterableReadableStream = void 0;
const tslib_1 = require("tslib");
const asynciterablex_js_1 = require("./asynciterablex.js");
/** @ignore */
const SharedArrayBuf = typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : ArrayBuffer;
/** @ignore */
/** @ignore */
class AsyncIterableReadableStream extends asynciterablex_js_1.AsyncIterableX {
    constructor(_stream) {
        super();
        this._stream = _stream;
    }
    [Symbol.asyncIterator]() {
        const stream = this._stream;
        const reader = stream['getReader']();
        return _consumeReader(stream, reader, defaultReaderToAsyncIterator(reader));
    }
}
exports.AsyncIterableReadableStream = AsyncIterableReadableStream;
/** @ignore */
/** @ignore */
class AsyncIterableReadableByteStream extends AsyncIterableReadableStream {
    [Symbol.asyncIterator]() {
        const stream = this._stream;
        let reader;
        try {
            reader = stream['getReader']({ mode: 'byob' });
        }
        catch (e) {
            return super[Symbol.asyncIterator]();
        }
        const iterator = _consumeReader(stream, reader, byobReaderToAsyncIterator(reader));
        // "pump" the iterator once so it initializes and is ready to accept a buffer or bytesToRead
        iterator.next();
        return iterator;
    }
}
exports.AsyncIterableReadableByteStream = AsyncIterableReadableByteStream;
function _consumeReader(stream, reader, iterator) {
    return tslib_1.__asyncGenerator(this, arguments, function* _consumeReader_1() {
        let threw = false;
        try {
            yield tslib_1.__await(yield* tslib_1.__asyncDelegator(tslib_1.__asyncValues(iterator)));
        }
        catch (e) {
            if ((threw = true) && reader) {
                yield tslib_1.__await(reader['cancel'](e));
            }
        }
        finally {
            if (reader) {
                if (!threw) {
                    yield tslib_1.__await(reader['cancel']());
                }
                if (stream.locked) {
                    try {
                        reader.closed.catch(() => {
                            /* */
                        });
                        reader.releaseLock();
                    }
                    catch (e) {
                        /* */
                    }
                }
            }
        }
    });
}
/** @ignore */
function defaultReaderToAsyncIterator(reader) {
    return tslib_1.__asyncGenerator(this, arguments, function* defaultReaderToAsyncIterator_1() {
        let r;
        while (!(r = yield tslib_1.__await(reader.read())).done) {
            yield yield tslib_1.__await(r.value);
        }
    });
}
/** @ignore */
function byobReaderToAsyncIterator(reader) {
    return tslib_1.__asyncGenerator(this, arguments, function* byobReaderToAsyncIterator_1() {
        let r;
        let value = yield yield tslib_1.__await(null);
        while (!(r = yield tslib_1.__await(readNext(reader, value, 0))).done) {
            value = yield yield tslib_1.__await(r.value);
        }
    });
}
/** @ignore */
function readNext(reader, bufferOrLen, offset) {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        let size;
        let buffer;
        if (typeof bufferOrLen === 'number') {
            buffer = new ArrayBuffer((size = bufferOrLen));
        }
        else if (bufferOrLen instanceof ArrayBuffer) {
            size = (buffer = bufferOrLen).byteLength;
        }
        else if (bufferOrLen instanceof SharedArrayBuf) {
            size = (buffer = bufferOrLen).byteLength;
        }
        else {
            return { done: true, value: undefined };
        }
        return yield readInto(reader, buffer, offset, size);
    });
}
/** @ignore */
function readInto(reader, buffer, offset, size) {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        let innerOffset = offset;
        if (innerOffset >= size) {
            return { done: false, value: new Uint8Array(buffer, 0, size) };
        }
        const { done, value } = yield reader.read(new Uint8Array(buffer, innerOffset, size - innerOffset));
        if ((innerOffset += value.byteLength) < size && !done) {
            return yield readInto(reader, value.buffer, innerOffset, size);
        }
        return { done, value: new Uint8Array(value.buffer, 0, innerOffset) };
    });
}
/**
 * Creates an async-iterable from an existing DOM stream and optional options.
 *
 * @param {ReadableStream} stream The readable stream to convert to an async-iterable.
 * @param {{ mode: 'byob' }} [options] The optional options to set the mode for the DOM stream.
 * @returns {AsyncIterableX<any>} An async-iterable created from the incoming async-iterable.
 */
function fromDOMStream(stream, options) {
    return !options || options['mode'] !== 'byob'
        ? new AsyncIterableReadableStream(stream)
        : new AsyncIterableReadableByteStream(stream);
}
exports.fromDOMStream = fromDOMStream;

//# sourceMappingURL=fromdomstream.js.map