@adaptabletools/adaptable-cjs 22.0.11 → 22.1.0-canary.1

package/src/components/Tree/TreeDropdown/index.js

@@ -65,35 +65,46 @@ const getLabelColumn = (field, { includeExpandCollapseButton }) => {
                 } }));
         },
         renderHeader: ({ dataSourceApi, api, allRowsSelected, someRowsSelected }) => {
-            const { treeApi } = dataSourceApi;
-            const allFirstLevelCollapsed = dataSourceApi
-                .getOriginalDataArray()
-                .every((item) => !treeApi.isNodeExpanded([item.id]));
-            return (React.createElement(Flex_1.Flex, { flexDirection: 'row', alignItems: 'center', className: "twa:w-full", onMouseDown: (e) => {
-                    // so we can keep the focus on the Grid
-                    e.preventDefault();
-                } },
-                React.createElement(CheckBox_1.CheckBox, { checked: someRowsSelected && !allRowsSelected ? null : allRowsSelected, className: "twa:mr-2", onChange: () => {
-                        if (allRowsSelected) {
-                            dataSourceApi.treeApi.deselectAll();
-                        }
-                        else {
-                            dataSourceApi.treeApi.selectAll();
-                        }
-                        api.focus();
-                    } }, allRowsSelected ? '(Deselect All)' : '(Select All)'),
-                React.createElement(Flex_1.Flex, { className: "twa:flex-1" }),
-                includeExpandCollapseButton ? (React.createElement(SimpleButton_1.default, { label: "toggle-expand-collapse", icon: allFirstLevelCollapsed ? 'expand-all' : 'collapse-all', onMouseDown: () => {
-                        if (allFirstLevelCollapsed) {
-                            dataSourceApi.treeApi.expandAll();
-                        }
-                        else {
-                            dataSourceApi.treeApi.collapseAll();
-                        }
-                    }, iconPosition: "end" })) : null));
+            return (React.createElement(CustomHeader, { dataSourceApi: dataSourceApi, api: api, allRowsSelected: allRowsSelected, someRowsSelected: someRowsSelected, includeExpandCollapseButton: includeExpandCollapseButton }));
         },
     };
 };
