cx 26.0.13 → 26.1.0

package/build/data/ZoomIntoPropertyView.spec.js

@@ -1,54 +0,0 @@
-import assert from "assert";
-import { Binding } from "./Binding";
-import { Store } from "./Store";
-import { ZoomIntoPropertyView } from "./ZoomIntoPropertyView";
-describe("ZoomIntoPropertyView", () => {
-    const getZoom = () => {
-        let store = new Store({
-            data: {
-                a: 3,
-                item: {
-                    firstName: "Jack",
-                },
-            },
-        });
-        return new ZoomIntoPropertyView({
-            store: store,
-            binding: Binding.get("item"),
-        });
-    };
-    it("allows direct access to properties of zoomed object", () => {
-        let zoom = getZoom();
-        assert.equal(zoom.get("firstName"), "Jack");
-    });
-    it("allows access to outside data through $root", () => {
-        let zoom = getZoom();
-        assert.equal(zoom.get("$root.a"), 3);
-    });
-    it("correctly sets zoomed object", () => {
-        let zoom = getZoom();
-        zoom.set("firstName", "Joe");
-        assert.equal(zoom.get("firstName"), "Joe");
-    });
-    it("correctly sets zoomed values", () => {
-        let zoom = getZoom();
-        zoom.set("firstName", "Joe");
-        assert.equal(zoom.get("firstName"), "Joe");
-        assert.equal(zoom.get("$root.item.firstName"), "Joe");
-    });
-    it("correctly sets outside values", () => {
-        let zoom = getZoom();
-        zoom.set("$root.a", 6);
-        assert.equal(zoom.get("$root.a"), 6);
-    });
-    it("correctly deletes zoomed values", () => {
-        let zoom = getZoom();
-        zoom.delete("firstName");
-        assert.equal(zoom.get("firstName"), undefined);
-    });
-    it("correctly deletes outside values", () => {
-        let zoom = getZoom();
-        zoom.delete("$root.a");
-        assert.equal(zoom.get("$root.a"), undefined);
-    });
-});

package/build/data/comparer.spec.d.ts

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

package/build/data/comparer.spec.js

@@ -1,50 +0,0 @@
-import { sorter } from "./comparer";
-import assert from "assert";
-describe("comparer", function () {
-    describe("sorter", function () {
-        it("orders by numeric values ASC", function () {
-            let records = [
-                { value: 3, id: 1 },
-                { value: -1, id: 2 },
-                { value: 2, id: 3 },
-                { value: null, id: 4 },
-                { value: null, id: 5 },
-            ];
-            let sort = sorter([{ value: { bind: "value" }, direction: "ASC" }]);
-            let sorted = sort(records);
-            assert.equal(sorted[0].value, -1);
-            assert.equal(sorted[1].value, 2);
-            assert.equal(sorted[2].value, 3);
-            assert.equal(sorted[3].value, null);
-            assert.equal(sorted[4].value, null);
-        });
-        it("orders by numeric values DESC", function () {
-            let records = [
-                { value: 3, id: 1 },
-                { value: 1, id: 2 },
-                { value: -2, id: 3 },
-                { value: null, id: 4 },
-                { value: null, id: 5 },
-            ];
-            let sort = sorter([{ value: { bind: "value" }, direction: "DESC" }]);
-            let sorted = sort(records);
-            assert.equal(sorted[0].value, 3);
-            assert.equal(sorted[1].value, 1);
-            assert.equal(sorted[2].value, -2);
-            assert.equal(sorted[3].value, null);
-            assert.equal(sorted[4].value, null);
-        });
-        it("supports field", function () {
-            let records = [
-                { value: 3, id: 1 },
-                { value: 1, id: 2 },
-                { value: 2, id: 3 },
-            ];
-            let sort = sorter([{ field: "value", direction: "ASC" }]);
-            let sorted = sort(records);
-            assert.equal(sorted[0].value, 1);
-            assert.equal(sorted[1].value, 2);
-            assert.equal(sorted[2].value, 3);
-        });
-    });
-});

package/build/data/computable.spec.d.ts

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

package/build/data/computable.spec.js

