cx 26.0.1 → 26.0.3

package/build/util/Format.js

@@ -0,0 +1,229 @@
+import { debug } from "./Debug";
+import { GlobalCacheIdentifier } from "./GlobalCacheIdentifier";
+import { isNumber } from "../util/isNumber";
+import { isUndefined } from "../util/isUndefined";
+import { isArray } from "../util/isArray";
+import { capitalize } from "./capitalize";
+import { parseDateInvariant } from "./date/parseDateInvariant";
+const defaultFormatter = (v) => v.toString();
+let formatFactory = {
+    string: function () {
+        return defaultFormatter;
+    },
+    wrap: function (part0, prefix, suffix) {
+        if (!prefix)
+            prefix = "";
+        if (!suffix)
+            suffix = "";
+        return (value) => prefix + String(value) + suffix;
+    },
+    fixed: function (part0, digits) {
+        return (value) => Number(value).toFixed(digits);
+    },
+    prefix: function (part0, prefix) {
+        if (!prefix)
+            prefix = "";
+        return (value) => prefix + String(value);
+    },
+    suffix: function (part0, suffix) {
+        if (!suffix)
+            suffix = "";
+        return (value) => String(value) + suffix;
+    },
+    uppercase: function () {
+        return (value) => String(value).toUpperCase();
+    },
+    lowercase: function () {
+        return (value) => String(value).toLowerCase();
+    },
+    urlencode: function () {
+        return (value) => encodeURIComponent(value);
+    },
+    number: function (part0, minFractionDigits, maxFractionDigits) {
+        let { minimumFractionDigits, maximumFractionDigits } = resolveMinMaxFractionDigits(minFractionDigits, maxFractionDigits);
+        let trimmable = maximumFractionDigits - minimumFractionDigits;
+        if (trimmable > 0) {
+            if (minimumFractionDigits == 0)
+                ++trimmable;
+            return (value) => trimFractionZeros(value.toFixed(maximumFractionDigits), trimmable);
+        }
+        return (value) => value.toFixed(maximumFractionDigits);
+    },
+    percentage: function (part0, minFractionDigits, maxFractionDigits) {
+        let numberFormatter = formatFactory.number(part0, minFractionDigits, maxFractionDigits);
+        return (value) => numberFormatter(value * 100) + "%";
+    },
+    percentageSign: function (part0, minFractionDigits, maxFractionDigits) {
+        let numberFormatter = formatFactory.number(part0, minFractionDigits, maxFractionDigits);
+        return (value) => numberFormatter(value) + "%";
+    },
+    date: function () {
+        return (value) => {
+            let date = parseDateInvariant(value);
+            return `${date.getMonth() + 1}/${date.getDate()}/${date.getFullYear()}`;
+        };
+    },
+    time: function () {
+        return (value) => {
+            let date = parseDateInvariant(value);
+            let h = date.getHours() >= 10 ? date.getHours() : "0" + date.getHours();
+            let m = date.getMinutes() >= 10 ? date.getMinutes() : "0" + date.getMinutes();
+            return `${h}:${m}`;
+        };
+    },
+    datetime: function () {
+        let date = formatFactory.date();
+        let time = formatFactory.time();
+        return (value) => date(value) + " " + time(value);
+    },
+    ellipsis: function (part0, length, where) {
+        length = Number(length);
+        if (!(length > 3))
+            length = 10;
+        switch (where) {
+            default:
+            case "end":
+                return (value) => {
+                    let s = String(value);
+                    if (s.length > length)
+                        return s.substring(0, length - 3) + "...";
+                    return s;
+                };
+            case "start":
+                return (value) => {
+                    let s = String(value);
+                    if (s.length > length)
+                        return "..." + s.substring(s.length - length + 3);
+                    return s;
+                };
+            case "middle":
+                return (value) => {
+                    let s = String(value);
+                    if (s.length > length) {
+                        let x = Math.floor(length - 2) / 2;
+                        return s.substring(0, x) + "..." + s.substring(s.length - (length - 3 - x));
+                    }
+                    return s;
+                };
+        }
+    },
+    zeroPad: function (part0, length) {
+        return (value) => {
+            let s = String(value);
+            return s.padStart(length, "0");
+        };
+    },
+    leftPad: function (part0, length, char) {
+        return (value) => {
+            let s = String(value);
+            return s.padStart(length, char ?? " ");
+        };
+    },
+    capitalize: function () {
+        return (value) => {
+            let s = String(value);
+            return capitalize(s);
+        };
+    },
+    titleCase: function () {
+        return (value) => {
+            let s = String(value);
+            return s.replace(/\w\S*/g, function (word) {
+                return capitalize(word.toLowerCase());
+            });
+        };
+    },
+};
+formatFactory.s = formatFactory.str = formatFactory.string;
+formatFactory.f = formatFactory.fixed;
+formatFactory.n = formatFactory.number;
+formatFactory.p = formatFactory.percentage;
+formatFactory.ps = formatFactory.percentageSign;
+formatFactory.d = formatFactory.date;
+formatFactory.t = formatFactory.time;
+formatFactory.dt = formatFactory.datetime;
+formatFactory.zeropad = formatFactory.zeroPad;
+formatFactory.leftpad = formatFactory.leftPad;
+formatFactory.capitalize = formatFactory.capitalize;
+formatFactory.titlecase = formatFactory.titleCase;
+function buildFormatter(format) {
+    let formatter = defaultFormatter, nullText = "";
+    if (format) {
+        let pipeParts = format.split("|");
+        nullText = pipeParts[1] || "";
+        let colonSepParts = pipeParts[0].split(":");
+        for (let i = 0; i < colonSepParts.length; i++) {
+            let parts = colonSepParts[i].split(";");
+            let factory = formatFactory[parts[0]];
+            if (!factory)
+                debug("Unknown string format: " + format);
+            else if (i == 0)
+                formatter = factory(...parts);
+            else {
+                let outerFmt = factory(...parts);
+                let innerFmt = formatter;
+                formatter = (v) => outerFmt(innerFmt(v));
+            }
+        }
+    }
+    return (v) => (v == null || v === "" ? nullText : formatter(v));
+}
+let format = { cache: {} };
+function getDefaultFormatCache() {
+    if (format.cacheIdentifier != GlobalCacheIdentifier.get()) {
+        format = { cache: {}, cacheIdentifier: GlobalCacheIdentifier.get() };
+    }
+    return format.cache;
+}
+let getFormatCache = getDefaultFormatCache;
+export function setGetFormatCacheCallback(callback) {
+    getFormatCache = callback;
+}
+function getFormatter(format) {
+    if (!format)
+        format = "";
+    let formatCache = getFormatCache();
+    let formatter = formatCache[format];
+    if (!formatter)
+        formatter = formatCache[format] = buildFormatter(format);
+    return formatter;
+}
+export class Format {
+    static value(v, format) {
+        let formatter = getFormatter(format);
+        return formatter(v);
+    }
+    static parse(format) {
+        return getFormatter(format);
+    }
+    static register(format, formatter) {
+        this.registerFactory(format, () => formatter);
+    }
+    static registerFactory(format, factory) {
+        if (isArray(format))
+            format.forEach((f) => this.registerFactory(f, factory));
+        else
+            formatFactory[format] = factory;
+    }
+}
+export function resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits) {
+    minimumFractionDigits = minimumFractionDigits != null ? Number(minimumFractionDigits) : minimumFractionDigits;
+    maximumFractionDigits = maximumFractionDigits != null ? Number(maximumFractionDigits) : maximumFractionDigits;
+    if (isNumber(minimumFractionDigits)) {
+        if (isUndefined(maximumFractionDigits))
+            maximumFractionDigits = minimumFractionDigits;
+        else if (isNumber(maximumFractionDigits) && maximumFractionDigits < minimumFractionDigits)
+            maximumFractionDigits = minimumFractionDigits;
+    }
+    else if (minimumFractionDigits == null && maximumFractionDigits == null) {
+        minimumFractionDigits = 0;
+        maximumFractionDigits = 18;
+    }
+    return { minimumFractionDigits, maximumFractionDigits };
+}
+export function trimFractionZeros(str, max) {
+    let cnt = 0, l = str.length;
+    while (cnt < max && (str[l - 1 - cnt] === "0" || str[l - 1 - cnt] === "."))
+        cnt++;
+    return cnt > 0 ? str.substring(0, l - cnt) : str;
+}

