verstak 0.22.508 → 0.22.510

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

@@ -6,3 +6,4 @@ export interface CellRange {
 }
 export declare function parseCellRange(text: string, result: CellRange): CellRange;
 export declare function emitCellRange(value: CellRange): string;
+export declare function equalCellRanges(a: CellRange, b: CellRange): boolean;

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

@@ -134,6 +134,9 @@ export function emitCellRange(value) {
     const p2 = emitCellPosition(value.x2, value.y2);
     return `${p1}${p2 !== "" ? `:${p2}` : ""}`;
 }
+export function equalCellRanges(a, b) {
+    return a.x1 === b.x1 && a.y1 === b.y1 && a.x2 === b.x2 && a.y1 === b.y2;
+}
 function isWhitespace(char) {
     return char === 32 || (char >= 9 && char <= 13) || char === 133 || char === 160;
 }

package/build/dist/source/core/{Allocator.d.ts → Cursor.d.ts}

@@ -1,6 +1,6 @@
 import { CellRange } from "./CellRange";
-export declare enum To {
-    Fit = 0,
+export declare enum Align {
+    Stretch = 0,
     Left = 1,
     Center = 2,
     Right = 3,
@@ -18,6 +18,12 @@ export interface ElasticSize {
 export interface TrackSize extends ElasticSize {
     track?: string | number;
 }
+export declare type Cells = undefined | string | number | {
+    right?: number;
+    horizontalOverlap?: boolean;
+    down?: number;
+    verticalOverlap?: boolean;
+};
 export interface Bounds {
     place?: string;
     widthSpan?: number;
@@ -30,28 +36,23 @@ export interface Bounds {
     heightMax?: string;
     heightGrowth?: number;
     heightOverlap?: boolean;
-    alignContent?: To;
-    alignFrame?: To;
-    flowWrap?: boolean;
+    alignContent?: Align;
+    alignFrame?: Align;
+    wrapping?: boolean;
+    dangling?: boolean;
 }
-export interface Place {
-    exact: CellRange | undefined;
-    widthMin: string;
-    widthMax: string;
-    widthGrowth: number;
-    heightMin: string;
-    heightMax: string;
-    heightGrowth: number;
-    alignContent: To;
-    alignFrame: To;
-    flowWrap: boolean;
-}
-export declare class Allocator {
+export declare class Cursor {
+    static readonly UndefinedCellRange: Readonly<{
+        x1: 0;
+        y1: 0;
+        x2: 0;
+        y2: 0;
+    }>;
     reset(): void;
+    onwards(cells: Cells): CellRange;
     lineFeed(): void;
-    allocate(bounds: Bounds | undefined): Place | undefined;
 }
-export declare class GridBasedAllocator implements Allocator {
+export declare class GridCursor extends Cursor {
     private maxColumnCount;
     private maxRowCount;
     private actualColumnCount;
@@ -60,7 +61,6 @@ export declare class GridBasedAllocator implements Allocator {
     private rowCursor;
     private newRowCursor;
     reset(): void;
+    onwards(cells: Cells): CellRange;
     lineFeed(): void;
-    allocate(bounds: Bounds | undefined): Place | undefined;
 }
-export declare function equalPlaces(a: Place | undefined, b: Place | undefined): boolean;

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

@@ -0,0 +1,125 @@
+import { parseCellRange } from "./CellRange";
+export var Align;
+(function (Align) {
+    Align[Align["Stretch"] = 0] = "Stretch";
+    Align[Align["Left"] = 1] = "Left";
+    Align[Align["Center"] = 2] = "Center";
+    Align[Align["Right"] = 3] = "Right";
+    Align[Align["Top"] = 4] = "Top";
+    Align[Align["CenterV"] = 8] = "CenterV";
+    Align[Align["Bottom"] = 12] = "Bottom";
+    Align[Align["Default"] = 16] = "Default";
+})(Align || (Align = {}));
+export class Cursor {
+    reset() { }
+    onwards(cells) { return Cursor.UndefinedCellRange; }
+    lineFeed() { }
+}
+Cursor.UndefinedCellRange = Object.freeze({ x1: 0, y1: 0, x2: 0, y2: 0 });
+export class GridCursor extends Cursor {
+    constructor() {
+        super(...arguments);
+        this.maxColumnCount = 0;
+        this.maxRowCount = 0;
+        this.actualColumnCount = 0;
+        this.actualRowCount = 0;
+        this.columnCursor = 0;
+        this.rowCursor = 0;
+        this.newRowCursor = 0;
+    }
+    reset() {
+        this.maxColumnCount = 0;
+        this.maxRowCount = 0;
+        this.actualColumnCount = 0;
+        this.actualRowCount = 0;
+        this.columnCursor = 0;
+        this.rowCursor = 0;
+        this.newRowCursor = 0;
+    }
+    onwards(cells) {
+        var _a, _b, _c, _d;
+        let result;
+        if (typeof (cells) === "string") {
+            result = parseCellRange(cells, { x1: 0, y1: 0, x2: 0, y2: 0 });
+            absolutizeCellRange(result, this.columnCursor + 1, this.rowCursor + 1, this.maxColumnCount || Infinity, this.maxRowCount || Infinity, result);
+        }
+        else {
+            let columns;
+            let rows;
+            let columnsOverlap;
+            let rowsOverlap;
+            if (typeof (cells) === "number") {
+                columns = cells;
+                rows = 1;
+                columnsOverlap = rowsOverlap = false;
+            }
+            else if (cells) {
+                columns = (_a = cells.right) !== null && _a !== void 0 ? _a : 1;
+                rows = (_b = cells.down) !== null && _b !== void 0 ? _b : 1;
+                columnsOverlap = (_c = cells.horizontalOverlap) !== null && _c !== void 0 ? _c : false;
+                rowsOverlap = (_d = cells.verticalOverlap) !== null && _d !== void 0 ? _d : false;
+            }
+            else {
+                columns = 1;
+                rows = 1;
+                columnsOverlap = rowsOverlap = false;
+            }
+            const totalColumnCount = this.maxColumnCount !== 0 ? this.maxColumnCount : this.actualColumnCount;
+            const totalRowCount = this.maxRowCount !== 0 ? this.maxRowCount : this.actualRowCount;
+            result = { x1: 0, y1: 0, x2: 0, y2: 0 };
+            if (columns === 0)
+                columns = totalColumnCount || 1;
+            if (columns >= 0) {
+                result.x1 = this.columnCursor + 1;
+                result.x2 = absolutizePosition(result.x1 + columns - 1, 0, this.maxColumnCount || Infinity);
+                if (!columnsOverlap)
+                    this.columnCursor = result.x2;
+            }
+            else {
+                result.x1 = Math.max(this.columnCursor + columns, 1);
+                result.x2 = this.columnCursor;
+            }
+            if (rows === 0)
+                rows = totalRowCount || 1;
+            if (rows >= 0) {
+                result.y1 = this.rowCursor + 1;
+                result.y2 = absolutizePosition(result.y1 + rows - 1, 0, this.maxRowCount || Infinity);
+                if (!rowsOverlap && result.y2 > this.newRowCursor)
+                    this.newRowCursor = result.y2;
+            }
+            else {
+                result.y1 = Math.max(this.rowCursor + rows, 1);
+                result.y2 = this.rowCursor;
+            }
+        }
+        return result;
+    }
+    lineFeed() {
+        this.columnCursor = 0;
+        this.rowCursor = this.newRowCursor;
+    }
+}
+function absolutizeCellRange(area, cursorX, cursorY, maxWidth, maxHeight, result) {
+    const x1 = absolutizePosition(area.x1, cursorX, maxWidth);
+    const x2 = absolutizePosition(area.x2, x1, maxWidth);
+    if (x1 <= x2)
+        result.x1 = x1, result.x2 = x2;
+    else
+        result.x1 = x2, result.x2 = x1;
+    const y1 = absolutizePosition(area.y1, cursorY, maxHeight);
+    const y2 = absolutizePosition(area.y2, y1, maxHeight);
+    if (y1 <= y2)
+        result.y1 = y1, result.y2 = y2;
+    else
+        result.y1 = y2, result.y2 = y1;
+    return result;
+}
+function absolutizePosition(pos, cursor, max) {
+    if (pos === 0)
+        pos = cursor;
+    else if (pos < 0)
+        pos = Math.max(max + pos, 1);
+    else
+        pos = Math.min(pos, max);
+    return pos;
+}

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

@@ -1,14 +1,16 @@
 import { Monitor, LoggingOptions, Item, CollectionReader } from "reactronic";
-import { Bounds, Place, Allocator } from "./Allocator";
+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>) => R;
+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 const enum Priority {
     SyncP0 = 0,
     AsyncP1 = 1,
     AsyncP2 = 2
 }
-export interface BlockArgs<T = unknown, M = unknown, R = void> extends Bounds {
+export declare type Type<T> = new (...args: any[]) => T;
+export interface BlockArgs<T = unknown, M = unknown, R = void> {
     reacting?: boolean;
     triggers?: unknown;
     priority?: Priority;
@@ -16,13 +18,14 @@ export interface BlockArgs<T = unknown, M = unknown, R = void> extends Bounds {
     throttling?: number;
     logging?: Partial<LoggingOptions>;
     shuffle?: boolean;
-    initialize?: Render<T, M, R> | Array<Render<T, M, R>>;
+    initialize?: Render<T, M, R>;
     override?: Render<T, M, R>;
-    render: Render<T, M, R>;
-    finalize?: Render<T, M, R> | Array<Render<T, M, R>>;
+    render?: Render<T, M, R>;
+    finalize?: Render<T, M, R>;
 }
-export declare function setContext<T extends Object>(type: new (...args: any[]) => T, context: T): void;
-export declare function use<T extends Object>(type: new (...args: any[]) => T): T;
+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 use<T extends Object>(type: Type<T>): T;
 export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     static readonly shortFrameDuration = 16;
     static readonly longFrameDuration = 300;
@@ -32,27 +35,36 @@ export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     abstract readonly driver: AbstractDriver<T>;
     abstract readonly args: Readonly<BlockArgs<T, M, R>>;
     abstract model: M;
+    abstract cells: Cells;
+    abstract widthGrowth: number;
+    abstract widthMin: string;
+    abstract widthMax: string;
+    abstract heightGrowth: number;
+    abstract heightMin: string;
+    abstract heightMax: string;
+    abstract alignContent: Align;
+    abstract alignFrame: Align;
+    abstract wrapping: boolean;
+    abstract dangling: boolean;
     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 place: Readonly<Place> | undefined;
-    render(): R;
     get isInitialRendering(): boolean;
     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, C = void>(name: string, args: BlockArgs<T, M, R>, driver?: AbstractDriver<T>): VBlock<T, M, R>;
+    static claim<T = undefined, M = unknown, R = void>(name: string, driver: AbstractDriver<T> | undefined, args: BlockArgs<T, M, R>): VBlock<T, M, R>;
     static getDefaultLoggingOptions(): LoggingOptions | undefined;
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
 export declare enum LayoutKind {
     Block = 0,
     Grid = 1,
-    Part = 2,
+    Row = 2,
     Group = 3,
     Text = 4
 }
@@ -60,21 +72,31 @@ export declare class AbstractDriver<T> {
     static readonly group: AbstractDriver<any>;
     readonly name: string;
     readonly layout: LayoutKind;
-    readonly createAllocator: () => Allocator;
+    readonly createCursor: () => Cursor;
     get isSequential(): boolean;
     get isAuxiliary(): boolean;
     get isBlock(): boolean;
     get isGrid(): boolean;
-    get isPart(): boolean;
-    constructor(name: string, layout: LayoutKind, createAllocator?: () => Allocator);
+    get isRow(): boolean;
+    constructor(name: string, layout: LayoutKind, createCursor?: () => Cursor);
     initialize(block: VBlock<T>, native: T | undefined): void;
     finalize(block: VBlock<T>, isLeader: boolean): boolean;
     deploy(block: VBlock<T>, sequential: boolean): void;
-    arrange(block: VBlock<T>, place: Place | undefined, heightGrowth: number | undefined): 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;
+    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;
+    applyWrapping(block: VBlock<T, any, any>, wrapping: 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, createAllocator?: () => Allocator);
+    constructor(element: T, name: string, layout: LayoutKind, createCursor?: () => Cursor);
     initialize(block: VBlock<T>, element: T | undefined): void;
 }