@jahed/sparql-engine/dist/engine/pipeline/rxjs-pipeline.js

SPARQL query engine for servers and web browsers.

// SPDX-License-Identifier: MIT
import { bufferCount, catchError, concat, defaultIfEmpty, distinct, EMPTY, endWith, filter, finalize, first, from, map, mergeMap, Observable, of, reduce, shareReplay, skip, Subscriber, take, tap, toArray, } from "rxjs";
import { PipelineEngine } from "./pipeline-engine.js";
const flatMap = mergeMap;
/**
 * A StreamPipelineInput implemented using Rxjs' subscribers.
 */
export class RxjsStreamInput {
    _subscriber;
    constructor(subscriber) {
        this._subscriber = subscriber;
    }
    next(value) {
        this._subscriber.next(value);
    }
    complete() {
        this._subscriber.complete();
    }
    error(err) {
        this._subscriber.error(err);
    }
}
/**
 * A pipeline implemented using Rx.js
 */
export default class RxjsPipeline extends PipelineEngine {
    empty() {
        return EMPTY;
    }
    of(...values) {
        return of(...values);
    }
    from(x) {
        return from(x);
    }
    fromAsync(cb) {
        return new Observable((subscriber) => {
            cb(new RxjsStreamInput(subscriber));
        });
    }
    clone(stage) {
        return stage.pipe(shareReplay(5));
    }
    catch(input, handler) {
        return input.pipe(catchError((err) => {
            if (handler === undefined) {
                throw err;
            }
            else {
                return handler(err);
            }
        }));
    }
    merge(...inputs) {
        return concat(...inputs);
    }
    map(input, mapper) {
        return input.pipe(map(mapper));
    }
    flatMap(input, mapper) {
        return input.pipe(flatMap(mapper));
    }
    mergeMap(input, mapper) {
        return input.pipe(mergeMap(mapper));
    }
    mergeMapAsync(input, mapper) {
        return input.pipe(mergeMap((v) => from(Promise.resolve(mapper(v))).pipe(mergeMap((n) => n))));
    }
    filter(input, predicate) {
        return input.pipe(filter(predicate));
    }
    filterAsync(input, predicate) {
        return input.pipe(flatMap((v) => from(Promise.resolve(predicate(v))).pipe(filter((b) => b), map(() => v))));
    }
    finalize(input, callback) {
        return input.pipe(finalize(callback));
    }
    reduce(input, reducer, initial) {
        return input.pipe(reduce(reducer, initial));
    }
    limit(input, stopAfter) {
        return input.pipe(take(stopAfter));
    }
    skip(input, toSkip) {
        return input.pipe(skip(toSkip));
    }
    distinct(input, selector) {
        return input.pipe(distinct(selector));
    }
    defaultValues(input, ...values) {
        if (values.length === 0) {
            return input;
        }
        else if (values.length === 1) {
            return input.pipe(defaultIfEmpty(values[0]));
        }
        else {
            return new Observable((subscriber) => {
                let isEmpty = true;
                return input.subscribe({
                    next: (x) => {
                        isEmpty = false;
                        subscriber.next(x);
                    },
                    error: (err) => subscriber.error(err),
                    complete: () => {
                        if (isEmpty) {
                            values.forEach((v) => subscriber.next(v));
                        }
                        subscriber.complete();
                    },
                });
            });
        }
    }
    bufferCount(input, count) {
        return input.pipe(bufferCount(count));
    }
    forEach(input, cb) {
        input
            .forEach(cb)
            .then()
            .catch((err) => {
            throw err;
        });
    }
    first(input) {
        return input.pipe(first());
    }
    endWith(input, values) {
        return input.pipe(endWith(...values));
    }
    tap(input, cb) {
        return input.pipe(tap(cb));
    }
    collect(input) {
        return input.pipe(toArray());
    }
}
//# sourceMappingURL=rxjs-pipeline.js.map