@electric-sql/client 0.4.1 → 0.5.1

package/dist/index.legacy-esm.js

@@ -1,7 +1,12 @@
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __spreadValues = (a, b) => {
   for (var prop in b || (b = {}))
@@ -14,6 +19,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
@@ -26,6 +32,11 @@ var __objRest = (source, exclude) => {
     }
   return target;
 };
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
 // src/parser.ts
 var parseNumber = (value) => Number(value);
@@ -146,34 +157,50 @@ function isChangeMessage(message) {
 function isControlMessage(message) {
   return !isChangeMessage(message);
 }
+function isUpToDateMessage(message) {
+  return isControlMessage(message) && message.headers.control === `up-to-date`;
+}
 
-// src/client.ts
-var BackoffDefaults = {
-  initialDelay: 100,
-  maxDelay: 1e4,
-  multiplier: 1.3
+// src/queue.ts
+function isThenable(value) {
+  return !!value && typeof value === `object` && `then` in value && typeof value.then === `function`;
+}
+var _processingChain;
+var AsyncProcessingQueue = class {
+  constructor() {
+    __privateAdd(this, _processingChain);
+  }
+  process(callback) {
+    __privateSet(this, _processingChain, isThenable(__privateGet(this, _processingChain)) ? __privateGet(this, _processingChain).then(callback) : callback());
+    return __privateGet(this, _processingChain);
+  }
+  async waitForProcessing() {
+    let currentChain;
+    do {
+      currentChain = __privateGet(this, _processingChain);
+      await currentChain;
+    } while (__privateGet(this, _processingChain) !== currentChain);
+  }
 };
+_processingChain = new WeakMap();
+var _queue, _callback;
 var MessageProcessor = class {
   constructor(callback) {
-    this.messageQueue = [];
-    this.isProcessing = false;
-    this.callback = callback;
+    __privateAdd(this, _queue, new AsyncProcessingQueue());
+    __privateAdd(this, _callback);
+    __privateSet(this, _callback, callback);
   }
   process(messages) {
-    this.messageQueue.push(messages);
-    if (!this.isProcessing) {
-      this.processQueue();
-    }
+    __privateGet(this, _queue).process(() => __privateGet(this, _callback).call(this, messages));
   }
-  async processQueue() {
-    this.isProcessing = true;
-    while (this.messageQueue.length > 0) {
-      const messages = this.messageQueue.shift();
-      await this.callback(messages);
-    }
-    this.isProcessing = false;
+  async waitForProcessing() {
+    await __privateGet(this, _queue).waitForProcessing();
   }
 };
+_queue = new WeakMap();
+_callback = new WeakMap();
+
+// src/error.ts
 var FetchError = class _FetchError extends Error {
   constructor(status, text, json, headers, url, message) {
     super(
@@ -200,312 +227,412 @@ var FetchError = class _FetchError extends Error {
     return new _FetchError(status, text, json, headers, url);
   }
 };
+var FetchBackoffAbortError = class extends Error {
+  constructor() {
+    super(`Fetch with backoff aborted`);
+  }
+};
+
+// src/fetch.ts
+var BackoffDefaults = {
+  initialDelay: 100,
+  maxDelay: 1e4,
+  multiplier: 1.3
+};
+function createFetchWithBackoff(fetchClient, backoffOptions = BackoffDefaults) {
+  const {
+    initialDelay,
+    maxDelay,
+    multiplier,
+    debug = false,
+    onFailedAttempt
+  } = backoffOptions;
+  return async (...args) => {
+    var _a;
+    const url = args[0];
+    const options = args[1];
+    let delay = initialDelay;
+    let attempt = 0;
+    while (true) {
+      try {
+        const result = await fetchClient(...args);
+        if (result.ok) return result;
+        else throw await FetchError.fromResponse(result, url.toString());
+      } catch (e) {
+        onFailedAttempt == null ? void 0 : onFailedAttempt();
+        if ((_a = options == null ? void 0 : options.signal) == null ? void 0 : _a.aborted) {
+          throw new FetchBackoffAbortError();
+        } else if (e instanceof FetchError && e.status >= 400 && e.status < 500) {
+          throw e;
+        } else {
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          delay = Math.min(delay * multiplier, maxDelay);
+          if (debug) {
+            attempt++;
+            console.log(`Retry attempt #${attempt} after ${delay}ms`);
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/constants.ts
+var SHAPE_ID_HEADER = `x-electric-shape-id`;
+var CHUNK_LAST_OFFSET_HEADER = `x-electric-chunk-last-offset`;
+var SHAPE_SCHEMA_HEADER = `x-electric-schema`;
+var SHAPE_ID_QUERY_PARAM = `shape_id`;
+var OFFSET_QUERY_PARAM = `offset`;
+var WHERE_QUERY_PARAM = `where`;
+var LIVE_QUERY_PARAM = `live`;
+
+// src/client.ts
+var _fetchClient, _messageParser, _subscribers, _upToDateSubscribers, _lastOffset, _lastSyncedAt, _isUpToDate, _connected, _shapeId, _schema, _ShapeStream_instances, publish_fn, sendErrorToSubscribers_fn, notifyUpToDateSubscribers_fn, sendErrorToUpToDateSubscribers_fn, reset_fn;
 var ShapeStream = class {
   constructor(options) {
-    this.subscribers = /* @__PURE__ */ new Map();
-    this.upToDateSubscribers = /* @__PURE__ */ new Map();
+    __privateAdd(this, _ShapeStream_instances);
+    __privateAdd(this, _fetchClient);
+    __privateAdd(this, _messageParser);
+    __privateAdd(this, _subscribers, /* @__PURE__ */ new Map());
+    __privateAdd(this, _upToDateSubscribers, /* @__PURE__ */ new Map());
+    __privateAdd(this, _lastOffset);
+    __privateAdd(this, _lastSyncedAt);
     // unix time
-    this.isUpToDate = false;
-    this.connected = false;
+    __privateAdd(this, _isUpToDate, false);
+    __privateAdd(this, _connected, false);
+    __privateAdd(this, _shapeId);
+    __privateAdd(this, _schema);
     var _a, _b, _c;
-    this.validateOptions(options);
+    validateOptions(options);
     this.options = __spreadValues({ subscribe: true }, options);
-    this.lastOffset = (_a = this.options.offset) != null ? _a : `-1`;
-    this.shapeId = this.options.shapeId;
-    this.messageParser = new MessageParser(options.parser);
-    this.backoffOptions = (_b = options.backoffOptions) != null ? _b : BackoffDefaults;
-    this.fetchClient = (_c = options.fetchClient) != null ? _c : (...args) => fetch(...args);
+    __privateSet(this, _lastOffset, (_a = this.options.offset) != null ? _a : `-1`);
+    __privateSet(this, _shapeId, this.options.shapeId);
+    __privateSet(this, _messageParser, new MessageParser(options.parser));
+    __privateSet(this, _fetchClient, createFetchWithBackoff(
+      (_b = options.fetchClient) != null ? _b : (...args) => fetch(...args),
+      __spreadProps(__spreadValues({}, (_c = options.backoffOptions) != null ? _c : BackoffDefaults), {
+        onFailedAttempt: () => {
+          var _a2, _b2;
+          __privateSet(this, _connected, false);
+          (_b2 = (_a2 = options.backoffOptions) == null ? void 0 : _a2.onFailedAttempt) == null ? void 0 : _b2.call(_a2);
+        }
+      })
+    ));
     this.start();
   }
+  get shapeId() {
+    return __privateGet(this, _shapeId);
+  }
+  get isUpToDate() {
+    return __privateGet(this, _isUpToDate);
+  }
   async start() {
     var _a;
-    this.isUpToDate = false;
+    __privateSet(this, _isUpToDate, false);
     const { url, where, signal } = this.options;
     try {
-      while (!(signal == null ? void 0 : signal.aborted) && !this.isUpToDate || this.options.subscribe) {
+      while (!(signal == null ? void 0 : signal.aborted) && !__privateGet(this, _isUpToDate) || this.options.subscribe) {
         const fetchUrl = new URL(url);
-        if (where) fetchUrl.searchParams.set(`where`, where);
-        fetchUrl.searchParams.set(`offset`, this.lastOffset);
-        if (this.isUpToDate) {
-          fetchUrl.searchParams.set(`live`, `true`);
+        if (where) fetchUrl.searchParams.set(WHERE_QUERY_PARAM, where);
+        fetchUrl.searchParams.set(OFFSET_QUERY_PARAM, __privateGet(this, _lastOffset));
+        if (__privateGet(this, _isUpToDate)) {
+          fetchUrl.searchParams.set(LIVE_QUERY_PARAM, `true`);
         }
-        if (this.shapeId) {
-          fetchUrl.searchParams.set(`shape_id`, this.shapeId);
+        if (__privateGet(this, _shapeId)) {
+          fetchUrl.searchParams.set(SHAPE_ID_QUERY_PARAM, __privateGet(this, _shapeId));
         }
         let response;
         try {
-          const maybeResponse = await this.fetchWithBackoff(fetchUrl);
-          if (maybeResponse) response = maybeResponse;
-          else break;
+          response = await __privateGet(this, _fetchClient).call(this, fetchUrl.toString(), { signal });
+          __privateSet(this, _connected, true);
         } catch (e) {
+          if (e instanceof FetchBackoffAbortError) break;
           if (!(e instanceof FetchError)) throw e;
           if (e.status == 400) {
-            this.reset();
-            this.publish(e.json);
+            __privateMethod(this, _ShapeStream_instances, reset_fn).call(this);
+            __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, e.json);
             continue;
           } else if (e.status == 409) {
-            const newShapeId = e.headers[`x-electric-shape-id`];
-            this.reset(newShapeId);
-            this.publish(e.json);
+            const newShapeId = e.headers[SHAPE_ID_HEADER];
+            __privateMethod(this, _ShapeStream_instances, reset_fn).call(this, newShapeId);
+            __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, e.json);
             continue;
           } else if (e.status >= 400 && e.status < 500) {
-            this.sendErrorToUpToDateSubscribers(e);
-            this.sendErrorToSubscribers(e);
+            __privateMethod(this, _ShapeStream_instances, sendErrorToUpToDateSubscribers_fn).call(this, e);
+            __privateMethod(this, _ShapeStream_instances, sendErrorToSubscribers_fn).call(this, e);
             throw e;
           }
         }
         const { headers, status } = response;
-        const shapeId = headers.get(`X-Electric-Shape-Id`);
+        const shapeId = headers.get(SHAPE_ID_HEADER);
         if (shapeId) {
-          this.shapeId = shapeId;
+          __privateSet(this, _shapeId, shapeId);
         }
-        const lastOffset = headers.get(`X-Electric-Chunk-Last-Offset`);
+        const lastOffset = headers.get(CHUNK_LAST_OFFSET_HEADER);
         if (lastOffset) {
-          this.lastOffset = lastOffset;
+          __privateSet(this, _lastOffset, lastOffset);
         }
         const getSchema = () => {
-          const schemaHeader = headers.get(`X-Electric-Schema`);
+          const schemaHeader = headers.get(SHAPE_SCHEMA_HEADER);
           return schemaHeader ? JSON.parse(schemaHeader) : {};
         };
-        this.schema = (_a = this.schema) != null ? _a : getSchema();
+        __privateSet(this, _schema, (_a = __privateGet(this, _schema)) != null ? _a : getSchema());
         const messages = status === 204 ? `[]` : await response.text();
         if (status === 204) {
-          this.lastSyncedAt = Date.now();
+          __privateSet(this, _lastSyncedAt, Date.now());
         }
-        const batch = this.messageParser.parse(messages, this.schema);
+        const batch = __privateGet(this, _messageParser).parse(messages, __privateGet(this, _schema));
         if (batch.length > 0) {
           const lastMessage = batch[batch.length - 1];
-          if (isControlMessage(lastMessage) && lastMessage.headers.control === `up-to-date`) {
-            this.lastSyncedAt = Date.now();
-            if (!this.isUpToDate) {
-              this.isUpToDate = true;
-              this.notifyUpToDateSubscribers();
+          if (isUpToDateMessage(lastMessage)) {
+            __privateSet(this, _lastSyncedAt, Date.now());
+            if (!__privateGet(this, _isUpToDate)) {
+              __privateSet(this, _isUpToDate, true);
+              __privateMethod(this, _ShapeStream_instances, notifyUpToDateSubscribers_fn).call(this);
             }
           }
-          this.publish(batch);
+          __privateMethod(this, _ShapeStream_instances, publish_fn).call(this, batch);
         }
       }
     } finally {
-      this.connected = false;
+      __privateSet(this, _connected, false);
     }
   }
   subscribe(callback, onError) {
     const subscriptionId = Math.random();
     const subscriber = new MessageProcessor(callback);
-    this.subscribers.set(subscriptionId, [subscriber, onError]);
+    __privateGet(this, _subscribers).set(subscriptionId, [subscriber, onError]);
     return () => {
-      this.subscribers.delete(subscriptionId);
+      __privateGet(this, _subscribers).delete(subscriptionId);
     };
   }
   unsubscribeAll() {
-    this.subscribers.clear();
-  }
-  publish(messages) {
-    this.subscribers.forEach(([subscriber, _]) => {
-      subscriber.process(messages);
-    });
-  }
-  sendErrorToSubscribers(error) {
-    this.subscribers.forEach(([_, errorFn]) => {
-      errorFn == null ? void 0 : errorFn(error);
-    });
+    __privateGet(this, _subscribers).clear();
   }
   subscribeOnceToUpToDate(callback, error) {
     const subscriptionId = Math.random();
-    this.upToDateSubscribers.set(subscriptionId, [callback, error]);
+    __privateGet(this, _upToDateSubscribers).set(subscriptionId, [callback, error]);
     return () => {
-      this.upToDateSubscribers.delete(subscriptionId);
+      __privateGet(this, _upToDateSubscribers).delete(subscriptionId);
     };
   }
   unsubscribeAllUpToDateSubscribers() {
-    this.upToDateSubscribers.clear();
+    __privateGet(this, _upToDateSubscribers).clear();
+  }
+  /** Unix time at which we last synced. Undefined when `isLoading` is true. */
+  lastSyncedAt() {
+    return __privateGet(this, _lastSyncedAt);
   }
   /** Time elapsed since last sync (in ms). Infinity if we did not yet sync. */
   lastSynced() {
-    if (this.lastSyncedAt === void 0) return Infinity;
-    return Date.now() - this.lastSyncedAt;
+    if (__privateGet(this, _lastSyncedAt) === void 0) return Infinity;
+    return Date.now() - __privateGet(this, _lastSyncedAt);
   }
+  /** Indicates if we are connected to the Electric sync service. */
   isConnected() {
-    return this.connected;
+    return __privateGet(this, _connected);
   }
-  notifyUpToDateSubscribers() {
-    this.upToDateSubscribers.forEach(([callback]) => {
-      callback();
-    });
+  /** True during initial fetch. False afterwise.  */
+  isLoading() {
+    return !this.isUpToDate;
   }
-  sendErrorToUpToDateSubscribers(error) {
-    this.upToDateSubscribers.forEach(
-      ([_, errorCallback]) => errorCallback(error)
-    );
+};
+_fetchClient = new WeakMap();
+_messageParser = new WeakMap();
+_subscribers = new WeakMap();
+_upToDateSubscribers = new WeakMap();
+_lastOffset = new WeakMap();
+_lastSyncedAt = new WeakMap();
+_isUpToDate = new WeakMap();
+_connected = new WeakMap();
+_shapeId = new WeakMap();
+_schema = new WeakMap();
+_ShapeStream_instances = new WeakSet();
+publish_fn = function(messages) {
+  __privateGet(this, _subscribers).forEach(([subscriber, _]) => {
+    subscriber.process(messages);
+  });
+};
+sendErrorToSubscribers_fn = function(error) {
+  __privateGet(this, _subscribers).forEach(([_, errorFn]) => {
+    errorFn == null ? void 0 : errorFn(error);
+  });
+};
+notifyUpToDateSubscribers_fn = function() {
+  __privateGet(this, _upToDateSubscribers).forEach(([callback]) => {
+    callback();
+  });
+};
+sendErrorToUpToDateSubscribers_fn = function(error) {
+  __privateGet(this, _upToDateSubscribers).forEach(
+    ([_, errorCallback]) => errorCallback(error)
+  );
+};
+/**
+ * Resets the state of the stream, optionally with a provided
+ * shape ID
+ */
+reset_fn = function(shapeId) {
+  __privateSet(this, _lastOffset, `-1`);
+  __privateSet(this, _shapeId, shapeId);
+  __privateSet(this, _isUpToDate, false);
+  __privateSet(this, _connected, false);
+  __privateSet(this, _schema, void 0);
+};
+function validateOptions(options) {
+  if (!options.url) {
+    throw new Error(`Invalid shape option. It must provide the url`);
   }
-  /**
-   * Resets the state of the stream, optionally with a provided
-   * shape ID
-   */
-  reset(shapeId) {
-    this.lastOffset = `-1`;
-    this.shapeId = shapeId;
-    this.isUpToDate = false;
-    this.connected = false;
-    this.schema = void 0;
-  }
-  validateOptions(options) {
-    if (!options.url) {
-      throw new Error(`Invalid shape option. It must provide the url`);
-    }
-    if (options.signal && !(options.signal instanceof AbortSignal)) {
-      throw new Error(
-        `Invalid signal option. It must be an instance of AbortSignal.`
-      );
-    }
-    if (options.offset !== void 0 && options.offset !== `-1` && !options.shapeId) {
-      throw new Error(
-        `shapeId is required if this isn't an initial fetch (i.e. offset > -1)`
-      );
-    }
+  if (options.signal && !(options.signal instanceof AbortSignal)) {
+    throw new Error(
+      `Invalid signal option. It must be an instance of AbortSignal.`
+    );
   }
-  async fetchWithBackoff(url) {
-    const { initialDelay, maxDelay, multiplier } = this.backoffOptions;
-    const signal = this.options.signal;
-    let delay = initialDelay;
-    let attempt = 0;
-    while (true) {
-      try {
-        const result = await this.fetchClient(url.toString(), { signal });
-        if (result.ok) {
-          if (this.options.subscribe) {
-            this.connected = true;
-          }
-          return result;
-        } else throw await FetchError.fromResponse(result, url.toString());
-      } catch (e) {
-        this.connected = false;
-        if (signal == null ? void 0 : signal.aborted) {
-          return void 0;
-        } else if (e instanceof FetchError && e.status >= 400 && e.status < 500) {
-          throw e;
-        } else {
-          await new Promise((resolve) => setTimeout(resolve, delay));
-          delay = Math.min(delay * multiplier, maxDelay);
-          attempt++;
-          console.log(`Retry attempt #${attempt} after ${delay}ms`);
-        }
-      }
-    }
+  if (options.offset !== void 0 && options.offset !== `-1` && !options.shapeId) {
+    throw new Error(
+      `shapeId is required if this isn't an initial fetch (i.e. offset > -1)`
+    );
   }
-};
+  return;
+}
+
+// src/shape.ts
+var _stream, _data, _subscribers2, _hasNotifiedSubscribersUpToDate, _error, _Shape_instances, process_fn, handleError_fn, notify_fn;
 var Shape = class {
   constructor(stream) {
-    this.data = /* @__PURE__ */ new Map();
-    this.subscribers = /* @__PURE__ */ new Map();
-    this.error = false;
-    this.hasNotifiedSubscribersUpToDate = false;
-    this.stream = stream;
-    this.stream.subscribe(this.process.bind(this), this.handleError.bind(this));
-    const unsubscribe = this.stream.subscribeOnceToUpToDate(
+    __privateAdd(this, _Shape_instances);
+    __privateAdd(this, _stream);
+    __privateAdd(this, _data, /* @__PURE__ */ new Map());
+    __privateAdd(this, _subscribers2, /* @__PURE__ */ new Map());
+    __privateAdd(this, _hasNotifiedSubscribersUpToDate, false);
+    __privateAdd(this, _error, false);
+    __privateSet(this, _stream, stream);
+    __privateGet(this, _stream).subscribe(
+      __privateMethod(this, _Shape_instances, process_fn).bind(this),
+      __privateMethod(this, _Shape_instances, handleError_fn).bind(this)
+    );
+    const unsubscribe = __privateGet(this, _stream).subscribeOnceToUpToDate(
       () => {
         unsubscribe();
       },
       (e) => {
-        this.handleError(e);
+        __privateMethod(this, _Shape_instances, handleError_fn).call(this, e);
         throw e;
       }
     );
   }
-  lastSynced() {
-    return this.stream.lastSynced();
-  }
-  isConnected() {
-    return this.stream.isConnected();
+  get isUpToDate() {
+    return __privateGet(this, _stream).isUpToDate;
   }
   get value() {
-    return new Promise((resolve) => {
-      if (this.stream.isUpToDate) {
+    return new Promise((resolve, reject) => {
+      if (__privateGet(this, _stream).isUpToDate) {
         resolve(this.valueSync);
       } else {
-        const unsubscribe = this.stream.subscribeOnceToUpToDate(
-          () => {
-            unsubscribe();
-            resolve(this.valueSync);
-          },
-          (e) => {
-            throw e;
-          }
-        );
+        const unsubscribe = this.subscribe((shapeData) => {
+          unsubscribe();
+          if (__privateGet(this, _error)) reject(__privateGet(this, _error));
+          resolve(shapeData);
+        });
       }
     });
   }
   get valueSync() {
-    return this.data;
+    return __privateGet(this, _data);
+  }
+  get error() {
+    return __privateGet(this, _error);
+  }
+  /** Unix time at which we last synced. Undefined when `isLoading` is true. */
+  lastSyncedAt() {
+    return __privateGet(this, _stream).lastSyncedAt();
+  }
+  /** Time elapsed since last sync (in ms). Infinity if we did not yet sync. */
+  lastSynced() {
+    return __privateGet(this, _stream).lastSynced();
+  }
+  /** True during initial fetch. False afterwise.  */
+  isLoading() {
+    return __privateGet(this, _stream).isLoading();
+  }
+  /** Indicates if we are connected to the Electric sync service. */
+  isConnected() {
+    return __privateGet(this, _stream).isConnected();
   }
   subscribe(callback) {
     const subscriptionId = Math.random();
-    this.subscribers.set(subscriptionId, callback);
+    __privateGet(this, _subscribers2).set(subscriptionId, callback);
     return () => {
-      this.subscribers.delete(subscriptionId);
+      __privateGet(this, _subscribers2).delete(subscriptionId);
     };
   }
   unsubscribeAll() {
-    this.subscribers.clear();
+    __privateGet(this, _subscribers2).clear();
   }
   get numSubscribers() {
-    return this.subscribers.size;
+    return __privateGet(this, _subscribers2).size;
   }
-  process(messages) {
-    let dataMayHaveChanged = false;
-    let isUpToDate = false;
-    let newlyUpToDate = false;
-    messages.forEach((message) => {
-      if (isChangeMessage(message)) {
-        dataMayHaveChanged = [`insert`, `update`, `delete`].includes(
-          message.headers.operation
-        );
-        switch (message.headers.operation) {
-          case `insert`:
-            this.data.set(message.key, message.value);
-            break;
-          case `update`:
-            this.data.set(message.key, __spreadValues(__spreadValues({}, this.data.get(message.key)), message.value));
-            break;
-          case `delete`:
-            this.data.delete(message.key);
-            break;
-        }
-      }
-      if (isControlMessage(message)) {
-        switch (message.headers.control) {
-          case `up-to-date`:
-            isUpToDate = true;
-            if (!this.hasNotifiedSubscribersUpToDate) {
-              newlyUpToDate = true;
-            }
-            break;
-          case `must-refetch`:
-            this.data.clear();
-            this.error = false;
-            isUpToDate = false;
-            newlyUpToDate = false;
-            break;
-        }
+};
+_stream = new WeakMap();
+_data = new WeakMap();
+_subscribers2 = new WeakMap();
+_hasNotifiedSubscribersUpToDate = new WeakMap();
+_error = new WeakMap();
+_Shape_instances = new WeakSet();
+process_fn = function(messages) {
+  let dataMayHaveChanged = false;
+  let isUpToDate = false;
+  let newlyUpToDate = false;
+  messages.forEach((message) => {
+    if (isChangeMessage(message)) {
+      dataMayHaveChanged = [`insert`, `update`, `delete`].includes(
+        message.headers.operation
+      );
+      switch (message.headers.operation) {
+        case `insert`:
+          __privateGet(this, _data).set(message.key, message.value);
+          break;
+        case `update`:
+          __privateGet(this, _data).set(message.key, __spreadValues(__spreadValues({}, __privateGet(this, _data).get(message.key)), message.value));
+          break;
+        case `delete`:
+          __privateGet(this, _data).delete(message.key);
+          break;
       }
-    });
-    if (newlyUpToDate || isUpToDate && dataMayHaveChanged) {
-      this.hasNotifiedSubscribersUpToDate = true;
-      this.notify();
     }
-  }
-  handleError(e) {
-    if (e instanceof FetchError) {
-      this.error = e;
-      this.notify();
+    if (isControlMessage(message)) {
+      switch (message.headers.control) {
+        case `up-to-date`:
+          isUpToDate = true;
+          if (!__privateGet(this, _hasNotifiedSubscribersUpToDate)) {
+            newlyUpToDate = true;
+          }
+          break;
+        case `must-refetch`:
+          __privateGet(this, _data).clear();
+          __privateSet(this, _error, false);
+          isUpToDate = false;
+          newlyUpToDate = false;
+          break;
+      }
     }
+  });
+  if (newlyUpToDate || isUpToDate && dataMayHaveChanged) {
+    __privateSet(this, _hasNotifiedSubscribersUpToDate, true);
+    __privateMethod(this, _Shape_instances, notify_fn).call(this);
   }
-  notify() {
-    this.subscribers.forEach((callback) => {
-      callback(this.valueSync);
-    });
+};
+handleError_fn = function(e) {
+  if (e instanceof FetchError) {
+    __privateSet(this, _error, e);
+    __privateMethod(this, _Shape_instances, notify_fn).call(this);
   }
 };
+notify_fn = function() {
+  __privateGet(this, _subscribers2).forEach((callback) => {
+    callback(this.valueSync);
+  });
+};
 export {
   BackoffDefaults,
   FetchError,