@reactivex/ix-esnext-esm/asynciterable/toobservable.js

import { observable as symbolObservable } from '../observer';
const noop = (_) => {
    /**/
};
function toObserver(next, error, complete) {
    if (next && typeof next === 'object') {
        const observer = next;
        return {
            next: (observer.next || noop).bind(observer),
            error: (observer.error || noop).bind(observer),
            complete: (observer.complete || noop).bind(observer)
        };
    }
    else {
        return {
            next: typeof next === 'function' ? next : noop,
            error: typeof error === 'function' ? error : noop,
            complete: typeof complete === 'function' ? complete : noop
        };
    }
}
class BooleanSubscription {
    constructor() {
        this.isUnsubscribed = false;
    }
    unsubscribe() {
        this.isUnsubscribed = true;
    }
}
class AsyncIterableObservable {
    constructor(source) {
        this._source = source;
    }
    [symbolObservable]() {
        return this;
    }
    subscribe(next, error, complete) {
        const observer = toObserver(next, error, complete);
        const subscription = new BooleanSubscription();
        const it = this._source[Symbol.asyncIterator]();
        const f = () => {
            it.next()
                .then(({ value, done }) => {
                if (!subscription.isUnsubscribed) {
                    if (done) {
                        observer.complete();
                    }
                    else {
                        observer.next(value);
                        f();
                    }
                }
            })
                .catch(err => {
                if (!subscription.isUnsubscribed) {
                    observer.error(err);
                }
            });
        };
        f();
        return subscription;
    }
}
export function toObservable(source) {
    return new AsyncIterableObservable(source);
}

//# sourceMappingURL=toobservable.mjs.map