cx 24.7.2 → 24.7.4

package/src/data/AggregateFunction.js

@@ -1,145 +1,145 @@
-export class AggregateFunction {
-   static sum() {
-      return new Sum();
-   }
-
-   static avg() {
-      return new Avg();
-   }
-
-   static count() {
-      return new Count();
-   }
-
-   static distinct() {
-      return new Distinct();
-   }
-
-   static min() {
-      return new Min();
-   }
-
-   static max() {
-      return new Max();
-   }
-
-   static last() {
-      return new LastValue();
-   }
-}
-
-class Sum {
-   process(value) {
-      this.empty = false;
-      if (!isNaN(value)) this.result += value;
-      else this.invalid = true;
-   }
-
-   getResult() {
-      if (this.invalid) return null;
-      return this.result;
-   }
-}
-
-Sum.prototype.result = 0;
-Sum.prototype.empty = true;
-
-class Avg {
-   process(value, count = 1) {
-      this.empty = false;
-      if (!isNaN(value) && !isNaN(count)) {
-         this.result += value * count;
-         this.count += count;
-      } else this.invalid = true;
-   }
-
-   getResult() {
-      if (this.empty || this.invalid || this.count == 0) return null;
-      return this.result / this.count;
-   }
-}
-
-Avg.prototype.result = 0;
-Avg.prototype.count = 0;
-Avg.prototype.empty = true;
-
-class Count {
-   process(value) {
-      if (value != null) this.result++;
-   }
-
-   getResult() {
-      return this.result;
-   }
-}
-
-Count.prototype.result = 0;
-
-class Distinct {
-   constructor() {
-      this.values = {};
-   }
-
-   process(value) {
-      if (value == null || this.values[value]) return;
-      this.values[value] = true;
-      this.empty = false;
-      this.result++;
-   }
-
-   getResult() {
-      if (this.empty || this.invalid) return null;
-      return this.result;
-   }
-}
-
-Distinct.prototype.result = 0;
-Distinct.prototype.empty = true;
-
-class Max {
-   process(value) {
-      if (!isNaN(value)) {
-         if (this.empty) this.result = value;
-         else if (value > this.result) this.result = value;
-         this.empty = false;
-      } else if (value != null) this.invalid = true;
-   }
-
-   getResult() {
-      if (this.empty || this.invalid) return null;
-      return this.result;
-   }
-}
-
-Max.prototype.result = 0;
-Max.prototype.empty = true;
-
-class Min {
-   process(value) {
-      if (!isNaN(value)) {
-         if (this.empty) this.result = value;
-         else if (value < this.result) this.result = value;
-         this.empty = false;
-      } else if (value != null) this.invalid = true;
-   }
-
-   getResult() {
-      if (this.empty || this.invalid) return null;
-      return this.result;
-   }
-}
-
-Min.prototype.result = 0;
-Min.prototype.empty = true;
-
-class LastValue {
-   process(value) {
-      this.result = value;
-   }
-
-   getResult() {
-      return this.result;
-   }
-}
-
-LastValue.prototype.result = null;
+export class AggregateFunction {
+   static sum() {
+      return new Sum();
+   }
+
+   static avg() {
+      return new Avg();
+   }
+
+   static count() {
+      return new Count();
+   }
+
+   static distinct() {
+      return new Distinct();
+   }
+
+   static min() {
+      return new Min();
+   }
+
+   static max() {
+      return new Max();
+   }
+
+   static last() {
+      return new LastValue();
+   }
+}
+
+class Sum {
+   process(value) {
+      this.empty = false;
+      if (!isNaN(value)) this.result += value;
+      else this.invalid = true;
+   }
+
+   getResult() {
+      if (this.invalid) return null;
+      return this.result;
+   }
+}
+
+Sum.prototype.result = 0;
+Sum.prototype.empty = true;
+
+class Avg {
+   process(value, count = 1) {
+      this.empty = false;
+      if (!isNaN(value) && !isNaN(count)) {
+         this.result += value * count;
+         this.count += count;
+      } else this.invalid = true;
+   }
+
+   getResult() {
+      if (this.empty || this.invalid || this.count == 0) return null;
+      return this.result / this.count;
+   }
+}
+
+Avg.prototype.result = 0;
+Avg.prototype.count = 0;
+Avg.prototype.empty = true;
+
+class Count {
+   process(value) {
+      if (value != null) this.result++;
+   }
+
+   getResult() {
+      return this.result;
+   }
+}
+
+Count.prototype.result = 0;
+
+class Distinct {
+   constructor() {
+      this.values = {};
+   }
+
+   process(value) {
+      if (value == null || this.values[value]) return;
+      this.values[value] = true;
+      this.empty = false;
+      this.result++;
+   }
+
+   getResult() {
+      if (this.empty || this.invalid) return null;
+      return this.result;
+   }
+}
+
+Distinct.prototype.result = 0;
+Distinct.prototype.empty = true;
+
+class Max {
+   process(value) {
+      if (!isNaN(value)) {
+         if (this.empty) this.result = value;
+         else if (value > this.result) this.result = value;
+         this.empty = false;
+      } else if (value != null) this.invalid = true;
+   }
+
+   getResult() {
+      if (this.empty || this.invalid) return null;
+      return this.result;
+   }
+}
+
+Max.prototype.result = 0;
+Max.prototype.empty = true;
+
+class Min {
+   process(value) {
+      if (!isNaN(value)) {
+         if (this.empty) this.result = value;
+         else if (value < this.result) this.result = value;
+         this.empty = false;
+      } else if (value != null) this.invalid = true;
+   }
+
+   getResult() {
+      if (this.empty || this.invalid) return null;
+      return this.result;
+   }
+}
+
+Min.prototype.result = 0;
+Min.prototype.empty = true;
+
+class LastValue {
+   process(value) {
+      this.result = value;
+   }
+
+   getResult() {
+      return this.result;
+   }
+}
+
+LastValue.prototype.result = null;

