@adaptabletools/adaptable 22.1.1 → 23.0.0-canary.1

package/src/Utilities/Helpers/ScheduledReportHelper.js

@@ -0,0 +1,49 @@
+import { createUuid } from '../../AdaptableState/Uuid';
+export function reportScheduleToSchedule(reportSchedule) {
+    const { ReportName: reportName, ScheduleType: _scheduleType, ...schedule } = reportSchedule;
+    return {
+        ...schedule,
+        ReportName: reportSchedule.ReportName ?? reportName ?? '',
+    };
+}
+export function withReportName(schedule, reportName) {
+    return { ...schedule, ReportName: reportName };
+}
+export function normalizeScheduledReportSchedule(schedule) {
+    return schedule;
+}
+export function getScheduledReports(exportState) {
+    return exportState.ReportSchedules ?? [];
+}
+function ensureScheduleUuid(schedule) {
+    return schedule.Uuid ? schedule : { ...schedule, Uuid: createUuid() };
+}
+export function exportStateNeedsScheduleUuids(exportState) {
+    return (exportState.ReportSchedules ?? []).some((schedule) => !schedule.Uuid);
+}
+/**
+ * Assigns a unique {@link ReportSchedule.Uuid} to any schedule that lacks one.
+ * Required so edit/suspend/delete match a single schedule (not every `undefined` uuid).
+ */
+export function ensureExportStateSchedulesUuids(exportState) {
+    if (!exportStateNeedsScheduleUuids(exportState)) {
+        return exportState;
+    }
+    return {
+        ...exportState,
+        ReportSchedules: (exportState.ReportSchedules ?? []).map(ensureScheduleUuid),
+    };
+}
+export function replaceScheduledReportScheduleInList(schedules, schedule) {
+    const index = schedules.findIndex((s) => s.Uuid === schedule.Uuid);
+    if (index < 0) {
+        return schedules;
+    }
+    const next = [...schedules];
+    next[index] = schedule;
+    return next;
+}
+export function countSchedulesForReport(exportState, reportName) {
+    return getScheduledReports(exportState).filter((s) => s.ReportName === reportName)
+        .length;
+}

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

@@ -1,4 +1,39 @@
 import { AdaptableStyle } from '../../types';
