verstak 0.23.105 → 0.23.106

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

@@ -18,11 +18,11 @@ export interface ElasticSize {
 export interface TrackSize extends ElasticSize {
     track?: string | number;
 }
-export type Cells = undefined | string | number | {
-    right?: number;
-    horizontalOverlap?: boolean;
-    down?: number;
-    verticalOverlap?: boolean;
+export type Bounds = undefined | string | number | {
+    widthInCells?: number;
+    heightInCells?: number;
+    widthOverlap?: boolean;
+    heightOverlap?: boolean;
 };
 export declare class Cursor {
     static readonly UndefinedCellRange: Readonly<{
@@ -32,7 +32,7 @@ export declare class Cursor {
         y2: 0;
     }>;
     reset(): void;
-    onwards(cells: Cells): CellRange;
+    onwards(bounds: Bounds): CellRange;
     lineFeed(): void;
 }
 export declare class GridCursor extends Cursor {
@@ -44,6 +44,6 @@ export declare class GridCursor extends Cursor {
     private rowCursor;
     private newRowCursor;
     reset(): void;
-    onwards(cells: Cells): CellRange;
+    onwards(bounds: Bounds): CellRange;
     lineFeed(): void;
 }

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

@@ -12,7 +12,7 @@ export var Align;
 })(Align || (Align = {}));
 export class Cursor {
     reset() { }
-    onwards(cells) { return Cursor.UndefinedCellRange; }
+    onwards(bounds) { return Cursor.UndefinedCellRange; }
     lineFeed() { }
 }
 Cursor.UndefinedCellRange = Object.freeze({ x1: 0, y1: 0, x2: 0, y2: 0 });
@@ -36,59 +36,59 @@ export class GridCursor extends Cursor {
         this.rowCursor = 0;
         this.newRowCursor = 0;
     }
-    onwards(cells) {
+    onwards(bounds) {
         var _a, _b, _c, _d;
         let result;
-        if (typeof (cells) === "string") {
-            result = parseCellRange(cells, { x1: 0, y1: 0, x2: 0, y2: 0 });
+        if (typeof (bounds) === "string") {
+            result = parseCellRange(bounds, { x1: 0, y1: 0, x2: 0, y2: 0 });
             absolutizeCellRange(result, this.columnCursor + 1, this.rowCursor + 1, this.maxColumnCount || Infinity, this.maxRowCount || Infinity, result);
         }
         else {
-            let columns;
-            let rows;
-            let columnsOverlap;
-            let rowsOverlap;
-            if (typeof (cells) === "number") {
-                columns = cells;
-                rows = 1;
-                columnsOverlap = rowsOverlap = false;
+            let w;
+            let h;
+            let wOverlap;
+            let hOverlap;
+            if (typeof (bounds) === "number") {
+                w = bounds;
+                h = 1;
+                wOverlap = hOverlap = false;
             }
-            else if (cells) {
-                columns = (_a = cells.right) !== null && _a !== void 0 ? _a : 1;
-                rows = (_b = cells.down) !== null && _b !== void 0 ? _b : 1;
-                columnsOverlap = (_c = cells.horizontalOverlap) !== null && _c !== void 0 ? _c : false;
-                rowsOverlap = (_d = cells.verticalOverlap) !== null && _d !== void 0 ? _d : false;
+            else if (bounds) {
+                w = (_a = bounds.widthInCells) !== null && _a !== void 0 ? _a : 1;
+                h = (_b = bounds.heightInCells) !== null && _b !== void 0 ? _b : 1;
+                wOverlap = (_c = bounds.widthOverlap) !== null && _c !== void 0 ? _c : false;
+                hOverlap = (_d = bounds.heightOverlap) !== null && _d !== void 0 ? _d : false;
             }
             else {
-                columns = 1;
-                rows = 1;
-                columnsOverlap = rowsOverlap = false;
+                w = 1;
+                h = 1;
+                wOverlap = hOverlap = false;
             }
             const totalColumnCount = this.maxColumnCount !== 0 ? this.maxColumnCount : this.actualColumnCount;
             const totalRowCount = this.maxRowCount !== 0 ? this.maxRowCount : this.actualRowCount;
             result = { x1: 0, y1: 0, x2: 0, y2: 0 };
-            if (columns === 0)
-                columns = totalColumnCount || 1;
-            if (columns >= 0) {
+            if (w === 0)
+                w = totalColumnCount || 1;
+            if (w >= 0) {
                 result.x1 = this.columnCursor + 1;
-                result.x2 = absolutizePosition(result.x1 + columns - 1, 0, this.maxColumnCount || Infinity);
-                if (!columnsOverlap)
+                result.x2 = absolutizePosition(result.x1 + w - 1, 0, this.maxColumnCount || Infinity);
+                if (!wOverlap)
                     this.columnCursor = result.x2;
             }
             else {
-                result.x1 = Math.max(this.columnCursor + columns, 1);
+                result.x1 = Math.max(this.columnCursor + w, 1);
                 result.x2 = this.columnCursor;
             }
-            if (rows === 0)
-                rows = totalRowCount || 1;
-            if (rows >= 0) {
+            if (h === 0)
+                h = totalRowCount || 1;
+            if (h >= 0) {
                 result.y1 = this.rowCursor + 1;
-                result.y2 = absolutizePosition(result.y1 + rows - 1, 0, this.maxRowCount || Infinity);
-                if (!rowsOverlap && result.y2 > this.newRowCursor)
+                result.y2 = absolutizePosition(result.y1 + h - 1, 0, this.maxRowCount || Infinity);
+                if (!hOverlap && result.y2 > this.newRowCursor)
                     this.newRowCursor = result.y2;
             }
             else {
-                result.y1 = Math.max(this.rowCursor + rows, 1);
+                result.y1 = Math.max(this.rowCursor + h, 1);
                 result.y2 = this.rowCursor;
             }
         }

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

@@ -17,7 +17,7 @@ export function getCallerInfo(prefix) {
         location = extractFunctionAndLocation(lines[i + 1]);
     }
     else {
-        while (!caller.func) {
+        while (!caller.func && i > 0) {
             i = i - 1;
             caller = extractFunctionAndLocation(lines[i]);
         }

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

@@ -1,6 +1,6 @@
 import { LoggingOptions, Item, CollectionReader, MemberOptions } from "reactronic";
 import { CellRange } from "./CellRange";
-import { Cursor, Align, Cells } from "./Cursor";
+import { Cursor, Align, Bounds } from "./Cursor";
 export type Callback<T = unknown> = (native: T) => void;
 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>;
@@ -28,7 +28,7 @@ export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     abstract readonly driver: AbstractDriver<T>;
     abstract readonly body: Readonly<BlockBody<T, M, R>>;
     abstract model: M;
-    abstract cells: Cells;
+    abstract bounds: Bounds;
     abstract widthGrowth: number;
     abstract minWidth: string;
     abstract maxWidth: string;

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

@@ -241,7 +241,7 @@ class VBlockImpl extends VBlock {
         this.driver = driver;
         this.body = body;
         this.model = undefined;
-        this.assignedCells = undefined;
+        this.assignedBounds = undefined;
         this.assignedStyle = false;
         this.appliedCellRange = Cursor.UndefinedCellRange;
         this.appliedWidthGrowth = 0;
@@ -276,16 +276,16 @@ class VBlockImpl extends VBlock {
     render(_triggers) {
         renderNow(this.item);
     }
-    get cells() { return this.assignedCells; }
-    set cells(value) {
-        if (this.assignedCells !== undefined)
+    get bounds() { return this.assignedBounds; }
+    set bounds(value) {
+        if (this.assignedBounds !== undefined)
             throw new Error("cells can be assigned only once during rendering");
         const cellRange = this.host.cursor.onwards(value);
         if (!equalCellRanges(cellRange, this.appliedCellRange)) {
             this.driver.applyCellRange(this, cellRange);
             this.appliedCellRange = cellRange;
         }
-        this.assignedCells = value !== null && value !== void 0 ? value : {};
+        this.assignedBounds = value !== null && value !== void 0 ? value : {};
     }
     get widthGrowth() { return this.appliedWidthGrowth; }
     set widthGrowth(value) {
@@ -428,9 +428,8 @@ function runRenderNestedTreesThenDo(error, action) {
         let promised = undefined;
         try {
             children.endMerge(error);
-            for (const item of children.removedItems(true)) {
+            for (const item of children.removedItems(true))
                 triggerFinalization(item, true, true);
-            }
             if (!error) {
                 const ownerIsBlock = owner.driver.isBlock;
                 const sequential = children.strict;
@@ -543,11 +542,13 @@ function redeployIfNecessary(block) {
     const driver = block.driver;
     if (block.stamp === 0) {
         block.stamp = 1;
-        driver.initialize(block, undefined);
-        driver.deploy(block);
+        nonreactive(() => {
+            driver.initialize(block, undefined);
+            driver.deploy(block);
+        });
     }
     else if (block.isMoved)
-        driver.deploy(block);
+        nonreactive(() => driver.deploy(block));
 }
 function renderNow(item) {
     const block = item.instance;
@@ -558,14 +559,14 @@ function renderNow(item) {
                 redeployIfNecessary(block);
                 block.stamp++;
                 block.numerator = 0;
-                block.assignedCells = undefined;
+                block.assignedBounds = undefined;
                 block.assignedStyle = false;
                 block.children.beginMerge();
                 result = block.driver.render(block);
                 if (block.driver.isLine)
                     block.host.cursor.lineFeed();
-                else if (block.assignedCells === undefined)
-                    block.cells = undefined;
+                else if (block.assignedBounds === undefined)
+                    block.bounds = undefined;
                 if (result instanceof Promise)
                     result.then(v => { runRenderNestedTreesThenDo(undefined, NOP); return v; }, e => { console.log(e); runRenderNestedTreesThenDo(e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
                 else
@@ -585,7 +586,7 @@ function triggerFinalization(item, isLeader, individual) {
         if (individual && block.key !== block.body.key && !block.driver.isLine)
             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);
+        const childrenAreLeaders = nonreactive(() => block.driver.finalize(block, isLeader));
         if (isReaction(block.body)) {
             item.aux = undefined;
             const last = gLastToDispose;

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

@@ -1,11 +1,11 @@
 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>, 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>, base?: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function Ribbon<M = unknown, R = void>(body?: BlockBody<HTMLElement, M, R>, base?: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function Table<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 Note(content: string, body?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
+export declare function HtmlNote(content: string, body?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
 export declare function Group<M = unknown, R = void>(body?: BlockBody<HTMLElement, M, R>, base?: 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;

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

@@ -1,32 +1,32 @@
 import { VBlock, LayoutKind, Align, GridCursor } from "../core/api";
 import { HtmlDriver } from "./HtmlDriver";
-export function Block(body, base) {
+export function Ribbon(body, base) {
     return VBlock.claim(VerstakTags.block, body, base);
 }
-export function PlainText(content, body) {
+export function Table(body, base) {
+    return VBlock.claim(VerstakTags.grid, body, base);
+}
+export function line(body) {
+    lineFeed();
+    body();
+}
+export function lineFeed(noCoalescing, key) {
+    return VBlock.claim(VerstakTags.line, { key });
+}
+export function Note(content, body) {
     return VBlock.claim(VerstakTags.text, body, {
         render(b) {
             b.native.innerText = content;
         }
     });
 }
-export function HtmlText(content, body) {
+export function HtmlNote(content, body) {
     return VBlock.claim(VerstakTags.text, body, {
         render(b) {
             b.native.innerHTML = content;
         }
     });
 }
-export function Grid(body, base) {
-    return VBlock.claim(VerstakTags.grid, body, base);
-}
-export function line(body) {
-    lineFeed();
-    body();
-}
-export function lineFeed(noCoalescing, key) {
-    return VBlock.claim(VerstakTags.line, { key });
-}
 export function Group(body, base) {
     return VBlock.claim(VerstakTags.group, body, base);
 }

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

@@ -97,7 +97,7 @@ export declare function Style<M = unknown, R = void>(body?: BlockBody<HTMLStyleE
 export declare function Sub<M = unknown, R = void>(body?: BlockBody<HTMLElement, M, R>, base?: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
 export declare function Summary<M = unknown, R = void>(body?: BlockBody<HTMLElement, M, R>, base?: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
 export declare function Sup<M = unknown, R = void>(body?: BlockBody<HTMLElement, M, R>, base?: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
-export declare function Table<M = unknown, R = void>(body?: BlockBody<HTMLTableElement, M, R>, base?: BlockBody<HTMLTableElement, M, R>): VBlock<HTMLTableElement, M, R>;
+export declare function Tbl<M = unknown, R = void>(body?: BlockBody<HTMLTableElement, M, R>, base?: BlockBody<HTMLTableElement, M, R>): VBlock<HTMLTableElement, M, R>;
 export declare function Template<M = unknown, R = void>(body?: BlockBody<HTMLTemplateElement, M, R>, base?: BlockBody<HTMLTemplateElement, M, R>): VBlock<HTMLTemplateElement, M, R>;
 export declare function TBody<M = unknown, R = void>(body?: BlockBody<HTMLTableSectionElement, M, R>, base?: BlockBody<HTMLTableSectionElement, M, R>): VBlock<HTMLTableSectionElement, M, R>;
 export declare function TD<M = unknown, R = void>(body?: BlockBody<HTMLTableCellElement, M, R>, base?: BlockBody<HTMLTableCellElement, M, R>): VBlock<HTMLTableCellElement, M, R>;

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

@@ -101,7 +101,7 @@ export function Style(body, base) { return VBlock.claim(HtmlTags.style, body, ba
 export function Sub(body, base) { return VBlock.claim(HtmlTags.sub, body, base); }
 export function Summary(body, base) { return VBlock.claim(HtmlTags.summary, body, base); }
 export function Sup(body, base) { return VBlock.claim(HtmlTags.sup, body, base); }
-export function Table(body, base) { return VBlock.claim(HtmlTags.table, body, base); }
+export function Tbl(body, base) { return VBlock.claim(HtmlTags.table, body, base); }
 export function Template(body, base) { return VBlock.claim(HtmlTags.template, body, base); }
 export function TBody(body, base) { return VBlock.claim(HtmlTags.tbody, body, base); }
 export function TD(body, base) { return VBlock.claim(HtmlTags.td, body, base); }

package/package.json

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