package/build/util/Format.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/util/Format.spec.js

@@ -0,0 +1,58 @@
+import assert from 'assert';
+import { Format } from './Format';
+describe('Format', function () {
+    describe('n,number ', function () {
+        it('correctly formats numbers with min and max allowed precision', function () {
+            assert.equal(Format.value(0.5, 'n;2;4'), '0.50');
+            assert.equal(Format.value(0.50101, 'n;2;4'), '0.501');
+            assert.equal(Format.value(0.5012, 'n;2;4'), '0.5012');
+            assert.equal(Format.value(0.0, 'n;0;4'), '0');
+        });
+        it('correctly formats numbers fixed precision', function () {
+            assert.equal(Format.value(0.5, 'number;3'), '0.500');
+            assert.equal(Format.value(0.50101, 'number;3'), '0.501');
+            assert.equal(Format.value(0.5016, 'number;3'), '0.502');
+        });
+    });
+    describe('p,percentage', function () {
+        it('correctly formats numbers with min and max allowed precision', function () {
+            assert.equal(Format.value(0.5, 'p;2;4'), '50.00%');
+            assert.equal(Format.value(0.50101, 'p;2;4'), '50.101%');
+            assert.equal(Format.value(0.50123456, 'p;2;4'), '50.1235%');
+            assert.equal(Format.value(0.0, 'p;0;4'), '0%');
+        });
+        it('correctly formats numbers fixed precision', function () {
+            assert.equal(Format.value(0.5, 'percentage;3'), '50.000%');
+            assert.equal(Format.value(0.50101, 'percentage;3'), '50.101%');
+            assert.equal(Format.value(0.5016, 'percentage;3'), '50.160%');
+        });
+    });
+    describe('date,time,datetime', function () {
+        it('correctly formats dates', function () {
+            assert.equal(Format.value(new Date(2015, 3, 1), 'd'), '4/1/2015');
+        });
+        it('correctly formats time', function () {
+            assert.equal(Format.value(new Date(2015, 3, 1, 16, 15, 14), 't'), '16:15');
+            assert.equal(Format.value(new Date(2015, 3, 1, 5, 6, 14), 'time'), '05:06');
+        });
+        it('correctly formats date-time', function () {
+            assert.equal(Format.value(new Date(2015, 3, 1, 5, 6, 14), 'dt'), '4/1/2015 05:06');
+        });
+    });
+    describe('ellipsis', function () {
+        it('can shorten long texts', function () {
+            assert.equal(Format.value('This is a very long text.', 'ellipsis;7'), 'This...');
+        });
+        it('can be used at the start of string', function () {
+            assert.equal(Format.value('This is a very long text.', 'ellipsis;8;start'), '...text.');
+        });
+        it('can be used in the middle of the string', function () {
+            assert.equal(Format.value('First (Middle) Last', 'ellipsis;11;middle'), 'Firs...Last');
+        });
+    });
+    describe('null text', function () {
+        it('can contain null text', function () {
+            assert.equal(Format.value(null, 'n;2|N/A'), 'N/A');
+        });
+    });
+});

