aotrautils 0.0.55 → 0.0.56

aotrautils/aotrautils.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils CLIENT library associated with aotra version : «1.0.0.000 (12/07/2022-01:46:29)»*/
+/*utils CLIENT library associated with aotra version : «1.0.0.000 (12/07/2022-23:38:27)»*/
 /*-----------------------------------------------------------------------------*/
 /* ## Utility global methods in a browser (htmljs) client environment.
  *
@@ -6509,6 +6509,9 @@ initClient=function(isNodeContext=true, useSocketIOImplementation=false, doOnSer
 	aotraClient.client={};
 	aotraClient.client.start=function(){
 	
+		// DBG
+		lognow("INFO : Setting up Websocket implementation server :...");
+		
 		
 		let socketToServer=WebsocketImplementation.getStatic(isNodeContext,useSocketIOImplementation).connectToServer(url, port, isSecure, timeout);
 		if(!socketToServer){
@@ -6848,7 +6851,7 @@ createFusrodaClient=function(doOnClientReady, doOnDataReception, urlParam=null,
 
 
 
-/*utils GEOMETRY library associated with aotra version : «1.0.0.000 (12/07/2022-01:46:29)»*/
+/*utils GEOMETRY library associated with aotra version : «1.0.0.000 (12/07/2022-23:38:27)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -8054,7 +8057,1307 @@ function rayVsUnitSphereClosestPoint(p, r) {
 // MUST REMAIN AT THE END OF THIS LIBRARY FILE !
 
 AOTRAUTILS_GEOMETRY_LIB_IS_LOADED=true;
-/*utils COMMONS library associated with aotra version : «1.0.0.000 (12/07/2022-01:46:29)»*/
+/*utils SERVER library associated with aotra version : «1.0.0.000 (12/07/2022-23:38:27)»*/
+/*-----------------------------------------------------------------------------*/
+
+
+/* ## Utility global methods in a javascript, console (nodejs) server, 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;	
+
+
+
+
+// =================================================================================
+// NODEJS UTILS
+
+const FILE_ENCODING="utf8";
+
+
+// Nodejs filesystem utils :
+if(typeof(fs)==="undefined"){
+	// TRACE
+	console.log("WARN : Could not find the nodejs dependency «fs», aborting persister setup.");
+	window.getPersister=()=>{	return null;	};
+	
+}else{
+	
+	
+	window.getPersister=function(dataDirPath,suffix=""){
+		
+		let self={
+		
+			dataDirPath:dataDirPath,
+			suffix:suffix,
+			
+			//FILE_NAME_PATTERN:"data.clientId.repositoryName.json",
+			/*private*/getPath:function(clientId,repositoryName){
+		//	let path=self.FILE_NAME_PATTERN.replace(new RegExp("@clientId@","g"),clientId);
+				let path=`${self.dataDirPath}`
+								+ (blank(self.suffix)?"":(self.suffix+"."))
+								+`${clientId}.${repositoryName}.json`;
+				return path;
+			},
+			
+			readTreeObjectFromFile:function(clientId, repositoryName, CLASSNAME_ATTR_NAME=DEFAULT_CLASSNAME_ATTR_NAME){
+				
+				let path=self.getPath(clientId,repositoryName);
+				
+				let resultFlat=null;
+		
+				try{
+					resultFlat=fs.readFileSync(path, FILE_ENCODING);
+					
+				}catch(error){
+					// TRACE
+					console.log("ERROR : Could not read file «"+path+"».");
+		
+					return null;
+				}
+				
+				
+				let resultData={};
+				if(!empty(resultFlat))	resultData=JSON.parse(resultFlat);
+			
+				
+				if(!empty(resultData) && isFlatMap(resultData)){
+					
+					resultData=getAsTreeStructure(resultData,true
+							// We have to keep the type information, here too ! (in the sub-objects)
+							,false);
+		
+				}
+				
+				return resultData;
+			},
+
+			
+			saveDataToFileForClient:function(clientId,repositoryName,dataFlatForClient,forceKeepUnflatten=false,doOnSuccess=null){
+				
+				
+				
+				if(!empty(dataFlatForClient) && !isFlatMap(dataFlatForClient) && !forceKeepUnflatten){
+					dataFlatForClient=getAsFlatStructure(dataFlatForClient,true);
+				}
+				
+				// reserved characters : -/\^$*+?.()|[]{}
+				// CANNOT USE stringifyObject(...) function because we are in a common, lower-level library !
+				let dataFlatStr=JSON.stringify(dataFlatForClient)
+					// We «aerate» the produced JSON :
+					.replace(/":[\w]*\{/gim,"\":{\n").replace(/,"/gim,",\n\"")
+					// ...except for inline, escaped JSON string representations :
+					.replace(/\\\":[\w]*\{\n/gim,"\\\":{");
+					// NO : .replace(/}/gim,"}\n");
+				
+				
+				let path=self.getPath(clientId,repositoryName);
+				
+				fs.writeFile(path, dataFlatStr, FILE_ENCODING, (error) => {
+			    if(error){
+			    	// TRACE
+						console.log("ERROR : Could not write file «"+path+"»:",error);
+			    	throw error;
+			    }
+			    if(doOnSuccess)	doOnSuccess(dataFlatForClient);
+				});
+			}
+			
+		};
+		
+		
+		return self;
+	};
+	
+}
+
+
+
+// Nodejs server launching helper functions :
+//Networking management :
+//- WEBSOCKETS AND NODEJS :
+
+// -Server :
+
+// UNUSED : (BUT KEEP CODE!!)
+//getServerParams=function(portParam,isSecureParam,certPathParam,keyPathParam){
+//	
+//	// Node dependencies :
+//	// https=require("https");
+//	// fs=require("fs");
+//	
+//	if(!https){
+//		// TRACE
+//		console.log("WARN : Could not find the nodejs dependency «https», aborting SSL setup.");
+//		return null;
+//	}
+//	if(!fs){
+//		// TRACE
+//		console.log("WARN : Could not find the nodejs dependency «fs», aborting SSL setup.");
+//		return null;
+//	}
+//
+//	var result={};
+//	
+//	// We read the command-line arguments if needed :
+//	var argCLPort;
+//	var argCLCertPath;
+//	var argCLKeyPath;
+//	process.argv.forEach(function (val, i){
+//		if(i<=1)	return;
+//		else if(i==2)	argCLPort=val;
+//		else if(i==3)	argCLCertPath=val;
+//		else if(i==4)	argCLKeyPath=val;
+//	});
+//	
+//	// Console, command-line arguments OVERRIDE parameters values :
+//	
+//	result.port=nonull(argCLPort,portParam);
+//	result.certPath=null;
+//	result.keyPath=null;
+//	result.isSecure=isSecureParam;
+//	
+//	if(isSecureParam){
+//		result.certPath=nonull(argCLCertPath,certPathParam);
+//		result.keyPath=nonull(argCLKeyPath,keyPathParam);
+//	}
+//	
+//	// Eventual encryption options :
+//	result.sslOptions=null;
+//	if(isSecureParam){
+//		result.sslOptions={
+//			cert: fs.readFileSync(certPath),
+//			key: fs.readFileSync(keyPath),
+//		};
+//	}
+//	
+//	return result;
+//}
+
+
+// NODE ONLY SERVER / CLIENTS : 
+WebsocketImplementation={
+		
+		isNodeContext:true,
+		useSocketIOImplementation:false,
+		useFlatStrings:false,
+		
+		// COMMON METHODS
+		/*private static*/isInRoom(clientSocket, clientsRoomsTag){
+			return !clientsRoomsTag || empty(clientsRoomsTag) || contains(clientsRoomsTag, clientSocket.clientRoomTag);
+		},
+		
+		
+		//
+		// NODE SERVER
+		//
+		getStatic:(isNodeContext=true, useSocketIOImplementation=false)=>{
+			
+			WebsocketImplementation.isNodeContext=isNodeContext;
+			
+			// cf. https://socket.io/docs/v4/client-socket-instance/
+			WebsocketImplementation.useSocketIOImplementation=useSocketIOImplementation;
+
+			// OLD : socket.io :
+			// https://stackoverflow.com/questions/31156884/how-to-use-https-on-node-js-using-express-socket-io
+			// https://stackoverflow.com/questions/6599470/node-js-socket-io-with-ssl
+			// https://nodejs.org/api/https.html#https_https_createserver_options_requestlistener
+			
+//			if(typeof(socketIO)==="undefined"){
+//				// TRACE
+//				console.log("«socket.io» SERVER library not called yet, calling it now.");
+//				socketIO=require("socket.io");
+//				return socketIO;
+//			}
+//			if(typeof(socketIO)==="undefined"){
+//				// TRACE
+//				console.log("ERROR : «socket.io» SERVER library not found. Cannot launch nodejs server. Aborting.");
+//				return null;
+//			}
+
+			// *********************************************************************************
+			
+			// NEW : ws :
+			// https://github.com/websockets/ws#installing
+			// https://github.com/websockets/ws/blob/master/doc/ws.md#event-message
+			// ON BROWSER SIDE : Native Websockets :
+			// https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+			// https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_client_applications
+			if(typeof(WebSocket)==="undefined"){
+				WebSocket=require("ws");
+				// TRACE
+				console.log("«ws» SERVER library not called yet, calling it now.");
+				return WebsocketImplementation;
+			}
+			if(typeof(WebSocket)==="undefined"){
+				// TRACE
+				console.log("ERROR : «ws» SERVER library not found. Cannot launch nodejs server. Aborting.");
+				return null;
+			}
+			
+			return WebsocketImplementation;
+		},
+		
+		
+		getServer:(listenableServer)=>{
+			
+			if(!WebsocketImplementation.isNodeContext){
+				// TRACE
+				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 :
+			let serverSocket;
+			if(!WebsocketImplementation.useSocketIOImplementation){
+				serverSocket=new WebSocket.Server({ "server":listenableServer });
+			}else{
+				// NOW : socket.io :
+				// Loading socket.io
+				serverSocket=socketIO.listen(listenableServer);
+				
+				// Setting up the disctonnect event :
+				serverSocket.on("endConnection",()=>{
+					serverSocket.disconnect();
+				});
+				
+			}
+
+			// NODE SERVER INSTANCE :
+			const nodeServerInstance={
+					
+					onClientLostListeners:[],
+					
+					clientTimeoutMillis:20000,
+//				clientsSockets:[],
+					serverSocket:serverSocket,
+					receptionEntryPoints:[],
+					
+					receive:(channelName, doOnIncomingMessage, clientsRoomsTag=null)=>{
+						
+						const receptionEntryPoint={
+							channelName:channelName,
+							clientsRoomsTag:clientsRoomsTag, 
+							execute:(clientSocketParam)=>{
+
+								
+							// With «ws» library we have no choive than register message events inside a «connection» event !
+//						nodeServerInstance.onConnectionToClient((serverParam, clientSocketParam)=>{
+	
+							// TODO : Find a way to remove this !
+							const doOnMessage=(message)=>{
+								
+//							dataWrapped=JSON.parse(dataWrapped);
+//							dataWrapped=getAt(dataWrapped,0);// We get the root element
+								const dataWrapped=(WebsocketImplementation.useFlatStrings?JSON.parse(message):message);
+
+								
+								// Channel information is stored in exchanged data :
+								if(dataWrapped.channelName!==receptionEntryPoint.channelName) return;
+
+								
+								const clientSocket=clientSocketParam;
+
+								// TODO : FIXME : Use one single interface !
+								// Room information is stored in client socket object :
+								if(!WebsocketImplementation.isInRoom(clientSocket, receptionEntryPoint.clientsRoomsTag)) return;
+								
+								doOnIncomingMessage(dataWrapped.data, clientSocket);
+									
+						   };
+
+
+							 if(!WebsocketImplementation.useSocketIOImplementation)	clientSocketParam.addEventListener("message", doOnMessage);
+							 else																										clientSocketParam.on(channelName, doOnMessage);
+
+
+								
+								
+							},
+						};
+						
+						
+						nodeServerInstance.receptionEntryPoints.push(receptionEntryPoint);
+						
+						
+						// DBG
+						console.log("ADD RECEPTION ENTRY POINT channelName:«"+channelName+"»! nodeServerInstance.receptionEntryPoints.length:",nodeServerInstance.receptionEntryPoints.length);
+						
+						
+						return nodeServerInstance;
+					},
+					
+					
+					send:(channelName, data, clientsRoomsTag=null, clientSocketParam=null)=>{
+						
+						
+						if(!clientSocketParam){
+							
+								// TODO : FIXME : Use one single interface !
+								let serverClients;
+								if(!WebsocketImplementation.useSocketIOImplementation)	serverClients=nodeServerInstance.serverSocket.clients;
+								else																										serverClients=nodeServerInstance.serverSocket.sockets.clients();
+						    
+						    serverClients.forEach((clientSocket)=>{
+						    	
+						    	
+				    				// TODO : FIXME : Use one single interface !
+									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=JSON.stringify(dataWrapped);
+									
+							// TODO : FIXME : Use one single interface !
+					      	if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
+						      else																										clientSocket.emit(channelName,dataWrapped);
+
+						    });
+						
+						}else{
+							
+							// 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=JSON.stringify(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);
+
+
+							// DBG
+							console.log("nodeServerInstance.receptionEntryPoints.length:",nodeServerInstance.receptionEntryPoints.length);
+
+
+		
+							// We execute the events registration listeners entry points:
+							foreach(nodeServerInstance.receptionEntryPoints,(receptionEntryPoint)=>{
+							
+								// DBG
+								console.log("ENTRY POINT !");
+							
+								receptionEntryPoint.execute(clientSocket);
+							});
+
+
+							doOnConnection(nodeServerInstance, clientSocket);
+							
+							
+							
+							
+							// To make the server aware of the clients connections states :
+							clientSocket.stateCheckInterval=setInterval(()=>{
+								
+								
+							    if (clientSocket.isAlive===false){
+			    				 	clearInterval(clientSocket.stateCheckInterval);
+			    				 	
+	    				 			// TODO : FIXME : DUPLICATED CODE :
+	    				 			// TODO : FIXME : Use one single interface !
+										if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.terminate();
+										else																										clientSocket.emit("endConnection");
+
+	    				 			// TODO : FIXME : DUPLICATED CODE :
+							    	if(!empty(nodeServerInstance.onClientLostListeners))
+							    		foreach(nodeServerInstance.onClientLostListeners,l=>{l.execute(clientSocket);});
+							    	
+							    	return;
+							    }
+							    
+							    clientSocket.isAlive=false;
+							    try{
+							    	clientSocket.ping();
+							    }catch(error){
+							    	lognow("ERROR : A problem occurred when tried to ping client socket : ",error);
+							    	// We effectively end the client connection to this server :
+
+										// TODO : FIXME : DUPLICATED CODE :
+										// TODO : FIXME : Use one single interface !
+										if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.terminate();
+										else																										clientSocket.emit("endConnection");
+
+	    				 			// TODO : FIXME : DUPLICATED CODE :
+							    	if(!empty(nodeServerInstance.onClientLostListeners))
+							    		foreach(nodeServerInstance.onClientLostListeners,l=>{l.execute(clientSocket);});
+
+							    	return;
+							    }
+							    
+							    
+							}, nodeServerInstance.clientTimeoutMillis);
+							clientSocket.on("pong",()=>{
+								clientSocket.isAlive=true;
+							});
+							
+							
+							
+						});
+						
+						
+						return nodeServerInstance;
+					},
+					
+					onFinalize:(doOnFinalizeServer)=>{
+					
+						doOnFinalizeServer(nodeServerInstance);
+					
+						// TRACE
+						console.log("INFO : SERVER : Node server setup complete.");
+						
+						return nodeServerInstance;
+					},
+					
+					addToRoom:(clientSocket,clientRoomTag)=>{
+						clientSocket.clientRoomTag=clientRoomTag;
+					},
+					
+					
+					
+			};
+			
+			// 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() {
+				
+				// TODO : FIXME : Use one single interface !
+				if(!WebsocketImplementation.useSocketIOImplementation)	serverClients=nodeServerInstance.serverSocket.clients;
+				else																										serverClients=nodeServerInstance.serverSocket.sockets.clients();
+				
+				serverClients.forEach((clientSocket)=>{
+				 	clearInterval(clientSocket.stateCheckInterval);
+				});
+			});
+			
+			
+			
+			return nodeServerInstance;
+		},
+		
+		
+		// NODE / BROWSER CLIENT CONNECTS TO SERVER MAIN ENTRYPOINT:
+		connectToServer:(serverURL, port, isSecure=false, timeout)=>{
+
+			// TRACE
+			lognow("INFO : Using websocket implementation : "+(WebsocketImplementation.isNodeContext?"node (server-side)":"browser (client-side)"));
+
+			if(WebsocketImplementation.isNodeContext)
+				return WebsocketImplementation.connectToServerFromNode(serverURL, port, isSecure, timeout);
+			else
+				return WebsocketImplementation.connectToServerFromBrowser(serverURL, port, isSecure, timeout);
+		},
+		
+		
+	
+		//
+		// NODE CLIENT
+		//
+		/*private*/connectToServerFromNode:(serverURL, port, isSecure, timeout)=>{
+			
+			
+			
+			// NEW : ws :
+			if(typeof(WebSocket)==="undefined"){
+				// TRACE
+				lognow("ERROR : CLIENT : Could not find websocket client lib, aborting client connection.");
+				return null;
+			}
+			
+			// NODE CLIENT MODE ONLY :
+			let clientSocket;
+			if(!WebsocketImplementation.useSocketIOImplementation){
+				clientSocket=new WebSocket(serverURL+":"+port,/*WORKAROUND:*/{ rejectUnauthorized:false, secure: isSecure });
+			}else{
+				// NOW : socket.io :
+				//client on server-side:
+				if(WebsocketImplementation.isNodeContext && typeof(socketIO)!=="undefined"){
+				//		// Node client :
+				//		connectToServer=function (serverURL, port, isSecure, timeout=10000){
+				//			return socketIO.connect(serverURL + ":" + port,{timeout: timeout});
+				//		}
+					clientSocket=socketIO.connect(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
+				}
+			}
+
+			// NODE CLIENT INSTANCE :
+			const nodeClientInstance={
+					clientSocket:clientSocket,
+			
+					receptionEntryPoints:[],
+					
+					receive:(channelName, doOnIncomingMessage, clientsRoomsTag=null)=>{
+						
+						const receptionEntryPoint={
+								channelName:channelName,
+								clientsRoomsTag:clientsRoomsTag, 
+								execute:(clientSocketParam)=>{
+									
+									const doOnMessage=(message)=>{
+										
+//									dataWrapped=JSON.parse(dataWrapped);
+//									dataWrapped=getAt(dataWrapped,0);// We get the root element
+																		
+										const dataWrapped=(WebsocketImplementation.useFlatStrings?JSON.parse(message):message);
+										
+										
+										// Channel information is stored in exchanged data :
+										if(dataWrapped.channelName && dataWrapped.channelName!==channelName) return;
+										
+										let clientSocket=nodeClientInstance.clientSocket;
+										
+										// Room information is stored in client socket object :
+										if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
+										
+										doOnIncomingMessage(dataWrapped.data, clientSocket);
+										
+									};
+									
+									if(!WebsocketImplementation.useSocketIOImplementation)	nodeClientInstance.clientSocket.addEventListener("message", doOnMessage);
+									else																										nodeClientInstance.clientSocket.on(channelName, doOnMessage);
+
+									
+								}
+						};
+						
+						
+						nodeClientInstance.receptionEntryPoints.push(receptionEntryPoint);
+						
+						return nodeClientInstance;
+					},
+					
+					
+					send:(channelName, data, clientsRoomsTag=null)=>{
+						
+						let clientSocket=nodeClientInstance.clientSocket;
+						
+						
+//			    // DBG
+//			    console.log("(NODE CLIENT) TRYING TO SEND : clientSocket.readyState:",clientSocket.readyState);
+
+						// TODO : FIXME : Use one single interface !
+						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};
+
+
+//					// DBG
+//			    console.log("(NODE CLIENT) SENDING DATA ! dataWrapped:",dataWrapped);
+
+
+						dataWrapped=JSON.stringify(dataWrapped);
+	
+	
+//			            // DBG
+//			            console.log("(NODE CLIENT) SENDING DATA ! channelName:«"+channelName+"» ; 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(channelName,dataWrapped);
+						
+						return nodeClientInstance;
+					},
+					
+					
+					join:(clientRoomTag)=>{
+						// Join room client part protocol :
+						const message={type:"joinRoom",clientRoomTag:clientRoomTag};
+						
+						nodeClientInstance.send("protocol",message);
+						
+					},
+					
+					
+					onConnectionToServer:(doOnConnection)=>{
+						
+						const doAllOnConnection=()=>{
+							
+							// To avoid triggering this event several times, depending on the implementation : 
+							if(nodeClientInstance.hasConnectEventFired)	return;
+							nodeClientInstance.hasConnectEventFired=true;
+							
+							let clientSocket=nodeClientInstance.clientSocket;
+							
+							doOnConnection(nodeClientInstance, clientSocket);
+							
+							// We execute the listeners entry points:
+							foreach(nodeClientInstance.receptionEntryPoints,(receptionEntryPoint)=>{
+								receptionEntryPoint.execute(clientSocket);
+							});
+							
+						};
+
+						if(!WebsocketImplementation.useSocketIOImplementation)	nodeClientInstance.clientSocket.addEventListener("open",doAllOnConnection);
+						else																										nodeClientInstance.clientSocket.on("connect",doAllOnConnection);
+						
+					},
+					
+				
+			};
+			
+			
+			return nodeClientInstance;
+		},
+		
+
+		
+		// BROWSER CLIENT
+		
+		/*private*/connectToServerFromBrowser:(serverURL, port, isSecure, timeout)=>{
+			
+			// NEW : ws :
+			if(typeof(WebSocket)==="undefined"){
+				// TRACE
+				lognow("ERROR : CLIENT : Could not find websocket client lib, aborting client connection.");
+				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"){
+				// NOW : socket.io :
+				//				// Browser client :
+				//				connectToServer=function (server, port, isSecure, timeout=10000){
+				//					return io.connect(serverURL + ":" + port,{timeout: timeout});
+				////				ALTERNATIVE : return io(serverURL + ":" + port,{timeout: timeout});
+				//				};
+				//			}else{
+				//				// TRACE
+				//				console.log("ERROR : Could not initialize socket !");
+					clientSocket=io.connect(serverURL + ":" + port,{timeout: timeout, secure: isSecure});
+			}
+			
+			
+			// BROWSER CLIENT INSTANCE :
+			const browserInstance={
+					clientSocket:clientSocket,
+					
+					receive:(channelName, doOnIncomingMessage, clientsRoomsTag=null)=>{
+
+						// DBG
+						lognow("!!! SETTING UP RECEIVE for :",channelName);
+						
+						const doOnMessage=(message)=>{
+							
+//							// DBG
+//							lognow("!!! RECEIVED : message",message);
+								
+								// OLD : let dataWrapped=JSON.parse(event.data);
+//							const dataWrapped=JSON.parse(message);
+//							dataWrapped=getAt(dataWrapped,0);// We get the root element
+
+								const dataWrapped=(WebsocketImplementation.useFlatStrings?JSON.parse(message):message);
+							
+								
+								// Channel information is stored in exchanged data :
+								if(dataWrapped.channelName && dataWrapped.channelName!==channelName) return;
+	
+								let clientSocket=browserInstance.clientSocket;
+	
+								// Room information is stored in client socket object :
+								if(!WebsocketImplementation.isInRoom(clientSocket,clientsRoomsTag)) return;
+	
+								doOnIncomingMessage(dataWrapped.data, clientSocket);
+					    	
+					    };
+					   
+					    
+					   if(!WebsocketImplementation.useSocketIOImplementation)	browserInstance.clientSocket.addEventListener("message", doOnMessage);
+						 else																										browserInstance.clientSocket.on(channelName, doOnMessage);
+
+						
+						 return browserInstance;
+					},
+					
+					
+					send:(channelName, data, clientsRoomsTag=null)=>{
+						
+						let clientSocket=browserInstance.clientSocket;
+			    	
+								
+//					// DBG
+//					console.log("(BROWSER) TRYING TO SEND : clientSocket.readyState:",clientSocket.readyState);
+
+						// TODO : FIXME : Use one single interface !
+						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};
+		      	
+		      	
+//			    // DBG
+//			    console.log("(BROWSER) SENDING... : dataWrapped :",dataWrapped);
+
+            
+						dataWrapped=JSON.stringify(dataWrapped);
+
+				   	
+		   				// TODO : FIXME : Use one single interface !
+						if(!WebsocketImplementation.useSocketIOImplementation)	clientSocket.send(dataWrapped);
+		      	else																										clientSocket.emit(channelName,dataWrapped);
+
+						
+						return browserInstance;
+					},
+					
+					
+					join:(clientRoomTag)=>{
+						// Join room client part protocol :
+						const message={type:"joinRoom",clientRoomTag:clientRoomTag};
+						browserInstance.send("protocol",message);
+					},
+					
+					
+					onConnectionToServer:(doOnConnection)=>{
+						
+						// To avoid triggering this event several times, depending on the implementation : 
+						if(browserInstance.hasConnectEventFired)	return;
+						browserInstance.hasConnectEventFired=true;
+						
+						if(!WebsocketImplementation.useSocketIOImplementation)	browserInstance.clientSocket.addEventListener("open",doOnConnection);
+						else																										browserInstance.clientSocket.on("connect",doOnConnection);
+						
+						
+					},
+					
+				
+			};
+			
+			
+			return browserInstance;
+		},
+
+};
+
+
+
+launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, /*OPTIONAL*/sslOptions=null){
+	
+	const EXCLUDED_FILENAMES_PARTS=[".saltkey."];
+	
+	
+	if(typeof(https)==="undefined"){
+		// TRACE
+		console.log("«https» SERVER library not called yet, calling it now.");
+		https=require("https");
+	}
+	if(typeof(http)==="undefined"){
+		// TRACE
+		console.log("«http» SERVER library not called yet, calling it now.");
+		http=require("http");
+	}
+	
+	
+	const handler=function(request, response){
+		
+		const url=request.url;
+
+		let isURLInExclusionZone=!!foreach(EXCLUDED_FILENAMES_PARTS,(excludedStr)=>{
+			if(contains(url,excludedStr)){
+				return true;
+			}
+		});
+		
+		if(isURLInExclusionZone){
+      	// TRACE
+      	console.log("ERROR 403 forbidden access error :");
+      	console.log(error);
+      	
+      	response.writeHead(403);
+        response.end("Sorry, cannot access resource : error: "+error.code+" ..\n");
+        response.end();
+        return;
+		}
+		
+
+		const urlFile="." + url;
+		
+		let filePath=urlFile.indexOf("?")!==-1?urlFile.split("?")[0]:urlFile;
+    	if(filePath == "./") filePath="./index.html";
+
+   	 	let extname=path.extname(filePath);
+    	let contentType="text/html";
+			
+	    
+	    fs.readFile(filePath, function(error, fileContent){
+	      if(error){
+	          if(error.code == "ENOENT"){
+	          	// TRACE
+	          	console.log("ERROR 404 file not found :"+filePath);
+	          	
+	            fs.readFile("./404.html", function(error, fileContent){
+	            	response.writeHead(200, { "Content-Type": contentType });
+	                response.end(fileContent, "utf-8");
+	            });
+	              
+	          }else {
+	
+	        	// TRACE
+	          	console.log("ERROR 500 server error :");
+	          	console.log(error);
+	          	
+	          	response.writeHead(500);
+	            response.end("Sorry, check with the site admin for error: "+error.code+" ..\n");
+	            response.end(); 
+	            
+	          }
+	      }else {
+	    	
+	    	// TRACE
+	      	console.log("INFO 200 OK :"+filePath);
+	
+	      	response.writeHead(200, { "Content-Type": contentType });
+	        response.end(fileContent, "utf-8");
+	        
+    		// res.writeHead(200);
+    		// res.end("hello world\n");
+    		// res.sendFile(__dirname + "/public/index.html");
+	    		
+	      }
+	    });
+      
+	};
+	
+	
+	let listenableServer;
+	if(sslOptions){
+		let httpsServer=https.createServer(sslOptions, handler).listen(port);
+		// TRACE
+		console.log("INFO : SERVER : HTTPS Server launched and listening on port " + port + "!");
+		listenableServer=httpsServer;
+	}else{
+		let httpServer=http.createServer(handler).listen(port);
+		// TRACE
+		console.log("INFO : SERVER : HTTP Server launched and listening on port " + port + "!");
+		listenableServer=httpServer;
+	}
+
+	
+	const server=WebsocketImplementation.getStatic(true).getServer(listenableServer);
+	
+	// When a client connects, we execute the callback :
+	// CAUTION : MUST BE CALLED ONLY ONCE !
+	server.onConnectionToClient((serverParam, clientSocketParam)=>{
+		if(doOnConnect) doOnConnect(serverParam, clientSocketParam);
+	});
+
+
+	server.onFinalize((serverParam)=>{
+		if(doOnFinalizeServer)	doOnFinalizeServer(serverParam);
+	});
+	
+
+	// TRACE
+	console.log("INFO : SERVER : Generic Nodejs server launched and listening on port:" + port + "!");
+
+
+	return server;
+}
+
+
+initNodeServer=function(doOnClientConnection=null, doOnFinalizeServer=null, /*OPTIONAL*/portParam, /*OPTIONAL*/certPathParam, /*OPTIONAL*/keyPathParam){
+
+	// TRACE
+	console.log("Server launched.");
+	console.log("Usage :													node <server.js> conf {port:[port], sslCertPath:[ssl certificate path | unsecure ], sslKeyPath:[ssl key path], serverConfig:[JSON server configuration]}");
+	console.log("Or (to generate password hash) :	node <server.js> hash <clientId@repositoryName> <clearTextSecretString>");
+	// 			EXAMPLE : 							node orita-srv.js hash orita.global@saltkey 1234567890
+	console.log("Server launched.");
+	
+	// We read the command-line arguments if needed :
+
+	let argCLPort;
+	let argCLCertPath;
+	let argCLKeyPath;
+	let serverConfig={};
+	let isForceUnsecure;
+
+	let isHashAsked=false;
+	let clearTextParam=null;
+	let persisterId=null;
+	
+	
+	process.argv.forEach(function (val, i){
+		if(!val)	return;
+		// 0 corresponds to «node / nodejs»
+		if(i<=1)	return; // 1 corresponds to « <server.js> »
+		else if(i==2){
+			if(val==="hash")		isHashAsked=true;
+		}else if(i==3){
+			if(!isHashAsked){
+				try{
+					const jsonConf=JSON.parse(val);	
+					argCLPort=jsonConf.port;
+					argCLCertPath=jsonConf.sslCertPath;
+					argCLKeyPath=jsonConf.sslKeyPath;
+					serverConfig=nonull({},jsonConf.serverConfig);
+				}catch(err1){
+					lognow("ERROR : Cannot parse argument JSON string «"+val+"».",err1);
+				}
+			}	else						persisterId=val;
+		}else if(i==4){
+			if(isHashAsked)		clearTextParam=val;
+		}
+	});
+	isForceUnsecure=(argCLCertPath==="unsecure");
+
+	
+	const aotraNodeServer={config:serverConfig};
+	aotraNodeServer.serverManager={ start:()=>{/*DEFAULT START FUNCTION, WILL BE OVERRIDEN LATER*/}};
+
+	if(isHashAsked){
+		// We isntanciate a temporary persister just to read the saltkey file:
+		const persister=getPersister("./");
+		let persisterIdSplits=persisterId.split("@");
+		if(empty(persisterIdSplits) || persisterIdSplits.length!=2){
+			// TRACE
+			console.log("ERROR : No persister repository IDs provided correctly. Cannot read saltkey. Aborting hash generation.");
+			return aotraNodeServer;
+		}
+		const persisterClientId=persisterIdSplits[0];
+		const persisterRepositoryName=persisterIdSplits[1];
+		let globalSaltkeyObject=persister.readTreeObjectFromFile(persisterClientId, persisterRepositoryName);
+		if(!globalSaltkeyObject || !globalSaltkeyObject.saltkey){
+			// TRACE
+			console.log("WARN : No saltkey found. Generating one now.");
+			globalSaltkeyObject={saltkey:getUUID(), hashes:[]};
+			persister.saveDataToFileForClient(persisterClientId,persisterRepositoryName,globalSaltkeyObject,false,()=>{
+				// TRACE
+				console.log("INFO : Saltkey generated and saved successfully.");
+			});
+		}
+		const globalSaltkey=globalSaltkeyObject.saltkey;
+		
+		let firstHash=getHashedString(clearTextParam);
+		
+		let generatedHash=getHashedString( firstHash + globalSaltkey, true);// (we use the heavy treatment thing.)
+		globalSaltkeyObject.hashes.push(generatedHash);
+
+		// We update the repository :
+		persister.saveDataToFileForClient(persisterClientId,persisterRepositoryName,globalSaltkeyObject,false,()=>{
+			// TRACE
+			console.log("INFO : Hash added to repository and saved successfully.");
+		});
+		
+		// OUTPUT
+		console.log("Here is your key : share it with your clients but DO NOT LEAK IT !\n********************\n"+clearTextParam+"\n********************\n");
+		
+		return aotraNodeServer;
+	}
+
+	
+	const DEFAULT_PORT=nonull(argCLPort,25000);
+	const DEFAULT_CERT_PATH=nonull(argCLCertPath,"cert.pem");
+	const DEFAULT_KEY_PATH=nonull(argCLKeyPath,"key.key");
+
+	
+	let port=portParam ? portParam : DEFAULT_PORT;
+	let certPath=null;
+	let keyPath=null;
+
+	if(!isForceUnsecure){
+		certPath=certPathParam?certPathParam:DEFAULT_CERT_PATH;
+		keyPath=keyPathParam?keyPathParam:DEFAULT_KEY_PATH;
+	}
+
+	
+	// UNUSEFUL :
+//aotraNodeServer.serverManager.microClientsSockets=[];
+	// UNUSEFUL :
+//aotraNodeServer.serverManager.mainClientsSockets=[];
+	aotraNodeServer.serverManager.start=function(){
+
+		// Eventual encryption options : 
+		let sslOptions=null; 
+		if(!isForceUnsecure){
+			if(!fs){
+				// TRACE
+				lognow("ERROR : «fs» node subsystem not present, cannot access files. Aborting SSL configuration of server.");
+			}else{
+				try{
+		  		sslOptions={
+		  			cert: fs.readFileSync(certPath),
+		  			key: fs.readFileSync(keyPath),
+		  		};
+				}catch(exception){
+					// TRACE
+					lognow("ERROR : Could not open SSL files certPath:«"+certPath+"» or keyPath:«"+keyPath+"». Aborting SSL configuration of server.");
+				}
+			}
+		}
+		
+		aotraNodeServer.server=launchNodeHTTPServer(port, doOnClientConnection, doOnFinalizeServer, sslOptions);
+		
+
+		return aotraNodeServer;
+	};
+
+	return aotraNodeServer;
+}
+
+// ========================= FUSRODA SERVER : =========================
+
+//
+// DOES NOT WORK : USE Java FusrodaServer instead :
+//
+///*FUSRODA server stands from FSRD SERVER, for Fucking Simple Remote Desktop SERVER*/
+//createFusrodaServer=function(certPathParam=null,keyPathParam=null,portParam=6080){
+//	
+//	// https://www.npmjs.com/package/screenshot-desktop
+//	// https://github.com/octalmage/robotjs
+//	// npm install --save screenshot-desktop
+//	//
+//	// sudo apt-get install libxtst-dev libx11-dev
+//	// npm install --save robotjs
+//	
+//	// http://getrobot.net/docs/usage.html
+//	// 
+//	// apt-get install build-essential python libxt-dev libxtst-dev libxinerama-dev -y 
+//	
+//	const screenshot=require("screenshot-desktop");
+//
+//	const REFRESH_SCREENSHOTS_MILLIS=500;
+//
+//	
+//	const server=initNodeServer(
+//		// On client connection :
+////	(serverParam, clientSocketParam)=>{},
+//		null,
+//		// On server finalization :
+//		(serverParam)=>{
+//
+//			serverParam.receive("protocol_fusroda", (message, clientSocket)=> {
+//				serverParam.addToRoom(clientSocket,"clients");
+//			});
+//			
+//			
+//			serverParam.sendScreenshotsRoutine=setInterval(()=>{
+//				if(serverParam.isScreenshotStarted)	return;
+//				
+//				serverParam.isScreenshotStarted=true;		
+//			
+//				screenshot().then((img) => {
+//	
+//					const data={image:img,messageType:"imageData"};
+//					serverParam.send("message", data, "clients");
+//					
+//					serverParam.isScreenshotStarted=false;		
+//
+//				}).catch((error) => {
+//				  // TRACE
+//					lognow("ERROR : Error during screenshot :",error);
+//				});
+//				
+//			},REFRESH_SCREENSHOTS_MILLIS);
+//			
+//			
+//		},portParam,certPathParam,keyPathParam);
+//
+//
+////	const doOnConnect=(serverParam, clientSocketParam)=>{
+////	};
+////	const doOnFinalizeServer=(serverParam)=>{
+////		/*DO NOTHING*/
+////	};
+////	const server={};
+////	server.start=(port=6080)=>{
+////		server.httpServer=launchNodeHTTPServer(port, doOnConnect, doOnFinalizeServer, sslOptions);
+////	};
+//
+//	return server;
+//}
+
+
+// ========================= UTILITY SERVERSIDE METHODS : =========================
+
+class ListManager{
+	constructor(config){
+		this.config=config;
+		this.maxItemsNumber=nonull(this.config.max,999);
+		this.simultaneousItemsNumber=nonull(this.config.simultaneous,1);
+		this.sessionDurationSeconds=nonull(this.config.duration,null);
+		this.mode=nonull(this.config.mode,"startAtConnexion");
+		
+		this.itemsInfos={};
+		this.time=null;
+		this.started=false;
+	}
+	
+	addItem(id,item){
+		if(id==null){
+			// TRACE
+			lognow("ERROR : Cannot add item with no id.");
+			return;
+		}
+		if(!item){
+			// TRACE
+			lognow("ERROR : Cannot add null item.");
+			return;
+		}
+		const numberOfItemsCurrently=countKeys(this.itemsInfos);
+		if(this.maxItemsNumber<=numberOfItemsCurrently){
+			// TRACE
+			lognow("ERROR : Cannot add item with id «"+id+"», list already full.");
+			return;
+		}
+		if(numberOfItemsCurrently==0 && this.mode==="startAtConnexion"){
+			this.startSession();
+		}
+		this.itemsInfos[id]={
+			item:item,
+			time:getNow(),
+		};
+	}
+	
+	startSession(){
+		this.time==getNow();
+		this.started=true;
+	}
+	
+	stopSession(){
+		this.started=false;
+	}
+	
+	isSessionActive(){
+		if(!this.sessionDurationSeconds)	return true;
+		if(!this.started)									return false;
+		return !hasDelayPassed(this.time, this.sessionDurationSeconds*1000);
+	}
+	
+	isClientActive(clientId){
+		if(!clientsListManager.isSessionActive())	return false;
+		const clientPosition=this.getItemPosition(clientId);
+		const result=(clientPosition<=this.maxItemsNumber);
+		return result;
+	}
+	
+	removeItem(id){
+		if(id==null){
+			// TRACE
+			lognow("ERROR : Cannot remove item, no id specified.");
+			return;
+		}
+		if(!this.itemsInfos[id]){
+			// TRACE
+			lognow("ERROR : Cannot remove item, item not found for id «"+id+"».");
+			return;
+		}
+		delete this.itemsInfos[id];
+	}
+
+	// Goes from 1 to <length>:
+	getItemPosition(id){
+		if(id==null){
+			// TRACE
+			lognow("ERROR : Cannot calculate item position, no id specified.");
+			return;
+		}
+		if(!this.itemsInfos[id]){
+			// TRACE
+			lognow("ERROR : Cannot calculate item position, item not found for id «"+id+"».");
+			return;
+		}
+		let result=0;
+		foreach(this.itemsInfos,(itemInfo,key)=>{
+			result++;
+			if(id==key)	return "break";
+		},null,(itemInfo1,itemInfo2)=>item1.time<item2.time);
+		return result;
+	}
+
+	
+}
+
+function getListManager(config){
+	return new ListManager(config);
+}
+
+
+
+
+
+
+
+
+/*utils COMMONS library associated with aotra version : «1.0.0.000 (12/07/2022-23:38:27)»*/
 /*-----------------------------------------------------------------------------*/
 
 

aotrautils/package.json

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