cx 26.0.13 → 26.1.0

package/build/ui/DataProxy.spec.js

@@ -1,208 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "cx/jsx-runtime";
-import { Store } from "../data/Store";
-import { createTestRenderer } from "../util/test/createTestRenderer";
-import assert from "assert";
-import { Controller } from "./Controller";
-import { DataProxy } from "./DataProxy";
-import { computable } from "../data/computable";
-import { useState } from "../hooks";
-import { createFunctionalComponent } from "./createFunctionalComponent";
-import { Widget } from "./Widget";
-import { bind } from "./bind";
-import { tpl } from "./tpl";
-describe("DataProxy", () => {
-    it("can calculate values", () => {
-        let widget = (_jsx("cx", { children: _jsx(DataProxy, { data: {
-                    $value: { bind: "value" },
-                }, children: _jsx("span", { text: bind("$value") }) }) }));
-        let store = new Store({
-            data: {
-                value: "good",
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "span",
-            props: {},
-            children: ["good"],
-        });
-    });
-    it("can write into values aliased with bind", () => {
-        class TestController extends Controller {
-            onInit() {
-                this.store.set("$value", "excellent");
-            }
-        }
-        let widget = (_jsx("cx", { children: _jsx(DataProxy, { data: {
-                    $value: { bind: "value" },
-                }, controller: TestController, children: _jsx("span", { text: bind("$value") }) }) }));
-        let store = new Store({
-            data: {
-                value: "good",
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert(store.get("value"), "excellent");
-        assert.deepEqual(tree, {
-            type: "span",
-            props: {},
-            children: ["excellent"],
-        });
-    });
-    it("can write into aliased values using provided setters", () => {
-        class TestController extends Controller {
-            onInit() {
-                this.store.set("$value", "excellent");
-            }
-        }
-        let widget = (_jsx("cx", { children: _jsx(DataProxy, { data: {
-                    $value: {
-                        expr: computable("value", (value) => value),
-                        set: (value, { store }) => {
-                            store.set("value", value);
-                        },
-                    },
-                }, controller: TestController, children: _jsx("span", { text: bind("$value") }) }) }));
-        let store = new Store({
-            data: {
-                value: "good",
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert(store.get("value"), "excellent");
-        assert.deepEqual(tree, {
-            type: "span",
-            props: {},
-            children: ["excellent"],
-        });
-    });
-    it("allows shorter syntax", () => {
-        let widget = (_jsx("cx", { children: _jsx(DataProxy, { alias: "$value", value: bind("value"), children: _jsx("span", { text: bind("$value") }) }) }));
-        let store = new Store({
-            data: {
-                value: "good",
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "span",
-            props: {},
-            children: ["good"],
-        });
-    });
-    it("correctly updates aliased data after write", () => {
-        class TestController extends Controller {
-            onInit() {
-                this.store.set("$value", "excellent");
-                assert.equal(this.store.get("$value"), "excellent");
-            }
-        }
-        let widget = (_jsx("cx", { children: _jsx(DataProxy, { data: {
-                    $value: { bind: "value" },
-                }, controller: TestController, children: _jsx("span", { text: bind("$value") }) }) }));
-        let store = new Store({
-            data: {
-                value: "good",
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert(store.get("value"), "excellent");
-        assert.deepEqual(tree, {
-            type: "span",
-            props: {},
-            children: ["excellent"],
-        });
-    });
-    it("properly binds structures", () => {
-        class TestController extends Controller {
-            onInit() {
-                this.store.set("$person.firstName", "Jim");
-            }
-        }
-        let widget = (_jsx("cx", { children: _jsx(DataProxy, { data: {
-                    $person: { bind: "person" },
-                }, controller: TestController, children: _jsx("span", { text: tpl("{$person.firstName} {$person.lastName}") }) }) }));
-        let store = new Store({
-            data: {
-                person: { firstName: "John", lastName: "Smith" },
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert(store.get("person.firstName"), "Jim");
-        assert.deepEqual(tree, {
-            type: "span",
-            props: {},
-            children: ["Jim Smith"],
-        });
-    });
-    it("works with Store refs", () => {
-        let widget = createFunctionalComponent(() => {
-            let valueRef = useState("a");
-            return (_jsx("cx", { children: _jsx(DataProxy, { data: {
-                        $value: valueRef,
-                    }, children: _jsx("span", { text: bind("$value"), controller: {
-                            onInit() {
-                                valueRef.set("b");
-                            },
-                        } }) }) }));
-        });
-        let store = new Store({
-            data: {
-            //value: "good"
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "span",
-            props: {},
-            children: ["b"],
-        });
-    });
-    it("controllers set on the DataProxy can see calculated values", () => {
-        let value;
-        let widget = Widget.create(_jsx("cx", { children: _jsx(DataProxy, { data: {
-                    $value: 5,
-                }, controller: {
-                    onInit() {
-                        value = this.store.get("$value");
-                    },
-                } }) }));
-        let store = new Store();
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.equal(value, 5);
-    });
-    it("correctly propagates undefined values over a previous value (bug)", () => {
-        let widget = (_jsxs("cx", { children: [_jsx(DataProxy, { data: {
-                        $value: { bind: "value" },
-                    }, children: _jsx("span", { text: bind("$value") }) }), _jsx(DataProxy, { data: {
-                        $value: { bind: "dummy" },
-                    }, children: _jsx("span", { text: bind("$value") }) })] }));
-        let store = new Store({
-            data: {
-                value: "initial",
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, [
-            {
-                type: "span",
-                props: {},
-                children: ["initial"],
-            },
-            {
-                type: "span",
-                props: {},
-                children: null,
-            },
-        ]);
-    });
-});

package/build/ui/IsolatedScope.spec.d.ts

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

package/build/ui/IsolatedScope.spec.js

@@ -1,42 +0,0 @@
-import { jsx as _jsx } from "cx/jsx-runtime";
-import { Store } from "../data/Store";
-import { createTestRenderer } from "../util/test/createTestRenderer";
-import assert from "assert";
-import { IsolatedScope } from "./IsolatedScope";
-import { bind } from "./bind";
-describe("IsolatedScope", () => {
-    it("prevents multiple re-renders", () => {
-        let list = [];
-        let widget = (_jsx("cx", { children: _jsx(IsolatedScope, { data: {
-                    value: { bind: 'value' }
-                }, children: _jsx("span", { text: bind("value"), onExplore: (context, { store }) => {
-                        list.push(store.get("value"));
-                    } }) }) }));
-        let store = new Store({
-            data: {
-                value: "bad",
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(list, ["bad"]);
-        assert.deepEqual(tree, {
-            type: "span",
-            props: {},
-            children: ["bad"],
-        });
-        //component should not re-render if unrelated data changes
-        store.set("dummy", "dummy");
-        tree = component.toJSON();
-        assert.deepEqual(list, ["bad"]);
-        //component should not re-render if unrelated data changes
-        store.set("value", "good");
-        tree = component.toJSON();
-        assert.deepEqual(list, ["bad", "good"]);
-        assert.deepEqual(tree, {
-            type: "span",
-            props: {},
-            children: ["good"],
-        });
-    });
-});

package/build/ui/PureContainer.spec.d.ts

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

package/build/ui/PureContainer.spec.js

@@ -1,149 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "cx/jsx-runtime";
-import { Store } from "../data/Store";
-import assert from "assert";
-import { createTestRenderer } from "../util/test/createTestRenderer";
-import { bind } from "./bind";
-import { PureContainer } from "./PureContainer";
-describe("PureContainer", () => {
-    it("renders static text children", () => {
-        let widget = (_jsx("cx", { children: _jsx(PureContainer, { children: _jsx("div", { children: "Test" }) }) }));
-        let store = new Store();
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert(tree && !Array.isArray(tree), "Expected single element");
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: ["Test"],
-        });
-    });
-    it("renders multiple children", () => {
-        let widget = (_jsx("cx", { children: _jsxs(PureContainer, { children: [_jsx("div", { children: "First" }), _jsx("div", { children: "Second" }), _jsx("div", { children: "Third" })] }) }));
-        let store = new Store();
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert(Array.isArray(tree), "Expected array of elements");
-        assert.equal(tree.length, 3);
-        assert.deepEqual(tree, [
-            {
-                type: "div",
-                props: {},
-                children: ["First"],
-            },
-            {
-                type: "div",
-                props: {},
-                children: ["Second"],
-            },
-            {
-                type: "div",
-                props: {},
-                children: ["Third"],
-            },
-        ]);
-    });
-    it("renders children with data bindings", () => {
-        let widget = (_jsx("cx", { children: _jsx(PureContainer, { children: _jsx("div", { text: bind("message") }) }) }));
-        let store = new Store({
-            data: {
-                message: "Hello World",
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert(tree && !Array.isArray(tree), "Expected single element");
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: ["Hello World"],
-        });
-    });
-    it("renders nested containers", () => {
-        let widget = (_jsx("cx", { children: _jsx(PureContainer, { children: _jsx("div", { children: _jsx(PureContainer, { children: _jsx("span", { children: "Nested" }) }) }) }) }));
-        let store = new Store();
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert(tree && !Array.isArray(tree), "Expected single element");
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: [
-                {
-                    type: "span",
-                    props: {},
-                    children: ["Nested"],
-                },
-            ],
-        });
-    });
-    it("conditionally renders children based on visible binding", () => {
-        let widget = (_jsx("cx", { children: _jsxs(PureContainer, { children: [_jsx("div", { visible: bind("show"), text: "Visible" }), _jsx("div", { visible: false, text: "Hidden" })] }) }));
-        let store = new Store({
-            data: {
-                show: true,
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert(tree && !Array.isArray(tree), "Expected single element");
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: ["Visible"],
-        });
-    });
-    it("handles empty children", () => {
-        let widget = (_jsx("cx", { children: _jsx(PureContainer, { children: _jsx("div", {}) }) }));
-        let store = new Store();
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert(tree && !Array.isArray(tree), "Expected single element");
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: null,
-        });
-    });
-    it("renders children from items property", () => {
-        let widget = (_jsx("cx", { children: _jsx(PureContainer, { items: [_jsx("div", { children: "Item 1" }, "1"), _jsx("div", { children: "Item 2" }, "2")] }) }));
-        let store = new Store();
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert(Array.isArray(tree), "Expected array of elements");
-        assert.equal(tree.length, 2);
-        assert.deepEqual(tree[0], {
-            type: "div",
-            props: {},
-            children: ["Item 1"],
-        });
-        assert.deepEqual(tree[1], {
-            type: "div",
-            props: {},
-            children: ["Item 2"],
-        });
-    });
-    it("updates children when store data changes", () => {
-        let widget = (_jsx("cx", { children: _jsx(PureContainer, { children: _jsx("div", { text: bind("count") }) }) }));
-        let store = new Store({
-            data: {
-                count: 0,
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: ["0"],
-        });
-        // Update the store
-        store.set("count", 5);
-        // Re-render
-        tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: ["5"],
-        });
-    });
-});

package/build/ui/Repeater.spec.d.ts

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

package/build/ui/Repeater.spec.js

@@ -1,109 +0,0 @@
-import { jsx as _jsx } from "cx/jsx-runtime";
-import { Store } from "../data/Store";
-import { Repeater } from "./Repeater";
-import { bind } from "./bind";
-import { createTestRenderer } from "../util/test/createTestRenderer";
-import assert from "assert";
-describe("Repeater", () => {
-    it("allows sorting", () => {
-        let data = [
-            {
-                value: "C",
-            },
-            {
-                value: "B",
-            },
-            {
-                value: "A",
-            },
-        ];
-        let widget = (_jsx("cx", { children: _jsx("div", { children: _jsx(Repeater, { records: data, sorters: [{ field: "value", direction: "ASC" }], recordAlias: "$item", children: _jsx("div", { text: bind("$item.value") }) }) }) }));
-        let store = new Store();
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: [
-                {
-                    type: "div",
-                    props: {},
-                    children: ["A"],
-                },
-                {
-                    type: "div",
-                    props: {},
-                    children: ["B"],
-                },
-                {
-                    type: "div",
-                    props: {},
-                    children: ["C"],
-                },
-            ],
-        });
-    });
-    it("changes are properly updated", () => {
-        let divInstances = [];
-        let widget = (_jsx("cx", { children: _jsx("div", { children: _jsx(Repeater, { records: bind("data"), sorters: [{ field: "value", direction: "ASC" }], recordAlias: "$item", children: _jsx("div", { text: bind("$item.value"), onExplore: (context, instance) => {
-                            divInstances.push(instance);
-                        } }) }) }) }));
-        let store = new Store({
-            data: {
-                data: [
-                    {
-                        value: "C",
-                    },
-                    {
-                        value: "B",
-                    },
-                ],
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: [
-                {
-                    type: "div",
-                    props: {},
-                    children: ["B"],
-                },
-                {
-                    type: "div",
-                    props: {},
-                    children: ["C"],
-                },
-            ],
-        });
-        divInstances = [];
-        store.update("data", (data) => [{ value: "A" }, ...data]);
-        assert.deepEqual(component.toJSON(), {
-            type: "div",
-            props: {},
-            children: [
-                {
-                    type: "div",
-                    props: {},
-                    children: ["A"],
-                },
-                {
-                    type: "div",
-                    props: {},
-                    children: ["B"],
-                },
-                {
-                    type: "div",
-                    props: {},
-                    children: ["C"],
-                },
-            ],
-        });
-        assert.equal(divInstances.length, 3);
-        assert.equal(divInstances[0].store.get("$item.value"), "A");
-        assert.equal(divInstances[1].store.get("$item.value"), "B");
-        assert.equal(divInstances[2].store.get("$item.value"), "C");
-    });
-});

package/build/ui/Rescope.spec.d.ts

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

package/build/ui/Rescope.spec.js

@@ -1,134 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "cx/jsx-runtime";
-import { Store } from "../data/Store";
-import { Rescope } from "./Rescope";
-import { bind } from "./bind";
-import { createTestRenderer } from "../util/test/createTestRenderer";
-import { Controller } from "./Controller";
-import assert from "assert";
-import { PureContainer } from "./PureContainer";
-describe("Rescope", () => {
-    it("allows simple access to nested data", () => {
-        let store = new Store({
-            data: {
-                $page: {
-                    data: {
-                        name: "John",
-                    },
-                },
-            },
-        });
-        let widget = (_jsx("cx", { children: _jsx(Rescope, { bind: "$page.data", children: _jsx("div", { text: bind("name") }) }) }));
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: ["John"],
-        });
-    });
-    it("allows parent access through $root", () => {
-        let store = new Store({
-            data: {
-                layout: {
-                    title: "Title",
-                },
-                $page: {
-                    data: {
-                        name: "John",
-                    },
-                },
-            },
-        });
-        let widget = (_jsx("cx", { children: _jsx(Rescope, { bind: "$page.data", children: _jsx("div", { text: bind("$root.layout.title") }) }) }));
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: ["Title"],
-        });
-    });
-    it("allows nested data access through data", () => {
-        let store = new Store({
-            data: {
-                layout: {
-                    title: "Title",
-                },
-            },
-        });
-        let widget = (_jsx("cx", { children: _jsx(Rescope, { bind: "$page", data: { $title: { bind: "layout.title" } }, children: _jsx("div", { text: bind("$title") }) }) }));
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: ["Title"],
-        });
-    });
-    it("nested data mutations are correctly propagated to the parent store", () => {
-        let store = new Store({
-            data: {
-                item: {
-                    value: 0,
-                },
-            },
-        });
-        let widget = (_jsxs("cx", { children: [_jsx(Rescope, { bind: "$page", data: { $value: { bind: "item.value" } }, children: _jsx(PureContainer, { controller: {
-                            onInit() {
-                                this.store.set("$value", 2);
-                            },
-                        } }) }), _jsx("div", { text: bind("item.value") })] }));
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: ["2"],
-        });
-    });
-    it("visible is calculated based on the inner scope", () => {
-        let store = new Store({
-            data: {
-                layout: {
-                    title: "Title",
-                },
-                $page: {
-                    data: {
-                        visible: true,
-                        name: "John",
-                    },
-                },
-            },
-        });
-        let widget = (_jsx("cx", { children: _jsx(Rescope, { bind: "$page.data", visible: bind("visible"), children: _jsx("div", { text: bind("name") }) }) }));
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: ["John"],
-        });
-    });
-    it("controllers see inner scope", () => {
-        let store = new Store({
-            data: {
-                $page: {
-                    data: {
-                        visible: true,
-                        name: "John",
-                    },
-                },
-            },
-        });
-        let testName = null;
-        class TestController extends Controller {
-            onInit() {
-                testName = this.store.get("name");
-            }
-        }
-        let widget = (_jsx("cx", { children: _jsx(Rescope, { bind: "$page.data", controller: TestController, children: _jsx("div", { text: bind("name") }) }) }));
-        const component = createTestRenderer(store, widget);
-        component.toJSON();
-        assert.equal(testName, "John");
-    });
-});

package/build/ui/Restate.spec.d.ts

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