cx 26.0.9 → 26.0.10

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 {};

package/build/ui/Restate.spec.js

@@ -1,257 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "cx/jsx-runtime";
-import { Restate } from "./Restate";
-import { Store } from "../data/Store";
-import { createTestRenderer } from "../util/test/createTestRenderer";
-import assert from "assert";
-import { Controller } from "./Controller";
-import { bind } from "./bind";
-import { FirstVisibleChildLayout } from "./layout/FirstVisibleChildLayout";
-describe("Restate", () => {
-    it("provides a blank slate", () => {
-        let widget = (_jsx("cx", { children: _jsx("div", { children: _jsxs(Restate, { data: {
-                        value: "good",
-                    }, children: [_jsx("span", { text: bind("value") }), _jsx("span", { text: bind("value2") })] }) }) }));
-        let store = new Store({
-            data: {
-                value: "bad",
-                value2: "also bad",
-            },
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: [
-                {
-                    type: "span",
-                    props: {},
-                    children: ["good"],
-                },
-                {
-                    type: "span",
-                    props: {},
-                    children: null,
-                },
-            ],
-        });
-    });
-    it("wires declared data", () => {
-        let widget = (_jsx("cx", { children: _jsx("div", { children: _jsx(Restate, { data: {
-                        name: { bind: "person.name" },
-                    }, children: _jsx("div", { controller: {
-                            onInit() {
-                                this.store.init("name", "Sasa");
-                                this.store.init("nickname", "Sale");
-                            },
-                        } }) }) }) }));
-        let changed = false;
-        let store = new Store();
-        store.subscribe(() => {
-            //console.log(store.getData());
-            changed = true;
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.equal(store.get("person.name"), "Sasa");
-        assert(store.get("person.nickname") === undefined);
-        assert(changed);
-    });
-    it("causes a global update if internal data changes", () => {
-        let controller;
-        class TestController extends Controller {
-            onInit() {
-                controller = this;
-            }
-            setNickname(nname) {
-                this.store.set("nickname", nname);
-            }
-        }
-        let widget = (_jsx("cx", { children: _jsx("div", { children: _jsx(Restate, { data: {
-                        name: { bind: "person.name" },
-                    }, children: _jsx("div", { controller: TestController, text: bind("nickname") }) }) }) }));
-        let changed = false;
-        let store = new Store();
-        store.subscribe(() => {
-            changed = true;
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: [
-                {
-                    type: "div",
-                    props: {},
-                    children: null,
-                },
-            ],
-        });
-        controller.setNickname("Sale");
-        let tree2 = component.toJSON();
-        assert.deepEqual(tree2, {
-            type: "div",
-            props: {},
-            children: [
-                {
-                    type: "div",
-                    props: {},
-                    children: ["Sale"],
-                },
-            ],
-        });
-    });
-    it("doesn't notify parent if not necessary in detached mode", () => {
-        class TestController extends Controller {
-            onInit() {
-                this.store.init("nickname", "Sale");
-            }
-        }
-        let widget = (_jsx("cx", { children: _jsx("div", { children: _jsx(Restate, { detached: true, data: {
-                        name: { bind: "person.name" },
-                    }, children: _jsx("div", { controller: TestController }) }) }) }));
-        let changed = false;
-        let store = new Store();
-        store.subscribe(() => {
-            changed = true;
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert(!changed);
-    });
-    it("shared state can be used across components inside and outside Restate", () => {
-        let widget = (_jsx("cx", { children: _jsxs("div", { children: [_jsx("div", { text: bind("person.gender", "Male") }), _jsxs(Restate, { detached: true, data: {
-                            person: { bind: "person" },
-                        }, children: [_jsx("div", { text: bind("person.firstName", "John") }), _jsx("div", { text: bind("person.lastName", "Doe") })] }), _jsx("div", { text: bind("person.address", "Unknown") })] }) }));
-        let changed = false;
-        let store = new Store();
-        store.subscribe(() => {
-            changed = true;
-            //console.log(store.getData());
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(store.getData(), {
-            person: {
-                firstName: "John",
-                lastName: "Doe",
-                address: "Unknown",
-                gender: "Male",
-            },
-        });
-    });
-    it("updates if shared state is changed from outside", () => {
-        [true, false].forEach((detached) => {
-            let widget = (_jsx("cx", { children: _jsxs("div", { children: [_jsx(Restate, { detached: detached, data: {
-                                person: { bind: "person" },
-                            }, children: _jsx("div", { text: bind("person.firstName") }) }), _jsx("div", { text: bind("person.firstName", "John") })] }) }));
-            let store = new Store();
-            const component = createTestRenderer(store, widget);
-            let tree = component.toJSON();
-            assert.deepEqual(tree, {
-                type: "div",
-                props: {},
-                children: [
-                    {
-                        type: "div",
-                        props: {},
-                        children: ["John"],
-                    },
-                    {
-                        type: "div",
-                        props: {},
-                        children: ["John"],
-                    },
-                ],
-            });
-            store.set("person.firstName", "Jack");
-            tree = component.toJSON();
-            assert.deepEqual(tree, {
-                type: "div",
-                props: {},
-                children: [
-                    {
-                        type: "div",
-                        props: {},
-                        children: ["Jack"],
-                    },
-                    {
-                        type: "div",
-                        props: {},
-                        children: ["Jack"],
-                    },
-                ],
-            });
-        });
-    });
-    it("allows field initialization in data declaration", () => {
-        [true, false].forEach((detached) => {
-            let widget = (_jsx("cx", { children: _jsx("div", { children: _jsx(Restate, { detached: detached, data: {
-                            name: bind("name", "Cx"),
-                        }, children: _jsx("div", { text: bind("name") }) }) }) }));
-            let store = new Store();
-            const component = createTestRenderer(store, widget);
-            let tree = component.toJSON();
-            assert.deepEqual(tree, {
-                type: "div",
-                props: {},
-                children: [
-                    {
-                        type: "div",
-                        props: {},
-                        children: ["Cx"],
-                    },
-                ],
-            });
-        });
-    });
-    it("updates if internal data changes", () => {
-        class TestController extends Controller {
-            onInit() {
-                this.store.init("nickname", "Sale");
-            }
-        }
-        let widget = (_jsx("cx", { children: _jsx("div", { children: _jsx(Restate, { children: _jsx(Restate, { children: _jsx("div", { controller: TestController, text: bind("nickname") }) }) }) }) }));
-        let changed = false;
-        let store = new Store();
-        store.subscribe(() => {
-            changed = true;
-        });
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: [
-                {
-                    type: "div",
-                    props: {},
-                    children: ["Sale"],
-                },
-            ],
-        });
-    });
-    it("works with FirstVisibleChildLayout", () => {
-        let widget = (_jsx("cx", { children: _jsx("div", { children: _jsxs(FirstVisibleChildLayout, { children: [_jsx(Restate, { children: _jsx("div", { children: "First" }) }), _jsx("div", { children: "Second" })] }) }) }));
-        let store = new Store();
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: [{ type: "div", props: {}, children: ["First"] }],
-        });
-    });
-    it("is transparent to FirstVisibleChildLayout", () => {
-        let widget = (_jsx("cx", { children: _jsx("div", { children: _jsxs(FirstVisibleChildLayout, { children: [_jsx(Restate, { children: _jsx("div", { visible: false, children: "First" }) }), _jsx("div", { children: "Second" })] }) }) }));
-        let store = new Store();
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: [{ type: "div", props: {}, children: ["Second"] }],
-        });
-    });
-});

