x4js 1.6.5 → 2.0.2

package/lib/src/core/core_element.ts

@@ -0,0 +1,98 @@
+/** 
+ *  ___  ___ __
+ *  \  \/  /  / _
+ *   \    /  /_| |_
+ *   /    \____   _|  
+ *  /__/\__\   |_|
+ * 
+ * @file core_element.ts
+ * @author Etienne Cochard 
+ * 
+ * @copyright (c) 2024 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.
+ **/
+
+import { EventMap, EventSource } from './core_events.js';
+
+/**
+ * 
+ */
+
+export class CoreElement<E extends EventMap = EventMap> {
+
+	#events: EventSource<E>;
+	#timers: Map<string, Function>;
+
+	private __startTimer( name: string, ms: number, repeat: boolean, callback: ( ) => void ) {
+		if (!this.#timers) {
+			this.#timers = new Map();
+		}
+		else {
+			this.__stopTimer(name);
+		}
+
+		const id = (repeat ? setInterval : setTimeout)( callback, ms );
+
+		this.#timers.set(name, () => { 
+			(repeat ? clearInterval : clearTimeout)(id); 
+			this.#timers.delete(name) 
+		});
+	}
+
+	private __stopTimer( name: string ) {
+		const clear = this.#timers.get(name);
+		if (clear) { clear(); }
+	}
+
+	setTimeout( name: string, ms: number, callback: () => void ) {
+		this.__startTimer( name, ms, false, callback );
+	}
+
+	clearTimeout( name: string ) {
+		this.__stopTimer( name );
+	}
+
+	setInterval( name: string, ms: number, callback: ( ) => void ) {
+		this.__startTimer( name, ms, true, callback );
+	}
+
+	clearInterval( name: string ) {
+		this.__stopTimer( name );
+	}
+
+	clearTimeouts( ) {
+		for( const [id,val] of this.#timers ) {
+			val( );
+		}
+		
+		this.#timers.clear( );
+	}
+
+	// :: EVENTS ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+
+	/**
+	 * attach to an event
+	 */
+
+	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 );
+		}
+		
+		this.#events.addListener( name, listener );
+	}
+
+	/**
+	 * 
+	 */
+
+	fire<K extends keyof E>( name: K, ev: E[K] ) {
+		if( this.#events ) {
+			this.#events.fire( name, ev );
+		}
+	}
+}

package/lib/src/core/core_events.ts

@@ -0,0 +1,149 @@
+/** 
+ *  ___  ___ __
+ *  \  \/  /  / _
+ *   \    /  /_| |_
+ *   /    \____   _|  
+ *  /__/\__\   |_|
+ * 
+ * @file core_events.ts
+ * @author Etienne Cochard 
+ * 
+ * @copyright (c) 2024 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.
+ **/
+
+import { CoreElement } from './core_element';
+
+/**
+ * 
+ */
+
+export interface CoreEvent {
+	readonly type?: string;			// type of the event 'click', 'change', ...
+	readonly source?: CoreElement;	// object that fires the event
+	readonly context?: any;			// contextual data, left to the user
+
+	propagationStopped?: boolean;	// if true, do not propagate the event
+	defaultPrevented?: boolean;		// if true, do not call default handler (if any)
+
+	stopPropagation?(): void;		// stop the propagation
+	preventDefault?(): void;		// prevent the default handler
+}
+
+// default stopPropagation implementation for Events
+const stopPropagation = function ( this: CoreEvent ) {
+	this.propagationStopped = true;
+}
+
+// default preventDefault implementation for Events
+const preventDefault = function ( this: CoreEvent ) {
+	this.defaultPrevented = true;
+}
+
+
+/**
+ * 
+ */
+
+export interface EventMap {
+}
+
+/**
+ * 
+ */
+
+export type EventCallback<T extends CoreEvent = CoreEvent> = (event: T) => any;
+
+/**
+ * 
+ */
+
+export class EventSource<E extends EventMap = EventMap > {
+
+	private _source: unknown;
+	private _registry: Map<string,EventCallback[]>;
+
+	constructor(source: unknown = null) {
+		this._source = source ?? this;
+	}
+
+	addListener<K extends keyof E>( name: K, callback: ( ev: E[K] ) => void, capturing = false ) {
+		
+		if (!this._registry) {
+			this._registry = new Map();
+		}
+
+		let listeners = this._registry.get(name as string);
+		if (!listeners) {
+			listeners = [];
+			this._registry.set(name as string, listeners);
+		}
+
+		const cb = callback as EventCallback;
+
+		if (listeners.indexOf(cb) == -1) {
+			if (capturing) {
+				listeners.unshift(cb);
+			}
+			else {
+				listeners.push(cb);
+			}
+		}
+	}
+
+	fire<K extends keyof E>(name: K, evx: E[K]) {
+		
+		let listeners = this._registry?.get(name as string);
+		//const defaultHandler = this.m_defaultHandlers?.get(eventName);
+
+		if (listeners && listeners.length) {
+			let ev = evx as CoreEvent;
+			if (!ev) {
+				ev = {};
+			}
+
+			if (!ev.source) {
+				// readonly
+				(ev as any).source = this._source;
+			}
+
+			if (!ev.type) {
+				// readonly
+				(ev as any).type = name;
+			}
+
+			
+			if (!ev.preventDefault) {
+				ev.preventDefault = preventDefault;
+			}
+
+			if (!ev.stopPropagation) {
+				ev.stopPropagation = stopPropagation;
+			}
+
+			// small optimisation
+			if (listeners.length == 1) {
+				listeners[0](ev);
+			}
+			else {
+				const temp = listeners.slice();
+				for (let i = 0, n = temp.length; i < n; i++) {
+					temp[i](ev);
+					if (ev.propagationStopped) {
+						break;
+					}
+				}
+			}
+		}
+
+		//if (defaultHandler && defaultHandler.length && !e.defaultPrevented) {
+		//	return defaultHandler[0](e);
+		//}
+	}
+}
+
+
+
+

