jsl-ui 9.28.2 → 9.28.3

package/lib/interaction/dataconverter.d.ts

@@ -1,4 +1,4 @@
-export interface IDataConverter<TData, TUI> {
-    toUI?: (value: TData) => TUI;
-    toData?: (value: TUI) => TData;
-}
+export interface IDataConverter<TData, TUI> {
+    toUI?: (value: TData) => TUI;
+    toData?: (value: TUI) => TData;
+}

package/lib/interaction/dataconverter.js

@@ -1 +0,0 @@
-export {};

package/lib/interaction/eventhandler.d.ts

@@ -1,13 +1,13 @@
-export interface IEvent<T, T2 = void> {
-    subscribe(fnc: (args?: T, args2?: T2) => any): any;
-    notify(val?: T): any;
-}
-export declare class EventHandler<T, T2 = void> implements IEvent<T, T2> {
-    static Create(click: (EventHandler<any, any> | ((p?: any, p2?: any) => any))): EventHandler<any, any>;
-    private handlers;
-    constructor(fnc?: (args?: T, args2?: T2) => any);
-    subscribe(fnc: (args?: T, args2?: T2) => any): void;
-    notify(val?: T, val2?: T2): void;
-    count(): number;
-    unSubscribe(fnc: (args?: T, args2?: T2) => any): void;
-}
+export interface IEvent<T, T2 = void> {
+    subscribe(fnc: (args?: T, args2?: T2) => any): any;
+    notify(val?: T): any;
+}
+export declare class EventHandler<T, T2 = void> implements IEvent<T, T2> {
+    static Create(click: (EventHandler<any, any> | ((p?: any, p2?: any) => any))): EventHandler<any, any>;
+    private handlers;
+    constructor(fnc?: (args?: T, args2?: T2) => any);
+    subscribe(fnc: (args?: T, args2?: T2) => any): void;
+    notify(val?: T, val2?: T2): void;
+    count(): number;
+    unSubscribe(fnc: (args?: T, args2?: T2) => any): void;
+}

package/lib/interaction/eventhandler.js

@@ -1,42 +1,39 @@
-var EventHandler = /** @class */ (function () {
-    function EventHandler(fnc) {
-        this.handlers = [];
-        if (fnc != null) {
-            this.handlers.push(fnc);
-        }
-    }
-    EventHandler.Create = function (click) {
-        if (click == null) {
-            return new EventHandler();
-        }
-        if (typeof click === "function") {
-            var res = new EventHandler();
-            res.subscribe(click);
-            return res;
-        }
-        return click;
-    };
-    EventHandler.prototype.subscribe = function (fnc) {
-        this.handlers.push(fnc);
-    };
-    EventHandler.prototype.notify = function (val, val2) {
-        for (var _i = 0, _a = this.handlers; _i < _a.length; _i++) {
-            var h = _a[_i];
-            h(val, val2);
-        }
-    };
-    EventHandler.prototype.count = function () {
-        return this.handlers.length;
-    };
-    EventHandler.prototype.unSubscribe = function (fnc) {
-        if (this.handlers.indexOf(fnc) >= 0) {
-            this.handlers.splice(this.handlers.indexOf(fnc), 1);
-        }
-        else {
-            // TODO? throw exception?
-            console.warn("handler not found in EventHandler.unSubscribe");
-        }
-    };
-    return EventHandler;
-}());
-export { EventHandler };
+export class EventHandler {
+    constructor(fnc) {
+        this.handlers = [];
+        if (fnc != null) {
+            this.handlers.push(fnc);
+        }
+    }
+    static Create(click) {
+        if (click == null) {
+            return new EventHandler();
+        }
+        if (typeof click === "function") {
+            const res = new EventHandler();
+            res.subscribe(click);
+            return res;
+        }
+        return click;
+    }
+    subscribe(fnc) {
+        this.handlers.push(fnc);
+    }
+    notify(val, val2) {
+        for (const h of this.handlers) {
+            h(val, val2);
+        }
+    }
+    count() {
+        return this.handlers.length;
+    }
+    unSubscribe(fnc) {
+        if (this.handlers.indexOf(fnc) >= 0) {
+            this.handlers.splice(this.handlers.indexOf(fnc), 1);
+        }
+        else {
+            // TODO? throw exception?
+            console.warn("handler not found in EventHandler.unSubscribe");
+        }
+    }
+}

