cx 26.0.12 → 26.0.13

package/build/ui/layout/ContentPlaceholder.spec.js

@@ -0,0 +1,333 @@
+import { jsx as _jsx, jsxs as _jsxs } from "cx/jsx-runtime";
+import { Store } from "../../data/Store";
+import { ContentPlaceholder, ContentPlaceholderScope } from "./ContentPlaceholder";
+import assert from "assert";
+import { PureContainer } from "../PureContainer";
+import { createTestRenderer } from "../../util/test/createTestRenderer";
+import { bind } from "../bind";
+describe("ContentPlaceholder", () => {
+    it("allows putting content inside", () => {
+        let store = new Store();
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsxs("div", { children: [_jsx("header", { children: _jsx(ContentPlaceholder, { name: "header" }) }), _jsx("main", { children: _jsx("h2", { putInto: "header", children: "Header" }) })] }) }));
+        let tree = component.toJSON();
+        assert.deepEqual(tree, {
+            type: "div",
+            props: {},
+            children: [
+                {
+                    type: "header",
+                    props: {},
+                    children: [
+                        {
+                            type: "h2",
+                            props: {},
+                            children: ["Header"],
+                        },
+                    ],
+                },
+                {
+                    type: "main",
+                    props: {},
+                    children: null,
+                },
+            ],
+        });
+    });
+    it("updates content on change", () => {
+        let store = new Store({
+            data: {
+                headerText: "Header",
+            },
+        });
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsxs("div", { children: [_jsx(ContentPlaceholder, { name: "header" }), _jsx("h2", { putInto: "header", text: bind("headerText") })] }) }));
+        let getTree = (headerText) => ({
+            type: "div",
+            props: {},
+            children: [
+                {
+                    type: "h2",
+                    props: {},
+                    children: [headerText],
+                },
+            ],
+        });
+        assert.deepEqual(component.toJSON(), getTree("Header"));
+        store.set("headerText", "Footer");
+        assert.deepEqual(component.toJSON(), getTree("Footer"));
+    });
+    it("allows putting multiple entries inside", () => {
+        let store = new Store();
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsxs("div", { children: [_jsx("header", { children: _jsx(ContentPlaceholder, { name: "headers", allowMultiple: true }) }), _jsxs("main", { children: [_jsx("h2", { putInto: "headers", children: "Header1" }), _jsx("h2", { putInto: "headers", children: "Header2" })] })] }) }));
+        let tree = component.toJSON();
+        assert.deepEqual(tree, {
+            type: "div",
+            props: {},
+            children: [
+                {
+                    type: "header",
+                    props: {},
+                    children: [
+                        {
+                            type: "h2",
+                            props: {},
+                            children: ["Header1"],
+                        },
+                        {
+                            type: "h2",
+                            props: {},
+                            children: ["Header2"],
+                        },
+                    ],
+                },
+                {
+                    type: "main",
+                    props: {},
+                    children: null,
+                },
+            ],
+        });
+    });
+    it("allows putting multiple entries inside when content is defined before and after the placeholder", () => {
+        let store = new Store();
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsxs("div", { children: [_jsxs(PureContainer, { children: [_jsx("h2", { putInto: "headers", children: "Header1" }), _jsx("h2", { putInto: "headers", children: "Header2" })] }), _jsx("header", { children: _jsx(ContentPlaceholder, { name: "headers", allowMultiple: true }) }), _jsxs(PureContainer, { children: [_jsx("h2", { putInto: "headers", children: "Header3" }), _jsx("h2", { putInto: "headers", children: "Header4" })] })] }) }));
+        let tree = component.toJSON();
+        assert.deepEqual(tree, {
+            type: "div",
+            props: {},
+            children: [
+                {
+                    type: "header",
+                    props: {},
+                    children: [
+                        {
+                            type: "h2",
+                            props: {},
+                            children: ["Header1"],
+                        },
+                        {
+                            type: "h2",
+                            props: {},
+                            children: ["Header2"],
+                        },
+                        {
+                            type: "h2",
+                            props: {},
+                            children: ["Header3"],
+                        },
+                        {
+                            type: "h2",
+                            props: {},
+                            children: ["Header4"],
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+    it("allows putting multiple entries into separate placeholders using content placeholder scopes", () => {
+        let store = new Store();
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsxs("div", { children: [_jsxs(ContentPlaceholderScope, { name: "headers", children: [_jsx("h2", { putInto: "headers", children: "Header1" }), _jsx("h2", { putInto: "headers", children: "Header2" }), _jsx("header", { children: _jsx(ContentPlaceholder, { name: "headers", allowMultiple: true }) })] }), _jsxs(ContentPlaceholderScope, { name: "headers", children: [_jsx("header", { children: _jsx(ContentPlaceholder, { name: "headers", allowMultiple: true }) }), _jsx("h2", { putInto: "headers", children: "Header3" }), _jsx("h2", { putInto: "headers", children: "Header4" })] })] }) }));
+        let tree = component.toJSON();
+        assert.deepEqual(tree, {
+            type: "div",
+            props: {},
+            children: [
+                {
+                    type: "header",
+                    props: {},
+                    children: [
+                        {
+                            type: "h2",
+                            props: {},
+                            children: ["Header1"],
+                        },
+                        {
+                            type: "h2",
+                            props: {},
+                            children: ["Header2"],
+                        },
+                    ],
+                },
+                {
+                    type: "header",
+                    props: {},
+                    children: [
+                        {
+                            type: "h2",
+                            props: {},
+                            children: ["Header3"],
+                        },
+                        {
+                            type: "h2",
+                            props: {},
+                            children: ["Header4"],
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+    it("is used for defining body position in outer layouts", () => {
+        let store = new Store();
+        let layout = (_jsx("cx", { children: _jsxs("div", { children: [_jsx("header", { children: "Header" }), _jsx(ContentPlaceholder, {}), _jsx("footer", { children: "Footer" })] }) }));
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("main", { outerLayout: layout }) }));
+        assert.deepEqual(component.toJSON(), {
+            type: "div",
+            props: {},
+            children: [
+                {
+                    type: "header",
+                    props: {},
+                    children: ["Header"],
+                },
+                {
+                    type: "main",
+                    props: {},
+                    children: null,
+                },
+                {
+                    type: "footer",
+                    props: {},
+                    children: ["Footer"],
+                },
+            ],
+        });
+    });
+    it("data in deeply nested placeholders is correctly updated", () => {
+        let store = new Store({
+            data: {
+                header: "H",
+                footer: "F",
+                body: "B",
+            },
+        });
+        let layout = (_jsx("cx", { children: _jsxs("div", { children: [_jsx("header", { children: _jsx(ContentPlaceholder, { name: "header" }) }), _jsx(ContentPlaceholder, {}), _jsx("footer", { children: _jsx(ContentPlaceholder, { name: "footer" }) })] }) }));
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsxs("main", { outerLayout: layout, children: [_jsx("div", { putInto: "header", children: _jsx("span", { text: bind("header") }) }), _jsx("div", { putInto: "footer", children: _jsx("span", { text: bind("footer") }) }), _jsx("span", { text: bind("body") })] }) }));
+        let getTree = (h, b, f) => ({
+            type: "div",
+            props: {},
+            children: [
+                {
+                    type: "header",
+                    props: {},
+                    children: [{ type: "div", props: {}, children: [{ type: "span", props: {}, children: [h] }] }],
+                },
+                {
+                    type: "main",
+                    props: {},
+                    children: [{ type: "span", props: {}, children: [b] }],
+                },
+                {
+                    type: "footer",
+                    props: {},
+                    children: [{ type: "div", props: {}, children: [{ type: "span", props: {}, children: [f] }] }],
+                },
+            ],
+        });
+        assert.deepEqual(component.toJSON(), getTree("H", "B", "F"));
+        store.set("header", "H2");
+        assert.deepEqual(component.toJSON(), getTree("H2", "B", "F"));
+        store.set("footer", "F2");
+        assert.deepEqual(component.toJSON(), getTree("H2", "B", "F2"));
+        store.set("body", "B2");
+        assert.deepEqual(component.toJSON(), getTree("H2", "B2", "F2"));
+    });
+    it("inside a two-level deep outer-layout works", () => {
+        let store = new Store();
+        let outerLayout = (_jsx("cx", { children: _jsx("div", { children: _jsx(ContentPlaceholder, {}) }) }));
+        let innerLayout = (_jsx("cx", { children: _jsx("main", { outerLayout: outerLayout, children: _jsx(ContentPlaceholder, {}) }) }));
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("section", { outerLayout: innerLayout }) }));
+        let tree = component.toJSON();
+        //console.log(tree);
+        assert.deepEqual(tree, {
+            type: "div",
+            props: {},
+            children: [
+                {
+                    type: "main",
+                    props: {},
+                    children: [
+                        {
+                            type: "section",
+                            props: {},
+                            children: null,
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+    it("works in strange order", () => {
+        let store = new Store();
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsxs("div", { children: [_jsx(ContentPlaceholder, { name: "footer" }), _jsx(PureContainer, { putInto: "footer-content", children: "works" }), _jsxs(PureContainer, { putInto: "footer", children: ["It", _jsx(ContentPlaceholder, { name: "footer-content", children: "doesn't work" })] })] }) }));
+        let tree = component.toJSON();
+        //console.log(tree);
+        assert.deepEqual(tree, {
+            type: "div",
+            props: {},
+            children: ["It", "works"],
+        });
+    });
+    it("inside a complex two-level-deep outer-layout works", () => {
+        let store = new Store();
+        let outerLayout = (_jsx("cx", { children: _jsx("div", { children: _jsx(ContentPlaceholder, {}) }) }));
+        let innerLayout = (_jsx("cx", { children: _jsx(PureContainer, { children: _jsx("main", { outerLayout: outerLayout, children: _jsx(ContentPlaceholder, {}) }) }) }));
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("section", { outerLayout: innerLayout }) }));
+        assert.deepEqual(component.toJSON(), {
+            type: "div",
+            props: {},
+            children: [{ type: "main", props: {}, children: [{ type: "section", props: {}, children: null }] }],
+        });
+    });
+    it("each level use an outer-layout", () => {
+        let store = new Store();
+        let outerLayout1 = (_jsx("cx", { children: _jsx("div", { children: _jsx(ContentPlaceholder, {}) }) }));
+        let outerLayout2 = (_jsx("cx", { children: _jsx("main", { children: _jsx(ContentPlaceholder, {}) }) }));
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsx(PureContainer, { outerLayout: outerLayout1, children: _jsx(PureContainer, { outerLayout: outerLayout2, children: "Content" }) }) }));
+        assert.deepEqual(component.toJSON(), {
+            type: "div",
+            props: {},
+            children: [{ type: "main", props: {}, children: ["Content"] }],
+        });
+    });
+    it("data in a two-level deep outer-layout is correctly updated", () => {
+        let store = new Store({
+            data: {
+                header: "H",
+                footer: "F",
+                body: "B",
+            },
+        });
+        let outerLayout = (_jsx("cx", { children: _jsxs("div", { children: [_jsx(ContentPlaceholder, {}), _jsx("footer", { children: _jsx(ContentPlaceholder, { name: "footer" }) })] }) }));
+        let innerLayout = (_jsx("cx", { children: _jsx(PureContainer, { children: _jsxs(PureContainer, { outerLayout: outerLayout, children: [_jsx("header", { children: _jsx(ContentPlaceholder, { name: "header" }) }), _jsx(ContentPlaceholder, {})] }) }) }));
+        const component = createTestRenderer(store, _jsx("cx", { children: _jsxs("main", { outerLayout: innerLayout, children: [_jsx("div", { putInto: "header", children: _jsx("span", { text: bind("header") }) }), _jsx("div", { putInto: "footer", children: _jsx("span", { text: bind("footer") }) }), _jsx("span", { text: bind("body") })] }) }));
+        let getTree = (h, b, f) => ({
+            type: "div",
+            props: {},
+            children: [
+                {
+                    type: "header",
+                    props: {},
+                    children: [{ type: "div", props: {}, children: [{ type: "span", props: {}, children: [h] }] }],
+                },
+                {
+                    type: "main",
+                    props: {},
+                    children: [{ type: "span", props: {}, children: [b] }],
+                },
+                {
+                    type: "footer",
+                    props: {},
+                    children: [{ type: "div", props: {}, children: [{ type: "span", props: {}, children: [f] }] }],
+                },
+            ],
+        });
+        assert.deepEqual(component.toJSON(), getTree("H", "B", "F"));
+        store.set("header", "H2");
+        assert.deepEqual(component.toJSON(), getTree("H2", "B", "F"));
+        store.set("footer", "F2");
+        assert.deepEqual(component.toJSON(), getTree("H2", "B", "F2"));
+        store.set("body", "B2");
+        assert.deepEqual(component.toJSON(), getTree("H2", "B2", "F2"));
+    });
+});

