x4js 1.4.4 → 1.4.7

package/lib/tooltips.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
 *  ___   ___ __
 *  \  \_/  /  / _
@@ -22,16 +23,18 @@
 *
 * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
 **/
-import { Component } from './component';
-import { Label } from './label';
-import { Icon } from './icon';
-import { isTouchDevice } from './tools';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initTooltips = exports.Tooltip = void 0;
+const component_1 = require("./component");
+const label_1 = require("./label");
+const icon_1 = require("./icon");
+const tools_1 = require("./tools");
 let tipTmo;
 let tooltip;
 /**
  *
  */
-export class Tooltip extends Component {
+class Tooltip extends component_1.Component {
     m_text;
     set text(text) {
         this.m_text.text = text;
@@ -40,8 +43,8 @@ export class Tooltip extends Component {
     render() {
         this.setClass('@non-maskable', true);
         this.setContent([
-            new Icon({ icon: 'cls(far fa-circle-info)' }),
-            this.m_text = new Label({ text: 'help' })
+            new icon_1.Icon({ icon: 'cls(far fa-circle-info)' }),
+            this.m_text = new label_1.Label({ text: 'help' })
         ]);
     }
     /**
@@ -75,8 +78,9 @@ export class Tooltip extends Component {
         this.setStyle({ left: x, top: y });
     }
 }
-export function initTooltips(cb) {
-    if (isTouchDevice()) {
+exports.Tooltip = Tooltip;
+function initTooltips(cb) {
+    if ((0, tools_1.isTouchDevice)()) {
         return;
     }
     let tipTarget = {
@@ -146,3 +150,4 @@ export function initTooltips(cb) {
     document.body.addEventListener('mouseout', handle_mouse);
     document.body.addEventListener('mousemove', handle_mpos);
 }
+exports.initTooltips = initTooltips;

package/lib/treeview.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
 *  ___   ___ __
 *  \  \_/  /  / _
@@ -22,18 +23,20 @@
 *
 * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
 **/
-import { Component, Container, EvDblClick } from './component';
-import { Icon } from './icon';
-import { Label } from './label';
-import { HLayout, VLayout } from './layout';
-import { EvClick, BasicEvent, EvDrag, EvSelectionChange, EvContextMenu } from './x4_events';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TreeView = void 0;
+const component_1 = require("./component");
+const icon_1 = require("./icon");
+const label_1 = require("./label");
+const layout_1 = require("./layout");
+const x4_events_1 = require("./x4_events");
 function EvExpand(node) {
-    return BasicEvent({ node });
+    return (0, x4_events_1.BasicEvent)({ node });
 }
 /**
  *
  */
-export class TreeView extends VLayout {
+class TreeView extends layout_1.VLayout {
     m_view;
     m_container;
     m_selection;
@@ -44,15 +47,15 @@ export class TreeView extends VLayout {
         props.gadgets = props.gadgets;
         props.sort = props.sort ?? false;
         this.m_selection = null;
-        this.m_container = new Container({ cls: '@scroll-container' });
-        this.m_view = new Container({
+        this.m_container = new component_1.Container({ cls: '@scroll-container' });
+        this.m_view = new component_1.Container({
             cls: '@scroll-view',
             flex: 1,
             content: this.m_container
         });
         this.setContent([
             this.m_view,
-            props.gadgets ? new HLayout({
+            props.gadgets ? new layout_1.HLayout({
                 cls: 'gadgets',
                 content: props.gadgets
             }) : null,
@@ -62,7 +65,7 @@ export class TreeView extends VLayout {
         this.setDomEvent('contextmenu', (e) => this._handleCtxMenu(e));
         if (props.canDragItems) {
             this.setDomEvent('dragstart', (ev) => {
-                let hit = Component.getElement(ev.target, Component);
+                let hit = component_1.Component.getElement(ev.target, component_1.Component);
                 let node = hit?.getData("node");
                 if (node) {
                     ev.dataTransfer.effectAllowed = 'move';
@@ -87,7 +90,7 @@ export class TreeView extends VLayout {
     }
     _dragEnter(ev) {
         ev.preventDefault();
-        let hit = Component.getElement(ev.target, Component);
+        let hit = component_1.Component.getElement(ev.target, component_1.Component);
         let node = hit?.getData("node");
         if (node) {
             hit.addClass('@drag-over');
@@ -95,14 +98,14 @@ export class TreeView extends VLayout {
         }
     }
     _dragLeave(ev) {
-        let hit = Component.getElement(ev.target, Component);
+        let hit = component_1.Component.getElement(ev.target, component_1.Component);
         let node = hit?.getData("node");
         if (node) {
             hit.removeClass('@drag-over');
         }
     }
     _drop(ev) {
-        let hit = Component.getElement(ev.target, Component);
+        let hit = component_1.Component.getElement(ev.target, component_1.Component);
         let node = hit?.getData("node");
         if (!node) {
             node = this.m_props.root;
@@ -120,7 +123,7 @@ export class TreeView extends VLayout {
             for (let i = 0; i < ev.dataTransfer.items.length; i++) {
                 ev.dataTransfer.items[0].getAsString((value) => {
                     let data = JSON.parse(value);
-                    this.emit('drag', EvDrag(node, data, parent));
+                    this.emit('drag', (0, x4_events_1.EvDrag)(node, data, parent));
                 });
             }
         }
@@ -222,13 +225,13 @@ export class TreeView extends VLayout {
         }
     }
     _renderDef(node) {
-        return new Label({ cls: 'tree-label', flex: 1, text: node.text });
+        return new label_1.Label({ cls: 'tree-label', flex: 1, text: node.text });
     }
     _makeNode(node, cls, icon, level) {
-        const item = new HLayout({
+        const item = new layout_1.HLayout({
             cls,
             content: [
-                new Icon({ cls: 'tree-icon', icon }),
+                new icon_1.Icon({ cls: 'tree-icon', icon }),
                 this.m_props.renderItem ? this.m_props.renderItem(node) : this._renderDef(node),
             ],
             data: {
@@ -319,7 +322,7 @@ export class TreeView extends VLayout {
             onsub = true;
         }
         while (dom != this.dom) {
-            let el = Component.getElement(dom);
+            let el = component_1.Component.getElement(dom);
             let nd = el?.getData('node');
             if (nd) {
                 if (nd.children && !onsub) {
@@ -339,14 +342,14 @@ export class TreeView extends VLayout {
                     this.selection = nd.id;
                     if (!onsub) {
                         if (ev.type == 'click') {
-                            this.emit('click', EvClick(nd));
+                            this.emit('click', (0, x4_events_1.EvClick)(nd));
                         }
                         else {
-                            this.emit('dblclick', EvDblClick(nd));
+                            this.emit('dblclick', (0, component_1.EvDblClick)(nd));
                         }
                     }
                 }
-                this.emit('selectionchange', EvSelectionChange(nd));
+                this.emit('selectionchange', (0, x4_events_1.EvSelectionChange)(nd));
                 return;
             }
             dom = dom.parentElement;
@@ -354,7 +357,7 @@ export class TreeView extends VLayout {
         if (ev.type == 'click') {
             this.m_selection = null;
             this.update();
-            this.emit('selectionchange', EvSelectionChange(null));
+            this.emit('selectionchange', (0, x4_events_1.EvSelectionChange)(null));
         }
     }
     _handleCtxMenu(ev) {
@@ -362,7 +365,7 @@ export class TreeView extends VLayout {
         let dom = ev.target;
         let idom = dom;
         while (dom != this.dom) {
-            let el = Component.getElement(dom);
+            let el = component_1.Component.getElement(dom);
             let nd = el?.getData('node');
             if (nd) {
                 if (nd.children) {
@@ -373,14 +376,14 @@ export class TreeView extends VLayout {
                 }
                 this.m_selection = { id: nd.id, el: null };
                 this.update();
-                this.emit('contextMenu', EvContextMenu(ev, nd));
+                this.emit('contextMenu', (0, x4_events_1.EvContextMenu)(ev, nd));
                 return;
             }
             dom = dom.parentElement;
         }
         this.m_selection = null;
         this.update();
-        this.emit('contextMenu', EvContextMenu(ev, null));
+        this.emit('contextMenu', (0, x4_events_1.EvContextMenu)(ev, null));
     }
     /**
      * constructs a tree node from an array of strings
@@ -488,3 +491,4 @@ export class TreeView extends VLayout {
         return root;
     }
 }
+exports.TreeView = TreeView;

package/lib/x4_events.d.ts

@@ -0,0 +1,253 @@
+/**
+*  ___   ___ __
+*  \  \_/  /  / _
+*   \     /  /_| |_
+*   /  _  \____   _|
+*  /__/ \__\   |_|
+*
+* @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;
+}