verstak 0.23.121 → 0.23.123

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

@@ -1,9 +1,9 @@
 import { MergeListReader, MergeItem, MemberOptions } from "reactronic";
 export type Callback<T = unknown> = (native: T) => void;
-export type Delegate<T = unknown, M = unknown, C = unknown, R = void> = (block: Block<T, M, C, R>, base: () => R) => R;
-export type AsyncDelegate<T = unknown, M = unknown> = (block: Block<T, M, Promise<void>>) => Promise<void>;
-export type SimpleDelegate<T = unknown> = (block: Block<T, any, any, any>) => void;
-export declare enum BlockKind {
+export type Delegate<T> = (element: T, base: () => void) => void;
+export type AsyncDelegate<T = unknown, M = unknown> = (element: El<T, M, Promise<void>>) => Promise<void>;
+export type SimpleDelegate<T = unknown> = (element: El<T, any, any, any>) => void;
+export declare enum ElKind {
     Section = 0,
     Table = 1,
     Note = 2,
@@ -12,15 +12,15 @@ export declare enum BlockKind {
     Cursor = 5,
     Native = 6
 }
-export interface Block<T = unknown, M = unknown, C = unknown, R = void> {
-    readonly node: BlockNode<T, M, C, R>;
-    readonly native: T;
+export interface El<T = unknown, M = unknown, C = unknown, R = void> {
+    readonly node: RxNode<T, M, C, R>;
     readonly isSection: boolean;
     readonly isTable: boolean;
+    native: T;
     model: M;
     controller: C;
-    kind: BlockKind;
-    area: BlockArea;
+    kind: ElKind;
+    area: ElArea;
     widthGrowth: number;
     minWidth: string;
     maxWidth: string;
@@ -28,71 +28,69 @@ export interface Block<T = unknown, M = unknown, C = unknown, R = void> {
     minHeight: string;
     maxHeight: string;
     contentAlignment: Align;
-    blockAlignment: Align;
+    elementAlignment: Align;
     contentWrapping: boolean;
     overlayVisible: boolean | undefined;
-    updatePriority?: Priority;
-    childrenShuffling: boolean;
-    strictOrder: boolean;
-    readonly isInitialUpdate: boolean;
     useStyle(styleName: string, enabled?: boolean): void;
     configureReactronic(options: Partial<MemberOptions>): MemberOptions;
 }
-export interface BlockNode<T = unknown, M = unknown, C = unknown, R = void> {
+export interface RxNode<T = unknown, M = unknown, C = unknown, R = void> {
     readonly key: string;
-    readonly driver: Driver<T>;
-    readonly builder: Readonly<BlockBuilder<T, M, C, R>>;
+    readonly driver: RxNodeDriver<T>;
+    readonly spec: Readonly<RxNodeSpec<El<T, M, C, R>>>;
     readonly level: number;
-    readonly owner: Block;
-    readonly host: Block;
-    readonly children: MergeListReader<Block>;
-    readonly ties: MergeItem<Block> | undefined;
+    readonly owner: RxNode;
+    readonly host: RxNode;
+    readonly children: MergeListReader<El>;
+    readonly slot: MergeItem<El> | undefined;
     readonly stamp: number;
-    readonly outer: Block;
-    readonly context: BlockCtx | undefined;
+    readonly outer: RxNode;
+    readonly context: RxNodeCtx | undefined;
+    readonly isInitialUpdate: boolean;
+    priority?: Priority;
+    childrenShuffling: boolean;
+    strictOrder: boolean;
+    has(mode: Mode): boolean;
 }
-export interface BlockBuilder<T = unknown, M = unknown, C = unknown, R = void> {
-    base?: BlockBuilder<T, M, C, R>;
+export interface RxNodeSpec<T = unknown> {
+    base?: RxNodeSpec<T>;
     key?: string;
     mode?: Mode;
     triggers?: unknown;
-    claim?: Delegate<T, M, C, R>;
-    create?: Delegate<T, M, C, R>;
-    initialize?: Delegate<T, M, C, R>;
-    update?: Delegate<T, M, C, R>;
-    finalize?: Delegate<T, M, C, R>;
+    specify?: Delegate<T>;
+    create?: Delegate<T>;
+    initialize?: Delegate<T>;
+    update?: Delegate<T>;
+    finalize?: Delegate<T>;
 }
-export interface BlockCtx<T extends Object = Object> {
+export interface RxNodeCtx<T extends Object = Object> {
     value: T;
 }
-export interface Driver<T, C = unknown> {
+export interface RxNodeDriver<T, C = unknown> {
     readonly name: string;
-    readonly isRow: boolean;
+    readonly isSeparator: boolean;
     readonly preset?: SimpleDelegate<T>;
-    claim(block: Block<T, unknown, C>): void;
-    create(block: Block<T, unknown, C>, b: {
-        native?: T;
-        controller?: C;
-    }): void;
-    initialize(block: Block<T, unknown, C>): void;
-    mount(block: Block<T, unknown, C>): void;
-    update(block: Block<T, unknown, C>): void | Promise<void>;
-    finalize(block: Block<T, unknown, C>, isLeader: boolean): boolean;
-    applyKind(block: Block<T, any, C, any>, value: BlockKind): void;
-    applyCoords(block: Block<T, any, C, any>, value: BlockCoords | undefined): void;
-    applyWidthGrowth(block: Block<T, any, C, any>, value: number): void;
-    applyMinWidth(block: Block<T, any, C, any>, value: string): void;
-    applyMaxWidth(block: Block<T, any, C, any>, value: string): void;
-    applyHeightGrowth(block: Block<T, any, C, any>, value: number): void;
-    applyMinHeight(block: Block<T, any, C, any>, value: string): void;
-    applyMaxHeight(block: Block<T, any, C, any>, value: string): void;
-    applyContentAlignment(block: Block<T, any, C, any>, value: Align): void;
-    applyBlockAlignment(block: Block<T, any, C, any>, value: Align): void;
-    applyContentWrapping(block: Block<T, any, C, any>, value: boolean): void;
-    applyOverlayVisible(block: Block<T, any, C, any>, value: boolean | undefined): void;
-    applyStyle(block: Block<T, any, C, any>, secondary: boolean, styleName: string, enabled?: boolean): void;
+    specify(element: El<T, unknown, C>): void;
+    create(element: El<T, unknown, C>): void;
+    initialize(element: El<T, unknown, C>): void;
+    mount(element: El<T, unknown, C>): void;
+    update(element: El<T, unknown, C>): void | Promise<void>;
+    finalize(element: El<T, unknown, C>, isLeader: boolean): boolean;
+    applyKind(element: El<T, any, C, any>, value: ElKind): void;
+    applyCoords(element: El<T, any, C, any>, value: ElCoords | undefined): void;
+    applyWidthGrowth(element: El<T, any, C, any>, value: number): void;
+    applyMinWidth(element: El<T, any, C, any>, value: string): void;
+    applyMaxWidth(element: El<T, any, C, any>, value: string): void;
+    applyHeightGrowth(element: El<T, any, C, any>, value: number): void;
+    applyMinHeight(element: El<T, any, C, any>, value: string): void;
+    applyMaxHeight(element: El<T, any, C, any>, value: string): void;
+    applyContentAlignment(element: El<T, any, C, any>, value: Align): void;
+    applyElementAlignment(element: El<T, any, C, any>, value: Align): void;
+    applyContentWrapping(element: El<T, any, C, any>, value: boolean): void;
+    applyOverlayVisible(element: El<T, any, C, any>, value: boolean | undefined): void;
+    applyStyle(element: El<T, any, C, any>, secondary: boolean, styleName: string, enabled?: boolean): void;
 }
-export interface BlockCoords {
+export interface ElCoords {
     x1: number;
     y1: number;
     x2: number;
@@ -128,7 +126,7 @@ export interface ElasticSize {
 export interface TrackSize extends ElasticSize {
     track?: string | number;
 }
-export type BlockArea = undefined | string | {
+export type ElArea = undefined | string | {
     cellsOverWidth?: number;
     cellsOverHeight?: number;
 };

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

@@ -1,13 +1,13 @@
-export var BlockKind;
-(function (BlockKind) {
-    BlockKind[BlockKind["Section"] = 0] = "Section";
-    BlockKind[BlockKind["Table"] = 1] = "Table";
-    BlockKind[BlockKind["Note"] = 2] = "Note";
-    BlockKind[BlockKind["Group"] = 3] = "Group";
-    BlockKind[BlockKind["Row"] = 4] = "Row";
-    BlockKind[BlockKind["Cursor"] = 5] = "Cursor";
-    BlockKind[BlockKind["Native"] = 6] = "Native";
-})(BlockKind || (BlockKind = {}));
+export var ElKind;
+(function (ElKind) {
+    ElKind[ElKind["Section"] = 0] = "Section";
+    ElKind[ElKind["Table"] = 1] = "Table";
+    ElKind[ElKind["Note"] = 2] = "Note";
+    ElKind[ElKind["Group"] = 3] = "Group";
+    ElKind[ElKind["Row"] = 4] = "Row";
+    ElKind[ElKind["Cursor"] = 5] = "Cursor";
+    ElKind[ElKind["Native"] = 6] = "Native";
+})(ElKind || (ElKind = {}));
 export var Priority;
 (function (Priority) {
     Priority[Priority["Realtime"] = 0] = "Realtime";

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

@@ -1,8 +1,8 @@
-import { BlockCoords } from "./Interfaces.js";
-export declare function parseBlockCoords(text: string, result: BlockCoords): BlockCoords;
-export declare function emitBlockCoords(value: BlockCoords): string;
+import { ElCoords } from "./Interfaces.js";
+export declare function parseElCoords(text: string, result: ElCoords): ElCoords;
+export declare function emitElCoords(value: ElCoords): string;
 export declare function emitLetters(n: number): string;
 export declare function emitCellPosition(x: number, y: number): string;
-export declare function equalBlockCoords(a: BlockCoords, b: BlockCoords): boolean;
+export declare function equalElCoords(a: ElCoords, b: ElCoords): boolean;
 export declare function objectHasMember<T>(obj: any, member: string): obj is T;
 export declare function getCallerInfo(prefix: string): string;

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

@@ -1,4 +1,4 @@
-export function parseBlockCoords(text, result) {
+export function parseElCoords(text, result) {
     let i = 0;
     let value = 0;
     let sign = 1;
@@ -129,7 +129,7 @@ export function parseBlockCoords(text, result) {
     }
     return result;
 }
-export function emitBlockCoords(value) {
+export function emitElCoords(value) {
     const p1 = emitCellPosition(value.x1, value.y1);
     const p2 = emitCellPosition(value.x2, value.y2);
     return `${p1}${p2 !== "" ? `:${p2}` : ""}`;
@@ -159,7 +159,7 @@ export function emitCellPosition(x, y) {
         result = "";
     return result;
 }
-export function equalBlockCoords(a, b) {
+export function equalElCoords(a, b) {
     return a.x1 === b.x1 && a.y1 === b.y1 && a.x2 === b.x2 && a.y1 === b.y2;
 }
 function isWhitespace(char) {
@@ -183,7 +183,7 @@ export function getCallerInfo(prefix) {
     const stack = error.stack || "";
     Error.stackTraceLimit = restore;
     const lines = stack.split("\n");
-    let i = lines.findIndex(x => x.indexOf(".claim") >= 0);
+    let i = lines.findIndex(x => x.indexOf(".specify") >= 0);
     i = i >= 0 ? i + 2 : 5;
     let caller = extractFunctionAndLocation(lines[i]);
     let location = caller;

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

@@ -1,53 +1,47 @@
 import { LoggingOptions } from "reactronic";
-import { BlockCoords, BlockKind, Priority, Align, BlockBuilder, Block, Driver, SimpleDelegate } from "./Interfaces.js";
+import { ElCoords, ElKind, Priority, Align, RxNodeSpec, El, RxNodeDriver, SimpleDelegate } from "./Interfaces.js";
 export declare class Verstak {
     static readonly shortFrameDuration = 16;
     static readonly longFrameDuration = 300;
     static currentUpdatePriority: Priority;
     static frameDuration: number;
-    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>): Block<T, M, C, R>;
-    static get block(): Block;
-    static triggerUpdate(block: Block<any, any, any, void>, triggers: unknown): void;
+    static specify<T = undefined, M = unknown, C = unknown, R = void>(driver: RxNodeDriver<T>, spec?: RxNodeSpec<El<T, M, C, R>>, base?: RxNodeSpec<El<T, M, C, R>>): El<T, M, C, R>;
+    static get element(): El;
+    static triggerUpdate(element: El<any, any, any, void>, triggers: unknown): void;
     static updateNestedTreesThenDo(action: (error: unknown) => void): void;
     static getDefaultLoggingOptions(): LoggingOptions | undefined;
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
 }
-export declare class BaseDriver<T, C = unknown> implements Driver<T, C> {
+export declare class BaseDriver<T, C = unknown> implements RxNodeDriver<T, C> {
     readonly name: string;
-    readonly isRow: boolean;
+    readonly isSeparator: boolean;
     readonly preset?: SimpleDelegate<T> | undefined;
     static readonly fragment: BaseDriver<any, unknown>;
-    constructor(name: string, isRow: boolean, preset?: SimpleDelegate<T> | undefined);
-    claim(block: Block<T, unknown, C>): void;
-    create(block: Block<T, unknown, C>, b: {
-        native?: T;
-        controller?: C;
-    }): void;
-    initialize(block: Block<T, unknown, C>): void;
-    mount(block: Block<T, unknown, C>): void;
-    update(block: Block<T, unknown, C>): void | Promise<void>;
-    finalize(block: Block<T, unknown, C>, isLeader: boolean): boolean;
-    applyKind(block: Block<T, any, C, any>, value: BlockKind): void;
-    applyCoords(block: Block<T, any, C, any>, value: BlockCoords | undefined): void;
-    applyWidthGrowth(block: Block<T, any, C, any>, value: number): void;
-    applyMinWidth(block: Block<T, any, C, any>, value: string): void;
-    applyMaxWidth(block: Block<T, any, C, any>, value: string): void;
-    applyHeightGrowth(block: Block<T, any, C, any>, value: number): void;
-    applyMinHeight(block: Block<T, any, C, any>, value: string): void;
-    applyMaxHeight(block: Block<T, any, C, any>, value: string): void;
-    applyContentAlignment(block: Block<T, any, C, any>, value: Align): void;
-    applyBlockAlignment(block: Block<T, any, C, any>, value: Align): void;
-    applyContentWrapping(block: Block<T, any, C, any>, value: boolean): void;
-    applyOverlayVisible(block: Block<T, any, C, any>, value: boolean | undefined): void;
-    applyStyle(block: Block<T, any, C, any>, secondary: boolean, styleName: string, enabled?: boolean): void;
+    constructor(name: string, isSeparator: boolean, preset?: SimpleDelegate<T> | undefined);
+    specify(element: El<T, unknown, C>): void;
+    create(element: El<T, unknown, C>): void;
+    initialize(element: El<T, unknown, C>): void;
+    mount(element: El<T, unknown, C>): void;
+    update(element: El<T, unknown, C>): void | Promise<void>;
+    finalize(element: El<T, unknown, C>, isLeader: boolean): boolean;
+    applyKind(element: El<T, any, C, any>, value: ElKind): void;
+    applyCoords(element: El<T, any, C, any>, value: ElCoords | undefined): void;
+    applyWidthGrowth(element: El<T, any, C, any>, value: number): void;
+    applyMinWidth(element: El<T, any, C, any>, value: string): void;
+    applyMaxWidth(element: El<T, any, C, any>, value: string): void;
+    applyHeightGrowth(element: El<T, any, C, any>, value: number): void;
+    applyMinHeight(element: El<T, any, C, any>, value: string): void;
+    applyMaxHeight(element: El<T, any, C, any>, value: string): void;
+    applyContentAlignment(element: El<T, any, C, any>, value: Align): void;
+    applyElementAlignment(element: El<T, any, C, any>, value: Align): void;
+    applyContentWrapping(element: El<T, any, C, any>, value: boolean): void;
+    applyOverlayVisible(element: El<T, any, C, any>, value: boolean | undefined): void;
+    applyStyle(element: El<T, any, C, any>, secondary: boolean, styleName: string, enabled?: boolean): void;
 }
 export declare class StaticDriver<T> extends BaseDriver<T> {
-    readonly element: T;
-    constructor(element: T, name: string, isRow: boolean, preset?: SimpleDelegate<T>);
-    create(block: Block<T, unknown, unknown, void>, b: {
-        native?: T;
-        controller?: unknown;
-    }): void;
+    readonly native: T;
+    constructor(native: T, name: string, isRow: boolean, preset?: SimpleDelegate<T>);
+    create(element: El<T, unknown, unknown, void>): void;
 }
 export declare class CursorCommand {
     absolute?: string;
@@ -56,10 +50,7 @@ export declare class CursorCommand {
 }
 export declare class CursorCommandDriver extends BaseDriver<CursorCommand, void> {
     constructor();
-    create(block: Block<CursorCommand, unknown, void, void>, b: {
-        native?: CursorCommand;
-        controller?: void;
-    }): void;
+    create(element: El<CursorCommand, unknown, void, void>): void;
 }
 export declare class SubTreeVariable<T extends Object = Object> {
     readonly defaultValue: T | undefined;