@@ -1,56 +0,0 @@
-import { computable } from "./computable";
-import assert from "assert";
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-describe("computable", function () {
-    it("creates a selector", function () {
-        let state = { person: { name: "Joe" } };
-        let nameLength = computable("person.name", (name) => name.length);
-        assert.equal(nameLength(state), 3);
-    });
-    it("fires every time if not memoized", function () {
-        let state = { person: { name: "Joe" } };
-        let fired = 0;
-        let nameLength = computable("person.name", (name) => {
-            fired++;
-            return name.length;
-        });
-        assert.equal(nameLength(state), 3);
-        assert.equal(nameLength(state), 3);
-        assert.equal(fired, 2);
-    });
-    it("fires once if memoized and data has not changed", function () {
-        let state = { person: { name: "Joe" } };
-        let fired = 0;
-        let nameLength = computable("person.name", (name) => {
-            fired++;
-            return name.length;
-        }).memoize();
-        assert.equal(nameLength(state), 3);
-        assert.equal(nameLength(state), 3);
-        assert.equal(fired, 1);
-    });
-    //weird but that's how triggers work and
-    it("memoize with warmup data will not call compute", function () {
-        let state = { person: { name: "Joe" } };
-        let fired = 0;
-        let nameLength = computable("person.name", (name) => {
-            fired++;
-            return name.length;
-        }).memoize(state);
-        assert.equal(nameLength(state), undefined);
-        assert.equal(nameLength(state), undefined);
-        assert.equal(fired, 0);
-    });
-    it("works with accessors", function () {
-        var m = createAccessorModelProxy();
-        let state = { person: { name: "Joe" } };
-        let nameLength = computable(m.person.name, (name) => name.length);
-        assert.equal(nameLength(state), 3);
-    });
-    it("works with array length accessor", function () {
-        var m = createAccessorModelProxy();
-        let state = { items: ["a", "b", "c"] };
-        let itemCount = computable(m.items.length, (length) => length);
-        assert.equal(itemCount(state), 3);
-    });
-});

package/build/data/createAccessorModelProxy.spec.d.ts

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

package/build/data/createAccessorModelProxy.spec.js

@@ -1,30 +0,0 @@
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-import assert from "assert";
-describe("createAccessorModelProxy", () => {
-    it("generates correct paths", () => {
-        let model = createAccessorModelProxy();
-        assert.strictEqual(model.firstName.toString(), "firstName");
-        assert.strictEqual(model.address.toString(), "address");
-        assert.strictEqual(model.address.city.toString(), "address.city");
-    });
-    it("can be used in string templates", () => {
-        let model = createAccessorModelProxy();
-        assert.strictEqual("address.city", `${model.address.city}`);
-        assert.strictEqual("address.city", "" + model.address.city);
-        assert.strictEqual("address.city.suffix", model.address.city + ".suffix");
-    });
-    it("nameOf returns name of the last prop ", () => {
-        let model = createAccessorModelProxy();
-        assert.strictEqual(model.firstName.nameOf(), "firstName");
-        assert.strictEqual(model.address.nameOf(), "address");
-        assert.strictEqual(model.address.city.nameOf(), "city");
-        assert.strictEqual(model.address.nameOf(), "address");
-        let { streetNumber, city } = model.address;
-        assert.strictEqual(streetNumber.nameOf(), "streetNumber");
-        assert.strictEqual(city.nameOf(), "city");
-    });
-    it("allows non-standard property identifiers ", () => {
-        let model = createAccessorModelProxy();
-        assert.strictEqual(model["@crazy"].nameOf(), "@crazy");
-    });
-});

package/build/data/createStructuredSelector.spec.d.ts

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

package/build/data/createStructuredSelector.spec.js

