x4js 1.4.3 → 1.4.4

package/lib/x4_events.d.ts

@@ -1,253 +0,0 @@
-/**
-*  ___   ___ __
-*  \  \_/  /  / _
-*   \     /  /_| |_
-*   /  _  \____   _|
-*  /__/ \__\   |_|
-*
-* @file observable.ts
-* @author Etienne Cochard
-* @license
-* Copyright (c) 2019-2021 R-libre ingenierie
-*
-* This program is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation; either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
-**/
-export declare type EventCallback<T extends BasicEvent = BasicEvent> = (event: T) => any;
-export interface EventDisposer {
-    dispose(): void;
-}
-/**
- * Basic event
- * name like that to avoid conflict with Browsers Event class.
- */
-export interface BasicEvent {
-    readonly type?: string;
-    readonly source?: unknown;
-    readonly context?: any;
-    propagationStopped?: boolean;
-    defaultPrevented?: boolean;
-    stopPropagation?(): void;
-    preventDefault?(): void;
-}
-/**
- * BasicEvent Builder
- * this function is responsable of BasicEvent creation
- * ie. is equivalent of new BasicEvent( xxx );
- * @param params
- * @returns BasicEvent
- */
-export declare function BasicEvent<T extends BasicEvent = BasicEvent>(params: any): T;
-/**
- * Click Event
- * click event do not have any additional parameters
- */
-export interface EvClick extends BasicEvent {
-}
-export declare function EvClick(context?: any): EvClick;
-/**
- * Change Event
- * value is the the element value
- */
-export interface EvChange extends BasicEvent {
-    readonly value: any;
-}
-export declare function EvChange(value: unknown, context?: any): EvChange;
-/**
- * Selection Event
- * value is the new selection or null
- */
-export interface EvSelectionChange extends BasicEvent {
-    readonly selection: unknown;
-}
-export declare function EvSelectionChange(selection: unknown, context?: any): EvSelectionChange;
-/**
- * ContextMenu Event
- */
-export interface EvContextMenu extends BasicEvent {
-    uievent: UIEvent;
-}
-export declare function EvContextMenu(uievent: UIEvent, context?: any): EvContextMenu;
-/**
- * Timer Event
- * @see startTimer, stopTimer
- */
-export interface EvTimer extends BasicEvent {
-    timer: string;
-    time: number;
-}
-export declare function EvTimer(timer: string, time?: number, context?: any): EvTimer;
-/**
- * Simple message
- */
-export interface EvMessage extends BasicEvent {
-    readonly msg: string;
-    readonly params?: any;
-}
-export declare function EvMessage(msg: string, params?: unknown, source?: unknown): EvMessage;
-/**
- * Drag/Drop event
- */
-export interface EvDrag extends BasicEvent {
-    element: unknown;
-    data: any;
-}
-export declare function EvDrag(element: unknown, data: any, ctx: any): EvDrag;
-/**
- * this Base interface is used to describe available events & their types
- *
- * you can implement your own event mapping:
- * @example
- * ```ts
- * interface MyEventMap extends EventMap {
- * 	  click: EvClick,
- *    'custom-message': Event,
- * 	  [key: string]: Event,
- * }
- * ```
- */
-export interface EventMap {
-}
-/**
- * basic event types, in general the type is builded from the eventMap
- * this is very usefull for editor completion
- * @example
- * ```ts
- * type MyEventType = MapEvents<MyEventMap>;
- * ```
- */
-export interface EventTypes {
-}
-/**
- * convert an EventMap to a EventType
- */
-export declare type MapEvents<Type> = {
-    [Property in keyof Type]?: (ev: Type[Property]) => any;
-};
-/**
- * Event emitter class
- * this class allow you to emit and handle events
- *
- * @example:
- * ```ts
- *
- * interface EvDoIt extends BasicEvent {
- *   param: unknown;
- * }
- *
- * function EvDoIt( e: EvDoIt ) : EvDoIt {
- *   return BasicEvent<EvDoIt>( e );
- * }
- *
- * interface TestEventMap extends EventMap {
- *	doit: EvDoIt;
- * }
- *
- * let ee = new EventSource<TestEventMap>(null);
- * ee.listen({
- *	doit: (e) => {
- *		console.log(e);
- *		e.preventDefault();
- *	},
- * });
- *
- * ee.defaults({
- *	doit: (e) => {
- *		console.log('default handler for ', e.type, e.selection);
- *	},
- * })
- *
- * ee.on('doit', (e) => {
- *	debugger;
- * })
- *
- * const ev = EvDoIt({ param: 10 });
- * ee.emit('change', ev);
- * if (ev.defaultPrevented) {
- *	console.log('prevented');
- * }
- * ```
- */
-export declare class EventSource<Q extends EventMap, T extends EventTypes = MapEvents<Q>> {
-    private m_source;
-    private m_eventRegistry;
-    private m_defaultHandlers;
-    constructor(source?: unknown);
-    /**
-     * emit an event
-     * you can stop propagation of event or prevent default
-     * @param eventName - name of event to emit
-     * @param event - event data
-     */
-    emit<K extends keyof Q>(type: K, event?: Q[K]): void;
-    _emit(eventName: string, e: BasicEvent): void;
-    /**
-     * signal en event
-     * signaled event are notification : no way to prevent default not stop propagation
-     * @param eventName name of event to signal
-     * @param event event data
-     */
-    signal<K extends keyof Q>(type: K, event: Q[K], delay?: number): void;
-    _signal(eventName: string, e: BasicEvent, delay?: number): void;
-    /**
-     * handle an event one time
-     * @param eventName - event name to handle
-     * @param callback - callback to call when event is signaled
-     * @returns Promise if callback is null
-     *
-     * take care with that because if the event is never fired and you await it,
-     * the system may overflow
-     */
-    once<K extends keyof Q>(type: K, callback: (ev: Q[K]) => any): void;
-    _once(eventName: string, callback: EventCallback): Promise<unknown>;
-    /**
-     * set the event default handler
-     * @param eventName - name of the event
-     * @param callback - callback to call when the event is not handled (and preventDeault has not been called)
-     */
-    setDefaultHandler(eventName: string, callback: EventCallback): void;
-    /**
-     * remove the previous default handler installed for an event
-     * @param eventName - event name
-     * @param callback - callback handler to remove (must be the same as in setDefaultHandler)
-     */
-    removeDefaultHandler(eventName: string, callback: EventCallback): void;
-    /**
-     * define a set of listeners in one call
-     * @param events
-     */
-    listen(events: T): void;
-    /**
-     * define a set of default handlers in one call
-     * @param events
-     */
-    defaults(events: T): void;
-    /**
-     * listen for an event
-     * @param eventName - event name to listen on
-     * @param callback - callback to call
-     * @param capturing - if true, capture event before other registred event handlers
-     */
-    on<K extends keyof Q>(type: K, callback: (ev: Q[K]) => any): EventDisposer;
-    _on(eventName: string, callback: EventCallback, capturing?: boolean): EventDisposer;
-    /**
-     * stop listening to an event
-     * @param eventName - event name
-     * @param callback - callback to remove (must be the same as in on )
-     */
-    off(eventName: string, callback: EventCallback): void;
-    /**
-     * remove all listeners for an event
-     * @param eventName - event name
-     */
-    removeAllListeners(eventName: string | null): void;
-}

