verstak 0.22.512 → 0.22.514

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

@@ -19,8 +19,8 @@ export interface BlockVmt<T = unknown, M = unknown, R = void> {
     render?: Render<T, M, R>;
     finalize?: Render<T, M, R>;
 }
-export declare function asComponent<T, M, R>(outer: BlockBody<T, M, R> | undefined, base: BlockBody<T, M, R>): BlockVmt<T, M, R>;
-export declare function setContext<T extends Object>(type: Type<T>, context: T): void;
+export declare function baseFor<T, M, R>(outer: BlockBody<T, M, R> | undefined, base: BlockBody<T, M, R>): BlockVmt<T, M, R>;
+export declare function defineSubTreeContext<T extends Object>(type: Type<T>, context: T): void;
 export declare function use<T extends Object>(type: Type<T>): T;
 export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     static readonly shortFrameDuration = 16;
@@ -33,16 +33,16 @@ export declare abstract class VBlock<T = unknown, M = unknown, R = void> {
     abstract model: M;
     abstract cells: Cells;
     abstract widthGrowth: number;
-    abstract widthMin: string;
-    abstract widthMax: string;
+    abstract minWidth: string;
+    abstract maxWidth: string;
     abstract heightGrowth: number;
-    abstract heightMin: string;
-    abstract heightMax: string;
-    abstract alignContent: Align;
-    abstract alignFrame: Align;
-    abstract wrapContent: boolean;
-    abstract dangling: boolean;
-    abstract shuffleChildren: boolean;
+    abstract minHeight: string;
+    abstract maxHeight: string;
+    abstract contentAlignment: Align;
+    abstract frameAlignment: Align;
+    abstract contentWrapping: boolean;
+    abstract floating: boolean;
+    abstract childrenShuffling: boolean;
     abstract renderingPriority?: Priority;
     abstract readonly level: number;
     abstract readonly host: VBlock;
@@ -83,15 +83,15 @@ export declare class AbstractDriver<T> {
     deploy(block: VBlock<T>, sequential: boolean): void;
     applyCellRange(block: VBlock<T, any, any>, cellRange: CellRange | undefined): void;
     applyWidthGrowth(block: VBlock<T, any, any>, widthGrowth: number): void;
-    applyWidthMin(block: VBlock<T, any, any>, widthMin: string): void;
-    applyWidthMax(block: VBlock<T, any, any>, widthMax: string): void;
+    applyMinWidth(block: VBlock<T, any, any>, minWidth: string): void;
+    applyMaxWidth(block: VBlock<T, any, any>, maxWidth: string): void;
     applyHeightGrowth(block: VBlock<T, any, any>, heightGrowth: number): void;
-    applyHeightMin(block: VBlock<T, any, any>, heightMin: string): void;
-    applyHeightMax(block: VBlock<T, any, any>, heightMax: string): void;
-    applyAlignContent(block: VBlock<T, any, any>, alignContent: Align): void;
-    applyAlignFrame(block: VBlock<T, any, any>, alignFrame: Align): void;
-    applyWrapContent(block: VBlock<T, any, any>, wrapContent: boolean): void;
-    applyDangling(block: VBlock<T, any, any>, dangling: boolean): void;
+    applyMinHeight(block: VBlock<T, any, any>, minHeight: string): void;
+    applyMaxHeight(block: VBlock<T, any, any>, maxHeight: string): void;
+    applyContentAlignment(block: VBlock<T, any, any>, contentAlignment: Align): void;
+    applyFrameAlignment(block: VBlock<T, any, any>, frameAlignment: Align): void;
+    applyContentWrapping(block: VBlock<T, any, any>, contentWrapping: boolean): void;
+    applyFloating(block: VBlock<T, any, any>, floating: boolean): void;
     render(block: VBlock<T>): void | Promise<void>;
 }
 export declare class StaticDriver<T> extends AbstractDriver<T> {

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

@@ -25,7 +25,7 @@ export var Priority;
     Priority[Priority["AsyncP1"] = 1] = "AsyncP1";
     Priority[Priority["AsyncP2"] = 2] = "AsyncP2";
 })(Priority || (Priority = {}));
