cx 26.3.9 → 26.4.0

package/src/data/Grouper.ts

@@ -1,158 +1,158 @@
-import { getSelector } from "./getSelector";
-import { AggregateFunction } from "./AggregateFunction";
-import { Binding } from "./Binding";
-
-/*
- 'column': {
-   index: 0,
-   sort: 'asc',
-   group: true
-   aggregate: 'count'
- }
- */
-
-export interface GroupResult {
-   key: any;
-   name?: any;
-   records: any[];
-   indexes: number[];
-   aggregates?: Record<string, any>;
-}
-
-export class Grouper {
-   keys: any[];
-   nameGetter?: any;
-   dataGetter: any;
-   aggregates?: any;
-   groups: any;
-
-   constructor(key: any, aggregates?: any, dataGetter?: any, nameGetter?: any) {
-      this.keys = Object.keys(key).map((keyField) => {
-         let isSimpleField = keyField.indexOf(".") === -1;
-         let keySetter;
-         if (isSimpleField) {
-            // use simple field setter wherever possible
-            keySetter = function set(result: any, value: any) {
-               result[keyField] = value;
-               return result;
-            };
-         } else {
-            // for complex paths, use deep setter
-            let binding = Binding.get(keyField);
-            keySetter = (result: any, value: any) => binding.set(result, value);
-         }
-         return {
-            name: keyField,
-            keySetter,
-            value: getSelector(key[keyField]),
-         };
-      });
-      if (nameGetter) this.nameGetter = getSelector(nameGetter);
-      this.dataGetter = dataGetter || ((x: any) => x);
-      this.aggregates =
-         aggregates &&
-         transformValues(aggregates, (prop) => {
-            if (!(prop.type in AggregateFunction)) throw new Error(`Unknown aggregate function '${prop.type}'.`);
-
-            return {
-               value: getSelector(prop.value),
-               weight: getSelector(prop.weight ?? 1),
-               type: prop.type,
-            };
-         });
-      this.reset();
-   }
-
-   reset() {
-      this.groups = this.initGroup(this.keys.length == 0);
-   }
-
-   initGroup(leaf: boolean) {
-      if (!leaf) return {};
-
-      return {
-         records: [],
-         indexes: [],
-         aggregates:
-            this.aggregates &&
-            transformValues(this.aggregates, (prop) => {
-               let f = (AggregateFunction as any)[prop.type];
-               return {
-                  processor: f(),
-                  value: prop.value,
-                  weight: prop.weight,
-               };
-            }),
-      };
-   }
-
-   process(record: any, index: number) {
-      let data = this.dataGetter(record);
-      let key = this.keys.map((k) => k.value(data));
-      let g = this.groups;
-      for (let i = 0; i < key.length; i++) {
-         let sg = g[key[i]];
-         if (!sg) {
-            sg = g[key[i]] = this.initGroup(i + 1 == key.length);
-            if (this.nameGetter) sg.name = this.nameGetter(data);
-         }
-         g = sg;
-      }
-
-      g.records.push(record);
-      g.indexes.push(index);
-
-      if (g.aggregates) {
-         for (let k in g.aggregates)
-            g.aggregates[k].processor.process(g.aggregates[k].value(data), g.aggregates[k].weight(data));
-      }
-   }
-
-   processAll(records: any[], indexes?: number[]) {
-      if (indexes) {
-         for (let i = 0; i < records.length; i++) this.process(records[i], indexes[i]);
-      } else records.forEach((r: any, i: number) => this.process(r, i));
-   }
-
-   report(g: any, path: any[], level: number, results: GroupResult[]) {
-      if (level == this.keys.length) {
-         let key = {};
-         this.keys.forEach((k: any, i: number) => {
-            key = k.keySetter(key, path[i]);
-         });
-         results.push({
-            key: key,
-            name: g.name,
-            records: g.records,
-            indexes: g.indexes,
-            aggregates: resolveKeyPaths(transformValues(g.aggregates, (p) => p.processor.getResult())),
-         });
-      } else {
-         Object.keys(g).forEach((k) => this.report(g[k], [...path, k], level + 1, results));
-      }
-   }
-
-   getResults(): GroupResult[] {
-      let g = this.groups;
-      let results: GroupResult[] = [];
-      this.report(g, [], 0, results);
-      return results;
-   }
-}
-
-// transform object values using a function
-function transformValues(o: Record<string, any>, f: (v: any, k?: string) => any): Record<string, any> {
-   let res: Record<string, any> = {};
-   for (let k in o) res[k] = f(o[k], k);
-   return res;
-}
-
-// transform keys like 'a.b.c' into nested objects
-function resolveKeyPaths(o: Record<string, any>) {
-   let res: Record<string, any> = {};
-   for (let k in o) {
-      if (k.indexOf(".") > 0) res = Binding.get(k).set(res, o[k]);
-      else res[k] = o[k];
-   }
-   return res;
-}
+import { getSelector } from "./getSelector";
+import { AggregateFunction } from "./AggregateFunction";
+import { Binding } from "./Binding";
+
+/*
+ 'column': {
+   index: 0,
+   sort: 'asc',
+   group: true
+   aggregate: 'count'
+ }
+ */
+
+export interface GroupResult {
+   key: any;
+   name?: any;
+   records: any[];
+   indexes: number[];
+   aggregates?: Record<string, any>;
+}
+
+export class Grouper {
+   keys: any[];
+   nameGetter?: any;
+   dataGetter: any;
+   aggregates?: any;
+   groups: any;
+
+   constructor(key: any, aggregates?: any, dataGetter?: any, nameGetter?: any) {
+      this.keys = Object.keys(key).map((keyField) => {
+         let isSimpleField = keyField.indexOf(".") === -1;
+         let keySetter;
+         if (isSimpleField) {
+            // use simple field setter wherever possible
+            keySetter = function set(result: any, value: any) {
+               result[keyField] = value;
+               return result;
+            };
+         } else {
+            // for complex paths, use deep setter
+            let binding = Binding.get(keyField);
+            keySetter = (result: any, value: any) => binding.set(result, value);
+         }
+         return {
+            name: keyField,
+            keySetter,
+            value: getSelector(key[keyField]),
+         };
+      });
+      if (nameGetter) this.nameGetter = getSelector(nameGetter);
+      this.dataGetter = dataGetter || ((x: any) => x);
+      this.aggregates =
+         aggregates &&
+         transformValues(aggregates, (prop) => {
+            if (!(prop.type in AggregateFunction)) throw new Error(`Unknown aggregate function '${prop.type}'.`);
+
+            return {
+               value: getSelector(prop.value),
+               weight: getSelector(prop.weight ?? 1),
+               type: prop.type,
+            };
+         });
+      this.reset();
+   }
+
+   reset() {
+      this.groups = this.initGroup(this.keys.length == 0);
+   }
+
+   initGroup(leaf: boolean) {
+      if (!leaf) return {};
+
+      return {
+         records: [],
+         indexes: [],
+         aggregates:
+            this.aggregates &&
+            transformValues(this.aggregates, (prop) => {
+               let f = (AggregateFunction as any)[prop.type];
+               return {
+                  processor: f(),
+                  value: prop.value,
+                  weight: prop.weight,
+               };
+            }),
+      };
+   }
+
+   process(record: any, index: number) {
+      let data = this.dataGetter(record);
+      let key = this.keys.map((k) => k.value(data));
+      let g = this.groups;
+      for (let i = 0; i < key.length; i++) {
+         let sg = g[key[i]];
+         if (!sg) {
+            sg = g[key[i]] = this.initGroup(i + 1 == key.length);
+            if (this.nameGetter) sg.name = this.nameGetter(data);
+         }
+         g = sg;
+      }
+
+      g.records.push(record);
+      g.indexes.push(index);
+
+      if (g.aggregates) {
+         for (let k in g.aggregates)
+            g.aggregates[k].processor.process(g.aggregates[k].value(data), g.aggregates[k].weight(data));
+      }
+   }
+
+   processAll(records: any[], indexes?: number[]) {
+      if (indexes) {
+         for (let i = 0; i < records.length; i++) this.process(records[i], indexes[i]);
+      } else records.forEach((r: any, i: number) => this.process(r, i));
+   }
+
+   report(g: any, path: any[], level: number, results: GroupResult[]) {
+      if (level == this.keys.length) {
+         let key = {};
+         this.keys.forEach((k: any, i: number) => {
+            key = k.keySetter(key, path[i]);
+         });
+         results.push({
+            key: key,
+            name: g.name,
+            records: g.records,
+            indexes: g.indexes,
+            aggregates: resolveKeyPaths(transformValues(g.aggregates, (p) => p.processor.getResult())),
+         });
+      } else {
+         Object.keys(g).forEach((k) => this.report(g[k], [...path, k], level + 1, results));
+      }
+   }
+
+   getResults(): GroupResult[] {
+      let g = this.groups;
+      let results: GroupResult[] = [];
+      this.report(g, [], 0, results);
+      return results;
+   }
+}
+
+// transform object values using a function
+function transformValues(o: Record<string, any>, f: (v: any, k?: string) => any): Record<string, any> {
+   let res: Record<string, any> = {};
+   for (let k in o) res[k] = f(o[k], k);
+   return res;
+}
+
+// transform keys like 'a.b.c' into nested objects
+function resolveKeyPaths(o: Record<string, any>) {
+   let res: Record<string, any> = {};
+   for (let k in o) {
+      if (k.indexOf(".") > 0) res = Binding.get(k).set(res, o[k]);
+      else res[k] = o[k];
+   }
+   return res;
+}

