verstak 0.23.100 → 0.23.101

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

@@ -2,28 +2,22 @@ import { LoggingOptions, Item, CollectionReader, MemberOptions } from "reactroni
 import { CellRange } from "./CellRange";
 import { Cursor, Align, Cells } from "./Cursor";
 export type Callback<T = unknown> = (native: T) => void;
-export type Operation<T = unknown, M = unknown, R = void> = (block: VBlock<T, M, R>) => R;
-export type VirtualOperation<T = unknown, M = unknown, R = void> = (block: VBlock<T, M, R>, base: () => R) => R;
+export type Operation<T = unknown, M = unknown, R = void> = (block: VBlock<T, M, R>, base: () => R) => R;
 export type AsyncOperation<T = unknown, M = unknown> = (block: VBlock<T, M, Promise<void>>) => Promise<void>;
-export type BlockBody<T = unknown, M = unknown, R = void> = Operation<T, M, R> | BlockVmt<T, M, R>;
 export declare const enum Priority {
     Realtime = 0,
     Normal = 1,
     Background = 2
 }
-export interface BlockVmt<T = unknown, M = unknown, R = void> {
-    base?: BlockVmt<T, M, R>;
+export interface BlockBody<T = unknown, M = unknown, R = void> {
+    base?: BlockBody<T, M, R>;
     key?: string;
-    autonomous?: boolean;
+    reaction?: boolean;
     triggers?: unknown;
     initialize?: Operation<T, M, R>;
     render?: Operation<T, M, R>;
     finalize?: Operation<T, M, R>;
-    redefinedInitialize?: VirtualOperation<T, M, R>;
-    redefinedRender?: VirtualOperation<T, M, R>;
-    redefinedFinalize?: VirtualOperation<T, M, R>;
 }
-export declare function vmt<T, M, R>(body: BlockBody<T, M, R> | undefined): BlockVmt<T, M, R> | undefined;
 export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     static readonly shortFrameDuration = 16;
     static readonly longFrameDuration = 300;
@@ -31,7 +25,7 @@ export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     static frameDuration: number;
     abstract readonly key: string;
     abstract readonly driver: AbstractDriver<T>;
-    abstract readonly body: Readonly<BlockVmt<T, M, R>>;
+    abstract readonly body: Readonly<BlockBody<T, M, R>>;
     abstract model: M;
     abstract cells: Cells;
     abstract widthGrowth: number;
@@ -59,7 +53,7 @@ export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     static get current(): VBlock;
     static renderNestedTreesThenDo(action: (error: unknown) => void): void;
     static runForAllBlocks<T>(action: (e: T) => void): void;
-    static claim<T = undefined, M = unknown, R = void>(driver: AbstractDriver<T> | undefined, body: BlockBody<T, M, R>): VBlock<T, M, R>;
+    static claim<T = undefined, M = unknown, R = void>(driver: AbstractDriver<T> | undefined, body?: BlockBody<T, M, R>, base?: BlockBody<T, M, R>): VBlock<T, M, R>;
     private static generateKey;
     static getDefaultLoggingOptions(): LoggingOptions | undefined;
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
@@ -68,7 +62,7 @@ export declare enum LayoutKind {
     Block = 0,
     Grid = 1,
     Line = 2,
-    Group = 3,
+    Fragment = 3,
     Text = 4
 }
 export declare class AbstractDriver<T> {

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

@@ -26,11 +26,6 @@ export var Priority;
     Priority[Priority["Normal"] = 1] = "Normal";
     Priority[Priority["Background"] = 2] = "Background";
 })(Priority || (Priority = {}));
