cx 26.0.13 → 26.1.0

package/build/data/Expression.spec.js

@@ -1,196 +0,0 @@
-import { Expression } from "./Expression";
-import assert from "assert";
-import { StringTemplate } from "./StringTemplate";
-describe("Expression", function () {
-    describe("#compile()", function () {
-        it("returns a selector", function () {
-            let e = Expression.compile("{person.name}");
-            let state = {
-                person: {
-                    name: "Jim",
-                },
-            };
-            assert.equal(e(state), "Jim");
-        });
-        it("ignores bindings in strings", function () {
-            let e = Expression.compile('"{person.name}"');
-            let state = {
-                person: {
-                    name: "Jim",
-                },
-            };
-            assert.equal(e(state), "{person.name}");
-        });
-        it("allows mixed curly braces in strings", () => {
-            let e = Expression.compile('"Hello {" + "person.name}"');
-            assert.equal(e({}), "Hello {person.name}");
-        });
-        it("properly encodes quotes #1", function () {
-            let e = Expression.compile('"\'"');
-            let state = {};
-            assert.equal(e(state), "'");
-        });
-        it("properly encodes quotes #2", function () {
-            let e = Expression.compile('"\\""');
-            let state = {};
-            assert.equal(e(state), '"');
-        });
-        it("properly encodes quotes #3", function () {
-            let e = Expression.compile('"\\\\\\""');
-            let state = {};
-            assert.equal(e(state), '\\"');
-        });
-        it("properly encodes quotes #4", function () {
-            let e = Expression.compile('"\\\\"');
-            let state = {};
-            assert.equal(e(state), "\\");
-        });
-    });
-    describe("allow subexpressions", function () {
-        it("in square brackets", function () {
-            let e = Expression.compile("{[{person.name}]}");
-            let state = {
-                person: {
-                    name: "Jim",
-                },
-            };
-            assert.equal(e(state), "Jim");
-        });
-        it("in square brackets", function () {
-            let e = Expression.compile("{[{person.alias} || {person.name}]}");
-            let state = {
-                person: {
-                    name: "Jim",
-                    alias: "J",
-                },
-            };
-            assert.equal(e(state), "J");
-        });
-        it("prefixed with % sign", function () {
-            let e = Expression.compile("%{1+1}");
-            assert.equal(e({}), "2");
-        });
-        it("can be formatted", function () {
-            let e = Expression.compile("{[1+1]:f;2}");
-            assert.equal(e({}), "2.00");
-        });
-        it("n level deep", function () {
-            let e = Expression.compile("{[{[{[1+1]}]}]:f;2}");
-            assert.equal(e({}), "2.00");
-        });
-        it("with complex math inside", function () {
-            let e = Expression.compile("%{{data}.reduce((a,b)=>a+b, 0):f;2}");
-            let state = {
-                data: [1, 2, 3],
-            };
-            assert.equal(e(state), "6.00");
-        });
-        it("with a conditional operator inside", function () {
-            let e = Expression.compile('{[true ? "T" : "F"]}');
-            assert.equal(e({}), "T");
-        });
-        it("with string interpolation inside", function () {
-            let e = Expression.compile("{[`${{test}}`]}");
-            assert.equal(e({ test: "T" }), "T");
-        });
-    });
-    describe("are working", function () {
-        it("function expressions with get", function () {
-            let e = Expression.get((get) => get("a") + get("b"));
-            assert.equal(e({ a: 1, b: 2 }), 3);
-        });
-        it("are properly memoized", function () {
-            let inv = 0;
-            let e = Expression.get((get) => {
-                inv++;
-                return get("a") + get("b");
-            }).memoize();
-            assert.equal(e({ a: 1, b: 1 }), 2);
-            assert.equal(inv, 1);
-            assert.equal(e({ a: 1, b: 1 }), 2);
-            assert.equal(inv, 1);
-            assert.equal(e({ a: 1, b: 2 }), 3);
-            assert.equal(inv, 2);
-            assert.equal(e({ a: 1, b: 2 }), 3);
-            assert.equal(inv, 2);
-            assert.equal(e({ a: 2, b: 2 }), 4);
-            assert.equal(inv, 3);
-        });
-        it("formatting can be used inside bindings", function () {
-            let e = Expression.get((get) => get("name:prefix;Hello "));
-            assert(e({ name: "CxJS" }), "Hello CxJS");
-        });
-        it("allows using the fmt function inside", function () {
-            let e = Expression.compile('{[fmt({text}, "prefix;Hello ")]}');
-            assert.equal(e({ text: "CxJS" }), "Hello CxJS");
-        });
-        it("allows using dashes inside names", function () {
-            let e = Expression.compile("{framework-name}");
-            assert.equal(e({ "framework-name": "CxJS" }), "CxJS");
-        });
-        it("allows using spaces and other characters inside names", function () {
-            let e = Expression.compile("{1nv@lid js ident1fier}");
-            assert.equal(e({ "1nv@lid js ident1fier": "CxJS" }), "CxJS");
-        });
-        it("allows strings in subexpressions", () => {
-            let e = Expression.compile("{['1']}");
-            assert.equal(e({}), "1");
-            let e2 = Expression.compile('%{"1"}');
-            assert.equal(e({}), "1");
-        });
-        it("allows string templates in nested expressions", () => {
-            Expression.registerHelper("tpl", StringTemplate.format);
-            let e = Expression.compile("tpl('{0:n;2} {1:p;2:wrap;(;)}', {value}, {percentage})");
-            assert.equal(e({ value: 1, percentage: 0.02 }), "1.00 (2.00%)");
-            let e2 = Expression.compile("{[tpl('{0:n;2} {1:p;2:wrap;(;)}', {value}, {percentage})]}");
-            assert.equal(e2({ value: 1, percentage: 0.02 }), "1.00 (2.00%)");
-            // we're going to need a better parser for this
-            // let e3 = Expression.compile("%{tpl('{0:n;2} {1:p;2:wrap;(;)}', {value}, {percentage})}");
-            // assert.equal(e3({ value: 1, percentage: 0.02 }), "1.00 (2.00%)");
-        });
-        it("string templates can be in the data", () => {
-            Expression.registerHelper("tpl", StringTemplate.format);
-            let e = Expression.compile("tpl({template}, {value}, {percentage})");
-            assert.equal(e({ value: 1, percentage: 0.02, template: "{0:n;2} {1:p;2:wrap;(;)}" }), "1.00 (2.00%)");
-        });
-        // it('are properly memoized with proxies', function () {
-        //    let inv = 0;
-        //    let e = Expression.get(d => { inv++; return d.a + d.b}).memoize();
-        //
-        //    assert.equal(e({ a: 1, b: 1 }), 2);
-        //    assert.equal(inv, 1);
-        //
-        //    assert.equal(e({ a: 1, b: 1 }), 2);
-        //    assert.equal(inv, 1);
-        //
-        //    assert.equal(e({ a: 1, b: 2 }), 3);
-        //    assert.equal(inv, 2);
-        //
-        //    assert.equal(e({ a: 1, b: 2 }), 3);
-        //    assert.equal(inv, 2);
-        //
-        //    assert.equal(e({ a: 2, b: 2 }), 4);
-        //    assert.equal(inv, 3);
-        // });
-        //
-        // it('are properly memoized with proxies and deep data', function () {
-        //    let inv = 0;
-        //    let e = Expression.get(d => { inv++; return d.v.a + d.v.b}).memoize();
-        //
-        //    assert.equal(e({ v: { a: 1, b: 1 }}), 2);
-        //    assert.equal(inv, 1);
-        //
-        //    assert.equal(e({ v: { a: 1, b: 1 }}), 2);
-        //    assert.equal(inv, 1);
-        //
-        //    assert.equal(e({ v: { a: 1, b: 2 }}), 3);
-        //    assert.equal(inv, 2);
-        //
-        //    assert.equal(e({ v: { a: 1, b: 2 }}), 3);
-        //    assert.equal(inv, 2);
-        //
-        //    assert.equal(e({ v: { a: 2, b: 2 }}), 4);
-        //    assert.equal(inv, 3);
-        // });
-    });
-});

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

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

