@one-grid-core/angular 0.5.2 → 0.5.3

package/lib/components/one-grid/one-grid.component.d.ts

@@ -177,9 +177,52 @@ export declare class OneGridComponent<T> implements OnInit, OnChanges, AfterView
     protected bodyScrollLeft: number;
     private _oneRowNumberColumnDef;
     private subscriptions;
+    /**
+     * Row grouping, as the grid sees it.
+     *
+     * The three `_host*` fields hold what was bound before grouping touched
+     * anything, because grouping is reversible: turn it off and the columns,
+     * the group column and the grid type all have to go back to what the host
+     * asked for. `_appliedGroupFields` is the grouping the registered columns
+     * currently reflect — the row model's copy lives in `api.rowGroupFields`.
+     */
+    private _hostColumnDefs;
+    private _hostAutoGroupColumnDef;
+    private _hostGridType;
+    private _hostTreeData;
+    private _appliedGroupFields;
     constructor(api: OneGridApi, eventService: OneGridEventService, elementRef: ElementRef, cdr: ChangeDetectorRef);
     ngOnChanges(changes: SimpleChanges): void;
     ngOnInit(): void;
+    /**
+     * The group column: host-tuned through `autoGroupColumnDef`, but its field
+     * is always the synthetic label — that is where a group row carries its
+     * display value — and it always carries the marker the tree machinery keys
+     * on, which is what puts the expander on this column.
+     */
+    private buildAutoGroupColumnDef;
+    /**
+     * The host's columns with the grouped-by ones hidden.
+     *
+     * A grouped-by column's value is on the group row; showing the flat column
+     * too repeats it down every leaf. Hidden, not removed — the host can bring
+     * one back with `api.setColumnVisible`, and ungrouping restores whatever
+     * visibility the host itself declared.
+     */
+    private groupedColumnDefs;
+    /** The columns the grid registers: row numbers, the group column, the host's. */
+    private columnStack;
+    /**
+     * Re-plumb everything grouping owns outside the row model: tree mode, the
+     * children field, the group column, and which of the host's columns are
+     * hidden because their value now shows on a group row.
+     *
+     * Driven by `rowGroupingChanged`, so a host regroups through one call —
+     * `api.setRowGrouping(['country', 'city'])` — instead of re-creating the
+     * grid. Grouping and host tree data are mutually exclusive, which the API
+     * enforces, so this only ever switches a tree that grouping itself built.
+     */
+    private applyRowGroupingColumns;
     ngAfterViewInit(): void;
     /**
      * Handle Body Scroll Event

package/lib/core/instants/one-grid-api.class.d.ts

@@ -46,11 +46,25 @@ export declare class OneGridApi<T = any> {
     private _quickFilterValue;
     private _activeFilters;
     private _visibleRowNodes;
+    /**
+     * The rows as the host last handed them over — before grouping folded
+     * them. Grouping is a transform on the way in, so this is what a change of
+     * grouping re-folds, and it is why regrouping keeps the host's row order
+     * instead of inheriting the order the previous grouping happened to leave.
+     */
+    private _sourceRows;
     private readonly _pinnedRowNodes;
     private _originalRowNodes;
     private _nodeCleanupMap;
     private _destroyed;
     private treeData;
+    /**
+     * Whether the *host* declared tree data, as opposed to grouping having
+     * turned tree mode on. `treeData` above answers "is this a tree right now",
+     * which grouping flips; this answers "whose tree is it", which decides
+     * whether grouping may touch it at all.
+     */
+    private _hostTreeData;
     private treeDataChildrenField;
     private groupDefaultExpanded;
     private masterDetail;
