@adaptabletools/adaptable 18.0.0-canary.30 → 18.0.0-canary.32

package/src/Api/Internal/AlertInternalApi.js

@@ -209,7 +209,7 @@ export class AlertInternalApi extends ApiBase {
     getAlertPredicateDefsForScope(scope) {
         return this.getPredicateApi()
             .internalApi.getAlertPredicateDefs(scope)
-            .filter((predicateDef) => this.getScopeApi().isScopeInScope(scope, predicateDef.columnScope));
+            .filter((predicateDef) => this.getColumnScopeApi().isScopeInScope(scope, predicateDef.columnScope));
     }
     /**
      * Returns a description of an Alert Definition
@@ -223,7 +223,7 @@ export class AlertInternalApi extends ApiBase {
         if (alertDefinition.MessageText != null) {
             return alertDefinition.MessageText;
         }
-        let scopeDescription = this.getScopeApi().getScopeDescription(alertDefinition.Scope);
+        let scopeDescription = this.getColumnScopeApi().getScopeDescription(alertDefinition.Scope);
         let ruleDescription = this.getAlertRuleDescription(alertDefinition);
         return scopeDescription + ' - ' + ruleDescription;
     }
@@ -415,7 +415,7 @@ export class AlertInternalApi extends ApiBase {
     getAlertDefinitionsForCellDataChange(dataChangedEvent) {
         const allActiveNonReactiveDefinitions = this.getActiveNonReactiveAlertDefinitions();
         let relatedAlertDefinitions = allActiveNonReactiveDefinitions
-            .filter((v) => this.getAdaptableApi().scopeApi.isColumnInScope(dataChangedEvent.column, v.Scope))
+            .filter((v) => this.getAdaptableApi().columnScopeApi.isColumnInScope(dataChangedEvent.column, v.Scope))
             .filter((alertDefinition) => !isReactiveQuery(alertDefinition.Rule));
         let triggeredAlerts = [];
         if (ArrayExtensions.IsNotNullOrEmpty(relatedAlertDefinitions)) {

package/src/Api/Internal/CustomSortInternalApi.js

@@ -3,7 +3,7 @@ export class CustomSortInternalApi extends ApiBase {
     getCustomSortComparer(columnId) {
         var _a;
         const column = this.getColumnApi().getColumnWithColumnId(columnId);
-        return (_a = this.getCustomSortOptions().customSortComparers) === null || _a === void 0 ? void 0 : _a.find((csc) => this.getAdaptableApi().scopeApi.isColumnInScope(column, csc.scope));
+        return (_a = this.getCustomSortOptions().customSortComparers) === null || _a === void 0 ? void 0 : _a.find((csc) => this.getAdaptableApi().columnScopeApi.isColumnInScope(column, csc.scope));
     }
     getDefaultCustomSortComparer(columnId, columnValues) {
         // have to return a function that may not have access to this

package/src/Api/Internal/ExportInternalApi.js

@@ -21,7 +21,7 @@ export class ExportInternalApi extends ApiBase {
                 break;
             case 'ScopeColumns':
                 // use the Scope object which will tell us if the Column is relevant
-                if (!this.getAdaptableApi().scopeApi.isColumnInScopeColumns(cellDataChangedInfo.column, report.Scope)) {
+                if (!this.getAdaptableApi().columnScopeApi.isColumnInScopeColumns(cellDataChangedInfo.column, report.Scope)) {
                     return false;
                 }
                 break;

package/src/Api/Internal/ExpressionInternalApi.js

@@ -41,7 +41,7 @@ export class ExpressionInternalApi extends ApiBase {
             context.predicates = predicates;
             // need to find a way to get the columns in the predicates
             // cand do later
-            //        this.getAdaptableApi().scopeApi.getColumnsForScope();
+            //        this.getAdaptableApi().columnScopeApi.getColumnsForScope();
         }
         return !evaluateExpressionExternallyFn(context);
     }

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

@@ -1,4 +1,4 @@
-import { AdaptableColumn, AdaptableFormat, AdaptablePredicateDef, AdaptableScope, FormatColumn, StringFormatterOptions } from '../../types';
+import { AdaptableColumn, AdaptableFormat, AdaptablePredicateDef, ColumnScope, FormatColumn, StringFormatterOptions } from '../../types';
 import { ApiBase } from '../Implementation/ApiBase';
 import { IRowNode } from '@ag-grid-community/core';
 export declare class FormatColumnInternalApi extends ApiBase {
@@ -76,7 +76,7 @@ export declare class FormatColumnInternalApi extends ApiBase {
      * Returns all Predicates appropriate for the given Scope
      * @param scope Scope to check
      */
-    getFormatColumnDefsForScope(scope: AdaptableScope): AdaptablePredicateDef[];
+    getFormatColumnDefsForScope(scope: ColumnScope): AdaptablePredicateDef[];
     /**
      * Checks if format column is relevant for a given cell (intersection of given AdaptableColumn and RowNode)
      *

package/src/Api/Internal/FormatColumnInternalApi.js

@@ -3,7 +3,6 @@ import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import FormatHelper from '../../Utilities/Helpers/FormatHelper';
 import ObjectFactory from '../../Utilities/ObjectFactory';
 import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
-import { ROW_SUMMARY_ROW_ID } from '../../PredefinedConfig/Common/RowSummary';
 export class FormatColumnInternalApi extends ApiBase {
     /**
      * Retrieves all Format Columns in Adaptable State with the `Style` property set
@@ -60,7 +59,7 @@ export class FormatColumnInternalApi extends ApiBase {
         return this.getFormatColumnsWithStyleForColumn(column, config).filter((formatColumn) => { var _a; return StringExtensions.IsNotNullOrEmpty((_a = formatColumn === null || formatColumn === void 0 ? void 0 : formatColumn.Style) === null || _a === void 0 ? void 0 : _a.ClassName); });
     }
     getFormatColumnWithColumnInScope(formatColumns, column) {
-        return this.getFormatColumnInColumnScope(formatColumns).filter((scopedFormatColumn) => this.getAdaptableApi().scopeApi.isColumnInScope(column, scopedFormatColumn.Scope));
+        return this.getFormatColumnInColumnScope(formatColumns).filter((scopedFormatColumn) => this.getAdaptableApi().columnScopeApi.isColumnInScope(column, scopedFormatColumn.Scope));
     }
     // TODO is this really needed, I don't think it achieves anything
     getFormatColumnInColumnScope(formatColumns) {
@@ -68,11 +67,11 @@ export class FormatColumnInternalApi extends ApiBase {
         return formatColumns.filter((fc) => {
             return (
                 // this.getFormatColumnsWithColumnScope(formatColumns)
-                (this.getAdaptableApi().scopeApi.scopeHasColumns(fc.Scope) ||
+                (this.getAdaptableApi().columnScopeApi.scopeHasColumns(fc.Scope) ||
                     // this.getFormatColumnsWithDataTypeScope(formatColumns)
-                    this.getAdaptableApi().scopeApi.scopeHasDataType(fc.Scope) ||
+                    this.getAdaptableApi().columnScopeApi.scopeHasDataType(fc.Scope) ||
                     // this.getFormatColumnsWithAllScope(formatColumns)
-                    this.getAdaptableApi().scopeApi.scopeIsAll(fc.Scope) || this.getAdaptableApi().scopeApi.scopeHasColumnType(fc.Scope))
+                    this.getAdaptableApi().columnScopeApi.scopeIsAll(fc.Scope) || this.getAdaptableApi().columnScopeApi.scopeHasColumnType(fc.Scope))
             );
         });
     }
@@ -145,7 +144,7 @@ export class FormatColumnInternalApi extends ApiBase {
     getFormatColumnDefsForScope(scope) {
         return this.getAdaptableApi()
             .predicateApi.internalApi.getFormatColumnPredicateDefs(scope)
-            .filter((predicateDef) => this.getAdaptableApi().scopeApi.isScopeInScope(scope, predicateDef.columnScope));
+            .filter((predicateDef) => this.getAdaptableApi().columnScopeApi.isScopeInScope(scope, predicateDef.columnScope));
     }
     /**
      * Checks if format column is relevant for a given cell (intersection of given AdaptableColumn and RowNode)
@@ -155,23 +154,34 @@ export class FormatColumnInternalApi extends ApiBase {
      * @param params
      */
     formatColumnShouldRender(formatColumn, column, rowNode, cellValue) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         // suspended is important to be first
         if (formatColumn.IsSuspended) {
             return false;
         }
-        if (!formatColumn.IncludeGroupedRows &&
-            this.getAdaptableApi().gridApi.isGroupRowNode(rowNode)) {
-            return false;
+        const isSummaryNode = this.getAdaptableApi().gridApi.isSummaryNode(rowNode);
+        const isGroupedRowNode = this.getAdaptableApi().gridApi.isGroupRowNode(rowNode);
+        // For Summary Rows cannot be excluded
+        if (isSummaryNode) {
+            if ((_a = formatColumn.RowScope) === null || _a === void 0 ? void 0 : _a.ExcludeSummaryRows) {
+                return false;
+            }
         }
-        if (!formatColumn.IncludeRowSummaries && ((_a = rowNode === null || rowNode === void 0 ? void 0 : rowNode.data) === null || _a === void 0 ? void 0 : _a[ROW_SUMMARY_ROW_ID])) {
-            return false;
+        else if (isGroupedRowNode) {
+            if ((_b = formatColumn.RowScope) === null || _b === void 0 ? void 0 : _b.ExcludeGroupedRows) {
+                return false;
+            }
+        }
+        else {
+            if ((_c = formatColumn.RowScope) === null || _c === void 0 ? void 0 : _c.ExcludeDataRows) {
+                return false;
+            }
         }
         if (!formatColumn.Rule) {
             return true;
         }
         // first run the predicate
-        if (formatColumn.Rule.Predicates && ((_c = (_b = formatColumn.Rule) === null || _b === void 0 ? void 0 : _b.Predicates) === null || _c === void 0 ? void 0 : _c.length)) {
+        if (formatColumn.Rule.Predicates && ((_e = (_d = formatColumn.Rule) === null || _d === void 0 ? void 0 : _d.Predicates) === null || _e === void 0 ? void 0 : _e.length)) {
             const predicateDefHandlerContext = Object.assign({ value: cellValue, oldValue: null, displayValue: cellValue, node: rowNode, column: column }, this.getAdaptableApi().internalApi.buildBaseContext());
             return this.evaluatePredicate(formatColumn, predicateDefHandlerContext);
         } // then run the Expression
@@ -240,7 +250,7 @@ export class FormatColumnInternalApi extends ApiBase {
         const columnsThatNeedRefresh = new Set();
         this.getFormatColumnsDependentOnColumns(impactedColumnIds).forEach((formatColumn) => {
             this.getAdaptableApi()
-                .scopeApi.getColumnsForScope(formatColumn.Scope)
+                .columnScopeApi.getColumnsForScope(formatColumn.Scope)
                 .forEach((col) => {
                 columnsThatNeedRefresh.add(col.columnId);
             });

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

@@ -2,7 +2,7 @@ import { ApiBase } from '../Implementation/ApiBase';
 import { AdaptablePredicate, AdaptablePredicateDef } from '../../PredefinedConfig/Common/AdaptablePredicate';
 import { SystemFilterPredicateId } from '../../PredefinedConfig/Common/ColumnFilter';
 import { AdaptableColumnDataType } from '../../PredefinedConfig/Common/AdaptableColumn';
-import { AdaptableScope } from '../../types';
+import { ColumnScope } from '../../types';
 export declare class PredicateInternalApi extends ApiBase {
     /**
      * Returns true if the predicate has a dropdown.
@@ -13,23 +13,23 @@ export declare class PredicateInternalApi extends ApiBase {
     /**
      * Get all Filter Predicate Definitions - System and Custom
      */
-    getFilterPredicateDefs(scope: AdaptableScope): AdaptablePredicateDef[];
+    getFilterPredicateDefs(scope: ColumnScope): AdaptablePredicateDef[];
     private getSystemFilterPredicateIds;
     /**
      * Get all Alert Predicate Definitions - System and Custom
      */
-    getAlertPredicateDefs(scope: AdaptableScope): AdaptablePredicateDef[];
+    getAlertPredicateDefs(scope: ColumnScope): AdaptablePredicateDef[];
     private getSystemAlertPredicateIds;
     private getSystemBadgeStylePredicateIds;
     /**
      * Get all Format Column Predicate Definitions - System and Custom
      */
-    getFormatColumnPredicateDefs(scope: AdaptableScope): AdaptablePredicateDef[];
+    getFormatColumnPredicateDefs(scope: ColumnScope): AdaptablePredicateDef[];
     private getSystemFormatColumnPredicateIds;
     /**
      * Get all Flashing Cell Predicate Definitions - System and Custom
      */
-    getFlashingCellPredicateDefs(scope: AdaptableScope): AdaptablePredicateDef[];
+    getFlashingCellPredicateDefs(scope: ColumnScope): AdaptablePredicateDef[];
     private getSystemFlashingCellPredicateIds;
     /**
      * Gets the correct Equality-type System Predicate for a particular DataType
@@ -39,7 +39,7 @@ export declare class PredicateInternalApi extends ApiBase {
     /**
      * Get all Badge Style Predicate Definitions - System and Custom
      */
-    getBadgeStylePredicateDefs(scope: AdaptableScope): AdaptablePredicateDef[];
+    getBadgeStylePredicateDefs(scope: ColumnScope): AdaptablePredicateDef[];
     /**
      * Merges System and Custom Predicate Definitions but ensures that Custom ones take precedence
      * (i.e. if there is a Custom Predicate with the same Id as a System one, the Custom one is used)

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

@@ -1,6 +1,6 @@
 import { ApiBase } from '../Implementation/ApiBase';
 import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
-import { BadgeStyleDefinition, CellColorRange, ColumnComparison, NumericStyledColumn, StyledColumn } from '../../PredefinedConfig/StyledColumnState';
+import { BadgeStyle, BadgeStyleDefinition, CellColorRange, ColumnComparison, NumericStyledColumn, StyledColumn } from '../../PredefinedConfig/StyledColumnState';
 import { IRowNode } from '@ag-grid-community/core';
 import { PredicateDefHandlerContext } from '../../types';
 export declare class StyledColumnInternalApi extends ApiBase {
@@ -57,6 +57,6 @@ export declare class StyledColumnInternalApi extends ApiBase {
      * @param styledColumn Styled Column to Add
      */
     hasStyledColumnRelativeCellRange(styledColumn: StyledColumn): boolean;
-    getApplicableBadge(styledColumn: StyledColumn, context: PredicateDefHandlerContext): BadgeStyleDefinition | null;
+    getApplicableBadge(badgeStyle: BadgeStyle, context: PredicateDefHandlerContext): BadgeStyleDefinition | null;
     getBadgePredicateDefsForColumn(columnId: string): import("../../types").AdaptablePredicateDef<string>[];
 }

package/src/Api/Internal/StyledColumnInternalApi.js

@@ -241,15 +241,14 @@ export class StyledColumnInternalApi extends ApiBase {
                 return cellColorRange.Min == 'Col-Min' || cellColorRange.Max == 'Col-Max';
             })))) !== null && _e !== void 0 ? _e : false);
     }
-    getApplicableBadge(styledColumn, context) {
-        var _a, _b;
-        if (!((_a = styledColumn.BadgeStyle) === null || _a === void 0 ? void 0 : _a.Badges.length)) {
+    getApplicableBadge(badgeStyle, context) {
+        if (!badgeStyle.Badges.length) {
             return null;
         }
         // first that matches, sort last ones without predicate
         const badgesWithoutAll = [];
         const badgesWithAll = [];
-        for (let badge of (_b = styledColumn.BadgeStyle) === null || _b === void 0 ? void 0 : _b.Badges) {
+        for (let badge of badgeStyle.Badges) {
             if (!badge.Predicate) {
                 badgesWithAll.push(badge);
             }
@@ -275,6 +274,6 @@ export class StyledColumnInternalApi extends ApiBase {
         };
         return this.getAdaptableApi()
             .predicateApi.internalApi.getBadgeStylePredicateDefs(scope)
-            .filter((predicate) => this.getAdaptableApi().scopeApi.isColumnInScope(column, predicate.columnScope));
+            .filter((predicate) => this.getAdaptableApi().columnScopeApi.isColumnInScope(column, predicate.columnScope));
     }
 }

package/src/PredefinedConfig/AlertState.d.ts

@@ -1,5 +1,5 @@
 import { ConfigState } from './ConfigState';
-import { AdaptableScope } from './Common/AdaptableScope';
+import { ColumnScope } from './Common/ColumnScope';
 import { AdaptableColumnPredicate } from './Common/AdaptablePredicate';
 import { TypeHint } from './Common/Types';
 import { AdaptableMessageType } from './Common/AdaptableMessageType';
@@ -27,7 +27,7 @@ export interface AlertDefinition extends SuspendableObject {
     /**
      * Where Alert can be triggered: one, some or all columns or DataTypes
      */
-    Scope: AdaptableScope;
+    Scope: ColumnScope;
     /**
      * When Alert should be triggered
      */

package/src/PredefinedConfig/Common/AdaptableObject.d.ts

@@ -1,5 +1,5 @@
 import { TypeUuid } from '../Uuid';
-import { AdaptableScope } from './AdaptableScope';
+import { ColumnScope } from './ColumnScope';
 /**
  * Base interface which all other Adaptable State-related objects extend
  */
@@ -30,9 +30,9 @@ export type AdaptableObjectTag = string;
  */
 export interface AdaptableObjectLookupCriteria {
     /**
-     * AdaptableScope
+     * ColumnScope
      */
-    scope?: AdaptableScope;
+    scope?: ColumnScope;
     /**
      * AdaptableObjectTag
      */
@@ -43,5 +43,5 @@ export interface AdaptableObjectLookupCriteria {
     ids?: AdaptableObject['Uuid'][];
 }
 export interface AdaptableObjectWithScope extends AdaptableObject {
-    Scope: AdaptableScope;
+    Scope: ColumnScope;
 }

package/src/PredefinedConfig/Common/AdaptablePredicate.d.ts

@@ -1,7 +1,7 @@
 import { IRowNode } from '@ag-grid-community/core';
 import { AdaptableIcon, ColumnFilter } from '../../types';
 import { AdaptableColumn, AdaptableColumnDataType } from './AdaptableColumn';
-import { AdaptableScope } from './AdaptableScope';
+import { ColumnScope } from './ColumnScope';
 import { BaseContext } from './BaseContext';
 /**
  * Predicate object used by AdapTableQL - essentially a boolean function
@@ -40,7 +40,7 @@ export interface AdaptablePredicateDef<PREDICATE_TYPE = string> {
     /**
      * Columns (or DataTypes) where Predicate is active
      */
-    columnScope: AdaptableScope;
+    columnScope: ColumnScope;
     /**
      * Modules where Predicate can run
      */

package/src/PredefinedConfig/Common/{AdaptableScope.d.ts → ColumnScope.d.ts}

@@ -14,4 +14,4 @@ export type ScopeColumnTypes = {
 /**
  * Defines where a given Object / Module is active
  */
-export type AdaptableScope<Type = ScopeDataType> = ScopeAll | ScopeDataTypes<Type> | ScopeColumnIds | ScopeColumnTypes;
+export type ColumnScope<Type = ScopeDataType> = ScopeAll | ScopeDataTypes<Type> | ScopeColumnIds | ScopeColumnTypes;

package/src/PredefinedConfig/Common/RowScope.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Defines which types of Rows to exclude when rendering Format Columns, Action Columns, Badges
+ */
+export type RowScope = {
+    /**
+     * Exclude regular data rows
+     */
+    ExcludeDataRows?: boolean;
+    /**
+     * Exclude Grouped Rows
+     */
+    ExcludeGroupedRows?: boolean;
+    /**
+     * Exclude Summary Rows (used in Row Summaries)
+     */
+    ExcludeSummaryRows?: boolean;
+};

package/src/PredefinedConfig/Common/RowScope.js

@@ -0,0 +1 @@
+export {};

package/src/PredefinedConfig/ExportState.d.ts

@@ -1,6 +1,6 @@
 import { ConfigState } from './ConfigState';
 import { BaseSchedule } from './Common/Schedule';
-import { AdaptableScope } from './Common/AdaptableScope';
+import { ColumnScope } from './Common/ColumnScope';
 import { AdaptableColumnBase } from './Common/AdaptableColumn';
 import { AdaptableObject } from './Common/AdaptableObject';
 import { AdaptableFormData } from './Common/AdaptableForm';
@@ -42,7 +42,7 @@ export interface Report extends AdaptableObject {
     /**
      * Columns Scope; only required if `ReportColumnScope` is 'ScopeColumns'
      */
-    Scope?: AdaptableScope;
+    Scope?: ColumnScope;
     /**
      * Query to use; only required if `ReportRowScope` is 'ExpressionRows'
      */

package/src/PredefinedConfig/FlashingCellState.d.ts

@@ -1,6 +1,6 @@
 import { ConfigState } from './ConfigState';
 import { AdaptableStyle } from './Common/AdaptableStyle';
-import { AdaptableColumnPredicate, AdaptableScope } from '../types';
+import { AdaptableColumnPredicate, ColumnScope } from '../types';
 import { XOR } from '../Utilities/Extensions/TypeExtensions';
 import { AdaptableBooleanQuery } from './Common/AdaptableQuery';
 import { TypeHint } from './Common/Types';
@@ -34,7 +34,7 @@ export interface FlashingCellDefinition extends SuspendableObject {
     /**
      * Where Flashing Cell can display: Column[s] or DataType[s]
      */
-    Scope: AdaptableScope;
+    Scope: ColumnScope;
     /**
      * When Flashing Cell should be triggered
      */

package/src/PredefinedConfig/FormatColumnState.d.ts

@@ -1,7 +1,8 @@
 import { ConfigState } from './ConfigState';
 import { AdaptableStyle } from './Common/AdaptableStyle';
 import { AdaptableFormat } from './Common/AdaptableFormat';
-import { AdaptableScope } from './Common/AdaptableScope';
+import { ColumnScope } from './Common/ColumnScope';
+import { RowScope } from './Common/RowScope';
 import { SuspendableObject } from './Common/SuspendableObject';
 import { XOR } from '../Utilities/Extensions/TypeExtensions';
 import { TypeHint } from './Common/Types';
@@ -23,7 +24,7 @@ export interface FormatColumn extends SuspendableObject {
     /**
      * Where Format will be applied - whole Row, some Columns or all Columns of given DataType
      */
-    Scope: AdaptableScope;
+    Scope: ColumnScope;
     /**
      * Rule used to decide whether to apply the Format; if undefined Format is always applied
      */
@@ -41,15 +42,13 @@ export interface FormatColumn extends SuspendableObject {
      */
     CellAlignment?: 'Left' | 'Right' | 'Center';
     /**
-     * Interop.io to Format the Column in Grouped Rows
-     * @defaultValue false
+     * Which types of Rows should be formatted (data, grouped, summary)
      */
-    IncludeGroupedRows?: boolean;
+    RowScope?: RowScope;
     /**
-     * Interop.io to include Row Summary Rows
-     * @defaultValue false
+     * @deprecated FormatColumns now apply to grouped rows by default; use RowScope for more control
      */
-    IncludeRowSummaries?: boolean;
+    IncludeGroupedRows?: never;
 }
 /**
  * The Format Column Rule - can be either a Predicate or a BooleanExpression

package/src/PredefinedConfig/PlusMinusState.d.ts

@@ -1,5 +1,5 @@
 import { ConfigState } from './ConfigState';
-import { AdaptableScope } from './Common/AdaptableScope';
+import { ColumnScope } from './Common/ColumnScope';
 import { AdaptableBooleanQuery } from './Common/AdaptableQuery';
 import { SuspendableObject } from './Common/SuspendableObject';
 /**
@@ -18,7 +18,7 @@ export interface PlusMinusNudge extends SuspendableObject {
     /**
      * Where Rule is applied
      */
-    Scope: AdaptableScope;
+    Scope: ColumnScope;
     /**
      * Amount by which to update cell when Rule is applied
      */

package/src/PredefinedConfig/ShortcutState.d.ts

@@ -1,5 +1,5 @@
 import { ConfigState } from './ConfigState';
-import { AdaptableScope } from './Common/AdaptableScope';
+import { ColumnScope } from './Common/ColumnScope';
 import { SuspendableObject } from './Common/SuspendableObject';
 /**
  * Predefined Configuration for Shortcut Module
@@ -21,7 +21,7 @@ export interface Shortcut extends SuspendableObject {
     /**
      * Numeric Columns where Shortcut is applied
      */
-    Scope: AdaptableScope<ShortcutScopeDataType>;
+    Scope: ColumnScope<ShortcutScopeDataType>;
     /**
      * Key which triggers the Shortcut when pressed
      */

package/src/PredefinedConfig/StyledColumnState.d.ts

@@ -3,6 +3,7 @@ import { SuspendableObject } from './Common/SuspendableObject';
 import { SparklineOptions } from '@ag-grid-community/core';
 import { AdaptableCustomIcon, AdaptableSystemIcon, AdaptablePredicate, AdaptableStyle } from '../types';
 import { TypeHint } from './Common/Types';
+import { RowScope } from "./Common/RowScope";
 /**
  * Predefined Configuration for Styled Column Module
  */
@@ -36,16 +37,6 @@ export interface StyledColumn extends SuspendableObject {
      * Displays cell values in Column as a Badge
      */
     BadgeStyle?: BadgeStyle;
-    /**
-     * Includes Styled Column in Grouped Rows
-     * @defaultValue false
-     */
-    IncludeGroupedRows?: boolean;
-    /**
-     * Includes Row Summaries in Styled Column
-     * @defaultValue false
-     */
-    IncludeRowSummaries?: boolean;
 }
 /**
  * Style used to display Percent Bars in Special Column Style
@@ -195,4 +186,8 @@ export interface BadgeStyle {
      * Collection of Badge Style Definitions
      */
     Badges?: BadgeStyleDefinition[];
+    /**
+     * Which types of Rows should contain a Badge (data, grouped, summary)
+     */
+    RowScope?: RowScope;
 }

package/src/Strategy/AlertModule.js

@@ -57,8 +57,8 @@ export class AlertModule extends AdaptableModuleBase {
         if (queryExpression) {
             return this.api.expressionApi.getColumnsFromExpression(queryExpression);
         }
-        else if (this.api.scopeApi.scopeHasColumns(alertDefinition.Scope)) {
-            return this.api.scopeApi
+        else if (this.api.columnScopeApi.scopeHasColumns(alertDefinition.Scope)) {
+            return this.api.columnScopeApi
                 .getColumnsForScope(alertDefinition.Scope)
                 .map((adaptableColumn) => adaptableColumn.columnId);
         }

package/src/Strategy/ExportModule.js

@@ -27,8 +27,8 @@ export class ExportModule extends AdaptableModuleBase {
     }
     getExplicitlyReferencedColumnIds(report) {
         if (report.ReportColumnScope === 'ScopeColumns' &&
-            this.api.scopeApi.scopeHasColumns(report.Scope)) {
-            return this.api.scopeApi
+            this.api.columnScopeApi.scopeHasColumns(report.Scope)) {
+            return this.api.columnScopeApi
                 .getColumnsForScope(report.Scope)
                 .map((adaptableColumn) => adaptableColumn.columnId);
         }

package/src/Strategy/FlashingCellModule.js

@@ -46,8 +46,8 @@ export class FlashingCellModule extends AdaptableModuleBase {
         if (queryExpression) {
             return this.api.expressionApi.getColumnsFromExpression(queryExpression);
         }
-        else if (this.api.scopeApi.scopeHasColumns(alertDefinition.Scope)) {
-            return this.api.scopeApi
+        else if (this.api.columnScopeApi.scopeHasColumns(alertDefinition.Scope)) {
+            return this.api.columnScopeApi
                 .getColumnsForScope(alertDefinition.Scope)
                 .map((adaptableColumn) => adaptableColumn.columnId);
         }
@@ -65,7 +65,7 @@ export class FlashingCellModule extends AdaptableModuleBase {
             if (!this.api.columnApi.isCalculatedColumn(column.columnId)) {
                 const flashingCellDefinitions = this.api.flashingCellApi.getFlashingCellDefinitions();
                 const flashingCellForCurrentColumn = flashingCellDefinitions.find((flashingCellDefinition) => {
-                    return this.api.scopeApi.isColumnInScope(column, flashingCellDefinition.Scope);
+                    return this.api.columnScopeApi.isColumnInScope(column, flashingCellDefinition.Scope);
                 });
                 if (flashingCellForCurrentColumn) {
                     return [
@@ -165,7 +165,7 @@ export class FlashingCellModule extends AdaptableModuleBase {
         const definitions = this.api.flashingCellApi.getActiveFlashingCellDefinitions();
         const defaultNoPredicateReturn = false;
         let relatedFlashingCellsDefinitions = definitions
-            .filter((v) => this.api.scopeApi.isColumnInScope(dataChangedEvent.column, v.Scope))
+            .filter((v) => this.api.columnScopeApi.isColumnInScope(dataChangedEvent.column, v.Scope))
             .filter((flashingCellDefinition) => !isReactiveQuery(flashingCellDefinition.Rule));
         let triggeredFlashingCells = [];
         if (ArrayExtensions.IsNotNullOrEmpty(relatedFlashingCellsDefinitions)) {

package/src/Strategy/FormatColumnModule.js

@@ -22,8 +22,8 @@ export class FormatColumnModule extends AdaptableModuleBase {
         if (queryExpression) {
             return this.api.expressionApi.getColumnsFromExpression(queryExpression);
         }
-        else if (this.api.scopeApi.scopeHasColumns(formatColumn.Scope)) {
-            return this.api.scopeApi
+        else if (this.api.columnScopeApi.scopeHasColumns(formatColumn.Scope)) {
+            return this.api.columnScopeApi
                 .getColumnsForScope(formatColumn.Scope)
                 .map((adaptableColumn) => adaptableColumn.columnId);
         }

package/src/Strategy/PlusMinusModule.js

@@ -19,8 +19,8 @@ export class PlusMinusModule extends AdaptableModuleBase {
         return this.api.plusMinusApi.getAllPlusMinus(config);
     }
     getExplicitlyReferencedColumnIds(plusMinusNudge) {
-        if (this.api.scopeApi.scopeHasColumns(plusMinusNudge.Scope)) {
-            return this.api.scopeApi
+        if (this.api.columnScopeApi.scopeHasColumns(plusMinusNudge.Scope)) {
+            return this.api.columnScopeApi
                 .getColumnsForScope(plusMinusNudge.Scope)
                 .map((adaptableColumn) => adaptableColumn.columnId);
         }
@@ -92,7 +92,7 @@ export class PlusMinusModule extends AdaptableModuleBase {
                 let replacementGridCell;
                 plusMinusNudges.forEach((pmr) => {
                     if (!foundRule) {
-                        if (this.api.scopeApi.isColumnInScope(gridCell.column, pmr.Scope)) {
+                        if (this.api.columnScopeApi.isColumnInScope(gridCell.column, pmr.Scope)) {
                             if (this.api.gridApi.isCellEditable(gridCell)) {
                                 //for aggrid as we are getting strings sometimes
                                 if (typeof gridCell.rawValue != 'number') {

package/src/Strategy/ShortcutModule.js

@@ -46,7 +46,7 @@ export class ShortcutModule extends AdaptableModuleBase {
         const matchingShortcut = this.api.shortcutApi
             .getActiveShortcuts()
             .find((x) => keyDownEvent.key.toLowerCase() === x.ShortcutKey.toLowerCase() &&
-            this.api.scopeApi.isColumnInScope(this.api.columnApi.getColumnWithColumnId(columnId), x.Scope));
+            this.api.columnScopeApi.isColumnInScope(this.api.columnApi.getColumnWithColumnId(columnId), x.Scope));
         if (!matchingShortcut || !matchingShortcut.ShortcutValue) {
             return;
         }

package/src/Strategy/StyledColumnModule.js

@@ -15,8 +15,8 @@ export class StyledColumnModule extends AdaptableModuleBase {
         return this.api.styledColumnApi.getStyledColumns(config);
     }
     getExplicitlyReferencedColumnIds(formatColumn) {
-        if (this.api.scopeApi.scopeHasColumns(formatColumn.Scope)) {
-            return this.api.scopeApi
+        if (this.api.columnScopeApi.scopeHasColumns(formatColumn.Scope)) {
+            return this.api.columnScopeApi
                 .getColumnsForScope(formatColumn.Scope)
                 .map((adaptableColumn) => adaptableColumn.columnId);
         }
@@ -104,7 +104,7 @@ export class StyledColumnModule extends AdaptableModuleBase {
                         // Number
                         // Create Styled Column - Gradient | Percent Bar | Badge
                         case 'Number':
-                            const emptyRanges = this.api.scopeApi.createCellColorRangesForScope({
+                            const emptyRanges = this.api.columnScopeApi.createCellColorRangesForScope({
                                 ColumnIds: [column.columnId],
                             });
                             const newGrandientButton = this.createMenuItemShowPopup('styled-column-gradient-add', 'Create Gradient Column', this.moduleInfo.Popup, 'gradient', Object.assign(Object.assign({}, popupParam), { value: Object.assign(Object.assign({}, newStyledColumn), { GradientStyle: {
@@ -162,6 +162,7 @@ export class StyledColumnModule extends AdaptableModuleBase {
         };
     }
     toView(styledColumn) {
+        var _a, _b, _c, _d, _e, _f;
         const specificTypeItems = [];
         if (styledColumn.GradientStyle || styledColumn.PercentBarStyle) {
             specificTypeItems.push({
@@ -175,8 +176,9 @@ export class StyledColumnModule extends AdaptableModuleBase {
             specificTypeItems.push({
                 name: 'Settings',
                 values: [
-                    `Include grouped rows: ${styledColumn.IncludeGroupedRows ? 'Yes' : 'No'}`,
-                    `Include row summaries: ${styledColumn.IncludeRowSummaries ? 'Yes' : 'No'}`,
+                    `Data Rows: ${((_b = (_a = styledColumn.BadgeStyle) === null || _a === void 0 ? void 0 : _a.RowScope) === null || _b === void 0 ? void 0 : _b.ExcludeDataRows) ? 'No' : 'Yes'}`,
+                    `Grouped Rows: ${((_d = (_c = styledColumn.BadgeStyle) === null || _c === void 0 ? void 0 : _c.RowScope) === null || _d === void 0 ? void 0 : _d.ExcludeGroupedRows) ? 'No' : 'Yes'}`,
+                    `Summary Rows: ${((_f = (_e = styledColumn.BadgeStyle) === null || _e === void 0 ? void 0 : _e.RowScope) === null || _f === void 0 ? void 0 : _f.ExcludeSummaryRows) ? 'No' : 'Yes'}`,
                 ],
             });
         }