package/src/data/NestedDataView.ts

@@ -1,43 +1,43 @@
-import { View, ViewConfig } from "./View";
-import { AugmentedViewBase } from "../data/AugmentedViewBase";
-
-export interface StructuredDataAccessor {
-   getSelector(): (data: object) => Record<string, any>;
-   get(): object;
-   setItem(key: string, value: any): boolean;
-   containsKey(key: string): boolean;
-   getKeys(): string[];
-}
-
-export interface NestedDataViewConfig extends ViewConfig {
-   nestedData?: StructuredDataAccessor;
-   store: View;
-}
-
-export class NestedDataView extends AugmentedViewBase {
-   declare nestedData?: StructuredDataAccessor;
-
-   constructor(config: NestedDataViewConfig) {
-      super(config);
-   }
-
-   protected embedAugmentData(result: Record<string, any>, parentStoreData: Record<string, any>): void {
-      if (this.nestedData) {
-         let nested = this.nestedData.getSelector()(parentStoreData);
-         for (let key in nested) result[key] = nested[key];
-      }
-   }
-
-   protected isExtraKey(key: string): boolean {
-      return !!this.nestedData && this.nestedData.containsKey(key);
-   }
-
-   protected setExtraKeyValue(key: string, value: any): boolean {
-      if (!this.nestedData) throw new Error("Internal error. This should not happen.");
-      return this.nestedData.setItem(key, value);
-   }
-
-   protected deleteExtraKeyValue(key: string): boolean {
-      return this.setExtraKeyValue(key, undefined);
-   }
-}
+import { View, ViewConfig } from "./View";
+import { AugmentedViewBase } from "../data/AugmentedViewBase";
+
+export interface StructuredDataAccessor {
+   getSelector(): (data: object) => Record<string, any>;
+   get(): object;
+   setItem(key: string, value: any): boolean;
+   containsKey(key: string): boolean;
+   getKeys(): string[];
+}
+
+export interface NestedDataViewConfig extends ViewConfig {
+   nestedData?: StructuredDataAccessor;
+   store: View;
+}
+
+export class NestedDataView extends AugmentedViewBase {
+   declare nestedData?: StructuredDataAccessor;
+
+   constructor(config: NestedDataViewConfig) {
+      super(config);
+   }
+
+   protected embedAugmentData(result: Record<string, any>, parentStoreData: Record<string, any>): void {
+      if (this.nestedData) {
+         let nested = this.nestedData.getSelector()(parentStoreData);
+         for (let key in nested) result[key] = nested[key];
+      }
+   }
+
+   protected isExtraKey(key: string): boolean {
+      return !!this.nestedData && this.nestedData.containsKey(key);
+   }
+
+   protected setExtraKeyValue(key: string, value: any): boolean {
+      if (!this.nestedData) throw new Error("Internal error. This should not happen.");
+      return this.nestedData.setItem(key, value);
+   }
+
+   protected deleteExtraKeyValue(key: string): boolean {
+      return this.setExtraKeyValue(key, undefined);
+   }
+}

