verstak 0.22.412

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

@@ -0,0 +1,182 @@
+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 { objectHasMember } from '../../core/Utils';
+import { grabElementDataList, SymDataForSensor } from './DataForSensor';
+import { HtmlElementSensor } from './HtmlElementSensor';
+export class FocusSensor extends HtmlElementSensor {
+    constructor(windowSensor) {
+        super(undefined, windowSensor);
+        this.activeData = undefined;
+        this.oldActiveData = undefined;
+        this.contextElementDataList = [];
+    }
+    setActiveData(data, debugHint = '') {
+        var _a, _b;
+        if (data !== this.activeData) {
+            const activeData = this.activeData;
+            if (activeData !== undefined && objectHasMember(activeData, 'isEditMode')) {
+                activeData.isEditMode = false;
+                (_a = activeData.onFocusOut) === null || _a === void 0 ? void 0 : _a.call(activeData, this);
+            }
+            if (data !== undefined) {
+                if (objectHasMember(data, 'isEditMode')) {
+                    data.isEditMode = true;
+                    (_b = data.onFocusIn) === null || _b === void 0 ? void 0 : _b.call(data, this);
+                }
+            }
+            this.oldActiveData = activeData;
+            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 });
+            }
+        }
+    }
+    reset() {
+        this.preventDefault = false;
+        this.stopPropagation = false;
+        this.revision++;
+    }
+    onFocusIn(e) {
+        this.doFocusIn(e);
+        this.setPreventDefaultAndStopPropagation(e);
+    }
+    onFocusOut(e) {
+        this.doFocusOut(e);
+        this.setPreventDefaultAndStopPropagation(e);
+    }
+    onMouseDown(e) {
+        this.doMouseDown(e);
+    }
+    doFocusIn(e) {
+        var _a;
+        const path = e.composedPath();
+        const { dataList: focusDataList, activeData: focusActiveData, window } = grabElementDataList(path, SymDataForSensor, 'focus', this.elementDataList, false, e => document.activeElement === e);
+        this.elementDataList = focusDataList;
+        this.setActiveData(focusActiveData);
+        (_a = this.windowSensor) === null || _a === void 0 ? void 0 : _a.setActiveWindow(window);
+        const { dataList: contextDataList } = grabElementDataList(path, SymDataForSensor, 'context', this.contextElementDataList, true);
+        this.contextElementDataList = toggleContextRefs(this, this.contextElementDataList, contextDataList);
+        this.reset();
+    }
+    doFocusOut(e) {
+        var _a;
+        const isLosingFocus = e.relatedTarget === null;
+        if (isLosingFocus) {
+            const path = e.composedPath();
+            const { dataList } = grabElementDataList(path, SymDataForSensor, 'focus', this.elementDataList, true);
+            this.elementDataList = dataList;
+            const filteredElementDataList = dataList.filter(x => x !== this.activeData);
+            if (filteredElementDataList.length > 0) {
+                this.trySetEditMode(filteredElementDataList[0], '  └─');
+            }
+            else {
+                const defaultData = this.getDefaultSensorData();
+                if ((defaultData === null || defaultData === void 0 ? void 0 : defaultData.focus) !== undefined) {
+                    this.trySetEditMode(defaultData.focus, '    └─');
+                }
+                else {
+                    this.setActiveData(undefined);
+                }
+                (_a = this.windowSensor) === null || _a === void 0 ? void 0 : _a.setActiveWindow(defaultData === null || defaultData === void 0 ? void 0 : defaultData.window);
+            }
+            this.contextElementDataList = toggleContextRefs(this, this.contextElementDataList, []);
+            this.reset();
+        }
+        else {
+        }
+    }
+    doMouseDown(e) {
+        const path = e.composedPath();
+        const isClickInsideTabIndexedElement = path.find(el => el !== document.body && el.tabIndex >= 0) !== undefined;
+        if (path.length > 0 && !isClickInsideTabIndexedElement) {
+            const { dataList } = grabElementDataList(path, SymDataForSensor, 'focus', this.elementDataList, true);
+            this.elementDataList = dataList;
+            if (dataList.length > 0) {
+                this.trySetEditMode(dataList[0], '└─');
+                e.preventDefault();
+            }
+            const { dataList: contextDataList } = grabElementDataList(path, SymDataForSensor, 'context', this.contextElementDataList, true);
+            this.contextElementDataList = toggleContextRefs(this, this.contextElementDataList, contextDataList);
+            this.reset();
+        }
+        else {
+        }
+    }
+    trySetEditMode(candidateData, indent = '') {
+        if (candidateData !== undefined && objectHasMember(candidateData, 'isEditMode')) {
+            candidateData.isEditMode = true;
+        }
+    }
+}
+__decorate([
+    transactional,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", void 0)
+], FocusSensor.prototype, "setActiveData", null);
+__decorate([
+    transactional,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Boolean]),
+    __metadata("design:returntype", void 0)
+], FocusSensor.prototype, "listen", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FocusEvent]),
+    __metadata("design:returntype", void 0)
+], FocusSensor.prototype, "doFocusIn", null);
+__decorate([
+    transactional,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [FocusEvent]),
+    __metadata("design:returntype", void 0)
+], FocusSensor.prototype, "doFocusOut", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [MouseEvent]),
+    __metadata("design:returntype", void 0)
+], FocusSensor.prototype, "doMouseDown", null);
+function toggleContextRefs(focusSensor, existing, updated) {
+    if (updated !== existing) {
+        existing.forEach(x => {
+            var _a;
+            if (objectHasMember(x, 'contextToggle') && x.contextToggle && x.contextToggle.valueOn !== x.contextToggle.valueOff)
+                x.contextToggle.variable = x.contextToggle.valueOff;
+            if (objectHasMember(x, 'onContextOut'))
+                (_a = x.onContextOut) === null || _a === void 0 ? void 0 : _a.call(x, focusSensor);
+        });
+        updated.forEach(x => {
+            var _a;
+            if (objectHasMember(x, 'contextToggle') && x.contextToggle)
+                x.contextToggle.variable = x.contextToggle.valueOn;
+            if (objectHasMember(x, 'onContextIn'))
+                (_a = x.onContextIn) === null || _a === void 0 ? void 0 : _a.call(x, focusSensor);
+        });
+    }
+    return updated;
+}

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