package/build/util/GlobalCacheIdentifier.d.ts

@@ -0,0 +1,4 @@
+export declare class GlobalCacheIdentifier {
+    static get(): number;
+    static change(): void;
+}

package/build/util/GlobalCacheIdentifier.js

@@ -0,0 +1,9 @@
+var globalCacheIdentifier = 1;
+export class GlobalCacheIdentifier {
+    static get() {
+        return globalCacheIdentifier;
+    }
+    static change() {
+        globalCacheIdentifier++;
+    }
+}

package/build/util/KeyCode.d.ts

@@ -0,0 +1,21 @@
+export declare class KeyCode {
+    static backspace: number;
+    static tab: number;
+    static enter: number;
+    static shift: number;
+    static ctrl: number;
+    static alt: number;
+    static esc: number;
+    static space: number;
+    static pageUp: number;
+    static pageDown: number;
+    static end: number;
+    static home: number;
+    static left: number;
+    static up: number;
+    static right: number;
+    static down: number;
+    static insert: number;
+    static delete: number;
+    static a: number;
+}

package/build/util/KeyCode.js

@@ -0,0 +1,21 @@
+export class KeyCode {
+    static backspace = 8;
+    static tab = 9;
+    static enter = 13;
+    static shift = 16;
+    static ctrl = 17;
+    static alt = 18;
+    static esc = 27;
+    static space = 32;
+    static pageUp = 33;
+    static pageDown = 34;
+    static end = 35;
+    static home = 36;
+    static left = 37;
+    static up = 38;
+    static right = 39;
+    static down = 40;
+    static insert = 45;
+    static delete = 46;
+    static a = 65;
+}

package/build/util/SubscriberList.d.ts

@@ -0,0 +1,39 @@
+type UnsubscribeFunction = () => void;
+type Callback = (...args: any[]) => void;
+export declare class SubscriberList {
+    private subscriptions;
+    private freeSlots;
+    private nextSlot;
+    private subscriptionCount;
+    constructor();
+    private getSlot;
+    private recycle;
+    /**
+     * Add a new subscription.
+     * @param callback
+     */
+    subscribe(callback: Callback): UnsubscribeFunction;
+    /**
+     * Clear all subscriptions.
+     */
+    clear(): void;
+    /**
+     * Returns true if there are no subscribers.
+     */
+    isEmpty(): boolean;
+    /**
+     * Returns an array of subscribed callbacks.
+     */
+    getSubscribers(): Callback[];
+    /**
+     * Trigger all subscribed callbacks with provided arguments.
+     * @param args - Arguments that will be passed to callback functions.
+     */
+    notify(...args: any[]): void;
+    /**
+     *
+     * @param callback
+     */
+    execute(callback: (c: Callback) => void): void;
+}
+export {};