-export function vmt(body) {
-    if (body instanceof Function)
-        body = { render: body };
-    return body;
-}
 export class VBlock {
     get isInitialRendering() {
         return this.stamp === 2;
@@ -48,15 +43,17 @@ export class VBlock {
     static runForAllBlocks(action) {
         forEachChildRecursively(gSysRoot, action);
     }
-    static claim(driver, body) {
+    static claim(driver, body, base) {
         var _a;
         let result;
         const owner = gCurrent.instance;
         const children = owner.children;
         let ex = undefined;
+        if (body)
+            body.base = base;
+        else
+            body = base !== null && base !== void 0 ? base : {};
         driver !== null && driver !== void 0 ? driver : (driver = AbstractDriver.group);
-        if (body instanceof Function)
-            body = { render: body };
         let key = body.key;
         if (driver.isLine) {
             const last = children.lastClaimedItem();
@@ -77,7 +74,7 @@ export class VBlock {
             result = new VBlockImpl(key || VBlock.generateKey(owner), driver, owner, body);
             result.item = children.add(result);
             VBlockImpl.grandCount++;
-            if (body.autonomous)
+            if (isReaction(body))
                 VBlockImpl.disposableCount++;
         }
         return result;
@@ -87,9 +84,9 @@ export class VBlock {
         const lettered = emitLetters(n);
         let result;
         if (Rx.isLogging)
-            result = `${getCallerInfo(lettered)}!`;
+            result = `·${getCallerInfo(lettered)}`;
         else
-            result = `${lettered}!`;
+            result = `·${lettered}`;
         return result;
     }
     static getDefaultLoggingOptions() {
@@ -108,7 +105,7 @@ export var LayoutKind;
     LayoutKind[LayoutKind["Block"] = 0] = "Block";
     LayoutKind[LayoutKind["Grid"] = 1] = "Grid";
     LayoutKind[LayoutKind["Line"] = 2] = "Line";
-    LayoutKind[LayoutKind["Group"] = 3] = "Group";
+    LayoutKind[LayoutKind["Fragment"] = 3] = "Fragment";
     LayoutKind[LayoutKind["Text"] = 4] = "Text";
 })(LayoutKind || (LayoutKind = {}));
 const createDefaultCursor = () => new Cursor();
@@ -164,42 +161,34 @@ export class AbstractDriver {
     applyStyling(block, secondary, styleName, enabled) {
     }
 }
-AbstractDriver.group = new AbstractDriver("group", LayoutKind.Group);
-function invokeInitializeChain(block, vmt) {
+AbstractDriver.group = new AbstractDriver("group", LayoutKind.Fragment);
+function isReaction(body) {
     var _a;
-    const redefined = vmt.redefinedInitialize;
-    const base = vmt.base;
-    if (!redefined) {
-        (_a = vmt.initialize) === null || _a === void 0 ? void 0 : _a.call(vmt, block);
-        if (base)
-            invokeInitializeChain(block, base);
-    }
-    else
-        redefined(block, base ? () => invokeInitializeChain(block, base) : NOP);
+    return (_a = body === null || body === void 0 ? void 0 : body.reaction) !== null && _a !== void 0 ? _a : ((body === null || body === void 0 ? void 0 : body.base) ? isReaction(body === null || body === void 0 ? void 0 : body.base) : false);
 }
-function invokeRenderChain(block, vmt) {
-    var _a;
-    const redefined = vmt.redefinedRender;
-    const base = vmt.base;
-    if (!redefined) {
-        if (base)
-            invokeRenderChain(block, base);
-        (_a = vmt.render) === null || _a === void 0 ? void 0 : _a.call(vmt, block);
-    }
-    else
-        redefined(block, base ? () => invokeRenderChain(block, base) : NOP);
+function invokeInitializeChain(block, body) {
+    const initialize = body.initialize;
+    const base = body.base;
+    if (initialize)
+        initialize(block, base ? () => invokeInitializeChain(block, base) : NOP);
+    else if (base)
+        invokeInitializeChain(block, base);
 }
-function invokeFinalizeChain(block, vmt) {
-    var _a;
-    const redefined = vmt.redefinedFinalize;
-    const base = vmt.base;
-    if (!redefined) {
-        (_a = vmt.finalize) === null || _a === void 0 ? void 0 : _a.call(vmt, block);
-        if (base)
-            invokeFinalizeChain(block, base);
-    }
-    else
-        redefined(block, base ? () => invokeFinalizeChain(block, base) : NOP);
+function invokeRenderChain(block, body) {
+    const render = body.render;
+    const base = body.base;
+    if (render)
+        render(block, base ? () => invokeRenderChain(block, base) : NOP);
+    else if (base)
+        invokeRenderChain(block, base);
+}
+function invokeFinalizeChain(block, body) {
+    const finalize = body.finalize;
+    const base = body.base;
+    if (finalize)
+        finalize(block, base ? () => invokeFinalizeChain(block, base) : NOP);
+    else if (base)
+        invokeFinalizeChain(block, base);
 }
 export class StaticDriver extends AbstractDriver {
     constructor(element, name, layout, createCursor) {
@@ -371,7 +360,7 @@ class VBlockImpl extends VBlock {
         this.assignedStyle = true;
     }
     configureReactronic(options) {
-        if (this.stamp !== 1 || !this.body.autonomous)
+        if (this.stamp !== 1 || !isReaction(this.body))
             throw new Error("reactronic can be configured only for reacting blocks and only inside initialize");
         return Rx.getController(this.render).configure(options);
     }
@@ -532,7 +521,7 @@ function renderIncrementally(owner, stamp, allChildren, items, priority) {
 function triggerRendering(item) {
     const block = item.instance;
     if (block.stamp >= 0) {
-        if (block.body.autonomous) {
+        if (isReaction(block.body)) {
             if (block.stamp === 0) {
                 Transaction.outside(() => {
                     if (Rx.isLogging)
@@ -595,7 +584,7 @@ function triggerFinalization(item, isLeader, individual) {
             console.log(`WARNING: it is recommended to assign explicit key for conditionally rendered block in order to avoid unexpected side effects: ${block.key}`);
         block.stamp = ~block.stamp;
         const childrenAreLeaders = block.driver.finalize(block, isLeader);
-        if (block.body.autonomous) {
+        if (isReaction(block.body)) {
             item.aux = undefined;
             const last = gLastToDispose;
             if (last)
@@ -700,8 +689,8 @@ function defaultReject(error) {
 }
 Promise.prototype.then = reactronicDomHookedThen;
 const NOP = (...args) => { };
-const gSysDriver = new StaticDriver(null, "SYSTEM", LayoutKind.Group);
-const gSysRoot = Collection.createItem(new VBlockImpl(gSysDriver.name, gSysDriver, { level: 0 }, { autonomous: true, render: NOP }));
+const gSysDriver = new StaticDriver(null, "SYSTEM", LayoutKind.Fragment);
+const gSysRoot = Collection.createItem(new VBlockImpl(gSysDriver.name, gSysDriver, { level: 0 }, { reaction: true, render: NOP }));
 gSysRoot.instance.item = gSysRoot;
 Object.defineProperty(gSysRoot.instance, "host", {
     value: gSysRoot.instance,

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

@@ -1,12 +1,12 @@
 import { VBlock, BlockBody, Align, CellRange } from "../core/api";
 import { HtmlDriver } from "./HtmlDriver";
-export declare function Block<M = unknown, R = void>(body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function Block<M = unknown, R = void>(body?: BlockBody<HTMLElement, M, R>, base?: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
 export declare function PlainText(content: string, body?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
 export declare function HtmlText(content: string, body?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
-export declare function Grid<M = unknown, R = void>(body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function Grid<M = unknown, R = void>(body?: BlockBody<HTMLElement, M, R>, base?: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
 export declare function line<T = void>(body: (block: void) => T): void;
 export declare function lineFeed(noCoalescing?: boolean, key?: string): VBlock<HTMLElement>;
-export declare function Group<M = unknown, R = void>(body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function Fragment<M = unknown, R = void>(body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
 export declare class VerstakDriver<T extends HTMLElement> extends HtmlDriver<T> {
     applyCellRange(block: VBlock<T>, cellRange: CellRange | undefined): void;
     applyWidthGrowth(block: VBlock<T>, widthGrowth: number): void;

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

@@ -1,24 +1,24 @@
-import { VBlock, LayoutKind, Align, GridCursor, vmt } from "../core/api";
+import { VBlock, LayoutKind, Align, GridCursor } from "../core/api";
 import { HtmlDriver } from "./HtmlDriver";
-export function Block(body) {
-    return VBlock.claim(VerstakTags.block, body);
+export function Block(body, base) {
+    return VBlock.claim(VerstakTags.block, body, base);
 }
 export function PlainText(content, body) {
-    return VBlock.claim(VerstakTags.text, Object.assign(Object.assign({}, vmt(body)), { base: {
-            render(b) {
-                b.native.innerText = content;
-            }
-        } }));
+    return VBlock.claim(VerstakTags.text, body, {
+        render(b) {
+            b.native.innerText = content;
+        }
+    });
 }
 export function HtmlText(content, body) {
-    return VBlock.claim(VerstakTags.text, Object.assign(Object.assign({}, vmt(body)), { base: {
-            render(b) {
-                b.native.innerHTML = content;
-            }
-        } }));
+    return VBlock.claim(VerstakTags.text, body, {
+        render(b) {
+            b.native.innerHTML = content;
+        }
+    });
 }
-export function Grid(body) {
-    return VBlock.claim(VerstakTags.grid, body);
+export function Grid(body, base) {
+    return VBlock.claim(VerstakTags.grid, body, base);
 }
 export function line(body) {
     lineFeed();
@@ -27,8 +27,8 @@ export function line(body) {
 export function lineFeed(noCoalescing, key) {
     return VBlock.claim(VerstakTags.line, { key });
 }
-export function Group(body) {
-    return VBlock.claim(VerstakTags.group, body);
+export function Fragment(body) {
+    return VBlock.claim(VerstakTags.fragment, body);
 }
 export class VerstakDriver extends HtmlDriver {
     applyCellRange(block, cellRange) {
@@ -148,7 +148,7 @@ const VerstakTags = {
     text: new VerstakDriver("v-text", LayoutKind.Text),
     grid: new VerstakDriver("v-grid", LayoutKind.Grid, () => new GridCursor()),
     line: new VerstakDriver("v-line", LayoutKind.Line),
-    group: new VerstakDriver("v-group", LayoutKind.Group),
+    fragment: new VerstakDriver("v-fragment", LayoutKind.Fragment),
 };
 const AlignToCss = ["stretch", "start", "center", "end"];
 const TextAlignCss = ["justify", "left", "center", "right"];

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

@@ -1,7 +1,7 @@
-import { VBlock } from "../core/api";
+import { Fragment } from "./Blocks";
 export function ReactingFocuser(target, model, switchEditMode = undefined) {
-    VBlock.claim(undefined, {
-        autonomous: true,
+    Fragment({
+        reaction: true,
         triggers: { target, model },
         initialize(b) {
             b.configureReactronic({ throttling: 0 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "verstak",
-  "version": "0.23.100",
+  "version": "0.23.101",
   "description": "Verstak - Front-End Library",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",