Function pipeTo

src/pull.js:1242–1424

* Write an async source through transforms to a writer. * * @param source - The source yielding Uint8Array[] batches (sync or async) * @param args - Variadic transforms, writer (required), and optional options * @returns Promise resolving to total bytes written

(source)

 * @returns Promise resolving to total bytes written
 */
function pipeTo(source) {
    var args = [];
    for (var _i = 1; _i < arguments.length; _i++) {
        args[_i - 1] = arguments[_i];
    }
    return __awaiter(this, void 0, void 0, function () {
        var _a, transforms, writer, options, finalTransforms, signal, totalBytes, hasWritev, writeBatch, batch, e_12_1, _b, _c, batch, streamableSource, pipeline, _d, pipeline_2, pipeline_2_1, batch, e_13_1, error_2;
        var _e, _f;
        var _this = this;
        var _g, source_6, source_6_1;
        var _h, e_12, _j, _k, _l, e_13, _m, _o;
        var _p, _q, _r, _s;
        return __generator(this, function (_t) {
            switch (_t.label) {
                case 0:
                    _a = parsePipeToArgs(args), transforms = _a.transforms, writer = _a.writer, options = _a.options;
                    finalTransforms = __spreadArray([], transforms, true);
                    if (isTransformObject(writer)) {
                        finalTransforms.push(writer);
                    }
                    signal = options === null || options === void 0 ? void 0 : options.signal;
                    // Check for abort
                    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
                        throw (_p = signal.reason) !== null && _p !== void 0 ? _p : new DOMException('Aborted', 'AbortError');
                    }
                    totalBytes = 0;
                    hasWritev = typeof writer.writev === 'function';
                    writeBatch = function (batch) { return __awaiter(_this, void 0, void 0, function () {
                        var _i, batch_3, chunk, promises, _a, batch_4, chunk, result;
                        return __generator(this, function (_b) {
                            switch (_b.label) {
                                case 0:
                                    if (!(hasWritev && batch.length > 1)) return [3 /*break*/, 2];
                                    return [4 /*yield*/, writer.writev(batch, signal ? { signal: signal } : undefined)];
                                case 1:
                                    _b.sent();
                                    for (_i = 0, batch_3 = batch; _i < batch_3.length; _i++) {
                                        chunk = batch_3[_i];
                                        totalBytes += chunk.byteLength;
                                    }
                                    return [3 /*break*/, 4];
                                case 2:
                                    promises = [];
                                    for (_a = 0, batch_4 = batch; _a < batch_4.length; _a++) {
                                        chunk = batch_4[_a];
                                        result = writer.write(chunk, signal ? { signal: signal } : undefined);
                                        if (result !== undefined) {
                                            promises.push(result);
                                        }
                                        totalBytes += chunk.byteLength;
                                    }
                                    if (!(promises.length > 0)) return [3 /*break*/, 4];
                                    return [4 /*yield*/, Promise.all(promises)];
                                case 3:
                                    _b.sent();
                                    _b.label = 4;
                                case 4: return [2 /*return*/];
                            }