x4js 2.2.47 → 2.2.50

package/src/core/core_element.ts

@@ -17,6 +17,13 @@
 import { EventMap, EventSource } from './core_events';
 
 
+interface TimerEntry {
+	cb: Function;
+	id: number;
+	clear: Function;
+}
+
+
 /**
  * CoreElement
  *
@@ -77,10 +84,14 @@ import { EventMap, EventSource } from './core_events';
  * el.clearInterval("poll");
  * ```
  */
+
 export class CoreElement<E extends EventMap = EventMap> {
 
 	#events: EventSource<E>;
-	#timers: Map<string, Function>;
+	#timers: Map<string, TimerEntry>;
+	#cleanup: Function[];
+
+	/** changed to stop timers when object is down
 
 	private __startTimer( name: string, ms: number, repeat: boolean, callback: ( ) => void ) {
 		if (!this.#timers) {
@@ -102,6 +113,69 @@ export class CoreElement<E extends EventMap = EventMap> {
 		const clear = this.#timers?.get(name);
 		if (clear) { clear(); }
 	}
+	*/
+
+	private __startTimer(name: string, ms: number, repeat: boolean, callback: () => void) {
+		if (!this.#timers) {
+			this.#timers = new Map();
+		}
+		else {
+			this.__stopTimer(name);
+		}
+
+		// Weak reference only: the native timer must not keep the element alive.
+		// The callback itself is stored in #timers, held by the element,
+		// so the element remains collectable while a timer is active.
+		const ref = new WeakRef(this);	// avoid keeping a ref on this.
+
+		let tick: () => void;
+
+		if (repeat) {
+			tick = () => {
+				const self = ref.deref();
+				if (!self) {
+					clearInterval(id);
+					return;
+				}
+
+				self.#timers.get(name)!.cb();
+			};
+
+			const id = setInterval( tick, ms );
+
+			this.#timers.set(name, {
+				cb: callback,
+				id,
+				clear( ) { clearInterval(id); }
+			});
+		}
+		else {
+			tick = () => {
+				const self = ref.deref();
+				if (!self) {
+					return;
+				}
+
+				// One-shot: remove the entry before firing so the map stays clean.
+				self.#timers.delete(name);
+				callback();
+			};
+
+			this.#timers.set(name, {
+				cb: callback,
+				id: setTimeout(tick, ms),
+				clear() { clearTimeout(this.id); }
+			});
+		}
+	}
+
+	private __stopTimer(name: string) {
+		const entry = this.#timers?.get(name);
+		if (entry) {
+			entry.clear();
+			this.#timers.delete(name);
+		}
+	}
 
 	/**
 	 * Sets a timeout that executes a callback function after a specified delay.
@@ -110,19 +184,19 @@ export class CoreElement<E extends EventMap = EventMap> {
 	 * @param ms - The delay in milliseconds before the callback is executed.
 	 * @param callback - The function to execute after the delay.
 	 */