package/lib/x4_events.js

@@ -1,363 +0,0 @@
-/**
-*  ___   ___ __
-*  \  \_/  /  / _
-*   \     /  /_| |_
-*   /  _  \____   _|
-*  /__/ \__\   |_|
-*
-* @file observable.ts
-* @author Etienne Cochard
-* @license
-* Copyright (c) 2019-2021 R-libre ingenierie
-*
-* This program is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation; either version 3 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
-**/
-// default stopPropagation implementation for Events
-const stopPropagation = function () {
-    this.propagationStopped = true;
-};
-// default preventDefault implementation for Events
-const preventDefault = function () {
-    this.defaultPrevented = true;
-};
-;
-/**
- * BasicEvent Builder
- * this function is responsable of BasicEvent creation
- * ie. is equivalent of new BasicEvent( xxx );
- * @param params
- * @returns BasicEvent
- */
-export function BasicEvent(params) {
-    return {
-        stopPropagation,
-        preventDefault,
-        ...params,
-    };
-}
-export function EvClick(context = null) {
-    return BasicEvent({ context });
-}
-export function EvChange(value, context = null) {
-    return BasicEvent({ value, context });
-}
-export function EvSelectionChange(selection, context = null) {
-    return BasicEvent({ selection, context });
-}
-export function EvContextMenu(uievent, context = null) {
-    return BasicEvent({ uievent, context });
-}
-export function EvTimer(timer, time = 0, context = null) {
-    return BasicEvent({ timer, time, context });
-}
-export function EvMessage(msg, params, source) {
-    return BasicEvent({ msg, params, source });
-}
-export function EvDrag(element, data, ctx) {
-    return BasicEvent({ element, data, context: ctx });
-}
-/**
- * Event emitter class
- * this class allow you to emit and handle events
- *
- * @example:
- * ```ts
- *
- * interface EvDoIt extends BasicEvent {
- *   param: unknown;
- * }
- *
- * function EvDoIt( e: EvDoIt ) : EvDoIt {
- *   return BasicEvent<EvDoIt>( e );
- * }
- *
- * interface TestEventMap extends EventMap {
- *	doit: EvDoIt;
- * }
- *
- * let ee = new EventSource<TestEventMap>(null);
- * ee.listen({
- *	doit: (e) => {
- *		console.log(e);
- *		e.preventDefault();
- *	},
- * });
- *
- * ee.defaults({
- *	doit: (e) => {
- *		console.log('default handler for ', e.type, e.selection);
- *	},
- * })
- *
- * ee.on('doit', (e) => {
- *	debugger;
- * })
- *
- * const ev = EvDoIt({ param: 10 });
- * ee.emit('change', ev);
- * if (ev.defaultPrevented) {
- *	console.log('prevented');
- * }
- * ```
- */
-export class EventSource {
-    m_source;
-    m_eventRegistry;
-    m_defaultHandlers;
-    constructor(source = null) {
-        this.m_source = source ?? this;
-    }
-    /**
-     * emit an event
-     * you can stop propagation of event or prevent default
-     * @param eventName - name of event to emit
-     * @param event - event data
-     */
-    emit(type, event) {
-        this._emit(type, event);
-    }
-    _emit(eventName, e) {
-        let listeners = this.m_eventRegistry?.get(eventName);
-        const defaultHandler = this.m_defaultHandlers?.get(eventName);
-        if (!e) {
-            e = {};
-        }
-        if (!e.source) {
-            e.source = this.m_source;
-        }
-        if (!e.type) {
-            e.type = eventName;
-        }
-        if (listeners && listeners.length) {
-            if (!e.preventDefault) {
-                e.preventDefault = preventDefault;
-            }
-            if (!e.stopPropagation) {
-                e.stopPropagation = stopPropagation;
-            }
-            // small optimisation
-            if (listeners.length == 1) {
-                listeners[0](e);
-            }
-            else {
-                const temp = listeners.slice();
-                for (let i = 0, n = temp.length; i < n; i++) {
-                    temp[i](e);
-                    if (e.propagationStopped) {
-                        break;
-                    }
-                }
-            }
-        }
-        if (defaultHandler && defaultHandler.length && !e.defaultPrevented) {
-            return defaultHandler[0](e);
-        }
-    }
-    /**
-     * signal en event
-     * signaled event are notification : no way to prevent default not stop propagation
-     * @param eventName name of event to signal
-     * @param event event data
-     */
-    signal(type, event, delay = -1) {
-        this._signal(type, event, delay);
-    }
-    _signal(eventName, e, delay = -1) {
-        if (!this.m_eventRegistry) {
-            return;
-        }
-        const listeners = this.m_eventRegistry.get(eventName);
-        if (!listeners || !listeners.length) {
-            return;
-        }
-        if (!e) {
-            e = {};
-        }
-        if (!e.type) {
-            e.type = eventName;
-        }
-        if (!e.source) {
-            e.source = this.m_source;
-        }
-        e.preventDefault = e.stopPropagation = () => {
-            console.error('this event cannot be stopped not default prevented');
-        };
-        // small optimisation
-        if (listeners.length == 1 && delay == -1) {
-            listeners[0](e);
-        }
-        else {
-            const temp = listeners.slice();
-            const call = () => {
-                for (let i = 0, n = temp.length; i < n; i++) {
-                    temp[i](e);
-                }
-            };
-            if (delay == -1) {
-                call();
-            }
-            else {
-                setTimeout(call, delay);
-            }
-        }
-    }
-    /**
-     * handle an event one time
-     * @param eventName - event name to handle
-     * @param callback - callback to call when event is signaled
-     * @returns Promise if callback is null
-     *
-     * take care with that because if the event is never fired and you await it,
-     * the system may overflow
-     */
-    once(type, callback) {
-        this._once(type, callback);
-    }
-    _once(eventName, callback) {
-        const newCallback = (ev) => {
-            this.off(eventName, newCallback);
-            callback(ev);
-        };
-        this._on(eventName, newCallback);
-        if (!callback) {
-            return new Promise(function (resolve) {
-                callback = resolve;
-            });
-        }
-    }
-    /**
-     * set the event default handler
-     * @param eventName - name of the event
-     * @param callback - callback to call when the event is not handled (and preventDeault has not been called)
-     */
-    setDefaultHandler(eventName, callback) {
-        let handlers = this.m_defaultHandlers;
-        if (!handlers) {
-            handlers = this.m_defaultHandlers = new Map();
-        }
-        let stack = handlers.get(eventName);
-        if (stack) {
-            // if already in the stack, remove it
-            const idx = stack.indexOf(callback);
-            if (idx != -1) {
-                stack.splice(idx, 1);
-            }
-            // then make it first
-            stack.unshift(callback);
-        }
-        else {
-            handlers.set(eventName, [callback]);
-        }
-    }
-    /**
-     * remove the previous default handler installed for an event
-     * @param eventName - event name
-     * @param callback - callback handler to remove (must be the same as in setDefaultHandler)
-     */
-    removeDefaultHandler(eventName, callback) {
-        const handlers = this.m_defaultHandlers;
-        if (!handlers) {
-            return;
-        }
-        const stack = handlers.get(eventName);
-        if (stack) {
-            const idx = stack.indexOf(callback);
-            if (idx != -1) {
-                stack.splice(idx, 1);
-            }
-        }
-    }
-    /**
-     * define a set of listeners in one call
-     * @param events
-     */
-    listen(events) {
-        for (let n in events) {
-            this._on(n, events[n]);
-        }
-    }
-    /**
-     * define a set of default handlers in one call
-     * @param events
-     */
-    defaults(events) {
-        for (let n in events) {
-            this.setDefaultHandler(n, events[n]);
-        }
-    }
-    /**
-     * listen for an event
-     * @param eventName - event name to listen on
-     * @param callback - callback to call
-     * @param capturing - if true, capture event before other registred event handlers
-     */
-    on(type, callback) {
-        return this._on(type, callback);
-    }
-    _on(eventName, callback, capturing = false) {
-        if (!this.m_eventRegistry) {
-            this.m_eventRegistry = new Map();
-        }
-        let listeners = this.m_eventRegistry.get(eventName);
-        if (!listeners) {
-            listeners = [];
-            this.m_eventRegistry.set(eventName, listeners);
-        }
-        if (listeners.indexOf(callback) == -1) {
-            if (capturing) {
-                listeners.unshift(callback);
-            }
-            else {
-                listeners.push(callback);
-            }
-        }
-        return {
-            dispose: () => { this.off(eventName, callback); }
-        };
-    }
-    /**
-     * stop listening to an event
-     * @param eventName - event name
-     * @param callback - callback to remove (must be the same as in on )
-     */
-    off(eventName, callback) {
-        if (!this.m_eventRegistry) {
-            return;
-        }
-        let listeners = this.m_eventRegistry.get(eventName);
-        if (!listeners) {
-            return;
-        }
-        const idx = listeners.indexOf(callback);
-        if (idx !== -1) {
-            listeners.splice(idx, 1);
-        }
-    }
-    /**
-     * remove all listeners for an event
-     * @param eventName - event name
-     */
-    removeAllListeners(eventName) {
-        if (!eventName) {
-            this.m_eventRegistry = this.m_defaultHandlers = undefined;
-        }
-        else {
-            if (this.m_eventRegistry) {
-                this.m_eventRegistry[eventName] = undefined;
-            }
-            if (this.m_defaultHandlers) {
-                this.m_defaultHandlers[eventName] = undefined;
-            }
-        }
-    }
-}