@livequery/core 2.0.76 → 2.0.78

package/dist/index.js

@@ -1618,6 +1618,240 @@ function of() {
 function concatMap(project, resultSelector) {
   return isFunction(resultSelector) ? mergeMap(project, resultSelector, 1) : mergeMap(project, 1);
 }
+// node_modules/rxjs/dist/esm5/internal/scheduler/Action.js
+var Action = function(_super) {
+  __extends(Action2, _super);
+  function Action2(scheduler, work) {
+    return _super.call(this) || this;
+  }
+  Action2.prototype.schedule = function(state, delay) {
+    if (delay === undefined) {
+      delay = 0;
+    }
+    return this;
+  };
+  return Action2;
+}(Subscription);
+
+// node_modules/rxjs/dist/esm5/internal/scheduler/intervalProvider.js
+var intervalProvider = {
+  setInterval: function(handler, timeout) {
+    var args = [];
+    for (var _i = 2;_i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    var delegate = intervalProvider.delegate;
+    if (delegate === null || delegate === undefined ? undefined : delegate.setInterval) {
+      return delegate.setInterval.apply(delegate, __spreadArray([handler, timeout], __read(args)));
+    }
+    return setInterval.apply(undefined, __spreadArray([handler, timeout], __read(args)));
+  },
+  clearInterval: function(handle) {
+    var delegate = intervalProvider.delegate;
+    return ((delegate === null || delegate === undefined ? undefined : delegate.clearInterval) || clearInterval)(handle);
+  },
+  delegate: undefined
+};
+
+// node_modules/rxjs/dist/esm5/internal/scheduler/AsyncAction.js
+var AsyncAction = function(_super) {
+  __extends(AsyncAction2, _super);
+  function AsyncAction2(scheduler, work) {
+    var _this = _super.call(this, scheduler, work) || this;
+    _this.scheduler = scheduler;
+    _this.work = work;
+    _this.pending = false;
+    return _this;
+  }
+  AsyncAction2.prototype.schedule = function(state, delay) {
+    var _a;
+    if (delay === undefined) {
+      delay = 0;
+    }
+    if (this.closed) {
+      return this;
+    }
+    this.state = state;
+    var id = this.id;
+    var scheduler = this.scheduler;
+    if (id != null) {
+      this.id = this.recycleAsyncId(scheduler, id, delay);
+    }
+    this.pending = true;
+    this.delay = delay;
+    this.id = (_a = this.id) !== null && _a !== undefined ? _a : this.requestAsyncId(scheduler, this.id, delay);
+    return this;
+  };
+  AsyncAction2.prototype.requestAsyncId = function(scheduler, _id, delay) {
+    if (delay === undefined) {
+      delay = 0;
+    }
+    return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
+  };
+  AsyncAction2.prototype.recycleAsyncId = function(_scheduler, id, delay) {
+    if (delay === undefined) {
+      delay = 0;
+    }
+    if (delay != null && this.delay === delay && this.pending === false) {
+      return id;
+    }
+    if (id != null) {
+      intervalProvider.clearInterval(id);
+    }
+    return;
+  };
+  AsyncAction2.prototype.execute = function(state, delay) {
+    if (this.closed) {
+      return new Error("executing a cancelled action");
+    }
+    this.pending = false;
+    var error = this._execute(state, delay);
+    if (error) {
+      return error;
+    } else if (this.pending === false && this.id != null) {
+      this.id = this.recycleAsyncId(this.scheduler, this.id, null);
+    }
+  };
+  AsyncAction2.prototype._execute = function(state, _delay) {
+    var errored = false;
+    var errorValue;
+    try {
+      this.work(state);
+    } catch (e) {
+      errored = true;
+      errorValue = e ? e : new Error("Scheduled action threw falsy error");
+    }
+    if (errored) {
+      this.unsubscribe();
+      return errorValue;
+    }
+  };
+  AsyncAction2.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      var _a = this, id = _a.id, scheduler = _a.scheduler;
+      var actions = scheduler.actions;
+      this.work = this.state = this.scheduler = null;
+      this.pending = false;
+      arrRemove(actions, this);
+      if (id != null) {
+        this.id = this.recycleAsyncId(scheduler, id, null);
+      }
+      this.delay = null;
+      _super.prototype.unsubscribe.call(this);
+    }
+  };
+  return AsyncAction2;
+}(Action);
+
+// node_modules/rxjs/dist/esm5/internal/scheduler/dateTimestampProvider.js
+var dateTimestampProvider = {
+  now: function() {
+    return (dateTimestampProvider.delegate || Date).now();
+  },
+  delegate: undefined
+};
+
+// node_modules/rxjs/dist/esm5/internal/Scheduler.js
+var Scheduler = function() {
+  function Scheduler2(schedulerActionCtor, now) {
+    if (now === undefined) {
+      now = Scheduler2.now;
+    }
+    this.schedulerActionCtor = schedulerActionCtor;
+    this.now = now;
+  }
+  Scheduler2.prototype.schedule = function(work, delay, state) {
+    if (delay === undefined) {
+      delay = 0;
+    }
+    return new this.schedulerActionCtor(this, work).schedule(state, delay);
+  };
+  Scheduler2.now = dateTimestampProvider.now;
+  return Scheduler2;
+}();
+
+// node_modules/rxjs/dist/esm5/internal/scheduler/AsyncScheduler.js
+var AsyncScheduler = function(_super) {
+  __extends(AsyncScheduler2, _super);
+  function AsyncScheduler2(SchedulerAction, now) {
+    if (now === undefined) {
+      now = Scheduler.now;
+    }
+    var _this = _super.call(this, SchedulerAction, now) || this;
+    _this.actions = [];
+    _this._active = false;
+    return _this;
+  }
+  AsyncScheduler2.prototype.flush = function(action) {
+    var actions = this.actions;
+    if (this._active) {
+      actions.push(action);
+      return;
+    }
+    var error;
+    this._active = true;
+    do {
+      if (error = action.execute(action.state, action.delay)) {
+        break;
+      }
+    } while (action = actions.shift());
+    this._active = false;
+    if (error) {
+      while (action = actions.shift()) {
+        action.unsubscribe();
+      }
+      throw error;
+    }
+  };
+  return AsyncScheduler2;
+}(Scheduler);
+
+// node_modules/rxjs/dist/esm5/internal/scheduler/async.js
+var asyncScheduler = new AsyncScheduler(AsyncAction);
+
+// node_modules/rxjs/dist/esm5/internal/operators/debounceTime.js
+function debounceTime(dueTime, scheduler) {
+  if (scheduler === undefined) {
+    scheduler = asyncScheduler;
+  }
+  return operate(function(source, subscriber) {
+    var activeTask = null;
+    var lastValue = null;
+    var lastTime = null;
+    var emit = function() {
+      if (activeTask) {
+        activeTask.unsubscribe();
+        activeTask = null;
+        var value = lastValue;
+        lastValue = null;
+        subscriber.next(value);
+      }
+    };
+    function emitWhenIdle() {
+      var targetTime = lastTime + dueTime;
+      var now = scheduler.now();
+      if (now < targetTime) {
+        activeTask = this.schedule(undefined, targetTime - now);
+        subscriber.add(activeTask);
+        return;
+      }
+      emit();
+    }
+    source.subscribe(createOperatorSubscriber(subscriber, function(value) {
+      lastValue = value;
+      lastTime = scheduler.now();
+      if (!activeTask) {
+        activeTask = scheduler.schedule(emitWhenIdle, dueTime);
+        subscriber.add(activeTask);
+      }
+    }, function() {
+      emit();
+      subscriber.complete();
+    }, undefined, function() {
+      lastValue = activeTask = null;
+    }));
+  });
+}
 // node_modules/rxjs/dist/esm5/internal/operators/filter.js
 function filter(predicate, thisArg) {
   return operate(function(source, subscriber) {
@@ -1650,14 +1884,6 @@ function pairwise() {
     }));
   });
 }
