cx 24.7.1 → 24.7.3

package/src/charts/axis/Stack.js

@@ -1,55 +1,55 @@
-export class Stack {
-   constructor() {
-      this.reset();
-   }
-
-   reset() {
-      this.stacks = {};
-      this.values = {};
-      this.normalized = false;
-      this.invalid = {};
-   }
-
-   acknowledge(ordinal, value) {
-      if (value != null) {
-         let s = this.stacks[ordinal];
-         if (!s) this.stacks[ordinal] = s = { total: 0, min: 0, max: 0 };
-         s.total += value;
-         if (s.total < s.min) s.min = s.total;
-         if (s.total > s.max) s.max = s.total;
-      } else {
-         this.invalid[ordinal] = true;
-      }
-   }
-
-   measure(normalized) {
-      if (normalized) {
-         this.normalized = true;
-         return [0, 1];
-      }
-
-      let max = 0,
-         min = 0;
-      for (let key in this.stacks) {
-         if (this.stacks[key].max > max) max = this.stacks[key].max;
-         if (this.stacks[key].min < min) min = this.stacks[key].min;
-      }
-      return [min, max];
-   }
-
-   stack(ordinal, value) {
-      if (value == null || this.invalid[ordinal]) return null;
-
-      let base = this.values[ordinal] || 0;
-
-      let result = (this.values[ordinal] = base + value);
-
-      if (!this.normalized) return result;
-
-      let total = this.stacks[ordinal].total;
-
-      if (total > 0) return result / total;
-
-      return null;
-   }
-}
+export class Stack {
+   constructor() {
+      this.reset();
+   }
+
+   reset() {
+      this.stacks = {};
+      this.values = {};
+      this.normalized = false;
+      this.invalid = {};
+   }
+
+   acknowledge(ordinal, value) {
+      if (value != null) {
+         let s = this.stacks[ordinal];
+         if (!s) this.stacks[ordinal] = s = { total: 0, min: 0, max: 0 };
+         s.total += value;
+         if (s.total < s.min) s.min = s.total;
+         if (s.total > s.max) s.max = s.total;
+      } else {
+         this.invalid[ordinal] = true;
+      }
+   }
+
+   measure(normalized) {
+      if (normalized) {
+         this.normalized = true;
+         return [0, 1];
+      }
+
+      let max = 0,
+         min = 0;
+      for (let key in this.stacks) {
+         if (this.stacks[key].max > max) max = this.stacks[key].max;
+         if (this.stacks[key].min < min) min = this.stacks[key].min;
+      }
+      return [min, max];
+   }
+
+   stack(ordinal, value) {
+      if (value == null || this.invalid[ordinal]) return null;
+
+      let base = this.values[ordinal] || 0;
+
+      let result = (this.values[ordinal] = base + value);
+
+      if (!this.normalized) return result;
+
+      let total = this.stacks[ordinal].total;
+
+      if (total > 0) return result / total;
+
+      return null;
+   }
+}

package/src/data/ArrayElementView.js

