verstak 0.22.412 → 0.22.503

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

@@ -0,0 +1,504 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { reactive, nonreactive, Transaction, options, Reentrance, Rx, Collection } from "reactronic";
+import { Allocator, To } from "./Allocator";
+export var Priority;
+(function (Priority) {
+    Priority[Priority["SyncP0"] = 0] = "SyncP0";
+    Priority[Priority["AsyncP1"] = 1] = "AsyncP1";
+    Priority[Priority["AsyncP2"] = 2] = "AsyncP2";
+})(Priority || (Priority = {}));
+export class VBlock {
+    baseRender() {
+        return callRenderFunctions(this);
+    }
+    get isInitialRendering() {
+        return this.stamp === 2;
+    }
+    static root(render) {
+        gSysRoot.instance.args.render = render;
+        prepareAndRunRender(gSysRoot, false, false);
+    }
+    static get current() {
+        return gContext.instance;
+    }
+    static renderNestedTreesThenDo(action) {
+        runRenderNestedTreesThenDo(undefined, action);
+    }
+    static runForAllBlocks(action) {
+        forEachChildRecursively(gSysRoot, action);
+    }
+    static claim(name, args, driver) {
+        var _a, _b;
+        let result;
+        const owner = gContext.instance;
+        const children = owner.children;
+        let existing = undefined;
+        driver !== null && driver !== void 0 ? driver : (driver = AbstractDriver.group);
+        name || (name = `${++owner.numerator}`);
+        if (driver.isLine) {
+            const last = children.lastClaimedItem();
+            if (((_a = last === null || last === void 0 ? void 0 : last.instance) === null || _a === void 0 ? void 0 : _a.driver) === driver)
+                existing = last;
+        }
+        existing !== null && existing !== void 0 ? existing : (existing = children.claim(name));
+        if (existing) {
+            result = existing.instance;
+            if (result.driver !== driver && driver !== undefined)
+                throw new Error(`changing block driver is not yet supported: "${result.driver.name}" -> "${driver === null || driver === void 0 ? void 0 : driver.name}"`);
+            const exTriggers = (_b = result.args) === null || _b === void 0 ? void 0 : _b.triggers;
+            if (triggersAreEqual(args.triggers, exTriggers))
+                args.triggers = exTriggers;
+            result.args = args;
+        }
+        else {
+            result = new VBlockImpl(name, driver, owner, args);
+            result.item = children.add(result);
+            VBlockImpl.grandCount++;
+            if (args.reacting)
+                VBlockImpl.disposableCount++;
+        }
+        return result;
+    }
+    static getDefaultLoggingOptions() {
+        return VBlockImpl.logging;
+    }
+    static setDefaultLoggingOptions(logging) {
+        VBlockImpl.logging = logging;
+    }
+}
+VBlock.shortFrameDuration = 16;
+VBlock.longFrameDuration = 300;
+VBlock.currentRenderingPriority = Priority.SyncP0;
+VBlock.frameDuration = VBlock.longFrameDuration;
+export var LayoutKind;
+(function (LayoutKind) {
+    LayoutKind[LayoutKind["Block"] = 0] = "Block";
+    LayoutKind[LayoutKind["Grid"] = 1] = "Grid";
+    LayoutKind[LayoutKind["Line"] = 2] = "Line";
+    LayoutKind[LayoutKind["Group"] = 3] = "Group";
+    LayoutKind[LayoutKind["Text"] = 4] = "Text";
+})(LayoutKind || (LayoutKind = {}));
+const createDefaultAllocator = () => new Allocator();
+export class AbstractDriver {
+    constructor(name, layout, createAllocator) {
+        this.name = name;
+        this.layout = layout;
+        this.createAllocator = createAllocator !== null && createAllocator !== void 0 ? createAllocator : createDefaultAllocator;
+    }
+    get isSequential() { return (this.layout & 1) === 0; }
+    get isAuxiliary() { return (this.layout & 2) === 2; }
+    get isBlock() { return this.layout === LayoutKind.Block; }
+    get isGrid() { return this.layout === LayoutKind.Grid; }
+    get isLine() { return this.layout === LayoutKind.Line; }
+    initialize(block, native) {
+        const b = block;
+        b.native = native;
+    }
+    finalize(block, isLeader) {
+        const b = block;
+        b.native = undefined;
+        return isLeader;
+    }
+    deploy(block, sequential) {
+    }
+    arrange(block, place, heightGrab) {
+        var _a, _b, _c;
+        const b = block;
+        if (heightGrab === undefined) {
+            b.place = place;
+            const host = b.host;
+            if (host.driver.isLine) {
+                const grab = (_a = place === null || place === void 0 ? void 0 : place.heightGrab) !== null && _a !== void 0 ? _a : 0;
+                if (grab > 0 && ((_c = (_b = host.place) === null || _b === void 0 ? void 0 : _b.heightGrab) !== null && _c !== void 0 ? _c : 0) < grab)
+                    host.driver.arrange(host, undefined, grab);
+            }
+        }
+        else if (heightGrab > 0) {
+            if (b.place === undefined)
+                b.place = {
+                    exact: undefined,
+                    widthMin: "", widthMax: "", widthGrab: 0,
+                    heightMin: "", heightMax: "", heightGrab,
+                    align: To.Default,
+                    dock: To.Default,
+                };
+            else
+                b.place.heightGrab = heightGrab;
+        }
+    }
+    render(block) {
+        var _a;
+        let result;
+        const wrapper = (_a = block.args) === null || _a === void 0 ? void 0 : _a.wrapper;
+        if (wrapper)
+            result = wrapper(block.native, block);
+        else
+            result = callRenderFunctions(block);
+        return result;
+    }
+}
+AbstractDriver.group = new AbstractDriver("group", LayoutKind.Group);
+function callRenderFunctions(block) {
+    var _a;
+    const uses = (_a = block.args) === null || _a === void 0 ? void 0 : _a.mixins;
+    if (uses)
+        for (const use of uses)
+            use(block.native, block);
+    return block.args.render(block.native, block);
+}
+export class StaticDriver extends AbstractDriver {
+    constructor(element, name, layout, createAllocator) {
+        super(name, layout, createAllocator);
+        this.element = element;
+    }
+    initialize(block, element) {
+        super.initialize(block, this.element);
+    }
+}
+function getBlockName(block) {
+    return block.stamp >= 0 ? block.name : undefined;
+}
+class VBlockImpl extends VBlock {
+    constructor(name, driver, owner, options) {
+        super();
+        this.name = name;
+        this.driver = driver;
+        this.args = options;
+        this.model = undefined;
+        this.level = owner.level + 1;
+        this.host = owner;
+        this.children = new Collection(driver.isSequential, getBlockName);
+        this.numerator = 0;
+        this.item = undefined;
+        this.stamp = 0;
+        this.native = undefined;
+        this.place = undefined;
+        this.allocator = driver.createAllocator();
+    }
+    rerender(_triggers) {
+        runRender(this.item);
+    }
+}
+VBlockImpl.grandCount = 0;
+VBlockImpl.disposableCount = 0;
+VBlockImpl.logging = undefined;
+__decorate([
+    reactive,
+    options({
+        reentrance: Reentrance.CancelPrevious,
+        triggeringArgs: true,
+        noSideEffects: false,
+    }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", void 0)
+], VBlockImpl.prototype, "rerender", null);
+function runRenderNestedTreesThenDo(error, action) {
+    var _a;
+    const context = gContext;
+    const owner = context.instance;
+    const children = owner.children;
+    if (children.isMergeInProgress) {
+        let promised = undefined;
+        try {
+            children.endMerge(error);
+            for (const item of children.removedItems(true))
+                runFinalize(item, true);
+            if (!error) {
+                const isBlockOwner = owner.driver.isBlock;
+                const sequential = children.strict;
+                const allocator = owner.allocator;
+                allocator.reset();
+                let p1 = undefined;
+                let p2 = undefined;
+                let redeploy = false;
+                let lineHost = owner;
+                for (const item of children.items()) {
+                    if (Transaction.isCanceled)
+                        break;
+                    const block = item.instance;
+                    const driver = block.driver;
+                    const opt = block.args;
+                    if (!driver.isLine) {
+                        const place = allocator.allocate(opt);
+                        driver.arrange(block, place, undefined);
+                    }
+                    else
+                        allocator.lineFeed();
+                    const host = driver.isLine ? owner : lineHost;
+                    redeploy = markToRedeployIfNecessary(redeploy, host, item, children, sequential);
+                    const priority = (_a = opt === null || opt === void 0 ? void 0 : opt.priority) !== null && _a !== void 0 ? _a : Priority.SyncP0;
+                    if (priority === Priority.SyncP0)
+                        prepareAndRunRender(item, children.isMoved(item), sequential);
+                    else if (priority === Priority.AsyncP1)
+                        p1 = push(item, p1);
+                    else
+                        p2 = push(item, p2);
+                    if (isBlockOwner && driver.isLine)
+                        lineHost = block;
+                }
+                if (!Transaction.isCanceled && (p1 !== undefined || p2 !== undefined))
+                    promised = startIncrementalRendering(context, children, p1, p2).then(() => action(error), e => action(e));
+            }
+        }
+        finally {
+            if (!promised)
+                action(error);
+        }
+    }
+}
+function markToRedeployIfNecessary(redeploy, host, item, children, sequential) {
+    const block = item.instance;
+    if (block.native) {
+        if (redeploy || block.host !== host) {
+            children.markAsMoved(item);
+            redeploy = false;
+        }
+    }
+    else if (sequential && children.isMoved(item))
+        redeploy = true;
+    block.host = host;
+    return redeploy;
+}
+function startIncrementalRendering(owner, allChildren, priority1, priority2) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const stamp = owner.instance.stamp;
+        if (priority1)
+            yield renderIncrementally(owner, stamp, allChildren, priority1, Priority.AsyncP1);
+        if (priority2)
+            yield renderIncrementally(owner, stamp, allChildren, priority2, Priority.AsyncP2);
+    });
+}
+function renderIncrementally(owner, stamp, allChildren, items, priority) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Transaction.requestNextFrame();
+        const block = owner.instance;
+        if (!Transaction.isCanceled || !Transaction.isFrameOver(1, VBlock.shortFrameDuration / 3)) {
+            let outerPriority = VBlock.currentRenderingPriority;
+            VBlock.currentRenderingPriority = priority;
+            try {
+                const sequential = block.children.strict;
+                if ((_a = block.args) === null || _a === void 0 ? void 0 : _a.shuffle)
+                    shuffle(items);
+                const frameDurationLimit = priority === Priority.AsyncP2 ? VBlock.shortFrameDuration : Infinity;
+                let frameDuration = Math.min(frameDurationLimit, Math.max(VBlock.frameDuration / 4, VBlock.shortFrameDuration));
+                for (const child of items) {
+                    prepareAndRunRender(child, allChildren.isMoved(child), sequential);
+                    if (Transaction.isFrameOver(1, frameDuration)) {
+                        VBlock.currentRenderingPriority = outerPriority;
+                        yield Transaction.requestNextFrame(0);
+                        outerPriority = VBlock.currentRenderingPriority;
+                        VBlock.currentRenderingPriority = priority;
+                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, VBlock.frameDuration));
+                    }
+                    if (Transaction.isCanceled && Transaction.isFrameOver(1, VBlock.shortFrameDuration / 3))
+                        break;
+                }
+            }
+            finally {
+                VBlock.currentRenderingPriority = outerPriority;
+            }
+        }
+    });
+}
+function prepareAndRunRender(item, redeploy, sequential) {
+    var _a, _b;
+    const block = item.instance;
+    if (block.stamp >= 0) {
+        prepareRender(item, redeploy, sequential);
+        if ((_a = block.args) === null || _a === void 0 ? void 0 : _a.reacting)
+            nonreactive(block.rerender, (_b = block.args) === null || _b === void 0 ? void 0 : _b.triggers);
+        else
+            runRender(item);
+    }
+}
+function prepareRender(item, redeploy, sequential) {
+    var _a;
+    const block = item.instance;
+    const driver = block.driver;
+    if (block.stamp === 0) {
+        block.stamp = 1;
+        if ((_a = block.args) === null || _a === void 0 ? void 0 : _a.reacting) {
+            Transaction.outside(() => {
+                var _a, _b, _c;
+                if (Rx.isLogging)
+                    Rx.setLoggingHint(block, block.name);
+                Rx.getController(block.rerender).configure({
+                    order: block.level,
+                    monitor: (_a = block.args) === null || _a === void 0 ? void 0 : _a.monitor,
+                    throttling: (_b = block.args) === null || _b === void 0 ? void 0 : _b.throttling,
+                    logging: (_c = block.args) === null || _c === void 0 ? void 0 : _c.logging,
+                });
+            });
+        }
+        driver.initialize(block, undefined);
+        driver.deploy(block, sequential);
+        driver.arrange(block, block.place, undefined);
+    }
+    else if (redeploy)
+        driver.deploy(block, sequential);
+}
+function runRender(item) {
+    const block = item.instance;
+    if (block.stamp >= 0) {
+        runUnder(item, () => {
+            let result = undefined;
+            try {
+                block.stamp++;
+                block.numerator = 0;
+                block.children.beginMerge();
+                result = block.driver.render(block);
+                if (result instanceof Promise)
+                    result.then(v => { runRenderNestedTreesThenDo(undefined, NOP); return v; }, e => { console.log(e); runRenderNestedTreesThenDo(e !== null && e !== void 0 ? e : new Error("unknown error"), NOP); });
+                else
+                    runRenderNestedTreesThenDo(undefined, NOP);
+            }
+            catch (e) {
+                runRenderNestedTreesThenDo(e, NOP);
+                console.log(`Rendering failed: ${block.name}`);
+                console.log(`${e}`);
+            }
+        });
+    }
+}
+function runFinalize(item, isLeader) {
+    var _a;
+    const block = item.instance;
+    if (block.stamp >= 0) {
+        block.stamp = ~block.stamp;
+        const childrenAreLeaders = block.driver.finalize(block, isLeader);
+        if ((_a = block.args) === null || _a === void 0 ? void 0 : _a.reacting) {
+            item.aux = undefined;
+            const last = gLastToDispose;
+            if (last)
+                gLastToDispose = last.aux = item;
+            else
+                gFirstToDispose = gLastToDispose = item;
+            if (gFirstToDispose === item)
+                Transaction.run({ separation: "disposal", hint: `runDisposalLoop(initiator=${item.instance.name})` }, () => {
+                    void runDisposalLoop().then(NOP, error => console.log(error));
+                });
+        }
+        for (const item of block.children.items())
+            runFinalize(item, childrenAreLeaders);
+        VBlockImpl.grandCount--;
+    }
+}
+function runDisposalLoop() {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Transaction.requestNextFrame();
+        let item = gFirstToDispose;
+        while (item !== undefined) {
+            if (Transaction.isFrameOver(500, 5))
+                yield Transaction.requestNextFrame();
+            Rx.dispose(item.instance);
+            item = item.aux;
+            VBlockImpl.disposableCount--;
+        }
+        gFirstToDispose = gLastToDispose = undefined;
+    });
+}
+function forEachChildRecursively(item, action) {
+    const block = item.instance;
+    const native = block.native;
+    native && action(native);
+    for (const item of block.children.items())
+        forEachChildRecursively(item, action);
+}
+function wrap(func) {
+    const ctx = gContext;
+    const wrappedRunUnder = (...args) => {
+        return runUnder(ctx, func, ...args);
+    };
+    return wrappedRunUnder;
+}
+function runUnder(item, func, ...args) {
+    const outer = gContext;
+    try {
+        gContext = item;
+        return func(...args);
+    }
+    finally {
+        gContext = outer;
+    }
+}
+function triggersAreEqual(a1, a2) {
+    let result = a1 === a2;
+    if (!result) {
+        if (Array.isArray(a1)) {
+            result = Array.isArray(a2) &&
+                a1.length === a2.length &&
+                a1.every((t, i) => t === a2[i]);
+        }
+        else if (a1 === Object(a1) && a2 === Object(a2)) {
+            for (const p in a1) {
+                result = a1[p] === a2[p];
+                if (!result)
+                    break;
+            }
+        }
+    }
+    return result;
+}
+function push(item, array) {
+    if (array == undefined)
+        array = new Array();
+    array.push(item);
+    return array;
+}
+function shuffle(array) {
+    const n = array.length - 1;
+    let i = n;
+    while (i >= 0) {
+        const j = Math.floor(Math.random() * n);
+        const t = array[i];
+        array[i] = array[j];
+        array[j] = t;
+        i--;
+    }
+    return array;
+}
+const ORIGINAL_PROMISE_THEN = Promise.prototype.then;
+function reactronicDomHookedThen(resolve, reject) {
+    resolve = resolve ? wrap(resolve) : defaultResolve;
+    reject = reject ? wrap(reject) : defaultReject;
+    return ORIGINAL_PROMISE_THEN.call(this, resolve, reject);
+}
+function defaultResolve(value) {
+    return value;
+}
+function defaultReject(error) {
+    throw error;
+}
+Promise.prototype.then = reactronicDomHookedThen;
+const NOP = () => { };
+const gSysDriver = new StaticDriver(null, "SYSTEM", LayoutKind.Group);
+const gSysRoot = Collection.createItem(new VBlockImpl("SYSTEM", gSysDriver, { level: 0 }, { reacting: true, render: NOP }));
+gSysRoot.instance.item = gSysRoot;
+Object.defineProperty(gSysRoot.instance, "host", {
+    value: gSysRoot.instance,
+    writable: false,
+    configurable: false,
+    enumerable: true,
+});
+let gContext = gSysRoot;
+let gFirstToDispose = undefined;
+let gLastToDispose = undefined;

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

