@signaldb/sync 1.0.1 → 1.1.1

package/dist/index.mjs

@@ -1,19 +1,19 @@
 var E = Object.defineProperty;
-var v = (d, e, t) => e in d ? E(d, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : d[e] = t;
-var u = (d, e, t) => v(d, typeof e != "symbol" ? e + "" : e, t);
-import { isEqual as g, Collection as m, modify as D, randomId as P } from "@signaldb/core";
-function M(d, e, t = {}) {
-  let a, s;
-  const { leading: n = !1, trailing: i = !0 } = t;
-  function o(...l) {
-    const c = n && !a, r = i && !a;
-    return a && clearTimeout(a), a = setTimeout(() => {
-      a = null, i && !c && (s = d.apply(this, l));
-    }, e), c ? s = d.apply(this, l) : r || (s = null), s;
+var $ = (c, e, t) => e in c ? E(c, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : c[e] = t;
+var u = (c, e, t) => $(c, typeof e != "symbol" ? e + "" : e, t);
+import { isEqual as m, Collection as y, modify as N, randomId as D } from "@signaldb/core";
+function x(c, e, t = {}) {
+  let s, n;
+  const { leading: a = !1, trailing: o = !0 } = t;
+  function r(...l) {
+    const i = a && !s, d = o && !s;
+    return s && clearTimeout(s), s = setTimeout(() => {
+      s = null, o && !i && (n = c.apply(this, l));
+    }, e), i ? n = c.apply(this, l) : d || (n = null), n;
   }
-  return o;
+  return r;
 }
-class I {
+class S {
   constructor() {
     u(this, "queue", []);
     u(this, "pendingPromise", !1);
@@ -24,9 +24,9 @@ class I {
    * @returns Promise that resolves when the task is done
    */
   add(e) {
-    return new Promise((t, a) => {
-      this.queue.push(() => e().then(t).catch((s) => {
-        throw a(s), s;
+    return new Promise((t, s) => {
+      this.queue.push(() => e().then(t).catch((n) => {
+        throw s(n), n;
       })), this.dequeue();
     });
   }
@@ -51,71 +51,71 @@ class I {
     }));
   }
 }
-function w(d, e) {
-  const t = [], a = [], s = [], n = new Map(d.map((o) => [o.id, o])), i = new Map(e.map((o) => [o.id, o]));
-  for (const [o, l] of n) {
-    const c = i.get(o);
-    c ? g(c, l) || a.push(c) : s.push(l);
+function g(c, e) {
+  const t = [], s = [], n = [], a = new Map(c.map((r) => [r.id, r])), o = new Map(e.map((r) => [r.id, r]));
+  for (const [r, l] of a) {
+    const i = o.get(r);
+    i ? m(i, l) || s.push(i) : n.push(l);
   }
-  for (const [o, l] of i)
-    n.has(o) || t.push(l);
-  return { added: t, modified: a, removed: s };
+  for (const [r, l] of o)
+    a.has(r) || t.push(l);
+  return { added: t, modified: s, removed: n };
 }
-function O(d, e) {
+function C(c, e) {
   if (e.items != null)
     return e.items;
-  const t = d || [];
-  return e.changes.added.forEach((a) => {
-    const s = t.findIndex((n) => n.id === a.id);
-    s === -1 ? t.push(a) : t[s] = a;
-  }), e.changes.modified.forEach((a) => {
-    const s = t.findIndex((n) => n.id === a.id);
-    s === -1 ? t.push(a) : t[s] = a;
-  }), e.changes.removed.forEach((a) => {
-    const s = t.findIndex((n) => n.id === a.id);
-    s !== -1 && t.splice(s, 1);
+  const t = c || [];
+  return e.changes.added.forEach((s) => {
+    const n = t.findIndex((a) => a.id === s.id);
+    n === -1 ? t.push(s) : t[n] = s;
+  }), e.changes.modified.forEach((s) => {
+    const n = t.findIndex((a) => a.id === s.id);
+    n === -1 ? t.push(s) : t[n] = s;
+  }), e.changes.removed.forEach((s) => {
+    const n = t.findIndex((a) => a.id === s.id);
+    n !== -1 && t.splice(n, 1);
   }), t;
 }
-async function $(d, e) {
-  const t = new m();
+async function P(c, e) {
+  const t = new y();
   t.batch(() => {
-    d.forEach((s) => t.insert(s)), e.forEach((s) => {
-      if (s.type === "remove") {
-        t.removeOne({ id: s.data });
+    c.forEach((n) => t.insert(n)), e.forEach((n) => {
+      if (n.type === "remove") {
+        t.removeOne({ id: n.data });
         return;
       }
-      const n = { id: s.data.id }, i = t.findOne(n);
-      if (s.type === "insert") {
-        i ? t.updateOne(n, { $set: s.data }) : t.insert(s.data);
+      const a = { id: n.data.id }, o = t.findOne(a);
+      if (n.type === "insert") {
+        o ? t.updateOne(a, { $set: n.data }) : t.insert(n.data);
         return;
       }
-      i ? t.updateOne(n, s.data.modifier) : t.insert(D(n, s.data.modifier));
+      o ? t.updateOne(a, n.data.modifier) : t.insert(N(a, n.data.modifier));
     });
   });
-  const a = t.find().fetch();
-  return await t.dispose(), a;
+  const s = t.find().fetch();
+  return await t.dispose(), s;
 }
-function N(d) {
-  return d.added.length > 0 || d.modified.length > 0 || d.removed.length > 0;
+function v(c) {
+  return c.added.length > 0 || c.modified.length > 0 || c.removed.length > 0;
 }
-function x(d, e) {
-  return N(w(d, e));
+function M(c, e) {
+  return v(g(c, e));
 }
-async function S({ changes: d, lastSnapshot: e, data: t, pull: a, push: s, insert: n, update: i, remove: o, batch: l }) {
-  let c = t, r = e || [], p = O(e, c);
-  if (d.length > 0) {
-    const h = await $(r, d);
-    if (x(r, h)) {
-      const y = await $(p, d), C = w(p, y);
-      N(C) && (await s(C), c = await a(), p = O(p, c)), r = h;
+async function I({ changes: c, lastSnapshot: e, data: t, pull: s, push: n, insert: a, update: o, remove: r, batch: l }) {
+  let i = t, d = e || [], f = C(e, i);
+  if (c.length > 0) {
+    const p = await P(d, c);
+    if (M(d, p)) {
+      const O = await P(f, c), w = g(f, O);
+      v(w) && (await n(w), i = await s(), f = C(f, i)), d = p;
     }
   }
-  const f = c.changes == null ? w(r, c.items) : c.changes;
+  const h = i.changes == null ? g(d, i.items) : i.changes;
   return l(() => {
-    f.added.forEach((h) => n(h)), f.modified.forEach((h) => i(h.id, { $set: h })), f.removed.forEach((h) => o(h.id));
-  }), p;
+    h.added.forEach((p) => a(p)), h.modified.forEach((p) => o(p.id, { $set: p })), h.removed.forEach((p) => r(p.id));
+  }), f;
 }
-class T {
+class q {
   /**
    * @param options Collection options
    * @param options.pull Function to pull data from remote source.
@@ -136,48 +136,33 @@ class T {
     u(this, "syncQueues", /* @__PURE__ */ new Map());
     u(this, "persistenceReady");
     u(this, "isDisposed", !1);
-    u(this, "instanceId", P());
+    u(this, "instanceId", D());
     u(this, "id");
-    u(this, "deboucedPush", M((e) => {
+    u(this, "deboucedPush", x((e) => {
       this.pushChanges(e).catch(() => {
       });
     }, 100));
-    this.options = e, this.id = this.options.id || "default-sync-manager";
-    const { reactivity: t } = this.options, a = this.createPersistenceAdapter("changes"), s = this.createPersistenceAdapter("snapshots"), n = this.createPersistenceAdapter("sync-operations");
-    this.changes = new m({
+    this.options = {
+      autostart: !0,
+      ...e
+    }, this.id = this.options.id || "default-sync-manager";
+    const { reactivity: t } = this.options, s = this.createPersistenceAdapter("changes"), n = this.createPersistenceAdapter("snapshots"), a = this.createPersistenceAdapter("sync-operations");
+    this.changes = new y({
       name: `${this.options.id}-changes`,
-      persistence: a == null ? void 0 : a.adapter,
+      persistence: s == null ? void 0 : s.adapter,
       reactivity: t
-    }), this.snapshots = new m({
+    }), this.snapshots = new y({
       name: `${this.options.id}-snapshots`,
-      persistence: s == null ? void 0 : s.adapter,
+      persistence: n == null ? void 0 : n.adapter,
       reactivity: t
-    }), this.syncOperations = new m({
+    }), this.syncOperations = new y({
       name: `${this.options.id}-sync-operations`,
-      persistence: n == null ? void 0 : n.adapter,
+      persistence: a == null ? void 0 : a.adapter,
       reactivity: t
-    }), this.changes.on("persistence.error", (i) => a == null ? void 0 : a.handler(i)), this.snapshots.on("persistence.error", (i) => s == null ? void 0 : s.handler(i)), this.syncOperations.on("persistence.error", (i) => n == null ? void 0 : n.handler(i)), this.persistenceReady = Promise.all([
-      new Promise((i, o) => {
-        if (!a) {
-          i();
-          return;
-        }
-        this.syncOperations.once("persistence.error", o), this.syncOperations.once("persistence.init", i);
-      }),
-      new Promise((i, o) => {
-        if (!s) {
-          i();
-          return;
-        }
-        this.changes.once("persistence.error", o), this.changes.once("persistence.init", i);
-      }),
-      new Promise((i, o) => {
-        if (!n) {
-          i();
-          return;
-        }
-        this.snapshots.once("persistence.error", o), this.snapshots.once("persistence.init", i);
-      })
+    }), this.changes.on("persistence.error", (o) => s == null ? void 0 : s.handler(o)), this.snapshots.on("persistence.error", (o) => n == null ? void 0 : n.handler(o)), this.syncOperations.on("persistence.error", (o) => a == null ? void 0 : a.handler(o)), this.persistenceReady = Promise.all([
+      this.syncOperations.isReady(),
+      this.changes.isReady(),
+      this.snapshots.isReady()
     ]).then(() => {
     }), this.changes.setMaxListeners(1e3), this.snapshots.setMaxListeners(1e3), this.syncOperations.setMaxListeners(1e3);
   }
@@ -187,14 +172,14 @@ class T {
     let t = () => {
     };
     return {
-      adapter: this.options.persistenceAdapter(`${this.id}-${e}`, (s) => {
-        t = s;
+      adapter: this.options.persistenceAdapter(`${this.id}-${e}`, (n) => {
+        t = n;
       }),
-      handler: (s) => t(s)
+      handler: (n) => t(n)
     };
   }
   getSyncQueue(e) {
-    return this.syncQueues.get(e) == null && this.syncQueues.set(e, new I()), this.syncQueues.get(e);
+    return this.syncQueues.get(e) == null && this.syncQueues.set(e, new S()), this.syncQueues.get(e);
   }
   /**
    * Clears all internal data structures
@@ -208,11 +193,22 @@ class T {
   }
   /**
    * Gets a collection with it's options by name
+   * @deprecated Use getCollectionProperties instead.
    * @param name Name of the collection
    * @throws Will throw an error if the name wasn't found
    * @returns Tuple of collection and options
    */
   getCollection(e) {
+    const { collection: t, options: s } = this.getCollectionProperties(e);
+    return [t, s];
+  }
+  /**
+   * Gets collection options by name
+   * @param name Name of the collection
+   * @throws Will throw an error if the name wasn't found
+   * @returns An object of all properties of the collection
+   */
+  getCollectionProperties(e) {
     const t = this.collections.get(e);
     if (t == null)
       throw new Error(`Collection with id '${e}' not found`);
@@ -227,85 +223,139 @@ class T {
   addCollection(e, t) {
     if (this.isDisposed)
       throw new Error("SyncManager is disposed");
-    this.options.registerRemoteChange && this.options.registerRemoteChange(t, async (n) => {
-      if (n == null)
-        await this.sync(t.name);
-      else {
-        const i = Date.now(), o = this.syncOperations.insert({
-          start: i,
-          collectionName: t.name,
-          instanceId: this.instanceId,
-          status: "active"
-        });
-        await this.syncWithData(t.name, n).then(() => {
-          this.syncOperations.removeMany({
-            id: { $ne: o },
-            collectionName: t.name,
-            $or: [
-              { end: { $lte: i } },
-              { status: "active" }
-            ]
-          }), this.syncOperations.updateOne({ id: o }, {
-            $set: { status: "done", end: Date.now() }
-          });
-        }).catch((l) => {
-          throw this.options.onError && this.options.onError(t, l), this.syncOperations.updateOne({ id: o }, {
-            $set: { status: "error", end: Date.now(), error: l.stack || l.message }
-          }), l;
-        });
-      }
-    }), this.collections.set(t.name, [e, t]);
-    const a = (n) => {
-      for (const i of this.remoteChanges)
-        if (g(i, n))
+    this.collections.set(t.name, {
+      collection: e,
+      options: t,
+      readyPromise: e.isReady(),
+      syncPaused: !0
+      // always start paused as the autostart will start it
+    });
+    const s = (a) => {
+      for (const o of this.remoteChanges)
+        if (m(o, a))
           return !0;
       return !1;
-    }, s = (n) => {
-      for (let i = 0; i < this.remoteChanges.length; i += 1)
-        if (g(this.remoteChanges[i], n)) {
-          this.remoteChanges.splice(i, 1);
+    }, n = (a) => {
+      for (let o = 0; o < this.remoteChanges.length; o += 1)
+        if (m(this.remoteChanges[o], a)) {
+          this.remoteChanges.splice(o, 1);
           return;
         }
     };
-    e.on("added", (n) => {
-      if (a({ collectionName: t.name, type: "insert", data: n })) {
-        s({ collectionName: t.name, type: "insert", data: n });
+    e.on("added", (a) => {
+      if (s({ collectionName: t.name, type: "insert", data: a })) {
+        n({ collectionName: t.name, type: "insert", data: a });
         return;
       }
       this.changes.insert({
         collectionName: t.name,
         time: Date.now(),
         type: "insert",
-        data: n
-      }), this.schedulePush(t.name);
-    }), e.on("changed", ({ id: n }, i) => {
-      const o = { id: n, modifier: i };
-      if (a({ collectionName: t.name, type: "update", data: o })) {
-        s({ collectionName: t.name, type: "update", data: o });
+        data: a
+      }), !this.getCollectionProperties(t.name).syncPaused && this.schedulePush(t.name);
+    }), e.on("changed", ({ id: a }, o) => {
+      const r = { id: a, modifier: o };
+      if (s({ collectionName: t.name, type: "update", data: r })) {
+        n({ collectionName: t.name, type: "update", data: r });
         return;
       }
       this.changes.insert({
         collectionName: t.name,
         time: Date.now(),
         type: "update",
-        data: o
-      }), this.schedulePush(t.name);
-    }), e.on("removed", ({ id: n }) => {
-      if (a({ collectionName: t.name, type: "remove", data: n })) {
-        s({ collectionName: t.name, type: "remove", data: n });
+        data: r
+      }), !this.getCollectionProperties(t.name).syncPaused && this.schedulePush(t.name);
+    }), e.on("removed", ({ id: a }) => {
+      if (s({ collectionName: t.name, type: "remove", data: a })) {
+        n({ collectionName: t.name, type: "remove", data: a });
         return;
       }
       this.changes.insert({
         collectionName: t.name,
         time: Date.now(),
         type: "remove",
-        data: n
-      }), this.schedulePush(t.name);
+        data: a
+      }), !this.getCollectionProperties(t.name).syncPaused && this.schedulePush(t.name);
+    }), this.options.autostart && this.startSync(t.name).catch((a) => {
+      this.options.onError && this.options.onError(this.getCollectionProperties(t.name).options, a);
     });
   }
   schedulePush(e) {
     this.deboucedPush(e);
   }
+  /**
+   * Setup all collections to be synced with remote changes
+   * and enable automatic pushing changes to the remote source.
+   */
+  async startAll() {
+    await Promise.all([...this.collections.keys()].map((e) => this.startSync(e)));
+  }
+  /**
+   * Setup a collection to be synced with remote changes
+   * and enable automatic pushing changes to the remote source.
+   * @param name Name of the collection
+   */
+  async startSync(e) {
+    const t = this.getCollectionProperties(e);
+    if (!t.syncPaused)
+      return;
+    this.schedulePush(e);
+    const s = this.options.registerRemoteChange ? await this.options.registerRemoteChange(t.options, async (n) => {
+      if (n == null)
+        await this.sync(e);
+      else {
+        const a = Date.now(), o = this.syncOperations.insert({
+          start: a,
+          collectionName: e,
+          instanceId: this.instanceId,
+          status: "active"
+        });
+        await this.syncWithData(e, n).then(() => {
+          this.syncOperations.removeMany({
+            id: { $ne: o },
+            collectionName: e,
+            $or: [
+              { end: { $lte: a } },
+              { status: "active" }
+            ]
+          }), this.syncOperations.updateOne({ id: o }, {
+            $set: { status: "done", end: Date.now() }
+          });
+        }).catch((r) => {
+          throw this.options.onError && this.options.onError(this.getCollectionProperties(e).options, r), this.syncOperations.updateOne({ id: o }, {
+            $set: { status: "error", end: Date.now(), error: r.stack || r.message }
+          }), r;
+        });
+      }
+    }) : void 0;
+    this.collections.set(e, {
+      ...t,
+      syncPaused: !1,
+      cleanupFunction: s
+    });
+  }
+  /**
+   * Pauses the sync process for all collections.
+   * This means that the collections will not be synced with remote changes
+   * and changes will not automatically be pushed to the remote source.
+   */
+  async pauseAll() {
+    await Promise.all([...this.collections.keys()].map((e) => this.pauseSync(e)));
+  }
+  /**
+   * Pauses the sync process for a collection.
+   * This means that the collection will not be synced with remote changes
+   * and changes will not automatically be pushed to the remote source.
+   * @param name Name of the collection
+   */
+  async pauseSync(e) {
+    const t = this.getCollectionProperties(e);
+    t.syncPaused || (t.cleanupFunction && await t.cleanupFunction(), this.collections.set(e, {
+      ...t,
+      cleanupFunction: void 0,
+      syncPaused: !0
+    }));
+  }
   /**
    * Starts the sync process for all collections
    */
@@ -313,8 +363,8 @@ class T {
     if (this.isDisposed)
       throw new Error("SyncManager is disposed");
     const e = [];
-    if (await Promise.all([...this.collections.keys()].map((t) => this.sync(t).catch((a) => {
-      e.push({ id: t, error: a });
+    if (await Promise.all([...this.collections.keys()].map((t) => this.sync(t).catch((s) => {
+      e.push({ id: t, error: s });
     }))), e.length > 0)
       throw new Error(`Error while syncing collections:
 ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
@@ -350,48 +400,61 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
     if (this.isDisposed)
       throw new Error("SyncManager is disposed");
     await this.isReady();
-    const s = this.getCollection(e)[1], n = this.syncOperations.find({
+    const { options: s, readyPromise: n } = this.getCollectionProperties(e);
+    await n;
+    const a = this.syncOperations.find({
       collectionName: e,
       instanceId: this.instanceId,
       status: "active"
-    }).count() > 0, i = Date.now();
-    let o = null;
-    await new Promise((c) => {
-      setTimeout(c, 0);
+    }, {
+      reactive: !1
+    }).count() > 0, o = Date.now();
+    let r = null;
+    await new Promise((i) => {
+      setTimeout(i, 0);
     });
     const l = async () => {
-      const c = this.syncOperations.findOne({ collectionName: e, status: "done" }, { sort: { end: -1 } });
+      const i = this.syncOperations.findOne({
+        collectionName: e,
+        status: "done"
+      }, {
+        sort: { end: -1 },
+        reactive: !1
+      });
       if (t != null && t.onlyWithChanges && this.changes.find({
         collectionName: e,
         $and: [
-          { time: { $lte: i } }
+          { time: { $lte: o } }
         ]
-      }, { sort: { time: 1 } }).count() === 0)
+      }, {
+        sort: { time: 1 },
+        reactive: !1
+      }).count() === 0)
         return;
-      n || (o = this.syncOperations.insert({
-        start: i,
+      a || (r = this.syncOperations.insert({
+        start: o,
         collectionName: e,
         instanceId: this.instanceId,
         status: "active"
       }));
-      const r = await this.options.pull(s, {
-        lastFinishedSyncStart: c == null ? void 0 : c.start,
-        lastFinishedSyncEnd: c == null ? void 0 : c.end
+      const d = await this.options.pull(s, {
+        lastFinishedSyncStart: i == null ? void 0 : i.start,
+        lastFinishedSyncEnd: i == null ? void 0 : i.end
       });
-      await this.syncWithData(e, r);
+      await this.syncWithData(e, d);
     };
-    await (t != null && t.force ? l() : this.getSyncQueue(e).add(l)).catch((c) => {
-      throw o != null && (this.options.onError && this.options.onError(s, c), this.syncOperations.updateOne({ id: o }, {
-        $set: { status: "error", end: Date.now(), error: c.stack || c.message }
-      })), c;
-    }), o != null && (this.syncOperations.removeMany({
-      id: { $ne: o },
+    await (t != null && t.force ? l() : this.getSyncQueue(e).add(l)).catch((i) => {
+      throw r != null && (this.options.onError && this.options.onError(s, i), this.syncOperations.updateOne({ id: r }, {
+        $set: { status: "error", end: Date.now(), error: i.stack || i.message }
+      })), i;
+    }), r != null && (this.syncOperations.removeMany({
+      id: { $ne: r },
       collectionName: e,
       $or: [
-        { end: { $lte: i } },
+        { end: { $lte: o } },
         { status: "active" }
       ]
-    }), this.syncOperations.updateOne({ id: o }, {
+    }), this.syncOperations.updateOne({ id: r }, {
       $set: { status: "done", end: Date.now() }
     }));
   }
@@ -405,77 +468,100 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
     });
   }
   async syncWithData(e, t) {
-    const a = this.getCollection(e), [s, n] = a, i = Date.now(), o = this.syncOperations.findOne({ collectionName: e, status: "done" }, { sort: { end: -1 } }), l = this.snapshots.findOne({ collectionName: e }, { sort: { time: -1 } }), c = this.changes.find({
+    const { collection: s, options: n } = this.getCollectionProperties(e), a = Date.now(), o = this.syncOperations.findOne({
+      collectionName: e,
+      status: "done"
+    }, {
+      sort: { end: -1 },
+      reactive: !1
+    }), r = this.snapshots.findOne({
+      collectionName: e
+    }, {
+      sort: { time: -1 },
+      reactive: !1
+    }), l = this.changes.find({
       collectionName: e,
       $and: [
-        { time: { $lte: i } }
+        { time: { $lte: a } }
       ]
-    }, { sort: { time: 1 } }).fetch();
-    await S({
-      changes: c,
-      lastSnapshot: l == null ? void 0 : l.items,
+    }, {
+      sort: { time: 1 },
+      reactive: !1
+    }).fetch();
+    await I({
+      changes: l,
+      lastSnapshot: r == null ? void 0 : r.items,
       data: t,
       pull: () => this.options.pull(n, {
         lastFinishedSyncStart: o == null ? void 0 : o.start,
         lastFinishedSyncEnd: o == null ? void 0 : o.end
       }),
-      push: (r) => this.options.push(n, { changes: r }),
-      insert: (r) => {
-        if (r.id && s.findOne({ id: r.id })) {
+      push: (i) => this.options.push(n, { changes: i }),
+      insert: (i) => {
+        if (i.id && !!s.findOne({
+          id: i.id
+        }, { reactive: !1 })) {
           this.remoteChanges.push({
             collectionName: e,
             type: "update",
-            data: { id: r.id, modifier: { $set: r } }
-          }), s.updateOne({ id: r.id }, { $set: r });
+            data: { id: i.id, modifier: { $set: i } }
+          }), s.updateOne({ id: i.id }, { $set: i });
           return;
         }
         this.remoteChanges.push({
           collectionName: e,
           type: "insert",
-          data: r
-        }), s.insert(r);
+          data: i
+        }), s.insert(i);
       },
-      update: (r, p) => {
-        if (r && !s.findOne({ id: r })) {
-          const f = { ...p.$set, id: r };
+      update: (i, d) => {
+        if (i && !s.findOne({
+          id: i
+        }, { reactive: !1 })) {
+          const h = { ...d.$set, id: i };
           this.remoteChanges.push({
             collectionName: e,
             type: "insert",
-            data: f
-          }), s.insert(f);
+            data: h
+          }), s.insert(h);
           return;
         }
         this.remoteChanges.push({
           collectionName: e,
           type: "update",
-          data: { id: r, modifier: p }
-        }), s.updateOne({ id: r }, p);
+          data: { id: i, modifier: d }
+        }), s.updateOne({ id: i }, d);
       },
-      remove: (r) => {
-        s.findOne({ id: r }) && (this.remoteChanges.push({
+      remove: (i) => {
+        s.findOne({
+          id: i
+        }, { reactive: !1 }) && (this.remoteChanges.push({
           collectionName: e,
           type: "remove",
-          data: r
-        }), s.removeOne({ id: r }));
+          data: i
+        }), s.removeOne({ id: i }));
       },
-      batch: (r) => {
+      batch: (i) => {
         s.batch(() => {
-          r();
+          i();
         });
       }
-    }).then(async (r) => {
-      if (this.snapshots.removeMany({ collectionName: e, time: { $lte: i } }), this.changes.removeMany({
+    }).then(async (i) => {
+      if (this.snapshots.removeMany({
         collectionName: e,
-        id: { $in: c.map((h) => h.id) }
+        time: { $lte: a }
+      }), this.changes.removeMany({
+        collectionName: e,
+        id: { $in: l.map((h) => h.id) }
       }), this.snapshots.insert({
-        time: i,
+        time: a,
         collectionName: e,
-        items: r
+        items: i
       }), await new Promise((h) => {
         setTimeout(h, 0);
       }), this.changes.find({
         collectionName: e
-      }).count() > 0) {
+      }, { reactive: !1 }).count() > 0) {
         await this.sync(e, {
           force: !0,
           onlyWithChanges: !0
@@ -483,13 +569,19 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
         return;
       }
       const f = s.find({
-        id: { $nin: r.map((h) => h.id) }
+        id: { $nin: i.map((h) => h.id) }
+      }, {
+        reactive: !1
       }).map((h) => h.id);
       s.batch(() => {
-        r.forEach((h) => {
-          const y = !!s.findOne({ id: h.id });
+        i.forEach((h) => {
+          const p = !!s.findOne({
+            id: h.id
+          }, {
+            reactive: !1
+          });
           /* istanbul ignore else -- @preserve */
-          y ? (this.remoteChanges.push({
+          p ? (this.remoteChanges.push({
             collectionName: e,
             type: "update",
             data: { id: h.id, modifier: { $set: h } }
@@ -506,6 +598,6 @@ ${e.map((t) => `${t.id}: ${t.error.message}`).join(`
   }
 }
 export {
-  T as SyncManager
+  q as SyncManager
 };
 //# sourceMappingURL=index.mjs.map