@floegence/floe-webapp-protocol 0.33.11 → 0.34.0

package/dist/client.d.ts

@@ -2,11 +2,12 @@ import { type JSX } from 'solid-js';
 import type { ChannelInitGrant, Client, ClientObserverLike, DirectConnectInfo } from '@floegence/flowersec-core';
 import { type AutoReconnectConfig, type ConnectionStatus } from '@floegence/flowersec-core/reconnect';
 import { type ControlplaneConfig } from './controlplane';
-import type { ProtocolContract } from './contract';
+import type { ProtocolContract, RpcClientLike } from './contract';
 interface ProtocolContextValue {
     status: () => ConnectionStatus;
     error: () => Error | null;
     client: () => Client | null;
+    rpcTransport: () => RpcClientLike;
     contract: () => ProtocolContract;
     connect: (config: ConnectConfig) => Promise<void>;
     /** Force a hard reconnect (disconnect old client and build a new one). */

package/dist/index2.js

@@ -1,101 +1,111 @@
-import { onCleanup as P, createComponent as I, useContext as M, createContext as y } from "solid-js";
-import { createStore as T } from "solid-js/store";
-import { createReconnectManager as x } from "@floegence/flowersec-core/reconnect";
-import { requestChannelGrant as k } from "./index4.js";
-const d = y();
-function S(o) {
-  const n = x(), [c, m] = T({
-    status: n.state().status,
-    error: n.state().error,
-    client: n.state().client
-  }), f = o.contract, w = n.subscribe((t) => {
-    m({
+import { onCleanup as x, createComponent as I, useContext as M, createContext as k } from "solid-js";
+import { createStore as q } from "solid-js/store";
+import { RpcProxy as E } from "@floegence/flowersec-core/rpc";
+import { createReconnectManager as G } from "@floegence/flowersec-core/reconnect";
+import { requestChannelGrant as R } from "./index4.js";
+const m = k();
+function _(c) {
+  const o = G(), a = o.state(), [s, h] = q({
+    status: a.status,
+    error: a.error,
+    client: a.client
+  }), p = c.contract, r = new E(), w = {
+    rpc: {
+      call: (t, e) => r.call(t, e),
+      notify: (t, e) => r.notify(t, e),
+      onNotify: (t, e) => r.onNotify(t, e)
+    }
+  };
+  a.client && r.attach(a.client.rpc);
+  const y = o.subscribe((t) => {
+    t.client ? r.attach(t.client.rpc) : r.detach(), h({
       status: t.status,
       error: t.error,
       client: t.client
     });
   });
-  let s = null, e = null;
-  const a = async (t, r) => {
-    const i = {
+  let i = null, n = null;
+  const l = async (t, e) => {
+    const u = {
       autoReconnect: t.autoReconnect,
       observer: t.observer,
       connectOnce: async ({
-        signal: p,
-        observer: v
+        signal: P,
+        observer: b
       }) => {
         const {
-          connectTunnelBrowser: b,
-          connectDirectBrowser: C
-        } = await import("@floegence/flowersec-core/browser"), l = {
-          observer: v,
-          signal: p,
+          connectTunnelBrowser: C,
+          connectDirectBrowser: T
+        } = await import("@floegence/flowersec-core/browser"), d = {
+          observer: b,
+          signal: P,
           keepaliveIntervalMs: t.keepaliveIntervalMs ?? 15e3,
           connectTimeoutMs: t.connectTimeoutMs ?? 1e4,
           handshakeTimeoutMs: t.handshakeTimeoutMs ?? 1e4
         };
         if ((t.mode ?? "tunnel") === "tunnel") {
-          const u = (t.getGrant ? await t.getGrant() : null) ?? t.grant ?? (t.controlplane ? await k(t.controlplane) : null);
-          if (!u)
+          const f = (t.getGrant ? await t.getGrant() : null) ?? t.grant ?? (t.controlplane ? await R(t.controlplane) : null);
+          if (!f)
             throw new Error("Tunnel mode requires `getGrant`, `grant`, or `controlplane` config");
-          return b(u, l);
+          return C(f, d);
         }
         if (!t.directInfo)
           throw new Error("Direct mode requires `directInfo`");
-        return C(t.directInfo, l);
+        return T(t.directInfo, d);
       }
     };
-    if (r === "hard") {
-      await n.connect(i);
+    if (e === "hard") {
+      await o.connect(u);
       return;
     }
-    await n.connectIfNeeded(i);
-  }, h = {
-    status: () => c.status,
-    error: () => c.error,
-    client: () => c.client,
-    contract: () => f,
+    await o.connectIfNeeded(u);
+  }, v = {
+    status: () => s.status,
+    error: () => s.error,
+    client: () => s.client,
+    rpcTransport: () => w,
+    contract: () => p,
     connect: async (t) => {
-      s = t;
-      const r = n.state();
-      if (!(r.status === "connected" && r.client) && !(r.status === "connecting" && !e)) {
-        if (e) {
-          await e;
+      i = t;
+      const e = o.state();
+      if (!(e.status === "connected" && e.client) && !(e.status === "connecting" && !n)) {
+        if (n) {
+          await n;
           return;
         }
-        e = a(t, "if_needed").finally(() => {
-          e = null;
-        }), await e;
+        n = l(t, "if_needed").finally(() => {
+          n = null;
+        }), await n;
       }
     },
     reconnect: async (t) => {
-      const r = t ?? s;
-      if (!r)
+      const e = t ?? i;
+      if (!e)
         throw new Error("reconnect() requires a config before the first connect() call");
-      return e || (s = r, e = a(r, "hard").finally(() => {
-        e = null;
-      }), e);
+      return n || (i = e, n = l(e, "hard").finally(() => {
+        n = null;
+      }), n);
     },
     disconnect: () => {
-      n.disconnect();
+      r.detach(), o.disconnect();
     }
   };
-  return P(() => {
-    w(), n.disconnect();
-  }), I(d.Provider, {
-    value: h,
+  return x(() => {
+    y(), r.detach(), o.disconnect();
+  }), I(m.Provider, {
+    value: v,
     get children() {
-      return o.children;
+      return c.children;
     }
   });
 }
-function A() {
-  const o = M(d);
-  if (!o)
+function j() {
+  const c = M(m);
+  if (!c)
     throw new Error("useProtocol must be used within a ProtocolProvider");
-  return o;
+  return c;
 }
 export {
-  S as ProtocolProvider,
-  A as useProtocol
+  _ as ProtocolProvider,
+  j as useProtocol
 };

package/dist/index3.js

@@ -1,5 +1,6 @@
-import { useProtocol as u } from "./index2.js";
-class p extends Error {
+import { useProtocol as d } from "./index2.js";
+import { RpcProxyDetachedError as u } from "@floegence/flowersec-core/rpc";
+class f extends Error {
   constructor() {
     super("Not connected"), this.name = "ProtocolNotConnectedError";
   }
@@ -7,50 +8,45 @@ class p extends Error {
 class a extends Error {
   typeId;
   code;
-  constructor(o) {
-    super(o.message ?? `RPC error: ${o.code}`, { cause: o.cause }), this.name = "RpcError", this.typeId = o.typeId, this.code = o.code;
+  constructor(t) {
+    super(t.message ?? `RPC error: ${t.code}`, { cause: t.cause }), this.name = "RpcError", this.typeId = t.typeId, this.code = t.code;
   }
 }
-function d(c) {
-  return { call: async (e, n) => {
-    const t = c.client();
-    if (!t) throw new p();
+function l(e) {
+  return { call: async (o, c) => {
+    const n = e.rpcTransport();
     let r;
     try {
-      r = await t.rpc.call(e, n);
-    } catch (l) {
-      throw new a({ typeId: e, code: -1, message: "RPC transport error", cause: l });
+      r = await n.rpc.call(o, c);
+    } catch (i) {
+      throw i instanceof u ? new f() : new a({ typeId: o, code: -1, message: "RPC transport error", cause: i });
     }
     if (r.error)
       throw new a({
-        typeId: e,
+        typeId: o,
         code: r.error.code,
         message: r.error.message ?? `RPC error: ${r.error.code}`,
         cause: r.error
       });
     return r.payload;
-  }, notify: async (e, n) => {
-    const t = c.client();
-    if (t)
-      try {
-        await t.rpc.notify(e, n);
-      } catch (r) {
-        throw new a({ typeId: e, code: -1, message: "RPC notify transport error", cause: r });
-      }
-  }, onNotify: (e, n) => {
-    const t = c.client();
-    return t ? t.rpc.onNotify(e, (r) => {
-      n(r);
-    }) : () => {
-    };
-  } };
+  }, notify: async (o, c) => {
+    const n = e.rpcTransport();
+    try {
+      await n.rpc.notify(o, c);
+    } catch (r) {
+      if (r instanceof u) return;
+      throw new a({ typeId: o, code: -1, message: "RPC notify transport error", cause: r });
+    }
+  }, onNotify: (o, c) => e.rpcTransport().rpc.onNotify(o, (r) => {
+    c(r);
+  }) };
 }
-function y(c) {
-  const o = u(), i = c?.contract ?? o.contract(), s = d(o), e = i.createRpc(s);
-  return Object.assign(e, s);
+function m(e) {
+  const t = d(), p = e?.contract ?? t.contract(), s = l(t), o = p.createRpc(s);
+  return Object.assign(o, s);
 }
 export {
-  p as ProtocolNotConnectedError,
+  f as ProtocolNotConnectedError,
   a as RpcError,
-  y as useRpc
+  m as useRpc
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/floe-webapp-protocol",
-  "version": "0.33.11",
+  "version": "0.34.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -30,7 +30,7 @@
     "solid-js": "^1.8.0"
   },
   "dependencies": {
-    "@floegence/flowersec-core": "^0.14.1"
+    "@floegence/flowersec-core": "^0.15.0"
   },
   "devDependencies": {
     "solid-js": "^1.9.11",