@@ -1,42 +0,0 @@
-import { createStructuredSelector } from "./createStructuredSelector";
-import assert from "assert";
-import { getSelector } from "./getSelector";
-import { computable } from "./computable";
-describe("createStructuredSelector", function () {
-    it("works", function () {
-        let structure = {
-            name: getSelector({ bind: "name" }),
-        };
-        let state = { name: "Joe" };
-        let selector = createStructuredSelector(structure);
-        assert.deepEqual(selector(state), { name: "Joe" });
-    });
-    it("does not memoize by default", function () {
-        let computes = 0;
-        let structure = {
-            name: computable("name", (name) => {
-                computes++;
-                return name;
-            }),
-        };
-        let state = { name: "Joe" };
-        let selector = createStructuredSelector(structure);
-        assert.deepEqual(selector(state), { name: "Joe" });
-        selector(state);
-        assert.deepEqual(computes, 2);
-    });
-    it("supports memoize", function () {
-        let computes = 0;
-        let structure = {
-            name: computable("name", (name) => {
-                computes++;
-                return name;
-            }),
-        };
-        let state = { name: "Joe" };
-        let selector = createStructuredSelector(structure).memoize();
-        assert.deepEqual(selector(state), { name: "Joe" });
-        selector(state);
-        assert.deepEqual(computes, 1);
-    });
-});

package/build/data/diff/diffs.spec.d.ts

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

package/build/data/diff/diffs.spec.js

@@ -1,45 +0,0 @@
-//@ts-nocheck
-import assert from 'assert';
-import { diffArrays } from './diffArrays';
-describe('diffArrays', function () {
-    it('should detect new elements', function () {
-        var a = [];
-        var b = [{ k: 1 }, { k: 2 }];
-        var d = diffArrays(a, b);
-        assert.deepEqual(d, {
-            added: [{ k: 1 }, { k: 2 }],
-            removed: [],
-            unchanged: [],
-            changed: []
-        });
-    });
-    it('should detect removed elements', function () {
-        var a = [];
-        var b = [{ k: 1 }, { k: 2 }];
-        var d = diffArrays(b, a);
-        assert.deepEqual(d, {
-            removed: [{ k: 1 }, { k: 2 }],
-            added: [],
-            unchanged: [],
-            changed: []
-        });
-    });
-    it('should detect changed elements', function () {
-        var a = [{ k: 1, v: 2 }];
-        var b = [{ k: 1 }, { k: 2 }];
-        var d = diffArrays(a, b, x => x.k);
-        assert.deepEqual(d, {
-            added: [{ k: 2 }],
-            removed: [],
-            unchanged: [],
-            changed: [{
-                    after: {
-                        k: 1
-                    },
-                    before: {
-                        k: 1, v: 2
-                    }
-                }]
-        });
-    });
-});

package/build/data/getAccessor.spec.d.ts

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

package/build/data/getAccessor.spec.js

@@ -1,10 +0,0 @@
-import assert from "assert";
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-import { getAccessor } from "./getAccessor";
-describe("getAccessor", function () {
-    it("works with accessor chains", function () {
-        let m = createAccessorModelProxy();
-        let accessor = getAccessor(m.a.b);
-        assert(typeof accessor.set == "function");
-    });
-});

package/build/data/getSelector.spec.d.ts

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

package/build/data/getSelector.spec.js

@@ -1,36 +0,0 @@
-import { getSelector } from "./getSelector";
-import assert from "assert";
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-describe("getSelector", function () {
-    it("array of selectors converts each element into a selector", function () {
-        let arraySelector = [{ bind: "name" }, { expr: "{name}" }];
-        let state = { name: "Joe" };
-        let selector = getSelector(arraySelector);
-        assert.deepEqual(selector(state), ["Joe", "Joe"]);
-    });
-    it("get can be used for selectors that have set defined too ", function () {
-        let selector = getSelector({ get: (data) => data.name, set: () => { } });
-        assert.deepEqual(selector({ name: "Jack" }), "Jack");
-    });
-    it("0 is a valid selector", function () {
-        let selector = getSelector(0);
-        assert.deepEqual(selector({}), 0);
-    });
-    it("false is a valid selector", function () {
-        let selector = getSelector(false);
-        assert.deepEqual(selector({}), false);
-    });
-    it("undefined is a valid selector", function () {
-        let selector = getSelector(undefined);
-        assert(selector({}) === undefined);
-    });
-    it("null is a valid selector", function () {
-        let selector = getSelector(null);
-        assert(selector({}) === null);
-    });
-    it("works with accessor chains", function () {
-        let m = createAccessorModelProxy();
-        let selector = getSelector(m.a.b);
-        assert(selector({ a: { b: 1 } }) === 1);
-    });
-});

