@adaptabletools/adaptable 23.1.0-canary.2 → 24.0.0-canary.0

package/src/Api/Internal/EventInternalApi.js

@@ -1,5 +1,6 @@
 import { ApiBase } from '../Implementation/ApiBase';
 import { isEqual } from '../../Utilities/Extensions/ObjectExtensions';
+import { getLayoutChangedAreas } from '../../Utilities/Helpers/Layouts/LayoutHelper';
 export class EventInternalApi extends ApiBase {
     fireGridSortedEvent() {
         if (this.isAdapTableReady()) {
@@ -93,10 +94,12 @@ export class EventInternalApi extends ApiBase {
         if (isEqual(oldState, newState)) {
             return;
         }
+        const changedAreas = getLayoutChangedAreas(trigger, oldState, newState);
         const layoutChangedInfo = {
             actionName: trigger,
             oldLayoutState: oldState,
             newLayoutState: newState,
+            ...(changedAreas ? { changedAreas } : {}),
             ...this.getAdaptableInternalApi().buildBaseContext(),
         };
         this.getEventApi().emit('LayoutChanged', layoutChangedInfo);
@@ -164,23 +167,62 @@ export class EventInternalApi extends ApiBase {
         this.getEventApi().emit('AdaptableStateReloaded', stateReloadedInfo);
     }
     fireCalculatedColumnChangedEvent(trigger, calculatedColumn) {
+        const expression = this.getCalculatedColumnApi().internalApi.getExpressionFromCalculatedColumn(calculatedColumn);
+        let calculatedColumnExpressionAST = null;
+        try {
+            calculatedColumnExpressionAST = expression
+                ? this.getExpressionApi().getASTForExpression(expression)
+                : null;
+        }
+        catch {
+            calculatedColumnExpressionAST = null;
+        }
         const calculatedColumnChangedInfo = {
             actionName: trigger,
             calculatedColumn: calculatedColumn,
-            calculatedColumnExpressionAST: this.getExpressionApi().getASTForExpression(this.getCalculatedColumnApi().internalApi.getExpressionFromCalculatedColumn(calculatedColumn)),
+            calculatedColumnExpressionAST,
             ...this.getAdaptableInternalApi().buildBaseContext(),
         };
         this.getEventApi().emit('CalculatedColumnChanged', calculatedColumnChangedInfo);
     }
-    fireColumnFilterAppliedEvent() {
-        if (this.isAdapTableReady()) {
+    fireNoteChangedEvent(actionName, note) {
+        const noteChangedInfo = {
+            actionName,
+            note,
+            ...this.getAdaptableInternalApi().buildBaseContext(),
+        };
+        this.getEventApi().emit('NoteChanged', noteChangedInfo);
+    }
+    fireColumnFilterChangedEvent(info) {
+        if (!this.isAdapTableReady()) {
+            return;
+        }
+        const columnFilters = info.columnFilters ?? this.getColumnFilterApi().getColumnFilters() ?? [];
+        const baseContext = this.getAdaptableInternalApi().buildBaseContext();
+        const columnFilterChangedInfo = {
+            columnId: info.columnId,
+            isApplied: info.isApplied,
+            isComplete: info.isComplete,
+            expression: info.expression,
+            columnFilters,
+            ...baseContext,
+        };
+        this.getEventApi().emit('ColumnFilterChanged', columnFilterChangedInfo);
+        if (info.isApplied) {
             const columnFilterAppliedInfo = {
-                columnFilters: this.getColumnFilterApi().getColumnFilters(),
-                ...this.getAdaptableInternalApi().buildBaseContext(),
+                columnFilters,
+                columnFilterExpressionASTs: columnFilters.map((columnFilter) => this.getASTForExpressionSafe(columnFilter.Expression)),
+                ...baseContext,
             };
             this.getEventApi().emit('ColumnFilterApplied', columnFilterAppliedInfo);
         }
     }
+    fireColumnFilterAppliedEvent() {
+        this.fireColumnFilterChangedEvent({
+            isApplied: true,
+            isComplete: true,
+        });
+    }
     fireGridFilterAppliedEvent() {
         if (this.isAdapTableReady()) {
             const currentGridFilter = this.getGridFilterApi().getCurrentGridFilter();
@@ -213,4 +255,15 @@ export class EventInternalApi extends ApiBase {
         };
         const results = this.getEventApi().emitSync('FlashingCellDisplayed', flashingCellFiredInfo);
     }
+    getASTForExpressionSafe(expression) {
+        if (!expression) {
+            return null;
+        }
+        try {
+            return this.getExpressionApi().getASTForExpression(expression);
+        }
+        catch {
+            return null;
+        }
+    }
 }

package/src/Api/Internal/ExportInternalApi.js

@@ -1,4 +1,5 @@
 import { ApiBase } from '../Implementation/ApiBase';
+import { resolveValueOrFunction } from '../../Utilities/Helpers/ValueOrFunctionHelper';
 import { createGrid, } from 'ag-grid-enterprise';
 import { createUuid } from '../../AdaptableState/Uuid';
 import { ALL_DATA_REPORT, CURRENT_LAYOUT_REPORT, SELECTED_DATA_REPORT, SYSTEM_EXPORT_DESTINATIONS, SYSTEM_REPORT_NAMES, } from '../../Utilities/Constants/GeneralConstants';
@@ -82,7 +83,7 @@ export class ExportInternalApi extends ApiBase {
                     Name: ALL_DATA_REPORT,
                     ReportColumnScope: 'AllColumns',
                     ReportRowScope: 'AllRows',
-                    Query: undefined,
+                    Expression: undefined,
                     IsReadOnly: true,
                 };
             case CURRENT_LAYOUT_REPORT:
@@ -91,7 +92,7 @@ export class ExportInternalApi extends ApiBase {
                     Name: CURRENT_LAYOUT_REPORT,
                     ReportColumnScope: 'VisibleColumns',
                     ReportRowScope: 'VisibleRows',
-                    Query: undefined,
+                    Expression: undefined,
                     IsReadOnly: true,
                 };
             case SELECTED_DATA_REPORT:
@@ -100,7 +101,7 @@ export class ExportInternalApi extends ApiBase {
                     Name: SELECTED_DATA_REPORT,
                     ReportColumnScope: 'SelectedColumns',
                     ReportRowScope: 'SelectedRows',
-                    Query: undefined,
+                    Expression: undefined,
                     IsReadOnly: true,
                 };
         }
@@ -158,7 +159,7 @@ export class ExportInternalApi extends ApiBase {
                 case 'SelectedRows':
                     return '[Selected Rows]';
                 case 'ExpressionRows':
-                    return this.getAdaptableInternalApi().getAdaptableQueryExpressionText(report.Query);
+                    return this.getAdaptableInternalApi().getAdaptableQueryExpressionText(report.Expression);
             }
         }
     }
@@ -396,9 +397,7 @@ export class ExportInternalApi extends ApiBase {
     }
     buildCsvExportParams(reportName, reportFormat, exportDestination) {
         const exportOptions = this.getAdaptableApi().optionsApi.getExportOptions();
-        const csvSeparator = typeof exportOptions.csvSeparator === 'function'
-            ? exportOptions.csvSeparator(this.buildBaseExportContext(reportName, reportFormat, exportDestination))
-            : exportOptions.csvSeparator;
+        const csvSeparator = resolveValueOrFunction(exportOptions.csvSeparator, this.buildBaseExportContext(reportName, reportFormat, exportDestination));
         return {
             columnSeparator: csvSeparator,
         };

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

@@ -1,7 +1,16 @@
 import { ApiBase } from '../Implementation/ApiBase';
-import { AdaptableQLModule } from '../../AdaptableState/Common/Types';
-import { AdaptableField, AdaptableObject, AdaptablePredicate } from '../../types';
+import { AdaptableModule, AdaptableQLModule } from '../../AdaptableState/Common/Types';
+import { AdaptableField, AdaptableObject } from '../../types';
+import { ModuleExpressionFunctionsMap } from '../../Utilities/Services/Interface/IQueryLanguageService';
 export declare class ExpressionInternalApi extends ApiBase {
+    /**
+     * Recomputes the expression functions available to the module, bypassing
+     * the per-module/user cache, and refreshes the cached entry (write-through)
+     * so the UI and evaluation immediately pick up the new result. Use after
+     * external state that availability callbacks depend on (permissions,
+     * feature toggles) has changed.
+     */
+    resolveModuleExpressionFunctionsMap(module: AdaptableModule): ModuleExpressionFunctionsMap;
     /**
      * Checks if a column is referenced in a given Expression
      * @param columnId Column to Check
@@ -9,7 +18,6 @@ export declare class ExpressionInternalApi extends ApiBase {
      */
     isColumnReferencedInExpression(columnId: string, expression: string): boolean;
     evaluateExpressionInAdaptableQL(module: AdaptableQLModule, object?: AdaptableObject, expression?: string): boolean;
-    shouldEvaluatePredicatesInAdaptableQL(module: AdaptableQLModule, object?: AdaptableObject, predicates?: AdaptablePredicate[]): boolean;
     private getFieldsFromOptions;
     getAvailableFields(data?: Record<string, any>): AdaptableField[];
     getFieldType(field: string): AdaptableField['dataType'];

package/src/Api/Internal/ExpressionInternalApi.js

@@ -1,6 +1,12 @@
 import { ApiBase } from '../Implementation/ApiBase';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
+import { resolveValueOrFunction } from '../../Utilities/Helpers/ValueOrFunctionHelper';
 export class ExpressionInternalApi extends ApiBase {
+    resolveModuleExpressionFunctionsMap(module) {
+        return this.getAdaptableInternalApi()
+            .getQueryLanguageService()
+            .resolveModuleExpressionFunctionsMap(module);
+    }
     isColumnReferencedInExpression(columnId, expression) {
         const colIds = this.getExpressionApi().getColumnsFromExpression(expression);
         return colIds.some((c) => c === columnId);
@@ -25,33 +31,10 @@ export class ExpressionInternalApi extends ApiBase {
         }
         return !evaluateExpressionExternallyFn(context);
     }
-    shouldEvaluatePredicatesInAdaptableQL(module, object, predicates) {
-        const evaluateExpressionExternallyFn = this.getExpressionOptions()?.evaluateAdaptableQLExternally;
-        if (typeof evaluateExpressionExternallyFn !== 'function') {
-            return true;
-        }
-        const context = {
-            ...this.getAdaptableInternalApi().buildBaseContext(),
-            module,
-        };
-        if (object) {
-            context.object = object;
-        }
-        if (predicates) {
-            context.predicates = predicates;
-        }
-        return !evaluateExpressionExternallyFn(context);
-    }
     getFieldsFromOptions() {
-        const fields = this.getExpressionOptions().fields;
-        if (fields != null && typeof fields === 'function') {
-            return fields(this.getAdaptableInternalApi().buildBaseContext());
-        }
-        else {
-            let arr = fields;
-            if (arr && ArrayExtensions.IsNotNullOrEmpty(arr)) {
-                return arr;
-            }
+        const fields = resolveValueOrFunction(this.getExpressionOptions().fields, this.getAdaptableInternalApi().buildBaseContext());
+        if (fields && ArrayExtensions.IsNotNullOrEmpty(fields)) {
+            return fields;
         }
     }
     getAvailableFields(data) {

package/src/Api/Internal/FlashingCellInternalApi.js

@@ -36,7 +36,7 @@ export class FlashingCellInternalApi extends ApiBase {
             ? toFlashingAlert(forPrimaryKey[columnId])
             : toFlashingAlert(forPrimaryKey[FLASHING_CELL_ROW_KEY]);
         if (adaptableFlashingCell?.flashingCellDefinition &&
-            !this.getLayoutApi().internalApi.isObjectExtendedInLayout(adaptableFlashingCell.flashingCellDefinition, 'FlashingCell', this.getLayoutApi().getCurrentLayout())) {
+            !this.getLayoutApi().internalApi.isObjectInLayout(adaptableFlashingCell.flashingCellDefinition, 'FlashingCell')) {
             return;
         }
         return adaptableFlashingCell;

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

@@ -1,5 +1,5 @@
 import { Column, HeaderValueGetterParams, IRowNode } from 'ag-grid-enterprise';
-import { AdaptableColumn, AdaptableFormat, AdaptablePredicateDef, ColumnScope, FormatColumn, FormatColumnConfig, FormatColumnTarget, StringFormatterOptions } from '../../types';
+import { AdaptableColumn, AdaptableFormat, FormatColumn, FormatColumnConfig, FormatColumnTarget, StringFormatterOptions } from '../../types';
 import { ApiBase } from '../Implementation/ApiBase';
 export declare class FormatColumnInternalApi extends ApiBase {
     /**
@@ -18,12 +18,12 @@ export declare class FormatColumnInternalApi extends ApiBase {
      * Retrieves all Format Columns in Adaptable State with the `Style` property set
      * @returns format columns
      */
-    getAllFormatColumnWithStyle(config?: FormatColumnConfig): FormatColumn[];
+    getAllFormatColumnWithStyle(): FormatColumn[];
     /**
      * Retrieves all Format Columns in Adaptable State with `DisplayFormat` property set
      * @returns format columns
      */
-    getAllFormatColumnWithDisplayFormat(config?: FormatColumnConfig): FormatColumn[];
+    getAllFormatColumnWithDisplayFormat(): FormatColumn[];
     /**
      * Get all FormatColumns which are defined for this column and have a custom AdaptableStyle
      * @param column
@@ -80,11 +80,6 @@ export declare class FormatColumnInternalApi extends ApiBase {
      */
     getDateFormattedValue(value: any, node: IRowNode, abColumn: AdaptableColumn, options: AdaptableFormat['Options']): string;
     private applyCustomFormatters;
-    /**
-     * Returns all Predicates appropriate for the given Scope
-     * @param scope Scope to check
-     */
-    getFormatColumnDefsForScope(scope: ColumnScope): AdaptablePredicateDef[];
     formatColumnWithColumnGroupScopeShouldRender(formatColumn: FormatColumn, column: AdaptableColumn): boolean;
     /**
      * Checks if format column is relevant for a given cell (intersection of given AdaptableColumn and RowNode)
@@ -104,7 +99,6 @@ export declare class FormatColumnInternalApi extends ApiBase {
      * @param column
      */
     formatColumnShouldRenderInHeader(formatColumn: FormatColumn, column: AdaptableColumn): boolean;
-    private evaluatePredicate;
     private evaluateExpression;
     /**
      * Extract from the given FormatColumns the one which is the most relevant  for a given cell (intersection of given AdaptableColumn and RowNode)
@@ -121,8 +115,8 @@ export declare class FormatColumnInternalApi extends ApiBase {
      * Retrieves all Format Columns which have an Expression
      * @returns Format Columns with Expression
      */
-    getFormatColumnsWithExpression(config?: FormatColumnConfig): FormatColumn[];
-    getFormatColumnsDependentOnColumns(columnSet: Set<string>, config?: FormatColumnConfig): FormatColumn[];
+    getFormatColumnsWithExpression(): FormatColumn[];
+    getFormatColumnsDependentOnColumns(columnSet: Set<string>): FormatColumn[];
     /**
      * Retrieves the columns that need rerendering based on format column predicates.
      */

package/src/Api/Internal/FormatColumnInternalApi.js

@@ -53,14 +53,14 @@ export class FormatColumnInternalApi extends ApiBase {
         const headerTarget = 'columnHeader';
         return (this.getFormatColumnApi().getFormatColumnState()?.FormatColumns ?? []).some((formatColumn) => formatColumn?.Target === headerTarget);
     }
-    getAllFormatColumnWithStyle(config) {
+    getAllFormatColumnWithStyle() {
         return this.getFormatColumnApi()
-            .getFormatColumns(config)
+            .getFormatColumns()
             .filter((fc) => fc.Style);
     }
-    getAllFormatColumnWithDisplayFormat(config) {
+    getAllFormatColumnWithDisplayFormat() {
         return this.getFormatColumnApi()
-            .getFormatColumns(config)
+            .getFormatColumns()
             .filter((fc) => fc.DisplayFormat);
     }
     getFormatColumnsWithStyleForColumn(column, config) {
@@ -125,17 +125,12 @@ export class FormatColumnInternalApi extends ApiBase {
             return context.cellValue;
         }, customDisplayFormatterContext);
     }
-    getFormatColumnDefsForScope(scope) {
-        return this.getAdaptableApi()
-            .predicateApi.internalApi.getFormatColumnPredicateDefs(scope)
-            .filter((predicateDef) => this.getColumnScopeApi().isScopeInScope(scope, predicateDef.columnScope));
-    }
     formatColumnWithColumnGroupScopeShouldRender(formatColumn, column) {
         if (!formatColumn.ColumnGroupScope) {
             return true;
         }
         const agGridApi = this.getAdaptableApi().agGridApi;
-        const agGridColumn = this._adaptable.isInPivotMode()
+        const agGridColumn = this.getLayoutApi().isCurrentLayoutPivot()
             ? agGridApi.getPivotResultColumns().find((col) => col.getColId() === column.columnId)
             : agGridApi.getColumn(column.columnId);
         if (!agGridColumn) {
@@ -194,19 +189,7 @@ export class FormatColumnInternalApi extends ApiBase {
         if (!formatColumn.Rule) {
             return true;
         }
-        if (formatColumn.Rule.Predicates && formatColumn.Rule?.Predicates?.length) {
-            const predicateDefHandlerContext = {
-                value: cellValue,
-                oldValue: null,
-                rawValue: cellValue,
-                displayValue: cellValue,
-                node: rowNode,
-                column: column,
-                ...this.getAdaptableInternalApi().buildBaseContext(),
-            };
-            return this.evaluatePredicate(formatColumn, predicateDefHandlerContext);
-        }
-        else if (formatColumn.Rule.BooleanExpression) {
+        if (StringExtensions.IsNotNullOrEmpty(formatColumn.Rule)) {
             return this.evaluateExpression(formatColumn, rowNode, column, pivotResultColumn);
         }
         return false;
@@ -221,16 +204,13 @@ export class FormatColumnInternalApi extends ApiBase {
         }
         return true;
     }
-    evaluatePredicate(formatColumn, predicateDefHandlerContext) {
-        return this.getPredicateApi().handleColumnPredicates(formatColumn.Rule?.Predicates, predicateDefHandlerContext, false);
-    }
     evaluateExpression(formatColumn, node, columnScope, pivotResultColumn) {
-        const isValidExpression = this.getExpressionApi().isValidBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, `Invalid format column rule '${formatColumn.Rule.BooleanExpression}'`);
+        const isValidExpression = this.getExpressionApi().isValidScalarExpression(formatColumn.Rule, ModuleConstants.FormatColumnModuleId, `Invalid format column rule '${formatColumn.Rule}'`);
         try {
             return (isValidExpression &&
                 this.getAdaptableApi()
                     .internalApi.getQueryLanguageService()
-                    .evaluateBooleanExpression(formatColumn.Rule.BooleanExpression, ModuleConstants.FormatColumnModuleId, node, { pivotResultColumn, columnScope: columnScope?.columnId }));
+                    .evaluateBooleanExpression(formatColumn.Rule, ModuleConstants.FormatColumnModuleId, node, { pivotResultColumn, columnScope: columnScope?.columnId }));
         }
         catch (error) {
             errorOnce(error.message);
@@ -240,15 +220,17 @@ export class FormatColumnInternalApi extends ApiBase {
     getMostRelevantFormatColumnForColumn(formatColumns, column, params) {
         return formatColumns.find((formatColumn) => this.formatColumnShouldRenderInCell(formatColumn, column, params.node, params.value));
     }
-    getFormatColumnsWithExpression(config) {
+    getFormatColumnsWithExpression() {
         return this.getFormatColumnApi()
-            .getFormatColumns(config)
-            .filter((fc) => !!fc.Rule?.BooleanExpression);
+            .getFormatColumns()
+            .filter((fc) => StringExtensions.IsNotNullOrEmpty(fc.Rule));
     }
-    getFormatColumnsDependentOnColumns(columnSet, config) {
+    getFormatColumnsDependentOnColumns(columnSet) {
         return this.getFormatColumnApi()
-            .getFormatColumns(config)
-            .filter((fc) => fc.Rule?.Predicates?.some((p) => columnSet.has(p.ColumnId)));
+            .getFormatColumns()
+            .filter((fc) => this.getExpressionApi()
+            .getColumnsFromExpression(fc.Rule)
+            .some((columnId) => columnSet.has(columnId)));
     }
     getFormatColumnColumnsDependentOnColumnChange(column) {
         const impactedColumnIds = new Set();

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

@@ -14,5 +14,13 @@ export declare class FreeTextColumnInternalApi extends ApiBase {
      */
     getFreeTextColumnModuleReferences(freeTextColumn: FreeTextColumn): string[];
     getColDefsForFreeTextColumns(): ColDef<any, any>[];
+    /**
+     * Module references that still block delete after Layout auto-remove is considered.
+     */
+    getBlockingModuleReferencesForDelete(freeTextColumn: FreeTextColumn): string[];
+    /**
+     * Returns false (and shows a notification) when the Free Text Column cannot be deleted.
+     * Safe to call before showing a delete confirmation.
+     */
     validateDeletedFreeTextColumn(freeTextColumn: FreeTextColumn): boolean;
 }

package/src/Api/Internal/FreeTextColumnInternalApi.js

@@ -4,6 +4,8 @@ import { AdaptableNumberEditor } from '../../agGrid/editors/AdaptableNumberEdito
 import { AdaptableDateEditor } from '../../agGrid/editors/AdaptableDateEditor';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import { FREE_TEXT_COLUMN_TYPE, } from '../../AdaptableState/Common/AdaptableColumn';
+import { LayoutFriendlyName } from '../../Utilities/Constants/ModuleConstants';
+import { getCellDataTypeForSpecialColumnSettings } from '../../agGrid/AgGridCellDataTypeHelper';
 export class FreeTextColumnInternalApi extends ApiBase {
     handleFreeTextColumnDataChange(cellDataChangedInfo) {
         let freeTextColumn = this.getFreeTextColumnApi()
@@ -72,7 +74,7 @@ export class FreeTextColumnInternalApi extends ApiBase {
                 valueSetter: (params) => {
                     return (params.data[freeTextColumn.ColumnId] = params.newValue);
                 },
-                cellDataType: freeTextColumnSettings.DataType,
+                cellDataType: getCellDataTypeForSpecialColumnSettings(freeTextColumnSettings),
                 valueGetter: (params) => this.getFreeTextColumnApi().getFreeTextColumnValueForRowNode(freeTextColumn, params.node),
             };
             if (freeTextColumnSettings.HeaderToolTip) {
@@ -82,8 +84,15 @@ export class FreeTextColumnInternalApi extends ApiBase {
             return newColDef;
         });
     }
+    getBlockingModuleReferencesForDelete(freeTextColumn) {
+        const references = this.getFreeTextColumnModuleReferences(freeTextColumn);
+        if (this.getLayoutOptions()?.autoRemoveDeletedColumnsFromLayouts !== false) {
+            return references.filter((ref) => ref !== LayoutFriendlyName);
+        }
+        return references;
+    }
     validateDeletedFreeTextColumn(freeTextColumn) {
-        const freeTextColumnReferences = this.getFreeTextColumnModuleReferences(freeTextColumn);
+        const freeTextColumnReferences = this.getBlockingModuleReferencesForDelete(freeTextColumn);
         if (freeTextColumnReferences.length) {
             const alert = {
                 alertType: 'generic',

package/src/Api/Internal/GridInternalApi.js

@@ -4,7 +4,8 @@ import { getDateComparatorForGridCell, getGenericComparatorForGridCell, getNumer
 import { multisort } from '@infinite-table/infinite-react';
 import { convertAdaptableStyleToCSS } from '../../Utilities/Helpers/StyleHelper';
 import { getRuleAlertProperties } from '../../Utilities/Helpers/Scheduling/ScheduledAlertHelper';
-import UIHelper from '../../View/UIHelper';
+import { invokeOptionCallback } from '../../Utilities/Helpers/ValueOrFunctionHelper';
+import UIHelper from '../../Utilities/Helpers/UIHelper';
 import { ApiBase } from '../Implementation/ApiBase';
 export class GridInternalApi extends ApiBase {
     getDistinctDisplayValuesForColumnOld(columnId) {
@@ -215,29 +216,17 @@ export class GridInternalApi extends ApiBase {
         return typeof this.getEditOptions()?.isCellEditable === 'function';
     }
     isCellEditableAccordingToEditOptions(gridCell, defaultColDefinitionEditableValue) {
-        const cellEditable = this.getEditOptions()?.isCellEditable;
-        if (cellEditable) {
-            const cellEditableContext = {
-                ...this.getAdaptableInternalApi().buildBaseContext(),
-                gridCell,
-                defaultColDefEditableValue: defaultColDefinitionEditableValue,
-            };
-            return cellEditable(cellEditableContext);
-        }
-        return undefined;
+        return invokeOptionCallback(this.getEditOptions()?.isCellEditable, {
+            ...this.getAdaptableInternalApi().buildBaseContext(),
+            gridCell,
+            defaultColDefEditableValue: defaultColDefinitionEditableValue,
+        }, undefined);
     }
     isRowFilterable(rowNode) {
-        const isRowFilterable = this.getOptionsApi().getFilterOptions().isRowFilterable;
-        if (typeof isRowFilterable === 'function') {
-            const rowFilterableContext = {
-                ...this.getAdaptableApi().internalApi.buildBaseContext(),
-                rowNode,
-                data: rowNode.data,
-            };
-            if (!isRowFilterable(rowFilterableContext)) {
-                return false;
-            }
-        }
-        return true;
+        return invokeOptionCallback(this.getOptionsApi().getFilterOptions().isRowFilterable, {
+            ...this.getAdaptableApi().internalApi.buildBaseContext(),
+            rowNode,
+            data: rowNode.data,
+        }, true);
     }
 }

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

@@ -1,6 +1,7 @@
+import { PivotLayoutCreationDefaultProperties, TableLayoutCreationDefaultProperties } from '../../AdaptableOptions/LayoutOptions';
 import { Layout, LayoutBase } from '../../AdaptableState/LayoutState';
 import { ApiBase } from '../Implementation/ApiBase';
-import { LayoutExtensionObject, LayoutExtensionModule } from '../../types';
+import { LayoutExtension, LayoutExtensionObject, LayoutExtensionModule } from '../../types';
 export declare class LayoutInternalApi extends ApiBase {
     /**
      * Compares 2 Layouts for equality
@@ -22,8 +23,22 @@ export declare class LayoutInternalApi extends ApiBase {
         ColumnSorts: boolean;
         RowSummaries: boolean;
     };
+    getLayoutExtensions(): LayoutExtension[] | undefined;
+    /**
+     * Whether any object is extended into any Layout
+     */
     hasLayoutSpecificObjects(): boolean;
-    isObjectExtendedInLayout(object: LayoutExtensionObject, module: LayoutExtensionModule, layout: Layout): boolean;
+    /**
+     * Whether the object applies in the Layout (defaults to Current Layout): true if it is global or extended into that Layout
+     */
+    isObjectInLayout(object: LayoutExtensionObject, module: LayoutExtensionModule, layoutName?: string): boolean;
+    /**
+     * Whether the object is not extended into any Layout (and so applies in all of them)
+     */
+    isObjectGlobal(object: LayoutExtensionObject, module: LayoutExtensionModule): boolean;
+    getLayoutsForObject(object: LayoutExtensionObject, module: LayoutExtensionModule): string[];
+    getAllLayoutExtensionObjects<T extends LayoutExtensionObject = LayoutExtensionObject>(module: LayoutExtensionModule): T[];
+    isLayoutExtensionsUIEnabled(): boolean;
     showLayoutNonExtendedObjects(): boolean;
     isLayoutGrouped(layout?: Layout): boolean;
     setupRowSummaries(): void;
@@ -32,8 +47,19 @@ export declare class LayoutInternalApi extends ApiBase {
     buildInitialLayout(providedLayout: Partial<Layout> & {
         Name: string;
     }, type?: 'table' | 'pivot'): Layout;
-    private getLayoutCreationDefaultProperties;
+    /**
+     * Builds an auto-created Layout: empty + creation defaults + ColDef snapshot (snapshot wins).
+     */
+    buildAutoCreatedLayout(derived: Partial<Layout> & {
+        Name: string;
+    }): Layout;
+    getLayoutCreationDefaultProperties(layoutType: 'table' | 'pivot'): TableLayoutCreationDefaultProperties | PivotLayoutCreationDefaultProperties;
     cloneLayout(layoutToClone: Layout): Omit<Layout, 'Name'>;
     getCurrentLayout_perfOptimized(): Layout | null;
     getCurrentLayoutRowGroupDisplayType(): LayoutBase['RowGroupDisplayType'];
+    /**
+     * Removes a Column Id from every Layout (used when deleting Calculated /
+     * Free Text Columns so Layout membership does not block delete).
+     */
+    removeColumnIdFromAllLayouts(columnId: string): void;
 }