cx 26.1.1 → 26.1.2

package/src/data/ZoomIntoPropertyView.spec.ts

@@ -1,64 +1,64 @@
-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);
-   });
-});
+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/src/data/ZoomIntoPropertyView.ts

@@ -1,45 +1,45 @@
-import { Binding } from "./Binding";
-import { NestedDataView, NestedDataViewConfig } from "./NestedDataView";
-
-export interface ZoomIntoPropertyViewConfig extends NestedDataViewConfig {
-   binding: Binding;
-   rootName?: string;
-}
-
-export class ZoomIntoPropertyView extends NestedDataView {
-   declare binding: Binding;
-   declare rootName: string;
-
-   constructor(config: ZoomIntoPropertyViewConfig) {
-      super(config);
-   }
-
-   protected getBaseData(parentStoreData: any): any {
-      let x = this.binding.value(parentStoreData);
-      if (x != null && typeof x != "object") throw new Error("Zoomed value must be an object.");
-      return {
-         ...x,
-      };
-   }
-
-   protected embedAugmentData(result: any, parentStoreData: any): void {
-      result[this.rootName] = parentStoreData;
-      super.embedAugmentData(result, parentStoreData);
-   }
-
-   setItem(path: string, value: any): boolean {
-      if (path.indexOf(this.rootName + ".") == 0)
-         return this.store.setItem(path.substring(this.rootName.length + 1), value);
-      if (this.isExtraKey(Binding.get(path).parts[0])) return super.setItem(path, value);
-      return super.setItem(this.binding.path + "." + path, value);
-   }
-
-   deleteItem(path: string): boolean {
-      if (path.indexOf(this.rootName + ".") == 0)
-         return this.store.deleteItem(path.substring(this.rootName.length + 1));
-      if (this.isExtraKey(Binding.get(path).parts[0])) return super.deleteItem(path);
-      return super.deleteItem(this.binding.path + "." + path);
-   }
-}
-
-ZoomIntoPropertyView.prototype.rootName = "$root";
+import { Binding } from "./Binding";
+import { NestedDataView, NestedDataViewConfig } from "./NestedDataView";
+
+export interface ZoomIntoPropertyViewConfig extends NestedDataViewConfig {
+   binding: Binding;
+   rootName?: string;
+}
+
+export class ZoomIntoPropertyView extends NestedDataView {
+   declare binding: Binding;
+   declare rootName: string;
+
+   constructor(config: ZoomIntoPropertyViewConfig) {
+      super(config);
+   }
+
+   protected getBaseData(parentStoreData: any): any {
+      let x = this.binding.value(parentStoreData);
+      if (x != null && typeof x != "object") throw new Error("Zoomed value must be an object.");
+      return {
+         ...x,
+      };
+   }
+
+   protected embedAugmentData(result: any, parentStoreData: any): void {
+      result[this.rootName] = parentStoreData;
+      super.embedAugmentData(result, parentStoreData);
+   }
+
+   setItem(path: string, value: any): boolean {
+      if (path.indexOf(this.rootName + ".") == 0)
+         return this.store.setItem(path.substring(this.rootName.length + 1), value);
+      if (this.isExtraKey(Binding.get(path).parts[0])) return super.setItem(path, value);
+      return super.setItem(this.binding.path + "." + path, value);
+   }
+
+   deleteItem(path: string): boolean {
+      if (path.indexOf(this.rootName + ".") == 0)
+         return this.store.deleteItem(path.substring(this.rootName.length + 1));
+      if (this.isExtraKey(Binding.get(path).parts[0])) return super.deleteItem(path);
+      return super.deleteItem(this.binding.path + "." + path);
+   }
+}
+
+ZoomIntoPropertyView.prototype.rootName = "$root";

package/src/data/comparer.spec.ts

@@ -1,60 +1,60 @@
-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);
-      });
-   });
-});
+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/src/data/comparer.ts