package/src/data/ReadOnlyDataView.ts

@@ -1,39 +1,39 @@
-import { View, ViewConfig } from "./View";
-
-export interface ReadOnlyDataViewConfig extends ViewConfig {
-   data?: any;
-}
-
-export class ReadOnlyDataView extends View {
-   declare store: View;
-   declare data?: any;
-   declare immutable?: boolean;
-
-   constructor(config?: ReadOnlyDataViewConfig) {
-      super(config);
-   }
-
-   getData(): any {
-      if (this.sealed && this.meta.version === this.cache.version && this.cache.data === this.data)
-         return this.cache.result;
-
-      let data = this.store.getData();
-      this.cache.result =
-         this.sealed || this.immutable || this.store.sealed
-            ? Object.assign({}, data, this.getAdditionalData(data))
-            : Object.assign(data, this.getAdditionalData(data));
-      this.cache.version = this.meta.version;
-      this.cache.data = this.data;
-      return this.cache.result;
-   }
-
-   getAdditionalData(data?: any): any {
-      return this.data;
-   }
-
-   setData(data: any): void {
-      this.data = data;
-   }
-}
-
-ReadOnlyDataView.prototype.immutable = false;
+import { View, ViewConfig } from "./View";
+
+export interface ReadOnlyDataViewConfig extends ViewConfig {
+   data?: any;
+}
+
+export class ReadOnlyDataView extends View {
+   declare store: View;
+   declare data?: any;
+   declare immutable?: boolean;
+
+   constructor(config?: ReadOnlyDataViewConfig) {
+      super(config);
+   }
+
+   getData(): any {
+      if (this.sealed && this.meta.version === this.cache.version && this.cache.data === this.data)
+         return this.cache.result;
+
+      let data = this.store.getData();
+      this.cache.result =
+         this.sealed || this.immutable || this.store.sealed
+            ? Object.assign({}, data, this.getAdditionalData(data))
+            : Object.assign(data, this.getAdditionalData(data));
+      this.cache.version = this.meta.version;
+      this.cache.data = this.data;
+      return this.cache.result;
+   }
+
+   getAdditionalData(data?: any): any {
+      return this.data;
+   }
+
+   setData(data: any): void {
+      this.data = data;
+   }
+}
+
+ReadOnlyDataView.prototype.immutable = false;

