@adaptabletools/adaptable 20.3.0-canary.2 → 21.0.0-canary.0

package/src/Api/Internal/FormatColumnInternalApi.js

@@ -36,36 +36,36 @@ export class FormatColumnInternalApi extends ApiBase {
      * Retrieves all Format Columns in Adaptable State with the `Style` property set
      * @returns format columns
      */
-    getAllFormatColumnWithStyle() {
+    getAllFormatColumnWithStyle(config) {
         return this.getFormatColumnApi()
-            .getFormatColumns()
+            .getFormatColumns(config)
             .filter((fc) => fc.Style);
     }
     /**
      * Retrieves all Format Columns in Adaptable State with the `Style` or the `CellAlignment` property set
      * @returns format columns
      */
-    getAllFormatColumnWithStyleAndCellAlignment() {
+    getAllFormatColumnWithStyleAndCellAlignment(config) {
         return this.getFormatColumnApi()
-            .getFormatColumns()
+            .getFormatColumns(config)
             .filter((fc) => fc.Style || fc.CellAlignment);
     }
     /**
      * Retrieves all Format Columns in Adaptable State with `DisplayFormat` property set
      * @returns format columns
      */
-    getAllFormatColumnWithDisplayFormat() {
+    getAllFormatColumnWithDisplayFormat(config) {
         return this.getFormatColumnApi()
-            .getFormatColumns()
+            .getFormatColumns(config)
             .filter((fc) => fc.DisplayFormat);
     }
     /**
      * Retrieves all Format Columns in Adaptable State with `CellAlignment` property set
      * @returns format columns
      */
-    getAllFormatColumnWithCellAlignment() {
+    getAllFormatColumnWithCellAlignment(config) {
         return this.getFormatColumnApi()
-            .getFormatColumns()
+            .getFormatColumns(config)
             .filter((fc) => fc.CellAlignment);
     }
     /**
@@ -78,8 +78,8 @@ export class FormatColumnInternalApi extends ApiBase {
         const formatColumns = this.getAllFormatColumnWithStyleAndCellAlignment()
             .filter((formatColumn) => {
             // FormatColumn default target is 'cell', so if no target is specified, we assume 'cell'
-            const fcTarget = formatColumn.Target ?? ['cell'];
-            return fcTarget.includes(config.target);
+            const fcTarget = formatColumn.Target ?? 'cell';
+            return fcTarget === config.target;
         })
             .filter((formatColumn) => config?.includeSuspended || !formatColumn.IsSuspended);
         return this.getFormatColumnWithColumnInScope(formatColumns, column);
@@ -116,7 +116,13 @@ export class FormatColumnInternalApi extends ApiBase {
      * @returns list of FormatColumn
      */
     getFormatColumnsWithDisplayFormatForColumn(column, config) {
-        const formatColumns = this.getAllFormatColumnWithDisplayFormat().filter((formatColumn) => config?.includeSuspended || !formatColumn.IsSuspended);
+        const formatColumns = this.getAllFormatColumnWithDisplayFormat()
+            .filter((formatColumn) => {
+            // FormatColumn default target is 'cell', so if no target is specified, we assume 'cell'
+            const fcTarget = formatColumn.Target ?? 'cell';
+            return fcTarget === config.target;
+        })
+            .filter((formatColumn) => config?.includeSuspended || !formatColumn.IsSuspended);
         return this.getFormatColumnWithColumnInScope(formatColumns, column);
     }
     /**
@@ -183,7 +189,7 @@ export class FormatColumnInternalApi extends ApiBase {
             return true;
         }
         const agGridApi = this.getAdaptableApi().agGridApi;
-        const agGridColumn = agGridApi.isPivotMode()
+        const agGridColumn = this._adaptable.isInPivotMode()
             ? agGridApi.getPivotResultColumns().find((col) => col.getColId() === column.columnId)
             : agGridApi.getColumn(column.columnId);
         if (!agGridColumn) {
@@ -325,14 +331,14 @@ export class FormatColumnInternalApi extends ApiBase {
      * Retrieves all Format Columns which have an Expression
      * @returns Format Columns with Expression
      */
-    getFormatColumnsWithExpression() {
+    getFormatColumnsWithExpression(config) {
         return this.getFormatColumnApi()
-            .getFormatColumns()
+            .getFormatColumns(config)
             .filter((fc) => !!fc.Rule?.BooleanExpression);
     }
-    getFormatColumnsDependentOnColumns(columnSet) {
+    getFormatColumnsDependentOnColumns(columnSet, config) {
         return this.getFormatColumnApi()
-            .getFormatColumns()
+            .getFormatColumns(config)
             .filter((fc) => fc.Rule?.Predicates?.some((p) => columnSet.has(p.ColumnId)));
     }
     /**
@@ -356,4 +362,27 @@ export class FormatColumnInternalApi extends ApiBase {
         });
         return [...columnsThatNeedRefresh];
     }
+    formatColumnHeaderName(headerName, params) {
+        // currently we only format the header name for normal columns (NOT column groups)
+        if (!params.column) {
+            return headerName;
+        }
+        const abColumn = this.getColumnApi().getColumnWithColumnId(params.column.getColId());
+        const activeFormatColumnsWithDisplayFormat = this.getFormatColumnApi().internalApi.getFormatColumnsWithDisplayFormatForColumn(abColumn, {
+            target: 'columnHeader',
+        });
+        if (!activeFormatColumnsWithDisplayFormat.length) {
+            return headerName;
+        }
+        const mostRelevantFormatColumn = activeFormatColumnsWithDisplayFormat.find((formatColumn) => this.formatColumnShouldRenderInHeader(formatColumn, abColumn));
+        if (!mostRelevantFormatColumn) {
+            return headerName;
+        }
+        if (mostRelevantFormatColumn.DisplayFormat?.Formatter !== 'StringFormatter') {
+            // headers are always strings, so we can only use StringFormatter
+            return headerName;
+        }
+        const formattedHeaderName = this.getFormatColumnApi().internalApi.getStringFormattedValue(headerName, null, abColumn, mostRelevantFormatColumn.DisplayFormat.Options);
+        return formattedHeaderName;
+    }
 }

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

@@ -1,11 +1,13 @@
-import { RowClassParams } from 'ag-grid-enterprise';
+import { IRowNode, RowClassParams } from 'ag-grid-enterprise';
 import { AdaptableColumn } from '../../AdaptableState/Common/AdaptableColumn';
 import { AdaptableMenuItem } from '../../AdaptableState/Common/Menu';
 import { SpecialColumnSettings } from '../../AdaptableState/Common/SpecialColumnSettings';
 import { GridCell } from '../../AdaptableState/Selection/GridCell';
 import { SelectedCellInfo } from '../../AdaptableState/Selection/SelectedCellInfo';
 import { SelectedRowInfo } from '../../AdaptableState/Selection/SelectedRowInfo';
+import { InFilterValue } from '../../types';
 import { ApiBase } from '../Implementation/ApiBase';
+import { EditColumnValueInfo } from '../../AdaptableOptions/EditOptions';
 export declare class GridInternalApi extends ApiBase {
     /**
      * Gets all distinct display values in the Column for given ColumnId
@@ -27,20 +29,13 @@ export declare class GridInternalApi extends ApiBase {
     getDistinctFilterDisplayValuesForColumn(options: {
         columnId: string;
         currentSearchValue: string;
-    }): Promise<{
-        value: any;
-        label: string;
-    }[]>;
+    }): Promise<InFilterValue[]>;
     getDistinctValuesForColumn(columnId: string): Promise<GridCell[]> | undefined;
-    getDistinctDisplayValuesForColumn(columnId: string): Promise<any[]> | undefined;
     getDistinctEditDisplayValuesForColumn(options: {
         columnId: string;
         gridCell: GridCell;
         currentSearchValue: string;
-    }): Promise<{
-        value: any;
-        label: string;
-    }[]> | undefined;
+    }): Promise<EditColumnValueInfo[]> | undefined;
     /**
      * Gets all distinct raw values in Column. Values are sorted.
      * @param columnId Column to check
@@ -51,6 +46,7 @@ export declare class GridInternalApi extends ApiBase {
      * @param columnId Column to check
      */
     getUnsortedDistinctRawValuesForColumn(columnId: string): any[];
+    getSortedRowNodesWithCurrentLayoutSortOrder(rowNodes?: IRowNode[]): IRowNode[];
     sortDistinctValues<T extends GridCell>(returnValues: T[], column: AdaptableColumn): T[];
     setColumns(columns: AdaptableColumn[]): void;
     setSelectedCells(selectedCellInfo: SelectedCellInfo): void;
@@ -72,4 +68,5 @@ export declare class GridInternalApi extends ApiBase {
      * DO NOT USE THIS METHOD DIRECTLY - use `GridApi.isCellEditable` instead
      */
     isCellEditableAccordingToEditOptions(gridCell: GridCell, defaultColDefinitionEditableValue: boolean): boolean | undefined;
+    isRowFilterable(rowNode: IRowNode): boolean;
 }

package/src/Api/Internal/GridInternalApi.js

@@ -1,6 +1,7 @@
 import { SortOrder } from '../../AdaptableState/Common/Enums';
 import * as InternalRedux from '../../Redux/ActionsReducers/InternalRedux';
-import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
+import { getDateComparatorForGridCell, getGenericComparatorForGridCell, getNumericComparatorForGridCell, sortCellValueArrayNumeric, sortCellValueArrayDates, sortCellValueArray, } from '../../Utilities/Extensions/ArrayExtensions';
+import { multisort } from '@infinite-table/infinite-react';
 import { convertAdaptableStyleToCSS } from '../../Utilities/Helpers/StyleHelper';
 import UIHelper from '../../View/UIHelper';
 import { ApiBase } from '../Implementation/ApiBase';
@@ -36,20 +37,13 @@ export class GridInternalApi extends ApiBase {
         if (abColumn == undefined) {
             return [];
         }
-        let gridCells = await this._adaptable.getDistinctFilterValuesForColumn({
+        const inFilterValues = await this._adaptable.getDistinctFilterValuesForColumn({
             column: abColumn,
             get currentSearchValue() {
                 return options.currentSearchValue;
             },
         });
-        gridCells = gridCells || [];
-        const valueOptions = gridCells.map((cv) => {
-            return {
-                label: cv.displayValue,
-                value: cv.normalisedValue,
-            };
-        });
-        return valueOptions;
+        return inFilterValues || [];
     }
     async getDistinctValuesForColumn(columnId) {
         const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);
@@ -59,31 +53,19 @@ export class GridInternalApi extends ApiBase {
         const gridCells = await this._adaptable.getDistinctValuesForColumn(abColumn);
         return gridCells;
     }
-    async getDistinctDisplayValuesForColumn(columnId) {
-        const distinctValues = await this.getDistinctValuesForColumn(columnId);
-        return distinctValues.map((gc) => {
-            return gc.displayValue;
-        });
-    }
     async getDistinctEditDisplayValuesForColumn(options) {
         const abColumn = this.getColumnApi().getColumnWithColumnId(options.columnId);
         if (!abColumn) {
             return undefined;
         }
-        let gridCells = await this._adaptable.getDistinctEditValuesForColumn({
+        const valueOptions = await this._adaptable.getDistinctEditValuesForColumn({
             column: abColumn,
             gridCell: options.gridCell,
             get currentSearchValue() {
                 return options.currentSearchValue;
             },
         });
-        gridCells = gridCells || [];
-        return gridCells.map((gc) => {
-            return {
-                label: gc.displayValue,
-                value: gc.normalisedValue,
-            };
-        });
+        return valueOptions || [];
     }
     /**
      * Gets all distinct raw values in Column. Values are sorted.
@@ -109,6 +91,58 @@ export class GridInternalApi extends ApiBase {
         }
         return this._adaptable.getDistinctGridCellsForColumn(abColumn);
     }
+    getSortedRowNodesWithCurrentLayoutSortOrder(rowNodes) {
+        const currentLayout = this.getLayoutApi().getCurrentLayout();
+        const columnSorts = currentLayout.ColumnSorts || [];
+        const columnApi = this.getColumnApi();
+        const rowNodesMapToCells = new Map();
+        const allRowNodes = [];
+        // for each row node,let's create an object
+        // with only those gridcells that are needed - meaning
+        // for those column that are in the current sort
+        const rowNodeCallback = (node) => {
+            allRowNodes.push(node);
+            const rowNodeCells = {};
+            rowNodesMapToCells.set(node, rowNodeCells);
+            columnSorts.forEach((columnSort, i) => {
+                const { ColumnId } = columnSort;
+                const gridCell = this._adaptable.getGridCellFromRowNode(node, ColumnId);
+                rowNodeCells[ColumnId] = gridCell;
+            });
+        };
+        if (rowNodes) {
+            rowNodes.forEach(rowNodeCallback);
+        }
+        else {
+            this.getAgGridApi().forEachNode(rowNodeCallback);
+        }
+        if (!columnSorts.length) {
+            return allRowNodes;
+        }
+        const sortInfo = columnSorts.map((columnSort) => {
+            const { ColumnId } = columnSort;
+            // NOTE: the comparator we pass to multisort should always sort in ascending order
+            // that's why we pass SortOrder.Asc to the comparators
+            const comparator = columnApi.hasNumberDataType(ColumnId)
+                ? getNumericComparatorForGridCell(SortOrder.Asc)
+                : columnApi.hasDateDataType(ColumnId)
+                    ? getDateComparatorForGridCell(SortOrder.Asc)
+                    : getGenericComparatorForGridCell(SortOrder.Asc);
+            return {
+                // but here we pass the actual direction of the column sort
+                dir: columnSort.SortOrder === 'Asc' ? 1 : -1,
+                fn: (rowNodeA, rowNodeB) => {
+                    const gridCellA = rowNodesMapToCells.get(rowNodeA)?.[ColumnId];
+                    const gridCellB = rowNodesMapToCells.get(rowNodeB)?.[ColumnId];
+                    if (!gridCellA || !gridCellB) {
+                        return 0;
+                    }
+                    return comparator(gridCellA, gridCellB);
+                },
+            };
+        });
+        return multisort(sortInfo, allRowNodes);
+    }
     sortDistinctValues(returnValues, column) {
         // this does NOT into account Custom Sort - far too hard for now...
         let sortOrder = undefined;
@@ -123,13 +157,13 @@ export class GridInternalApi extends ApiBase {
         }
         if (sortOrder) {
             if (this.getColumnApi().hasNumberDataType(column?.columnId)) {
-                returnValues = ArrayExtensions.sortCellValueArrayNumeric(returnValues, sortOrder);
+                returnValues = sortCellValueArrayNumeric(returnValues, sortOrder);
             }
             else if (this.getColumnApi().hasDateDataType(column?.columnId)) {
-                returnValues = ArrayExtensions.sortCellValueArrayDates(returnValues, sortOrder);
+                returnValues = sortCellValueArrayDates(returnValues, sortOrder);
             }
             else {
-                returnValues = ArrayExtensions.sortCellValueArray(returnValues, sortOrder);
+                returnValues = sortCellValueArray(returnValues, sortOrder);
             }
         }
         return returnValues;
@@ -222,4 +256,19 @@ export class GridInternalApi extends ApiBase {
         }
         return undefined;
     }
+    isRowFilterable(rowNode) {
+        // first assess if the Row is filterable - if not, then return true so it appears in Grid
+        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;
+    }
 }

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

@@ -1,8 +1,7 @@
-import { LayoutAssociatedObject } from '../../AdaptableOptions/LayoutOptions';
-import { AdaptableModule } from '../../AdaptableState/Common/Types';
-import { Layout, PivotLayout, TableLayout } from '../../AdaptableState/LayoutState';
+import { Layout, LayoutBase, PivotLayout, TableLayout } from '../../AdaptableState/LayoutState';
 import { ApiBase } from '../Implementation/ApiBase';
 import { ColDef, ColGroupDef } from 'ag-grid-enterprise';
+import { LayoutExtensionObject, LayoutExtensionModule } from '../../types';
 export declare class LayoutInternalApi extends ApiBase {
     getNormalizedLayout(layout: TableLayout | PivotLayout): TableLayout | PivotLayout;
     sortColumnDefsByPivotAggregationOrder(columnDefs: (ColDef | ColGroupDef)[], pivotAggregationColumns: PivotLayout['PivotAggregationColumns']): (ColDef | ColGroupDef)[];
@@ -27,9 +26,10 @@ export declare class LayoutInternalApi extends ApiBase {
         RowSummaries: boolean;
     };
     hasLayoutSpecificObjects(): boolean;
-    isObjectAvailableInLayout(object: LayoutAssociatedObject, module: AdaptableModule, layout: Layout): boolean;
-    showLayoutNotAssociatedObjects(): boolean;
+    isObjectExtendedInLayout(object: LayoutExtensionObject, module: LayoutExtensionModule, layout: Layout): boolean;
+    showLayoutNonExtendedObjects(): boolean;
     isLayoutGrouped(layout?: Layout): boolean;
     setupRowSummaries(): void;
     refreshLayout(): void;
+    getChangedColumnSorts(oldSorts: LayoutBase['ColumnSorts'], newSorts: LayoutBase['ColumnSorts']): string[];
 }

package/src/Api/Internal/LayoutInternalApi.js

@@ -120,12 +120,12 @@ export class LayoutInternalApi extends ApiBase {
             return false;
         }
         if (layoutTagOptions.autoCheckTagsForLayouts == true ||
-            typeof layoutTagOptions?.isObjectAvailableInLayout === 'function') {
+            typeof layoutTagOptions?.isObjectExtendedInLayout === 'function') {
             return true;
         }
         return false;
     }
-    isObjectAvailableInLayout(object, module, layout) {
+    isObjectExtendedInLayout(object, module, layout) {
         if (!this.hasLayoutSpecificObjects()) {
             return true;
         }
@@ -139,10 +139,10 @@ export class LayoutInternalApi extends ApiBase {
             layout,
             ...this.getAdaptableInternalApi().buildBaseContext(),
         };
-        return layoutTagOptions?.isObjectAvailableInLayout(context);
+        return layoutTagOptions?.isObjectExtendedInLayout(context);
     }
-    showLayoutNotAssociatedObjects() {
-        return this.getAdaptableState().Internal.Layout.ShowLayoutNotAssociatedObjects;
+    showLayoutNonExtendedObjects() {
+        return this.getAdaptableState().Internal.Layout.showLayoutNonExtendedObjects;
     }
     isLayoutGrouped(layout) {
         if (!layout) {
@@ -151,6 +151,10 @@ export class LayoutInternalApi extends ApiBase {
         return (layout?.RowGroupedColumns?.length || layout?.PivotGroupedColumns?.length) > 0;
     }
     setupRowSummaries() {
+        if (!this._adaptable.agGridModulesAdapter.isAgGridModuleRegistered('PinnedRowModule')) {
+            this.getAdaptableApi().consoleError(`Can NOT set Layout Row Summaries - missing required AG Grid module 'PinnedRowModule'`);
+            return;
+        }
         const rowSummaries = this.getAdaptableState().Internal?.RowSummary?.rowSummaries ?? [];
         const { top, bottom } = rowSummaries.reduce((acc, summaryRow) => {
             const row = summaryRow.RowData;
@@ -169,4 +173,37 @@ export class LayoutInternalApi extends ApiBase {
     refreshLayout() {
         this._adaptable.refreshLayout();
     }
+    getChangedColumnSorts(oldSorts, newSorts) {
+        if (ArrayExtensions.IsNullOrEmpty(oldSorts) && ArrayExtensions.IsNullOrEmpty(newSorts)) {
+            return [];
+        }
+        // If either one is empty but not both, all columns in the non-empty array have changed
+        if (ArrayExtensions.IsNullOrEmpty(oldSorts)) {
+            return newSorts.map((sort) => sort.ColumnId);
+        }
+        if (ArrayExtensions.IsNullOrEmpty(newSorts)) {
+            return oldSorts.map((sort) => sort.ColumnId);
+        }
+        const changedColumnIds = [];
+        // Create maps for quick lookup
+        const oldSortsMap = new Map();
+        oldSorts.forEach((sort) => {
+            oldSortsMap.set(sort.ColumnId, sort.SortOrder);
+        });
+        // Check columns in new sorts that changed from old sorts
+        newSorts.forEach((newSort) => {
+            const oldSortOrder = oldSortsMap.get(newSort.ColumnId);
+            // If column wasn't sorted before or sort order changed
+            if (oldSortOrder === undefined || oldSortOrder !== newSort.SortOrder) {
+                changedColumnIds.push(newSort.ColumnId);
+            }
+            // Remove processed columns from the map
+            oldSortsMap.delete(newSort.ColumnId);
+        });
+        // Add remaining columns from old sorts (these were removed in new sorts)
+        oldSortsMap.forEach((_, columnId) => {
+            changedColumnIds.push(columnId);
+        });
+        return changedColumnIds;
+    }
 }

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

@@ -4,12 +4,8 @@ import { SystemFilterPredicateId } from '../../AdaptableState/Common/ColumnFilte
 import { AdaptableColumnDataType } from '../../AdaptableState/Common/AdaptableColumn';
 import { ColumnScope } from '../../types';
 export declare class PredicateInternalApi extends ApiBase {
-    /**
-     * Returns true if the predicate has a dropdown.
-     *
-     * @param predicate
-     */
-    hasPredicateValues(predicate: AdaptablePredicate): boolean;
+    IsInOrNotInPredicate(predicate: AdaptablePredicate): boolean;
+    IsInorNotInPredicateDef(predicateDef: AdaptablePredicateDef): boolean;
     /**
      * Get all Filter Predicate Definitions - System and Custom
      */

package/src/Api/Internal/PredicateInternalApi.js

@@ -1,13 +1,11 @@
 import { ApiBase } from '../Implementation/ApiBase';
 export class PredicateInternalApi extends ApiBase {
-    /**
-     * Returns true if the predicate has a dropdown.
-     *
-     * @param predicate
-     */
-    hasPredicateValues(predicate) {
+    IsInOrNotInPredicate(predicate) {
         return predicate?.PredicateId === 'In' || predicate?.PredicateId === 'NotIn';
     }
+    IsInorNotInPredicateDef(predicateDef) {
+        return predicateDef && ['In', 'NotIn'].includes(predicateDef.id);
+    }
     /**
      * Get all Filter Predicate Definitions - System and Custom
      */

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

@@ -2,5 +2,6 @@ import { AdaptableColumn, AdaptableIcon } from '../../types';
 import { ApiBase } from '../Implementation/ApiBase';
 export declare class UserInterfaceInternalApi extends ApiBase {
     prepareAdaptableIconDef(icon: AdaptableIcon): AdaptableIcon;
+    getCustomIconDefinition(iconName: string): AdaptableIcon | import("../../types").CustomIcon;
     shouldShowSelectCellEditor(column: AdaptableColumn): boolean;
 }

package/src/Api/Internal/UserInterfaceInternalApi.js

@@ -2,15 +2,22 @@ import { ApiBase } from '../Implementation/ApiBase';
 export class UserInterfaceInternalApi extends ApiBase {
     prepareAdaptableIconDef(icon) {
         if (icon && 'name' in icon) {
-            let customIcon = icon && 'name' in icon
-                ? this.getUserInterfaceApi().getCustomIconDefinition(icon.name)
-                : null;
+            let customIcon = icon && 'name' in icon ? this.getCustomIconDefinition(icon.name) : null;
             if (customIcon) {
                 icon = customIcon;
             }
         }
         return icon;
     }
+    getCustomIconDefinition(iconName) {
+        let customIcon = undefined;
+        const customIcons = this.getUserInterfaceApi().getCustomIcons();
+        customIcon = customIcons.find((icon) => icon.name === iconName);
+        if (customIcon) {
+            return customIcon.icon;
+        }
+        return customIcon;
+    }
     shouldShowSelectCellEditor(column) {
         const showSelectCellEditor = this.getEditOptions().showSelectCellEditor;
         if (showSelectCellEditor) {

package/src/Api/LayoutApi.d.ts

@@ -1,5 +1,5 @@
 import { AdaptableColumn, ColumnSort, PivotLayout, TableLayout } from '../../types';
-import { ExtendedLayoutInfo } from '../AdaptableState/Common/ExtendedLayoutInfo';
+import { ExtendedLayout } from '../AdaptableState/Common/ExtendedLayout';
 import { LayoutState, Layout } from '../AdaptableState/LayoutState';
 /**
  * Provides run-time access to the Layout Module and associated state
@@ -61,7 +61,12 @@ export interface LayoutApi {
      * @param layoutName Layout to retrieve
      * @returns layout
      */
-    getExtendedLayoutByName(layoutName: string): ExtendedLayoutInfo | undefined;
+    getExtendedLayoutByName(layoutName: string): ExtendedLayout | undefined;
+    /**
+     * Creates (or Updates) an Extended Layout
+     * @param extendedLayoutInfo extendedLayout to Create
+     */
+    createOrUpdateExtendedLayout(extendedLayoutInfo: ExtendedLayout): void;
     /**
      * Retrieves all Layouts in Adaptable State
      * @returns layouts

package/src/Api/PlusMinusApi.d.ts

@@ -1,5 +1,6 @@
 import { PlusMinusState, PlusMinusNudge } from '../AdaptableState/PlusMinusState';
 import { CellUpdateRequest, GridCell } from '../AdaptableState/Selection/GridCell';
+import { LayoutExtendedConfig } from '../types';
 /**
  * Provides run-time access to the Plus / Minus Module and associated state
  */
@@ -10,27 +11,25 @@ export interface PlusMinusApi {
     getPlusMinusState(): PlusMinusState;
     /**
      * Retrieves all Plus Minus Rules in Adaptable State with those with expressions first
-     * @returns plus minus rule
+     * @returns all plus minus rules
      */
-    getAllPlusMinus(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): PlusMinusNudge[];
+    getAllPlusMinus(config?: LayoutExtendedConfig): PlusMinusNudge[];
     /**
      * Retrieves Plus Minus Rule by the technical ID (from `PlusMinusState`)
      * @param id Plus Minus id
      * @returns plus minus rule
      */
-    getPlusMinusById(id: PlusMinusNudge['Uuid']): PlusMinusNudge;
+    getPlusMinusById(id: PlusMinusNudge['Uuid'], config?: LayoutExtendedConfig): PlusMinusNudge;
     /**
      * Retrieves all active (not-suspended) Plus Minus Rules in Adaptable State with those with expressions first
      * @returns plus minus rules
      */
-    getAllActivePlusMinus(): PlusMinusNudge[];
+    getAllActivePlusMinus(config?: LayoutExtendedConfig): PlusMinusNudge[];
     /**
      * Retrieves all suspended Plus Minus Rules in Adaptable State with those with expressions first
      * @returns plus minus rules
      */
-    getAllSuspendedPlusMinus(): PlusMinusNudge[];
+    getAllSuspendedPlusMinus(config?: LayoutExtendedConfig): PlusMinusNudge[];
     /**
      * Applies a Plus Minus Rule to given cells
      * @param plusMinusNudge Plus Minus Rule to apply
@@ -53,6 +52,11 @@ export interface PlusMinusApi {
      * @returns plus minus rule
      */
     editPlusMinusNudge(plusMinusNudge: PlusMinusNudge): PlusMinusNudge;
+    /**
+     * Deletes a plus minus rule
+     * @param plusMinusNudge Plus Minus Rule to delete
+     */
+    deletePlusMinusNudge(plusMinusNudge: PlusMinusNudge): void;
     /**
      * Adds new Plus Minus Rule to State
      * @param plusMinusNudge Plus Minus Rule to add

package/src/Api/ScheduleApi.d.ts

@@ -3,6 +3,7 @@ import { ReportSchedule } from '../AdaptableState/ExportState';
 import { IPushPullSchedule } from '../AdaptableState/IPushPullState';
 import { OpenFinSchedule } from '../AdaptableState/OpenFinState';
 import { ReminderSchedule, ScheduleState } from '../AdaptableState/ScheduleState';
+import { LayoutExtendedConfig } from '../types';
 /**
  * Provides run-time access to the Schedule Module and associated state
  */
@@ -15,30 +16,28 @@ export interface ScheduleApi {
      * Retrieves the Schedule section from Adaptable State
      * @returns schedules
      */
-    getSchedules(): BaseSchedule[];
+    getSchedules(config?: LayoutExtendedConfig): BaseSchedule[];
     /**
      * Retrieves Schedule by id
      * @param id Schedule id
      * @returns schedule
      */
-    getScheduleById(id: BaseSchedule['Uuid']): BaseSchedule;
+    getScheduleById(id: BaseSchedule['Uuid'], config?: LayoutExtendedConfig): BaseSchedule;
     /**
      * Retrieves all Reminder-based Schedules from Schedule State
      * @returns reminder schedules
      */
-    getReminderSchedules(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): ReminderSchedule[];
+    getReminderSchedules(config?: LayoutExtendedConfig): ReminderSchedule[];
     /**
      * Retrieves all active (not-suspended) Reminder-based Schedules from Schedule State
      * @returns reminder schedules
      */
-    getActiveReminderSchedules(): ReminderSchedule[];
+    getActiveReminderSchedules(config?: LayoutExtendedConfig): ReminderSchedule[];
     /**
      * Retrieves all suspended Reminder-based Schedules from Schedule State
      * @returns reminder schedules
      */
-    getSuspendedReminderSchedules(): ReminderSchedule[];
+    getSuspendedReminderSchedules(config?: LayoutExtendedConfig): ReminderSchedule[];
     /**
      * Adds Reminder-based Schedule
      * @param ReminderSchedule Reminder Schedule to add
@@ -72,9 +71,7 @@ export interface ScheduleApi {
      * Retrieves all Report / Export Schedules from Schedule State
      * @returns report schedules
      */
-    getReportSchedules(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): ReportSchedule[];
+    getReportSchedules(config?: LayoutExtendedConfig): ReportSchedule[];
     /**
      * Retrieves all active (not-suspended) Report / Export Schedules from Schedule State
      * @returns report schedules
@@ -118,9 +115,7 @@ export interface ScheduleApi {
      * Retrieves all ipushpull-based Schedules from Schedule State
      * @returns IPushPull schedules
      */
-    getIPushPullSchedules(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): IPushPullSchedule[];
+    getIPushPullSchedules(config?: LayoutExtendedConfig): IPushPullSchedule[];
     /**
      * Retrieves all active (not-suspended) ipushpull-based Schedules from Schedule State
      * @returns IPushPull schedules
@@ -164,9 +159,7 @@ export interface ScheduleApi {
      * Retrieves all OpenFin-based Schedules from Schedule State
      * @returns OpenFin schedules
      */
-    getOpenFinSchedules(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): OpenFinSchedule[];
+    getOpenFinSchedules(config?: LayoutExtendedConfig): OpenFinSchedule[];
     /**
      * Retrieves all active (not-suspended) OpenFin-based Schedules from Schedule State
      * @returns OpenFin schedules