verstak 0.24.124 → 0.24.127

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);
 }

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

@@ -20,8 +20,8 @@ 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

@@ -29,24 +29,21 @@ export var KeyboardModifiers;
     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;
     }
-    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() {
@@ -95,12 +92,6 @@ export class KeyboardSensor extends HtmlElementSensor {
         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),

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,8 +12,8 @@ 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;
@@ -51,24 +51,16 @@ 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) {
@@ -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;
@@ -248,7 +240,8 @@ export class PointerSensor extends BasePointerSensor {
         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() {
@@ -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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "verstak",
-  "version": "0.24.124",
+  "version": "0.24.127",
   "description": "Verstak - Front-End Library",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
@@ -31,23 +31,23 @@
   },
   "homepage": "https://github.com/nezaboodka/verstak/blob/master/README.md#readme",
   "dependencies": {
-    "reactronic": "^0.24.124"
+    "reactronic": "^0.24.127"
   },
   "devDependencies": {
-    "@types/node": "20.10.4",
-    "@typescript-eslint/eslint-plugin": "6.13.2",
-    "@typescript-eslint/parser": "6.13.2",
-    "ava": "5.3.1",
-    "c8": "8.0.1",
-    "eslint": "8.55.0",
+    "@types/node": "20.11.16",
+    "@typescript-eslint/eslint-plugin": "6.20.0",
+    "@typescript-eslint/parser": "6.20.0",
+    "ava": "6.1.1",
+    "c8": "9.1.0",
+    "eslint": "8.56.0",
     "ts-node": "10.9.2",
     "tsconfig-paths": "4.2.0",
     "typescript": "5.3.2"
   },
   "scripts": {
-    "build": "eslint source/**/*.ts test/**/*.ts && tsc",
-    "fix": "eslint --fix source/**/*.ts test/**/*.ts",
-    "pack": "eslint source/**/*.ts test/**/*.ts && tsc --sourceMap false --removeComments true",
+    "build": "eslint source/**.ts test/**.ts && tsc",
+    "fix": "eslint --fix source/**.ts test/**.ts",
+    "pack": "eslint source/**.ts test/**.ts && tsc --sourceMap false --removeComments true",
     "test": "ava",
     "cover": "c8 ava && open build/coverage/index.html"
   }

package/build/dist/source/html/ReactingFocuser.d.ts

@@ -1,2 +0,0 @@
-import { FocusModel } from "./sensors/FocusSensor.js";
-export declare function FocuserReaction(key: string, target: HTMLElement, model: FocusModel, switchEditMode?: ((model?: FocusModel) => void) | undefined): void;

package/build/dist/source/html/ReactingFocuser.js

@@ -1,20 +0,0 @@
-import { Mode } from "reactronic";
-import { PseudoElement } from "./Elements.js";
-export function FocuserReaction(key, target, model, switchEditMode = undefined) {
-    PseudoElement({
-        key,
-        mode: Mode.IndependentUpdate,
-        triggers: { target, model },
-        initialize(b) {
-            b.node.configureReactronic({ throttling: 0 });
-        },
-        update() {
-            if (switchEditMode !== undefined) {
-                switchEditMode(model);
-            }
-            else {
-                model.isEditMode ? target.focus() : target.blur();
-            }
-        },
-    });
-}