verstak 0.23.122 → 0.23.123

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

@@ -1,6 +1,6 @@
 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> = (element: El<T, M, C, R>, base: () => R) => R;
+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 {
@@ -13,10 +13,10 @@ export declare enum ElKind {
     Native = 6
 }
 export interface El<T = unknown, M = unknown, C = unknown, R = void> {
-    readonly node: ElNode<T, M, C, R>;
-    readonly native: T;
+    readonly node: RxNode<T, M, C, R>;
     readonly isSection: boolean;
     readonly isTable: boolean;
+    native: T;
     model: M;
     controller: C;
     kind: ElKind;
@@ -31,52 +31,49 @@ export interface El<T = unknown, M = unknown, C = unknown, R = void> {
     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;
-    hasMode(mode: Mode): boolean;
 }
-export interface ElNode<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<ElBuilder<T, M, C, R>>;
+    readonly driver: RxNodeDriver<T>;
+    readonly spec: Readonly<RxNodeSpec<El<T, M, C, R>>>;
     readonly level: number;
-    readonly owner: El;
-    readonly host: El;
+    readonly owner: RxNode;
+    readonly host: RxNode;
     readonly children: MergeListReader<El>;
-    readonly ties: MergeItem<El> | undefined;
+    readonly slot: MergeItem<El> | undefined;
     readonly stamp: number;
-    readonly outer: El;
-    readonly context: ElCtx | undefined;
+    readonly outer: RxNode;
+    readonly context: RxNodeCtx | undefined;
+    readonly isInitialUpdate: boolean;
+    priority?: Priority;
+    childrenShuffling: boolean;
+    strictOrder: boolean;
+    has(mode: Mode): boolean;
 }
-export interface ElBuilder<T = unknown, M = unknown, C = unknown, R = void> {
-    base?: ElBuilder<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 ElCtx<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(element: El<T, unknown, C>): void;
-    create(element: El<T, unknown, C>, b: {
-        native?: T;
-        controller?: C;
-    }): 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>, nativeHost?: T): 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;

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

@@ -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,30 +1,27 @@
 import { LoggingOptions } from "reactronic";
-import { ElCoords, ElKind, Priority, Align, ElBuilder, El, 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?: ElBuilder<T, M, C, R>, base?: ElBuilder<T, M, C, R>): El<T, M, C, R>;
+    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(element: El<T, unknown, C>): void;
-    create(element: El<T, unknown, C>, result: {
-        native?: T;
-        controller?: C;
-    }): 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>, nativeHost?: T): 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;
@@ -44,10 +41,7 @@ export declare class BaseDriver<T, C = unknown> implements Driver<T, C> {
 export declare class StaticDriver<T> extends BaseDriver<T> {
     readonly native: T;
     constructor(native: T, name: string, isRow: boolean, preset?: SimpleDelegate<T>);
-    create(element: El<T, unknown, unknown, void>, result: {
-        native?: T;
-        controller?: unknown;
-    }): void;
+    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(element: El<CursorCommand, unknown, void, void>, result: {
-        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;