x4js 1.4.52 → 1.4.53

package/lib/{x4react.js → cjs/x4react.js}

@@ -42,10 +42,7 @@ const createElement = (clsOrTag, attrs, ...children) => {
     }
     // basic tag
     else {
-        comp = new component_1.Component({
-            tag: clsOrTag,
-            ...attrs,
-        });
+        comp = new component_1.Component(Object.assign({ tag: clsOrTag }, attrs));
     }
     if (children && children.length) {
         comp.setContent(children);

package/lib/esm/action.js

@@ -0,0 +1,53 @@
+/**
+*  ___  ___ __
+*  \  \/  /  / _
+*   \    /  /_| |_
+*   /    \____   _|
+*  /__/\__\   |_|
+*
+* @file action.ts
+* @author Etienne Cochard
+*
+* Copyright (c) 2019-2022 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 { BasicEvent, EvChange } from './x4events';
+import { BaseComponent } from './base_component';
+export function EvAction(source) {
+    return BasicEvent({ source });
+}
+export class Action extends BaseComponent {
+    constructor(props) {
+        super(props);
+        this.mapPropEvents(props, "run");
+    }
+    get props() {
+        return this.m_props;
+    }
+    set text(t) {
+        this.m_props.text = t;
+        this.emit("change", EvChange(this));
+    }
+    set icon(i) {
+        this.m_props.icon = i;
+        this.emit("change", EvChange(this));
+    }
+    fire() {
+        this.emit("run", EvAction(this));
+    }
+}

package/lib/esm/application.js

@@ -0,0 +1,184 @@
+/**
+*  ___  ___ __
+*  \  \/  /  / _
+*   \    /  /_| |_
+*   /    \____   _|
+*  /__/\__\   |_|
+*
+* @file application.ts
+* @author Etienne Cochard
+*
+* Copyright (c) 2019-2022 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 { BaseComponent } from './base_component';
+import { Component, flyWrap } from './component';
+import { Settings } from './settings';
+const _x4_touch_time = Symbol();
+/**
+ * Represents an x4 application, which is typically a single page app.
+ * You should inherit Application to define yours.
+ * Application derives from BaseComponent so you can use that to implement a global messaging system.
+ * @example ```ts
+ *
+ * // in yout main caode
+ * let app = new Application( );
+ *
+ * app.events.close.on( ( ev ) => {
+ * 	... do something
+ * });
+ *
+ * // somewhere else in the source
+ * function xxx( ) {
+ * 	let app = Application.instance( );
+ * 	app.events.close.emit( new Events.close() );
+ * }
+ */
+export class Application extends BaseComponent {
+    static self = null;
+    /**
+     * the application singleton
+     */
+    static instance() {
+        return Application.self;
+    }
+    m_mainView;
+    m_app_name;
+    m_app_version;
+    m_app_uid;
+    m_local_storage;
+    m_user_data;
+    m_touch_time;
+    m_touch_count;
+    constructor(props) {
+        console.assert(Application.self === null, 'application is a singleton');
+        super(props);
+        this.m_app_name = props.app_name ?? 'application';
+        this.m_app_version = props.app_version ?? '1.0';
+        this.m_app_uid = props.app_uid ?? 'application';
+        let settings_name = `${this.m_app_name}.${this.m_app_version}.settings`;
+        this.m_local_storage = new Settings(settings_name);
+        this.m_user_data = {};
+        this.m_touch_time = 0;
+        this.m_touch_count = 0;
+        Application.self = this;
+        if ('onload' in globalThis) {
+            globalThis.addEventListener('load', () => {
+                this.ApplicationCreated();
+            });
+        }
+        else {
+            this.ApplicationCreated();
+        }
+    }
+    ApplicationCreated() {
+        this.setTitle('');
+    }
+    get app_name() {
+        return this.m_app_name;
+    }
+    get app_uid() {
+        return this.m_app_uid;
+    }
+    get app_version() {
+        return this.m_app_version;
+    }
+    get local_storage() {
+        return this.m_local_storage;
+    }
+    get user_data() {
+        return this.m_user_data;
+    }
+    get history() {
+        //if( !this.m_history ) {
+        //	this.m_history = new NavigationHistory( );
+        //}
+        //
+        //return this.m_history;
+        debugger;
+        return null;
+    }
+    /**
+     * define the application root object (MainView)
+     * @example ```ts
+     *
+     * let myApp = new Application( ... );
+     * let mainView = new VLayout( ... );
+     * myApp.mainView = mainView;
+     */
+    setMainView(root, clearBefore) {
+        const ddom = this.m_props.renderTo ?? x4document.body;
+        const dest = flyWrap(ddom);
+        if (!this.m_props.renderTo) {
+            dest.setStyleValue('position', 'absolute');
+        }
+        dest.addClass('x4-root-element');
+        if (clearBefore) {
+            dest._empty();
+        }
+        this.m_mainView = root;
+        root.setStyleValue('position', 'absolute');
+        root._build();
+        ddom.appendChild(root.dom);
+    }
+    set mainView(root) {
+        this.setMainView(root, false);
+    }
+    get mainView() {
+        return this.m_mainView;
+    }
+    setTitle(title) {
+        x4document.title = this.m_app_name + (title ? (' > ' + title) : '');
+    }
+    disableZoomWheel() {
+        window.addEventListener('wheel', function (ev) {
+            if (ev.ctrlKey) {
+                ev.preventDefault();
+                //ev.stopPropagation( );
+            }
+        }, { passive: false, capture: true });
+    }
+    enterModal(enter) {
+    }
+    enableTouchDblClick() {
+        x4document.addEventListener('touchstart', (ev) => {
+            let now = Date.now();
+            if ((now - this.m_touch_time) > 700) {
+                this.m_touch_count = 1;
+            }
+            else {
+                this.m_touch_count++;
+            }
+            this.m_touch_time = now;
+            if (this.m_touch_count == 2) {
+                this.m_touch_count = 0;
+                // dirty fake dblclick event
+                const tch = ev.touches[0];
+                let fake = { type: "dblclick" };
+                for (const n in tch) {
+                    fake[n] = tch[n];
+                }
+                // ignore -> private: dirty x2
+                Component._dispatchEvent(fake);
+                ev.stopPropagation();
+            }
+        });
+    }
+}
+;

package/lib/esm/autocomplete.js

@@ -0,0 +1,155 @@
+/**
+*  ___  ___ __
+*  \  \/  /  / _
+*   \    /  /_| |_
+*   /    \____   _|
+*  /__/\__\   |_|
+*
+* @file autocomplete.ts
+* @author Etienne Cochard
+*
+* Copyright (c) 2019-2022 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 { PopupListView } from "./listview";
+import { TextEdit } from './textedit';
+/**
+ *
+ */
+export class AutoComplete extends TextEdit {
+    m_popup;
+    m_popvis;
+    m_needval;
+    m_lockpop;
+    constructor(props) {
+        super(props);
+        this.setDomEvent("input", () => this._onChange());
+        this.setDomEvent("focusin", () => this._onFocus());
+        this.startTimer("focus-check", 100, true, () => this._checkFocus());
+        this.m_popvis = false;
+        this.m_needval = false;
+        this.m_lockpop = false;
+        this.setDomEvent("keydown", e => this._onKey(e));
+    }
+    _onKey(e) {
+        if (this.m_popvis) {
+            if (e.key == "ArrowUp" || e.key == "ArrowDown") {
+                this.m_lockpop = true;
+                this.m_popup.handleKey(e);
+                this.m_lockpop = false;
+                e.preventDefault();
+                e.stopPropagation();
+            }
+            else if (e.key == "Escape") {
+                this._hidePopup();
+                e.preventDefault();
+                e.stopPropagation();
+            }
+        }
+        else if (e.key == "ArrowDown") {
+            this._onChange();
+            e.preventDefault();
+            e.stopPropagation();
+        }
+    }
+    _onChange() {
+        const items = this.m_props.enumValues(this.value);
+        this.showPopup(items);
+    }
+    componentDisposed() {
+        if (this.m_popup) {
+            this._hidePopup();
+        }
+        super.componentDisposed();
+    }
+    /**
+     * display the popup
+     */
+    showPopup(items) {
+        let props = this.m_props;
+        if (props.readOnly || this.hasClass("@disable")) {
+            return;
+        }
+        // need creation ?
+        if (!this.m_popup) {
+            let cstyle = this.getComputedStyle();
+            let fontFamily = cstyle.value('fontFamily');
+            let fontSize = cstyle.value('fontSize');
+            // prepare the combo listview
+            this.m_popup = new PopupListView({
+                cls: '@combo-popup',
+                attrs: {
+                    tabindex: 0
+                },
+                selectionChange: (e) => {
+                    this.value = e.selection.id;
+                    if (!this.m_lockpop) {
+                        this._hidePopup();
+                        this.focus();
+                    }
+                },
+                style: {
+                    fontFamily,
+                    fontSize
+                }
+            });
+        }
+        this.m_popup.items = items.map(c => ({ id: c, text: c }));
+        let r1 = this.m_ui_input.getBoundingRect();
+        this.m_popup.setStyle({
+            minWidth: r1.width,
+        });
+        this.m_popup.displayAt(r1.left, r1.bottom);
+        this.m_popvis = true;
+        //if( this.value!==undefined ) {
+        //	this.m_popup.selection = this.value;
+        //}
+    }
+    _validate(value) {
+        return true;
+    }
+    validate() {
+        return super._validate(this.value);
+    }
+    _checkFocus() {
+        const focus = document.activeElement;
+        if (this.dom && this.dom.contains(focus)) {
+            return;
+        }
+        if (this.m_popup && this.m_popup.dom && this.m_popup.dom.contains(focus)) {
+            return;
+        }
+        this._hidePopup();
+    }
+    _hidePopup() {
+        if (this.m_popvis) {
+            this.m_popup.close();
+            this.m_popvis = false;
+        }
+        if (this.m_needval) {
+            this.validate();
+            this.m_needval = false;
+        }
+    }
+    _onFocus() {
+        if (this.value.length == 0) {
+            this._onChange();
+        }
+        this.m_needval = true;
+    }
+}

package/lib/{base_component.js → esm/base_component.js}

@@ -1,4 +1,3 @@
-"use strict";
 /**
 *  ___  ___ __
 *  \  \/  /  / _
@@ -28,13 +27,11 @@
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 **/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseComponent = void 0;
-const x4events_1 = require("./x4events");
+import { EventSource, EvTimer } from './x4events';
 /**
  * BaseComponent class
  */
-class BaseComponent extends x4events_1.EventSource {
+export class BaseComponent extends EventSource {
     m_props;
     #m_timers;
     constructor(props) {
@@ -64,7 +61,7 @@ class BaseComponent extends x4events_1.EventSource {
                 callback(name, tm);
             }
             else {
-                this.emit('timer', (0, x4events_1.EvTimer)(name, tm));
+                this.emit('timer', EvTimer(name, tm));
             }
         }, timeout);
         this.#m_timers.set(name, () => { (repeat ? clearInterval : clearTimeout)(id); });
@@ -108,4 +105,3 @@ class BaseComponent extends x4events_1.EventSource {
         });
     }
 }
