@adaptabletools/adaptable-cjs 23.0.0-canary.0 → 23.0.0-canary.10

package/src/Utilities/Helpers/StyledColumns/PercentBarStyleHelper.d.ts

@@ -0,0 +1,20 @@
+import { StyledColumn } from '../../../AdaptableState/StyledColumnState';
+import { PercentBarStyle } from '../../../AdaptableState/StyledColumns/PercentBarStyle';
+export declare const hasPercentBarRangesConfigured: (pb: PercentBarStyle | undefined) => boolean;
+/** Illustrative scale for preview — shows negatives when origin is Auto or Zero. */
+export declare const getPercentBarPreviewScale: (pb: PercentBarStyle) => {
+    min: number;
+    max: number;
+};
+export declare const getPercentBarPreviewSampleValues: (pb: PercentBarStyle) => number[];
+export type PercentBarPreviewGeometry = {
+    barLeftPercent: number;
+    barWidthPercent: number;
+    percentageValue: number;
+    barColor?: string;
+};
+export declare const getPercentBarPreviewGeometry: (numericValue: number, pb: PercentBarStyle, min: number, max: number) => PercentBarPreviewGeometry;
+export declare const formatPercentBarPreviewCellText: (numericValue: number, percentageValue: number, pb: PercentBarStyle) => string;
+export declare const getPercentBarPreviewTrackColor: (pb: PercentBarStyle) => string | undefined;
+export declare const getPercentBarPreviewResolvedBarColor: (color: string | undefined) => string | undefined;
+export declare const hasPercentBarStylePreview: (styledColumn: StyledColumn) => boolean;

