verstak 0.23.106 → 0.23.107

package/README.md

@@ -6,7 +6,7 @@
 # **Verstak** - Experimental Front-End Library
 
 Verstak is an experimental JavaScript library that provides
-grid-based layout and
+chain-based an table-based layouts with
 [transactional reactive](https://blog.nezaboodka.com/post/2019/593-modern-database-should-natively-support-transactionally-reactive-programming)
 facilities for building front-end applications.
 

package/build/dist/source/archive/RxDomV1.js

@@ -33,18 +33,19 @@ export class BasicNodeType {
             throw new Error("element must be initialized before rendering");
         if (inst.buffer)
             throw new Error("rendering re-entrance is not supported yet");
+        const native = inst.native;
         inst.buffer = [];
         let result;
         if (node.superRender)
             result = node.superRender(options => {
-                const res = node.render(inst.native, options);
+                const res = node.render(native, options);
                 if (res instanceof Promise)
                     return res.then();
                 else
                     return options;
-            }, inst.native);
+            }, native);
         else
-            result = node.render(inst.native, args);
+            result = node.render(native, args);
         if (result instanceof Promise)
             result = result.then(value => { RxDom.renderChildrenThenDo(NOP); return value; }, error => { console.log(error); RxDom.renderChildrenThenDo(NOP); });
         else

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

