cx 26.0.14 → 26.1.0

package/build/hooks/resolveCallback.spec.js

@@ -1,35 +0,0 @@
-import { jsx as _jsx } from "cx/jsx-runtime";
-import assert from "assert";
-import { Store } from "../data/Store";
-import { createFunctionalComponent } from "../ui/createFunctionalComponent";
-import { createTestRenderer } from "../util/test/createTestRenderer";
-import { resolveCallback } from "./resolveCallback";
-describe("resolveCallback", () => {
-    it("works with functions", () => {
-        const FComp = createFunctionalComponent(({ onTest }) => {
-            let callback = resolveCallback(onTest);
-            assert(typeof callback === 'function');
-            callback("works");
-            return (_jsx("cx", { children: _jsx("div", {}) }));
-        });
-        let store = new Store();
-        let value;
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx(FComp, { onTest: (v) => { value = v; } }) }));
-        component.toJSON();
-        assert.equal(value, "works");
-    });
-    it("works with controller methods", () => {
-        const FComp = createFunctionalComponent(({ onTest }) => {
-            let callback = resolveCallback(onTest);
-            assert(typeof callback === 'function');
-            return (_jsx("cx", { children: _jsx("div", { onInit: () => { callback("works"); } }) }));
-        });
-        let store = new Store();
-        let value;
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx(FComp, { onTest: "onTest", controller: {
-                    onTest(v) { value = v; }
-                } }) }));
-        component.toJSON();
-        assert.equal(value, "works");
-    });
-});

package/build/hooks/store.spec.d.ts

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

package/build/hooks/store.spec.js

@@ -1,48 +0,0 @@
-import { jsx as _jsx } from "cx/jsx-runtime";
-import assert from "assert";
-import { createTestRenderer } from "../util/test/createTestRenderer";
-import { computable } from "../data";
-import { Store } from "../data/Store";
-import { createFunctionalComponent } from "../ui/createFunctionalComponent";
-import { ref } from "./store";
-describe("ref", () => {
-    it("allows store references in functional components", () => {
-        const FComp = createFunctionalComponent(({}) => {
-            let testValue = ref({ bind: "x", defaultValue: 10 });
-            return (_jsx("cx", { children: _jsx("div", { text: testValue }) }));
-        });
-        let store = new Store();
-        const component = createTestRenderer(store, FComp);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            children: ["10"],
-            props: {},
-        });
-    });
-    it("can be used to adapt any prop passed to a functional component", () => {
-        const FComp = createFunctionalComponent(({ value }) => {
-            return (_jsx("cx", { children: _jsx("div", { text: computable(ref(value), (value) => `x${value}`) }) }));
-        });
-        let store = new Store({ data: { value: 100 } });
-        function test(value, expectation) {
-            const component = createTestRenderer(store, _jsx(FComp, { value: value }));
-            let tree = component.toJSON();
-            assert.deepEqual(tree, {
-                type: "div",
-                children: [expectation],
-                props: {},
-            });
-        }
-        test({ bind: "value" }, "x100");
-        test({ expr: "{value}" }, "x100");
-        test({ tpl: "{value:n;2}" }, "x100.00");
-        test(200, "x200");
-        test(() => 500, "x500");
-        test(computable("value", (value) => value + 100), "x200");
-        test(null, "xnull");
-        test(undefined, "xundefined");
-        test(0, "x0");
-        test(false, "xfalse");
-    });
-});

package/build/hooks/useTrigger.spec.d.ts

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

package/build/hooks/useTrigger.spec.js

@@ -1,59 +0,0 @@
-import { jsx as _jsx } from "cx/jsx-runtime";
-import assert from "assert";
-import { createTestRenderer } from "../util/test/createTestRenderer";
-import { Store } from "../data/Store";
-import { createFunctionalComponent } from "../ui/createFunctionalComponent";
-import { useTrigger } from "./useTrigger";
-describe("useTrigger", () => {
-    it("works", () => {
-        let last = null;
-        const FComp = createFunctionalComponent(({ ...props }) => {
-            useTrigger(["test"], (test) => {
-                last = test;
-            });
-            return (_jsx("cx", { children: _jsx("div", {}) }));
-        });
-        let store = new Store();
-        let test = store.ref("test", 1);
-        const component = createTestRenderer(store, FComp);
-        component.toJSON();
-        assert.equal(last, null); //trigger did not fire because it didn't receive true as the last argument
-        test.set(2);
-        component.toJSON();
-        assert.equal(last, 2);
-    });
-    it("fires immediately if the last argument is true", () => {
-        let last = null;
-        const FComp = createFunctionalComponent(({ ...props }) => {
-            useTrigger(["test"], (test) => {
-                last = test;
-            }, true);
-            return (_jsx("cx", { children: _jsx("div", {}) }));
-        });
-        let store = new Store();
-        let test = store.ref("test", 1);
-        const component = createTestRenderer(store, FComp);
-        component.toJSON();
-        assert.equal(last, 1);
-        test.set(2);
-        component.toJSON();
-        assert.equal(last, 2);
-    });
-    it("accepts refs as arguments", () => {
-        let last = null;
-        let store = new Store();
-        let test = store.ref("test", 1);
-        const FComp = createFunctionalComponent(({ ...props }) => {
-            useTrigger([test], (test) => {
-                last = test;
-            }, true);
-            return (_jsx("cx", { children: _jsx("div", {}) }));
-        });
-        const component = createTestRenderer(store, FComp);
-        component.toJSON();
-        assert.equal(last, 1);
-        test.set(2);
-        component.toJSON();
-        assert.equal(last, 2);
-    });
-});

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

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