package/src/Utilities/Helpers/StyledColumns/PercentBarStyleHelper.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPercentBarStylePreview = exports.getPercentBarPreviewResolvedBarColor = exports.getPercentBarPreviewTrackColor = exports.formatPercentBarPreviewCellText = exports.getPercentBarPreviewGeometry = exports.getPercentBarPreviewSampleValues = exports.getPercentBarPreviewScale = exports.hasPercentBarRangesConfigured = void 0;
+const StyleHelper_1 = require("../StyleHelper");
+const NumberExtensions_1 = require("../../Extensions/NumberExtensions");
+const GradientStyleHelper_1 = require("./GradientStyleHelper");
+const BarStylesHelper_1 = require("./BarStylesHelper");
+const evenlySpacedValues = (min, max, count) => {
+    if (count <= 1) {
+        return [min];
+    }
+    const step = (max - min) / (count - 1);
+    return Array.from({ length: count }, (_, i) => min + step * i);
+};
+const toFraction = (value, min, max) => {
+    if (max === min) {
+        return 0;
+    }
+    return (0, NumberExtensions_1.clamp)((value - min) / (max - min), 0, 1);
+};
+const resolveOrigin = (percentBarStyle, cellValue, min, max) => {
+    const origin = percentBarStyle.Origin ?? 'Auto';
+    if (typeof origin === 'number') {
+        return origin;
+    }
+    if (origin === 'Zero') {
+        return 0;
+    }
+    if (origin === 'Min') {
+        return min;
+    }
+    if (min < 0 || max < 0 || cellValue < 0) {
+        return 0;
+    }
+    return min;
+};
+const columnComparisonUsesCentredAxis = (origin) => {
+    const o = origin ?? 'Auto';
+    if (typeof o === 'number') {
+        return false;
+    }
+    return o === 'Zero' || o === 'Auto';
+};
+const resolveRangeEndpoint = (endpoint, scaleMin, scaleMax) => {
+    if (endpoint === 'Col-Min') {
+        return scaleMin;
+    }
+    if (endpoint === 'Col-Max') {
+        return scaleMax;
+    }
+    if (typeof endpoint === 'number') {
+        return endpoint;
+    }
+    return scaleMin;
+};
+const getPreviewBarColor = (value, pb, scaleMin, scaleMax) => {
+    if (pb.ColumnComparison) {
+        return pb.ColumnComparison.Color;
+    }
+    for (const range of pb.CellRanges ?? []) {
+        const rMin = resolveRangeEndpoint(range.Min, scaleMin, scaleMax);
+        const rMax = resolveRangeEndpoint(range.Max, scaleMin, scaleMax);
+        if (value >= Math.min(rMin, rMax) && value <= Math.max(rMin, rMax)) {
+            return range.Color;
+        }
+    }
+    return pb.CellRanges?.[0]?.Color;
+};
+const hasPercentBarRangesConfigured = (pb) => !!(pb?.CellRanges?.length || pb?.ColumnComparison);
+exports.hasPercentBarRangesConfigured = hasPercentBarRangesConfigured;
+/** Illustrative scale for preview — shows negatives when origin is Auto or Zero. */
+const getPercentBarPreviewScale = (pb) => {
+    const origin = pb.Origin ?? 'Auto';
+    if (origin === 'Zero' || origin === 'Auto') {
+        return { min: GradientStyleHelper_1.ZERO_CENTRED_PREVIEW_SCALE_MIN, max: GradientStyleHelper_1.ZERO_CENTRED_PREVIEW_SCALE_MAX };
+    }
+    return { min: 0, max: 100 };
+};
+exports.getPercentBarPreviewScale = getPercentBarPreviewScale;
+const getPercentBarPreviewSampleValues = (pb) => {
+    const { min, max } = (0, exports.getPercentBarPreviewScale)(pb);
+    return evenlySpacedValues(min, max, GradientStyleHelper_1.STYLED_COLUMN_PREVIEW_SAMPLE_COUNT);
+};
+exports.getPercentBarPreviewSampleValues = getPercentBarPreviewSampleValues;
+const getPercentBarPreviewGeometry = (numericValue, pb, min, max) => {
+    let percentageValue = 0;
+    let barLeftPercent = 0;
+    let barWidthPercent = 0;
+    if (pb.ColumnComparison) {
+        const absMax = Math.abs(max);
+        percentageValue = absMax === 0 ? 0 : (numericValue / absMax) * 100;
+        const magnitude = Math.min(100, Math.abs(percentageValue));
+        const origin = pb.Origin ?? 'Auto';
+        const isCentred = columnComparisonUsesCentredAxis(origin);
+        if (isCentred) {
+            const halfWidth = magnitude / 2;
+            if (percentageValue >= 0) {
+                barLeftPercent = 50;
+                barWidthPercent = halfWidth;
+            }
+            else {
+                barLeftPercent = 50 - halfWidth;
+                barWidthPercent = halfWidth;
+            }
+        }
+        else {
+            barLeftPercent = 0;
+            barWidthPercent = magnitude;
+        }
+    }
+    else if (max === min) {
+        percentageValue = 0;
+        barLeftPercent = 0;
+        barWidthPercent = 0;
+    }
+    else {
+        percentageValue = (((0, NumberExtensions_1.clamp)(numericValue, min, max) - min) / (max - min)) * 100;
+        const origin = resolveOrigin(pb, numericValue, min, max);
+        const valueFrac = toFraction(numericValue, min, max);
+        const originFrac = toFraction(origin, min, max);
+        const start = Math.min(valueFrac, originFrac);
+        const end = Math.max(valueFrac, originFrac);
+        barLeftPercent = start * 100;
+        barWidthPercent = (end - start) * 100;
+    }
+    return {
+        barLeftPercent,
+        barWidthPercent,
+        percentageValue,
+        barColor: getPreviewBarColor(numericValue, pb, min, max),
+    };
+};
+exports.getPercentBarPreviewGeometry = getPercentBarPreviewGeometry;
+const formatPercentBarPreviewCellText = (numericValue, percentageValue, pb) => {
+    const labels = (0, BarStylesHelper_1.buildBarStyleCellTextLabels)(pb.CellTextProperties, Number.isInteger(numericValue) ? String(numericValue) : numericValue.toFixed(1), `${percentageValue.toFixed(0)}%`);
+    return (0, BarStylesHelper_1.joinBarStyleCellTextLabels)(labels);
+};
+exports.formatPercentBarPreviewCellText = formatPercentBarPreviewCellText;
+const getPercentBarPreviewTrackColor = (pb) => {
+    if (pb.ColumnComparison) {
+        return pb.BackColor ?? undefined;
+    }
+    return pb.BackColor ?? undefined;
+};
+exports.getPercentBarPreviewTrackColor = getPercentBarPreviewTrackColor;
+const getPercentBarPreviewResolvedBarColor = (color) => (color ? (0, StyleHelper_1.getVariableColor)(color) : undefined);
+exports.getPercentBarPreviewResolvedBarColor = getPercentBarPreviewResolvedBarColor;
+const hasPercentBarStylePreview = (styledColumn) => (0, exports.hasPercentBarRangesConfigured)(styledColumn.PercentBarStyle);
+exports.hasPercentBarStylePreview = hasPercentBarStylePreview;