@@ -1,78 +1,78 @@
-import { getSelector } from "./getSelector";
-import { isDefined } from "../util/isDefined";
-import { defaultCompare } from "./defaultCompare";
-
-interface Sorter {
-   value?: any;
-   field?: string;
-   direction?: string;
-   comparer?: (a: any, b: any) => number;
-   compare?: (a: any, b: any) => number;
-}
-
-export function getComparer(
-   sorters: Sorter[],
-   dataAccessor?: (x: any) => any,
-   comparer?: (a: any, b: any) => number,
-): (a: any, b: any) => number {
-   let resolvedSorters = (sorters || []).map((s) => {
-      let selector = isDefined(s.value)
-         ? getSelector(s.value)
-         : s.field
-           ? (x: Record<string, any>) => x[s.field!]
-           : () => null;
-      return {
-         getter: dataAccessor ? (x: any) => selector(dataAccessor(x)) : selector,
-         factor: s.direction && s.direction[0].toLowerCase() == "d" ? -1 : 1,
-         compare: s.comparer || s.compare || comparer || defaultCompare,
-      };
-   });
-
-   return function (a, b) {
-      let d, av, bv;
-      for (let i = 0; i < resolvedSorters.length; i++) {
-         d = resolvedSorters[i];
-         av = d.getter(a);
-         bv = d.getter(b);
-
-         // show nulls always on the bottom
-         if (av == null) {
-            if (bv == null) continue;
-            else return 1;
-         }
-         if (bv == null) return -1;
-
-         let r = d.compare(av, bv);
-         if (r == 0) continue;
-         return d.factor * r;
-      }
-      return 0;
-   };
-}
-
-export function indexSorter(
-   sorters: Sorter[],
-   dataAccessor?: (x: any) => any,
-   compare?: (a: any, b: any) => number,
-): (data: any[]) => number[] {
-   let cmp = getComparer(sorters, dataAccessor, compare);
-   return function (data) {
-      let result = Array.from({ length: data.length }, (v, k) => k);
-      result.sort((ia, ib) => cmp(data[ia], data[ib]));
-      return result;
-   };
-}
-
-export function sorter(
-   sorters: Sorter[],
-   dataAccessor?: (x: any) => any,
-   compare?: (a: any, b: any) => number,
-): (data: any[]) => any[] {
-   let cmp = getComparer(sorters, dataAccessor, compare);
-
-   return function (data) {
-      let result = [...data];
-      result.sort(cmp);
-      return result;
-   };
-}
+import { getSelector } from "./getSelector";
+import { isDefined } from "../util/isDefined";
+import { defaultCompare } from "./defaultCompare";
+
+interface Sorter {
+   value?: any;
+   field?: string;
+   direction?: string;
+   comparer?: (a: any, b: any) => number;
+   compare?: (a: any, b: any) => number;
+}
+
+export function getComparer(
+   sorters: Sorter[],
+   dataAccessor?: (x: any) => any,
+   comparer?: (a: any, b: any) => number,
+): (a: any, b: any) => number {
+   let resolvedSorters = (sorters || []).map((s) => {
+      let selector = isDefined(s.value)
+         ? getSelector(s.value)
+         : s.field
+           ? (x: Record<string, any>) => x[s.field!]
+           : () => null;
+      return {
+         getter: dataAccessor ? (x: any) => selector(dataAccessor(x)) : selector,
+         factor: s.direction && s.direction[0].toLowerCase() == "d" ? -1 : 1,
+         compare: s.comparer || s.compare || comparer || defaultCompare,
+      };
+   });
+
+   return function (a, b) {
+      let d, av, bv;
+      for (let i = 0; i < resolvedSorters.length; i++) {
+         d = resolvedSorters[i];
+         av = d.getter(a);
+         bv = d.getter(b);
+
+         // show nulls always on the bottom
+         if (av == null) {
+            if (bv == null) continue;
+            else return 1;
+         }
+         if (bv == null) return -1;
+
+         let r = d.compare(av, bv);
+         if (r == 0) continue;
+         return d.factor * r;
+      }
+      return 0;
+   };
+}
+
+export function indexSorter(
+   sorters: Sorter[],
+   dataAccessor?: (x: any) => any,
+   compare?: (a: any, b: any) => number,
+): (data: any[]) => number[] {
+   let cmp = getComparer(sorters, dataAccessor, compare);
+   return function (data) {
+      let result = Array.from({ length: data.length }, (v, k) => k);
+      result.sort((ia, ib) => cmp(data[ia], data[ib]));
+      return result;
+   };
+}
+
+export function sorter(
+   sorters: Sorter[],
+   dataAccessor?: (x: any) => any,
+   compare?: (a: any, b: any) => number,
+): (data: any[]) => any[] {
+   let cmp = getComparer(sorters, dataAccessor, compare);
+
+   return function (data) {
+      let result = [...data];
+      result.sort(cmp);
+      return result;
+   };
+}

