aotrautils-srv 0.0.801 → 0.0.803

aotrautils-srv/aotrautils-srv.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils COMMONS library associated with aotra version : «1_29072022-2359 (15/02/2024-00:44:20)»*/
+/*utils COMMONS library associated with aotra version : «1_29072022-2359 (21/02/2024-23:22:39)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -4086,6 +4086,122 @@ window.areEquivalentFlatMaps=function(o1,o2,UUID_ATTR_NAME=DEFAULT_UUID_ATTR_NAM
 	return areEquivalent;
 }
 
+
+window.overlaps=(delimitedObj1,delimitedObj2)=>{
+	return (delimitedObj2.start<=delimitedObj1.start && delimitedObj1.start<=delimitedObj2.end)
+			|| (delimitedObj2.start<=delimitedObj1.end   && delimitedObj1.end  <=delimitedObj2.end);
+}
+
+
+window.findCommonChunks=(str1,str2,minimalLength=2,invertLogic=false,characterFilterFunction=null)=>{
+	const results=[];
+	
+	if(empty(str1))	return results;
+	if(empty(str2))	return results;
+	
+
+	// 1) We build a binary correspondances matrix :
+	
+	const correspondancesMatrix=[];
+	
+	for(let i=0;i<str1.length;i++){
+		
+		const currentCharAtRow=str1.charAt(i);
+		
+		const row=[];
+		for(let j=0;j<str2.length;j++){
+			
+				const currentCharAtColumn=str2.charAt(j);
+
+				if(	currentCharAtColumn==currentCharAtRow 
+					&& (!characterFilterFunction || characterFilterFunction(currentCharAtColumn)))
+					row.push(true && !invertLogic);
+				else
+					row.push(false || invertLogic);
+			
+		}
+		correspondancesMatrix.push(row);
+	}
+	
+	// 2) We try to walk through the diagonal of each found correspondance to create each chunk, and removing those already walked along the way :
+	// This way we build the raw chunks dictionnary :
+	for(let i=0;i<correspondancesMatrix.length;i++){
+
+		for(let j=0;j<correspondancesMatrix[i].length;j++){
+
+			if(!correspondancesMatrix[i][j])	continue;
+			
+			let newChunk=null;
+			
+			// Proximity algorithm : Here it's just a simple diagonal walking
+			// (for blobs in a 2D image detection, instead of hunks in a string detection, it would be a recursive algorithm !)
+			let k;
+			for(k=0;(i+k)<correspondancesMatrix.length && (j+k)<correspondancesMatrix[i].length;k++){
+				
+				if(!correspondancesMatrix[i+k][j+k])		break;
+				
+				if(k==0){
+					newChunk=str1[i+k];
+				}else{
+					newChunk+=str1[i+k];
+				}
+				correspondancesMatrix[i+k][j+k]=false;
+			}
+			if(newChunk && minimalLength<=newChunk.length){
+				results.push(
+							[
+								{start:i+k-newChunk.length,end:i+k-1,value:newChunk,length:newChunk.length},
+								{start:j+k-newChunk.length,end:j+k-1,value:newChunk,length:newChunk.length}
+							]
+						);
+			}
+			
+		}
+	}
+	
+	
+	// 3) We filter all the overlapping chunks definitions, meaning when chunks overlap, only the biggest is kept !
+	
+	const refinedResults=[];
+	for(let i=0;i<results.length;i++){
+		let chunk1=results[i];
+		
+		for(let j=0;j<results.length;j++){
+			let chunk2=results[j];
+		
+			if(overlaps(chunk1[0],chunk2[0]))	continue;
+			
+			let chosenChunk=chunk1;
+			if(chunk1[0].length<chunk2[0].length)	chosenChunk=chunk2;
+			
+			refinedResults.push(chosenChunk);
+		
+		}
+	}
+	
+	// (we need to do the adding in both directions :)
+	for(let i=0;i<results.length;i++){
+		let chunk1=results[i];
+		
+		for(let j=0;j<results.length;j++){
+			let chunk2=results[j];
+		
+			if(overlaps(chunk1[1],chunk2[1]))	continue;
+			
+			let chosenChunk=chunk1;
+			if(chunk1[1].length<chunk2[1].length)	chosenChunk=chunk2;
+			
+			refinedResults.push(chosenChunk);
+		
+		}
+	}
+	
+	
+	return refinedResults;
+}
+
+
+
 window.areEquivalentSimple=function(obj1Param,obj2Param, caseSensitive=true){
 	const str1=(isString(obj1Param)?obj1Param:stringifyObject(obj1Param));
 	const str2=(isString(obj2Param)?obj2Param:stringifyObject(obj2Param));
@@ -5167,7 +5283,7 @@ AOTRAUTILS_LIB_IS_LOADED=true;
 
 	
 
-/*utils SERVER library associated with aotra version : «1_29072022-2359 (15/02/2024-00:44:20)»*/
+/*utils SERVER library associated with aotra version : «1_29072022-2359 (21/02/2024-23:22:39)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -6314,7 +6430,7 @@ WebsocketImplementation={
 
 
 
-launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, /*OPTIONAL*/sslOptions=null, httpHandlerParam=null){
+launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, /*OPTIONAL*/sslOptions=null, httpHandlerParam=null, addCORSHeader=ADD_CORS_HEADER){
 	
 	const EXCLUDED_FILENAMES_PARTS=[".keyHash."];
 	
@@ -6365,7 +6481,7 @@ launchNodeHTTPServer=function(port, doOnConnect=null, doOnFinalizeServer=null, /
 		const headers={ "Content-Type": contentType };
 
 		// To remove the CORS error message (cf. https://medium.com/@dtkatz/3-ways-to-fix-the-cors-error-and-how-access-control-allow-origin-works-d97d55946d9)
-		if(ADD_CORS_HEADER)		headers["Access-Control-Allow-Origin"]="*";
+		if(addCORSHeader)		headers["Access-Control-Allow-Origin"]="*";
 		
     
     fs.readFile(filePath, function(error, fileContent){
@@ -6836,18 +6952,18 @@ class ListManager{
 		return getArraySize(this.itemsInfos);
 	}
 	
-}
+};
 
 getListManager=function(config){
 	return new ListManager(config);
-}
+};
+
 
 
 // NO : IN A NODE CONTEXT WITH requre("") WILL RESULT IN AN UNDEFINED FUNCTION ERROR !!! 
-// function performHTTPRequestNode(url,httpMethod="GET",headers={},postRequestBodyOrNamedArgs=null){
+// function performHTTPRequestNode(...){...
 // USE THIS INSTEAD :
-performHTTPRequestNode=function(completeURL,httpMethod="GET",headers={},postRequestBodyOrNamedArgs=null){
-
+performHTTPRequestNode=function(completeURL,httpMethod="GET",headers={},requestBodyOrNamedArgs=null,addCORSHeader=ADD_CORS_HEADER){
 	
 	if(!require){
 		// TODO : FIXME : Support also a browser context!!
@@ -6855,7 +6971,7 @@ performHTTPRequestNode=function(completeURL,httpMethod="GET",headers={},postRequ
 		throw new Error("Unsupported context non-nodejs for performHTTPRequestNode().");
 	}
 	
-	const isSecure=completeURL.includes("https://");
+	const isSecure=(!empty(completeURL) && contains(completeURL.toLowerCase(),"https://"));
 	const httpHandler = isSecure?require("https"):require("http");
 	
 	// Options for the HTTP request
@@ -6868,9 +6984,19 @@ performHTTPRequestNode=function(completeURL,httpMethod="GET",headers={},postRequ
 		options.json=true;
 		headers["Content-Type"]="application/json";
 		// To remove the CORS error message (cf. https://medium.com/@dtkatz/3-ways-to-fix-the-cors-error-and-how-access-control-allow-origin-works-d97d55946d9)
-		if(ADD_CORS_HEADER)		headers["Access-Control-Allow-Origin"]="*";
+		if(addCORSHeader)		headers["Access-Control-Allow-Origin"]="*";
+	}	else if(httpMethod==="GET" && requestBodyOrNamedArgs){
+		// Not the same way to send parameters in GET http method :
+		// DBG
+		lognow("unformatted API URL : "+completeURL);
+		
+		completeURL=appendGetParameters(completeURL, requestBodyOrNamedArgs);
+		
+		// DBG
+		lognow("formatted API URL : "+completeURL);
 	}
 	
+	
   options.headers=headers;
   
 	return new Promise((resolve,reject)=>{
@@ -6889,8 +7015,17 @@ performHTTPRequestNode=function(completeURL,httpMethod="GET",headers={},postRequ
 		
 		  // The whole response has been received.
 		  response.on("end", () => {
-				const responseData=parseJSON(responseDataStr);
-				resolve(responseData);
+			
+				try{
+					const responseData=parseJSON(responseDataStr);
+					resolve(responseData, response, responseDataStr);
+				}catch(error){
+					// DBG
+					lognow("WARN : Could not JSON parse the response data ! Must deal with the string:«"+responseDataStr+"»", error);
+					resolve(responseDataStr, response, responseDataStr);
+					return;
+				}
+				
 		  });
 		});
 		
@@ -6903,8 +7038,8 @@ performHTTPRequestNode=function(completeURL,httpMethod="GET",headers={},postRequ
 		// Not the same way to send parameters in POST http method :
 		if(contains(["POST","PUT"],httpMethod)){
 			// (We need to stringify parameters or else we'll have an error :)
-			if(!empty(postRequestBodyOrNamedArgs)){
-				request.write(stringifyObject(postRequestBodyOrNamedArgs));
+			if(!empty(requestBodyOrNamedArgs)){
+				request.write(stringifyObject(requestBodyOrNamedArgs));
 			}
 		}
 		
@@ -6913,10 +7048,30 @@ performHTTPRequestNode=function(completeURL,httpMethod="GET",headers={},postRequ
 
 	});
 	
-}
+};
+
 
 
 
+replacePathVariablesNamesWithValuesIfPossible=function(apiURL, namedArgs){
+	let result=apiURL;
+	foreach(namedArgs,(namedArgValue, namedArgKey)=>{
+		result=result.replace("{"+namedArgKey+"}",namedArgValue);
+	});
+	return result;
+};
+
+appendGetParameters=function(apiURL, namedArgs){
+	let result=apiURL;
+
+	const paramCouples=[];
+	foreach(namedArgs,(value,key)=>{paramCouples.push(key+"="+value);});
+
+	if(!empty(paramCouples)) result+=("?"+paramCouples.join("&"));
+
+	return result;
+};
+
 
 /* INCLUDED EXTERNAL LIBRAIRIES
 */

aotrautils-srv/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "aotrautils-srv",
-	"version": "0.0.801",
+	"version": "0.0.803",
 	"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)",