@@ -7,11 +7,11 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { cached, Transaction } from 'reactronic';
+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 './Elements';
-export * from './Restyler';
-export * from './Utils';
+export * from "./Utils";
+export * from "./CellRange";
+export * from "./Allocator";
+export * from "./Kernel";
+export * from "./Restyler";

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

@@ -1,4 +1,5 @@
-export * from './RxNode';
-export * from './Elements';
-export * from './Restyler';
-export * from './Utils';
+export * from "./Utils";
+export * from "./CellRange";
+export * from "./Allocator";
+export * from "./Kernel";
+export * from "./Restyler";

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

@@ -0,0 +1,14 @@
+import { VBlock, Place, BlockArgs } from "../core/api";
+import { HtmlDriver } from "./HtmlDriver";
+export declare function Block<M = unknown, R = void>(name: string, args: BlockArgs<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function PlainText(content: string): VBlock<HTMLElement, void, void>;
+export declare function MdText(content: string): VBlock<HTMLElement, void, void>;
+export declare function HtmlText(content: string): VBlock<HTMLElement, void, void>;
+export declare function Grid<M = unknown, R = void>(name: string, args: BlockArgs<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare function Line<T = void>(claim: (x: void) => T): VBlock<HTMLElement>;
+export declare function lineFeed(args?: BlockArgs<HTMLElement, void, void>, noCoalescing?: boolean): VBlock<HTMLElement>;
+export declare function Group<M = unknown, R = void>(name: string, args: BlockArgs<HTMLElement, M, R>): VBlock<HTMLElement, M, R>;
+export declare class VerstakDriver<T extends HTMLElement> extends HtmlDriver<T> {
+    arrange(block: VBlock<T>, place: Place | undefined, heightGrab: number | undefined): void;
+    render(block: VBlock<T>): void | Promise<void>;
+}