package/build/ui/Controller.spec.js

@@ -1,247 +0,0 @@
-import { jsx as _jsx } from "cx/jsx-runtime";
-import { Store } from "../data/Store";
-import { Controller } from "./Controller";
-import { createTestRenderer } from "../util/test/createTestRenderer";
-import { Widget } from "./Widget";
-import { bind } from "./bind";
-import assert from "assert";
-describe("Controller", () => {
-    it("invokes lifetime methods", () => {
-        let init = 0, prepare = 0, explore = 0, cleanup = 0;
-        class TestController extends Controller {
-            onInit() {
-                init++;
-            }
-            onExplore() {
-                explore++;
-            }
-            onPrepare() {
-                prepare++;
-            }
-            onCleanup() {
-                cleanup++;
-            }
-        }
-        let store = new Store();
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("div", { controller: TestController }) }));
-        let tree = component.toJSON();
-        assert.equal(init, 1);
-        assert.equal(explore, 1);
-        assert.equal(prepare, 1);
-        assert.equal(cleanup, 1);
-    });
-    it("widgets invoke controller methods specified as strings", () => {
-        let callback = 0;
-        class TestController extends Controller {
-            callback() {
-                ++callback;
-            }
-        }
-        class Cmp extends Widget {
-            render(context, instance, key) {
-                instance.invoke("onTest");
-                return null;
-            }
-        }
-        let store = new Store();
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx(Cmp, { controller: TestController, onTest: "callback" }) }));
-        let tree = component.toJSON();
-        assert.equal(callback, 1);
-    });
-    it("widgets can access controller methods specified in ancestor controllers", () => {
-        let callback1 = 0;
-        let callback2 = 0;
-        class TestController1 extends Controller {
-            callback1() {
-                ++callback1;
-            }
-        }
-        class TestController2 extends Controller {
-            callback2() {
-                ++callback2;
-            }
-        }
-        class Cmp extends Widget {
-            render(context, instance, key) {
-                instance.invoke("onTest");
-                return null;
-            }
-        }
-        let store = new Store();
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("div", { controller: TestController1, children: _jsx(Cmp, { controller: TestController2, onTest: "callback1" }) }) }));
-        let tree = component.toJSON();
-        assert.equal(callback1, 1);
-        assert.equal(callback2, 0);
-    });
-    it("ancestor controllers are initialized first", () => {
-        let order = [];
-        class TestController1 extends Controller {
-            onInit() {
-                order.push("1");
-            }
-        }
-        class TestController2 extends Controller {
-            onInit() {
-                order.push("2");
-            }
-        }
-        let store = new Store();
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("div", { controller: TestController1, children: _jsx("div", { controller: TestController2 }) }) }));
-        let tree = component.toJSON();
-        assert.deepEqual(order, ["1", "2"]);
-    });
-    it("controllers on invisible elements are not initialized", () => {
-        let order = [];
-        class TestController1 extends Controller {
-            onInit() {
-                order.push("1");
-            }
-        }
-        class TestController2 extends Controller {
-            onInit() {
-                order.push("2");
-            }
-        }
-        let store = new Store();
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("div", { controller: TestController1, children: _jsx("div", { visible: false, controller: TestController2 }) }) }));
-        let tree = component.toJSON();
-        assert.deepEqual(order, ["1"]);
-    });
-    it("invokes triggers and computables in order of definition", () => {
-        let log = [];
-        class TestController extends Controller {
-            onInit() {
-                this.addTrigger("t1", [], () => {
-                    log.push("t1");
-                }, true);
-                this.addComputable("c1", [], () => {
-                    log.push("c1");
-                    return null;
-                });
-                this.addTrigger("t2", [], () => {
-                    log.push("t2");
-                }, true);
-            }
-        }
-        let store = new Store();
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("div", { controller: TestController }) }));
-        let tree = component.toJSON();
-        assert.deepEqual(log, ["t1", "c1", "t2"]);
-    });
-    it("is recreated if a component is hidden and shown", () => {
-        let initCount = 0;
-        class TestController extends Controller {
-            onInit() {
-                initCount++;
-            }
-        }
-        let store = new Store();
-        store.set("visible", true);
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("div", { visible: bind("visible"), controller: TestController }) }));
-        let tree1 = component.toJSON();
-        assert.equal(initCount, 1);
-        store.set("visible", false);
-        let tree2 = component.toJSON();
-        assert.equal(tree2, null);
-        store.set("visible", true);
-        let tree3 = component.toJSON();
-        assert.equal(initCount, 2);
-    });
-    it("allows creation through a factory", () => {
-        let store = new Store({ data: { x: 0 } });
-        const controllerFactory = ({ store }) => {
-            return {
-                increment() {
-                    store.update("x", (x) => x + 1);
-                },
-            };
-        };
-        let c = Controller.create(controllerFactory, { store });
-        c.increment();
-        assert.equal(store.get("x"), 1);
-    });
-    it("lifetime methods of a functional controller are properly invoked", () => {
-        let initCount = 0, destroyCount = 0;
-        const testController = () => ({
-            onInit() {
-                initCount++;
-            },
-            onDestroy() {
-                destroyCount++;
-            },
-        });
-        let store = new Store();
-        store.set("visible", true);
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("div", { visible: bind("visible"), controller: testController }) }));
-        let tree1 = component.toJSON();
-        assert.equal(initCount, 1);
-        store.set("visible", false);
-        let tree2 = component.toJSON();
-        assert.equal(destroyCount, 1);
-        store.set("visible", true);
-        let tree3 = component.toJSON();
-        assert.equal(initCount, 2);
-    });
-    it("widgets can easily define controller methods", () => {
-        let store = new Store({ data: { x: 0 } });
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("div", { controller: {
-                    increment(count) {
-                        this.store.update("x", (x) => x + count);
-                    },
-                }, children: _jsx("div", { controller: {
-                        onInit() {
-                            this.invokeParentMethod("increment", 1);
-                        },
-                    } }) }) }));
-        let tree1 = component.toJSON();
-        assert.equal(store.get("x"), 1);
-    });
-    it("functional controllers get store methods through configuration", () => {
-        let store = new Store({ data: { x: 0 } });
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("div", { controller: ({ update }) => ({
-                    increment(count) {
-                        update("x", (x) => x + count);
-                    },
-                }), children: _jsx("div", { controller: {
-                        onInit() {
-                            this.invokeParentMethod("increment", 1);
-                        },
-                    } }) }) }));
-        let tree1 = component.toJSON();
-        assert.equal(store.get("x"), 1);
-    });
-    it("addComputable accepts refs", () => {
-        let store = new Store({ data: { x: 0 } });
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("div", { controller: ({ ref }) => {
-                    let x = ref("x");
-                    return {
-                        onInit() {
-                            this.addComputable("y", [x], (x) => x + 1);
-                        },
-                    };
-                } }) }));
-        let tree1 = component.toJSON();
-        assert.equal(store.get("y"), 1);
-    });
-    it("invokeParentMethod is invoked on parent instance", () => {
-        let testValid = [];
-        class TestController1 extends Controller {
-            onInit() {
-                this.test();
-            }
-            test() {
-                testValid.push(1);
-                this.invokeParentMethod("test", 2);
-            }
-        }
-        class TestController2 extends Controller {
-            test(val) {
-                testValid.push(val);
-            }
-        }
-        let store = new Store();
-        const component = createTestRenderer(store, _jsx("cx", { children: _jsx("div", { controller: TestController2, children: _jsx("div", { controller: TestController1 }) }) }));
-        // let tree = component.toJSON();
-        assert.deepStrictEqual(testValid, [1, 2]);
-    });
-});

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

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

