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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "21.0.0-canary.0",
+  "version": "21.0.0-canary.2",
   "description": "Powerful data-agnostic HTML5 AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",

package/src/AdaptableInterfaces/IAdaptable.d.ts

@@ -10,7 +10,7 @@ import { SelectedCellInfo } from '../AdaptableState/Selection/SelectedCellInfo';
 import { AdaptableTheme } from '../AdaptableState/ThemeState';
 import { IAdaptableStore } from '../Redux/Store/Interface/IAdaptableStore';
 import { IModuleCollection } from '../Strategy/Interface/IModule';
-import { AdaptableMenuItem, AdaptableOptions, AdaptablePlugin, AdaptableState, ChartDefinition, InFilterValue, SelectedRowInfo } from '../types';
+import { AdaptableMenuItem, AdaptableOptions, AdaptablePlugin, AdaptableState, ChartDefinition, InFilterValueResult, SelectedRowInfo } from '../types';
 import { ICalculatedColumnExpressionService } from '../Utilities/Services/Interface/ICalculatedColumnExpressionService';
 import { IDataService } from '../Utilities/Services/Interface/IDataService';
 import { AnnotationsService } from '../Utilities/Services/AnnotationsService';
@@ -183,7 +183,8 @@ export interface IAdaptable {
     getDistinctFilterValuesForColumn(options: {
         column: AdaptableColumn;
         currentSearchValue: string;
-    }): Promise<InFilterValue[]>;
+        previousResult: InFilterValueResult | undefined;
+    }): Promise<InFilterValueResult>;
     getGridCellFromRowNode(rowNode: IRowNode, columnId: string): GridCell | undefined;
     getRawValueFromRowNode(rowNode: IRowNode, columnId: string): any;
     getDisplayValueFromRowNode(rowNode: IRowNode, columnId: string): string | undefined;

package/src/AdaptableOptions/DefaultAdaptableOptions.js

