@livequery/core 2.0.86 → 2.0.89

package/dist/index.js

@@ -1242,45 +1242,56 @@ function process(asyncIterable, subscriber) {
   });
 }
 
-// node_modules/rxjs/dist/esm5/internal/util/executeSchedule.js
-function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
-  if (delay === undefined) {
-    delay = 0;
-  }
-  if (repeat === undefined) {
-    repeat = false;
-  }
-  var scheduleSubscription = scheduler.schedule(function() {
-    work();
-    if (repeat) {
-      parentSubscription.add(this.schedule(null, delay));
-    } else {
-      this.unsubscribe();
+// node_modules/rxjs/dist/esm5/internal/observable/defer.js
+function defer(observableFactory) {
+  return new Observable(function(subscriber) {
+    innerFrom(observableFactory()).subscribe(subscriber);
+  });
+}
+// node_modules/rxjs/dist/esm5/internal/util/argsArgArrayOrObject.js
+var isArray = Array.isArray;
+var getPrototypeOf = Object.getPrototypeOf;
+var objectProto = Object.prototype;
+var getKeys = Object.keys;
+function argsArgArrayOrObject(args) {
+  if (args.length === 1) {
+    var first_1 = args[0];
+    if (isArray(first_1)) {
+      return { args: first_1, keys: null };
+    }
+    if (isPOJO(first_1)) {
+      var keys = getKeys(first_1);
+      return {
+        args: keys.map(function(key) {
+          return first_1[key];
+        }),
+        keys
+      };
     }
-  }, delay);
-  parentSubscription.add(scheduleSubscription);
-  if (!repeat) {
-    return scheduleSubscription;
   }
+  return { args, keys: null };
+}
+function isPOJO(obj) {
+  return obj && typeof obj === "object" && getPrototypeOf(obj) === objectProto;
 }
 
-// node_modules/rxjs/dist/esm5/internal/util/lift.js
-function hasLift(source) {
-  return isFunction(source === null || source === undefined ? undefined : source.lift);
+// node_modules/rxjs/dist/esm5/internal/util/isScheduler.js
+function isScheduler(value) {
+  return value && isFunction(value.schedule);
 }
-function operate(init) {
-  return function(source) {
-    if (hasLift(source)) {
-      return source.lift(function(liftedSource) {
-        try {
-          return init(liftedSource, this);
-        } catch (err) {
-          this.error(err);
-        }
-      });
-    }
-    throw new TypeError("Unable to lift unknown Observable type");
-  };
+
+// node_modules/rxjs/dist/esm5/internal/util/args.js
+function last(arr) {
+  return arr[arr.length - 1];
+}
+function popResultSelector(args) {
+  return isFunction(last(args)) ? args.pop() : undefined;
+}
+function popScheduler(args) {
+  return isScheduler(last(args)) ? args.pop() : undefined;
+}
+function popNumber(args, defaultValue) {
+  return typeof last(args) === "number" ? args.pop() : defaultValue;
 }
 
 // node_modules/rxjs/dist/esm5/internal/operators/OperatorSubscriber.js
@@ -1331,6 +1342,117 @@ var OperatorSubscriber = function(_super) {
   return OperatorSubscriber2;
 }(Subscriber);
 
+// node_modules/rxjs/dist/esm5/internal/util/lift.js
+function hasLift(source) {
+  return isFunction(source === null || source === undefined ? undefined : source.lift);
+}
+function operate(init) {
+  return function(source) {
+    if (hasLift(source)) {
+      return source.lift(function(liftedSource) {
+        try {
+          return init(liftedSource, this);
+        } catch (err) {
+          this.error(err);
+        }
+      });
+    }
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+
+// node_modules/rxjs/dist/esm5/internal/operators/map.js
+function map(project, thisArg) {
+  return operate(function(source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      subscriber.next(project.call(thisArg, value, index++));
+    }));
+  });
+}
+
+// node_modules/rxjs/dist/esm5/internal/util/mapOneOrManyArgs.js
+var isArray2 = Array.isArray;
+function callOrApply(fn, args) {
+  return isArray2(args) ? fn.apply(undefined, __spreadArray([], __read(args))) : fn(args);
+}
+function mapOneOrManyArgs(fn) {
+  return map(function(args) {
+    return callOrApply(fn, args);
+  });
+}
+
+// node_modules/rxjs/dist/esm5/internal/util/createObject.js
+function createObject(keys, values) {
+  return keys.reduce(function(result, key, i) {
+    return result[key] = values[i], result;
+  }, {});
+}
+
+// node_modules/rxjs/dist/esm5/internal/observable/forkJoin.js
+function forkJoin() {
+  var args = [];
+  for (var _i = 0;_i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  var resultSelector = popResultSelector(args);
+  var _a = argsArgArrayOrObject(args), sources = _a.args, keys = _a.keys;
+  var result = new Observable(function(subscriber) {
+    var length = sources.length;
+    if (!length) {
+      subscriber.complete();
+      return;
+    }
+    var values = new Array(length);
+    var remainingCompletions = length;
+    var remainingEmissions = length;
+    var _loop_1 = function(sourceIndex2) {
+      var hasValue = false;
+      innerFrom(sources[sourceIndex2]).subscribe(createOperatorSubscriber(subscriber, function(value) {
+        if (!hasValue) {
+          hasValue = true;
+          remainingEmissions--;
+        }
+        values[sourceIndex2] = value;
+      }, function() {
+        return remainingCompletions--;
+      }, undefined, function() {
+        if (!remainingCompletions || !hasValue) {
+          if (!remainingEmissions) {
+            subscriber.next(keys ? createObject(keys, values) : values);
+          }
+          subscriber.complete();
+        }
+      }));
+    };
+    for (var sourceIndex = 0;sourceIndex < length; sourceIndex++) {
+      _loop_1(sourceIndex);
+    }
+  });
+  return resultSelector ? result.pipe(mapOneOrManyArgs(resultSelector)) : result;
+}
+// node_modules/rxjs/dist/esm5/internal/util/executeSchedule.js
+function executeSchedule(parentSubscription, scheduler, work, delay, repeat) {
+  if (delay === undefined) {
+    delay = 0;
+  }
+  if (repeat === undefined) {
+    repeat = false;
+  }
+  var scheduleSubscription = scheduler.schedule(function() {
+    work();
+    if (repeat) {
+      parentSubscription.add(this.schedule(null, delay));
+    } else {
+      this.unsubscribe();
+    }
+  }, delay);
+  parentSubscription.add(scheduleSubscription);
+  if (!repeat) {
+    return scheduleSubscription;
+  }
+}
+
 // node_modules/rxjs/dist/esm5/internal/operators/observeOn.js
 function observeOn(scheduler, delay) {
   if (delay === undefined) {
@@ -1476,16 +1598,6 @@ function scheduled(input, scheduler) {
 function from(input, scheduler) {
   return scheduler ? scheduled(input, scheduler) : innerFrom(input);
 }
-// node_modules/rxjs/dist/esm5/internal/operators/map.js
-function map(project, thisArg) {
-  return operate(function(source, subscriber) {
-    var index = 0;
-    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
-      subscriber.next(project.call(thisArg, value, index++));
-    }));
-  });
-}
-
 // node_modules/rxjs/dist/esm5/internal/operators/mergeInternals.js
 function mergeInternals(source, subscriber, project, concurrent, onBeforeNext, expand, innerSubScheduler, additionalFinalizer) {
   var buffer = [];
@@ -1578,22 +1690,6 @@ var EMPTY = new Observable(function(subscriber) {
   return subscriber.complete();
 });
 
-// node_modules/rxjs/dist/esm5/internal/util/isScheduler.js
-function isScheduler(value) {
-  return value && isFunction(value.schedule);
-}
-
-// node_modules/rxjs/dist/esm5/internal/util/args.js
-function last(arr) {
-  return arr[arr.length - 1];
-}
-function popScheduler(args) {
-  return isScheduler(last(args)) ? args.pop() : undefined;
-}
-function popNumber(args, defaultValue) {
-  return typeof last(args) === "number" ? args.pop() : defaultValue;
-}
-
 // node_modules/rxjs/dist/esm5/internal/observable/merge.js
 function merge() {
   var args = [];
@@ -1852,60 +1948,14 @@ function debounceTime(dueTime, scheduler) {
     }));
   });
 }
-// node_modules/rxjs/dist/esm5/internal/operators/concatAll.js
-function concatAll() {
-  return mergeAll(1);
-}
-
-// node_modules/rxjs/dist/esm5/internal/observable/concat.js
-function concat() {
-  var args = [];
-  for (var _i = 0;_i < arguments.length; _i++) {
-    args[_i] = arguments[_i];
+// node_modules/rxjs/dist/esm5/internal/operators/expand.js
+function expand(project, concurrent, scheduler) {
+  if (concurrent === undefined) {
+    concurrent = Infinity;
   }
-  return concatAll()(from(args, popScheduler(args)));
-}
-
-// node_modules/rxjs/dist/esm5/internal/operators/take.js
-function take(count) {
-  return count <= 0 ? function() {
-    return EMPTY;
-  } : operate(function(source, subscriber) {
-    var seen = 0;
-    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
-      if (++seen <= count) {
-        subscriber.next(value);
-        if (count <= seen) {
-          subscriber.complete();
-        }
-      }
-    }));
-  });
-}
-
-// node_modules/rxjs/dist/esm5/internal/operators/ignoreElements.js
-function ignoreElements() {
+  concurrent = (concurrent || 0) < 1 ? Infinity : concurrent;
   return operate(function(source, subscriber) {
-    source.subscribe(createOperatorSubscriber(subscriber, noop));
-  });
-}
-
-// node_modules/rxjs/dist/esm5/internal/operators/mapTo.js
-function mapTo(value) {
-  return map(function() {
-    return value;
-  });
-}
-
-// node_modules/rxjs/dist/esm5/internal/operators/delayWhen.js
-function delayWhen(delayDurationSelector, subscriptionDelay) {
-  if (subscriptionDelay) {
-    return function(source) {
-      return concat(subscriptionDelay.pipe(take(1), ignoreElements()), source.pipe(delayWhen(delayDurationSelector)));
-    };
-  }
-  return mergeMap(function(value, index) {
-    return innerFrom(delayDurationSelector(value, index)).pipe(take(1), mapTo(value));
+    return mergeInternals(source, subscriber, project, concurrent, undefined, true, scheduler);
   });
 }
 // node_modules/rxjs/dist/esm5/internal/operators/filter.js
