aotrautils 0.0.1838 → 0.0.1840

aotrautils/aotrautils.build.js

@@ -1,6 +1,6 @@
 
 
-/*utils COMMONS library associated with aotra version : «1_29072022-2359 (05/04/2026-01:20:06)»*/
+/*utils COMMONS library associated with aotra version : «1_29072022-2359 (05/04/2026-12:42:00)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -4116,72 +4116,53 @@ window.instanciate=function(className=null){
 	// If class name is a simple array, a simple «[]» is enough :
 	if(className==="Array")	return [];
 
+	
 	const classInWindow=window[className];
-
 	if(!classInWindow){
 		// TRACE
 		lognow(`WARN : CAUTION : «${className}» class does not seem to be registered in the global window object. This can lead to problems instanciating it in a pure nodejs context.`);
 	}
-	
-	
-	try{
-		try{
-			newObj=Reflect.construct(classInWindow);
-		}catch(e1){
-		
-//			// TRACE
-//			console.log("WARN : Could not instanciate class «"+className+"». (Maybe class is undefined or default constructor doesn't exist !)");
-			
-			// TODO : FIXME : I don't like that at all, to use eval(...), but on today I know of no other solution... :
-			newObj=eval("new "+className+"();");
-			
-		}
-	}catch(e2){
-		
-//		// TRACE
-//		console.log("ERROR : Could not instanciate class «"+className+"» with eval. (Maybe class is undefined or default constructor doesn't exist !)");
-		
-		try{
 
-//		// TODO : FIXME : I don't like that at all, to use eval(...), but on today I know of no other solution... :
-//		newObj=eval("new window."+className+"();");
-
-			newObj=Reflect.construct(classInWindow);
-
-		
-		}catch(e3){
-		
-//			// TRACE
-//			console.log("ERROR : Could not instanciate class «"+className+"» with eval and «window.». (Maybe class is undefined or default constructor doesn't exist !)");
-//			// TRACE
-//			console.log("ERROR : Could not instanciate class «"+className+"» with Reflect and «window.». (Maybe class is undefined or default constructor doesn't exist !)");
-
-			
-			// TODO : FIXME : This is the most performance-costing fallback :
-			try{
-				
-				if(classInWindow){
-
-					newObj.__proto__=classInWindow.prototype;
-					
-				}else{
-				
-					// TODO : FIXME : I don't like that at all, to use eval(...), but on today I know of no other solution... :
-					newObj.__proto__=eval(className+".prototype");
-				}
-				
-			}catch(e4){
-				
-//				// TRACE
-//				console.log("ERROR : Could not instanciate class «"+className+"» with prototype affectation.");
-//				console.log("ERROR : Returning plain object since all instantiation methods have failed for class «"+className+"».");
-				
-			}
-
-			
-		}
-	}
 	
+// OLD :
+//	try{
+//		try{
+//			newObj=Reflect.construct(classInWindow);
+//		}catch(e1){
+////			// TRACE
+////			console.log("WARN : Could not instanciate class «"+className+"». (Maybe class is undefined or default constructor doesn't exist !)");
+//			// TODO : FIXME : I don't like that at all, to use eval(...), but on today I know of no other solution... :
+//			newObj=eval("new "+className+"();");
+//		}
+//	}catch(e2){
+////		// TRACE
+////		console.log("ERROR : Could not instanciate class «"+className+"» with eval. (Maybe class is undefined or default constructor doesn't exist !)");
+//		try{
+////		// TODO : FIXME : I don't like that at all, to use eval(...), but on today I know of no other solution... :
+////		newObj=eval("new window."+className+"();");
+//			newObj=Reflect.construct(classInWindow);
+//		}catch(e3){
+////			// TRACE
+////			console.log("ERROR : Could not instanciate class «"+className+"» with eval and «window.». (Maybe class is undefined or default constructor doesn't exist !)");
+////			console.log("ERROR : Could not instanciate class «"+className+"» with Reflect and «window.». (Maybe class is undefined or default constructor doesn't exist !)");
+//			// TODO : FIXME : This is the most performance-costing fallback :
+//			try{
+//				if(classInWindow){
+//					newObj.__proto__=classInWindow.prototype;
+//				}else{
+//				
+//					// TODO : FIXME : I don't like that at all, to use eval(...), but on today I know of no other solution... :
+//					newObj.__proto__=eval(className+".prototype");
+//				}
+//			}catch(e4){
+////				// TRACE
+////				console.log("ERROR : Could not instanciate class «"+className+"» with prototype affectation.");
+////				console.log("ERROR : Returning plain object since all instantiation methods have failed for class «"+className+"».");
+//			}
+//		}
+//	}
+
+	newObj=new classInWindow();
 	return newObj;
 };
 
@@ -5136,6 +5117,264 @@ window.getPathFileName=(path, fileSeparator="/", removeExtension=false)=>{
 }
 
 
+// -------------------------------------------------------------------------
+// ====================================================== ROUTINES ======================================================
+
+
+// ======================== Timeout ========================
+
+// CAUTION : This is not a routine, but a single-use timeout !
+window.MonoThreadedTimeout=class {
+	constructor(actuator, delayMillis){
+		this.actuator=actuator;
+	}
+	start(delayMillis=null){
+		this.started=true;
+		this.time=getNow();
+		this.delayMillis=delayMillis;
+	}
+	doStep(args=null){
+		if(!this.started)	return;
+		if(!hasDelayPassed(this.time, this.delayMillis))	return;
+		return this.stop(args);
+	}
+	stop(args=null){
+		if(!this.started)	return;
+		this.started=false;
+		if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
+		return this;
+	}
+}
+
+window.getMonoThreadedTimeout=function(actuator=null){
+	return new MonoThreadedTimeout(actuator);
+}
+
+
+// ======================== Routine ========================
+
+window.MonoThreadedRoutine=class {
+	constructor(actuator,refreshMillis=null,startDependsOnParentOnly=false){
+
+		this.actuator=actuator;
+		this.startDependsOnParentOnly=startDependsOnParentOnly;
+		this.started=false;
+		this.paused=false;
+		this.time=getNow();
+		this.refreshMillis=refreshMillis;
+		
+		this.durationTimeFactorHolder={durationTimeFactor:1};
+		// Three-states : started, paused, stopped.
+
+	}
+	
+	setDurationTimeFactorHolder(durationTimeFactorHolder){
+		this.durationTimeFactorHolder=durationTimeFactorHolder;
+		return this;
+	}
+	isStarted(){
+		return this.started || this.startDependsOnParentOnly;
+	}
+	start(args=null){
+		// if(this.isStarted()) return;
+		if(this.actuator.terminateFunction && this.actuator.terminateFunction(args)){
+			// CAUTION : Even if the routine is «pre-terminated» before even starting 
+			// (ie. its stop conditions are fullfilled even before it has started)
+			// we all the same have to trigger its stop treatments :
+			if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
+			return;
+		}
+		this.started=true;
+		this.paused=false;
+		return this;
+	}
+	stop(args=null){
+		if(!this.isStarted())	return;
+		this.started=false;
+		if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
+	}
+	pause(args=null){
+		this.paused=true;
+		if(this.actuator.doOnSuspend)	this.actuator.doOnSuspend(args);
+	}
+	resume(args=null){
+		this.paused=false;
+		if(this.actuator.doOnResume)	this.actuator.doOnResume(args);
+	}
+	isPaused(){
+		return this.paused;
+	}
+	doStep(args=null){
+		if(!this.isStarted() || this.paused)	return;
+		// Looping index with a delay :
+		
+		const delayHasPassed=hasDelayPassed(this.time, this.refreshMillis*this.durationTimeFactorHolder.getDurationTimeFactor());
+		if(!this.refreshMillis || delayHasPassed){
+			if(this.refreshMillis && delayHasPassed){
+				this.time=getNow();
+			}
+			// We perform the step :
+			if(this.actuator.terminateFunction && this.actuator.terminateFunction(args)){
+				this.stop(args);
+				return;
+			}
+			if(this.actuator.doOnEachStep)	this.actuator.doOnEachStep(args);
+		}
+		
+	}
+	
+}
+
+
+window.getMonoThreadedRoutine=function(actuator, refreshMillis=null, startDependsOnParentOnly=false){
+	return new MonoThreadedRoutine(actuator, refreshMillis, startDependsOnParentOnly);
+}
+
+
+window.MonoThreadedGoToGoal=class {
+	constructor(actuator,actualValue,goalValue,refreshMillis=null,totalTimeMillis=1000,mode="linear"){
+		
+		this.actuator=actuator;
+		
+		this.actualValue=actualValue;
+		this.mode=mode;
+		this.totalTimeMillis=totalTimeMillis;
+		this.stepValue=((refreshMillis*(goalValue-actualValue))/totalTimeMillis);
+		this.value=actualValue;
+		this.goalValue=goalValue;
+		this.started=false;
+		this.paused=false;
+		this.time=getNow();
+		this.refreshMillis=refreshMillis;
+		
+		this.durationTimeFactorHolder={durationTimeFactor:1};
+	
+		// Three-states : started, paused, stopped.
+	}
+	setDurationTimeFactorHolder(durationTimeFactorHolder){
+		this.durationTimeFactorHolder=durationTimeFactorHolder;
+		
+		// We recalculate total time-dependent values :
+		this.totalTimeMillis=this.totalTimeMillis*this.durationTimeFactorHolder.getDurationTimeFactor();
+		this.stepValue=((this.refreshMillis*(this.goalValue-this.actualValue))/this.totalTimeMillis);
+
+		return this;
+	}
+	isStarted(){
+		return this.started || this.startDependsOnParentOnly;
+	}
+	resetValueAndGoalTo(resetValue){
+		this.value=resetValue;
+		this.goalValue=resetValue;
+		return this;
+	}
+	setNewGoal(goalValue, refreshMillisParam=null, totalTimeMillis=null){
+		if(Math.round(this.value)===Math.round(goalValue))	return;
+		if(refreshMillisParam)	this.refreshMillis=refreshMillisParam;
+		if(totalTimeMillis)			this.totalTimeMillis=totalTimeMillis*this.durationTimeFactorHolder.getDurationTimeFactor();
+
+		this.goalValue=goalValue;
+		this.stepValue=((this.refreshMillis*(this.goalValue-this.value))/this.totalTimeMillis);
+		
+		if(!this.isStarted())	this.start();
+			
+		return this;
+	}
+	start(args=null){
+		
+		if(    this.value===this.goalValue
+		//  || this.isStarted();
+				|| (this.actuator.terminateFunction && this.actuator.terminateFunction())
+				|| this.hasReachedGoal()){
+
+			// CAUTION : Even if the routine is «pre-terminated» before even starting 
+			// (ie. its stop conditions are fullfilled even before it has started)
+			// we all the same have to trigger its stop treatments :
+			if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
+
+			return;
+		}
+		this.started=true;
+		this.paused=false;
+		
+		return this;
+	}
+	stop(args=null){
+		if(!this.isStarted())	return;
+		this.started=false;
+		if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
+	}
+	pause(){
+		this.paused=true;
+	}
+	resume(){
+		this.paused=false;
+	}
+	hasReachedGoal(){
+		if(this.stepValue<0){
+			if(this.value<=this.goalValue)	return true;
+		}else{
+			if(this.goalValue<=this.value)	return true;
+		}
+		return false;
+	}
+	
+	doStep(args=null){
+		if(!this.isStarted() || this.paused)	return this.value;
+
+		// Looping index with a delay :
+		
+		if(!this.refreshMillis || this.hasDelayPassed()){
+			if(this.refreshMillis && this.hasDelayPassed()){
+				this.time=getNow();
+			}
+			
+			// We check if we must stop :
+			if(this.actuator.terminateFunction){
+				if(this.actuator.terminateFunction()){
+					this.stop();
+					this.value=this.goalValue;
+					return this.value;
+				}
+			}else{
+				if(this.hasReachedGoal()){
+					this.stop();
+					this.value=this.goalValue;
+					return this.value;
+				}
+			}
+			
+			// We perform the step :
+			if(this.mode==="exponential"){
+				this.value+=Math.pow(this.stepValue,2);
+			}else{ // default is "linear"
+				this.value+=this.stepValue;
+			}
+			
+			if(this.actuator.doOnEachStep)	this.actuator.doOnEachStep(args);
+		}
+		
+		return this.value;
+	}
+	
+	hasDelayPassed(){
+		return (!this.time || hasDelayPassed(this.time, this.refreshMillis*this.durationTimeFactorHolder.getDurationTimeFactor()));
+	}
+
+	
+}
+
+
+window.getMonoThreadedGoToGoal=function(actuator,actualValue,goalValue,refreshMillis=null,totalTimeMillis=1000,mode="linear"){
+	return new MonoThreadedGoToGoal(actuator,actualValue,goalValue,refreshMillis,totalTimeMillis,mode);
+}
+
+
+// =====================================================================================================================
+
+// -------------------------------------------------------------------------
+
+
 
 // MUST REMAIN AT THE END OF THIS LIBRARY FILE !
 
@@ -5145,7 +5384,7 @@ AOTRAUTILS_LIB_IS_LOADED=true;
 
 	
 
-/*utils CLIENT library associated with aotra version : «1_29072022-2359 (05/04/2026-01:20:06)»*/
+/*utils CLIENT library associated with aotra version : «1_29072022-2359 (05/04/2026-12:42:00)»*/
 /*-----------------------------------------------------------------------------*/
 /* ## Utility global methods in a browser (htmljs) client environment.
  *
@@ -9339,260 +9578,6 @@ function getSpriteMonoThreaded(imagesPool,/*OPTIONAL*/refreshMillis=null,
 		zoomsParam);
 }
 
