verstak 0.22.412

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

@@ -0,0 +1,143 @@
+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, sensitive, transactional, LoggingLevel } from 'reactronic';
+import { grabElementDataList, SymDataForSensor } from './DataForSensor';
+import { HtmlElementSensor } from './HtmlElementSensor';
+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 = {}));
+export class KeyboardSensor extends HtmlElementSensor {
+    constructor() {
+        super();
+        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 });
+            }
+        }
+    }
+    reset() {
+        this.preventDefault = false;
+        this.stopPropagation = false;
+        this.down = '';
+        this.up = '';
+        this.modifiers = KeyboardModifiers.None;
+    }
+    onKeyDown(e) {
+        this.keyDown(e);
+        this.setPreventDefaultAndStopPropagation(e);
+    }
+    onKeyUp(e) {
+        this.keyUp(e);
+        this.setPreventDefaultAndStopPropagation(e);
+    }
+    keyDown(e) {
+        this.updateSensorData(e);
+        this.up = '';
+        sensitive(true, () => this.down = e.key);
+    }
+    keyUp(e) {
+        this.updateSensorData(e);
+        this.down = '';
+        sensitive(true, () => this.up = e.key);
+    }
+    updateSensorData(e) {
+        this.preventDefault = false;
+        this.stopPropagation = false;
+        const path = e.composedPath();
+        this.elementDataList = grabElementDataList(path, SymDataForSensor, 'keyboard', this.elementDataList).dataList;
+        this.modifiers = extractModifierKeys(e);
+        this.revision++;
+    }
+    static getKeyAsModifierIfAny(key) {
+        let modifier = KeyboardModifiers.None;
+        if (key === 'Control')
+            modifier = KeyboardModifiers.Ctrl;
+        else if (key === 'Shift')
+            modifier = KeyboardModifiers.Shift;
+        else if (key === 'Alt')
+            modifier = KeyboardModifiers.Alt;
+        else if (key === '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),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], KeyboardSensor.prototype, "reset", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [KeyboardEvent]),
+    __metadata("design:returntype", void 0)
+], KeyboardSensor.prototype, "keyDown", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [KeyboardEvent]),
+    __metadata("design:returntype", void 0)
+], KeyboardSensor.prototype, "keyUp", null);
+export function extractModifierKeys(e) {
+    let modifiers = KeyboardModifiers.None;
+    if (e.ctrlKey)
+        modifiers |= KeyboardModifiers.Ctrl;
+    else
+        modifiers &= ~KeyboardModifiers.Ctrl;
+    if (e.shiftKey)
+        modifiers |= KeyboardModifiers.Shift;
+    else
+        modifiers &= ~KeyboardModifiers.Shift;
+    if (e.altKey)
+        modifiers |= KeyboardModifiers.Alt;
+    else
+        modifiers &= ~KeyboardModifiers.Alt;
+    if (e.metaKey)
+        modifiers |= KeyboardModifiers.Meta;
+    else
+        modifiers &= ~KeyboardModifiers.Meta;
+    return modifiers;
+}

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

@@ -0,0 +1,60 @@
+import { PointerButton, BasePointerSensor } from './BasePointerSensor';
+import { FocusSensor } from './FocusSensor';
+import { KeyboardModifiers } from './KeyboardSensor';
+import { WindowSensor } from './WindowSensor';
+export declare class PointerSensor extends BasePointerSensor {
+    pointerButton: PointerButton;
+    private clickable;
+    hotPositionX: number;
+    hotPositionY: number;
+    clicking: unknown;
+    clicked: unknown;
+    clickX: number;
+    clickY: number;
+    private tryingDragging;
+    draggableData: unknown;
+    dragSource: unknown;
+    dragTarget: unknown;
+    dragTargetWindow: unknown;
+    previousDragTarget: unknown;
+    dragStarted: boolean;
+    dragFinished: boolean;
+    startX: number;
+    startY: number;
+    private draggingData;
+    dropAllowed: boolean;
+    draggingOver: boolean;
+    positionX: number;
+    positionY: number;
+    modifiers: KeyboardModifiers;
+    dropX: number;
+    dropY: number;
+    dropped: boolean;
+    immediatePositionX: number;
+    immediatePositionY: number;
+    immediateModifiers: KeyboardModifiers;
+    static readonly DraggingThreshold = 4;
+    constructor(focusSensor: FocusSensor, windowSensor: WindowSensor);
+    getData(): unknown;
+    setData(value: unknown): void;
+    listen(element: HTMLElement | undefined, enabled?: boolean): void;
+    protected onPointerDown(e: PointerEvent): void;
+    protected onPointerMove(e: PointerEvent): void;
+    protected onPointerUp(e: PointerEvent): void;
+    protected onLostPointerCapture(e: PointerEvent): void;
+    protected onKeyDown(e: KeyboardEvent): void;
+    protected moveOver(e: PointerEvent): void;
+    protected tryClickingOrDragging(e: PointerEvent): void;
+    protected clickingOver(e: PointerEvent): void;
+    protected click(e: PointerEvent): void;
+    protected startDragging(e: PointerEvent): void;
+    protected dragOver(e: PointerEvent): void;
+    protected drop(e: PointerEvent): void;
+    protected finishDragging(): void;
+    protected cancelDragging(): void;
+    protected reset(): void;
+    protected updateClicking(e: PointerEvent): boolean;
+    protected updateDragTarget(e: PointerEvent): void;
+    protected whenClickingOrDragging(): void;
+    protected whenMoving(): void;
+}

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

