verstak 0.23.108 → 0.23.109

package/README.md

@@ -5,23 +5,44 @@
 
 # **Verstak** - Experimental Front-End Library
 
-Verstak is an experimental JavaScript library that provides
-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.
-
-Transactional reactivity means that state changes are being made in an
-isolated data snapshot and then, once atomically applied, are
-**consistently propagated** to corresponding visual components for
-(re)rendering. All that is done in automatic, seamless, and fine-grained
-way, because reactronic **takes full care of tracking dependencies**
-between visual components (observers) and state objects (observables).
-
-Based on Reactronic: https://github.com/nezaboodka/reactronic/blob/master/README.md#readme
-
-Example of the application built with Verstak: https://nevod.io
-
-Source code of the example: https://gitlab.com/nezaboodka/nevod.web.public/-/blob/master/README.md
+Verstak is a experimental library for rapid development of user
+interfaces. It provides **automatic refresh** of visual elements
+upon change of underlying data in a program.
+
+Refresh on the screen is **fine-grained**, meaning that only
+those visual elements are refreshed, which really depend on
+actual data changed. It is achieved by automatic tracking of
+all dependencies between visual elements and data they use
+during run time. Such an approach is usually called reactive
+programming. It frees a programmer from writing boilerplate
+code for "pushing" changed data to visual elements.
+
+Changing of compound data and refreshing of visual elements
+on the screen is performed consistently, in other words in
+"all-or-nothing" way. It means that in case of changing
+multiple variables in a program actual visual refresh
+happens only in case of successful change of all the variables.
+Partial changes are "not visible" to visual elements even
+in case of exception or cancellation of changes. Such a
+change of compound data in "all-or-nothing" way is called
+a transaction.
+
+Verstak supports asynchronous programming out of the box
+at all the layers, including transactions and visual elements
+rendering.
+
+Altogether it is called reactive transactional programming.
+Transactional reactivity means that state changes are being
+made in an isolated data snapshot and then, once atomically
+applied, are **consistently propagated** to corresponding
+visual components for (re)rendering. All that is done in
+automatic, seamless, and fine-grained way, because Verstak
+**takes full care of tracking dependencies** between visual
+components (observers) and state objects (observables).
+
+Example application: https://nevod.io ([source code](https://gitlab.com/nezaboodka/nevod.web.public/-/blob/master/README.md)).
+
+Verstak is based on [Reactronic](https://github.com/nezaboodka/reactronic/blob/master/README.md#readme).
 
 # Contribution
 

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

@@ -1,34 +1,19 @@
 import { CollectionReader, Item, MemberOptions } from "reactronic";
 export type Callback<T = unknown> = (native: T) => void;
-export type Delegate<T = unknown, M = unknown, C = unknown, R = void> = (block: VBlock<T, M, C, R>, original: () => R) => R;
-export type AsyncDelegate<T = unknown, M = unknown> = (block: VBlock<T, M, Promise<void>>) => Promise<void>;
-export type SimpleDelegate<T = unknown> = (block: VBlock<T, any, any, any>) => void;
-export interface BlockBuilder<T = unknown, M = unknown, C = unknown, R = void> {
-    original?: BlockBuilder<T, M, C, R>;
-    key?: string;
-    modes?: Mode;
-    triggers?: unknown;
-    claim?: Delegate<T, M, C, R>;
-    create?: Delegate<T, M, C, R>;
-    initialize?: Delegate<T, M, C, R>;
-    render?: Delegate<T, M, C, R>;
-    finalize?: Delegate<T, M, C, R>;
-}
-export interface VBlockDescriptor<T = unknown, M = unknown, C = unknown, R = void> {
-    readonly key: string;
-    readonly driver: Driver<T>;
-    readonly builder: Readonly<BlockBuilder<T, M, C, R>>;
-    readonly level: number;
-    readonly owner: VBlock;
-    readonly host: VBlock;
-    readonly children: CollectionReader<VBlock>;
-    readonly item: Item<VBlock> | undefined;
-    readonly stamp: number;
-    readonly outer: VBlock;
-    readonly context: VBlockCtx | undefined;
+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 {
+    Band = 0,
+    Table = 1,
+    Note = 2,
+    Group = 3,
+    Row = 4,
+    Cursor = 5,
+    Native = 6
 }
-export interface VBlock<T = unknown, M = unknown, C = unknown, R = void> {
-    readonly descriptor: VBlockDescriptor<T, M, C, R>;
+export interface Block<T = unknown, M = unknown, C = unknown, R = void> {
+    readonly descriptor: BlockDescriptor<T, M, C, R>;
     readonly native: T;
     readonly isBand: boolean;
     readonly isTable: boolean;
@@ -50,38 +35,62 @@ export interface VBlock<T = unknown, M = unknown, C = unknown, R = void> {
     renderingPriority?: Priority;
     isSequential: boolean;
     readonly isInitialRendering: boolean;
-    style(styleName: string, enabled?: boolean): void;
+    useStyle(styleName: string, enabled?: boolean): void;
     configureReactronic(options: Partial<MemberOptions>): MemberOptions;
 }
-export interface VBlockCtx<T extends Object = Object> {
+export interface BlockDescriptor<T = unknown, M = unknown, C = unknown, R = void> {
+    readonly key: string;
+    readonly driver: Driver<T>;
+    readonly builder: Readonly<BlockBuilder<T, M, C, R>>;
+    readonly level: number;
+    readonly owner: Block;
+    readonly host: Block;
+    readonly children: CollectionReader<Block>;
+    readonly item: Item<Block> | undefined;
+    readonly stamp: number;
+    readonly outer: Block;
+    readonly context: BlockCtx | undefined;
+}
+export interface BlockBuilder<T = unknown, M = unknown, C = unknown, R = void> {
+    base?: BlockBuilder<T, M, C, R>;
+    key?: string;
+    mode?: Mode;
+    triggers?: unknown;
+    claim?: Delegate<T, M, C, R>;
+    create?: Delegate<T, M, C, R>;
+    initialize?: Delegate<T, M, C, R>;
+    render?: Delegate<T, M, C, R>;
+    finalize?: Delegate<T, M, C, R>;
+}
+export interface BlockCtx<T extends Object = Object> {
     value: T;
 }
 export interface Driver<T, C = unknown> {
     readonly name: string;
     readonly isRow: boolean;
     readonly preset?: SimpleDelegate<T>;
-    claim(block: VBlock<T, unknown, C>): void;
-    create(block: VBlock<T, unknown, C>, b: {
+    claim(block: Block<T, unknown, C>): void;
+    create(block: Block<T, unknown, C>, b: {
         native?: T;
         controller?: C;
     }): void;
-    initialize(block: VBlock<T, unknown, C>): void;
-    mount(block: VBlock<T, unknown, C>): void;
-    render(block: VBlock<T, unknown, C>): void | Promise<void>;
-    finalize(block: VBlock<T, unknown, C>, isLeader: boolean): boolean;
-    applyKind(block: VBlock<T, any, C, any>, value: BlockKind): void;
-    applyCoords(block: VBlock<T, any, C, any>, value: BlockCoords | 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;
+    initialize(block: Block<T, unknown, C>): void;
+    mount(block: Block<T, unknown, C>): void;
+    render(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;
 }
 export interface BlockCoords {
     x1: number;
@@ -89,14 +98,6 @@ export interface BlockCoords {
     x2: number;
     y2: number;
 }
-export declare enum BlockKind {
-    Band = 0,
-    Table = 1,
-    Note = 2,
-    Group = 3,
-    Row = 4,
-    Cursor = 5
-}
 export declare const enum Priority {
     Realtime = 0,
     Normal = 1,
@@ -104,8 +105,8 @@ export declare const enum Priority {
 }
 export declare enum Mode {
     Default = 0,
-    SeparateReaction = 1,
-    ManualMount = 2
+    PinpointRefresh = 1,
+    ManualMounting = 2
 }
 export declare enum Align {
     Stretch = 0,

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

@@ -6,6 +6,7 @@ export var BlockKind;
     BlockKind[BlockKind["Group"] = 3] = "Group";
     BlockKind[BlockKind["Row"] = 4] = "Row";
     BlockKind[BlockKind["Cursor"] = 5] = "Cursor";
+    BlockKind[BlockKind["Native"] = 6] = "Native";
 })(BlockKind || (BlockKind = {}));
 export var Priority;
 (function (Priority) {
@@ -16,8 +17,8 @@ export var Priority;
 export var Mode;
 (function (Mode) {
     Mode[Mode["Default"] = 0] = "Default";
-    Mode[Mode["SeparateReaction"] = 1] = "SeparateReaction";
-    Mode[Mode["ManualMount"] = 2] = "ManualMount";
+    Mode[Mode["PinpointRefresh"] = 1] = "PinpointRefresh";
+    Mode[Mode["ManualMounting"] = 2] = "ManualMounting";
 })(Mode || (Mode = {}));
 export var Align;
 (function (Align) {

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

@@ -1,12 +1,12 @@
 import { LoggingOptions } from "reactronic";
-import { BlockCoords, BlockKind, Priority, Align, BlockBuilder, VBlock, Driver, SimpleDelegate } from "./Interfaces";
+import { BlockCoords, BlockKind, Priority, Align, BlockBuilder, Block, Driver, SimpleDelegate } from "./Interfaces";
 export declare class Verstak {
     static readonly shortFrameDuration = 16;
     static readonly longFrameDuration = 300;
     static currentRenderingPriority: Priority;
     static frameDuration: number;
-    static claim<T = undefined, M = unknown, C = unknown, R = void>(driver: Driver<T>, builder?: BlockBuilder<T, M, C, R>, original?: BlockBuilder<T, M, C, R>): VBlock<T, M, C, R>;
-    static get block(): VBlock;
+    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 renderNestedTreesThenDo(action: (error: unknown) => void): void;
     static getDefaultLoggingOptions(): LoggingOptions | undefined;
     static setDefaultLoggingOptions(logging?: LoggingOptions): void;
@@ -17,33 +17,33 @@ export declare class BaseDriver<T, C = unknown> implements Driver<T, C> {
     readonly preset?: SimpleDelegate<T> | undefined;
     static readonly fragment: BaseDriver<any, unknown>;
     constructor(name: string, isRow: boolean, preset?: SimpleDelegate<T> | undefined);
-    claim(block: VBlock<T, unknown, C>): void;
-    create(block: VBlock<T, unknown, C>, b: {
+    claim(block: Block<T, unknown, C>): void;
+    create(block: Block<T, unknown, C>, b: {
         native?: T;
         controller?: C;
     }): void;
-    initialize(block: VBlock<T, unknown, C>): void;
-    mount(block: VBlock<T, unknown, C>): void;
-    render(block: VBlock<T, unknown, C>): void | Promise<void>;
-    finalize(block: VBlock<T, unknown, C>, isLeader: boolean): boolean;
-    applyKind(block: VBlock<T, any, C, any>, value: BlockKind): void;
-    applyCoords(block: VBlock<T, any, C, any>, value: BlockCoords | 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;
+    initialize(block: Block<T, unknown, C>): void;
+    mount(block: Block<T, unknown, C>): void;
+    render(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;
 }
 export declare class StaticDriver<T> extends BaseDriver<T> {
     readonly element: T;
     constructor(element: T, name: string, isRow: boolean, preset?: SimpleDelegate<T>);
-    create(block: VBlock<T, unknown, unknown, void>, b: {
+    create(block: Block<T, unknown, unknown, void>, b: {
         native?: T;
         controller?: unknown;
     }): void;
@@ -55,7 +55,7 @@ export declare class CursorCommand {
 }
 export declare class CursorCommandDriver extends BaseDriver<CursorCommand, void> {
     constructor();
-    create(block: VBlock<CursorCommand, unknown, void, void>, b: {
+    create(block: Block<CursorCommand, unknown, void, void>, b: {
         native?: CursorCommand;
         controller?: void;
     }): void;