@@ -324,10 +338,19 @@ export declare class OneGridApi<T = any> {
     /** The fields the rows are grouped by, in nesting order. Empty when off. */
     get rowGroupFields(): readonly string[];
     /**
-     * Turn row grouping on. Called by `OneGridComponent` when column
-     * definitions declare `rowGroup`; the grid then behaves as a tree over
-     * synthetic group rows, and `setRowData` / `updateRowData` keep taking the
-     * flat rows they always took.
+     * Group the rows by these fields, in nesting order — or ungroup by passing
+     * an empty array.
+     *
+     * `OneGridComponent` calls this once for the column definitions that
+     * declare `rowGroup`; hosts call it to regroup afterwards. Either way the
+     * grid re-plumbs itself around the new grouping — tree mode, the auto group
+     * column, the visibility of the grouped-by columns — and folds the rows it
+     * already holds again, so nothing has to be rebound and no grid has to be
+     * torn down and re-created to group by a different column.
+     *
+     * `aggregations` defaults to the `aggFunc` columns currently registered, so
+     * `setRowGrouping(['country'])` keeps the totals the column definitions
+     * already describe.
      */
     setRowGrouping(groupFields: string[], aggregations?: OneAggColumn<T>[]): void;
     private _undoLimit;

package/lib/core/models/one-column-def-types.model.d.ts

@@ -192,6 +192,10 @@ export interface OneColumnDef<T = any> {
      * hidden automatically (their value shows on the group row); un-hide via
      * `api.setColumnVisible` if you want both. Client-side rows only, and
      * exclusive with `treeData` and `masterDetail`.
+     *
+     * This is the *initial* grouping, read when the grid initialises; needs a
+     * `field` to group on. `api.setRowGrouping(fields)` changes it afterwards
+     * — any columns, in any nesting order, `[]` to ungroup.
      */
     rowGroup?: boolean;
     /**

package/lib/core/models/one-event-types.model.d.ts

@@ -101,6 +101,18 @@ export interface RowOrderChangedEvent<T = any> {
     fromIndex: number;
     toIndex: number;
 }
+/**
+ * The grouping changed through `api.setRowGrouping` — including the call the
+ * grid makes itself for the `rowGroup` column definitions when it starts.
+ *
+ * Carries the fields in nesting order, empty when grouping was turned off,
+ * and the ones that were in force before, so a listener can tell what the
+ * change actually was.
+ */
+export interface RowGroupingChangedEvent {
+    groupFields: readonly string[];
+    previousGroupFields: readonly string[];
+}
 export interface EventPayloadMap<T = any> {
     rowSelected: RowSelectedEvent;
     cellClicked: CellClickedEvent;
@@ -114,6 +126,7 @@ export interface EventPayloadMap<T = any> {
     rowOrderChanged: RowOrderChangedEvent<T>;
     cellStateChanged: CellStateChangedEvent<T>;
     cellValueChanged: CellValueChangedEvent<T>;
+    rowGroupingChanged: RowGroupingChangedEvent;
 }
 export type OneCheckboxState = 'checked' | 'unchecked' | 'indeterminate';
 export type RowSelectionMode = 'single' | 'multiple' | null;

package/lib/core/services/og-column.service.d.ts

@@ -19,6 +19,14 @@ export declare class OgColumnService {
     private columnDefs$;
     private groupColumnDefs$;
     initColumnDefs(defaultColumnDef: OneColumnDef, columnDefs: OneColumnDef[], groupColumnDefs: OneGroupColumnDef[], context?: unknown): void;
+    /**
+     * Every registered column, hidden ones included, in display order.
+     *
+     * `getColumnState` answers what is on screen; this answers what the grid
+     * knows about — which is what anything reading a column's *configuration*
+     * (an `aggFunc`, say) needs, since hiding a column does not unconfigure it.
+     */
+    getAllColumnDefs(): readonly OneColumnDef[];
     getColumnState(): ColumnChangedEvent;
     setGroupColumnDefs(groupColumnDefs: OneGroupColumnDef[]): void;
     setColumnDefs(columnDefs: OneColumnDef[]): void;

package/lib/helpers/one-row-grouping.helper.d.ts

@@ -14,7 +14,13 @@ export interface OneAggColumn<T = any> {
     field: string;
     aggFunc: OneAggFunc<T>;
 }
-/** The `rowGroup` fields of a column set, in definition order. */
+/**
+ * The `rowGroup` fields of a column set, in definition order.
+ *
+ * Grouping keys on a row's own field, so a column that asks to group without
+ * one has nothing to group by — it is dropped, but not silently: that is a
+ * definition that reads as if it works.
+ */
 export declare function rowGroupFields<T>(columns: readonly OneColumnDef<T>[]): string[];
 /** The `aggFunc` columns of a column set. */
 export declare function aggColumns<T>(columns: readonly OneColumnDef<T>[]): OneAggColumn<T>[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@one-grid-core/angular",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "OneGrid — a feature-rich Angular data grid component with tree data, master/detail, editing, selection, pagination, and virtual scrolling.",
   "keywords": [
     "angular",