cx 26.0.12 → 26.0.14

package/build/data/StringTemplate.spec.js

@@ -0,0 +1,112 @@
+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

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

package/build/data/StructuredSelector.spec.js

@@ -0,0 +1,102 @@
+//@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

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

package/build/data/View.spec.js

@@ -0,0 +1,44 @@
+//@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

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

package/build/data/ZoomIntoPropertyView.spec.js

@@ -0,0 +1,54 @@
+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

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

package/build/data/comparer.spec.js

@@ -0,0 +1,50 @@
+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.d.ts

@@ -2,9 +2,6 @@ import { AccessorChain } from "./createAccessorModelProxy";
 import { CanMemoize, MemoSelector, Selector } from "./Selector";
 export type ComputableSelector<T = any> = string | Selector<T> | AccessorChain<T> | CanMemoize<T>;
 export type InferSelectorValue<T> = T extends Selector<infer R> ? R : T extends AccessorChain<infer R> ? R : T extends string ? any : never;
-export declare function computable<Selectors extends readonly any[], R>(...args: [
-    ...selectors: ComputableSelector[],
-    compute: (...values: {
-        [K in keyof Selectors]: InferSelectorValue<Selectors[K]>;
-    }) => R
-]): MemoSelector<R>;
+export declare function computable<T extends ComputableSelector[], R>(...args: [...T, (...values: {
+    [K in keyof T]: InferSelectorValue<T[K]>;
+}) => R]): MemoSelector<R>;

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

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

package/build/data/computable.spec.js

@@ -0,0 +1,56 @@
+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.d.ts

@@ -6,12 +6,14 @@ interface AccessorChainMethods {
 type AccessorChainMap<M extends object> = {
     [prop in Exclude<keyof M, keyof AccessorChainMethods>]: AccessorChain<M[prop]>;
 };
+type IsAny<T> = 0 extends 1 & T ? true : false;
 export type AccessorChain<M> = {
     toString(): string;
-    valueOf(): string;
+    valueOf(): M | undefined;
     nameOf(): string;
-    __accessorChainType?: M;
-} & (M extends object ? AccessorChainMap<M> : {});
+} & (IsAny<M> extends true ? {
+    [key: string]: any;
+} : M extends object ? AccessorChainMap<M> : {});
 export declare function createAccessorModelProxy<M>(chain?: string): AccessorChain<M>;
 export declare function isAccessorChain<M>(value: unknown): value is AccessorChain<M>;
 export {};

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

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

package/build/data/createAccessorModelProxy.spec.js

@@ -0,0 +1,30 @@
+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

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

package/build/data/createStructuredSelector.spec.js

@@ -0,0 +1,42 @@
+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

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

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

@@ -0,0 +1,45 @@
+//@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

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

package/build/data/getAccessor.spec.js

@@ -0,0 +1,10 @@
+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

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

package/build/data/getSelector.spec.js

@@ -0,0 +1,36 @@
+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

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