package/build/data/Grouper.spec.js

@@ -1,48 +0,0 @@
-import { Grouper } from "./Grouper";
-import assert from "assert";
-describe("Grouper", function () {
-    describe("single grouping", function () {
-        it("should work", function () {
-            let data = [
-                { name: "John", age: 12 },
-                { name: "Jane", age: 12 },
-            ];
-            let grouper = new Grouper({ name: { bind: "name" } });
-            grouper.processAll(data);
-            let results = grouper.getResults();
-            // console.log(results);
-            assert.equal(results.length, 2);
-        });
-        it("keys can have nested properties", function () {
-            let data = [
-                { name: "John", age: 12 },
-                { name: "Jane", age: 12 },
-            ];
-            let grouper = new Grouper({ "person.name": { bind: "name" } });
-            grouper.processAll(data);
-            let results = grouper.getResults();
-            assert.equal(results.length, 2);
-            assert.equal(results[0].key.person?.name, "John");
-            assert.equal(results[1].key.person?.name, "Jane");
-        });
-    });
-    describe("multi grouping", function () {
-        it("should work", function () {
-            let data = [
-                { name: "John", age: 12 },
-                { name: "John", age: 12 },
-                { name: "John", age: 13 },
-                { name: "John", age: 14 },
-                { name: "Jane", age: 12 },
-                { name: "Jane", age: 13 },
-                { name: "Jane", age: 14 },
-            ];
-            let grouper = new Grouper({ name: { bind: "name" }, age: { bind: "age" } });
-            grouper.processAll(data);
-            let results = grouper.getResults();
-            // console.log(results);
-            assert.equal(results.length, 6);
-            assert.equal(results[0].records.length, 2);
-        });
-    });
-});

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

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

