@floegence/floe-webapp-protocol 0.48.2 → 0.48.4

package/dist/contract.d.ts

@@ -1,10 +1,11 @@
-import type { JsonValue, RpcPeer } from '@floegence/flowersec-core';
+import type { JsonValue, OperationOptions, RpcPeer } from '@floegence/flowersec-core';
 export interface RpcClientLike {
     rpc: Pick<RpcPeer, 'call' | 'notify' | 'onNotify'>;
 }
 export type RpcDecoder<T> = (payload: JsonValue) => T;
+export type RpcOperationOptions = OperationOptions;
 export interface RpcHelpers {
-    call: <Req extends JsonValue, Res>(typeId: number, payload: Req, decodeResponse: RpcDecoder<Res>) => Promise<Res>;
+    call: <Req extends JsonValue, Res>(typeId: number, payload: Req, decodeResponse: RpcDecoder<Res>, options?: RpcOperationOptions) => Promise<Res>;
     /** Strict notification: detached transports fail with ProtocolNotConnectedError. */
     notify: <Req extends JsonValue>(typeId: number, payload: Req) => Promise<void>;
     /** Best-effort notification: detached transports are treated as already dropped. */

package/dist/index3.js

@@ -1,44 +1,44 @@
-import { useProtocol as y } from "./index2.js";
-class f extends Error {
+import { useProtocol as h } from "./index2.js";
+class u extends Error {
   constructor() {
     super("Not connected"), this.name = "ProtocolNotConnectedError";
   }
 }
-class p extends Error {
+class d 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;
   }
 }
-function h(n) {
-  const o = async (r, t, s) => {
-    const c = n.rpcTransport();
-    if (!c) throw new f();
-    let e;
+function w(e) {
+  const o = async (r, t, s, c) => {
+    const i = e.rpcTransport();
+    if (!i) throw new u();
+    let n;
     try {
-      e = await c.call(r, t, s);
-    } catch (u) {
-      throw new p({ typeId: r, code: -1, message: "RPC transport or response decode error", cause: u });
+      n = await i.call(r, t, s, c);
+    } catch (y) {
+      throw new d({ typeId: r, code: -1, message: "RPC transport or response decode error", cause: y });
     }
-    if (!e.ok)
-      throw new p({
+    if (!n.ok)
+      throw new d({
         typeId: r,
-        code: e.error.code,
-        message: e.error.message ?? `RPC error: ${e.error.code}`,
-        cause: e.error
+        code: n.error.code,
+        message: n.error.message ?? `RPC error: ${n.error.code}`,
+        cause: n.error
       });
-    return e.payload;
+    return n.payload;
   }, a = async (r, t, s) => {
-    const c = n.rpcTransport();
+    const c = e.rpcTransport();
     if (!c) {
       if (s.detached === "ignore") return;
-      throw new f();
+      throw new u();
     }
     try {
       await c.notify(r, t);
-    } catch (e) {
-      throw new p({ typeId: r, code: -1, message: "RPC notify transport error", cause: e });
+    } catch (i) {
+      throw new d({ typeId: r, code: -1, message: "RPC notify transport error", cause: i });
     }
   };
   return { call: o, notify: async (r, t) => {
@@ -46,17 +46,17 @@ function h(n) {
   }, notifyBestEffort: async (r, t) => {
     await a(r, t, { detached: "ignore" });
   }, onNotify: (r, t, s) => {
-    const c = n.rpcTransport();
+    const c = e.rpcTransport();
     return c ? c.onNotify(r, t, s) : () => {
     };
   } };
 }
-function m(n) {
-  const o = y(), a = n?.contract ?? o.contract(), i = h(o), d = a.createRpc(i);
-  return Object.assign(d, i);
+function E(e) {
+  const o = h(), a = e?.contract ?? o.contract(), p = w(o), f = a.createRpc(p);
+  return Object.assign(f, p);
 }
 export {
-  f as ProtocolNotConnectedError,
-  p as RpcError,
-  m as useRpc
+  u as ProtocolNotConnectedError,
+  d as RpcError,
+  E as useRpc
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@floegence/floe-webapp-protocol",
-  "version": "0.48.2",
+  "version": "0.48.4",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",