stitchkit 0.110.0 → 0.110.2

package/dist/index-86sxnvpr.js

@@ -0,0 +1,336 @@
+import {
+  RealtimeRequestTimeoutError2,
+  RealtimeRequestDisconnectedError2
+} from "./index-4s0fep5q.js";
+import {
+  isModuleNotFound
+} from "./index-srs8hj9c.js";
+import {
+  realtimeRequestTraces,
+  createRequestTracer,
+  bindRealtimeClient2
+} from "./index-pvh3z03x.js";
+
+// src/browser/retained.ts
+function createRetainedTopics2() {
+  const last = {};
+  return {
+    record(topic, payload) {
+      last[topic] = payload;
+    },
+    replay(topic, handler) {
+      const value = last[topic];
+      if (value !== undefined)
+        handler(value);
+    },
+    get(topic) {
+      return last[topic];
+    },
+    clear(topic) {
+      if (topic !== undefined) {
+        delete last[topic];
+        return;
+      }
+      for (const key of Object.keys(last))
+        Reflect.deleteProperty(last, key);
+    }
+  };
+}
+
+// src/browser/socket-io-connection.ts
+function toIoAuth(auth) {
+  if (typeof auth !== "function")
+    return auth;
+  return (cb) => {
+    Promise.resolve().then(auth).then(cb, () => cb({}));
+  };
+}
+function ioOptions(config) {
+  return {
+    path: config.path ?? "/socket.io/",
+    withCredentials: config.withCredentials ?? true,
+    auth: toIoAuth(config.auth),
+    ...config.query && { query: config.query },
+    ...config.extraHeaders && { extraHeaders: config.extraHeaders },
+    transports: config.transports ?? ["websocket", "polling"],
+    autoConnect: false,
+    reconnection: true,
+    reconnectionAttempts: config.reconnectionAttempts ?? Infinity,
+    reconnectionDelay: config.reconnectionDelay ?? 1000,
+    reconnectionDelayMax: config.reconnectionDelayMax ?? 5000,
+    timeout: config.timeout ?? 20000
+  };
+}
+function reportPeerFailure(config, error) {
+  if (!config.onConnectError)
+    throw error;
+  config.onConnectError({
+    message: error instanceof Error ? error.message : String(error),
+    data: error,
+    terminal: true
+  });
+}
+function awaitAcknowledgement(input) {
+  const { active, event } = input;
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      input.pendingRequestDisconnects.delete(onDisconnect);
+      active.off("disconnect", onDisconnect);
+      result();
+    };
+    const onDisconnect = () => {
+      finish(() => {
+        input.closeTrace("disconnected");
+        reject(new RealtimeRequestDisconnectedError2(event));
+      });
+    };
+    input.pendingRequestDisconnects.add(onDisconnect);
+    active.on("disconnect", onDisconnect);
+    const acknowledgement = input.emit();
+    acknowledgement.then((value) => finish(() => resolve(value)), () => {
+      finish(() => {
+        const connected = active.connected;
+        input.closeTrace(connected ? "timeout" : "disconnected");
+        reject(connected ? new RealtimeRequestTimeoutError2(event, input.timeoutMs) : new RealtimeRequestDisconnectedError2(event));
+      });
+    });
+  });
+}
+function createStickyEvents(retain) {
+  const names = retain ? retain.map(String) : [];
+  const known = new Set(names);
+  const retained = names.length > 0 ? createRetainedTopics2() : null;
+  return {
+    record(socket) {
+      if (!retained)
+        return;
+      for (const name of names) {
+        socket.on(name, (payload) => retained.record(name, payload));
+      }
+    },
+    replay(name, handler) {
+      if (retained && known.has(name))
+        retained.replay(name, (payload) => handler(payload));
+    }
+  };
+}
+function createRecycle(delay) {
+  let timer = null;
+  const clear = () => {
+    if (timer === null)
+      return;
+    clearTimeout(timer);
+    timer = null;
+  };
+  return {
+    clear,
+    schedule(run) {
+      if (delay === false)
+        return;
+      clear();
+      timer = setTimeout(() => {
+        timer = null;
+        run();
+      }, delay);
+    }
+  };
+}
+function connectErrorReport(error, socket) {
+  return {
+    message: error.message,
+    data: Reflect.get(error, "data"),
+    terminal: socket !== null && !socket.active
+  };
+}
+
+// src/browser/socket-io-peer.ts
+function isIoModule(module) {
+  if (typeof module !== "object" || module === null)
+    return false;
+  return typeof Reflect.get(module, "io") === "function";
+}
+function createIoResolver(injected, defaultIo) {
+  if (!injected)
+    return defaultIo;
+  let pending = null;
+  return () => {
+    if (!pending) {
+      pending = Promise.resolve().then(injected).then((module) => {
+        const io = isIoModule(module) ? module.io : null;
+        if (!io) {
+          pending = null;
+          throw new Error("stitchkit: the loader passed in `peers.client` did not return the \"socket.io-client\" module — it must resolve to the module itself, as `() => import('socket.io-client')`.");
+        }
+        return io;
+      }, (cause) => {
+        pending = null;
+        if (!isModuleNotFound(cause))
+          throw cause;
+        throw new Error('stitchkit: createSocketIOClient could not load "socket.io-client" through the loader passed in `peers` — the artifact does not contain it. Check that the loader is a literal `import(\'socket.io-client\')` your bundler can follow, and that "socket.io-client" is a dependency of the package being bundled.', { cause });
+      });
+    }
+    return pending;
+  };
+}
+
+// src/browser/socket-io-client.ts
+function createRealtimeClientWithPeer(contract, { onRejected, logger, onRequestPhase, ...config }, defaultIo) {
+  const transport = createSocketIOClientInternal(config, defaultIo, onRequestPhase);
+  const bound = bindRealtimeClient2(contract, transport, { onRejected, logger });
+  return {
+    ...bound,
+    get connected() {
+      return bound.connected;
+    },
+    connect: transport.connect,
+    disconnect: transport.disconnect
+  };
+}
+function createSocketIOClientWithPeer(config, defaultIo) {
+  return createSocketIOClientInternal(config, defaultIo);
+}
+function createSocketIOClientInternal(config, defaultIo, onRequestPhase) {
+  let socket = null;
+  const resolveIo = createIoResolver(config.peers?.client, defaultIo);
+  let desiredConnected = false;
+  let loadingPeer = false;
+  const recycle = createRecycle(config.reconnectOnServerDisconnect ?? 1000);
+  const pendingRequestDisconnects = new Set;
+  const tracer = createRequestTracer(onRequestPhase);
+  const connectionListeners = new Set;
+  const subscriptions = new Set;
+  const sticky = createStickyEvents(config.retain);
+  function notifyConnection(connected, reason) {
+    for (const listener of connectionListeners)
+      listener(connected, reason);
+  }
+  function openSocket(io) {
+    if (!desiredConnected || socket)
+      return;
+    socket = io(config.url, ioOptions(config));
+    tracer.observeEachOpen(socket, () => socket);
+    socket.on("connect", () => notifyConnection(true));
+    socket.on("disconnect", (reason) => {
+      notifyConnection(false, reason);
+      if (reason === "io server disconnect") {
+        const current = socket;
+        recycle.schedule(() => {
+          if (socket === current && current && !current.connected)
+            current.connect();
+        });
+      }
+    });
+    socket.io.on("reconnect_failed", () => {
+      desiredConnected = false;
+    });
+    socket.on("connect_error", (error) => {
+      const report = connectErrorReport(error, socket);
+      if (report.terminal)
+        desiredConnected = false;
+      config.onConnectError?.(report);
+    });
+    sticky.record(socket);
+    for (const attach of subscriptions)
+      attach(socket);
+    socket.connect();
+  }
+  return {
+    get connected() {
+      return socket?.connected ?? false;
+    },
+    connect() {
+      if (socket?.connected || desiredConnected)
+        return;
+      desiredConnected = true;
+      if (socket) {
+        socket.connect();
+        return;
+      }
+      if (loadingPeer)
+        return;
+      loadingPeer = true;
+      resolveIo().then((io) => {
+        loadingPeer = false;
+        openSocket(io);
+      }, (error) => {
+        loadingPeer = false;
+        desiredConnected = false;
+        reportPeerFailure(config, error);
+      });
+    },
+    disconnect() {
+      desiredConnected = false;
+      recycle.clear();
+      for (const reject of [...pendingRequestDisconnects])
+        reject();
+      if (!socket)
+        return;
+      const wasConnected = socket.connected;
+      socket.removeAllListeners();
+      socket.disconnect();
+      socket = null;
+      if (wasConnected)
+        notifyConnection(false);
+    },
+    on(event, handler) {
+      const name = event;
+      const attach = (s) => {
+        s.on(name, handler);
+      };
+      subscriptions.add(attach);
+      if (socket)
+        attach(socket);
+      const fn = handler;
+      sticky.replay(name, fn);
+      return () => {
+        subscriptions.delete(attach);
+        socket?.off(name, handler);
+      };
+    },
+    emit(event, ...args) {
+      const name = event;
+      if (!socket?.connected) {
+        config.onDroppedEmit?.({ event: name, args });
+        return false;
+      }
+      socket.emit(name, ...args);
+      return true;
+    },
+    emitWithAck(event, args, options) {
+      const trace = tracer.start(event, options.onPhase);
+      const closeTrace = (phase) => tracer.close(trace, phase);
+      const active = socket;
+      if (!active?.connected) {
+        const pending = Promise.reject(new RealtimeRequestDisconnectedError2(event));
+        closeTrace("disconnected");
+        if (trace)
+          realtimeRequestTraces.set(pending, trace);
+        return pending;
+      }
+      if (trace)
+        tracer.observe(active);
+      const pending = awaitAcknowledgement({
+        active,
+        event,
+        args,
+        timeoutMs: options.timeoutMs,
+        pendingRequestDisconnects,
+        closeTrace,
+        emit: () => tracer.starting(trace, () => active.timeout(options.timeoutMs).emitWithAck(event, ...args))
+      });
+      if (trace)
+        realtimeRequestTraces.set(pending, trace);
+      return pending;
+    },
+    onConnectionChange(listener) {
+      connectionListeners.add(listener);
+      return () => connectionListeners.delete(listener);
+    }
+  };
+}
+
+export { createRetainedTopics2, createRealtimeClientWithPeer, createSocketIOClientWithPeer };