@@ -1927,6 +1977,157 @@ function finalize(callback) {
     }
   });
 }
+// node_modules/rxjs/dist/esm5/internal/operators/groupBy.js
+function groupBy(keySelector, elementOrOptions, duration, connector) {
+  return operate(function(source, subscriber) {
+    var element;
+    if (!elementOrOptions || typeof elementOrOptions === "function") {
+      element = elementOrOptions;
+    } else {
+      duration = elementOrOptions.duration, element = elementOrOptions.element, connector = elementOrOptions.connector;
+    }
+    var groups = new Map;
+    var notify = function(cb) {
+      groups.forEach(cb);
+      cb(subscriber);
+    };
+    var handleError = function(err) {
+      return notify(function(consumer) {
+        return consumer.error(err);
+      });
+    };
+    var activeGroups = 0;
+    var teardownAttempted = false;
+    var groupBySourceSubscriber = new OperatorSubscriber(subscriber, function(value) {
+      try {
+        var key_1 = keySelector(value);
+        var group_1 = groups.get(key_1);
+        if (!group_1) {
+          groups.set(key_1, group_1 = connector ? connector() : new Subject);
+          var grouped = createGroupedObservable(key_1, group_1);
+          subscriber.next(grouped);
+          if (duration) {
+            var durationSubscriber_1 = createOperatorSubscriber(group_1, function() {
+              group_1.complete();
+              durationSubscriber_1 === null || durationSubscriber_1 === undefined || durationSubscriber_1.unsubscribe();
+            }, undefined, undefined, function() {
+              return groups.delete(key_1);
+            });
+            groupBySourceSubscriber.add(innerFrom(duration(grouped)).subscribe(durationSubscriber_1));
+          }
+        }
+        group_1.next(element ? element(value) : value);
+      } catch (err) {
+        handleError(err);
+      }
+    }, function() {
+      return notify(function(consumer) {
+        return consumer.complete();
+      });
+    }, handleError, function() {
+      return groups.clear();
+    }, function() {
+      teardownAttempted = true;
+      return activeGroups === 0;
+    });
+    source.subscribe(groupBySourceSubscriber);
+    function createGroupedObservable(key, groupSubject) {
+      var result = new Observable(function(groupSubscriber) {
+        activeGroups++;
+        var innerSub = groupSubject.subscribe(groupSubscriber);
+        return function() {
+          innerSub.unsubscribe();
+          --activeGroups === 0 && teardownAttempted && groupBySourceSubscriber.unsubscribe();
+        };
+      });
+      result.key = key;
+      return result;
+    }
+  });
+}
+// node_modules/rxjs/dist/esm5/internal/observable/throwError.js
+function throwError(errorOrErrorFactory, scheduler) {
+  var errorFactory = isFunction(errorOrErrorFactory) ? errorOrErrorFactory : function() {
+    return errorOrErrorFactory;
+  };
+  var init = function(subscriber) {
+    return subscriber.error(errorFactory());
+  };
+  return new Observable(scheduler ? function(subscriber) {
+    return scheduler.schedule(init, 0, subscriber);
+  } : init);
+}
+
+// node_modules/rxjs/dist/esm5/internal/Notification.js
+var NotificationKind;
+(function(NotificationKind2) {
+  NotificationKind2["NEXT"] = "N";
+  NotificationKind2["ERROR"] = "E";
+  NotificationKind2["COMPLETE"] = "C";
+})(NotificationKind || (NotificationKind = {}));
+var Notification = function() {
+  function Notification2(kind, value, error) {
+    this.kind = kind;
+    this.value = value;
+    this.error = error;
+    this.hasValue = kind === "N";
+  }
+  Notification2.prototype.observe = function(observer) {
+    return observeNotification(this, observer);
+  };
+  Notification2.prototype.do = function(nextHandler, errorHandler, completeHandler) {
+    var _a = this, kind = _a.kind, value = _a.value, error = _a.error;
+    return kind === "N" ? nextHandler === null || nextHandler === undefined ? undefined : nextHandler(value) : kind === "E" ? errorHandler === null || errorHandler === undefined ? undefined : errorHandler(error) : completeHandler === null || completeHandler === undefined ? undefined : completeHandler();
+  };
+  Notification2.prototype.accept = function(nextOrObserver, error, complete) {
+    var _a;
+    return isFunction((_a = nextOrObserver) === null || _a === undefined ? undefined : _a.next) ? this.observe(nextOrObserver) : this.do(nextOrObserver, error, complete);
+  };
+  Notification2.prototype.toObservable = function() {
+    var _a = this, kind = _a.kind, value = _a.value, error = _a.error;
+    var result = kind === "N" ? of(value) : kind === "E" ? throwError(function() {
+      return error;
+    }) : kind === "C" ? EMPTY : 0;
+    if (!result) {
+      throw new TypeError("Unexpected notification kind " + kind);
+    }
+    return result;
+  };
+  Notification2.createNext = function(value) {
+    return new Notification2("N", value);
+  };
+  Notification2.createError = function(err) {
+    return new Notification2("E", undefined, err);
+  };
+  Notification2.createComplete = function() {
+    return Notification2.completeNotification;
+  };
+  Notification2.completeNotification = new Notification2("C");
+  return Notification2;
+}();
+function observeNotification(notification, observer) {
+  var _a, _b, _c;
+  var _d = notification, kind = _d.kind, value = _d.value, error = _d.error;
+  if (typeof kind !== "string") {
+    throw new TypeError('Invalid notification, missing "kind"');
+  }
+  kind === "N" ? (_a = observer.next) === null || _a === undefined || _a.call(observer, value) : kind === "E" ? (_b = observer.error) === null || _b === undefined || _b.call(observer, error) : (_c = observer.complete) === null || _c === undefined || _c.call(observer);
+}
+
+// node_modules/rxjs/dist/esm5/internal/operators/materialize.js
+function materialize() {
+  return operate(function(source, subscriber) {
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      subscriber.next(Notification.createNext(value));
+    }, function() {
+      subscriber.next(Notification.createComplete());
+      subscriber.complete();
+    }, function(err) {
+      subscriber.next(Notification.createError(err));
+      subscriber.complete();
+    }));
+  });
+}
 // node_modules/rxjs/dist/esm5/internal/operators/pairwise.js
 function pairwise() {
   return operate(function(source, subscriber) {
@@ -1940,6 +2141,27 @@ function pairwise() {
     }));
   });
 }