package/build/ui/layout/FirstVisibleChildLayout.spec.d.ts

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

package/build/ui/layout/FirstVisibleChildLayout.spec.js

@@ -0,0 +1,101 @@
+import { jsx as _jsx, jsxs as _jsxs } from "cx/jsx-runtime";
+import { Store } from "../../data/Store";
+import { expr } from "../expr";
+import { createTestRenderer } from "../../util/test/createTestRenderer";
+import assert from "assert";
+import { FirstVisibleChildLayout } from "./FirstVisibleChildLayout";
+import { UseParentLayout } from "./UseParentLayout";
+import { PureContainer } from "../PureContainer";
+import { createFunctionalComponent } from "../createFunctionalComponent";
+describe("FirstVisibleChildLayout", () => {
+    it("renders only the first child", () => {
+        let widget = (_jsx("cx", { children: _jsxs("div", { layout: FirstVisibleChildLayout, children: [_jsx("header", {}), _jsx("main", {}), _jsx("footer", {})] }) }));
+        let store = new Store();
+        const component = createTestRenderer(store, widget);
+        let tree = component.toJSON();
+        assert.deepEqual(tree, {
+            type: "div",
+            props: {},
+            children: [{ type: "header", props: {}, children: null }],
+        });
+    });
+    it("does not process other widgets", () => {
+        let h = false, m = false, f = false;
+        let widget = (_jsx("cx", { children: _jsxs("div", { layout: FirstVisibleChildLayout, children: [_jsx("header", { onInit: () => {
+                            h = true;
+                        } }), _jsx("main", { onInit: () => {
+                            m = true;
+                        } }), _jsx("footer", { onInit: () => {
+                            f = true;
+                        } })] }) }));
+        let store = new Store();
+        const component = createTestRenderer(store, widget);
+        let tree = component.toJSON();
+        assert.deepEqual(tree, {
+            type: "div",
+            props: {},
+            children: [{ type: "header", props: {}, children: null }],
+        });
+        assert.equal(h, true);
+        assert.equal(m, false);
+        assert.equal(f, false);
+    });
+    it("skips the first child if not visible", () => {
+        let widget = (_jsx("cx", { children: _jsxs("div", { layout: FirstVisibleChildLayout, children: [_jsx("header", { visible: false }), _jsx("main", {}), _jsx("footer", {})] }) }));
+        let store = new Store();
+        const component = createTestRenderer(store, widget);
+        let tree = component.toJSON();
+        assert.deepEqual(tree, {
+            type: "div",
+            props: {},
+            children: [{ type: "main", props: {}, children: null }],
+        });
+    });
+    it("skips pure containers which use parent layouts", () => {
+        let widget = (_jsx("cx", { children: _jsxs("div", { layout: FirstVisibleChildLayout, children: [_jsx(PureContainer, { layout: UseParentLayout, children: _jsx("header", { visible: false }) }), _jsx("main", {}), _jsx("footer", {})] }) }));
+        let store = new Store();
+        const component = createTestRenderer(store, widget);
+        let tree = component.toJSON();
+        assert.deepEqual(tree, {
+            type: "div",
+            props: {},
+            children: [{ type: "main", props: {}, children: null }],
+        });
+    });
+    it("works with functional components", () => {
+        let FC = createFunctionalComponent(({ children }) => _jsx("cx", { children: children }));
+        let widget = (_jsx("cx", { children: _jsxs("div", { layout: FirstVisibleChildLayout, children: [_jsx(FC, { dummy: true, children: _jsx("header", { visible: false }) }), _jsx("main", {}), _jsx("footer", {})] }) }));
+        let store = new Store();
+        const component = createTestRenderer(store, widget);
+        let tree = component.toJSON();
+        assert.deepEqual(tree, {
+            type: "div",
+            props: {},
+            children: [{ type: "main", props: {}, children: null }],
+        });
+    });
+    it("properly destroys invisible items", () => {
+        let destroyList = [];
+        let widget = (_jsx("cx", { children: _jsxs("div", { layout: FirstVisibleChildLayout, children: [_jsx("div", { visible: expr("{index} == 0"), onDestroy: () => destroyList.push(0) }), _jsx("div", { visible: expr("{index} == 1"), onDestroy: () => destroyList.push(1) }), _jsx("div", { visible: expr("{index} == 2"), onDestroy: () => destroyList.push(2) }), _jsx("div", { visible: expr("{index} == 3"), onDestroy: () => destroyList.push(3) }), _jsx("div", { visible: expr("{index} == 4"), onDestroy: () => destroyList.push(4) })] }) }));
+        let store = new Store();
+        const component = createTestRenderer(store, widget);
+        store.set("index", 0);
+        component.toJSON();
+        assert.deepEqual(destroyList, []);
+        store.set("index", 3);
+        component.toJSON();
+        assert.deepEqual(destroyList, [0]);
+        store.set("index", 1);
+        component.toJSON();
+        assert.deepEqual(destroyList, [0, 3]);
+        store.set("index", 4);
+        component.toJSON();
+        assert.deepEqual(destroyList, [0, 3, 1]);
+        store.set("index", 0);
+        component.toJSON();
+        assert.deepEqual(destroyList, [0, 3, 1, 4]);
+        store.set("index", -1);
+        component.toJSON();
+        assert.deepEqual(destroyList, [0, 3, 1, 4, 0]);
+    });
+});

