@adaptabletools/adaptable 23.0.22 → 23.1.0-canary.1

package/src/agGrid/gridRefreshScope.d.ts

@@ -0,0 +1,20 @@
+import type { GridRefreshScope } from '../AdaptableInterfaces/IAdaptable';
+/**
+ * see #narrow_column_model_refresh
+ *
+ * Helpers for the refresh scope of a column-model pass (`AdaptableAgGrid.updateColumnModelAndRefreshGrid`).
+ */
+/** The legacy behaviour: destroy & recreate every rendered row and every header cell. */
+export declare const FULL_GRID_REFRESH_SCOPE: Readonly<GridRefreshScope>;
+/** Re-run the cell-level callbacks on the rendered cells; rows and header are kept. */
+export declare const CELLS_GRID_REFRESH_SCOPE: Readonly<GridRefreshScope>;
+/** Only set up the columns; whatever colDef value changed is refreshed by AG Grid itself (see #col_def_commit). */
+export declare const NO_GRID_REFRESH_SCOPE: Readonly<GridRefreshScope>;
+export declare const mergeGridRefreshScopes: (a: GridRefreshScope, b: GridRefreshScope) => GridRefreshScope;
+/**
+ * The part of `requested` that `done` did not cover, or `null` when `done` already covers everything.
+ * A row redraw covers a cell refresh (the cells are recreated with the rows).
+ */
+export declare const getMissingGridRefreshScope: (done: GridRefreshScope, requested: GridRefreshScope) => GridRefreshScope | null;
+/** eg `rows+header`, `cells`, `none` - used in the perf track details and the log line */
+export declare const describeGridRefreshScope: (scope: GridRefreshScope) => string;

package/src/agGrid/gridRefreshScope.js

@@ -0,0 +1,39 @@
+export const FULL_GRID_REFRESH_SCOPE = Object.freeze({
+    rows: true,
+    header: true,
+});
+export const CELLS_GRID_REFRESH_SCOPE = Object.freeze({
+    cells: true,
+});
+export const NO_GRID_REFRESH_SCOPE = Object.freeze({});
+export const mergeGridRefreshScopes = (a, b) => ({
+    rows: !!(a.rows || b.rows),
+    cells: !!(a.cells || b.cells),
+    header: !!(a.header || b.header),
+});
+export const getMissingGridRefreshScope = (done, requested) => {
+    const missing = {};
+    if (requested.rows && !done.rows) {
+        missing.rows = true;
+    }
+    if (requested.cells && !done.cells && !done.rows && !missing.rows) {
+        missing.cells = true;
+    }
+    if (requested.header && !done.header) {
+        missing.header = true;
+    }
+    return Object.keys(missing).length ? missing : null;
+};
+export const describeGridRefreshScope = (scope) => {
+    const parts = [];
+    if (scope.rows) {
+        parts.push('rows');
+    }
+    else if (scope.cells) {
+        parts.push('cells');
+    }
+    if (scope.header) {
+        parts.push('header');
+    }
+    return parts.length ? parts.join('+') : 'none';
+};

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

@@ -22,14 +22,14 @@ export interface RadioProps extends TypeProps, Omit<BoxProps, keyof TypeProps> {
     onClick?: React.MouseEventHandler<HTMLDivElement>;
     onFocus?: React.FocusEventHandler<HTMLDivElement>;
 }