package/src/Utilities/Helpers/StyledColumns/SparklineStyleHelper.d.ts

@@ -0,0 +1,7 @@
+import type { AgSparklineOptions } from 'ag-charts-types';
+/**
+ * AG Charts sparklines do not resolve Adaptable `var(--ab-color-*)` tokens.
+ * Resolve palette / theme CSS variables to concrete colours at render time so
+ * wizard previews and grid cells match the chosen Fill / Stroke values.
+ */
+export declare function resolveSparklineOptionsForRender(options: AgSparklineOptions): AgSparklineOptions;

package/src/Utilities/Helpers/StyledColumns/SparklineStyleHelper.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSparklineOptionsForRender = resolveSparklineOptionsForRender;
+const StyleHelper_1 = require("../StyleHelper");
+const resolveCssColor = (color) => {
+    if (color == null || color === '') {
+        return color;
+    }
+    const resolved = (0, StyleHelper_1.getVariableColor)(color);
+    return resolved || color;
+};
+const resolveHighlightStyle = (style) => {
+    if (!style) {
+        return style;
+    }
+    const resolved = { ...style };
+    if (style.fill != null) {
+        resolved.fill = resolveCssColor(style.fill);
+    }
+    if (style.stroke != null) {
+        resolved.stroke = resolveCssColor(style.stroke);
+    }
+    return resolved;
+};
+/**
+ * AG Charts sparklines do not resolve Adaptable `var(--ab-color-*)` tokens.
+ * Resolve palette / theme CSS variables to concrete colours at render time so
+ * wizard previews and grid cells match the chosen Fill / Stroke values.
+ */
+function resolveSparklineOptionsForRender(options) {
+    const resolved = { ...options };
+    if ('fill' in options && options.fill != null) {
+        resolved.fill = resolveCssColor(options.fill);
+    }
+    if (options.stroke != null) {
+        resolved.stroke = resolveCssColor(options.stroke);
+    }
+    if (options.background?.fill != null) {
+        resolved.background = {
+            ...options.background,
+            fill: resolveCssColor(options.background.fill),
+        };
+    }
+    if ('marker' in options && options.marker) {
+        const marker = { ...options.marker };
+        if (marker.fill != null) {
+            marker.fill = resolveCssColor(marker.fill);
+        }
+        if (marker.stroke != null) {
+            marker.stroke = resolveCssColor(marker.stroke);
+        }
+        resolved.marker = marker;
+    }
+    if (options.highlight) {
+        resolved.highlight = {
+            ...options.highlight,
+            highlightedItem: resolveHighlightStyle(options.highlight.highlightedItem),
+            highlightedSeries: resolveHighlightStyle(options.highlight.highlightedSeries),
+        };
+    }
+    if (options.axis && typeof options.axis === 'object' && options.axis.stroke != null) {
+        resolved.axis = {
+            ...options.axis,
+            stroke: resolveCssColor(options.axis.stroke),
+        };
+    }
+    return resolved;
+}

