verstak 0.22.412 → 0.22.500

package/build/dist/source/{html/CellRange.js → core/Layout.js}

@@ -1,4 +1,64 @@
-export class CellRangeUtils {
+export class Layout {
+    constructor() {
+        this.maxColumnCount = 0;
+        this.maxRowCount = 0;
+        this.actualColumnCount = 0;
+        this.actualRowCount = 0;
+        this.columnCursor = 0;
+        this.rowCursor = 0;
+        this.newRowCursor = 0;
+    }
+    reset(maxColumnCount, maxRowCount) {
+        this.maxColumnCount = maxColumnCount;
+        this.maxRowCount = maxRowCount;
+        this.actualColumnCount = 0;
+        this.actualRowCount = 0;
+        this.columnCursor = 0;
+        this.rowCursor = 0;
+        this.newRowCursor = 0;
+    }
+    claim(p, result) {
+        var _a, _b;
+        const maxColumnCount = this.maxColumnCount !== 0 ? this.maxColumnCount : this.actualColumnCount;
+        const maxRowCount = this.maxRowCount !== 0 ? this.maxRowCount : this.actualRowCount;
+        if (p.area) {
+            Layout.parseCellRange(p.area, result);
+            absolutizeCellRange(result, this.columnCursor + 1, this.rowCursor + 1, maxColumnCount, maxRowCount, result);
+        }
+        else {
+            if (p.lineBegin) {
+                this.columnCursor = 0;
+                this.rowCursor = this.newRowCursor;
+            }
+            let w = (_a = p.columns) !== null && _a !== void 0 ? _a : 1;
+            if (w === 0)
+                w = maxColumnCount;
+            if (w >= 0) {
+                result.x1 = this.columnCursor + 1;
+                result.x2 = absolutizePosition(result.x1 + w, 0, maxColumnCount);
+                if (p.cursorRight !== false)
+                    this.columnCursor = result.x2;
+            }
+            else {
+                result.x1 = Math.max(this.columnCursor + w, 1);
+                result.x2 = this.columnCursor;
+            }
+            let h = (_b = p.rows) !== null && _b !== void 0 ? _b : 1;
+            if (h === 0)
+                h = maxRowCount;
+            if (h >= 0) {
+                result.y1 = this.rowCursor + 1;
+                result.y2 = absolutizePosition(result.y1 + h, 0, maxRowCount);
+                if (p.cursorDown !== false && result.y2 > this.newRowCursor)
+                    this.newRowCursor = result.y2;
+            }
+            else {
+                result.y1 = Math.max(this.rowCursor + h, 1);
+                result.y2 = this.rowCursor;
+            }
+        }
+        return result;
+    }
     static parseCellRange(text, result) {
         let i = 0;
         let value = 0;
@@ -131,24 +191,10 @@ export class CellRangeUtils {
         return result;
     }
     static emitCellRange(value) {
-        const p1 = CellRangeUtils.emitCellPos(value.x1, value.y1);
-        const p2 = CellRangeUtils.emitCellPos(value.x2, value.y2);
+        const p1 = emitCellPosition(value.x1, value.y1);
+        const p2 = emitCellPosition(value.x2, value.y2);
         return `${p1}${p2 !== '' ? `:${p2}` : ''}`;
     }
-    static emitCellPos(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;
-    }
 }
 function isWhitespace(char) {
     return char === 32 || (char >= 9 && char <= 13) || char === 133 || char === 160;
@@ -173,3 +219,41 @@ function emitLetters(n) {
     }
     return result;
 }
+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;
+}
+function absolutizeCellRange(area, cursorX, cursorY, maxWidth, maxHeight, result) {
+    const x1 = absolutizePosition(area.x1, cursorX, maxWidth);
+    const x2 = absolutizePosition(area.x2, cursorX, 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, cursorY, 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;
+}

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

@@ -1,5 +1,5 @@
-export declare function restyler<T>(restyle: () => T): RxStyler<T>;
-export declare class RxStyler<T> {
+export declare function restyler<T>(restyle: () => T): ObservablesStyles<T>;
+export declare class ObservablesStyles<T> {
     private readonly restyle;
     constructor(restyle: () => T);
     protected cache(): T;

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

@@ -9,9 +9,9 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { cached, Transaction } from 'reactronic';
 export function restyler(restyle) {
-    return Transaction.run(null, () => new RxStyler(restyle));
+    return Transaction.run(null, () => new ObservablesStyles(restyle));
 }
-export class RxStyler {
+export class ObservablesStyles {
     constructor(restyle) {
         this.restyle = restyle;
     }
@@ -27,4 +27,4 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", []),
     __metadata("design:returntype", Object)
-], RxStyler.prototype, "cache", null);
+], ObservablesStyles.prototype, "cache", null);

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

@@ -1,4 +1,5 @@
-export * from './RxNode';
+export * from './Utils';
+export * from './Layout';
+export * from './Block';
 export * from './Elements';
 export * from './Restyler';
-export * from './Utils';

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

@@ -1,4 +1,5 @@
-export * from './RxNode';
+export * from './Utils';
+export * from './Layout';
+export * from './Block';
 export * from './Elements';
 export * from './Restyler';
-export * from './Utils';

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

@@ -0,0 +1,11 @@
+import { Block, Render, Place, BlockOptions } from '../core/api';
+export interface ElasticSize {
+    line: string | number;
+    min?: string;
+    max?: string;
+    growth?: number;
+}
+export declare function InlBlock<M = unknown, R = void>(name: string, options: BlockOptions<Place> | undefined, renderer: Render<HTMLDivElement, M, Place, R>): Block<HTMLDivElement, M, Place, R>;
+export declare function RxBlock<M = unknown, R = void>(name: string, options: BlockOptions<Place> | undefined, renderer: Render<HTMLDivElement, M, Place, R>): Block<HTMLDivElement, M, Place, R>;
+export declare function InlCluster<M = unknown, R = void>(name: string, options: BlockOptions | undefined, renderer: Render<HTMLDivElement, M, void, R>): Block<HTMLDivElement, M, void, R>;
+export declare function RxCluster<M = unknown, R = void>(name: string, options: BlockOptions | undefined, renderer: Render<HTMLDivElement, M, void, R>): Block<HTMLDivElement, M, void, R>;

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

@@ -0,0 +1,14 @@
+import { Reaction, Inline } from '../core/api';
+import { Div, RxDiv } from './HtmlElements';
+export function InlBlock(name, options, renderer) {
+    return Div(name, options, renderer);
+}
+export function RxBlock(name, options, renderer) {
+    return RxDiv(name, options, renderer);
+}
+export function InlCluster(name, options, renderer) {
+    return Inline(name, options, renderer);
+}
+export function RxCluster(name, options, renderer) {
+    return Reaction(name, options, renderer);
+}