@adaptabletools/adaptable-cjs 22.1.1-canary.1 → 23.0.0-canary.0

package/src/Utilities/Helpers/ScheduledJobsMiddlewareHelper.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshScheduledAlertJobs = refreshScheduledAlertJobs;
+exports.refreshScheduledReportJobs = refreshScheduledReportJobs;
+const tslib_1 = require("tslib");
+const ModuleConstants = tslib_1.__importStar(require("../Constants/ModuleConstants"));
+function refreshScheduledAlertJobs(adaptable) {
+    const alertModule = adaptable.adaptableModules.get(ModuleConstants.AlertModuleId);
+    alertModule?.setUpScheduledAlertJobs?.();
+}
+function refreshScheduledReportJobs(adaptable) {
+    const exportModule = adaptable.adaptableModules.get(ModuleConstants.ExportModuleId);
+    exportModule?.setUpScheduledReportJobs?.();
+}

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

@@ -0,0 +1,16 @@
+import { ExportState, ReportNameType, ReportSchedule } from '../../AdaptableState/ExportState';
+export declare function reportScheduleToSchedule(reportSchedule: {
+    ReportName?: string;
+    ScheduleType?: string;
+} & Omit<ReportSchedule, 'ReportName'> & Partial<Pick<ReportSchedule, 'ReportName'>>): ReportSchedule;
+export declare function withReportName(schedule: ReportSchedule, reportName: ReportNameType): ReportSchedule;
+export declare function normalizeScheduledReportSchedule(schedule: ReportSchedule): ReportSchedule;
+export declare function getScheduledReports(exportState: ExportState): ReportSchedule[];
+export declare function exportStateNeedsScheduleUuids(exportState: ExportState): boolean;
+/**
+ * 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 declare function ensureExportStateSchedulesUuids(exportState: ExportState): ExportState;
+export declare function replaceScheduledReportScheduleInList(schedules: ReportSchedule[], schedule: ReportSchedule): ReportSchedule[];
+export declare function countSchedulesForReport(exportState: ExportState, reportName: ReportNameType): number;

package/src/Utilities/Helpers/ScheduledReportHelper.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportScheduleToSchedule = reportScheduleToSchedule;
+exports.withReportName = withReportName;
+exports.normalizeScheduledReportSchedule = normalizeScheduledReportSchedule;
+exports.getScheduledReports = getScheduledReports;
+exports.exportStateNeedsScheduleUuids = exportStateNeedsScheduleUuids;
+exports.ensureExportStateSchedulesUuids = ensureExportStateSchedulesUuids;
+exports.replaceScheduledReportScheduleInList = replaceScheduledReportScheduleInList;
+exports.countSchedulesForReport = countSchedulesForReport;
+const Uuid_1 = require("../../AdaptableState/Uuid");
+function reportScheduleToSchedule(reportSchedule) {
+    const { ReportName: reportName, ScheduleType: _scheduleType, ...schedule } = reportSchedule;
+    return {
+        ...schedule,
+        ReportName: reportSchedule.ReportName ?? reportName ?? '',
+    };
+}
+function withReportName(schedule, reportName) {
+    return { ...schedule, ReportName: reportName };
+}
+function normalizeScheduledReportSchedule(schedule) {
+    return schedule;
+}
+function getScheduledReports(exportState) {
+    return exportState.ReportSchedules ?? [];
+}
+function ensureScheduleUuid(schedule) {
+    return schedule.Uuid ? schedule : { ...schedule, Uuid: (0, Uuid_1.createUuid)() };
+}
+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).
+ */
+function ensureExportStateSchedulesUuids(exportState) {
+    if (!exportStateNeedsScheduleUuids(exportState)) {
+        return exportState;
+    }
+    return {
+        ...exportState,
+        ReportSchedules: (exportState.ReportSchedules ?? []).map(ensureScheduleUuid),
+    };
+}
+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;
+}
+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,7 +1,96 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVariableColor = exports.toStyle = exports.convertCSSAbsoluteFontSizeToPt = exports.convertAdaptableStyleToCSS = exports.sanitizeStyle = exports.normalizeStyleForAgGrid = exports.AgGridCellStyleProperties = void 0;
+exports.getVariableColor = exports.toStyle = exports.convertCSSAbsoluteFontSizeToPt = exports.convertAdaptableStyleToCSS = exports.sanitizeStyle = exports.normalizeStyleForAgGrid = exports.AgGridCellStyleProperties = exports.omitCellBoxStyle = exports.omitCellFontStyle = exports.pickCellBoxStyle = exports.pickCellFontStyle = exports.hasCellBoxStyle = exports.hasCellFontStyle = exports.CELL_BOX_STYLE_KEYS = exports.CELL_FONT_STYLE_KEYS = void 0;
 const EnumExtensions_1 = require("../Extensions/EnumExtensions");