package/src/data/computable.spec.ts

@@ -1,87 +1,87 @@
-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: string) => 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: string) => {
-         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: string) => {
-         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: string) => {
-         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<{ person: { name: string } }>();
-      let state = { person: { name: "Joe" } };
-      let nameLength = computable(m.person.name, (name) => {
-         // name should be inferred as string
-         const typedName: string = name;
-         // @ts-expect-error - name should not be number
-         const wrongType: number = name;
-         return typedName.length;
-      });
-      assert.equal(nameLength(state), 3);
-   });
-
-   it("works with array length accessor", function () {
-      var m = createAccessorModelProxy<{ items: string[] }>();
-      let state = { items: ["a", "b", "c"] };
-      let itemCount = computable(m.items.length, (length) => {
-         // length should be inferred as number
-         const typedLength: number = length;
-         // @ts-expect-error - length should not be string
-         const wrongType: string = length;
-         return typedLength;
-      });
-      assert.equal(itemCount(state), 3);
-   });
-
-   it("resolves AccessorChain<any> and nested properties to any", function () {
-      var m = createAccessorModelProxy<{ data: any }>();
-      let state = { data: { nested: { value: 42 } } };
-      let result = computable(m.data.nested.value, (value) => {
-         // value should be any, so all assignments should work
-         const asString: string = value;
-         const asNumber: number = value;
-         const asBoolean: boolean = value;
-         return value;
-      });
-      assert.equal(result(state), 42);
-   });
-});
+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: string) => 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: string) => {
+         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: string) => {
+         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: string) => {
+         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<{ person: { name: string } }>();
+      let state = { person: { name: "Joe" } };
+      let nameLength = computable(m.person.name, (name) => {
+         // name should be inferred as string
+         const typedName: string = name;
+         // @ts-expect-error - name should not be number
+         const wrongType: number = name;
+         return typedName.length;
+      });
+      assert.equal(nameLength(state), 3);
+   });
+
+   it("works with array length accessor", function () {
+      var m = createAccessorModelProxy<{ items: string[] }>();
+      let state = { items: ["a", "b", "c"] };
+      let itemCount = computable(m.items.length, (length) => {
+         // length should be inferred as number
+         const typedLength: number = length;
+         // @ts-expect-error - length should not be string
+         const wrongType: string = length;
+         return typedLength;
+      });
+      assert.equal(itemCount(state), 3);
+   });
+
+   it("resolves AccessorChain<any> and nested properties to any", function () {
+      var m = createAccessorModelProxy<{ data: any }>();
+      let state = { data: { nested: { value: 42 } } };
+      let result = computable(m.data.nested.value, (value) => {
+         // value should be any, so all assignments should work
+         const asString: string = value;
+         const asNumber: number = value;
+         const asBoolean: boolean = value;
+         return value;
+      });
+      assert.equal(result(state), 42);
+   });
+});