@persistica/flux-agent 0.0.25 → 0.0.27

package/index.js

@@ -40,6 +40,7 @@ var ON_NETWORK_CHANNEL_PUBLISH = "nc-on-pub";
 var SUBSCRIBE_NETWORK_CHANNEL_NAME = "subscribe-to-nc-name";
 var SUBSCRIBED_NETWORK_CHANNEL_NAME = "subscribed-to-nc-name";
 var UNSUBSCRIBE_NETWORK_CHANNEL_NAME = "unsubscribe-nc-name";
+var UNSUBSCRIBED_NETWORK_CHANNEL_NAME = "unsubscribed-nc-name";
 var AUTHORITY_CHANNEL_SUBSCRIBE = "acs";
 var AUTHORITY_DISCONNECT_AGENT = "ada";
 var ERROR = "e";
@@ -264,6 +265,7 @@ var FluxRemoteClient = class {
   constructor(iceConnection) {
     this.iceConnection = iceConnection;
   }
+  iceConnection;
   /**
    * Calls a remote procedure on the connected client.
    */
@@ -319,6 +321,8 @@ var ICEConnection = class {
     this._fluxWebSocketClientConnection.registerMethod("acceptAnswer", this.acceptAnswer.bind(this));
     this._fluxWebSocketClientConnection.registerMethod("answerAcceptedByInitiator", this.answerAcceptedByInitiator.bind(this));
   }
+  _fluxWebSocketClientConnection;
+  _stateChange;
   //extends RPCServer<'createOffer' | 'acceptOffer' | 'acceptAnswer'> {
   peerConnection = new RTCPeerConnection(peerConnectionConfig);
   dataChannel;
@@ -407,6 +411,9 @@ var FluxAgentNetworkConnection = class {
       console.warn("\u2757WebRTC is not available in this environment.");
     }
   }
