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

package/src/Api/Internal/LayoutInternalApi.js

@@ -2,7 +2,8 @@ import { ACCESS_LEVEL_HIDDEN } from '../../Utilities/Constants/GeneralConstants'
 import { ColumnFilterModuleId, GridFilterModuleId, } from '../../Utilities/Constants/ModuleConstants';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import { ApiBase } from '../Implementation/ApiBase';
-import { areLayoutsEqual, isPivotLayout } from '../Implementation/LayoutHelpers';
+import { areLayoutsEqual, isPivotLayout, removeColumnIdFromLayout, } from '../../Utilities/Helpers/Layouts/LayoutHelper';
+import { getAllLayoutExtensionObjects, getLayoutsForObject, hasLayoutExtensions, isObjectGlobal, isObjectInLayout, } from '../../Utilities/Helpers/Layouts/LayoutExtensionHelper';
 import ObjectFactory from '../../Utilities/ObjectFactory';
 import Helper from '../../Utilities/Helpers/Helper';
 import AdaptableHelper from '../../Utilities/Helpers/AdaptableHelper';
@@ -47,35 +48,27 @@ export class LayoutInternalApi extends ApiBase {
         }
         return layoutSupportedFeatures;
     }
+    getLayoutExtensions() {
+        return this.getAdaptableState().Layout.LayoutExtensions;
+    }
     hasLayoutSpecificObjects() {
-        const layoutTagOptions = this.getLayoutOptions().layoutTagOptions;
-        if (!layoutTagOptions) {
-            return false;
-        }
-        if (layoutTagOptions.autoCheckTagsForLayouts == true ||
-            typeof layoutTagOptions?.isObjectExtendedInLayout === 'function') {
-            return true;
-        }
-        return false;
+        return hasLayoutExtensions(this.getLayoutExtensions());
     }