package/lib/interaction/moveable.d.ts

@@ -1,39 +1,39 @@
-import "./moveable.css";
-import "../core/polyfills";
-import { EventHandler } from "./eventhandler";
-export interface IMoveEventArg {
-    x: number;
-    y: number;
-    target: HTMLElement;
-    evt: MouseEvent;
-    cancelEvent: () => void;
-}
-export interface IMoveableOptions {
-    moveDelta?: number;
-    onStart?: EventHandler<IMoveEventArg>;
-    onStop?: EventHandler<IMoveEventArg>;
-    onMove?: EventHandler<IMoveEventArg>;
-    gridX?: number;
-    gridY?: number;
-    selector?: string;
-    handleSelector?: string;
-    direction?: "x" | "y" | "both";
-    containInParent?: boolean;
-}
-export declare class MoveableContainer {
-    private container;
-    private options;
-    private element;
-    private resizeX;
-    private resizeY;
-    private initialX;
-    private initialY;
-    private startSize;
-    constructor(container: HTMLElement, options: IMoveableOptions);
-    private init;
-    private mouseDownContainer;
-    private mouseMove;
-    private mouseUp;
-    private extractArg;
-}
-export declare function Moveable(selector: HTMLElement | string, options?: IMoveableOptions): MoveableContainer;
+import "./moveable.css";
+import "../core/polyfills";
+import { EventHandler } from "./eventhandler";
+export interface IMoveEventArg {
+    x: number;
+    y: number;
+    target: HTMLElement;
+    evt: MouseEvent;
+    cancelEvent: () => void;
+}
+export interface IMoveableOptions {
+    moveDelta?: number;
+    onStart?: EventHandler<IMoveEventArg>;
+    onStop?: EventHandler<IMoveEventArg>;
+    onMove?: EventHandler<IMoveEventArg>;
+    gridX?: number;
+    gridY?: number;
+    selector?: string;
+    handleSelector?: string;
+    direction?: "x" | "y" | "both";
+    containInParent?: boolean;
+}
+export declare class MoveableContainer {
+    private container;
+    private options;
+    private element;
+    private resizeX;
+    private resizeY;
+    private initialX;
+    private initialY;
+    private startSize;
+    constructor(container: HTMLElement, options: IMoveableOptions);
+    private init;
+    private mouseDownContainer;
+    private mouseMove;
+    private mouseUp;
+    private extractArg;
+}
+export declare function Moveable(selector: HTMLElement | string, options?: IMoveableOptions): MoveableContainer;

package/lib/interaction/moveable.js

