verstak 0.22.500 → 0.22.503

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

@@ -1,62 +0,0 @@
-import { Monitor, LoggingOptions, Item, CollectionReader } from 'reactronic';
-export declare type Callback<T = unknown> = (impl: T) => void;
-export declare type Render<T = unknown, M = unknown, P = void, R = void> = (impl: T, block: Block<T, M, P, R>) => R;
-export declare type AsyncRender<T = unknown, M = unknown, P = void> = (impl: T, block: Block<T, M, P, Promise<void>>) => Promise<void>;
-export declare const enum Priority {
-    SyncP0 = 0,
-    AsyncP1 = 1,
-    AsyncP2 = 2
-}
-export interface BlockOptions<P = void> {
-    place?: P;
-    triggers?: unknown;
-    priority?: Priority;
-    monitor?: Monitor;
-    throttling?: number;
-    logging?: Partial<LoggingOptions>;
-    shuffle?: boolean;
-}
-export declare abstract class Block<T = unknown, M = unknown, P = void, R = void> {
-    static readonly shortFrameDuration = 16;
-    static readonly longFrameDuration = 300;
-    static currentRenderingPriority: Priority;
-    static frameDuration: number;
-    abstract readonly name: string;
-    abstract readonly factory: BlockFactory<T>;
-    abstract readonly inline: boolean;
-    abstract readonly renderer: Render<T, M, P, R>;
-    abstract readonly wrapper: Render<T, M, P, R> | undefined;
-    abstract readonly options: Readonly<BlockOptions<P>> | undefined;
-    abstract model?: M;
-    abstract readonly level: number;
-    abstract readonly parent: Block;
-    abstract readonly children: CollectionReader<Block>;
-    abstract readonly item: Item<Block> | undefined;
-    abstract readonly stamp: number;
-    abstract readonly impl?: T;
-    render(): R;
-    get isInitialRendering(): boolean;
-    abstract wrapBy(renderer: Render<T, M, P, R> | undefined): this;
-    static root(render: () => void): void;
-    static get current(): Block;
-    static renderChildrenThenDo(action: (error: unknown) => void): void;
-    static forAllBlocksDo<T>(action: (e: T) => void): void;
-    static claim<T = undefined, M = unknown, P = void, R = void>(name: string, inline: boolean, options: BlockOptions<P> | undefined, renderer: Render<T, M, P, R>, factory?: BlockFactory<T>): Block<T, M, P, R>;
-    static getDefaultLoggingOptions(): LoggingOptions | undefined;
-    static setDefaultLoggingOptions(logging?: LoggingOptions): void;
-}
-export declare class BlockFactory<T> {
-    static readonly default: BlockFactory<any>;
-    readonly name: string;
-    readonly strict: boolean;
-    constructor(name: string, strict: boolean);
-    initialize(block: Block<T>, impl: T | undefined): void;
-    finalize(block: Block<T>, isLeader: boolean): boolean;
-    layout(block: Block<T>, strict: boolean): void;
-    render(block: Block<T>): void | Promise<void>;
-}
-export declare class StaticBlockFactory<T> extends BlockFactory<T> {
-    readonly element: T;
-    constructor(name: string, sequential: boolean, element: T);
-    initialize(block: Block<T>, element: T | undefined): void;
-}

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