package/build/util/SubscriberList.js

@@ -0,0 +1,70 @@
+export class SubscriberList {
+    constructor() {
+        this.clear();
+    }
+    getSlot() {
+        if (this.freeSlots.length)
+            return this.freeSlots.pop();
+        let slot = String(this.nextSlot++);
+        return slot;
+    }
+    recycle(slot, callback) {
+        if (this.subscriptions[slot] === callback) {
+            this.freeSlots.push(slot);
+            delete this.subscriptions[slot];
+            this.subscriptionCount--;
+        }
+    }
+    /**
+     * Add a new subscription.
+     * @param callback
+     */
+    subscribe(callback) {
+        let slot = this.getSlot();
+        this.subscriptions[slot] = callback;
+        this.subscriptionCount++;
+        return () => {
+            this.recycle(slot, callback);
+        };
+    }
+    /**
+     * Clear all subscriptions.
+     */
+    clear() {
+        this.subscriptions = {};
+        this.freeSlots = [];
+        this.nextSlot = 1;
+        this.subscriptionCount = 0;
+    }
+    /**
+     * Returns true if there are no subscribers.
+     */
+    isEmpty() {
+        return this.subscriptionCount == 0;
+    }
+    /**
+     * Returns an array of subscribed callbacks.
+     */
+    getSubscribers() {
+        let result = [];
+        for (let key in this.subscriptions)
+            result.push(this.subscriptions[key]);
+        return result;
+    }
+    /**
+     * Trigger all subscribed callbacks with provided arguments.
+     * @param args - Arguments that will be passed to callback functions.
+     */
+    notify(...args) {
+        for (let key in this.subscriptions)
+            this.subscriptions[key](...args);
+    }
+    /**
+     *
+     * @param callback
+     */
+    execute(callback) {
+        for (let key in this.subscriptions)
+            callback(this.subscriptions[key]);
+    }
+}

package/build/util/Timing.d.ts

@@ -0,0 +1,15 @@
+export declare const appLoopFlag = "app-loop";
+export declare const vdomRenderFlag = "vdom-render";
+export declare function now(): number;
+declare function enable(flag: string): void;
+declare function disable(flag: string): void;
+declare function count(flag: string): number | undefined;
+declare function log(flag: string, ...args: any[]): void;
+export declare const Timing: {
+    now: typeof now;
+    enable: typeof enable;
+    disable: typeof disable;
+    count: typeof count;
+    log: typeof log;
+};
+export {};

package/build/util/Timing.js

@@ -0,0 +1,49 @@
+import { Console } from './Console';
+export const appLoopFlag = 'app-loop';
+export const vdomRenderFlag = 'vdom-render';
+let counter = {};
+let activeFlags = {};
+let nowImpl = () => Date.now();
+export function now() {
+    if (process.env.NODE_ENV !== "production") {
+        return nowImpl();
+    }
+    else {
+        return 0;
+    }
+}
+function enable(flag) {
+    if (process.env.NODE_ENV !== "production") {
+        activeFlags[flag] = true;
+    }
+}
+function disable(flag) {
+    if (process.env.NODE_ENV !== "production") {
+        activeFlags[flag] = false;
+    }
+}
+function count(flag) {
+    if (process.env.NODE_ENV !== "production") {
+        if (!activeFlags[flag])
+            return undefined;
+        return counter[flag] = (counter[flag] || 0) + 1;
+    }
+    return undefined;
+}
+function log(flag, ...args) {
+    if (process.env.NODE_ENV !== "production") {
+        if (!activeFlags[flag])
+            return;
+        Console.log(flag, ...args);
+    }
+}
+if (process.env.NODE_ENV !== "production" && typeof window != 'undefined' && window.performance && typeof window.performance.now === 'function') {
+    nowImpl = () => performance.now();
+}
+export const Timing = {
+    now,
+    enable,
+    disable,
+    count,
+    log
+};

package/build/util/TraversalStack.d.ts

@@ -0,0 +1,8 @@
+export declare class TraversalStack<T> {
+    private data;
+    constructor();
+    push(node: T): void;
+    hop(): void;
+    pop(): T | null;
+    empty(): boolean;
+}

