Function writeGroupRow

src/queries/index.ts:551–607

(
              leaf: [IdMap2<Cell>, IdSet, Id, Row],
              changedGroupedSelectedCells: IdMap<[Cell]>,
              selectedRowId: Id,
              forceRemove?: 1,
            )

            const tree = mapNew<Cell, any>();

            const writeGroupRow = (
              leaf: [IdMap2<Cell>, IdSet, Id, Row],
              changedGroupedSelectedCells: IdMap<[Cell]>,
              selectedRowId: Id,
              forceRemove?: 1,
            ) =>
              ifNotUndefined(
                leaf,
                ([selectedCells, selectedRowIds, groupRowId, groupRow]) => {
                  mapForEach(
                    changedGroupedSelectedCells,
                    (selectedCellId, [newCell]) => {
                      const selectedCell = mapEnsure(
                        selectedCells,
                        selectedCellId,
                        mapNew,
                      );
                      const oldLeafCell = mapGet(selectedCell, selectedRowId);
                      const newLeafCell = forceRemove ? undefined : newCell;
                      if (oldLeafCell !== newLeafCell) {
                        const oldNewSet = setNew([[oldLeafCell, newLeafCell]]);
                        const oldLength = collSize(selectedCell);
                        mapSet(selectedCell, selectedRowId, newLeafCell);
                        collForEach(
                          mapGet(groupedSelectedCellIds, selectedCellId),
                          ([groupedCellId, aggregators]) => {
                            const aggregateValue = getAggregateValue(
                              groupRow[groupedCellId],
                              oldLength,
                              selectedCell as IdMap<Cell>,
                              oldNewSet as Set<ChangedCell>,
                              aggregators,
                            );
                            groupRow[groupedCellId] = (
                              isUndefined(getCellOrValueType(aggregateValue))
                                ? undefined
                                : aggregateValue
                            ) as Cell;
                          },
                        );
                      }
                    },
                  );
                  if (
                    collIsEmpty(selectedRowIds) ||
                    !arrayEvery(havings, (having) =>
                      having((cellId) => groupRow[cellId] as any),
                    )
                  ) {
                    resultStore.delRow(queryId, groupRowId);
                  } else if (isUndefined(groupRowId)) {
                    leaf[2] = resultStore.addRow(queryId, groupRow) as Id;
                  } else {
                    resultStore.setRow(queryId, groupRowId, groupRow);
                  }
                },
              );