-    isObjectExtendedInLayout(object, module, layout) {
-        if (!this.hasLayoutSpecificObjects()) {
-            return true;
-        }
-        const layoutTagOptions = this.getLayoutOptions().layoutTagOptions;
-        if (layoutTagOptions?.autoCheckTagsForLayouts == true) {
-            const tags = 'ReportSchedule' in object && object.ReportSchedule
-                ? object.ReportSchedule.Tags
-                : object.Tags;
-            return ArrayExtensions.IsNullOrEmpty(tags) ? true : tags?.includes(layout.Name);
-        }
-        const context = {
-            adaptableObject: object,
-            module,
-            layout,
-            ...this.getAdaptableInternalApi().buildBaseContext(),
-        };
-        return layoutTagOptions?.isObjectExtendedInLayout(context);
+    isObjectInLayout(object, module, layoutName = this.getLayoutApi().getCurrentLayoutName()) {
+        return isObjectInLayout(this.getLayoutExtensions(), module, object?.Name, layoutName);
+    }
+    isObjectGlobal(object, module) {
+        return isObjectGlobal(this.getLayoutExtensions(), module, object?.Name);
+    }
+    getLayoutsForObject(object, module) {
+        return getLayoutsForObject(this.getLayoutExtensions(), module, object?.Name);
+    }
+    getAllLayoutExtensionObjects(module) {
+        return getAllLayoutExtensionObjects(this.getAdaptableState(), module);
+    }
+    isLayoutExtensionsUIEnabled() {
+        const layoutOptions = this.getLayoutOptions();
+        return (layoutOptions.enableLayoutExtensionsUI === true);
     }
     showLayoutNonExtendedObjects() {
         return this.getAdaptableState().Internal.Layout.showLayoutNonExtendedObjects;
@@ -87,7 +80,7 @@ export class LayoutInternalApi extends ApiBase {
         return (layout?.RowGroupedColumns?.length || layout?.PivotGroupedColumns?.length) > 0;
     }
     setupRowSummaries() {
-        if (!this._adaptable.agGridModulesAdapter.isAgGridModuleRegistered('PinnedRowModule')) {
+        if (!this.getAdaptableApi().internalApi.getAgGridModulesAdapter().isAgGridModuleRegistered('PinnedRowModule')) {
             this.getAdaptableApi().consoleError('Layout Row Summaries require the AG Grid "PinnedRowModule". Please register this module.');
             return;
         }
@@ -150,6 +143,18 @@ export class LayoutInternalApi extends ApiBase {
         };
         return initialLayout;
     }
+    buildAutoCreatedLayout(derived) {
+        const layoutType = isPivotLayout(derived) ? 'pivot' : 'table';
+        const empty = layoutType === 'pivot'
+            ? ObjectFactory.CreateEmptyPivotLayout({ Name: derived.Name })
+            : ObjectFactory.CreateEmptyTableLayout({ Name: derived.Name });
+        const defaultLayoutProperties = this.getLayoutCreationDefaultProperties(layoutType);
+        return {
+            ...empty,
+            ...defaultLayoutProperties,
+            ...derived,
+        };
+    }
     getLayoutCreationDefaultProperties(layoutType) {
         const layoutCreationDefPropsOption = this.getLayoutOptions().layoutCreationDefaultProperties;
         if (typeof layoutCreationDefPropsOption === 'object') {
@@ -187,4 +192,17 @@ export class LayoutInternalApi extends ApiBase {
     getCurrentLayoutRowGroupDisplayType() {
         return this.getLayoutApi().getCurrentLayout()?.RowGroupDisplayType ?? 'single';
     }
+    removeColumnIdFromAllLayouts(columnId) {
+        if (!columnId) {
+            return;
+        }
+        this.getLayoutApi()
+            .getLayouts()
+            .forEach((layout) => {
+            const updatedLayout = removeColumnIdFromLayout(layout, columnId);
+            if (!this.areLayoutsEqual(layout, updatedLayout)) {
+                this.getLayoutApi().createOrUpdateLayout(updatedLayout);
+            }
+        });
+    }
 }

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

@@ -1,3 +1,4 @@
+import { NamedQueryReturnType } from '../../AdaptableState/NamedQueryState';
 import { ApiBase } from '../Implementation/ApiBase';
 export declare class NamedQueryInternalApi extends ApiBase {
     /**
@@ -12,4 +13,9 @@ export declare class NamedQueryInternalApi extends ApiBase {
     getNamedQueryModuleReferences(namedQueryName: string): string[];
     validateDeletedNamedQuery(namedQuery: string): boolean;
     validateRenamedNamedQuery(namedQuery: string): boolean;
+    /**
+     * Blocks changing a referenced Named Query's ReturnType away from boolean
+     * (would break Grid Filter / Alert roots that use `QUERY("name")`).
+     */
+    validateNamedQueryReturnTypeChange(namedQueryName: string, previousReturnType: NamedQueryReturnType, nextReturnType: NamedQueryReturnType): boolean;
 }

package/src/Api/Internal/NamedQueryInternalApi.js

@@ -58,4 +58,24 @@ export class NamedQueryInternalApi extends ApiBase {
             return true;
         }
     }
+    validateNamedQueryReturnTypeChange(namedQueryName, previousReturnType, nextReturnType) {
+        if (previousReturnType === nextReturnType) {
+            return true;
+        }
+        if (previousReturnType !== 'boolean' || nextReturnType === 'boolean') {
+            return true;
+        }
+        const namedQueryReferences = this.getNamedQueryModuleReferences(namedQueryName);
+        if (!namedQueryReferences.length) {
+            return true;
+        }
+        const alert = {
+            alertType: 'generic',
+            header: 'Named Query',
+            message: `Result Type cannot change from boolean to ${nextReturnType}. This Named Query is still referenced by: ${namedQueryReferences.join(', ')}.`,
+            alertDefinition: ObjectFactory.CreateInternalAlertDefinitionForMessages('Error'),
+        };
+        this.getAlertApi().displayAdaptableAlertNotification(alert);
+        return false;
+    }
 }

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

@@ -2,4 +2,11 @@ import { ApiBase } from '../Implementation/ApiBase';
 export declare class NoteInternalApi extends ApiBase {
     areNotesSupported(): boolean;
     getNotesDateFormat(): string;
+    /**
+     * Whether AdapTable's AG Grid Cell Notes integration is operational.
+     *
+     * AdapTable always renders Notes via AG Grid's native Cell Notes engine (bridged onto
+     * Note State); this is true when the required AG Grid `NotesModule` is registered.
+     */
+    isAgGridNotesActive(): boolean;
 }

package/src/Api/Internal/NoteInternalApi.js

@@ -1,4 +1,5 @@
 import { ApiBase } from '../Implementation/ApiBase';
+import { resolveValueOrFunction } from '../../Utilities/Helpers/ValueOrFunctionHelper';
 export class NoteInternalApi extends ApiBase {
     areNotesSupported() {
         if (this.getLayoutApi().isCurrentLayoutPivot()) {
@@ -7,7 +8,9 @@ export class NoteInternalApi extends ApiBase {
         return true;
     }
     getNotesDateFormat() {
-        const dateFormat = this.getNoteOptions().dateFormat;
-        return typeof dateFormat === 'function' ? dateFormat() : dateFormat;
+        return resolveValueOrFunction(this.getNoteOptions().dateFormat);
+    }
+    isAgGridNotesActive() {
+        return this.getAdaptableApi().internalApi.getAgGridModulesAdapter().isAgGridModuleRegistered('NotesModule');
     }
 }

package/src/Api/Internal/RowFormInternalApi.js

@@ -1,4 +1,5 @@
 import { ApiBase } from '../Implementation/ApiBase';
+import { invokeOptionCallback, resolveValueOrFunction, } from '../../Utilities/Helpers/ValueOrFunctionHelper';
 export class RowFormInternalApi extends ApiBase {
     async buildRowEditForm(rowNode) {
         return this.buildRowForm('rowEdited', rowNode);
@@ -24,9 +25,7 @@ export class RowFormInternalApi extends ApiBase {
         if (rowFormOptions.rowFormTitle == undefined) {
             return type === 'rowCreated' ? 'Create New Row' : 'Edit Row';
         }
-        return typeof rowFormOptions.rowFormTitle === 'function'
-            ? rowFormOptions.rowFormTitle(this.buildFormParamContext(type, rowNode))
-            : rowFormOptions.rowFormTitle;
+        return resolveValueOrFunction(rowFormOptions.rowFormTitle, this.buildFormParamContext(type, rowNode));
     }
     buildFormParamContext(type, rowNode) {
         return {
@@ -37,9 +36,7 @@ export class RowFormInternalApi extends ApiBase {
     }
     getFormDescription(type, rowNode) {
         const rowFormOptions = this.getRowFormOptions();
-        return typeof rowFormOptions.rowFormDescription === 'function'
-            ? rowFormOptions.rowFormDescription(this.buildFormParamContext(type, rowNode))
-            : rowFormOptions.rowFormDescription;
+        return resolveValueOrFunction(rowFormOptions.rowFormDescription, this.buildFormParamContext(type, rowNode));
     }
     buidRowFormButtons(type, rowNode, formFields) {
         if (Array.isArray(this.getRowFormOptions().rowFormButtons)) {
@@ -115,15 +112,11 @@ export class RowFormInternalApi extends ApiBase {
         if (adaptableColumn.isActionColumn) {
             return false;
         }
-        const showColumnFn = this.getRowFormOptions()?.includeColumnInRowForm;
-        if (typeof showColumnFn === 'function') {
-            return showColumnFn({
-                ...this.getAdaptableInternalApi().buildBaseContext(),
-                adaptableColumn,
-                rowFormType: rowFormType,
-            });
-        }
-        return true;
+        return invokeOptionCallback(this.getRowFormOptions()?.includeColumnInRowForm, {
+            ...this.getAdaptableInternalApi().buildBaseContext(),
+            adaptableColumn,
+            rowFormType,
+        }, true);
     }
     isCellEditable(column, rowNode) {
         if (!rowNode) {
@@ -162,10 +155,7 @@ export class RowFormInternalApi extends ApiBase {
         return baseField;
     }
     getRowFormFieldLabel(type, column, rowNode) {
-        const customFieldLabel = typeof this.getRowFormOptions().rowFormFieldLabel === 'function'
-            ? this.getRowFormOptions().rowFormFieldLabel(this.buildFormFieldLabelContext(type, column, rowNode))
-            : undefined;
-        return customFieldLabel ?? column.friendlyName;
+        return invokeOptionCallback(this.getRowFormOptions().rowFormFieldLabel, this.buildFormFieldLabelContext(type, column, rowNode), column.friendlyName);
     }
     buildFormFieldLabelContext(type, column, rowNode) {
         return {

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

@@ -1,6 +1,8 @@
+import { AdaptableStateFunctionConfig } from '../../AdaptableOptions/StateOptions';
 import { AdaptablePersistentState, AdaptableState, InitialState } from '../../types';
 import { ApiBase } from '../Implementation/ApiBase';
 export declare class StateInternalApi extends ApiBase {
+    buildAdaptableStateFunctionConfig(): AdaptableStateFunctionConfig;
     /**
      * Startup-equivalent merge: Initial State + user state → store, layout/theme/cells, persist.
      * Does not clear persistence and does not call `loadState` (caller supplies user state).

package/src/Api/Internal/StateInternalApi.js

@@ -1,12 +1,20 @@
 import { getPersistableState, LoadState, InitState } from '../../Redux/Store/AdaptableStore';
 import { MergeStateFunction } from '../../Redux/Store/AdaptableReduxMerger';
-import { buildAdaptableStateFunctionConfig } from '../../Redux/Store/buildAdaptableStateFunctionConfig';
 import { addUuidsToInitialState } from '../../Utilities/Helpers/AdaptableHelper';
 import { ApiBase } from '../Implementation/ApiBase';
 function deepClone(value) {
     return JSON.parse(JSON.stringify(value ?? null));
 }
 export class StateInternalApi extends ApiBase {
+    buildAdaptableStateFunctionConfig() {
+        return {
+            adaptableId: this._adaptable.adaptableOptions.adaptableId,
+            adaptableStateKey: this._adaptable.adaptableOptions.adaptableStateKey,
+            userName: this._adaptable.adaptableOptions.userName,
+            adaptableApi: this._adaptable.api,
+            adaptableContext: this._adaptable.api?.optionsApi?.getAdaptableContext(),
+        };
+    }
     applyMergedInitialAndUserState(initialState, userState) {
         return new Promise((resolve, reject) => {
             this.getAdaptableInternalApi().executeWithProgressIndicator('Applying Initial State...', () => {
@@ -15,11 +23,14 @@ export class StateInternalApi extends ApiBase {
                     const initialForMerge = addUuidsToInitialState(deepClone(initialState));
                     const userForMerge = deepClone(userState ?? {});
                     let merged = MergeStateFunction(initialForMerge, userForMerge);
-                    const stateFunctionConfig = buildAdaptableStateFunctionConfig(this._adaptable);
+                    const stateFunctionConfig = this.buildAdaptableStateFunctionConfig();
                     merged = this.getOptions().stateOptions.applyState(merged, stateFunctionConfig);
+                    merged = this._adaptable.migrateLoadedAdaptableState(merged);
                     const agGridOptions = {
                         columnDefs: this._adaptable.agGridAdapter.getGridOption('columnDefs'),
                         autoGroupColumnDef: this._adaptable.agGridAdapter.getGridOption('autoGroupColumnDef'),
+                        defaultColDef: this._adaptable.agGridAdapter.getGridOption('defaultColDef'),
+                        pivotMode: this._adaptable.agGridAdapter.getGridOption('pivotMode'),
                         rowModelType: this._adaptable.agGridAdapter.getGridOption('rowModelType'),
                         treeData: this._adaptable.agGridAdapter.getGridOption('treeData'),
                     };
@@ -51,7 +62,7 @@ export class StateInternalApi extends ApiBase {
             allState = { ...allState };
             allState.Layout = { ...allState.Layout };
             allState.Layout.Layouts = allState.Layout.Layouts.map((layout) => {
-                let ColumnSizing = layout.ColumnSizing;
+                const ColumnSizing = { ...(layout.ColumnSizing ?? {}) };
                 if (Array.isArray(layout.TableColumns)) {
                     layout.TableColumns.forEach((colId) => {
                         if (!ColumnSizing[colId]) {
@@ -76,13 +87,16 @@ export class StateInternalApi extends ApiBase {
                     const agGridOptions = {
                         columnDefs: this._adaptable.agGridAdapter.getGridOption('columnDefs'),
                         autoGroupColumnDef: this._adaptable.agGridAdapter.getGridOption('autoGroupColumnDef'),
+                        defaultColDef: this._adaptable.agGridAdapter.getGridOption('defaultColDef'),
+                        pivotMode: this._adaptable.agGridAdapter.getGridOption('pivotMode'),
                         rowModelType: this._adaptable.agGridAdapter.getGridOption('rowModelType'),
                         treeData: this._adaptable.agGridAdapter.getGridOption('treeData'),
                     };
                     const clonedState = state.Internal
                         ? JSON.parse(JSON.stringify(state))
                         : getPersistableState(JSON.parse(JSON.stringify(state)));
-                    let processedState = this._adaptable.normalizeAdaptableState(clonedState, agGridOptions);
+                    let processedState = this._adaptable.migrateLoadedAdaptableState(clonedState);
+                    processedState = this._adaptable.normalizeAdaptableState(processedState, agGridOptions);
                     this.getAdaptableStore().TheStore.dispatch(LoadState(processedState));
                     this.getAdaptableStore().TheStore.dispatch(InitState());
                     this._adaptable.refreshLayout();

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

@@ -5,7 +5,6 @@ import { CellColorRange, ColumnComparison, NumericStyledColumn } from '../../Ada
 import { BadgeStyle, BadgeStyleDefinition } from '../../AdaptableState/StyledColumns/BadgeStyle';
 import { IRowNode } from 'ag-grid-enterprise';
 import type { AgChartInstance, AgSparklineOptions } from 'ag-charts-types';
-import { PredicateDefHandlerContext } from '../../types';
 export declare class StyledColumnInternalApi extends ApiBase {
     /**
      * Creates a sparkline described by `options` in its target container and
@@ -71,6 +70,18 @@ export declare class StyledColumnInternalApi extends ApiBase {
      * @param styledColumn Styled Column to Add
      */
     hasStyledColumnRelativeCellRange(styledColumn: StyledColumn): boolean;
-    getApplicableBadge(badgeStyle: BadgeStyle, context: PredicateDefHandlerContext): BadgeStyleDefinition | null;
-    getBadgePredicateDefsForColumn(columnId: string): import("../../types").AdaptablePredicateDef<string>[];
+    getApplicableBadge(badgeStyle: BadgeStyle, context: {
+        value: unknown;
+        node: IRowNode;
+        column: AdaptableColumn;
+    }): BadgeStyleDefinition | null;
+    /**
+     * Evaluates a Badge Style rule Expression for one cell value (or one
+     * array element — `context.value` is the element when the column is an
+     * array column). References to the badge's own column resolve to that
+     * value via `cellValueOverride`, preserving the per-element semantics
+     * of the legacy predicates. Invalid / erroring expressions hide the
+     * badge (returns `false`) — FormatColumn parity.
+     */
+    private evaluateBadgeExpression;
 }

package/src/Api/Internal/StyledColumnInternalApi.js

@@ -1,5 +1,7 @@
 import { ApiBase } from '../Implementation/ApiBase';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
+import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
+import { errorOnce } from '../../agGrid/AdaptableLogger';
 import { expandGradientCellRanges, gradientStyleRangeLookupValueType } from '../../Utilities/Helpers/StyledColumns/GradientStyleHelper';
 const DYNAMIC_RANGE_ENDPOINTS = [
     'Col-Min',
@@ -275,34 +277,42 @@ export class StyledColumnInternalApi extends ApiBase {
         if (!badgeStyle.Badges.length) {
             return null;
         }
-        const badgesWithoutAll = [];
-        const badgesWithAll = [];
+        const badgesWithRule = [];
+        const badgesWithoutRule = [];
         for (let badge of badgeStyle.Badges) {
-            if (!badge.Predicate) {
-                badgesWithAll.push(badge);
+            if (badge.Rule) {
+                badgesWithRule.push(badge);
             }
             else {
-                badgesWithoutAll.push(badge);
+                badgesWithoutRule.push(badge);
             }
         }
-        for (let badge of badgesWithoutAll) {
-            if (this.getPredicateApi().handlePredicate(badge.Predicate, context, false)) {
-                return badge;
+        for (let badge of badgesWithRule) {
+            if (badge.Rule) {
+                if (this.evaluateBadgeExpression(badge.Rule, context)) {
+                    return badge;
+                }
             }
         }
-        const [firstBadgeWithAll] = badgesWithAll;
-        return firstBadgeWithAll ?? null;
+        const [firstBadgeWithoutRule] = badgesWithoutRule;
+        return firstBadgeWithoutRule ?? null;
     }
-    getBadgePredicateDefsForColumn(columnId) {
-        const column = this.getColumnApi().getColumnWithColumnId(columnId);
-        if (!column) {
-            return undefined;
+    evaluateBadgeExpression(expression, context) {
+        const isValidExpression = this.getExpressionApi().isValidScalarExpression(expression, ModuleConstants.StyledColumnModuleId, `Invalid Badge Style rule '${expression}'`);
+        if (!isValidExpression) {
+            return false;
+        }
+        try {
+            return Boolean(this.getAdaptableApi()
+                .internalApi.getQueryLanguageService()
+                .evaluateBooleanExpression(expression, ModuleConstants.StyledColumnModuleId, context.node, {
+                columnScope: context.column.columnId,
+                cellValueOverride: { columnId: context.column.columnId, value: context.value },
+            }));
+        }
+        catch (error) {
+            errorOnce(error?.message ?? String(error));
+            return false;
         }
-        const scope = {
-            ColumnIds: [column.columnId],
-        };
-        return this.getPredicateApi()
-            .internalApi.getBadgeStylePredicateDefs(scope)
-            .filter((predicate) => this.getColumnScopeApi().isColumnInScope(column, predicate.columnScope));
     }
 }

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

@@ -1,6 +1,13 @@
 import { ApiBase } from '../Implementation/ApiBase';
-import { AdaptableSharedEntity } from '../../AdaptableState/TeamSharingState';
+import { AdaptableSharedEntity, SharedEntity } from '../../AdaptableState/TeamSharingState';
 export declare class TeamSharingInternalApi extends ApiBase {
+    private migratedSharedEntitiesPersisted;
+    /**
+     * One write per grid session after `TEAMSHARING_GET`, when migration changed
+     * any entity and the user has full Team Sharing rights. Does not bump
+     * `Revision` or `ChangedAt` — the list is persisted as loaded.
+     */
+    persistMigratedSharedEntitiesIfNeeded(sharedEntities: SharedEntity[]): void;
     /**
      * Retrieves shared entry dependencies.
      */

package/src/Api/Internal/TeamSharingInternalApi.js

@@ -1,5 +1,31 @@
 import { ApiBase } from '../Implementation/ApiBase';
+import { readMigrationChangedCount } from '../../migration/entityMigration';
 export class TeamSharingInternalApi extends ApiBase {
+    migratedSharedEntitiesPersisted = false;
+    persistMigratedSharedEntitiesIfNeeded(sharedEntities) {
+        if (this.migratedSharedEntitiesPersisted || !sharedEntities) {
+            return;
+        }
+        const changedCount = readMigrationChangedCount(sharedEntities);
+        if (changedCount <= 0) {
+            return;
+        }
+        if (this.getTeamSharingOptions().persistMigratedSharedEntities === false) {
+            return;
+        }
+        if (!this.getTeamSharingApi().hasTeamSharingFullRights()) {
+            return;
+        }
+        this.migratedSharedEntitiesPersisted = true;
+        const noun = changedCount === 1 ? 'entity' : 'entities';
+        void this.getTeamSharingApi()
+            .persistSharedEntities(sharedEntities)
+            .then((persisted) => {
+            if (persisted) {
+                this.logInfo(`Persisted ${changedCount} migrated shared ${noun}`);
+            }
+        });
+    }
     getSharedEntryDependencies(sharedEntity) {
         const allEntities = this.getTeamSharingApi().getLoadedAdaptableSharedEntities();
         return (sharedEntity?.EntityDependencyIds ?? []).map((id) => allEntities.find((entity) => entity.Uuid === id));

package/src/Api/Internal/UserInterfaceInternalApi.js

@@ -1,3 +1,4 @@
+import { invokeOptionCallback } from '../../Utilities/Helpers/ValueOrFunctionHelper';
 import { ApiBase } from '../Implementation/ApiBase';
 export class UserInterfaceInternalApi extends ApiBase {
     prepareAdaptableIconDef(icon) {
@@ -19,14 +20,9 @@ export class UserInterfaceInternalApi extends ApiBase {
         return customIcon;
     }
     shouldShowSelectCellEditor(column) {
-        const showSelectCellEditor = this.getEditOptions().showSelectCellEditor;
-        if (showSelectCellEditor) {
-            const columnColumnContext = {
-                column,
-                ...this.getAdaptableInternalApi().buildBaseContext(),
-            };
-            return showSelectCellEditor(columnColumnContext);
-        }
-        return false;
+        return invokeOptionCallback(this.getEditOptions().showSelectCellEditor, {
+            column,
+            ...this.getAdaptableInternalApi().buildBaseContext(),
+        }, false);
     }
 }

package/src/Api/LayoutApi.d.ts

@@ -1,5 +1,5 @@
 import { AdaptableColumn, ColumnSort, PivotLayout, TableLayout } from '../../types';
-import { ExtendedLayout } from '../AdaptableState/Common/ExtendedLayout';
+import { ExtendedLayout, LayoutExtensionInfo, LayoutExtensionModule, LayoutExtensionObject } from '../AdaptableState/Common/ExtendedLayout';
 import { LayoutState, Layout } from '../AdaptableState/LayoutState';
 /**
  * Provides run-time access to the Layout Module and associated state
@@ -62,23 +62,69 @@ export interface LayoutApi {
      */
     setExtendedLayout(extendedLayout: ExtendedLayout): void;
     /**
-     *
-     * Retrieves Layout with the given name
+     * Retrieves the Layout with the given name, together with the objects extended into it
+     * (global objects, which apply in every Layout, are not included)
      * @param layoutName Layout to retrieve
-     * @returns layout
      */
     getExtendedLayoutByName(layoutName: string): ExtendedLayout | undefined;
     /**
-     * Creates (or Updates) an Extended Layout
+     * Creates (or Updates) an Extended Layout: saves the Layout, adds any extension objects not yet in state,
+     * and makes those objects the Layout's complete Layout Extension
      * @param extendedLayout ExtendedLayout to Create
      */
     createOrUpdateExtendedLayout(extendedLayout: ExtendedLayout): void;
     /**
-     * Clones an Extended Layout
+     * Clones an Extended Layout - the new Layout is extended with the same objects
      * @param extendedLayoutToClone ExtendedLayout to Clone
      * @param layoutName New name for Layout being cloned
      */
     cloneExtendedLayout(extendedLayoutToClone: ExtendedLayout, layoutName: string): ExtendedLayout | false;
+    /**
+     * Renames a Layout, keeping the objects extended into it
+     * @param layoutName Current name of the Layout
+     * @param newLayoutName New name (must not be used by another Layout)
+     * @returns false if the Layout does not exist or the new name is taken
+     */
+    renameLayout(layoutName: string, newLayoutName: string): boolean;
+    /**
+     * Retrieves the names of the objects, per Module, extended into a Layout
+     * @param layoutName Layout to check
+     */
+    getLayoutExtensions(layoutName: string): LayoutExtensionInfo;
+    /**
+     * Replaces the objects extended into a Layout (an empty extensionInfo makes those objects global again, unless
+     * they are extended into other Layouts)
+     * @param layoutName Layout to update
+     * @param extensionInfo Names of the objects, per Module, to extend into the Layout
+     */
+    setLayoutExtensions(layoutName: string, extensionInfo: LayoutExtensionInfo): void;
+    /**
+     * Extends an object into a Layout - once extended into any Layout, it applies only in those Layouts
+     * @param object Object to extend
+     * @param module Module the object belongs to
+     * @param layoutName Layout to extend it into; defaults to Current Layout
+     */
+    addObjectToLayout(object: LayoutExtensionObject, module: LayoutExtensionModule, layoutName?: string): void;
+    /**
+     * Removes an object from a Layout - when it is no longer extended into any Layout, it becomes global
+     * @param object Object to remove
+     * @param module Module the object belongs to
+     * @param layoutName Layout to remove it from; defaults to Current Layout
+     */
+    removeObjectFromLayout(object: LayoutExtensionObject, module: LayoutExtensionModule, layoutName?: string): void;
+    /**
+     * Retrieves the names of the Layouts an object is extended into (empty when the object is global)
+     * @param object Object to check
+     * @param module Module the object belongs to
+     */
+    getLayoutsForObject(object: LayoutExtensionObject, module: LayoutExtensionModule): string[];
+    /**
+     * Extends an object into exactly the given Layouts, removing it from any others
+     * @param object Object to extend (referenced by its Name)
+     * @param module Module the object belongs to
+     * @param layoutNames Layouts to extend the object into; an empty array makes the object global
+     */
+    setLayoutsForObject(object: LayoutExtensionObject, module: LayoutExtensionModule, layoutNames: string[]): void;
     /**
      * Retrieves all Layouts in Adaptable State
      * @returns layouts

package/src/Api/NoteApi.d.ts

@@ -1,5 +1,5 @@
 import { AdaptableNote, AdaptableNotes, NoteState } from '../AdaptableState/NoteState';
-import { CellAddress } from '../../types';
+import { AdaptableMessageType, CellAddress } from '../../types';
 /**
  * Provides run-time access to Notes Module and related State
  */
@@ -9,8 +9,10 @@ export interface NoteApi {
      * @param text
      * @param primaryKeyValue
      * @param columnId
+     * @param extra optional additional Note properties (e.g. `Author`, `Metadata`, `IsReadOnly`);
+     *  `Author` and `CreatedAt` are stamped automatically when not supplied
      */
-    addNote(text: string, primaryKeyValue: any, columnId: string): void;
+    addNote(text: string, primaryKeyValue: any, columnId: string, extra?: Partial<AdaptableNote>): void;
     /**
      * Edits a Note
      * @param note
@@ -22,6 +24,12 @@ export interface NoteApi {
      * @param note
      */
     updateNoteText(text: string, note: AdaptableNote): void;
+    /**
+     * Sets Type of a Note (`'Info' | 'Warning' | 'Error' | 'Success'`), which drives colour of Note indicator
+     * @param note the Note to update
+     * @param noteType the new Note Type
+     */
+    setNoteType(note: AdaptableNote, noteType: AdaptableMessageType): void;
     /**
      * Deletes a Note
      * @param note

package/src/Api/OptionsApi.d.ts

@@ -1,4 +1,4 @@
-import { ActionColumnOptions, AdaptableOptions, AlertOptions, CalendarOptions, CellSummaryOptions, ChartingOptions, ColumnMenuOptions, ColumnOptions, CommentOptions, ContainerOptions, ContextMenuOptions, CustomSortOptions, DashboardOptions, DataChangeHistoryOptions, DataImportOptions, DataSetOptions, EditOptions, EntitlementOptions, ExportOptions, ExpressionOptions, Fdc3Options, FilterOptions, FlashingCellOptions, FormatColumnOptions, LayoutOptions, NoteOptions, NotificationsOptions, PredicateOptions, QuickSearchOptions, RowFormOptions, SettingsPanelOptions, StateOptions, TeamSharingOptions, ToolPanelOptions, UserInterfaceOptions } from '../types';
+import { ActionColumnOptions, AdaptableOptions, AlertOptions, CalendarOptions, CellSummaryOptions, ChartingOptions, CalculatedColumnOptions, ColumnMenuOptions, ColumnOptions, CommentOptions, ContainerOptions, ContextMenuOptions, CustomSortOptions, DashboardOptions, DataChangeHistoryOptions, DataImportOptions, DataSetOptions, EditOptions, EntitlementOptions, ExportOptions, ExpressionOptions, Fdc3Options, FilterOptions, FlashingCellOptions, FormatColumnOptions, LayoutOptions, NoteOptions, NotificationsOptions, QuickSearchOptions, RowFormOptions, SettingsPanelOptions, StateOptions, TeamSharingOptions, ToolPanelOptions, UserInterfaceOptions } from '../types';
 /**
  * Range of functions to access Adaptable Options
  */
@@ -67,6 +67,10 @@ export interface OptionsApi {
      * Returns `AdaptableOptions.commentOptions`
      */
     getCommentOptions(): Readonly<CommentOptions>;
+    /**
+     * Returns `AdaptableOptions.calculatedColumnOptions`
+     */
+    getCalculatedColumnOptions(): Readonly<CalculatedColumnOptions>;
     /**
      * Returns `AdaptableOptions.customSortOptions`
      */
@@ -135,10 +139,6 @@ export interface OptionsApi {
      * Returns `AdaptableOptions.noteOptions`
      */
     getNoteOptions(): Readonly<NoteOptions>;
-    /**
-     * Returns `AdaptableOptions.predicateOptions`
-     */
-    getPredicateOptions(): Readonly<PredicateOptions>;
     /**
      * Returns `AdaptableOptions.settingsPanelOptions`
      */