package/build/data/Ref.spec.js

@@ -1,72 +0,0 @@
-//@ts-nocheck
-import assert from "assert";
-import { Store } from "./Store";
-import { Ref } from "./Ref";
-import { append } from "./ops/append";
-import { StoreRef } from "./StoreRef";
-const getStore = () => {
-    return new Store({
-        data: {
-            a: 3,
-            item: {
-                firstName: "Jack",
-            },
-            array: [],
-        },
-    });
-};
-describe("Ref", () => {
-    it("can init data", () => {
-        let store = getStore();
-        let b = store.ref("b", 1);
-        assert.equal(store.get("b"), 1);
-    });
-    it("can set data", () => {
-        let store = getStore();
-        let b = store.ref("b", 1);
-        b.set(2);
-        assert.equal(store.get("b"), 2);
-    });
-    it("can delete data", () => {
-        let store = getStore();
-        let b = store.ref("item");
-        b.delete();
-        assert.equal(store.get("item"), undefined);
-    });
-    it("can cast itself to a ref of another type", () => {
-        class ArrayRef extends StoreRef {
-            append(...args) {
-                this.update(append, ...args);
-            }
-        }
-        let store = getStore();
-        let array = store.ref("array").as(ArrayRef);
-        array.append(1, 2, 3);
-        assert.deepEqual(array.get(), [1, 2, 3]);
-    });
-    it("can extend itself in a functional way", () => {
-        let store = getStore();
-        let array = store.ref("array").as(({ update, set, path }) => ({
-            append(...args) {
-                update(path, append, ...args);
-            },
-            clear() {
-                set(path, []);
-            },
-        }));
-        array.append(1, 2, 3);
-        assert.deepEqual(array.get(), [1, 2, 3]);
-        array.clear();
-        assert.deepEqual(array.get(), []);
-    });
-    it("can get subrefs", () => {
-        let store = getStore();
-        let person = new Ref({
-            get: () => store.get("person"),
-            set: (value) => store.set("person", value),
-        });
-        let name = person.ref("name");
-        name.set("John");
-        assert.equal(name.get(), "John");
-    });
-});

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

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

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