verstak 0.22.412 → 0.22.503

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

@@ -7,9 +7,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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';
+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";
@@ -31,29 +31,29 @@ export var KeyboardModifiers;
 export class KeyboardSensor extends HtmlElementSensor {
     constructor() {
         super();
-        this.down = '';
-        this.up = '';
+        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 });
+                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 });
+                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.down = "";
+        this.up = "";
         this.modifiers = KeyboardModifiers.None;
     }
     onKeyDown(e) {
@@ -66,31 +66,31 @@ export class KeyboardSensor extends HtmlElementSensor {
     }
     keyDown(e) {
         this.updateSensorData(e);
-        this.up = '';
+        this.up = "";
         sensitive(true, () => this.down = e.key);
     }
     keyUp(e) {
         this.updateSensorData(e);
-        this.down = '';
+        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.elementDataList = grabElementDataList(path, SymDataForSensor, "keyboard", this.elementDataList).dataList;
         this.modifiers = extractModifierKeys(e);
         this.revision++;
     }
     static getKeyAsModifierIfAny(key) {
         let modifier = KeyboardModifiers.None;
-        if (key === 'Control')
+        if (key === "Control")
             modifier = KeyboardModifiers.Ctrl;
-        else if (key === 'Shift')
+        else if (key === "Shift")
             modifier = KeyboardModifiers.Shift;
-        else if (key === 'Alt')
+        else if (key === "Alt")
             modifier = KeyboardModifiers.Alt;
-        else if (key === 'Meta')
+        else if (key === "Meta")
             modifier = KeyboardModifiers.Meta;
         return modifier;
     }

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

@@ -1,7 +1,7 @@
-import { PointerButton, BasePointerSensor } from './BasePointerSensor';
-import { FocusSensor } from './FocusSensor';
-import { KeyboardModifiers } from './KeyboardSensor';
-import { WindowSensor } from './WindowSensor';
+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;

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

@@ -7,10 +7,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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';
+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);
@@ -55,19 +55,19 @@ export class PointerSensor extends BasePointerSensor {
         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 });
+                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 });
+                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 });
             }
         }
     }
