@flarehr/apollo-benefits 1.2.97 → 1.3.54109

package/dist/lib/esm/filter-aeb65cac.js

@@ -1,370 +0,0 @@
-import { h as hostReportError, o as observable, s as subscribeToArray, i as isObject, S as Subscriber, O as Observable, a as Subscription, c as scheduleArray } from './scheduleArray-b9669898.js';
-
-const subscribeToPromise = (promise) => (subscriber) => {
-    promise.then((value) => {
-        if (!subscriber.closed) {
-            subscriber.next(value);
-            subscriber.complete();
-        }
-    }, (err) => subscriber.error(err))
-        .then(null, hostReportError);
-    return subscriber;
-};
-
-function getSymbolIterator() {
-    if (typeof Symbol !== 'function' || !Symbol.iterator) {
-        return '@@iterator';
-    }
-    return Symbol.iterator;
-}
-const iterator = getSymbolIterator();
-
-const subscribeToIterable = (iterable) => (subscriber) => {
-    const iterator$1 = iterable[iterator]();
-    do {
-        let item;
-        try {
-            item = iterator$1.next();
-        }
-        catch (err) {
-            subscriber.error(err);
-            return subscriber;
-        }
-        if (item.done) {
-            subscriber.complete();
-            break;
-        }
-        subscriber.next(item.value);
-        if (subscriber.closed) {
-            break;
-        }
-    } while (true);
-    if (typeof iterator$1.return === 'function') {
-        subscriber.add(() => {
-            if (iterator$1.return) {
-                iterator$1.return();
-            }
-        });
-    }
-    return subscriber;
-};
-
-const subscribeToObservable = (obj) => (subscriber) => {
-    const obs = obj[observable]();
-    if (typeof obs.subscribe !== 'function') {
-        throw new TypeError('Provided object does not correctly implement Symbol.observable');
-    }
-    else {
-        return obs.subscribe(subscriber);
-    }
-};
-
-const isArrayLike = ((x) => x && typeof x.length === 'number' && typeof x !== 'function');
-
-function isPromise(value) {
-    return !!value && typeof value.subscribe !== 'function' && typeof value.then === 'function';
-}
-
-const subscribeTo = (result) => {
-    if (!!result && typeof result[observable] === 'function') {
-        return subscribeToObservable(result);
-    }
-    else if (isArrayLike(result)) {
-        return subscribeToArray(result);
-    }
-    else if (isPromise(result)) {
-        return subscribeToPromise(result);
-    }
-    else if (!!result && typeof result[iterator] === 'function') {
-        return subscribeToIterable(result);
-    }
-    else {
-        const value = isObject(result) ? 'an invalid object' : `'${result}'`;
-        const msg = `You provided ${value} where a stream was expected.`
-            + ' You can provide an Observable, Promise, Array, or Iterable.';
-        throw new TypeError(msg);
-    }
-};
-
-class SimpleInnerSubscriber extends Subscriber {
-    constructor(parent) {
-        super();
-        this.parent = parent;
-    }
-    _next(value) {
-        this.parent.notifyNext(value);
-    }
-    _error(error) {
-        this.parent.notifyError(error);
-        this.unsubscribe();
-    }
-    _complete() {
-        this.parent.notifyComplete();
-        this.unsubscribe();
-    }
-}
-class SimpleOuterSubscriber extends Subscriber {
-    notifyNext(innerValue) {
-        this.destination.next(innerValue);
-    }
-    notifyError(err) {
-        this.destination.error(err);
-    }
-    notifyComplete() {
-        this.destination.complete();
-    }
-}
-function innerSubscribe(result, innerSubscriber) {
-    if (innerSubscriber.closed) {
-        return undefined;
-    }
-    if (result instanceof Observable) {
-        return result.subscribe(innerSubscriber);
-    }
-    let subscription;
-    try {
-        subscription = subscribeTo(result)(innerSubscriber);
-    }
-    catch (error) {
-        innerSubscriber.error(error);
-    }
-    return subscription;
-}
-
-function scheduleObservable(input, scheduler) {
-    return new Observable(subscriber => {
-        const sub = new Subscription();
-        sub.add(scheduler.schedule(() => {
-            const observable$1 = input[observable]();
-            sub.add(observable$1.subscribe({
-                next(value) { sub.add(scheduler.schedule(() => subscriber.next(value))); },
-                error(err) { sub.add(scheduler.schedule(() => subscriber.error(err))); },
-                complete() { sub.add(scheduler.schedule(() => subscriber.complete())); },
-            }));
-        }));
-        return sub;
-    });
-}
-
-function schedulePromise(input, scheduler) {
-    return new Observable(subscriber => {
-        const sub = new Subscription();
-        sub.add(scheduler.schedule(() => input.then(value => {
-            sub.add(scheduler.schedule(() => {
-                subscriber.next(value);
-                sub.add(scheduler.schedule(() => subscriber.complete()));
-            }));
-        }, err => {
-            sub.add(scheduler.schedule(() => subscriber.error(err)));
-        })));
-        return sub;
-    });
-}
-
-function scheduleIterable(input, scheduler) {
-    if (!input) {
-        throw new Error('Iterable cannot be null');
-    }
-    return new Observable(subscriber => {
-        const sub = new Subscription();
-        let iterator$1;
-        sub.add(() => {
-            if (iterator$1 && typeof iterator$1.return === 'function') {
-                iterator$1.return();
-            }
-        });
-        sub.add(scheduler.schedule(() => {
-            iterator$1 = input[iterator]();
-            sub.add(scheduler.schedule(function () {
-                if (subscriber.closed) {
-                    return;
-                }
-                let value;
-                let done;
-                try {
-                    const result = iterator$1.next();
-                    value = result.value;
-                    done = result.done;
-                }
-                catch (err) {
-                    subscriber.error(err);
-                    return;
-                }
-                if (done) {
-                    subscriber.complete();
-                }
-                else {
-                    subscriber.next(value);
-                    this.schedule();
-                }
-            }));
-        }));
-        return sub;
-    });
-}
-
-function isInteropObservable(input) {
-    return input && typeof input[observable] === 'function';
-}
-
-function isIterable(input) {
-    return input && typeof input[iterator] === 'function';
-}
-
-function scheduled(input, scheduler) {
-    if (input != null) {
-        if (isInteropObservable(input)) {
-            return scheduleObservable(input, scheduler);
-        }
-        else if (isPromise(input)) {
-            return schedulePromise(input, scheduler);
-        }
-        else if (isArrayLike(input)) {
-            return scheduleArray(input, scheduler);
-        }
-        else if (isIterable(input) || typeof input === 'string') {
-            return scheduleIterable(input, scheduler);
-        }
-    }
-    throw new TypeError((input !== null && typeof input || input) + ' is not observable');
-}
-
-function from(input, scheduler) {
-    if (!scheduler) {
-        if (input instanceof Observable) {
-            return input;
-        }
-        return new Observable(subscribeTo(input));
-    }
-    else {
-        return scheduled(input, scheduler);
-    }
-}
-
-function map(project, thisArg) {
-    return function mapOperation(source) {
-        if (typeof project !== 'function') {
-            throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');
-        }
-        return source.lift(new MapOperator(project, thisArg));
-    };
-}
-class MapOperator {
-    constructor(project, thisArg) {
-        this.project = project;
-        this.thisArg = thisArg;
-    }
-    call(subscriber, source) {
-        return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));
-    }
-}
-class MapSubscriber extends Subscriber {
-    constructor(destination, project, thisArg) {
-        super(destination);
-        this.project = project;
-        this.count = 0;
-        this.thisArg = thisArg || this;
-    }
-    _next(value) {
-        let result;
-        try {
-            result = this.project.call(this.thisArg, value, this.count++);
-        }
-        catch (err) {
-            this.destination.error(err);
-            return;
-        }
-        this.destination.next(result);
-    }
-}
-
-function distinctUntilChanged(compare, keySelector) {
-    return (source) => source.lift(new DistinctUntilChangedOperator(compare, keySelector));
-}
-class DistinctUntilChangedOperator {
-    constructor(compare, keySelector) {
-        this.compare = compare;
-        this.keySelector = keySelector;
-    }
-    call(subscriber, source) {
-        return source.subscribe(new DistinctUntilChangedSubscriber(subscriber, this.compare, this.keySelector));
-    }
-}
-class DistinctUntilChangedSubscriber extends Subscriber {
-    constructor(destination, compare, keySelector) {
-        super(destination);
-        this.keySelector = keySelector;
-        this.hasKey = false;
-        if (typeof compare === 'function') {
-            this.compare = compare;
-        }
-    }
-    compare(x, y) {
-        return x === y;
-    }
-    _next(value) {
-        let key;
-        try {
-            const { keySelector } = this;
-            key = keySelector ? keySelector(value) : value;
-        }
-        catch (err) {
-            return this.destination.error(err);
-        }
-        let result = false;
-        if (this.hasKey) {
-            try {
-                const { compare } = this;
-                result = compare(this.key, key);
-            }
-            catch (err) {
-                return this.destination.error(err);
-            }
-        }
-        else {
-            this.hasKey = true;
-        }
-        if (!result) {
-            this.key = key;
-            this.destination.next(value);
-        }
-    }
-}
-
-function filter(predicate, thisArg) {
-    return function filterOperatorFunction(source) {
-        return source.lift(new FilterOperator(predicate, thisArg));
-    };
-}
-class FilterOperator {
-    constructor(predicate, thisArg) {
-        this.predicate = predicate;
-        this.thisArg = thisArg;
-    }
-    call(subscriber, source) {
-        return source.subscribe(new FilterSubscriber(subscriber, this.predicate, this.thisArg));
-    }
-}
-class FilterSubscriber extends Subscriber {
-    constructor(destination, predicate, thisArg) {
-        super(destination);
-        this.predicate = predicate;
-        this.thisArg = thisArg;
-        this.count = 0;
-    }
-    _next(value) {
-        let result;
-        try {
-            result = this.predicate.call(this.thisArg, value, this.count++);
-        }
-        catch (err) {
-            this.destination.error(err);
-            return;
-        }
-        if (result) {
-            this.destination.next(value);
-        }
-    }
-}
-
-export { SimpleOuterSubscriber as S, SimpleInnerSubscriber as a, filter as b, distinctUntilChanged as d, from as f, innerSubscribe as i, map as m };