package/build/data/ops/append.spec.d.ts

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

package/build/data/ops/append.spec.js

@@ -1,24 +0,0 @@
-import assert from 'assert';
-import { Store } from '../Store';
-import { append } from './append';
-describe('append', function () {
-    it('should add elements to an array', function () {
-        let store = new Store({
-            data: {
-                array: []
-            }
-        });
-        assert(store.update('array', append, 1));
-        assert.deepEqual(store.get('array'), [1]);
-    });
-    it('should work with undefined arrays', function () {
-        let store = new Store();
-        assert(store.update('array', append, 1));
-        assert.deepEqual(store.get('array'), [1]);
-    });
-    it('accepts multiple arguments', function () {
-        let store = new Store();
-        assert(store.update('array', append, 1, 2, 3));
-        assert.deepEqual(store.get('array'), [1, 2, 3]);
-    });
-});

package/build/data/ops/filter.spec.d.ts

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

package/build/data/ops/filter.spec.js

@@ -1,25 +0,0 @@
-import assert from "assert";
-import { Store } from "../Store";
-import { filter } from "./filter";
-describe("filter", function () {
-    it("should filter array elements", function () {
-        let store = new Store({
-            data: {
-                array: [1, 2, 3],
-            },
-        });
-        assert(store.update("array", filter, (x) => x > 1));
-        assert.deepEqual(store.get("array"), [2, 3]);
-    });
-    it("should work with undefined arrays", function () {
-        let store = new Store();
-        assert.equal(false, store.update("array", filter, (x) => x > 1));
-        assert.deepEqual(store.get("array"), undefined);
-    });
-    it("returns same array if all elements satisfy condition", function () {
-        let array = [1, 2, 3];
-        let store = new Store({ data: { array } });
-        assert.equal(false, store.update("array", filter, (x) => x > 0));
-        assert(store.get("array") === array);
-    });
-});

package/build/data/ops/findTreeNode.spec.d.ts

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

package/build/data/ops/findTreeNode.spec.js

@@ -1,20 +0,0 @@
-import assert from 'assert';
-import { findTreeNode } from './findTreeNode';
-describe('removeTreeNodes', function () {
-    it('removes all nodes that satisfy criteria', function () {
-        let array = [{
-                id: 'n1',
-                value: 1,
-                children: [{
-                        id: 'n11',
-                        value: 2
-                    }, {
-                        id: 'n12',
-                        value: 3
-                    }]
-            }];
-        let node = findTreeNode(array, x => x.value == 3, 'children');
-        assert(node);
-        assert.equal(node.value, 3);
-    });
-});

package/build/data/ops/merge.spec.d.ts

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

package/build/data/ops/merge.spec.js

@@ -1,23 +0,0 @@
-import { Store } from "../Store";
-import { merge } from "./merge";
-import assert from "assert";
-describe("merge", function () {
-    it("performs multiple set operations", function () {
-        let store = new Store({
-            data: {
-                person: { firstName: "John", lastName: "Doe" },
-            },
-        });
-        assert(store.update("person", merge, { firstName: "Johny", age: 18 }));
-        assert.deepEqual(store.get("person"), { firstName: "Johny", lastName: "Doe", age: 18 });
-    });
-    it("does not modify data if not necessary", function () {
-        let store = new Store({
-            data: {
-                person: { firstName: "John", lastName: "Doe" },
-            },
-        });
-        assert(store.update("person", merge, { firstName: "John" }) == false);
-        assert.deepEqual(store.get("person"), { firstName: "John", lastName: "Doe" });
-    });
-});

package/build/data/ops/removeTreeNodes.spec.d.ts

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

package/build/data/ops/removeTreeNodes.spec.js

@@ -1,35 +0,0 @@
-import { Store } from "../Store";
-import { removeTreeNodes } from "./removeTreeNodes";
-import assert from "assert";
-describe("removeTreeNodes", function () {
-    it("removes all nodes that satisfy criteria", function () {
-        let store = new Store({
-            data: {
-                array: [
-                    {
-                        id: "n1",
-                        value: 1,
-                        children: [
-                            {
-                                id: "n11",
-                                value: 2,
-                            },
-                            {
-                                id: "n12",
-                                value: 3,
-                            },
-                        ],
-                    },
-                ],
-            },
-        });
-        assert(store.update("array", removeTreeNodes, (x) => x.value > 1, "children"));
-        assert.deepEqual(store.get("array"), [
-            {
-                id: "n1",
-                value: 1,
-                children: [],
-            },
-        ]);
-    });
-});

