@electric-sql/client 1.5.3 → 1.5.4

package/dist/index.legacy-esm.js

@@ -854,10 +854,202 @@ function compileOrderBy(clauses, columnMapper) {
   }).join(`, `);
 }
 
-// src/client.ts
-import {
-  fetchEventSource
-} from "@microsoft/fetch-event-source";
+// ../../node_modules/.pnpm/@microsoft+fetch-event-source@2.0.1_patch_hash=46f4e76dd960e002a542732bb4323817a24fce1673cb71e2f458fe09776fa188/node_modules/@microsoft/fetch-event-source/lib/esm/parse.js
+async function getBytes(stream, onChunk) {
+  const reader = stream.getReader();
+  let result;
+  while (!(result = await reader.read()).done) {
+    onChunk(result.value);
+  }
+}
+function getLines(onLine) {
+  let buffer;
+  let position;
+  let fieldLength;
+  let discardTrailingNewline = false;
+  return function onChunk(arr) {
+    if (buffer === void 0) {
+      buffer = arr;
+      position = 0;
+      fieldLength = -1;
+    } else {
+      buffer = concat(buffer, arr);
+    }
+    const bufLength = buffer.length;
+    let lineStart = 0;
+    while (position < bufLength) {
+      if (discardTrailingNewline) {
+        if (buffer[position] === 10) {
+          lineStart = ++position;
+        }
+        discardTrailingNewline = false;
+      }
+      let lineEnd = -1;
+      for (; position < bufLength && lineEnd === -1; ++position) {
+        switch (buffer[position]) {
+          case 58:
+            if (fieldLength === -1) {
+              fieldLength = position - lineStart;
+            }
+            break;
+          case 13:
+            discardTrailingNewline = true;
+          case 10:
+            lineEnd = position;
+            break;
+        }
+      }
+      if (lineEnd === -1) {
+        break;
+      }
+      onLine(buffer.subarray(lineStart, lineEnd), fieldLength);
+      lineStart = position;
+      fieldLength = -1;
+    }
+    if (lineStart === bufLength) {
+      buffer = void 0;
+    } else if (lineStart !== 0) {
+      buffer = buffer.subarray(lineStart);
+      position -= lineStart;
+    }
+  };
+}
+function getMessages(onId, onRetry, onMessage) {
+  let message = newMessage();
+  const decoder = new TextDecoder();
+  return function onLine(line, fieldLength) {
+    if (line.length === 0) {
+      onMessage === null || onMessage === void 0 ? void 0 : onMessage(message);
+      message = newMessage();
+    } else if (fieldLength > 0) {
+      const field = decoder.decode(line.subarray(0, fieldLength));
+      const valueOffset = fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
+      const value = decoder.decode(line.subarray(valueOffset));
+      switch (field) {
+        case "data":
+          message.data = message.data ? message.data + "\n" + value : value;
+          break;
+        case "event":
+          message.event = value;
+          break;
+        case "id":
+          onId(message.id = value);
+          break;
+        case "retry":
+          const retry = parseInt(value, 10);
+          if (!isNaN(retry)) {
+            onRetry(message.retry = retry);
+          }
+          break;
+      }
+    }
+  };
+}
+function concat(a, b) {
+  const res = new Uint8Array(a.length + b.length);
+  res.set(a);
+  res.set(b, a.length);
+  return res;
+}
+function newMessage() {
+  return {
+    data: "",
+    event: "",
+    id: "",
+    retry: void 0
+  };
+}
+
+// ../../node_modules/.pnpm/@microsoft+fetch-event-source@2.0.1_patch_hash=46f4e76dd960e002a542732bb4323817a24fce1673cb71e2f458fe09776fa188/node_modules/@microsoft/fetch-event-source/lib/esm/fetch.js
+var __rest = function(s, e) {
+  var t = {};
+  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+    t[p] = s[p];
+  if (s != null && typeof Object.getOwnPropertySymbols === "function")
+    for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+      if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+        t[p[i]] = s[p[i]];
+    }
+  return t;
+};
+var EventStreamContentType = "text/event-stream";
+var DefaultRetryInterval = 1e3;
+var LastEventId = "last-event-id";
+function fetchEventSource(input, _a) {
+  var { signal: inputSignal, headers: inputHeaders, onopen: inputOnOpen, onmessage, onclose, onerror, openWhenHidden, fetch: inputFetch } = _a, rest = __rest(_a, ["signal", "headers", "onopen", "onmessage", "onclose", "onerror", "openWhenHidden", "fetch"]);
+  return new Promise((resolve, reject) => {
+    const headers = Object.assign({}, inputHeaders);
+    if (!headers.accept) {
+      headers.accept = EventStreamContentType;
+    }
+    let curRequestController;
+    function onVisibilityChange() {
+      curRequestController.abort();
+      if (typeof document !== "undefined" && !document.hidden) {
+        create();
+      }
+    }
+    if (typeof document !== "undefined" && !openWhenHidden) {
+      document.addEventListener("visibilitychange", onVisibilityChange);
+    }
+    let retryInterval = DefaultRetryInterval;
+    let retryTimer = 0;
+    function dispose() {
+      if (typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", onVisibilityChange);
+      }
+      clearTimeout(retryTimer);
+      curRequestController.abort();
+    }
+    inputSignal === null || inputSignal === void 0 ? void 0 : inputSignal.addEventListener("abort", () => {
+      dispose();
+    });
+    const fetch2 = inputFetch !== null && inputFetch !== void 0 ? inputFetch : window.fetch;
+    const onopen = inputOnOpen !== null && inputOnOpen !== void 0 ? inputOnOpen : defaultOnOpen;
+    async function create() {
+      var _a2;
+      curRequestController = new AbortController();
+      const sig = inputSignal.aborted ? inputSignal : curRequestController.signal;
+      try {
+        const response = await fetch2(input, Object.assign(Object.assign({}, rest), { headers, signal: sig }));
+        await onopen(response);
+        await getBytes(response.body, getLines(getMessages((id) => {
+          if (id) {
+            headers[LastEventId] = id;
+          } else {
+            delete headers[LastEventId];
+          }
+        }, (retry) => {
+          retryInterval = retry;
+        }, onmessage)));
+        onclose === null || onclose === void 0 ? void 0 : onclose();
+        dispose();
+        resolve();
+      } catch (err) {
+        if (sig.aborted) {
+          dispose();
+          reject(err);
+        } else if (!curRequestController.signal.aborted) {
+          try {
+            const interval = (_a2 = onerror === null || onerror === void 0 ? void 0 : onerror(err)) !== null && _a2 !== void 0 ? _a2 : retryInterval;
+            clearTimeout(retryTimer);
+            retryTimer = setTimeout(create, interval);
+          } catch (innerErr) {
+            dispose();
+            reject(innerErr);
+          }
+        }
+      }
+    }
+    create();
+  });
+}
+function defaultOnOpen(response) {
+  const contentType = response.headers.get("content-type");
+  if (!(contentType === null || contentType === void 0 ? void 0 : contentType.startsWith(EventStreamContentType))) {
+    throw new Error(`Expected content-type to be ${EventStreamContentType}, Actual: ${contentType}`);
+  }
+}
 
 // src/expired-shapes-cache.ts
 var ExpiredShapesCache = class {