@@ -0,0 +1,394 @@
+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, reactive, Reentrance, transactional, raw, Transaction, LoggingLevel } from 'reactronic';
+import { extractPointerButton, isPointerButtonDown, PointerButton, BasePointerSensor } from './BasePointerSensor';
+import { findTargetElementData, SymDataForSensor } from './DataForSensor';
+import { extractModifierKeys, KeyboardModifiers } from './KeyboardSensor';
+export class PointerSensor extends BasePointerSensor {
+    constructor(focusSensor, windowSensor) {
+        super(focusSensor, windowSensor);
+        this.hotPositionX = Infinity;
+        this.hotPositionY = Infinity;
+        this.pointerButton = PointerButton.None;
+        this.tryingDragging = false;
+        this.clickable = undefined;
+        this.clicking = undefined;
+        this.clicked = undefined;
+        this.clickX = Infinity;
+        this.clickY = Infinity;
+        this.draggableData = undefined;
+        this.dragSource = undefined;
+        this.dragTarget = undefined;
+        this.dragTargetWindow = undefined;
+        this.previousDragTarget = undefined;
+        this.dragStarted = false;
+        this.dragFinished = false;
+        this.startX = Infinity;
+        this.startY = Infinity;
+        this.draggingData = undefined;
+        this.dropAllowed = false;
+        this.draggingOver = false;
+        this.positionX = Infinity;
+        this.positionY = Infinity;
+        this.modifiers = KeyboardModifiers.None;
+        this.dropX = Infinity;
+        this.dropY = Infinity;
+        this.dropped = false;
+        this.immediatePositionX = Infinity;
+        this.immediatePositionY = Infinity;
+        this.immediateModifiers = KeyboardModifiers.None;
+    }
+    getData() {
+        return this.draggingData;
+    }
+    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 });
+            }
+        }
+    }
+    onPointerDown(e) {
+        const button = extractPointerButton(e);
+        if (!this.dragStarted && this.clickable === undefined &&
+            (button === PointerButton.Left || button === PointerButton.Right)) {
+            this.tryClickingOrDragging(e);
+        }
+    }
+    onPointerMove(e) {
+        this.moveOver(e);
+        if (isPointerButtonDown(this.pointerButton, e.buttons)) {
+            if (this.tryingDragging) {
+                if (Math.abs(e.clientX - this.startX) > PointerSensor.DraggingThreshold ||
+                    Math.abs(e.clientY - this.startY) > PointerSensor.DraggingThreshold) {
+                    this.startDragging(e);
+                }
+            }
+            else if (this.dragStarted) {
+                this.dragOver(e);
+            }
+            else if (this.clickable) {
+                this.clickingOver(e);
+            }
+        }
+        else {
+            if (this.dragStarted) {
+                this.cancelDragging();
+                this.reset();
+            }
+            else if (this.clickable) {
+                this.reset();
+            }
+        }
+    }
+    onPointerUp(e) {
+        if (this.draggingOver) {
+            this.drop(e);
+            this.finishDragging();
+        }
+        else if (this.dragStarted) {
+            this.finishDragging();
+        }
+        else if (this.clickable) {
+            this.click(e);
+        }
+        this.reset();
+    }
+    onLostPointerCapture(e) {
+        if (this.dragStarted || this.clickable) {
+            this.cancelDragging();
+            this.reset();
+        }
+    }
+    onKeyDown(e) {
+        if (e.key === 'Escape' && (this.dragStarted || this.clickable)) {
+            this.cancelDragging();
+            this.reset();
+        }
+    }
+    moveOver(e) {
+        this.immediatePositionX = e.clientX;
+        this.immediatePositionY = e.clientY;
+    }
+    tryClickingOrDragging(e) {
+        var _a;
+        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 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.pointerButton = extractPointerButton(e);
+            this.startX = e.clientX;
+            this.startY = e.clientY;
+            this.modifiers = extractModifierKeys(e);
+            this.positionX = e.clientX;
+            this.positionY = e.clientY;
+            this.dropped = false;
+            this.dragTarget = undefined;
+            this.dragTargetWindow = undefined;
+            this.previousDragTarget = undefined;
+            Transaction.separate(() => {
+                var _a;
+                (_a = this.windowSensor) === null || _a === void 0 ? void 0 : _a.setActiveWindow(window, 'pointer');
+            });
+        }
+        this.revision++;
+    }
+    clickingOver(e) {
+        this.updateClicking(e);
+        this.revision++;
+    }
+    click(e) {
+        if (this.updateClicking(e)) {
+            this.modifiers = this.immediateModifiers;
+            this.clickX = e.clientX;
+            this.clickY = e.clientY;
+            this.clicked = this.clicking;
+        }
+        this.clickable = undefined;
+        this.revision++;
+    }
+    startDragging(e) {
+        this.updateDragTarget(e);
+        this.clickable = undefined;
+        this.dragStarted = true;
+        this.dragFinished = false;
+        this.tryingDragging = false;
+        this.dropped = false;
+        this.revision++;
+    }
+    dragOver(e) {
+        this.updateDragTarget(e);
+        this.draggingOver = true;
+        this.dropped = false;
+        this.revision++;
+    }
+    drop(e) {
+        this.updateDragTarget(e);
+        this.modifiers = this.immediateModifiers;
+        this.dropX = e.clientX;
+        this.dropY = e.clientY;
+        this.dropped = true;
+        this.revision++;
+    }
+    finishDragging() {
+        this.dragFinished = true;
+        this.tryingDragging = false;
+        this.revision++;
+    }
+    cancelDragging() {
+        this.dragFinished = true;
+        this.tryingDragging = false;
+        this.dropped = false;
+        this.revision++;
+    }
+    reset() {
+        this.pointerButton = PointerButton.None;
+        this.clickable = undefined;
+        this.clicking = undefined;
+        this.clicked = undefined;
+        this.clickX = Infinity;
+        this.clickY = Infinity;
+        this.tryingDragging = false;
+        this.draggableData = undefined;
+        this.dragSource = undefined;
+        this.dragTarget = undefined;
+        this.dragTargetWindow = undefined;
+        this.previousDragTarget = undefined;
+        this.dragStarted = false;
+        this.dragFinished = false;
+        this.startX = Infinity;
+        this.startY = Infinity;
+        this.draggingData = undefined;
+        this.dropAllowed = false;
+        this.draggingOver = false;
+        this.positionX = Infinity;
+        this.positionY = Infinity;
+        this.modifiers = KeyboardModifiers.None;
+        this.dropX = Infinity;
+        this.dropY = Infinity;
+        this.dropped = false;
+        this.immediatePositionX = Infinity;
+        this.immediatePositionY = Infinity;
+        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;
+        const isSameClickable = this.clickable === clickable;
+        if (isSameClickable)
+            this.clicking = clickable;
+        this.immediateModifiers = extractModifierKeys(e);
+        this.immediatePositionX = e.clientX;
+        this.immediatePositionY = e.clientY;
+        return isSameClickable;
+    }
+    updateDragTarget(e) {
+        const targetPath = e.composedPath();
+        const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
+        const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['drag']);
+        const dragTarget = data === null || data === void 0 ? void 0 : data.drag;
+        if (dragTarget !== this.dragTarget) {
+            this.previousDragTarget = this.dragTarget;
+            this.dragTarget = dragTarget;
+            this.dragTargetWindow = window;
+        }
+        this.immediateModifiers = extractModifierKeys(e);
+        this.immediatePositionX = e.clientX;
+        this.immediatePositionY = e.clientY;
+    }
+    whenClickingOrDragging() {
+        if (this.draggingOver || this.clickable) {
+            this.positionX = this.immediatePositionX;
+            this.positionY = this.immediatePositionY;
+            this.modifiers = this.immediateModifiers;
+        }
+    }
+    whenMoving() {
+        if (Number.isFinite(this.immediatePositionX) && Number.isFinite(this.immediatePositionY)) {
+            this.hotPositionX = this.immediatePositionX;
+            this.hotPositionY = this.immediatePositionY;
+        }
+    }
+}
+PointerSensor.DraggingThreshold = 4;
+__decorate([
+    raw,
+    __metadata("design:type", Object)
+], PointerSensor.prototype, "clickable", void 0);
+__decorate([
+    raw,
+    __metadata("design:type", Boolean)
+], PointerSensor.prototype, "tryingDragging", void 0);
+__decorate([
+    raw,
+    __metadata("design:type", Object)
+], PointerSensor.prototype, "draggingData", void 0);
+__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 }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PointerEvent]),
+    __metadata("design:returntype", void 0)
+], PointerSensor.prototype, "moveOver", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PointerEvent]),
+    __metadata("design:returntype", void 0)
+], PointerSensor.prototype, "tryClickingOrDragging", null);
+__decorate([
+    transactional,
+    options({ reentrance: Reentrance.CancelPrevious, logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PointerEvent]),
+    __metadata("design:returntype", void 0)
+], PointerSensor.prototype, "clickingOver", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PointerEvent]),
+    __metadata("design:returntype", void 0)
+], PointerSensor.prototype, "click", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PointerEvent]),
+    __metadata("design:returntype", void 0)
+], PointerSensor.prototype, "startDragging", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PointerEvent]),
+    __metadata("design:returntype", void 0)
+], PointerSensor.prototype, "dragOver", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PointerEvent]),
+    __metadata("design:returntype", void 0)
+], PointerSensor.prototype, "drop", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], PointerSensor.prototype, "finishDragging", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], PointerSensor.prototype, "cancelDragging", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], PointerSensor.prototype, "reset", null);
+__decorate([
+    reactive,
+    options({ throttling: 0 }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], PointerSensor.prototype, "whenClickingOrDragging", null);
+__decorate([
+    reactive,
+    options({ throttling: 0 }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], PointerSensor.prototype, "whenMoving", null);

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

@@ -0,0 +1,18 @@
+import { RxNode } from '../../core/api';
+import { Sensor } from './Sensor';
+export interface ResizedElement {
+    readonly borderBoxSize: ReadonlyArray<ResizeObserverSize>;
+    readonly contentBoxSize: ReadonlyArray<ResizeObserverSize>;
+    readonly contentRect: DOMRectReadOnly;
+    readonly resizeData: any;
+}
+export declare class ResizeSensor extends Sensor {
+    private readonly observer;
+    resizedElements: Array<ResizedElement>;
+    constructor();
+    reset(): void;
+    observeResizing(node: RxNode<any, any, any>, value: boolean, boxSizing?: ResizeObserverBoxOptions): void;
+    protected onResize(entries: Array<ResizeObserverEntry>): void;
+    protected resize(entries: Array<ResizeObserverEntry>): void;
+    protected doReset(): void;
+}

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

@@ -0,0 +1,72 @@
+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, transactional, LoggingLevel } from 'reactronic';
+import { Sensor } from './Sensor';
+export class ResizeSensor extends Sensor {
+    constructor() {
+        super();
+        this.resizedElements = [];
+        this.observer = new ResizeObserver(this.onResize.bind(this));
+    }
+    reset() {
+        this.doReset();
+    }
+    observeResizing(node, value, boxSizing = 'content-box') {
+        const native = node.element;
+        if (native instanceof Element) {
+            if (value) {
+                if (native.resizeObserver !== undefined && native.resizeObserver !== this.observer)
+                    native.resizeObserver.unobserve(native);
+                native.resizeObserver = this.observer;
+                this.observer.observe(native, { box: boxSizing });
+            }
+            else {
+                if (native.resizeObserver === this.observer) {
+                    this.observer.unobserve(native);
+                    native.resizeObserver = undefined;
+                }
+            }
+        }
+        else
+            throw new Error('cannot observe resizing of non-HTML node');
+    }
+    onResize(entries) {
+        this.resize(entries);
+        this.reset();
+    }
+    resize(entries) {
+        this.revision++;
+        this.resizedElements = entries.map(entry => {
+            const element = entry.target;
+            return {
+                borderBoxSize: entry.borderBoxSize,
+                contentBoxSize: entry.contentBoxSize,
+                contentRect: entry.contentRect,
+                resizeData: element.dataForSensor.resize,
+            };
+        });
+    }
+    doReset() {
+        this.resizedElements = [];
+    }
+}
+__decorate([
+    transactional,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], ResizeSensor.prototype, "reset", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", void 0)
+], ResizeSensor.prototype, "resize", null);