verstak 0.24.125 → 0.24.128

package/build/dist/source/html/sensors/HtmlSensors.js

@@ -1,13 +1,3 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { transactional } from "reactronic";
 import { FocusSensor } from "./FocusSensor.js";
 import { HoverSensor } from "./HoverSensor.js";
 import { HtmlDragSensor } from "./HtmlDragSensor.js";
@@ -15,33 +5,89 @@ import { KeyboardSensor } from "./KeyboardSensor.js";
 import { ButtonSensor } from "./ButtonSensor.js";
 import { ResizeSensor } from "./ResizeSensor.js";
 import { WheelSensor } from "./WheelSensor.js";
+import { ScrollSensor } from "./ScrollSensor.js";
 import { WindowSensor } from "./WindowSensor.js";
 import { PointerSensor } from "./PointerSensor.js";
 export class HtmlSensors {
-    constructor() {
-        this.window = new WindowSensor();
-        this.focus = new FocusSensor(this.window);
-        this.hover = new HoverSensor();
-        this.keyboard = new KeyboardSensor();
-        this.wheel = new WheelSensor();
-        this.resize = new ResizeSensor();
-        this.htmlDrag = new HtmlDragSensor(this.focus, this.window);
-        this.button = new ButtonSensor(this.focus, this.window);
-        this.pointer = new PointerSensor(this.focus, this.window);
-    }
-    listen(element, enabled = true) {
-        this.focus.listen(element, enabled);
-        this.hover.listen(element, enabled);
-        this.keyboard.listen(element, enabled);
-        this.wheel.listen(element, enabled);
-        this.htmlDrag.listen(element, enabled);
-        this.button.listen(element, enabled);
-        this.pointer.listen(element, enabled);
+    get window() {
+        if (this._window === undefined) {
+            this._window = new WindowSensor();
+        }
+        return this._window;
+    }
+    get focus() {
+        if (this._focus === undefined) {
+            this._focus = new FocusSensor(this._element, this.window);
+            this._focus.listen();
+        }
+        return this._focus;
+    }
+    get hover() {
+        if (this._hover === undefined) {
+            this._hover = new HoverSensor(this._element);
+            this._hover.listen();
+        }
+        return this._hover;
+    }
+    get keyboard() {
+        if (this._keyboard === undefined) {
+            this._keyboard = new KeyboardSensor(this._element);
+            this._keyboard.listen();
+        }
+        return this._keyboard;
+    }
+    get wheel() {
+        if (this._wheel === undefined) {
+            this._wheel = new WheelSensor(this._element);
+            this._wheel.listen();
+        }
+        return this._wheel;
+    }
+    get scroll() {
+        if (this._scroll === undefined) {
+            this._scroll = new ScrollSensor(this._element);
+            this._scroll.listen();
+        }
+        return this._scroll;
+    }
+    get resize() {
+        if (this._resize === undefined) {
+            this._resize = new ResizeSensor();
+        }
+        return this._resize;
+    }
+    get htmlDrag() {
+        if (this._htmlDrag === undefined) {
+            this._htmlDrag = new HtmlDragSensor(this._element, this.focus, this.window);
+            this._htmlDrag.listen();
+        }
+        return this._htmlDrag;
+    }
+    get button() {
+        if (this._button === undefined) {
+            this._button = new ButtonSensor(this._element, this.focus, this.window);
+            this._button.listen();
+        }
+        return this._button;
+    }
+    get pointer() {
+        if (this._pointer === undefined) {
+            this._pointer = new PointerSensor(this._element, this.focus, this.window);
+            this._pointer.listen();
+        }
+        return this._pointer;
+    }
+    constructor(element) {
+        this._element = element;
+        this._window = undefined;
+        this._focus = undefined;
+        this._hover = undefined;
+        this._keyboard = undefined;
+        this._wheel = undefined;
+        this._scroll = undefined;
+        this._resize = undefined;
+        this._htmlDrag = undefined;
+        this._button = undefined;
+        this._pointer = undefined;
     }
 }
-__decorate([
-    transactional,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Boolean]),
-    __metadata("design:returntype", void 0)
-], HtmlSensors.prototype, "listen", null);