package/src/data/Ref.spec.ts

@@ -1,79 +1,79 @@
-import assert from "assert";
-import { Store } from "./Store";
-import { Ref } from "./Ref";
-import { append } from "./ops/append";
-import { StoreRef } from "./StoreRef";
-
-const getStore = () => {
-   return new Store({
-      data: {
-         a: 3,
-         item: {
-            firstName: "Jack",
-         },
-         array: [],
-      },
-   });
-};
-
-describe("Ref", () => {
-   it("can init data", () => {
-      let store = getStore();
-      let b = store.ref("b", 1);
-      assert.equal(store.get("b"), 1);
-   });
-
-   it("can set data", () => {
-      let store = getStore();
-      let b = store.ref("b", 1);
-      b.set(2);
-      assert.equal(store.get("b"), 2);
-   });
-
-   it("can delete data", () => {
-      let store = getStore();
-      let b = store.ref("item");
-      b.delete();
-      assert.equal(store.get("item"), undefined);
-   });
-
-   it("can cast itself to a ref of another type", () => {
-      class ArrayRef extends StoreRef {
-         append(...args: any[]) {
-            this.update(append, ...args);
-         }
-      }
-      let store = getStore();
-      let array = store.ref("array").as(ArrayRef);
-      (array as ArrayRef).append(1, 2, 3);
-      assert.deepEqual(array.get(), [1, 2, 3]);
-   });
-
-   it("can extend itself in a functional way", () => {
-      let store = getStore();
-      let array = store.ref("array").as(({ update, set, path }: { update: any; set: any; path: string }) => ({
-         append(...args: any[]) {
-            update(path, append, ...args);
-         },
-
-         clear() {
-            set(path, []);
-         },
-      }));
-      (array as any).append(1, 2, 3);
-      assert.deepEqual(array.get(), [1, 2, 3]);
-      (array as any).clear();
-      assert.deepEqual(array.get(), []);
-   });
-
-   it("can get subrefs", () => {
-      let store = getStore();
-      let person = new Ref({
-         get: () => store.get("person"),
-         set: (value) => store.set("person", value),
-      });
-      let name = person.ref("name");
-      name.set("John");
-      assert.equal(name.get(), "John");
-   });
-});
+import assert from "assert";
+import { Store } from "./Store";
+import { Ref } from "./Ref";
+import { append } from "./ops/append";
+import { StoreRef } from "./StoreRef";
+
+const getStore = () => {
+   return new Store({
+      data: {
+         a: 3,
+         item: {
+            firstName: "Jack",
+         },
+         array: [],
+      },
+   });
+};
+
+describe("Ref", () => {
+   it("can init data", () => {
+      let store = getStore();
+      let b = store.ref("b", 1);
+      assert.equal(store.get("b"), 1);
+   });
+
+   it("can set data", () => {
+      let store = getStore();
+      let b = store.ref("b", 1);
+      b.set(2);
+      assert.equal(store.get("b"), 2);
+   });
+
+   it("can delete data", () => {
+      let store = getStore();
+      let b = store.ref("item");
+      b.delete();
+      assert.equal(store.get("item"), undefined);
+   });
+
+   it("can cast itself to a ref of another type", () => {
+      class ArrayRef extends StoreRef {
+         append(...args: any[]) {
+            this.update(append, ...args);
+         }
+      }
+      let store = getStore();
+      let array = store.ref("array").as(ArrayRef);
+      (array as ArrayRef).append(1, 2, 3);
+      assert.deepEqual(array.get(), [1, 2, 3]);
+   });
+
+   it("can extend itself in a functional way", () => {
+      let store = getStore();
+      let array = store.ref("array").as(({ update, set, path }: { update: any; set: any; path: string }) => ({
+         append(...args: any[]) {
+            update(path, append, ...args);
+         },
+
+         clear() {
+            set(path, []);
+         },
+      }));
+      (array as any).append(1, 2, 3);
+      assert.deepEqual(array.get(), [1, 2, 3]);
+      (array as any).clear();
+      assert.deepEqual(array.get(), []);
+   });
+
+   it("can get subrefs", () => {
+      let store = getStore();
+      let person = new Ref({
+         get: () => store.get("person"),
+         set: (value) => store.set("person", value),
+      });
+      let name = person.ref("name");
+      name.set("John");
+      assert.equal(name.get(), "John");
+   });
+});