@@ -1,431 +0,0 @@
-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';
-export var Priority;
-(function (Priority) {
-    Priority[Priority["SyncP0"] = 0] = "SyncP0";
-    Priority[Priority["AsyncP1"] = 1] = "AsyncP1";
-    Priority[Priority["AsyncP2"] = 2] = "AsyncP2";
-})(Priority || (Priority = {}));
-export class Block {
-    render() {
-        return this.renderer(this.impl, this);
-    }
-    get isInitialRendering() {
-        return this.stamp === 2;
-    }
-    static root(render) {
-        gSysRoot.self.renderer = render;
-        prepareThenRunRender(gSysRoot, false, false);
-    }
-    static get current() {
-        return gContext.self;
-    }
-    static renderChildrenThenDo(action) {
-        runRenderChildrenThenDo(undefined, action);
-    }
-    static forAllBlocksDo(action) {
-        forEachChildRecursively(gSysRoot, action);
-    }
-    static claim(name, inline, options, renderer, factory) {
-        var _a;
-        const parent = gContext.self;
-        const children = parent.children;
-        const item = children.claim(name);
-        let block;
-        if (item) {
-            block = item.self;
-            if (block.factory !== factory && factory !== undefined)
-                throw new Error(`changing block type is not yet supported: "${block.factory.name}" -> "${factory === null || factory === void 0 ? void 0 : factory.name}"`);
-            if (options) {
-                const existingTriggers = (_a = block.options) === null || _a === void 0 ? void 0 : _a.triggers;
-                if (triggersAreEqual(options.triggers, existingTriggers))
-                    options.triggers = existingTriggers;
-            }
-            block.options = options;
-            block.renderer = renderer;
-        }
-        else {
-            block = new VerstakBlock(name, factory !== null && factory !== void 0 ? factory : BlockFactory.default, inline !== null && inline !== void 0 ? inline : false, parent, options, renderer, undefined);
-            block.item = children.add(block);
-            VerstakBlock.grandCount++;
-            if (!block.inline)
-                VerstakBlock.disposableCount++;
-        }
-        return block;
-    }
-    static getDefaultLoggingOptions() {
-        return VerstakBlock.logging;
-    }
-    static setDefaultLoggingOptions(logging) {
-        VerstakBlock.logging = logging;
-    }
-}
-Block.shortFrameDuration = 16;
-Block.longFrameDuration = 300;
-Block.currentRenderingPriority = Priority.SyncP0;
-Block.frameDuration = Block.longFrameDuration;
-const NOP = () => { };
-export class BlockFactory {
-    constructor(name, strict) {
-        this.name = name;
-        this.strict = strict;
-    }
-    initialize(block, impl) {
-        const b = block;
-        b.impl = impl;
-    }
-    finalize(block, isLeader) {
-        const b = block;
-        b.impl = undefined;
-        return isLeader;
-    }
-    layout(block, strict) {
-    }
-    render(block) {
-        let result;
-        if (block.wrapper)
-            result = block.wrapper(block.impl, block);
-        else
-            result = block.render();
-        return result;
-    }
-}
-BlockFactory.default = new BlockFactory('default', false);
-export class StaticBlockFactory extends BlockFactory {
-    constructor(name, sequential, element) {
-        super(name, sequential);
-        this.element = element;
-    }
-    initialize(block, element) {
-        super.initialize(block, this.element);
-    }
-}
-function getBlockName(block) {
-    return block.stamp >= 0 ? block.name : undefined;
-}
-class VerstakBlock extends Block {
-    constructor(name, factory, inline, parent, options, renderer, wrapper) {
-        super();
-        this.name = name;
-        this.factory = factory;
-        this.inline = inline;
-        this.options = options;
-        this.renderer = renderer;
-        this.wrapper = wrapper;
-        this.model = undefined;
-        this.level = parent.level + 1;
-        this.parent = parent;
-        this.children = new Collection(factory.strict, getBlockName);
-        this.item = undefined;
-        this.stamp = 0;
-        this.impl = undefined;
-    }
-    autorender(_triggers) {
-        runRender(this.item);
-    }
-    wrapBy(renderer) {
-        this.wrapper = renderer;
-        return this;
-    }
-}
-VerstakBlock.grandCount = 0;
-VerstakBlock.disposableCount = 0;
-VerstakBlock.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)
-], VerstakBlock.prototype, "autorender", null);
-function runRenderChildrenThenDo(error, action) {
-    var _a, _b;
-    const context = gContext;
-    const block = context.self;
-    const children = block.children;
-    if (children.isMergeInProgress) {
-        let promised = undefined;
-        try {
-            children.endMerge(error);
-            for (const child of children.removedItems(true))
-                runFinalize(child, true);
-            if (!error) {
-                const strict = children.strict;
-                let p1 = undefined;
-                let p2 = undefined;
-                let isMoved = false;
-                for (const child of children.items()) {
-                    if (Transaction.isCanceled)
-                        break;
-                    isMoved = checkIsMoved(isMoved, child, children, strict);
-                    const x = child.self;
-                    const priority = (_b = (_a = x.options) === null || _a === void 0 ? void 0 : _a.priority) !== null && _b !== void 0 ? _b : Priority.SyncP0;
-                    if (priority === Priority.SyncP0)
-                        prepareThenRunRender(child, children.isMoved(child), strict);
-                    else if (priority === Priority.AsyncP1)
-                        p1 = push(child, p1);
-                    else
-                        p2 = push(child, p2);
-                }
-                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 checkIsMoved(isMoved, child, children, strict) {
-    if (child.self.impl) {
-        if (isMoved) {
-            children.markAsMoved(child);
-            isMoved = false;
-        }
-    }
-    else if (strict && children.isMoved(child))
-        isMoved = true;
-    return isMoved;
-}
-function startIncrementalRendering(parent, allChildren, priority1, priority2) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const stamp = parent.self.stamp;
-        if (priority1)
-            yield renderIncrementally(parent, stamp, allChildren, priority1, Priority.AsyncP1);
-        if (priority2)
-            yield renderIncrementally(parent, stamp, allChildren, priority2, Priority.AsyncP2);
-    });
-}
-function renderIncrementally(parent, stamp, allChildren, items, priority) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        yield Transaction.requestNextFrame();
-        const block = parent.self;
-        if (!Transaction.isCanceled || !Transaction.isFrameOver(1, Block.shortFrameDuration / 3)) {
-            let outerPriority = Block.currentRenderingPriority;
-            Block.currentRenderingPriority = priority;
-            try {
-                const strict = block.children.strict;
-                if ((_a = block.options) === null || _a === void 0 ? void 0 : _a.shuffle)
-                    shuffle(items);
-                const frameDurationLimit = priority === Priority.AsyncP2 ? Block.shortFrameDuration : Infinity;
-                let frameDuration = Math.min(frameDurationLimit, Math.max(Block.frameDuration / 4, Block.shortFrameDuration));
-                for (const child of items) {
-                    prepareThenRunRender(child, allChildren.isMoved(child), strict);
-                    if (Transaction.isFrameOver(1, frameDuration)) {
-                        Block.currentRenderingPriority = outerPriority;
-                        yield Transaction.requestNextFrame(0);
-                        outerPriority = Block.currentRenderingPriority;
-                        Block.currentRenderingPriority = priority;
-                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, Block.frameDuration));
-                    }
-                    if (Transaction.isCanceled && Transaction.isFrameOver(1, Block.shortFrameDuration / 3))
-                        break;
-                }
-            }
-            finally {
-                Block.currentRenderingPriority = outerPriority;
-            }
-        }
-    });
-}
-function prepareThenRunRender(item, moved, strict) {
-    var _a;
-    const block = item.self;
-    if (block.stamp >= 0) {
-        prepareRender(item, moved, strict);
-        if (block.inline)
-            runRender(item);
-        else
-            nonreactive(block.autorender, (_a = block.options) === null || _a === void 0 ? void 0 : _a.triggers);
-    }
-}
-function prepareRender(item, moved, strict) {
-    var _a, _b, _c;
-    const block = item.self;
-    const factory = block.factory;
-    if (block.stamp === 0) {
-        block.stamp = 1;
-        if (!block.inline) {
-            Transaction.outside(() => {
-                var _a, _b, _c;
-                if (Rx.isLogging)
-                    Rx.setLoggingHint(block, block.name);
-                Rx.getController(block.autorender).configure({
-                    order: block.level,
-                    monitor: (_a = block.options) === null || _a === void 0 ? void 0 : _a.monitor,
-                    throttling: (_b = block.options) === null || _b === void 0 ? void 0 : _b.throttling,
-                    logging: (_c = block.options) === null || _c === void 0 ? void 0 : _c.logging,
-                });
-            });
-        }
-        (_a = factory.initialize) === null || _a === void 0 ? void 0 : _a.call(factory, block, undefined);
-        (_b = factory.layout) === null || _b === void 0 ? void 0 : _b.call(factory, block, strict);
-    }
-    else if (moved)
-        (_c = factory.layout) === null || _c === void 0 ? void 0 : _c.call(factory, block, strict);
-}
-function runRender(item) {
-    const block = item.self;
-    if (block.stamp >= 0) {
-        runUnder(item, () => {
-            let result = undefined;
-            try {
-                block.stamp++;
-                block.children.beginMerge();
-                result = block.factory.render(block);
-                if (result instanceof Promise)
-                    result.then(v => { runRenderChildrenThenDo(undefined, NOP); return v; }, e => { console.log(e); runRenderChildrenThenDo(e !== null && e !== void 0 ? e : new Error('unknown error'), NOP); });
-                else
-                    runRenderChildrenThenDo(undefined, NOP);
-            }
-            catch (e) {
-                runRenderChildrenThenDo(e, NOP);
-                console.log(`Rendering failed: ${block.name}`);
-                console.log(`${e}`);
-            }
-        });
-    }
-}
-function runFinalize(item, isLeader) {
-    const block = item.self;
-    if (block.stamp >= 0) {
-        block.stamp = ~block.stamp;
-        const childrenAreLeaders = block.factory.finalize(block, isLeader);
-        if (!block.inline) {
-            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.self.name})` }, () => {
-                    void runDisposalLoop().then(NOP, error => console.log(error));
-                });
-        }
-        for (const item of block.children.items())
-            runFinalize(item, childrenAreLeaders);
-        VerstakBlock.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.self);
-            item = item.aux;
-            VerstakBlock.disposableCount--;
-        }
-        gFirstToDispose = gLastToDispose = undefined;
-    });
-}
-function forEachChildRecursively(item, action) {
-    const block = item.self;
-    const impl = block.impl;
-    impl && action(impl);
-    for (const item of block.children.items())
-        forEachChildRecursively(item, action);
-}
-function wrap(func) {
-    const parent = gContext;
-    const wrappedRunUnder = (...args) => {
-        return runUnder(parent, 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 gSysRoot = Collection.createItem(new VerstakBlock('SYSTEM', new StaticBlockFactory('SYSTEM', false, null), false, { level: 0 }, undefined, NOP));
-gSysRoot.self.item = gSysRoot;
-Object.defineProperty(gSysRoot, 'parent', {
-    value: gSysRoot,
-    writable: false,
-    configurable: false,
-    enumerable: true,
-});
-let gContext = gSysRoot;
-let gFirstToDispose = undefined;
-let gLastToDispose = undefined;

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

@@ -1,3 +0,0 @@
-import { Block, Render, BlockFactory, BlockOptions } from './Block';
-export declare function Reaction<T = undefined, M = unknown, P = void, R = void>(name: string, options: BlockOptions<P> | undefined, renderer: Render<T, M, P, R>, factory?: BlockFactory<T>): Block<T, M, P, R>;
-export declare function Inline<T = undefined, M = unknown, P = void, R = void>(name: string, options: BlockOptions<P> | undefined, renderer: Render<T, M, P, R>, factory?: BlockFactory<T>): Block<T, M, P, R>;

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

@@ -1,7 +0,0 @@
-import { Block } from './Block';
-export function Reaction(name, options, renderer, factory) {
-    return Block.claim(name, false, options, renderer, factory);
-}
-export function Inline(name, options, renderer, factory) {
-    return Block.claim(name, true, options, renderer, factory);
-}

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

@@ -1,27 +0,0 @@
-export interface Place {
-    lineBegin?: boolean;
-    area?: string;
-    columns?: number;
-    rows?: number;
-    cursorRight?: boolean;
-    cursorDown?: boolean;
-}
-export interface CellRange {
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-}
-export declare class Layout {
-    private maxColumnCount;
-    private maxRowCount;
-    private actualColumnCount;
-    private actualRowCount;
-    private columnCursor;
-    private rowCursor;
-    private newRowCursor;
-    reset(maxColumnCount: number, maxRowCount: number): void;
-    claim(p: Place, result: CellRange): CellRange;
-    static parseCellRange(text: string, result: CellRange): CellRange;
-    static emitCellRange(value: CellRange): string;
-}