+  _fluxWebSocketConnection;
+  _fluxWebSocketClientConnection;
+  _webRTCStateChange;
   iceConnection;
   connectedChannelSet = /* @__PURE__ */ new Set();
   /**
@@ -420,7 +427,7 @@ var FluxAgentNetworkConnection = class {
     const fluxNetworkChannel = await this._fluxWebSocketConnection.joinChannel(
       channelName
     );
-    this.connectedChannelSet.add(fluxNetworkChannel.channelName);
+    this.connectedChannelSet.add(channelName);
     return fluxNetworkChannel;
   }
   /**
@@ -486,16 +493,18 @@ var PicoLogger = /* @__PURE__ */ (() => {
 
 // libs/flux/shared/connection/src/lib/flux-network-channel.class.ts
 var FluxNetworkChannel = class {
-  constructor(channelName, _fluxWebSocketConnection) {
-    this.channelName = channelName;
+  constructor(_channelName, _fluxWebSocketConnection) {
+    this._channelName = _channelName;
     this._fluxWebSocketConnection = _fluxWebSocketConnection;
   }
+  _channelName;
+  _fluxWebSocketConnection;
   /**
    * Broadcasts a message to the channel.
    */
   publish(message) {
     this._fluxWebSocketConnection.publish(
-      this.channelName,
+      this._channelName,
       message
     );
   }
@@ -504,7 +513,7 @@ var FluxNetworkChannel = class {
    */
   onPublish(fn) {
     this._fluxWebSocketConnection.onPublish(
-      this.channelName,
+      this._channelName,
       fn
       // TODO
     );
@@ -515,11 +524,17 @@ var FluxNetworkChannel = class {
 var CONNECTION_TIMEOUT_MS = 2e3;
 var ChannelStateManager = class {
   connectionTimeouts = /* @__PURE__ */ new Map();
+  joinedChannels = /* @__PURE__ */ new Map();
   /**
    * Join a channel.
    */
   async joinChannel(channelName, fluxWebSocketConnection, webSocketClient) {
     if (webSocketClient) {
+      const existingChannel = this.joinedChannels.get(channelName);
+      if (existingChannel) {
+        existingChannel.useCount++;
+        return Promise.resolve(existingChannel.channel);
+      }
       return new Promise((resolve, reject) => {
         const existingTimeout = this.connectionTimeouts.get(channelName);
         if (existingTimeout) {
@@ -537,7 +552,9 @@ var ChannelStateManager = class {
             this.connectionTimeouts.delete(channelName);
           }
           fluxWebSocketConnection.removePackageTypeInterceptor(SUBSCRIBED_NETWORK_CHANNEL_NAME, cb);
-          resolve(new FluxNetworkChannel(channelName, fluxWebSocketConnection));
+          const channel = new FluxNetworkChannel(channelName, fluxWebSocketConnection);
+          this.joinedChannels.set(channelName, { channel, useCount: 1 });
+          resolve(channel);
         };
         fluxWebSocketConnection.interceptPackageTypeMessages(
           SUBSCRIBED_NETWORK_CHANNEL_NAME,
@@ -559,9 +576,46 @@ var ChannelStateManager = class {
   /**
    * Leave a channel.
    */
-  async leaveChannel(channelName, webSocketClient) {
+  async leaveChannel(channelName, fluxWebSocketConnection, webSocketClient) {
+    const existingChannel = this.joinedChannels.get(channelName);
+    if (!existingChannel) {
+      return Promise.reject(new Error("No channel instance found"));
+    }
+    existingChannel.useCount--;
+    if (existingChannel.useCount <= 0) {
+      this.joinedChannels.delete(channelName);
+    }
+    if (webSocketClient && existingChannel.useCount <= 0) {
+      return new Promise((resolve, reject) => {
+        const cb = (message) => {
+          const receivedChannelName = message.substring(message.indexOf(":") + 1);
+          if (channelName !== receivedChannelName) {
+            return;
+          }
+          const timeout = this.connectionTimeouts.get(channelName);
+          if (timeout) {
+            clearTimeout(timeout);
+            this.connectionTimeouts.delete(channelName);
+          }
+          fluxWebSocketConnection.removePackageTypeInterceptor(UNSUBSCRIBED_NETWORK_CHANNEL_NAME, cb);
+          resolve(void 0);
+        };
+        fluxWebSocketConnection.interceptPackageTypeMessages(
+          UNSUBSCRIBED_NETWORK_CHANNEL_NAME,
+          cb
+        );
+        this.connectionTimeouts.set(
+          channelName,
+          setTimeout(() => {
+            this.connectionTimeouts.delete(channelName);
+            fluxWebSocketConnection.removePackageTypeInterceptor(UNSUBSCRIBED_NETWORK_CHANNEL_NAME, cb);
+            reject(new Error(`Channel unsubscription timed out for channel "${channelName}"`));
+          }, CONNECTION_TIMEOUT_MS)
+        );
+        webSocketClient.send(`${UNSUBSCRIBE_NETWORK_CHANNEL_NAME}:${channelName}`);
+      });
+    }
     if (webSocketClient) {
-      webSocketClient.send(`${UNSUBSCRIBE_NETWORK_CHANNEL_NAME}:${channelName}`);
       return Promise.resolve(void 0);
     }
     return Promise.reject(new Error("Not connected"));
@@ -607,6 +661,11 @@ var FluxWebSocketConnection = class {
     );
     this.interceptPackageTypeMessages("isReady", this.readyInterceptor);
   }
+  fluxInstanceId;
+  onReconnectCallback;
+  stateManager;
+  token;
+  options;
   // ****************************************************************************
   // *** State
   // ****************************************************************************
@@ -675,7 +734,6 @@ var FluxWebSocketConnection = class {
     });
     this.socket.clearEventSubscribers();
     this.socket.on("message", this.socketMessageHandler).on("close", this.socketCloseHandler).on("connecting", this.socketConnectingHandler).on("error", this.socketErrorHandler);
-    this.stateManager.emitNetworkState("connecting");
     void this.socket.connect();
     return this.connectPromise;
   }
@@ -729,6 +787,7 @@ var FluxWebSocketConnection = class {
   async leaveChannel(channelName) {
     return this.channelStateManager.leaveChannel(
       channelName,
+      this,
       this.webSocketClient
     );
   }
@@ -815,7 +874,7 @@ var FluxWebSocketConnection = class {
     this.stateManager.emitNetworkState(reason === "kicked" ? "kicked" : "disconnected");
   }
   handleSocketConnecting(retryAttempt) {
-    this.stateManager.emitNetworkState("disconnected");
+    this.stateManager.emitNetworkState("connecting");
     if (retryAttempt > 0) {
       PicoLogger.log(`\u{1F504} Connecting attempt: #${retryAttempt} of ${this.options.retries ?? "none"}`, this.fluxInstanceId);
     } else {
@@ -1148,15 +1207,19 @@ var FluxClientData = class {
 // packages/flux/agent/src/lib/flux-agent.class.ts
 var DEFAULT_FLUX_DOMAIN = "https://mesh.persistica.io";
 var FluxAgent = class {
-  constructor(networkId, options) {
-    this.networkId = networkId;
-    this.options = options;
-    validateNetworkIdOrThrow(this.networkId);
-  }
   id = nanoid();
+  networkId;
   fluxWebSocketConnection;
   fluxClientData = new FluxClientData();
   stateManager = new StateManager();
+  options;
+  constructor(networkId, options) {
+    if (!validateNetworkIdOrThrow(networkId)) {
+      throw new Error("Will never be thrown");
+    }
+    this.networkId = networkId;
+    this.options = options;
+  }
   /**
    * Connect to the network using provided identification.
    * 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@persistica/flux-agent",
-    "version": "0.0.25",
+    "version": "0.0.27",
     "description": "Persistica Flux Agent",
     "type": "module",
     "keywords": [],

package/src/lib/flux-agent.class.d.ts

@@ -1,17 +1,18 @@
+import { type TNetworkId_S } from '@flux/shared/types';
 import type { TMessageCallback } from '@flux/shared/ws';
 import type { FluxAgentNetworkConnection } from '@flux/shared/connection';
 export declare class FluxAgent {
-    private readonly networkId;
-    private readonly options?;
     readonly id: string;
+    readonly networkId: TNetworkId_S;
     private fluxWebSocketConnection;
     private readonly fluxClientData;
     private readonly stateManager;
+    private readonly options;
     constructor(networkId: string, options?: {
         domain?: string;
         secretKey?: string;
         retries?: number;
-    } | undefined);
+    });
     /**
      * Connect to the network using provided identification.
      *

package/src/lib/flux-interface.class.d.ts

@@ -8,5 +8,5 @@ import type { FluxWebSocketConnection } from '../../../../../libs/flux/shared/co
 export declare class FluxInterface {
     private readonly socketConnection;
     constructor(socketConnection: FluxWebSocketConnection);
-    messageReport(packageStatus: Omit<IPackageStatus, 'txNode'>): void;
+    messageReport(_packageStatus: Omit<IPackageStatus, 'txNode'>): void;
 }