@@ -0,0 +1,10 @@
+import { BasePointerSensor } from './BasePointerSensor';
+export declare class HoverSensor extends BasePointerSensor {
+    target: unknown;
+    constructor();
+    listen(element: HTMLElement | undefined, enabled?: boolean): void;
+    protected onPointerOver(e: PointerEvent): void;
+    protected onPointerOut(e: PointerEvent): void;
+    protected doPointerOver(e: PointerEvent): void;
+    protected doPointerOut(): void;
+}

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

@@ -0,0 +1,80 @@
+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 { findTargetElementData, SymDataForSensor } from './DataForSensor';
+import { extractModifierKeys, KeyboardModifiers } from './KeyboardSensor';
+import { BasePointerSensor } from './BasePointerSensor';
+export class HoverSensor extends BasePointerSensor {
+    constructor() {
+        super();
+        this.target = undefined;
+        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 });
+            }
+        }
+    }
+    onPointerOver(e) {
+        this.doPointerOver(e);
+    }
+    onPointerOut(e) {
+        this.doPointerOut();
+    }
+    doPointerOver(e) {
+        var _a;
+        this.preventDefault = false;
+        this.stopPropagation = false;
+        const targetPath = e.composedPath();
+        const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
+        this.target = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['hover']).data) === null || _a === void 0 ? void 0 : _a.hover;
+        this.modifiers = extractModifierKeys(e);
+        this.positionX = e.clientX;
+        this.positionY = e.clientY;
+        this.revision++;
+    }
+    doPointerOut() {
+        this.preventDefault = false;
+        this.stopPropagation = false;
+        this.positionX = Infinity;
+        this.positionY = Infinity;
+        this.modifiers = KeyboardModifiers.None;
+        this.target = undefined;
+    }
+}
+__decorate([
+    transactional,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Boolean]),
+    __metadata("design:returntype", void 0)
+], HoverSensor.prototype, "listen", null);
+__decorate([
+    transactional,
+    options({ logging: LoggingLevel.Off }),
+    __metadata("design:type", Function),
+    __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", []),
+    __metadata("design:returntype", void 0)
+], HoverSensor.prototype, "doPointerOut", null);

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

@@ -0,0 +1,61 @@
+import { FocusSensor } from './FocusSensor';
+import { HtmlElementSensor } from './HtmlElementSensor';
+import { KeyboardModifiers } from './KeyboardSensor';
+import { WindowSensor } from './WindowSensor';
+export declare type DragEffectAllowed = 'none' | 'copy' | 'copyLink' | 'copyMove' | 'link' | 'linkMove' | 'move' | 'all' | 'uninitialized';
+export declare type DropEffect = 'none' | 'copy' | 'link' | 'move';
+export declare class HtmlDragSensor extends HtmlElementSensor {
+    draggable: unknown;
+    dragSource: unknown;
+    dragTarget: unknown;
+    dragTargetWindow: unknown;
+    previousDragTarget: unknown;
+    dragStarted: boolean;
+    dragFinished: boolean;
+    startX: number;
+    startY: number;
+    private dataByFormat;
+    private draggingImage;
+    private draggingImageX;
+    private draggingImageY;
+    dropEffect: DropEffect;
+    dataTypesAllowed: string[];
+    effectAllowed: DragEffectAllowed;
+    dropAllowed: boolean;
+    draggingOver: boolean;
+    draggingDataTypes: string[];
+    positionX: number;
+    positionY: number;
+    modifiers: KeyboardModifiers;
+    dropX: number;
+    dropY: number;
+    dropped: boolean;
+    immediatePositionX: number;
+    immediatePositionY: number;
+    immediateModifiers: KeyboardModifiers;
+    constructor(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;
+    protected onDragStart(e: DragEvent): void;
+    protected onDrag(e: DragEvent): void;
+    protected onDragEnter(e: DragEvent): void;
+    protected onDragLeave(e: DragEvent): void;
+    protected onDragOver(e: DragEvent): void;
+    protected onDrop(e: DragEvent): void;
+    protected onDragEnd(e: DragEvent): void;
+    protected startDragging(e: DragEvent): void;
+    protected dragging(e: DragEvent): void;
+    protected finishDragging(e: DragEvent): void;
+    protected enterTarget(e: DragEvent): void;
+    protected leaveTarget(e: DragEvent): void;
+    protected dragOver(e: DragEvent): void;
+    protected drop(e: DragEvent): void;
+    protected updateEventOnDragStart(e: DragEvent): void;
+    protected updateEventOnDropAllowed(e: DragEvent): void;
+    protected reset(): void;
+    protected updateDragTarget(e: DragEvent): void;
+    protected whenDragging(): void;
+}