@@ -2,12 +2,13 @@ import { CellRange } from "./CellRange";
 export declare enum Align {
     Stretch = 0,
     Left = 1,
-    Center = 2,
+    CenterX = 2,
     Right = 3,
     Top = 4,
-    CenterV = 8,
+    CenterY = 8,
     Bottom = 12,
-    Default = 16
+    Default = 16,
+    Center = 10
 }
 export interface ElasticSize {
     cells?: number;
@@ -18,7 +19,7 @@ export interface ElasticSize {
 export interface TrackSize extends ElasticSize {
     track?: string | number;
 }
-export type Bounds = undefined | string | number | {
+export type Placement = undefined | string | {
     widthInCells?: number;
     heightInCells?: number;
     widthOverlap?: boolean;
@@ -32,10 +33,10 @@ export declare class Cursor {
         y2: 0;
     }>;
     reset(): void;
-    onwards(bounds: Bounds): CellRange;
-    lineFeed(): void;
+    onwards(placement: Placement): CellRange;
+    rowBreak(): void;
 }
-export declare class GridCursor extends Cursor {
+export declare class TableCursor extends Cursor {
     private maxColumnCount;
     private maxRowCount;
     private actualColumnCount;
@@ -44,6 +45,6 @@ export declare class GridCursor extends Cursor {
     private rowCursor;
     private newRowCursor;
     reset(): void;
-    onwards(bounds: Bounds): CellRange;
-    lineFeed(): void;
+    onwards(placement: Placement): CellRange;
+    rowBreak(): void;
 }

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

@@ -3,20 +3,21 @@ export var Align;
 (function (Align) {
     Align[Align["Stretch"] = 0] = "Stretch";
     Align[Align["Left"] = 1] = "Left";
-    Align[Align["Center"] = 2] = "Center";
+    Align[Align["CenterX"] = 2] = "CenterX";
     Align[Align["Right"] = 3] = "Right";
     Align[Align["Top"] = 4] = "Top";
-    Align[Align["CenterV"] = 8] = "CenterV";
+    Align[Align["CenterY"] = 8] = "CenterY";
     Align[Align["Bottom"] = 12] = "Bottom";
     Align[Align["Default"] = 16] = "Default";
+    Align[Align["Center"] = 10] = "Center";
 })(Align || (Align = {}));
 export class Cursor {
     reset() { }
-    onwards(bounds) { return Cursor.UndefinedCellRange; }
-    lineFeed() { }
+    onwards(placement) { return Cursor.UndefinedCellRange; }
+    rowBreak() { }
 }
 Cursor.UndefinedCellRange = Object.freeze({ x1: 0, y1: 0, x2: 0, y2: 0 });
-export class GridCursor extends Cursor {
+export class TableCursor extends Cursor {
     constructor() {
         super(...arguments);
         this.maxColumnCount = 0;
@@ -36,11 +37,11 @@ export class GridCursor extends Cursor {
         this.rowCursor = 0;
         this.newRowCursor = 0;
     }
-    onwards(bounds) {
+    onwards(placement) {
         var _a, _b, _c, _d;
         let result;
-        if (typeof (bounds) === "string") {
-            result = parseCellRange(bounds, { x1: 0, y1: 0, x2: 0, y2: 0 });
+        if (typeof (placement) === "string") {
+            result = parseCellRange(placement, { x1: 0, y1: 0, x2: 0, y2: 0 });
             absolutizeCellRange(result, this.columnCursor + 1, this.rowCursor + 1, this.maxColumnCount || Infinity, this.maxRowCount || Infinity, result);
         }
         else {
@@ -48,16 +49,11 @@ export class GridCursor extends Cursor {
             let h;
             let wOverlap;
             let hOverlap;
-            if (typeof (bounds) === "number") {
-                w = bounds;
-                h = 1;
-                wOverlap = hOverlap = false;
-            }
-            else if (bounds) {
-                w = (_a = bounds.widthInCells) !== null && _a !== void 0 ? _a : 1;
-                h = (_b = bounds.heightInCells) !== null && _b !== void 0 ? _b : 1;
-                wOverlap = (_c = bounds.widthOverlap) !== null && _c !== void 0 ? _c : false;
-                hOverlap = (_d = bounds.heightOverlap) !== null && _d !== void 0 ? _d : false;
+            if (placement) {
+                w = (_a = placement.widthInCells) !== null && _a !== void 0 ? _a : 1;
+                h = (_b = placement.heightInCells) !== null && _b !== void 0 ? _b : 1;
+                wOverlap = (_c = placement.widthOverlap) !== null && _c !== void 0 ? _c : false;
+                hOverlap = (_d = placement.heightOverlap) !== null && _d !== void 0 ? _d : false;
             }
             else {
                 w = 1;
@@ -94,7 +90,7 @@ export class GridCursor extends Cursor {
         }
         return result;
     }
-    lineFeed() {
+    rowBreak() {
         this.columnCursor = 0;
         this.rowCursor = this.newRowCursor;
     }

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

@@ -1,34 +1,37 @@
 import { LoggingOptions, Item, CollectionReader, MemberOptions } from "reactronic";
 import { CellRange } from "./CellRange";
-import { Cursor, Align, Bounds } from "./Cursor";
+import { Align, Placement } from "./Cursor";
 export type Callback<T = unknown> = (native: T) => void;
-export type Operation<T = unknown, M = unknown, R = void> = (block: VBlock<T, M, R>, base: () => R) => R;
+export type Operation<T = unknown, M = unknown, C = unknown, R = void> = (block: VBlock<T, M, C, R>, base: () => R) => R;
 export type AsyncOperation<T = unknown, M = unknown> = (block: VBlock<T, M, Promise<void>>) => Promise<void>;
+export type SimpleOperation<T = unknown> = (block: VBlock<T, any, any, any>) => void;
 export declare const enum Priority {
     Realtime = 0,
     Normal = 1,
     Background = 2
 }
-export interface BlockBody<T = unknown, M = unknown, R = void> {
-    base?: BlockBody<T, M, R>;
+export interface BlockBuilder<T = unknown, M = unknown, C = unknown, R = void> {
+    base?: BlockBuilder<T, M, C, R>;
     key?: string;
     reaction?: boolean;
     triggers?: unknown;
-    initialize?: Operation<T, M, R>;
-    render?: Operation<T, M, R>;
-    finalize?: Operation<T, M, R>;
+    claim?: Operation<T, M, C, R>;
+    initialize?: Operation<T, M, C, R>;
+    render?: Operation<T, M, C, R>;
+    finalize?: Operation<T, M, C, R>;
 }
-export declare function Fragment<M = unknown, R = void>(body?: BlockBody<void, M, R>, base?: BlockBody<void, M, R>): VBlock<void, M, R>;
-export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
+export declare function Fragment<M = unknown, R = void>(builder?: BlockBuilder<void, M, R>, base?: BlockBuilder<void, M, R>): VBlock<void, M, R>;
+export declare abstract class VBlock<T = unknown, M = unknown, C = unknown, R = void> {
     static readonly shortFrameDuration = 16;
     static readonly longFrameDuration = 300;
     static currentRenderingPriority: Priority;
     static frameDuration: number;
     abstract readonly key: string;
-    abstract readonly driver: AbstractDriver<T>;
-    abstract readonly body: Readonly<BlockBody<T, M, R>>;
+    abstract readonly driver: Driver<T>;
+    abstract readonly builder: Readonly<BlockBuilder<T, M, C, R>>;
     abstract model: M;
-    abstract bounds: Bounds;
+    abstract childrenLayout: Layout;
+    abstract placement: Placement;
     abstract widthGrowth: number;
     abstract minWidth: string;
     abstract maxWidth: string;
@@ -36,7 +39,7 @@ export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     abstract minHeight: string;
     abstract maxHeight: string;
     abstract contentAlignment: Align;
-    abstract frameAlignment: Align;
+    abstract blockAlignment: Align;
     abstract contentWrapping: boolean;
     abstract overlayVisible: boolean | undefined;
     abstract childrenShuffling: boolean;
@@ -48,56 +51,61 @@ export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     abstract readonly item: Item<VBlock> | undefined;
     abstract readonly stamp: number;
     abstract readonly native: T;
+    abstract readonly controller: C;
     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>(driver: AbstractDriver<T>, body?: BlockBody<T, M, R>, base?: BlockBody<T, M, R>): VBlock<T, M, R>;
+    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>): VBlock<T, M, C, R>;
     private static generateKey;
     static getDefaultLoggingOptions(): LoggingOptions | undefined;
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
-export declare enum LayoutKind {
-    Block = 0,
-    Grid = 1,
-    Line = 2,
-    Fragment = 3,
-    Text = 4
+export declare enum Layout {
+    Section = 0,
+    Table = 1,
+    Row = 2,
+    Group = 3,
+    Note = 4
 }
-export declare class AbstractDriver<T> {
-    static readonly fragment: AbstractDriver<any>;
+export declare class Driver<T, C = unknown> {
     readonly name: string;
-    readonly layout: LayoutKind;
-    readonly createCursor: () => Cursor;
-    get isSequential(): boolean;
-    get isAuxiliary(): boolean;
-    get isBlock(): boolean;
-    get isGrid(): boolean;
-    get isLine(): boolean;
-    constructor(name: string, layout: LayoutKind, createCursor?: () => Cursor);
-    initialize(block: VBlock<T>, native: T): void;
-    deploy(block: VBlock<T>): void;
-    render(block: VBlock<T>): void | Promise<void>;
-    finalize(block: VBlock<T>, isLeader: boolean): boolean;
-    applyCellRange(block: VBlock<T, any, any>, cellRange: CellRange | undefined): void;
-    applyWidthGrowth(block: VBlock<T, any, any>, widthGrowth: number): 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;
-    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;
-    applyOverlayVisible(block: VBlock<T, any, any>, overlayVisible: boolean | undefined): void;
-    applyStyling(block: VBlock<T, any, any>, secondary: boolean, styleName: string, enabled?: boolean): void;
+    readonly isRow: boolean;
+    readonly preset?: SimpleOperation<T> | undefined;
+    static readonly fragment: Driver<any, unknown>;
+    constructor(name: string, isRow: boolean, preset?: SimpleOperation<T> | undefined);
+    create(block: VBlock<T, unknown, C>, b: {
+        native?: T;
+        controller?: C;
+    }): void;
+    claim(block: VBlock<T, unknown, C>): void;
+    initialize(block: VBlock<T, unknown, C>): void;
+    deploy(block: VBlock<T, unknown, C>): void;
+    render(block: VBlock<T, unknown, C>): void | Promise<void>;
+    finalize(block: VBlock<T, unknown, C>, isLeader: boolean): boolean;
+    applyChildrenLayout(block: VBlock<T, any, C, any>, value: Layout): void;
+    applyCellRange(block: VBlock<T, any, C, any>, value: CellRange | undefined): void;
+    applyWidthGrowth(block: VBlock<T, any, C, any>, value: number): void;
+    applyMinWidth(block: VBlock<T, any, C, any>, value: string): void;
+    applyMaxWidth(block: VBlock<T, any, C, any>, value: string): void;
+    applyHeightGrowth(block: VBlock<T, any, C, any>, value: number): void;
+    applyMinHeight(block: VBlock<T, any, C, any>, value: string): void;
+    applyMaxHeight(block: VBlock<T, any, C, any>, value: string): void;
+    applyContentAlignment(block: VBlock<T, any, C, any>, value: Align): void;
+    applyBlockAlignment(block: VBlock<T, any, C, any>, value: Align): void;
+    applyContentWrapping(block: VBlock<T, any, C, any>, value: boolean): void;
+    applyOverlayVisible(block: VBlock<T, any, C, any>, value: boolean | undefined): void;
+    applyStyle(block: VBlock<T, any, C, any>, secondary: boolean, styleName: string, enabled?: boolean): void;
 }
-export declare class StaticDriver<T> extends AbstractDriver<T> {
+export declare class StaticDriver<T> extends Driver<T> {
     readonly element: T;
-    constructor(element: T, name: string, layout: LayoutKind, createCursor?: () => Cursor);
-    initialize(block: VBlock<T>, element: T): void;
+    constructor(element: T, name: string, isRow: boolean, preset?: SimpleOperation<T>);
+    create(block: VBlock<T, unknown, unknown, void>, b: {
+        native?: T;
+        controller?: unknown;
+    }): void;
 }
 export declare class ContextVariable<T extends Object = Object> {
     readonly defaultValue: T | undefined;