verstak 0.22.500 → 0.22.504

package/build/dist/source/api.d.ts

@@ -1,2 +1,2 @@
-export * from './core/api';
-export * from './html/api';
+export * from "./core/api";
+export * from "./html/api";

package/build/dist/source/api.js

@@ -1,2 +1,2 @@
-export * from './core/api';
-export * from './html/api';
+export * from "./core/api";
+export * from "./html/api";

package/build/dist/source/archive/RxDomV1.d.ts

@@ -1,4 +1,4 @@
-import { Render, SuperRender, RxNodeType, RxNodeInstance, RxNode } from './RxDomV1.Types';
+import { Render, SuperRender, RxNodeType, RxNodeInstance, RxNode } from "./RxDomV1.Types";
 export declare class BasicNodeType<E, O> implements RxNodeType<E, O> {
     readonly name: string;
     readonly sequential: boolean;

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

@@ -16,8 +16,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { reactive, nonreactive, Transaction, Rx, options, Reentrance } from 'reactronic';
-import { RxNode } from './RxDomV1.Types';
+import { reactive, nonreactive, Transaction, Rx, options, Reentrance } from "reactronic";
+import { RxNode } from "./RxDomV1.Types";
 export class BasicNodeType {
     constructor(name, sequential) {
         this.name = name;
@@ -30,9 +30,9 @@ export class BasicNodeType {
     render(node, args) {
         const inst = node.instance;
         if (!inst)
-            throw new Error('element must be initialized before rendering');
+            throw new Error("element must be initialized before rendering");
         if (inst.buffer)
-            throw new Error('rendering re-entrance is not supported yet');
+            throw new Error("rendering re-entrance is not supported yet");
         inst.buffer = [];
         let result;
         if (node.superRender)
@@ -96,7 +96,7 @@ export class RxDom {
     static Root(render) {
         const inst = SYSTEM.instance;
         if (inst.buffer)
-            throw new Error('rendering re-entrance is not supported yet');
+            throw new Error("rendering re-entrance is not supported yet");
         inst.buffer = [];
         let result = render();
         if (result instanceof Promise)
@@ -110,14 +110,14 @@ export class RxDom {
         const o = creator !== null && creator !== void 0 ? creator : gCreator;
         const inst = o.instance;
         if (!inst)
-            throw new Error('element must be initialized before children');
+            throw new Error("element must be initialized before children");
         if (type === undefined)
             type = RxDom.basic;
         if (!host)
             host = gHost;
         const node = new RxNode(id, args, render, superRender, 0, false, type, inline !== null && inline !== void 0 ? inline : false, o, host);
         if (inst.buffer === undefined)
-            throw new Error('children are rendered already');
+            throw new Error("children are rendered already");
         const rev = (_b = (_a = host.instance) === null || _a === void 0 ? void 0 : _a.revision) !== null && _b !== void 0 ? _b : ~1;
         if (rev >= ~0)
             inst.buffer.push(node);
@@ -148,8 +148,8 @@ export class RxDom {
         const inst = new RxNodeInstanceImpl(0);
         const node = new RxNode(id, null, () => { }, undefined, 0, false, { name: id, sequential }, false, {}, {}, inst);
         const a = node;
-        a['creator'] = node;
-        a['host'] = node;
+        a["creator"] = node;
+        a["host"] = node;
         inst.native = native;
         return node;
     }
@@ -159,13 +159,13 @@ export class RxDom {
     static currentNodeInstance() {
         const inst = gCreator.instance;
         if (!inst)
-            throw new Error('currentNodeInstance function can be called only inside rendering function');
+            throw new Error("currentNodeInstance function can be called only inside rendering function");
         return inst;
     }
     static currentNodeInstanceInternal() {
         const inst = gCreator.instance;
         if (!inst)
-            throw new Error('currentNodeInstanceInternal function can be called only inside rendering function');
+            throw new Error("currentNodeInstanceInternal function can be called only inside rendering function");
         return inst;
     }
     static currentNodeRevision() {
@@ -416,7 +416,7 @@ export class RxDom {
         }
     }
 }
-RxDom.basic = new BasicNodeType('basic', false);
+RxDom.basic = new BasicNodeType("basic", false);
 function tryToRender(node) {
     const inst = node.instance;
     if (node.inline)
@@ -551,6 +551,6 @@ export function rejectRethrow(error) {
 Promise.prototype.then = reactronicDomHookedThen;
 const NOP = () => { };
 const EMPTY = Object.freeze([]);
-const SYSTEM = RxDom.createRootNode('SYSTEM', false, 'SYSTEM');
+const SYSTEM = RxDom.createRootNode("SYSTEM", false, "SYSTEM");
 let gCreator = SYSTEM;
 let gHost = SYSTEM;

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

@@ -0,0 +1,64 @@
+import { CellRange } from "./CellRange";
+export declare enum To {
+    Fit = 0,
+    Left = 1,
+    Center = 2,
+    Right = 3,
+    Top = 4,
+    CenterV = 8,
+    Bottom = 12,
+    Default = 16
+}
+export interface ElasticSize {
+    cells?: number;
+    min?: string;
+    max?: string;
+    growth?: number;
+}
+export interface TrackSize extends ElasticSize {
+    track?: string | number;
+}
+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?: To;
+    alignFrame?: To;
+}
+export interface Place {
+    exact: CellRange | undefined;
+    widthMin: string;
+    widthMax: string;
+    widthGrowth: number;
+    heightMin: string;
+    heightMax: string;
+    heightGrowth: number;
+    alignContent: To;
+    alignFrame: To;
+}
+export declare class Allocator {
+    reset(): void;
+    lineFeed(): void;
+    allocate(bounds: Bounds | undefined): Place | undefined;
+}
+export declare class GridBasedAllocator implements Allocator {
+    private maxColumnCount;
+    private maxRowCount;
+    private actualColumnCount;
+    private actualRowCount;
+    private columnCursor;
+    private rowCursor;
+    private newRowCursor;
+    reset(): void;
+    lineFeed(): void;
+    allocate(bounds: Bounds | undefined): Place | undefined;
+}
+export declare function equalPlaces(a: Place | undefined, b: Place | undefined): boolean;

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

@@ -0,0 +1,141 @@
+import { parseCellRange } from "./CellRange";
+export var To;
+(function (To) {
+    To[To["Fit"] = 0] = "Fit";
+    To[To["Left"] = 1] = "Left";
+    To[To["Center"] = 2] = "Center";
+    To[To["Right"] = 3] = "Right";
+    To[To["Top"] = 4] = "Top";
+    To[To["CenterV"] = 8] = "CenterV";
+    To[To["Bottom"] = 12] = "Bottom";
+    To[To["Default"] = 16] = "Default";
+})(To || (To = {}));
+export class Allocator {
+    reset() {
+    }
+    lineFeed() {
+    }
+    allocate(bounds) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return !bounds ? undefined : {
+            exact: bounds.place ? parseCellRange(bounds.place, { x1: 0, y1: 0, x2: 0, y2: 0 }) : undefined,
+            widthMin: (_a = bounds.widthMin) !== null && _a !== void 0 ? _a : "",
+            widthMax: (_b = bounds.widthMax) !== null && _b !== void 0 ? _b : "",
+            widthGrowth: (_c = bounds.widthGrowth) !== null && _c !== void 0 ? _c : 0,
+            heightMin: (_d = bounds.heightMin) !== null && _d !== void 0 ? _d : "",
+            heightMax: (_e = bounds.heightMax) !== null && _e !== void 0 ? _e : "",
+            heightGrowth: (_f = bounds.heightGrowth) !== null && _f !== void 0 ? _f : 0,
+            alignContent: (_g = bounds.alignContent) !== null && _g !== void 0 ? _g : To.Default,
+            alignFrame: (_h = bounds.alignFrame) !== null && _h !== void 0 ? _h : To.Default,
+        };
+    }
+}
+export class GridBasedAllocator {
+    constructor() {
+        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;
+    }
+    lineFeed() {
+        this.columnCursor = 0;
+        this.rowCursor = this.newRowCursor;
+    }
+    allocate(bounds) {
+        var _a, _b, _c, _d;
+        const result = {
+            exact: undefined,
+            widthMin: "", widthMax: "", widthGrowth: 0,
+            heightMin: "", heightMax: "", heightGrowth: 0,
+            alignContent: (_a = bounds === null || bounds === void 0 ? void 0 : bounds.alignContent) !== null && _a !== void 0 ? _a : To.Default,
+            alignFrame: (_b = bounds === null || bounds === void 0 ? void 0 : bounds.alignFrame) !== null && _b !== void 0 ? _b : To.Default,
+        };
+        if (bounds === null || bounds === void 0 ? void 0 : bounds.place) {
+            result.exact = parseCellRange(bounds.place, { x1: 0, y1: 0, x2: 0, y2: 0 });
+            absolutizeCellRange(result.exact, this.columnCursor + 1, this.rowCursor + 1, this.maxColumnCount || Infinity, this.maxRowCount || Infinity, result.exact);
+        }
+        else {
+            const totalColumnCount = this.maxColumnCount !== 0 ? this.maxColumnCount : this.actualColumnCount;
+            const totalRowCount = this.maxRowCount !== 0 ? this.maxRowCount : this.actualRowCount;
+            const cr = result.exact = { x1: 0, y1: 0, x2: 0, y2: 0 };
+            let w = (_c = bounds === null || bounds === void 0 ? void 0 : bounds.widthSpan) !== null && _c !== void 0 ? _c : 1;
+            if (w === 0)
+                w = totalColumnCount || 1;
+            if (w >= 0) {
+                cr.x1 = this.columnCursor + 1;
+                cr.x2 = absolutizePosition(cr.x1 + w - 1, 0, this.maxColumnCount || Infinity);
+                if (!(bounds === null || bounds === void 0 ? void 0 : bounds.widthOverlap))
+                    this.columnCursor = cr.x2;
+            }
+            else {
+                cr.x1 = Math.max(this.columnCursor + w, 1);
+                cr.x2 = this.columnCursor;
+            }
+            let h = (_d = bounds === null || bounds === void 0 ? void 0 : bounds.heightSpan) !== null && _d !== void 0 ? _d : 1;
+            if (h === 0)
+                h = totalRowCount || 1;
+            if (h >= 0) {
+                cr.y1 = this.rowCursor + 1;
+                cr.y2 = absolutizePosition(cr.y1 + h - 1, 0, this.maxRowCount || Infinity);
+                if (!(bounds === null || bounds === void 0 ? void 0 : bounds.heightOverlap) && cr.y2 > this.newRowCursor)
+                    this.newRowCursor = cr.y2;
+            }
+            else {
+                cr.y1 = Math.max(this.rowCursor + h, 1);
+                cr.y2 = this.rowCursor;
+            }
+        }
+        return result;
+    }
+}
+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;
+}
+export function equalPlaces(a, b) {
+    let result;
+    if (a) {
+        if (b) {
+            result = a.widthGrowth == b.widthGrowth;
+        }
+        else
+            result = false;
+    }
+    else if (b)
+        result = false;
+    else
+        result = true;
+    return result;
+}

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

@@ -0,0 +1,8 @@
+export interface CellRange {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+export declare function parseCellRange(text: string, result: CellRange): CellRange;
+export declare function emitCellRange(value: CellRange): string;

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

@@ -0,0 +1,173 @@
+export function parseCellRange(text, result) {
+    let i = 0;
+    let value = 0;
+    let sign = 1;
+    let component = 0;
+    while (i < text.length) {
+        const charCode = text.charCodeAt(i);
+        if (isCapitalLetter(charCode)) {
+            if (component % 2 === 0)
+                value = value * 26 + charCode - 64;
+            else
+                console.error(`Digit is expected, but letter ('${text[i]}') was read`);
+        }
+        else if (isLowercaseLetter(charCode)) {
+            if (component % 2 === 0) {
+                value = value * 26 + charCode - 96;
+            }
+            else {
+                console.error(`Digit is expected, but letter ('${text[i]}') was read`);
+            }
+        }
+        else if (isDigit(charCode)) {
+            if (component % 2 === 0) {
+                if (value !== 0) {
+                    if (component === 0)
+                        result.x1 = value * sign;
+                    else
+                        result.x2 = value * sign;
+                    value = 0;
+                }
+                component++;
+            }
+            value = value * 10 + charCode - 48;
+        }
+        else if (charCode === 40) {
+            if (component === 0)
+                result.x1 = value * sign;
+            else if (component === 2)
+                result.x2 = value * sign;
+            if (sign > 0) {
+                sign = -1;
+                component &= ~1;
+                value = 0;
+            }
+            else {
+                console.error("Sign must not be negative");
+            }
+        }
+        else if (charCode === 41) {
+            if (sign > 0) {
+                console.error("Sign must be negative");
+            }
+            switch (component) {
+                case 0:
+                    result.x1 = value * sign;
+                    break;
+                case 1:
+                    result.y1 = value * sign;
+                    break;
+                case 2:
+                    result.x2 = value * sign;
+                    break;
+                case 3:
+                    result.y2 = value * sign;
+                    break;
+            }
+            sign = 1;
+            value = 0;
+            component++;
+        }
+        else if (charCode === 58) {
+            if (sign < 0)
+                console.error(`area '${text}': e1`);
+            if (component === 1)
+                result.y1 = value * sign;
+            else if (component !== 2)
+                console.error(`area '${text}': [e2] component = ${component}`);
+            component = 2;
+            value = 0;
+        }
+        else if (isWhitespace(charCode)) {
+        }
+        else {
+            console.error(`Unknown symbol '${text[i]}' in '${text}'`);
+        }
+        i++;
+    }
+    if (value !== 0) {
+        switch (component) {
+            case 0: {
+                result.x1 = value * sign;
+                if (sign < 0 && result.y1 === 0)
+                    result.y1 = sign;
+                break;
+            }
+            case 1: {
+                if (sign < 0 && result.x1 === 0)
+                    result.x1 = sign;
+                result.y1 = value * sign;
+                break;
+            }
+            case 2: {
+                result.x2 = value * sign;
+                if (sign < 0 && result.y2 === 0)
+                    result.y2 = sign;
+                break;
+            }
+            case 3: {
+                if (sign < 0 && result.x2 === 0)
+                    result.x2 = sign;
+                result.y2 = value * sign;
+                break;
+            }
+        }
+    }
+    else if (sign < 0) {
+        if (component === 0) {
+            if (result.x1 === 0)
+                result.x1 = sign;
+            if (result.y1 === 0)
+                result.y1 = sign;
+        }
+        else {
+            if (result.x2 === 0)
+                result.x2 = sign;
+            if (result.y2 === 0)
+                result.y2 = sign;
+        }
+    }
+    return result;
+}
+export function emitCellRange(value) {
+    const p1 = emitCellPosition(value.x1, value.y1);
+    const p2 = emitCellPosition(value.x2, value.y2);
+    return `${p1}${p2 !== "" ? `:${p2}` : ""}`;
+}
+function isWhitespace(char) {
+    return char === 32 || (char >= 9 && char <= 13) || char === 133 || char === 160;
+}
+function isDigit(input, index) {
+    return 48 <= input && input <= 57;
+}
+function isCapitalLetter(ch) {
+    return 65 <= ch && ch <= 90;
+}
+function isLowercaseLetter(ch) {
+    return 97 <= ch && ch <= 122;
+}
+function emitLetters(n) {
+    if (n < 0)
+        throw new Error(`emitLetters: argument (${n}) should not be negative or zero`);
+    let result = "";
+    while (n >= 0) {
+        const r = n % 26;
+        n = Math.floor(n / 26) - 1;
+        result = String.fromCharCode(65 + r) + result;
+    }
+    return result;
+}
+function emitCellPosition(x, y) {
+    let result = "";
+    if (x > 0 && y > 0)
+        result = `${emitLetters(x - 1)}${y}`;
+    else if (x > 0 && y < 0)
+        result = `${emitLetters(x - 1)}(${-y})`;
+    else if (x < 0 && y > 0)
+        result = `(${emitLetters(-x - 1)})${y}`;
+    else if (x < 0 && y < 0)
+        result = `(${emitLetters(-x - 1)}${-y})`;
+    else
+        result = "";
+    return result;
+}

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

@@ -0,0 +1,82 @@
+import { Monitor, LoggingOptions, Item, CollectionReader } from "reactronic";
+import { Bounds, Place, Allocator } from "./Allocator";
+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 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 {
+    reacting?: boolean;
+    triggers?: unknown;
+    priority?: Priority;
+    monitor?: Monitor;
+    throttling?: number;
+    logging?: Partial<LoggingOptions>;
+    shuffle?: boolean;
+    render: Render<T, M, R>;
+    initialize?: Render<T, M, R> | Array<Render<T, M, R>>;
+    finalize?: Render<T, M, R> | Array<Render<T, M, R>>;
+    override?: Render<T, M, R>;
+    subTreeContext?: Object;
+    subTreeContextType?: Object;
+}
+export declare function useContext<T extends Object>(type: new (...args: any[]) => T): T;
+export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
+    static readonly shortFrameDuration = 16;
+    static readonly longFrameDuration = 300;
+    static currentRenderingPriority: Priority;
+    static frameDuration: number;
+    abstract readonly name: string;
+    abstract readonly driver: AbstractDriver<T>;
+    abstract readonly args: Readonly<BlockArgs<T, M, R>>;
+    abstract model?: M;
+    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 getDefaultLoggingOptions(): LoggingOptions | undefined;
+    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
+    private static trySwitchContext;
+}
+export declare enum LayoutKind {
+    Block = 0,
+    Grid = 1,
+    Line = 2,
+    Group = 3,
+    Text = 4
+}
+export declare class AbstractDriver<T> {
+    static readonly group: AbstractDriver<any>;
+    readonly name: string;
+    readonly layout: LayoutKind;
+    readonly createAllocator: () => Allocator;
+    get isSequential(): boolean;
+    get isAuxiliary(): boolean;
+    get isBlock(): boolean;
+    get isGrid(): boolean;
+    get isLine(): boolean;
+    constructor(name: string, layout: LayoutKind, createAllocator?: () => Allocator);
+    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;
+    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);
+    initialize(block: VBlock<T>, element: T | undefined): void;
+}