package/build/util/Console.d.ts

@@ -1,4 +1,5 @@
 export declare const Console: {
     log: (...args: any[]) => void;
     warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
 };

package/build/util/Console.js

@@ -1,10 +1,14 @@
 export const Console = {
     log: (...args) => {
-        if (typeof window != 'undefined' && window.console)
+        if (typeof window != "undefined" && window.console)
             console.log(...args);
     },
     warn: (...args) => {
-        if (typeof window != 'undefined' && window.console)
+        if (typeof window != "undefined" && window.console)
             console.warn(...args);
-    }
+    },
+    error: (...args) => {
+        if (typeof window != "undefined" && window.console)
+            console.error(...args);
+    },
 };

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/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/date/upperBoundCheck.spec.d.ts

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

package/build/util/date/upperBoundCheck.spec.js

@@ -0,0 +1,22 @@
+import assert from 'assert';
+import { upperBoundCheck } from './upperBoundCheck';
+describe('upperBoundCheck', () => {
+    let may18th = new Date('2017-05-18'); // May 18th
+    let may19th = new Date('2017-05-19'); // May 19th
+    let exclusive = true; // strictly less than...
+    it('returns true for May 18th <= May 19th', () => {
+        assert.equal(upperBoundCheck(may18th, may19th), true);
+    });
+    it('returns true for May 19th <= May 19th', () => {
+        assert.equal(upperBoundCheck(may19th, may19th), true);
+    });
+    it('returns true for May 19th <= May 19th with exclusive=`false`', () => {
+        assert.equal(upperBoundCheck(may19th, may19th, false), true);
+    });
+    it('returns false for May 19th < May 19th', () => {
+        assert.equal(upperBoundCheck(may19th, may19th, exclusive), false);
+    });
+    it('returns false for May 19th <= May 18th', () => {
+        assert.equal(upperBoundCheck(may19th, may18th), false);
+    });
+});

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

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

