verstak 0.22.500 → 0.22.504

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 { Block } 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(block: Block<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,24 +18,24 @@ export class ResizeSensor extends Sensor {
     reset() {
         this.doReset();
     }
-    observeResizing(block, value, boxSizing = 'content-box') {
-        const impl = block.impl;
-        if (impl instanceof Element) {
+    observeResizing(block, value, boxSizing = "content-box") {
+        const native = block.native;
+        if (native instanceof Element) {
             if (value) {
-                if (impl.resizeObserver !== undefined && impl.resizeObserver !== this.observer)
-                    impl.resizeObserver.unobserve(impl);
-                impl.resizeObserver = this.observer;
-                this.observer.observe(impl, { box: boxSizing });
+                if (native.resizeObserver !== undefined && native.resizeObserver !== this.observer)
+                    native.resizeObserver.unobserve(native);
+                native.resizeObserver = this.observer;
+                this.observer.observe(native, { box: boxSizing });
             }
             else {
-                if (impl.resizeObserver === this.observer) {
-                    this.observer.unobserve(impl);
-                    impl.resizeObserver = undefined;
+                if (native.resizeObserver === this.observer) {
+                    this.observer.unobserve(native);
+                    native.resizeObserver = undefined;
                 }
             }
         }
         else
-            throw new Error('cannot observe resizing of non-HTML block');
+            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.500",
-  "description": "Verstak - Transactional Reactive Front-End Development Framework",
+  "version": "0.22.504",
+  "description": "Verstak - Front-End Library",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
   "type": "module",
@@ -31,15 +31,15 @@
   },
   "homepage": "https://github.com/nezaboodka/verstak/blob/master/README.md#readme",
   "dependencies": {
-    "reactronic": "^0.22.411"
+    "reactronic": "^0.22.504"
   },
   "devDependencies": {
-    "@types/node": "18.11.7",
-    "@typescript-eslint/eslint-plugin": "5.41.0",
-    "@typescript-eslint/parser": "5.41.0",
+    "@types/node": "18.11.9",
+    "@typescript-eslint/eslint-plugin": "5.42.1",
+    "@typescript-eslint/parser": "5.42.1",
     "ava": "4.3.3",
     "c8": "7.12.0",
-    "eslint": "8.26.0",
+    "eslint": "8.27.0",
     "ts-node": "10.9.1",
     "tsconfig-paths": "4.1.0",
     "typescript": "4.8.4"

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

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