verstak 0.23.107 → 0.23.109

package/build/dist/source/html/HtmlDriver.d.ts

@@ -1,27 +1,28 @@
 import { Item } from "reactronic";
-import { VBlock, Driver } from "../core/api";
-export declare abstract class BaseHtmlDriver<T extends Element, C = unknown> extends Driver<T, C> {
-    create(block: VBlock<T, unknown, C, void>, b: {
+import { Block, BaseDriver } from "../core/api";
+export declare abstract class BaseHtmlDriver<T extends Element, C = unknown> extends BaseDriver<T, C> {
+    create(block: Block<T, unknown, C, void>, b: {
         native?: T;
         controller?: C;
     }): void;
-    finalize(block: VBlock<T, unknown, C>, isLeader: boolean): boolean;
-    deploy(block: VBlock<T, unknown, C>): void;
-    relocate(block: VBlock<T, unknown, C>): void;
-    render(block: VBlock<T, unknown, C>): void | Promise<void>;
-    static get blinkingEffect(): string | undefined;
-    static set blinkingEffect(value: string | undefined);
-    static findNearestParentHtmlBlock(block: VBlock<any>): VBlock<HTMLElement>;
-    static findPrevSiblingHtmlBlock(item: Item<VBlock<any>>): Item<VBlock<HTMLElement>> | undefined;
+    initialize(block: Block<T, unknown, C, void>): void;
+    finalize(block: Block<T, unknown, C>, isLeader: boolean): boolean;
+    mount(block: Block<T, unknown, C>): void;
+    relocate(block: Block<T, unknown, C>): void;
+    render(block: Block<T, unknown, C>): void | Promise<void>;
+    static get blinkingEffectMarker(): string | undefined;
+    static set blinkingEffectMarker(value: string | undefined);
+    static findEffectiveHtmlBlockHost(block: Block<any>): Block<HTMLElement | SVGElement>;
+    static findPrevSiblingHtmlBlock(item: Item<Block<any>>): Item<Block<HTMLElement | SVGElement>> | undefined;
 }
 export declare class HtmlDriver<T extends HTMLElement, C = unknown> extends BaseHtmlDriver<T, C> {
-    create(block: VBlock<T, unknown, C, void>, b: {
+    create(block: Block<T, unknown, C, void>, b: {
         native?: T | undefined;
         controller?: C | undefined;
     }): void;
 }
 export declare class SvgDriver<T extends SVGElement, C = unknown> extends BaseHtmlDriver<T, C> {
-    create(block: VBlock<T, unknown, C, void>, b: {
+    create(block: Block<T, unknown, C, void>, b: {
         native?: T | undefined;
         controller?: C | undefined;
     }): void;

package/build/dist/source/html/HtmlDriver.js

@@ -1,11 +1,14 @@
 import { Rx } from "reactronic";
-import { VBlock, Driver } from "../core/api";
-export class BaseHtmlDriver extends Driver {
+import { Verstak, BaseDriver } from "../core/api";
+export class BaseHtmlDriver extends BaseDriver {
     create(block, b) {
-        if (Rx.isLogging && !block.driver.isRow)
-            block.native.setAttribute("key", block.key);
         super.create(block, b);
     }
+    initialize(block) {
+        if (Rx.isLogging && !block.descriptor.driver.isRow)
+            block.native.setAttribute("key", block.descriptor.key);
+        super.initialize(block);
+    }
     finalize(block, isLeader) {
         var _a;
         const e = block.native;
@@ -17,15 +20,16 @@ export class BaseHtmlDriver extends Driver {
         super.finalize(block, isLeader);
         return false;
     }
-    deploy(block) {
+    mount(block) {
         const e = block.native;
         if (e) {
-            const sequential = block.host.children.isStrict;
-            const nativeParent = BaseHtmlDriver.findNearestParentHtmlBlock(block).native;
+            const bNode = block.descriptor;
+            const sequential = bNode.owner.descriptor.children.isStrict;
+            const nativeParent = BaseHtmlDriver.findEffectiveHtmlBlockHost(block).native;
             if (nativeParent) {
-                if (sequential && !block.driver.isRow) {
-                    const after = BaseHtmlDriver.findPrevSiblingHtmlBlock(block.item);
-                    if (after === undefined || after.instance.driver.isRow) {
+                if (sequential && !bNode.driver.isRow) {
+                    const after = BaseHtmlDriver.findPrevSiblingHtmlBlock(block.descriptor.item);
+                    if (after === undefined || after.instance.descriptor.driver.isRow) {
                         if (nativeParent !== e.parentNode || !e.previousSibling)
                             nativeParent.prepend(e);
                     }
@@ -46,48 +50,39 @@ export class BaseHtmlDriver extends Driver {
     }
     render(block) {
         const result = super.render(block);
-        if (gBlinkingEffect)
-            blink(block.native, VBlock.currentRenderingPriority, block.stamp);
+        if (gBlinkingEffectMarker)
+            blink(block.native, Verstak.currentRenderingPriority, block.descriptor.stamp);
         return result;
     }
-    static get blinkingEffect() {
-        return gBlinkingEffect;
+    static get blinkingEffectMarker() {
+        return gBlinkingEffectMarker;
     }
-    static set blinkingEffect(value) {
-        if (value === undefined) {
-            const effect = gBlinkingEffect;
-            VBlock.runForAllBlocks((e) => {
-                if (e instanceof HTMLElement) {
-                    e.classList.remove(`${effect}-0-0`, `${effect}-0-1`);
-                    e.classList.remove(`${effect}-1-0`, `${effect}-1-1`);
-                    e.classList.remove(`${effect}-2-0`, `${effect}-2-1`);
-                }
-            });
-        }
-        gBlinkingEffect = value;
+    static set blinkingEffectMarker(value) {
+        gBlinkingEffectMarker = value;
     }
-    static findNearestParentHtmlBlock(block) {
-        let p = block.host;
-        while (p.native instanceof HTMLElement === false && p !== block)
-            p = p.host;
+    static findEffectiveHtmlBlockHost(block) {
+        let p = block.descriptor.host;
+        while (p.native instanceof HTMLElement === false &&
+            p.native instanceof SVGElement === false && p !== block)
+            p = p.descriptor.host;
         return p;
     }
     static findPrevSiblingHtmlBlock(item) {
         let p = item.prev;
-        while (p && !(p.instance.native instanceof HTMLElement))
+        while (p && !(p.instance.native instanceof HTMLElement) && !(p.instance.native instanceof SVGElement))
             p = p.prev;
         return p;
     }
 }
 export class HtmlDriver extends BaseHtmlDriver {
     create(block, b) {
-        b.native = document.createElement(block.driver.name);
+        b.native = document.createElement(block.descriptor.driver.name);
         super.create(block, b);
     }
 }
 export class SvgDriver extends BaseHtmlDriver {
     create(block, b) {
-        b.native = document.createElementNS("http://www.w3.org/2000/svg", block.driver.name);
+        b.native = document.createElementNS("http://www.w3.org/2000/svg", block.descriptor.driver.name);
         super.create(block, b);
     }
 }
@@ -95,9 +90,9 @@ function blink(e, priority, revision) {
     if (e !== undefined) {
         const n1 = revision % 2;
         const n2 = 1 >> n1;
-        const effect = gBlinkingEffect;
-        e.classList.toggle(`${effect}-${priority}-${n1}`, true);
-        e.classList.toggle(`${effect}-${priority}-${n2}`, false);
+        const bem = gBlinkingEffectMarker;
+        e.classList.toggle(`${bem}${priority}${n1}`, true);
+        e.classList.toggle(`${bem}${priority}${n2}`, false);
     }
 }
-let gBlinkingEffect = undefined;
+let gBlinkingEffectMarker = undefined;

package/build/dist/source/html/ReactingFocuser.d.ts

@@ -1,2 +1,2 @@
 import { FocusModel } from "./sensors/FocusSensor";
-export declare function ReactingFocuser(key: string, target: HTMLElement, model: FocusModel, switchEditMode?: ((model?: FocusModel) => void) | undefined): void;
+export declare function FocuserReaction(key: string, target: HTMLElement, model: FocusModel, switchEditMode?: ((model?: FocusModel) => void) | undefined): void;

package/build/dist/source/html/ReactingFocuser.js

@@ -1,8 +1,9 @@
-import { Fragment } from "../core/api";
-export function ReactingFocuser(key, target, model, switchEditMode = undefined) {
+import { Mode } from "../core/api";
+import { Fragment } from "./Blocks";
+export function FocuserReaction(key, target, model, switchEditMode = undefined) {
     Fragment({
         key,
-        reaction: true,
+        mode: Mode.PinpointRefresh,
         triggers: { target, model },
         initialize(b) {
             b.configureReactronic({ throttling: 0 });

package/build/dist/source/html/sensors/ResizeSensor.d.ts

@@ -1,4 +1,4 @@
-import { VBlock } from "../../core/api";
+import { Block } from "../../core/api";
 import { Sensor } from "./Sensor";
 export interface ResizedElement {
     readonly borderBoxSize: ReadonlyArray<ResizeObserverSize>;
@@ -11,7 +11,7 @@ export declare class ResizeSensor extends Sensor {
     resizedElements: Array<ResizedElement>;
     constructor();
     reset(): void;
-    observeResizing(block: VBlock<any, any, any>, value: boolean, boxSizing?: ResizeObserverBoxOptions): void;
+    observeResizing(block: Block<any, any, any>, value: boolean, boxSizing?: ResizeObserverBoxOptions): void;
     protected onResize(entries: Array<ResizeObserverEntry>): void;
     protected resize(entries: Array<ResizeObserverEntry>): void;
     protected doReset(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "verstak",
-  "version": "0.23.107",
+  "version": "0.23.109",
   "description": "Verstak - Front-End Library",
   "publisher": "Nezaboodka Software",
   "license": "Apache-2.0",

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

@@ -1,11 +0,0 @@
-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;
-export declare function emitLetters(n: number): string;
-export declare function emitCellPosition(x: number, y: number): string;
-export declare function equalCellRanges(a: CellRange, b: CellRange): boolean;

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

@@ -1,176 +0,0 @@
-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}` : ""}`;
-}
-export 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;
-}
-export 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;
-}
-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;
-}
-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;
-}

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

@@ -1,50 +0,0 @@
-import { CellRange } from "./CellRange";
-export declare enum Align {
-    Stretch = 0,
-    Left = 1,
-    CenterX = 2,
-    Right = 3,
-    Top = 4,
-    CenterY = 8,
-    Bottom = 12,
-    Default = 16,
-    Center = 10
-}
-export interface ElasticSize {
-    cells?: number;
-    min?: string;
-    max?: string;
-    growth?: number;
-}
-export interface TrackSize extends ElasticSize {
-    track?: string | number;
-}
-export type Placement = undefined | string | {
-    widthInCells?: number;
-    heightInCells?: number;
-    widthOverlap?: boolean;
-    heightOverlap?: boolean;
-};
-export declare class Cursor {
-    static readonly UndefinedCellRange: Readonly<{
-        x1: 0;
-        y1: 0;
-        x2: 0;
-        y2: 0;
-    }>;
-    reset(): void;
-    onwards(placement: Placement): CellRange;
-    rowBreak(): void;
-}
-export declare class TableCursor extends Cursor {
-    private maxColumnCount;
-    private maxRowCount;
-    private actualColumnCount;
-    private actualRowCount;
-    private columnCursor;
-    private rowCursor;
-    private newRowCursor;
-    reset(): void;
-    onwards(placement: Placement): CellRange;
-    rowBreak(): void;
-}

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

@@ -1,121 +0,0 @@
-import { parseCellRange } from "./CellRange";
-export var Align;
-(function (Align) {
-    Align[Align["Stretch"] = 0] = "Stretch";
-    Align[Align["Left"] = 1] = "Left";
-    Align[Align["CenterX"] = 2] = "CenterX";
-    Align[Align["Right"] = 3] = "Right";
-    Align[Align["Top"] = 4] = "Top";
-    Align[Align["CenterY"] = 8] = "CenterY";
-    Align[Align["Bottom"] = 12] = "Bottom";
-    Align[Align["Default"] = 16] = "Default";
-    Align[Align["Center"] = 10] = "Center";
-})(Align || (Align = {}));
-export class Cursor {
-    reset() { }
-    onwards(placement) { return Cursor.UndefinedCellRange; }
-    rowBreak() { }
-}
-Cursor.UndefinedCellRange = Object.freeze({ x1: 0, y1: 0, x2: 0, y2: 0 });
-export class TableCursor 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(placement) {
-        var _a, _b, _c, _d;
-        let result;
-        if (typeof (placement) === "string") {
-            result = parseCellRange(placement, { 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 w;
-            let h;
-            let wOverlap;
-            let hOverlap;
-            if (placement) {
-                w = (_a = placement.widthInCells) !== null && _a !== void 0 ? _a : 1;
-                h = (_b = placement.heightInCells) !== null && _b !== void 0 ? _b : 1;
-                wOverlap = (_c = placement.widthOverlap) !== null && _c !== void 0 ? _c : false;
-                hOverlap = (_d = placement.heightOverlap) !== null && _d !== void 0 ? _d : false;
-            }
-            else {
-                w = 1;
-                h = 1;
-                wOverlap = hOverlap = 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 (w === 0)
-                w = totalColumnCount || 1;
-            if (w >= 0) {
-                result.x1 = this.columnCursor + 1;
-                result.x2 = absolutizePosition(result.x1 + w - 1, 0, this.maxColumnCount || Infinity);
-                if (!wOverlap)
-                    this.columnCursor = result.x2;
-            }
-            else {
-                result.x1 = Math.max(this.columnCursor + w, 1);
-                result.x2 = this.columnCursor;
-            }
-            if (h === 0)
-                h = totalRowCount || 1;
-            if (h >= 0) {
-                result.y1 = this.rowCursor + 1;
-                result.y2 = absolutizePosition(result.y1 + h - 1, 0, this.maxRowCount || Infinity);
-                if (!hOverlap && result.y2 > this.newRowCursor)
-                    this.newRowCursor = result.y2;
-            }
-            else {
-                result.y1 = Math.max(this.rowCursor + h, 1);
-                result.y2 = this.rowCursor;
-            }
-        }
-        return result;
-    }
-    rowBreak() {
-        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;
-}