package/src/Utilities/Helpers/StyledColumns/StyledColumnHelper.d.ts

@@ -0,0 +1,52 @@
+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;
+/**
+ * Returns `true` when the Styled Column should render on the given row.
+ *
+ * Single source of truth consulted by every styled-column cell renderer
+ * (Badge / Icon / Rating / Percent Bar / Bullet Chart / Range Bar) and
+ * by `getStyledColumnStyle` (Gradient / Percent Bar cellStyle).
+ *
+ * Semantics:
+ *  - **Type capabilities** first: some types never target certain row kinds
+ *    (see {@link isStyledColumnRowKindSupported}). Unsupported kinds always
+ *    return `false` regardless of `RowScope`.
+ *  - When `StyledColumn.RowScope` is **set**, the explicit `Exclude*`
+ *    flags win. Unset flags default to "include" — i.e. `RowScope: {}`
+ *    means "render on every *supported* row kind".
+ *  - When `StyledColumn.RowScope` is **unset**, the historical per-type
+ *    default applies:
+ *      - Badge: render on every row kind (that the type supports).
+ *      - All other types: render on every row kind *except* group rows
+ *        (matches the hardcoded "isGroupRowNode → plain text" check that
+ *        every other styled-column renderer used to carry), again
+ *        intersected with type capabilities (e.g. Sparkline → data only).
+ *
+ * The per-type default lets us promote `RowScope` cleanly without
+ * altering existing user-visible behaviour: state that doesn't mention
+ * `RowScope` keeps rendering exactly as before.
+ */
+export declare const shouldRenderStyledColumnOnRow: (styledColumn: StyledColumn, node: IRowNode, api: AdaptableApi) => boolean;

