cx 24.3.6 → 24.3.8

package/src/ui/adapter/GroupAdapter.js

@@ -1,138 +1,141 @@
-import { ArrayAdapter } from "./ArrayAdapter";
-import { ReadOnlyDataView } from "../../data/ReadOnlyDataView";
-import { Grouper } from "../../data/Grouper";
-import { isArray } from "../../util/isArray";
-import { isDefined } from "../../util/isDefined";
-import { getComparer } from "../../data/comparer";
-import { Culture } from "../Culture";
-
-export class GroupAdapter extends ArrayAdapter {
-   init() {
-      super.init();
-
-      if (this.groupRecordsAlias) this.groupRecordsName = this.groupRecordsAlias;
-
-      if (this.groupings) this.groupBy(this.groupings);
-   }
-
-   getRecords(context, instance, records, parentStore) {
-      let result = super.getRecords(context, instance, records, parentStore);
-
-      if (this.groupings) {
-         let groupedResults = [];
-         this.processLevel([], result, groupedResults, parentStore);
-         result = groupedResults;
-      }
-
-      return result;
-   }
-
-   processLevel(keys, records, result, parentStore) {
-      let level = keys.length;
-      let inverseLevel = this.groupings.length - level;
-
-      if (inverseLevel == 0) {
-         for (let i = 0; i < records.length; i++) {
-            records[i].store.setStore(parentStore);
-            result.push(records[i]);
-         }
-         return;
-      }
-
-      let grouping = this.groupings[level];
-      let { grouper } = grouping;
-      grouper.reset();
-      grouper.processAll(records);
-      let results = grouper.getResults();
-      if (grouping.comparer) results.sort(grouping.comparer);
-
-      results.forEach((gr) => {
-         keys.push(gr.key);
-
-         let key = keys
-            .map((key) =>
-               Object.keys(key)
-                  .map((k) => key[k])
-                  .join(":")
-            )
-            .join("|");
-
-         let $group = {
-            ...gr.key,
-            ...gr.aggregates,
-            $name: gr.name,
-            $level: inverseLevel,
-            $records: gr.records || [],
-            $key: key,
-         };
-
-         let data = {
-            [this.recordName]: gr.records.length > 0 ? gr.records[0].data : null,
-            [this.groupName]: $group,
-         };
-
-         let groupStore = new ReadOnlyDataView({
-            store: parentStore,
-            data,
-            immutable: this.immutable,
-         });
-
-         let group = {
-            key,
-            data,
-            group: $group,
-            grouping,
-            store: groupStore,
-            level: inverseLevel,
-         };
-
-         if (grouping.includeHeader !== false)
-            result.push({
-               ...group,
-               type: "group-header",
-               key: "header:" + group.key,
-            });
-
-         this.processLevel(keys, gr.records, result, groupStore);
-
-         if (grouping.includeFooter !== false)
-            result.push({
-               ...group,
-               type: "group-footer",
-               key: "footer:" + group.key,
-            });
-
-         keys.pop();
-      });
-   }
-
-   groupBy(groupings) {
-      if (!groupings) this.groupings = null;
-      else if (isArray(groupings)) {
-         this.groupings = groupings;
-         this.groupings.forEach((g) => {
-            let groupSorters = [];
-            let key = {};
-            for (let name in g.key) {
-               if (!g.key[name] || !isDefined(g.key[name].direction) || !isDefined(g.key[name].value))
-                  g.key[name] = { value: g.key[name], direction: "ASC" };
-               key[name] = g.key[name].value;
-               groupSorters.push({
-                  field: name,
-                  direction: g.key[name].direction,
-               });
-            }
-            g.grouper = new Grouper(key, { ...this.aggregates, ...g.aggregates }, (r) => r.store.getData(), g.text);
-            g.comparer = null;
-            if (groupSorters.length > 0)
-               g.comparer = getComparer(
-                  groupSorters,
-                  (x) => x.key,
-                  this.sortOptions ? Culture.getComparer(this.sortOptions) : null
-               );
-         });
-      } else throw new Error("Invalid grouping provided.");
-   }
-}
-
-GroupAdapter.prototype.groupName = "$group";
+import { ArrayAdapter } from "./ArrayAdapter";
+import { ReadOnlyDataView } from "../../data/ReadOnlyDataView";
+import { Grouper } from "../../data/Grouper";
+import { isArray } from "../../util/isArray";
+import { isDefined } from "../../util/isDefined";
+import { getComparer } from "../../data/comparer";
+import { Culture } from "../Culture";
+import { isObject } from "../../util/isObject";
+
+export class GroupAdapter extends ArrayAdapter {
+   init() {
+      super.init();
+
+      if (this.groupRecordsAlias) this.groupRecordsName = this.groupRecordsAlias;
+
+      if (this.groupings) this.groupBy(this.groupings);
+   }
+
+   getRecords(context, instance, records, parentStore) {
+      let result = super.getRecords(context, instance, records, parentStore);
+
+      if (this.groupings) {
+         let groupedResults = [];
+         this.processLevel([], result, groupedResults, parentStore);
+         result = groupedResults;
+      }
+
+      return result;
+   }
+
+   processLevel(keys, records, result, parentStore) {
+      let level = keys.length;
+      let inverseLevel = this.groupings.length - level;
+
+      if (inverseLevel == 0) {
+         for (let i = 0; i < records.length; i++) {
+            records[i].store.setStore(parentStore);
+            result.push(records[i]);
+         }
+         return;
+      }
+
+      let grouping = this.groupings[level];
+      let { grouper } = grouping;
+      grouper.reset();
+      grouper.processAll(records);
+      let results = grouper.getResults();
+      if (grouping.comparer) results.sort(grouping.comparer);
+
+      results.forEach((gr) => {
+         keys.push(gr.key);
+
+         let key = keys.map(serializeKey).join("|");
+
+         let $group = {
+            ...gr.key,
+            ...gr.aggregates,
+            $name: gr.name,
+            $level: inverseLevel,
+            $records: gr.records || [],
+            $key: key,
+         };
+
+         let data = {
+            [this.recordName]: gr.records.length > 0 ? gr.records[0].data : null,
+            [this.groupName]: $group,
+         };
+
+         let groupStore = new ReadOnlyDataView({
+            store: parentStore,
+            data,
+            immutable: this.immutable,
+         });
+
+         let group = {
+            key,
+            data,
+            group: $group,
+            grouping,
+            store: groupStore,
+            level: inverseLevel,
+         };
+
+         if (grouping.includeHeader !== false)
+            result.push({
+               ...group,
+               type: "group-header",
+               key: "header:" + group.key,
+            });
+
+         this.processLevel(keys, gr.records, result, groupStore);
+
+         if (grouping.includeFooter !== false)
+            result.push({
+               ...group,
+               type: "group-footer",
+               key: "footer:" + group.key,
+            });
+
+         keys.pop();
+      });
+   }
+
+   groupBy(groupings) {
+      if (!groupings) this.groupings = null;
+      else if (isArray(groupings)) {
+         this.groupings = groupings;
+         this.groupings.forEach((g) => {
+            let groupSorters = [];
+            let key = {};
+            for (let name in g.key) {
+               if (!g.key[name] || !isDefined(g.key[name].direction) || !isDefined(g.key[name].value))
+                  g.key[name] = { value: g.key[name], direction: "ASC" };
+               key[name] = g.key[name].value;
+               groupSorters.push({
+                  field: name,
+                  direction: g.key[name].direction,
+               });
+            }
+            g.grouper = new Grouper(key, { ...this.aggregates, ...g.aggregates }, (r) => r.store.getData(), g.text);
+            g.comparer = null;
+            if (groupSorters.length > 0)
+               g.comparer = getComparer(
+                  groupSorters,
+                  (x) => x.key,
+                  this.sortOptions ? Culture.getComparer(this.sortOptions) : null,
+               );
+         });
+      } else throw new Error("Invalid grouping provided.");
+   }
+}
+
+GroupAdapter.prototype.groupName = "$group";
+
+function serializeKey(data) {
+   if (isObject(data))
+      return Object.keys(data)
+         .map((k) => serializeKey(data[k]))
+         .join(":");
+   return data?.toString() ?? "";
+}

