@flarehr/apollo-super-selection 3.17.52781 → 3.21.53721

package/dist/lib/cjs/datorama-akita-7f4b082a.js

@@ -0,0 +1,2704 @@
+'use strict';
+
+const delay = require('./delay-81aff2f1.js');
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+const ObjectUnsubscribedErrorImpl = (() => {
+    function ObjectUnsubscribedErrorImpl() {
+        Error.call(this);
+        this.message = 'object unsubscribed';
+        this.name = 'ObjectUnsubscribedError';
+        return this;
+    }
+    ObjectUnsubscribedErrorImpl.prototype = Object.create(Error.prototype);
+    return ObjectUnsubscribedErrorImpl;
+})();
+const ObjectUnsubscribedError = ObjectUnsubscribedErrorImpl;
+
+class SubjectSubscription extends delay.Subscription {
+    constructor(subject, subscriber) {
+        super();
+        this.subject = subject;
+        this.subscriber = subscriber;
+        this.closed = false;
+    }
+    unsubscribe() {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        const subject = this.subject;
+        const observers = subject.observers;
+        this.subject = null;
+        if (!observers || observers.length === 0 || subject.isStopped || subject.closed) {
+            return;
+        }
+        const subscriberIndex = observers.indexOf(this.subscriber);
+        if (subscriberIndex !== -1) {
+            observers.splice(subscriberIndex, 1);
+        }
+    }
+}
+
+class SubjectSubscriber extends delay.Subscriber {
+    constructor(destination) {
+        super(destination);
+        this.destination = destination;
+    }
+}
+class Subject extends delay.Observable {
+    constructor() {
+        super();
+        this.observers = [];
+        this.closed = false;
+        this.isStopped = false;
+        this.hasError = false;
+        this.thrownError = null;
+    }
+    [delay.rxSubscriber]() {
+        return new SubjectSubscriber(this);
+    }
+    lift(operator) {
+        const subject = new AnonymousSubject(this, this);
+        subject.operator = operator;
+        return subject;
+    }
+    next(value) {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        if (!this.isStopped) {
+            const { observers } = this;
+            const len = observers.length;
+            const copy = observers.slice();
+            for (let i = 0; i < len; i++) {
+                copy[i].next(value);
+            }
+        }
+    }
+    error(err) {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        this.hasError = true;
+        this.thrownError = err;
+        this.isStopped = true;
+        const { observers } = this;
+        const len = observers.length;
+        const copy = observers.slice();
+        for (let i = 0; i < len; i++) {
+            copy[i].error(err);
+        }
+        this.observers.length = 0;
+    }
+    complete() {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        this.isStopped = true;
+        const { observers } = this;
+        const len = observers.length;
+        const copy = observers.slice();
+        for (let i = 0; i < len; i++) {
+            copy[i].complete();
+        }
+        this.observers.length = 0;
+    }
+    unsubscribe() {
+        this.isStopped = true;
+        this.closed = true;
+        this.observers = null;
+    }
+    _trySubscribe(subscriber) {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        else {
+            return super._trySubscribe(subscriber);
+        }
+    }
+    _subscribe(subscriber) {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        else if (this.hasError) {
+            subscriber.error(this.thrownError);
+            return delay.Subscription.EMPTY;
+        }
+        else if (this.isStopped) {
+            subscriber.complete();
+            return delay.Subscription.EMPTY;
+        }
+        else {
+            this.observers.push(subscriber);
+            return new SubjectSubscription(this, subscriber);
+        }
+    }
+    asObservable() {
+        const observable = new delay.Observable();
+        observable.source = this;
+        return observable;
+    }
+}
+Subject.create = (destination, source) => {
+    return new AnonymousSubject(destination, source);
+};
+class AnonymousSubject extends Subject {
+    constructor(destination, source) {
+        super();
+        this.destination = destination;
+        this.source = source;
+    }
+    next(value) {
+        const { destination } = this;
+        if (destination && destination.next) {
+            destination.next(value);
+        }
+    }
+    error(err) {
+        const { destination } = this;
+        if (destination && destination.error) {
+            this.destination.error(err);
+        }
+    }
+    complete() {
+        const { destination } = this;
+        if (destination && destination.complete) {
+            this.destination.complete();
+        }
+    }
+    _subscribe(subscriber) {
+        const { source } = this;
+        if (source) {
+            return this.source.subscribe(subscriber);
+        }
+        else {
+            return delay.Subscription.EMPTY;
+        }
+    }
+}
+
+class BehaviorSubject extends Subject {
+    constructor(_value) {
+        super();
+        this._value = _value;
+    }
+    get value() {
+        return this.getValue();
+    }
+    _subscribe(subscriber) {
+        const subscription = super._subscribe(subscriber);
+        if (subscription && !subscription.closed) {
+            subscriber.next(this._value);
+        }
+        return subscription;
+    }
+    getValue() {
+        if (this.hasError) {
+            throw this.thrownError;
+        }
+        else if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        else {
+            return this._value;
+        }
+    }
+    next(value) {
+        super.next(this._value = value);
+    }
+}
+
+class QueueAction extends delay.AsyncAction {
+    constructor(scheduler, work) {
+        super(scheduler, work);
+        this.scheduler = scheduler;
+        this.work = work;
+    }
+    schedule(state, delay = 0) {
+        if (delay > 0) {
+            return super.schedule(state, delay);
+        }
+        this.delay = delay;
+        this.state = state;
+        this.scheduler.flush(this);
+        return this;
+    }
+    execute(state, delay) {
+        return (delay > 0 || this.closed) ?
+            super.execute(state, delay) :
+            this._execute(state, delay);
+    }
+    requestAsyncId(scheduler, id, delay = 0) {
+        if ((delay !== null && delay > 0) || (delay === null && this.delay > 0)) {
+            return super.requestAsyncId(scheduler, id, delay);
+        }
+        return scheduler.flush(this);
+    }
+}
+
+class QueueScheduler extends delay.AsyncScheduler {
+}
+
+const queueScheduler = new QueueScheduler(QueueAction);
+const queue = queueScheduler;
+
+class ObserveOnSubscriber extends delay.Subscriber {
+    constructor(destination, scheduler, delay = 0) {
+        super(destination);
+        this.scheduler = scheduler;
+        this.delay = delay;
+    }
+    static dispatch(arg) {
+        const { notification, destination } = arg;
+        notification.observe(destination);
+        this.unsubscribe();
+    }
+    scheduleMessage(notification) {
+        const destination = this.destination;
+        destination.add(this.scheduler.schedule(ObserveOnSubscriber.dispatch, this.delay, new ObserveOnMessage(notification, this.destination)));
+    }
+    _next(value) {
+        this.scheduleMessage(delay.Notification.createNext(value));
+    }
+    _error(err) {
+        this.scheduleMessage(delay.Notification.createError(err));
+        this.unsubscribe();
+    }
+    _complete() {
+        this.scheduleMessage(delay.Notification.createComplete());
+        this.unsubscribe();
+    }
+}
+class ObserveOnMessage {
+    constructor(notification, destination) {
+        this.notification = notification;
+        this.destination = destination;
+    }
+}
+
+class ReplaySubject extends Subject {
+    constructor(bufferSize = Number.POSITIVE_INFINITY, windowTime = Number.POSITIVE_INFINITY, scheduler) {
+        super();
+        this.scheduler = scheduler;
+        this._events = [];
+        this._infiniteTimeWindow = false;
+        this._bufferSize = bufferSize < 1 ? 1 : bufferSize;
+        this._windowTime = windowTime < 1 ? 1 : windowTime;
+        if (windowTime === Number.POSITIVE_INFINITY) {
+            this._infiniteTimeWindow = true;
+            this.next = this.nextInfiniteTimeWindow;
+        }
+        else {
+            this.next = this.nextTimeWindow;
+        }
+    }
+    nextInfiniteTimeWindow(value) {
+        if (!this.isStopped) {
+            const _events = this._events;
+            _events.push(value);
+            if (_events.length > this._bufferSize) {
+                _events.shift();
+            }
+        }
+        super.next(value);
+    }
+    nextTimeWindow(value) {
+        if (!this.isStopped) {
+            this._events.push(new ReplayEvent(this._getNow(), value));
+            this._trimBufferThenGetEvents();
+        }
+        super.next(value);
+    }
+    _subscribe(subscriber) {
+        const _infiniteTimeWindow = this._infiniteTimeWindow;
+        const _events = _infiniteTimeWindow ? this._events : this._trimBufferThenGetEvents();
+        const scheduler = this.scheduler;
+        const len = _events.length;
+        let subscription;
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+        else if (this.isStopped || this.hasError) {
+            subscription = delay.Subscription.EMPTY;
+        }
+        else {
+            this.observers.push(subscriber);
+            subscription = new SubjectSubscription(this, subscriber);
+        }
+        if (scheduler) {
+            subscriber.add(subscriber = new ObserveOnSubscriber(subscriber, scheduler));
+        }
+        if (_infiniteTimeWindow) {
+            for (let i = 0; i < len && !subscriber.closed; i++) {
+                subscriber.next(_events[i]);
+            }
+        }
+        else {
+            for (let i = 0; i < len && !subscriber.closed; i++) {
+                subscriber.next(_events[i].value);
+            }
+        }
+        if (this.hasError) {
+            subscriber.error(this.thrownError);
+        }
+        else if (this.isStopped) {
+            subscriber.complete();
+        }
+        return subscription;
+    }
+    _getNow() {
+        return (this.scheduler || queue).now();
+    }
+    _trimBufferThenGetEvents() {
+        const now = this._getNow();
+        const _bufferSize = this._bufferSize;
+        const _windowTime = this._windowTime;
+        const _events = this._events;
+        const eventsCount = _events.length;
+        let spliceCount = 0;
+        while (spliceCount < eventsCount) {
+            if ((now - _events[spliceCount].time) < _windowTime) {
+                break;
+            }
+            spliceCount++;
+        }
+        if (eventsCount > _bufferSize) {
+            spliceCount = Math.max(spliceCount, eventsCount - _bufferSize);
+        }
+        if (spliceCount > 0) {
+            _events.splice(0, spliceCount);
+        }
+        return _events;
+    }
+}
+class ReplayEvent {
+    constructor(time, value) {
+        this.time = time;
+        this.value = value;
+    }
+}
+
+function isObservable(obj) {
+    return !!obj && (obj instanceof delay.Observable || (typeof obj.lift === 'function' && typeof obj.subscribe === 'function'));
+}
+
+const ArgumentOutOfRangeErrorImpl = (() => {
+    function ArgumentOutOfRangeErrorImpl() {
+        Error.call(this);
+        this.message = 'argument out of range';
+        this.name = 'ArgumentOutOfRangeError';
+        return this;
+    }
+    ArgumentOutOfRangeErrorImpl.prototype = Object.create(Error.prototype);
+    return ArgumentOutOfRangeErrorImpl;
+})();
+const ArgumentOutOfRangeError = ArgumentOutOfRangeErrorImpl;
+
+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 delay.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);
+    }
+}
+
+const subscribeToPromise = (promise) => (subscriber) => {
+    promise.then((value) => {
+        if (!subscriber.closed) {
+            subscriber.next(value);
+            subscriber.complete();
+        }
+    }, (err) => subscriber.error(err))
+        .then(null, delay.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[delay.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[delay.observable] === 'function') {
+        return subscribeToObservable(result);
+    }
+    else if (isArrayLike(result)) {
+        return delay.subscribeToArray(result);
+    }
+    else if (isPromise(result)) {
+        return subscribeToPromise(result);
+    }
+    else if (!!result && typeof result[iterator] === 'function') {
+        return subscribeToIterable(result);
+    }
+    else {
+        const value = delay.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);
+    }
+};
+
+function scheduleObservable(input, scheduler) {
+    return new delay.Observable(subscriber => {
+        const sub = new delay.Subscription();
+        sub.add(scheduler.schedule(() => {
+            const observable = input[delay.observable]();
+            sub.add(observable.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 delay.Observable(subscriber => {
+        const sub = new delay.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 delay.Observable(subscriber => {
+        const sub = new delay.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[delay.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 delay.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 delay.Observable) {
+            return input;
+        }
+        return new delay.Observable(subscribeTo(input));
+    }
+    else {
+        return scheduled(input, scheduler);
+    }
+}
+
+class SimpleInnerSubscriber extends delay.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 delay.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 delay.Observable) {
+        return result.subscribe(innerSubscriber);
+    }
+    return subscribeTo(result)(innerSubscriber);
+}
+
+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 delay.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);
+        }
+    }
+}
+
+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 delay.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 take(count) {
+    return (source) => {
+        if (count === 0) {
+            return delay.empty();
+        }
+        else {
+            return source.lift(new TakeOperator(count));
+        }
+    };
+}
+class TakeOperator {
+    constructor(total) {
+        this.total = total;
+        if (this.total < 0) {
+            throw new ArgumentOutOfRangeError;
+        }
+    }
+    call(subscriber, source) {
+        return source.subscribe(new TakeSubscriber(subscriber, this.total));
+    }
+}
+class TakeSubscriber extends delay.Subscriber {
+    constructor(destination, total) {
+        super(destination);
+        this.total = total;
+        this.count = 0;
+    }
+    _next(value) {
+        const total = this.total;
+        const count = ++this.count;
+        if (count <= total) {
+            this.destination.next(value);
+            if (count === total) {
+                this.destination.complete();
+                this.unsubscribe();
+            }
+        }
+    }
+}
+
+function switchMap(project, resultSelector) {
+    if (typeof resultSelector === 'function') {
+        return (source) => source.pipe(switchMap((a, i) => from(project(a, i)).pipe(map((b, ii) => resultSelector(a, b, i, ii)))));
+    }
+    return (source) => source.lift(new SwitchMapOperator(project));
+}
+class SwitchMapOperator {
+    constructor(project) {
+        this.project = project;
+    }
+    call(subscriber, source) {
+        return source.subscribe(new SwitchMapSubscriber(subscriber, this.project));
+    }
+}
+class SwitchMapSubscriber extends SimpleOuterSubscriber {
+    constructor(destination, project) {
+        super(destination);
+        this.project = project;
+        this.index = 0;
+    }
+    _next(value) {
+        let result;
+        const index = this.index++;
+        try {
+            result = this.project(value, index);
+        }
+        catch (error) {
+            this.destination.error(error);
+            return;
+        }
+        this._innerSub(result);
+    }
+    _innerSub(result) {
+        const innerSubscription = this.innerSubscription;
+        if (innerSubscription) {
+            innerSubscription.unsubscribe();
+        }
+        const innerSubscriber = new SimpleInnerSubscriber(this);
+        const destination = this.destination;
+        destination.add(innerSubscriber);
+        this.innerSubscription = innerSubscribe(result, innerSubscriber);
+        if (this.innerSubscription !== innerSubscriber) {
+            destination.add(this.innerSubscription);
+        }
+    }
+    _complete() {
+        const { innerSubscription } = this;
+        if (!innerSubscription || innerSubscription.closed) {
+            super._complete();
+        }
+        this.unsubscribe();
+    }
+    _unsubscribe() {
+        this.innerSubscription = undefined;
+    }
+    notifyComplete() {
+        this.innerSubscription = undefined;
+        if (this.isStopped) {
+            super._complete();
+        }
+    }
+    notifyNext(innerValue) {
+        this.destination.next(innerValue);
+    }
+}
+
+const currentAction = {
+    type: null,
+    entityIds: null,
+    skip: false,
+};
+let customActionActive = false;
+function resetCustomAction() {
+    customActionActive = false;
+}
+// public API for custom actions. Custom action always wins
+function logAction(type, entityIds) {
+    setAction(type, entityIds);
+    customActionActive = true;
+}
+function setAction(type, entityIds) {
+    if (customActionActive === false) {
+        currentAction.type = type;
+        currentAction.entityIds = entityIds;
+    }
+}
+function action(action, entityIds) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            logAction(action, entityIds);
+            return originalMethod.apply(this, args);
+        };
+        return descriptor;
+    };
+}
+
+// @internal
+function hasEntity(entities, id) {
+    return entities.hasOwnProperty(id);
+}
+
+// @internal
+function addEntities({ state, entities, idKey, options = {}, preAddEntity }) {
+    let newEntities = {};
+    let newIds = [];
+    let hasNewEntities = false;
+    for (const entity of entities) {
+        if (hasEntity(state.entities, entity[idKey]) === false) {
+            // evaluate the middleware first to support dynamic ids
+            const current = preAddEntity(entity);
+            const entityId = current[idKey];
+            newEntities[entityId] = current;
+            if (options.prepend)
+                newIds.unshift(entityId);
+            else
+                newIds.push(entityId);
+            hasNewEntities = true;
+        }
+    }
+    return hasNewEntities
+        ? {
+            newState: Object.assign({}, state, { entities: Object.assign({}, state.entities, newEntities), ids: options.prepend ? [...newIds, ...state.ids] : [...state.ids, ...newIds] }),
+            newIds
+        }
+        : null;
+}
+
+// @internal
+function isNil(v) {
+    return v === null || v === undefined;
+}
+
+// @internal
+function coerceArray(value) {
+    if (isNil(value)) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+}
+
+const DEFAULT_ID_KEY = 'id';
+
+var EntityActions;
+(function (EntityActions) {
+    EntityActions["Set"] = "Set";
+    EntityActions["Add"] = "Add";
+    EntityActions["Update"] = "Update";
+    EntityActions["Remove"] = "Remove";
+})(EntityActions || (EntityActions = {}));
+
+const isBrowser = typeof window !== 'undefined';
+
+let __DEV__ = true;
+function enableAkitaProdMode() {
+    __DEV__ = false;
+    if (isBrowser) {
+        delete window.$$stores;
+        delete window.$$queries;
+    }
+}
+// @internal
+function isDev() {
+    return __DEV__;
+}
+
+// @internal
+function isObject(value) {
+    const type = typeof value;
+    return value != null && (type == 'object' || type == 'function');
+}
+
+// @internal
+function isArray(value) {
+    return Array.isArray(value);
+}
+
+// @internal
+function getActiveEntities(idOrOptions, ids, currentActive) {
+    let result;
+    if (isArray(idOrOptions)) {
+        result = idOrOptions;
+    }
+    else {
+        if (isObject(idOrOptions)) {
+            if (isNil(currentActive))
+                return;
+            idOrOptions = Object.assign({ wrap: true }, idOrOptions);
+            const currentIdIndex = ids.indexOf(currentActive);
+            if (idOrOptions.prev) {
+                const isFirst = currentIdIndex === 0;
+                if (isFirst && !idOrOptions.wrap)
+                    return;
+                result = isFirst ? ids[ids.length - 1] : ids[currentIdIndex - 1];
+            }
+            else if (idOrOptions.next) {
+                const isLast = ids.length === currentIdIndex + 1;
+                if (isLast && !idOrOptions.wrap)
+                    return;
+                result = isLast ? ids[0] : ids[currentIdIndex + 1];
+            }
+        }
+        else {
+            if (idOrOptions === currentActive)
+                return;
+            result = idOrOptions;
+        }
+    }
+    return result;
+}
+
+// @internal
+const getInitialEntitiesState = () => ({
+    entities: {},
+    ids: [],
+    loading: true,
+    error: null
+});
+
+// @internal
+function isDefined(val) {
+    return isNil(val) === false;
+}
+
+// @internal
+function isEmpty(arr) {
+    if (isArray(arr)) {
+        return arr.length === 0;
+    }
+    return false;
+}
+
+// @internal
+function isFunction(value) {
+    return typeof value === 'function';
+}
+
+// @internal
+function isUndefined(value) {
+    return value === undefined;
+}
+
+// @internal
+function hasActiveState(state) {
+    return state.hasOwnProperty('active');
+}
+// @internal
+function isMultiActiveState(active) {
+    return isArray(active);
+}
+// @internal
+function resolveActiveEntity({ active, ids, entities }) {
+    if (isMultiActiveState(active)) {
+        return getExitingActives(active, ids);
+    }
+    if (hasEntity(entities, active) === false) {
+        return null;
+    }
+    return active;
+}
+// @internal
+function getExitingActives(currentActivesIds, newIds) {
+    const filtered = currentActivesIds.filter(id => newIds.indexOf(id) > -1);
+    /** Return the same reference if nothing has changed */
+    if (filtered.length === currentActivesIds.length) {
+        return currentActivesIds;
+    }
+    return filtered;
+}
+
+// @internal
+function removeEntities({ state, ids }) {
+    if (isNil(ids))
+        return removeAllEntities(state);
+    const entities = state.entities;
+    let newEntities = {};
+    for (const id of state.ids) {
+        if (ids.includes(id) === false) {
+            newEntities[id] = entities[id];
+        }
+    }
+    const newState = Object.assign({}, state, { entities: newEntities, ids: state.ids.filter(current => ids.includes(current) === false) });
+    if (hasActiveState(state)) {
+        newState.active = resolveActiveEntity(newState);
+    }
+    return newState;
+}
+// @internal
+function removeAllEntities(state) {
+    return Object.assign({}, state, { entities: {}, ids: [], active: isMultiActiveState(state.active) ? [] : null });
+}
+
+// @internal
+function toEntitiesObject(entities, idKey, preAddEntity) {
+    const acc = {
+        entities: {},
+        ids: []
+    };
+    for (const entity of entities) {
+        // evaluate the middleware first to support dynamic ids
+        const current = preAddEntity(entity);
+        acc.entities[current[idKey]] = current;
+        acc.ids.push(current[idKey]);
+    }
+    return acc;
+}
+
+// @internal
+function isEntityState(state) {
+    return state.entities && state.ids;
+}
+// @internal
+function applyMiddleware(entities, preAddEntity) {
+    let mapped = {};
+    for (const id of Object.keys(entities)) {
+        mapped[id] = preAddEntity(entities[id]);
+    }
+    return mapped;
+}
+// @internal
+function setEntities({ state, entities, idKey, preAddEntity, isNativePreAdd }) {
+    let newEntities;
+    let newIds;
+    if (isArray(entities)) {
+        const resolve = toEntitiesObject(entities, idKey, preAddEntity);
+        newEntities = resolve.entities;
+        newIds = resolve.ids;
+    }
+    else if (isEntityState(entities)) {
+        newEntities = isNativePreAdd ? entities.entities : applyMiddleware(entities.entities, preAddEntity);
+        newIds = entities.ids;
+    }
+    else {
+        // it's an object
+        newEntities = isNativePreAdd ? entities : applyMiddleware(entities, preAddEntity);
+        newIds = Object.keys(newEntities).map(id => (isNaN(id) ? id : Number(id)));
+    }
+    const newState = Object.assign({}, state, { entities: newEntities, ids: newIds, loading: false });
+    if (hasActiveState(state)) {
+        newState.active = resolveActiveEntity(newState);
+    }
+    return newState;
+}
+
+let CONFIG = {
+    resettable: false,
+    ttl: null,
+    producerFn: undefined
+};
+// @internal
+function getAkitaConfig() {
+    return CONFIG;
+}
+function getGlobalProducerFn() {
+    return CONFIG.producerFn;
+}
+
+// @internal
+function deepFreeze(o) {
+    Object.freeze(o);
+    const oIsFunction = typeof o === 'function';
+    const hasOwnProp = Object.prototype.hasOwnProperty;
+    Object.getOwnPropertyNames(o).forEach(function (prop) {
+        if (hasOwnProp.call(o, prop) &&
+            (oIsFunction ? prop !== 'caller' && prop !== 'callee' && prop !== 'arguments' : true) &&
+            o[prop] !== null &&
+            (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&
+            !Object.isFrozen(o[prop])) {
+            deepFreeze(o[prop]);
+        }
+    });
+    return o;
+}
+
+// @internal
+const $$deleteStore = new Subject();
+// @internal
+const $$addStore = new ReplaySubject(50, 5000);
+// @internal
+const $$updateStore = new Subject();
+// @internal
+function dispatchDeleted(storeName) {
+    $$deleteStore.next(storeName);
+}
+// @internal
+function dispatchAdded(storeName) {
+    $$addStore.next(storeName);
+}
+// @internal
+function dispatchUpdate(storeName, action) {
+    $$updateStore.next({ storeName, action });
+}
+// @internal
+function assertStoreHasName(name, className) {
+    if (!name) {
+        console.error(`@StoreConfig({ name }) is missing in ${className}`);
+    }
+}
+
+// @internal
+function toBoolean(value) {
+    return value != null && `${value}` !== 'false';
+}
+
+// @internal
+function isPlainObject(value) {
+    return toBoolean(value) && value.constructor.name === 'Object';
+}
+
+const configKey = 'akitaConfig';
+function StoreConfig(metadata) {
+    return function (constructor) {
+        constructor[configKey] = { idKey: 'id' };
+        for (let i = 0, keys = Object.keys(metadata); i < keys.length; i++) {
+            const key = keys[i];
+            /* name is preserved read only key */
+            if (key === 'name') {
+                constructor[configKey]['storeName'] = metadata[key];
+            }
+            else {
+                constructor[configKey][key] = metadata[key];
+            }
+        }
+    };
+}
+
+// @internal
+const __stores__ = {};
+// @internal
+const __queries__ = {};
+if (isBrowser) {
+    window.$$stores = __stores__;
+    window.$$queries = __queries__;
+}
+
+// @internal
+const transactionFinished = new Subject();
+// @internal
+const transactionInProcess = new BehaviorSubject(false);
+// @internal
+const transactionManager = {
+    activeTransactions: 0,
+    batchTransaction: null
+};
+// @internal
+function startBatch() {
+    if (!isTransactionInProcess()) {
+        transactionManager.batchTransaction = new Subject();
+    }
+    transactionManager.activeTransactions++;
+    transactionInProcess.next(true);
+}
+// @internal
+function endBatch() {
+    if (--transactionManager.activeTransactions === 0) {
+        transactionManager.batchTransaction.next(true);
+        transactionManager.batchTransaction.complete();
+        transactionInProcess.next(false);
+        transactionFinished.next(true);
+    }
+}
+// @internal
+function isTransactionInProcess() {
+    return transactionManager.activeTransactions > 0;
+}
+// @internal
+function commit() {
+    return transactionManager.batchTransaction ? transactionManager.batchTransaction.asObservable() : delay.of(true);
+}
+/**
+ *  A logical transaction.
+ *  Use this transaction to optimize the dispatch of all the stores.
+ *  The following code will update the store, BUT  emits only once
+ *
+ *  @example
+ *  applyTransaction(() => {
+ *    this.todosStore.add(new Todo(1, title));
+ *    this.todosStore.add(new Todo(2, title));
+ *  });
+ *
+ */
+function applyTransaction(action, thisArg = undefined) {
+    startBatch();
+    try {
+        return action.apply(thisArg);
+    }
+    finally {
+        logAction('@Transaction');
+        endBatch();
+    }
+}
+/**
+ *  A logical transaction.
+ *  Use this transaction to optimize the dispatch of all the stores.
+ *
+ *  The following code will update the store, BUT  emits only once.
+ *
+ *  @example
+ *  @transaction
+ *  addTodos() {
+ *    this.todosStore.add(new Todo(1, title));
+ *    this.todosStore.add(new Todo(2, title));
+ *  }
+ *
+ *
+ */
+function transaction() {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            return applyTransaction(() => {
+                return originalMethod.apply(this, args);
+            }, this);
+        };
+        return descriptor;
+    };
+}
+
+/**
+ *
+ * Store for managing any type of data
+ *
+ * @example
+ *
+ * export interface SessionState {
+ *   token: string;
+ *   userDetails: UserDetails
+ * }
+ *
+ * export function createInitialState(): SessionState {
+ *  return {
+ *    token: '',
+ *    userDetails: null
+ *  };
+ * }
+ *
+ * @StoreConfig({ name: 'session' })
+ * export class SessionStore extends Store<SessionState> {
+ *   constructor() {
+ *    super(createInitialState());
+ *   }
+ * }
+ */
+class Store {
+    constructor(initialState, options = {}) {
+        this.options = options;
+        this.inTransaction = false;
+        this.cache = {
+            active: new BehaviorSubject(false),
+            ttl: null,
+        };
+        this.onInit(initialState);
+    }
+    /**
+     *  Set the loading state
+     *
+     *  @example
+     *
+     *  store.setLoading(true)
+     *
+     */
+    setLoading(loading = false) {
+        if (loading !== this._value().loading) {
+            isDev() && setAction('Set Loading');
+            this._setState((state) => (Object.assign({}, state, { loading })));
+        }
+    }
+    /**
+     *
+     * Set whether the data is cached
+     *
+     * @example
+     *
+     * store.setHasCache(true)
+     * store.setHasCache(false)
+     * store.setHasCache(true, { restartTTL: true })
+     *
+     */
+    setHasCache(hasCache, options = { restartTTL: false }) {
+        if (hasCache !== this.cache.active.value) {
+            this.cache.active.next(hasCache);
+        }
+        if (options.restartTTL) {
+            const ttlConfig = this.getCacheTTL();
+            if (ttlConfig) {
+                if (this.cache.ttl !== null) {
+                    clearTimeout(this.cache.ttl);
+                }
+                this.cache.ttl = setTimeout(() => this.setHasCache(false), ttlConfig);
+            }
+        }
+    }
+    /**
+     *
+     * Sometimes we need to access the store value from a store
+     *
+     * @example middleware
+     *
+     */
+    getValue() {
+        return this.storeValue;
+    }
+    /**
+     *  Set the error state
+     *
+     *  @example
+     *
+     *  store.setError({text: 'unable to load data' })
+     *
+     */
+    setError(error) {
+        if (error !== this._value().error) {
+            isDev() && setAction('Set Error');
+            this._setState((state) => (Object.assign({}, state, { error })));
+        }
+    }
+    // @internal
+    _select(project) {
+        return this.store.asObservable().pipe(map((snapshot) => project(snapshot.state)), distinctUntilChanged());
+    }
+    // @internal
+    _value() {
+        return this.storeValue;
+    }
+    // @internal
+    _cache() {
+        return this.cache.active;
+    }
+    // @internal
+    get config() {
+        return this.constructor[configKey] || {};
+    }
+    // @internal
+    get storeName() {
+        return this.config.storeName || this.options.storeName || this.options.name;
+    }
+    // @internal
+    get deepFreeze() {
+        return this.config.deepFreezeFn || this.options.deepFreezeFn || deepFreeze;
+    }
+    // @internal
+    get cacheConfig() {
+        return this.config.cache || this.options.cache;
+    }
+    get _producerFn() {
+        return this.config.producerFn || this.options.producerFn || getGlobalProducerFn();
+    }
+    // @internal
+    get resettable() {
+        return isDefined(this.config.resettable) ? this.config.resettable : this.options.resettable;
+    }
+    // @internal
+    _setState(newState, _dispatchAction = true) {
+        if (isFunction(newState)) {
+            const _newState = newState(this._value());
+            this.storeValue = __DEV__ ? this.deepFreeze(_newState) : _newState;
+        }
+        else {
+            this.storeValue = newState;
+        }
+        if (!this.store) {
+            this.store = new BehaviorSubject({ state: this.storeValue });
+            if (isDev()) {
+                this.store.subscribe(({ action }) => {
+                    if (action) {
+                        dispatchUpdate(this.storeName, action);
+                    }
+                });
+            }
+            return;
+        }
+        if (isTransactionInProcess()) {
+            this.handleTransaction();
+            return;
+        }
+        this.dispatch(this.storeValue, _dispatchAction);
+    }
+    /**
+     *
+     * Reset the current store back to the initial value
+     *
+     * @example
+     *
+     * store.reset()
+     *
+     */
+    reset() {
+        if (this.isResettable()) {
+            isDev() && setAction('Reset');
+            this._setState(() => Object.assign({}, this._initialState));
+            this.setHasCache(false);
+        }
+        else {
+            isDev() && console.warn(`You need to enable the reset functionality`);
+        }
+    }
+    update(stateOrCallback) {
+        isDev() && setAction('Update');
+        let newState;
+        const currentState = this._value();
+        if (isFunction(stateOrCallback)) {
+            newState = isFunction(this._producerFn) ? this._producerFn(currentState, stateOrCallback) : stateOrCallback(currentState);
+        }
+        else {
+            newState = stateOrCallback;
+        }
+        const withHook = this.akitaPreUpdate(currentState, Object.assign({}, currentState, newState));
+        const resolved = isPlainObject(currentState) ? withHook : new currentState.constructor(withHook);
+        this._setState(resolved);
+    }
+    updateStoreConfig(newOptions) {
+        this.options = Object.assign({}, this.options, newOptions);
+    }
+    // @internal
+    akitaPreUpdate(_, nextState) {
+        return nextState;
+    }
+    ngOnDestroy() {
+        this.destroy();
+    }
+    /**
+     *
+     * Destroy the store
+     *
+     * @example
+     *
+     * store.destroy()
+     *
+     */
+    destroy() {
+        const hmrEnabled = isBrowser ? window.hmrEnabled : false;
+        if (!hmrEnabled && this === __stores__[this.storeName]) {
+            delete __stores__[this.storeName];
+            dispatchDeleted(this.storeName);
+            this.setHasCache(false);
+            this.cache.active.complete();
+            this.store.complete();
+        }
+    }
+    onInit(initialState) {
+        __stores__[this.storeName] = this;
+        this._setState(() => initialState);
+        dispatchAdded(this.storeName);
+        if (this.isResettable()) {
+            this._initialState = initialState;
+        }
+        isDev() && assertStoreHasName(this.storeName, this.constructor.name);
+    }
+    dispatch(state, _dispatchAction = true) {
+        let action = undefined;
+        if (_dispatchAction) {
+            action = currentAction;
+            resetCustomAction();
+        }
+        this.store.next({ state, action });
+    }
+    watchTransaction() {
+        commit().subscribe(() => {
+            this.inTransaction = false;
+            this.dispatch(this._value());
+        });
+    }
+    isResettable() {
+        if (this.resettable === false) {
+            return false;
+        }
+        return this.resettable || getAkitaConfig().resettable;
+    }
+    handleTransaction() {
+        if (!this.inTransaction) {
+            this.watchTransaction();
+            this.inTransaction = true;
+        }
+    }
+    getCacheTTL() {
+        return (this.cacheConfig && this.cacheConfig.ttl) || getAkitaConfig().ttl;
+    }
+}
+
+// @internal
+function updateEntities({ state, ids, idKey, newStateOrFn, preUpdateEntity, producerFn, onEntityIdChanges }) {
+    const updatedEntities = {};
+    let isUpdatingIdKey = false;
+    let idToUpdate;
+    for (const id of ids) {
+        // if the entity doesn't exist don't do anything
+        if (hasEntity(state.entities, id) === false) {
+            continue;
+        }
+        const oldEntity = state.entities[id];
+        let newState;
+        if (isFunction(newStateOrFn)) {
+            newState = isFunction(producerFn) ? producerFn(oldEntity, newStateOrFn) : newStateOrFn(oldEntity);
+        }
+        else {
+            newState = newStateOrFn;
+        }
+        const isIdChanged = newState.hasOwnProperty(idKey) && newState[idKey] !== oldEntity[idKey];
+        let newEntity;
+        idToUpdate = id;
+        if (isIdChanged) {
+            isUpdatingIdKey = true;
+            idToUpdate = newState[idKey];
+        }
+        const merged = Object.assign({}, oldEntity, newState);
+        if (isPlainObject(oldEntity)) {
+            newEntity = merged;
+        }
+        else {
+            /**
+             * In case that new state is class of it's own, there's
+             * a possibility that it will be different than the old
+             * class.
+             * For example, Old state is an instance of animal class
+             * and new state is instance of person class.
+             * To avoid run over new person class with the old animal
+             * class we check if the new state is a class of it's own.
+             * If so, use it. Otherwise, use the old state class
+             */
+            if (isPlainObject(newState)) {
+                newEntity = new oldEntity.constructor(merged);
+            }
+            else {
+                newEntity = new newState.constructor(merged);
+            }
+        }
+        updatedEntities[idToUpdate] = preUpdateEntity(oldEntity, newEntity);
+    }
+    let updatedIds = state.ids;
+    let stateEntities = state.entities;
+    if (isUpdatingIdKey) {
+        const [id] = ids;
+        const _a = state.entities, _b = id, rest = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+        stateEntities = rest;
+        updatedIds = state.ids.map((current) => (current === id ? idToUpdate : current));
+        onEntityIdChanges(id, idToUpdate);
+    }
+    return Object.assign({}, state, { entities: Object.assign({}, stateEntities, updatedEntities), ids: updatedIds });
+}
+
+var _b;
+/**
+ *
+ * Store for managing a collection of entities
+ *
+ * @example
+ *
+ * export interface WidgetsState extends EntityState<Widget> { }
+ *
+ * @StoreConfig({ name: 'widgets' })
+ *  export class WidgetsStore extends EntityStore<WidgetsState> {
+ *   constructor() {
+ *     super();
+ *   }
+ * }
+ *
+ *
+ */
+class EntityStore extends Store {
+    constructor(initialState = {}, options = {}) {
+        super(Object.assign({}, getInitialEntitiesState(), initialState), options);
+        this.options = options;
+        this.entityActions = new Subject();
+        this.entityIdChanges = new Subject();
+    }
+    // @internal
+    get selectEntityAction$() {
+        return this.entityActions.asObservable();
+    }
+    // @internal
+    get selectEntityIdChanges$() {
+        return this.entityIdChanges.asObservable();
+    }
+    // @internal
+    get idKey() {
+        return this.config.idKey || this.options.idKey || DEFAULT_ID_KEY;
+    }
+    /**
+     *
+     * Replace current collection with provided collection
+     *
+     * @example
+     *
+     * this.store.set([Entity, Entity])
+     * this.store.set({ids: [], entities: {}})
+     * this.store.set({ 1: {}, 2: {}})
+     *
+     */
+    set(entities, options = {}) {
+        if (isNil(entities))
+            return;
+        isDev() && setAction('Set Entity');
+        const isNativePreAdd = this.akitaPreAddEntity === EntityStore.prototype.akitaPreAddEntity;
+        this.setHasCache(true, { restartTTL: true });
+        this._setState((state) => {
+            const newState = setEntities({
+                state,
+                entities,
+                idKey: this.idKey,
+                preAddEntity: this.akitaPreAddEntity,
+                isNativePreAdd,
+            });
+            if (isUndefined(options.activeId) === false) {
+                newState.active = options.activeId;
+            }
+            return newState;
+        });
+        if (this.hasInitialUIState()) {
+            this.handleUICreation();
+        }
+        this.entityActions.next({ type: EntityActions.Set, ids: this.ids });
+    }
+    /**
+     * Add entities
+     *
+     * @example
+     *
+     * this.store.add([Entity, Entity])
+     * this.store.add(Entity)
+     * this.store.add(Entity, { prepend: true })
+     *
+     * this.store.add(Entity, { loading: false })
+     */
+    add(entities, options = { loading: false }) {
+        const collection = coerceArray(entities);
+        if (isEmpty(collection))
+            return;
+        const data = addEntities({
+            state: this._value(),
+            preAddEntity: this.akitaPreAddEntity,
+            entities: collection,
+            idKey: this.idKey,
+            options,
+        });
+        if (data) {
+            isDev() && setAction('Add Entity');
+            data.newState.loading = options.loading;
+            this._setState(() => data.newState);
+            if (this.hasInitialUIState()) {
+                this.handleUICreation(true);
+            }
+            this.entityActions.next({ type: EntityActions.Add, ids: data.newIds });
+        }
+    }
+    update(idsOrFnOrState, newStateOrFn) {
+        if (isUndefined(newStateOrFn)) {
+            super.update(idsOrFnOrState);
+            return;
+        }
+        let ids = [];
+        if (isFunction(idsOrFnOrState)) {
+            // We need to filter according the predicate function
+            ids = this.ids.filter((id) => idsOrFnOrState(this.entities[id]));
+        }
+        else {
+            // If it's nil we want all of them
+            ids = isNil(idsOrFnOrState) ? this.ids : coerceArray(idsOrFnOrState);
+        }
+        if (isEmpty(ids))
+            return;
+        isDev() && setAction('Update Entity', ids);
+        let entityIdChanged;
+        this._setState((state) => updateEntities({
+            idKey: this.idKey,
+            ids,
+            preUpdateEntity: this.akitaPreUpdateEntity,
+            state,
+            newStateOrFn,
+            producerFn: this._producerFn,
+            onEntityIdChanges: (oldId, newId) => {
+                entityIdChanged = { oldId, newId };
+                this.entityIdChanges.next(Object.assign({}, entityIdChanged, { pending: true }));
+            },
+        }));
+        if (entityIdChanged) {
+            this.entityIdChanges.next(Object.assign({}, entityIdChanged, { pending: false }));
+        }
+        this.entityActions.next({ type: EntityActions.Update, ids });
+    }
+    upsert(ids, newState, onCreate, options = {}) {
+        const toArray = coerceArray(ids);
+        const predicate = (isUpdate) => (id) => hasEntity(this.entities, id) === isUpdate;
+        const baseClass = isFunction(onCreate) ? options.baseClass : onCreate ? onCreate.baseClass : undefined;
+        const isClassBased = isFunction(baseClass);
+        const updateIds = toArray.filter(predicate(true));
+        const newEntities = toArray.filter(predicate(false)).map((id) => {
+            const newStateObj = typeof newState === 'function' ? newState({}) : newState;
+            const entity = isFunction(onCreate) ? onCreate(id, newStateObj) : newStateObj;
+            const withId = Object.assign({}, entity, { [this.idKey]: id });
+            if (isClassBased) {
+                return new baseClass(withId);
+            }
+            return withId;
+        });
+        // it can be any of the three types
+        this.update(updateIds, newState);
+        this.add(newEntities);
+        isDev() && logAction('Upsert Entity');
+    }
+    /**
+     *
+     * Upsert entity collection (idKey must be present)
+     *
+     * @example
+     *
+     * store.upsertMany([ { id: 1 }, { id: 2 }]);
+     *
+     * store.upsertMany([ { id: 1 }, { id: 2 }], { loading: true  });
+     * store.upsertMany([ { id: 1 }, { id: 2 }], { baseClass: Todo  });
+     *
+     */
+    upsertMany(entities, options = {}) {
+        const addedIds = [];
+        const updatedIds = [];
+        const updatedEntities = {};
+        // Update the state directly to optimize performance
+        for (const entity of entities) {
+            const withPreCheckHook = this.akitaPreCheckEntity(entity);
+            const id = withPreCheckHook[this.idKey];
+            if (hasEntity(this.entities, id)) {
+                const prev = this._value().entities[id];
+                const merged = Object.assign({}, this._value().entities[id], withPreCheckHook);
+                const next = options.baseClass ? new options.baseClass(merged) : merged;
+                const withHook = this.akitaPreUpdateEntity(prev, next);
+                const nextId = withHook[this.idKey];
+                updatedEntities[nextId] = withHook;
+                updatedIds.push(nextId);
+            }
+            else {
+                const newEntity = options.baseClass ? new options.baseClass(withPreCheckHook) : withPreCheckHook;
+                const withHook = this.akitaPreAddEntity(newEntity);
+                const nextId = withHook[this.idKey];
+                addedIds.push(nextId);
+                updatedEntities[nextId] = withHook;
+            }
+        }
+        isDev() && logAction('Upsert Many');
+        this._setState((state) => (Object.assign({}, state, { ids: addedIds.length ? [...state.ids, ...addedIds] : state.ids, entities: Object.assign({}, state.entities, updatedEntities), loading: !!options.loading })));
+        updatedIds.length && this.entityActions.next({ type: EntityActions.Update, ids: updatedIds });
+        addedIds.length && this.entityActions.next({ type: EntityActions.Add, ids: addedIds });
+        if (addedIds.length && this.hasUIStore()) {
+            this.handleUICreation(true);
+        }
+    }
+    /**
+     *
+     * Replace one or more entities (except the id property)
+     *
+     *
+     * @example
+     *
+     * this.store.replace(5, newEntity)
+     * this.store.replace([1,2,3], newEntity)
+     */
+    replace(ids, newState) {
+        const toArray = coerceArray(ids);
+        if (isEmpty(toArray))
+            return;
+        let replaced = {};
+        for (const id of toArray) {
+            newState[this.idKey] = id;
+            replaced[id] = newState;
+        }
+        isDev() && setAction('Replace Entity', ids);
+        this._setState((state) => (Object.assign({}, state, { entities: Object.assign({}, state.entities, replaced) })));
+    }
+    /**
+     *
+     * Move entity inside the collection
+     *
+     *
+     * @example
+     *
+     * this.store.move(fromIndex, toIndex)
+     */
+    move(from, to) {
+        const ids = this.ids.slice();
+        ids.splice(to < 0 ? ids.length + to : to, 0, ids.splice(from, 1)[0]);
+        isDev() && setAction('Move Entity');
+        this._setState((state) => (Object.assign({}, state, { 
+            // Change the entities reference so that selectAll emit
+            entities: Object.assign({}, state.entities), ids })));
+    }
+    remove(idsOrFn) {
+        if (isEmpty(this.ids))
+            return;
+        const idPassed = isDefined(idsOrFn);
+        // null means remove all
+        let ids = [];
+        if (isFunction(idsOrFn)) {
+            ids = this.ids.filter((entityId) => idsOrFn(this.entities[entityId]));
+        }
+        else {
+            ids = idPassed ? coerceArray(idsOrFn) : this.ids;
+        }
+        if (isEmpty(ids))
+            return;
+        isDev() && setAction('Remove Entity', ids);
+        this._setState((state) => removeEntities({ state, ids }));
+        if (!idPassed) {
+            this.setHasCache(false);
+        }
+        this.handleUIRemove(ids);
+        this.entityActions.next({ type: EntityActions.Remove, ids });
+    }
+    /**
+     *
+     * Update the active entity
+     *
+     * @example
+     *
+     * this.store.updateActive({ completed: true })
+     * this.store.updateActive(active => {
+     *   return {
+     *     config: {
+     *      ..active.config,
+     *      date
+     *     }
+     *   }
+     * })
+     */
+    updateActive(newStateOrCallback) {
+        const ids = coerceArray(this.active);
+        isDev() && setAction('Update Active', ids);
+        this.update(ids, newStateOrCallback);
+    }
+    setActive(idOrOptions) {
+        const active = getActiveEntities(idOrOptions, this.ids, this.active);
+        if (active === undefined) {
+            return;
+        }
+        isDev() && setAction('Set Active', active);
+        this._setActive(active);
+    }
+    /**
+     * Add active entities
+     *
+     * @example
+     *
+     * store.addActive(2);
+     * store.addActive([3, 4, 5]);
+     */
+    addActive(ids) {
+        const toArray = coerceArray(ids);
+        if (isEmpty(toArray))
+            return;
+        const everyExist = toArray.every((id) => this.active.indexOf(id) > -1);
+        if (everyExist)
+            return;
+        isDev() && setAction('Add Active', ids);
+        this._setState((state) => {
+            /** Protect against case that one of the items in the array exist */
+            const uniques = Array.from(new Set([...state.active, ...toArray]));
+            return Object.assign({}, state, { active: uniques });
+        });
+    }
+    /**
+     * Remove active entities
+     *
+     * @example
+     *
+     * store.removeActive(2)
+     * store.removeActive([3, 4, 5])
+     */
+    removeActive(ids) {
+        const toArray = coerceArray(ids);
+        if (isEmpty(toArray))
+            return;
+        const someExist = toArray.some((id) => this.active.indexOf(id) > -1);
+        if (!someExist)
+            return;
+        isDev() && setAction('Remove Active', ids);
+        this._setState((state) => {
+            return Object.assign({}, state, { active: Array.isArray(state.active) ? state.active.filter((currentId) => toArray.indexOf(currentId) === -1) : null });
+        });
+    }
+    /**
+     * Toggle active entities
+     *
+     * @example
+     *
+     * store.toggle(2)
+     * store.toggle([3, 4, 5])
+     */
+    toggleActive(ids) {
+        const toArray = coerceArray(ids);
+        const filterExists = (remove) => (id) => this.active.includes(id) === remove;
+        const remove = toArray.filter(filterExists(true));
+        const add = toArray.filter(filterExists(false));
+        this.removeActive(remove);
+        this.addActive(add);
+        isDev() && logAction('Toggle Active');
+    }
+    /**
+     *
+     * Create sub UI store for managing Entity's UI state
+     *
+     * @example
+     *
+     * export type ProductUI = {
+     *   isLoading: boolean;
+     *   isOpen: boolean
+     * }
+     *
+     * interface ProductsUIState extends EntityState<ProductUI> {}
+     *
+     * export class ProductsStore EntityStore<ProductsState, Product> {
+     *   ui: EntityUIStore<ProductsUIState, ProductUI>;
+     *
+     *   constructor() {
+     *     super();
+     *     this.createUIStore();
+     *   }
+     *
+     * }
+     */
+    createUIStore(initialState = {}, storeConfig = {}) {
+        const defaults = { name: `UI/${this.storeName}`, idKey: this.idKey };
+        this.ui = new EntityUIStore(initialState, Object.assign({}, defaults, storeConfig));
+        return this.ui;
+    }
+    // @internal
+    destroy() {
+        super.destroy();
+        if (this.ui instanceof EntityStore) {
+            this.ui.destroy();
+        }
+        this.entityActions.complete();
+    }
+    // @internal
+    akitaPreUpdateEntity(_, nextEntity) {
+        return nextEntity;
+    }
+    // @internal
+    akitaPreAddEntity(newEntity) {
+        return newEntity;
+    }
+    // @internal
+    akitaPreCheckEntity(newEntity) {
+        return newEntity;
+    }
+    get ids() {
+        return this._value().ids;
+    }
+    get entities() {
+        return this._value().entities;
+    }
+    get active() {
+        return this._value().active;
+    }
+    _setActive(ids) {
+        this._setState((state) => {
+            return Object.assign({}, state, { active: ids });
+        });
+    }
+    handleUICreation(add = false) {
+        const ids = this.ids;
+        const isFunc = isFunction(this.ui._akitaCreateEntityFn);
+        let uiEntities;
+        const createFn = (id) => {
+            const current = this.entities[id];
+            const ui = isFunc ? this.ui._akitaCreateEntityFn(current) : this.ui._akitaCreateEntityFn;
+            return Object.assign({ [this.idKey]: current[this.idKey] }, ui);
+        };
+        if (add) {
+            uiEntities = this.ids.filter((id) => isUndefined(this.ui.entities[id])).map(createFn);
+        }
+        else {
+            uiEntities = ids.map(createFn);
+        }
+        add ? this.ui.add(uiEntities) : this.ui.set(uiEntities);
+    }
+    hasInitialUIState() {
+        return this.hasUIStore() && isUndefined(this.ui._akitaCreateEntityFn) === false;
+    }
+    handleUIRemove(ids) {
+        if (this.hasUIStore()) {
+            this.ui.remove(ids);
+        }
+    }
+    hasUIStore() {
+        return this.ui instanceof EntityUIStore;
+    }
+}
+__decorate([
+    transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object, Object]),
+    __metadata("design:returntype", void 0)
+], EntityStore.prototype, "upsert", null);
+__decorate([
+    transaction(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [typeof (_b = typeof T !== "undefined" && T) === "function" ? _b : Object]),
+    __metadata("design:returntype", void 0)
+], EntityStore.prototype, "toggleActive", null);
+// @internal
+class EntityUIStore extends EntityStore {
+    constructor(initialState = {}, storeConfig = {}) {
+        super(initialState, storeConfig);
+    }
+    /**
+     *
+     * Set the initial UI entity state. This function will determine the entity's
+     * initial state when we call `set()` or `add()`.
+     *
+     * @example
+     *
+     * constructor() {
+     *   super();
+     *   this.createUIStore().setInitialEntityState(entity => ({ isLoading: false, isOpen: true }));
+     *   this.createUIStore().setInitialEntityState({ isLoading: false, isOpen: true });
+     * }
+     *
+     */
+    setInitialEntityState(createFn) {
+        this._akitaCreateEntityFn = createFn;
+    }
+}
+
+var Order;
+(function (Order) {
+    Order["ASC"] = "asc";
+    Order["DESC"] = "desc";
+})(Order || (Order = {}));
+
+// @internal
+function isString(value) {
+    return typeof value === 'string';
+}
+
+const queryConfigKey = 'akitaQueryConfig';
+
+function compareKeys(keysOrFuncs) {
+    return function (prevState, currState) {
+        const isFns = isFunction(keysOrFuncs[0]);
+        // Return when they are NOT changed
+        return keysOrFuncs.some(keyOrFunc => {
+            if (isFns) {
+                return keyOrFunc(prevState) !== keyOrFunc(currState);
+            }
+            return prevState[keyOrFunc] !== currState[keyOrFunc];
+        }) === false;
+    };
+}
+
+class Query {
+    constructor(store) {
+        this.store = store;
+        this.__store__ = store;
+        if (isDev()) {
+            // @internal
+            __queries__[store.storeName] = this;
+        }
+    }
+    select(project) {
+        let mapFn;
+        if (isFunction(project)) {
+            mapFn = project;
+        }
+        else if (isString(project)) {
+            mapFn = state => state[project];
+        }
+        else if (Array.isArray(project)) {
+            return this.store
+                ._select(state => state)
+                .pipe(distinctUntilChanged(compareKeys(project)), map(state => {
+                if (isFunction(project[0])) {
+                    return project.map(func => func(state));
+                }
+                return project.reduce((acc, k) => {
+                    acc[k] = state[k];
+                    return acc;
+                }, {});
+            }));
+        }
+        else {
+            mapFn = state => state;
+        }
+        return this.store._select(mapFn);
+    }
+    /**
+     * Select the loading state
+     *
+     * @example
+     *
+     * this.query.selectLoading().subscribe(isLoading => {})
+     */
+    selectLoading() {
+        return this.select(state => state.loading);
+    }
+    /**
+     * Select the error state
+     *
+     * @example
+     *
+     * this.query.selectError().subscribe(error => {})
+     */
+    selectError() {
+        return this.select(state => state.error);
+    }
+    /**
+     * Get the store's value
+     *
+     * @example
+     *
+     * this.query.getValue()
+     *
+     */
+    getValue() {
+        return this.store._value();
+    }
+    /**
+     * Select the cache state
+     *
+     * @example
+     *
+     * this.query.selectHasCache().pipe(
+     *   switchMap(hasCache => {
+     *     return hasCache ? of() : http().pipe(res => store.set(res))
+     *   })
+     * )
+     */
+    selectHasCache() {
+        return this.store._cache().asObservable();
+    }
+    /**
+     * Whether we've cached data
+     *
+     * @example
+     *
+     * this.query.getHasCache()
+     *
+     */
+    getHasCache() {
+        return this.store._cache().value;
+    }
+    // @internal
+    get config() {
+        return this.constructor[queryConfigKey];
+    }
+}
+
+/**
+ * @example
+ *
+ * query.selectEntity(2).pipe(filterNil)
+ */
+const filterNil = (source) => source.pipe(filter((value) => value !== null && typeof value !== 'undefined'));
+
+/**
+ * @internal
+ *
+ * @example
+ *
+ * getValue(state, 'todos.ui')
+ *
+ */
+function getValue(obj, prop) {
+    /** return the whole state  */
+    if (prop.split('.').length === 1) {
+        return obj;
+    }
+    const removeStoreName = prop
+        .split('.')
+        .slice(1)
+        .join('.');
+    return removeStoreName.split('.').reduce((acc, part) => acc && acc[part], obj);
+}
+
+/**
+ * @internal
+ *
+ * @example
+ * setValue(state, 'todos.ui', { filter: {} })
+ */
+function setValue(obj, prop, val) {
+    const split = prop.split('.');
+    if (split.length === 1) {
+        return Object.assign({}, obj, val);
+    }
+    obj = Object.assign({}, obj);
+    const lastIndex = split.length - 2;
+    const removeStoreName = prop.split('.').slice(1);
+    removeStoreName.reduce((acc, part, index) => {
+        if (index !== lastIndex) {
+            acc[part] = Object.assign({}, acc[part]);
+            return acc && acc[part];
+        }
+        acc[part] = Array.isArray(acc[part]) || !isObject(acc[part]) ? val : Object.assign({}, acc[part], val);
+        return acc && acc[part];
+    }, obj);
+    return obj;
+}
+const _persistStateInit = new ReplaySubject(1);
+
+class AkitaPlugin {
+    constructor(query, config) {
+        this.query = query;
+        if (config && config.resetFn) {
+            if (getAkitaConfig().resettable) {
+                this.onReset(config.resetFn);
+            }
+        }
+    }
+    /** This method is responsible for getting access to the query. */
+    getQuery() {
+        return this.query;
+    }
+    /** This method is responsible for getting access to the store. */
+    getStore() {
+        return this.getQuery().__store__;
+    }
+    /** This method is responsible tells whether the plugin is entityBased or not.  */
+    isEntityBased(entityId) {
+        return toBoolean(entityId);
+    }
+    /** This method is responsible for selecting the source; it can be the whole store or one entity. */
+    selectSource(entityId, property) {
+        if (this.isEntityBased(entityId)) {
+            return this.getQuery().selectEntity(entityId).pipe(filterNil);
+        }
+        if (property) {
+            return this.getQuery().select(state => getValue(state, this.withStoreName(property)));
+        }
+        return this.getQuery().select();
+    }
+    getSource(entityId, property) {
+        if (this.isEntityBased(entityId)) {
+            return this.getQuery().getEntity(entityId);
+        }
+        const state = this.getQuery().getValue();
+        if (property) {
+            return getValue(state, this.withStoreName(property));
+        }
+        return state;
+    }
+    withStoreName(prop) {
+        return `${this.storeName}.${prop}`;
+    }
+    get storeName() {
+        return this.getStore().storeName;
+    }
+    /** This method is responsible for updating the store or one entity; it can be the whole store or one entity. */
+    updateStore(newState, entityId, property) {
+        if (this.isEntityBased(entityId)) {
+            this.getStore().update(entityId, newState);
+        }
+        else {
+            if (property) {
+                this.getStore()._setState(state => {
+                    return setValue(state, this.withStoreName(property), newState);
+                });
+                return;
+            }
+            this.getStore()._setState(state => (Object.assign({}, state, newState)));
+        }
+    }
+    /**
+     * Function to invoke upon reset
+     */
+    onReset(fn) {
+        const original = this.getStore().reset;
+        this.getStore().reset = (...params) => {
+            /** It should run after the plugin destroy method */
+            setTimeout(() => {
+                original.apply(this.getStore(), params);
+                fn();
+            });
+        };
+    }
+}
+
+const paginatorDefaults = {
+    pagesControls: false,
+    range: false,
+    startWith: 1,
+    cacheTimeout: undefined,
+    clearStoreWithCache: true
+};
+class PaginatorPlugin extends AkitaPlugin {
+    constructor(query, config = {}) {
+        super(query, {
+            resetFn: () => {
+                this.initial = false;
+                this.destroy({ clearCache: true, currentPage: 1 });
+            }
+        });
+        this.query = query;
+        this.config = config;
+        /** Save current filters, sorting, etc. in cache */
+        this.metadata = new Map();
+        this.pages = new Map();
+        this.pagination = {
+            currentPage: 1,
+            perPage: 0,
+            total: 0,
+            lastPage: 0,
+            data: []
+        };
+        /**
+         * When the user navigates to a different page and return
+         * we don't want to call `clearCache` on first time.
+         */
+        this.initial = true;
+        /**
+         * Proxy to the query loading
+         */
+        this.isLoading$ = this.query.selectLoading().pipe(delay.delay(0));
+        this.config = Object.assign(paginatorDefaults, config);
+        const { startWith, cacheTimeout } = this.config;
+        this.page = new BehaviorSubject(startWith);
+        if (isObservable(cacheTimeout)) {
+            this.clearCacheSubscription = cacheTimeout.subscribe(() => this.clearCache());
+        }
+    }
+    /**
+     * Listen to page changes
+     */
+    get pageChanges() {
+        return this.page.asObservable();
+    }
+    /**
+     * Get the current page number
+     */
+    get currentPage() {
+        return this.pagination.currentPage;
+    }
+    /**
+     * Check if current page is the first one
+     */
+    get isFirst() {
+        return this.currentPage === 1;
+    }
+    /**
+     * Check if current page is the last one
+     */
+    get isLast() {
+        return this.currentPage === this.pagination.lastPage;
+    }
+    /**
+     * Whether to generate an array of pages for *ngFor
+     * [1, 2, 3, 4]
+     */
+    withControls() {
+        this.config.pagesControls = true;
+        return this;
+    }
+    /**
+     * Whether to generate the `from` and `to` keys
+     * [1, 2, 3, 4]
+     */
+    withRange() {
+        this.config.range = true;
+        return this;
+    }
+    /**
+     * Set the loading state
+     */
+    setLoading(value = true) {
+        this.getStore().setLoading(value);
+    }
+    /**
+     * Update the pagination object and add the page
+     */
+    update(response) {
+        this.pagination = response;
+        this.addPage(response.data);
+    }
+    /**
+     *
+     * Set the ids and add the page to store
+     */
+    addPage(data) {
+        this.pages.set(this.currentPage, { ids: data.map(entity => entity[this.getStore().idKey]) });
+        this.getStore().upsertMany(data);
+    }
+    /**
+     * Clear the cache.
+     */
+    clearCache(options = {}) {
+        if (!this.initial) {
+            logAction('@Pagination - Clear Cache');
+            if (options.clearStore !== false && (this.config.clearStoreWithCache || options.clearStore)) {
+                this.getStore().remove();
+            }
+            this.pages = new Map();
+            this.metadata = new Map();
+        }
+        this.initial = false;
+    }
+    clearPage(page) {
+        this.pages.delete(page);
+    }
+    /**
+     * Clear the cache timeout and optionally the pages
+     */
+    destroy({ clearCache, currentPage } = {}) {
+        if (this.clearCacheSubscription) {
+            this.clearCacheSubscription.unsubscribe();
+        }
+        if (clearCache) {
+            this.clearCache();
+        }
+        if (!isUndefined(currentPage)) {
+            this.setPage(currentPage);
+        }
+        this.initial = true;
+    }
+    /**
+     * Whether the provided page is active
+     */
+    isPageActive(page) {
+        return this.currentPage === page;
+    }
+    /**
+     * Set the current page
+     */
+    setPage(page) {
+        if (page !== this.currentPage || !this.hasPage(page)) {
+            this.page.next((this.pagination.currentPage = page));
+        }
+    }
+    /**
+     * Increment current page
+     */
+    nextPage() {
+        if (this.currentPage !== this.pagination.lastPage) {
+            this.setPage(this.pagination.currentPage + 1);
+        }
+    }
+    /**
+     * Decrement current page
+     */
+    prevPage() {
+        if (this.pagination.currentPage > 1) {
+            this.setPage(this.pagination.currentPage - 1);
+        }
+    }
+    /**
+     * Set current page to last
+     */
+    setLastPage() {
+        this.setPage(this.pagination.lastPage);
+    }
+    /**
+     * Set current page to first
+     */
+    setFirstPage() {
+        this.setPage(1);
+    }
+    /**
+     * Check if page exists in cache
+     */
+    hasPage(page) {
+        return this.pages.has(page);
+    }
+    /**
+     * Get the current page if it's in cache, otherwise invoke the request
+     */
+    getPage(req) {
+        let page = this.pagination.currentPage;
+        if (this.hasPage(page)) {
+            return this.selectPage(page);
+        }
+        else {
+            this.setLoading(true);
+            return from(req()).pipe(switchMap((config) => {
+                page = config.currentPage;
+                applyTransaction(() => {
+                    this.setLoading(false);
+                    this.update(config);
+                });
+                return this.selectPage(page);
+            }));
+        }
+    }
+    getQuery() {
+        return this.query;
+    }
+    refreshCurrentPage() {
+        if (isNil(this.currentPage) === false) {
+            this.clearPage(this.currentPage);
+            this.setPage(this.currentPage);
+        }
+    }
+    getFrom() {
+        if (this.isFirst) {
+            return 1;
+        }
+        return (this.currentPage - 1) * this.pagination.perPage + 1;
+    }
+    getTo() {
+        if (this.isLast) {
+            return this.pagination.total;
+        }
+        return this.currentPage * this.pagination.perPage;
+    }
+    /**
+     * Select the page
+     */
+    selectPage(page) {
+        return this.query.selectAll({ asObject: true }).pipe(take(1), map(entities => {
+            let response = Object.assign({}, this.pagination, { data: this.pages.get(page).ids.map(id => entities[id]) });
+            const { range, pagesControls } = this.config;
+            /** If no total - calc it */
+            if (isNaN(this.pagination.total)) {
+                if (response.lastPage === 1) {
+                    response.total = response.data ? response.data.length : 0;
+                }
+                else {
+                    response.total = response.perPage * response.lastPage;
+                }
+                this.pagination.total = response.total;
+            }
+            if (range) {
+                response.from = this.getFrom();
+                response.to = this.getTo();
+            }
+            if (pagesControls) {
+                response.pageControls = generatePages(this.pagination.total, this.pagination.perPage);
+            }
+            return response;
+        }));
+    }
+}
+__decorate([
+    action('@Pagination - New Page'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], PaginatorPlugin.prototype, "update", null);
+/**
+ * Generate an array so we can ngFor them to navigate between pages
+ */
+function generatePages(total, perPage) {
+    const len = Math.ceil(total / perPage);
+    let arr = [];
+    for (let i = 0; i < len; i++) {
+        arr.push(i + 1);
+    }
+    return arr;
+}
+
+var StoreAction;
+(function (StoreAction) {
+    StoreAction["Update"] = "UPDATE";
+})(StoreAction || (StoreAction = {}));
+var EntityStoreAction;
+(function (EntityStoreAction) {
+    EntityStoreAction["Update"] = "UPDATE";
+    EntityStoreAction["AddEntities"] = "ADD_ENTITIES";
+    EntityStoreAction["SetEntities"] = "SET_ENTITIES";
+    EntityStoreAction["UpdateEntities"] = "UPDATE_ENTITIES";
+    EntityStoreAction["RemoveEntities"] = "REMOVE_ENTITIES";
+    EntityStoreAction["UpsertEntities"] = "UPSERT_ENTITIES";
+    EntityStoreAction["UpsertManyEntities"] = "UPSERT_MANY_ENTITIES";
+})(EntityStoreAction || (EntityStoreAction = {}));
+
+exports.Query = Query;
+exports.SimpleInnerSubscriber = SimpleInnerSubscriber;
+exports.SimpleOuterSubscriber = SimpleOuterSubscriber;
+exports.Store = Store;
+exports.StoreConfig = StoreConfig;
+exports.distinctUntilChanged = distinctUntilChanged;
+exports.enableAkitaProdMode = enableAkitaProdMode;
+exports.filter = filter;
+exports.from = from;
+exports.innerSubscribe = innerSubscribe;
+exports.map = map;