-export declare const useRadioContext: <T extends unknown>() => {
+export declare const useRadioContext: <T extends any>() => {
     value: T;
     onChange: (value: T) => void;
     name: string;
     variant: Variant;
 };
 declare const Radio: ({ children, checked, onChange, value, name, gapDistance, childrenPosition, as, id, tabIndex, disabled, ...props }: RadioProps) => React.JSX.Element;
-export declare const RadioGroup: <T extends unknown>(props: {
+export declare const RadioGroup: <T extends any>(props: {
     orientation: "horizontal" | "vertical";
     value?: T;
     name?: string;

package/src/devTools/DevToolsTracks.d.ts

@@ -20,6 +20,12 @@ export declare const DevToolsTracks: {
         readonly track: "Runtime";
         readonly labels: {
             readonly SetLayout: "Setting layout";
+            readonly UpdateColumnModel: "Update column model & refresh grid";
+            readonly DeriveColumnState: "Derive column state from AG Grid";
+            readonly SetupColumns: "Setup columns";
+            readonly RedrawBody: "Redraw body";
+            readonly RefreshCells: "Refresh cells";
+            readonly RefreshHeader: "Refresh header";
         };
     };
     readonly Redux: {

package/src/devTools/DevToolsTracks.js

@@ -20,6 +20,12 @@ export const DevToolsTracks = {
         track: 'Runtime',
         labels: {
             SetLayout: 'Setting layout',
+            UpdateColumnModel: 'Update column model & refresh grid',
+            DeriveColumnState: 'Derive column state from AG Grid',
+            SetupColumns: 'Setup columns',
+            RedrawBody: 'Redraw body',
+            RefreshCells: 'Refresh cells',
+            RefreshHeader: 'Refresh header',
         },
     },
     Redux: {

package/src/devTools/index.d.ts

@@ -73,13 +73,37 @@ export declare class DevToolsMarker implements PerfMarker {
         readonly Runtime: {
             start: DevToolsMarker["start"];
             end: (markerDetails: Omit<DevToolsMarkerDetails, "track"> & {
-                label: "SetLayout";
+                label: "SetLayout" | "UpdateColumnModel" | "DeriveColumnState" | "SetupColumns" | "RedrawBody" | "RefreshCells" | "RefreshHeader";
             }) => DevToolsMarker;
             label: {
                 readonly SetLayout: {
                     end: EndMethod<Omit<DevToolsMarkerDetails, "track" | "label">>;
                     start: DevToolsMarker["start"];
                 };
+                readonly UpdateColumnModel: {
+                    end: EndMethod<Omit<DevToolsMarkerDetails, "track" | "label">>;
+                    start: DevToolsMarker["start"];
+                };
+                readonly DeriveColumnState: {
+                    end: EndMethod<Omit<DevToolsMarkerDetails, "track" | "label">>;
+                    start: DevToolsMarker["start"];
+                };
+                readonly SetupColumns: {
+                    end: EndMethod<Omit<DevToolsMarkerDetails, "track" | "label">>;
+                    start: DevToolsMarker["start"];
+                };
+                readonly RedrawBody: {
+                    end: EndMethod<Omit<DevToolsMarkerDetails, "track" | "label">>;
+                    start: DevToolsMarker["start"];
+                };
+                readonly RefreshCells: {
+                    end: EndMethod<Omit<DevToolsMarkerDetails, "track" | "label">>;
+                    start: DevToolsMarker["start"];
+                };
+                readonly RefreshHeader: {
+                    end: EndMethod<Omit<DevToolsMarkerDetails, "track" | "label">>;
+                    start: DevToolsMarker["start"];
+                };
             };
         };
         readonly Redux: {

package/src/env.js

@@ -1,5 +1,5 @@
 export 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: 1789246590646 || Date.now(),
-    VERSION: "23.0.22" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1789562482621 || Date.now(),
+    VERSION: "23.1.0-canary.1" || '--current-version--',
 };

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

@@ -104,6 +104,15 @@ export declare class LayoutManager<DATA_TYPE = any> extends LMEmitter {
     private computeColumnOrderAndVisibility;
     autoSizeColumns(columnIds?: string[]): false | string[];
     private applyPivotLayout;
+    /**
+     * Applies the layout state that targets pivot result columns (order, sorts, pinning).
+     *
+     * Must be called after the primary applyColumnState call(s) - i.e. after the pivot
+     * result columns have been (re)generated by AG Grid - because pivot result column
+     * state included in the same call that changes pivot/aggregation config is applied
+     * to the previous generation of pivot result columns (see AG Grid 36 notes in applyPivotLayout).
+     */
+    private applyPivotResultColumnsState;
     applyPivotTotals(layout: PivotLayoutModel): void;
     applyColumnGroupCollapseExpandState(layout: PivotLayoutModel | TableLayoutModel): void;
     private withSuppressColumnAnimation;

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

@@ -1340,20 +1340,6 @@ export class LayoutManager extends LMEmitter {
         this.computeColumnSorts(layout, columnState);
         this.computePinnedColumns(layout, columnState);
         this.computePivotAggregations(layout, columnState);
-        if (Array.isArray(layout.PivotResultColumnsOrder)) {
-            const pivotResultColumnsOrderSet = new Set(layout.PivotResultColumnsOrder);
-            const existingPivotResultState = {};
-            columnState.state = columnState.state.filter((colState) => {
-                if (pivotResultColumnsOrderSet.has(colState.colId)) {
-                    existingPivotResultState[colState.colId] = colState;
-                    return false;
-                }
-                return true;
-            });
-            layout.PivotResultColumnsOrder.forEach((colId) => {
-                columnState.state.push(existingPivotResultState[colId] || { colId });
-            });
-        }
         return columnState;
     }
     computePivotAggregations(layout, columnState) {
@@ -1583,10 +1569,8 @@ export class LayoutManager extends LMEmitter {
                 this.gridApi.applyColumnState(columnState);
             });
             this.computePivotAggregations(layout, columnState);
-            if (Array.isArray(layout.PivotResultColumnsOrder)) {
-                columnState.applyOrder = true;
-            }
             this.gridApi.applyColumnState(columnState);
+            this.applyPivotResultColumnsState(layout);
             if (layout.ColumnSizing) {
                 const colWidthForPivotResultColumns = [];
                 (this.gridApi.getPivotResultColumns() || []).forEach((col) => {
@@ -1608,6 +1592,43 @@ export class LayoutManager extends LMEmitter {
             }
         });
     }
+    applyPivotResultColumnsState(layout) {
+        const existingPivotResultColIds = (this.gridApi.getPivotResultColumns() || []).map((col) => col.getColId());
+        if (!existingPivotResultColIds.length) {
+            return;
+        }
+        const existingSet = new Set(existingPivotResultColIds);
+        const persistedOrder = Array.isArray(layout.PivotResultColumnsOrder) && layout.PivotResultColumnsOrder.length > 0
+            ? layout.PivotResultColumnsOrder
+            : null;
+        let orderedColIds = existingPivotResultColIds;
+        if (persistedOrder) {
+            const desiredSet = new Set(persistedOrder);
+            const knownColIds = existingPivotResultColIds.filter((colId) => desiredSet.has(colId));
+            const extraColIds = existingPivotResultColIds.filter((colId) => !desiredSet.has(colId));
+            orderedColIds = [
+                ...sortColumnIdsByOrder(knownColIds, persistedOrder).filter((colId) => existingSet.has(colId)),
+                ...extraColIds,
+            ];
+        }
+        const sorts = layout.ColumnSorts || [];
+        const sortIndexes = new Map(sorts.map((sort, index) => [sort.ColumnId, index]));
+        const pinning = layout.ColumnPinning || {};
+        const state = orderedColIds.map((colId) => {
+            const sortIndex = sortIndexes.get(colId);
+            const sort = sortIndex != null ? sorts[sortIndex] : undefined;
+            return {
+                colId,
+                sort: sort ? (sort.SortOrder === 'Asc' ? 'asc' : 'desc') : null,
+                sortIndex: sort ? sortIndex : null,
+                pinned: pinning[colId] ?? null,
+            };
+        });
+        this.gridApi.applyColumnState({
+            state,
+            applyOrder: !!persistedOrder,
+        });
+    }
     applyPivotTotals(layout) {
         if (layout.PivotGrandTotal) {
             const pivotGrandTotal = layout.PivotGrandTotal === true || layout.PivotGrandTotal === 'before'

package/src/parser/src/types.d.ts

@@ -63,7 +63,9 @@ export interface ExpressionContext extends BaseContext {
      */
     dataChangedEvent?: CellDataChangedInfo;
     /**
-     * Pivot Result Column when evaluating a Pivoted Column
+     * The Pivot Result Column when evaluating an expression for a pivot result cell:
+     * `COL` / `$SCOPE` of its base column resolve to the pivot result cell value.
+     * See #derived_pivot_cell_style (`AgGridColumnAdapter`)
      */
     pivotResultColumn?: Column;
     /**

package/src/types.d.ts

@@ -34,7 +34,7 @@ export type { OpenFinPluginOptions } from './AdaptableOptions/OpenFinPluginOptio
 export type { InteropioPluginOptions } from './AdaptableOptions/InteropioPluginOptions';
 export type { MasterDetailPluginOptions, DetailInitContext, } from './AdaptableOptions/MasterDetailPluginOptions';
 export type { DateInputOptions } from './AdaptableOptions/DateInputOptions';
-export type { FilterOptions, ColumnFilterOptions, GridFilterOptions, IsRowFilterableContext, InFilterValueInfo, InFilterValueResult, InFilterValue, CustomInFilterValuesContext, GridFilterEditors, DefaultPredicateFilterContext, AdaptableFilterComponentLocation, } from './AdaptableOptions/FilterOptions';
+export type { FilterOptions, ColumnFilterOptions, GridFilterOptions, IsRowFilterableContext, InFilterValueInfo, InFilterValueResult, InFilterValue, CustomInFilterValuesContext, InFilterLabelContext, GridFilterEditors, DefaultPredicateFilterContext, AdaptableFilterComponentLocation, } from './AdaptableOptions/FilterOptions';
 export type { QuickSearchOptions, QuickSearchContext } from './AdaptableOptions/QuickSearchOptions';
 export type { FormatColumnOptions, CustomDisplayFormatter, CustomDisplayFormatterContext, } from './AdaptableOptions/FormatColumnOptions';
 export type { PlusMinusOptions } from './AdaptableOptions/EditOptions';