verstak 0.22.412 → 0.22.500

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

@@ -1,19 +1,19 @@
 import { Item } from 'reactronic';
-import { RxNode, NodeFactory } from '../core/api';
-export declare abstract class ElementNodeFactory<E extends Element> extends NodeFactory<E> {
-    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>;
+import { Block, BlockFactory } from '../core/api';
+export declare abstract class AbstractHtmlBlockFactory<T extends Element> extends BlockFactory<T> {
+    initialize(block: Block<T>, element: T | undefined): void;
+    finalize(block: Block<T>, isLeader: boolean): boolean;
+    layout(block: Block<T>, strict: boolean): void;
+    render(block: Block<T>): void | Promise<void>;
     static get blinkingEffect(): string | undefined;
     static set blinkingEffect(value: string | undefined);
-    static findNearestParentHtmlElementNode(node: RxNode): RxNode<Element>;
-    static findPrevSiblingHtmlElementNode(item: Item<RxNode>): Item<RxNode<Element>> | undefined;
-    protected abstract createElement(node: RxNode<E>): E;
+    static findNearestParentHtmlBlock(block: Block<any>): Block<Element>;
+    static findPrevSiblingHtmlBlock(item: Item<Block<any>>): Item<Block<Element>> | undefined;
+    protected abstract createElement(block: Block<T>): T;
 }
-export declare class HtmlElementNodeFactory<E extends HTMLElement> extends ElementNodeFactory<E> {
-    protected createElement(node: RxNode<E>): E;
+export declare class HtmlBlockFactory<T extends HTMLElement> extends AbstractHtmlBlockFactory<T> {
+    protected createElement(block: Block<T>): T;
 }
-export declare class SvgElementNodeFactory<E extends SVGElement> extends ElementNodeFactory<E> {
-    protected createElement(node: RxNode<E>): E;
+export declare class SvgBlockFactory<T extends SVGElement> extends AbstractHtmlBlockFactory<T> {
+    protected createElement(block: Block<T>): T;
 }

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

@@ -1,36 +1,36 @@
 import { Rx } from 'reactronic';
-import { RxNode, NodeFactory } from '../core/api';
-export class ElementNodeFactory extends NodeFactory {
-    initialize(node, element) {
-        element = this.createElement(node);
+import { Block, BlockFactory } from '../core/api';
+export class AbstractHtmlBlockFactory extends BlockFactory {
+    initialize(block, element) {
+        element = this.createElement(block);
         if (Rx.isLogging)
-            element.id = node.name;
-        super.initialize(node, element);
+            element.id = block.name;
+        super.initialize(block, element);
     }
-    finalize(node, isLeader) {
+    finalize(block, isLeader) {
         var _a;
-        const e = node.element;
+        const e = block.impl;
         if (e) {
             (_a = e.resizeObserver) === null || _a === void 0 ? void 0 : _a.unobserve(e);
             if (isLeader)
                 e.remove();
         }
-        super.finalize(node, isLeader);
+        super.finalize(block, isLeader);
         return false;
     }
-    arrange(node, strict) {
-        const e = node.element;
+    layout(block, strict) {
+        const e = block.impl;
         if (e) {
-            const nativeParent = ElementNodeFactory.findNearestParentHtmlElementNode(node).element;
+            const nativeParent = AbstractHtmlBlockFactory.findNearestParentHtmlBlock(block).impl;
             if (nativeParent) {
                 if (strict) {
-                    const after = ElementNodeFactory.findPrevSiblingHtmlElementNode(node.item);
+                    const after = AbstractHtmlBlockFactory.findPrevSiblingHtmlBlock(block.item);
                     if (after === undefined) {
                         if (nativeParent !== e.parentNode || !e.previousSibling)
                             nativeParent.prepend(e);
                     }
-                    else if (after.self.parent.element === nativeParent) {
-                        const nativeAfter = after.self.element;
+                    else if (after.self.parent.impl === nativeParent) {
+                        const nativeAfter = after.self.impl;
                         if (nativeAfter instanceof Element) {
                             if (nativeAfter.nextSibling !== e)
                                 nativeParent.insertBefore(e, nativeAfter.nextSibling);
@@ -42,10 +42,10 @@ export class ElementNodeFactory extends NodeFactory {
             }
         }
     }
-    render(node) {
-        const result = super.render(node);
+    render(block) {
+        const result = super.render(block);
         if (gBlinkingEffect)
-            blink(node.element, RxNode.currentRenderingPriority, node.stamp);
+            blink(block.impl, Block.currentRenderingPriority, block.stamp);
         return result;
     }
     static get blinkingEffect() {
@@ -54,34 +54,34 @@ export class ElementNodeFactory extends NodeFactory {
     static set blinkingEffect(value) {
         if (value === undefined) {
             const effect = gBlinkingEffect;
-            RxNode.forAllNodesDo((e) => {
+            Block.forAllBlocksDo((e) => {
                 if (e instanceof HTMLElement)
                     e.classList.remove(`${effect}-0`, `${effect}-1`);
             });
         }
         gBlinkingEffect = value;
     }
-    static findNearestParentHtmlElementNode(node) {
-        let p = node.parent;
-        while (p.element instanceof Element === false && p !== node)
+    static findNearestParentHtmlBlock(block) {
+        let p = block.parent;
+        while (p.impl instanceof Element === false && p !== block)
             p = p.parent;
         return p;
     }
-    static findPrevSiblingHtmlElementNode(item) {
+    static findPrevSiblingHtmlBlock(item) {
         let p = item.prev;
-        while (p && !(p.self.element instanceof Element))
+        while (p && !(p.self.impl instanceof Element))
             p = p.prev;
         return p;
     }
 }
-export class HtmlElementNodeFactory extends ElementNodeFactory {
-    createElement(node) {
-        return document.createElement(node.factory.name);
+export class HtmlBlockFactory extends AbstractHtmlBlockFactory {
+    createElement(block) {
+        return document.createElement(block.factory.name);
     }
 }
-export class SvgElementNodeFactory extends ElementNodeFactory {
-    createElement(node) {
-        return document.createElementNS('http://www.w3.org/2000/svg', node.factory.name);
+export class SvgBlockFactory extends AbstractHtmlBlockFactory {
+    createElement(block) {
+        return document.createElementNS('http://www.w3.org/2000/svg', block.factory.name);
     }
 }
 function blink(e, priority, revision) {

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

@@ -1,11 +1,11 @@
 import { Reaction } from '../core/Elements';
 export function RxFocuser(name, target, model, switchEditMode = undefined) {
-    Reaction(name, { target, model }, (_, node) => {
+    Reaction(name, { triggers: { target, model }, throttling: 0 }, () => {
         if (switchEditMode !== undefined) {
             switchEditMode(model);
         }
         else {
             model.isEditMode ? target.focus() : target.blur();
         }
-    }, undefined, undefined, 0);
+    });
 }

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

@@ -2,7 +2,6 @@ export * from './HtmlNodeFactory';
 export * from './HtmlElements';
 export * from './HtmlApiExt';
 export * from './RxFocuser';
-export * from './CellRange';
 export * from './sensors/Sensor';
 export * from './sensors/PointerSensor';
 export * from './sensors/BasePointerSensor';

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

@@ -2,7 +2,6 @@ export * from './HtmlNodeFactory';
 export * from './HtmlElements';
 export * from './HtmlApiExt';
 export * from './RxFocuser';
-export * from './CellRange';
 export * from './sensors/Sensor';
 export * from './sensors/PointerSensor';
 export * from './sensors/BasePointerSensor';

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

@@ -1,4 +1,4 @@
-import { RxNode } from '../../core/api';
+import { Block } from '../../core/api';
 import { Sensor } from './Sensor';
 export interface ResizedElement {
     readonly borderBoxSize: 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: Block<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

@@ -18,24 +18,24 @@ export class ResizeSensor extends Sensor {
     reset() {
         this.doReset();
     }
-    observeResizing(node, value, boxSizing = 'content-box') {
-        const native = node.element;
-        if (native instanceof Element) {
+    observeResizing(block, value, boxSizing = 'content-box') {
+        const impl = block.impl;
+        if (impl 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 });
+                if (impl.resizeObserver !== undefined && impl.resizeObserver !== this.observer)
+                    impl.resizeObserver.unobserve(impl);
+                impl.resizeObserver = this.observer;
+                this.observer.observe(impl, { box: boxSizing });
             }
             else {
-                if (native.resizeObserver === this.observer) {
-                    this.observer.unobserve(native);
-                    native.resizeObserver = undefined;
+                if (impl.resizeObserver === this.observer) {
+                    this.observer.unobserve(impl);
+                    impl.resizeObserver = undefined;
                 }
             }
         }
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "verstak",
-  "version": "0.22.412",
+  "version": "0.22.500",
   "description": "Verstak - Transactional Reactive Front-End Development Framework",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",
@@ -34,15 +34,15 @@
     "reactronic": "^0.22.411"
   },
   "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/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;
-}

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

@@ -1,11 +0,0 @@
-export interface CellRange {
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-}
-export declare class CellRangeUtils {
-    static parseCellRange(text: string, result: CellRange): CellRange;
-    static emitCellRange(value: CellRange): string;
-    private static emitCellPos;
-}