@@ -1,174 +1,160 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import "./moveable.css";
-import "../core/polyfills";
-import { EventHandler } from "./eventhandler";
-var defaultOptions = {
-    onStart: new EventHandler(),
-    onStop: new EventHandler(),
-    onMove: new EventHandler(),
-    direction: "both",
-    moveDelta: 0,
-    containInParent: true
-};
-var MoveableContainer = /** @class */ (function () {
-    function MoveableContainer(container, options) {
-        var _this = this;
-        this.container = container;
-        this.options = options;
-        this.resizeX = false;
-        this.resizeY = false;
-        this.initialX = null;
-        this.initialY = null;
-        this.startSize = { x: null, y: null };
-        this.mouseDownContainer = function (evt) {
-            var target = evt.target;
-            var directChild = target;
-            while (directChild.parentElement != null && directChild.parentElement !== _this.container) {
-                if (_this.options.selector != null && directChild.matches(_this.options.selector)) {
-                    break;
-                }
-                directChild = directChild.parentElement;
-            }
-            if (directChild.parentElement == null) {
-                return;
-            }
-            if (_this.options.selector != null && !directChild.matches(_this.options.selector)) {
-                return;
-            }
-            _this.element = directChild;
-            var canceled = false;
-            var args = {
-                evt: evt,
-                target: _this.element,
-                x: _this.element.offsetLeft,
-                y: _this.element.offsetTop,
-                cancelEvent: function () { canceled = true; }
-            };
-            _this.options.onStart.notify(args);
-            if (canceled) {
-                return;
-            }
-            evt.preventDefault();
-            evt.stopPropagation();
-            evt.stopImmediatePropagation();
-            _this.initialX = _this.extractArg(evt, "clientX") - _this.element.offsetLeft;
-            _this.initialY = _this.extractArg(evt, "clientY") - _this.element.offsetTop;
-            // register event listeners
-            window.addEventListener("mousemove", _this.mouseMove, false);
-            window.addEventListener("mouseup", _this.mouseUp, false);
-            window.addEventListener("touchmove", _this.mouseMove, false);
-            window.addEventListener("touchend", _this.mouseUp, false);
-        };
-        this.mouseMove = function (evt) {
-            var raiseEvt = false;
-            var x = 0;
-            if (_this.resizeX) {
-                var val = _this.extractArg(evt, "clientX");
-                if (_this.startSize != null && _this.startSize.x == null) {
-                    _this.startSize.x = val;
-                }
-                if (_this.startSize == null || Math.abs(_this.startSize.x - val) >= _this.options.moveDelta) {
-                    //if (!this.options.gridX || Math.round(val) % this.options.gridX === 0) {
-                    x = val - _this.initialX;
-                    if (_this.options.gridX) {
-                        x = Math.round(x / _this.options.gridX) * _this.options.gridX;
-                    }
-                    if (_this.options.containInParent) {
-                        if (x < 0) {
-                            x = 0;
-                        }
-                        var maxX = _this.container.clientWidth - _this.element.offsetWidth;
-                        if (x > maxX) {
-                            x = maxX;
-                        }
-                    }
-                    _this.element.style.left = x + "px";
-                    raiseEvt = true;
-                    _this.startSize = null;
-                    //}
-                }
-            }
-            var y = 0;
-            if (_this.resizeY) {
-                var val = _this.extractArg(evt, "clientY");
-                if (_this.startSize != null && _this.startSize.y == null) {
-                    _this.startSize.y = val;
-                }
-                if (_this.startSize == null || Math.abs(_this.startSize.y - val) >= _this.options.moveDelta) {
-                    //if (!this.options.gridY || Math.round(val) % this.options.gridY === 0) {
-                    y = val - _this.initialY;
-                    if (_this.options.gridY) {
-                        y = Math.round(y / _this.options.gridY) * _this.options.gridY;
-                    }
-                    if (_this.options.containInParent) {
-                        if (y < 0) {
-                            y = 0;
-                        }
-                        var maxY = _this.container.clientHeight - _this.element.offsetHeight;
-                        if (y > maxY) {
-                            y = maxY;
-                        }
-                    }
-                    _this.element.style.top = y + "px";
-                    raiseEvt = true;
-                    _this.startSize = null;
-                    //}
-                }
-            }
-            if (raiseEvt) {
-                _this.options.onMove.notify({
-                    evt: evt,
-                    target: _this.element,
-                    x: x,
-                    y: y,
-                    cancelEvent: function () { }
-                });
-            }
-        };
-        this.mouseUp = function (evt) {
-            window.removeEventListener("mousemove", _this.mouseMove, false);
-            window.removeEventListener("mouseup", _this.mouseUp, false);
-            window.removeEventListener("touchmove", _this.mouseMove, false);
-            window.removeEventListener("touchend", _this.mouseUp, false);
-            _this.options.onStop.notify({
-                evt: evt,
-                target: _this.element,
-                x: _this.element.offsetLeft,
-                y: _this.element.offsetTop,
-                cancelEvent: function () { }
-            });
-            _this.startSize = { x: null, y: null };
-        };
-        if (options.direction === "x" || options.direction === "both") {
-            this.resizeX = true;
-        }
-        if (options.direction === "y" || options.direction === "both") {
-            this.resizeY = true;
-        }
-        this.init();
-    }
-    MoveableContainer.prototype.init = function () {
-        this.container.addEventListener("mousedown", this.mouseDownContainer, false);
-        this.container.addEventListener("touchstart", this.mouseDownContainer, false);
-    };
-    MoveableContainer.prototype.extractArg = function (evt, key) {
-        return evt[key] != null ? evt[key] : (evt.touches.length > 0 ? evt.touches : evt.changedTouches)[0][key];
-    };
-    return MoveableContainer;
-}());
-export { MoveableContainer };
-export function Moveable(selector, options) {
-    return new MoveableContainer(typeof selector === "string" ?
-        document.querySelector(selector) :
-        selector, __assign(__assign({}, defaultOptions), options));
-}
+import "./moveable.css";
+import "../core/polyfills";
+import { EventHandler } from "./eventhandler";
+const defaultOptions = {
+    onStart: new EventHandler(),
+    onStop: new EventHandler(),
+    onMove: new EventHandler(),
+    direction: "both",
+    moveDelta: 0,
+    containInParent: true
+};
+export class MoveableContainer {
+    constructor(container, options) {
+        this.container = container;
+        this.options = options;
+        this.resizeX = false;
+        this.resizeY = false;
+        this.initialX = null;
+        this.initialY = null;
+        this.startSize = { x: null, y: null };
+        this.mouseDownContainer = (evt) => {
+            const target = evt.target;
+            let directChild = target;
+            while (directChild.parentElement != null && directChild.parentElement !== this.container) {
+                if (this.options.selector != null && directChild.matches(this.options.selector)) {
+                    break;
+                }
+                directChild = directChild.parentElement;
+            }
+            if (directChild.parentElement == null) {
+                return;
+            }
+            if (this.options.selector != null && !directChild.matches(this.options.selector)) {
+                return;
+            }
+            this.element = directChild;
+            let canceled = false;
+            const args = {
+                evt,
+                target: this.element,
+                x: this.element.offsetLeft,
+                y: this.element.offsetTop,
+                cancelEvent: () => { canceled = true; }
+            };
+            this.options.onStart.notify(args);
+            if (canceled) {
+                return;
+            }
+            evt.preventDefault();
+            evt.stopPropagation();
+            evt.stopImmediatePropagation();
+            this.initialX = this.extractArg(evt, "clientX") - this.element.offsetLeft;
+            this.initialY = this.extractArg(evt, "clientY") - this.element.offsetTop;
+            // register event listeners
+            window.addEventListener("mousemove", this.mouseMove, false);
+            window.addEventListener("mouseup", this.mouseUp, false);
+            window.addEventListener("touchmove", this.mouseMove, false);
+            window.addEventListener("touchend", this.mouseUp, false);
+        };
+        this.mouseMove = (evt) => {
+            let raiseEvt = false;
+            let x = 0;
+            if (this.resizeX) {
+                const val = this.extractArg(evt, "clientX");
+                if (this.startSize != null && this.startSize.x == null) {
+                    this.startSize.x = val;
+                }
+                if (this.startSize == null || Math.abs(this.startSize.x - val) >= this.options.moveDelta) {
+                    //if (!this.options.gridX || Math.round(val) % this.options.gridX === 0) {
+                    x = val - this.initialX;
+                    if (this.options.gridX) {
+                        x = Math.round(x / this.options.gridX) * this.options.gridX;
+                    }
+                    if (this.options.containInParent) {
+                        if (x < 0) {
+                            x = 0;
+                        }
+                        const maxX = this.container.clientWidth - this.element.offsetWidth;
+                        if (x > maxX) {
+                            x = maxX;
+                        }
+                    }
+                    this.element.style.left = x + "px";
+                    raiseEvt = true;
+                    this.startSize = null;
+                    //}
+                }
+            }
+            let y = 0;
+            if (this.resizeY) {
+                const val = this.extractArg(evt, "clientY");
+                if (this.startSize != null && this.startSize.y == null) {
+                    this.startSize.y = val;
+                }
+                if (this.startSize == null || Math.abs(this.startSize.y - val) >= this.options.moveDelta) {
+                    //if (!this.options.gridY || Math.round(val) % this.options.gridY === 0) {
+                    y = val - this.initialY;
+                    if (this.options.gridY) {
+                        y = Math.round(y / this.options.gridY) * this.options.gridY;
+                    }
+                    if (this.options.containInParent) {
+                        if (y < 0) {
+                            y = 0;
+                        }
+                        const maxY = this.container.clientHeight - this.element.offsetHeight;
+                        if (y > maxY) {
+                            y = maxY;
+                        }
+                    }
+                    this.element.style.top = y + "px";
+                    raiseEvt = true;
+                    this.startSize = null;
+                    //}
+                }
+            }
+            if (raiseEvt) {
+                this.options.onMove.notify({
+                    evt,
+                    target: this.element,
+                    x,
+                    y,
+                    cancelEvent: () => { }
+                });
+            }
+        };
+        this.mouseUp = (evt) => {
+            window.removeEventListener("mousemove", this.mouseMove, false);
+            window.removeEventListener("mouseup", this.mouseUp, false);
+            window.removeEventListener("touchmove", this.mouseMove, false);
+            window.removeEventListener("touchend", this.mouseUp, false);
+            this.options.onStop.notify({
+                evt,
+                target: this.element,
+                x: this.element.offsetLeft,
+                y: this.element.offsetTop,
+                cancelEvent: () => { }
+            });
+            this.startSize = { x: null, y: null };
+        };
+        if (options.direction === "x" || options.direction === "both") {
+            this.resizeX = true;
+        }
+        if (options.direction === "y" || options.direction === "both") {
+            this.resizeY = true;
+        }
+        this.init();
+    }
+    init() {
+        this.container.addEventListener("mousedown", this.mouseDownContainer, false);
+        this.container.addEventListener("touchstart", this.mouseDownContainer, false);
+    }
+    extractArg(evt, key) {
+        return evt[key] != null ? evt[key] : (evt.touches.length > 0 ? evt.touches : evt.changedTouches)[0][key];
+    }
+}
+export function Moveable(selector, options) {
+    return new MoveableContainer(typeof selector === "string" ?
+        document.querySelector(selector) :
+        selector, { ...defaultOptions, ...options });
+}

