@adaptabletools/adaptable 21.0.11 → 21.1.0-canary.0

package/src/AdaptableState/Common/AdaptablePredicate.js

@@ -14,6 +14,26 @@ import { isYesterday } from 'date-fns';
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import { parseDateValue } from '../../Utilities/Helpers/DateHelper';
 import Helper from '../../Utilities/Helpers/Helper';
+import { AG_GRID_GROUPED_COLUMN } from '../../Utilities/Constants/GeneralConstants';
+function getGroupValuesForNode(config) {
+    const { node, value } = config;
+    const groupValues = node.group
+        ? []
+        : /*for the leaf node, also use its value*/ value != null
+            ? [value]
+            : [];
+    let currentNode = node.group ? node : node.parent;
+    while (currentNode && currentNode.groupData) {
+        if (currentNode.treeParent && !currentNode.data) {
+            // skip filler groups in tree mode
+        }
+        else {
+            groupValues.unshift(currentNode.groupData[AG_GRID_GROUPED_COLUMN]);
+        }
+        currentNode = currentNode.parent;
+    }
+    return groupValues;
+}
 /**
  * Array of Predicate Defs which are shipped by AdapTable
  */
@@ -22,7 +42,10 @@ export const SystemPredicateDefs = [
         id: 'In',
         label: 'In',
         icon: { text: 'IN' },
-        columnScope: { DataTypes: ['text', 'number', 'date', 'textArray', 'numberArray'] },
+        columnScope: {
+            DataTypes: ['text', 'number', 'date', 'textArray', 'numberArray'],
+            ColumnIds: [AG_GRID_GROUPED_COLUMN],
+        },
         moduleScope: ['columnFilter', 'flashingcell', 'formatColumn', 'alert', 'badgeStyle'],
         handler: (context) => {
             const { inputs = [], column, value, adaptableApi } = context;
@@ -59,9 +82,26 @@ export const SystemPredicateDefs = [
             if (inputs.length === 0) {
                 return true;
             }
+            if (column.columnId === AG_GRID_GROUPED_COLUMN) {
+                const { node, treeSelectionState } = context;
+                const groupValues = getGroupValuesForNode({ node, value });
+                if (!treeSelectionState) {
+                    // in case we don't have treeSelectionState
+                    // this is another possible implementation
+                    // though it won't be as performant as using the treeSelectionState
+                    const currentValues = (groupValues ?? []).join('#');
+                    return inputs.some((values) => {
+                        const valuesString = values.join('#');
+                        return currentValues.startsWith(valuesString);
+                    });
+                }
+                const result = groupValues ? treeSelectionState.isNodeSelected(groupValues) : false;
+                // console.log('filter', groupValues, 'pass', result, treeSelectionState.getState());
+                return result;
+            }
             if (column.dataType === 'date') {
                 return inputs.some((input) => {
-                    if (adaptableApi.optionsApi.getPredicateOptions().evaluateInPredicateUsingTime) {
+                    if (adaptableApi.predicateApi.internalApi.shouldEvaluateInPredicateUsingTime(column.columnId)) {
                         return isEqual(input, value);
                     }
                     else {
@@ -78,7 +118,7 @@ export const SystemPredicateDefs = [
                     return arrayValue.includes(input);
                 });
             }
-            const useCaseSensitivity = adaptableApi.predicateApi.useCaseSensitivity();
+            const useCaseSensitivity = adaptableApi.predicateApi.useCaseSensitivity(column.columnId);
             if (column.dataType === 'text') {
                 return useCaseSensitivity
                     ? inputs
@@ -101,6 +141,80 @@ export const SystemPredicateDefs = [
         toString: ({ inputs }) => `IN (${inputs.join(', ')})`,
         shortcuts: ['#', '['],
     },
+    // {
+    //   id: 'Tree',
+    //   label: 'Tree',
+    //   icon: { text: 'Tree' },
+    //   columnScope: { DataTypes: ['date'] },
+    //   moduleScope: ['columnFilter', 'flashingcell', 'formatColumn', 'alert'],
+    //   handler: (context) => {
+    //     const { inputs = [], column, value, adaptableApi } = context;
+    //     const predicateInputs = (context.inputs || []).reduce<AdaptablePredicateDef[]>(
+    //       (acc, input) => {
+    //         const predicate = adaptableApi.predicateApi.getPredicateDefById(input);
+    //         if (predicate) {
+    //           acc.push(predicate);
+    //         }
+    //         return acc;
+    //       },
+    //       []
+    //     );
+    //     if (predicateInputs.length) {
+    //       const nestedContext = { ...context };
+    //       delete nestedContext.inputs;
+    //       const predicateResult = predicateInputs.some((predicate) => {
+    //         return adaptableApi.predicateApi.handlePredicate(
+    //           {
+    //             PredicateId: predicate.id,
+    //           },
+    //           nestedContext,
+    //           false
+    //         );
+    //       });
+    //       if (predicateResult) {
+    //         // We want to use the only true values, to allow for multiple predicates to be used
+    //         return predicateResult;
+    //       }
+    //     }
+    //     if (inputs.length === 0) {
+    //       return true;
+    //     }
+    //     if (column.dataType === 'date') {
+    //       const treeSelectionState = new TreeSelectionState(
+    //         {
+    //           defaultSelection: false,
+    //           // make sure something like
+    //           // Predicates: [{ PredicateId: 'Tree', Inputs: [['2021', '2'], ['2022']] }],
+    //           // is always converted to numbers
+    //           selectedPaths: inputs
+    //             .map((array) => {
+    //               if (!Array.isArray(array)) {
+    //                 return null;
+    //               }
+    //               return array.map(Number);
+    //             })
+    //             .filter(Boolean),
+    //         },
+    //         () => {
+    //           return {
+    //             treeDeepMap: new DeepMap<string, any>(),
+    //             treePaths: new DeepMap<string, any>(),
+    //           };
+    //         }
+    //       );
+    //       const currrentDate = parseDateValue(value);
+    //       const currentYear = currrentDate.getFullYear();
+    //       const currentMonth = currrentDate.getMonth() + 1;
+    //       const currentDay = currrentDate.getDate();
+    //       const result = treeSelectionState.isNodeSelected([currentYear, currentMonth, currentDay]);
+    //       // console.log({ currentYear, currentMonth, currentDay, result, inputs: inputs.join('-') });
+    //       return result;
+    //     }
+    //     return true;
+    //   },
+    //   toString: ({ inputs }) => `IN Tree (${inputs.join(', ')})`,
+    //   shortcuts: ['#', '['],
+    // },
     {
         id: 'NotIn',
         label: 'Not In',
@@ -145,7 +259,7 @@ export const SystemPredicateDefs = [
                 return true;
             }
             if (column.dataType === 'date') {
-                if (adaptableApi.optionsApi.getPredicateOptions().evaluateInPredicateUsingTime) {
+                if (adaptableApi.predicateApi.useCaseSensitivity(column.columnId)) {
                     return inputs.every((input) => {
                         return !isEqual(input, value);
                     });
@@ -166,7 +280,7 @@ export const SystemPredicateDefs = [
                 });
             }
             if (column.dataType === 'text') {
-                return adaptableApi.predicateApi.useCaseSensitivity()
+                return adaptableApi.predicateApi.useCaseSensitivity(column.columnId)
                     ? !inputs
                         .map((i) => {
                         return i?.toLocaleLowerCase();
@@ -177,7 +291,7 @@ export const SystemPredicateDefs = [
             if (column.dataType === 'textArray') {
                 const arrayValue = Array.isArray(value) ? value : [value];
                 return inputs.every((input) => {
-                    return adaptableApi.predicateApi.useCaseSensitivity()
+                    return adaptableApi.predicateApi.useCaseSensitivity(column.columnId)
                         ? !arrayValue.map((v) => v?.toLocaleLowerCase()).includes(input?.toLocaleLowerCase())
                         : !arrayValue.includes(input);
                 });
@@ -333,11 +447,11 @@ export const SystemPredicateDefs = [
         columnScope: { DataTypes: ['text'] },
         moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'text' }],
-        handler: ({ value, inputs, adaptableApi }) => {
+        handler: ({ value, inputs, adaptableApi, column }) => {
             if (!value) {
                 return false;
             }
-            const ignoreCase = !adaptableApi.predicateApi.useCaseSensitivity();
+            const ignoreCase = !adaptableApi.predicateApi.internalApi.shouldUseCaseSensitivePredicates(column);
             const v = ignoreCase ? String(value).toLocaleLowerCase() : String(value);
             const i = ignoreCase ? String(inputs[0]).toLocaleLowerCase() : String(inputs[0]);
             return v == i;
@@ -352,11 +466,11 @@ export const SystemPredicateDefs = [
         columnScope: { DataTypes: ['text'] },
         moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'text' }],
-        handler: ({ value, inputs, adaptableApi }) => {
+        handler: ({ value, inputs, adaptableApi, column }) => {
             if (!value) {
                 return true;
             }
-            const ignoreCase = !adaptableApi.predicateApi.useCaseSensitivity();
+            const ignoreCase = !adaptableApi.predicateApi.internalApi.shouldUseCaseSensitivePredicates(column);
             const v = ignoreCase ? String(value).toLocaleLowerCase() : String(value);
             const i = ignoreCase ? String(inputs[0]).toLocaleLowerCase() : String(inputs[0]);
             return v != i;
@@ -371,11 +485,11 @@ export const SystemPredicateDefs = [
         columnScope: { DataTypes: ['text'] },
         moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'text' }],
-        handler: ({ value, inputs, adaptableApi }) => {
+        handler: ({ value, inputs, adaptableApi, column }) => {
             if (!value) {
                 return false;
             }
-            const ignoreCase = !adaptableApi.predicateApi.useCaseSensitivity();
+            const ignoreCase = !adaptableApi.predicateApi.internalApi.shouldUseCaseSensitivePredicates(column);
             const v = ignoreCase ? String(value).toLocaleLowerCase() : String(value);
             const i = ignoreCase ? String(inputs[0]).toLocaleLowerCase() : String(inputs[0]);
             return v.indexOf(i) !== -1;
@@ -389,11 +503,11 @@ export const SystemPredicateDefs = [
         columnScope: { DataTypes: ['text'] },
         moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'text' }],
-        handler: ({ value, inputs, adaptableApi }) => {
+        handler: ({ value, inputs, adaptableApi, column }) => {
             if (!value) {
                 return true;
             }
-            const ignoreCase = !adaptableApi.predicateApi.useCaseSensitivity();
+            const ignoreCase = !adaptableApi.predicateApi.internalApi.shouldUseCaseSensitivePredicates(column);
             const v = ignoreCase ? String(value).toLocaleLowerCase() : String(value);
             const i = ignoreCase ? String(inputs[0]).toLocaleLowerCase() : String(inputs[0]);
             return v.indexOf(i) === -1;
@@ -407,11 +521,11 @@ export const SystemPredicateDefs = [
         columnScope: { DataTypes: ['text'] },
         moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'text' }],
-        handler: ({ value, inputs, adaptableApi }) => {
+        handler: ({ value, inputs, adaptableApi, column }) => {
             if (!value) {
                 return false;
             }
-            const ignoreCase = !adaptableApi.predicateApi.useCaseSensitivity();
+            const ignoreCase = !adaptableApi.predicateApi.internalApi.shouldUseCaseSensitivePredicates(column);
             const v = ignoreCase ? String(value).toLocaleLowerCase() : String(value);
             const i = ignoreCase ? String(inputs[0]).toLocaleLowerCase() : String(inputs[0]);
             return v.startsWith(i);
@@ -425,11 +539,11 @@ export const SystemPredicateDefs = [
         columnScope: { DataTypes: ['text'] },
         moduleScope: ['columnFilter', 'alert', 'flashingcell', 'formatColumn', 'badgeStyle'],
         inputs: [{ type: 'text' }],
-        handler: ({ value, inputs, adaptableApi }) => {
+        handler: ({ value, inputs, adaptableApi, column }) => {
             if (!value) {
                 return false;
             }
-            const ignoreCase = !adaptableApi.predicateApi.useCaseSensitivity();
+            const ignoreCase = !adaptableApi.predicateApi.internalApi.shouldUseCaseSensitivePredicates(column);
             const v = ignoreCase ? String(value).toLocaleLowerCase() : String(value);
             const i = ignoreCase ? String(inputs[0]).toLocaleLowerCase() : String(inputs[0]);
             return v.endsWith(i);

package/src/AdaptableState/Selection/GridCell.d.ts

@@ -64,6 +64,16 @@ export interface GridCellWithCount extends GridCell {
      */
     visibleCount?: number;
 }
+export interface GridCellWithChildren extends GridCell {
+    /**
+     * Children of Cell
+     */
+    children?: GridCellWithChildren[];
+    /**
+     * For the grouping scenario, how many leafs are there under this item
+     */
+    leafChildrenCount?: number;
+}
 export interface UniqueGridCell<TData = any> {
     /**
      * Raw value of Cell

package/src/Api/Implementation/ExportApiImpl.js

@@ -2,7 +2,7 @@ import * as ExportRedux from '../../Redux/ActionsReducers/ExportRedux';
 import { ApiBase } from './ApiBase';
 import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
 import { ExportInternalApi } from '../Internal/ExportInternalApi';
-import { ALL_DATA_REPORT, CLIPBOARD_EXPORT_DESTINATION, DOWNLOAD_EXPORT_DESTINATION, EMPTY_STRING, SYSTEM_EXPORT_DESTINATIONS, SYSTEM_REPORT_FORMATS, SYSTEM_REPORT_NAMES, VISUAL_EXCEL_FORMAT_REPORT, } from '../../Utilities/Constants/GeneralConstants';
+import { ALL_DATA_REPORT, CLIPBOARD_EXPORT_DESTINATION, DOWNLOAD_EXPORT_DESTINATION, EMPTY_STRING, SYSTEM_EXPORT_DESTINATIONS, SYSTEM_REPORT_FORMATS, SYSTEM_REPORT_NAMES, } from '../../Utilities/Constants/GeneralConstants';
 export class ExportApiImpl extends ApiBase {
     constructor(_adaptable) {
         super(_adaptable);
@@ -85,13 +85,7 @@ export class ExportApiImpl extends ApiBase {
                 currentReportFormat: this.getExportApi().getCurrentReportFormat(),
             })
             : systemExportDestinationsOption;
-        return systemExportDestinations.filter((destination) => {
-            // VisualExcel format can't be exported to custom destinations
-            if (this.getExportApi().getCurrentReportFormat() === VISUAL_EXCEL_FORMAT_REPORT) {
-                return false;
-            }
-            return true;
-        });
+        return systemExportDestinations;
     }
     getAvailableCustomDestinations() {
         const customDestinationsOption = this.getExportOptions().customDestinations;

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

@@ -3,6 +3,8 @@ import { PredicateApi } from '../PredicateApi';
 import { AdaptableColumnPredicate, AdaptablePredicate, AdaptablePredicateDef, PredicateDefHandlerContext, PredicateModuleScope } from '../../types';
 import { IAdaptable } from '../../AdaptableInterfaces/IAdaptable';
 import { PredicateInternalApi } from '../Internal/PredicateInternalApi';
+import { TreeSelectionState } from '@infinite-table/infinite-react';
+export declare const getTreeSelectionStateForPredicateInputs: (inputs: any[], cache?: WeakMap<any[], TreeSelectionState>) => TreeSelectionState<any>;
 export declare class PredicateApiImpl extends ApiBase implements PredicateApi {
     internalApi: PredicateInternalApi;
     constructor(_adaptable: IAdaptable);
@@ -22,5 +24,5 @@ export declare class PredicateApiImpl extends ApiBase implements PredicateApi {
     handleColumnPredicates(predicates: AdaptableColumnPredicate[], context: Omit<PredicateDefHandlerContext, 'adaptableApi' | 'inputs'>, defaultReturn: boolean): boolean;
     handlePredicate(predicate: AdaptablePredicate | undefined, context: Omit<PredicateDefHandlerContext, 'adaptableApi' | 'inputs'>, defaultReturn: boolean): boolean;
     handlePredicates(predicates: AdaptablePredicate[], params: Omit<PredicateDefHandlerContext, 'adaptableApi' | 'inputs'>, defaultReturn: boolean): boolean;
-    useCaseSensitivity(): boolean;
+    useCaseSensitivity(columnId: string): boolean;
 }

package/src/Api/Implementation/PredicateApiImpl.js

@@ -3,6 +3,24 @@ import ArrayExtensions from '../../Utilities/Extensions/ArrayExtensions';
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import { PredicateInternalApi } from '../Internal/PredicateInternalApi';
 import { SystemPredicateDefs } from '../../AdaptableState/Common/AdaptablePredicate';
+import { AG_GRID_GROUPED_COLUMN } from '../../Utilities/Constants/GeneralConstants';
+import { TreeSelectionState } from '@infinite-table/infinite-react';
+const treeSelectionStatesForPredicates = new WeakMap();
+export const getTreeSelectionStateForPredicateInputs = (inputs, cache = treeSelectionStatesForPredicates) => {
+    const treeSelectionState = cache.get(inputs);
+    if (treeSelectionState) {
+        return treeSelectionState;
+    }
+    const newTreeSelectionState = new TreeSelectionState({
+        defaultSelection: false,
+        selectedPaths: inputs,
+    }, {
+        treePaths: inputs,
+        strictCheckPaths: false,
+    });
+    cache.set(inputs, newTreeSelectionState);
+    return newTreeSelectionState;
+};
 export class PredicateApiImpl extends ApiBase {
     constructor(_adaptable) {
         super(_adaptable);
@@ -125,10 +143,15 @@ export class PredicateApiImpl extends ApiBase {
         if (predicateDef.inputs?.some((_, i) => predicate.Inputs?.[i] === undefined || predicate.Inputs?.[i] === '')) {
             return defaultReturn;
         }
+        let treeSelectionState;
+        if (context.column.columnId === AG_GRID_GROUPED_COLUMN && predicate.PredicateId === 'In') {
+            treeSelectionState = getTreeSelectionStateForPredicateInputs(predicate.Inputs);
+        }
         try {
             return predicateDef.handler({
                 adaptableApi: this.getAdaptableApi(),
                 inputs: predicate.Inputs,
+                treeSelectionState,
                 ...context,
             });
         }
@@ -146,7 +169,7 @@ export class PredicateApiImpl extends ApiBase {
         }
         return predicates?.every((p) => this.handlePredicate(p, params, defaultReturn));
     }
-    useCaseSensitivity() {
-        return this.getPredicateOptions().caseSensitivePredicates;
+    useCaseSensitivity(columnId) {
+        return this.internalApi.shouldUseCaseSensitivePredicates(columnId);
     }
 }

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

@@ -23,7 +23,7 @@ import { AdaptableFrameworkComponent } from '../../agGrid/AdaptableFrameworkComp
 import { IMetamodelService } from '../../Utilities/Services/Interface/IMetamodelService';
 import { IModuleCollection } from '../../Strategy/Interface/IModule';
 import { AdaptableObjectTag, AdaptableObjectWithScope } from '../../AdaptableState/Common/AdaptableObject';
-import { AdaptableForm, CellSummmaryInfo, FormContext, RowDataChangeTrigger, RowDataChangedInfo } from '../../../types';
+import { AdaptableForm, CellSummmaryInfo, FormContext, RowDataChangeTrigger, RowDataChangedInfo, AdaptableColumn, AdaptableColumnContext } from '../../../types';
 import { Fdc3Service } from '../../Utilities/Services/Fdc3Service';
 import { AnnotationsService } from '../../Utilities/Services/AnnotationsService';
 import { RowFormService } from '../../Utilities/Services/RowFormService';
@@ -122,6 +122,7 @@ export declare class AdaptableInternalApi extends ApiBase {
     setValueUsingField(rowData: Record<string, any>, fieldName: string, newValue: any): Record<string, any>;
     findAdaptableObjectsByLookupCriteria<T extends AdaptableObjectWithScope>({ scope, tag, ids }: AdaptableObjectLookupCriteria, specificAdaptableObjects: T[]): T[];
     buildBaseContext(): BaseContext;
+    buildAdaptableColumnContext(column: AdaptableColumn<any> | string): AdaptableColumnContext;
     setCellSummaryInfo(cellSummaryInfo: CellSummmaryInfo): void;
     parseDateValue(dateValue: string | Date | number): Date | undefined;
 }

package/src/Api/Internal/AdaptableInternalApi.js

@@ -437,6 +437,12 @@ export class AdaptableInternalApi extends ApiBase {
             clientTimestamp: new Date(),
         };
     }
+    buildAdaptableColumnContext(column) {
+        return {
+            ...this.buildBaseContext(),
+            column: typeof column === 'string' ? this.getColumnApi().getColumnWithColumnId(column) : column,
+        };
+    }
     setCellSummaryInfo(cellSummaryInfo) {
         this.dispatchAction(InternalRedux.SetCellSummaryInfo(cellSummaryInfo));
     }

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

@@ -1,7 +1,7 @@
 import { ApiBase } from '../Implementation/ApiBase';
 import { AdaptablePredicate, AdaptablePredicateDef } from '../../AdaptableState/Common/AdaptablePredicate';
 import { SystemFilterPredicateId } from '../../AdaptableState/Common/ColumnFilter';
-import { AdaptableColumnDataType } from '../../AdaptableState/Common/AdaptableColumn';
+import { AdaptableColumn, AdaptableColumnDataType } from '../../AdaptableState/Common/AdaptableColumn';
 import { ColumnScope } from '../../types';
 export declare class PredicateInternalApi extends ApiBase {
     IsInOrNotInPredicate(predicate: AdaptablePredicate): boolean;
@@ -10,6 +10,8 @@ export declare class PredicateInternalApi extends ApiBase {
      * Get all Filter Predicate Definitions - System and Custom
      */
     getFilterPredicateDefs(scope: ColumnScope): AdaptablePredicateDef[];
+    shouldUseCaseSensitivePredicates(column: string | AdaptableColumn): boolean;
+    shouldEvaluateInPredicateUsingTime(column: string | AdaptableColumn): boolean;
     private getSystemFilterPredicateIds;
     /**
      * Get all Alert Predicate Definitions - System and Custom

package/src/Api/Internal/PredicateInternalApi.js

@@ -12,6 +12,20 @@ export class PredicateInternalApi extends ApiBase {
     getFilterPredicateDefs(scope) {
         return this.mergeSystemAndCustomPredicates(this.getSystemFilterPredicateIds(scope)?.map((predicateId) => this.getPredicateApi().getPredicateDefById(predicateId)), this.getPredicateApi().getCustomPredicateDefs()).filter((predicateDef) => predicateDef.moduleScope.includes('columnFilter'));
     }
+    shouldUseCaseSensitivePredicates(column) {
+        const caseSensitivePredicates = this.getPredicateOptions().caseSensitivePredicates;
+        if (typeof caseSensitivePredicates === 'function') {
+            return caseSensitivePredicates(this.getAdaptableInternalApi().buildAdaptableColumnContext(column));
+        }
+        return caseSensitivePredicates;
+    }
+    shouldEvaluateInPredicateUsingTime(column) {
+        const evaluateInPredicateUsingTime = this.getPredicateOptions().evaluateInPredicateUsingTime;
+        if (typeof evaluateInPredicateUsingTime === 'function') {
+            return evaluateInPredicateUsingTime(this.getAdaptableInternalApi().buildAdaptableColumnContext(column));
+        }
+        return evaluateInPredicateUsingTime;
+    }
     getSystemFilterPredicateIds(scope) {
         const systemFilterPredicates = this.getPredicateOptions().systemFilterPredicates;
         if (typeof systemFilterPredicates === 'function') {

package/src/Api/PredicateApi.d.ts

@@ -95,5 +95,5 @@ export interface PredicateApi {
     /**
      * Whether Predicates are evaluated using Case Sensitivity
      */
-    useCaseSensitivity(): boolean;
+    useCaseSensitivity(columnId: string): boolean;
 }

package/src/Redux/Store/AdaptableStore.js

@@ -38,6 +38,7 @@ import * as InternalRedux from '../ActionsReducers/InternalRedux';
 import * as TeamSharingRedux from '../ActionsReducers/TeamSharingRedux';
 import * as ThemeRedux from '../ActionsReducers/ThemeRedux';
 import * as ToolPanelRedux from '../ActionsReducers/ToolPanelRedux';
+import { areAdaptableProfileTracksEnabled, getMarker } from '../../devTools';
 import { isAdaptableSharedEntity, isCustomSharedEntity, } from '../../AdaptableState/TeamSharingState';
 import { buildAdaptableStateFunctionConfig } from './buildAdaptableStateFunctionConfig';
 const INIT_STATE = 'INIT_STATE';
@@ -227,17 +228,21 @@ export class AdaptableStore {
             }
             return finalState;
         };
+        const devToolsActionMarkerMiddleware = createDevToolsActionMarkerMiddleware(adaptable);
         const pluginsMiddleware = [];
         adaptable.forPlugins((plugin) => {
             if (plugin.reduxMiddleware) {
                 pluginsMiddleware.push(plugin.reduxMiddleware(adaptable));
             }
         });
+        const middlewares = [
+            devToolsActionMarkerMiddleware,
+            adaptableMiddleware(adaptable), // the main middleware that actually does stuff,
+            ...pluginsMiddleware, // the plugins middleware
+        ].filter(Boolean);
         //TODO: need to check if we want the storage to be done before or after
         //we enrich the state with the AB middleware
-        this.TheStore = Redux.createStore(persistedReducer, composeEnhancers(Redux.applyMiddleware(adaptableMiddleware(adaptable), // the main middleware that actually does stuff,
-        ...pluginsMiddleware // the plugins middleware
-        )));
+        this.TheStore = Redux.createStore(persistedReducer, composeEnhancers(Redux.applyMiddleware(...middlewares)));
         this.storageEngine = storageEngine;
     }
     destroy() {
@@ -258,6 +263,109 @@ export class AdaptableStore {
         return Promise.resolve(true);
     }
 }
+function createDevToolsActionMarkerMiddleware(adaptable) {
+    const adaptableId = adaptable?.adaptableOptions?.adaptableId;
+    if (!adaptableId) {
+        return null;
+    }
+    if (!areAdaptableProfileTracksEnabled(adaptableId)) {
+        return null;
+    }
+    return (middlewareAPI) => (next) => (action) => {
+        if (!isTrackableReduxAction(action)) {
+            return next(action);
+        }
+        const previousState = middlewareAPI.getState();
+        const marker = getMarker(adaptableId).track.Redux.label.Action.start();
+        try {
+            return next(action);
+        }
+        finally {
+            const nextState = middlewareAPI.getState();
+            const changedKeys = detectChangedAdaptableStateKeys(previousState, nextState);
+            const details = buildDevToolsActionDetails(action, changedKeys);
+            marker.end({
+                label: action.type,
+                tooltip: changedKeys?.length ? `State changes: ${changedKeys.join(', ')}` : undefined,
+                details: details.length ? details : undefined,
+            });
+        }
+    };
+}
+const MAX_MARKER_DETAILS = 6;
+function buildDevToolsActionDetails(action, changedKeys) {
+    const details = [];
+    if (changedKeys && changedKeys.length > 0) {
+        const truncatedKeys = changedKeys.slice(0, MAX_MARKER_DETAILS);
+        const suffix = changedKeys.length > truncatedKeys.length
+            ? ` +${changedKeys.length - truncatedKeys.length} more`
+            : '';
+        details.push({
+            name: 'State changes',
+            value: `${truncatedKeys.join(', ')}${suffix}`,
+        });
+    }
+    if (isActionWithPayload(action)) {
+        const entries = Object.entries(action).filter(([key]) => key !== 'type');
+        for (const [key, value] of entries) {
+            if (details.length >= MAX_MARKER_DETAILS) {
+                break;
+            }
+            details.push({
+                name: `action.${key}`,
+                value: coerceMarkerDetailValue(value),
+            });
+        }
+    }
+    return details;
+}
+function detectChangedAdaptableStateKeys(previousState, nextState) {
+    if (!previousState || !nextState || previousState === nextState) {
+        return undefined;
+    }
+    const previous = previousState;
+    const next = nextState;
+    const keys = new Set([...Object.keys(previous), ...Object.keys(next)]);
+    const changed = [];
+    keys.forEach((key) => {
+        if (previous[key] !== next[key]) {
+            changed.push(key);
+        }
+    });
+    return changed.length > 0 ? changed : undefined;
+}
+function isTrackableReduxAction(action) {
+    return !!action && typeof action.type === 'string';
+}
+function isActionWithPayload(action) {
+    return !!action && typeof action === 'object';
+}
+function coerceMarkerDetailValue(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (value === undefined) {
+        return 'undefined';
+    }
+    const valueType = typeof value;
+    if (valueType === 'string' || valueType === 'number' || valueType === 'boolean') {
+        return value;
+    }
+    if (valueType === 'function') {
+        return '[function]';
+    }
+    try {
+        const json = JSON.stringify(value);
+        if (!json) {
+            return '[empty]';
+        }
+        const MAX_LENGTH = 200;
+        return json.length > MAX_LENGTH ? `${json.slice(0, MAX_LENGTH - 3)}...` : json;
+    }
+    catch (err) {
+        return '[unserializable]';
+    }
+}
 // this is the main function for dealing with Redux Actions which require additional functionality to be triggered.
 // Please document each use case where we have to use the Store rather than a module or a popup screen
 // This should ideally be the ONLY place where we LISTEN to store changes

package/src/Utilities/Helpers/Helper.js

@@ -88,8 +88,32 @@ export async function copyToClipboard(text) {
         return true;
     }
     catch (ex) {
-        AdaptableLogger.consoleErrorBase('Copy to clipboard failed.', ex);
-        return false;
+        return copyToClipboardForOldBrowsers(text);
+    }
+}
+function copyToClipboardForOldBrowsers(text) {
+    if (document.queryCommandSupported && document.queryCommandSupported('copy')) {
+        let textarea = document.createElement('textarea');
+        textarea.textContent = text;
+        textarea.style.width = '1px';
+        textarea.style.height = '1px';
+        textarea.style.top = '0px';
+        textarea.style.left = '0px';
+        textarea.style.position = 'absolute';
+        textarea.style.opacity = '0.0';
+        document.body.appendChild(textarea);
+        textarea.select();
+        textarea.focus();
+        try {
+            return document.execCommand('copy'); // Security exception may be thrown by some browsers.
+        }
+        catch (ex) {
+            AdaptableLogger.consoleErrorBase('Copy to clipboard failed.', ex);
+            return false;
+        }
+        finally {
+            document.body.removeChild(textarea);
+        }
     }
 }
 export function returnItemCount(items, itemName) {

package/src/Utilities/Hooks/index.d.ts

@@ -0,0 +1,4 @@
+import { useAdaptableColumn } from './useAdaptableColumn';
+import { useAdaptableOptions } from './useAdaptableOptions';
+import { useAdaptableState } from './useAdaptableState';
+export { useAdaptableColumn, useAdaptableOptions, useAdaptableState };

package/src/Utilities/Hooks/index.js

@@ -0,0 +1,4 @@
+import { useAdaptableColumn } from './useAdaptableColumn';
+import { useAdaptableOptions } from './useAdaptableOptions';
+import { useAdaptableState } from './useAdaptableState';
+export { useAdaptableColumn, useAdaptableOptions, useAdaptableState };

package/src/Utilities/Hooks/useAdaptableColumn.d.ts

@@ -0,0 +1,2 @@
+import { AdaptableColumn } from '../../types';
+export declare function useAdaptableColumn(columnId: string): AdaptableColumn | undefined;

package/src/Utilities/Hooks/useAdaptableColumn.js

@@ -0,0 +1,6 @@
+import { useAdaptable } from '../../View/AdaptableContext';
+export function useAdaptableColumn(columnId) {
+    const api = useAdaptable().api;
+    const column = api.columnApi.getColumnWithColumnId(columnId);
+    return column;
+}