-exports.BaseComponent = BaseComponent;

package/lib/esm/button.js

@@ -0,0 +1,257 @@
+/**
+*  ___  ___ __
+*  \  \/  /  / _
+*   \    /  /_| |_
+*   /    \____   _|
+*  /__/\__\   |_|
+*
+* @file button.ts
+* @author Etienne Cochard
+*
+* Copyright (c) 2019-2022 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 { Component } from './component';
+import { EvClick, EvChange } from './x4events';
+import { Icon } from './icon';
+import { Label } from './label';
+import { Menu } from './menu';
+import { isFunction } from './tools';
+/**
+ * Base button
+ */
+export class BaseButton extends Component {
+    constructor(props) {
+        super(props);
+        this.setTag('button');
+        this.setDomEvent('click', (e) => this._handleClick(e));
+        this.setDomEvent('mousedown', () => { this._startAutoRep(true); });
+        this.setDomEvent('mouseup', () => { this._startAutoRep(false); });
+        this.setDomEvent('keydown', (e) => this._handleKeyDown(e));
+        this.mapPropEvents(props, 'click');
+    }
+    render(props) {
+        const action = props.action;
+        let icon = props.icon;
+        let text = props.text;
+        if (action) {
+            if (!icon && action.props.icon) {
+                icon = action.props.icon;
+            }
+            if (text === undefined && action.props.text) {
+                text = action.props.text;
+            }
+        }
+        const ui_icon = icon ? new Icon({ icon, cls: 'left', ref: 'l_icon' }) : null;
+        const ui_label = new Label({ flex: 1, text: text ?? '', align: props.align, ref: 'label' });
+        const ui_ricon = props.rightIcon ? new Icon({ icon: props.rightIcon, cls: 'right', ref: 'r_icon' }) : null;
+        if (text === undefined) {
+            ui_label.addClass("@hidden");
+        }
+        this.setContent([ui_icon, ui_label, ui_ricon]);
+        this._setTabIndex(props.tabIndex);
+    }
+    /**
+     * starts/stops the autorepeat
+     */
+    _startAutoRep(start) {
+        if (!this.m_props.autoRepeat) {
+            return;
+        }
+        if (start) {
+            // 1st timer 1s
+            this.startTimer('repeat', 700, false, () => {
+                // auto click
+                this.startTimer('repeat', this.m_props.autoRepeat, true, this._sendClick);
+            });
+        }
+        else {
+            this.stopTimer('repeat');
+        }
+    }
+    /**
+     *
+     */
+    _handleKeyDown(ev) {
+        if (!ev.ctrlKey && !ev.shiftKey && !ev.altKey) {
+            if (ev.key == 'Enter' || ev.key == ' ') {
+                this._sendClick();
+                ev.preventDefault();
+                ev.stopPropagation();
+            }
+        }
+    }
+    /**
+     * called by the system on click event
+     */
+    _handleClick(ev) {
+        if (this.m_props.menu) {
+            let menu = new Menu({
+                items: isFunction(this.m_props.menu) ? this.m_props.menu() : this.m_props.menu
+            });
+            let rc = this.getBoundingRect();
+            menu.displayAt(rc.left, rc.bottom, 'tl');
+        }
+        else {
+            this._sendClick();
+        }
+        ev.preventDefault();
+        ev.stopPropagation();
+    }
+    /**
+     * sends a click to the observers
+     */
+    _sendClick() {
+        if (this.m_props.menu) {
+            let menu = new Menu({
+                items: isFunction(this.m_props.menu) ? this.m_props.menu() : this.m_props.menu
+            });
+            let rc = this.getBoundingRect();
+            menu.displayAt(rc.left, rc.bottom, 'tl');
+        }
+        else {
+            this.emit('click', EvClick());
+            if (this.m_props.action) {
+                this.m_props.action.fire();
+            }
+        }
+    }
+    /**
+     * change the button text
+     * @example
+     * ```ts
+     * let btn = new Button( {
+     * 	text: 'hello'
+     * });
+     *
+     * btn.text = 'world';
+     * ```
+     */
+    set text(text) {
+        this.m_props.text = text;
+        let label = this.itemWithRef('label');
+        if (label) {
+            label.text = text;
+            label.removeClass("@hidden");
+        }
+    }
+    get text() {
+        let label = this.itemWithRef('label');
+        return label?.text;
+    }
+    /**
+     * change the button icon
+     * todo: do nothing if no icon defined at startup
+     *
+     * @example
+     * ```ts
+     * let btn = new Button( {
+     * 	text: 'hello',
+     *  icon: 'close'
+     * });
+     * btn.setIcon( 'open' );
+     * ```
+     */
+    set icon(icon) {
+        this.m_props.icon = icon;
+        let ico = this.itemWithRef('l_icon');
+        if (ico) {
+            ico.icon = icon;
+        }
+        else {
+            this.update();
+        }
+    }
+    get icon() {
+        let ico = this.itemWithRef('l_icon');
+        return ico?.icon;
+    }
+    /**
+     * change the button right icon
+     * todo: do nothing if no icon defined at startup
+     *
+     * @example
+     * ```ts
+     * let btn = new Button( {
+     * 	text: 'hello',
+     *  icon: 'close'
+     * });
+     * btn.setIcon( 'open' );
+     * ```
+     */
+    set rightIcon(icon) {
+        this.m_props.rightIcon = icon;
+        let ico = this.itemWithRef('r_icon');
+        if (ico) {
+            ico.icon = icon;
+        }
+    }
+    get rightIcon() {
+        let ico = this.itemWithRef('l_icon');
+        return ico?.icon;
+    }
+    /**
+     *
+     */
+    set menu(items) {
+        this.m_props.menu = items;
+    }
+}
+// :: BUTTON ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
+/**
+ *
+ */
+export class Button extends BaseButton {
+}
+/**
+ *
+ */
+export class ToggleButton extends BaseButton {
+    constructor(props) {
+        super(props);
+    }
+    /**
+     *
+     */
+    render(props) {
+        super.render(props);
+        if (props.checked) {
+            this.addClass('checked');
+            this._updateIcon();
+        }
+    }
+    /**
+     *
+     */
+    _sendClick() {
+        super._sendClick();
+        this.m_props.checked = !this.m_props.checked;
+        this.setClass('checked', this.m_props.checked);
+        this.emit('change', EvChange(this.m_props.checked));
+        this._updateIcon();
+    }
+    _updateIcon() {
+        if (this.m_props.checkedIcon) {
+            const ic = this.m_props.checked ? this.m_props.checkedIcon : this.m_props.icon;
+            let ico = this.itemWithRef('l_icon');
+            if (ico) {
+                ico.icon = ic;
+            }
+        }
+    }
+}