verstak 0.22.510 → 0.22.512

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

@@ -24,23 +24,6 @@ export declare type Cells = undefined | string | number | {
     down?: number;
     verticalOverlap?: boolean;
 };
-export interface Bounds {
-    place?: string;
-    widthSpan?: number;
-    widthMin?: string;
-    widthMax?: string;
-    widthGrowth?: number;
-    widthOverlap?: boolean;
-    heightSpan?: number;
-    heightMin?: string;
-    heightMax?: string;
-    heightGrowth?: number;
-    heightOverlap?: boolean;
-    alignContent?: Align;
-    alignFrame?: Align;
-    wrapping?: boolean;
-    dangling?: boolean;
-}
 export declare class Cursor {
     static readonly UndefinedCellRange: Readonly<{
         x1: 0;

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

@@ -1,29 +1,25 @@
-import { Monitor, LoggingOptions, Item, CollectionReader } from "reactronic";
+import { LoggingOptions, Item, CollectionReader, MemberOptions } from "reactronic";
 import { CellRange } from "./CellRange";
 import { Cursor, Align, Cells } from "./Cursor";
 export declare type Callback<T = unknown> = (native: T) => void;
-export declare type Render<T = unknown, M = unknown, R = void> = (native: T, block: VBlock<T, M, R>, base: () => R) => R;
-export declare type AsyncRender<T = unknown, M = unknown> = (native: T, block: VBlock<T, M, Promise<void>>) => Promise<void>;
+export declare type Render<T = unknown, M = unknown, R = void> = (block: VBlock<T, M, R>, base: () => R) => R;
+export declare type AsyncRender<T = unknown, M = unknown> = (block: VBlock<T, M, Promise<void>>) => Promise<void>;
 export declare const enum Priority {
     SyncP0 = 0,
     AsyncP1 = 1,
     AsyncP2 = 2
 }
 export declare type Type<T> = new (...args: any[]) => T;
-export interface BlockArgs<T = unknown, M = unknown, R = void> {
+export declare type BlockBody<T = unknown, M = unknown, R = void> = Render<T, M, R> | BlockVmt<T, M, R>;
+export interface BlockVmt<T = unknown, M = unknown, R = void> {
     reacting?: boolean;
     triggers?: unknown;
-    priority?: Priority;
-    monitor?: Monitor;
-    throttling?: number;
-    logging?: Partial<LoggingOptions>;
-    shuffle?: boolean;
     initialize?: Render<T, M, R>;
     override?: Render<T, M, R>;
     render?: Render<T, M, R>;
     finalize?: Render<T, M, R>;
 }
-export declare function asComponent<T, M, R>(outer: BlockArgs<T, M, R> | undefined, base: BlockArgs<T, M, R>): BlockArgs<T, M, R>;
+export declare function asComponent<T, M, R>(outer: BlockBody<T, M, R> | undefined, base: BlockBody<T, M, R>): BlockVmt<T, M, R>;
 export declare function setContext<T extends Object>(type: Type<T>, context: T): void;
 export declare function use<T extends Object>(type: Type<T>): T;
 export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
@@ -33,7 +29,7 @@ export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     static frameDuration: number;
     abstract readonly name: string;
     abstract readonly driver: AbstractDriver<T>;
-    abstract readonly args: Readonly<BlockArgs<T, M, R>>;
+    abstract readonly body: Readonly<BlockVmt<T, M, R>>;
     abstract model: M;
     abstract cells: Cells;
     abstract widthGrowth: number;
@@ -44,20 +40,23 @@ export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     abstract heightMax: string;
     abstract alignContent: Align;
     abstract alignFrame: Align;
-    abstract wrapping: boolean;
+    abstract wrapContent: boolean;
     abstract dangling: boolean;
+    abstract shuffleChildren: boolean;
+    abstract renderingPriority?: Priority;
     abstract readonly level: number;
     abstract readonly host: VBlock;
     abstract readonly children: CollectionReader<VBlock>;
     abstract readonly item: Item<VBlock> | undefined;
     abstract readonly stamp: number;
-    abstract readonly native: T | undefined;
+    abstract readonly native: T;
     get isInitialRendering(): boolean;
+    abstract configureReactronic(options: Partial<MemberOptions>): MemberOptions;
     static root(render: () => void): 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>(name: string, driver: AbstractDriver<T> | undefined, args: BlockArgs<T, M, R>): VBlock<T, M, R>;
+    static claim<T = undefined, M = unknown, R = void>(name: string, driver: AbstractDriver<T> | undefined, body: BlockBody<T, M, R>): VBlock<T, M, R>;
     static getDefaultLoggingOptions(): LoggingOptions | undefined;
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
@@ -79,7 +78,7 @@ export declare class AbstractDriver<T> {
     get isGrid(): boolean;
     get isRow(): boolean;
     constructor(name: string, layout: LayoutKind, createCursor?: () => Cursor);
-    initialize(block: VBlock<T>, native: T | undefined): void;
+    initialize(block: VBlock<T>, native: T): void;
     finalize(block: VBlock<T>, isLeader: boolean): boolean;
     deploy(block: VBlock<T>, sequential: boolean): void;
     applyCellRange(block: VBlock<T, any, any>, cellRange: CellRange | undefined): void;
@@ -91,12 +90,12 @@ export declare class AbstractDriver<T> {
     applyHeightMax(block: VBlock<T, any, any>, heightMax: string): void;
     applyAlignContent(block: VBlock<T, any, any>, alignContent: Align): void;
     applyAlignFrame(block: VBlock<T, any, any>, alignFrame: Align): void;
-    applyWrapping(block: VBlock<T, any, any>, wrapping: boolean): void;
+    applyWrapContent(block: VBlock<T, any, any>, wrapContent: boolean): void;
     applyDangling(block: VBlock<T, any, any>, dangling: boolean): void;
     render(block: VBlock<T>): void | Promise<void>;
 }
 export declare class StaticDriver<T> extends AbstractDriver<T> {
     readonly element: T;
     constructor(element: T, name: string, layout: LayoutKind, createCursor?: () => Cursor);
-    initialize(block: VBlock<T>, element: T | undefined): void;
+    initialize(block: VBlock<T>, element: T): void;
 }

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

@@ -26,12 +26,16 @@ export var Priority;
     Priority[Priority["AsyncP2"] = 2] = "AsyncP2";
 })(Priority || (Priority = {}));
 export function asComponent(outer, base) {
+    if (outer instanceof Function)
+        outer = { render: outer };
+    if (base instanceof Function)
+        base = { render: base };
     const result = Object.assign(Object.assign(Object.assign({}, base), outer), { initialize: via(outer === null || outer === void 0 ? void 0 : outer.initialize, base.initialize), render: via(outer === null || outer === void 0 ? void 0 : outer.render, base.render), finalize: via(outer === null || outer === void 0 ? void 0 : outer.finalize, base.finalize) });
     return result;
 }
 function via(outer, base) {
     const inherited = base !== null && base !== void 0 ? base : NOP;
-    return outer ? (e, b) => outer(e, b, () => inherited(e, b)) : inherited;
+    return outer ? b => outer(b, () => inherited(b)) : inherited;
 }
 export function setContext(type, context) {
     return VBlockImpl.setContext(type, context);
@@ -44,7 +48,7 @@ export class VBlock {
         return this.stamp === 2;
     }
     static root(render) {
-        gSysRoot.instance.args.render = render;
+        gSysRoot.instance.body.render = render;
         prepareAndRunRender(gSysRoot, false, false);
     }
     static get current() {
@@ -56,8 +60,10 @@ export class VBlock {
     static runForAllBlocks(action) {
         forEachChildRecursively(gSysRoot, action);
     }
-    static claim(name, driver, args) {
+    static claim(name, driver, body) {
         var _a, _b;
+        if (body instanceof Function)
+            body = { render: body };
         let result;
         const owner = gCurrent.instance;
         const children = owner.children;
@@ -74,16 +80,16 @@ export class VBlock {
             result = ex.instance;
             if (result.driver !== driver && driver !== undefined)
                 throw new Error(`changing block driver is not yet supported: "${result.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
-            const exTriggers = (_b = result.args) === null || _b === void 0 ? void 0 : _b.triggers;
-            if (triggersAreEqual(args.triggers, exTriggers))
-                args.triggers = exTriggers;
-            result.args = args;
+            const exTriggers = (_b = result.body) === null || _b === void 0 ? void 0 : _b.triggers;
+            if (triggersAreEqual(body.triggers, exTriggers))
+                body.triggers = exTriggers;
+            result.body = body;
         }
         else {
-            result = new VBlockImpl(name, driver, owner, args);
+            result = new VBlockImpl(name, driver, owner, body);
             result.item = children.add(result);
             VBlockImpl.grandCount++;
-            if (args.reacting)
+            if (body.reacting)
                 VBlockImpl.disposableCount++;
         }
         return result;
@@ -123,14 +129,13 @@ export class AbstractDriver {
         var _a, _b;
         const b = block;
         b.native = native;
-        (_b = (_a = block.args).initialize) === null || _b === void 0 ? void 0 : _b.call(_a, native, block, NOP);
+        (_b = (_a = block.body).initialize) === null || _b === void 0 ? void 0 : _b.call(_a, block, NOP);
     }
     finalize(block, isLeader) {
         var _a, _b;
         const b = block;
-        const native = block.native;
-        (_b = (_a = block.args).finalize) === null || _b === void 0 ? void 0 : _b.call(_a, native, block, NOP);
-        b.native = undefined;
+        (_b = (_a = block.body).finalize) === null || _b === void 0 ? void 0 : _b.call(_a, block, NOP);
+        b.native = null;
         return isLeader;
     }
     deploy(block, sequential) {
@@ -153,16 +158,16 @@ export class AbstractDriver {
     }
     applyAlignFrame(block, alignFrame) {
     }
-    applyWrapping(block, wrapping) {
+    applyWrapContent(block, wrapContent) {
     }
     applyDangling(block, dangling) {
     }
     render(block) {
         var _a;
         let result;
-        const override = (_a = block.args) === null || _a === void 0 ? void 0 : _a.override;
+        const override = (_a = block.body) === null || _a === void 0 ? void 0 : _a.override;
         if (override)
-            result = override(block.native, block, NOP);
+            result = override(block, NOP);
         else
             result = invokeRenderFunction(block);
         return result;
@@ -171,8 +176,8 @@ export class AbstractDriver {
 AbstractDriver.group = new AbstractDriver("group", LayoutKind.Group);
 function invokeRenderFunction(block) {
     var _a;
-    const r = (_a = block.args.render) !== null && _a !== void 0 ? _a : NOP;
-    return r(block.native, block, NOP);
+    const r = (_a = block.body.render) !== null && _a !== void 0 ? _a : NOP;
+    return r(block, NOP);
 }
 export class StaticDriver extends AbstractDriver {
     constructor(element, name, layout, createCursor) {
@@ -198,11 +203,11 @@ __decorate([
     __metadata("design:type", Object)
 ], VBlockContext.prototype, "type", void 0);
 class VBlockImpl extends VBlock {
-    constructor(name, driver, owner, args) {
+    constructor(name, driver, owner, body) {
         super();
         this.name = name;
         this.driver = driver;
-        this.args = args;
+        this.body = body;
         this.model = undefined;
         this.assignedCells = undefined;
         this.appliedCellRange = Cursor.UndefinedCellRange;
@@ -214,8 +219,10 @@ class VBlockImpl extends VBlock {
         this.appliedHeightMax = "";
         this.appliedAlignContent = Align.Default;
         this.appliedAlignFrame = Align.Default;
-        this.appliedWrapping = false;
+        this.appliedWrapContent = false;
         this.appliedDangling = false;
+        this.shuffleChildren = false;
+        this.renderingPriority = Priority.SyncP0;
         this.level = owner.level + 1;
         this.host = owner;
         this.children = new Collection(driver.isSequential, getBlockName);
@@ -297,11 +304,11 @@ class VBlockImpl extends VBlock {
             this.appliedAlignFrame = value;
         }
     }
-    get wrapping() { return this.appliedWrapping; }
-    set wrapping(value) {
-        if (value !== this.appliedWrapping) {
-            this.driver.applyWrapping(this, value);
-            this.appliedWrapping = value;
+    get wrapContent() { return this.appliedWrapContent; }
+    set wrapContent(value) {
+        if (value !== this.appliedWrapContent) {
+            this.driver.applyWrapContent(this, value);
+            this.appliedWrapContent = value;
         }
     }
     get dangling() { return this.appliedDangling; }
@@ -311,6 +318,11 @@ class VBlockImpl extends VBlock {
             this.appliedDangling = value;
         }
     }
+    configureReactronic(options) {
+        if (this.stamp !== 1 || !this.body.reacting)
+            throw new Error("reactronic can be configured only for reacting blocks and only inside initialize");
+        return Rx.getController(this.rerender).configure(options);
+    }
     static use(type) {
         var _a, _b;
         let b = gCurrent.instance;
@@ -384,13 +396,12 @@ function runRenderNestedTreesThenDo(error, action) {
                         break;
                     const block = item.instance;
                     const driver = block.driver;
-                    const opt = block.args;
                     const host = driver.isRow ? owner : partHost;
+                    const p = (_a = block.renderingPriority) !== null && _a !== void 0 ? _a : Priority.SyncP0;
                     redeploy = markToRedeployIfNecessary(redeploy, host, item, children, sequential);
-                    const priority = (_a = opt === null || opt === void 0 ? void 0 : opt.priority) !== null && _a !== void 0 ? _a : Priority.SyncP0;
-                    if (priority === Priority.SyncP0)
+                    if (p === Priority.SyncP0)
                         prepareAndRunRender(item, children.isMoved(item), sequential);
-                    else if (priority === Priority.AsyncP1)
+                    else if (p === Priority.AsyncP1)
                         p1 = push(item, p1);
                     else
                         p2 = push(item, p2);
@@ -430,7 +441,6 @@ function startIncrementalRendering(owner, allChildren, priority1, priority2) {
     });
 }
 function renderIncrementally(owner, stamp, allChildren, items, priority) {
-    var _a;
     return __awaiter(this, void 0, void 0, function* () {
         yield Transaction.requestNextFrame();
         const block = owner.instance;
@@ -439,7 +449,7 @@ function renderIncrementally(owner, stamp, allChildren, items, priority) {
             VBlock.currentRenderingPriority = priority;
             try {
                 const sequential = block.children.strict;
-                if ((_a = block.args) === null || _a === void 0 ? void 0 : _a.shuffle)
+                if (block.shuffleChildren)
                     shuffle(items);
                 const frameDurationLimit = priority === Priority.AsyncP2 ? VBlock.shortFrameDuration : Infinity;
                 let frameDuration = Math.min(frameDurationLimit, Math.max(VBlock.frameDuration / 4, VBlock.shortFrameDuration));
@@ -467,8 +477,8 @@ function prepareAndRunRender(item, redeploy, sequential) {
     const block = item.instance;
     if (block.stamp >= 0) {
         prepareRender(item, redeploy, sequential);
-        if ((_a = block.args) === null || _a === void 0 ? void 0 : _a.reacting)
-            nonreactive(block.rerender, (_b = block.args) === null || _b === void 0 ? void 0 : _b.triggers);
+        if ((_a = block.body) === null || _a === void 0 ? void 0 : _a.reacting)
+            nonreactive(block.rerender, (_b = block.body) === null || _b === void 0 ? void 0 : _b.triggers);
         else
             runRender(item);
     }
@@ -480,16 +490,12 @@ function prepareRender(item, redeploy, sequential) {
         block.stamp = 1;
         runUnder(item, () => {
             var _a;
-            if ((_a = block.args) === null || _a === void 0 ? void 0 : _a.reacting) {
+            if ((_a = block.body) === null || _a === void 0 ? void 0 : _a.reacting) {
                 Transaction.outside(() => {
-                    var _a, _b, _c;
                     if (Rx.isLogging)
                         Rx.setLoggingHint(block, block.name);
                     Rx.getController(block.rerender).configure({
                         order: block.level,
-                        monitor: (_a = block.args) === null || _a === void 0 ? void 0 : _a.monitor,
-                        throttling: (_b = block.args) === null || _b === void 0 ? void 0 : _b.throttling,
-                        logging: (_c = block.args) === null || _c === void 0 ? void 0 : _c.logging,
                     });
                 });
             }
@@ -536,7 +542,7 @@ function runFinalize(item, isLeader) {
     if (block.stamp >= 0) {
         block.stamp = ~block.stamp;
         const childrenAreLeaders = block.driver.finalize(block, isLeader);
-        if ((_a = block.args) === null || _a === void 0 ? void 0 : _a.reacting) {
+        if ((_a = block.body) === null || _a === void 0 ? void 0 : _a.reacting) {
             item.aux = undefined;
             const last = gLastToDispose;
             if (last)
@@ -569,8 +575,8 @@ function runDisposalLoop() {
 }
 function forEachChildRecursively(item, action) {
     const block = item.instance;
-    const native = block.native;
-    native && action(native);
+    const e = block.native;
+    e && action(e);
     for (const item of block.children.items())
         forEachChildRecursively(item, action);
 }

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

@@ -1,12 +1,12 @@
-import { VBlock, BlockArgs, Align, CellRange } from "../core/api";
+import { VBlock, BlockBody, Align, CellRange } from "../core/api";
 import { HtmlDriver } from "./HtmlDriver";
-export declare function Block<M = unknown, R = void>(name: string, args: BlockArgs<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
-export declare function PlainText(content: string, name?: string, args?: BlockArgs<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
-export declare function HtmlText(content: string, name?: string, args?: BlockArgs<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
-export declare function Grid<M = unknown, R = void>(name: string, args: BlockArgs<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function Block<M = unknown, R = void>(name: string, args: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function PlainText(content: string, name?: string, args?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
+export declare function HtmlText(content: string, name?: string, args?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
+export declare function Grid<M = unknown, R = void>(name: string, body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
 export declare function Line<T = void>(claim: (x: void) => T): VBlock<HTMLElement>;
-export declare function lineFeed(args?: BlockArgs<HTMLElement, void, void>, noCoalescing?: boolean): VBlock<HTMLElement>;
-export declare function Group<M = unknown, R = void>(name: string, args: BlockArgs<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function lineFeed(body?: BlockBody<HTMLElement, void, void>, noCoalescing?: boolean): VBlock<HTMLElement>;
+export declare function Group<M = unknown, R = void>(name: string, 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;
@@ -17,7 +17,7 @@ export declare class VerstakDriver<T extends HTMLElement> extends HtmlDriver<T>
     applyHeightMax(block: VBlock<T>, heightMax: string): void;
     applyAlignContent(block: VBlock<T>, alignContent: Align): void;
     applyAlignFrame(block: VBlock<T>, alignFrame: Align): void;
-    applyWrapping(block: VBlock<T>, wrapping: boolean): void;
+    applyWrapContent(block: VBlock<T>, wrapContent: boolean): void;
     applyDangling(block: VBlock<T>, dangling: boolean): void;
     render(block: VBlock<T>): void | Promise<void>;
 }

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

@@ -5,32 +5,32 @@ export function Block(name, args) {
 }
 export function PlainText(content, name, args) {
     return VBlock.claim(name !== null && name !== void 0 ? name : "", VerstakTags.text, asComponent(args, {
-        render(e) {
-            e.innerText = content;
+        render(b) {
+            b.native.innerText = content;
         },
     }));
 }
 export function HtmlText(content, name, args) {
     return VBlock.claim(name !== null && name !== void 0 ? name : "", VerstakTags.text, asComponent(args, {
-        render(e) {
-            e.innerHTML = content;
+        render(b) {
+            b.native.innerHTML = content;
         },
     }));
 }
-export function Grid(name, args) {
-    return VBlock.claim(name, VerstakTags.grid, args);
+export function Grid(name, body) {
+    return VBlock.claim(name, VerstakTags.grid, body);
 }
 export function Line(claim) {
-    const result = VBlock.claim("", VerstakTags.row, EMPTY_RENDER);
+    const result = VBlock.claim("", VerstakTags.row, EMPTY_BLOCK_BODY);
     claim();
-    VBlock.claim("", VerstakTags.row, EMPTY_RENDER);
+    VBlock.claim("", VerstakTags.row, EMPTY_BLOCK_BODY);
     return result;
 }
-export function lineFeed(args, noCoalescing) {
-    return VBlock.claim("", VerstakTags.row, args !== null && args !== void 0 ? args : EMPTY_RENDER);
+export function lineFeed(body, noCoalescing) {
+    return VBlock.claim("", VerstakTags.row, body !== null && body !== void 0 ? body : EMPTY_BLOCK_BODY);
 }
-export function Group(name, args) {
-    return VBlock.claim(name, VerstakTags.group, args);
+export function Group(name, body) {
+    return VBlock.claim(name, VerstakTags.group, body);
 }
 export class VerstakDriver extends HtmlDriver {
     applyCellRange(block, cellRange) {
@@ -106,8 +106,8 @@ export class VerstakDriver extends HtmlDriver {
         else
             css.alignSelf = css.justifySelf = "";
     }
-    applyWrapping(block, wrapping) {
-        if (wrapping)
+    applyWrapContent(block, wrapContent) {
+        if (wrapContent)
             block.native.setAttribute("wrapping", "true");
         else
             block.native.removeAttribute("wrapping");
@@ -120,7 +120,7 @@ export class VerstakDriver extends HtmlDriver {
     }
     render(block) {
         if (block.driver.layout < LayoutKind.Row)
-            VBlock.claim("", VerstakTags.row, EMPTY_RENDER);
+            VBlock.claim("", VerstakTags.row, EMPTY_BLOCK_BODY);
         return super.render(block);
     }
 }
@@ -131,6 +131,6 @@ const VerstakTags = {
     row: new VerstakDriver("v-row", LayoutKind.Row),
     group: new VerstakDriver("v-group", LayoutKind.Group),
 };
-const EMPTY_RENDER = { render() { } };
+const EMPTY_BLOCK_BODY = { render() { } };
 const AlignToCss = ["stretch", "start", "center", "end"];
 const TextAlignCss = ["justify", "left", "center", "right"];