cx 26.0.9 → 26.0.10

package/build/data/Store.spec.js

@@ -1,19 +0,0 @@
-import assert from 'assert';
-import { Store } from './Store';
-describe('Store', () => {
-    const getStore = () => {
-        return new Store({
-            data: {
-                a: 3,
-                item: {
-                    firstName: 'Jack'
-                }
-            }
-        });
-    };
-    it('changes version on each update', () => {
-        let store = getStore();
-        store.set('a', 4);
-        assert.equal(store.getMeta().version, 1);
-    });
-});

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

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

package/build/data/StoreRef.spec.js

@@ -1,22 +0,0 @@
-//@ts-nocheck
-import assert from "assert";
-import { Store } from "./Store";
-const getStore = () => {
-    return new Store({
-        data: {
-            person: {
-                name: "Jack",
-            },
-        },
-    });
-};
-describe("StoreRef", () => {
-    it("can access child refs", () => {
-        let store = getStore();
-        let person = store.ref("person");
-        let name = person.ref("name");
-        assert.equal(name.get("person"), "Jack");
-        name.set("John");
-        assert.equal(name.get("person"), "John");
-    });
-});

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

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

package/build/data/StringTemplate.spec.js

@@ -1,112 +0,0 @@
-import { StringTemplate } from "./StringTemplate";
-import assert from "assert";
-describe("StringTemplate", function () {
-    describe("#compile()", function () {
-        it("returns a selector", function () {
-            var e = StringTemplate.compile("Hello {person.name}");
-            var state = {
-                person: {
-                    name: "Jim",
-                },
-            };
-            assert.equal(e(state), "Hello Jim");
-        });
-        it("allows empty strings", function () {
-            let e = StringTemplate.compile("");
-            assert.equal(e({}), "");
-        });
-        it("properly encodes ' and \"", function () {
-            var e = StringTemplate.compile('It\'s "working"!');
-            assert.equal(e({}), 'It\'s "working"!');
-        });
-        it("allows \\ before a binding", function () {
-            var e = StringTemplate.compile("t\\{person.name}");
-            assert.equal(e({ person: { name: "Ogi" } }), "t\\Ogi");
-        });
-        it("supports multi-line strings", function () {
-            var e = StringTemplate.compile("a\nb");
-            assert.equal(e({}), "a\nb");
-            var e = StringTemplate.compile("a\r\nb");
-            assert.equal(e({}), "a\r\nb");
-        });
-    });
-    describe("double brackets are used to escape brackets", function () {
-        it("double brackets are preserved", function () {
-            var e = StringTemplate.compile("Hello {{person.name}}");
-            var state = {
-                person: {
-                    name: "Jim",
-                },
-            };
-            assert.equal(e(state), "Hello {person.name}");
-        });
-        it("triple brackets are converted to single brackets and a binding", function () {
-            var e = StringTemplate.compile("Hello {{{person.name}}}");
-            var state = {
-                person: {
-                    name: "Jim",
-                },
-            };
-            assert.equal(e(state), "Hello {Jim}");
-        });
-        it("open brackets are ignored", function () {
-            var e = StringTemplate.compile("B { A");
-            assert.equal(e({}), "B { A");
-        });
-    });
-    describe("supports formatting", function () {
-        it("with colon", function () {
-            var e = StringTemplate.compile("{str:suffix;kg}");
-            assert.equal(e({ str: "5" }), "5kg");
-        });
-        it("with multiple formats", function () {
-            var e = StringTemplate.compile("{str:suffix;kg:wrap;(;)}");
-            assert.equal(e({ str: "5" }), "(5kg)");
-        });
-        it("with null values", function () {
-            var e = StringTemplate.compile("{str:suffix;kg:|N/A}");
-            assert.equal(e({ str: null }), "N/A");
-        });
-        it("of null values", function () {
-            var e = StringTemplate.compile("{str|N/A}");
-            assert.equal(e({ str: null }), "N/A");
-        });
-    });
-    describe("properly handles backslashes", function () {
-        it("in a string", function () {
-            var e = StringTemplate.compile("a\\b");
-            assert.equal(e({}), "a\\b");
-        });
-        it("before a special character", function () {
-            var e = StringTemplate.compile("\\t");
-            assert.equal(e({}), "\\t");
-        });
-    });
-    describe("supports expressions", function () {
-        it("using []", function () {
-            var e = StringTemplate.compile("1 + 2 = {[1+2]}");
-            assert.equal(e({}), "1 + 2 = 3");
-        });
-        it("using %", function () {
-            var e = StringTemplate.compile("1 + 2 = %{1+2}");
-            assert.equal(e({}), "1 + 2 = 3");
-        });
-        it("with subexpressions", function () {
-            var e = StringTemplate.compile("1 + 2 = {[%{1+2}]}");
-            assert.equal(e({}), "1 + 2 = 3");
-        });
-        it("with a conditional operator", function () {
-            var e = StringTemplate.compile("1 + 2 = {[true ? 3 : 2]:s}");
-            assert.equal(e({}), "1 + 2 = 3");
-        });
-        it("with sub-expression formatting", function () {
-            var e = StringTemplate.compile("{[!!{person.age} ? {person.age:suffix; years old} : 'Age unknown']}");
-            var state = {
-                person: {
-                    age: 32,
-                },
-            };
-            assert.equal(e(state), "32 years old");
-        });
-    });
-});

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

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