+import { CellBoxStyle, CellFontStyle } from '../../AdaptableState/Common/AdaptableStyle';
+/**
+ * Keys belonging to the "Font" slice (text rendering + alignment).
+ * See {@link CellFontStyle}.
+ */
+export declare const CELL_FONT_STYLE_KEYS: ReadonlyArray<keyof CellFontStyle>;
+/**
+ * Keys belonging to the "Cell" slice (cell chrome — background and border).
+ * See {@link CellBoxStyle}.
+ */
+export declare const CELL_BOX_STYLE_KEYS: ReadonlyArray<keyof CellBoxStyle>;
+/**
+ * Returns true when the given style has any property in the Font slice set.
+ */
+export declare const hasCellFontStyle: (style: Partial<CellFontStyle> | undefined) => boolean;
+/**
+ * Returns true when the given style has any property in the Cell (box) slice set.
+ */
+export declare const hasCellBoxStyle: (style: Partial<CellBoxStyle> | undefined) => boolean;
+/**
+ * Returns a copy of `style` containing only Font-slice keys.
+ */
+export declare const pickCellFontStyle: (style: Partial<AdaptableStyle> | undefined) => CellFontStyle;
+/**
+ * Returns a copy of `style` containing only Cell-slice (box) keys.
+ */
+export declare const pickCellBoxStyle: (style: Partial<AdaptableStyle> | undefined) => CellBoxStyle;
+/**
+ * Returns a copy of `style` with all Font-slice keys removed.
+ */
+export declare const omitCellFontStyle: (style: AdaptableStyle | undefined) => AdaptableStyle;
+/**
+ * Returns a copy of `style` with all Cell-slice (box) keys removed.
+ */
+export declare const omitCellBoxStyle: (style: AdaptableStyle | undefined) => AdaptableStyle;
 export declare const AgGridCellStyleProperties: readonly ["backgroundColor", "color", "fontWeight", "fontStyle", "fontSize", "borderColor", "--ab-dynamic-background-color", "--ab-dynamic-color", "--ab-dynamic-font-weight", "--ab-dynamic-font-style", "--ab-dynamic-font-size", "--ab-dynamic-text-decoration", "--ab-dynamic-border-radius", "--ab-dynamic-border-color"];
 export declare const normalizeStyleForAgGrid: (style: Record<string, any>) => {
     [x: string]: any;

package/src/Utilities/Helpers/StyleHelper.js

@@ -1,4 +1,87 @@
 import { EnumExtensions } from '../Extensions/EnumExtensions';
+/**
+ * Keys belonging to the "Font" slice (text rendering + alignment).
+ * See {@link CellFontStyle}.
+ */
+export const CELL_FONT_STYLE_KEYS = [
+    'ForeColor',
+    'FontWeight',
+    'FontStyle',
+    'TextDecoration',
+    'FontSize',
+    'Alignment',
+];
+/**
+ * Keys belonging to the "Cell" slice (cell chrome — background and border).
+ * See {@link CellBoxStyle}.
+ */
+export const CELL_BOX_STYLE_KEYS = [
+    'BackColor',
+    'BorderColor',
+    'BorderRadius',
+];
+const hasAtLeastOneKey = (obj, keys) => {
+    if (!obj) {
+        return false;
+    }
+    return keys.some((k) => obj[k] !== undefined && obj[k] !== null);
+};
+/**
+ * Returns true when the given style has any property in the Font slice set.
+ */
+export const hasCellFontStyle = (style) => hasAtLeastOneKey(style, CELL_FONT_STYLE_KEYS);
+/**
+ * Returns true when the given style has any property in the Cell (box) slice set.
+ */
+export const hasCellBoxStyle = (style) => hasAtLeastOneKey(style, CELL_BOX_STYLE_KEYS);
+/**
+ * Returns a copy of `style` containing only Font-slice keys.
+ */
+export const pickCellFontStyle = (style) => {
+    const out = {};
+    if (!style) {
+        return out;
+    }
+    CELL_FONT_STYLE_KEYS.forEach((k) => {
+        const v = style[k];
+        if (v !== undefined && v !== null) {
+            out[k] = v;
+        }
+    });
+    return out;
+};
+/**
+ * Returns a copy of `style` containing only Cell-slice (box) keys.
+ */
+export const pickCellBoxStyle = (style) => {
+    const out = {};
+    if (!style) {
+        return out;
+    }
+    CELL_BOX_STYLE_KEYS.forEach((k) => {
+        const v = style[k];
+        if (v !== undefined && v !== null) {
+            out[k] = v;
+        }
+    });
+    return out;
+};
+/**
+ * Returns a copy of `style` with all Font-slice keys removed.
+ */
+export const omitCellFontStyle = (style) => {
+    const out = { ...(style ?? {}) };
+    CELL_FONT_STYLE_KEYS.forEach((k) => delete out[k]);
+    return out;
+};
+/**
+ * Returns a copy of `style` with all Cell-slice (box) keys removed.
+ */
+export const omitCellBoxStyle = (style) => {
+    const out = { ...(style ?? {}) };
+    CELL_BOX_STYLE_KEYS.forEach((k) => delete out[k]);
+    return out;
+};
 // required for hacky fix for https://github.com/AdaptableTools/adaptable/issues/2119
 export const AgGridCellStyleProperties = [
     'backgroundColor',

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

@@ -0,0 +1,30 @@
+import { CellColorRange, GradientStyle, NumericStyledColumn } from '../../AdaptableState/StyledColumnState';
+/**
+ * Default alpha at the **low** end of a Gradient range when `MinAlpha` is unset.
+ * Slightly above zero so the bottom-edge value of every range still shows its
+ * colour (rather than rendering fully transparent).
+ */
+export declare const DEFAULT_GRADIENT_MIN_ALPHA = 0.15;
+/**
+ * Default alpha at the **high** end of a Gradient range when `MaxAlpha` is unset.
+ */
+export declare const DEFAULT_GRADIENT_MAX_ALPHA = 1;
+/**
+ * Effective cell ranges for gradient rendering / range lookup.
+ * When `ZeroCentred` is set, expands to the canonical Col-Min…0 and 0…Col-Max bands.
+ */
+export declare function expandGradientCellRanges(gs: GradientStyle): CellColorRange[] | undefined;
+/**
+ * Value type passed to `findRangeForColumn` / `getCellColorRangeMinValue` /
+ * `getCellColorRangeMaxValue` when resolving which gradient band a cell falls in.
+ *
+ * Zero-centred bands use numeric `0` as an **absolute** zero crossing between
+ * `Col-Min…0` and `0…Col-Max`. Under `RangeValueType: 'Percentage'`, numeric
+ * endpoints are interpreted as % positions along the column min–max span, so
+ * literal `0` wrongly becomes `Col-Min` and the negative band collapses to a
+ * single point — boundary cells (e.g. the column minimum) pick up the negative
+ * colour incorrectly. Zero-centred lookup must always use Number semantics.
+ */
+export declare function gradientStyleRangeLookupValueType(gs: GradientStyle): NumericStyledColumn['RangeValueType'];
+/** The negative half of a zero-centred gradient (darker toward Col-Min). */
+export declare function isNegativeZeroCentredBand(range: CellColorRange): boolean;

package/src/Utilities/Helpers/StyledColumnGradientHelper.js

@@ -0,0 +1,41 @@
+/**
+ * Default alpha at the **low** end of a Gradient range when `MinAlpha` is unset.
+ * Slightly above zero so the bottom-edge value of every range still shows its
+ * colour (rather than rendering fully transparent).
+ */
+export const DEFAULT_GRADIENT_MIN_ALPHA = 0.15;
+/**
+ * Default alpha at the **high** end of a Gradient range when `MaxAlpha` is unset.
+ */
+export const DEFAULT_GRADIENT_MAX_ALPHA = 1;
+/**
+ * Effective cell ranges for gradient rendering / range lookup.
+ * When `ZeroCentred` is set, expands to the canonical Col-Min…0 and 0…Col-Max bands.
+ */
+export function expandGradientCellRanges(gs) {
+    if (gs.ZeroCentred) {
+        return [
+            { Min: 'Col-Min', Max: 0, Color: gs.ZeroCentred.NegativeColor },
+            { Min: 0, Max: 'Col-Max', Color: gs.ZeroCentred.PositiveColor },
+        ];
+    }
+    return gs.CellRanges;
+}
+/**
+ * Value type passed to `findRangeForColumn` / `getCellColorRangeMinValue` /
+ * `getCellColorRangeMaxValue` when resolving which gradient band a cell falls in.
+ *
+ * Zero-centred bands use numeric `0` as an **absolute** zero crossing between
+ * `Col-Min…0` and `0…Col-Max`. Under `RangeValueType: 'Percentage'`, numeric
+ * endpoints are interpreted as % positions along the column min–max span, so
+ * literal `0` wrongly becomes `Col-Min` and the negative band collapses to a
+ * single point — boundary cells (e.g. the column minimum) pick up the negative
+ * colour incorrectly. Zero-centred lookup must always use Number semantics.
+ */
+export function gradientStyleRangeLookupValueType(gs) {
+    return gs.ZeroCentred ? 'Number' : gs.RangeValueType ?? 'Number';
+}
+/** The negative half of a zero-centred gradient (darker toward Col-Min). */
+export function isNegativeZeroCentredBand(range) {
+    return range.Min === 'Col-Min' && range.Max === 0;
+}

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

@@ -0,0 +1,2 @@
+import { AlertButtonForm, AlertDefinition } from '../../AdaptableState/AlertState';
+export declare function resolveAlertFormForDefinition(alert: AlertDefinition, defaultForm: AlertButtonForm): string | AlertButtonForm;

package/src/Utilities/Helpers/alertFormHelper.js

@@ -0,0 +1,11 @@
+import { getScheduledAlertNotificationForm, isScheduledAlertDefinition, } from './ScheduledAlertHelper';
+export function resolveAlertFormForDefinition(alert, defaultForm) {
+    if (isScheduledAlertDefinition(alert)) {
+        if (!alert.AlertProperties?.DisplayNotification) {
+            return defaultForm;
+        }
+        return getScheduledAlertNotificationForm(alert.AlertProperties?.IncludeSuspendButton ?? false);
+    }
+    const ruleAlert = alert;
+    return ruleAlert.AlertForm ?? defaultForm;
+}

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

@@ -0,0 +1,14 @@
+import { ChartRef } from 'ag-grid-enterprise';
+import { ChartDefinition, ExternalChartDefinition } from '../../AdaptableState/ChartingState';
+import { Layout, LayoutOpenChart } from '../../AdaptableState/LayoutState';
+import { AdaptableApi } from '../../Api/AdaptableApi';
+export declare function closeAgChartDefinitionIfOpen(api: AdaptableApi, chartDefinition: ChartDefinition): void;
+export declare function closeExternalChartDefinitionIfOpen(api: AdaptableApi, chartDefinition: ExternalChartDefinition): void;
+export declare function closeChartDefinitionIfOpen(api: AdaptableApi, chartDefinition: ChartDefinition | ExternalChartDefinition): void;
+export declare function closeAllOpenAgCharts(api: AdaptableApi): void;
+export declare function isChartNameTaken(api: AdaptableApi, name: string, excludeUuid?: string): boolean;
+export declare function validateChartName(api: AdaptableApi, name: string, excludeUuid?: string): true | string;
+export declare function resolveAgChartDefinitionByName(api: AdaptableApi, chartName: string): ChartDefinition | undefined;
+export declare function showChartDefinitions(api: AdaptableApi, chartDefinitions: ChartDefinition[], openCharts?: LayoutOpenChart[]): ChartRef[];
+export declare function restoreChartsOnReady(api: AdaptableApi): void;
+export declare function openLayoutCharts(api: AdaptableApi, layout: Layout | undefined): void;

package/src/Utilities/Helpers/chartingHelper.js

@@ -0,0 +1,112 @@
+import { isAgChartDefinition, isExternalChartDefinition, } from '../../AdaptableState/ChartingState';
+import StringExtensions from '../Extensions/StringExtensions';
+export function closeAgChartDefinitionIfOpen(api, chartDefinition) {
+    const chartId = chartDefinition?.Model?.chartId;
+    if (!chartId) {
+        return;
+    }
+    const chartRef = api.chartingApi.getChartRef(chartId);
+    chartRef?.destroyChart();
+}
+export function closeExternalChartDefinitionIfOpen(api, chartDefinition) {
+    if (api.chartingApi.internalApi.isExternalChartOpened(chartDefinition)) {
+        api.chartingApi.internalApi.onHideExternalChart(chartDefinition);
+    }
+}
+export function closeChartDefinitionIfOpen(api, chartDefinition) {
+    if (isAgChartDefinition(chartDefinition)) {
+        closeAgChartDefinitionIfOpen(api, chartDefinition);
+    }
+    else if (isExternalChartDefinition(chartDefinition)) {
+        closeExternalChartDefinitionIfOpen(api, chartDefinition);
+    }
+}
+export function closeAllOpenAgCharts(api) {
+    api.chartingApi.getCurrentChartModels().forEach((model) => {
+        api.chartingApi.getChartRef(model.chartId)?.destroyChart();
+    });
+}
+export function isChartNameTaken(api, name, excludeUuid) {
+    const trimmedName = name?.trim();
+    if (!trimmedName) {
+        return false;
+    }
+    return [...api.chartingApi.getChartDefinitions(), ...api.chartingApi.getExternalChartDefinitions()]
+        .filter((chart) => chart.Uuid !== excludeUuid)
+        .some((chart) => chart.Name === trimmedName);
+}
+export function validateChartName(api, name, excludeUuid) {
+    const trimmedName = name?.trim();
+    if (!trimmedName) {
+        return 'A name is required.';
+    }
+    if (isChartNameTaken(api, trimmedName, excludeUuid)) {
+        return 'A chart with this name already exists.';
+    }
+    return true;
+}
+export function resolveAgChartDefinitionByName(api, chartName) {
+    if (!StringExtensions.IsNotNullOrEmpty(chartName)) {
+        return undefined;
+    }
+    return api.chartingApi.getChartDefinitionByName(chartName.trim());
+}
+function resolveChartDefinitionsToRestore(api, restoreChartsOnReady) {
+    const allCharts = api.chartingApi.getChartDefinitions();
+    if (!restoreChartsOnReady) {
+        return [];
+    }
+    if (restoreChartsOnReady === true || restoreChartsOnReady === 'all') {
+        return allCharts;
+    }
+    if (Array.isArray(restoreChartsOnReady)) {
+        return restoreChartsOnReady
+            .map((chartName) => resolveAgChartDefinitionByName(api, chartName))
+            .filter(Boolean);
+    }
+    return [];
+}
+function resolveContainerElement(api, containerName) {
+    if (!StringExtensions.IsNotNullOrEmpty(containerName)) {
+        return undefined;
+    }
+    const chartingOptions = api.optionsApi.getChartingOptions();
+    if (containerName === chartingOptions.agGridContainerName) {
+        return undefined;
+    }
+    return api.chartingApi.internalApi.getContainerElemetnByName(containerName) ?? undefined;
+}
+export function showChartDefinitions(api, chartDefinitions, openCharts) {
+    const refs = [];
+    chartDefinitions.forEach((chartDefinition) => {
+        const openSpec = openCharts?.find((openChart) => openChart.ChartName === chartDefinition.Name);
+        const container = resolveContainerElement(api, openSpec?.ContainerName);
+        const chartRef = api.chartingApi.showChartDefinitionOnce(chartDefinition, container);
+        if (chartRef) {
+            refs.push(chartRef);
+        }
+    });
+    return refs;
+}
+export function restoreChartsOnReady(api) {
+    const chartingOptions = api.optionsApi.getChartingOptions();
+    const chartsToRestore = resolveChartDefinitionsToRestore(api, chartingOptions.restoreChartsOnReady);
+    if (!chartsToRestore.length) {
+        return;
+    }
+    showChartDefinitions(api, chartsToRestore);
+}
+export function openLayoutCharts(api, layout) {
+    if (!layout || layout.OpenCharts === undefined) {
+        return;
+    }
+    closeAllOpenAgCharts(api);
+    if (!layout.OpenCharts.length) {
+        return;
+    }
+    const chartsToOpen = layout.OpenCharts.map((openChart) => resolveAgChartDefinitionByName(api, openChart.ChartName)).filter(Boolean);
+    if (!chartsToOpen.length) {
+        return;
+    }
+    showChartDefinitions(api, chartsToOpen, layout.OpenCharts);
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Icon Column Style resolves one key → glyph per scalar cell value; AdapTable
+ * array column types are not supported (use Badge Style for per-element visuals).
+ */
+export declare function isUnsupportedColumnDataTypeForIconStyle(dataType?: string): boolean;

package/src/Utilities/Helpers/iconStyledColumnColumnSupport.js

@@ -0,0 +1,15 @@
+/**
+ * Icon Column Style resolves one key → glyph per scalar cell value; AdapTable
+ * array column types are not supported (use Badge Style for per-element visuals).
+ */
+export function isUnsupportedColumnDataTypeForIconStyle(dataType) {
+    switch (dataType) {
+        case 'textArray':
+        case 'numberArray':
+        case 'tupleArray':
+        case 'objectArray':
+            return true;
+        default:
+            return false;
+    }
+}

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

@@ -0,0 +1,41 @@
+import type { EditOptions, PlusMinusOptions } from '../../AdaptableOptions/EditOptions';
+import type { PlusMinusNudge } from '../../AdaptableState/PlusMinusState';
+/**
+ * Resolve increment/decrement trigger strings for a single nudge.
+ * Per-nudge fields win; otherwise {@link PlusMinusOptions}; otherwise `+` / `-`.
+ */
+export declare function resolvePlusMinusTriggerKeysForNudge(nudge: Pick<PlusMinusNudge, 'IncrementKey' | 'DecrementKey'>, globalOptions: Readonly<EditOptions['plusMinusOptions']> | undefined): {
+    incrementKey: string;
+    decrementKey: string;
+};
+/** True when resolved increment and decrement would match the same key press. */
+export declare function plusMinusResolvedKeysConflict(nudge: Pick<PlusMinusNudge, 'IncrementKey' | 'DecrementKey'>, globalOptions: Readonly<EditOptions['plusMinusOptions']> | undefined): boolean;
+/**
+ * Match a pressed key against a configured trigger. Single-character keys are
+ * compared case-insensitively (aligned with Shortcut module behaviour).
+ */
+export declare function plusMinusKeyMatches(actualKey: string, configuredKey: string): boolean;
+/** Increment key from `AdaptableOptions.plusMinusOptions` only, then built-in `+`. */
+export declare function plusMinusIncrementKeyFromOptionsOnly(globalOptions: Readonly<PlusMinusOptions> | undefined): string;
+/** Decrement key from `AdaptableOptions.plusMinusOptions` only, then built-in `-`. */
+export declare function plusMinusDecrementKeyFromOptionsOnly(globalOptions: Readonly<PlusMinusOptions> | undefined): string;
+/**
+ * True when `candidate` is the same trigger as `baseline` for “no nudge override to persist”
+ * (single-character keys compared case-insensitively, same as {@link plusMinusKeyMatches}).
+ */
+export declare function plusMinusTriggerSameAsBaseline(candidate: string, baseline: string): boolean;
+/**
+ * Precomputed keys for fast keydown filtering (mirrors {@link plusMinusKeyMatches} semantics).
+ * Single-character triggers are stored lowercased; longer triggers are exact strings.
+ */
+export type PlusMinusTriggerKeyLookup = {
+    singleCharLower: Set<string>;
+    exactKeys: Set<string>;
+};
+/** Build a lookup of all increment/decrement keys across active nudges (resolved). */
+export declare function buildPlusMinusTriggerKeyLookup(nudges: PlusMinusNudge[], globalOptions: Readonly<PlusMinusOptions> | undefined): PlusMinusTriggerKeyLookup;
+/**
+ * O(1) check: whether this pressed key could match any configured Plus Minus trigger.
+ * When false, skip fetching cells / running nudge rules.
+ */
+export declare function plusMinusKeyCouldTrigger(keyEventString: string, lookup: PlusMinusTriggerKeyLookup): boolean;

package/src/Utilities/Helpers/plusMinusTriggerKeys.js

@@ -0,0 +1,90 @@
+const DEFAULT_INCREMENT_KEY = '+';
+const DEFAULT_DECREMENT_KEY = '-';
+/**
+ * Resolve increment/decrement trigger strings for a single nudge.
+ * Per-nudge fields win; otherwise {@link PlusMinusOptions}; otherwise `+` / `-`.
+ */
+export function resolvePlusMinusTriggerKeysForNudge(nudge, globalOptions) {
+    const incrementKey = nudge.IncrementKey?.trim() || plusMinusIncrementKeyFromOptionsOnly(globalOptions);
+    const decrementKey = nudge.DecrementKey?.trim() || plusMinusDecrementKeyFromOptionsOnly(globalOptions);
+    return { incrementKey, decrementKey };
+}
+/** True when resolved increment and decrement would match the same key press. */
+export function plusMinusResolvedKeysConflict(nudge, globalOptions) {
+    const { incrementKey, decrementKey } = resolvePlusMinusTriggerKeysForNudge(nudge, globalOptions);
+    if (incrementKey === decrementKey) {
+        return true;
+    }
+    if (incrementKey.length === 1 && decrementKey.length === 1) {
+        return incrementKey.toLowerCase() === decrementKey.toLowerCase();
+    }
+    return false;
+}
+/**
+ * Match a pressed key against a configured trigger. Single-character keys are
+ * compared case-insensitively (aligned with Shortcut module behaviour).
+ */
+export function plusMinusKeyMatches(actualKey, configuredKey) {
+    if (!configuredKey) {
+        return false;
+    }
+    if (actualKey === configuredKey) {
+        return true;
+    }
+    if (configuredKey.length === 1 && actualKey.length === 1) {
+        return actualKey.toLowerCase() === configuredKey.toLowerCase();
+    }
+    return false;
+}
+/** Increment key from `AdaptableOptions.plusMinusOptions` only, then built-in `+`. */
+export function plusMinusIncrementKeyFromOptionsOnly(globalOptions) {
+    return globalOptions?.incrementKey?.trim() || DEFAULT_INCREMENT_KEY;
+}
+/** Decrement key from `AdaptableOptions.plusMinusOptions` only, then built-in `-`. */
+export function plusMinusDecrementKeyFromOptionsOnly(globalOptions) {
+    return globalOptions?.decrementKey?.trim() || DEFAULT_DECREMENT_KEY;
+}
+/**
+ * True when `candidate` is the same trigger as `baseline` for “no nudge override to persist”
+ * (single-character keys compared case-insensitively, same as {@link plusMinusKeyMatches}).
+ */
+export function plusMinusTriggerSameAsBaseline(candidate, baseline) {
+    return plusMinusKeyMatches(candidate, baseline) && plusMinusKeyMatches(baseline, candidate);
+}
+function addConfiguredKeyToLookup(lookup, configuredKey) {
+    if (!configuredKey) {
+        return;
+    }
+    if (configuredKey.length === 1) {
+        lookup.singleCharLower.add(configuredKey.toLowerCase());
+    }
+    else {
+        lookup.exactKeys.add(configuredKey);
+    }
+}
+/** Build a lookup of all increment/decrement keys across active nudges (resolved). */
+export function buildPlusMinusTriggerKeyLookup(nudges, globalOptions) {
+    const lookup = {
+        singleCharLower: new Set(),
+        exactKeys: new Set(),
+    };
+    for (const nudge of nudges) {
+        const { incrementKey, decrementKey } = resolvePlusMinusTriggerKeysForNudge(nudge, globalOptions);
+        addConfiguredKeyToLookup(lookup, incrementKey);
+        addConfiguredKeyToLookup(lookup, decrementKey);
+    }
+    return lookup;
+}
+/**
+ * O(1) check: whether this pressed key could match any configured Plus Minus trigger.
+ * When false, skip fetching cells / running nudge rules.
+ */
+export function plusMinusKeyCouldTrigger(keyEventString, lookup) {
+    if (!keyEventString) {
+        return false;
+    }
+    if (keyEventString.length === 1) {
+        return lookup.singleCharLower.has(keyEventString.toLowerCase());
+    }
+    return lookup.exactKeys.has(keyEventString);
+}

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

@@ -0,0 +1,25 @@
+import type { IRowNode } from 'ag-grid-enterprise';
+import type { AdaptableApi } from '../../Api/AdaptableApi';
+import type { StyledColumn } from '../../AdaptableState/StyledColumnState';
+import type { RowScope } from '../../AdaptableState/Common/RowScope';
+/**
+ * Row kinds used by {@link RowScope} and the Styled Column Scope wizard.
+ * All are available to all Styled Columns with exception of Sparkline (which is data rows only)
+ */
+export type StyledColumnRowKind = 'Data' | 'Group' | 'Summary' | 'Total';
+export declare const STYLED_COLUMN_ROW_KINDS: StyledColumnRowKind[];
+export declare const STYLED_COLUMN_ROW_KIND_EXCLUDE_KEY: Record<StyledColumnRowKind, keyof RowScope>;
+export declare const isStyledColumnRowKindSupported: (styledColumn: StyledColumn, kind: StyledColumnRowKind) => boolean;
+export declare const getStyledColumnRowKindDisabledReason: (styledColumn: StyledColumn, kind: StyledColumnRowKind) => string | undefined;
+/**
+ * Classifies the AG Grid row node into a single {@link StyledColumnRowKind}.
+ * Order matches {@link shouldRenderStyledColumnOnRow}: total before summary,
+ * summary before group.
+ */
+export declare const getStyledColumnRowKindForNode: (node: IRowNode, api: AdaptableApi) => StyledColumnRowKind;
+/**
+ * Forces `Exclude*` to `true` for row kinds that do not apply to the current
+ * Styled Column type, so persisted state cannot contradict the capability
+ * matrix. Returns `undefined` when no change is needed.
+ */
+export declare const sanitizeStyledColumnRowScope: (styledColumn: StyledColumn) => RowScope | undefined;

package/src/Utilities/Helpers/styledColumnRowKindSupport.js

@@ -0,0 +1,63 @@
+export const STYLED_COLUMN_ROW_KINDS = ['Data', 'Group', 'Summary', 'Total'];
+export const STYLED_COLUMN_ROW_KIND_EXCLUDE_KEY = {
+    Data: 'ExcludeDataRows',
+    Group: 'ExcludeGroupRows',
+    Summary: 'ExcludeSummaryRows',
+    Total: 'ExcludeTotalRows',
+};
+export const isStyledColumnRowKindSupported = (styledColumn, kind) => {
+    if (styledColumn.SparklineStyle) {
+        return kind === 'Data';
+    }
+    return true;
+};
+export const getStyledColumnRowKindDisabledReason = (styledColumn, kind) => {
+    if (isStyledColumnRowKindSupported(styledColumn, kind)) {
+        return undefined;
+    }
+    if (styledColumn.SparklineStyle) {
+        return 'Sparklines only apply to leaf data rows (cells with a numeric array of points).';
+    }
+    return undefined;
+};
+/**
+ * Classifies the AG Grid row node into a single {@link StyledColumnRowKind}.
+ * Order matches {@link shouldRenderStyledColumnOnRow}: total before summary,
+ * summary before group.
+ */
+export const getStyledColumnRowKindForNode = (node, api) => {
+    if (api.gridApi.isGrandTotalRowNode(node)) {
+        return 'Total';
+    }
+    if (api.gridApi.isSummaryNode(node)) {
+        return 'Summary';
+    }
+    if (api.gridApi.isGroupRowNode(node)) {
+        return 'Group';
+    }
+    return 'Data';
+};
+/**
+ * Forces `Exclude*` to `true` for row kinds that do not apply to the current
+ * Styled Column type, so persisted state cannot contradict the capability
+ * matrix. Returns `undefined` when no change is needed.
+ */
+export const sanitizeStyledColumnRowScope = (styledColumn) => {
+    const scope = styledColumn.RowScope;
+    if (!scope) {
+        return undefined;
+    }
+    let next = { ...scope };
+    let changed = false;
+    for (const kind of STYLED_COLUMN_ROW_KINDS) {
+        if (isStyledColumnRowKindSupported(styledColumn, kind)) {
+            continue;
+        }
+        const key = STYLED_COLUMN_ROW_KIND_EXCLUDE_KEY[kind];
+        if (next[key] !== true) {
+            next = { ...next, [key]: true };
+            changed = true;
+        }
+    }
+    return changed ? next : undefined;
+};