+// node_modules/rxjs/dist/esm5/internal/operators/scanInternals.js
+function scanInternals(accumulator, seed, hasSeed, emitOnNext, emitBeforeComplete) {
+  return function(source, subscriber) {
+    var hasState = hasSeed;
+    var state = seed;
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      var i = index++;
+      state = hasState ? accumulator(state, value, i) : (hasState = true, value);
+      emitOnNext && subscriber.next(state);
+    }, emitBeforeComplete && function() {
+      hasState && subscriber.next(state);
+      subscriber.complete();
+    }));
+  };
+}
+
+// node_modules/rxjs/dist/esm5/internal/operators/scan.js
+function scan(accumulator, seed) {
+  return operate(scanInternals(accumulator, seed, arguments.length >= 2, true));
+}
 // node_modules/rxjs/dist/esm5/internal/ReplaySubject.js
 var ReplaySubject = function(_super) {
   __extends(ReplaySubject2, _super);
@@ -2131,6 +2353,29 @@ function switchMap(project, resultSelector) {
     }));
   });
 }
+// node_modules/rxjs/dist/esm5/internal/operators/takeUntil.js
+function takeUntil(notifier) {
+  return operate(function(source, subscriber) {
+    innerFrom(notifier).subscribe(createOperatorSubscriber(subscriber, function() {
+      return subscriber.complete();
+    }, noop));
+    !subscriber.closed && source.subscribe(subscriber);
+  });
+}
+// node_modules/rxjs/dist/esm5/internal/operators/takeWhile.js
+function takeWhile(predicate, inclusive) {
+  if (inclusive === undefined) {
+    inclusive = false;
+  }
+  return operate(function(source, subscriber) {
+    var index = 0;
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      var result = predicate(value, index++);
+      (result || inclusive) && subscriber.next(value);
+      !result && subscriber.complete();
+    }));
+  });
+}
 // node_modules/rxjs/dist/esm5/internal/operators/tap.js
 function tap(observerOrNext, error, complete) {
   var tapObserver = isFunction(observerOrNext) || error || complete ? { next: observerOrNext, error, complete } : observerOrNext;
@@ -2185,6 +2430,7 @@ class LivequeryDocument extends BehaviorSubject {
 
 // src/LivequeryCollection.ts
 class LivequeryCollection {
+  options;
   id = (Math.random() * 1000000000000000000).toString(36);
   #keys = new Map;
   #indexes;
@@ -2192,7 +2438,6 @@ class LivequeryCollection {
   #filters = new Subject;
   ref;
   collection_ref;
-  #items = [];
   items;
   summary;
   metadata;
@@ -2200,8 +2445,8 @@ class LivequeryCollection {
   filters;
   paging;
   error;
-  options;
-  constructor(options) {
+  constructor(options = {}) {
+    this.options = options;
     this.#indexes = new Map;
     this.items = new BehaviorSubject([]);
     this.summary = new BehaviorSubject({});
@@ -2216,8 +2461,9 @@ class LivequeryCollection {
       this.options = options;
     }
   }
-  #reindex() {
-    this.#indexes = this.#items.reduce((p, c, index) => {
+  #commit(items) {
+    this.items.next(items);
+    this.#indexes = items.reduce((p, c, index) => {
       p.set(c.value.id, index);
       return p;
     }, new Map);
@@ -2232,20 +2478,16 @@ class LivequeryCollection {
     this.#core = core;
     const timer2 = this.options.lazy !== true && setTimeout(() => this.query(this.filters.value || {}));
     this.#subscription?.unsubscribe();
-    this.#subscription = merge(this.options.debounce ? merge(this.#filters.pipe(debounceTime(this.options.debounce), switchMap((filters) => this.query(filters))), this.#show$.pipe(debounceTime(this.options.debounce || 0), tap((visible) => {
-      this.options.visible = visible;
-      this.items.next(this.options.visible ? this.#items.filter((i) => this.options.visible(i.value)) : this.#items);
-    }))) : EMPTY, core.watch(this.ref, this.id).pipe(finalize(() => {
+    this.#subscription = merge(this.options.debounce ? merge(this.#filters.pipe(debounceTime(this.options.debounce), switchMap((filters) => this.query(filters)))) : EMPTY, core.watch(this.ref, this.id, this.options.mode || "server-first").pipe(finalize(() => {
       timer2 && clearTimeout(timer2);
     }), tap((event) => {
+      event.loading !== undefined && event.loading !== this.loading.value && this.loading.next(event.loading);
       event.summary && this.summary.next(event.summary);
       event.metadata && this.metadata.next(event.metadata);
       event.paging && this.paging.next(event.paging);
       event.error && this.error.next(event.error);
-      if (!event.changes || event.changes.length == 0) {
-        event.from == "query" && this.loading.next(null);
+      if (!event.changes || event.changes.length == 0)
         return;
-      }
       const chaos = event.changes && event.changes.some((change) => {
         if (change.type == "added" || change.type == "removed")
           return true;
@@ -2290,7 +2532,7 @@ class LivequeryCollection {
         const target = index != null && index >= 0 ? p[index] : null;
         target && target.next({ ...target.value, ...data });
         return p;
-      }, this.#items);
+      }, this.items.value);
       const new_items = events.added.filter((a) => a.data).reduce((p, c) => {
         if (!p.indexes.has(c.id)) {
           const doc = new LivequeryDocument(this, { id: c.id, ...c.data });
@@ -2313,31 +2555,18 @@ class LivequeryCollection {
         ...new_items.list
       ]);
       const items = chaos ? unsort_items.sort(sorter) : unsort_items;
-      if (chaos) {
-        this.#items = items;
-        this.items.next(this.options.visible ? items.filter((i) => this.options.visible(i.value)) : items);
-        this.#reindex();
-      }
-      event.from == "query" && this.loading.next(null);
+      chaos && this.#commit(items);
       event.paging && this.paging.next(event.paging);
-      event.from == "query" && this.loading.next(null);
     }))).subscribe();
     return this.#subscription;
   }
-  #show$ = new Subject;
-  async show(visible) {
-    this.#show$.next(visible);
-  }
   async#query(filters, flush) {
     if (!this.#core)
       return;
     if (!this.ref)
       return;
     this.error.next(null);
-    if (flush) {
-      this.#items = [];
-      this.items.next([]);
-    }
+    flush && this.#commit([]);
     this.#keys = Object.entries(filters).reduce((p, [k, v]) => {
       if (k.endsWith(":sort")) {
         const field = k.split(":")[0];
@@ -2346,23 +2575,16 @@ class LivequeryCollection {
       return p;
     }, new Map);
     this.filters.next(filters);
-    const next = filters[":after"];
-    const prev = filters[":before"];
-    const loading = next && prev ? "all" : next ? "next" : prev ? "prev" : "all";
-    this.loading.next(loading);
-    const items = await this.#core.query({
+    const cache = await this.#core.query({
       ref: this.ref,
       filters,
       collection_id: this.id
     });
-    if (flush && this.options.cache && Object.keys(filters || {}).length == 0) {
-      this.#items = (this.options.visible ? items.documents.filter((i) => this.options.visible(i)) : items.documents).map((i) => new LivequeryDocument(this, i));
-      this.items.next(this.#items);
-      this.loading.next(null);
+    if (cache && cache.documents && flush) {
+      this.#commit(cache.documents.map((i) => new LivequeryDocument(this, i)));
     }
   }
   async query(filters) {
-    this.loading.next("all");
     await this.#query(filters, true);
   }
   async debounceQuery(filters) {
@@ -2376,7 +2598,6 @@ class LivequeryCollection {
       ...this.filters.value,
       ":after": next.cursor
     };
-    this.loading.next("next");
     await this.#query(filters || {}, false);
   }
   async loadPrev() {
@@ -2387,7 +2608,6 @@ class LivequeryCollection {
       ...this.filters.value,
       ":before": prev.cursor
     };
-    this.loading.next("prev");
     await this.#query(filters || {}, false);
   }
   async loadAround(cursor) {
@@ -2396,7 +2616,6 @@ class LivequeryCollection {
       ":after": cursor,
       ":before": cursor
     };
-    this.loading.next("all");
     await this.#query(filters || {}, false);
   }
   add(payload) {
@@ -2450,6 +2669,92 @@ var tryCatch = async (fn) => {
   }
 };
 
+// src/helpers/whenCompleted.ts
+function whenCompleted(stream) {
+  return stream.pipe(materialize(), filter((n) => n.kind === "C" || n.kind === "E"), map(() => {
+    return;
+  }), shareReplay(1));
+}
+
+// src/helpers/filterDocs.ts
+function filterDocs(documents, filters) {
+  if (!filters)
+    return documents;
+  const normalized = filters;
+  return documents.filter((doc) => matchesAllFilters(doc, normalized));
+}
+function matchesAllFilters(doc, filters) {
+  for (const [key, expected] of Object.entries(filters)) {
+    if (key.startsWith(":") || key.endsWith(":sort"))
+      continue;
+    const split = key.split(":");
+    const fieldPath = split[0];
+    if (!fieldPath)
+      continue;
+    const op = split[1] || "eq";
+    const actual = getByPath(doc, fieldPath);
+    if (!matchByOperator(actual, op, expected)) {
+      return false;
+    }
+  }
+  return true;
+}
+function matchByOperator(actual, op, expected) {
+  switch (op) {
+    case "gt":
+      return asNumber(actual) > asNumber(expected);
+    case "gte":
+      return asNumber(actual) >= asNumber(expected);
+    case "lt":
+      return asNumber(actual) < asNumber(expected);
+    case "lte":
+      return asNumber(actual) <= asNumber(expected);
+    case "eq-number":
+      return asNumber(actual) === asNumber(expected);
+    case "in":
+      return Array.isArray(expected) ? expected.includes(actual) : false;
+    case "nin":
+      return Array.isArray(expected) ? !expected.includes(actual) : true;
+    case "include":
+      return Array.isArray(actual) ? actual.includes(expected) : false;
+    case "boolean":
+      return matchBoolean(actual, expected);
+    case "like":
+      return String(actual || "").toLowerCase().includes(String(expected || "").toLowerCase());
+    case "null":
+      return expected === "null-only" ? actual === null || typeof actual === "undefined" : actual !== null && typeof actual !== "undefined";
+    case "eq":
+    default:
+      return actual === expected;
+  }
+}
+function matchBoolean(actual, expected) {
+  switch (expected) {
+    case "true":
+      return actual === true;
+    case "false":
+      return actual === false;
+    case "not-true":
+      return actual !== true;
+    case "not-false":
+      return actual !== false;
+    default:
+      return false;
+  }
+}
+function getByPath(obj, path) {
+  if (!path.includes("."))
+    return obj[path];
+  return path.split(".").reduce((acc, key) => {
+    if (!acc || typeof acc !== "object")
+      return;
+    return acc[key];
+  }, obj);
+}
+function asNumber(value) {
+  return Number(value);
+}
+
 // src/LivequeryCore.ts
 class LivequeryCore {
   config;
@@ -2461,79 +2766,95 @@ class LivequeryCore {
     this.config = config3;
     this.#start();
   }
-  #start() {
-    const cache = new Map;
-    const changes$ = new Subject;
-    merge(changes$.pipe(delayWhen((change) => {
-      if (change.type == "modified" || change.type == "removed")
-        return of(1);
-      return this.#adding.get(change.collection_ref) || of(1);
-    }), tap((change) => this.#sync("realtime", change))), this.#queries$.pipe(mergeMap(async ({ collection, ref, filters, headers }) => {
-      if (collection.document_id) {
-        const doc = await this.config.storage.get(collection.collection_ref, collection.document_id);
-        if (doc) {
-          collection.o.next({
-            from: "query",
-            changes: [{
-              type: "added",
-              collection_ref: collection.collection_ref,
-              id: doc.id,
-              data: doc
-            }]
-          });
-          return EMPTY;
-        }
+  #cache = new Map;
+  #query(e, deduplicate_key) {
+    const clear = () => deduplicate_key && this.#cache.delete(deduplicate_key);
+    const cached = deduplicate_key && this.#cache.get(deduplicate_key);
+    if (cached)
+      return Object.assign(cached, { clear });
+    const $ = from(Object.values(this.config.transporters)).pipe(mergeMap((transporter) => transporter.query(e).pipe(tap((result) => {
+      for (const change of result.changes || []) {
+        change.type == "added" && change.data && this.config.storage.add(change.collection_ref, {
+          id: change.data.id,
+          ...change.data
+        });
+        change.type == "modified" && change.data && this.config.storage.update(change.collection_ref, change.id, change.data);
+        change.type == "removed" && this.config.storage.delete(change.collection_ref, change.id);
       }
-      return from(Object.values(this.config.transporters)).pipe(map((transporter) => {
-        const key = `${ref}?${new URLSearchParams(filters || {}).toString()}`;
-        const cached = cache.get(key);
-        if (cached)
-          return cached;
-        const query = transporter.query({
-          ref,
-          filters,
-          headers
-        }).pipe(tap((result) => {
-          for (const change of result.changes || []) {
-            change.type == "added" && change.data && this.config.storage.add(change.collection_ref, {
-              id: change.data.id,
-              ...change.data
-            });
-            change.type == "modified" && change.data && this.config.storage.update(change.collection_ref, change.id, change.data);
-            change.type == "removed" && this.config.storage.delete(change.collection_ref, change.id);
-          }
-        }), map((result, index) => {
-          if (index == 0) {
-            cache.delete(key);
-            return { result };
-          }
-          result.changes?.forEach((change) => changes$.next(change));
-        }), filter(Boolean), shareReplay());
-        cache.set(key, query);
-        return query;
-      }), mergeMap(($) => $), map(({ result }, index) => {
-        collection.o.next({
+    }), map((result, index) => ({ result, index })), mergeMap(({ result, index }) => {
+      if (index == 0)
+        return of(result);
+      const changes = result.changes || [];
+      if (changes.length === 0)
+        return EMPTY;
+      const lock$ = this.#adding.get(e.collection.collection_ref);
+      if (!lock$) {
+        this.#broadcast(e.collection.collection_ref, "realtime", changes);
+        return EMPTY;
+      }
+      const ok_changes = changes.filter((c) => c.type != "added");
+      const delay_changes = changes.filter((c) => c.type == "added");
+      this.#broadcast(e.collection.collection_ref, "realtime", ok_changes);
+      return lock$.pipe(tap(() => this.#broadcast(e.collection.collection_ref, "realtime", delay_changes)), switchMap(() => EMPTY));
+    }))), finalize(clear), shareReplay());
+    deduplicate_key && this.#cache.set(deduplicate_key, $);
+    return Object.assign($, { clear });
+  }
+  #start() {
+    lastValueFrom(merge(this.#queries$.pipe(filter((req) => req.collection.mode == "server-first" || req.collection.mode == "cache-first"), mergeMap((e) => {
+      const deduplicate_key = `${e.collection.collection_id}:${JSON.stringify(e.filters)}`;
+      const before = e.filters?.[":before"];
+      const after = e.filters?.[":after"];
+      const around = e.filters?.[":around"];
+      const loading = !before && !after || before && after || around ? "all" : before ? "prev" : "next";
+      e.collection.data$.next({
+        from: "query",
+        loading: e.collection.document_id ? "all" : loading
+      });
+      return this.#query(e, deduplicate_key).pipe(takeUntil(whenCompleted(e.collection.data$)), tap((result) => {
+        e.collection.data$.next({
           ...result,
-          from: index === 0 ? "query" : "realtime"
+          from: "query",
+          loading: null
         });
       }));
-    }), mergeMap(($) => $))).subscribe();
+    })), this.#queries$.pipe(filter((req) => req.collection.mode == "local-first"), groupBy((e) => `${e.collection.collection_ref}/${e.collection.document_id || "::"}`), mergeMap(($) => $.pipe(mergeMap((e, index) => {
+      index == 0 && e.collection.data$.next({
+        from: "query",
+        loading: "all"
+      });
+      return merge(of(e), index > 0 ? EMPTY : defer(() => {
+        return this.#query(e).pipe(expand((res) => {
+          const next = res.paging?.next;
+          if (!next)
+            return EMPTY;
+          return this.#query({
+            ...e,
+            filters: { ":after": next.cursor }
+          });
+        }), tap((result) => {
+          this.#broadcast(e.collection.collection_ref, "query", result.changes || []);
+        }));
+      }).pipe(switchMap(() => EMPTY)));
+    }), scan((p, c) => new Set([...p, c.collection.data$].filter(($2) => !$2.closed)), new Set), map((set) => [...set].map(($2) => whenCompleted($2))), switchMap((list) => forkJoin(list)), takeWhile(() => false))))));
   }
