verstak 0.22.412

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

@@ -0,0 +1,426 @@
+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 RxNode {
+    render() {
+        return this.renderer(this.element, 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 shuffleChildrenRendering(shuffle) {
+        gContext.self.shuffle = shuffle;
+    }
+    static renderChildrenThenDo(action) {
+        runRenderChildrenThenDo(undefined, action);
+    }
+    static forAllNodesDo(action) {
+        forEachChildRecursively(gSysRoot, action);
+    }
+    static claim(name, triggers, inline, renderer, priority, monitor, throttling, logging, factory) {
+        const parent = gContext.self;
+        const children = parent.children;
+        const item = children.claim(name);
+        let node;
+        if (item) {
+            node = item.self;
+            if (node.factory !== factory && factory !== undefined)
+                throw new Error(`changing node type is not yet supported: "${node.factory.name}" -> "${factory === null || factory === void 0 ? void 0 : factory.name}"`);
+            if (node.inline || !triggersAreEqual(node.triggers, triggers))
+                node.triggers = triggers;
+            node.renderer = renderer;
+            node.priority = priority !== null && priority !== void 0 ? priority : Priority.SyncP0;
+        }
+        else {
+            node = new RxNodeImpl(name, factory !== null && factory !== void 0 ? factory : NodeFactory.default, inline !== null && inline !== void 0 ? inline : false, parent, triggers, renderer, undefined, priority, monitor, throttling, logging);
+            node.item = children.add(node);
+            RxNodeImpl.grandCount++;
+            if (!node.inline)
+                RxNodeImpl.disposableCount++;
+        }
+        return node;
+    }
+    static getDefaultLoggingOptions() {
+        return RxNodeImpl.logging;
+    }
+    static setDefaultLoggingOptions(logging) {
+        RxNodeImpl.logging = logging;
+    }
+}
+RxNode.currentRenderingPriority = Priority.SyncP0;
+RxNode.shortFrameDuration = 16;
+RxNode.longFrameDuration = 300;
+RxNode.frameDuration = RxNode.longFrameDuration;
+const NOP = () => { };
+export class NodeFactory {
+    constructor(name, strict) {
+        this.name = name;
+        this.strict = strict;
+    }
+    initialize(node, element) {
+        const impl = node;
+        impl.element = element;
+    }
+    finalize(node, isLeader) {
+        const impl = node;
+        impl.element = undefined;
+        return isLeader;
+    }
+    arrange(node, strict) {
+    }
+    render(node) {
+        let result;
+        if (node.wrapper)
+            result = node.wrapper(node.element, node);
+        else
+            result = node.render();
+        return result;
+    }
+}
+NodeFactory.default = new NodeFactory('default', false);
+export class StaticNodeFactory extends NodeFactory {
+    constructor(name, sequential, element) {
+        super(name, sequential);
+        this.element = element;
+    }
+    initialize(node, element) {
+        super.initialize(node, this.element);
+    }
+}
+function getNodeName(node) {
+    return node.stamp >= 0 ? node.name : undefined;
+}
+class RxNodeImpl extends RxNode {
+    constructor(name, factory, inline, parent, triggers, renderer, wrapper, priority, monitor, throttling, logging) {
+        super();
+        this.name = name;
+        this.factory = factory;
+        this.inline = inline;
+        this.triggers = triggers;
+        this.renderer = renderer;
+        this.wrapper = wrapper;
+        this.monitor = monitor;
+        this.throttling = throttling !== null && throttling !== void 0 ? throttling : -1;
+        this.logging = logging !== null && logging !== void 0 ? logging : RxNodeImpl.logging;
+        this.priority = priority !== null && priority !== void 0 ? priority : Priority.SyncP0;
+        this.shuffle = false;
+        this.model = undefined;
+        this.level = parent.level + 1;
+        this.parent = parent;
+        this.children = new Collection(factory.strict, getNodeName);
+        this.item = undefined;
+        this.stamp = 0;
+        this.element = undefined;
+    }
+    autorender(_triggers) {
+        runRender(this.item);
+    }
+    wrapBy(renderer) {
+        this.wrapper = renderer;
+        return this;
+    }
+}
+RxNodeImpl.grandCount = 0;
+RxNodeImpl.disposableCount = 0;
+RxNodeImpl.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)
+], RxNodeImpl.prototype, "autorender", null);
+function runRenderChildrenThenDo(error, action) {
+    const context = gContext;
+    const node = context.self;
+    const children = node.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;
+                    const x = child.self;
+                    if (x.element) {
+                        if (isMoved) {
+                            children.markAsMoved(child);
+                            isMoved = false;
+                        }
+                    }
+                    else if (strict && children.isMoved(child))
+                        isMoved = true;
+                    if (x.priority === Priority.SyncP0)
+                        prepareThenRunRender(child, children.isMoved(child), strict);
+                    else if (x.priority === Priority.AsyncP1)
+                        p1 = push(p1, child);
+                    else
+                        p2 = push(p2, child);
+                }
+                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 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) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield Transaction.requestNextFrame();
+        const node = parent.self;
+        if (!Transaction.isCanceled || !Transaction.isFrameOver(1, RxNode.shortFrameDuration / 3)) {
+            let outerPriority = RxNode.currentRenderingPriority;
+            RxNode.currentRenderingPriority = priority;
+            try {
+                const strict = node.children.strict;
+                if (node.shuffle)
+                    shuffle(items);
+                const frameDurationLimit = priority === Priority.AsyncP2 ? RxNode.shortFrameDuration : Infinity;
+                let frameDuration = Math.min(frameDurationLimit, Math.max(RxNode.frameDuration / 4, RxNode.shortFrameDuration));
+                for (const child of items) {
+                    prepareThenRunRender(child, allChildren.isMoved(child), strict);
+                    if (Transaction.isFrameOver(1, frameDuration)) {
+                        RxNode.currentRenderingPriority = outerPriority;
+                        yield Transaction.requestNextFrame(0);
+                        outerPriority = RxNode.currentRenderingPriority;
+                        RxNode.currentRenderingPriority = priority;
+                        frameDuration = Math.min(4 * frameDuration, Math.min(frameDurationLimit, RxNode.frameDuration));
+                    }
+                    if (Transaction.isCanceled && Transaction.isFrameOver(1, RxNode.shortFrameDuration / 3))
+                        break;
+                }
+            }
+            finally {
+                RxNode.currentRenderingPriority = outerPriority;
+            }
+        }
+    });
+}
+function prepareThenRunRender(item, moved, strict) {
+    const node = item.self;
+    if (node.stamp >= 0) {
+        prepareRender(item, moved, strict);
+        if (node.inline)
+            runRender(item);
+        else
+            nonreactive(node.autorender, node.triggers);
+    }
+}
+function prepareRender(item, moved, strict) {
+    var _a, _b, _c;
+    const node = item.self;
+    const factory = node.factory;
+    if (node.stamp === 0) {
+        node.stamp = 1;
+        if (!node.inline) {
+            Transaction.outside(() => {
+                if (Rx.isLogging)
+                    Rx.setLoggingHint(node, node.name);
+                Rx.getController(node.autorender).configure({
+                    order: node.level,
+                    monitor: node.monitor,
+                    throttling: node.throttling,
+                    logging: node.logging,
+                });
+            });
+        }
+        (_a = factory.initialize) === null || _a === void 0 ? void 0 : _a.call(factory, node, undefined);
+        (_b = factory.arrange) === null || _b === void 0 ? void 0 : _b.call(factory, node, strict);
+    }
+    else if (moved)
+        (_c = factory.arrange) === null || _c === void 0 ? void 0 : _c.call(factory, node, strict);
+}
+function runRender(item) {
+    const node = item.self;
+    if (node.stamp >= 0) {
+        runUnder(item, () => {
+            let result = undefined;
+            try {
+                node.stamp++;
+                node.children.beginMerge();
+                result = node.factory.render(node);
+                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: ${node.name}`);
+                console.log(`${e}`);
+            }
+        });
+    }
+}
+function runFinalize(item, isLeader) {
+    const node = item.self;
+    if (node.stamp >= 0) {
+        node.stamp = ~node.stamp;
+        const childrenAreLeaders = node.factory.finalize(node, isLeader);
+        if (!node.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 node.children.items())
+            runFinalize(item, childrenAreLeaders);
+        RxNodeImpl.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;
+            RxNodeImpl.disposableCount--;
+        }
+        gFirstToDispose = gLastToDispose = undefined;
+    });
+}
+function forEachChildRecursively(item, action) {
+    const node = item.self;
+    const e = node.element;
+    e && action(e);
+    for (const item of node.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(array, item) {
+    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 RxNodeImpl('SYSTEM', new StaticNodeFactory('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/Utils.d.ts

@@ -0,0 +1 @@
+export declare function objectHasMember<T>(obj: any, member: string): obj is T;

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

@@ -0,0 +1,3 @@
+export function objectHasMember(obj, member) {
+    return obj === Object(obj) && !Array.isArray(obj) && member in obj;
+}

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

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

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

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

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

@@ -0,0 +1,11 @@
+export interface CellRange {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+export declare class CellRangeUtils {
+    static parseCellRange(text: string, result: CellRange): CellRange;
+    static emitCellRange(value: CellRange): string;
+    private static emitCellPos;
+}

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

@@ -0,0 +1,175 @@
+export class CellRangeUtils {
+    static 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;
+    }
+    static emitCellRange(value) {
+        const p1 = CellRangeUtils.emitCellPos(value.x1, value.y1);
+        const p2 = CellRangeUtils.emitCellPos(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;
+}
+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;
+}
+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;
+}

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

@@ -0,0 +1,7 @@
+import { DataForSensor } from './sensors/DataForSensor';
+declare global {
+    interface Element {
+        dataForSensor: DataForSensor;
+        resizeObserver?: ResizeObserver;
+    }
+}

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

@@ -0,0 +1,25 @@
+import { SymDataForSensor, SymResizeObserver } from './sensors/DataForSensor';
+const ElementType = global.Element;
+if (ElementType !== undefined) {
+    Object.defineProperty(ElementType.prototype, 'dataForSensor', {
+        configurable: false, enumerable: false,
+        get() {
+            let result = this[SymDataForSensor];
+            if (result === undefined)
+                result = this[SymDataForSensor] = {};
+            return result;
+        },
+        set(value) {
+            this[SymDataForSensor] = value;
+        },
+    });
+    Object.defineProperty(ElementType.prototype, 'resizeObserver', {
+        configurable: false, enumerable: false,
+        get() {
+            return this[SymResizeObserver];
+        },
+        set(value) {
+            this[SymResizeObserver] = value;
+        },
+    });
+}