@one-grid-core/angular 0.5.2 → 0.5.4

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/components/one-grid-row-action/one-grid-row-action.component.d.ts

@@ -37,6 +37,7 @@ export declare class OneGridRowActionComponent<T> implements OnInit {
     protected detailActiveExcludeLevels: Set<number>;
     protected gotoDetailExcludeLevels: Set<number>;
     protected addNewExcludeLevels: Set<number>;
+    protected gotoListExcludeLevels: Set<number>;
     /**
      * Accessible names for the action buttons.
      *

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

@@ -98,6 +98,7 @@ export interface OneCellRendererParams<T = any> {
     copyButtonStatus?: OneCellStatus;
     deleteButtonStatus?: OneCellStatus;
     gotoListButtonStatus?: OneCellStatus;
+    gotoListExcludeLevels?: number[];
     optionButtonStatus?: OneCellStatus;
     languageButtonStatus?: OneCellStatus;
     editButtonStatus?: OneCellStatus;
@@ -192,6 +193,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.4",
   "description": "OneGrid — a feature-rich Angular data grid component with tree data, master/detail, editing, selection, pagination, and virtual scrolling.",
   "keywords": [
     "angular",

package/scss/_one-grid.scss

@@ -57,9 +57,22 @@ $row-drag-indicator-size: 2px !default;
 
 // Master / detail
 //
-// The detail area is a continuation of the row that opened it, so it sits
-// flush by default. Set this to inset it.
-$detail-padding: 0 !default;
+// The inset around a detail row's nested grid — one step of the spacing scale
+// (the same 8px as `$cell-item-space`, declared literally because that
+// variable comes later in this file).
+//
+// A gap this size is what separates the nested grid from the master rows above
+// and below it without turning it into a card: it reads as content belonging
+// to its row, and the left inset indents it the way nesting is read everywhere
+// else in the grid. Anything larger starts to float; anything smaller stops
+// registering as deliberate.
+//
+// It costs height. `node.detailRowHeight` is the nested grid's own height, and
+// the block around it is that plus this inset top and bottom, which the body's
+// fixed-`itemSize` virtual scroller cannot see — the same drift an expanded
+// row already causes, 2 × this larger. Set it to `0` for a flush detail area
+// that adds nothing at all.
+$detail-padding: 8px !default;
 
 // Cell
 $cell-height: 30px !default;
@@ -531,17 +544,18 @@ $_og-defaults: (
                 outline-offset: -2px;
             }
 
-            // A detail row is a continuation of the master row above it, not a
-            // card floating inside the grid, so it sits flush: its left edge
-            // lines up with the master grid's and it occupies exactly the
-            // height the API reserved.
+            // A detail row belongs to the master row above it, so it is inset
+            // rather than boxed: `detail-padding` all round separates it from
+            // the rows either side and indents it, and the body background
+            // shows through the gap instead of a border or a card surface.
             //
-            // That reserved height is the reason the default is 0 rather than
-            // a taste call. `node.detailRowHeight` is what the grid computes
-            // for an open row, and the body's virtual-scroll viewport is
-            // configured with a single fixed `itemSize` — any padding here is
-            // height the scroller cannot see, so it becomes scroll drift on
-            // top of the drift an expanded row already causes.
+            // The inset is the only height this box adds. The nested grid
+            // keeps exactly the height the API reserved for it — padding is
+            // never taken out of it, which would clip its last row — so the
+            // block is `node.detailRowHeight` plus the inset top and bottom.
+            // The body's virtual-scroll viewport runs on a single fixed
+            // `itemSize` and cannot see any of it; `--one-grid-detail-padding: 0`
+            // restores a flush detail area that adds nothing beyond the grid.
             //
             // `height: inherit` used to sit here. It resolved to `auto`, since
             // that is the content wrapper's computed height, so it never did