package/build/ui/adapter/ArrayAdapter.spec.d.ts

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

package/build/ui/adapter/ArrayAdapter.spec.js

@@ -1,44 +0,0 @@
-import { RenderingContext } from "../RenderingContext";
-import { Instance } from "../Instance";
-import assert from "assert";
-import { Store } from "../../data";
-import { ArrayAdapter } from "./ArrayAdapter";
-describe("ArrayAdapter", () => {
-    it("maps data into records", () => {
-        let adapter = new ArrayAdapter();
-        let data = [
-            {
-                id: 1,
-                text: "1",
-            },
-            {
-                id: 2,
-                text: "2",
-            },
-        ];
-        let store = new Store();
-        let records = adapter.mapRecords(new RenderingContext(), new Instance(null, "1", null, store), data, store);
-        assert.equal(records.length, 2);
-        assert.equal(records[0].data, records[0].store.get("$record"));
-        assert.equal(records[1].data, records[1].store.get("$record"));
-    });
-    it("can sort data", () => {
-        let adapter = new ArrayAdapter();
-        adapter.sort([{ field: "id", direction: "DESC" }]);
-        let data = [
-            {
-                id: 1,
-                text: "1",
-            },
-            {
-                id: 2,
-                text: "2",
-            },
-        ];
-        let store = new Store();
-        let records = adapter.mapRecords(new RenderingContext(), new Instance(null, "1", null, store), data, store);
-        assert.equal(records.length, 2);
-        assert.equal(data[1], records[0].store.get("$record"));
-        assert.equal(data[0], records[1].store.get("$record"));
-    });
-});