-// ====================================================== ROUTINES ======================================================
-
-
-// ======================== Timeout ========================
-
-// CAUTION : This is not a routine, but a single-use timeout !
-class MonoThreadedTimeout{
-	constructor(actuator, delayMillis){
-		this.actuator=actuator;
-	}
-	start(delayMillis=null){
-		this.started=true;
-		this.time=getNow();
-		this.delayMillis=delayMillis;
-	}
-	doStep(args=null){
-		if(!this.started)	return;
-		if(!hasDelayPassed(this.time, this.delayMillis))	return;
-		return this.stop(args);
-	}
-	stop(args=null){
-		if(!this.started)	return;
-		this.started=false;
-		if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
-		return this;
-	}
-}
-
-function getMonoThreadedTimeout(actuator=null){
-	return new MonoThreadedTimeout(actuator);
-}
-
-
-// ======================== Routine ========================
-
-class MonoThreadedRoutine{
-	constructor(actuator,refreshMillis=null,startDependsOnParentOnly=false){
-
-		this.actuator=actuator;
-		this.startDependsOnParentOnly=startDependsOnParentOnly;
-		this.started=false;
-		this.paused=false;
-		this.time=getNow();
-		this.refreshMillis=refreshMillis;
-		
-		this.durationTimeFactorHolder={durationTimeFactor:1};
-		// Three-states : started, paused, stopped.
-
-	}
-	
-	setDurationTimeFactorHolder(durationTimeFactorHolder){
-		this.durationTimeFactorHolder=durationTimeFactorHolder;
-		return this;
-	}
-	isStarted(){
-		return this.started || this.startDependsOnParentOnly;
-	}
-	start(args=null){
-		// if(this.isStarted()) return;
-		if(this.actuator.terminateFunction && this.actuator.terminateFunction(args)){
-			// CAUTION : Even if the routine is «pre-terminated» before even starting 
-			// (ie. its stop conditions are fullfilled even before it has started)
-			// we all the same have to trigger its stop treatments :
-			if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
-			return;
-		}
-		this.started=true;
-		this.paused=false;
-		return this;
-	}
-	stop(args=null){
-		if(!this.isStarted())	return;
-		this.started=false;
-		if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
-	}
-	pause(args=null){
-		this.paused=true;
-		if(this.actuator.doOnSuspend)	this.actuator.doOnSuspend(args);
-	}
-	resume(args=null){
-		this.paused=false;
-		if(this.actuator.doOnResume)	this.actuator.doOnResume(args);
-	}
-	isPaused(){
-		return this.paused;
-	}
-	doStep(args=null){
-		if(!this.isStarted() || this.paused)	return;
-		// Looping index with a delay :
-		
-		const delayHasPassed=hasDelayPassed(this.time, this.refreshMillis*this.durationTimeFactorHolder.getDurationTimeFactor());
-		if(!this.refreshMillis || delayHasPassed){
-			if(this.refreshMillis && delayHasPassed){
-				this.time=getNow();
-			}
-			// We perform the step :
-			if(this.actuator.terminateFunction && this.actuator.terminateFunction(args)){
-				this.stop(args);
-				return;
-			}
-			if(this.actuator.doOnEachStep)	this.actuator.doOnEachStep(args);
-		}
-		
-	}
-	
-}
-
-
-function getMonoThreadedRoutine(actuator, refreshMillis=null, startDependsOnParentOnly=false){
-	return new MonoThreadedRoutine(actuator, refreshMillis, startDependsOnParentOnly);
-}
-
-
-class MonoThreadedGoToGoal{
-	constructor(actuator,actualValue,goalValue,refreshMillis=null,totalTimeMillis=1000,mode="linear"){
-		
-		this.actuator=actuator;
-		
-		this.actualValue=actualValue;
-		this.mode=mode;
-		this.totalTimeMillis=totalTimeMillis;
-		this.stepValue=((refreshMillis*(goalValue-actualValue))/totalTimeMillis);
-		this.value=actualValue;
-		this.goalValue=goalValue;
-		this.started=false;
-		this.paused=false;
-		this.time=getNow();
-		this.refreshMillis=refreshMillis;
-		
-		this.durationTimeFactorHolder={durationTimeFactor:1};
-	
-		// Three-states : started, paused, stopped.
-	}
-	setDurationTimeFactorHolder(durationTimeFactorHolder){
-		this.durationTimeFactorHolder=durationTimeFactorHolder;
-		
-		// We recalculate total time-dependent values :
-		this.totalTimeMillis=this.totalTimeMillis*this.durationTimeFactorHolder.getDurationTimeFactor();
-		this.stepValue=((this.refreshMillis*(this.goalValue-this.actualValue))/this.totalTimeMillis);
-
-		return this;
-	}
-	isStarted(){
-		return this.started || this.startDependsOnParentOnly;
-	}
-	resetValueAndGoalTo(resetValue){
-		this.value=resetValue;
-		this.goalValue=resetValue;
-		return this;
-	}
-	setNewGoal(goalValue, refreshMillisParam=null, totalTimeMillis=null){
-		if(Math.round(this.value)===Math.round(goalValue))	return;
-		if(refreshMillisParam)	this.refreshMillis=refreshMillisParam;
-		if(totalTimeMillis)			this.totalTimeMillis=totalTimeMillis*this.durationTimeFactorHolder.getDurationTimeFactor();
-
-		this.goalValue=goalValue;
-		this.stepValue=((this.refreshMillis*(this.goalValue-this.value))/this.totalTimeMillis);
-		
-		if(!this.isStarted())	this.start();
-			
-		return this;
-	}
-	start(args=null){
-		
-		if(    this.value===this.goalValue
-		//  || this.isStarted();
-				|| (this.actuator.terminateFunction && this.actuator.terminateFunction())
-				|| this.hasReachedGoal()){
-
-			// CAUTION : Even if the routine is «pre-terminated» before even starting 
-			// (ie. its stop conditions are fullfilled even before it has started)
-			// we all the same have to trigger its stop treatments :
-			if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
-
-			return;
-		}
-		this.started=true;
-		this.paused=false;
-		
-		return this;
-	}
-	stop(args=null){
-		if(!this.isStarted())	return;
-		this.started=false;
-		if(this.actuator.doOnStop)	this.actuator.doOnStop(args);
-	}
-	pause(){
-		this.paused=true;
-	}
-	resume(){
-		this.paused=false;
-	}
-	hasReachedGoal(){
-		if(this.stepValue<0){
-			if(this.value<=this.goalValue)	return true;
-		}else{
-			if(this.goalValue<=this.value)	return true;
-		}
-		return false;
-	}
-	
-	doStep(args=null){
-		if(!this.isStarted() || this.paused)	return this.value;
-
-		// Looping index with a delay :
-		
-		if(!this.refreshMillis || this.hasDelayPassed()){
-			if(this.refreshMillis && this.hasDelayPassed()){
-				this.time=getNow();
-			}
-			
-			// We check if we must stop :
-			if(this.actuator.terminateFunction){
-				if(this.actuator.terminateFunction()){
-					this.stop();
-					this.value=this.goalValue;
-					return this.value;
-				}
-			}else{
-				if(this.hasReachedGoal()){
-					this.stop();
-					this.value=this.goalValue;
-					return this.value;
-				}
-			}
-			
-			// We perform the step :
-			if(this.mode==="exponential"){
-				this.value+=Math.pow(this.stepValue,2);
-			}else{ // default is "linear"
-				this.value+=this.stepValue;
-			}
-			
-			if(this.actuator.doOnEachStep)	this.actuator.doOnEachStep(args);
-		}
-		
-		return this.value;
-	}
-	
-	hasDelayPassed(){
-		return (!this.time || hasDelayPassed(this.time, this.refreshMillis*this.durationTimeFactorHolder.getDurationTimeFactor()));
-	}
-
-	
-}
-
-
-function getMonoThreadedGoToGoal(actuator,actualValue,goalValue,refreshMillis=null,totalTimeMillis=1000,mode="linear"){
-	return new MonoThreadedGoToGoal(actuator,actualValue,goalValue,refreshMillis,totalTimeMillis,mode);
-}
-
-
-// =====================================================================================================================
-
 
 //if signed :
 //when precision==1/10000, range is -3.2766 to 3.2766