package/build/ui/Cx.spec.js

@@ -1,153 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "cx/jsx-runtime";
-import { VDOM } from "./VDOM";
-import { ContainerBase } from "./Container";
-import { Store } from "../data/Store";
-import { bind } from "./bind";
-import { createTestRenderer, createTestWidget } from "../util/test/createTestRenderer";
-import assert from "assert";
-describe("Cx", () => {
-    it("can render cx content", () => {
-        let widget = (_jsx("cx", { children: _jsx("div", { children: "Test" }) }));
-        let store = new Store();
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: ["Test"],
-        });
-    });
-    it("store changes preserve the instance", () => {
-        let instanceLog = [];
-        let storeLog = [];
-        let widget = (_jsx("cx", { children: _jsx("div", { text: bind("text"), onExplore: (context, instance) => {
-                    instanceLog.push(instance);
-                    storeLog.push(instance.store);
-                } }) }));
-        let store1 = new Store({ data: { text: "Test1" } });
-        let store2 = new Store({ data: { text: "Test2" } });
-        const component = createTestRenderer(store1, widget);
-        let tree1 = component.toJSON();
-        assert.deepEqual(tree1, {
-            type: "div",
-            props: {},
-            children: ["Test1"],
-        });
-        component.update(createTestWidget(store2, widget));
-        let tree2 = component.toJSON();
-        assert.deepEqual(tree2, {
-            type: "div",
-            props: {},
-            children: ["Test2"],
-        });
-        assert.equal(instanceLog.length, 2);
-        assert.equal(instanceLog[0], instanceLog[1]); //store changes should preserve the instance
-        assert(storeLog[0] === store1);
-        assert(storeLog[1] === store2);
-    });
-    it("invokes lifetime methods in the right order", () => {
-        let events = [];
-        class TestWidget extends ContainerBase {
-            explore(context, instance) {
-                super.explore(context, instance);
-                events.push(["explore", this.id]);
-            }
-            exploreCleanup(context, instance) {
-                //super.exploreCleanup(context, instance);
-                events.push(["exploreCleanup", this.id]);
-            }
-            prepare(context, instance) {
-                //super.prepare(context, instance);
-                events.push(["prepare", this.id]);
-            }
-            prepareCleanup(context, instance) {
-                //super.prepareCleanup(context, instance);
-                events.push(["prepareCleanup", this.id]);
-            }
-            render(context, instance, key) {
-                events.push(["render", this.id]);
-                return VDOM.createElement("div", { key }, this.renderChildren(context, instance));
-            }
-        }
-        let widget = (_jsx("cx", { children: _jsxs(TestWidget, { id: "0", children: [_jsx(TestWidget, { id: "0.0" }), _jsxs(TestWidget, { id: "0.1", children: [_jsx(TestWidget, { id: "0.1.0" }), _jsx(TestWidget, { id: "0.1.1" })] }), _jsx(TestWidget, { id: "0.2", children: _jsx(TestWidget, { id: "0.2.0" }) })] }) }));
-        let store = new Store();
-        const component = createTestRenderer(store, widget);
-        let tree = component.toJSON();
-        assert.deepEqual(tree, {
-            type: "div",
-            props: {},
-            children: [
-                {
-                    type: "div",
-                    props: {},
-                    children: null,
-                },
-                {
-                    type: "div",
-                    props: {},
-                    children: [
-                        {
-                            type: "div",
-                            props: {},
-                            children: null,
-                        },
-                        {
-                            type: "div",
-                            props: {},
-                            children: null,
-                        },
-                    ],
-                },
-                {
-                    type: "div",
-                    props: {},
-                    children: [
-                        {
-                            type: "div",
-                            props: {},
-                            children: null,
-                        },
-                    ],
-                },
-            ],
-        });
-        //console.log(events);
-        assert.deepEqual(events, [
-            ["explore", "0"],
-            ["explore", "0.0"],
-            ["exploreCleanup", "0.0"],
-            ["explore", "0.1"],
-            ["explore", "0.1.0"],
-            ["exploreCleanup", "0.1.0"],
-            ["explore", "0.1.1"],
-            ["exploreCleanup", "0.1.1"],
-            ["exploreCleanup", "0.1"],
-            ["explore", "0.2"],
-            ["explore", "0.2.0"],
-            ["exploreCleanup", "0.2.0"],
-            ["exploreCleanup", "0.2"],
-            ["exploreCleanup", "0"],
-            ["prepare", "0"],
-            ["prepare", "0.0"],
-            ["prepareCleanup", "0.0"],
-            ["prepare", "0.1"],
-            ["prepare", "0.1.0"],
-            ["prepareCleanup", "0.1.0"],
-            ["prepare", "0.1.1"],
-            ["prepareCleanup", "0.1.1"],
-            ["prepareCleanup", "0.1"],
-            ["prepare", "0.2"],
-            ["prepare", "0.2.0"],
-            ["prepareCleanup", "0.2.0"],
-            ["prepareCleanup", "0.2"],
-            ["prepareCleanup", "0"],
-            ["render", "0.2.0"],
-            ["render", "0.2"],
-            ["render", "0.1.1"],
-            ["render", "0.1.0"],
-            ["render", "0.1"],
-            ["render", "0.0"],
-            ["render", "0"],
-        ]);
-    });
-});

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

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