package/build/ui/adapter/TreeAdapter.spec.d.ts

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

package/build/ui/adapter/TreeAdapter.spec.js

@@ -1,71 +0,0 @@
-import { RenderingContext } from "../RenderingContext";
-import { Instance } from "../Instance";
-import { TreeAdapter } from "./TreeAdapter";
-import assert from "assert";
-import { Store } from "../../data";
-describe("TreeAdapter", () => {
-    it("properly expands records", () => {
-        let tree = new TreeAdapter({
-            childrenField: "children",
-            expandedField: "expanded",
-        });
-        let data = [
-            {
-                id: 1,
-                text: "1",
-                expanded: false,
-                children: [
-                    {
-                        id: 4,
-                        text: "4",
-                    },
-                ],
-            },
-            {
-                id: 2,
-                text: "2",
-                expanded: true,
-                children: [
-                    {
-                        id: 3,
-                        text: "3",
-                        expanded: true,
-                        children: [
-                            {
-                                id: 5,
-                                text: "5",
-                                expanded: true,
-                                children: [
-                                    {
-                                        id: 6,
-                                        text: "6",
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            },
-            {
-                id: 7,
-                text: "7",
-                expanded: false,
-            },
-        ];
-        let store = new Store();
-        let records = tree.mapRecords(new RenderingContext(), new Instance(null, "1", null, store), data, store);
-        assert.equal(records.length, 6);
-        assert.equal(records[0].data.id, 1);
-        assert.equal(records[1].data.id, 2);
-        assert.equal(records[2].data.id, 3);
-        assert.equal(records[3].data.id, 5);
-        assert.equal(records[4].data.id, 6);
-        assert.equal(records[5].data.id, 7);
-        assert.equal(records[5].store.get("$record.id"), 7);
-        assert.equal(records[2].store.get("$record.id"), 3);
-        assert.equal(records[3].store.get("$record.id"), 5);
-        assert.equal(records[2].store.get("$record.id"), 3);
-        assert.equal(records[0].store.get("$record.id"), 1);
-        assert.equal(records[1].store.get("$record.id"), 2);
-    });
-});

package/build/ui/app/Url.spec.d.ts

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

package/build/ui/app/Url.spec.js

@@ -1,43 +0,0 @@
-import { Url } from "./Url";
-import Route from "route-parser";
-import assert from "assert";
-describe("Url", function () {
-    describe(".unresolve", function () {
-        it("preserves query parameters", function () {
-            Url.absoluteBase = "https://cxjs.io/docs/";
-            assert.equal("~/?state=1", Url.unresolve("https://cxjs.io/docs/?state=1"));
-        });
-        it("doesn't touch unresolved urls", function () {
-            assert.equal("~/test", Url.unresolve("~/test"));
-        });
-    });
-    describe(".getBaseFromScriptSrc", () => {
-        it("ignores query strings", function () {
-            assert.equal(Url.getBaseFromScriptSrc("/vendor.js?qs=1", "~/vendor.js"), "/");
-        });
-        it("allows wildcards", function () {
-            assert.equal(Url.getBaseFromScriptSrc("/vendor.123.js?qs=1", "~/vendor.*.js"), "/");
-        });
-        it("works for an application folder", function () {
-            assert.equal(Url.getBaseFromScriptSrc("/datasync/vendor.124c82.js", "~/vendor.*.js"), "/datasync/");
-        });
-    });
-});
-describe("Route", function () {
-    it("matches query param", function () {
-        let route = new Route("~/?state=:state");
-        let result = route.match("~/?state=1");
-        assert(result !== false);
-        assert.equal(result.state, "1");
-    });
-    it("matches routes with extra query params", function () {
-        let route = new Route("~/?state=:state");
-        let result = route.match("~/?state=1&more=2");
-        assert(result);
-    });
-    it.skip("matches query params in any order", function () {
-        let route = new Route("~/?a=:a&b=:b");
-        let result = route.match("~/?b=1&a=2");
-        assert(result);
-    });
-});

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

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