+function useAllFirstLevelCollapsed(treeApi) {
+    const { originalDataArray } = (0, InfiniteTable_1.useDataSourceState)((state) => {
+        return {
+            originalDataArray: state.originalDataArray,
+            treeExpandState: state.treeExpandState,
+        };
+    });
+    return originalDataArray.every((item) => !treeApi.isNodeExpanded([item.id]));
+}
+function CustomHeader({ dataSourceApi, api, allRowsSelected, someRowsSelected, includeExpandCollapseButton, }) {
+    const { treeApi } = dataSourceApi;
+    const allFirstLevelCollapsed = useAllFirstLevelCollapsed(treeApi);
+    const checked = someRowsSelected && !allRowsSelected ? null : allRowsSelected;
+    return (React.createElement(Flex_1.Flex, { flexDirection: 'row', alignItems: 'center', className: "twa:w-full", onMouseDown: (e) => {
+            // so we can keep the focus on the Grid
+            e.preventDefault();
+        } },
+        React.createElement(CheckBox_1.CheckBox, { checked: checked, className: "twa:mr-2", onChange: () => {
+                if (allRowsSelected) {
+                    dataSourceApi.treeApi.deselectAll();
+                }
+                else {
+                    dataSourceApi.treeApi.selectAll();
+                }
+                api.focus();
+            } }, allRowsSelected ? '(Deselect All)' : '(Select All)'),
+        React.createElement(Flex_1.Flex, { className: "twa:flex-1" }),
+        includeExpandCollapseButton ? (React.createElement(SimpleButton_1.default, { label: "toggle-expand-collapse", icon: allFirstLevelCollapsed ? 'expand-all' : 'collapse-all', onMouseDown: () => {
+                if (allFirstLevelCollapsed) {
+                    dataSourceApi.treeApi.expandAll();
+                }
+                else {
+                    dataSourceApi.treeApi.collapseAll();
+                }
+            }, iconPosition: "end" })) : null));
+}
 const sizeFull = {
     width: '100%',
     height: '100%',

package/src/components/dnd/index.d.ts

@@ -1,13 +1,3 @@
-import * as React from 'react';
-import { DropResult, Draggable, DroppableProps, DragDropContextProps } from '@adaptabletools/react-beautiful-dnd';
-/**
- * We're doing all this because the placeholder is not correctly displayed in react-beautiful-dnd
- * with React 19.
- * So we make sure it properly occupies the space of the dragged item, so the
- * container won't flicker when we're dragging an item (as the drag item receives
- * position: fixed while dragging, so content does not have the initial height anymore, therefore,
- * the placeholder is included, with the computed height of the dragging element)
- */
-declare const Droppable: (props: DroppableProps) => React.JSX.Element;
-declare const DragDropContext: (props: DragDropContextProps) => React.JSX.Element;
-export { type DropResult, Draggable, Droppable, DragDropContext };
+import { DragProxyMoveParams } from '@infinite-table/infinite-react';
+export { DragDropProvider, DragList, useDragDropProvider, useDragListContext, DRAG_ITEM_ATTRIBUTE, type DragListProps, type DragDropSourceAndTarget, } from '@infinite-table/infinite-react';
+export declare function defaultDragProxyMove({ proxyElement, dx, dy }: DragProxyMoveParams): void;

package/src/components/dnd/index.js

@@ -1,61 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DragDropContext = exports.Droppable = exports.Draggable = void 0;
-const tslib_1 = require("tslib");
-const React = tslib_1.__importStar(require("react"));
-const react_beautiful_dnd_1 = require("@adaptabletools/react-beautiful-dnd");
-Object.defineProperty(exports, "Draggable", { enumerable: true, get: function () { return react_beautiful_dnd_1.Draggable; } });
-const react_1 = require("react");
-/**
- * We're doing all this because the placeholder is not correctly displayed in react-beautiful-dnd
- * with React 19.
- * So we make sure it properly occupies the space of the dragged item, so the
- * container won't flicker when we're dragging an item (as the drag item receives
- * position: fixed while dragging, so content does not have the initial height anymore, therefore,
- * the placeholder is included, with the computed height of the dragging element)
- */
-const Droppable = (props) => {
-    const children = props.children;
-    const { placeholderStyle } = React.useContext(AdaptableDDContext);
-    return (React.createElement(react_beautiful_dnd_1.Droppable, { ...props }, (provided, snapshot) => {
-        provided.placeholder = (React.createElement("div", { key: "placeholder", style: placeholderStyle || {
-                visibility: 'hidden',
-                pointerEvents: 'none',
-                height: 0,
-            } }));
-        return children(provided, snapshot);
-    }));
-};
-exports.Droppable = Droppable;
-const queryAttr = 'data-rbd-draggable-id';
-const AdaptableDDContext = React.createContext({
-    placeholderStyle: null,
-});
-const DragDropContext = (props) => {
-    const getDraggedDom = (draggableId) => {
-        const domQuery = `[${queryAttr}='${draggableId}']`;
-        const draggedDOM = document.querySelector(domQuery);
-        return draggedDOM;
-    };
-    const [placeholderStyle, setPlaceholderStyle] = (0, react_1.useState)(null);
-    const handleDragStart = (initial, provided) => {
-        props.onDragStart?.(initial, provided);
-        const draggedDOM = getDraggedDom(initial.draggableId);
-        if (!draggedDOM) {
-            return;
-        }
-        const { clientHeight, clientWidth } = draggedDOM;
-        const computedStyle = window.getComputedStyle(draggedDOM);
-        setPlaceholderStyle({
-            height: clientHeight + parseFloat(computedStyle.marginTop) + parseFloat(computedStyle.marginBottom),
-            width: clientWidth,
-        });
-    };
-    const handleDragEnd = (result, provided) => {
-        props.onDragEnd?.(result, provided);
-        setPlaceholderStyle(null);
-    };
-    return (React.createElement(AdaptableDDContext.Provider, { value: { placeholderStyle } },
-        React.createElement(react_beautiful_dnd_1.DragDropContext, { ...props, onDragStart: handleDragStart, onDragEnd: handleDragEnd })));
-};
-exports.DragDropContext = DragDropContext;
+exports.DRAG_ITEM_ATTRIBUTE = exports.useDragListContext = exports.useDragDropProvider = exports.DragList = exports.DragDropProvider = void 0;
+exports.defaultDragProxyMove = defaultDragProxyMove;
+var infinite_react_1 = require("@infinite-table/infinite-react");
+Object.defineProperty(exports, "DragDropProvider", { enumerable: true, get: function () { return infinite_react_1.DragDropProvider; } });
+Object.defineProperty(exports, "DragList", { enumerable: true, get: function () { return infinite_react_1.DragList; } });
+Object.defineProperty(exports, "useDragDropProvider", { enumerable: true, get: function () { return infinite_react_1.useDragDropProvider; } });
+Object.defineProperty(exports, "useDragListContext", { enumerable: true, get: function () { return infinite_react_1.useDragListContext; } });
+Object.defineProperty(exports, "DRAG_ITEM_ATTRIBUTE", { enumerable: true, get: function () { return infinite_react_1.DRAG_ITEM_ATTRIBUTE; } });
+function defaultDragProxyMove({ proxyElement, dx, dy }) {
+    proxyElement.style.transform = `translate3d(${Math.round(dx)}px, ${Math.round(dy)}px, 0)`;
+}

package/src/env.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     NEXT_PUBLIC_INFINITE_TABLE_LICENSE_KEY: "StartDate=2021-06-29|EndDate=2030-01-01|Owner=Adaptable|Type=distribution|TS=1624971462479|C=137829811,1004007071,2756196225,1839832928,3994409405,636616862" || '',
-    PUBLISH_TIMESTAMP: 1775828219195 || Date.now(),
-    VERSION: "22.0.11" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1776672498444 || Date.now(),
+    VERSION: "22.1.0-canary.1" || '--current-version--',
 };

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,13 @@ 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;
+    static shouldUnlockSelectionColumnPosition(layout: TableLayoutModel): 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

