ix/asynciterable/fromdomstream.mjs

The Interactive Extensions for JavaScript

import { __asyncDelegator, __asyncGenerator, __asyncValues, __await, __awaiter } from "tslib";
import { AsyncIterableX } from './asynciterablex.mjs';
/** @ignore */
const SharedArrayBuf = typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : ArrayBuffer;
/** @ignore */
/** @ignore */
export class AsyncIterableReadableStream extends AsyncIterableX {
    constructor(_stream) {
        super();
        this._stream = _stream;
    }
    [Symbol.asyncIterator]() {
        const stream = this._stream;
        const reader = stream['getReader']();
        return _consumeReader(stream, reader, defaultReaderToAsyncIterator(reader));
    }
}
/** @ignore */
/** @ignore */
export 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;
    }
}
function _consumeReader(stream, reader, iterator) {
    return __asyncGenerator(this, arguments, function* _consumeReader_1() {
        let threw = false;
        try {
            yield __await(yield* __asyncDelegator(__asyncValues(iterator)));
        }
        catch (e) {
            if ((threw = true) && reader) {
                yield __await(reader['cancel'](e));
            }
        }
        finally {
            if (reader) {
                if (!threw) {
                    yield __await(reader['cancel']());
                }
                if (stream.locked) {
                    try {
                        reader.closed.catch(() => {
                            /* */
                        });
                        reader.releaseLock();
                    }
                    catch (e) {
                        /* */
                    }
                }
            }
        }
    });
}
/** @ignore */
function defaultReaderToAsyncIterator(reader) {
    return __asyncGenerator(this, arguments, function* defaultReaderToAsyncIterator_1() {
        let r;
        while (!(r = yield __await(reader.read())).done) {
            yield yield __await(r.value);
        }
    });
}
/** @ignore */
function byobReaderToAsyncIterator(reader) {
    return __asyncGenerator(this, arguments, function* byobReaderToAsyncIterator_1() {
        let r;
        let value = yield yield __await(null);
        while (!(r = yield __await(readNext(reader, value, 0))).done) {
            value = yield yield __await(r.value);
        }
    });
}
/** @ignore */
function readNext(reader, bufferOrLen, offset) {
    return __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 __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.
 */
export function fromDOMStream(stream, options) {
    return !options || options['mode'] !== 'byob'
        ? new AsyncIterableReadableStream(stream)
        : new AsyncIterableReadableByteStream(stream);
}

//# sourceMappingURL=fromdomstream.mjs.map