-  watch(ref, collection_id) {
+  watch(ref, collection_id, mode) {
     const refs = ref.split("/");
     const document_id = refs.length % 2 == 0 ? refs[refs.length - 1] : undefined;
     const collection_ref = refs.length % 2 == 0 ? refs.slice(0, -1).join("/") : ref;
     const collections = this.#refs.get(collection_ref) || new Set;
     collections.add(collection_id);
     this.#refs.set(collection_ref, collections);
-    const o = new Subject;
+    const data$ = new Subject;
     this.#collections.set(collection_id, {
-      o,
+      data$,
       document_id,
       collection_id,
-      collection_ref
+      collection_ref,
+      mode,
+      filters: {}
     });
-    return o.pipe(finalize(() => {
+    return data$.pipe(finalize(() => {
       this.#collections.delete(collection_id);
       collections.delete(collection_id);
       if (collections.size === 0) {
@@ -2543,27 +2864,69 @@ class LivequeryCore {
   }
   async query(req) {
     const collection = this.#collections.get(req.collection_id);
-    collection && setTimeout(() => this.#queries$.next({ ...req, collection }));
-    return await this.config.storage.query(req.ref, req.filters);
+    if (!collection)
+      throw new Error(`Collection with id ${req.collection_id} not found`);
+    if (collection.document_id) {
+      const ids = this.#refs.get(collection.collection_ref);
+      const collections = ids ? [...ids].map((id) => this.#collections.get(id)).filter((c) => c && c.document_id) : [];
+      const doc = await this.config.storage.get(collection.collection_ref, collection.document_id);
+      if (collections.length > 0 && doc)
+        return {
+          documents: [doc]
+        };
+    }
+    setTimeout(() => this.#queries$.next({
+      ...req,
+      filters: collection.mode == "local-first" ? {} : req.filters,
+      collection
+    }));
+    collection.filters = req.filters || {};
+    if (collection.mode == "local-first") {
+      return await this.config.storage.query(req.ref, req.filters);
+    }
+    if (collection.mode == "cache-first") {
+      const before = req.filters?.[":before"];
+      const after = req.filters?.[":after"];
+      const is_first_query = !before && !after;
+      if (is_first_query) {
+        return await this.config.storage.query(req.ref, req.filters);
+      }
+    }
   }
-  #sync(source, change) {
-    const collections = this.#refs.get(change.collection_ref) || new Set;
+  #broadcast(collection_ref, from2, events) {
+    const collections = this.#refs.get(collection_ref) || new Set;
     for (const collection_id of collections) {
-      const sender = this.#collections.get(collection_id);
-      if (!sender)
+      const collection = this.#collections.get(collection_id);
+      if (!collection)
         continue;
-      if (!sender.document_id || sender.document_id === change.id) {
-        sender.o.next({
+      if (collection.document_id) {
+        const change = events.find((c) => c.id == collection.document_id);
+        change && collection.data$.next({
           changes: [change],
-          from: source
+          from: from2,
+          loading: null
         });
-        const new_id = change.data?.id;
-        if (sender.document_id && new_id) {
-          sender.document_id = new_id;
-        }
+        continue;
+      }
+      if (collection.mode == "local-first") {
+        const changes = events.filter((e) => {
+          if (e.type == "added")
+            return e.data && matchesAllFilters(e.data, collection.filters);
+          return true;
+        });
+        changes.length > 0 && collection.data$.next({
+          changes,
+          from: from2,
+          ...from2 == "query" ? { loading: null } : {}
+        });
+        continue;
       }
+      collection.data$.next({
+        changes: events,
+        from: from2,
+        ...from2 == "query" ? { loading: null } : {}
+      });
     }
-    return change.data;
   }
   #push(collection_ref, id, doc) {
     const cleanDoc = Object.entries(doc).reduce((p, [k, v]) => {
@@ -2583,12 +2946,12 @@ class LivequeryCore {
             ...e ? { _adding_error: e } : {}
           };
           await this.config.storage.update(collection_ref, id, fnd);
-          this.#sync("action", {
+          this.#broadcast(collection_ref, "action", [{
             collection_ref,
             type: "modified",
             id,
             data: fnd
-          });
+          }]);
         }
         o.next();
         o.complete();
@@ -2602,19 +2965,19 @@ class LivequeryCore {
             _deleting_error: e
           };
           await this.config.storage.update(collection_ref, id, fnd);
-          this.#sync("action", {
+          this.#broadcast(collection_ref, "action", [{
             collection_ref,
             type: "modified",
             id,
             data: fnd
-          });
+          }]);
         } else {
           await this.config.storage.delete(collection_ref, id);
-          this.#sync("action", {
+          this.#broadcast(collection_ref, "action", [{
             collection_ref,
             type: "removed",
             id
-          });
+          }]);
         }
       }
       if (doc._prev && Object.keys(doc._prev).length > 0) {
@@ -2629,24 +2992,24 @@ class LivequeryCore {
           _updating_error: e
         };
         await this.config.storage.update(collection_ref, id, fnd);
-        this.#sync("action", {
+        this.#broadcast(collection_ref, "action", [{
           collection_ref,
           type: "modified",
           id,
           data: fnd
-        });
+        }]);
       }
       return EMPTY;
     })), { defaultValue: undefined });
   }
   async add(collection_ref, doc) {
     const data = await this.config.storage.add(collection_ref, { ...doc, _adding: true });
-    this.#sync("action", {
+    this.#broadcast(collection_ref, "action", [{
+      collection_ref,
       id: data.id,
       type: "added",
-      data,
-      collection_ref
-    });
+      data
+    }]);
     await this.#push(collection_ref, data.id, data);
     return data;
   }