@@ -141,6 +141,19 @@ function getDefaultColumnSizeStateForColDef(colId, colDef, options) {
     }
     return undefined;
 }
+function adjustColumnIdsForSelection(columnIds, layout) {
+    const selectionColPinning = layout.ColumnPinning?.[LayoutManager.SELECTION_COLUMN_ID];
+    if ((layout.RowSelection || selectionColPinning) &&
+        !columnIds.includes(LayoutManager.SELECTION_COLUMN_ID)) {
+        if (selectionColPinning === 'right') {
+            columnIds = [...columnIds, LayoutManager.SELECTION_COLUMN_ID];
+        }
+        else {
+            columnIds = [LayoutManager.SELECTION_COLUMN_ID, ...columnIds];
+        }
+    }
+    return columnIds;
+}
 class LayoutManager extends LMEmitter_1.LMEmitter {
     gridApi;
     fieldsToIds = {};
@@ -154,6 +167,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 +176,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 +418,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 +450,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 +757,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;
     }
@@ -809,13 +825,15 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
         layout.TableColumns = layout.TableColumns.filter((colId) => colId != undefined);
         layout = (0, normalizeLayoutModel_1.normalizeTableLayoutModel)(layout, { isTree: _options?.isTree ?? false });
         const agGridState = {};
-        const columnIds = getColumnOrderIdsForAllColDefs(layout.TableColumns, colDefs);
+        const columnIds = adjustColumnIdsForSelection(getColumnOrderIdsForAllColDefs(layout.TableColumns, colDefs), layout);
         agGridState.columnOrder = {
             orderedColIds: columnIds,
         };
         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 +1122,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 +1180,131 @@ 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;
+    }
+    static shouldUnlockSelectionColumnPosition(layout) {
+        const tableColumns = layout.TableColumns;
+        if (!tableColumns) {
+            return false;
+        }
+        const index = tableColumns.indexOf(LayoutManager.SELECTION_COLUMN_ID);
+        if (index > 0) {
+            return true;
+        }
+        const columnPinning = layout.ColumnPinning;
+        if (columnPinning && columnPinning[LayoutManager.SELECTION_COLUMN_ID]) {
+            return true;
+        }
+        return false;
+    }
+    ensureSelectionColumnPositionUnlocked(layout) {
+        if (LayoutManager.shouldUnlockSelectionColumnPosition(layout)) {
+            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);
+        const prevRowSelection = this.gridApi.getGridOption('rowSelection');
+        this.gridApi.setGridOption('rowSelection', rowSelection);
+        // AG Grid does not always refresh already-rendered cells in the selection
+        // column when `rowSelection.checkboxes` is changed at runtime via setGridOption
+        // (e.g. toggling `checkboxes` or `headerCheckbox`).
+        // In the React wrapper this is masked by React-driven re-renders, but in the vanilla integration
+        // the selection column keeps showing stale content until a manual
+        // `refreshCells` is triggered. We force the refresh here so
+        // all integrations behave consistently.
+        if (typeof prevRowSelection === 'object' &&
+            typeof rowSelection === 'object' &&
+            rowSelection.checkboxes !== prevRowSelection.checkboxes) {
+            const selectionColumn = this.gridApi.getColumn(LayoutManager.SELECTION_COLUMN_ID);
+            if (selectionColumn) {
+                this.gridApi.refreshCells({
+                    columns: [LayoutManager.SELECTION_COLUMN_ID],
+                });
+            }
+        }
+    }
     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);
@@ -1480,10 +1622,20 @@ class LayoutManager extends LMEmitter_1.LMEmitter {
     computeColumnOrderAndVisibility(layout, columnState) {
         const visibility = layout.ColumnVisibility || {};
         const columnOrderSet = new Set(layout.TableColumns);
-        const isColHidden = (colId) => visibility[colId] === false || !columnOrderSet.has(colId);
+        const isColHidden = (colId) => {
+            if (visibility[colId] === false) {
+                return true;
+            }
+            // for the selection column, return true even
+            // if not explicitly listed in the TableColumns
+            if (colId === LayoutManager.SELECTION_COLUMN_ID && layout.RowSelection) {
+                return false;
+            }
+            return !columnOrderSet.has(colId);
+        };
         columnState = columnState ?? {};
         columnState.applyOrder = true;
-        const columnIds = getColumnOrderIdsForAllColDefs(layout.TableColumns, this.gridApi.getColumnDefs());
+        const columnIds = adjustColumnIdsForSelection(getColumnOrderIdsForAllColDefs(layout.TableColumns, this.gridApi.getColumnDefs()), layout);
         columnState.state = columnIds.map((columnId) => {
             return {
                 colId: columnId,

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';