@adaptabletools/adaptable-cjs 21.0.0-canary.4 → 21.0.0-canary.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable-cjs",
-  "version": "21.0.0-canary.4",
+  "version": "21.0.0-canary.6",
   "description": "Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",

package/src/AdaptableOptions/DefaultAdaptableOptions.js

@@ -153,7 +153,7 @@ const DefaultAdaptableOptions = {
         showDatePicker: true,
         columnFilterOptions: {
             indicateFilteredColumns: true,
-            autoApplyColumnFilter: true,
+            manuallyApplyColumnFilter: false,
             defaultNumericColumnFilter: 'Equals',
             defaultTextColumnFilter: 'Contains',
             defaultDateColumnFilter: 'On',

package/src/AdaptableOptions/FilterOptions.d.ts

@@ -79,13 +79,13 @@ export interface ColumnFilterOptions<TData = any> {
      */
     indicateFilteredColumns?: boolean;
     /**
-     * Apply Column Filters immediately; if false an Apply Filter button is displayed and Quick Filter is disabled
+     * Manually apply Column Filters; an Apply Filter button is displayed and Quick Filter is disabled
      *
-     * @defaultValue true
+     * @defaultValue false
      * @gridInfoItem
      * @noCodeItem
      */
-    autoApplyColumnFilter?: boolean | ((context: AdaptableColumnContext) => boolean);
+    manuallyApplyColumnFilter?: boolean | ((context: AdaptableColumnContext) => boolean);
     /**
      * Default filter type for numeric Columns
      *
@@ -260,7 +260,7 @@ export interface CustomInFilterValuesContext<TData = any> extends AdaptableColum
      */
     currentSearchValue: string;
     /**
-     * Previous filter result; avoids expensive recomputations (e.g for async op or server-side filtering)
+     * Last filter result; avoids expensive recomputations (eg if async or server-side filtering)
      */
     previousFilterResult?: InFilterValueResult;
 }

package/src/AdaptableState/LayoutState.d.ts

@@ -258,7 +258,7 @@ export type ColumnDirectionMap = {
     [columnId: string]: 'left' | 'right';
 };
 /**
- * State & behaviour for sizing a column (must set `width` or `flex` property, but not both); all other props optional
+ * State & behaviour for column sizing (must set `width` or `flex` but not both); all other props optional
  */
 export type ColumnSizingDefinition = ({
     Width?: number;

package/src/Api/Internal/AlertInternalApi.js

@@ -529,7 +529,7 @@ class AlertInternalApi extends ApiBase_1.ApiBase {
                             isValidExpression &&
                                 this.getAdaptableApi()
                                     .internalApi.getQueryLanguageService()
-                                    .evaluateBooleanExpression(expression, 'Alert', rowNode, dataChangedEvent);
+                                    .evaluateBooleanExpression(expression, 'Alert', rowNode, { dataChangedEvent });
                     }
                     catch (error) {
                         isSatisfiedExpression = false;

package/src/Api/Internal/ColumnFilterInternalApi.d.ts

@@ -54,7 +54,7 @@ export declare class ColumnFilterInternalApi extends ApiBase {
         columnId: string;
         currentSearchValue: string;
     }): Promise<InFilterValueResult>;
-    shouldAutoApplyColumnFilter(columnId: string): boolean;
+    shouldManuallyApplyColumnFilter(columnId: string): boolean;
     getAdaptableFilterHandler(columnId: string): AdaptableFilterHandler | undefined;
     getAllAdaptableFilterHandlers(): AdaptableFilterHandler[];
 }

package/src/Api/Internal/ColumnFilterInternalApi.js

@@ -267,21 +267,21 @@ class ColumnFilterInternalApi extends ApiBase_1.ApiBase {
         }
         return columnFilterHandler.getFromCacheOrFetchFilterDisplayValues(newOptions);
     }
-    shouldAutoApplyColumnFilter(columnId) {
-        const autoApplyColumnFilterOpt = this.getOptionsApi().getFilterOptions().columnFilterOptions?.autoApplyColumnFilter;
-        if (typeof autoApplyColumnFilterOpt === 'boolean') {
-            return autoApplyColumnFilterOpt;
+    shouldManuallyApplyColumnFilter(columnId) {
+        const manuallyApplyColumnFilterOpt = this.getOptionsApi().getFilterOptions().columnFilterOptions?.manuallyApplyColumnFilter;
+        if (typeof manuallyApplyColumnFilterOpt === 'boolean') {
+            return manuallyApplyColumnFilterOpt;
         }
-        if (typeof autoApplyColumnFilterOpt === 'function') {
+        if (typeof manuallyApplyColumnFilterOpt === 'function') {
             const column = this.getColumnApi().getColumnWithColumnId(columnId);
             const context = {
                 column,
                 ...this.getAdaptableApi().internalApi.buildBaseContext(),
             };
-            return autoApplyColumnFilterOpt(context);
+            return manuallyApplyColumnFilterOpt(context);
         }
         // fallback, should never happen
-        return true;
+        return false;
     }
     getAdaptableFilterHandler(columnId) {
         return this.getAgGridApi().getColumnFilterHandler(columnId);

package/src/Api/Internal/FormatColumnInternalApi.d.ts

@@ -1,4 +1,4 @@
-import { HeaderValueGetterParams, IRowNode } from 'ag-grid-enterprise';
+import { Column, HeaderValueGetterParams, IRowNode } from 'ag-grid-enterprise';
 import { AdaptableColumn, AdaptableFormat, AdaptablePredicateDef, ColumnScope, FormatColumn, FormatColumnConfig, FormatColumnTarget, StringFormatterOptions } from '../../types';
 import { ApiBase } from '../Implementation/ApiBase';
 export declare class FormatColumnInternalApi extends ApiBase {
@@ -85,7 +85,7 @@ export declare class FormatColumnInternalApi extends ApiBase {
      * @param column
      * @param params
      */
-    formatColumnShouldRenderInCell(formatColumn: FormatColumn, column: AdaptableColumn, rowNode: IRowNode, cellValue: any): boolean;
+    formatColumnShouldRenderInCell(formatColumn: FormatColumn, column: AdaptableColumn, rowNode: IRowNode, cellValue: any, pivotResultColumn?: Column): boolean;
     /**
      * Checks if format column is relevant for a given Column Header
      *
@@ -95,17 +95,6 @@ export declare class FormatColumnInternalApi extends ApiBase {
     formatColumnShouldRenderInHeader(formatColumn: FormatColumn, column: AdaptableColumn): boolean;
     private evaluatePredicate;
     private evaluateExpression;
-    /**
-     * Extract from the given FormatColumns only the ones which are relevant for a given cell (intersection of given AdaptableColumn and RowNode)
-     *
-     * @param formatColumns
-     * @param column
-     * @param params
-     */
-    getFormatColumnsRelevantForColumn(formatColumns: FormatColumn[], column: AdaptableColumn, params: {
-        node: IRowNode;
-        value: any;
-    }): FormatColumn[];
     /**
      * Extract from the given FormatColumns the one which is the most relevant  for a given cell (intersection of given AdaptableColumn and RowNode)
      *

package/src/Api/Internal/FormatColumnInternalApi.js

@@ -226,7 +226,7 @@ class FormatColumnInternalApi extends ApiBase_1.ApiBase {
      * @param column
      * @param params
      */
-    formatColumnShouldRenderInCell(formatColumn, column, rowNode, cellValue) {
+    formatColumnShouldRenderInCell(formatColumn, column, rowNode, cellValue, pivotResultColumn) {
         // suspended is important to be first
         if (formatColumn.IsSuspended) {
             return false;
@@ -274,7 +274,7 @@ class FormatColumnInternalApi extends ApiBase_1.ApiBase {
             return this.evaluatePredicate(formatColumn, predicateDefHandlerContext);
         } // then run the Expression
         else if (formatColumn.Rule.BooleanExpression) {
-            return this.evaluateExpression(formatColumn, rowNode);
+            return this.evaluateExpression(formatColumn, rowNode, pivotResultColumn);
         }
         // nothing has passed then return false
         return false;
@@ -298,29 +298,19 @@ class FormatColumnInternalApi extends ApiBase_1.ApiBase {
     evaluatePredicate(formatColumn, predicateDefHandlerContext) {
         return this.getPredicateApi().handleColumnPredicates(formatColumn.Rule?.Predicates, predicateDefHandlerContext, false);
     }
-    evaluateExpression(formatColumn, node) {
+    evaluateExpression(formatColumn, node, pivotResultColumn) {
         const isValidExpression = this.getExpressionApi().isValidBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, `Invalid format column rule '${formatColumn.Rule.BooleanExpression}'`);
         try {
             return (isValidExpression &&
                 this.getAdaptableApi()
                     .internalApi.getQueryLanguageService()
-                    .evaluateBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, node));
+                    .evaluateBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, node, { pivotResultColumn }));
         }
         catch (error) {
             (0, AdaptableLogger_1.errorOnce)(error.message);
             return false;
         }
     }
-    /**
-     * Extract from the given FormatColumns only the ones which are relevant for a given cell (intersection of given AdaptableColumn and RowNode)
-     *
-     * @param formatColumns
-     * @param column
-     * @param params
-     */
-    getFormatColumnsRelevantForColumn(formatColumns, column, params) {
-        return formatColumns.filter((formatColumn) => this.formatColumnShouldRenderInCell(formatColumn, column, params.node, params.value));
-    }
     /**
      * Extract from the given FormatColumns the one which is the most relevant  for a given cell (intersection of given AdaptableColumn and RowNode)
      *

package/src/Strategy/FlashingCellModule.js

@@ -89,7 +89,9 @@ class FlashingCellModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                             isValidExpression &&
                                 this.api.internalApi
                                     .getQueryLanguageService()
-                                    .evaluateBooleanExpression(expression, this.moduleInfo.ModuleName, rowNode, cellDataChangedInfo);
+                                    .evaluateBooleanExpression(expression, this.moduleInfo.ModuleName, rowNode, {
+                                    dataChangedEvent: cellDataChangedInfo,
+                                });
                     }
                     catch (error) {
                         isSatisfiedExpression = false;

package/src/Utilities/ExpressionFunctions/scalarExpressionFunctions.js

@@ -64,6 +64,14 @@ exports.scalarExpressionFunctions = {
             if (!column.queryable) {
                 throw new ExpressionEvaluationError_1.ExpressionEvaluationError('COL', `Column name "${columnId}" is not queryable`);
             }
+            // see #derived_pivot_cell_style
+            if (context.pivotResultColumn) {
+                const baseColumnId = context.pivotResultColumn.getColDef()?.pivotValueColumn?.getColId();
+                if (baseColumnId === columnId) {
+                    // we evaluate the pivot result column instead of the base column
+                    return context.adaptableApi?.gridApi.getNormalisedValueFromRowNode(context.node, context.pivotResultColumn.getColId());
+                }
+            }
             return context.adaptableApi?.gridApi.getNormalisedValueFromRowNode(context.node, columnId);
         },
         description: 'Returns the value of a Column',

package/src/Utilities/Services/Interface/IQueryLanguageService.d.ts

@@ -1,6 +1,6 @@
 import { Observable } from 'rxjs';
 import { IAdaptableService } from './IAdaptableService';
-import { IRowNode } from 'ag-grid-enterprise';
+import { Column, IRowNode } from 'ag-grid-enterprise';
 import { CellDataChangedInfo } from '../../../AdaptableState/Common/CellDataChangedInfo';
 import { RowDataChangedInfo } from '../../../AdaptableState/Common/RowDataChangedInfo';
 import { AdaptableModule } from '../../../AdaptableState/Common/Types';
@@ -11,7 +11,10 @@ import { ScalarFunctionName } from '../../ExpressionFunctions/scalarExpressionFu
 import { ObservableFunctionName } from '../../ExpressionFunctions/observableExpressionFunctions';
 import { ExpressionFunctionMap } from '../../../parser/src/types';
 export interface IQueryLanguageService extends IAdaptableService {
-    evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: IRowNode, dataChangedEvent?: CellDataChangedInfo): boolean;
+    evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: IRowNode, evalContext?: {
+        dataChangedEvent?: CellDataChangedInfo;
+        pivotResultColumn?: Column;
+    }): boolean;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: IRowNode): any;
     evaluateObservableExpression(expression: string, module: AdaptableModule): Observable<CellDataChangedInfo | RowDataChangedInfo>;
     evaluateAggregatedBooleanExpression(expression: string, module: AdaptableModule): BooleanAggregationParameter;

package/src/Utilities/Services/QueryLanguageService.d.ts

@@ -1,4 +1,4 @@
-import { IRowNode } from 'ag-grid-enterprise';
+import { Column, IRowNode } from 'ag-grid-enterprise';
 import { Observable } from 'rxjs';
 import { AdaptableApi, RowDataChangedInfo } from '../../../types';
 import { GlobalExpressionFunctionsContext } from '../../AdaptableOptions/ExpressionOptions';
@@ -16,7 +16,10 @@ export declare class QueryLanguageService implements IQueryLanguageService {
     private cacheAggregatedScalarValidation;
     private cacheModuleSpecificExpressionFunctions;
     constructor(adaptableApi: AdaptableApi);
-    evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any, dataChangedEvent?: CellDataChangedInfo): any;
+    evaluateBooleanExpression(expression: string, module: AdaptableModule, rowNode: any, evalContext?: {
+        dataChangedEvent?: CellDataChangedInfo;
+        pivotResultColumn?: Column;
+    }): any;
     evaluateScalarExpression(expression: string, module: AdaptableModule, rowNode: IRowNode): any;
     evaluateAggregatedScalarExpression(expression: string, module: AdaptableModule, getRowNodes?: () => IRowNode[]): ScalarAggregationParameter;
     evaluateObservableExpression(reactiveExpression: string, module: AdaptableModule): Observable<CellDataChangedInfo | RowDataChangedInfo>;

package/src/Utilities/Services/QueryLanguageService.js

@@ -21,7 +21,7 @@ class QueryLanguageService {
         this.cacheAggregatedScalarValidation = new Map();
         this.cacheModuleSpecificExpressionFunctions = new Map();
     }
-    evaluateBooleanExpression(expression, module, rowNode, dataChangedEvent) {
+    evaluateBooleanExpression(expression, module, rowNode, evalContext) {
         if (expression == undefined) {
             // should never happen, but just in case
             this.adaptableApi.logError('QueryLanguageService.evaluateBooleanExpression was called with an undefined expression');
@@ -33,7 +33,8 @@ class QueryLanguageService {
             node: rowNode,
             functions: booleanAndScalarFunctions,
             evaluateCustomQueryVariable: this.evaluateCustomQueryVariable,
-            dataChangedEvent,
+            dataChangedEvent: evalContext?.dataChangedEvent,
+            pivotResultColumn: evalContext?.pivotResultColumn,
             ...this.adaptableApi.internalApi.buildBaseContext(),
         });
     }
@@ -125,7 +126,7 @@ class QueryLanguageService {
                 newValue: 100,
                 oldValue: 150,
             };
-            this.evaluateBooleanExpression(expression, module, firstRowNode, dataChangedEvent);
+            this.evaluateBooleanExpression(expression, module, firstRowNode, { dataChangedEvent });
             const result = {
                 isValid: true,
                 errorMessage: '',

package/src/View/Components/ColumnFilter/ColumnFilter.js

@@ -66,16 +66,16 @@ const AndOrInput = (props) => {
 };
 const ColumnFilterComponent = (props) => {
     const adaptable = (0, AdaptableContext_1.useAdaptable)();
-    const autoApplyColumnFilter = adaptable.api.filterApi.columnFilterApi.internalApi.shouldAutoApplyColumnFilter(props.columnId);
+    const manuallyApplyColumnFilter = adaptable.api.filterApi.columnFilterApi.internalApi.shouldManuallyApplyColumnFilter(props.columnId);
     const [predicateNotYetApplied, setPredicateNotYetApplied] = React.useState(props.predicate);
     const applyFilter = () => {
         props.onPredicateChange(currentPredicateRef.current);
         setPredicateNotYetApplied(undefined);
     };
     const onPredicateChange = (predicate) => {
-        // even if autoApplyColumnFilter is false, when we explicitly clear the filter
+        // even if manuallyApplyColumnFilter is false, when we explicitly clear the filter
         // we want to apply the filter immediately
-        if (autoApplyColumnFilter || !predicate) {
+        if (!manuallyApplyColumnFilter || !predicate) {
             props.onPredicateChange(predicate);
         }
         else {
@@ -99,7 +99,7 @@ const ColumnFilterComponent = (props) => {
         };
         onPredicateChange(newPredicate);
     };
-    const currentPredicate = autoApplyColumnFilter
+    const currentPredicate = !manuallyApplyColumnFilter
         ? props.predicate
         : predicateNotYetApplied ?? props.predicate;
     const currentPredicateRef = React.useRef(currentPredicate);
@@ -145,7 +145,7 @@ const ColumnFilterComponent = (props) => {
                         } }));
                 }),
                 isLastPredicateValid && filterPredicateDropdown),
-            !autoApplyColumnFilter ? (React.createElement(React.Fragment, null,
+            manuallyApplyColumnFilter ? (React.createElement(React.Fragment, null,
                 React.createElement(rebass_1.Box, { flex: 1, "data-name": "spacer" }),
                 React.createElement(rebass_1.Flex, { pt: 2, className: "ab-ColumnFilter-actions", justifyContent: "space-between" },
                     React.createElement(rebass_1.Box, { className: "ab-ColumnFilter-action-apply" },

package/src/View/Components/ColumnFilter/FloatingFilter.js

@@ -18,7 +18,7 @@ const FloatingFilter = (props) => {
      * The wrapper is in charge of constructing the correct column filter.
      */
     const isMultiple = props.predicate?.args?.length > 1;
-    const isManualApply = !adaptable.api.filterApi.columnFilterApi.internalApi.shouldAutoApplyColumnFilter(props.columnId);
+    const isManualApply = adaptable.api.filterApi.columnFilterApi.internalApi.shouldManuallyApplyColumnFilter(props.columnId);
     const isInlineEditable = !isMultiple && !isManualApply;
     // only used when there is only one filter selected
     let singleFilterPredicateDef = null;

package/src/agGrid/AgGridColumnAdapter.js

@@ -319,7 +319,13 @@ class AgGridColumnAdapter {
                     const baseColumn = params.column.getColDef()?.pivotValueColumn;
                     if (baseColumn) {
                         const baseColDefCellStyle = baseColumn?.getColDef()?.cellStyle;
-                        const baseColParams = { ...params, column: baseColumn };
+                        const baseColParams = {
+                            ...params,
+                            column: baseColumn,
+                            // @ts-ignore
+                            // #derived_pivot_cell_style
+                            __pivotResultColumn: params.column,
+                        };
                         baseStyles =
                             typeof baseColDefCellStyle === 'function'
                                 ? baseColDefCellStyle(baseColParams)
@@ -1144,7 +1150,9 @@ class AgGridColumnAdapter {
             return {};
         }
         const relevantFormatColumnsWithStyle = activeFormatColumnsWithStyle.filter((formatColumn) => {
-            return this.adaptableApi.formatColumnApi.internalApi.formatColumnShouldRenderInCell(formatColumn, abColumn, params.node, params.value);
+            return this.adaptableApi.formatColumnApi.internalApi.formatColumnShouldRenderInCell(formatColumn, abColumn, params.node, params.value, 
+            // @ts-ignore see #derived_pivot_cell_style
+            params.__pivotResultColumn);
         });
         return this.getFormatColumnAdaptableStyle(relevantFormatColumnsWithStyle);
     }

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: 1757087891356 || Date.now(),
-    VERSION: "21.0.0-canary.4" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1757310431328 || Date.now(),
+    VERSION: "21.0.0-canary.6" || '--current-version--',
 };

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

@@ -1953,32 +1953,32 @@ export declare const ADAPTABLE_METAMODEL: {
             desc: string;
             isOpt: boolean;
             gridInfo: string;
-            noCode: string;
             defVal: string;
+            noCode?: undefined;
         } | {
             name: string;
             kind: string;
             desc: string;
             isOpt: boolean;
-            gridInfo: string;
             defVal: string;
+            gridInfo?: undefined;
             noCode?: undefined;
         } | {
             name: string;
             kind: string;
             desc: string;
             isOpt: boolean;
+            gridInfo: string;
+            noCode: string;
             defVal: string;
-            gridInfo?: undefined;
-            noCode?: undefined;
         } | {
             name: string;
             kind: string;
             desc: string;
             isOpt: boolean;
             gridInfo?: undefined;
-            noCode?: undefined;
             defVal?: undefined;
+            noCode?: undefined;
         } | {
             name: string;
             kind: string;