@adaptabletools/adaptable 20.3.0 → 21.0.0-canary.0

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

package/src/Api/ShortcutApi.d.ts

@@ -1,4 +1,5 @@
 import { ShortcutState, Shortcut } from '../AdaptableState/ShortcutState';
+import { LayoutExtendedConfig } from '../types';
 /**
  * Provides run-time access to Shortcut Module and associated state
  */
@@ -11,25 +12,23 @@ export interface ShortcutApi {
      * Gets all Shortcuts in Adaptable State
      * @returns shortcuts
      */
-    getShortcuts(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): Shortcut[];
+    getShortcuts(config?: LayoutExtendedConfig): Shortcut[];
     /**
      * Retrieves Shortcut by Id
      * @param id Shortcut id
      * @returns shortcut
      */
-    getShortcutById(id: Shortcut['Uuid']): Shortcut;
+    getShortcutById(id: Shortcut['Uuid'], config?: LayoutExtendedConfig): Shortcut;
     /**
      * Gets all active (not-suspended) Shortcuts in Adaptable State
      * @returns shortcuts
      */
-    getActiveShortcuts(): Shortcut[];
+    getActiveShortcuts(config?: LayoutExtendedConfig): Shortcut[];
     /**
      * Gets all suspended Shortcuts in Adaptable State
      * @returns shortcuts
      */
-    getSuspendedShortcuts(): Shortcut[];
+    getSuspendedShortcuts(config?: LayoutExtendedConfig): Shortcut[];
     /**
      * Adds new Shortcut to the state
      * @param shortcut Shortcut to add

package/src/Api/StyledColumnApi.d.ts

@@ -1,5 +1,6 @@
 import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
 import { StyledColumn, StyledColumnState } from '../AdaptableState/StyledColumnState';
+import { LayoutExtendedConfig } from '../types';
 /**
  * Provides run-time access to Styled Column Module and associated state
  */
@@ -12,36 +13,38 @@ export interface StyledColumnApi {
      * Retrieves all Styled Columns in Adaptable State
      * @returns Styled Columns
      */
-    getStyledColumns(config?: {
-        includeLayoutNotAssociatedObjects?: boolean;
-    }): StyledColumn[];
+    getStyledColumns(config?: LayoutExtendedConfig): StyledColumn[];
     /**
      * Retrieves Styled Column by Id
      * @param id Styled Column id
      * @returns Styled Column
      */
-    getStyledColumnById(id: StyledColumn['Uuid']): StyledColumn;
+    getStyledColumnById(id: StyledColumn['Uuid'], config?: LayoutExtendedConfig): StyledColumn;
     /**
      * Retrieves Styled Column for given Column Id
      * @param columnId Styled Column id
      * @returns Styled Column
      */
-    getStyledColumnForColumnId(columnId: StyledColumn['ColumnId']): StyledColumn;
+    getStyledColumnForColumnId(columnId: StyledColumn['ColumnId'], config?: LayoutExtendedConfig): StyledColumn;
     /**
      * Retrieves all active (not-suspended) Styled Columns in Adaptable State
      * @returns Styled Columns
      */
-    getActiveStyledColumns(): StyledColumn[];
+    getActiveStyledColumns(config?: LayoutExtendedConfig): StyledColumn[];
     /**
      * Retrieves all suspended Styled Columns in Adaptable State
      * @returns Styled Columns
      */
-    getSuspendedStyledColumns(): StyledColumn[];
+    getSuspendedStyledColumns(config?: LayoutExtendedConfig): StyledColumn[];
     /**
      * Delete a Styled column
      * @param styledColumn
      */
     deleteStyledColumn(styledColumn: StyledColumn): void;
+    /**
+     * Delete all Styled Columns in State
+     */
+    deleteAllStyledColumns(): void;
     /**
      * Create a Styled column
      * @param styledColumn

package/src/Api/UserInterfaceApi.d.ts

@@ -1,6 +1,6 @@
 import { AdaptableStyle } from '../AdaptableState/Common/AdaptableStyle';
 import { AdaptableObject, AdaptableObjectTag } from '../AdaptableState/Common/AdaptableObject';
-import { AdaptableIcon, AdaptableModule } from '../types';
+import { AdaptableModule, CustomIcon } from '../types';
 import { CustomWindowConfig } from '../AdaptableState/Common/CustomWindowConfig';
 import { ProgressIndicatorConfig } from '../AdaptableState/Common/ProgressIndicatorConfig';
 /**
@@ -11,6 +11,10 @@ export interface UserInterfaceApi {
      * Retrieves Color Palette currently being used
      */
     getColorPalette(): string[];
+    /**
+     * Retrieves Custom Icons provided by users
+     */
+    getCustomIcons(): CustomIcon[];
     /**
      * Retrieves any Style Class Names from User Interface Options
      */
@@ -37,11 +41,6 @@ export interface UserInterfaceApi {
      * @param adaptableModule optional Module to check
      */
     getAdaptableObjectsWithTag(tag: AdaptableObjectTag, adaptableModule?: AdaptableModule): AdaptableObject[] | undefined;
-    /**
-     * Returns AdapTable Icon with given name
-     * @param name name of Icon
-     */
-    getCustomIconDefinition(name: string): AdaptableIcon | undefined;
     /**
      * Displays a progress indicator
      * @param config.progressText - text to display in the progress indicator

package/src/Redux/ActionsReducers/InternalRedux.d.ts

@@ -63,7 +63,7 @@ export declare const SETTINGS_PANEL_SET = "SETTINGS_PANEL_SET";
 export declare const QUICK_FILTER_BAR_SHOW = "QUICK_FILTER_BAR_SHOW";
 export declare const QUICK_FILTER_BAR_HIDE = "QUICK_FILTER_BAR_HIDE";
 export declare const DISABLE_DELETE_CONFIRMATION = "DISABLE_DELETE_CONFIRMATION";
-export declare const LAYOUT_SHOW_NOT_ASSOCIATED_OBJECTS = "LAYOUT_SHOW_NOT_ASSOCIATED_OBJECTS";
+export declare const LAYOUT_SHOW_NON_EXTENDED_OBJECTS = "LAYOUT_SHOW_NON_EXTENDED_OBJECTS";
 export declare const DASHBOARD_REFRESH = "DASHBOARD_REFRESH";
 export declare const DATA_SET_SELECT = "DATA_SET_SELECT";
 export declare const CHARTING_SET_CURRENT_CHART_MODELS = "CHARTING_SET_CURRENT_CHART_MODELS";
@@ -261,8 +261,8 @@ export interface QuickFilterBarShowAction extends Redux.Action {
 }
 export interface QuickFilterBarHideAction extends Redux.Action {
 }
-export interface LayoutShowNotAssociatedObjectsAction extends Redux.Action {
-    showNotAssociatedObjects: boolean;
+export interface LayoutShowNonExtendedObjectsAction extends Redux.Action {
+    showNonExtendedObjects: boolean;
 }
 export interface DataSetSelectAction extends Redux.Action {
     dataSet: DataSet;
@@ -324,7 +324,7 @@ export declare const DataChangeHistoryResume: () => DataChangeHistoryResumeActio
 export declare const SettingsPanelSet: (name: string, settings: InternalState['SettingsPanel']['0']) => SettingsPanelSetAction;
 export declare const QuickFilterBarShow: () => QuickFilterBarShowAction;
 export declare const QuickFilterBarHide: () => QuickFilterBarHideAction;
-export declare const LayoutShowNotAssociatedObjects: (showNotAssociatedObjects: boolean) => LayoutShowNotAssociatedObjectsAction;
+export declare const LayoutShowNonExtendedObjects: (showNonExtendedObjects: boolean) => LayoutShowNonExtendedObjectsAction;
 export declare const DashboardRefresh: () => DashboardRefreshAction;
 export declare const DataSetSelect: (dataSet: DataSet) => DataSetSelectAction;
 export declare const ChartingSetCurrentChartModels: (chartModels: ChartModel[]) => ChartingSetCurrentChartModelsAction;

package/src/Redux/ActionsReducers/InternalRedux.js

@@ -75,7 +75,7 @@ export const QUICK_FILTER_BAR_HIDE = 'QUICK_FILTER_BAR_HIDE';
 // Delete warning
 export const DISABLE_DELETE_CONFIRMATION = 'DISABLE_DELETE_CONFIRMATION';
 // Layout
-export const LAYOUT_SHOW_NOT_ASSOCIATED_OBJECTS = 'LAYOUT_SHOW_NOT_ASSOCIATED_OBJECTS';
+export const LAYOUT_SHOW_NON_EXTENDED_OBJECTS = 'LAYOUT_SHOW_NON_EXTENDED_OBJECTS';
 export const DASHBOARD_REFRESH = 'DASHBOARD_REFRESH';
 // DataSet
 export const DATA_SET_SELECT = 'DATA_SET_SELECT';
@@ -275,9 +275,9 @@ export const QuickFilterBarShow = () => ({
 export const QuickFilterBarHide = () => ({
     type: QUICK_FILTER_BAR_HIDE,
 });
-export const LayoutShowNotAssociatedObjects = (showNotAssociatedObjects) => ({
-    type: LAYOUT_SHOW_NOT_ASSOCIATED_OBJECTS,
-    showNotAssociatedObjects,
+export const LayoutShowNonExtendedObjects = (showNonExtendedObjects) => ({
+    type: LAYOUT_SHOW_NON_EXTENDED_OBJECTS,
+    showNonExtendedObjects: showNonExtendedObjects,
 });
 export const DashboardRefresh = () => ({
     type: DASHBOARD_REFRESH,
@@ -388,7 +388,7 @@ const initialState = {
         externalChartingDefinitions: [],
     },
     Layout: {
-        ShowLayoutNotAssociatedObjects: false,
+        showLayoutNonExtendedObjects: false,
     },
     DisableDeleteConfirmation: false,
     Export: {
@@ -769,12 +769,12 @@ export const InternalReducer = (state = initialState, action) => {
             return Object.assign({}, state, { IsQuickFilterVisible: true });
         case QUICK_FILTER_BAR_HIDE:
             return Object.assign({}, state, { IsQuickFilterVisible: false });
-        case LAYOUT_SHOW_NOT_ASSOCIATED_OBJECTS: {
+        case LAYOUT_SHOW_NON_EXTENDED_OBJECTS: {
             const typedAction = action;
             return {
                 ...state,
                 Layout: {
-                    ShowLayoutNotAssociatedObjects: typedAction.showNotAssociatedObjects,
+                    showLayoutNonExtendedObjects: typedAction.showNonExtendedObjects,
                 },
             };
         }

package/src/Redux/ActionsReducers/StyledColumnRedux.d.ts

@@ -12,6 +12,10 @@ export declare const STYLED_COLUMN_EDIT = "STYLED_COLUMN_EDIT";
  * @ReduxAction A Special Column Style has been deleted
  */
 export declare const STYLED_COLUMN_DELETE = "STYLED_COLUMN_DELETE";
+/**
+ * @ReduxAction Delete ALL Styled Columns
+ */
+export declare const STYLED_COLUMN_DELETE_ALL = "STYLED_COLUMN_DELETE_ALL";
 /**
  * @ReduxAction StyledColumn Module is ready
  */
@@ -41,6 +45,8 @@ export interface StyledColumnEditAction extends StyledColumnAction {
 }
 export interface StyledColumnDeleteAction extends StyledColumnAction {
 }
+export interface StyledColumnDeleteAllAction extends Redux.Action {
+}
 export interface StyledColumnSuspendAction extends StyledColumnAction {
 }
 export interface StyledColumnUnSuspendAction extends StyledColumnAction {
@@ -55,6 +61,7 @@ export interface StyledColumnReadyAction extends Redux.Action {
 export declare const StyledColumnAdd: (formatColumn: StyledColumn) => StyledColumnAddAction;
 export declare const StyledColumnEdit: (formatColumn: StyledColumn) => StyledColumnEditAction;
 export declare const StyledColumnDelete: (formatColumn: StyledColumn) => StyledColumnDeleteAction;
+export declare const StyledColumnDeleteAll: () => StyledColumnDeleteAllAction;
 export declare const StyledColumnSuspend: (formatColumn: StyledColumn) => StyledColumnSuspendAction;
 export declare const StyledColumnUnSuspend: (formatColumn: StyledColumn) => StyledColumnSuspendAction;
 export declare const StyledColumnSuspendAll: () => StyledColumnSuspendAllAction;

package/src/Redux/ActionsReducers/StyledColumnRedux.js

@@ -13,6 +13,10 @@ export const STYLED_COLUMN_EDIT = 'STYLED_COLUMN_EDIT';
  * @ReduxAction A Special Column Style has been deleted
  */
 export const STYLED_COLUMN_DELETE = 'STYLED_COLUMN_DELETE';
+/**
+ * @ReduxAction Delete ALL Styled Columns
+ */
+export const STYLED_COLUMN_DELETE_ALL = 'STYLED_COLUMN_DELETE_ALL';
 /**
  * @ReduxAction StyledColumn Module is ready
  */
@@ -45,6 +49,9 @@ export const StyledColumnDelete = (formatColumn) => ({
     type: STYLED_COLUMN_DELETE,
     StyledColumn: formatColumn,
 });
+export const StyledColumnDeleteAll = () => ({
+    type: STYLED_COLUMN_DELETE_ALL,
+});
 export const StyledColumnSuspend = (formatColumn) => ({
     type: STYLED_COLUMN_SUSPEND,
     StyledColumn: formatColumn,
@@ -89,6 +96,12 @@ export const StyledColumnReducer = (state = initialState, action) => {
                 StyledColumns: state.StyledColumns.filter((abObject) => abObject.Uuid !== actionStyledColumn.Uuid),
             };
         }
+        case STYLED_COLUMN_DELETE_ALL: {
+            return {
+                ...state,
+                StyledColumns: [],
+            };
+        }
         case STYLED_COLUMN_SUSPEND: {
             return {
                 ...state,

package/src/Redux/Store/AdaptableStore.js

@@ -892,18 +892,18 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     const newLayout = (newLayoutState.Layouts || []).find((l) => l.Name == newLayoutState.CurrentLayout) ||
                         newLayoutState.Layouts[0] ||
                         ERROR_LAYOUT;
-                    // Apply filtering if Column or Grid filters have been changed
-                    let refreshFilters = false;
+                    const changedColumnSorts = adaptable.api.layoutApi.internalApi.getChangedColumnSorts(oldLayout.ColumnSorts, newLayout.ColumnSorts);
+                    changedColumnSorts.forEach((columnId) => adaptable.api.filterApi.columnFilterApi.resetFilterValues(columnId));
+                    let refreshColumnFilters = false;
                     if (adaptable.api.filterApi.columnFilterApi.internalApi.areColumnFiltersDifferent(oldLayout.ColumnFilters, newLayout.ColumnFilters)) {
-                        refreshFilters = true;
+                        refreshColumnFilters = true;
                     }
-                    // Apply Grid filtering if Grid filter has been changed
-                    if (!refreshFilters &&
-                        adaptable.api.filterApi.gridFilterApi.internalApi.isGridFilterDifferent(oldLayout.GridFilter, newLayout.GridFilter)) {
-                        refreshFilters = true;
+                    let refreshGridFilter = false;
+                    if (adaptable.api.filterApi.gridFilterApi.internalApi.isGridFilterDifferent(oldLayout.GridFilter, newLayout.GridFilter)) {
+                        refreshGridFilter = true;
                     }
-                    if (refreshFilters) {
-                        adaptable.applyFiltering();
+                    if (refreshColumnFilters || refreshGridFilter) {
+                        adaptable.applyFiltering({ updateColumnFilterModel: refreshColumnFilters });
                     }
                     if (returnAction.type == LayoutRedux.LAYOUT_SELECT ||
                         returnAction.type == LayoutRedux.LAYOUT_DELETE) {
@@ -969,7 +969,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     adaptable.api.eventApi.internalApi.fireGridFilterAppliedEvent();
                     adaptable.api.eventApi.internalApi.fireLayoutChangedEvent(action.type, null, middlewareAPI.getState().Layout);
                     setTimeout(() => {
-                        adaptable.applyFiltering();
+                        adaptable.applyFiltering({ updateColumnFilterModel: false });
                     }, 5);
                     return next(returnAction);
                 }