+/**
+ * Keys belonging to the "Font" slice (text rendering + alignment).
+ * See {@link CellFontStyle}.
+ */
+exports.CELL_FONT_STYLE_KEYS = [
+    'ForeColor',
+    'FontWeight',
+    'FontStyle',
+    'TextDecoration',
+    'FontSize',
+    'Alignment',
+];
+/**
+ * Keys belonging to the "Cell" slice (cell chrome — background and border).
+ * See {@link CellBoxStyle}.
+ */
+exports.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.
+ */
+const hasCellFontStyle = (style) => hasAtLeastOneKey(style, exports.CELL_FONT_STYLE_KEYS);
+exports.hasCellFontStyle = hasCellFontStyle;
+/**
+ * Returns true when the given style has any property in the Cell (box) slice set.
+ */
+const hasCellBoxStyle = (style) => hasAtLeastOneKey(style, exports.CELL_BOX_STYLE_KEYS);
+exports.hasCellBoxStyle = hasCellBoxStyle;
+/**
+ * Returns a copy of `style` containing only Font-slice keys.
+ */
+const pickCellFontStyle = (style) => {
+    const out = {};
+    if (!style) {
+        return out;
+    }
+    exports.CELL_FONT_STYLE_KEYS.forEach((k) => {
+        const v = style[k];
+        if (v !== undefined && v !== null) {
+            out[k] = v;
+        }
+    });
+    return out;
+};
+exports.pickCellFontStyle = pickCellFontStyle;
+/**
+ * Returns a copy of `style` containing only Cell-slice (box) keys.
+ */
+const pickCellBoxStyle = (style) => {
+    const out = {};
+    if (!style) {
+        return out;
+    }
+    exports.CELL_BOX_STYLE_KEYS.forEach((k) => {
+        const v = style[k];
+        if (v !== undefined && v !== null) {
+            out[k] = v;
+        }
+    });
+    return out;
+};
+exports.pickCellBoxStyle = pickCellBoxStyle;
+/**
+ * Returns a copy of `style` with all Font-slice keys removed.
+ */
+const omitCellFontStyle = (style) => {
+    const out = { ...(style ?? {}) };
+    exports.CELL_FONT_STYLE_KEYS.forEach((k) => delete out[k]);
+    return out;
+};
+exports.omitCellFontStyle = omitCellFontStyle;
+/**
+ * Returns a copy of `style` with all Cell-slice (box) keys removed.
+ */
+const omitCellBoxStyle = (style) => {
+    const out = { ...(style ?? {}) };
+    exports.CELL_BOX_STYLE_KEYS.forEach((k) => delete out[k]);
+    return out;
+};
+exports.omitCellBoxStyle = omitCellBoxStyle;
 // required for hacky fix for https://github.com/AdaptableTools/adaptable/issues/2119
 exports.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,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_GRADIENT_MAX_ALPHA = exports.DEFAULT_GRADIENT_MIN_ALPHA = void 0;