package/build/dist/source/html/sensors/KeyboardSensor.d.ts

@@ -1,27 +1,27 @@
 import { HtmlElementSensor } from "./HtmlElementSensor.js";
 export declare enum KeyboardModifiers {
-    None = 0,
-    Ctrl = 1,
-    Shift = 2,
-    Alt = 4,
-    Meta = 8,
-    CtrlShift = 3,
-    CtrlAlt = 5,
-    CtrlMeta = 9,
-    CtrlShiftAlt = 7,
-    CtrlShiftAltMeta = 15,
-    CtrlShiftMeta = 11,
-    ShiftAlt = 6,
-    ShiftMeta = 10,
-    ShiftAltMeta = 14,
-    AltMeta = 12
+    none = 0,
+    ctrl = 1,
+    shift = 2,
+    alt = 4,
+    meta = 8,
+    ctrlShift = 3,
+    ctrlAlt = 5,
+    ctrlMeta = 9,
+    ctrlShiftAlt = 7,
+    ctrlShiftAltMeta = 15,
+    ctrlShiftMeta = 11,
+    shiftAlt = 6,
+    shiftMeta = 10,
+    shiftAltMeta = 14,
+    altMeta = 12
 }
 export declare class KeyboardSensor extends HtmlElementSensor {
     down: string;
     up: string;
     modifiers: KeyboardModifiers;
-    constructor();
-    listen(element: HTMLElement | undefined, enabled?: boolean): void;
+    constructor(element: HTMLElement | SVGElement);
+    listen(enabled?: boolean): void;
     reset(): void;
     protected onKeyDown(e: KeyboardEvent): void;
     protected onKeyUp(e: KeyboardEvent): void;

package/build/dist/source/html/sensors/KeyboardSensor.js

@@ -12,41 +12,38 @@ import { grabElementDataList, SymDataForSensor } from "./DataForSensor.js";
 import { HtmlElementSensor } from "./HtmlElementSensor.js";
 export var KeyboardModifiers;
 (function (KeyboardModifiers) {
-    KeyboardModifiers[KeyboardModifiers["None"] = 0] = "None";
-    KeyboardModifiers[KeyboardModifiers["Ctrl"] = 1] = "Ctrl";
-    KeyboardModifiers[KeyboardModifiers["Shift"] = 2] = "Shift";
-    KeyboardModifiers[KeyboardModifiers["Alt"] = 4] = "Alt";
-    KeyboardModifiers[KeyboardModifiers["Meta"] = 8] = "Meta";
-    KeyboardModifiers[KeyboardModifiers["CtrlShift"] = 3] = "CtrlShift";
-    KeyboardModifiers[KeyboardModifiers["CtrlAlt"] = 5] = "CtrlAlt";
-    KeyboardModifiers[KeyboardModifiers["CtrlMeta"] = 9] = "CtrlMeta";
-    KeyboardModifiers[KeyboardModifiers["CtrlShiftAlt"] = 7] = "CtrlShiftAlt";
-    KeyboardModifiers[KeyboardModifiers["CtrlShiftAltMeta"] = 15] = "CtrlShiftAltMeta";
-    KeyboardModifiers[KeyboardModifiers["CtrlShiftMeta"] = 11] = "CtrlShiftMeta";
-    KeyboardModifiers[KeyboardModifiers["ShiftAlt"] = 6] = "ShiftAlt";
-    KeyboardModifiers[KeyboardModifiers["ShiftMeta"] = 10] = "ShiftMeta";
-    KeyboardModifiers[KeyboardModifiers["ShiftAltMeta"] = 14] = "ShiftAltMeta";
-    KeyboardModifiers[KeyboardModifiers["AltMeta"] = 12] = "AltMeta";
+    KeyboardModifiers[KeyboardModifiers["none"] = 0] = "none";
+    KeyboardModifiers[KeyboardModifiers["ctrl"] = 1] = "ctrl";
+    KeyboardModifiers[KeyboardModifiers["shift"] = 2] = "shift";
+    KeyboardModifiers[KeyboardModifiers["alt"] = 4] = "alt";
+    KeyboardModifiers[KeyboardModifiers["meta"] = 8] = "meta";
+    KeyboardModifiers[KeyboardModifiers["ctrlShift"] = 3] = "ctrlShift";
+    KeyboardModifiers[KeyboardModifiers["ctrlAlt"] = 5] = "ctrlAlt";
+    KeyboardModifiers[KeyboardModifiers["ctrlMeta"] = 9] = "ctrlMeta";
+    KeyboardModifiers[KeyboardModifiers["ctrlShiftAlt"] = 7] = "ctrlShiftAlt";
+    KeyboardModifiers[KeyboardModifiers["ctrlShiftAltMeta"] = 15] = "ctrlShiftAltMeta";
+    KeyboardModifiers[KeyboardModifiers["ctrlShiftMeta"] = 11] = "ctrlShiftMeta";
+    KeyboardModifiers[KeyboardModifiers["shiftAlt"] = 6] = "shiftAlt";
+    KeyboardModifiers[KeyboardModifiers["shiftMeta"] = 10] = "shiftMeta";
+    KeyboardModifiers[KeyboardModifiers["shiftAltMeta"] = 14] = "shiftAltMeta";
+    KeyboardModifiers[KeyboardModifiers["altMeta"] = 12] = "altMeta";
 })(KeyboardModifiers || (KeyboardModifiers = {}));
 export class KeyboardSensor extends HtmlElementSensor {
-    constructor() {
-        super();
+    constructor(element) {
+        super(element);
         this.down = "";
         this.up = "";
-        this.modifiers = KeyboardModifiers.None;
+        this.modifiers = KeyboardModifiers.none;
     }
-    listen(element, enabled = true) {
-        const existing = this.sourceElement;
-        if (element !== existing) {
-            if (existing) {
-                existing.removeEventListener("keydown", this.onKeyDown.bind(this), { capture: true });
-                existing.removeEventListener("keyup", this.onKeyUp.bind(this), { capture: true });
-            }
-            this.sourceElement = element;
-            if (element && enabled) {
-                element.addEventListener("keydown", this.onKeyDown.bind(this), { capture: true });
-                element.addEventListener("keyup", this.onKeyUp.bind(this), { capture: true });
-            }
+    listen(enabled = true) {
+        const element = this.sourceElement;
+        if (enabled) {
+            element.addEventListener("keydown", this.onKeyDown.bind(this), { capture: true });
+            element.addEventListener("keyup", this.onKeyUp.bind(this), { capture: true });
+        }
+        else {
+            element.removeEventListener("keydown", this.onKeyDown.bind(this), { capture: true });
+            element.removeEventListener("keyup", this.onKeyUp.bind(this), { capture: true });
         }
     }
     reset() {
@@ -54,7 +51,7 @@ export class KeyboardSensor extends HtmlElementSensor {
         this.stopPropagation = false;
         this.down = "";
         this.up = "";
-        this.modifiers = KeyboardModifiers.None;
+        this.modifiers = KeyboardModifiers.none;
     }
     onKeyDown(e) {
         this.keyDown(e);
@@ -83,24 +80,18 @@ export class KeyboardSensor extends HtmlElementSensor {
         this.revision++;
     }
     static getKeyAsModifierIfAny(key) {
-        let modifier = KeyboardModifiers.None;
+        let modifier = KeyboardModifiers.none;
         if (key === "Control")
-            modifier = KeyboardModifiers.Ctrl;
+            modifier = KeyboardModifiers.ctrl;
         else if (key === "Shift")
-            modifier = KeyboardModifiers.Shift;
+            modifier = KeyboardModifiers.shift;
         else if (key === "Alt")
-            modifier = KeyboardModifiers.Alt;
+            modifier = KeyboardModifiers.alt;
         else if (key === "Meta")
-            modifier = KeyboardModifiers.Meta;
+            modifier = KeyboardModifiers.meta;
         return modifier;
     }
 }
-__decorate([
-    transactional,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Boolean]),
-    __metadata("design:returntype", void 0)
-], KeyboardSensor.prototype, "listen", null);
 __decorate([
     transactional,
     __metadata("design:type", Function),
@@ -122,22 +113,22 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], KeyboardSensor.prototype, "keyUp", null);
 export function extractModifierKeys(e) {
-    let modifiers = KeyboardModifiers.None;
+    let modifiers = KeyboardModifiers.none;
     if (e.ctrlKey)
-        modifiers |= KeyboardModifiers.Ctrl;
+        modifiers |= KeyboardModifiers.ctrl;
     else
-        modifiers &= ~KeyboardModifiers.Ctrl;
+        modifiers &= ~KeyboardModifiers.ctrl;
     if (e.shiftKey)
-        modifiers |= KeyboardModifiers.Shift;
+        modifiers |= KeyboardModifiers.shift;
     else
-        modifiers &= ~KeyboardModifiers.Shift;
+        modifiers &= ~KeyboardModifiers.shift;
     if (e.altKey)
-        modifiers |= KeyboardModifiers.Alt;
+        modifiers |= KeyboardModifiers.alt;
     else
-        modifiers &= ~KeyboardModifiers.Alt;
+        modifiers &= ~KeyboardModifiers.alt;
     if (e.metaKey)
-        modifiers |= KeyboardModifiers.Meta;
+        modifiers |= KeyboardModifiers.meta;
     else
-        modifiers &= ~KeyboardModifiers.Meta;
+        modifiers &= ~KeyboardModifiers.meta;
     return modifiers;
 }

package/build/dist/source/html/sensors/PointerSensor.d.ts

@@ -34,10 +34,10 @@ export declare class PointerSensor extends BasePointerSensor {
     immediatePositionY: number;
     immediateModifiers: KeyboardModifiers;
     static readonly DraggingThreshold = 4;
-    constructor(focusSensor: FocusSensor, windowSensor: WindowSensor);
+    constructor(element: HTMLElement | SVGElement, focusSensor: FocusSensor, windowSensor: WindowSensor);
     getData(): unknown;
     setData(value: unknown): void;
-    listen(element: HTMLElement | undefined, enabled?: boolean): void;
+    listen(enabled?: boolean): void;
     protected onPointerDown(e: PointerEvent): void;
     protected onPointerMove(e: PointerEvent): void;
     protected onPointerUp(e: PointerEvent): void;
@@ -54,6 +54,7 @@ export declare class PointerSensor extends BasePointerSensor {
     protected cancelDragging(): void;
     protected reset(): void;
     protected updateClicking(e: PointerEvent): boolean;
+    private _getDefaultDataForSensor;
     protected updateDragTarget(e: PointerEvent): void;
     protected whenClickingOrDragging(): void;
     protected whenMoving(): void;

package/build/dist/source/html/sensors/PointerSensor.js

@@ -12,11 +12,11 @@ import { extractPointerButton, isPointerButtonDown, PointerButton, BasePointerSe
 import { findTargetElementData, SymDataForSensor } from "./DataForSensor.js";
 import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor.js";
 export class PointerSensor extends BasePointerSensor {
-    constructor(focusSensor, windowSensor) {
-        super(focusSensor, windowSensor);
+    constructor(element, focusSensor, windowSensor) {
+        super(element, focusSensor, windowSensor);
         this.hotPositionX = Infinity;
         this.hotPositionY = Infinity;
-        this.pointerButton = PointerButton.None;
+        this.pointerButton = PointerButton.none;
         this.tryingDragging = false;
         this.clickable = undefined;
         this.clicking = undefined;
@@ -37,13 +37,13 @@ export class PointerSensor extends BasePointerSensor {
         this.draggingOver = false;
         this.positionX = Infinity;
         this.positionY = Infinity;
-        this.modifiers = KeyboardModifiers.None;
+        this.modifiers = KeyboardModifiers.none;
         this.dropX = Infinity;
         this.dropY = Infinity;
         this.dropped = false;
         this.immediatePositionX = Infinity;
         this.immediatePositionY = Infinity;
-        this.immediateModifiers = KeyboardModifiers.None;
+        this.immediateModifiers = KeyboardModifiers.none;
     }
     getData() {
         return this.draggingData;
@@ -51,30 +51,22 @@ export class PointerSensor extends BasePointerSensor {
     setData(value) {
         this.draggingData = value;
     }
-    listen(element, enabled = true) {
-        const existing = this.sourceElement;
-        if (element !== existing) {
-            if (existing) {
-                existing.removeEventListener("pointerdown", this.onPointerDown.bind(this), { capture: true });
-                existing.removeEventListener("pointermove", this.onPointerMove.bind(this), { capture: true });
-                existing.removeEventListener("pointerup", this.onPointerUp.bind(this), { capture: true });
-                existing.removeEventListener("lostpointercapture", this.onLostPointerCapture.bind(this), { capture: true });
-                existing.removeEventListener("keydown", this.onKeyDown.bind(this), { capture: true });
-            }
-            this.sourceElement = element;
-            if (element && enabled) {
-                element.addEventListener("pointerdown", this.onPointerDown.bind(this), { capture: true });
-                element.addEventListener("pointermove", this.onPointerMove.bind(this), { capture: true });
-                element.addEventListener("pointerup", this.onPointerUp.bind(this), { capture: true });
-                element.addEventListener("lostpointercapture", this.onLostPointerCapture.bind(this), { capture: true });
-                element.addEventListener("keydown", this.onKeyDown.bind(this), { capture: true });
-            }
+    listen(enabled = true) {
+        const element = this.sourceElement;
+        if (enabled) {
+            element.addEventListener("pointerdown", this.onPointerDown.bind(this), { capture: true });
+            element.addEventListener("pointermove", this.onPointerMove.bind(this), { capture: true });
+            element.addEventListener("pointerup", this.onPointerUp.bind(this), { capture: true });
+            element.addEventListener("lostpointercapture", this.onLostPointerCapture.bind(this), { capture: true });
+            element.addEventListener("keydown", this.onKeyDown.bind(this), { capture: true });
+        }
+        else {
         }
     }
     onPointerDown(e) {
         const button = extractPointerButton(e);
         if (!this.dragStarted && this.clickable === undefined &&
-            (button === PointerButton.Left || button === PointerButton.Right)) {
+            (button === PointerButton.left || button === PointerButton.right)) {
             this.tryClickingOrDragging(e);
         }
     }
@@ -134,20 +126,20 @@ export class PointerSensor extends BasePointerSensor {
         this.immediatePositionY = e.clientY;
     }
     tryClickingOrDragging(e) {
-        var _a;
+        var _a, _b;
         this.preventDefault = false;
         this.stopPropagation = false;
         const targetPath = e.composedPath();
         const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
         const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["click", "draggable"]);
-        const clickable = data === null || data === void 0 ? void 0 : data.click;
+        const clickable = (_a = data === null || data === void 0 ? void 0 : data.click) !== null && _a !== void 0 ? _a : this._getDefaultDataForSensor(e);
         const draggable = data === null || data === void 0 ? void 0 : data.draggable;
         if (clickable || draggable) {
             this.clickable = clickable;
             this.clicking = clickable;
             this.draggableData = draggable;
             this.tryingDragging = draggable !== undefined;
-            this.dragSource = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["drag"], true).data) === null || _a === void 0 ? void 0 : _a.drag;
+            this.dragSource = (_b = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["drag"], true).data) === null || _b === void 0 ? void 0 : _b.drag;
             this.pointerButton = extractPointerButton(e);
             this.startX = e.clientX;
             this.startY = e.clientY;
@@ -214,7 +206,7 @@ export class PointerSensor extends BasePointerSensor {
         this.revision++;
     }
     reset() {
-        this.pointerButton = PointerButton.None;
+        this.pointerButton = PointerButton.none;
         this.clickable = undefined;
         this.clicking = undefined;
         this.clicked = undefined;
@@ -235,20 +227,21 @@ export class PointerSensor extends BasePointerSensor {
         this.draggingOver = false;
         this.positionX = Infinity;
         this.positionY = Infinity;
-        this.modifiers = KeyboardModifiers.None;
+        this.modifiers = KeyboardModifiers.none;
         this.dropX = Infinity;
         this.dropY = Infinity;
         this.dropped = false;
         this.immediatePositionX = Infinity;
         this.immediatePositionY = Infinity;
-        this.immediateModifiers = KeyboardModifiers.None;
+        this.immediateModifiers = KeyboardModifiers.none;
         this.revision++;
     }
     updateClicking(e) {
         var _a;
         const targetPath = e.composedPath();
         const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
-        const clickable = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["click"]).data) === null || _a === void 0 ? void 0 : _a.click;
+        let clickable = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["click"]).data) === null || _a === void 0 ? void 0 : _a.click;
+        clickable = clickable !== null && clickable !== void 0 ? clickable : this._getDefaultDataForSensor(e);
         const isSameClickable = this.clickable === clickable;
         if (isSameClickable)
             this.clicking = clickable;
@@ -257,6 +250,9 @@ export class PointerSensor extends BasePointerSensor {
         this.immediatePositionY = e.clientY;
         return isSameClickable;
     }
+    _getDefaultDataForSensor(e) {
+        return e.currentTarget === this.sourceElement ? e.currentTarget : undefined;
+    }
     updateDragTarget(e) {
         const targetPath = e.composedPath();
         const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
@@ -302,12 +298,6 @@ __decorate([
     raw,
     __metadata("design:type", Boolean)
 ], PointerSensor.prototype, "dropAllowed", void 0);
-__decorate([
-    transactional,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Boolean]),
-    __metadata("design:returntype", void 0)
-], PointerSensor.prototype, "listen", null);
 __decorate([
     transactional,
     options({ logging: LoggingLevel.Off }),
@@ -324,7 +314,7 @@ __decorate([
 ], PointerSensor.prototype, "tryClickingOrDragging", null);
 __decorate([
     transactional,
-    options({ reentrance: Reentrance.CancelPrevious, logging: LoggingLevel.Off }),
+    options({ reentrance: Reentrance.cancelPrevious, logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)

package/build/dist/source/html/sensors/ScrollSensor.d.ts

@@ -0,0 +1,12 @@
+import { HtmlElementSensor } from "./HtmlElementSensor.js";
+export declare class ScrollSensor extends HtmlElementSensor {
+    x: number;
+    y: number;
+    constructor(element: HTMLElement | SVGElement);
+    listen(enabled?: boolean): void;
+    reset(): void;
+    protected onScroll(e: Event): void;
+    protected doScroll(e: Event): void;
+    protected doReset(): void;
+    protected updateSensorData(e: Event): void;
+}

package/build/dist/source/html/sensors/ScrollSensor.js

@@ -0,0 +1,62 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { options, Reentrance, transactional, LoggingLevel } from "reactronic";
+import { HtmlElementSensor } from "./HtmlElementSensor.js";
+export class ScrollSensor extends HtmlElementSensor {
+    constructor(element) {
+        super(element);
+        this.x = Infinity;
+        this.y = Infinity;
+    }
+    listen(enabled = true) {
+        const element = this.sourceElement;
+        if (enabled) {
+            element.addEventListener("scroll", this.onScroll.bind(this), { capture: true, passive: true });
+        }
+        else {
+            element.removeEventListener("scroll", this.onScroll.bind(this), { capture: true });
+        }
+    }
+    reset() {
+        this.doReset();
+    }
+    onScroll(e) {
+        this.doScroll(e);
+    }
+    doScroll(e) {
+        this.updateSensorData(e);
+    }
+    doReset() {
+        this.preventDefault = false;
+        this.stopPropagation = false;
+        this.x = Infinity;
+        this.y = Infinity;
+    }
+    updateSensorData(e) {
+        this.preventDefault = false;
+        this.stopPropagation = false;
+        this.x = this.sourceElement.scrollLeft;
+        this.y = this.sourceElement.scrollTop;
+        this.revision++;
+    }
+}
+__decorate([
+    transactional,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ScrollSensor.prototype, "reset", null);
+__decorate([
+    transactional,
+    options({ reentrance: Reentrance.cancelPrevious, logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Event]),
+    __metadata("design:returntype", void 0)
+], ScrollSensor.prototype, "doScroll", null);

package/build/dist/source/html/sensors/WheelSensor.d.ts

@@ -3,8 +3,8 @@ export declare class WheelSensor extends BasePointerSensor {
     target: unknown;
     deltaX: number;
     deltaY: number;
-    constructor();
-    listen(element: HTMLElement | undefined, enabled?: boolean): void;
+    constructor(element: HTMLElement | SVGElement);
+    listen(enabled?: boolean): void;
     reset(): void;
     protected onWheel(e: WheelEvent): void;
     protected doWheel(e: WheelEvent): void;

package/build/dist/source/html/sensors/WheelSensor.js

@@ -12,23 +12,20 @@ import { findTargetElementData, SymDataForSensor } from "./DataForSensor.js";
 import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor.js";
 import { BasePointerSensor } from "./BasePointerSensor.js";
 export class WheelSensor extends BasePointerSensor {
-    constructor() {
-        super();
+    constructor(element) {
+        super(element);
         this.target = undefined;
         this.target = undefined;
         this.deltaX = Infinity;
         this.deltaY = Infinity;
     }
-    listen(element, enabled = true) {
-        const existing = this.sourceElement;
-        if (element !== existing) {
-            if (existing) {
-                existing.removeEventListener("wheel", this.onWheel.bind(this), { capture: true });
-            }
-            this.sourceElement = element;
-            if (element && enabled) {
-                element.addEventListener("wheel", this.onWheel.bind(this), { capture: true, passive: true });
-            }
+    listen(enabled = true) {
+        const element = this.sourceElement;
+        if (enabled) {
+            element.addEventListener("wheel", this.onWheel.bind(this), { capture: true, passive: true });
+        }
+        else {
+            element.removeEventListener("wheel", this.onWheel.bind(this), { capture: true });
         }
     }
     reset() {
@@ -43,7 +40,7 @@ export class WheelSensor extends BasePointerSensor {
     doReset() {
         this.preventDefault = false;
         this.stopPropagation = false;
-        this.modifiers = KeyboardModifiers.None;
+        this.modifiers = KeyboardModifiers.none;
         this.positionX = Infinity;
         this.positionY = Infinity;
         this.target = undefined;
@@ -65,12 +62,6 @@ export class WheelSensor extends BasePointerSensor {
         this.revision++;
     }
 }
-__decorate([
-    transactional,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Boolean]),
-    __metadata("design:returntype", void 0)
-], WheelSensor.prototype, "listen", null);
 __decorate([
     transactional,
     __metadata("design:type", Function),
@@ -79,7 +70,7 @@ __decorate([
 ], WheelSensor.prototype, "reset", null);
 __decorate([
     transactional,
-    options({ reentrance: Reentrance.CancelPrevious, logging: LoggingLevel.Off }),
+    options({ reentrance: Reentrance.cancelPrevious, logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [WheelEvent]),
     __metadata("design:returntype", void 0)