package/lib/interaction/resizable.d.ts

@@ -1,37 +1,37 @@
-import "./resizable.css";
-import "../core/polyfills";
-import { EventHandler } from "./eventhandler";
-export interface IResizeEventArg {
-    x: number;
-    y: number;
-    target: HTMLElement;
-    evt: MouseEvent;
-}
-export interface IResizeOptions {
-    minWidth?: number;
-    maxWidth?: number;
-    minHeight?: number;
-    maxHeight?: number;
-    resizeDelta?: number;
-    resizeHandlePrefix?: string;
-    onStart?: EventHandler<IResizeEventArg>;
-    onStop?: EventHandler<IResizeEventArg>;
-    onResize?: EventHandler<IResizeEventArg>;
-    gridX?: number;
-    gridY?: number;
-}
-export declare class ResizeContainer {
-    private container;
-    private options;
-    private element;
-    private resizeX;
-    private resizeY;
-    private startSize;
-    constructor(container: HTMLElement, options: IResizeOptions);
-    private init;
-    private mouseDownContainer;
-    private mouseMove;
-    private mouseUp;
-    private extractArg;
-}
-export declare function Resizable(selector: HTMLElement | string, options?: IResizeOptions): ResizeContainer;
+import "./resizable.css";
+import "../core/polyfills";
+import { EventHandler } from "./eventhandler";
+export interface IResizeEventArg {
+    x: number;
+    y: number;
+    target: HTMLElement;
+    evt: MouseEvent;
+}
+export interface IResizeOptions {
+    minWidth?: number;
+    maxWidth?: number;
+    minHeight?: number;
+    maxHeight?: number;
+    resizeDelta?: number;
+    resizeHandlePrefix?: string;
+    onStart?: EventHandler<IResizeEventArg>;
+    onStop?: EventHandler<IResizeEventArg>;
+    onResize?: EventHandler<IResizeEventArg>;
+    gridX?: number;
+    gridY?: number;
+}
+export declare class ResizeContainer {
+    private container;
+    private options;
+    private element;
+    private resizeX;
+    private resizeY;
+    private startSize;
+    constructor(container: HTMLElement, options: IResizeOptions);
+    private init;
+    private mouseDownContainer;
+    private mouseMove;
+    private mouseUp;
+    private extractArg;
+}
+export declare function Resizable(selector: HTMLElement | string, options?: IResizeOptions): ResizeContainer;