package/src/widgets/grid/Grid.js

@@ -43,6 +43,7 @@ import { unfocusElement } from "../../ui/FocusManager";
 import { tooltipMouseMove, tooltipMouseLeave } from "../overlay/tooltip-ops";
 import { Container } from "../../ui/Container";
 import { findFirstChild } from "../../util/DOM";
+import { Binding } from "../../data/Binding";
 
 export class Grid extends Container {
    declareData(...args) {
@@ -910,9 +911,9 @@ export class Grid extends Container {
                   }
 
                   if (colSpan > 1) skip = colSpan - 1;
-               } else if (c.aggregate && c.aggregateAlias && c.caption !== false) {
+               } else if (c.aggregate && c.aggregateAliasGetter && c.caption !== false) {
                   empty = false;
-                  v = group[c.aggregateAlias];
+                  v = c.aggregateAliasGetter(group);
                   if (isString(ci.data.format)) v = Format.value(v, ci.data.format);
                }
 
@@ -993,9 +994,9 @@ export class Grid extends Container {
                }
 
                if (colSpan > 1) skip = colSpan - 1;
-            } else if (c.aggregate && c.aggregateAlias && c.footer !== false) {
+            } else if (c.aggregate && c.aggregateAliasGetter && c.footer !== false) {
                empty = false;
-               v = group[c.aggregateAlias];
+               v = c.aggregateAliasGetter(group);
                if (isString(ci.data.format)) v = Format.value(v, ci.data.format);
             }
 