@@ -150,7 +150,6 @@ const DefaultAdaptableOptions = {
         columnFilterOptions: {
             indicateFilteredColumns: true,
             autoApplyColumnFilter: true,
-            cacheInFilterValues: true,
             defaultNumericColumnFilter: 'Equals',
             defaultTextColumnFilter: 'Contains',
             defaultDateColumnFilter: 'On',

package/src/AdaptableOptions/EditOptions.d.ts

@@ -58,7 +58,12 @@ export interface EditColumnValueInfo {
     value: any;
     label?: string;
 }
-export interface CustomEditColumnValueInfo extends EditColumnValueInfo {
+/**
+ * Information about items in the custom Edit Controls
+ */
+export interface CustomEditColumnValueInfo {
+    value: any;
+    label?: string;
 }
 /**
  * Used for Server Validation ie. after an edit in AG Grid which must be checked on Server

package/src/AdaptableOptions/FilterOptions.d.ts

@@ -30,7 +30,7 @@ export interface FilterOptions<TData = any> {
      * @param context
      * @returns
      */
-    customInFilterValues?: (context: CustomInFilterValuesContext<TData>) => Promise<InFilterValueInfo[]> | InFilterValueInfo[];
+    customInFilterValues?: (context: CustomInFilterValuesContext<TData>) => Promise<InFilterValueResult> | InFilterValueResult;
     /**
      * When to re-filter grid after data changes: 'Always', 'Never' or 'Throttle' (with a delay value)
      *
@@ -86,13 +86,6 @@ export interface ColumnFilterOptions<TData = any> {
      * @noCodeItem
      */
     autoApplyColumnFilter?: boolean | ((context: AdaptableColumnContext) => boolean);
-    /**
-     * Whether to cache the values in the IN Filter component
-     * @defaultValue true
-     * @gridInfoItem
-     * @noCodeItem
-     */
-    cacheInFilterValues?: boolean | ((context: AdaptableColumnContext) => boolean);
     /**
      * Default filter type for numeric Columns
      *
@@ -212,6 +205,20 @@ export interface InFilterValue<ValueType = any> {
      */
     tooltip?: boolean | string;
 }
+/**
+ * Result when providing custom values for the IN Column Filter
+ */
+export type InFilterValueResult = {
+    /**
+     * List of Items to display in the IN Column Filter
+     */
+    values: InFilterValueInfo[];
+    /**
+     * When TRUE, displays the provided values without any filtering.
+     * When FALSE, the values are filtered based on the current search text.
+     */
+    skipDefaultSearch?: boolean;
+};
 /**
  * Information about items in the IN Column Filter
  */
@@ -253,6 +260,11 @@ export interface CustomInFilterValuesContext<TData = any> extends AdaptableColum
      * Search text in the IN Filter component - used when filtering on server
      */
     currentSearchValue: string;
+    /**
+     * Memoized result from previous invocation. Helps avoid expensive recomputations,
+     * especially for async operations (e.g. server-side filtering).
+     */
+    previousFilterResult?: InFilterValueResult;
 }
 /**
  * List of Editors that can be used when creating the Grid Filter

package/src/AdaptableOptions/LayoutOptions.d.ts

@@ -1,4 +1,4 @@
-import { Layout } from '../AdaptableState/LayoutState';
+import { Layout, PivotLayout, TableLayout } from '../AdaptableState/LayoutState';
 import { AdaptableObjectTag } from '../AdaptableState/Common/AdaptableObject';
 import { BaseContext, LayoutExtensionModule, LayoutExtensionObject } from '../../types';
 /**
@@ -17,6 +17,10 @@ export interface LayoutOptions {
      * Columns to display in Table that opens when viewing Pivot Cell contents
      */
     pivotPreviewColumns?: string[] | ((context: PivotPreviewColumnsContext) => string[]);
+    /**
+     * Default properties to apply when creating a new Layout (Table or Pivot)
+     */
+    defaultLayoutProperties?: DefaultLayoutProperties | ((context: DefaultLayoutPropertiesContext) => DefaultTableLayoutProperties | DefaultPivotLayoutProperties);
 }
 /**
  * Options for managing Tags in Layouts (used to enhance Layouts)
@@ -93,3 +97,33 @@ export interface PivotPreviewColumnsContext extends BaseContext {
      */
     columnId: string;
 }
+/**
+ * Default properties to apply when creating a new Table Layout
+ */
+export type DefaultTableLayoutProperties = Partial<Omit<TableLayout, 'Name'>>;
+/**
+ * Default properties to apply when creating a new Pivot Layout
+ */
+export type DefaultPivotLayoutProperties = Partial<Omit<PivotLayout, 'Name'>>;
+/**
+ * Default properties to apply when creating a new Layout (Table or Pivot)
+ */
+export interface DefaultLayoutProperties {
+    /**
+     * Default properties to apply when creating a new Table Layout
+     */
+    tableLayout?: DefaultTableLayoutProperties;
+    /**
+     * Default properties to apply when creating a new Pivot Layout
+     */
+    pivotLayout?: DefaultPivotLayoutProperties;
+}
+/**
+ * Context for `LayoutOptions.defaultLayoutProperties` function
+ */
+export interface DefaultLayoutPropertiesContext extends BaseContext {
+    /**
+     * Type of Layout ('table' | 'pivot')
+     */
+    layoutType: 'table' | 'pivot';
+}

package/src/AdaptableState/Common/AdaptableColumn.d.ts

@@ -1,11 +1,11 @@
 import { AdaptableObject } from './AdaptableObject';
-import { BaseCellDataType, ColDef } from 'ag-grid-enterprise';
+import { ColDef } from 'ag-grid-enterprise';
 import { UniqueGridCell } from '../Selection/GridCell';
 import { ColumnFilter } from './ColumnFilter';
 /**
  * Defines data type of a Column; can be an AG Grid BaseCellDataType or an AdapTable array-related one
  */