-// node_modules/rxjs/dist/esm5/internal/scheduler/dateTimestampProvider.js
-var dateTimestampProvider = {
-  now: function() {
-    return (dateTimestampProvider.delegate || Date).now();
-  },
-  delegate: undefined
-};
-
 // node_modules/rxjs/dist/esm5/internal/ReplaySubject.js
 var ReplaySubject = function(_super) {
   __extends(ReplaySubject2, _super);
@@ -1907,6 +2133,7 @@ class LivequeryCollection {
   #keys = new Map;
   #indexes;
   #core;
+  #filters = new Subject;
   ref;
   items;
   summary;
@@ -1937,8 +2164,8 @@ class LivequeryCollection {
       return;
     this.ref = ref;
     this.#core = core;
-    const timer2 = this.options.lazy !== false && setTimeout(() => this.query(this.options.filters || {}));
-    this.#subscription = core.watch(this.ref, this.id).pipe(finalize(() => {
+    const timer2 = this.options.lazy !== true && setTimeout(() => this.query(this.options.filters || {}));
+    this.#subscription = merge(this.options.debounce ? this.#filters.pipe(debounceTime(this.options.debounce), switchMap((filters) => this.query(filters))) : EMPTY, core.watch(this.ref, this.id).pipe(finalize(() => {
       timer2 && clearTimeout(timer2);
     }), tap((event) => {
       event.summary && this.summary.next(event.summary);
@@ -2021,7 +2248,7 @@ class LivequeryCollection {
       chaos && this.items.next(items);
       this.loading.next(null);
       event.paging && this.paging.next(event.paging);
-    })).subscribe();
+    }))).subscribe();
     return this.#subscription;
   }
   async#query(filters) {
@@ -2054,6 +2281,9 @@ class LivequeryCollection {
     this.loading.next("all");
     await this.#query(filters);
   }
+  async debounceQuery(filters) {
+    this.#filters.next(filters);
+  }
   async loadMore() {
     const next = this.paging.value.next;
     if (!next)
@@ -2163,7 +2393,6 @@ class LivequeryCore {
         cache.set(key, query);
         return query;
       }), mergeMap(($) => $), map(({ result }, index) => {
-        result.error && collection.o.error(result.error);
         collection.o.next({
           ...result,
           from: index === 0 ? "query" : "realtime"
@@ -2518,5 +2747,5 @@ export {
   LivequeryCollection
 };
 
-//# debugId=9A74193E4514496764756E2164756E21
+//# debugId=15C911E72000AF4C64756E2164756E21
 //# sourceMappingURL=index.js.map