@adaptabletools/adaptable 23.1.0 → 24.0.0-canary.0

package/src/Api/Implementation/CalendarApiImpl.js

@@ -1,55 +1,40 @@
 import { ApiBase } from './ApiBase';
 import { isToday, isTomorrow, isYesterday } from 'date-fns';
+import { resolveValueOrFunction } from '../../Utilities/Helpers/ValueOrFunctionHelper';
+import { buildHolidayDayKeys, findNextWorkingDay, findPreviousWorkingDay, isConfiguredHoliday, isWeekendDay, isWorkingCalendarDay, normalizeWeekendDays, } from '../../Utilities/Helpers/CalendarHelper';
 export class CalendarApiImpl extends ApiBase {
-    getNextWorkingDay() {
-        let counterDate = new Date();
-        let isWorkingDay = false;
-        while (!isWorkingDay) {
-            counterDate.setDate(counterDate.getDate() + 1);
-            isWorkingDay = this.isWorkingDay(counterDate);
-        }
-        return counterDate;
-    }
-    getPreviousWorkingDay() {
-        let counterDate = new Date();
-        let isWorkingDay = false;
-        while (!isWorkingDay) {
-            counterDate.setDate(counterDate.getDate() - 1);
-            isWorkingDay = this.isWorkingDay(counterDate);
-        }
-        return counterDate;
+    getNextWorkingDay(from = new Date()) {
+        const { weekendDays, holidayDayKeys } = this.getWorkingCalendarContext();
+        return findNextWorkingDay(from, weekendDays, holidayDayKeys);
+    }
+    getPreviousWorkingDay(from = new Date()) {
+        const { weekendDays, holidayDayKeys } = this.getWorkingCalendarContext();
+        return findPreviousWorkingDay(from, weekendDays, holidayDayKeys);
     }
     isWorkingDay(dateToCheck) {
-        const holidays = this.getHolidays();
-        if (!holidays) {
-            return dateToCheck.getDay() != 0 && dateToCheck.getDay() != 6;
-        }
-        for (let holiday of holidays) {
-            if (holiday.setHours(0, 0, 0, 0) == dateToCheck.setHours(0, 0, 0, 0)) {
-                return false;
-            }
-        }
-        return dateToCheck.getDay() != 0 && dateToCheck.getDay() != 6;
+        const { weekendDays, holidayDayKeys } = this.getWorkingCalendarContext();
+        return isWorkingCalendarDay(dateToCheck, weekendDays, holidayDayKeys);
     }
     isHoliday(dateToCheck) {
-        return !this.isWorkingDay(dateToCheck);
+        const { holidayDayKeys } = this.getWorkingCalendarContext();
+        return isConfiguredHoliday(dateToCheck, holidayDayKeys);
+    }
+    isWeekend(dateToCheck) {
+        const { weekendDays } = this.getWorkingCalendarContext();
+        return isWeekendDay(dateToCheck, weekendDays);
+    }
+    getWeekStartsOn() {
+        const weekStartsOn = this.getCalendarOptions().weekStartsOn;
+        if (Number.isInteger(weekStartsOn) && weekStartsOn >= 0 && weekStartsOn <= 6) {
+            return weekStartsOn;
+        }
+        return 0;
     }
     isSameDay(firstDateToCheck, secondDateToCheck) {
         return (firstDateToCheck.getFullYear() === secondDateToCheck.getFullYear() &&
             firstDateToCheck.getMonth() === secondDateToCheck.getMonth() &&
             firstDateToCheck.getDate() === secondDateToCheck.getDate());
     }
-    getHolidays() {
-        const holidays = this.getCalendarOptions().holidays;
-        if (holidays) {
-            if (typeof holidays === 'function') {
-                return holidays(this.getAdaptableInternalApi().buildBaseContext());
-            }
-            else {
-                return holidays;
-            }
-        }
-    }
     isToday(dateToCheck) {
         return isToday(dateToCheck);
     }
@@ -59,4 +44,14 @@ export class CalendarApiImpl extends ApiBase {
     isTomorrow(dateToCheck) {
         return isTomorrow(dateToCheck);
     }
+    getWorkingCalendarContext() {
+        const options = this.getCalendarOptions();
+        return {
+            weekendDays: normalizeWeekendDays(options.weekendDays),
+            holidayDayKeys: buildHolidayDayKeys(this.getHolidays()),
+        };
+    }
+    getHolidays() {
+        return resolveValueOrFunction(this.getCalendarOptions().holidays, this.getAdaptableInternalApi().buildBaseContext());
+    }
 }

package/src/Api/Implementation/CellSummaryApiImpl.js

@@ -1,10 +1,9 @@
 import { ApiBase } from './ApiBase';
-import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
 import * as InternalRedux from '../../Redux/ActionsReducers/InternalRedux';
 import { SummaryOperation } from '../../AdaptableState/Common/Enums';
 export class CellSummaryApiImpl extends ApiBase {
     openCellSummaryPopupSettingsPanel() {
-        this.showModulePopup(ModuleConstants.CellSummaryModuleId);
+        this.getSettingsPanelApi().openSettingsPanel('CellSummary');
     }
     getCurrentCellSummaryOperation() {
         return this.getAdaptableState().Internal.CellSummary.CellSummaryOperation;

package/src/Api/Implementation/ColumnApiImpl.d.ts

@@ -5,6 +5,7 @@ import { ColumnApi } from '../ColumnApi';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { ColumnInternalApi } from '../Internal/ColumnInternalApi';
 import { ColDef, ColGroupDef, Column, GridApi } from 'ag-grid-enterprise';
+import { type AvailableCellDataTypeInfo } from '../../agGrid/AgGridCellDataTypeHelper';
 export declare function isAutoRowGroupColumn(columnId: string): boolean;
 export declare function isAutoRowGroupColumnForSingle(columnId: string): boolean;
 export declare function isAutoRowGroupColumnForMulti(columnId: string): boolean;
@@ -17,8 +18,19 @@ export declare function isPivotResultColumn(columnId: string): boolean;
 export declare function isPivotGrandTotal(columnId: string): boolean;
 export declare class ColumnApiImpl extends ApiBase implements ColumnApi {
     internalApi: ColumnInternalApi;
+    /**
+     * `columnId → column` index over the current column model. The reducer
+     * replaces the `Columns` array on every column-model change, so the index
+     * is keyed by array identity: a stale array means a stale index, no
+     * explicit invalidation needed. `getColumnWithColumnId` is on the per-row
+     * hot path of every AQL `[col]` (2–3 lookups per reference); a linear
+     * scan over a wide grid dominated evaluation.
+     */
+    private columnIndexSource;
+    private columnIndex;
     constructor(_adaptable: IAdaptable);
     getColumns(): AdaptableColumn[];
+    private getColumnIndex;
     getUIAvailableColumns(): AdaptableColumn[];
     getSpecialColumns(): AdaptableColumn[];
     getNonSpecialColumns(): AdaptableColumn[];
@@ -52,6 +64,8 @@ export declare class ColumnApiImpl extends ApiBase implements ColumnApi {
     hasNumericArrayDataType(columnId: string): boolean;
     hasDateDataType(columnId: string): boolean;
     getColumnDataTypeForColumnId(columnId: string): AdaptableColumnDataType | undefined;
+    getAvailableCellDataTypes(): AvailableCellDataTypeInfo[];
+    getAdaptableDataTypeForCellDataType(cellDataType: string): AdaptableColumnDataType | undefined;
     getFriendlyNameForColumnId(columnId: string, layout?: Layout): string;
     doesColumnExist(columnId: string): boolean;
     getFriendlyNamesForColumnIds(columnIds: string[]): string[];
@@ -83,7 +97,7 @@ export declare class ColumnApiImpl extends ApiBase implements ColumnApi {
     private logMissingColumnWarning;
     getPrimaryKeyColumn(): AdaptableColumn<any>;
     getDefaultAggFunc(columnId: string): string;
-    openColumnInfoSettingsPanel(): void;
+    openColumnInfoSettingsPanel(columnId?: string): void;
     getColumnTypes(): import("../../AdaptableState/Common/Types").TypeHint<string, import("../../types").AdaptableColumnTypeName>[];
     getColumnsByColumnType(columnType: string): AdaptableColumn[];
     getRowGroupedColumns(): AdaptableColumn[];

package/src/Api/Implementation/ColumnApiImpl.js

@@ -5,8 +5,10 @@ import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
 import { ColumnInternalApi } from '../Internal/ColumnInternalApi';
 import { AUTO_GROUP_COLUMN_ID__MULTI_PREFIX, AUTO_GROUP_COLUMN_ID__SINGLE, } from '../../layout-manager/src/normalizeLayoutModel';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
+import { resolveValueOrFunction } from '../../Utilities/Helpers/ValueOrFunctionHelper';
 import { isPivotColumnTotal } from '../../layout-manager/src/isPivotColumnTotal';
-import { isPivotLayout } from './LayoutHelpers';
+import { isPivotLayout } from '../../Utilities/Helpers/Layouts/LayoutHelper';
+import { buildCustomCellDataTypes, getAdaptableDataTypeForCellDataType, } from '../../agGrid/AgGridCellDataTypeHelper';
 const ROW_GROUP_COLUMN_DEFAULTS = {
     columnId: '',
     isTreeColumn: false,
@@ -46,7 +48,7 @@ export function isAutoRowGroupColumnForSingle(columnId) {
     return columnId === AUTO_GROUP_COLUMN_ID__SINGLE;
 }
 export function isAutoRowGroupColumnForMulti(columnId) {
-    return columnId.startsWith(AUTO_GROUP_COLUMN_ID__MULTI_PREFIX);
+    return columnId != null && columnId.startsWith(AUTO_GROUP_COLUMN_ID__MULTI_PREFIX);
 }
 export function generateAutoRowGroupSingleColumn() {
     return {
@@ -111,6 +113,8 @@ export function isPivotGrandTotal(columnId) {
 }
 export class ColumnApiImpl extends ApiBase {
     internalApi;
+    columnIndexSource;
+    columnIndex;
     constructor(_adaptable) {
         super(_adaptable);
         this.internalApi = new ColumnInternalApi(_adaptable);
@@ -118,6 +122,19 @@ export class ColumnApiImpl extends ApiBase {
     getColumns() {
         return this.getGridApi().getInternalState().Columns ?? [];
     }
+    getColumnIndex(columns) {
+        if (this.columnIndexSource !== columns || !this.columnIndex) {
+            const index = new Map();
+            for (const column of columns) {
+                if (!index.has(column.columnId)) {
+                    index.set(column.columnId, column);
+                }
+            }
+            this.columnIndexSource = columns;
+            this.columnIndex = index;
+        }
+        return this.columnIndex;
+    }
     getUIAvailableColumns() {
         return this.getColumns().filter((c) => !c.isUIHiddenColumn &&
             !c.isGeneratedSelectionColumn &&
@@ -228,10 +245,13 @@ export class ColumnApiImpl extends ApiBase {
         if (columnId == undefined) {
             return;
         }
-        if (ArrayExtensions.IsNullOrEmpty(this.getColumns())) {
+        const columns = this.getColumns();
+        if (ArrayExtensions.IsNullOrEmpty(columns)) {
             return;
         }
-        const foundColumn = this.getColumns().find((c) => c.columnId == columnId);
+        const index = this.getColumnIndex(columns);
+        const foundColumn = index.get(columnId) ??
+            (typeof columnId !== 'string' ? index.get(String(columnId)) : undefined);
         if (foundColumn) {
             return foundColumn;
         }
@@ -287,6 +307,18 @@ export class ColumnApiImpl extends ApiBase {
         }
         return column.dataType;
     }
+    getAvailableCellDataTypes() {
+        const definitions = this.getAgGridApi()?.getGridOption('dataTypeDefinitions');
+        const userDefinitions = this._adaptable.agGridAdapter.getUserGridOptionsProperty('dataTypeDefinitions');
+        return buildCustomCellDataTypes(definitions, userDefinitions);
+    }
+    getAdaptableDataTypeForCellDataType(cellDataType) {
+        if (!cellDataType) {
+            return undefined;
+        }
+        const definitions = this.getAgGridApi()?.getGridOption('dataTypeDefinitions');
+        return getAdaptableDataTypeForCellDataType(cellDataType, definitions);
+    }
     getFriendlyNameForColumnId(columnId, layout) {
         if (this.isPivotResultColumn(columnId)) {
             return getFriendlyNameForPivotResultColumn(columnId, this.getAgGridApi());
@@ -486,22 +518,17 @@ export class ColumnApiImpl extends ApiBase {
         const agColumn = this.internalApi.getAgGridColumnForAdaptableColumn(columnId)?.getColDef?.();
         return agColumn?.defaultAggFunc ?? availableAggregationFunctions[0];
     }
-    openColumnInfoSettingsPanel() {
-        this.showModulePopup(ModuleConstants.ColumnInfoModuleId);
+    openColumnInfoSettingsPanel(columnId) {
+        const column = columnId ? this.getColumnWithColumnId(columnId) : undefined;
+        this.showModulePopup(ModuleConstants.ColumnInfoModuleId, column ? { source: 'Api', column } : undefined);
     }
     getColumnTypes() {
-        const columnTypes = this.getOptions().columnOptions.columnTypes;
-        if (typeof columnTypes === 'function') {
-            const types = this.internalApi.getAllAgGridColumnTypes();
-            const columnTypesContext = {
-                types,
-                ...this.getAdaptableInternalApi().buildBaseContext(),
-            };
-            return columnTypes(columnTypesContext);
-        }
-        else {
-            return columnTypes;
-        }
+        const types = this.internalApi.getAllAgGridColumnTypes();
+        const columnTypesContext = {
+            types,
+            ...this.getAdaptableInternalApi().buildBaseContext(),
+        };
+        return resolveValueOrFunction(this.getOptions().columnOptions.columnTypes, columnTypesContext);
     }
     getColumnsByColumnType(columnType) {
         const abColumns = this.getColumns();

package/src/Api/Implementation/ColumnFilterApiImpl.d.ts

@@ -1,7 +1,5 @@
 import { ApiBase } from './ApiBase';
-import { AdaptablePredicateDef, ColumnFilterDef } from '../../AdaptableState/Common/AdaptablePredicate';
-import { AdaptableColumn } from '../../AdaptableState/Common/AdaptableColumn';
-import { ColumnFilter, ColumnFilterPredicate, InFilterValueInfo, InFilterValueResult } from '../../types';
+import { ColumnFilter, InFilterValueResult } from '../../types';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { ColumnFilterInternalApi } from '../Internal/ColumnFilterInternalApi';
 import { ColumnFilterApi } from '../ColumnFilterApi';
@@ -9,15 +7,12 @@ export declare class ColumnFilterApiImpl extends ApiBase implements ColumnFilter
     internalApi: ColumnFilterInternalApi;
     constructor(_adaptable: IAdaptable);
     hideColumnFilterMenu(): void;
-    getFilterPredicateDefsForColumn(column: AdaptableColumn): AdaptablePredicateDef[];
-    getFilterPredicateDefsForColumnId(columnId: string): AdaptablePredicateDef[] | undefined;
     showQuickFilterBar(): void;
     hideQuickFilterBar(): void;
     isQuickFilterAvailable(): boolean;
     isQuickFilterVisible(): boolean;
     getColumnFilters(): ColumnFilter[];
     getActiveColumnFilters(): ColumnFilter[];
-    getColumnFilterDefs(): ColumnFilterDef[];
     getColumnFiltersForLayout(layoutName: string): ColumnFilter[];
     setColumnFilters(columnFilters: ColumnFilter[]): ColumnFilter[] | null;
     clearColumnFilter(columnFilter: ColumnFilter): void;
@@ -32,19 +27,15 @@ export declare class ColumnFilterApiImpl extends ApiBase implements ColumnFilter
     isColumnFilterActiveForColumn(columnId: string): boolean;
     /**
      * Checks if a filter is applied. It is applied when:
-     * - has no inputs
-     * - has inputs and inputs have values
+     * - has an Expression set (non-empty)
      *
      * @param filter
      */
     isColumnFilterActive(filter: ColumnFilter): boolean;
-    setColumnFilterForColumn(columnId: string, columnFilterPredicate: ColumnFilterPredicate): void;
-    clearAndSetColumnFilterForColumn(columnId: string, columnFilterPredicate: ColumnFilterPredicate): void;
     suspendColumnFilter(columnFilter: ColumnFilter): void;
     unSuspendColumnFilter(columnFilter: ColumnFilter): void;
     suspendAllColumnFilters(): void;
     unSuspendAllColumnFilters(): void;
-    addBlanksToInFilterValues(columnDistinctValues: InFilterValueInfo[]): InFilterValueInfo[];
     refreshFilterValues(columnId: string): Promise<InFilterValueResult>;
     refreshAllFilterValues(): Promise<Record<string, InFilterValueResult>>;
     resetFilterValues(columnId: string): void;

package/src/Api/Implementation/ColumnFilterApiImpl.js

@@ -1,7 +1,6 @@
 import * as InternalRedux from '../../Redux/ActionsReducers/InternalRedux';
 import * as LayoutRedux from '../../Redux/ActionsReducers/LayoutRedux';
 import { ApiBase } from './ApiBase';
-import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import { ColumnFilterInternalApi } from '../Internal/ColumnFilterInternalApi';
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 export class ColumnFilterApiImpl extends ApiBase {
@@ -13,21 +12,6 @@ export class ColumnFilterApiImpl extends ApiBase {
     hideColumnFilterMenu() {
         this.getAgGridApi().hideColumnFilter();
     }
-    getFilterPredicateDefsForColumn(column) {
-        if (!column) {
-            return [];
-        }
-        const scope = {
-            ColumnIds: [column.columnId],
-        };
-        return this.getAdaptableApi()
-            .predicateApi.internalApi.getFilterPredicateDefs(scope)
-            .filter((predicate) => this.getColumnScopeApi().isColumnInScope(column, predicate.columnScope));
-    }
-    getFilterPredicateDefsForColumnId(columnId) {
-        const column = this.getColumnApi().getColumnWithColumnId(columnId);
-        return column ? this.getFilterPredicateDefsForColumn(column) : undefined;
-    }
     showQuickFilterBar() {
         this.dispatchAction(InternalRedux.QuickFilterBarShow());
     }
@@ -48,41 +32,30 @@ export class ColumnFilterApiImpl extends ApiBase {
     getActiveColumnFilters() {
         return this.getColumnFilters().filter((columnFilter) => !columnFilter.IsSuspended);
     }
-    getColumnFilterDefs() {
-        const filters = this.getColumnFilters();
-        return filters.map((columnFilter) => {
-            const column = this.getColumnApi().getColumnWithColumnId(columnFilter.ColumnId);
-            const predicates = columnFilter.Predicates.map((predicate) => this.getPredicateApi().getPredicateDefById(predicate.PredicateId));
-            return {
-                predicates,
-                dataType: column?.dataType,
-                columnFilter: columnFilter,
-            };
-        });
-    }
     getColumnFiltersForLayout(layoutName) {
         const layout = this.getLayoutApi().getLayoutByName(layoutName);
         return layout.ColumnFilters ?? [];
     }
     setColumnFilters(columnFilters) {
         columnFilters.forEach((columnFilter) => {
-            if (!columnFilter.Predicates || columnFilter.Predicates.length == 0) {
-                this.logWarn('Column Filter has no Predicate', columnFilter);
+            const hasExpression = StringExtensions.IsNotNullOrEmpty(columnFilter.Expression);
+            const hasPreferredFilter = StringExtensions.IsNotNullOrEmpty(columnFilter.PreferredFilter);
+            if (!hasExpression && !hasPreferredFilter) {
+                this.logWarn('Column Filter has neither Expression nor PreferredFilter', columnFilter);
+                return;
+            }
+            if (hasExpression) {
+                delete columnFilter.PreferredFilter;
+            }
+            else {
+                delete columnFilter.Expression;
+            }
+            this.addUidToAdaptableObject(columnFilter);
+            if (this.getColumnFilters().find((cf) => cf.ColumnId == columnFilter.ColumnId)) {
+                this.dispatchAction(LayoutRedux.LayoutColumnFilterSet(columnFilter));
             }
             else {
-                const isValidPredicate = this.getPredicateApi().isEveryPredicateValid(columnFilter.Predicates);
-                if (!isValidPredicate) {
-                    this.logWarn('Column Filter Predicate is not valid', columnFilter);
-                }
-                else {
-                    this.addUidToAdaptableObject(columnFilter);
-                    if (this.getColumnFilters().find((cf) => cf.ColumnId == columnFilter.ColumnId)) {
-                        this.dispatchAction(LayoutRedux.LayoutColumnFilterSet(columnFilter));
-                    }
-                    else {
-                        this.dispatchAction(LayoutRedux.LayoutColumnFilterAdd(columnFilter));
-                    }
-                }
+                this.dispatchAction(LayoutRedux.LayoutColumnFilterAdd(columnFilter));
             }
         });
         return columnFilters
@@ -120,10 +93,13 @@ export class ColumnFilterApiImpl extends ApiBase {
             return 'No Column Filter';
         }
         const friendlyName = this.getColumnApi().getFriendlyNameForColumnId(columnFilter.ColumnId);
-        return ('[' +
-            friendlyName +
-            '] ' +
-            this.getPredicateApi().predicatesToString(columnFilter.Predicates, columnFilter.PredicatesOperator));
+        if (StringExtensions.IsNotNullOrEmpty(columnFilter.Expression)) {
+            return '[' + friendlyName + '] ' + columnFilter.Expression;
+        }
+        if (StringExtensions.IsNotNullOrEmpty(columnFilter.PreferredFilter)) {
+            return '[' + friendlyName + '] ' + columnFilter.PreferredFilter;
+        }
+        return '[' + friendlyName + ']';
     }
     columnFiltersToString(columnFilters) {
         return columnFilters.map((cf) => this.columnFilterToString(cf)).join(', ');
@@ -136,41 +112,13 @@ export class ColumnFilterApiImpl extends ApiBase {
         return columnFilter ? this.isColumnFilterActive(columnFilter) : false;
     }
     isColumnFilterActive(filter) {
-        if (!filter || !filter.Predicates?.length) {
+        if (!filter) {
             return false;
         }
         if (filter.IsSuspended) {
             return false;
         }
-        return filter.Predicates.some((predicate) => {
-            const predicateDef = this.getPredicateApi().getPredicateDefById(predicate.PredicateId);
-            if (ArrayExtensions.IsNull(predicateDef.inputs) &&
-                !this.getPredicateApi().internalApi.IsInOrNotInPredicate(predicate)) {
-                return true;
-            }
-            const inputs = predicate.Inputs || [];
-            if (ArrayExtensions.IsEmpty(inputs)) {
-                return false;
-            }
-            const allInputsHaveValues = inputs.every((value) => {
-                return value !== undefined && value !== null && value !== '';
-            });
-            return allInputsHaveValues;
-        });
-    }
-    setColumnFilterForColumn(columnId, columnFilterPredicate) {
-        const columnFilter = {
-            ColumnId: columnId,
-            Predicates: [columnFilterPredicate],
-        };
-        this.setColumnFilters([columnFilter]);
-    }
-    clearAndSetColumnFilterForColumn(columnId, columnFilterPredicate) {
-        const columnFilter = {
-            ColumnId: columnId,
-            Predicates: [columnFilterPredicate],
-        };
-        this.setColumnFilters([columnFilter]);
+        return StringExtensions.IsNotNullOrEmpty(filter.Expression);
     }
     suspendColumnFilter(columnFilter) {
         this.dispatchAction(LayoutRedux.LayoutColumnFilterSuspend(columnFilter));
@@ -184,18 +132,6 @@ export class ColumnFilterApiImpl extends ApiBase {
     unSuspendAllColumnFilters() {
         this.dispatchAction(LayoutRedux.LayoutColumnFilterUnSuspendAll());
     }
-    addBlanksToInFilterValues(columnDistinctValues) {
-        if (columnDistinctValues.some((item) => StringExtensions.IsNullOrEmpty(item.value))) {
-            return [
-                {
-                    label: 'Blanks',
-                    value: 'Blanks',
-                },
-                ...columnDistinctValues,
-            ];
-        }
-        return columnDistinctValues;
-    }
     async refreshFilterValues(columnId) {
         const columnFilterHandler = this.getAgGridApi().getColumnFilterHandler(columnId);
         if (!columnFilterHandler ||

package/src/Api/Implementation/ColumnScopeApiImpl.d.ts

@@ -27,6 +27,7 @@ export declare class ColumnScopeApiImpl extends ApiBase implements ColumnScopeAp
     isColumnInNumericScope(column: AdaptableColumn, scope: ColumnScope): boolean;
     isColumnInTextScope(column: AdaptableColumn, scope: ColumnScope): boolean;
     isColumnInDateScope(column: AdaptableColumn, scope: ColumnScope): boolean;
+    private isColumnInDataTypeScope;
     isScopeInScope(a: ColumnScope, b: ColumnScope): boolean;
     createCellColorRangesForScope(scope: ColumnScope): CellColorRange[];
     getAnyColumnIdForScope(scope: ColumnScope): string | undefined;

package/src/Api/Implementation/ColumnScopeApiImpl.js

@@ -1,6 +1,6 @@
 import { ApiBase } from './ApiBase';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
-import { getGraySwatchColor } from '../../View/UIHelper';
+import { getGraySwatchColor } from '../../Utilities/Helpers/UIHelper';
 export class ColumnScopeApiImpl extends ApiBase {
     isColumnInScope(column, scope) {
         if (!column) {
@@ -167,45 +167,16 @@ export class ColumnScopeApiImpl extends ApiBase {
         return undefined;
     }
     isColumnInNumericScope(column, scope) {
-        if (column == null || column == undefined || column.dataType !== 'number') {
-            return false;
-        }
-        if (scope == undefined) {
-            return false;
-        }
-        if ('ColumnIds' in scope && scope.ColumnIds.includes(column.columnId)) {
-            return true;
-        }
-        if ('DataTypes' in scope && scope.DataTypes.includes('number')) {
-            return true;
-        }
-        if ('ColumnTypes' in scope &&
-            scope.ColumnTypes?.some?.((scopeColumnType) => column.columnTypes?.includes?.(scopeColumnType))) {
-            return true;
-        }
-        return false;
+        return this.isColumnInDataTypeScope(column, scope, 'number');
     }
     isColumnInTextScope(column, scope) {
-        if (column == null || column == undefined || column.dataType !== 'text') {
-            return false;
-        }
-        if (scope == undefined) {
-            return false;
-        }
-        if ('ColumnIds' in scope && scope.ColumnIds.includes(column.columnId)) {
-            return true;
-        }
-        if ('DataTypes' in scope && scope.DataTypes.includes('text')) {
-            return true;
-        }
-        if ('ColumnTypes' in scope &&
-            scope.ColumnTypes?.some?.((scopeColumnType) => column.columnTypes?.includes?.(scopeColumnType))) {
-            return true;
-        }
-        return false;
+        return this.isColumnInDataTypeScope(column, scope, 'text');
     }
     isColumnInDateScope(column, scope) {
-        if (column == null || column == undefined || column.dataType !== 'date') {
+        return this.isColumnInDataTypeScope(column, scope, 'date');
+    }
+    isColumnInDataTypeScope(column, scope, dataType) {
+        if (column == null || column.dataType !== dataType) {
             return false;
         }
         if (scope == undefined) {
@@ -214,7 +185,7 @@ export class ColumnScopeApiImpl extends ApiBase {
         if ('ColumnIds' in scope && scope.ColumnIds.includes(column.columnId)) {
             return true;
         }
-        if ('DataTypes' in scope && scope.DataTypes.includes('date')) {
+        if ('DataTypes' in scope && scope.DataTypes.includes(dataType)) {
             return true;
         }
         if ('ColumnTypes' in scope &&

package/src/Api/Implementation/CommentsApiImpl.js

@@ -45,6 +45,6 @@ export class CommentsApiImpl extends ApiBase {
         this.setComments([]);
     }
     hideCommentsPopup() {
-        this.getAdaptableInternalApi().getAnnotationsService().hidePopup();
+        this.getAdaptableInternalApi().getCommentsService().hidePopup();
     }
 }

package/src/Api/Implementation/CustomSortApiImpl.d.ts

@@ -4,18 +4,17 @@ import { CustomSort, CustomSortState } from '../../AdaptableState/CustomSortStat
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { CustomSortInternalApi } from '../Internal/CustomSortInternalApi';
 import { ColumnValuesComparer } from '../../AdaptableOptions/CustomSortOptions';
-import { LayoutExtendedConfig } from '../../types';
 export declare class CustomSortApiImpl extends ApiBase implements CustomSortApi {
     internalApi: CustomSortInternalApi;
     constructor(_adaptable: IAdaptable);
     getCustomSortState(): CustomSortState;
-    getCustomSorts(config?: LayoutExtendedConfig): CustomSort[];
-    getCustomSortById(id: CustomSort['Uuid'], config?: LayoutExtendedConfig): CustomSort;
+    getCustomSorts(): CustomSort[];
+    getCustomSortById(id: CustomSort['Uuid']): CustomSort;
     getCustomSortByName(name: string): CustomSort | undefined;
     getLiveCustomSorts(): CustomSort[];
     getLiveCustomSortComparers(): ColumnValuesComparer[];
-    getActiveCustomSorts(config?: LayoutExtendedConfig): CustomSort[];
-    getSuspendedCustomSorts(config?: LayoutExtendedConfig): CustomSort[];
+    getActiveCustomSorts(): CustomSort[];
+    getSuspendedCustomSorts(): CustomSort[];
     getCustomSortByColumn(column: string): CustomSort;
     getCustomSortForColumn(columnId: string): CustomSort | undefined;
     addCustomSort(customSort: CustomSort): CustomSort;

package/src/Api/Implementation/CustomSortApiImpl.js

@@ -11,11 +11,11 @@ export class CustomSortApiImpl extends ApiBase {
     getCustomSortState() {
         return this.getAdaptableState().CustomSort;
     }
-    getCustomSorts(config) {
-        return (this.handleLayoutExtensionObjects(this.getCustomSortState().CustomSorts, 'CustomSort', config) ?? []);
+    getCustomSorts() {
+        return (this.handleLayoutExtensionObjects(this.getCustomSortState().CustomSorts, 'CustomSort') ?? []);
     }
-    getCustomSortById(id, config) {
-        return this.getCustomSorts(config).find((customSort) => customSort.Uuid === id);
+    getCustomSortById(id) {
+        return this.getCustomSorts().find((customSort) => customSort.Uuid === id);
     }
     getCustomSortByName(name) {
         return this.getCustomSorts().find((customSort) => customSort.Name === name);
@@ -56,11 +56,11 @@ export class CustomSortApiImpl extends ApiBase {
         });
         return returnComparers;
     }
-    getActiveCustomSorts(config) {
-        return this.getCustomSorts(config).filter((customSort) => !customSort.IsSuspended);
+    getActiveCustomSorts() {
+        return this.getCustomSorts().filter((customSort) => !customSort.IsSuspended);
     }
-    getSuspendedCustomSorts(config) {
-        return this.getCustomSorts(config).filter((customSort) => customSort.IsSuspended);
+    getSuspendedCustomSorts() {
+        return this.getCustomSorts().filter((customSort) => customSort.IsSuspended);
     }
     getCustomSortByColumn(column) {
         return this.getCustomSorts().find((cs) => cs.ColumnId == column);

package/src/Api/Implementation/EntitlementApiImpl.d.ts

@@ -7,6 +7,12 @@ export declare class EntitlementApiImpl extends ApiBase implements EntitlementAp
     internalApi: EntitlementInternalApi;
     constructor(_adaptable: IAdaptable);
     getEntitlementAccessLevelForModule(adaptableModule: AdaptableModule): AccessLevel;
+    /**
+     * Per-module default when no explicit entitlement is set.
+     * Prefer `module.getDefaultAccessLevel()` (ModuleBase → options.defaultAccessLevel, or a module override).
+     * Fall back if modules are not ready yet.
+     */
+    private getModuleDefaultAccessLevel;
     isObjectReadonly(object: AdaptableObject): boolean;
     isModuleHiddenEntitlement(adaptableModule: AdaptableModule): boolean;
     isModuleFullEntitlement(adaptableModule: AdaptableModule): boolean;