Buckets:
| import { __asyncValues, __awaiter, __generator, __values } from "tslib"; | |
| import { isArrayLike } from '../util/isArrayLike'; | |
| import { isPromise } from '../util/isPromise'; | |
| import { Observable } from '../Observable'; | |
| import { isInteropObservable } from '../util/isInteropObservable'; | |
| import { isAsyncIterable } from '../util/isAsyncIterable'; | |
| import { createInvalidObservableTypeError } from '../util/throwUnobservableError'; | |
| import { isIterable } from '../util/isIterable'; | |
| import { isReadableStreamLike, readableStreamLikeToAsyncGenerator } from '../util/isReadableStreamLike'; | |
| import { isFunction } from '../util/isFunction'; | |
| import { reportUnhandledError } from '../util/reportUnhandledError'; | |
| import { observable as Symbol_observable } from '../symbol/observable'; | |
| export function innerFrom(input) { | |
| if (input instanceof Observable) { | |
| return input; | |
| } | |
| if (input != null) { | |
| if (isInteropObservable(input)) { | |
| return fromInteropObservable(input); | |
| } | |
| if (isArrayLike(input)) { | |
| return fromArrayLike(input); | |
| } | |
| if (isPromise(input)) { | |
| return fromPromise(input); | |
| } | |
| if (isAsyncIterable(input)) { | |
| return fromAsyncIterable(input); | |
| } | |
| if (isIterable(input)) { | |
| return fromIterable(input); | |
| } | |
| if (isReadableStreamLike(input)) { | |
| return fromReadableStreamLike(input); | |
| } | |
| } | |
| throw createInvalidObservableTypeError(input); | |
| } | |
| export function fromInteropObservable(obj) { | |
| return new Observable(function (subscriber) { | |
| var obs = obj[Symbol_observable](); | |
| if (isFunction(obs.subscribe)) { | |
| return obs.subscribe(subscriber); | |
| } | |
| throw new TypeError('Provided object does not correctly implement Symbol.observable'); | |
| }); | |
| } | |
| export function fromArrayLike(array) { | |
| return new Observable(function (subscriber) { | |
| for (var i = 0; i < array.length && !subscriber.closed; i++) { | |
| subscriber.next(array[i]); | |
| } | |
| subscriber.complete(); | |
| }); | |
| } | |
| export function fromPromise(promise) { | |
| return new Observable(function (subscriber) { | |
| promise | |
| .then(function (value) { | |
| if (!subscriber.closed) { | |
| subscriber.next(value); | |
| subscriber.complete(); | |
| } | |
| }, function (err) { return subscriber.error(err); }) | |
| .then(null, reportUnhandledError); | |
| }); | |
| } | |
| export function fromIterable(iterable) { | |
| return new Observable(function (subscriber) { | |
| var e_1, _a; | |
| try { | |
| for (var iterable_1 = __values(iterable), iterable_1_1 = iterable_1.next(); !iterable_1_1.done; iterable_1_1 = iterable_1.next()) { | |
| var value = iterable_1_1.value; | |
| subscriber.next(value); | |
| if (subscriber.closed) { | |
| return; | |
| } | |
| } | |
| } | |
| catch (e_1_1) { e_1 = { error: e_1_1 }; } | |
| finally { | |
| try { | |
| if (iterable_1_1 && !iterable_1_1.done && (_a = iterable_1.return)) _a.call(iterable_1); | |
| } | |
| finally { if (e_1) throw e_1.error; } | |
| } | |
| subscriber.complete(); | |
| }); | |
| } | |
| export function fromAsyncIterable(asyncIterable) { | |
| return new Observable(function (subscriber) { | |
| process(asyncIterable, subscriber).catch(function (err) { return subscriber.error(err); }); | |
| }); | |
| } | |
| export function fromReadableStreamLike(readableStream) { | |
| return fromAsyncIterable(readableStreamLikeToAsyncGenerator(readableStream)); | |
| } | |
| function process(asyncIterable, subscriber) { | |
| var asyncIterable_1, asyncIterable_1_1; | |
| var e_2, _a; | |
| return __awaiter(this, void 0, void 0, function () { | |
| var value, e_2_1; | |
| return __generator(this, function (_b) { | |
| switch (_b.label) { | |
| case 0: | |
| _b.trys.push([0, 5, 6, 11]); | |
| asyncIterable_1 = __asyncValues(asyncIterable); | |
| _b.label = 1; | |
| case 1: return [4, asyncIterable_1.next()]; | |
| case 2: | |
| if (!(asyncIterable_1_1 = _b.sent(), !asyncIterable_1_1.done)) return [3, 4]; | |
| value = asyncIterable_1_1.value; | |
| subscriber.next(value); | |
| if (subscriber.closed) { | |
| return [2]; | |
| } | |
| _b.label = 3; | |
| case 3: return [3, 1]; | |
| case 4: return [3, 11]; | |
| case 5: | |
| e_2_1 = _b.sent(); | |
| e_2 = { error: e_2_1 }; | |
| return [3, 11]; | |
| case 6: | |
| _b.trys.push([6, , 9, 10]); | |
| if (!(asyncIterable_1_1 && !asyncIterable_1_1.done && (_a = asyncIterable_1.return))) return [3, 8]; | |
| return [4, _a.call(asyncIterable_1)]; | |
| case 7: | |
| _b.sent(); | |
| _b.label = 8; | |
| case 8: return [3, 10]; | |
| case 9: | |
| if (e_2) throw e_2.error; | |
| return [7]; | |
| case 10: return [7]; | |
| case 11: | |
| subscriber.complete(); | |
| return [2]; | |
| } | |
| }); | |
| }); | |
| } | |
| //# sourceMappingURL=innerFrom.js.map |
Xet Storage Details
- Size:
- 5.39 kB
- Xet hash:
- c6623d2688f106cb230237fa4b31db91e37f503e0a47a82f3efa114b3442e68f
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.