verstak 0.23.111 → 0.23.112

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

@@ -4,7 +4,7 @@ export type Delegate<T = unknown, M = unknown, C = unknown, R = void> = (block:
 export type AsyncDelegate<T = unknown, M = unknown> = (block: Block<T, M, Promise<void>>) => Promise<void>;
 export type SimpleDelegate<T = unknown> = (block: Block<T, any, any, any>) => void;
 export declare enum BlockKind {
-    Band = 0,
+    Section = 0,
     Table = 1,
     Note = 2,
     Group = 3,
@@ -15,7 +15,7 @@ export declare enum BlockKind {
 export interface Block<T = unknown, M = unknown, C = unknown, R = void> {
     readonly node: BlockNode<T, M, C, R>;
     readonly native: T;
-    readonly isBand: boolean;
+    readonly isSection: boolean;
     readonly isTable: boolean;
     model: M;
     controller: C;
@@ -31,10 +31,10 @@ export interface Block<T = unknown, M = unknown, C = unknown, R = void> {
     blockAlignment: Align;
     contentWrapping: boolean;
     overlayVisible: boolean | undefined;
-    renderingPriority?: Priority;
+    updatePriority?: Priority;
     childrenShuffling: boolean;
     strictOrder: boolean;
-    readonly isInitialRendering: boolean;
+    readonly isInitialUpdate: boolean;
     useStyle(styleName: string, enabled?: boolean): void;
     configureReactronic(options: Partial<MemberOptions>): MemberOptions;
 }
@@ -59,7 +59,7 @@ export interface BlockBuilder<T = unknown, M = unknown, C = unknown, R = void> {
     claim?: Delegate<T, M, C, R>;
     create?: Delegate<T, M, C, R>;
     initialize?: Delegate<T, M, C, R>;
-    render?: Delegate<T, M, C, R>;
+    update?: Delegate<T, M, C, R>;
     finalize?: Delegate<T, M, C, R>;
 }
 export interface BlockCtx<T extends Object = Object> {
@@ -76,7 +76,7 @@ export interface Driver<T, C = unknown> {
     }): void;
     initialize(block: Block<T, unknown, C>): void;
     mount(block: Block<T, unknown, C>): void;
-    render(block: Block<T, unknown, C>): void | Promise<void>;
+    update(block: Block<T, unknown, C>): void | Promise<void>;
     finalize(block: Block<T, unknown, C>, isLeader: boolean): boolean;
     applyKind(block: Block<T, any, C, any>, value: BlockKind): void;
     applyCoords(block: Block<T, any, C, any>, value: BlockCoords | undefined): void;
@@ -105,7 +105,7 @@ export declare const enum Priority {
 }
 export declare enum Mode {
     Default = 0,
-    PinpointRefresh = 1,
+    PinpointUpdate = 1,
     ManualMount = 2
 }
 export declare enum Align {

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

@@ -1,6 +1,6 @@
 export var BlockKind;
 (function (BlockKind) {
-    BlockKind[BlockKind["Band"] = 0] = "Band";
+    BlockKind[BlockKind["Section"] = 0] = "Section";
     BlockKind[BlockKind["Table"] = 1] = "Table";
     BlockKind[BlockKind["Note"] = 2] = "Note";
     BlockKind[BlockKind["Group"] = 3] = "Group";
@@ -17,7 +17,7 @@ export var Priority;
 export var Mode;
 (function (Mode) {
     Mode[Mode["Default"] = 0] = "Default";
-    Mode[Mode["PinpointRefresh"] = 1] = "PinpointRefresh";
+    Mode[Mode["PinpointUpdate"] = 1] = "PinpointUpdate";
     Mode[Mode["ManualMount"] = 2] = "ManualMount";
 })(Mode || (Mode = {}));
 export var Align;

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

@@ -187,7 +187,7 @@ export function getCallerInfo(prefix) {
     i = i >= 0 ? i + 2 : 5;
     let caller = extractFunctionAndLocation(lines[i]);
     let location = caller;
-    if (caller.func.endsWith(".render")) {
+    if (caller.func.endsWith(".update")) {
         i = i - 1;
         caller = extractFunctionAndLocation(lines[i]);
         location = extractFunctionAndLocation(lines[i + 1]);

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

@@ -3,12 +3,12 @@ import { BlockCoords, BlockKind, Priority, Align, BlockBuilder, Block, Driver, S
 export declare class Verstak {
     static readonly shortFrameDuration = 16;
     static readonly longFrameDuration = 300;
-    static currentRenderingPriority: Priority;
+    static currentUpdatePriority: Priority;
     static frameDuration: number;
     static claim<T = undefined, M = unknown, C = unknown, R = void>(driver: Driver<T>, builder?: BlockBuilder<T, M, C, R>, base?: BlockBuilder<T, M, C, R>): Block<T, M, C, R>;
     static get block(): Block;
-    static triggerRendering(block: Block<any, any, any, void>, triggers: unknown): void;
-    static renderNestedTreesThenDo(action: (error: unknown) => void): void;
+    static triggerUpdate(block: Block<any, any, any, void>, triggers: unknown): void;
+    static updatedNestedTreesThenDo(action: (error: unknown) => void): void;
     static getDefaultLoggingOptions(): LoggingOptions | undefined;
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
@@ -25,7 +25,7 @@ export declare class BaseDriver<T, C = unknown> implements Driver<T, C> {
     }): void;
     initialize(block: Block<T, unknown, C>): void;
     mount(block: Block<T, unknown, C>): void;
-    render(block: Block<T, unknown, C>): void | Promise<void>;
+    update(block: Block<T, unknown, C>): void | Promise<void>;
     finalize(block: Block<T, unknown, C>, isLeader: boolean): boolean;
     applyKind(block: Block<T, any, C, any>, value: BlockKind): void;
     applyCoords(block: Block<T, any, C, any>, value: BlockCoords | undefined): void;

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

@@ -37,7 +37,7 @@ export class Verstak {
                 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"));
+            ex !== null && ex !== void 0 ? ex : (ex = children.claim(key = key || generateKey(owner), undefined, "nested blocks can be declared inside update function only"));
             if (ex) {
                 result = ex.instance;
                 const node = result.node;
@@ -56,7 +56,7 @@ export class Verstak {
         else {
             result = new BlockImpl(key || "", driver, owner, builder);
             result.node.ties = Collection.createItem(result);
-            triggerRendering(result.node.ties);
+            triggerUpdate(result.node.ties);
         }
         return result;
     }
@@ -65,16 +65,16 @@ export class Verstak {
             throw new Error("current block is undefined");
         return gCurrent.instance;
     }
-    static triggerRendering(block, triggers) {
+    static triggerUpdate(block, triggers) {
         const b = block;
         const builder = b.node.builder;
         if (!triggersAreEqual(triggers, builder.triggers)) {
             builder.triggers = triggers;
-            triggerRendering(b.node.ties);
+            triggerUpdate(b.node.ties);
         }
     }
-    static renderNestedTreesThenDo(action) {
-        runRenderNestedTreesThenDo(undefined, action);
+    static updatedNestedTreesThenDo(action) {
+        runUpdateNestedTreesThenDo(undefined, action);
     }
     static getDefaultLoggingOptions() {
         return BlockImpl.logging;
@@ -85,7 +85,7 @@ export class Verstak {
 }
 Verstak.shortFrameDuration = 16;
 Verstak.longFrameDuration = 300;
-Verstak.currentRenderingPriority = Priority.Realtime;
+Verstak.currentUpdatePriority = Priority.Realtime;
 Verstak.frameDuration = Verstak.longFrameDuration;
 export class BaseDriver {
     constructor(name, isRow, preset) {
@@ -108,8 +108,8 @@ export class BaseDriver {
     }
     mount(block) {
     }
-    render(block) {
-        chainedRender(block, block.node.builder);
+    update(block) {
+        chainedUpdate(block, block.node.builder);
     }
     finalize(block, isLeader) {
         const b = block;
@@ -169,13 +169,13 @@ function chainedInitialize(block, bb) {
     else if (base)
         chainedInitialize(block, base);
 }
-function chainedRender(block, bb) {
-    const render = bb.render;
+function chainedUpdate(block, bb) {
+    const update = bb.update;
     const base = bb.base;
-    if (render)
-        render(block, base ? () => chainedRender(block, base) : NOP);
+    if (update)
+        update(block, base ? () => chainedUpdate(block, base) : NOP);
     else if (base)
-        chainedRender(block, base);
+        chainedUpdate(block, base);
 }
 function chainedFinalize(block, bb) {
     const finalize = bb.finalize;
@@ -302,25 +302,25 @@ class BlockImpl {
         this._contentWrapping = true;
         this._overlayVisible = undefined;
         this._hasStyles = false;
-        this.renderingPriority = Priority.Realtime;
+        this.updatePriority = Priority.Realtime;
         this.childrenShuffling = false;
         BlockImpl.grandBlockCount++;
-        if (this.isOn(Mode.PinpointRefresh))
+        if (this.isOn(Mode.PinpointUpdate))
             BlockImpl.disposableBlockCount++;
     }
-    render(_triggers) {
-        renderNow(this.node.ties);
+    update(_triggers) {
+        updateNow(this.node.ties);
     }
-    prepareForRender() {
+    prepareForUpdate() {
         this._area = undefined;
         this._hasStyles = false;
     }
     isOn(mode) {
         return (chainedMode(this.node.builder) & mode) === mode;
     }
-    get isInitialRendering() { return this.node.stamp === 2; }
+    get isInitialUpdate() { return this.node.stamp === 2; }
     get isAuxiliary() { return this.kind > BlockKind.Note; }
-    get isBand() { return this.kind === BlockKind.Band; }
+    get isSection() { return this.kind === BlockKind.Section; }
     get isTable() { return this.kind === BlockKind.Table; }
     get isAutoMountEnabled() { return !this.isOn(Mode.ManualMount) && this.node.host !== this; }
     get isMoved() { return this.node.owner.node.children.isMoved(this.node.ties); }
@@ -428,9 +428,9 @@ class BlockImpl {
         this._hasStyles = true;
     }
     configureReactronic(options) {
-        if (this.node.stamp !== 1 || !this.isOn(Mode.PinpointRefresh))
+        if (this.node.stamp !== 1 || !this.isOn(Mode.PinpointUpdate))
             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);
+        return Rx.getController(this.update).configure(options);
     }
     static get curr() {
         if (!gCurrent)
@@ -498,7 +498,7 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", void 0)
-], BlockImpl.prototype, "render", null);
+], BlockImpl.prototype, "update", null);
 function getBlockKey(block) {
     const node = block.node;
     return node.stamp >= 0 ? node.key : undefined;
@@ -580,7 +580,7 @@ function getEffectiveBlockCoords(isRegularBlock, area, maxX, maxY, cursorPositio
         throw new Error("relative layout requires sequential children");
     return result;
 }
-function runRenderNestedTreesThenDo(error, action) {
+function runUpdateNestedTreesThenDo(error, action) {
     var _a;
     const curr = BlockImpl.curr;
     const owner = curr.instance;
@@ -592,7 +592,7 @@ function runRenderNestedTreesThenDo(error, action) {
             for (const item of children.removedItems(true))
                 triggerFinalization(item, true, true);
             if (!error) {
-                const ownerIsBand = owner.isBand;
+                const ownerIsSection = owner.isSection;
                 const sequential = children.isStrict;
                 let p1 = undefined;
                 let p2 = undefined;
@@ -604,19 +604,19 @@ function runRenderNestedTreesThenDo(error, action) {
                     const block = item.instance;
                     const isRow = block.node.driver.isRow;
                     const host = isRow ? owner : hostingRow;
-                    const p = (_a = block.renderingPriority) !== null && _a !== void 0 ? _a : Priority.Realtime;
+                    const p = (_a = block.updatePriority) !== null && _a !== void 0 ? _a : Priority.Realtime;
                     mounting = markToMountIfNecessary(mounting, host, item, children, sequential);
                     if (p === Priority.Realtime)
-                        triggerRendering(item);
+                        triggerUpdate(item);
                     else if (p === Priority.Normal)
                         p1 = push(item, p1);
                     else
                         p2 = push(item, p2);
-                    if (ownerIsBand && isRow)
+                    if (ownerIsSection && isRow)
                         hostingRow = block;
                 }
                 if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
-                    promised = startIncrementalRendering(curr, children, p1, p2).then(() => action(error), e => action(e));
+                    promised = startIncrementalUpdate(curr, children, p1, p2).then(() => action(error), e => action(e));
             }
         }
         finally {
@@ -639,34 +639,34 @@ function markToMountIfNecessary(mounting, host, ties, children, sequential) {
     node.host = host;
     return mounting;
 }
-function startIncrementalRendering(owner, allChildren, priority1, priority2) {
+function startIncrementalUpdate(owner, allChildren, priority1, priority2) {
     return __awaiter(this, void 0, void 0, function* () {
         const stamp = owner.instance.node.stamp;
         if (priority1)
-            yield renderIncrementally(owner, stamp, allChildren, priority1, Priority.Normal);
+            yield updateIncrementally(owner, stamp, allChildren, priority1, Priority.Normal);
         if (priority2)
-            yield renderIncrementally(owner, stamp, allChildren, priority2, Priority.Background);
+            yield updateIncrementally(owner, stamp, allChildren, priority2, Priority.Background);
     });
 }
-function renderIncrementally(owner, stamp, allChildren, items, priority) {
+function updateIncrementally(owner, stamp, allChildren, items, priority) {
     return __awaiter(this, void 0, void 0, function* () {
         yield Transaction.requestNextFrame();
         const block = owner.instance;
         if (!Transaction.isCanceled || !Transaction.isFrameOver(1, Verstak.shortFrameDuration / 3)) {
-            let outerPriority = Verstak.currentRenderingPriority;
-            Verstak.currentRenderingPriority = priority;
+            let outerPriority = Verstak.currentUpdatePriority;
+            Verstak.currentUpdatePriority = priority;
             try {
                 if (block.childrenShuffling)
                     shuffle(items);
                 const frameDurationLimit = priority === Priority.Background ? Verstak.shortFrameDuration : Infinity;
                 let frameDuration = Math.min(frameDurationLimit, Math.max(Verstak.frameDuration / 4, Verstak.shortFrameDuration));
                 for (const child of items) {
-                    triggerRendering(child);
+                    triggerUpdate(child);
                     if (Transaction.isFrameOver(1, frameDuration)) {
-                        Verstak.currentRenderingPriority = outerPriority;
+                        Verstak.currentUpdatePriority = outerPriority;
                         yield Transaction.requestNextFrame(0);
-                        outerPriority = Verstak.currentRenderingPriority;
-                        Verstak.currentRenderingPriority = priority;
+                        outerPriority = Verstak.currentUpdatePriority;
+                        Verstak.currentUpdatePriority = priority;
                         frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, Verstak.frameDuration));
                     }
                     if (Transaction.isCanceled && Transaction.isFrameOver(1, Verstak.shortFrameDuration / 3))
@@ -674,29 +674,29 @@ function renderIncrementally(owner, stamp, allChildren, items, priority) {
                 }
             }
             finally {
-                Verstak.currentRenderingPriority = outerPriority;
+                Verstak.currentUpdatePriority = outerPriority;
             }
         }
     });
 }
-function triggerRendering(ties) {
+function triggerUpdate(ties) {
     const b = ties.instance;
     const node = b.node;
     if (node.stamp >= 0) {
-        if (b.isOn(Mode.PinpointRefresh)) {
+        if (b.isOn(Mode.PinpointUpdate)) {
             if (node.stamp === 0) {
                 Transaction.outside(() => {
                     if (Rx.isLogging)
                         Rx.setLoggingHint(b, node.key);
-                    Rx.getController(b.render).configure({
+                    Rx.getController(b.update).configure({
                         order: node.level,
                     });
                 });
             }
-            nonreactive(b.render, node.builder.triggers);
+            nonreactive(b.update, node.builder.triggers);
         }
         else
-            renderNow(ties);
+            updateNow(ties);
     }
 }
 function mountIfNecessary(block) {
@@ -714,7 +714,7 @@ function mountIfNecessary(block) {
     else if (block.isMoved && block.isAutoMountEnabled)
         nonreactive(() => driver.mount(block));
 }
-function renderNow(ties) {
+function updateNow(ties) {
     const b = ties.instance;
     const node = b.node;
     if (node.stamp >= 0) {
@@ -724,20 +724,20 @@ function renderNow(ties) {
                 mountIfNecessary(b);
                 node.stamp++;
                 node.numerator = 0;
-                b.prepareForRender();
+                b.prepareForUpdate();
                 node.children.beginMerge();
                 const driver = node.driver;
-                result = driver.render(b);
+                result = driver.update(b);
                 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); });
+                    result.then(v => { runUpdateNestedTreesThenDo(undefined, NOP); return v; }, e => { console.log(e); runUpdateNestedTreesThenDo(e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
                 else
-                    runRenderNestedTreesThenDo(undefined, NOP);
+                    runUpdateNestedTreesThenDo(undefined, NOP);
             }
             catch (e) {
-                runRenderNestedTreesThenDo(e, NOP);
-                console.log(`Rendering failed: ${node.key}`);
+                runUpdateNestedTreesThenDo(e, NOP);
+                console.log(`Update failed: ${node.key}`);
                 console.log(`${e}`);
             }
         });
@@ -749,12 +749,12 @@ function triggerFinalization(ties, isLeader, individual) {
     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}`);
+            console.log(`WARNING: it is recommended to assign explicit key for conditional 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.isOn(Mode.PinpointRefresh)) {
+        if (b.isOn(Mode.PinpointUpdate)) {
             ties.aux = undefined;
             const last = gLastToDispose;
             if (last)

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

@@ -1,6 +1,6 @@
 import { Block, BlockKind, BlockBuilder, Align, BlockCoords, BlockArea } from "../core/api";
 import { HtmlDriver } from "./HtmlDriver";
-export declare function Band<M = unknown, R = void>(builder?: BlockBuilder<HTMLElement, M, R>, base?: BlockBuilder<HTMLElement, M, R>): Block<HTMLElement, M, R>;
+export declare function Section<M = unknown, R = void>(builder?: BlockBuilder<HTMLElement, M, R>, base?: BlockBuilder<HTMLElement, M, R>): Block<HTMLElement, M, R>;
 export declare function Table<M = unknown, R = void>(builder?: BlockBuilder<HTMLElement, M, R>, base?: BlockBuilder<HTMLElement, M, R>): Block<HTMLElement, M, R>;
 export declare function row<T = void>(builder?: (block: void) => T, shiftCursorDown?: number): void;
 export declare function fromNewRow(shiftCursorDown?: number): void;
@@ -23,5 +23,5 @@ export declare class VerstakHtmlDriver<T extends HTMLElement> extends HtmlDriver
     applyContentWrapping(block: Block<T>, value: boolean): void;
     applyOverlayVisible(block: Block<T>, value: boolean | undefined): void;
     applyStyle(block: Block<T, any, any>, secondary: boolean, styleName: string, enabled?: boolean): void;
-    render(block: Block<T>): void | Promise<void>;
+    update(block: Block<T>): void | Promise<void>;
 }

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

@@ -1,7 +1,7 @@
 import { Verstak, BlockKind, Align, CursorCommandDriver, BaseDriver } from "../core/api";
 import { HtmlDriver } from "./HtmlDriver";
-export function Band(builder, base) {
-    return Verstak.claim(Drivers.band, builder, base);
+export function Section(builder, base) {
+    return Verstak.claim(Drivers.section, builder, base);
 }
 export function Table(builder, base) {
     return Verstak.claim(Drivers.table, builder, base);
@@ -15,21 +15,21 @@ export function fromNewRow(shiftCursorDown) {
 }
 export function cursor(areaParams) {
     Verstak.claim(Drivers.cursor, {
-        render(b) {
+        update(b) {
             b.area = areaParams;
         },
     });
 }
 export function Note(content, builder) {
     return Verstak.claim(Drivers.note, builder, {
-        render(b) {
+        update(b) {
             b.native.innerText = content;
         }
     });
 }
 export function HtmlNote(content, builder) {
     return Verstak.claim(Drivers.note, builder, {
-        render(b) {
+        update(b) {
             b.native.innerHTML = content;
         }
     });
@@ -177,20 +177,20 @@ export class VerstakHtmlDriver extends HtmlDriver {
         else
             e.className = enabled ? styleName : "";
     }
-    render(block) {
+    update(block) {
         if (block.kind <= BlockKind.Table)
             fromNewRow();
-        return super.render(block);
+        return super.update(block);
     }
 }
 const Constants = {
     block: "block",
     row: "row",
-    layouts: ["band", "table", "note", "group", "", ""],
+    layouts: ["section", "table", "note", "group", "", ""],
     attribute: "kind",
 };
 const Drivers = {
-    band: new VerstakHtmlDriver(Constants.block, false, b => b.kind = BlockKind.Band),
+    section: new VerstakHtmlDriver(Constants.block, false, b => b.kind = BlockKind.Section),
     table: new VerstakHtmlDriver(Constants.block, false, b => b.kind = BlockKind.Table),
     note: new VerstakHtmlDriver(Constants.block, false, b => b.kind = BlockKind.Note),
     group: new VerstakHtmlDriver(Constants.block, false, b => b.kind = BlockKind.Group),

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

@@ -1,7 +1,7 @@
 import { Verstak, StaticDriver, BlockKind } from "../core/api";
 import { HtmlDriver, SvgDriver } from "./HtmlDriver";
 export function HtmlBody(builder, base) {
-    const driver = new StaticDriver(global.document.body, "HtmlBody", false, b => b.kind = BlockKind.Band);
+    const driver = new StaticDriver(global.document.body, "HtmlBody", false, b => b.kind = BlockKind.Section);
     return Verstak.claim(driver, builder, base);
 }
 export function A(builder, base) { return Verstak.claim(HtmlTags.a, builder, base); }

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

@@ -9,7 +9,7 @@ export declare abstract class BaseHtmlDriver<T extends Element, C = unknown> ext
     finalize(block: Block<T, unknown, C>, isLeader: boolean): boolean;
     mount(block: Block<T, unknown, C>): void;
     relocate(block: Block<T, unknown, C>): void;
-    render(block: Block<T, unknown, C>): void | Promise<void>;
+    update(block: Block<T, unknown, C>): void | Promise<void>;
     static get blinkingEffectMarker(): string | undefined;
     static set blinkingEffectMarker(value: string | undefined);
     static findEffectiveHtmlBlockHost(block: Block<any>): Block<HTMLElement | SVGElement>;

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

@@ -48,10 +48,10 @@ export class BaseHtmlDriver extends BaseDriver {
     }
     relocate(block) {
     }
-    render(block) {
-        const result = super.render(block);
+    update(block) {
+        const result = super.update(block);
         if (gBlinkingEffectMarker)
-            blink(block.native, Verstak.currentRenderingPriority, block.node.stamp);
+            blink(block.native, Verstak.currentUpdatePriority, block.node.stamp);
         return result;
     }
     static get blinkingEffectMarker() {

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

@@ -3,12 +3,12 @@ import { Fragment } from "./Blocks";
 export function FocuserReaction(key, target, model, switchEditMode = undefined) {
     Fragment({
         key,
-        mode: Mode.PinpointRefresh,
+        mode: Mode.PinpointUpdate,
         triggers: { target, model },
         initialize(b) {
             b.configureReactronic({ throttling: 0 });
         },
-        render() {
+        update() {
             if (switchEditMode !== undefined) {
                 switchEditMode(model);
             }

package/package.json

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