verstak 0.22.511 → 0.22.514

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

@@ -1,30 +1,26 @@
-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 setContext<T extends Object>(type: Type<T>, context: T): void;
+export declare function baseFor<T, M, R>(outer: BlockBody<T, M, R> | undefined, base: BlockBody<T, M, R>): BlockVmt<T, M, R>;
+export declare function defineSubTreeContext<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> {
     static readonly shortFrameDuration = 16;
@@ -33,31 +29,34 @@ 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;
-    abstract widthMin: string;
-    abstract widthMax: string;
+    abstract minWidth: string;
+    abstract maxWidth: string;
     abstract heightGrowth: number;
-    abstract heightMin: string;
-    abstract heightMax: string;
-    abstract alignContent: Align;
-    abstract alignFrame: Align;
-    abstract wrapContent: boolean;
-    abstract dangling: boolean;
+    abstract minHeight: string;
+    abstract maxHeight: string;
+    abstract contentAlignment: Align;
+    abstract frameAlignment: Align;
+    abstract contentWrapping: boolean;
+    abstract floating: boolean;
+    abstract childrenShuffling: 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,24 +78,24 @@ 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;
     applyWidthGrowth(block: VBlock<T, any, any>, widthGrowth: number): void;
-    applyWidthMin(block: VBlock<T, any, any>, widthMin: string): void;
-    applyWidthMax(block: VBlock<T, any, any>, widthMax: string): void;
+    applyMinWidth(block: VBlock<T, any, any>, minWidth: string): void;
+    applyMaxWidth(block: VBlock<T, any, any>, maxWidth: string): void;
     applyHeightGrowth(block: VBlock<T, any, any>, heightGrowth: number): void;
-    applyHeightMin(block: VBlock<T, any, any>, heightMin: string): void;
-    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;
-    applyWrapContent(block: VBlock<T, any, any>, wrapContent: boolean): void;
-    applyDangling(block: VBlock<T, any, any>, dangling: boolean): void;
+    applyMinHeight(block: VBlock<T, any, any>, minHeight: string): void;
+    applyMaxHeight(block: VBlock<T, any, any>, maxHeight: string): void;
+    applyContentAlignment(block: VBlock<T, any, any>, contentAlignment: Align): void;
+    applyFrameAlignment(block: VBlock<T, any, any>, frameAlignment: Align): void;
+    applyContentWrapping(block: VBlock<T, any, any>, contentWrapping: boolean): void;
+    applyFloating(block: VBlock<T, any, any>, floating: 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

@@ -25,16 +25,20 @@ export var Priority;
     Priority[Priority["AsyncP1"] = 1] = "AsyncP1";
     Priority[Priority["AsyncP2"] = 2] = "AsyncP2";
 })(Priority || (Priority = {}));