-	
-	setTimeout( name: string, ms: number, callback: () => void ) {
-		this.__startTimer( name, ms, false, callback );
+
+	setTimeout(name: string, ms: number, callback: () => void) {
+		this.__startTimer(name, ms, false, callback);
 	}
-	
+
 	/**
 	 * Clears a previously set timeout.
 	 * @param name - The name of the timeout to clear.
-	 * @link setTimeout
+	 * @see setTimeout
 	 */
 
-	clearTimeout( name: string ) {
-		this.__stopTimer( name );
+	clearTimeout(name: string) {
+		this.__stopTimer(name);
 	}
 
 	/**
@@ -133,31 +207,59 @@ export class CoreElement<E extends EventMap = EventMap> {
 	 * @param callback - The function to execute after the delay.
 	 */
 
-	setInterval( name: string, ms: number, callback: ( ) => void ) {
-		this.__startTimer( name, ms, true, callback );
+	setInterval(name: string, ms: number, callback: () => void) {
+		this.__startTimer(name, ms, true, callback);
 	}
 
 	/**
 	 * Clears a previously set interval.
 	 * @param name - The name of the interval to clear.
-	 * @link setInterval
+	 * @see setInterval
 	 */
 
-	clearInterval( name: string ) {
-		this.__stopTimer( name );
+	clearInterval(name: string) {
+		this.__stopTimer(name);
 	}
 
 	/**
 	 * Clears all timeouts and intervals currently managed by this instance.
 	 * This stops all scheduled callbacks and removes their references.
-	 * @link setTimeout
+	 * @see setTimeout
 	 */
-	clearTimeouts( ) {
-		for( const [id,val] of this.#timers ) {
-			val( );
+	
+	clearTimeouts() {
+		if (!this.#timers) {
+			return;
+		}
+
+		// Entries no longer mutate the map in clear(), so plain iteration is safe.
+		for (const entry of this.#timers.values()) {
+			entry.clear();
 		}
-		
-		this.#timers.clear( );
+
+		this.#timers.clear();
+	}
+
+	/**
+	 * add a cleanup function to the cleanup list
+	 * @see cleanUp
+	 */
+
+	addCleanup( fn : Function ) {
+		if( !this.#cleanup ) {
+			this.#cleanup = [];
+		}
+
+		this.#cleanup.push( fn );
+	}
+
+	/**
+	 * called when element is removed from dom
+	 */ 
+
+	cleanUp( ) {
+		this.clearTimeouts( );
+		this.#cleanup?.forEach( x => x() );
 	}
 
 	// :: EVENTS ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
@@ -169,21 +271,21 @@ export class CoreElement<E extends EventMap = EventMap> {
 	 * @param name - The name of the event to listen for.
 	 * @param listener - The callback function to execute when the event is fired.
 	 * @returns An object containing an `off()` method to unsubscribe the listener.
-	 * @link fire
+	 * @see fire
 	 * attach to an event
 	 */
 
-	on<K extends keyof E>( name: K, listener: ( ev: E[K] ) => void ) {
-		console.assert( listener!==undefined && listener!==null );
+	on<K extends keyof E>(name: K, listener: (ev: E[K]) => void) {
+		console.assert(listener !== undefined && listener !== null);
 
-		if( !this.#events ) {
-			this.#events = new EventSource( this );
+		if (!this.#events) {
+			this.#events = new EventSource(this);
 		}
-		
-		this.#events.addListener( name, listener );
+
+		this.#events.addListener(name, listener);
 		return {
-			off: ( ) => {
-				this.#events.removeListener( name, listener );
+			off: () => {
+				this.#events.removeListener(name, listener);
 			}
 		}
 	}
@@ -193,15 +295,15 @@ export class CoreElement<E extends EventMap = EventMap> {
 	 * If the listener was not found or no events were registered, this method does nothing.
 	 * @param name - The name of the event from which to remove the listener.
 	 * @param listener - The specific listener function to remove.
-	 * @link on
-	 * @link fire
+	 * @see on
+	 * @see fire
 	 */
 
-	off<K extends keyof E>( name: K, listener: ( ev: E[K] ) => void ) {
-		console.assert( listener!==undefined && listener!==null );
+	off<K extends keyof E>(name: K, listener: (ev: E[K]) => void) {
+		console.assert(listener !== undefined && listener !== null);
 
-		if( this.#events ) {
-			this.#events.removeListener( name, listener );
+		if (this.#events) {
+			this.#events.removeListener(name, listener);
 		}
 	}
 
@@ -210,13 +312,13 @@ export class CoreElement<E extends EventMap = EventMap> {
 	 * If no listeners are registered for the event name, or if no EventSource has been initialized, this method does nothing.
 	 * @param name - The name of the event to fire.
 	 * @param ev - The payload (event object) to pass to the listeners.
-	 * @link on
-	 * @link off
+	 * @see on
+	 * @see off
 	 */
 
-	fire<K extends keyof E>( name: K, ev: E[K] ) {
-		if( this.#events ) {
-			this.#events.fire( name, ev );
+	fire<K extends keyof E>(name: K, ev: E[K]) {
+		if (this.#events) {
+			this.#events.fire(name, ev);
 		}
 	}
 }

package/src/core/core_pdf.ts

@@ -124,6 +124,7 @@ function serialize(val: PDFValue): string {
 	return String(val)
 }
 
+// @internal
 class Ref {
 	id: number
 	constructor(id: number) { this.id = id }

package/src/core/core_svg.ts

@@ -267,7 +267,7 @@ class SvgItem {
 
 	/**
 	 * add a class
-	 * @param name class name to add 
+	 * @param cls class name to add 
 	 */
 	
 	addClass( cls: string ): this {
@@ -287,7 +287,7 @@ class SvgItem {
 
 	/**
 	 * remove a class
-	 * @param name class name to remove
+	 * @param cls class name to remove
 	 */
 	
 	removeClass( cls: string ): this {

package/src/core/core_tools.ts

@@ -424,8 +424,6 @@ export function oneshot(callback: () => void, ms = 0) {
 
 /**
  * prepend 0 to a value to a given length
- * @param value 
- * @param length 
  */
 
 export function pad(what: any, size: number, ch: string = '0') {
@@ -466,7 +464,7 @@ export function sprintf(format: string, ...args: any[]) {
 /**
  * inverse of camel case
  * theThingToCase -> the-thing-to-case
- * @param {String} str 
+ * @param string 
  */
 
 export function pascalCase(string: string): string {
@@ -524,8 +522,6 @@ export function date_format(date: Date, options?: any): string {
 
 /**
  * difference between 2 dates
- * @param date 
- * @param options 
  * @return text
  */
 

package/src/x4doc.ts

@@ -0,0 +1,23 @@
+/** 
+ *  ___  ___ __
+ *  \  \/  /  / _
+ *   \    /  /_| |_
+ *   /    \____   _|  
+ *  /__/\__\   |_|
+ * 
+ * @file x4-doc.ts
+ * @author Etienne Cochard 
+ * 
+ * @copyright (c) 2026 R-libre ingenierie
+ *
+ * Use of this source code is governed by an MIT-style license 
+ * that can be found in the LICENSE file or at https://opensource.org/licenses/MIT.
+ **/
+
+
+/**
+ * do not use, only to generate full x4documentation
+ */
+
+export * from "./x4.js"
+export * from "./components/monaco/monaco.js"