cx 26.1.0 → 26.1.1

package/src/data/StructuredSelector.spec.ts

@@ -1,113 +1,113 @@
-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();
-
-         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();
-
-         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();
-
-         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();
-
-         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();
-
-      let r1 = s(x);
-      let r2 = s(x);
-
-      assert.equal(r1, r2);
-   });
-
-   it("accessor model proxy works", function () {
-      var x = { a: { b: 2 } };
-      var m = createAccessorModelProxy<typeof x>();
-      var s = new StructuredSelector({
-         props: {
-            b: undefined,
-         },
-         values: {
-            b: m.a.b,
-         },
-      }).create();
-      assert.deepEqual(s(x), { b: 2 });
-   });
-});
+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();
+
+         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();
+
+         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();
+
+         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();
+
+         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();
+
+      let r1 = s(x);
+      let r2 = s(x);
+
+      assert.equal(r1, r2);
+   });
+
+   it("accessor model proxy works", function () {
+      var x = { a: { b: 2 } };
+      var m = createAccessorModelProxy<typeof x>();
+      var s = new StructuredSelector({
+         props: {
+            b: undefined,
+         },
+         values: {
+            b: m.a.b,
+         },
+      }).create();
+      assert.deepEqual(s(x), { b: 2 });
+   });
+});

package/src/data/SubscribableView.ts

@@ -1,63 +1,63 @@
-import { View, ViewConfig } from "./View";
-import { SubscriberList } from "../util/SubscriberList";
-
-export interface SubscribableViewConfig extends ViewConfig {
-   async?: boolean;
-}
-
-export class SubscribableView<D> extends View<D> {
-   subscribers?: any;
-   changes: string[];
-   declare async: boolean;
-   scheduled: boolean;
-
-   constructor(config?: SubscribableViewConfig) {
-      super(config);
-      this.subscribers = new SubscriberList();
-      this.changes = [];
-   }
-
-   subscribe(callback: () => void) {
-      return this.subscribers.subscribe(callback);
-   }
-
-   unsubscribeAll() {
-      this.subscribers.clear();
-   }
-
-   doNotify(path: string) {
-      if (this.notificationsSuspended) return;
-
-      if (!this.async) {
-         this.subscribers.notify([path]);
-      } else {
-         this.changes.push(path || "");
-         if (!this.scheduled) {
-            this.scheduled = true;
-            setTimeout(() => {
-               this.scheduled = false;
-               let changes = this.changes;
-               this.changes = [];
-               this.subscribers.notify(changes);
-            }, 0);
-         }
-      }
-   }
-
-   silently(callback: (store?: View) => void) {
-      this.notificationsSuspended = (this.notificationsSuspended || 0) + 1;
-      let wasDirty = this.dirty,
-         dirty;
-      this.dirty = false;
-      try {
-         callback(this);
-      } finally {
-         this.notificationsSuspended--;
-         dirty = this.dirty;
-         this.dirty = wasDirty;
-      }
-      return dirty;
-   }
-}
-
-SubscribableView.prototype.async = false;
+import { View, ViewConfig } from "./View";
+import { SubscriberList } from "../util/SubscriberList";
+
+export interface SubscribableViewConfig extends ViewConfig {
+   async?: boolean;
+}
+
+export class SubscribableView<D> extends View<D> {
+   subscribers?: any;
+   changes: string[];
+   declare async: boolean;
+   scheduled: boolean;
+
+   constructor(config?: SubscribableViewConfig) {
+      super(config);
+      this.subscribers = new SubscriberList();
+      this.changes = [];
+   }
+
+   subscribe(callback: () => void) {
+      return this.subscribers.subscribe(callback);
+   }
+
+   unsubscribeAll() {
+      this.subscribers.clear();
+   }
+
+   doNotify(path: string) {
+      if (this.notificationsSuspended) return;
+
+      if (!this.async) {
+         this.subscribers.notify([path]);
+      } else {
+         this.changes.push(path || "");
+         if (!this.scheduled) {
+            this.scheduled = true;
+            setTimeout(() => {
+               this.scheduled = false;
+               let changes = this.changes;
+               this.changes = [];
+               this.subscribers.notify(changes);
+            }, 0);
+         }
+      }
+   }
+
+   silently(callback: (store?: View) => void) {
+      this.notificationsSuspended = (this.notificationsSuspended || 0) + 1;
+      let wasDirty = this.dirty,
+         dirty;
+      this.dirty = false;
+      try {
+         callback(this);
+      } finally {
+         this.notificationsSuspended--;
+         dirty = this.dirty;
+         this.dirty = wasDirty;
+      }
+      return dirty;
+   }
+}
+
+SubscribableView.prototype.async = false;

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.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/ops/updateArray.ts

@@ -1,31 +1,31 @@
-export function updateArray<T = any>(
-   array: T[] | undefined,
-   updateCallback: (item: T, index: number) => T,
-   itemFilter?: null | ((item: T, index: number) => boolean),
-   removeFilter?: (item: T, index: number) => boolean,
-): T[] | undefined {
-   if (!array) return array;
-
-   const newArray: T[] = [];
-   let dirty: boolean = false;
-
-   for (let index = 0; index < array.length; index++) {
-      const item = array[index];
-
-      if (removeFilter && removeFilter(item, index)) {
-         dirty = true;
-         continue;
-      }
-
-      if (!itemFilter || itemFilter(item, index)) {
-         const newItem = updateCallback(item, index);
-         newArray.push(newItem);
-
-         if (newItem !== item) dirty = true;
-      } else {
-         newArray.push(item);
-      }
-   }
-
-   return dirty ? newArray : array;
-}
+export function updateArray<T = any>(
+   array: T[] | undefined,
+   updateCallback: (item: T, index: number) => T,
+   itemFilter?: null | ((item: T, index: number) => boolean),
+   removeFilter?: (item: T, index: number) => boolean,
+): T[] | undefined {
+   if (!array) return array;
+
+   const newArray: T[] = [];
+   let dirty: boolean = false;
+
+   for (let index = 0; index < array.length; index++) {
+      const item = array[index];
+
+      if (removeFilter && removeFilter(item, index)) {
+         dirty = true;
+         continue;
+      }
+
+      if (!itemFilter || itemFilter(item, index)) {
+         const newItem = updateCallback(item, index);
+         newArray.push(newItem);
+
+         if (newItem !== item) dirty = true;
+      } else {
+         newArray.push(item);
+      }
+   }
+
+   return dirty ? newArray : array;
+}