aotrautils-srv 0.0.1476 → 0.0.1477

aotrautils-srv/aotrautils-srv.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils COMMONS library associated with aotra version : «1_29072022-2359 (26/04/2025-13:41:01)»*/
+/*utils COMMONS library associated with aotra version : «1_29072022-2359 (26/04/2025-16:15:53)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -4894,7 +4894,7 @@ AOTRAUTILS_LIB_IS_LOADED=true;
 
 	
 
-/*utils AI library associated with aotra version : «1_29072022-2359 (26/04/2025-13:41:01)»*/
+/*utils AI library associated with aotra version : «1_29072022-2359 (26/04/2025-16:15:53)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -5040,11 +5040,11 @@ getOpenAIAPIClient=(modelName, apiURL, agentRole, defaultPrompt)=>{
 
 
 
-/*utils SERVER library associated with aotra version : «1_29072022-2359 (26/04/2025-13:41:01)»*/
+/*utils CONSOLE library associated with aotra version : «1_29072022-2359 (26/04/2025-16:15:53)»*/
 /*-----------------------------------------------------------------------------*/
 
 
-/* ## Utility global methods in a javascript, console (nodejs) server, or vanilla javascript with no browser environment.
+/* ## Utility global methods in a javascript, console (nodejs) or vanilla javascript with no browser environment.
  *
  * This set of methods gathers utility generic-purpose methods usable in any JS project.
  * Several authors of snippets published freely on the Internet contributed to this library.
@@ -5378,7 +5378,6 @@ WebsocketImplementation={
 				throw new Error("ERROR : SERVER : Server launch is not supported in a non-nodejs context for any implementation.");
 			}
 			
-
 			
 			// TODO : FIXME : Use one single interface !
 			// NODE SERVER MODE ONLY :
@@ -5404,322 +5403,20 @@ WebsocketImplementation={
 			}
 			
 			serverSocket.on("error",(error)=>{
-				
 				// TRACE
 				lognow("ERROR : An error occurred when trying to start the server : ",error);
 				
 			});
 
 			// NODE SERVER INSTANCE :
-			const nodeServerInstance={
-					
-					onClientLostListeners:[],
-					
-					clientPingIntervalMillis:5000,
-					setPingPongTimeout:(clientPingIntervalMillis)=>{
-						nodeServerInstance.clientPingIntervalMillis=clientPingIntervalMillis;
-						return nodeServerInstance;
-					},
-					
-//					clientsSockets:[],
-					serverSocket:serverSocket,
-					listenableServer:listenableServer,
-					
-					receptionEntryPoints:[],
-					
-					close:(doOnCloseServer)=>{
-						if(!nodeServerInstance.serverSocket)	return;
-						nodeServerInstance.serverSocket.close(()=>{
-							if(!nodeServerInstance.listenableServer)	return;	
-							nodeServerInstance.listenableServer.close(doOnCloseServer);
-						});
-					},
-					
-					receive:(channelNameParam, doOnIncomingMessage, clientsRoomsTag=null)=>{
-						
-						// DBG
-						lognow("(SERVER) Registering receive for «"+channelNameParam+"»...");
-						
-						
-						
-						const receptionEntryPoint={
-							channelName:channelNameParam,
-							clientsRoomsTag:clientsRoomsTag, 
-							execute:(eventOrMessage, clientSocketParam)=>{
-
-							 // With «ws» library we have no choive than register message events inside a «connection» event !
-								
-//							// DBG
-//							lognow("(SERVER) RECEIVED SOMETHING FROM CLIENT...", eventOrMessage.data);
-								
-//							dataWrapped=parseJSON(dataWrapped);
-//							dataWrapped=getAt(dataWrapped,0);// We get the root element
-								
-
-								const dataWrapped=WebsocketImplementation.getMessageDataBothImplementations(eventOrMessage);
-							
-							
-								// Channel information is stored in exchanged data :
-								if(dataWrapped.channelName!==receptionEntryPoint.channelName) return;
-								
-																
-//								// DBG
-//								lognow("(SERVER) ENTRY POINT IS OF THE RIGHT CHANNEL:", receptionEntryPoint.channelName);
-								
-
-								// TODO : FIXME : Use one single interface !
-								// Room information is stored in client socket object :
-								const isClientInRoom=WebsocketImplementation.isInRoom(clientSocketParam, receptionEntryPoint.clientsRoomsTag);
-								
-								// DBG
-								lognow("(SERVER) isClientInRoom:",isClientInRoom);
-								
-								if(!isClientInRoom) return;
-
-								if(doOnIncomingMessage){
-									// DBG
-									lognow("(SERVER) doOnIncomingMessage:");
-									doOnIncomingMessage(dataWrapped.data, clientSocketParam);
-								}
-								
-							},
-						};
-						
-						
-						///!!!
-						nodeServerInstance.receptionEntryPoints.push(receptionEntryPoint);
-						
-						// SPECIAL FOR THE SOCKETIO IMPLEMENTATION :
-						if(WebsocketImplementation.useSocketIOImplementation){
-							const channelName=receptionEntryPoint.channelName;
-							clientSocket.on(channelName, (eventOrMessage)=>{
-								receptionEntryPoint.execute(eventOrMessage, clientSocket);
-							});
-						}
-
-						
-//					// DBG
-//					console.log("ADD RECEPTION ENTRY POINT channelName:«"+channelName+"»! nodeServerInstance.receptionEntryPoints.length:",nodeServerInstance.receptionEntryPoints.length);
-						
-						
-						return nodeServerInstance;
-					},
-					
-					
-					send:(channelName, data, clientsRoomsTag=null, clientSocketParam=null)=>{
-						
-						// DBG
-						lognow("(SERVER) SERVER TRIES TO SEND !");
-						
-						
-						if(!clientSocketParam){
-							
-								// DBG
-								lognow("(SERVER) (server sends to all clients)");
-							
-								// TODO : FIXME : Use one single interface !
-								let serverClients;
-								if(!WebsocketImplementation.useSocketIOImplementation)	serverClients=nodeServerInstance.serverSocket.clients;
-//							OLD:	else																							serverClients=nodeServerInstance.serverSocket.sockets.clients();
-								else																										serverClients=nodeServerInstance.serverSocket.sockets.sockets;
-						    
-						    
-						    
-						    serverClients.forEach((clientSocket)=>{
-						    	
-						    	
-									if(!isConnected(clientSocket))	return;
-						    	
-		
-									// Room information is stored in client socket object :
-							   	if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
-			
-						      // Channel information is stored in exchanged data :
-							   	let dataWrapped={channelName:channelName, data:data};
-					      	
-						      
-									dataWrapped=stringifyObject(dataWrapped);
-									
-									// TODO : FIXME : Use one single interface !
-					      	if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
-						      else																										clientSocket.emit(channelName,dataWrapped);
-
-						    });
-						
-						}else{
-							
-							// DBG
-							lognow("(SERVER) (server sends to a client)");
-							
-							
-							// TODO : FIXME : Use one single interface !
-							let clientSocket=clientSocketParam;
-							if(!WebsocketImplementation.useSocketIOImplementation)	if(clientSocket.readyState!==WebSocket.OPEN)	return;
-							else																										if(clientSocket.connected)	return;
-
-
-							// Room information is stored in client socket object :
-				      if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
-
-			      	// Channel information is stored in exchanged data :
-				      let dataWrapped={channelName:channelName, data:data};
-							dataWrapped=stringifyObject(dataWrapped);
-							
-							
-							// DBG
-							lognow("(SERVER) WebsocketImplementation.useSocketIOImplementation:"+WebsocketImplementation.useSocketIOImplementation);
-//						lognow("(SERVER) dataWrapped:"+dataWrapped);
-							
-							
-							// TODO : FIXME : Use one single interface !
-							if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
-			      	else																										clientSocket.emit(channelName,dataWrapped);
-			      	
-			      	
-						}
-				    
-						
-						return nodeServerInstance;
-					},
-					
-					
-					onConnectionToClient:(doOnConnection)=>{
-						
-						// «connection» is the only event fired by the serverSocket :
-						nodeServerInstance.serverSocket.on("connection", (clientSocket)=>{
-						
-							// DBG
-							console.log("SERVER : ON CONNECTION !");
-							
-							
-//						if(contains(nodeServerInstance.clientsSockets, clientSocket))	return;
-//						nodeServerInstance.clientsSockets.push(clientSocket);
-
-
-							const clientId="autogeneratedid_"+getUUID();
-							
-							
-							clientSocket.clientId=clientId;
-							
-							
-
-							const doOnMessage=(eventOrMessage)=>{
-								// We execute the events registration listeners entry points:
-								foreach(nodeServerInstance.receptionEntryPoints,(receptionEntryPoint,i)=>{
-									receptionEntryPoint.execute(eventOrMessage, clientSocket);
-								});
-							};
-
-		 					if(!WebsocketImplementation.useSocketIOImplementation){	clientSocket.addEventListener("message", doOnMessage);
-							// NO:	else																						clientSocket.on("message", doOnMessage);
-							}
-								
-							doOnConnection(nodeServerInstance, clientSocket);
-							
-							
-							// DBG
-							lognow("DEBUG : Starting ping-pong with client : clientSocket.clientId:",clientSocket.clientId);
-							lognow("DEBUG : WebsocketImplementation.useSocketIOImplementation:",WebsocketImplementation.useSocketIOImplementation);
-							lognow("DEBUG : clientSocket.readyState:",clientSocket.readyState);
-							
-							
-							// To make the server aware of the clients connections states :
-							clientSocket.isConnectionAlive=true;
-							clientSocket.stateCheckInterval=setInterval(()=>{
-								
-								
-							    if (clientSocket.isConnectionAlive===false){
-			    				 	
-			    				 	
-			    				 	// On today, this method is named as same for the two implementations :
-			    				 	// TRACE
-			    				 	lognow("(SERVER) Removing all listeners for client socket «"+clientSocket.clientId+"».");
-			    				 	
-			    				 	clientSocket.removeAllListeners();
-			    				 	
-			    				 	
-	    				 			// TODO : FIXME : Use one single interface !
-										if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.terminate();
-										else																										clientSocket.emit("endConnection");
-
-							    	if(!empty(nodeServerInstance.onClientLostListeners))
-							    		foreach(nodeServerInstance.onClientLostListeners,l=>{l.execute(clientSocket);});
-
-							    	// DBG
-							    	lognow("DEBUG : (SERVER) Connection closed for failed ping-pong.");
-							    	
-							    	
-			    				 	clearInterval(clientSocket.stateCheckInterval);
-							    	return;
-							    }
-							    
-							    clientSocket.isConnectionAlive=false;
-								
-//									// DBG
-//									lognow("(SERVER) DEBUG : SENDING PING");
-								
-									if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.ping();
-									// OLD :
-//								else																										clientSocket.emit("ping");
-									else 																										nodeServerInstance.send("protocol",{type:"ping"}, null, clientSocket);
-
-							    
-							}, nodeServerInstance.clientPingIntervalMillis);
-							
-							
-							if(!WebsocketImplementation.useSocketIOImplementation){
-								clientSocket.on("pong",()=>{
-									clientSocket.isConnectionAlive=true;
-								});
-							}else{
-//						// OLD :
-//							clientSocket.on("ping",()=>{
-//								clientSocket.isConnectionAlive=true;
-//							});
-
-								nodeServerInstance.receive("protocol",(message)=>{
-									if(message.type!=="pong")	return;
-									clientSocket.isConnectionAlive=true;
-								});
-								
-							}
-							
-							
-							
-						});
-						
-						
-						return nodeServerInstance;
-					},
-					
-					onFinalize:(doOnFinalizeServer)=>{
-					
-						doOnFinalizeServer(nodeServerInstance);
-					
-						// TRACE
-						console.log("INFO : SERVER : Node server setup complete.");
-						
-						return nodeServerInstance;
-					},
-					
-					addToRoom:(clientSocket,clientRoomTag)=>{
-						clientSocket.clientRoomTag=clientRoomTag;
-					},
-					
-					
-					
-			};
+			const nodeServerInstance=new NodeServerInstance(serverSocket, listenableServer);
 			
 			// Join room server part protocol :
 			nodeServerInstance.receive("protocol",(message, clientSocket)=>{
-				
 				if(message.type!=="joinRoom" || !clientSocket)	return;
 				nodeServerInstance.addToRoom(clientSocket, message.clientRoomTag);
-
 			});
 			
-			
-			
 			// To make the server aware of the clients connections states :
 			nodeServerInstance.serverSocket.on("close", function close() {
 				
@@ -5732,8 +5429,6 @@ WebsocketImplementation={
 				 	clearInterval(clientSocket.stateCheckInterval);
 				});
 			});
-			
-			
 
 			return nodeServerInstance;
 		},
@@ -5751,14 +5446,12 @@ WebsocketImplementation={
 				return WebsocketImplementation.connectToServerFromBrowser(serverURL, port, isSecure, timeout);
 		},
 		
-		
 	
 		//
 		// NODE CLIENT
 		//
 		/*private*/connectToServerFromNode:(serverURL, port, isSecure, timeout)=>{
 			
-			
 			// NODE CLIENT MODE ONLY :
 			let clientSocket;
 			if(!WebsocketImplementation.useSocketIOImplementation){
@@ -5787,219 +5480,13 @@ WebsocketImplementation={
 			// DBG
 			lognow("DEBUG : CLIENT : clientSocket created:");
 
-
-			// NODE CLIENT INSTANCE :
-			const nodeClientInstance={
-					clientSocket:clientSocket,
-			
-					receptionEntryPoints:[],
-					
-					receive:(channelNameParam, doOnIncomingMessage, clientsRoomsTag=null)=>{
-						
-						const receptionEntryPoint={
-								channelName:channelNameParam,
-								clientsRoomsTag:clientsRoomsTag, 
-								execute:(eventOrMessage)=>{
-										
-//								dataWrapped=parseJSON(dataWrapped);
-//								dataWrapped=getAt(dataWrapped,0);// We get the root element
-//								const dataWrapped=(WebsocketImplementation.useFlatStrings?parseJSON(eventOrMessage):eventOrMessage);
-										
-									const dataWrapped=WebsocketImplementation.getMessageDataBothImplementations(eventOrMessage);
-									
-									// Channel information is stored in exchanged data :
-									if(dataWrapped.channelName && dataWrapped.channelName!==channelNameParam) return;
-									
-									const clientSocket=nodeClientInstance.clientSocket;
-														
-									// Room information is stored in client socket object :
-									if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
-									
-									if(doOnIncomingMessage)	doOnIncomingMessage(dataWrapped.data, clientSocket);
-									
-									
-								}
-						};
-						
-						
-						///!!!
-						nodeClientInstance.receptionEntryPoints.push(receptionEntryPoint);
-						
-						// SPECIAL FOR THE SOCKETIO IMPLEMENTATION :
-						if(WebsocketImplementation.useSocketIOImplementation){
-							const channelName=receptionEntryPoint.channelName;
-							clientSocket.on(channelName, (eventOrMessage)=>{
-								receptionEntryPoint.execute(eventOrMessage, clientSocket);
-							});
-						}
-						
-						
-						return nodeClientInstance;
-					},
-					
-					
-
-					// TODO : FIXME : DUPLICATED CODE !
-					sendChainable:(channelNameParam, data, clientsRoomsTag=null)=>{
-						
-						// DBG
-						lognow(">>>>>>sendChainable NODE CLIENT ("+channelNameParam+"):data:",data);
-						
-						// We add a message id :
-						const messageId=getUUID();
-						data.messageId=messageId;
-						
-						// 1) We prepare the reception :
-						const resultPromise={
-							clientsRoomsTag:clientsRoomsTag,
-							messageId:messageId,
-							thenWhenReceiveMessageType:(channelNameForResponse, listenerConfig={messageType:"",condition:()=>true}, doOnIncomingMessageForResponse)=>{
-								
-								listenerConfig=nonull(listenerConfig,{messageType:"",condition:()=>true});
-								const listenerId=nonull(listenerConfig.messageType,"");
-								
-								//
-								nodeClientInstance.receive(channelNameForResponse, (dataLocal, clientSocket)=>{
-									
-									// We check if the message matches the condition :
-									if(listenerConfig.condition && !listenerConfig.condition(dataLocal, clientSocket))	return ;
-									
-									// We check if we have the same message id:
-									if(resultPromise.messageId!==dataLocal.messageId){
-										// DBG
-										lognow("resultPromise.messageId:"+resultPromise.messageId+"|dataLocal.messageId"+dataLocal.messageId);
-										return;
-									}
-									
-									doOnIncomingMessageForResponse(dataLocal, clientSocket);
-								}, resultPromise.clientsRoomsTag, listenerId, {destroyListenerAfterReceiving:true});
-								//
-								
-								return resultPromise;
-							}
-						};
-
-						// 2) We send the data :
-						nodeClientInstance.send(channelNameParam, data, clientsRoomsTag);
-						
-
-						return resultPromise;
-					},
-					
-					
-					send:(channelNameParam, data, clientsRoomsTag=null)=>{
-						
-						// // DBG
-						// lognow("(CLIENT) (NODEJS) CLIENT TRIES TO SEND !");
-						
-						
-						const clientSocket=nodeClientInstance.clientSocket;
-						
-						
-//			    // DBG
-//			    console.log("(NODE CLIENT) TRYING TO SEND : clientSocket.readyState:",clientSocket.readyState);
-
-						if(!isConnected(clientSocket))	return;
-						
-
-						// Room information is stored in client socket object :
-						if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
-						
-						// Channel information is stored in exchanged data :
-						let dataWrapped={channelName:channelNameParam, data:data};
-
-
-//					// DBG
-//			    console.log("(NODE CLIENT) SENDING DATA ! dataWrapped:",dataWrapped);
-
-
-						dataWrapped=stringifyObject(dataWrapped);
-	
-	
-//			            // DBG
-//			            console.log("(NODE CLIENT) SENDING DATA ! channelNameParam:«"+channelNameParam+"» ; clientsRoomsTag:«"+clientsRoomsTag+"»");
-//			            console.log("(NODE CLIENT) SENDING DATA ! dataWrapped:",dataWrapped);
-	
-						// TODO : FIXME : Use one single interface !
-						if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
-		      	else																										clientSocket.emit(channelNameParam,dataWrapped);
-						
-						return nodeClientInstance;
-					},
-					
-					
-					join:(clientRoomTag)=>{
-						// Join room client part protocol :
-						const message={type:"joinRoom",clientRoomTag:clientRoomTag};
-						nodeClientInstance.send("protocol",message);
-					},
-					
-					
-					onConnectionToServer:(doOnConnection)=>{
-						
-						// DBG
-						lognow("DEBUG : CLIENT : setting up onConnectionToServer.");
-						
-						const doAllOnConnection=()=>{
-							
-							// To avoid triggering this event several times, depending on the implementation : 
-							if(nodeClientInstance.hasConnectEventFired)	return;
-							nodeClientInstance.hasConnectEventFired=true;
-							
-							// DBG
-							lognow("DEBUG : CLIENT (NODEJS) : doOnConnection !");
-
-							const doOnMessage=(eventOrMessage)=>{
-								
-								// We execute the listeners entry points registration :
-								foreach(nodeClientInstance.receptionEntryPoints,(receptionEntryPoint)=>{
-									receptionEntryPoint.execute(eventOrMessage);
-								});
-
-							};
-							
-							const clientSocket=nodeClientInstance.clientSocket;
-							if(!WebsocketImplementation.useSocketIOImplementation){	clientSocket.addEventListener("message", doOnMessage);
-							// NO:	else																						clientSocket.on("message", doOnMessage);
-							}
-
-							doOnConnection(nodeClientInstance, clientSocket);
-							
-						};
-						
-
-						if(!WebsocketImplementation.useSocketIOImplementation)	nodeClientInstance.clientSocket.addEventListener("open",doAllOnConnection);
-						else																										nodeClientInstance.clientSocket.on("connect",doAllOnConnection);
-						
-						
-						// DBG
-						lognow("DEBUG : CLIENT : nodeClientInstance.clientSocket.on(connect)");
-
-						
-						// Node client ping handling :  (SocketIO implementation only)
-						if(WebsocketImplementation.useSocketIOImplementation){
-							nodeClientInstance.receive("protocol",(message)=>{
-								if(message.type!=="ping")	return;
-								nodeClientInstance.send("protocol",{type:"pong"});
-								
-								// DBG
-								lognow("DEBUG : NODE CLIENT : Pong sent.");
-							});
-						}
-						
-						
-					},
-					
-				
-			};
-			
-			
+			const nodeClientInstance=new ClientInstance(clientSocket);
 			return nodeClientInstance;
 		},
 		
-
-		
+		//
 		// BROWSER CLIENT
+		//
 		
 		/*private*/connectToServerFromBrowser:(serverURL, port, isSecure, timeout)=>{
 			
@@ -6010,228 +5497,20 @@ WebsocketImplementation={
 				return null;
 			}
 			
-			// TODO : FIXME : Use one single interface !
-			// BROWSER CLIENT MODE ONLY :
-			let clientSocket;
-			if(!WebsocketImplementation.useSocketIOImplementation){
-				clientSocket=new WebSocket(serverURL+":"+port,["ws","wss"]);
-			}else if(typeof(io)!=="undefined"){
-					// OLD SYNTAX :clientSocket=io.connect(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
-					// ALTERNATIVE :
-					clientSocket=io(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
-			}
-			
-			
-			// BROWSER CLIENT INSTANCE :
-			const browserInstance={
-				
-					clientSocket:clientSocket,
-					receptionEntryPoints:[],
-					
-					receive:(channelNameParam, doOnIncomingMessage, clientsRoomsTag=null, receptionEntryPointId=null, listenerConfig={destroyListenerAfterReceiving:false})=>{
-
-						// DBG
-						lognow("INFO : (CLIENT-BROWSER)  SETTING UP RECEIVE for :",channelNameParam);
-
-
-						const receptionEntryPoint={
-								channelName:channelNameParam,
-								clientsRoomsTag:clientsRoomsTag,
-								// TODO : ADD TO ALL OTHER SUBSYSTEMS !
-								id:receptionEntryPointId,
-								listenerConfig:listenerConfig,
-								doOnIncomingMessage:doOnIncomingMessage,
-								execute:(eventOrMessage)=>{
-										
-									const dataWrapped=WebsocketImplementation.getMessageDataBothImplementations(eventOrMessage);
-									
-									// Channel information is stored in exchanged data :
-									if(dataWrapped.channelName && dataWrapped.channelName!==receptionEntryPoint.channelName) return;
-									
-									// Room information is stored in client socket object :
-									const clientSocket=browserInstance.clientSocket;
-									if(!WebsocketImplementation.isInRoom(clientSocket, receptionEntryPoint.clientsRoomsTag)) return;
-									
-									// We remove one-time usage listeners :
-									// We remove BEFORE executing doOnIncomingMessage(), because in receptionEntryPoint function we can have other listener registration UNDER THE SAME ID !
-									if(receptionEntryPoint.listenerConfig && receptionEntryPoint.listenerConfig.destroyListenerAfterReceiving)
-										remove(browserInstance.receptionEntryPoints, receptionEntryPoint);
-									
-									if(receptionEntryPoint.doOnIncomingMessage)
-										receptionEntryPoint.doOnIncomingMessage(dataWrapped.data, clientSocket);
-										
-								}
-						};
-						
-						///!!!
-						// TODO : ADD TO ALL OTHER SUBSYSTEMS !
-						if(!contains.filter((l)=>(l.id && receptionEntryPoint.id && l.id===receptionEntryPoint.id))(browserInstance.receptionEntryPoints))
-							browserInstance.receptionEntryPoints.push(receptionEntryPoint);
-						
-						// SPECIAL FOR THE SOCKETIO IMPLEMENTATION :
-						if(WebsocketImplementation.useSocketIOImplementation){
-							const channelName=receptionEntryPoint.channelName;
-							clientSocket.on(channelName, (eventOrMessage)=>{
-								receptionEntryPoint.execute(eventOrMessage, clientSocket);
-							});
-						}
-								
-						
-						return browserInstance;
-					},
-					
-					
-
-					// TODO : FIXME : DUPLICATED CODE !
-					sendChainable:(channelNameParam, data, clientsRoomsTag=null)=>{
-						
-						// DBG
-						lognow(">>>>>>sendChainable BROWSER CLIENT ("+channelNameParam+"):data:",data);
-						
-						// We add a message id :
-						const messageId=getUUID();
-						data.messageId=messageId;
-						
-						// 1) We prepare the reception :
-						const resultPromise={
-							clientsRoomsTag:clientsRoomsTag,
-							messageId:messageId,
-							thenWhenReceiveMessageType:(channelNameForResponse, listenerConfig={messageType:"",condition:()=>true}, doOnIncomingMessageForResponse)=>{
-								listenerConfig=nonull(listenerConfig,{messageType:"",condition:()=>true});
-								const listenerId=nonull(listenerConfig.messageType,"");
-								
-								browserInstance.receive(channelNameForResponse, (dataLocal, clientSocket)=>{
-									
-									// We check if the message matches the condition :
-									if(listenerConfig.condition && !listenerConfig.condition(dataLocal, clientSocket))	return ;
-									
-									// We check if we have the same message id:
-									if(resultPromise.messageId!==dataLocal.messageId){
-										// DBG
-										lognow("resultPromise.messageId:"+resultPromise.messageId+"|dataLocal.messageId"+dataLocal.messageId);
-										return;
-									}
-									
-									doOnIncomingMessageForResponse(dataLocal, clientSocket);
-								}, resultPromise.clientsRoomsTag, listenerId, {destroyListenerAfterReceiving:true});
-								return resultPromise;
-							}
-						};
-
-						// 2) We send the data :
-						browserInstance.send(channelNameParam, data, clientsRoomsTag);
-						
-
-						return resultPromise;
-					},
-					
-					
-					
-					
-					
-					
-					send:(channelNameParam, data, clientsRoomsTag=null)=>{
-						
-						// // DBG
-						// lognow("(CLIENT) (BROWSER) CLIENT TRIES TO SEND !");
-						
-						const clientSocket=browserInstance.clientSocket;
-			    	
-								
-//					// DBG
-//					console.log("(BROWSER) TRYING TO SEND : clientSocket.readyState:",clientSocket.readyState);
-
-						if(!isConnected(clientSocket))	return;
-						
-						
-						// Room information is stored in client socket object :
-						if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
-
-						// Channel information is stored in exchanged data :
-					  let dataWrapped={channelName:channelNameParam, data:data};
-		      	
-		      	
-				    // // DBG
-				    // console.log("(BROWSER) SENDING... : dataWrapped :",dataWrapped);
-				    // console.log("(BROWSER) SENDING... : clientSocket :",clientSocket);
-
-            
-						dataWrapped=stringifyObject(dataWrapped);
-
-				   	
-		   			// TODO : FIXME : Use one single interface !
-						if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
-		      	else																										clientSocket.emit(channelNameParam,dataWrapped);
-
-						
-						return browserInstance;
-					},
-					
-					
-					join:(clientRoomTag)=>{
-						// Join room client part protocol :
-						const message={type:"joinRoom",clientRoomTag:clientRoomTag};
-						browserInstance.send("protocol",message);
-					},
-					
-					
-					onConnectionToServer:(doOnConnection)=>{
-						const doAllOnConnection=()=>{
-
-							// To avoid triggering this event several times, depending on the implementation : 
-							if(browserInstance.hasConnectEventFired)	return;
-							browserInstance.hasConnectEventFired=true;
-
-							
-							
-							// DBG
-							lognow("DEBUG : CLIENT (BROWSER) : doOnConnection !");
-							
-							const doOnMessage=(eventOrMessage)=>{
-								
-								// We execute the listeners entry points registration :
-								foreach(browserInstance.receptionEntryPoints,(receptionEntryPoint)=>{
-									receptionEntryPoint.execute(eventOrMessage);
-								});
-
-							};
-						    
-							const clientSocket=browserInstance.clientSocket;
-						  if(!WebsocketImplementation.useSocketIOImplementation){	clientSocket.addEventListener("message", doOnMessage);
-							// NO:	else																						clientSocket.on("message", doOnMessage);
-							}
-
-
-							doOnConnection(browserInstance, clientSocket);
-							
-						};
-						
-						if(!WebsocketImplementation.useSocketIOImplementation)	browserInstance.clientSocket.addEventListener("open",doAllOnConnection);
-						else																										browserInstance.clientSocket.on("connect",doAllOnConnection);
-						
-						
-						
-						// Browser client ping handling : (SocketIO implementation only)
-						if(WebsocketImplementation.useSocketIOImplementation){
-							browserInstance.receive("protocol",(message)=>{
-								if(message.type!=="ping")	return;
-								browserInstance.send("protocol",{type:"pong"});
-								
-								// DBG
-								lognow("DEBUG : BROWSER CLIENT : Pong sent.");
-							});
-						}
-						
-						
-					},
-					
-				
-			};
-			
-			
-			
+			// TODO : FIXME : Use one single interface !
+			// BROWSER CLIENT MODE ONLY :
+			let clientSocket;
+			if(!WebsocketImplementation.useSocketIOImplementation){
+				clientSocket=new WebSocket(serverURL+":"+port,["ws","wss"]);
+			}else if(typeof(io)!=="undefined"){
+					// OLD SYNTAX :clientSocket=io.connect(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
+					// ALTERNATIVE :
+					clientSocket=io(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
+			}
 			
-			return browserInstance;
+			// BROWSER CLIENT INSTANCE :
+			const browserClientInstance=new ClientInstance(clientSocket);
+			return browserClientInstance;
 		},
 
 };
@@ -7837,9 +7116,495 @@ getAORTACNode=function(nodeId=getUUID(), selfOrigin="ws://127.0.0.1:40000", outc
 
 
 
+// ==================================================================================================================
+
+class NodeServerInstance{
+	
+	constructor(serverSocket, listenableServer){
+		
+		this.onClientLostListeners=[];
+		
+		this.clientPingIntervalMillis=5000;
+		this.serverSocket=serverSocket;
+		this.listenableServer=listenableServer;
+		this.receptionEntryPoints=[];
+		
+	}
+	
+	setPingPongTimeout(clientPingIntervalMillis){
+		this.clientPingIntervalMillis=clientPingIntervalMillis;
+		return this;
+	}
+					
+	close(doOnCloseServer){
+		if(!this.serverSocket)	return;
+		this.serverSocket.close(()=>{
+			if(!this.listenableServer)	return;	
+			this.listenableServer.close(doOnCloseServer);
+		});
+	}
+					
+	receive(channelNameParam, doOnIncomingMessage, clientsRoomsTag=null){
+		const self=this;
+			
+		// DBG
+		lognow("(SERVER) Registering receive for «"+channelNameParam+"»...");
+		
+		
+		const receptionEntryPoint={
+			channelName:channelNameParam,
+			clientsRoomsTag:clientsRoomsTag, 
+			execute:(eventOrMessage, clientSocketParam)=>{
+
+			  // With «ws» library we have no choive than register message events inside a «connection» event !
+
+				const dataWrapped=WebsocketImplementation.getMessageDataBothImplementations(eventOrMessage);
+			
+				// Channel information is stored in exchanged data :
+				if(dataWrapped.channelName!==receptionEntryPoint.channelName) return;
+												
+
+				// TODO : FIXME : Use one single interface !
+				// Room information is stored in client socket object :
+				const isClientInRoom=WebsocketImplementation.isInRoom(clientSocketParam, receptionEntryPoint.clientsRoomsTag);
+				
+				// DBG
+				lognow("(SERVER) isClientInRoom:",isClientInRoom);
+				
+				if(!isClientInRoom) return;
+
+				if(doOnIncomingMessage){
+					// DBG
+					lognow("(SERVER) doOnIncomingMessage:");
+					doOnIncomingMessage(dataWrapped.data, clientSocketParam);
+				}
+				
+			},
+		};
+		
+		
+		///!!!
+		self.receptionEntryPoints.push(receptionEntryPoint);
+		
+		// SPECIAL FOR THE SOCKETIO IMPLEMENTATION :
+		if(WebsocketImplementation.useSocketIOImplementation){
+			const channelName=receptionEntryPoint.channelName;
+			clientSocket.on(channelName, (eventOrMessage)=>{
+				receptionEntryPoint.execute(eventOrMessage, clientSocket);
+			});
+		}
+		
+		return this;
+	}
+					
+					
+	send(channelName, data, clientsRoomsTag=null, clientSocketParam=null){
+						
+		// DBG
+		lognow("(SERVER) SERVER TRIES TO SEND !");
+		
+		
+		if(!clientSocketParam){
+			
+				// DBG
+				lognow("(SERVER) (server sends to all clients)");
+			
+				// TODO : FIXME : Use one single interface !
+				let serverClients;
+				if(!WebsocketImplementation.useSocketIOImplementation)	serverClients=this.serverSocket.clients;
+				else																										serverClients=this.serverSocket.sockets.sockets;
+		    
+		    
+		    serverClients.forEach((clientSocket)=>{
+		    	
+		    	
+					if(!isConnected(clientSocket))	return;
+		    	
+	
+					// Room information is stored in client socket object :
+			   	if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
+	
+		      // Channel information is stored in exchanged data :
+			   	let dataWrapped={channelName:channelName, data:data};
+	      	
+		      
+					dataWrapped=stringifyObject(dataWrapped);
+					
+					// TODO : FIXME : Use one single interface !
+	      	if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
+		      else																										clientSocket.emit(channelName,dataWrapped);
+	
+		    });
+		
+		}else{
+			
+			// DBG
+			lognow("(SERVER) (server sends to a client)");
+			
+			
+			// TODO : FIXME : Use one single interface !
+			let clientSocket=clientSocketParam;
+			if(!WebsocketImplementation.useSocketIOImplementation)	if(clientSocket.readyState!==WebSocket.OPEN)	return;
+			else																										if(clientSocket.connected)	return;
+	
+	
+			// Room information is stored in client socket object :
+	    if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
+	
+	  	// Channel information is stored in exchanged data :
+	    let dataWrapped={channelName:channelName, data:data};
+			dataWrapped=stringifyObject(dataWrapped);
+			
+			
+			// DBG
+			lognow("(SERVER) WebsocketImplementation.useSocketIOImplementation:"+WebsocketImplementation.useSocketIOImplementation);
+			
+			
+			// TODO : FIXME : Use one single interface !
+			if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
+	  	else																										clientSocket.emit(channelName,dataWrapped);
+	  	
+		}
+	  
+		
+		return this;
+	}
+					
+					
+	onConnectionToClient(doOnConnection){
+		const self=this;
+		
+		
+		// «connection» is the only event fired by the serverSocket :
+		this.serverSocket.on("connection", (clientSocket)=>{
+		
+			// DBG
+			console.log("SERVER : ON CONNECTION !");
+			
+
+			const clientId="autogeneratedid_"+getUUID();
+			
+			clientSocket.clientId=clientId;
+			
+
+			const doOnMessage=(eventOrMessage)=>{
+				// We execute the events registration listeners entry points:
+				foreach(self.receptionEntryPoints,(receptionEntryPoint,i)=>{
+					receptionEntryPoint.execute(eventOrMessage, clientSocket);
+				});
+			};
+
+			if(!WebsocketImplementation.useSocketIOImplementation)
+				clientSocket.addEventListener("message", doOnMessage);
+				
+			doOnConnection(this, clientSocket);
+			
+			
+			// DBG
+			lognow("DEBUG : Starting ping-pong with client : clientSocket.clientId:",clientSocket.clientId);
+			lognow("DEBUG : WebsocketImplementation.useSocketIOImplementation:",WebsocketImplementation.useSocketIOImplementation);
+			lognow("DEBUG : clientSocket.readyState:",clientSocket.readyState);
+			
+			
+			// To make the server aware of the clients connections states :
+			clientSocket.isConnectionAlive=true;
+			clientSocket.stateCheckInterval=setInterval(()=>{
+				
+			    if (clientSocket.isConnectionAlive===false){
+  				 	
+  				 	// On today, this method is named as same for the two implementations :
+  				 	// TRACE
+  				 	lognow("(SERVER) Removing all listeners for client socket «"+clientSocket.clientId+"».");
+  				 	
+  				 	clientSocket.removeAllListeners();
+  				 	
+			 			// TODO : FIXME : Use one single interface !
+						if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.terminate();
+						else																										clientSocket.emit("endConnection");
+
+			    	if(!empty(self.onClientLostListeners))
+			    		foreach(self.onClientLostListeners,l=>{l.execute(clientSocket);});
+
+			    	// DBG
+			    	lognow("DEBUG : (SERVER) Connection closed for failed ping-pong.");
+			    	
+			    	
+  				 	clearInterval(clientSocket.stateCheckInterval);
+			    	return;
+			    }
+			    
+			    clientSocket.isConnectionAlive=false;
+				
+					if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.ping();
+					else 																										self.send("protocol",{type:"ping"}, null, clientSocket);
+
+			    
+			}, this.clientPingIntervalMillis);
+			
+			
+			if(!WebsocketImplementation.useSocketIOImplementation){
+				clientSocket.on("pong",()=>{
+					clientSocket.isConnectionAlive=true;
+				});
+			}else{
+
+				this.receive("protocol",(message)=>{
+					if(message.type!=="pong")	return;
+					clientSocket.isConnectionAlive=true;
+				});
+				
+			}
+			
+		});
+		
+		
+		return this;
+	}
+					
+	onFinalize(doOnFinalizeServer){
+					
+		doOnFinalizeServer(this);
+	
+		// TRACE
+		console.log("INFO : SERVER : Node server setup complete.");
+		
+		return this;
+	}
+	
+	addToRoom(clientSocket, clientRoomTag){
+		clientSocket.clientRoomTag=clientRoomTag;
+	}
+
+}
+
+
+
+
+
+
+
+
+/* ## Utility network global methods in a javascript, console (nodejs), or vanilla javascript with no browser environment.
+ *
+ * This set of methods gathers utility generic-purpose methods usable in any JS project.
+ * Several authors of snippets published freely on the Internet contributed to this library.
+ * Feel free to use/modify-enhance/publish them under the terms of its license.
+ * 
+ * # Library name : «aotrautils» 
+ * # Library license : HGPL(Help Burma) (see aotra README information for details : https://alqemia.com/aotra.js )
+ * # Author name : Jérémie Ratomposon (massively helped by his native country free education system)
+ * # Author email : info@alqemia.com
+ * # Organization name : Alqemia
+ * # Organization email : admin@alqemia.com
+ * # Organization website :  https://alqemia.com
+ * 
+ *  
+ */
+
+
+
+// COMPATIBILITY browser javascript / nodejs environment :
+if(typeof(window)==="undefined")	window=global;	
+
+
+
+// ==================================================================================================================
+
+//
+// CLIENT INSTANCE :
+//
+class ClientInstance{
+
+	constructor(clientSocket){
+		this.clientSocket=clientSocket;
+		this.receptionEntryPoints=[];
+		
+	}
+		
+	receive(channelNameParam, doOnIncomingMessage, clientsRoomsTag=null, receptionEntryPointId=null, listenerConfig={destroyListenerAfterReceiving:false}){
+		const self=this;
+		
+		// DBG
+		lognow("INFO : (CLIENT-BROWSER)  SETTING UP RECEIVE for :",channelNameParam);
+
+		const receptionEntryPoint={
+				channelName:channelNameParam,
+				clientsRoomsTag:clientsRoomsTag,
+				// TODO : ADD TO ALL OTHER SUBSYSTEMS !
+				id:receptionEntryPointId,
+				listenerConfig:listenerConfig,
+				doOnIncomingMessage:doOnIncomingMessage,
+				execute:(eventOrMessage)=>{
+						
+					const dataWrapped=WebsocketImplementation.getMessageDataBothImplementations(eventOrMessage);
+					
+					// Channel information is stored in exchanged data :
+					if(dataWrapped.channelName && dataWrapped.channelName!==receptionEntryPoint.channelName) return;
+					
+					// Room information is stored in client socket object :
+					const clientSocket=self.clientSocket;
+					if(!WebsocketImplementation.isInRoom(clientSocket, receptionEntryPoint.clientsRoomsTag)) return;
+					
+					// We remove one-time usage listeners :
+					// We remove BEFORE executing doOnIncomingMessage(), because in receptionEntryPoint function we can have other listener registration UNDER THE SAME ID !
+					if(receptionEntryPoint.listenerConfig && receptionEntryPoint.listenerConfig.destroyListenerAfterReceiving)
+						remove(self.receptionEntryPoints, receptionEntryPoint);
+					
+					if(receptionEntryPoint.doOnIncomingMessage)
+						receptionEntryPoint.doOnIncomingMessage(dataWrapped.data, clientSocket);
+						
+				}
+		};
+		
+		///!!!
+		// TODO : ADD TO ALL OTHER SUBSYSTEMS !
+		if(!contains.filter((l)=>(l.id && receptionEntryPoint.id && l.id===receptionEntryPoint.id))(this.receptionEntryPoints))
+			this.receptionEntryPoints.push(receptionEntryPoint);
+		
+		// SPECIAL FOR THE SOCKETIO IMPLEMENTATION :
+		if(WebsocketImplementation.useSocketIOImplementation){
+			const channelName=receptionEntryPoint.channelName;
+			clientSocket.on(channelName, (eventOrMessage)=>{
+				receptionEntryPoint.execute(eventOrMessage, clientSocket);
+			});
+		}
+				
+		
+		return this;
+	}
+
+	
+	// TODO : FIXME : DUPLICATED CODE !
+	sendChainable(channelNameParam, data, clientsRoomsTag=null){
+		const self=this;
+		
+		// DBG
+		lognow(">>>>>>sendChainable CLIENT ("+channelNameParam+"):data:",data);
+		
+		// We add a message id :
+		const messageId=getUUID();
+		data.messageId=messageId;
+		
+		// 1) We prepare the reception :
+		const resultPromise={
+			clientsRoomsTag:clientsRoomsTag,
+			messageId:messageId,
+			thenWhenReceiveMessageType:(channelNameForResponse, listenerConfig={messageType:"",condition:()=>true}, doOnIncomingMessageForResponse)=>{
+				listenerConfig=nonull(listenerConfig,{messageType:"",condition:()=>true});
+				const listenerId=nonull(listenerConfig.messageType,"");
+				
+				//
+				self.receive(channelNameForResponse, (dataLocal, clientSocket)=>{
+					
+					// We check if the message matches the condition :
+					if(listenerConfig.condition && !listenerConfig.condition(dataLocal, clientSocket))	return ;
+					
+					// We check if we have the same message id:
+					if(resultPromise.messageId!==dataLocal.messageId){
+						// DBG
+						lognow("resultPromise.messageId:"+resultPromise.messageId+"|dataLocal.messageId"+dataLocal.messageId);
+						return;
+					}
+					
+					doOnIncomingMessageForResponse(dataLocal, clientSocket);
+				}, resultPromise.clientsRoomsTag, listenerId, {destroyListenerAfterReceiving:true});
+				//
+				
+				return resultPromise;
+			}
+		};
+
+		// 2) We send the data :
+		this.send(channelNameParam, data, clientsRoomsTag);
+		
+
+		return resultPromise;
+	}
+		
+		
+	send(channelNameParam, data, clientsRoomsTag=null){
+		
+		// // DBG
+		// lognow("(CLIENT) CLIENT TRIES TO SEND !");
+		
+		const clientSocket=this.clientSocket;
+  	
+		if(!isConnected(clientSocket))	return;
+		
+		// Room information is stored in client socket object :
+		if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
+
+		// Channel information is stored in exchanged data :
+	  let dataWrapped={channelName:channelNameParam, data:data};
+    
+		dataWrapped=stringifyObject(dataWrapped);
+   	
+		// TODO : FIXME : Use one single interface !
+		if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
+  	else																										clientSocket.emit(channelNameParam,dataWrapped);
+		
+		return this;
+	}
+	
+	
+	join(clientRoomTag){
+		// Join room client part protocol :
+		const message={type:"joinRoom",clientRoomTag:clientRoomTag};
+		this.send("protocol",message);
+	}
+		
+	
+	onConnectionToServer(doOnConnection){
+		const self=this;
+		
+		// DBG
+		lognow("DEBUG : CLIENT : setting up onConnectionToServer.");
+		
+		const doAllOnConnection=()=>{
 
+			// To avoid triggering this event several times, depending on the implementation : 
+			if(self.hasConnectEventFired)	return;
+			self.hasConnectEventFired=true;
+			
+			// DBG
+			lognow("DEBUG : CLIENT : doOnConnection !");
+			
+			const doOnMessage=(eventOrMessage)=>{
+				
+				// We execute the listeners entry points registration :
+				foreach(self.receptionEntryPoints,(receptionEntryPoint)=>{
+					receptionEntryPoint.execute(eventOrMessage);
+				});
 
+			};
+		    
+			const clientSocket=self.clientSocket;
+		  if(!WebsocketImplementation.useSocketIOImplementation){	clientSocket.addEventListener("message", doOnMessage);
+			}
 
+			doOnConnection(self, clientSocket);
+			
+		};
+		
+		if(!WebsocketImplementation.useSocketIOImplementation)	this.clientSocket.addEventListener("open",doAllOnConnection);
+		else																										this.clientSocket.on("connect",doAllOnConnection);
+		
+		
+		// Client ping handling : (SocketIO implementation only)
+		if(WebsocketImplementation.useSocketIOImplementation){
+			this.receive("protocol",(message)=>{
+				if(message.type!=="ping")	return;
+				self.send("protocol",{type:"pong"});
+				
+				// DBG
+				lognow("DEBUG : CLIENT : Pong sent.");
+			});
+		}
+		
+		
+	}
+	
+}
 
 
 /* INCLUDED EXTERNAL LIBRAIRIES

aotrautils-srv/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "aotrautils-srv",
-	"version": "0.0.1476",
+	"version": "0.0.1477",
 	"main": "aotrautils-srv.build.js",
 	"description": "A library for vanilla javascript utils (server-side) used in aotra javascript CMS",
 	"author": "Jeremie Ratomposon <info@alqemia.com> (https://alqemia.com)",