package/build/util/getSearchQueryPredicate.spec.js

@@ -0,0 +1,33 @@
+import { getSearchQueryPredicate, getSearchQueryHighlighter } from "./getSearchQueryPredicate";
+import assert from "assert";
+describe("getSearchQueryPredicate", function () {
+    it("blank means allow all", function () {
+        var m = getSearchQueryPredicate("");
+        assert(m("cx"));
+    });
+    it("is case insensitive", function () {
+        var m = getSearchQueryPredicate("Cx");
+        assert(m("cx"));
+    });
+    it("if multiple words are provided, all must be matched", function () {
+        var m = getSearchQueryPredicate("jo smi");
+        assert(m("John Smith"));
+        assert(!m("John Nash"));
+    });
+    it("regex special characters are properly escaped", function () {
+        var m = getSearchQueryPredicate("*?");
+        assert(m("*?"));
+    });
+});
+describe("getSearchQueryHighlighter", function () {
+    it("detects search parts", function () {
+        var m = getSearchQueryHighlighter("jo smi");
+        let items = m("John Smith");
+        assert.deepStrictEqual(items, ["", "Jo", "hn ", "Smi", "th"]);
+    });
+    it("detects search parts occuring multiple times", function () {
+        var m = getSearchQueryHighlighter("O");
+        let items = m("Option 1");
+        assert.deepStrictEqual(items, ["", "O", "pti", "o", "n 1"]);
+    });
+});

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

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