-export type AdaptableColumnDataType = BaseCellDataType | 'textArray' | 'numberArray' | 'tupleArray' | 'objectArray' | 'unknown';
+export type AdaptableColumnDataType = 'text' | 'number' | 'boolean' | 'date' | 'object' | 'textArray' | 'numberArray' | 'tupleArray' | 'objectArray' | 'unknown';
 /**
  * Column Types recognised by AdapTable; to be set in GridOptions
  */

package/src/Api/ColumnFilterApi.d.ts

@@ -1,4 +1,4 @@
-import { AdaptableColumn, ColumnFilter, ColumnFilterPredicate, InFilterValue, InFilterValueInfo } from '../types';
+import { AdaptableColumn, ColumnFilter, ColumnFilterPredicate, InFilterValueInfo, InFilterValueResult } from '../types';
 import { AdaptablePredicateDef, ColumnFilterDef } from '../AdaptableState/Common/AdaptablePredicate';
 /**
  * Provides run-time access to Filter section of Adaptable State.
@@ -138,16 +138,16 @@ export interface ColumnFilterApi {
      * @param columnId - the ID of the Column for which to refresh filter values.
      * @return a Promise that resolves to the list of filter values, each represented as an object with `value` and `label` properties.
      */
-    refreshFilterValues(columnId: string): Promise<InFilterValue[]>;
+    refreshFilterValues(columnId: string): Promise<InFilterValueResult>;
     /**
      * Refreshes (reloads) the filter values for ALL Columns (for `IN` Filter).
      *
      * @returns A Promise that resolves to a map where:
      *          - keys are column IDs (string)
-     *          - values are arrays of filter values for the corresponding column
-     *            Each filter value contains a `value` and display `label` property
+     *          - values are objects with a `values` property, which is an array of values for the corresponding column
+     *            Each item in the array contains a `value` and display `label` property
      */
