verstak 0.23.108 → 0.23.110

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

@@ -20,43 +20,43 @@ import { reactive, nonreactive, Transaction, options, Reentrance, Rx, Collection
 import { BlockKind, Priority, Mode, Align } from "./Interfaces";
 import { emitLetters, equalBlockCoords, parseBlockCoords, getCallerInfo } from "./Utils";
 export class Verstak {
-    static claim(driver, builder, original) {
+    static claim(driver, builder, base) {
         var _a;
         let result;
         if (builder)
-            builder.original = original;
+            builder.base = base;
         else
-            builder = original !== null && original !== void 0 ? original : {};
+            builder = base !== null && base !== void 0 ? base : {};
         let key = builder.key;
         const owner = gCurrent === null || gCurrent === void 0 ? void 0 : gCurrent.instance;
         if (owner) {
             let ex = undefined;
-            const children = owner.descriptor.children;
+            const children = owner.node.children;
             if (driver.isRow) {
                 const last = children.lastClaimedItem();
-                if (((_a = last === null || last === void 0 ? void 0 : last.instance) === null || _a === void 0 ? void 0 : _a.descriptor.driver) === driver)
+                if (((_a = last === null || last === void 0 ? void 0 : last.instance) === null || _a === void 0 ? void 0 : _a.node.driver) === driver)
                     ex = last;
             }
             ex !== null && ex !== void 0 ? ex : (ex = children.claim(key = key || generateKey(owner), undefined, "nested blocks can be declared inside render function only"));
             if (ex) {
                 result = ex.instance;
-                const d = result.descriptor;
-                if (d.driver !== driver && driver !== undefined)
-                    throw new Error(`changing block driver is not yet supported: "${result.descriptor.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
-                const exTriggers = d.builder.triggers;
+                const node = result.node;
+                if (node.driver !== driver && driver !== undefined)
+                    throw new Error(`changing block driver is not yet supported: "${result.node.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
+                const exTriggers = node.builder.triggers;
                 if (triggersAreEqual(builder.triggers, exTriggers))
                     builder.triggers = exTriggers;
-                d.builder = builder;
+                node.builder = builder;
             }
             else {
-                result = new XBlock(key || generateKey(owner), driver, owner, builder);
-                result.descriptor.item = children.add(result);
+                result = new BlockImpl(key || generateKey(owner), driver, owner, builder);
+                result.node.ties = children.add(result);
             }
         }
         else {
-            result = new XBlock(key || "", driver, owner, builder);
-            result.descriptor.item = Collection.createItem(result);
-            triggerRendering(result.descriptor.item);
+            result = new BlockImpl(key || "", driver, owner, builder);
+            result.node.ties = Collection.createItem(result);
+            triggerRendering(result.node.ties);
         }
         return result;
     }
@@ -65,14 +65,22 @@ export class Verstak {
             throw new Error("current block is undefined");
         return gCurrent.instance;
     }
+    static triggerRendering(block, triggers) {
+        const b = block;
+        const builder = b.node.builder;
+        if (!triggersAreEqual(triggers, builder.triggers)) {
+            builder.triggers = triggers;
+            triggerRendering(b.node.ties);
+        }
+    }
     static renderNestedTreesThenDo(action) {
         runRenderNestedTreesThenDo(undefined, action);
     }
     static getDefaultLoggingOptions() {
-        return XBlock.logging;
+        return BlockImpl.logging;
     }
     static setDefaultLoggingOptions(logging) {
-        XBlock.logging = logging;
+        BlockImpl.logging = logging;
     }
 }
 Verstak.shortFrameDuration = 16;
@@ -87,57 +95,44 @@ export class BaseDriver {
     }
     claim(block) {
         const b = block;
-        chainedClaim(b, b.descriptor.builder);
+        chainedClaim(b, b.node.builder);
     }
     create(block, b) {
-        chainedCreate(block, block.descriptor.builder);
+        chainedCreate(block, block.node.builder);
     }
     initialize(block) {
         var _a;
         const b = block;
         (_a = this.preset) === null || _a === void 0 ? void 0 : _a.call(this, b);
-        chainedInitialize(b, b.descriptor.builder);
+        chainedInitialize(b, b.node.builder);
     }
     mount(block) {
     }
     render(block) {
-        chainedRender(block, block.descriptor.builder);
+        chainedRender(block, block.node.builder);
     }
     finalize(block, isLeader) {
         const b = block;
-        chainedFinalize(b, b.descriptor.builder);
+        chainedFinalize(b, b.node.builder);
         return isLeader;
     }
-    applyKind(block, value) {
-    }
-    applyCoords(block, value) {
-    }
-    applyWidthGrowth(block, value) {
-    }
-    applyMinWidth(block, value) {
-    }
-    applyMaxWidth(block, value) {
-    }
-    applyHeightGrowth(block, value) {
-    }
-    applyMinHeight(block, value) {
-    }
-    applyMaxHeight(block, value) {
-    }
-    applyContentAlignment(block, value) {
-    }
-    applyBlockAlignment(block, value) {
-    }
-    applyContentWrapping(block, value) {
-    }
-    applyOverlayVisible(block, value) {
-    }
-    applyStyle(block, secondary, styleName, enabled) {
-    }
+    applyKind(block, value) { }
+    applyCoords(block, value) { }
+    applyWidthGrowth(block, value) { }
+    applyMinWidth(block, value) { }
+    applyMaxWidth(block, value) { }
+    applyHeightGrowth(block, value) { }
+    applyMinHeight(block, value) { }
+    applyMaxHeight(block, value) { }
+    applyContentAlignment(block, value) { }
+    applyBlockAlignment(block, value) { }
+    applyContentWrapping(block, value) { }
+    applyOverlayVisible(block, value) { }
+    applyStyle(block, secondary, styleName, enabled) { }
 }
 BaseDriver.fragment = new BaseDriver("fragment", false, b => b.kind = BlockKind.Group);
 function generateKey(owner) {
-    const n = owner.descriptor.numerator++;
+    const n = owner.node.numerator++;
     const lettered = emitLetters(n);
     let result;
     if (Rx.isLogging)
@@ -146,49 +141,49 @@ function generateKey(owner) {
         result = `·${lettered}`;
     return result;
 }
-function chainedMode(builder) {
+function chainedMode(bb) {
     var _a;
-    return (_a = builder === null || builder === void 0 ? void 0 : builder.modes) !== null && _a !== void 0 ? _a : ((builder === null || builder === void 0 ? void 0 : builder.original) ? chainedMode(builder === null || builder === void 0 ? void 0 : builder.original) : Mode.Default);
+    return (_a = bb === null || bb === void 0 ? void 0 : bb.mode) !== null && _a !== void 0 ? _a : ((bb === null || bb === void 0 ? void 0 : bb.base) ? chainedMode(bb === null || bb === void 0 ? void 0 : bb.base) : Mode.Default);
 }
-function chainedClaim(block, builder) {
-    const claim = builder.claim;
-    const original = builder.original;
+function chainedClaim(block, bb) {
+    const claim = bb.claim;
+    const base = bb.base;
     if (claim)
-        claim(block, original ? () => chainedClaim(block, original) : NOP);
-    else if (original)
-        chainedClaim(block, original);
+        claim(block, base ? () => chainedClaim(block, base) : NOP);
+    else if (base)
+        chainedClaim(block, base);
 }
-function chainedCreate(block, builder) {
-    const create = builder.create;
-    const original = builder.original;
+function chainedCreate(block, bb) {
+    const create = bb.create;
+    const base = bb.base;
     if (create)
-        create(block, original ? () => chainedCreate(block, original) : NOP);
-    else if (original)
-        chainedCreate(block, original);
+        create(block, base ? () => chainedCreate(block, base) : NOP);
+    else if (base)
+        chainedCreate(block, base);
 }
-function chainedInitialize(block, builder) {
-    const initialize = builder.initialize;
-    const original = builder.original;
+function chainedInitialize(block, bb) {
+    const initialize = bb.initialize;
+    const base = bb.base;
     if (initialize)
-        initialize(block, original ? () => chainedInitialize(block, original) : NOP);
-    else if (original)
-        chainedInitialize(block, original);
+        initialize(block, base ? () => chainedInitialize(block, base) : NOP);
+    else if (base)
+        chainedInitialize(block, base);
 }
-function chainedRender(block, builder) {
-    const render = builder.render;
-    const original = builder.original;
+function chainedRender(block, bb) {
+    const render = bb.render;
+    const base = bb.base;
     if (render)
-        render(block, original ? () => chainedRender(block, original) : NOP);
-    else if (original)
-        chainedRender(block, original);
+        render(block, base ? () => chainedRender(block, base) : NOP);
+    else if (base)
+        chainedRender(block, base);
 }
-function chainedFinalize(block, builder) {
-    const finalize = builder.finalize;
-    const original = builder.original;
+function chainedFinalize(block, bb) {
+    const finalize = bb.finalize;
+    const base = bb.base;
     if (finalize)
-        finalize(block, original ? () => chainedFinalize(block, original) : NOP);
-    else if (original)
-        chainedFinalize(block, original);
+        finalize(block, base ? () => chainedFinalize(block, base) : NOP);
+    else if (base)
+        chainedFinalize(block, base);
 }
 export class StaticDriver extends BaseDriver {
     constructor(element, name, isRow, preset) {
@@ -210,18 +205,18 @@ export class CursorCommandDriver extends BaseDriver {
         super.create(block, b);
     }
 }
-export class ContextVariable {
+export class SubTreeVariable {
     constructor(defaultValue) {
         this.defaultValue = defaultValue;
     }
     set value(value) {
-        XBlock.setContextVariableValue(this, value);
+        BlockImpl.setSubTreeVariableValue(this, value);
     }
     get value() {
-        return XBlock.useContextVariableValue(this);
+        return BlockImpl.useSubTreeVariableValue(this);
     }
     get valueOrUndefined() {
-        return XBlock.tryUseContextVariable(this);
+        return BlockImpl.tryUseSubTreeVariable(this);
     }
 }
 class CursorPosition {
@@ -242,7 +237,7 @@ var CursorFlags;
 })(CursorFlags || (CursorFlags = {}));
 const UndefinedBlockCoords = Object.freeze({ x1: 0, y1: 0, x2: 0, y2: 0 });
 const InitialCursorPosition = Object.freeze(new CursorPosition({ x: 1, y: 1, runningMaxX: 0, runningMaxY: 0, flags: CursorFlags.None }));
-class XBlockCtx extends ObservableObject {
+class BlockCtxImpl extends ObservableObject {
     constructor(variable, value) {
         super();
         this.next = undefined;
@@ -253,12 +248,12 @@ class XBlockCtx extends ObservableObject {
 __decorate([
     raw,
     __metadata("design:type", Object)
-], XBlockCtx.prototype, "next", void 0);
+], BlockCtxImpl.prototype, "next", void 0);
 __decorate([
     raw,
-    __metadata("design:type", ContextVariable)
-], XBlockCtx.prototype, "variable", void 0);
-class XBlockDescriptor {
+    __metadata("design:type", SubTreeVariable)
+], BlockCtxImpl.prototype, "variable", void 0);
+class BlockNodeImpl {
     constructor(key, driver, builder, self, owner) {
         this.maxColumnCount = 0;
         this.maxRowCount = 0;
@@ -266,10 +261,10 @@ class XBlockDescriptor {
         this.driver = driver;
         this.builder = builder;
         if (owner) {
-            const d = owner.descriptor;
-            this.level = d.level + 1;
+            const node = owner.node;
+            this.level = node.level + 1;
             this.owner = owner;
-            this.outer = d.context ? owner : d.outer;
+            this.outer = node.context ? owner : node.outer;
         }
         else {
             this.level = 1;
@@ -278,7 +273,7 @@ class XBlockDescriptor {
         }
         this.host = self;
         this.children = new Collection(getBlockKey, true);
-        this.item = undefined;
+        this.ties = undefined;
         this.stamp = 0;
         this.context = undefined;
         this.numerator = 0;
@@ -287,9 +282,9 @@ class XBlockDescriptor {
         this.cursorPosition = undefined;
     }
 }
-class XBlock {
+class BlockImpl {
     constructor(key, driver, owner, builder) {
-        this.descriptor = new XBlockDescriptor(key, driver, builder, this, owner);
+        this.node = new BlockNodeImpl(key, driver, builder, this, owner);
         this.native = undefined;
         this.model = undefined;
         this.controller = undefined;
@@ -304,45 +299,51 @@ class XBlock {
         this._maxHeight = "";
         this._contentAlignment = Align.Default;
         this._blockAlignment = Align.Default;
-        this._contentWrapping = false;
+        this._contentWrapping = true;
         this._overlayVisible = undefined;
-        this.hasStyles = false;
-        this.childrenShuffling = false;
+        this._hasStyles = false;
         this.renderingPriority = Priority.Realtime;
-        XBlock.grandCount++;
-        if (this.has(Mode.SeparateReaction))
-            XBlock.disposableCount++;
+        this.childrenShuffling = false;
+        BlockImpl.grandBlockCount++;
+        if (this.isOn(Mode.PinpointRefresh))
+            BlockImpl.disposableBlockCount++;
     }
     render(_triggers) {
-        renderNow(this.descriptor.item);
+        renderNow(this.node.ties);
+    }
+    prepareForRender() {
+        this._area = undefined;
+        this._hasStyles = false;
+    }
+    isOn(mode) {
+        return (chainedMode(this.node.builder) & mode) === mode;
     }
-    has(mode) { return (chainedMode(this.descriptor.builder) & mode) === mode; }
-    get isInitialRendering() { return this.descriptor.stamp === 2; }
-    get isSequential() { return this.descriptor.children.isStrict; }
-    set isSequential(value) { this.descriptor.children.isStrict = value; }
+    get isInitialRendering() { return this.node.stamp === 2; }
     get isAuxiliary() { return this.kind > BlockKind.Note; }
     get isBand() { return this.kind === BlockKind.Band; }
     get isTable() { return this.kind === BlockKind.Table; }
-    get isAutoMountEnabled() { return !this.has(Mode.ManualMount) && this.descriptor.host !== this; }
-    get isMoved() { return this.descriptor.owner.descriptor.children.isMoved(this.descriptor.item); }
+    get isAutoMountEnabled() { return !this.isOn(Mode.ManualMount) && this.node.host !== this; }
+    get isMoved() { return this.node.owner.node.children.isMoved(this.node.ties); }
+    get strictOrder() { return this.node.children.isStrict; }
+    set strictOrder(value) { this.node.children.isStrict = value; }
     get kind() { return this._kind; }
     set kind(value) {
-        if (value !== this._kind || this.descriptor.stamp < 2) {
-            this.descriptor.driver.applyKind(this, value);
+        if (value !== this._kind || this.node.stamp < 2) {
+            this.node.driver.applyKind(this, value);
             this._kind = value;
         }
     }
     get area() { return this._area; }
     set area(value) {
         var _a, _b;
-        const d = this.descriptor;
-        const driver = d.driver;
+        const node = this.node;
+        const driver = node.driver;
         if (!driver.isRow) {
-            const owner = d.owner.descriptor;
-            const cursorPosition = (_b = (_a = d.item.prev) === null || _a === void 0 ? void 0 : _a.instance.descriptor.cursorPosition) !== null && _b !== void 0 ? _b : InitialCursorPosition;
-            const newCursorPosition = d.cursorPosition = owner.children.isStrict ? new CursorPosition(cursorPosition) : undefined;
+            const owner = node.owner.node;
+            const cursorPosition = (_b = (_a = node.ties.prev) === null || _a === void 0 ? void 0 : _a.instance.node.cursorPosition) !== null && _b !== void 0 ? _b : InitialCursorPosition;
+            const newCursorPosition = node.cursorPosition = owner.children.isStrict ? new CursorPosition(cursorPosition) : undefined;
             const isCursorBlock = driver instanceof CursorCommandDriver;
-            const coords = areaToCoords(!isCursorBlock, value, owner.maxColumnCount, owner.maxRowCount, cursorPosition, newCursorPosition);
+            const coords = getEffectiveBlockCoords(!isCursorBlock, value, owner.maxColumnCount, owner.maxRowCount, cursorPosition, newCursorPosition);
             if (!equalBlockCoords(coords, this._coords)) {
                 driver.applyCoords(this, coords);
                 this._coords = coords;
@@ -355,79 +356,79 @@ class XBlock {
     get widthGrowth() { return this._widthGrowth; }
     set widthGrowth(value) {
         if (value !== this._widthGrowth) {
-            this.descriptor.driver.applyWidthGrowth(this, value);
+            this.node.driver.applyWidthGrowth(this, value);
             this._widthGrowth = value;
         }
     }
     get minWidth() { return this._minWidth; }
     set minWidth(value) {
         if (value !== this._minWidth) {
-            this.descriptor.driver.applyMinWidth(this, value);
+            this.node.driver.applyMinWidth(this, value);
             this._minWidth = value;
         }
     }
     get maxWidth() { return this._maxWidth; }
     set maxWidth(value) {
         if (value !== this._maxWidth) {
-            this.descriptor.driver.applyMaxWidth(this, value);
+            this.node.driver.applyMaxWidth(this, value);
             this._maxWidth = value;
         }
     }
     get heightGrowth() { return this._heightGrowth; }
     set heightGrowth(value) {
         if (value !== this._heightGrowth) {
-            this.descriptor.driver.applyHeightGrowth(this, value);
+            this.node.driver.applyHeightGrowth(this, value);
             this._heightGrowth = value;
         }
     }
     get minHeight() { return this._minHeight; }
     set minHeight(value) {
         if (value !== this._minHeight) {
-            this.descriptor.driver.applyMinHeight(this, value);
+            this.node.driver.applyMinHeight(this, value);
             this._minHeight = value;
         }
     }
     get maxHeight() { return this._maxHeight; }
     set maxHeight(value) {
         if (value !== this._maxHeight) {
-            this.descriptor.driver.applyMaxHeight(this, value);
+            this.node.driver.applyMaxHeight(this, value);
             this._maxHeight = value;
         }
     }
     get contentAlignment() { return this._contentAlignment; }
     set contentAlignment(value) {
         if (value !== this._contentAlignment) {
-            this.descriptor.driver.applyContentAlignment(this, value);
+            this.node.driver.applyContentAlignment(this, value);
             this._contentAlignment = value;
         }
     }
     get blockAlignment() { return this._blockAlignment; }
     set blockAlignment(value) {
         if (value !== this._blockAlignment) {
-            this.descriptor.driver.applyBlockAlignment(this, value);
+            this.node.driver.applyBlockAlignment(this, value);
             this._blockAlignment = value;
         }
     }
     get contentWrapping() { return this._contentWrapping; }
     set contentWrapping(value) {
         if (value !== this._contentWrapping) {
-            this.descriptor.driver.applyContentWrapping(this, value);
+            this.node.driver.applyContentWrapping(this, value);
             this._contentWrapping = value;
         }
     }
     get overlayVisible() { return this._overlayVisible; }
     set overlayVisible(value) {
         if (value !== this._overlayVisible) {
-            this.descriptor.driver.applyOverlayVisible(this, value);
+            this.node.driver.applyOverlayVisible(this, value);
             this._overlayVisible = value;
         }
     }
-    style(styleName, enabled) {
-        this.descriptor.driver.applyStyle(this, this.hasStyles, styleName, enabled);
-        this.hasStyles = true;
+    useStyle(styleName, enabled) {
+        this.node.driver.applyStyle(this, this._hasStyles, styleName, enabled);
+        this._hasStyles = true;
     }
     configureReactronic(options) {
-        if (this.descriptor.stamp !== 1 || !this.has(Mode.SeparateReaction))
+        if (this.node.stamp !== 1 || !this.isOn(Mode.PinpointRefresh))
             throw new Error("reactronic can be configured only for blocks with separate reaction mode and only inside initialize");
         return Rx.getController(this.render).configure(options);
     }
@@ -436,57 +437,57 @@ class XBlock {
             throw new Error("current block is undefined");
         return gCurrent;
     }
-    static tryUseContextVariable(variable) {
+    static tryUseSubTreeVariable(variable) {
         var _a, _b;
-        let b = XBlock.curr.instance;
-        while (((_a = b.descriptor.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && b.descriptor.owner !== b)
-            b = b.descriptor.outer;
-        return (_b = b.descriptor.context) === null || _b === void 0 ? void 0 : _b.value;
+        let b = BlockImpl.curr.instance;
+        while (((_a = b.node.context) === null || _a === void 0 ? void 0 : _a.variable) !== variable && b.node.owner !== b)
+            b = b.node.outer;
+        return (_b = b.node.context) === null || _b === void 0 ? void 0 : _b.value;
     }
-    static useContextVariableValue(variable) {
+    static useSubTreeVariableValue(variable) {
         var _a;
-        const result = (_a = XBlock.tryUseContextVariable(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
+        const result = (_a = BlockImpl.tryUseSubTreeVariable(variable)) !== null && _a !== void 0 ? _a : variable.defaultValue;
         if (!result)
             throw new Error("context doesn't exist");
         return result;
     }
-    static setContextVariableValue(variable, value) {
-        const b = XBlock.curr.instance;
-        const d = b.descriptor;
-        const owner = d.owner;
-        const hostCtx = nonreactive(() => { var _a; return (_a = owner.descriptor.context) === null || _a === void 0 ? void 0 : _a.value; });
+    static setSubTreeVariableValue(variable, value) {
+        const b = BlockImpl.curr.instance;
+        const node = b.node;
+        const owner = node.owner;
+        const hostCtx = nonreactive(() => { var _a; return (_a = owner.node.context) === null || _a === void 0 ? void 0 : _a.value; });
         if (value && value !== hostCtx) {
             if (hostCtx)
-                d.outer = owner;
+                node.outer = owner;
             else
-                d.outer = owner.descriptor.outer;
+                node.outer = owner.node.outer;
             Transaction.run({ separation: true }, () => {
-                const ctx = d.context;
+                const ctx = node.context;
                 if (ctx) {
                     ctx.variable = variable;
                     ctx.value = value;
                 }
                 else
-                    d.context = new XBlockCtx(variable, value);
+                    node.context = new BlockCtxImpl(variable, value);
             });
         }
         else if (hostCtx)
-            d.outer = owner;
+            node.outer = owner;
         else
-            d.outer = owner.descriptor.outer;
+            node.outer = owner.node.outer;
     }
     rowBreak() {
         var _a, _b;
-        const d = this.descriptor;
-        const cursorPosition = (_b = (_a = d.item.prev) === null || _a === void 0 ? void 0 : _a.instance.descriptor.cursorPosition) !== null && _b !== void 0 ? _b : InitialCursorPosition;
-        const newCursorPosition = this.descriptor.cursorPosition = new CursorPosition(cursorPosition);
+        const node = this.node;
+        const cursorPosition = (_b = (_a = node.ties.prev) === null || _a === void 0 ? void 0 : _a.instance.node.cursorPosition) !== null && _b !== void 0 ? _b : InitialCursorPosition;
+        const newCursorPosition = this.node.cursorPosition = new CursorPosition(cursorPosition);
         newCursorPosition.x = 1;
         newCursorPosition.y = newCursorPosition.runningMaxY + 1;
     }
 }
-XBlock.grandCount = 0;
-XBlock.disposableCount = 0;
-XBlock.logging = undefined;
+BlockImpl.grandBlockCount = 0;
+BlockImpl.disposableBlockCount = 0;
+BlockImpl.logging = undefined;
 __decorate([
     reactive,
     options({
@@ -497,12 +498,12 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
-], XBlock.prototype, "render", null);
+], BlockImpl.prototype, "render", null);
 function getBlockKey(block) {
-    const d = block.descriptor;
-    return d.stamp >= 0 ? d.key : undefined;
+    const node = block.node;
+    return node.stamp >= 0 ? node.key : undefined;
 }
-function areaToCoords(isRegularBlock, area, maxX, maxY, cursorPosition, newCursorPosition) {
+function getEffectiveBlockCoords(isRegularBlock, area, maxX, maxY, cursorPosition, newCursorPosition) {
     var _a, _b;
     let result;
     if (typeof (area) === "string") {
@@ -581,9 +582,9 @@ function areaToCoords(isRegularBlock, area, maxX, maxY, cursorPosition, newCurso
 }
 function runRenderNestedTreesThenDo(error, action) {
     var _a;
-    const curr = XBlock.curr;
+    const curr = BlockImpl.curr;
     const owner = curr.instance;
-    const children = owner.descriptor.children;
+    const children = owner.node.children;
     if (children.isMergeInProgress) {
         let promised = undefined;
         try {
@@ -601,7 +602,7 @@ function runRenderNestedTreesThenDo(error, action) {
                     if (Transaction.isCanceled)
                         break;
                     const block = item.instance;
-                    const isRow = block.descriptor.driver.isRow;
+                    const isRow = block.node.driver.isRow;
                     const host = isRow ? owner : hostingRow;
                     const p = (_a = block.renderingPriority) !== null && _a !== void 0 ? _a : Priority.Realtime;
                     mounting = markToMountIfNecessary(mounting, host, item, children, sequential);
@@ -624,23 +625,23 @@ function runRenderNestedTreesThenDo(error, action) {
         }
     }
 }
-function markToMountIfNecessary(mounting, host, item, children, sequential) {
-    const b = item.instance;
-    const d = b.descriptor;
-    if (b.native && !b.has(Mode.ManualMount)) {
-        if (mounting || d.host !== host) {
-            children.markAsMoved(item);
+function markToMountIfNecessary(mounting, host, ties, children, sequential) {
+    const b = ties.instance;
+    const node = b.node;
+    if (b.native && !b.isOn(Mode.ManualMount)) {
+        if (mounting || node.host !== host) {
+            children.markAsMoved(ties);
             mounting = false;
         }
     }
-    else if (sequential && children.isMoved(item))
+    else if (sequential && children.isMoved(ties))
         mounting = true;
-    d.host = host;
+    node.host = host;
     return mounting;
 }
 function startIncrementalRendering(owner, allChildren, priority1, priority2) {
     return __awaiter(this, void 0, void 0, function* () {
-        const stamp = owner.instance.descriptor.stamp;
+        const stamp = owner.instance.node.stamp;
         if (priority1)
             yield renderIncrementally(owner, stamp, allChildren, priority1, Priority.Normal);
         if (priority2)
@@ -678,31 +679,31 @@ function renderIncrementally(owner, stamp, allChildren, items, priority) {
         }
     });
 }
-function triggerRendering(item) {
-    const b = item.instance;
-    const d = b.descriptor;
-    if (d.stamp >= 0) {
-        if (b.has(Mode.SeparateReaction)) {
-            if (d.stamp === 0) {
+function triggerRendering(ties) {
+    const b = ties.instance;
+    const node = b.node;
+    if (node.stamp >= 0) {
+        if (b.isOn(Mode.PinpointRefresh)) {
+            if (node.stamp === 0) {
                 Transaction.outside(() => {
                     if (Rx.isLogging)
-                        Rx.setLoggingHint(b, d.key);
+                        Rx.setLoggingHint(b, node.key);
                     Rx.getController(b.render).configure({
-                        order: d.level,
+                        order: node.level,
                     });
                 });
             }
-            nonreactive(b.render, d.builder.triggers);
+            nonreactive(b.render, node.builder.triggers);
         }
         else
-            renderNow(item);
+            renderNow(ties);
     }
 }
 function mountIfNecessary(block) {
-    const d = block.descriptor;
-    const driver = d.driver;
-    if (d.stamp === 0) {
-        d.stamp = 1;
+    const node = block.node;
+    const driver = node.driver;
+    if (node.stamp === 0) {
+        node.stamp = 1;
         nonreactive(() => {
             driver.create(block, block);
             driver.initialize(block);
@@ -713,22 +714,21 @@ function mountIfNecessary(block) {
     else if (block.isMoved && block.isAutoMountEnabled)
         nonreactive(() => driver.mount(block));
 }
-function renderNow(item) {
-    const b = item.instance;
-    const d = b.descriptor;
-    if (d.stamp >= 0) {
+function renderNow(ties) {
+    const b = ties.instance;
+    const node = b.node;
+    if (node.stamp >= 0) {
         let result = undefined;
-        runInside(item, () => {
+        runInside(ties, () => {
             try {
                 mountIfNecessary(b);
-                d.stamp++;
-                d.numerator = 0;
-                b._area = undefined;
-                b.hasStyles = false;
-                d.children.beginMerge();
-                const driver = d.driver;
+                node.stamp++;
+                node.numerator = 0;
+                b.prepareForRender();
+                node.children.beginMerge();
+                const driver = node.driver;
                 result = driver.render(b);
-                if (b._area === undefined && d.owner.isTable)
+                if (b.area === undefined && node.owner.isTable)
                     b.area = 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); });
@@ -737,38 +737,38 @@ function renderNow(item) {
             }
             catch (e) {
                 runRenderNestedTreesThenDo(e, NOP);
-                console.log(`Rendering failed: ${d.key}`);
+                console.log(`Rendering failed: ${node.key}`);
                 console.log(`${e}`);
             }
         });
     }
 }
-function triggerFinalization(item, isLeader, individual) {
-    const b = item.instance;
-    const d = b.descriptor;
-    if (d.stamp >= 0) {
-        const driver = d.driver;
-        if (individual && d.key !== d.builder.key && !driver.isRow)
-            console.log(`WARNING: it is recommended to assign explicit key for conditionally rendered block in order to avoid unexpected side effects: ${d.key}`);
-        d.stamp = ~d.stamp;
+function triggerFinalization(ties, isLeader, individual) {
+    const b = ties.instance;
+    const node = b.node;
+    if (node.stamp >= 0) {
+        const driver = node.driver;
+        if (individual && node.key !== node.builder.key && !driver.isRow)
+            console.log(`WARNING: it is recommended to assign explicit key for conditionally rendered block in order to avoid unexpected side effects: ${node.key}`);
+        node.stamp = ~node.stamp;
         const childrenAreLeaders = nonreactive(() => driver.finalize(b, isLeader));
         b.native = null;
         b.controller = null;
-        if (b.has(Mode.SeparateReaction)) {
-            item.aux = undefined;
+        if (b.isOn(Mode.PinpointRefresh)) {
+            ties.aux = undefined;
             const last = gLastToDispose;
             if (last)
-                gLastToDispose = last.aux = item;
+                gLastToDispose = last.aux = ties;
             else
-                gFirstToDispose = gLastToDispose = item;
-            if (gFirstToDispose === item)
-                Transaction.run({ separation: "disposal", hint: `runDisposalLoop(initiator=${item.instance.descriptor.key})` }, () => {
+                gFirstToDispose = gLastToDispose = ties;
+            if (gFirstToDispose === ties)
+                Transaction.run({ separation: "disposal", hint: `runDisposalLoop(initiator=${ties.instance.node.key})` }, () => {
                     void runDisposalLoop().then(NOP, error => console.log(error));
                 });
         }
-        for (const item of d.children.items())
+        for (const item of node.children.items())
             triggerFinalization(item, childrenAreLeaders, false);
-        XBlock.grandCount--;
+        BlockImpl.grandBlockCount--;
     }
 }
 function runDisposalLoop() {
@@ -780,7 +780,7 @@ function runDisposalLoop() {
                 yield Transaction.requestNextFrame();
             Rx.dispose(item.instance);
             item = item.aux;
-            XBlock.disposableCount--;
+            BlockImpl.disposableBlockCount--;
         }
         gFirstToDispose = gLastToDispose = undefined;
     });
@@ -796,10 +796,10 @@ function wrapToRunInside(func) {
         wrappedToRunInside = func;
     return wrappedToRunInside;
 }
-function runInside(item, func, ...args) {
+function runInside(ties, func, ...args) {
     const outer = gCurrent;
     try {
-        gCurrent = item;
+        gCurrent = ties;
         return func(...args);
     }
     finally {