@@ -13225,7 +13210,7 @@ createOritaMicroClient=function(url, port, isNode=false, staticMicroClientIdPara
 
 
 
-/*utils GEOMETRY library associated with aotra version : «1_29072022-2359 (05/04/2026-01:20:06)»*/
+/*utils GEOMETRY library associated with aotra version : «1_29072022-2359 (05/04/2026-12:42:00)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -14554,10 +14539,10 @@ function rayVsUnitSphereClosestPoint(p, r) {
 // MUST REMAIN AT THE END OF THIS LIBRARY FILE !
 
 AOTRAUTILS_GEOMETRY_LIB_IS_LOADED=true;
-/*utils 3D library associated with aotra version : «1_29072022-2359 (05/04/2026-01:20:06)»*/
+/*utils 3D library associated with aotra version : «1_29072022-2359 (05/04/2026-12:42:00)»*/
 /*-----------------------------------------------------------------------------*/
 
-/*utils AI library associated with aotra version : «1_29072022-2359 (05/04/2026-01:20:06)»*/
+/*utils AI library associated with aotra version : «1_29072022-2359 (05/04/2026-12:42:00)»*/
 /*-----------------------------------------------------------------------------*/
 
 
@@ -14703,7 +14688,7 @@ getOpenAIAPIClient=(modelName, apiURL, agentRole, defaultPrompt)=>{
 
 
 
-/*utils CONSOLE library associated with aotra version : «1_29072022-2359 (05/04/2026-01:20:06)»*/
+/*utils CONSOLE library associated with aotra version : «1_29072022-2359 (05/04/2026-12:42:00)»*/
 /*-----------------------------------------------------------------------------*/
 
 

aotrautils/package.json

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