package/src/data/ArrayElementView.d.ts

@@ -1,13 +1,13 @@
-import {Accessor} from "./getAccessor";
-import {AugmentedViewBase} from "./AugmentedViewBase";
-
-export abstract class ArrayElementView extends AugmentedViewBase {
-   arrayAccessor: Accessor;
-   immutable: boolean;
-   recordAlias: string;
-   indexAlias: string;
-   lengthAlias: string;
-
-   setIndex(itemIndex: number): void;
-}
-
+import {Accessor} from "./getAccessor";
+import {AugmentedViewBase} from "./AugmentedViewBase";
+
+export abstract class ArrayElementView extends AugmentedViewBase {
+   arrayAccessor: Accessor;
+   immutable: boolean;
+   recordAlias: string;
+   indexAlias: string;
+   lengthAlias: string;
+
+   setIndex(itemIndex: number): void;
+}
+

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/ArrayRef.d.ts

@@ -1,15 +1,15 @@
-import {Ref} from "./Ref";
-
-export class ArrayRef<T = any> extends Ref<T[]> {
-   append(...args: T[]);
-
-   insert(index, ...args: T[]);
-
-   filter(predicate: (item: T, index?: number) => boolean);
-
-   move(fromIndex: number, toIndex: number);
-
-   clear();
-
-   sort(compare: (a: T, b: T) => number);
+import {Ref} from "./Ref";
+
+export class ArrayRef<T = any> extends Ref<T[]> {
+   append(...args: T[]);
+
+   insert(index, ...args: T[]);
+
+   filter(predicate: (item: T, index?: number) => boolean);
+
+   move(fromIndex: number, toIndex: number);
+
+   clear();
+
+   sort(compare: (a: T, b: T) => number);
 }

package/src/data/ArrayRef.js

@@ -1,35 +1,35 @@
-import {Ref} from "./Ref";
-import {append} from "./ops/append";
-import {moveElement} from "./ops/moveElement";
-import {insertElement} from "./ops/insertElement";
-
-export class ArrayRef extends Ref {
-   append(...args) {
-      this.update(append, ...args);
-   }
-
-   insert(index, ...args) {
-      this.update(insertElement, ...args)
-   }
-
-   filter(predicate) {
-      this.update(array => array.filter(a => predicate(a)));
-   }
-
-   move(fromIndex, toIndex) {
-      this.update(moveElement, fromIndex, toIndex);
-   }
-
-   clear() {
-      this.set([]);
-   }
-
-   sort(compare) {
-      let data = this.get();
-      if (!data)
-         return;
-      let x = [...data];
-      x.sort(compare);
-      this.set(x);
-   }
+import {Ref} from "./Ref";
+import {append} from "./ops/append";
+import {moveElement} from "./ops/moveElement";
+import {insertElement} from "./ops/insertElement";
+
+export class ArrayRef extends Ref {
+   append(...args) {
+      this.update(append, ...args);
+   }
+
+   insert(index, ...args) {
+      this.update(insertElement, ...args)
+   }
+
+   filter(predicate) {
+      this.update(array => array.filter(a => predicate(a)));
+   }
+
+   move(fromIndex, toIndex) {
+      this.update(moveElement, fromIndex, toIndex);
+   }
+
+   clear() {
+      this.set([]);
+   }
+
+   sort(compare) {
+      let data = this.get();
+      if (!data)
+         return;
+      let x = [...data];
+      x.sort(compare);
+      this.set(x);
+   }
 }

package/src/data/AugmentedViewBase.d.ts

@@ -1,18 +1,18 @@
-import { View, ViewConfig } from "./View";
-import * as Cx from "../core";
-
-export interface AugmentedViewBaseConfig extends ViewConfig {
-   immutable?: boolean;
-}
-
-export abstract class AugmentedViewBase extends View {
-   constructor(config: AugmentedViewBaseConfig);
-
-   protected abstract setExtraKeyValue(key: string, value: any): boolean;
-
-   protected abstract deleteExtraKeyValue(key: string): boolean;
-
-   protected abstract isExtraKey(key: string): boolean;
-
-   protected abstract embedAugmentData(result: Cx.Record, parentStoreData: Cx.Record): void;
-}
+import { View, ViewConfig } from "./View";
+import * as Cx from "../core";
+
+export interface AugmentedViewBaseConfig extends ViewConfig {
+   immutable?: boolean;
+}
+
+export abstract class AugmentedViewBase extends View {
+   constructor(config: AugmentedViewBaseConfig);
+
+   protected abstract setExtraKeyValue(key: string, value: any): boolean;
+
+   protected abstract deleteExtraKeyValue(key: string): boolean;
+
+   protected abstract isExtraKey(key: string): boolean;
+
+   protected abstract embedAugmentData(result: Cx.Record, parentStoreData: Cx.Record): void;
+}

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.d.ts

@@ -1,19 +1,19 @@
-import { Record, AccessorChain, Bind } from "../core";
-
-export class Binding<V = any> {
-   constructor(path: string);
-
-   readonly path: string;
-
-   set(state: Record, value: V): Record;
-
-   delete(state: Record): Record;
-
-   value(state: Record): any;
-
-   static get(path: string): Binding;
-   static get(bind: Bind): Binding;
-   static get<V>(chain: AccessorChain<V>): Binding<V>;
-}
-
-export function isBinding(value: any): boolean;
+import { Record, AccessorChain, Bind } from "../core";
+
+export class Binding<V = any> {
+   constructor(path: string);
+
+   readonly path: string;
+
+   set(state: Record, value: V): Record;
+
+   delete(state: Record): Record;
+
+   value(state: Record): any;
+
+   static get(path: string): Binding;
+   static get(bind: Bind): Binding;
+   static get<V>(chain: AccessorChain<V>): Binding<V>;
+}
+
+export function isBinding(value: any): boolean;