@adaptabletools/adaptable-cjs 22.0.10 → 22.1.0-canary.0

package/src/layout-manager/src/LayoutManagerModel.d.ts

@@ -1,4 +1,4 @@
-import { ColumnSizingMap } from '../../AdaptableState/LayoutState';
+import { ColumnSizingMap, LayoutRowSelection } from '../../AdaptableState/LayoutState';
 import { XOR } from '../../Utilities/Extensions/TypeExtensions';
 /**
  * Defines how a Column is sorted
@@ -112,6 +112,7 @@ export interface BaseLayoutModel {
     ColumnPinning?: {
         [columnId: string]: 'left' | 'right';
     };
+    RowSelection?: LayoutRowSelection | false;
     /**
      * Display Grand Total Row of the Pivot Table
      */

package/src/layout-manager/src/index.d.ts

@@ -1,6 +1,7 @@
 import { ColumnState, GridApi, GridOptions, GridState } from 'ag-grid-enterprise';
 import { PivotLayoutModel, TableLayoutModel } from './LayoutManagerModel';
 import { LMEmitter } from './LMEmitter';
+import { LayoutRowSelection } from '../../AdaptableState/LayoutState';
 export declare const PIVOT_ANY_TOTAL_COL_TYPE = "pivotAnyTotal";
 export declare const PIVOT_GRAND_TOTAL_COL_TYPE = "pivotGrandTotal";
 export declare const PIVOT_COLUMN_TOTAL_COL_TYPE = "pivotColumnTotal";
@@ -9,6 +10,7 @@ export type LayoutManagerOptions = {
     gridApi: GridApi;
     debugId: string;
     layoutChangeDebounce?: number;
+    initialRowSelection?: GridOptions['rowSelection'];
 };
 type ApplyLayoutOptions = {
     skipApplyRowGroupsExpandedState?: boolean;
@@ -26,6 +28,7 @@ export declare class LayoutManager<DATA_TYPE = any> extends LMEmitter {
     private suppressGlobalAgGridEventListener;
     private supressGlobalAgGridEventTimeoutId;
     private layoutManagerDebugId;
+    private initialRowSelection;
     constructor(options: LayoutManagerOptions);
     destroy(): void;
     private setupEvents;
@@ -69,6 +72,12 @@ export declare class LayoutManager<DATA_TYPE = any> extends LMEmitter {
     private getLayoutDetailsAsString;
     applyColumnDefsChanges(layout: TableLayoutModel | PivotLayoutModel): boolean;
     private applyColumnSizingColumnDefsChanges;
+    static readonly SELECTION_COLUMN_ID = "ag-Grid-SelectionColumn";
+    static getGridOptionForRowSelectionFromLayout(layoutRowSelection: LayoutRowSelection | false | undefined, baseGridRowSelection: GridOptions['rowSelection']): GridOptions['rowSelection'] | undefined;
+    static isSelectionColumnInNonFirstPosition(tableColumns: string[] | undefined): boolean;
+    private ensureSelectionColumnPositionUnlocked;
+    private getRowSelectionFromGrid;
+    private applyRowSelection;
     private applyTableLayout;
     private getRowGroupNodePathsAs;
     applyRowGroupValues(RowGroupValues: TableLayoutModel['RowGroupValues'], rowGroupedColumns: string[]): void;

package/src/layout-manager/src/index.js

@@ -154,6 +154,7 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
     suppressGlobalAgGridEventListener = false;
     supressGlobalAgGridEventTimeoutId = null;
     layoutManagerDebugId;
+    initialRowSelection;
     constructor(options) {
         super({ debugId: options.debugId });
         this.layoutChangeDebounce = options.layoutChangeDebounce ?? 0;
@@ -162,6 +163,7 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
                 wait: this.layoutChangeDebounce,
             }).bind(this);
         }
+        this.initialRowSelection = options.initialRowSelection;
         this.setOptions(options);
         // this ensures the grand total columns are positioned correctly (before/after) even when changed at runtime
         // see https://www.ag-grid.com/react-data-grid/pivoting-column-groups/#changing-data-filters-and-configurations
@@ -403,6 +405,7 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
             PivotGroupedColumns: layout.RowGroupedColumns,
             PivotAggregationColumns: layout.TableAggregationColumns,
             GrandTotalRow: layout.GrandTotalRow,
+            RowSelection: layout.RowSelection,
             PivotExpandLevel: prevLayout?.PivotExpandLevel ?? -1,
         };
         if (storePivotResultColumns) {
@@ -434,7 +437,6 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
     }
     getUndecidedLayoutModelFromGrid(columnState) {
         let TableColumns = columnState.map((c) => c.colId);
-        // .filter((colId) => colId !== 'ag-Grid-SelectionColumn');
         let ColumnSorts = [];
         const RowGroupedColumns = [];
         let RowGroupValues = undefined;
@@ -742,6 +744,7 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
             GrandTotalRow: this.gridApi.getGridOption('grandTotalRow'),
             SuppressAggFuncInHeader: this.gridApi.getGridOption('suppressAggFuncInHeader'),
             RowGroupDisplayType: this.gridApi.getGridOption('groupDisplayType') === 'multipleColumns' ? 'multi' : 'single',
+            RowSelection: this.getRowSelectionFromGrid(),
         });
         return layout;
     }