package/lib/src/{i18n.ts → core/core_i18n.ts}

@@ -1,33 +1,18 @@
-/**
-*  ___  ___ __
-*  \  \/  /  / _
-*   \    /  /_| |_
-*   /    \____   _|  
-*  /__/\__\   |_|
-*        
-* @file i18n.ts
-* @author Etienne Cochard 
-*
-* Copyright (c) 2019-2023 R-libre ingenierie
-*
-* Permission is hereby granted, free of charge, to any person obtaining a copy 
-* of this software and associated documentation files (the "Software"), to deal 
-* in the Software without restriction, including without limitation the rights 
-* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
-* of the Software, and to permit persons to whom the Software is furnished to do so, 
-* subject to the following conditions:
-* The above copyright notice and this permission notice shall be included in all copies
-* or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
-* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
-* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 
-* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**/
-
-
+/** 
+ *  ___  ___ __
+ *  \  \/  /  / _
+ *   \    /  /_| |_
+ *   /    \____   _|  
+ *  /__/\__\   |_|
+ * 
+ * @file core_i18n.ts
+ * @author Etienne Cochard 
+ * 
+ * @copyright (c) 2024 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.
+ **/
 
 
 /**
@@ -90,7 +75,7 @@ export function isLanguage( name: string ): boolean {
  * ```
   */
 