+exports.expandGradientCellRanges = expandGradientCellRanges;
+exports.gradientStyleRangeLookupValueType = gradientStyleRangeLookupValueType;
+exports.isNegativeZeroCentredBand = isNegativeZeroCentredBand;
+/**
+ * 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).
+ */
+exports.DEFAULT_GRADIENT_MIN_ALPHA = 0.15;
+/**
+ * Default alpha at the **high** end of a Gradient range when `MaxAlpha` is unset.
+ */
+exports.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.
+ */
+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.
+ */
+function gradientStyleRangeLookupValueType(gs) {
+    return gs.ZeroCentred ? 'Number' : gs.RangeValueType ?? 'Number';
+}
+/** The negative half of a zero-centred gradient (darker toward Col-Min). */
+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,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAlertFormForDefinition = resolveAlertFormForDefinition;
+const ScheduledAlertHelper_1 = require("./ScheduledAlertHelper");
+function resolveAlertFormForDefinition(alert, defaultForm) {
+    if ((0, ScheduledAlertHelper_1.isScheduledAlertDefinition)(alert)) {
+        if (!alert.AlertProperties?.DisplayNotification) {
+            return defaultForm;
+        }
+        return (0, ScheduledAlertHelper_1.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,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closeAgChartDefinitionIfOpen = closeAgChartDefinitionIfOpen;
+exports.closeExternalChartDefinitionIfOpen = closeExternalChartDefinitionIfOpen;
+exports.closeChartDefinitionIfOpen = closeChartDefinitionIfOpen;
+exports.closeAllOpenAgCharts = closeAllOpenAgCharts;
+exports.isChartNameTaken = isChartNameTaken;
+exports.validateChartName = validateChartName;
+exports.resolveAgChartDefinitionByName = resolveAgChartDefinitionByName;
+exports.showChartDefinitions = showChartDefinitions;
+exports.restoreChartsOnReady = restoreChartsOnReady;
+exports.openLayoutCharts = openLayoutCharts;
+const tslib_1 = require("tslib");
+const ChartingState_1 = require("../../AdaptableState/ChartingState");
+const StringExtensions_1 = tslib_1.__importDefault(require("../Extensions/StringExtensions"));
+function closeAgChartDefinitionIfOpen(api, chartDefinition) {
+    const chartId = chartDefinition?.Model?.chartId;
+    if (!chartId) {
+        return;
+    }
+    const chartRef = api.chartingApi.getChartRef(chartId);
+    chartRef?.destroyChart();
+}
+function closeExternalChartDefinitionIfOpen(api, chartDefinition) {
+    if (api.chartingApi.internalApi.isExternalChartOpened(chartDefinition)) {
+        api.chartingApi.internalApi.onHideExternalChart(chartDefinition);
+    }
+}
+function closeChartDefinitionIfOpen(api, chartDefinition) {
+    if ((0, ChartingState_1.isAgChartDefinition)(chartDefinition)) {
+        closeAgChartDefinitionIfOpen(api, chartDefinition);
+    }
+    else if ((0, ChartingState_1.isExternalChartDefinition)(chartDefinition)) {
+        closeExternalChartDefinitionIfOpen(api, chartDefinition);
+    }
+}
+function closeAllOpenAgCharts(api) {
+    api.chartingApi.getCurrentChartModels().forEach((model) => {
+        api.chartingApi.getChartRef(model.chartId)?.destroyChart();
+    });
+}
+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);
+}
+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;
+}
+function resolveAgChartDefinitionByName(api, chartName) {
+    if (!StringExtensions_1.default.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_1.default.IsNotNullOrEmpty(containerName)) {
+        return undefined;
+    }
+    const chartingOptions = api.optionsApi.getChartingOptions();
+    if (containerName === chartingOptions.agGridContainerName) {
+        return undefined;
+    }
+    return api.chartingApi.internalApi.getContainerElemetnByName(containerName) ?? undefined;
+}
+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;
+}
+function restoreChartsOnReady(api) {
+    const chartingOptions = api.optionsApi.getChartingOptions();
+    const chartsToRestore = resolveChartDefinitionsToRestore(api, chartingOptions.restoreChartsOnReady);
+    if (!chartsToRestore.length) {
+        return;
+    }
+    showChartDefinitions(api, chartsToRestore);
+}
+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,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnsupportedColumnDataTypeForIconStyle = isUnsupportedColumnDataTypeForIconStyle;
+/**
+ * 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).
+ */
+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,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePlusMinusTriggerKeysForNudge = resolvePlusMinusTriggerKeysForNudge;
+exports.plusMinusResolvedKeysConflict = plusMinusResolvedKeysConflict;
+exports.plusMinusKeyMatches = plusMinusKeyMatches;
+exports.plusMinusIncrementKeyFromOptionsOnly = plusMinusIncrementKeyFromOptionsOnly;
+exports.plusMinusDecrementKeyFromOptionsOnly = plusMinusDecrementKeyFromOptionsOnly;
+exports.plusMinusTriggerSameAsBaseline = plusMinusTriggerSameAsBaseline;
+exports.buildPlusMinusTriggerKeyLookup = buildPlusMinusTriggerKeyLookup;
+exports.plusMinusKeyCouldTrigger = plusMinusKeyCouldTrigger;
+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 `+` / `-`.
+ */
+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. */
+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).
+ */
+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 `+`. */
+function plusMinusIncrementKeyFromOptionsOnly(globalOptions) {
+    return globalOptions?.incrementKey?.trim() || DEFAULT_INCREMENT_KEY;
+}
+/** Decrement key from `AdaptableOptions.plusMinusOptions` only, then built-in `-`. */
+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}).
+ */
+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). */
+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.
+ */
+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;