-export function asComponent(outer, base) {
+export function baseFor(outer, base) {
     if (outer instanceof Function)
         outer = { render: outer };
     if (base instanceof Function)
@@ -37,8 +37,8 @@ function via(outer, base) {
     const inherited = base !== null && base !== void 0 ? base : NOP;
     return outer ? b => outer(b, () => inherited(b)) : inherited;
 }
-export function setContext(type, context) {
-    return VBlockImpl.setContext(type, context);
+export function defineSubTreeContext(type, context) {
+    return VBlockImpl.defineSubTreeContext(type, context);
 }
 export function use(type) {
     return VBlockImpl.use(type);
@@ -144,23 +144,23 @@ export class AbstractDriver {
     }
     applyWidthGrowth(block, widthGrowth) {
     }
-    applyWidthMin(block, widthMin) {
+    applyMinWidth(block, minWidth) {
     }
-    applyWidthMax(block, widthMax) {
+    applyMaxWidth(block, maxWidth) {
     }
     applyHeightGrowth(block, heightGrowth) {
     }
-    applyHeightMin(block, heightMin) {
+    applyMinHeight(block, minHeight) {
     }
-    applyHeightMax(block, heightMax) {
+    applyMaxHeight(block, maxHeight) {
     }
-    applyAlignContent(block, alignContent) {
+    applyContentAlignment(block, contentAlignment) {
     }
-    applyAlignFrame(block, alignFrame) {
+    applyFrameAlignment(block, frameAlignment) {
     }
-    applyWrapContent(block, wrapContent) {
+    applyContentWrapping(block, contentWrapping) {
     }
-    applyDangling(block, dangling) {
+    applyFloating(block, floating) {
     }
     render(block) {
         var _a;
@@ -212,16 +212,16 @@ class VBlockImpl extends VBlock {
         this.assignedCells = undefined;
         this.appliedCellRange = Cursor.UndefinedCellRange;
         this.appliedWidthGrowth = 0;
-        this.appliedWidthMin = "";
-        this.appliedWidthMax = "";
+        this.appliedMinWidth = "";
+        this.appliedMaxWidth = "";
         this.appliedHeightGrowth = 0;
-        this.appliedHeightMin = "";
-        this.appliedHeightMax = "";
-        this.appliedAlignContent = Align.Default;
-        this.appliedAlignFrame = Align.Default;
-        this.appliedWrapContent = false;
-        this.appliedDangling = false;
-        this.shuffleChildren = false;
+        this.appliedMinHeight = "";
+        this.appliedMaxHeight = "";
+        this.appliedContentAlignment = Align.Default;
+        this.appliedFrameAlignment = Align.Default;
+        this.appliedContentWrapping = false;
+        this.appliedFloating = false;
+        this.childrenShuffling = false;
         this.renderingPriority = Priority.SyncP0;
         this.level = owner.level + 1;
         this.host = owner;
@@ -255,18 +255,18 @@ class VBlockImpl extends VBlock {
             this.appliedWidthGrowth = value;
         }
     }
-    get widthMin() { return this.appliedWidthMin; }
-    set widthMin(value) {
-        if (value !== this.appliedWidthMin) {
-            this.driver.applyWidthMin(this, value);
-            this.appliedWidthMin = value;
+    get minWidth() { return this.appliedMinWidth; }
+    set minWidth(value) {
+        if (value !== this.appliedMinWidth) {
+            this.driver.applyMinWidth(this, value);
+            this.appliedMinWidth = value;
         }
     }
-    get widthMax() { return this.appliedWidthMax; }
-    set widthMax(value) {
-        if (value !== this.appliedWidthMax) {
-            this.driver.applyWidthMax(this, value);
-            this.appliedWidthMax = value;
+    get maxWidth() { return this.appliedMaxWidth; }
+    set maxWidth(value) {
+        if (value !== this.appliedMaxWidth) {
+            this.driver.applyMaxWidth(this, value);
+            this.appliedMaxWidth = value;
         }
     }
     get heightGrowth() { return this.appliedHeightGrowth; }
@@ -276,46 +276,46 @@ class VBlockImpl extends VBlock {
             this.appliedHeightGrowth = value;
         }
     }
-    get heightMin() { return this.appliedHeightMin; }
-    set heightMin(value) {
-        if (value !== this.appliedWidthMin) {
-            this.driver.applyWidthMin(this, value);
-            this.appliedWidthMin = value;
+    get minHeight() { return this.appliedMinHeight; }
+    set minHeight(value) {
+        if (value !== this.appliedMinWidth) {
+            this.driver.applyMinWidth(this, value);
+            this.appliedMinWidth = value;
         }
     }
-    get heightMax() { return this.appliedHeightMax; }
-    set heightMax(value) {
-        if (value !== this.appliedWidthMax) {
-            this.driver.applyWidthMax(this, value);
-            this.appliedWidthMax = value;
+    get maxHeight() { return this.appliedMaxHeight; }
+    set maxHeight(value) {
+        if (value !== this.appliedMaxWidth) {
+            this.driver.applyMaxWidth(this, value);
+            this.appliedMaxWidth = value;
         }
     }
-    get alignContent() { return this.appliedAlignContent; }
-    set alignContent(value) {
-        if (value !== this.appliedAlignContent) {
-            this.driver.applyAlignContent(this, value);
-            this.appliedAlignContent = value;
+    get contentAlignment() { return this.appliedContentAlignment; }
+    set contentAlignment(value) {
+        if (value !== this.appliedContentAlignment) {
+            this.driver.applyContentAlignment(this, value);
+            this.appliedContentAlignment = value;
         }
     }
-    get alignFrame() { return this.appliedAlignFrame; }
-    set alignFrame(value) {
-        if (value !== this.appliedAlignFrame) {
-            this.driver.applyAlignFrame(this, value);
-            this.appliedAlignFrame = value;
+    get frameAlignment() { return this.appliedFrameAlignment; }
+    set frameAlignment(value) {
+        if (value !== this.appliedFrameAlignment) {
+            this.driver.applyFrameAlignment(this, value);
+            this.appliedFrameAlignment = value;
         }
     }
-    get wrapContent() { return this.appliedWrapContent; }
-    set wrapContent(value) {
-        if (value !== this.appliedWrapContent) {
-            this.driver.applyWrapContent(this, value);
-            this.appliedWrapContent = value;
+    get contentWrapping() { return this.appliedContentWrapping; }
+    set contentWrapping(value) {
+        if (value !== this.appliedContentWrapping) {
+            this.driver.applyContentWrapping(this, value);
+            this.appliedContentWrapping = value;
         }
     }
-    get dangling() { return this.appliedDangling; }
-    set dangling(value) {
-        if (value !== this.appliedDangling) {
-            this.driver.applyDangling(this, value);
-            this.appliedDangling = value;
+    get floating() { return this.appliedFloating; }
+    set floating(value) {
+        if (value !== this.appliedFloating) {
+            this.driver.applyFloating(this, value);
+            this.appliedFloating = value;
         }
     }
     configureReactronic(options) {
@@ -332,7 +332,7 @@ class VBlockImpl extends VBlock {
             throw new Error(`${type.name} context doesn't exist`);
         return (_b = b.context) === null || _b === void 0 ? void 0 : _b.instance;
     }
-    static setContext(type, context) {
+    static defineSubTreeContext(type, context) {
         const block = gCurrent.instance;
         const host = block.host;
         const hostCtx = nonreactive(() => { var _a; return (_a = host.context) === null || _a === void 0 ? void 0 : _a.instance; });
@@ -449,7 +449,7 @@ function renderIncrementally(owner, stamp, allChildren, items, priority) {
             VBlock.currentRenderingPriority = priority;
             try {
                 const sequential = block.children.strict;
-                if (block.shuffleChildren)
+                if (block.childrenShuffling)
                     shuffle(items);
                 const frameDurationLimit = priority === Priority.AsyncP2 ? VBlock.shortFrameDuration : Infinity;
                 let frameDuration = Math.min(frameDurationLimit, Math.max(VBlock.frameDuration / 4, VBlock.shortFrameDuration));

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

@@ -1,8 +1,8 @@
 import { VBlock, BlockBody, Align, CellRange } from "../core/api";
 import { HtmlDriver } from "./HtmlDriver";
-export declare function Block<M = unknown, R = void>(name: string, args: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
-export declare function PlainText(content: string, name?: string, args?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
-export declare function HtmlText(content: string, name?: string, args?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
+export declare function Block<M = unknown, R = void>(name: string, body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function PlainText(content: string, name?: string, body?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
+export declare function HtmlText(content: string, name?: string, body?: BlockBody<HTMLElement, void, void>): VBlock<HTMLElement, void, void>;
 export declare function Grid<M = unknown, R = void>(name: string, body: BlockBody<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
 export declare function Line<T = void>(claim: (x: void) => T): VBlock<HTMLElement>;
 export declare function lineFeed(body?: BlockBody<HTMLElement, void, void>, noCoalescing?: boolean): VBlock<HTMLElement>;
@@ -10,14 +10,14 @@ export declare function Group<M = unknown, R = void>(name: string, body: BlockBo
 export declare class VerstakDriver<T extends HTMLElement> extends HtmlDriver<T> {
     applyCellRange(block: VBlock<T>, cellRange: CellRange | undefined): void;
     applyWidthGrowth(block: VBlock<T>, widthGrowth: number): void;
-    applyWidthMin(block: VBlock<T>, widthMin: string): void;
-    applyWidthMax(block: VBlock<T>, widthMax: string): void;
+    applyMinWidth(block: VBlock<T>, minWidth: string): void;
+    applyMaxWidth(block: VBlock<T>, maxWidth: string): void;
     applyHeightGrowth(block: VBlock<T>, heightGrowth: number): void;
-    applyHeightMin(block: VBlock<T>, heightMin: string): void;
-    applyHeightMax(block: VBlock<T>, heightMax: string): void;
-    applyAlignContent(block: VBlock<T>, alignContent: Align): void;
-    applyAlignFrame(block: VBlock<T>, alignFrame: Align): void;
-    applyWrapContent(block: VBlock<T>, wrapContent: boolean): void;
-    applyDangling(block: VBlock<T>, dangling: boolean): void;
+    applyMinHeight(block: VBlock<T>, minHeight: string): void;
+    applyMaxHeight(block: VBlock<T>, maxHeight: string): void;
+    applyContentAlignment(block: VBlock<T>, contentAlign: Align): void;
+    applyFrameAlignment(block: VBlock<T>, frameAlign: Align): void;
+    applyContentWrapping(block: VBlock<T>, contentWrapping: boolean): void;
+    applyFloating(block: VBlock<T>, floating: boolean): void;
     render(block: VBlock<T>): void | Promise<void>;
 }

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

@@ -1,17 +1,17 @@
-import { VBlock, LayoutKind, Align, GridCursor, asComponent } from "../core/api";
+import { VBlock, LayoutKind, Align, GridCursor, baseFor } from "../core/api";
 import { HtmlDriver } from "./HtmlDriver";
-export function Block(name, args) {
-    return VBlock.claim(name, VerstakTags.block, args);
+export function Block(name, body) {
+    return VBlock.claim(name, VerstakTags.block, body);
 }
-export function PlainText(content, name, args) {
-    return VBlock.claim(name !== null && name !== void 0 ? name : "", VerstakTags.text, asComponent(args, {
+export function PlainText(content, name, body) {
+    return VBlock.claim(name !== null && name !== void 0 ? name : "", VerstakTags.text, baseFor(body, {
         render(b) {
             b.native.innerText = content;
         },
     }));
 }
-export function HtmlText(content, name, args) {
-    return VBlock.claim(name !== null && name !== void 0 ? name : "", VerstakTags.text, asComponent(args, {
+export function HtmlText(content, name, body) {
+    return VBlock.claim(name !== null && name !== void 0 ? name : "", VerstakTags.text, baseFor(body, {
         render(b) {
             b.native.innerHTML = content;
         },
@@ -57,11 +57,11 @@ export class VerstakDriver extends HtmlDriver {
             css.flexBasis = "";
         }
     }
-    applyWidthMin(block, widthMin) {
-        block.native.style.minWidth = `${widthMin}`;
+    applyMinWidth(block, minWidth) {
+        block.native.style.minWidth = `${minWidth}`;
     }
-    applyWidthMax(block, widthMax) {
-        block.native.style.maxWidth = `${widthMax}`;
+    applyMaxWidth(block, maxWidth) {
+        block.native.style.maxWidth = `${maxWidth}`;
     }
     applyHeightGrowth(block, heightGrowth) {
         if (block.driver.isRow) {
@@ -72,22 +72,22 @@ export class VerstakDriver extends HtmlDriver {
                 css.flexGrow = "";
         }
         else if (block.host.driver.isRow) {
-            block.driver.applyAlignFrame(block, Align.Stretch);
+            block.driver.applyFrameAlignment(block, Align.Stretch);
             block.host.driver.applyHeightGrowth(block.host, heightGrowth);
         }
     }
-    applyHeightMin(block, heightMin) {
-        block.native.style.minHeight = `${heightMin}`;
+    applyMinHeight(block, minHeight) {
+        block.native.style.minHeight = `${minHeight}`;
     }
-    applyHeightMax(block, heightMax) {
-        block.native.style.maxHeight = `${heightMax}`;
+    applyMaxHeight(block, maxHeight) {
+        block.native.style.maxHeight = `${maxHeight}`;
     }
-    applyAlignContent(block, alignContent) {
+    applyContentAlignment(block, contentAlign) {
         const css = block.native.style;
-        if ((alignContent & Align.Default) === 0) {
-            const v = AlignToCss[(alignContent >> 2) & 0b11];
-            const h = AlignToCss[alignContent & 0b11];
-            const t = TextAlignCss[alignContent & 0b11];
+        if ((contentAlign & Align.Default) === 0) {
+            const v = AlignToCss[(contentAlign >> 2) & 0b11];
+            const h = AlignToCss[contentAlign & 0b11];
+            const t = TextAlignCss[contentAlign & 0b11];
             css.justifyContent = v;
             css.alignItems = h;
             css.textAlign = t;
@@ -95,28 +95,28 @@ export class VerstakDriver extends HtmlDriver {
         else
             css.justifyContent = css.alignContent = css.textAlign = "";
     }
-    applyAlignFrame(block, alignFrame) {
+    applyFrameAlignment(block, frameAlign) {
         const css = block.native.style;
-        if ((alignFrame & Align.Default) === 0) {
-            const v = AlignToCss[(alignFrame >> 2) & 0b11];
-            const h = AlignToCss[alignFrame & 0b11];
+        if ((frameAlign & Align.Default) === 0) {
+            const v = AlignToCss[(frameAlign >> 2) & 0b11];
+            const h = AlignToCss[frameAlign & 0b11];
             css.alignSelf = v;
             css.justifySelf = h;
         }
         else
             css.alignSelf = css.justifySelf = "";
     }
-    applyWrapContent(block, wrapContent) {
-        if (wrapContent)
+    applyContentWrapping(block, contentWrapping) {
+        if (contentWrapping)
             block.native.setAttribute("wrapping", "true");
         else
             block.native.removeAttribute("wrapping");
     }
-    applyDangling(block, dangling) {
-        if (dangling)
-            block.native.setAttribute("dangling", "true");
+    applyFloating(block, floating) {
+        if (floating)
+            block.native.setAttribute("floating", "true");
         else
-            block.native.removeAttribute("dangling");
+            block.native.removeAttribute("floating");
     }
     render(block) {
         if (block.driver.layout < LayoutKind.Row)

package/package.json

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