-export function addTranslation( name, ...parts ) {
+export function addTranslation( name: string, ...parts: any[] ) {
 	
 	if( !isLanguage(name) ) {
 		return;
@@ -136,9 +121,9 @@ function _patch( obj: any, by: any ) {
  * (deep traverse)
  */
 
-function _proxyfy( obj: any, base: any, root ) {
+function _proxyfy( obj: any, base: any, root: any ) {
 
-	const result = {}
+	const result: any = {}
 
 	for( const n in obj ) {
 		if( typeof obj[n]!=="string" && !Array.isArray(obj[n])) {
@@ -162,15 +147,22 @@ function _mk_proxy( obj: any, base: string, root: boolean ) : any {
 		get: (target, prop) => {
 			if( root ) {
 				req_path = [prop];
-		}
+			}
 			else {
 				req_path.push( prop );
-	}
+			}
 
 			let value = target[prop];
-			if( value===undefined && base ) {
-				value = _findBaseTrans( base );
+			if( value===undefined ) {
+				if( base ) {
+					value = _findBaseTrans( base );
+				}
+
+				if( value===undefined ) {
+					console.error( "I18N error: unable to find", '_tr.'+req_path.join('.') );
+				}
 			}
+
 			return value;
 		}
 	});
@@ -193,7 +185,7 @@ let req_path: (string | symbol)[];
  * 
  */
 
-function _findBaseTrans( base ) {
+function _findBaseTrans( base: any ) {
 
 	while( base ) {
 		const lang = languages[base];
@@ -216,11 +208,10 @@ function _findBaseTrans( base ) {
 		base = lang.base;
 	}
 
-	console.error( "I18N error: unable to find", '_tr.'+req_path.join('.') );
 	return undefined;
 }
 
-export let _tr: any = {};
+export let _tr: Partial<typeof fr> = {};
 
 /**
  * select the given language as current
@@ -234,7 +225,7 @@ export function selectLanguage( name: string ) {
 	}
 
 	_tr = languages[name].translations;
-	_tr[sym_lang] = name;
+	(_tr as any)[sym_lang] = name;
 	return _tr;
 }
 
@@ -243,7 +234,7 @@ export function selectLanguage( name: string ) {
  */
 
 export function getCurrentLanguage( ): string {
-	return _tr[sym_lang];
+	return (_tr as any)[sym_lang];
 }
 
 /**
@@ -269,6 +260,11 @@ let fr = {
 		ignore: 'Ignorer',
 		yes: 'Oui',
 		no: 'Non',
+		abort: "Abandonner",
+		retry: "Réessayer",
+
+		error: "Erreur",
+		today: "Aujourd'hui",
 
 		open: 'Ouvrir',
 		new: 'Nouveau',
@@ -320,6 +316,11 @@ let en = {
 		ignore: 'Ignore',
 		yes: 'Yes',
 		no: 'No',
+		abort: "Abort",
+		retry: "Retry",
+
+		error: "Error",
+		today: "Today",
 
 		open: 'Open',
 		new: 'New',

package/lib/src/{router.ts → core/core_router.ts}

@@ -1,35 +1,21 @@
-/**
-*  ___   ___ __
-*  \  \_/  /  / _
-*   \     /  /_| |_
-*   /  _  \____   _|  
-*  /__/ \__\   |_|
-*        
-* @file router.ts
-* @author Etienne Cochard 
-*
-* Copyright (c) 2019-2023 R-libre ingenierie
-*
-* Permission is hereby granted, free of charge, to any person obtaining a copy 
-* of this software and associated documentation files (the "Software"), to deal 
-* in the Software without restriction, including without limitation the rights 
-* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
-* of the Software, and to permit persons to whom the Software is furnished to do so, 
-* subject to the following conditions:
-* The above copyright notice and this permission notice shall be included in all copies
-* or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 
-* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
-* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 
-* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**/
-
-import { x4document } from './x4dom'
-
-import { EvSource, EvError, EventMap } from "./x4events"
+/** 
+ *  ___  ___ __
+ *  \  \/  /  / _
+ *   \    /  /_| |_
+ *   /    \____   _|  
+ *  /__/\__\   |_|
+ * 
+ * @file core_router.ts
+ * @author Etienne Cochard 
+ * 
+ * @copyright (c) 2024 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.
+ **/
+
+import { EvError } from './component.js';
+import { EventMap, EventSource } from './core_events.js';
 
 type RouteHandler = ( params: any, path: string ) => void;
 
@@ -90,7 +76,7 @@ function parseRoute(str: string | RegExp, loose = false): Segment {
 	};
 }
 
-interface RouterEventMap extends EventMap {
+interface RouterEvents extends EventMap {
 	error: EvError;
 }
 
@@ -120,7 +106,7 @@ interface RouterEventMap extends EventMap {
  */
 
 
-export class Router extends EvSource< RouterEventMap > {
+export class Router extends EventSource< RouterEvents > {
 
 	private m_routes: Route[];
 	private m_useHash: boolean;
@@ -151,7 +137,7 @@ export class Router extends EvSource< RouterEventMap > {
 	}
 
 	private _getLocation( ) {
-		return this.m_useHash ? '/'+x4document.location.hash.substring(1) : x4document.location.pathname;
+		return this.m_useHash ? '/'+document.location.hash.substring(1) : document.location.pathname;
 	}
 
 	navigate( uri: string, notify = true, replace = false ) {
@@ -165,7 +151,7 @@ export class Router extends EvSource< RouterEventMap > {
 		if( !found || found.handlers.length==0 ) {
 			//window.history.pushState({}, '', 'error')
 			console.log( 'route not found: '+uri );
-			this.signal( "error", EvError( 404, "route not found" ) );
+			this.fire( "error", {code: 404, message: "route not found" } );
 			return;
 		}
 
@@ -191,11 +177,11 @@ export class Router extends EvSource< RouterEventMap > {
 		}
 	}
 
-	private _find( url: string ): { params: any, handlers: RouteHandler[] } {
+	private _find( url: string ): { params: Record<string,any>, handlers: RouteHandler[] } {
 		
 		let matches = [];
-		let params = {};
-		let handlers = [];
+		let params: Record<string,any> = {};
+		let handlers: RouteHandler[] = [];
 
 		for (const tmp of this.m_routes ) {
 			if (!tmp.keys ) {
@@ -231,4 +217,5 @@ export class Router extends EvSource< RouterEventMap > {
 
 		return { params, handlers };
 	}
-}
+}
+