-    refreshAllFilterValues(): Promise<Record<string, InFilterValue[]>>;
+    refreshAllFilterValues(): Promise<Record<string, InFilterValueResult>>;
     /**
      * Reset(clear cache) the filter values for a given Column (for `IN` Filter).
      * @param columnId - the ID of the Column for which to reset filter values.

package/src/Api/Implementation/ColumnApiImpl.js

@@ -414,7 +414,7 @@ export class ColumnApiImpl extends ApiBase {
         return this.getUIAvailableColumns().filter((c) => c.dataType === 'textArray');
     }
     getDateColumns() {
-        return this.getUIAvailableColumns().filter((c) => c.dataType === 'date' || c.dataType === 'dateString');
+        return this.getUIAvailableColumns().filter((c) => c.dataType === 'date');
     }
     getBooleanColumns() {
         return this.getUIAvailableColumns().filter((c) => c.dataType === 'boolean');

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

@@ -1,7 +1,7 @@
 import { ApiBase } from './ApiBase';
 import { AdaptablePredicateDef, ColumnFilterDef } from '../../AdaptableState/Common/AdaptablePredicate';
 import { AdaptableColumn } from '../../AdaptableState/Common/AdaptableColumn';
-import { ColumnFilter, ColumnFilterPredicate, InFilterValueInfo, InFilterValue } from '../../types';
+import { ColumnFilter, ColumnFilterPredicate, InFilterValueInfo, InFilterValueResult } from '../../types';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { ColumnFilterInternalApi } from '../Internal/ColumnFilterInternalApi';
 import { ColumnFilterApi } from '../ColumnFilterApi';
@@ -44,8 +44,8 @@ export declare class ColumnFilterApiImpl extends ApiBase implements ColumnFilter
     suspendAllColumnFilters(): void;
     unSuspendAllColumnFilters(): void;
     addBlanksToInFilterValues(columnDistinctValues: InFilterValueInfo[]): InFilterValueInfo[];
-    refreshFilterValues(columnId: string): Promise<InFilterValue[]>;
-    refreshAllFilterValues(): Promise<Record<string, InFilterValue[]>>;
+    refreshFilterValues(columnId: string): Promise<InFilterValueResult>;
+    refreshAllFilterValues(): Promise<Record<string, InFilterValueResult>>;
     resetFilterValues(columnId: string): void;
     resetAllFilterValues(): void;
 }

package/src/Api/Implementation/ColumnFilterApiImpl.js

@@ -214,19 +214,19 @@ export class ColumnFilterApiImpl extends ApiBase {
     async refreshAllFilterValues() {
         const allFilterHandlers = this.internalApi.getAllAdaptableFilterHandlers();
         const handlerPromises = allFilterHandlers.map(async (handler) => {
-            let values = [];
+            let result = { values: [] };
             if (typeof handler.refreshFilterDisplayValues === 'function') {
-                values = await handler.refreshFilterDisplayValues();
+                result = await handler.refreshFilterDisplayValues();
             }
             else {
                 this.logWarn(`No refresh function for filter handler: ${handler.colId}`);
-                values = [];
+                result = { values: [] };
             }
-            return { columnId: handler.colId, values };
+            return { columnId: handler.colId, result };
         });
         return Promise.all(handlerPromises).then((results) => {
-            return results.reduce((acc, { columnId, values }) => {
-                acc[columnId] = values;
+            return results.reduce((acc, { columnId, result }) => {
+                acc[columnId] = result;
                 return acc;
             }, {});
         });

package/src/Api/Implementation/LayoutApiImpl.js

@@ -2,8 +2,6 @@ import * as LayoutRedux from '../../Redux/ActionsReducers/LayoutRedux';
 import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
 import { ApiBase } from './ApiBase';
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
-import ObjectFactory from '../../Utilities/ObjectFactory';
-import Helper from '../../Utilities/Helpers/Helper';
 import { createUuid } from '../../AdaptableState/Uuid';
 import { PopupShowPrompt } from '../../Redux/ActionsReducers/PopupRedux';
 import { LayoutInternalApi } from '../Internal/LayoutInternalApi';
@@ -275,7 +273,7 @@ export class LayoutApiImpl extends ApiBase {
             this.logError("Cannot create layout with the Name: '" + layoutToCreate.Name + "' as it already exists");
             return false;
         }
-        const newLayout = ObjectFactory.CreateEmptyLayout({ ...layoutToCreate });
+        const newLayout = this.internalApi.buildInitialLayout(layoutToCreate);
         this.addUidToAdaptableObject(newLayout);
         this.dispatchAction(LayoutRedux.LayoutAdd(newLayout));
         return newLayout;
@@ -292,9 +290,11 @@ export class LayoutApiImpl extends ApiBase {
             this.logError("Cannot clone layout with Name: '" + layoutName + "' as other Layout does not exist");
             return false;
         }
-        const newLayout = Helper.cloneObject(layoutToClone);
-        newLayout.Uuid = createUuid();
-        newLayout.Name = layoutName;
+        const newLayout = {
+            ...this.internalApi.cloneLayout(layoutToClone),
+            Name: layoutName,
+            Uuid: createUuid(),
+        };
         this.dispatchAction(LayoutRedux.LayoutAdd(newLayout));
         return this.getLayoutById(newLayout.Uuid);
     }

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

@@ -5,7 +5,7 @@ import { AdaptablePredicateDef } from '../../AdaptableState/Common/AdaptablePred
 import { ColumnFilter } from '../../AdaptableState/Common/ColumnFilter';
 import { GridCell } from '../../AdaptableState/Selection/GridCell';
 import { LayoutColumnFilterAction } from '../../Redux/ActionsReducers/LayoutRedux';
-import { InFilterValue } from '../../types';
+import { InFilterValueResult } from '../../types';
 import { ApiBase } from '../Implementation/ApiBase';
 import { AdaptableFilterHandler } from '../../agGrid/AdaptableFilterHandler';
 export declare class ColumnFilterInternalApi extends ApiBase {
@@ -53,8 +53,7 @@ export declare class ColumnFilterInternalApi extends ApiBase {
     getColumnFilterValues(options: {
         columnId: string;
         currentSearchValue: string;
-    }): Promise<InFilterValue[]>;
+    }): Promise<InFilterValueResult>;
     shouldAutoApplyColumnFilter(columnId: string): boolean;
-    shouldCacheColumnFilterValues(columnId: string): boolean;
     getAllAdaptableFilterHandlers(): AdaptableFilterHandler[];
 }

package/src/Api/Internal/ColumnFilterInternalApi.js

@@ -240,20 +240,28 @@ export class ColumnFilterInternalApi extends ApiBase {
      * Only if the FilterHandler is not available we fallback to the GridApi method
      */
     async getColumnFilterValues(options) {
-        const shouldUseCachedValues = this.shouldCacheColumnFilterValues(options.columnId);
-        if (!shouldUseCachedValues) {
-            return this.getGridApi().internalApi.getDistinctFilterDisplayValuesForColumn(options);
-        }
+        const filterOptions = this.getOptionsApi().getFilterOptions();
+        const newOptions = {
+            columnId: options.columnId,
+            get currentSearchValue() {
+                // we need this in order to keep it lazy
+                return options.currentSearchValue;
+            },
+            previousResult: undefined,
+        };
         const columnFilterHandler = this.getAgGridApi().getColumnFilterHandler(options.columnId);
         if (!columnFilterHandler) {
             this.logWarn(`No ColumnFilterHandler found for columnId: ${options.columnId}!`);
-            return this.getGridApi().internalApi.getDistinctFilterDisplayValuesForColumn(options);
+            return this.getGridApi().internalApi.getDistinctFilterDisplayValuesForColumn(newOptions);
+        }
+        if (typeof columnFilterHandler.getFilterDisplayValuesFromCache !== 'function') {
+            this.logWarn(`ColumnFilterHandler for columnId: ${options.columnId} does not have getFilterDisplayValuesFromCache method!`);
+            return this.getGridApi().internalApi.getDistinctFilterDisplayValuesForColumn(newOptions);
         }
-        if (typeof columnFilterHandler.getFilterDisplayValues !== 'function') {
-            this.logWarn(`ColumnFilterHandler for columnId: ${options.columnId} does not have getFilterDisplayValues method!`);
-            return this.getGridApi().internalApi.getDistinctFilterDisplayValuesForColumn(options);
+        if (filterOptions.customInFilterValues) {
+            return columnFilterHandler.fetchFilterDisplayValues(newOptions);
         }
-        return columnFilterHandler.getFilterDisplayValues(options.currentSearchValue);
+        return columnFilterHandler.getFilterDisplayValuesFromCache(newOptions);
     }
     shouldAutoApplyColumnFilter(columnId) {
         const autoApplyColumnFilterOpt = this.getOptionsApi().getFilterOptions().columnFilterOptions?.autoApplyColumnFilter;
@@ -271,22 +279,6 @@ export class ColumnFilterInternalApi extends ApiBase {
         // fallback, should never happen
         return true;
     }
-    shouldCacheColumnFilterValues(columnId) {
-        const cacheColumnFilterValuesOpt = this.getOptionsApi().getFilterOptions().columnFilterOptions?.cacheInFilterValues;
-        if (typeof cacheColumnFilterValuesOpt === 'boolean') {
-            return cacheColumnFilterValuesOpt;
-        }
-        if (typeof cacheColumnFilterValuesOpt === 'function') {
-            const column = this.getColumnApi().getColumnWithColumnId(columnId);
-            const context = {
-                column,
-                ...this.getAdaptableApi().internalApi.buildBaseContext(),
-            };
-            return cacheColumnFilterValuesOpt(context);
-        }
-        // fallback, should never happen
-        return true;
-    }
     getAllAdaptableFilterHandlers() {
         const allFilterableColumns = this.getColumnApi().getFilterableColumns();
         const filterHandlers = allFilterableColumns

package/src/Api/Internal/ColumnInternalApi.js

@@ -296,6 +296,6 @@ export class ColumnInternalApi extends ApiBase {
     }
     getColumnDateTypes() {
         // this is required because Adaptable uses 'date' type for all AG Grid date types: 'date', 'dateString'
-        return ['date', 'dateString'];
+        return ['date'];
     }
 }

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

@@ -5,7 +5,7 @@ import { SpecialColumnSettings } from '../../AdaptableState/Common/SpecialColumn
 import { GridCell } from '../../AdaptableState/Selection/GridCell';
 import { SelectedCellInfo } from '../../AdaptableState/Selection/SelectedCellInfo';
 import { SelectedRowInfo } from '../../AdaptableState/Selection/SelectedRowInfo';
-import { InFilterValue } from '../../types';
+import { InFilterValueResult } from '../../types';
 import { ApiBase } from '../Implementation/ApiBase';
 import { EditColumnValueInfo } from '../../AdaptableOptions/EditOptions';
 export declare class GridInternalApi extends ApiBase {
@@ -29,7 +29,8 @@ export declare class GridInternalApi extends ApiBase {
     getDistinctFilterDisplayValuesForColumn(options: {
         columnId: string;
         currentSearchValue: string;
-    }): Promise<InFilterValue[]>;
+        previousResult: InFilterValueResult | undefined;
+    }): Promise<InFilterValueResult>;
     getDistinctValuesForColumn(columnId: string): Promise<GridCell[]> | undefined;
     getDistinctEditDisplayValuesForColumn(options: {
         columnId: string;

package/src/Api/Internal/GridInternalApi.js

@@ -35,15 +35,16 @@ export class GridInternalApi extends ApiBase {
     async getDistinctFilterDisplayValuesForColumn(options) {
         const abColumn = this.getColumnApi().getColumnWithColumnId(options.columnId);
         if (abColumn == undefined) {
-            return [];
+            return { values: [] };
         }
         const inFilterValues = await this._adaptable.getDistinctFilterValuesForColumn({
             column: abColumn,
             get currentSearchValue() {
                 return options.currentSearchValue;
             },
+            previousResult: options.previousResult,
         });
-        return inFilterValues || [];
+        return inFilterValues || { values: [] };
     }
     async getDistinctValuesForColumn(columnId) {
         const abColumn = this.getColumnApi().getColumnWithColumnId(columnId);

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

@@ -32,4 +32,9 @@ export declare class LayoutInternalApi extends ApiBase {
     setupRowSummaries(): void;
     refreshLayout(): void;
     getChangedColumnSorts(oldSorts: LayoutBase['ColumnSorts'], newSorts: LayoutBase['ColumnSorts']): string[];
+    buildInitialLayout(providedLayout: Partial<Layout> & {
+        Name: string;
+    }, type?: 'table' | 'pivot'): Layout;
+    private getDefaultLayoutProperties;
+    cloneLayout(layoutToClone: Layout): Omit<Layout, 'Name'>;
 }

package/src/Api/Internal/LayoutInternalApi.js

@@ -1,7 +1,10 @@
 import { ColumnFilterModuleId, GridFilterModuleId, } from '../../Utilities/Constants/ModuleConstants';
 import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import { ApiBase } from '../Implementation/ApiBase';
-import { areLayoutsEqual, normalizeLayout } from '../Implementation/LayoutHelpers';
+import { areLayoutsEqual, isPivotLayout, normalizeLayout } from '../Implementation/LayoutHelpers';
+import ObjectFactory from '../../Utilities/ObjectFactory';
+import Helper from '../../Utilities/Helpers/Helper';
+import AdaptableHelper from '../../Utilities/Helpers/AdaptableHelper';
 export class LayoutInternalApi extends ApiBase {
     getNormalizedLayout(layout) {
         return normalizeLayout(layout);
@@ -206,4 +209,44 @@ export class LayoutInternalApi extends ApiBase {
         });
         return changedColumnIds;
     }
+    buildInitialLayout(providedLayout, type) {
+        const layoutType = type || (isPivotLayout(providedLayout) ? 'pivot' : 'table');
+        const providedTableLayout = providedLayout;
+        const providedPivotLayout = providedLayout;
+        const initialEmptyLayout = layoutType === 'pivot'
+            ? ObjectFactory.CreateEmptyPivotLayout({ ...providedPivotLayout })
+            : ObjectFactory.CreateEmptyTableLayout({ ...providedTableLayout });
+        const defaultLayoutProperties = this.getDefaultLayoutProperties(layoutType);
+        const initialLayout = {
+            ...initialEmptyLayout,
+            ...defaultLayoutProperties,
+        };
+        return initialLayout;
+    }
+    getDefaultLayoutProperties(layoutType) {
+        const defaultLayoutPropertiesOption = this.getLayoutOptions().defaultLayoutProperties;
+        if (typeof defaultLayoutPropertiesOption === 'object') {
+            const initialProps = layoutType === 'table'
+                ? defaultLayoutPropertiesOption.tableLayout
+                : defaultLayoutPropertiesOption.pivotLayout;
+            return initialProps;
+        }
+        if (typeof defaultLayoutPropertiesOption === 'function') {
+            const context = {
+                layoutType,
+                ...this.getAdaptableInternalApi().buildBaseContext(),
+            };
+            return defaultLayoutPropertiesOption(context);
+        }
+        return {};
+    }
+    cloneLayout(layoutToClone) {
+        let clonedLayout = Helper.cloneObject(layoutToClone);
+        let result = {
+            ...this.buildInitialLayout(clonedLayout),
+        };
+        result = AdaptableHelper.removeAdaptableObjectPrimitivesInlineDeep(result);
+        delete result.Name;
+        return result;
+    }
 }

package/src/Api/Internal/PredicateInternalApi.js

@@ -106,7 +106,6 @@ export class PredicateInternalApi extends ApiBase {
                 predicateId = 'Equals';
                 break;
             case 'date':
-            case 'dateString':
                 predicateId = 'On';
                 break;
             case 'text':

package/src/Redux/Store/AdaptableStore.js

@@ -892,8 +892,6 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     const newLayout = (newLayoutState.Layouts || []).find((l) => l.Name == newLayoutState.CurrentLayout) ||
                         newLayoutState.Layouts[0] ||
                         ERROR_LAYOUT;
-                    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)) {
                         refreshColumnFilters = true;

package/src/Strategy/ColumnFilterModule.js

@@ -30,11 +30,18 @@ export class ColumnFilterModule extends AdaptableModuleBase {
         // we reset the filter cache on sort change, because we might have columns
         // with "In" filters, with custom values, which use `context.orderedValues`
         // customInFilterValues: (context: CustomInFilterValuesContext<Car>) => {
-        //   return context.orderedValues;
+        //   return {values: context.orderedValues};
         // }
         // and that order will most likely change when sorting happens
         // so we need to reset the cached filter values when sorting changes
         this.api.eventApi.on('GridSorted', () => {
+            const filterOptions = this.api.optionsApi.getFilterOptions();
+            if (!filterOptions.customInFilterValues) {
+                // no-one is using context.sortedValues/context.orderedValues
+                // or a custom property from a value, like value.count or value.visible
+                // so no need to reset the filter display values
+                return;
+            }
             this.api.filterApi.columnFilterApi.resetAllFilterValues();
         });
     }

package/src/Utilities/Helpers/AdaptableHelper.d.ts

@@ -14,6 +14,7 @@ export declare const AdaptableHelper: {
     addAdaptableObjectPrimitives: typeof addAdaptableObjectPrimitives;
     removeAdaptableObjectPrimitives: typeof removeAdaptableObjectPrimitives;
     removeAdaptableObjectPrimitivesInline: typeof removeAdaptableObjectPrimitivesInline;
+    removeAdaptableObjectPrimitivesInlineDeep: typeof removeAdaptableObjectPrimitivesInlineDeep;
     isAdaptableObject: typeof isAdaptableObject;
 };
 export default AdaptableHelper;

package/src/Utilities/Helpers/AdaptableHelper.js

@@ -106,6 +106,7 @@ export const AdaptableHelper = {
     addAdaptableObjectPrimitives,
     removeAdaptableObjectPrimitives,
     removeAdaptableObjectPrimitivesInline,
+    removeAdaptableObjectPrimitivesInlineDeep,
     isAdaptableObject,
 };
 export default AdaptableHelper;

package/src/Utilities/ObjectFactory.d.ts

@@ -23,7 +23,7 @@ import { NotificationsOptions } from '../AdaptableOptions/NotificationsOptions';
 import { CellSummmaryInfo } from '../AdaptableState/Common/CellSummary';
 import { AdaptableTheme, ChartDefinition, ColumnFilter, CommentThread, CustomDisplayFormatterContext, FlashingCellDefinition, RowDataChangedInfo, SpecialColumnSettings, SystemFilterPredicateId } from '../types';
 import { IRowNode } from 'ag-grid-enterprise';
-import { AdaptableApi, AdaptableComment, BadgeStyleDefinition, CellAddress, NamedQuery, PivotLayout } from '../../types';
+import { AdaptableApi, AdaptableComment, BadgeStyleDefinition, CellAddress, NamedQuery, PivotLayout, TableLayout } from '../../types';
 import { ToastOptions } from '../components/Toastify';
 import { StyledColumn } from '../AdaptableState/StyledColumnState';
 export declare function CreateEmptyCustomSort(): CustomSort;
@@ -51,12 +51,15 @@ export declare function CreateEmptySchedule(): Schedule;
 export declare function CreateEmptyShortcut(): Shortcut;
 export declare function CreateEmptyFormatColumn(): FormatColumn;
 export declare function CreateEmptyFreeTextColumn(defaultSpecialColumnSettings: Partial<SpecialColumnSettings>): FreeTextColumn;
-export declare function CreateEmptyPivotLayout(layout?: Partial<PivotLayout> & {
+export declare function CreateEmptyPivotLayout(pivotLayout?: Partial<PivotLayout> & {
     Name: string;
 }): PivotLayout;
+export declare function CreateEmptyTableLayout(tableLayout?: Partial<TableLayout> & {
+    Name: string;
+}): TableLayout;
 export declare function CreateEmptyLayout(layout?: Partial<Layout> & {
     Name: string;
-}, adaptableColumns?: AdaptableColumn[]): Layout;
+}): Layout;
 export declare function CreateEmptyStyle(): AdaptableStyle;
 export declare function CreateSystemStatusMessageInfo(message: string, type: AdaptableMessageType, furtherInfo?: string): SystemStatusMessageInfo;
 export declare function CreateEmptyCellSummmary(): CellSummmaryInfo;
@@ -100,6 +103,7 @@ export declare const ObjectFactory: {
     CreateEmptyFreeTextColumn: typeof CreateEmptyFreeTextColumn;
     CreateEmptyLayout: typeof CreateEmptyLayout;
     CreateEmptyPivotLayout: typeof CreateEmptyPivotLayout;
+    CreateEmptyTableLayout: typeof CreateEmptyTableLayout;
     CreateColumnFilter: typeof CreateColumnFilter;
     CreateEmptyStyle: typeof CreateEmptyStyle;
     CreateEmptyCellSummmary: typeof CreateEmptyCellSummmary;