package/build/util/TraversalStack.js

@@ -0,0 +1,37 @@
+export class TraversalStack {
+    data;
+    constructor() {
+        this.data = [];
+    }
+    push(node) {
+        if (this.data.length == 0)
+            this.hop();
+        this.data[this.data.length - 1].elements.push(node);
+    }
+    hop() {
+        this.data.push({
+            elements: [],
+            index: 0
+        });
+    }
+    pop() {
+        while (this.data.length > 0) {
+            let line = this.data[this.data.length - 1];
+            if (line.index < line.elements.length) {
+                line.index++;
+                return line.elements[line.index - 1];
+            }
+            this.data.pop();
+        }
+        return null;
+    }
+    empty() {
+        while (this.data.length > 0) {
+            let line = this.data[this.data.length - 1];
+            if (line.index < line.elements.length)
+                return false;
+            this.data.pop();
+        }
+        return true;
+    }
+}

package/build/util/TraversalStack.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/build/util/TraversalStack.spec.js

@@ -0,0 +1,43 @@
+import { TraversalStack } from './TraversalStack';
+import assert from 'assert';
+describe('TraversalStack', function () {
+    it('push', function () {
+        let stack = new TraversalStack();
+        stack.push(1);
+        assert.equal(stack.pop(), 1);
+    });
+    it('traverses the tree in the right order', function () {
+        let stack = new TraversalStack();
+        let tree = {
+            id: 1,
+            children: [{
+                    id: 2,
+                    children: [{
+                            id: 3
+                        }, {
+                            id: 4
+                        }]
+                }, {
+                    id: 5,
+                    children: [{
+                            id: 6
+                        }]
+                }]
+        };
+        let list = [];
+        stack.push(tree);
+        while (!stack.empty()) {
+            let node = stack.pop();
+            if (node) {
+                list.push(node.id);
+                if (node.children) {
+                    stack.hop();
+                    node.children.forEach((child) => {
+                        stack.push(child);
+                    });
+                }
+            }
+        }
+        assert.deepEqual(list, [1, 2, 3, 4, 5, 6]);
+    });
+});

package/build/util/addEventListenerWithOptions.d.ts

@@ -0,0 +1,17 @@
+interface EventMap {
+    wheel: WheelEvent;
+    scroll: Event;
+    click: MouseEvent;
+    mousedown: MouseEvent;
+    mouseup: MouseEvent;
+    mousemove: MouseEvent;
+    touchstart: TouchEvent;
+    touchmove: TouchEvent;
+    touchend: TouchEvent;
+    keydown: KeyboardEvent;
+    keyup: KeyboardEvent;
+    keypress: KeyboardEvent;
+}
+export declare function addEventListenerWithOptions<K extends keyof EventMap>(element: Element, event: K, callback: (event: EventMap[K]) => void, options: AddEventListenerOptions): () => void;
+export declare function addEventListenerWithOptions(element: Element, event: string, callback: (event: Event) => void, options: AddEventListenerOptions): () => void;
+export {};

package/build/util/addEventListenerWithOptions.js

@@ -0,0 +1,8 @@
+import { browserSupportsPassiveEventHandlers } from "./browserSupportsPassiveEventHandlers";
+export function addEventListenerWithOptions(element, event, callback, options) {
+    let thirdParam = browserSupportsPassiveEventHandlers() ? options : options.capture === true;
+    element.addEventListener(event, callback, thirdParam);
+    return () => {
+        element.removeEventListener(event, callback, thirdParam);
+    };
+}

package/build/util/browserSupportsPassiveEventHandlers.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Checks if the browser supports passive event handlers.
+ * @returns {boolean}
+ */
+export declare function browserSupportsPassiveEventHandlers(): boolean;

package/build/util/browserSupportsPassiveEventHandlers.js

@@ -0,0 +1,20 @@
+let passiveEventsSupported = null;
+/**
+ * Checks if the browser supports passive event handlers.
+ * @returns {boolean}
+ */
+export function browserSupportsPassiveEventHandlers() {
+    if (passiveEventsSupported == null) {
+        try {
+            passiveEventsSupported = false;
+            const options = Object.defineProperty({}, "passive", {
+                get() {
+                    passiveEventsSupported = true;
+                },
+            });
+            window.addEventListener("test", null, options);
+        }
+        catch (e) { }
+    }
+    return passiveEventsSupported;
+}

package/build/util/calculateNaturalElementHeight.d.ts

@@ -0,0 +1 @@
+export declare function calculateNaturalElementHeight(el: HTMLElement): number;