package/build/data/StructuredSelector.spec.js

@@ -1,102 +0,0 @@
-//@ts-nocheck
-import { StructuredSelector } from "./StructuredSelector";
-import assert from "assert";
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-describe("StructuredSelector", function () {
-    describe("#create()", function () {
-        it("constants", function () {
-            var x = {};
-            var s = new StructuredSelector({
-                props: {
-                    a: undefined,
-                    b: undefined,
-                },
-                values: {
-                    a: 1,
-                    b: 2,
-                },
-            }).create(x);
-            assert.deepEqual(s(x), { a: 1, b: 2 });
-        });
-        it("bindings", function () {
-            var x = { a: 1, b: 2 };
-            var s = new StructuredSelector({
-                props: {
-                    a: undefined,
-                    b: undefined,
-                },
-                values: {
-                    a: { bind: "b" },
-                    b: { bind: "a" },
-                },
-            }).create(x);
-            assert.deepEqual(s(x), { a: 2, b: 1 });
-        });
-        it("templates", function () {
-            var x = { a: 1, b: 2 };
-            var s = new StructuredSelector({
-                props: {
-                    a: undefined,
-                    b: undefined,
-                },
-                values: {
-                    a: { tpl: "b{a}" },
-                    b: { tpl: "a{b}" },
-                },
-            }).create(x);
-            assert.deepEqual(s(x), { a: "b1", b: "a2" });
-        });
-        it("structured", function () {
-            var x = { a: 1, b: 2 };
-            var s = new StructuredSelector({
-                props: {
-                    a: {
-                        structured: true,
-                    },
-                    b: undefined,
-                },
-                values: {
-                    a: {
-                        x: { expr: "{a} == 1" },
-                        y: { expr: "{b} == 1" },
-                    },
-                    b: { tpl: "a{b}" },
-                },
-            }).create(x);
-            assert.deepEqual(s(x), { a: { x: true, y: false }, b: "a2" });
-        });
-    });
-    it("structures do not change if data doesn't change", function () {
-        var x = { a: 1, b: 2 };
-        var s = new StructuredSelector({
-            props: {
-                a: {
-                    structured: true,
-                },
-            },
-            values: {
-                a: {
-                    x: { expr: "{a} == 1" },
-                    y: { expr: "{b} == 1" },
-                },
-                b: { tpl: "a{b}" },
-            },
-        }).create(x);
-        let r1 = s(x);
-        let r2 = s(x);
-        assert.equal(r1, r2);
-    });
-    it("structures do not change if data doesn't change", function () {
-        var x = { a: { b: 2 } };
-        var m = createAccessorModelProxy();
-        var s = new StructuredSelector({
-            props: {
-                b: undefined,
-            },
-            values: {
-                b: m.a.b,
-            },
-        }).create(x);
-        assert.deepEqual(s(x), { b: 2 });
-    });
-});

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

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

package/build/data/View.spec.js

@@ -1,44 +0,0 @@
-//@ts-nocheck
-import assert from 'assert';
-import { Store } from './Store';
-describe('View', () => {
-    const getStore = () => {
-        return new Store({
-            data: {
-                a: 3,
-                item: {
-                    firstName: 'Jack'
-                }
-            }
-        });
-    };
-    describe('.get', () => {
-        it('retrieves a value pointed by a selector path', () => {
-            let store = getStore();
-            assert.equal(store.get('item.firstName'), 'Jack');
-        });
-        it('will return an array if multiple arguments are passed', () => {
-            let store = getStore();
-            assert.deepEqual(store.get('a', 'item.firstName'), [3, 'Jack']);
-        });
-        it('will return an array if array is passed', () => {
-            let store = getStore();
-            assert.deepEqual(store.get(['a', 'item.firstName']), [3, 'Jack']);
-        });
-    });
-    describe('.set', () => {
-        it('supports deep selectors', () => {
-            let store = getStore();
-            store.set('item.firstName', 'Jill');
-            assert.equal(store.get('item.firstName'), 'Jill');
-        });
-        it('supports setting multiple items through an object', () => {
-            let store = getStore();
-            store.set({
-                'b': 4,
-                'item.firstName': 'Jill'
-            });
-            assert.deepEqual(store.get(['b', 'item.firstName']), [4, 'Jill']);
-        });
-    });
-});

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

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

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