@@ -816,6 +819,8 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
         const flatColDefs = flattenColDefs(colDefs);
         const colDefsById = new Map(flatColDefs.map((colDef) => [colDef.colId ?? colDef.field, colDef]));
         const getColDef = (colId) => colDefsById.get(colId);
+        // TODO to implement support for row selection in server-side row model
+        // agGridState.rowSelection = { ... }
         agGridState.columnVisibility = {
             hiddenColIds: flatColDefs
                 .filter((colDef) => {
@@ -1104,6 +1109,7 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
         else {
             this.gridApi.setGridOption('grandTotalRow', null);
         }
+        this.applyRowSelection(layout);
         this.applyColumnDefsChanges(layout);
         if ((0, isPivotLayoutModel_1.isPivotLayoutModel)(layout)) {
             try {
@@ -1161,8 +1167,98 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
         }
         return false;
     }
+    static SELECTION_COLUMN_ID = 'ag-Grid-SelectionColumn';
+    static getGridOptionForRowSelectionFromLayout(layoutRowSelection, baseGridRowSelection) {
+        if (layoutRowSelection === false) {
+            return undefined;
+        }
+        if (layoutRowSelection == null) {
+            return baseGridRowSelection;
+        }
+        const current = baseGridRowSelection && typeof baseGridRowSelection !== 'string'
+            ? baseGridRowSelection
+            : {};
+        const updated = { ...current };
+        if (layoutRowSelection.Mode != null) {
+            updated.mode = layoutRowSelection.Mode;
+        }
+        if (layoutRowSelection.Checkboxes != null) {
+            updated.checkboxes = layoutRowSelection.Checkboxes;
+        }
+        if (layoutRowSelection.GroupSelectMode != null) {
+            updated.groupSelects = layoutRowSelection.GroupSelectMode;
+        }
+        if (layoutRowSelection.SelectAllMode != null) {
+            updated.selectAll = layoutRowSelection.SelectAllMode;
+        }
+        if (layoutRowSelection.HeaderCheckbox != null) {
+            updated.headerCheckbox = layoutRowSelection.HeaderCheckbox;
+        }
+        if (layoutRowSelection.EnableClickSelection != null) {
+            updated.enableClickSelection = layoutRowSelection.EnableClickSelection;
+        }
+        if (layoutRowSelection.CheckboxInGroupColumn != null) {
+            updated.checkboxLocation = layoutRowSelection.CheckboxInGroupColumn
+                ? 'autoGroupColumn'
+                : 'selectionColumn';
+        }
+        return updated;
+    }
+    static isSelectionColumnInNonFirstPosition(tableColumns) {
+        if (!tableColumns) {
+            return false;
+        }
+        const index = tableColumns.indexOf(LayoutManager.SELECTION_COLUMN_ID);
+        return index > 0;
+    }
+    ensureSelectionColumnPositionUnlocked(layout) {
+        if (LayoutManager.isSelectionColumnInNonFirstPosition(layout.TableColumns)) {
+            const current = this.gridApi.getGridOption('selectionColumnDef');
+            if (!current || current.lockPosition !== false) {
+                this.gridApi.setGridOption('selectionColumnDef', {
+                    ...current,
+                    lockPosition: false,
+                });
+            }
+        }
+    }
+    getRowSelectionFromGrid() {
+        const gridRowSelection = this.gridApi.getGridOption('rowSelection');
+        if (!gridRowSelection || typeof gridRowSelection === 'string') {
+            return this.currentLayout?.RowSelection === false ? false : undefined;
+        }
+        const rs = gridRowSelection;
+        const result = {
+            Mode: rs.mode ?? 'singleRow',
+        };
+        if (rs.checkboxes != null) {
+            result.Checkboxes = rs.checkboxes;
+        }
+        if (rs.mode === 'multiRow' && rs.groupSelects != null) {
+            result.GroupSelectMode = rs.groupSelects;
+        }
+        if (rs.mode === 'multiRow' && rs.selectAll != null) {
+            result.SelectAllMode = rs.selectAll;
+        }
+        if (rs.mode === 'multiRow' && rs.headerCheckbox != null) {
+            result.HeaderCheckbox = rs.headerCheckbox;
+        }
+        if (rs.enableClickSelection != null) {
+            result.EnableClickSelection =
+                rs.enableClickSelection;
+        }
+        if (rs.checkboxLocation != null) {
+            result.CheckboxInGroupColumn = rs.checkboxLocation === 'autoGroupColumn';
+        }
+        return result;
+    }
+    applyRowSelection(layout) {
+        const rowSelection = LayoutManager.getGridOptionForRowSelectionFromLayout(layout.RowSelection, this.initialRowSelection);
+        this.gridApi.setGridOption('rowSelection', rowSelection);
+    }
     applyTableLayout(layout, options) {
         this.withSuppressColumnAnimation(() => {
+            this.ensureSelectionColumnPositionUnlocked(layout);
             // if we apply the state here, before calling setGridOption for groupDisplayType
             // the order is not always correctly applied
             // this.gridApi.applyColumnState(state);

package/src/layout-manager/src/normalizeLayoutModel.js

@@ -41,6 +41,10 @@ function normalizeTableLayoutModel(layout, options) {
         // make it an own property
         layout.GrandTotalRow = undefined;
     }
+    if (!('RowSelection' in layout)) {
+        // make it an own property
+        layout.RowSelection = undefined;
+    }
     const ColumnOrderSet = new Set(layout.TableColumns);
     if (layout.RowGroupedColumns && layout.RowGroupedColumns.length && layout.TableColumns) {
         // the layout.TableColumns might not include the group columns
@@ -174,6 +178,10 @@ function normalizePivotLayoutModel(layout) {
         // make it an own property
         layout.PivotColumnTotal = undefined;
     }
+    if (!('RowSelection' in layout)) {
+        // make it an own property
+        layout.RowSelection = undefined;
+    }
     // if (layout.PivotGroupedColumns && layout.PivotGroupedColumns.length) {
     layout.RowGroupDisplayType = layout.RowGroupDisplayType || 'single';
     // }

package/src/layout-manager/src/simplifyLayoutModel.js

@@ -13,6 +13,9 @@ function simplifyTableLayoutModel(layout) {
     if (layout.ColumnSizing && !Object.keys(layout.ColumnSizing).length) {
         delete layout.ColumnSizing;
     }
+    if (layout.RowSelection == undefined) {
+        delete layout.RowSelection;
+    }
     if (layout.ColumnSorts && !layout.ColumnSorts.length) {
         delete layout.ColumnSorts;
     }
@@ -77,6 +80,9 @@ function simplifyPivotLayoutModel(layout) {
     if (layout.ColumnSizing && !Object.keys(layout.ColumnSizing).length) {
         delete layout.ColumnSizing;
     }
+    if (layout.RowSelection == undefined) {
+        delete layout.RowSelection;
+    }
     if (!layout.SuppressAggFuncInHeader) {
         delete layout.SuppressAggFuncInHeader;
     }

package/src/metamodel/adaptable-metamodel-model.d.ts

@@ -1,19 +1,28 @@
 export type AdaptableMetamodel = Record<string, MetamodelItem>;
 export interface MetamodelItem {
-    name: string;
-    kind: 'A' | 'I' | 'C';
-    desc: string;
-    props?: MetamodelItemProperty[];
+    /** Item kind: 'A' (type alias), 'I' (interface), 'C' (class) */
+    k: 'A' | 'I' | 'C';
+    /** Description (only present for noCode-tagged items) */
+    d?: string;
+    /** Properties of this item */
+    p?: MetamodelItemProperty[];
 }
 export interface MetamodelItemProperty {
-    name: string;
-    kind: MetamodelItemPropertyKind;
-    desc: string;
-    uiLabel?: string;
-    ref?: string;
-    isOpt?: boolean;
-    defVal?: unknown;
-    gridInfo?: 'item' | 'container';
-    noCode?: 'item' | 'container';
+    /** Property name */
+    n: string;
+    /** Property kind / type */
+    k: MetamodelItemPropertyKind;
+    /** Description (only present for noCode-tagged properties) */
+    d?: string;
+    /** UI label override for display */
+    l?: string;
+    /** Reference to another MetamodelItem key */
+    r?: string;
+    /** Whether the property is optional */
+    o?: boolean;
+    /** Grid Info role: 'item' or 'container' */
+    g?: 'item' | 'container';
+    /** No-Code role: 'item' or 'container' */
+    nC?: 'item' | 'container';
 }
 export type MetamodelItemPropertyKind = 'R' | 'n' | 's' | 'b' | 'd' | 'f' | 'a' | 'i' | 'u';