@@ -2663,7 +3026,7 @@ class LivequeryCore {
       };
     }, old._prev || {});
     await this.config.storage.update(collection_ref, id, { _prev, _updating: true, ...data });
-    const doc = await this.#sync("action", {
+    const doc = await this.#broadcast(collection_ref, "action", [{
       collection_ref,
       id,
       type: "modified",
@@ -2672,7 +3035,7 @@ class LivequeryCore {
         _updating: true,
         ...data
       }
-    });
+    }]);
     await this.#push(collection_ref, id, { ...data, _prev, _updating: true });
     return doc;
   }
@@ -2681,108 +3044,29 @@ class LivequeryCore {
     const is_local_doc = id.startsWith("local:");
     if (!soft || is_local_doc) {
       await this.config.storage.delete(collection_ref, id);
-      await this.#sync("action", {
+      await this.#broadcast(collection_ref, "action", [{
         collection_ref,
         id,
         type: "removed"
-      });
+      }]);
       return;
     }
     await this.config.storage.update(collection_ref, id, { _deleting: true });
-    const doc = await this.#sync("action", {
+    const doc = await this.#broadcast(collection_ref, "action", [{
       collection_ref,
       id,
       type: "modified",
       data: {
         _deleting: true
       }
-    });
-    await this.#push(collection_ref, id, { ...doc, _deleting: true });
+    }]);
+    await this.#push(collection_ref, id, { _deleting: true });
     return doc;
   }
   trigger(action) {
     return from(Object.values(this.config.transporters)).pipe(mergeMap((transporter) => transporter.trigger(action)));
   }
 }