@@ -1594,19 +1595,25 @@ class GridComponent extends VDOM.Component {
             </tbody>
          );
 
+         let dataRecordClass = CSS.element(baseClass, "data");
+
+         let isDataRecord = widget.buffered
+            ? (item) => item?.props?.instance?.data?.class == dataRecordClass
+            : (item) => item?.props?.record?.type;
+
          let index = 0;
-         while (index < children.length && children[index]?.props?.record?.type != "data") index++;
+         while (index < children.length && !isDataRecord(children[index])) index++;
 
          let count = 0;
          while (index < children.length && count < this.state.dropInsertionIndex) {
-            if (children[index]?.props?.record?.type == "data") count++;
+            if (isDataRecord(children[index])) count++;
             index++;
          }
 
          let savedIndexPos = index;
 
          if (!this.state.dropNextToTheRowAbove)
-            while (index < children.length && children[index]?.props?.record?.type != "data") index++;
+            while (index < children.length && !isDataRecord(children[index])) index++;
 
          // do not allow insertion after the last group footer
          if (savedIndexPos < index && index == children.length) index = savedIndexPos;
@@ -2002,15 +2009,15 @@ class GridComponent extends VDOM.Component {
          if (dropTarget == "grid" && widget.onDrop && dropInsertionIndex != null) {
             e.target = {
                insertionIndex: start + dropInsertionIndex,
-               recordBefore: this.getRecordAt(start + dropInsertionIndex - 1),
-               recordAfter: this.getRecordAt(start + dropInsertionIndex),
+               recordBefore: this.getDataRecordAt(start + dropInsertionIndex - 1),
+               recordAfter: this.getDataRecordAt(start + dropInsertionIndex),
                dropNextToTheRowAbove,
             };
             instance.invoke("onDrop", e, instance);
          } else if (dropTarget == "row") {
             e.target = {
                index: start + dropInsertionIndex,
-               record: this.getRecordAt(start + dropInsertionIndex),
+               record: this.getDataRecordAt(start + dropInsertionIndex),
             };
             instance.invoke("onRowDrop", e, instance);
          } else if (dropTarget == "column" && widget.onColumnDrop) {
@@ -2730,6 +2737,13 @@ class GridComponent extends VDOM.Component {
       widget.selection.selectMultiple(instance.store, selection, indexes, options);
    }
 
+   getDataRecordAt(index) {
+      let { records } = this.props.instance;
+      if (!records) return this.getRecordAt(index);
+      let dataRecords = records.filter((r) => r.type == "data");
+      return dataRecords[index];
+   }
+
    getRecordAt(cursor) {
       let { instance, data } = this.props;
       let { records, widget } = instance;
@@ -3097,6 +3111,7 @@ class GridColumnHeader extends Widget {
       if (!this.aggregateField && this.field) this.aggregateField = this.field;
 
       if (!this.aggregateAlias) this.aggregateAlias = this.aggregateField;
+      if (this.aggregateAlias) this.aggregateAliasGetter = Binding.get(this.aggregateAlias).value;
 
       if (this.footer && isSelector(this.footer))
          this.footer = {