@@ -124,7 +124,7 @@ export class PointerSensor extends BasePointerSensor {
         }
     }
     onKeyDown(e) {
-        if (e.key === 'Escape' && (this.dragStarted || this.clickable)) {
+        if (e.key === "Escape" && (this.dragStarted || this.clickable)) {
             this.cancelDragging();
             this.reset();
         }
@@ -139,7 +139,7 @@ export class PointerSensor extends BasePointerSensor {
         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 { 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) {
@@ -147,7 +147,7 @@ export class PointerSensor extends BasePointerSensor {
             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 = (_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;
@@ -160,7 +160,7 @@ export class PointerSensor extends BasePointerSensor {
             this.previousDragTarget = undefined;
             Transaction.separate(() => {
                 var _a;
-                (_a = this.windowSensor) === null || _a === void 0 ? void 0 : _a.setActiveWindow(window, 'pointer');
+                (_a = this.windowSensor) === null || _a === void 0 ? void 0 : _a.setActiveWindow(window, "pointer");
             });
         }
         this.revision++;
@@ -248,7 +248,7 @@ 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;
+        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;
@@ -260,7 +260,7 @@ export class PointerSensor extends BasePointerSensor {
     updateDragTarget(e) {
         const targetPath = e.composedPath();
         const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
-        const { data, window } = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['drag']);
+        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;

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

@@ -1,5 +1,5 @@
-import { RxNode } from '../../core/api';
-import { Sensor } from './Sensor';
+import { VBlock } from "../../core/api";
+import { Sensor } from "./Sensor";
 export interface ResizedElement {
     readonly borderBoxSize: ReadonlyArray<ResizeObserverSize>;
     readonly contentBoxSize: ReadonlyArray<ResizeObserverSize>;
@@ -11,7 +11,7 @@ export declare class ResizeSensor extends Sensor {
     resizedElements: Array<ResizedElement>;
     constructor();
     reset(): void;
-    observeResizing(node: RxNode<any, any, any>, value: boolean, boxSizing?: ResizeObserverBoxOptions): void;
+    observeResizing(block: VBlock<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

@@ -7,8 +7,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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';
+import { options, transactional, LoggingLevel } from "reactronic";
+import { Sensor } from "./Sensor";
 export class ResizeSensor extends Sensor {
     constructor() {
         super();
@@ -18,8 +18,8 @@ export class ResizeSensor extends Sensor {
     reset() {
         this.doReset();
     }
-    observeResizing(node, value, boxSizing = 'content-box') {
-        const native = node.element;
+    observeResizing(block, value, boxSizing = "content-box") {
+        const native = block.native;
         if (native instanceof Element) {
             if (value) {
                 if (native.resizeObserver !== undefined && native.resizeObserver !== this.observer)
@@ -35,7 +35,7 @@ export class ResizeSensor extends Sensor {
             }
         }
         else
-            throw new Error('cannot observe resizing of non-HTML node');
+            throw new Error("cannot observe resizing of non-HTML block");
     }
     onResize(entries) {
         this.resize(entries);

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

@@ -1,4 +1,4 @@
-import { ObservableObject } from 'reactronic';
+import { ObservableObject } from "reactronic";
 export declare class Sensor extends ObservableObject {
     revision: number;
     elementDataList: unknown[];

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

@@ -1,4 +1,4 @@
-import { ObservableObject } from 'reactronic';
+import { ObservableObject } from "reactronic";
 export class Sensor extends ObservableObject {
     constructor() {
         super(...arguments);

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

@@ -1,4 +1,4 @@
-import { BasePointerSensor } from './BasePointerSensor';
+import { BasePointerSensor } from "./BasePointerSensor";
 export declare class WheelSensor extends BasePointerSensor {
     target: unknown;
     deltaX: number;

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

@@ -7,10 +7,10 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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 { findTargetElementData, SymDataForSensor } from './DataForSensor';
-import { extractModifierKeys, KeyboardModifiers } from './KeyboardSensor';
-import { BasePointerSensor } from './BasePointerSensor';
+import { options, Reentrance, transactional, LoggingLevel } from "reactronic";
+import { findTargetElementData, SymDataForSensor } from "./DataForSensor";
+import { extractModifierKeys, KeyboardModifiers } from "./KeyboardSensor";
+import { BasePointerSensor } from "./BasePointerSensor";
 export class WheelSensor extends BasePointerSensor {
     constructor() {
         super();
@@ -23,11 +23,11 @@ export class WheelSensor extends BasePointerSensor {
         const existing = this.sourceElement;
         if (element !== existing) {
             if (existing) {
-                existing.removeEventListener('wheel', this.onWheel.bind(this), { capture: true });
+                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 });
+                element.addEventListener("wheel", this.onWheel.bind(this), { capture: true, passive: true });
             }
         }
     }
@@ -56,7 +56,7 @@ export class WheelSensor extends BasePointerSensor {
         this.stopPropagation = false;
         const targetPath = e.composedPath();
         const underPointer = document.elementsFromPoint(e.clientX, e.clientY);
-        this.target = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ['wheel']).data) === null || _a === void 0 ? void 0 : _a.wheel;
+        this.target = (_a = findTargetElementData(targetPath, underPointer, SymDataForSensor, ["wheel"]).data) === null || _a === void 0 ? void 0 : _a.wheel;
         this.modifiers = extractModifierKeys(e);
         this.positionX = e.clientX;
         this.positionY = e.clientY;

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

@@ -1,5 +1,5 @@
-import { ToggleRef } from 'reactronic';
-import { Sensor } from './Sensor';
+import { ToggleRef } from "reactronic";
+import { Sensor } from "./Sensor";
 export interface WindowModel {
     popupToggle?: ToggleRef;
 }

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

@@ -7,19 +7,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { ToggleRef, transactional } from 'reactronic';
-import { objectHasMember } from '../../core/Utils';
-import { Sensor } from './Sensor';
+import { ToggleRef, transactional } from "reactronic";
+import { objectHasMember } from "../../core/Utils";
+import { Sensor } from "./Sensor";
 export class WindowSensor extends Sensor {
     constructor() {
         super(...arguments);
         this.activeData = undefined;
         this.previousActiveData = undefined;
     }
-    setActiveWindow(window, debugHint = '') {
+    setActiveWindow(window, debugHint = "") {
         if (window !== this.activeData) {
             const activeData = this.activeData;
-            if (activeData && objectHasMember(activeData, 'popupToggle')) {
+            if (activeData && objectHasMember(activeData, "popupToggle")) {
                 const popupToggle = activeData.popupToggle;
                 if (popupToggle instanceof ToggleRef) {
                     popupToggle.variable = popupToggle.valueOff;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "verstak",
-  "version": "0.22.412",
-  "description": "Verstak - Transactional Reactive Front-End Development Framework",
+  "version": "0.22.503",
+  "description": "Verstak - Front-End Library",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
   "type": "module",
@@ -31,18 +31,18 @@
   },
   "homepage": "https://github.com/nezaboodka/verstak/blob/master/README.md#readme",
   "dependencies": {
-    "reactronic": "^0.22.411"
+    "reactronic": "^0.22.503"
   },
   "devDependencies": {
-    "@types/node": "18.7.18",
-    "@typescript-eslint/eslint-plugin": "5.37.0",
-    "@typescript-eslint/parser": "5.37.0",
+    "@types/node": "18.11.7",
+    "@typescript-eslint/eslint-plugin": "5.41.0",
+    "@typescript-eslint/parser": "5.41.0",
     "ava": "4.3.3",
     "c8": "7.12.0",
-    "eslint": "8.23.1",
+    "eslint": "8.26.0",
     "ts-node": "10.9.1",
     "tsconfig-paths": "4.1.0",
-    "typescript": "4.8.2"
+    "typescript": "4.8.4"
   },
   "scripts": {
     "build": "eslint source/**/*.ts test/**/*.ts && tsc",

package/build/dist/source/core/Elements.d.ts

@@ -1,4 +0,0 @@
-import { Monitor, LoggingOptions } from 'reactronic';
-import { RxNode, Render, NodeFactory, Priority } from './RxNode';
-export declare function Reaction<E = undefined, M = unknown, R = void>(name: string, triggers: unknown, renderer: Render<E, M, R>, priority?: Priority, monitor?: Monitor, throttling?: number, logging?: Partial<LoggingOptions>, factory?: NodeFactory<E>): RxNode<E, M, R>;
-export declare function Inline<E = undefined, M = unknown, R = void>(name: string, renderer: Render<E, M, R>, priority?: Priority, factory?: NodeFactory<E>): RxNode<E, M, R>;

package/build/dist/source/core/Elements.js

@@ -1,7 +0,0 @@
-import { RxNode } from './RxNode';
-export function Reaction(name, triggers, renderer, priority, monitor, throttling, logging, factory) {
-    return RxNode.claim(name, triggers, false, renderer, priority, monitor, throttling, logging, factory);
-}
-export function Inline(name, renderer, priority, factory) {
-    return RxNode.claim(name, undefined, true, renderer, priority, undefined, undefined, undefined, factory);
-}

package/build/dist/source/core/RxNode.d.ts

@@ -1,59 +0,0 @@
-import { Monitor, LoggingOptions, Item, CollectionReader } from 'reactronic';
-export declare type Callback<E = unknown> = (element: E) => void;
-export declare type Render<E = unknown, M = unknown, R = void> = (element: E, node: RxNode<E, M, R>) => R;
-export declare type AsyncRender<E = unknown, M = unknown> = (element: E, node: RxNode<E, M, Promise<void>>) => Promise<void>;
-export declare const enum Priority {
-    SyncP0 = 0,
-    AsyncP1 = 1,
-    AsyncP2 = 2
-}
-export declare abstract class RxNode<E = any, M = unknown, R = void> {
-    static currentRenderingPriority: Priority;
-    static readonly shortFrameDuration = 16;
-    static readonly longFrameDuration = 300;
-    static frameDuration: number;
-    abstract readonly name: string;
-    abstract readonly factory: NodeFactory<E>;
-    abstract readonly inline: boolean;
-    abstract readonly triggers: unknown;
-    abstract readonly renderer: Render<E, M, R>;
-    abstract readonly wrapper: Render<E, M, R> | undefined;
-    abstract readonly monitor?: Monitor;
-    abstract readonly throttling?: number;
-    abstract readonly logging?: Partial<LoggingOptions>;
-    abstract readonly priority: Priority;
-    abstract readonly shuffle: boolean;
-    abstract model?: M;
-    abstract readonly level: number;
-    abstract readonly parent: RxNode;
-    abstract readonly children: CollectionReader<RxNode>;
-    abstract readonly item: Item<RxNode> | undefined;
-    abstract readonly stamp: number;
-    abstract readonly element?: E;
-    render(): R;
-    get isInitialRendering(): boolean;
-    abstract wrapBy(renderer: Render<E, M, R> | undefined): this;
-    static root(render: () => void): void;
-    static get current(): RxNode;
-    static shuffleChildrenRendering(shuffle: boolean): void;
-    static renderChildrenThenDo(action: (error: unknown) => void): void;
-    static forAllNodesDo<E>(action: (e: E) => void): void;
-    static claim<E = undefined, M = unknown, R = void>(name: string, triggers: unknown, inline: boolean, renderer: Render<E, M, R>, priority?: Priority, monitor?: Monitor, throttling?: number, logging?: Partial<LoggingOptions>, factory?: NodeFactory<E>): RxNode<E, M, R>;
-    static getDefaultLoggingOptions(): LoggingOptions | undefined;
-    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
-}
-export declare class NodeFactory<E> {
-    static readonly default: NodeFactory<any>;
-    readonly name: string;
-    readonly strict: boolean;
-    constructor(name: string, strict: boolean);
-    initialize(node: RxNode<E>, element: E | undefined): void;
-    finalize(node: RxNode<E>, isLeader: boolean): boolean;
-    arrange(node: RxNode<E>, strict: boolean): void;
-    render(node: RxNode<E>): void | Promise<void>;
-}
-export declare class StaticNodeFactory<E> extends NodeFactory<E> {
-    readonly element: E;
-    constructor(name: string, sequential: boolean, element: E);
-    initialize(node: RxNode<E>, element: E | undefined): void;
-}