package/src/Utilities/Helpers/StyledColumns/StyledColumnHelper.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldRenderStyledColumnOnRow = exports.sanitizeStyledColumnRowScope = exports.getStyledColumnRowKindForNode = exports.getStyledColumnRowKindDisabledReason = exports.isStyledColumnRowKindSupported = exports.STYLED_COLUMN_ROW_KIND_EXCLUDE_KEY = exports.STYLED_COLUMN_ROW_KINDS = void 0;
+exports.STYLED_COLUMN_ROW_KINDS = ['Data', 'Group', 'Summary', 'Total'];
+exports.STYLED_COLUMN_ROW_KIND_EXCLUDE_KEY = {
+    Data: 'ExcludeDataRows',
+    Group: 'ExcludeGroupRows',
+    Summary: 'ExcludeSummaryRows',
+    Total: 'ExcludeTotalRows',
+};
+const isStyledColumnRowKindSupported = (styledColumn, kind) => {
+    if (styledColumn.SparklineStyle) {
+        return kind === 'Data';
+    }
+    return true;
+};
+exports.isStyledColumnRowKindSupported = isStyledColumnRowKindSupported;
+const getStyledColumnRowKindDisabledReason = (styledColumn, kind) => {
+    if ((0, exports.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;
+};
+exports.getStyledColumnRowKindDisabledReason = getStyledColumnRowKindDisabledReason;
+/**
+ * Classifies the AG Grid row node into a single {@link StyledColumnRowKind}.
+ * Order matches {@link shouldRenderStyledColumnOnRow}: total before summary,
+ * summary before group.
+ */
+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';
+};
+exports.getStyledColumnRowKindForNode = getStyledColumnRowKindForNode;
+/**
+ * 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.
+ */
+const sanitizeStyledColumnRowScope = (styledColumn) => {
+    const scope = styledColumn.RowScope;
+    if (!scope) {
+        return undefined;
+    }
+    let next = { ...scope };
+    let changed = false;
+    for (const kind of exports.STYLED_COLUMN_ROW_KINDS) {
+        if ((0, exports.isStyledColumnRowKindSupported)(styledColumn, kind)) {
+            continue;
+        }
+        const key = exports.STYLED_COLUMN_ROW_KIND_EXCLUDE_KEY[kind];
+        if (next[key] !== true) {
+            next = { ...next, [key]: true };
+            changed = true;
+        }
+    }
+    return changed ? next : undefined;
+};
+exports.sanitizeStyledColumnRowScope = sanitizeStyledColumnRowScope;
+/**
+ * Returns `true` when the Styled Column should render on the given row.
+ *
+ * Single source of truth consulted by every styled-column cell renderer
+ * (Badge / Icon / Rating / Percent Bar / Bullet Chart / Range Bar) and
+ * by `getStyledColumnStyle` (Gradient / Percent Bar cellStyle).
+ *
+ * Semantics:
+ *  - **Type capabilities** first: some types never target certain row kinds
+ *    (see {@link isStyledColumnRowKindSupported}). Unsupported kinds always
+ *    return `false` regardless of `RowScope`.
+ *  - When `StyledColumn.RowScope` is **set**, the explicit `Exclude*`
+ *    flags win. Unset flags default to "include" — i.e. `RowScope: {}`
+ *    means "render on every *supported* row kind".
+ *  - When `StyledColumn.RowScope` is **unset**, the historical per-type
+ *    default applies:
+ *      - Badge: render on every row kind (that the type supports).
+ *      - All other types: render on every row kind *except* group rows
+ *        (matches the hardcoded "isGroupRowNode → plain text" check that
+ *        every other styled-column renderer used to carry), again
+ *        intersected with type capabilities (e.g. Sparkline → data only).
+ *
+ * The per-type default lets us promote `RowScope` cleanly without
+ * altering existing user-visible behaviour: state that doesn't mention
+ * `RowScope` keeps rendering exactly as before.
+ */
+const shouldRenderStyledColumnOnRow = (styledColumn, node, api) => {
+    const rowKind = (0, exports.getStyledColumnRowKindForNode)(node, api);
+    if (!(0, exports.isStyledColumnRowKindSupported)(styledColumn, rowKind)) {
+        return false;
+    }
+    const isGroup = api.gridApi.isGroupRowNode(node);
+    const isTotal = api.gridApi.isGrandTotalRowNode(node);
+    const isSummary = !isTotal && api.gridApi.isSummaryNode(node);
+    const isLeaf = !isGroup && !isSummary && !isTotal;
+    const scope = styledColumn.RowScope;
+    if (scope) {
+        if (isLeaf && scope.ExcludeDataRows)
+            return false;
+        if (isGroup && scope.ExcludeGroupRows)
+            return false;
+        if (isSummary && scope.ExcludeSummaryRows)
+            return false;
+        if (isTotal && scope.ExcludeTotalRows)
+            return false;
+        return true;
+    }
+    // No explicit RowScope → fall back to historical per-type behaviour.
+    if (styledColumn.BadgeStyle) {
+        return true;
+    }
+    return !isGroup;
+};
+exports.shouldRenderStyledColumnOnRow = shouldRenderStyledColumnOnRow;

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

@@ -0,0 +1,5 @@
+import { AdaptableTheme, SystemThemeEntry } from '../../AdaptableState/ThemeState';
+import { AdaptableLogger } from '../../agGrid/AdaptableLogger';
+export declare function isLegacySystemThemeObject(theme: SystemThemeEntry | AdaptableTheme): theme is AdaptableTheme;
+export declare function resolveSystemThemeDescription(name: string): string;
+export declare function systemThemeEntryToAdaptableTheme(theme: SystemThemeEntry | AdaptableTheme, logger?: AdaptableLogger): AdaptableTheme;

package/src/Utilities/Helpers/ThemeHelper.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLegacySystemThemeObject = isLegacySystemThemeObject;
+exports.resolveSystemThemeDescription = resolveSystemThemeDescription;
+exports.systemThemeEntryToAdaptableTheme = systemThemeEntryToAdaptableTheme;
+const themes_1 = require("../../themes");
+const logDeprecation_1 = require("../logDeprecation");
+const LEGACY_SYSTEM_THEME_PROPS = ['Description', 'CSSVariables', 'Variant'];
+function isLegacySystemThemeObject(theme) {
+    if (typeof theme === 'string') {
+        return false;
+    }
+    return LEGACY_SYSTEM_THEME_PROPS.some((prop) => prop in theme && theme[prop] !== undefined);
+}
+function resolveSystemThemeDescription(name) {
+    return themes_1.StaticThemes.find((staticTheme) => staticTheme.Name === name)?.Description ?? name;
+}
+function systemThemeEntryToAdaptableTheme(theme, logger) {
+    if (typeof theme === 'string') {
+        return {
+            Name: theme,
+            Description: resolveSystemThemeDescription(theme),
+        };
+    }
+    if (isLegacySystemThemeObject(theme)) {
+        if (logger) {
+            (0, logDeprecation_1.logDeprecation)(logger, 'ThemeState', 'SystemThemes', undefined, 'Passing a full AdaptableTheme object in SystemThemes is deprecated. Use a theme name string or SystemThemeOptions (Name with AgThemeMode / AgGridClassName only).');
+        }
+        return {
+            Name: theme.Name,
+            Description: theme.Description ?? resolveSystemThemeDescription(theme.Name),
+            AgThemeMode: theme.AgThemeMode,
+            AgGridClassName: theme.AgGridClassName,
+        };
+    }
+    const options = theme;
+    return {
+        Name: options.Name,
+        Description: resolveSystemThemeDescription(options.Name),
+        AgThemeMode: options.AgThemeMode,
+        AgGridClassName: options.AgGridClassName,
+    };
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Timing helpers for delaying / rate-limiting function calls.
+ *
+ * `debounce` and `throttle` are drop-in replacements for the equivalent
+ * lodash exports (`debounce` supports `{ leading, trailing, maxWait }`,
+ * `throttle` supports `{ leading, trailing }`).
+ *
+ * Both return an instance of `DebouncedFunction<T>` which exposes
+ * `cancel()` and `flush()` for managing pending invocations.
+ */
+export interface DebounceOptions {
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+}
+export interface DebouncedFunction<T extends (...args: any[]) => any> {
+    (...args: Parameters<T>): ReturnType<T> | undefined;
+    cancel(): void;
+    flush(): ReturnType<T> | undefined;
+}
+export declare function debounce<T extends (...args: any[]) => any>(func: T, wait?: number, options?: DebounceOptions): DebouncedFunction<T>;
+export interface ThrottleOptions {
+    leading?: boolean;
+    trailing?: boolean;
+}
+/**
+ * Implemented in terms of `debounce` with `maxWait` (same approach as lodash).
+ */
+export declare function throttle<T extends (...args: any[]) => any>(func: T, wait?: number, options?: ThrottleOptions): DebouncedFunction<T>;
+export declare const TimingHelper: {
+    debounce: typeof debounce;
+    throttle: typeof throttle;
+};
+export default TimingHelper;

package/src/Utilities/{utils/debounce.js → Helpers/TimingHelper.js}

@@ -1,15 +1,18 @@
 "use strict";
 /**
- * Creates a debounced function that delays invoking func until after wait
- * milliseconds have elapsed since the last time the debounced function was
- * invoked. The debounced function comes with a cancel method to cancel
- * delayed func invocations and a flush method to immediately invoke them.
+ * Timing helpers for delaying / rate-limiting function calls.
  *
- * Supports options: { leading, trailing, maxWait }
- * Drop-in replacement for lodash/debounce.
+ * `debounce` and `throttle` are drop-in replacements for the equivalent
+ * lodash exports (`debounce` supports `{ leading, trailing, maxWait }`,
+ * `throttle` supports `{ leading, trailing }`).
+ *
+ * Both return an instance of `DebouncedFunction<T>` which exposes
+ * `cancel()` and `flush()` for managing pending invocations.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = debounce;
+exports.TimingHelper = void 0;
+exports.debounce = debounce;
+exports.throttle = throttle;
 function debounce(func, wait = 0, options) {
     let lastArgs;
     let lastThis;
@@ -62,7 +65,6 @@ function debounce(func, wait = 0, options) {
             trailingEdge(time);
             return;
         }
-        // Restart the timer
         startTimer(timerExpired, remainingWait(time));
     }
     function trailingEdge(time) {
@@ -94,7 +96,6 @@ function debounce(func, wait = 0, options) {
                 return result;
             }
             if (maxing) {
-                // Handle invocations in a tight loop with maxWait
                 cancelTimer();
                 startTimer(timerExpired, wait);
                 invokeFunc(time);
@@ -122,3 +123,18 @@ function debounce(func, wait = 0, options) {
     };
     return debounced;
 }
+/**
+ * Implemented in terms of `debounce` with `maxWait` (same approach as lodash).
+ */
+function throttle(func, wait = 0, options) {
+    return debounce(func, wait, {
+        leading: options?.leading ?? true,
+        trailing: options?.trailing ?? true,
+        maxWait: wait,
+    });
+}
+exports.TimingHelper = {
+    debounce,
+    throttle,
+};
+exports.default = exports.TimingHelper;

package/src/Utilities/ObjectFactory.d.ts

@@ -16,7 +16,7 @@ import { PlusMinusNudge } from '../AdaptableState/PlusMinusState';
 import { Shortcut } from '../AdaptableState/ShortcutState';
 import { NotificationsOptions } from '../AdaptableOptions/NotificationsOptions';
 import { CellSummmaryInfo } from '../AdaptableState/Common/CellSummary';
-import { AdaptableTheme, ChartDefinition, ColumnFilter, CommentThread, CustomDisplayFormatterContext, FlashingCellDefinition, RowDataChangedInfo, SpecialColumnSettings, SystemFilterPredicateId } from '../types';
+import { ChartDefinition, ColumnFilter, CommentThread, CustomDisplayFormatterContext, FlashingCellDefinition, RowDataChangedInfo, SpecialColumnSettings, SystemFilterPredicateId } from '../types';
 import { IRowNode } from 'ag-grid-enterprise';
 import { AdaptableApi, AdaptableComment, BadgeStyleDefinition, CellAddress, NamedQuery, PivotLayout, TableLayout } from '../../types';
 import { ToastOptions } from '../components/Toastify';
@@ -54,7 +54,6 @@ export declare function CreateEmptyStyledColumn(): StyledColumn;
 export declare function CreateDefaultStyledColumnBadge(): BadgeStyleDefinition;
 export declare function CreateEmptyChartDefinition(chartDefinition?: ChartDefinition): ChartDefinition;
 export declare function CreateCustomDisplayFormatterContext(value: any, node: IRowNode, abColumn: AdaptableColumn, api: AdaptableApi): CustomDisplayFormatterContext;
-export declare function CreateEmptyTheme(name?: string): AdaptableTheme;
 export declare function CreateEmptyCommentThread(cellAddress: CellAddress): CommentThread;
 export declare function CreateToastOptions(notificationsOptions: NotificationsOptions, { onClose, containerId }: {
     onClose?: VoidFunction;
@@ -91,7 +90,6 @@ export declare const ObjectFactory: {
     CreateEmptyStyledColumn: typeof CreateEmptyStyledColumn;
     CreateDefaultStyledColumnBadge: typeof CreateDefaultStyledColumnBadge;
     CreateEmptyChartDefinition: typeof CreateEmptyChartDefinition;
-    CreateEmptyTheme: typeof CreateEmptyTheme;
     CreateEmptyCommentThread: typeof CreateEmptyCommentThread;
     CreateAdaptableComment: typeof CreateAdaptableComment;
     CreateDefaultSchedule: typeof CreateDefaultSchedule;

package/src/Utilities/ObjectFactory.js

@@ -28,13 +28,12 @@ exports.CreateEmptyStyledColumn = CreateEmptyStyledColumn;
 exports.CreateDefaultStyledColumnBadge = CreateDefaultStyledColumnBadge;
 exports.CreateEmptyChartDefinition = CreateEmptyChartDefinition;
 exports.CreateCustomDisplayFormatterContext = CreateCustomDisplayFormatterContext;
-exports.CreateEmptyTheme = CreateEmptyTheme;
 exports.CreateEmptyCommentThread = CreateEmptyCommentThread;
 exports.CreateToastOptions = CreateToastOptions;
 exports.CreateDefaultSchedule = CreateDefaultSchedule;
 const Enums_1 = require("../AdaptableState/Common/Enums");
 const Uuid_1 = require("../AdaptableState/Uuid");
-const ScheduleHelper_1 = require("./Helpers/ScheduleHelper");
+const ScheduleHelper_1 = require("./Helpers/Scheduling/ScheduleHelper");
 const GeneralConstants_1 = require("./Constants/GeneralConstants");
 const ObjectDefaultConstants_1 = require("./Constants/ObjectDefaultConstants");
 const Toastify_1 = require("../components/Toastify");
@@ -322,13 +321,6 @@ function CreateCustomDisplayFormatterContext(value, node, abColumn, api) {
         ...api.internalApi.buildBaseContext(),
     };
 }
-function CreateEmptyTheme(name) {
-    return {
-        Uuid: (0, Uuid_1.createUuid)(),
-        Name: name || 'Custom Theme',
-        Description: name || 'Custom Theme',
-    };
-}
 function CreateEmptyCommentThread(cellAddress) {
     return {
         ...cellAddress,
@@ -423,7 +415,6 @@ exports.ObjectFactory = {
     CreateEmptyStyledColumn,
     CreateDefaultStyledColumnBadge,
     CreateEmptyChartDefinition,
-    CreateEmptyTheme,
     CreateEmptyCommentThread,
     CreateAdaptableComment,
     CreateDefaultSchedule,

package/src/Utilities/Services/CalculatedColumnExpressionService.d.ts

@@ -8,6 +8,7 @@ export declare class CalculatedColumnExpressionService implements ICalculatedCol
     private adaptableApi;
     private aggregatedScalarLiveValuesMap;
     constructor(adaptableApi: AdaptableApi);
+    buildSyntheticCellDataChangedInfosForCalcColumns(cellDataChangedInfo: CellDataChangedInfo): CellDataChangedInfo[];
     listentoCellDataChange(cellDataChangedInfo: CellDataChangedInfo): void;
     listentoRowDataChange(rowDataChangedInfo: RowDataChangedInfo): void;
     destroy(): void;
@@ -17,3 +18,5 @@ export declare class CalculatedColumnExpressionService implements ICalculatedCol
     createAggregatedScalarLiveValue(calculatedColumn: CalculatedColumn): void;
     destroyAggregatedScalarLiveValue(calculatedColumn: CalculatedColumn): void;
 }
+export declare function buildSyntheticCellDataChangedInfosForCalcColumns(adaptableApi: AdaptableApi, info: CellDataChangedInfo): CellDataChangedInfo[];
+export declare function expandCellDataChangedInfosWithCalculatedColumns(adaptableApi: AdaptableApi, cellDataChangedInfos: CellDataChangedInfo[]): CellDataChangedInfo[];