-export function asComponent(outer, base) {
+export function baseFor(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);
+export function defineSubTreeContext(type, context) {
+    return VBlockImpl.defineSubTreeContext(type, context);
 }
 export function use(type) {
     return VBlockImpl.use(type);
@@ -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) {
@@ -139,30 +144,30 @@ export class AbstractDriver {
     }
     applyWidthGrowth(block, widthGrowth) {
     }
-    applyWidthMin(block, widthMin) {
+    applyMinWidth(block, minWidth) {
     }
-    applyWidthMax(block, widthMax) {
+    applyMaxWidth(block, maxWidth) {
     }
     applyHeightGrowth(block, heightGrowth) {
     }
-    applyHeightMin(block, heightMin) {
+    applyMinHeight(block, minHeight) {
     }
-    applyHeightMax(block, heightMax) {
+    applyMaxHeight(block, maxHeight) {
     }
-    applyAlignContent(block, alignContent) {
+    applyContentAlignment(block, contentAlignment) {
     }
-    applyAlignFrame(block, alignFrame) {
+    applyFrameAlignment(block, frameAlignment) {
     }
-    applyWrapContent(block, wrapContent) {
+    applyContentWrapping(block, contentWrapping) {
     }
-    applyDangling(block, dangling) {
+    applyFloating(block, floating) {
     }
     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,24 +203,26 @@ __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;
         this.appliedWidthGrowth = 0;
-        this.appliedWidthMin = "";
-        this.appliedWidthMax = "";
+        this.appliedMinWidth = "";
+        this.appliedMaxWidth = "";
         this.appliedHeightGrowth = 0;
-        this.appliedHeightMin = "";
-        this.appliedHeightMax = "";
-        this.appliedAlignContent = Align.Default;
-        this.appliedAlignFrame = Align.Default;
-        this.appliedWrapContent = false;
-        this.appliedDangling = false;
+        this.appliedMinHeight = "";
+        this.appliedMaxHeight = "";
+        this.appliedContentAlignment = Align.Default;
+        this.appliedFrameAlignment = Align.Default;
+        this.appliedContentWrapping = false;
+        this.appliedFloating = false;
+        this.childrenShuffling = false;
+        this.renderingPriority = Priority.SyncP0;
         this.level = owner.level + 1;
         this.host = owner;
         this.children = new Collection(driver.isSequential, getBlockName);
@@ -248,18 +255,18 @@ class VBlockImpl extends VBlock {
             this.appliedWidthGrowth = value;
         }
     }
-    get widthMin() { return this.appliedWidthMin; }
-    set widthMin(value) {
-        if (value !== this.appliedWidthMin) {
-            this.driver.applyWidthMin(this, value);
-            this.appliedWidthMin = value;
+    get minWidth() { return this.appliedMinWidth; }
+    set minWidth(value) {
+        if (value !== this.appliedMinWidth) {
+            this.driver.applyMinWidth(this, value);
+            this.appliedMinWidth = value;
         }
     }
-    get widthMax() { return this.appliedWidthMax; }
-    set widthMax(value) {
-        if (value !== this.appliedWidthMax) {
-            this.driver.applyWidthMax(this, value);
-            this.appliedWidthMax = value;
+    get maxWidth() { return this.appliedMaxWidth; }
+    set maxWidth(value) {
+        if (value !== this.appliedMaxWidth) {
+            this.driver.applyMaxWidth(this, value);
+            this.appliedMaxWidth = value;
         }
     }
     get heightGrowth() { return this.appliedHeightGrowth; }
@@ -269,48 +276,53 @@ class VBlockImpl extends VBlock {
             this.appliedHeightGrowth = value;
         }
     }
-    get heightMin() { return this.appliedHeightMin; }
-    set heightMin(value) {
-        if (value !== this.appliedWidthMin) {
-            this.driver.applyWidthMin(this, value);
-            this.appliedWidthMin = value;
+    get minHeight() { return this.appliedMinHeight; }
+    set minHeight(value) {
+        if (value !== this.appliedMinWidth) {
+            this.driver.applyMinWidth(this, value);
+            this.appliedMinWidth = value;
         }
     }
-    get heightMax() { return this.appliedHeightMax; }
-    set heightMax(value) {
-        if (value !== this.appliedWidthMax) {
-            this.driver.applyWidthMax(this, value);
-            this.appliedWidthMax = value;
+    get maxHeight() { return this.appliedMaxHeight; }
+    set maxHeight(value) {
+        if (value !== this.appliedMaxWidth) {
+            this.driver.applyMaxWidth(this, value);
+            this.appliedMaxWidth = value;
         }
     }
-    get alignContent() { return this.appliedAlignContent; }
-    set alignContent(value) {
-        if (value !== this.appliedAlignContent) {
-            this.driver.applyAlignContent(this, value);
-            this.appliedAlignContent = value;
+    get contentAlignment() { return this.appliedContentAlignment; }
+    set contentAlignment(value) {
+        if (value !== this.appliedContentAlignment) {
+            this.driver.applyContentAlignment(this, value);
+            this.appliedContentAlignment = value;
         }
     }
-    get alignFrame() { return this.appliedAlignFrame; }
-    set alignFrame(value) {
-        if (value !== this.appliedAlignFrame) {
-            this.driver.applyAlignFrame(this, value);
-            this.appliedAlignFrame = value;
+    get frameAlignment() { return this.appliedFrameAlignment; }
+    set frameAlignment(value) {
+        if (value !== this.appliedFrameAlignment) {
+            this.driver.applyFrameAlignment(this, value);
+            this.appliedFrameAlignment = value;
         }
     }
-    get wrapContent() { return this.appliedWrapContent; }
-    set wrapContent(value) {
-        if (value !== this.appliedWrapContent) {
-            this.driver.applyWrapContent(this, value);
-            this.appliedWrapContent = value;
+    get contentWrapping() { return this.appliedContentWrapping; }
+    set contentWrapping(value) {
+        if (value !== this.appliedContentWrapping) {
+            this.driver.applyContentWrapping(this, value);
+            this.appliedContentWrapping = value;
         }
     }
-    get dangling() { return this.appliedDangling; }
-    set dangling(value) {
-        if (value !== this.appliedDangling) {
-            this.driver.applyDangling(this, value);
-            this.appliedDangling = value;
+    get floating() { return this.appliedFloating; }
+    set floating(value) {
+        if (value !== this.appliedFloating) {
+            this.driver.applyFloating(this, value);
+            this.appliedFloating = 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;
@@ -320,7 +332,7 @@ class VBlockImpl extends VBlock {
             throw new Error(`${type.name} context doesn't exist`);
         return (_b = b.context) === null || _b === void 0 ? void 0 : _b.instance;
     }
-    static setContext(type, context) {
+    static defineSubTreeContext(type, context) {
         const block = gCurrent.instance;
         const host = block.host;
         const hostCtx = nonreactive(() => { var _a; return (_a = host.context) === null || _a === void 0 ? void 0 : _a.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.childrenShuffling)
                     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,23 +1,23 @@
-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, body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function PlainText(content: string, name?: string, body?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
+export declare function HtmlText(content: string, name?: string, body?: 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;
-    applyWidthMin(block: VBlock<T>, widthMin: string): void;
-    applyWidthMax(block: VBlock<T>, widthMax: string): void;
+    applyMinWidth(block: VBlock<T>, minWidth: string): void;
+    applyMaxWidth(block: VBlock<T>, maxWidth: string): void;
     applyHeightGrowth(block: VBlock<T>, heightGrowth: number): void;
-    applyHeightMin(block: VBlock<T>, heightMin: string): void;
-    applyHeightMax(block: VBlock<T>, heightMax: string): void;
-    applyAlignContent(block: VBlock<T>, alignContent: Align): void;
-    applyAlignFrame(block: VBlock<T>, alignFrame: Align): void;
-    applyWrapContent(block: VBlock<T>, wrapContent: boolean): void;
-    applyDangling(block: VBlock<T>, dangling: boolean): void;
+    applyMinHeight(block: VBlock<T>, minHeight: string): void;
+    applyMaxHeight(block: VBlock<T>, maxHeight: string): void;
+    applyContentAlignment(block: VBlock<T>, contentAlign: Align): void;
+    applyFrameAlignment(block: VBlock<T>, frameAlign: Align): void;
+    applyContentWrapping(block: VBlock<T>, contentWrapping: boolean): void;
+    applyFloating(block: VBlock<T>, floating: boolean): void;
     render(block: VBlock<T>): void | Promise<void>;
 }