-// src/helpers/filterDocs.ts
-function filterDocs(documents, filters) {
-  if (!filters)
-    return documents;
-  const normalized = filters;
-  return documents.filter((doc) => matchesAllFilters(doc, normalized));
-}
-function matchesAllFilters(doc, filters) {
-  for (const [key, expected] of Object.entries(filters)) {
-    if (key.startsWith(":") || key.endsWith(":sort"))
-      continue;
-    const split = key.split(":");
-    const fieldPath = split[0];
-    if (!fieldPath)
-      continue;
-    const op = split[1] || "eq";
-    const actual = getByPath(doc, fieldPath);
-    if (!matchByOperator(actual, op, expected)) {
-      return false;
-    }
-  }
-  return true;
-}
-function matchByOperator(actual, op, expected) {
-  switch (op) {
-    case "gt":
-      return asNumber(actual) > asNumber(expected);
-    case "gte":
-      return asNumber(actual) >= asNumber(expected);
-    case "lt":
-      return asNumber(actual) < asNumber(expected);
-    case "lte":
-      return asNumber(actual) <= asNumber(expected);
-    case "eq-number":
-      return asNumber(actual) === asNumber(expected);
-    case "in":
-      return Array.isArray(expected) ? expected.includes(actual) : false;
-    case "nin":
-      return Array.isArray(expected) ? !expected.includes(actual) : true;
-    case "include":
-      return Array.isArray(actual) ? actual.includes(expected) : false;
-    case "boolean":
-      return matchBoolean(actual, expected);
-    case "like":
-      return String(actual || "").toLowerCase().includes(String(expected || "").toLowerCase());
-    case "null":
-      return expected === "null-only" ? actual === null || typeof actual === "undefined" : actual !== null && typeof actual !== "undefined";
-    case "eq":
-    default:
-      return actual === expected;
-  }
-}
-function matchBoolean(actual, expected) {
-  switch (expected) {
-    case "true":
-      return actual === true;
-    case "false":
-      return actual === false;
-    case "not-true":
-      return actual !== true;
-    case "not-false":
-      return actual !== false;
-    default:
-      return false;
-  }
-}
-function getByPath(obj, path) {
-  if (!path.includes("."))
-    return obj[path];
-  return path.split(".").reduce((acc, key) => {
-    if (!acc || typeof acc !== "object")
-      return;
-    return acc[key];
-  }, obj);
-}
-function asNumber(value) {
-  return Number(value);
-}
-
 // src/LivequeryMemoryStorage.ts
 class LivequeryMemoryStorage {
   #collections = new Map;
@@ -2879,5 +3163,5 @@ export {
   LivequeryCollection
 };
 
-//# debugId=447AFCFF8503374864756E2164756E21
+//# debugId=E4687FC651D4981264756E2164756E21
 //# sourceMappingURL=index.js.map