package/build/data/ops/updateArray.spec.d.ts

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

package/build/data/ops/updateArray.spec.js

@@ -1,33 +0,0 @@
-import { Store } from "../Store";
-import { updateArray } from "./updateArray";
-import assert from "assert";
-describe("updateArray", function () {
-    it("updates all elements that satisfy criteria", function () {
-        let store = new Store({
-            data: { array: [1, 2, 3, 4, 5, 6] },
-        });
-        assert(store.update("array", updateArray, (x) => x + 1, (x) => x > 3));
-        assert.deepEqual(store.get("array"), [1, 2, 3, 5, 6, 7]);
-    });
-    it("does not modify data if not necessary", function () {
-        let array = [1, 2, 3, 4, 5, 6];
-        let store = new Store({
-            data: { array },
-        });
-        assert(false ===
-            store.update("array", updateArray, (x) => x + 1, (x) => x > 10));
-        assert(store.get("array") === array);
-    });
-    it("works with null or undefined", function () {
-        let store = new Store();
-        assert(false ===
-            store.update("array", updateArray, (x) => x + 1, (x) => x > 0));
-    });
-    it("can remove elements given the criteria", function () {
-        let store = new Store({
-            data: { array: [1, 2, 3, 4, 5, 6] },
-        });
-        assert(store.update("array", updateArray, (x) => x + 1, (x) => x > 3, (x) => x <= 3));
-        assert.deepEqual(store.get("array"), [5, 6, 7]);
-    });
-});

package/build/data/ops/updateTree.spec.d.ts

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

package/build/data/ops/updateTree.spec.js

@@ -1,44 +0,0 @@
-import { Store } from "../Store";
-import { updateTree } from "./updateTree";
-import assert from "assert";
-describe("updateTree", function () {
-    it("updates all nodes that satisfy criteria", function () {
-        let store = new Store({
-            data: {
-                array: [
-                    {
-                        id: "n1",
-                        value: 1,
-                        children: [
-                            {
-                                id: "n11",
-                                value: 2,
-                            },
-                            {
-                                id: "n12",
-                                value: 3,
-                            },
-                        ],
-                    },
-                ],
-            },
-        });
-        assert(store.update("array", updateTree, (x) => ({ ...x, value: x.value + 1 }), (x) => x.value > 1, "children"));
-        assert.deepEqual(store.get("array"), [
-            {
-                id: "n1",
-                value: 1,
-                children: [
-                    {
-                        id: "n11",
-                        value: 3,
-                    },
-                    {
-                        id: "n12",
-                        value: 4,
-                    },
-                ],
-            },
-        ]);
-    });
-});

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

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

package/build/hooks/invokeCallback.spec.js

@@ -1,44 +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 { invokeCallback } from "./invokeCallback";
-describe("invokeCallback", () => {
-    it("works with functions", () => {
-        const FComp = createFunctionalComponent(({ onTest }) => {
-            invokeCallback(null, onTest, "works");
-            return (_jsx("cx", { children: _jsx("div", {}) }));
-        });
-        let store = new Store();
-        let value;
-        const component = createTestRenderer(store, {
-            type: FComp,
-            onTest: (v) => {
-                value = v;
-            },
-        });
-        component.toJSON();
-        assert.equal(value, "works");
-    });
-    it("works with controller methods", () => {
-        const FComp = createFunctionalComponent(({ onTest }) => {
-            return (_jsx("cx", { children: _jsx("div", { onExplore: (context, instance) => {
-                        invokeCallback(instance, onTest, "works");
-                    } }) }));
-        });
-        let store = new Store();
-        let value;
-        const component = createTestRenderer(store, {
-            type: FComp,
-            onTest: "onTest",
-            controller: {
-                onTest(v) {
-                    value = v;
-                },
-            },
-        });
-        component.toJSON();
-        assert.equal(value, "works");
-    });
-});

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

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