@adaptabletools/adaptable 23.0.3 → 23.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaptabletools/adaptable",
-  "version": "23.0.3",
+  "version": "23.0.4",
   "description": "Powerful AG Grid extension which provides advanced, cutting-edge functionality to meet all DataGrid requirements",
   "keywords": [
     "web-components",
@@ -48,7 +48,6 @@
     "@tanstack/react-virtual": "^3.13.22",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
-    "cron-parser": "^4.9.0",
     "date-fns": "^4.1.0",
     "lucide-react": "^0.563.0",
     "normalize.css": "^8.0.1",

package/src/Api/GridApi.d.ts

@@ -38,6 +38,24 @@ export interface GridApi {
      * Retrieves visible data from the grid (filtered and sorted)
      */
     getVisibleData(): any[];
+    /**
+     * Retrieves all the values for a single Column.
+     *
+     * @param columnId the Column to read the values from
+     */
+    getColumnData(columnId: string): any[];
+    /**
+     * Retrieves the filtered values for a single Column.
+     *
+     * @param columnId the Column to read the values from
+     */
+    getFilteredColumnData(columnId: string): any[];
+    /**
+     * Retrieves the visible (filtered and sorted) values for a single Column.
+     *
+     * @param columnId the Column to read the values from
+     */
+    getVisibleColumnData(columnId: string): any[];
     /**
      * Loads data into grid and fire a `RowChanged.trigger='Load'` event
      * @param data data to load

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

@@ -27,6 +27,9 @@ export declare class GridApiImpl extends ApiBase implements GridApi {
     getGridData(): any[];
     getFilteredData(): any[];
     getVisibleData(): any[];
+    getColumnData(columnId: string): any[];
+    getFilteredColumnData(columnId: string): any[];
+    getVisibleColumnData(columnId: string): any[];
     updateGridData(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<IRowNode[]>;
     addOrUpdateGridData(dataRows: any[], dataUpdateConfig?: DataUpdateConfig): Promise<{
         addedRows: IRowNode[];

package/src/Api/Implementation/GridApiImpl.js

@@ -47,6 +47,33 @@ export class GridApiImpl extends ApiBase {
         });
         return data;
     }
+    getColumnData(columnId) {
+        const data = [];
+        this._adaptable.forAllRowNodesDo((rowNode) => {
+            if (!this.isGroupRowNode(rowNode)) {
+                data.push(this.getRawValueFromRowNode(rowNode, columnId));
+            }
+        });
+        return data;
+    }
+    getFilteredColumnData(columnId) {
+        const data = [];
+        this.getAgGridApi().forEachNodeAfterFilter((rowNode) => {
+            if (!this.isGroupRowNode(rowNode)) {
+                data.push(this.getRawValueFromRowNode(rowNode, columnId));
+            }
+        });
+        return data;
+    }
+    getVisibleColumnData(columnId) {
+        const data = [];
+        this.getAdaptableInternalApi().forAllVisibleRowNodesDo((rowNode) => {
+            if (!this.isGroupRowNode(rowNode)) {
+                data.push(this.getRawValueFromRowNode(rowNode, columnId));
+            }
+        });
+        return data;
+    }
     async updateGridData(dataRows, dataUpdateConfig) {
         const rowNodes = await this._adaptable.updateRows(dataRows, dataUpdateConfig);
         const rowDataChangedInfo = this.getAdaptableInternalApi().buildRowDataChangedInfo(dataRows, rowNodes, 'Update');

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

@@ -1,3 +1,4 @@
+import type { AgChartInstance, AgSparklineOptions } from 'ag-charts-types';
 import { ApiBase } from './ApiBase';
 import { StyledColumnApi } from '../StyledColumnApi';
 import { StyledColumn, StyledColumnState } from '../../AdaptableState/StyledColumnState';
@@ -25,6 +26,7 @@ export declare class StyledColumnApiImpl extends ApiBase implements StyledColumn
     hasBulletChartStyle(columnId: string): boolean;
     hasRatingStyle(columnId: string): boolean;
     canDisplaySparklines(): boolean;
+    renderSparkline(options: AgSparklineOptions): AgChartInstance<AgSparklineOptions> | null;
     suspendStyledColumn(styledColumn: StyledColumn): void;
     unSuspendStyledColumn(styledColumn: StyledColumn): void;
     suspendAllStyledColumn(): void;

package/src/Api/Implementation/StyledColumnApiImpl.js

@@ -79,6 +79,9 @@ export class StyledColumnApiImpl extends ApiBase {
     canDisplaySparklines() {
         return this._adaptable.canDisplaySparklines();
     }
+    renderSparkline(options) {
+        return this.internalApi.createSparkline(options);
+    }
     suspendStyledColumn(styledColumn) {
         this.dispatchAction(StyledColumnRedux.StyledColumnSuspend(styledColumn));
     }

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

@@ -4,8 +4,18 @@ import { StyledColumn } from '../../AdaptableState/StyledColumnState';
 import { CellColorRange, ColumnComparison, NumericStyledColumn } from '../../AdaptableState/StyledColumns/Common/NumericStyledColumn';
 import { BadgeStyle, BadgeStyleDefinition } from '../../AdaptableState/StyledColumns/BadgeStyle';
 import { IRowNode } from 'ag-grid-enterprise';
+import type { AgChartInstance, AgSparklineOptions } from 'ag-charts-types';
 import { PredicateDefHandlerContext } from '../../types';
 export declare class StyledColumnInternalApi extends ApiBase {
+    /**
+     * Creates a sparkline described by `options` in its target container and
+     * returns the chart instance (used to update / destroy it).
+     *
+     * Centralises sparkline creation so view components don't import
+     * `ag-charts-enterprise` directly: the `createSparkline` factory is sourced
+     * from the AG Grid Sparklines module via the grid's registry bean.
+     */
+    createSparkline(options: AgSparklineOptions): AgChartInstance<AgSparklineOptions> | null;
     getMinValueForNumericColumn(column: AdaptableColumn | undefined): number | undefined;
     getMaxValueForNumericColumn(column: AdaptableColumn | undefined): number | undefined;
     getAvgValueForNumericColumn(column: AdaptableColumn | undefined): number | undefined;

package/src/Api/Internal/StyledColumnInternalApi.js

@@ -10,6 +10,26 @@ const DYNAMIC_RANGE_ENDPOINTS = [
 const isDynamicRangeEndpoint = (value) => typeof value === 'string' &&
     DYNAMIC_RANGE_ENDPOINTS.includes(value);
 export class StyledColumnInternalApi extends ApiBase {
+    /**
+     * Creates a sparkline described by `options` in its target container and
+     * returns the chart instance (used to update / destroy it).
+     *
+     * Centralises sparkline creation so view components don't import
+     * `ag-charts-enterprise` directly: the `createSparkline` factory is sourced
+     * from the AG Grid Sparklines module via the grid's registry bean.
+     */
+    createSparkline(options) {
+        if (!this.getStyledColumnApi().canDisplaySparklines()) {
+            this.logWarn('Cannot render Sparkline: AG Grid Sparklines are not enabled. Register the AG Grid Sparklines module (e.g. `AllEnterpriseModule.with(AgChartsEnterpriseModule)`) to use Sparklines.');
+            return null;
+        }
+        const createSparklineFactory = this._adaptable.agGridAdapter.DANGER_getCreateSparkline();
+        if (!createSparklineFactory) {
+            this.logWarn('Cannot render Sparkline: unable to obtain the AG Grid Sparkline rendering factory.');
+            return null;
+        }
+        return createSparklineFactory(options);
+    }
     getMinValueForNumericColumn(column) {
         if (!column || column.dataType !== 'number') {
             return undefined;

package/src/Api/StyledColumnApi.d.ts

@@ -1,3 +1,4 @@
+import type { AgChartInstance, AgSparklineOptions } from 'ag-charts-types';
 import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
 import { StyledColumn, StyledColumnState } from '../AdaptableState/StyledColumnState';
 import { LayoutExtendedConfig } from '../types';
@@ -117,4 +118,17 @@ export interface StyledColumnApi {
      * Can this AdapTable instance display Sparklines (e.g. is AG Grid SparklinesModule installed)
      */
     canDisplaySparklines(): boolean;
+    /**
+     * Renders a standalone [Sparkline](https://www.ag-grid.com/javascript-data-grid/sparklines-overview/)
+     * into a DOM element you provide, using the same AG Charts engine as Sparkline Styled Columns.
+     *
+     * Provide at least `container` (where to render) and `data` (what to plot) on `options`; see
+     * [AgSparklineOptions](https://www.ag-grid.com/javascript-data-grid/sparklines-overview/) for the
+     * full set (`type`, `width`/`height`, `min`/`max`, etc.).
+     *
+     * The caller owns the returned instance and is responsible for its lifecycle: call `update()` to
+     * re-render it when the data or options change, and `destroy()` to dispose of it (e.g. when the
+     * `container` is removed) to avoid memory leaks. AdapTable does not track or clean it up for you.
+     */
+    renderSparkline(options: AgSparklineOptions): AgChartInstance<AgSparklineOptions> | null;
 }

package/src/Utilities/Helpers/Scheduling/CronExpression.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Lightweight, dependency-free parser for standard 5-field cron expressions:
+ *
+ *   minute  hour  day-of-month  month  day-of-week
+ *
+ * Each field supports:
+ *   - `*` — every value in the field range
+ *   - A single integer (e.g. `9`)
+ *   - A comma-separated list (e.g. `1,3,5`)
+ *   - A range (e.g. `1-5`)
+ *   - A step (e.g. `* /15`, `0-30/5`)
+ *
+ * For day-of-week, both `0` and `7` represent Sunday.
+ *
+ * This module exists to keep AdapTable free of the `cron-parser` package (which
+ * transitively pulls in `luxon`). AdapTable only uses cron expressions in the
+ * Scheduling system, and only ever needs to:
+ *   1. validate a user-entered cron string, and
+ *   2. compute the next fire time from "now".
+ */
+interface ParsedCron {
+    minute: Set<number>;
+    hour: Set<number>;
+    dayOfMonth: Set<number>;
+    month: Set<number>;
+    dayOfWeek: Set<number>;
+    /** True when the day-of-month field is `*` (i.e. unrestricted). */
+    dayOfMonthIsStar: boolean;
+    /** True when the day-of-week field is `*` (i.e. unrestricted). */
+    dayOfWeekIsStar: boolean;
+}
+/**
+ * Parses a 5-field cron expression. Throws when the expression is invalid.
+ */
+export declare function parseCronExpression(expression: string): ParsedCron;
+/**
+ * Returns true if the given expression is a valid 5-field cron expression.
+ */
+export declare function isCronExpressionValid(expression: string): boolean;
+/**
+ * Returns the next time the cron expression fires after `fromDate` (exclusive).
+ * Returns null if no match is found within a 4-year horizon.
+ */
+export declare function getNextCronOccurrence(expression: string, fromDate?: Date): Date | null;
+export {};

package/src/Utilities/Helpers/Scheduling/CronExpression.js

@@ -0,0 +1,179 @@
+/**
+ * Lightweight, dependency-free parser for standard 5-field cron expressions:
+ *
+ *   minute  hour  day-of-month  month  day-of-week
+ *
+ * Each field supports:
+ *   - `*` — every value in the field range
+ *   - A single integer (e.g. `9`)
+ *   - A comma-separated list (e.g. `1,3,5`)
+ *   - A range (e.g. `1-5`)
+ *   - A step (e.g. `* /15`, `0-30/5`)
+ *
+ * For day-of-week, both `0` and `7` represent Sunday.
+ *
+ * This module exists to keep AdapTable free of the `cron-parser` package (which
+ * transitively pulls in `luxon`). AdapTable only uses cron expressions in the
+ * Scheduling system, and only ever needs to:
+ *   1. validate a user-entered cron string, and
+ *   2. compute the next fire time from "now".
+ */
+const MINUTE_RANGE = [0, 59];
+const HOUR_RANGE = [0, 23];
+const DAY_OF_MONTH_RANGE = [1, 31];
+const MONTH_RANGE = [1, 12];
+const FIELD_LABELS = ['minute', 'hour', 'day-of-month', 'month', 'day-of-week'];
+/**
+ * Parses a 5-field cron expression. Throws when the expression is invalid.
+ */
+export function parseCronExpression(expression) {
+    if (!expression || typeof expression !== 'string') {
+        throw new Error('Cron expression is empty');
+    }
+    const parts = expression.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Expected 5 cron fields (minute hour day-of-month month day-of-week) but got ${parts.length}`);
+    }
+    const minute = parseField(parts[0], MINUTE_RANGE, FIELD_LABELS[0]);
+    const hour = parseField(parts[1], HOUR_RANGE, FIELD_LABELS[1]);
+    const dayOfMonth = parseField(parts[2], DAY_OF_MONTH_RANGE, FIELD_LABELS[2]);
+    const month = parseField(parts[3], MONTH_RANGE, FIELD_LABELS[3]);
+    const dayOfWeek = parseDayOfWeekField(parts[4]);
+    return {
+        minute,
+        hour,
+        dayOfMonth,
+        month,
+        dayOfWeek,
+        dayOfMonthIsStar: parts[2] === '*',
+        dayOfWeekIsStar: parts[4] === '*',
+    };
+}
+/**
+ * Returns true if the given expression is a valid 5-field cron expression.
+ */
+export function isCronExpressionValid(expression) {
+    try {
+        parseCronExpression(expression);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Returns the next time the cron expression fires after `fromDate` (exclusive).
+ * Returns null if no match is found within a 4-year horizon.
+ */
+export function getNextCronOccurrence(expression, fromDate = new Date()) {
+    const cron = parseCronExpression(expression);
+    // Bump to the start of the next minute - cron has minute granularity and
+    // we never want to return `fromDate` itself.
+    const next = new Date(fromDate.getTime());
+    next.setSeconds(0, 0);
+    next.setMinutes(next.getMinutes() + 1);
+    // Safety horizon — patterns like "0 0 31 2 *" (31 Feb) can never match.
+    const horizon = new Date(next.getTime());
+    horizon.setFullYear(horizon.getFullYear() + 4);
+    while (next < horizon) {
+        if (!cron.month.has(next.getMonth() + 1)) {
+            // Jump to the 1st of the next month.
+            next.setDate(1);
+            next.setHours(0, 0, 0, 0);
+            next.setMonth(next.getMonth() + 1);
+            continue;
+        }
+        if (!matchesDay(cron, next)) {
+            next.setHours(0, 0, 0, 0);
+            next.setDate(next.getDate() + 1);
+            continue;
+        }
+        if (!cron.hour.has(next.getHours())) {
+            next.setMinutes(0, 0, 0);
+            next.setHours(next.getHours() + 1);
+            continue;
+        }
+        if (!cron.minute.has(next.getMinutes())) {
+            next.setSeconds(0, 0);
+            next.setMinutes(next.getMinutes() + 1);
+            continue;
+        }
+        return next;
+    }
+    return null;
+}
+/**
+ * Standard cron day matching:
+ *   - if both day-of-month and day-of-week are `*`, the day always matches
+ *   - if only one is `*`, only the other is applied
+ *   - if neither is `*`, the day matches when **either** matches (OR semantics)
+ */
+function matchesDay(cron, date) {
+    const domMatches = cron.dayOfMonth.has(date.getDate());
+    const dowMatches = cron.dayOfWeek.has(date.getDay());
+    if (cron.dayOfMonthIsStar && cron.dayOfWeekIsStar) {
+        return true;
+    }
+    if (cron.dayOfMonthIsStar) {
+        return dowMatches;
+    }
+    if (cron.dayOfWeekIsStar) {
+        return domMatches;
+    }
+    return domMatches || dowMatches;
+}
+function parseField(field, range, label) {
+    const [min, max] = range;
+    const values = new Set();
+    const segments = field.split(',');
+    for (const raw of segments) {
+        const segment = raw.trim();
+        if (segment === '') {
+            throw new Error(`Invalid ${label} field "${field}"`);
+        }
+        const [rangePart, stepPart] = segment.split('/');
+        const step = stepPart === undefined ? 1 : Number(stepPart);
+        if (!Number.isInteger(step) || step <= 0) {
+            throw new Error(`Invalid step value in ${label} field "${segment}"`);
+        }
+        let from;
+        let to;
+        if (rangePart === '*') {
+            from = min;
+            to = max;
+        }
+        else if (rangePart.includes('-')) {
+            const [fromStr, toStr] = rangePart.split('-');
+            from = Number(fromStr);
+            to = Number(toStr);
+        }
+        else {
+            from = Number(rangePart);
+            to = from;
+        }
+        if (!Number.isInteger(from) || !Number.isInteger(to)) {
+            throw new Error(`Invalid ${label} field "${segment}"`);
+        }
+        if (from < min || to > max || from > to) {
+            throw new Error(`Out-of-range ${label} field "${segment}" (expected ${min}-${max})`);
+        }
+        for (let v = from; v <= to; v += step) {
+            values.add(v);
+        }
+    }
+    if (values.size === 0) {
+        throw new Error(`Empty ${label} field`);
+    }
+    return values;
+}
+function parseDayOfWeekField(field) {
+    // Cron allows 0 or 7 to represent Sunday — parse with an extended range
+    // [0,7] and then collapse 7 → 0 so callers can compare against
+    // `Date.getDay()` which returns 0-6.
+    const extended = parseField(field, [0, 7], 'day-of-week');
+    const normalised = new Set();
+    for (const value of extended) {
+        normalised.add(value === 7 ? 0 : value);
+    }
+    return normalised;
+}

package/src/Utilities/Helpers/Scheduling/ScheduleHelper.js

@@ -1,5 +1,5 @@
-import { parseExpression } from 'cron-parser';
 import StringExtensions from '../../Extensions/StringExtensions';
+import { getNextCronOccurrence, isCronExpressionValid as isCronExpressionValidInternal, } from './CronExpression';
 const WEEKDAY_TO_CRON = {
     Sunday: 0,
     Monday: 1,
@@ -123,11 +123,9 @@ export function getNextRunDateFromSchedule(schedule) {
         if (!schedule.CronExpression?.trim()) {
             return null;
         }
-        const interval = parseExpression(schedule.CronExpression.trim(), {
-            currentDate: new Date(),
-        });
-        const next = interval.next().toDate();
-        return next > new Date() ? next : null;
+        const now = new Date();
+        const next = getNextCronOccurrence(schedule.CronExpression.trim(), now);
+        return next && next > now ? next : null;
     }
     catch {
         return null;
@@ -154,13 +152,10 @@ export function isScheduleValid(schedule) {
     if (preset === 'selectedDays' && days.length === 0) {
         return 'Select at least one day';
     }
-    try {
-        parseExpression(schedule.CronExpression.trim());
-        return true;
-    }
-    catch {
+    if (!isCronExpressionValidInternal(schedule.CronExpression.trim())) {
         return 'Cron expression is not valid';
     }
+    return true;
 }
 export function getScheduleDescription(schedule) {
     if (!schedule) {
@@ -226,11 +221,5 @@ export function isValidCronExpression(expression) {
     if (StringExtensions.IsNullOrEmpty(expression)) {
         return false;
     }
-    try {
-        parseExpression(expression.trim());
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return isCronExpressionValidInternal(expression.trim());
 }

package/src/View/StyledColumn/Wizard/StyledColumnWizardStyleSection/Components/StyledColumnSparklinePreview.js

@@ -1,6 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import * as React from 'react';
-import { AgChartsEnterpriseModule } from 'ag-charts-enterprise';
 import { AdaptableHelper } from '../../../../../Utilities/Helpers/AdaptableHelper';
 import { resolveSparklineOptionsForRender } from '../../../../../Utilities/Helpers/StyledColumns/SparklineStyleHelper';
 import { convertAdaptableStyleToCSS, hasCellBoxStyle, } from '../../../../../Utilities/Helpers/StyleHelper';
@@ -53,23 +52,6 @@ const buildSparklinePreviewOptions = (sparklineStyle, container, data, width, he
     }
     return options;
 };
-/**
- * AG Grid registers chart modules via `AgChartsEnterpriseModule.setup()` when
- * sparklines are enabled. Standalone `AgCharts.createSparkline` needs the same
- * setup — otherwise the settings-panel preview throws "No modules registered".
- */
-let agChartsPreviewModulesReady = false;
-const ensureAgChartsEnterpriseModules = () => {
-    if (agChartsPreviewModulesReady) {
-        return;
-    }
-    AgChartsEnterpriseModule.setup();
-    agChartsPreviewModulesReady = true;
-};
-const createSparkline = (options) => {
-    ensureAgChartsEnterpriseModules();
-    return AgChartsEnterpriseModule.createSparkline(options);
-};
 const SparklinePreviewCanvas = ({ sparklineStyle, columnId }) => {
     const adaptable = useAdaptable();
     const containerRef = React.useRef(null);
@@ -93,7 +75,7 @@ const SparklinePreviewCanvas = ({ sparklineStyle, columnId }) => {
         const options = buildSparklinePreviewOptions(sparklineStyle, container, data, width, PREVIEW_HEIGHT);
         try {
             if (!instanceRef.current) {
-                instanceRef.current = createSparkline(options);
+                instanceRef.current = adaptable.api.styledColumnApi.internalApi.createSparkline(options);
             }
             else {
                 instanceRef.current.update(options);

package/src/agGrid/AgGridAdapter.d.ts

@@ -1,4 +1,5 @@
 import { ColDef, ColGroupDef, Column, GridApi, GridOptions, IRowNode, ManagedGridOptionKey, ManagedGridOptions, Module } from 'ag-grid-enterprise';
+import type { AgChartInstance, AgSparklineOptions } from 'ag-charts-types';
 import { AdaptableAgGrid } from './AdaptableAgGrid';
 import { AdaptableColumn, AdaptableColumnGroup } from '../AdaptableState/Common/AdaptableColumn';
 import { SelectedCellInfo } from '../AdaptableState/Selection/SelectedCellInfo';
@@ -31,6 +32,7 @@ export declare class AgGridAdapter {
     monkeyPatchingAggColumnFilters(): void;
     monkeyPatchingAggFuncLabels(): void;
     private DANGER_getPrivateAgGridBeans;
+    DANGER_getCreateSparkline(): ((options: AgSparklineOptions) => AgChartInstance<AgSparklineOptions>) | undefined;
     DANGER_getLiveGridOptions(): GridOptions<any>;
     getAgGridRootElement(): HTMLElement;
     /**

package/src/agGrid/AgGridAdapter.js

@@ -239,6 +239,16 @@ export class AgGridAdapter {
         }
         return beans;
     }
+    // #sparkline_factory
+    // The AG Grid Sparklines module stores the `createSparkline` factory (sourced from
+    // `AgChartsEnterpriseModule`) in the registered `agSparklineCellRenderer` default params.
+    // We read it straight from the registry bean so Adaptable can render standalone sparkline
+    // previews without taking a direct dependency on `ag-charts-enterprise`.
+    DANGER_getCreateSparkline() {
+        const registry = this.DANGER_getPrivateAgGridBeans()?.registry;
+        const sparklineComponent = registry?.getUserComponent('agSparklineCellRenderer', 'agSparklineCellRenderer');
+        return sparklineComponent?.params?.createSparkline;
+    }
     DANGER_getLiveGridOptions() {
         return this.DANGER_getPrivateAgGridBeans()?.gridOptions;
     }

package/src/env.js

@@ -1,5 +1,5 @@
 export default {
     NEXT_PUBLIC_INFINITE_TABLE_LICENSE_KEY: "StartDate=2021-06-29|EndDate=2030-01-01|Owner=Adaptable|Type=distribution|TS=1624971462479|C=137829811,1004007071,2756196225,1839832928,3994409405,636616862" || '',
-    PUBLISH_TIMESTAMP: 1782392443346 || Date.now(),
-    VERSION: "23.0.3" || '--current-version--',
+    PUBLISH_TIMESTAMP: 1782415229232 || Date.now(),
+    VERSION: "23.0.4" || '--current-version--',
 };