verstak 0.24.125 → 0.24.128

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

@@ -13,54 +13,51 @@ import { findTargetElementData, SymDataForSensor } from "./DataForSensor.js";
 import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor.js";
 export var ButtonState;
 (function (ButtonState) {
-    ButtonState[ButtonState["Pressed"] = 0] = "Pressed";
-    ButtonState[ButtonState["Selecting"] = 1] = "Selecting";
-    ButtonState[ButtonState["Selected"] = 2] = "Selected";
-    ButtonState[ButtonState["Released"] = 3] = "Released";
+    ButtonState[ButtonState["pressed"] = 0] = "pressed";
+    ButtonState[ButtonState["selecting"] = 1] = "selecting";
+    ButtonState[ButtonState["selected"] = 2] = "selected";
+    ButtonState[ButtonState["released"] = 3] = "released";
 })(ButtonState || (ButtonState = {}));
 export class ButtonSensor extends BasePointerSensor {
-    constructor(focusSensor, windowSensor) {
-        super(focusSensor, windowSensor);
-        this.state = ButtonState.Released;
-        this.pointerButton = PointerButton.None;
+    constructor(element, focusSensor, windowSensor) {
+        super(element, focusSensor, windowSensor);
+        this.state = ButtonState.released;
+        this.pointerButton = PointerButton.none;
         this.originData = undefined;
         this.selectedData = undefined;
         this.selectedX = Infinity;
         this.selectedY = Infinity;
         this.selected = false;
     }
-    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 {
+            element.removeEventListener("pointerdown", this.onPointerDown.bind(this), { capture: true });
+            element.removeEventListener("pointermove", this.onPointerMove.bind(this), { capture: true });
+            element.removeEventListener("pointerup", this.onPointerUp.bind(this), { capture: true });
+            element.removeEventListener("lostpointercapture", this.onLostPointerCapture.bind(this), { capture: true });
+            element.removeEventListener("keydown", this.onKeyDown.bind(this), { capture: true });
         }
     }
     onPointerDown(e) {
-        if (this.state === ButtonState.Released && (this.pointerButton === PointerButton.None))
+        if (this.state === ButtonState.released && (this.pointerButton === PointerButton.none))
             this.press(e);
         this.setPreventDefaultAndStopPropagation(e);
     }
     onPointerMove(e) {
         const state = this.state;
         if (isPointerButtonDown(this.pointerButton, e.buttons)) {
-            if (state === ButtonState.Pressed || state === ButtonState.Selecting)
+            if (state === ButtonState.pressed || state === ButtonState.selecting)
                 this.selecting(e);
         }
-        else if (state !== ButtonState.Released) {
+        else if (state !== ButtonState.released) {
             this.cancel();
             this.reset();
         }
@@ -69,11 +66,11 @@ export class ButtonSensor extends BasePointerSensor {
     onPointerUp(e) {
         const button = extractPointerButton(e);
         if (button === this.pointerButton) {
-            if (this.state === ButtonState.Selecting) {
+            if (this.state === ButtonState.selecting) {
                 this.select(e);
                 this.release();
             }
-            else if (this.state === ButtonState.Pressed) {
+            else if (this.state === ButtonState.pressed) {
                 this.release();
             }
         }
@@ -83,13 +80,13 @@ export class ButtonSensor extends BasePointerSensor {
         this.setPreventDefaultAndStopPropagation(e);
     }
     onLostPointerCapture(e) {
-        if (this.state !== ButtonState.Released) {
+        if (this.state !== ButtonState.released) {
             this.cancel();
             this.reset();
         }
     }
     onKeyDown(e) {
-        if (e.key === "Escape" && this.state !== ButtonState.Released) {
+        if (e.key === "Escape" && this.state !== ButtonState.released) {
             this.cancel();
             this.reset();
         }
@@ -102,7 +99,7 @@ export class ButtonSensor extends BasePointerSensor {
         const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["button"]);
         const originData = data === null || data === void 0 ? void 0 : data.button;
         if (originData) {
-            this.state = ButtonState.Pressed;
+            this.state = ButtonState.pressed;
             this.pointerButton = extractPointerButton(e);
             this.originData = originData;
             this.modifiers = extractModifierKeys(e);
@@ -117,12 +114,12 @@ export class ButtonSensor extends BasePointerSensor {
     }
     selecting(e) {
         this.updateSensorData(e);
-        this.state = ButtonState.Selecting;
+        this.state = ButtonState.selecting;
         this.selected = false;
     }
     select(e) {
         this.updateSensorData(e);
-        this.state = ButtonState.Selected;
+        this.state = ButtonState.selected;
         this.selectedX = e.clientX;
         this.selectedY = e.clientY;
         this.selected = true;
@@ -130,26 +127,26 @@ export class ButtonSensor extends BasePointerSensor {
     release() {
         this.preventDefault = false;
         this.stopPropagation = false;
-        this.state = ButtonState.Released;
+        this.state = ButtonState.released;
         this.revision++;
     }
     cancel() {
-        this.state = ButtonState.Released;
+        this.state = ButtonState.released;
         this.selected = false;
         this.revision++;
     }
     reset() {
         this.preventDefault = false;
         this.stopPropagation = false;
-        this.state = ButtonState.Released;
+        this.state = ButtonState.released;
         this.originData = undefined;
         this.selectedData = undefined;
-        this.pointerButton = PointerButton.None;
+        this.pointerButton = PointerButton.none;
         this.positionX = Infinity;
         this.positionY = Infinity;
         this.selectedX = Infinity;
         this.selectedY = Infinity;
-        this.modifiers = KeyboardModifiers.None;
+        this.modifiers = KeyboardModifiers.none;
         this.selected = false;
     }
     updateSensorData(e) {
@@ -161,12 +158,6 @@ export class ButtonSensor extends BasePointerSensor {
         this.revision++;
     }
 }
-__decorate([
-    transactional,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Boolean]),
-    __metadata("design:returntype", void 0)
-], ButtonSensor.prototype, "listen", null);
 __decorate([
     transactional,
     options({ logging: LoggingLevel.Off }),
@@ -176,7 +167,7 @@ __decorate([
 ], ButtonSensor.prototype, "press", 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/DataForSensor.d.ts

@@ -13,6 +13,7 @@ export type DataForSensor = {
     htmlDraggable?: unknown;
     button?: unknown;
 };
+export declare const SymHtmlSensors: unique symbol;
 export declare const SymDataForSensor: unique symbol;
 export declare const SymResizeObserver: unique symbol;
 export declare const EmptyDataArray: any[];

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

@@ -1,3 +1,4 @@
+export const SymHtmlSensors = Symbol("HtmlSensors");
 export const SymDataForSensor = Symbol("DataForSensor");
 export const SymResizeObserver = Symbol("ResizeObserver");
 export const EmptyDataArray = [];

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

@@ -15,9 +15,9 @@ export declare class FocusSensor extends HtmlElementSensor {
     activeData: unknown;
     oldActiveData: unknown;
     contextElementDataList: unknown[];
-    constructor(windowSensor: WindowSensor);
+    constructor(element: HTMLElement | SVGElement, windowSensor: WindowSensor);
     setActiveData(data: unknown, debugHint?: string): void;
-    listen(element: HTMLElement | undefined, enabled?: boolean): void;
+    listen(enabled?: boolean): void;
     reset(): void;
     protected onFocusIn(e: FocusEvent): void;
     protected onFocusOut(e: FocusEvent): void;

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

@@ -12,8 +12,8 @@ import { objectHasMember } from "../ElUtils.js";
 import { grabElementDataList, SymDataForSensor } from "./DataForSensor.js";
 import { HtmlElementSensor } from "./HtmlElementSensor.js";
 export class FocusSensor extends HtmlElementSensor {
-    constructor(windowSensor) {
-        super(undefined, windowSensor);
+    constructor(element, windowSensor) {
+        super(element, undefined, windowSensor);
         this.activeData = undefined;
         this.oldActiveData = undefined;
         this.contextElementDataList = [];
@@ -36,20 +36,17 @@ export class FocusSensor extends HtmlElementSensor {
             this.activeData = data;
         }
     }
-    listen(element, enabled = true) {
-        const existing = this.sourceElement;
-        if (element !== existing) {
-            if (existing) {
-                existing.removeEventListener("focusin", this.onFocusIn.bind(this), { capture: true });
-                existing.removeEventListener("focusout", this.onFocusOut.bind(this), { capture: true });
-                existing.removeEventListener("mousedown", this.onMouseDown.bind(this), { capture: true });
-            }
-            this.sourceElement = element;
-            if (element && enabled) {
-                element.addEventListener("focusin", this.onFocusIn.bind(this), { capture: true });
-                element.addEventListener("focusout", this.onFocusOut.bind(this), { capture: true });
-                element.addEventListener("mousedown", this.onMouseDown.bind(this), { capture: true });
-            }
+    listen(enabled = true) {
+        const element = this.sourceElement;
+        if (enabled) {
+            element.addEventListener("focusin", this.onFocusIn.bind(this), { capture: true });
+            element.addEventListener("focusout", this.onFocusOut.bind(this), { capture: true });
+            element.addEventListener("mousedown", this.onMouseDown.bind(this), { capture: true });
+        }
+        else {
+            element.removeEventListener("focusin", this.onFocusIn.bind(this), { capture: true });
+            element.removeEventListener("focusout", this.onFocusOut.bind(this), { capture: true });
+            element.removeEventListener("mousedown", this.onMouseDown.bind(this), { capture: true });
         }
     }
     reset() {
@@ -138,7 +135,7 @@ __decorate([
 __decorate([
     transactional,
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Boolean]),
+    __metadata("design:paramtypes", [Boolean]),
     __metadata("design:returntype", void 0)
 ], FocusSensor.prototype, "listen", null);
 __decorate([

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

@@ -1,10 +1,21 @@
 import { BasePointerSensor } from "./BasePointerSensor.js";
+export type IHoverable = {
+    isHovered: boolean;
+    onHoverStart?: (hover: HoverSensor) => void;
+    onHoverEnd?: (hover: HoverSensor) => void;
+};
 export declare class HoverSensor extends BasePointerSensor {
+    isHovered: boolean;
     target: unknown;
-    constructor();
-    listen(element: HTMLElement | undefined, enabled?: boolean): void;
+    constructor(element: HTMLElement | SVGElement);
+    listen(enabled?: boolean): void;
+    protected onPointerEnter(e: PointerEvent): void;
     protected onPointerOver(e: PointerEvent): void;
-    protected onPointerOut(e: PointerEvent): void;
+    protected onPointerMove(e: PointerEvent): void;
+    protected onPointerLeave(e: PointerEvent): void;
+    protected doPointerEnter(e: PointerEvent): void;
     protected doPointerOver(e: PointerEvent): void;
-    protected doPointerOut(): void;
+    protected doPointerMove(e: PointerEvent): void;
+    protected doPointerLeave(e: PointerEvent): void;
+    protected reset(): void;
 }

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

@@ -8,34 +8,48 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { options, transactional, LoggingLevel } from "reactronic";
-import { findTargetElementData, SymDataForSensor } from "./DataForSensor.js";
-import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor.js";
+import { SymDataForSensor, findTargetElementData } from "./DataForSensor.js";
 import { BasePointerSensor } from "./BasePointerSensor.js";
+import { KeyboardModifiers, extractModifierKeys } from "./KeyboardSensor.js";
 export class HoverSensor extends BasePointerSensor {
-    constructor() {
-        super();
+    constructor(element) {
+        super(element);
         this.target = undefined;
+        this.isHovered = false;
         this.target = undefined;
     }
-    listen(element, enabled = true) {
-        const existing = this.sourceElement;
-        if (element !== existing) {
-            if (existing) {
-                existing.removeEventListener("pointerover", this.onPointerOver.bind(this), { capture: true });
-                existing.removeEventListener("pointerout", this.onPointerOut.bind(this), { capture: true });
-            }
-            this.sourceElement = element;
-            if (element && enabled) {
-                element.addEventListener("pointerover", this.onPointerOver.bind(this), { capture: true });
-                element.addEventListener("pointerout", this.onPointerOut.bind(this), { capture: true });
-            }
+    listen(enabled = true) {
+        const element = this.sourceElement;
+        if (enabled) {
+            element.addEventListener("pointerenter", this.onPointerEnter.bind(this));
+            element.addEventListener("pointerover", this.onPointerOver.bind(this), { capture: true });
+            element.addEventListener("pointermove", this.onPointerMove.bind(this), { capture: true });
+            element.addEventListener("pointerleave", this.onPointerLeave.bind(this));
         }
+        else {
+            element.removeEventListener("pointerenter", this.onPointerEnter.bind(this));
+            element.removeEventListener("pointerover", this.onPointerOver.bind(this), { capture: true });
+            element.removeEventListener("pointermove", this.onPointerMove.bind(this), { capture: true });
+            element.removeEventListener("pointerleave", this.onPointerLeave.bind(this));
+        }
+    }
+    onPointerEnter(e) {
+        this.doPointerEnter(e);
     }
     onPointerOver(e) {
         this.doPointerOver(e);
     }
-    onPointerOut(e) {
-        this.doPointerOut();
+    onPointerMove(e) {
+        this.doPointerMove(e);
+    }
+    onPointerLeave(e) {
+        this.doPointerLeave(e);
+    }
+    doPointerEnter(e) {
+        this.preventDefault = false;
+        this.stopPropagation = false;
+        this.isHovered = true;
+        this.revision++;
     }
     doPointerOver(e) {
         var _a;
@@ -49,21 +63,34 @@ export class HoverSensor extends BasePointerSensor {
         this.positionY = e.clientY;
         this.revision++;
     }
-    doPointerOut() {
+    doPointerMove(e) {
+        this.preventDefault = false;
+        this.stopPropagation = false;
+        this.modifiers = extractModifierKeys(e);
+        this.positionX = e.clientX;
+        this.positionY = e.clientY;
+        this.revision++;
+    }
+    doPointerLeave(e) {
+        this.reset();
+    }
+    reset() {
         this.preventDefault = false;
         this.stopPropagation = false;
+        this.isHovered = false;
+        this.target = undefined;
         this.positionX = Infinity;
         this.positionY = Infinity;
-        this.modifiers = KeyboardModifiers.None;
-        this.target = undefined;
+        this.modifiers = KeyboardModifiers.none;
     }
 }
 __decorate([
     transactional,
+    options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Boolean]),
+    __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
-], HoverSensor.prototype, "listen", null);
+], HoverSensor.prototype, "doPointerEnter", null);
 __decorate([
     transactional,
     options({ logging: LoggingLevel.Off }),
@@ -71,10 +98,24 @@ __decorate([
     __metadata("design:paramtypes", [PointerEvent]),
     __metadata("design:returntype", void 0)
 ], HoverSensor.prototype, "doPointerOver", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PointerEvent]),
+    __metadata("design:returntype", void 0)
+], HoverSensor.prototype, "doPointerMove", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PointerEvent]),
+    __metadata("design:returntype", void 0)
+], HoverSensor.prototype, "doPointerLeave", null);
 __decorate([
     transactional,
     options({ logging: LoggingLevel.Off }),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", void 0)
-], HoverSensor.prototype, "doPointerOut", null);
+], HoverSensor.prototype, "reset", null);

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

@@ -33,12 +33,12 @@ export declare class HtmlDragSensor extends HtmlElementSensor {
     immediatePositionX: number;
     immediatePositionY: number;
     immediateModifiers: KeyboardModifiers;
-    constructor(focusSensor: FocusSensor, windowSensor: WindowSensor);
+    constructor(element: HTMLElement | SVGElement, focusSensor: FocusSensor, windowSensor: WindowSensor);
     getData(format: string): unknown;
     setData(format: string, value: unknown): void;
     clearData(format?: string): void;
     setDragImage(value: HTMLElement, x: number, y: number): void;
-    listen(element: HTMLElement | undefined, enabled?: boolean): void;
+    listen(enabled?: boolean): void;
     protected onDragStart(e: DragEvent): void;
     protected onDrag(e: DragEvent): void;
     protected onDragEnter(e: DragEvent): void;

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

@@ -12,8 +12,8 @@ import { findTargetElementData, SymDataForSensor } from "./DataForSensor.js";
 import { HtmlElementSensor } from "./HtmlElementSensor.js";
 import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor.js";
 export class HtmlDragSensor extends HtmlElementSensor {
-    constructor(focusSensor, windowSensor) {
-        super(focusSensor, windowSensor);
+    constructor(element, focusSensor, windowSensor) {
+        super(element, focusSensor, windowSensor);
         this.draggable = undefined;
         this.dragSource = undefined;
         this.dragTarget = undefined;
@@ -35,13 +35,13 @@ export class HtmlDragSensor extends HtmlElementSensor {
         this.draggingDataTypes = [];
         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(format) {
         return this.dataByFormat.get(format);
@@ -60,28 +60,25 @@ export class HtmlDragSensor extends HtmlElementSensor {
         this.draggingImageX = x;
         this.draggingImageY = y;
     }
-    listen(element, enabled = true) {
-        const existing = this.sourceElement;
-        if (element !== existing) {
-            if (existing) {
-                existing.removeEventListener("dragstart", this.onDragStart.bind(this), { capture: true });
-                existing.removeEventListener("drag", this.onDrag.bind(this), { capture: true });
-                existing.removeEventListener("dragenter", this.onDragEnter.bind(this), { capture: false });
-                existing.removeEventListener("dragleave", this.onDragLeave.bind(this), { capture: false });
-                existing.removeEventListener("dragover", this.onDragOver.bind(this), { capture: true });
-                existing.removeEventListener("drop", this.onDrop.bind(this), { capture: true });
-                existing.removeEventListener("dragend", this.onDragEnd.bind(this), { capture: true });
-            }
-            this.sourceElement = element;
-            if (element && enabled) {
-                element.addEventListener("dragstart", this.onDragStart.bind(this), { capture: true });
-                element.addEventListener("drag", this.onDrag.bind(this), { capture: true });
-                element.addEventListener("dragenter", this.onDragEnter.bind(this), { capture: false });
-                element.addEventListener("dragleave", this.onDragLeave.bind(this), { capture: false });
-                element.addEventListener("dragover", this.onDragOver.bind(this), { capture: true });
-                element.addEventListener("drop", this.onDrop.bind(this), { capture: true });
-                element.addEventListener("dragend", this.onDragEnd.bind(this), { capture: true });
-            }
+    listen(enabled = true) {
+        const element = this.sourceElement;
+        if (enabled) {
+            element.addEventListener("dragstart", this.onDragStart.bind(this), { capture: true });
+            element.addEventListener("drag", this.onDrag.bind(this), { capture: true });
+            element.addEventListener("dragenter", this.onDragEnter.bind(this), { capture: false });
+            element.addEventListener("dragleave", this.onDragLeave.bind(this), { capture: false });
+            element.addEventListener("dragover", this.onDragOver.bind(this), { capture: true });
+            element.addEventListener("drop", this.onDrop.bind(this), { capture: true });
+            element.addEventListener("dragend", this.onDragEnd.bind(this), { capture: true });
+        }
+        else {
+            element.removeEventListener("dragstart", this.onDragStart.bind(this), { capture: true });
+            element.removeEventListener("drag", this.onDrag.bind(this), { capture: true });
+            element.removeEventListener("dragenter", this.onDragEnter.bind(this), { capture: false });
+            element.removeEventListener("dragleave", this.onDragLeave.bind(this), { capture: false });
+            element.removeEventListener("dragover", this.onDragOver.bind(this), { capture: true });
+            element.removeEventListener("drop", this.onDrop.bind(this), { capture: true });
+            element.removeEventListener("dragend", this.onDragEnd.bind(this), { capture: true });
         }
     }
     onDragStart(e) {
@@ -217,13 +214,13 @@ export class HtmlDragSensor extends HtmlElementSensor {
         this.draggingDataTypes = [];
         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++;
     }
     updateDragTarget(e) {
@@ -291,12 +288,6 @@ __decorate([
     raw,
     __metadata("design:type", Boolean)
 ], HtmlDragSensor.prototype, "dropAllowed", void 0);
-__decorate([
-    transactional,
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Boolean]),
-    __metadata("design:returntype", void 0)
-], HtmlDragSensor.prototype, "listen", null);
 __decorate([
     transactional,
     options({ logging: LoggingLevel.Off }),

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

@@ -2,12 +2,12 @@ import { DataForSensor } from "./DataForSensor.js";
 import { Sensor } from "./Sensor.js";
 import { WindowSensor } from "./WindowSensor.js";
 export declare class HtmlElementSensor extends Sensor {
+    readonly sourceElement: HTMLElement | SVGElement;
     readonly focusSensor?: any;
     readonly windowSensor?: WindowSensor;
-    sourceElement: HTMLElement | undefined;
     preventDefault: boolean;
     stopPropagation: boolean;
-    constructor(focusSensor?: any, windowSensor?: WindowSensor);
-    protected getDefaultSensorData(): DataForSensor | undefined;
+    constructor(sourceElement: HTMLElement | SVGElement, focusSensor?: any, windowSensor?: WindowSensor);
+    protected getDefaultSensorData(): DataForSensor;
     protected setPreventDefaultAndStopPropagation(e: Event): void;
 }

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

@@ -12,17 +12,16 @@ import { SymDataForSensor } from "./DataForSensor.js";
 import { Sensor } from "./Sensor.js";
 import { WindowSensor } from "./WindowSensor.js";
 export class HtmlElementSensor extends Sensor {
-    constructor(focusSensor, windowSensor) {
+    constructor(sourceElement, focusSensor, windowSensor) {
         super();
-        this.sourceElement = undefined;
+        this.sourceElement = sourceElement;
         this.focusSensor = focusSensor;
         this.windowSensor = windowSensor;
         this.preventDefault = false;
         this.stopPropagation = false;
     }
     getDefaultSensorData() {
-        const sourceElement = this.sourceElement;
-        return sourceElement ? sourceElement[SymDataForSensor] : undefined;
+        return this.sourceElement[SymDataForSensor];
     }
     setPreventDefaultAndStopPropagation(e) {
         if (this.preventDefault) {
@@ -35,6 +34,10 @@ export class HtmlElementSensor extends Sensor {
         }
     }
 }
+__decorate([
+    raw,
+    __metadata("design:type", Object)
+], HtmlElementSensor.prototype, "sourceElement", void 0);
 __decorate([
     raw,
     __metadata("design:type", Object)

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

@@ -5,18 +5,30 @@ 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 declare class HtmlSensors {
-    readonly window: WindowSensor;
-    readonly focus: FocusSensor;
-    readonly hover: HoverSensor;
-    readonly keyboard: KeyboardSensor;
-    readonly wheel: WheelSensor;
-    readonly resize: ResizeSensor;
-    readonly htmlDrag: HtmlDragSensor;
-    readonly button: ButtonSensor;
-    readonly pointer: PointerSensor;
-    constructor();
-    listen(element: HTMLElement | undefined, enabled?: boolean): void;
+    private readonly _element;
+    private _window;
+    get window(): WindowSensor;
+    private _focus;
+    get focus(): FocusSensor;
+    private _hover;
+    get hover(): HoverSensor;
+    private _keyboard;
+    get keyboard(): KeyboardSensor;
+    private _wheel;
+    get wheel(): WheelSensor;
+    private _scroll;
+    get scroll(): ScrollSensor;
+    private _resize;
+    get resize(): ResizeSensor;
+    private _htmlDrag;
+    get htmlDrag(): HtmlDragSensor;
+    private _button;
+    get button(): ButtonSensor;
+    private _pointer;
+    get pointer(): PointerSensor;
+    constructor(element: HTMLElement | SVGElement);
 }