@@ -1,29 +1,37 @@
-import {AugmentedViewBase} from "./AugmentedViewBase";
-import { isArray} from "../util/isArray";
+import { AugmentedViewBase } from "./AugmentedViewBase";
+import { isArray } from "../util/isArray";
+import { Binding } from "./Binding";
 
 export class ArrayElementView extends AugmentedViewBase {
+   constructor(config) {
+      super(config);
+      this.hasNestedAliases =
+         this.recordAlias.indexOf(".") >= 0 || this.indexAlias.indexOf(".") >= 0 || this.lengthAlias.indexOf(".") >= 0;
+      this.recordBinding = Binding.get(this.recordAlias);
+      if (this.hasNestedAliases) {
+         this.indexBinding = Binding.get(this.indexAlias);
+         this.lengthAlias = Binding.get(this.lengthAlias);
+      }
+   }
 
-   isExtraKey(key) {
-      return key == this.recordAlias || key == this.indexAlias || key == this.lengthAlias;
+   getExtraKeyBinding(key) {
+      if (!key.startsWith(this.recordAlias)) return null;
+      if (key.length == this.recordAlias.length || key[this.recordAlias.length] == ".") return this.recordBinding;
+      return null;
    }
 
    deleteExtraKeyValue(key) {
-      if (key != this.recordAlias)
-         throw new Error(`Field ${key} cannot be deleted.`);
+      if (key != this.recordAlias) throw new Error(`Field ${key} cannot be deleted.`);
       const array = this.arrayAccessor.get(this.store.getData());
-      if (!array)
-         return false;
+      if (!array) return false;
       const newArray = [...array.slice(0, this.itemIndex), ...array.slice(this.itemIndex + 1)];
       return this.arrayAccessor.set(newArray, this.store);
    }
 
    setExtraKeyValue(key, value) {
-      if (key != this.recordAlias)
-         throw new Error(`Field ${key} is read-only.`);
-
+      if (key != this.recordAlias) throw new Error(`Field ${key} is read-only.`);
       const array = this.arrayAccessor.get(this.store.getData());
-      if (!array || value === array[this.itemIndex])
-         return false;
+      if (!array || value === array[this.itemIndex]) return false;
       const newArray = [...array.slice(0, this.itemIndex), value, ...array.slice(this.itemIndex + 1)];
       return this.arrayAccessor.set(newArray, this.store);
    }
@@ -31,9 +39,19 @@ export class ArrayElementView extends AugmentedViewBase {
    embedAugmentData(result, parentStoreData) {
       let array = this.arrayAccessor.get(parentStoreData);
       if (!isArray(array)) return;
-      result[this.recordAlias] = array[this.itemIndex];
-      result[this.indexAlias] = this.itemIndex;
-      result[this.lengthAlias] = array.length;
+      if (!this.hasNestedAliases) {
+         result[this.recordAlias] = array[this.itemIndex];
+         result[this.indexAlias] = this.itemIndex;
+         result[this.lengthAlias] = array.length;
+      } else {
+         let copy = result;
+         copy = this.recordBinding.set(copy, array[this.itemIndex]);
+         copy = this.indexBinding.set(copy, this.itemIndex);
+         copy = this.lengthAlias.set(copy, array.length);
+         result[this.recordBinding.parts[0]] = copy[this.recordBinding.parts[0]];
+         result[this.indexBinding.parts[0]] = copy[this.indexBinding.parts[0]];
+         result[this.lengthAlias.parts[0]] = copy[this.lengthAlias.parts[0]];
+      }
    }
 
    setIndex(itemIndex) {
@@ -41,6 +59,6 @@ export class ArrayElementView extends AugmentedViewBase {
    }
 }
 
-ArrayElementView.prototype.recordAlias = '$record';
-ArrayElementView.prototype.indexAlias = '$index';
-ArrayElementView.prototype.lengthAlias = '$length';
+ArrayElementView.prototype.recordAlias = "$record";
+ArrayElementView.prototype.indexAlias = "$index";
+ArrayElementView.prototype.lengthAlias = "$length";

package/src/data/ArrayElementView.spec.js

@@ -41,6 +41,24 @@ describe("ArrayElementView", function () {
       assert.equal(record, letters[1]);
    });
 
+   it("aliases allow nesting", function () {
+      let letters = [{ letter: "A" }, { letter: "B" }];
+      let store = new Store({ data: { letters } });
+      let elementView = new ArrayElementView({
+         store,
+         itemIndex: 1,
+         arrayAccessor: getAccessor({ bind: "letters" }),
+         recordAlias: "$iter.letter",
+         indexAlias: "$iter.index.letter",
+      });
+      let record = elementView.get("$iter.letter");
+      assert.equal(record, letters[1]);
+      assert.equal(elementView.get("$iter.index.letter"), 1);
+
+      elementView.set("$iter.letter.letter", "C");
+      assert.equal(store.get("letters.1.letter"), "C");
+   });
+
    it("when immutable preserves the parent data object", function () {
       let letters = [{ letter: "A" }, { letter: "B" }];
       let store = new Store({ data: { letters } });

package/src/data/AugmentedViewBase.js

@@ -3,8 +3,7 @@ import { Binding } from "./Binding";
 
 export class AugmentedViewBase extends View {
    getData() {
-      if (this.meta.version === this.cache.version && this.sealed)
-         return this.cache.result;
+      if (this.meta.version === this.cache.version && this.sealed) return this.cache.result;
       let parentStoreData = this.store.getData();
       let result = this.getBaseData(parentStoreData);
       this.embedAugmentData(result, parentStoreData);
@@ -27,6 +26,12 @@ export class AugmentedViewBase extends View {
       throw new Error("abstract");
    }
 
+   // Stores which need to support nested aliases should override this method
+   getExtraKeyBinding(key) {
+      let binding = Binding.get(key);
+      return this.isExtraKey(binding.parts[0]) ? Binding.get(binding.parts[0]) : null;
+   }
+
    setExtraKeyValue(key, value) {
       throw new Error("abstract");
    }
@@ -36,29 +41,32 @@ export class AugmentedViewBase extends View {
    }
 
    setItem(path, value) {
-      let binding = Binding.get(path);
-      if (this.isExtraKey(binding.parts[0])) {
-         let bindingRoot = binding.parts[0];
+      let extraKeyBinding = this.getExtraKeyBinding(path);
+      if (extraKeyBinding) {
+         let binding = Binding.get(path);
          let newValue = value;
-         if (binding.parts.length > 1) {
+         if (binding.parts.length > extraKeyBinding.parts.length) {
             let data = {};
             this.embedAugmentData(data, this.store.getData());
-            newValue = binding.set(data, value)[bindingRoot];
+            let binding = Binding.get(path);
+            data = binding.set(data, value);
+            newValue = extraKeyBinding.value(data);
          }
-         return this.setExtraKeyValue(bindingRoot, newValue);
+         return this.setExtraKeyValue(extraKeyBinding.path, newValue);
       }
       return super.setItem(path, value);
    }
 
    deleteItem(path) {
-      let binding = Binding.get(path);
-      if (this.isExtraKey(binding.parts[0])) {
-         let bindingRoot = binding.parts[0];
-         if (binding.parts.length == 1) return this.deleteExtraKeyValue(bindingRoot);
+      let extraKeyBinding = this.getExtraKeyBinding(path);
+      if (extraKeyBinding) {
+         if (path == extraKeyBinding.path) return this.deleteExtraKeyValue(extraKeyBinding.path);
          let data = {};
          this.embedAugmentData(data, this.store.getData());
-         let newValue = binding.delete(data)[bindingRoot];
-         return this.setExtraKeyValue(bindingRoot, newValue);
+         let binding = Binding.get(path);
+         data = binding.delete(data);
+         let newValue = extraKeyBinding.value(data);
+         return this.setExtraKeyValue(extraKeyBinding.path, newValue);
       }
       return super.deleteItem(path);
    }

package/src/data/Binding.spec.js

@@ -1,69 +1,69 @@
-import { Binding } from "./Binding";
-import assert from "assert";
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-
-describe("Binding", function () {
-   describe("#get()", function () {
-      it("should get value if value is defined", function () {
-         var state = { person: { name: "Joe" } };
-         var b = Binding.get("person.name");
-         assert.equal(b.value(state), "Joe");
-      });
-
-      it("allows non-standard property identifiers", function () {
-         var state = { person: { "@schema": "Person" } };
-         var b = Binding.get("person.@schema");
-         assert.equal(b.path, "person.@schema");
-         assert.equal(b.value(state), "Person");
-      });
-
-      it("properly resolves accessor models", function () {
-         var state = { person: { schema: "Person" } };
-         var b = Binding.get(createAccessorModelProxy("person.schema"));
-         assert.equal(b.value(state), "Person");
-      });
-   });
-
-   describe("#set()", function () {
-      it("produces new objects along the binding path", function () {
-         var state = { person: { name: "Joe" } };
-         var b = Binding.get("person.name");
-         var ns = b.set(state, "Jack");
-         assert.equal(ns.person.name, "Jack");
-         assert.notEqual(state, ns);
-         assert.notEqual(state.person, ns.person);
-         assert.notEqual(state.person.name, ns.person.name);
-      });
-
-      it("returns same state object if value does not change", function () {
-         var state = { person: { name: "Joe" } };
-         var b = Binding.get("person.name");
-         var ns = b.set(state, "Joe");
-         assert.equal(state, ns);
-      });
-
-      it("allows non-standard property identifiers", function () {
-         var state = { person: { "@schema": "Person" } };
-         var b = Binding.get("person.@schema");
-         var ns = b.set(state, "Test");
-         assert.equal(ns.person["@schema"], "Test");
-      });
-   });
-
-   describe(".delete()", function () {
-      it("correctly removes pointed properties", function () {
-         var state = { person: { name: "Joe" } };
-         var b = Binding.get("person.name");
-         var ns = b.delete(state);
-         assert("person" in ns);
-         assert(!("name" in ns.person));
-      });
-
-      it("does not change state if property is non-existent", function () {
-         var state = { person: { name: "Joe" } };
-         var b = Binding.get("person.name2");
-         var ns = b.delete(state);
-         assert(ns == state);
-      });
-   });
-});
+import { Binding } from "./Binding";
+import assert from "assert";
+import { createAccessorModelProxy } from "./createAccessorModelProxy";
+
+describe("Binding", function () {
+   describe("#get()", function () {
+      it("should get value if value is defined", function () {
+         var state = { person: { name: "Joe" } };
+         var b = Binding.get("person.name");
+         assert.equal(b.value(state), "Joe");
+      });
+
+      it("allows non-standard property identifiers", function () {
+         var state = { person: { "@schema": "Person" } };
+         var b = Binding.get("person.@schema");
+         assert.equal(b.path, "person.@schema");
+         assert.equal(b.value(state), "Person");
+      });
+
+      it("properly resolves accessor models", function () {
+         var state = { person: { schema: "Person" } };
+         var b = Binding.get(createAccessorModelProxy("person.schema"));
+         assert.equal(b.value(state), "Person");
+      });
+   });
+
+   describe("#set()", function () {
+      it("produces new objects along the binding path", function () {
+         var state = { person: { name: "Joe" } };
+         var b = Binding.get("person.name");
+         var ns = b.set(state, "Jack");
+         assert.equal(ns.person.name, "Jack");
+         assert.notEqual(state, ns);
+         assert.notEqual(state.person, ns.person);
+         assert.notEqual(state.person.name, ns.person.name);
+      });
+
+      it("returns same state object if value does not change", function () {
+         var state = { person: { name: "Joe" } };
+         var b = Binding.get("person.name");
+         var ns = b.set(state, "Joe");
+         assert.equal(state, ns);
+      });
+
+      it("allows non-standard property identifiers", function () {
+         var state = { person: { "@schema": "Person" } };
+         var b = Binding.get("person.@schema");
+         var ns = b.set(state, "Test");
+         assert.equal(ns.person["@schema"], "Test");
+      });
+   });
+
+   describe(".delete()", function () {
+      it("correctly removes pointed properties", function () {
+         var state = { person: { name: "Joe" } };
+         var b = Binding.get("person.name");
+         var ns = b.delete(state);
+         assert("person" in ns);
+         assert(!("name" in ns.person));
+      });
+
+      it("does not change state if property is non-existent", function () {
+         var state = { person: { name: "Joe" } };
+         var b = Binding.get("person.name2");
+         var ns = b.delete(state);
+         assert(ns == state);
+      });
+   });
+});

package/src/data/StringTemplate.spec.js

@@ -1,105 +1,105 @@
-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("properly encodes ' and \"", function () {
-         var e = StringTemplate.compile('It\'s "working"!');
-         assert.equal(e({}), 'It\'s "working"!');
-      });
-
-      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}");
-      });
-   });
-
-   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("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");
-      });
-   });
-});
+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("properly encodes ' and \"", function () {
+         var e = StringTemplate.compile('It\'s "working"!');
+         assert.equal(e({}), 'It\'s "working"!');
+      });
+
+      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}");
+      });
+   });
+
+   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("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/src/data/getAccessor.spec.js

@@ -1,11 +1,11 @@
-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");
-   });
-});
+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");
+   });
+});