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

package/src/Aggregation/ParameterizedAggregationRegistry.d.ts

@@ -0,0 +1,35 @@
+import { IAggFuncParams } from 'ag-grid-enterprise';
+import { AdaptableApi } from '../Api/AdaptableApi';
+import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
+import { AggregationColumnValue, ParameterizedAggFunc } from '../AdaptableState/Common/AggregationColumns';
+import { ColumnAggregationModel } from '../layout-manager/src/LayoutManagerModel';
+export interface ParameterizedAggregationDefinition<T extends ParameterizedAggFunc = ParameterizedAggFunc> {
+    type: T['type'];
+    agGridAggFuncName: string;
+    label: string;
+    /** Label for the secondary column picker in the Layout wizard */
+    argColumnLabel?: string;
+    isComplete(def: T): boolean;
+    isAvailableForColumn(column: AdaptableColumn): boolean;
+    compute(params: IAggFuncParams, valueColumnId: string, def: T): unknown;
+    toColumnAggregationModel(def: T): ColumnAggregationModel;
+    fromColumnAggregationModel(model: ColumnAggregationModel): T | null;
+    createInitialDefinition(): T;
+    createDefinition?(argColumnId: string): T;
+    /**
+     * Value inside parentheses when agg is shown in header.
+     * For column-arg aggs, use "ValueColumn-ArgColumn" (e.g. Interest-Book).
+     */
+    getHeaderParenthesisValue?(api: AdaptableApi, valueColumnId: string, def: T): string;
+    /** Short label for wizard summaries, e.g. "weightedAvg(Interest-Book)" */
+    formatSummaryLabel?(api: AdaptableApi, valueColumnId: string, def: T): string;
+}
+export declare function getParameterizedAggregationDefinitions(): ParameterizedAggregationDefinition[];
+export declare function getParameterizedAggregationDefinition(type: string): ParameterizedAggregationDefinition | undefined;
+export declare function getParameterizedAggregationDefinitionByAgGridName(agGridAggFuncName: string): ParameterizedAggregationDefinition | undefined;
+export declare function isParameterizedAggFuncName(aggFunc: string): boolean;
+export declare function isParameterizedAggregation(aggFunc: AggregationColumnValue): aggFunc is ParameterizedAggFunc;
+export declare function getParameterizedAggFuncName(aggFunc: AggregationColumnValue): string | undefined;
+export declare function aggregationValueToColumnAggregationModel(aggFunc: AggregationColumnValue): ColumnAggregationModel;
+export declare function aggregationValueFromColumnAggregationModel(columnAggregationModel: ColumnAggregationModel): AggregationColumnValue | undefined;
+export declare function computeParameterizedAggregation(params: IAggFuncParams, valueColumnId: string, def: ParameterizedAggFunc): unknown;

package/src/Aggregation/ParameterizedAggregationRegistry.js

@@ -0,0 +1,63 @@
+import { weightedAverageAggregationDefinition } from './definitions/weightedAverageAggregationDefinition';
+const PARAMETERIZED_AGGREGATION_DEFINITIONS = [
+    weightedAverageAggregationDefinition,
+];
+const definitionsByType = new Map(PARAMETERIZED_AGGREGATION_DEFINITIONS.map((definition) => [definition.type, definition]));
+const definitionsByAgGridName = new Map(PARAMETERIZED_AGGREGATION_DEFINITIONS.map((definition) => [
+    definition.agGridAggFuncName,
+    definition,
+]));
+export function getParameterizedAggregationDefinitions() {
+    return PARAMETERIZED_AGGREGATION_DEFINITIONS;
+}
+export function getParameterizedAggregationDefinition(type) {
+    return definitionsByType.get(type);
+}
+export function getParameterizedAggregationDefinitionByAgGridName(agGridAggFuncName) {
+    return definitionsByAgGridName.get(agGridAggFuncName);
+}
+export function isParameterizedAggFuncName(aggFunc) {
+    return definitionsByAgGridName.has(aggFunc);
+}
+export function isParameterizedAggregation(aggFunc) {
+    return (typeof aggFunc === 'object' &&
+        aggFunc != null &&
+        'type' in aggFunc &&
+        definitionsByType.has(aggFunc.type));
+}
+export function getParameterizedAggFuncName(aggFunc) {
+    if (!isParameterizedAggregation(aggFunc)) {
+        return undefined;
+    }
+    return getParameterizedAggregationDefinition(aggFunc.type)?.agGridAggFuncName;
+}
+export function aggregationValueToColumnAggregationModel(aggFunc) {
+    if (isParameterizedAggregation(aggFunc)) {
+        const definition = getParameterizedAggregationDefinition(aggFunc.type);
+        if (definition) {
+            return definition.toColumnAggregationModel(aggFunc);
+        }
+    }
+    return { aggFunc: aggFunc };
+}
+export function aggregationValueFromColumnAggregationModel(columnAggregationModel) {
+    if (columnAggregationModel &&
+        typeof columnAggregationModel.aggFunc === 'string' &&
+        isParameterizedAggFuncName(columnAggregationModel.aggFunc)) {
+        const definition = getParameterizedAggregationDefinitionByAgGridName(columnAggregationModel.aggFunc);
+        if (definition) {
+            const parameterizedValue = definition.fromColumnAggregationModel(columnAggregationModel);
+            if (parameterizedValue) {
+                return parameterizedValue;
+            }
+        }
+    }
+    return undefined;
+}
+export function computeParameterizedAggregation(params, valueColumnId, def) {
+    const definition = getParameterizedAggregationDefinition(def.type);
+    if (!definition || !definition.isComplete(def)) {
+        return undefined;
+    }
+    return definition.compute(params, valueColumnId, def);
+}

package/src/Aggregation/definitions/weightedAverageAggregationDefinition.d.ts

@@ -0,0 +1,3 @@
+import { WeightedAverageAggregation } from '../../AdaptableState/Common/AggregationColumns';
+import { ParameterizedAggregationDefinition } from '../ParameterizedAggregationRegistry';
+export declare const weightedAverageAggregationDefinition: ParameterizedAggregationDefinition<WeightedAverageAggregation>;

package/src/Aggregation/definitions/weightedAverageAggregationDefinition.js

@@ -0,0 +1,55 @@
+import { WEIGHTED_AVERAGE_AGG_FN_NAME, } from '../../AdaptableState/Common/AggregationColumns';
+import { weightedAverage } from '../../Utilities/weightedAverage';
+function formatValueAndArgColumnHeaderLabel(api, valueColumnId, argColumnId) {
+    const valueName = api.columnApi.getFriendlyNameForColumnId(valueColumnId);
+    const argName = api.columnApi.getFriendlyNameForColumnId(argColumnId);
+    return `${valueName}-${argName}`;
+}
+export const weightedAverageAggregationDefinition = {
+    type: 'weightedAverage',
+    agGridAggFuncName: WEIGHTED_AVERAGE_AGG_FN_NAME,
+    label: 'Weighted Average',
+    argColumnLabel: 'Weight',
+    isComplete(def) {
+        return !!def.weightedColumnId;
+    },
+    isAvailableForColumn(column) {
+        return column.dataType === 'number' && column.aggregatable;
+    },
+    compute(params, valueColumnId, def) {
+        return weightedAverage(params, valueColumnId, def.weightedColumnId);
+    },
+    toColumnAggregationModel(def) {
+        return {
+            aggFunc: WEIGHTED_AVERAGE_AGG_FN_NAME,
+            weightedColumnId: def.weightedColumnId,
+        };
+    },
+    fromColumnAggregationModel(model) {
+        if (model.aggFunc !== WEIGHTED_AVERAGE_AGG_FN_NAME) {
+            return null;
+        }
+        return {
+            type: 'weightedAverage',
+            weightedColumnId: model.weightedColumnId,
+        };
+    },
+    createInitialDefinition() {
+        return {
+            type: 'weightedAverage',
+            weightedColumnId: null,
+        };
+    },
+    createDefinition(weightColumnId) {
+        return {
+            type: 'weightedAverage',
+            weightedColumnId: weightColumnId,
+        };
+    },
+    getHeaderParenthesisValue(api, valueColumnId, def) {
+        return formatValueAndArgColumnHeaderLabel(api, valueColumnId, def.weightedColumnId);
+    },
+    formatSummaryLabel(api, valueColumnId, def) {
+        return `${WEIGHTED_AVERAGE_AGG_FN_NAME}(${formatValueAndArgColumnHeaderLabel(api, valueColumnId, def.weightedColumnId)})`;
+    },
+};

package/src/Aggregation/parameterizedAggregationColumnMenu.d.ts

@@ -0,0 +1,8 @@
+import { DefaultMenuItem, MenuItemDef } from 'ag-grid-enterprise';
+import { AdaptableApi } from '../Api/AdaptableApi';
+import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
+import { ParameterizedAggFunc } from '../AdaptableState/Common/AggregationColumns';
+export declare function buildParameterizedAggregationMenuItems(api: AdaptableApi, column: AdaptableColumn, onSelect: (columnId: string, parameterizedAgg: ParameterizedAggFunc) => void): MenuItemDef[];
+export declare function buildConsolidatedAggregationColumnMenuItem(api: AdaptableApi, column: AdaptableColumn, onSelectParameterizedAgg: (columnId: string, parameterizedAgg: ParameterizedAggFunc) => void, onSelectStandardAgg: (columnId: string, aggFunc: string | null) => void): MenuItemDef | null;
+export declare function isValueAggregationMenuItem(item: DefaultMenuItem | MenuItemDef): boolean;
+export declare function findParameterizedAggMenuInsertIndex(menuItems: (DefaultMenuItem | MenuItemDef)[]): number;

package/src/Aggregation/parameterizedAggregationColumnMenu.js

@@ -0,0 +1,137 @@
+import { isPivotLayout } from '../Api/Implementation/LayoutHelpers';
+import { getAggregationValueForColumn, getNumericWeightColumnCandidates, isParameterizedAggFuncAllowedForColumn, isValueAggregationColumnMenuAvailable, } from './parameterizedAggregationHelpers';
+import { getParameterizedAggregationDefinitions, getParameterizedAggregationDefinition, isParameterizedAggregation, } from './ParameterizedAggregationRegistry';
+const DEFAULT_AGG_FUNC_LABELS = {
+    sum: 'Sum',
+    min: 'Min',
+    max: 'Max',
+    count: 'Count',
+    avg: 'Average',
+    first: 'First',
+    last: 'Last',
+    only: 'Only',
+};
+function getAggFuncLabel(aggFuncName) {
+    return DEFAULT_AGG_FUNC_LABELS[aggFuncName] ?? aggFuncName;
+}
+function isCurrentStandardAgg(layoutAgg, aggFuncName) {
+    return typeof layoutAgg === 'string' && layoutAgg === aggFuncName;
+}
+export function buildParameterizedAggregationMenuItems(api, column, onSelect) {
+    const layout = api.layoutApi.getCurrentLayout();
+    const features = api.layoutApi.internalApi.getLayoutSupportedFeatures();
+    const supportsAggregations = isPivotLayout(layout)
+        ? features.PivotAggregationColumns
+        : features.TableAggregationColumns;
+    if (!supportsAggregations) {
+        return [];
+    }
+    // Match AG Grid: "Value Aggregation" is only offered when the grid is grouped.
+    if (!isValueAggregationColumnMenuAvailable(api, layout)) {
+        return [];
+    }
+    const layoutAgg = getAggregationValueForColumn(column.columnId, layout);
+    const weightColumnCandidates = getNumericWeightColumnCandidates(api, column.columnId);
+    return getParameterizedAggregationDefinitions()
+        .filter((definition) => definition.isAvailableForColumn(column) &&
+        isParameterizedAggFuncAllowedForColumn(api, column, definition.agGridAggFuncName))
+        .map((definition) => {
+        const isCurrentType = isParameterizedAggregation(layoutAgg) &&
+            layoutAgg.type === definition.type &&
+            definition.isComplete(layoutAgg);
+        return {
+            name: definition.label,
+            subMenu: weightColumnCandidates.length === 0
+                ? [
+                    {
+                        name: 'No weight columns available',
+                        disabled: true,
+                    },
+                ]
+                : weightColumnCandidates.map((weightColumn) => {
+                    const isSelected = isCurrentType &&
+                        isParameterizedAggregation(layoutAgg) &&
+                        layoutAgg.weightedColumnId === weightColumn.columnId;
+                    return {
+                        name: weightColumn.friendlyName,
+                        checked: isSelected,
+                        action: () => {
+                            if (definition.createDefinition) {
+                                onSelect(column.columnId, definition.createDefinition(weightColumn.columnId));
+                            }
+                        },
+                    };
+                }),
+        };
+    });
+}
+export function buildConsolidatedAggregationColumnMenuItem(api, column, onSelectParameterizedAgg, onSelectStandardAgg) {
+    const parameterizedMenuItems = buildParameterizedAggregationMenuItems(api, column, onSelectParameterizedAgg);
+    if (!parameterizedMenuItems.length) {
+        // No parameterized options: keep AG Grid's native Value Aggregation menu.
+        return null;
+    }
+    const layout = api.layoutApi.getCurrentLayout();
+    // Layout is the source of truth; the grid is updated from layout on each selection.
+    const layoutAgg = getAggregationValueForColumn(column.columnId, layout);
+    const currentParameterizedDefinition = isParameterizedAggregation(layoutAgg)
+        ? getParameterizedAggregationDefinition(layoutAgg.type)
+        : undefined;
+    const standardAggFuncs = [...new Set(column.availableAggregationFunctions ?? [])];
+    const standardAggMenuItems = [
+        {
+            name: 'None',
+            checked: layoutAgg == null,
+            action: () => onSelectStandardAgg(column.columnId, null),
+        },
+        ...standardAggFuncs.map((aggFuncName) => ({
+            name: getAggFuncLabel(aggFuncName),
+            checked: isCurrentStandardAgg(layoutAgg, aggFuncName),
+            action: () => onSelectStandardAgg(column.columnId, aggFuncName),
+        })),
+    ];
+    const subMenu = standardAggMenuItems.length && parameterizedMenuItems.length
+        ? [...standardAggMenuItems, 'separator', ...parameterizedMenuItems]
+        : [...standardAggMenuItems, ...parameterizedMenuItems];
+    const currentParameterizedAggName = currentParameterizedDefinition
+        ? currentParameterizedDefinition.label
+        : undefined;
+    return {
+        name: 'Value Aggregation',
+        subMenu,
+        tooltip: currentParameterizedAggName != null
+            ? `Current: ${currentParameterizedAggName}`
+            : undefined,
+    };
+}
+export function isValueAggregationMenuItem(item) {
+    if (item === 'valueAggSubMenu') {
+        return true;
+    }
+    if (typeof item !== 'object' || item == null) {
+        return false;
+    }
+    const name = item.name;
+    return (name === 'valueAggSubMenu' ||
+        name === 'Value Aggregation' ||
+        (typeof name === 'string' && name.toLowerCase().includes('value agg')));
+}
+export function findParameterizedAggMenuInsertIndex(menuItems) {
+    const valueAggSubMenuIndex = menuItems.findIndex((item) => isValueAggregationMenuItem(item));
+    if (valueAggSubMenuIndex !== -1) {
+        return valueAggSubMenuIndex + 1;
+    }
+    const separatorBeforeAdaptableIndex = menuItems.findIndex((item) => item === 'separator');
+    if (separatorBeforeAdaptableIndex !== -1) {
+        return separatorBeforeAdaptableIndex;
+    }
+    const rowUnGroupIndex = menuItems.findIndex((item) => item === 'rowUnGroup');
+    if (rowUnGroupIndex !== -1) {
+        return rowUnGroupIndex + 1;
+    }
+    const rowGroupIndex = menuItems.findIndex((item) => item === 'rowGroup');
+    if (rowGroupIndex !== -1) {
+        return rowGroupIndex + 1;
+    }
+    return menuItems.length;
+}

package/src/Aggregation/parameterizedAggregationHeader.d.ts

@@ -0,0 +1,13 @@
+import { AdaptableApi } from '../Api/AdaptableApi';
+import { Layout } from '../AdaptableState/LayoutState';
+/**
+ * Layout may still list a parameterized agg while the column no longer has an active aggFunc
+ * (e.g. user cleared aggregation from the column menu). Only customise headers when both match.
+ */
+export declare function isParameterizedAggregationActiveOnColumn(api: AdaptableApi, valueColumnId: string, layout: Layout): boolean;
+/**
+ * When agg func names are shown in the header, AG Grid renders: `${aggLabel}(${headerValue})`.
+ * For parameterized aggs, return the weight (or other arg) column friendly name for that slot.
+ */
+export declare function getParameterizedAggregationHeaderParenthesisValue(api: AdaptableApi, valueColumnId: string, layout: Layout): string | null;
+export declare function getParameterizedAggregationDisplayName(api: AdaptableApi, aggFunc: import('../AdaptableState/Common/AggregationColumns').AggregationColumnValue, valueColumnId?: string): string;

package/src/Aggregation/parameterizedAggregationHeader.js

@@ -0,0 +1,60 @@
+import { getParameterizedAggregationDefinition, getParameterizedAggregationDefinitionByAgGridName, isParameterizedAggFuncName, isParameterizedAggregation, } from './ParameterizedAggregationRegistry';
+import { getParameterizedAggForColumn } from './parameterizedAggregationHelpers';
+/**
+ * Layout may still list a parameterized agg while the column no longer has an active aggFunc
+ * (e.g. user cleared aggregation from the column menu). Only customise headers when both match.
+ */
+export function isParameterizedAggregationActiveOnColumn(api, valueColumnId, layout) {
+    const layoutDef = getParameterizedAggForColumn(valueColumnId, layout);
+    if (!layoutDef) {
+        return false;
+    }
+    const definition = getParameterizedAggregationDefinition(layoutDef.type);
+    if (!definition?.isComplete(layoutDef)) {
+        return false;
+    }
+    const agColumn = api.columnApi.internalApi.getAgGridColumnForAdaptableColumn(valueColumnId);
+    const activeAggFunc = agColumn?.getColDef()?.aggFunc;
+    if (typeof activeAggFunc !== 'string' || !isParameterizedAggFuncName(activeAggFunc)) {
+        return false;
+    }
+    return getParameterizedAggregationDefinitionByAgGridName(activeAggFunc)?.type === layoutDef.type;
+}
+/**
+ * When agg func names are shown in the header, AG Grid renders: `${aggLabel}(${headerValue})`.
+ * For parameterized aggs, return the weight (or other arg) column friendly name for that slot.
+ */
+export function getParameterizedAggregationHeaderParenthesisValue(api, valueColumnId, layout) {
+    if (!isParameterizedAggregationActiveOnColumn(api, valueColumnId, layout)) {
+        return null;
+    }
+    const def = getParameterizedAggForColumn(valueColumnId, layout);
+    if (!def) {
+        return null;
+    }
+    const definition = getParameterizedAggregationDefinition(def.type);
+    if (!definition?.isComplete(def) || !definition.getHeaderParenthesisValue) {
+        return null;
+    }
+    return definition.getHeaderParenthesisValue(api, valueColumnId, def);
+}
+export function getParameterizedAggregationDisplayName(api, aggFunc, valueColumnId) {
+    if (isParameterizedAggregation(aggFunc)) {
+        const definition = getParameterizedAggregationDefinition(aggFunc.type);
+        if (definition?.isComplete(aggFunc) &&
+            definition.formatSummaryLabel &&
+            valueColumnId) {
+            return definition.formatSummaryLabel(api, valueColumnId, aggFunc);
+        }
+        if (definition) {
+            return definition.label;
+        }
+    }
+    if (typeof aggFunc === 'string') {
+        return aggFunc;
+    }
+    if (aggFunc === true) {
+        return 'default';
+    }
+    return String(aggFunc);
+}

package/src/Aggregation/parameterizedAggregationHelpers.d.ts

@@ -0,0 +1,23 @@
+import { AdaptableApi } from '../Api/AdaptableApi';
+import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
+import { AggregationColumnValue, ParameterizedAggFunc, TableAggregationColumns } from '../AdaptableState/Common/AggregationColumns';
+import { Layout, PivotLayout, TableLayout } from '../AdaptableState/LayoutState';
+export declare function getAggregationColumnsFromLayout(layout: Layout): TableAggregationColumns | undefined;
+export declare function getParameterizedAggForColumn(columnId: string, layout: Layout): ParameterizedAggFunc | null;
+export declare function getAggregationValueForColumn(columnId: string, layout: Layout): AggregationColumnValue | undefined;
+export declare function upsertColumnAggregationInLayout(layout: TableLayout | PivotLayout, columnId: string, aggFunc: AggregationColumnValue): void;
+export declare function removeColumnAggregationFromLayout(layout: TableLayout | PivotLayout, columnId: string): void;
+/**
+ * Whether the Value Aggregation / parameterized agg column menu should be available.
+ * Aligns with AG Grid, which only offers value aggregation when the grid is grouped.
+ */
+export declare function isValueAggregationColumnMenuAvailable(api: AdaptableApi, layout: Layout): boolean;
+/**
+ * Whether a parameterized agg (e.g. `weightedAvg`) may be offered for a column.
+ * Uses `allowedAggFuncs` from the user's Grid Options only, not Adaptable's rewritten list.
+ */
+export declare function isParameterizedAggFuncAllowedForColumn(api: AdaptableApi, column: AdaptableColumn, agGridAggFuncName: string): boolean;
+export declare function getNumericWeightColumnCandidates(api: AdaptableApi, valueColumnId: string): {
+    columnId: string;
+    friendlyName: string;
+}[];

package/src/Aggregation/parameterizedAggregationHelpers.js

@@ -0,0 +1,111 @@
+import { isPivotLayout } from '../Api/Implementation/LayoutHelpers';
+import { getParameterizedAggregationDefinition, isParameterizedAggregation, } from './ParameterizedAggregationRegistry';
+export function getAggregationColumnsFromLayout(layout) {
+    if (isPivotLayout(layout)) {
+        return layout.PivotAggregationColumns;
+    }
+    return layout.TableAggregationColumns;
+}
+export function getParameterizedAggForColumn(columnId, layout) {
+    if (!columnId) {
+        return null;
+    }
+    const aggregationColumns = getAggregationColumnsFromLayout(layout) || [];
+    const aggFunc = aggregationColumns.find((col) => col.ColumnId === columnId)?.AggFunc;
+    if (isParameterizedAggregation(aggFunc) && getParameterizedAggregationDefinition(aggFunc.type)) {
+        return aggFunc;
+    }
+    return null;
+}
+export function getAggregationValueForColumn(columnId, layout) {
+    if (!columnId) {
+        return undefined;
+    }
+    const aggregationColumns = getAggregationColumnsFromLayout(layout) || [];
+    return aggregationColumns.find((col) => col.ColumnId === columnId)?.AggFunc;
+}
+export function upsertColumnAggregationInLayout(layout, columnId, aggFunc) {
+    if (isPivotLayout(layout)) {
+        let pivotAggregationColumns = [...(layout.PivotAggregationColumns || [])];
+        let found = false;
+        pivotAggregationColumns = pivotAggregationColumns.map((entry) => {
+            if (entry.ColumnId === columnId) {
+                found = true;
+                return { ...entry, AggFunc: aggFunc };
+            }
+            return entry;
+        });
+        if (!found) {
+            pivotAggregationColumns.push({ ColumnId: columnId, AggFunc: aggFunc });
+        }
+        layout.PivotAggregationColumns = pivotAggregationColumns;
+        return;
+    }
+    let tableAggregationColumns = [...(layout.TableAggregationColumns || [])];
+    let found = false;
+    tableAggregationColumns = tableAggregationColumns.map((entry) => {
+        if (entry.ColumnId === columnId) {
+            found = true;
+            return { ColumnId: columnId, AggFunc: aggFunc };
+        }
+        return entry;
+    });
+    if (!found) {
+        tableAggregationColumns.push({ ColumnId: columnId, AggFunc: aggFunc });
+    }
+    layout.TableAggregationColumns = tableAggregationColumns;
+}
+export function removeColumnAggregationFromLayout(layout, columnId) {
+    if (isPivotLayout(layout)) {
+        layout.PivotAggregationColumns = (layout.PivotAggregationColumns || []).filter((entry) => entry.ColumnId !== columnId);
+        if (!layout.PivotAggregationColumns?.length) {
+            delete layout.PivotAggregationColumns;
+        }
+        return;
+    }
+    layout.TableAggregationColumns = (layout.TableAggregationColumns || []).filter((entry) => entry.ColumnId !== columnId);
+    if (!layout.TableAggregationColumns?.length) {
+        delete layout.TableAggregationColumns;
+    }
+}
+/**
+ * Whether the Value Aggregation / parameterized agg column menu should be available.
+ * Aligns with AG Grid, which only offers value aggregation when the grid is grouped.
+ */
+export function isValueAggregationColumnMenuAvailable(api, layout) {
+    const rowGroupColumnCount = api.agGridApi.getRowGroupColumns?.()?.length ?? 0;
+    if (rowGroupColumnCount > 0) {
+        return true;
+    }
+    if (isPivotLayout(layout)) {
+        return (layout.PivotGroupedColumns?.length ?? 0) > 0;
+    }
+    return (layout.RowGroupedColumns?.length ?? 0) > 0;
+}
+function getUserAllowedAggFuncsForColumn(api, columnId) {
+    const adaptable = api.internalApi.getAdaptableInstance();
+    const userColumnAllowed = adaptable?.agGridColumnAdapter?.getUserColDefProperty(columnId, 'allowedAggFuncs');
+    const userDefaultColDef = adaptable?.agGridAdapter?.getUserGridOptionsProperty('defaultColDef');
+    const userAllowed = userColumnAllowed ?? userDefaultColDef?.allowedAggFuncs;
+    return Array.isArray(userAllowed) ? [...userAllowed] : undefined;
+}
+/**
+ * Whether a parameterized agg (e.g. `weightedAvg`) may be offered for a column.
+ * Uses `allowedAggFuncs` from the user's Grid Options only, not Adaptable's rewritten list.
+ */
+export function isParameterizedAggFuncAllowedForColumn(api, column, agGridAggFuncName) {
+    const userAllowedAggFuncs = getUserAllowedAggFuncsForColumn(api, column.columnId);
+    if (!userAllowedAggFuncs) {
+        return true;
+    }
+    return userAllowedAggFuncs.includes(agGridAggFuncName);
+}
+export function getNumericWeightColumnCandidates(api, valueColumnId) {
+    return api.columnApi
+        .getNumericColumns()
+        .filter((col) => col.columnId !== valueColumnId)
+        .map((col) => ({
+        columnId: col.columnId,
+        friendlyName: col.friendlyName,
+    }));
+}

package/src/Aggregation/parameterizedAggregationWizardHelpers.d.ts

@@ -0,0 +1,9 @@
+import { AdaptableColumn } from '../AdaptableState/Common/AdaptableColumn';
+import { AggregationColumnValue, TableAggregationColumns } from '../AdaptableState/Common/AggregationColumns';
+import { AdaptableApi } from '../Api/AdaptableApi';
+export declare function getAdaptableAggFuncNamesForColumn(column: AdaptableColumn): string[];
+export declare function buildAggregationColumnsMap(entries: TableAggregationColumns, allColumnsMap: Record<string, AdaptableColumn | null>): Record<string, string>;
+export declare function resolveAggFuncValueFromWizardSelection(fnName: string): AggregationColumnValue;
+export declare function upsertColumnAggregationEntry(entries: TableAggregationColumns, columnId: string, aggFunc: AggregationColumnValue): TableAggregationColumns;
+export declare function getParameterizedArgColumnLabel(aggFuncName: string): string;
+export declare function formatParameterizedArgSelectionLabel(api: AdaptableApi, valueColumnId: string, aggValue: AggregationColumnValue | undefined): string;

package/src/Aggregation/parameterizedAggregationWizardHelpers.js

@@ -0,0 +1,66 @@
+import { getAggFuncName, } from '../AdaptableState/Common/AggregationColumns';
+import { getParameterizedAggregationDefinition, getParameterizedAggregationDefinitionByAgGridName, getParameterizedAggregationDefinitions, isParameterizedAggregation, } from './ParameterizedAggregationRegistry';
+export function getAdaptableAggFuncNamesForColumn(column) {
+    return getParameterizedAggregationDefinitions()
+        .filter((definition) => definition.isAvailableForColumn(column))
+        .map((definition) => definition.agGridAggFuncName);
+}
+export function buildAggregationColumnsMap(entries, allColumnsMap) {
+    return (entries || []).reduce((acc, { ColumnId: colId, AggFunc }) => {
+        if (typeof AggFunc === 'boolean') {
+            const defaultFn = allColumnsMap[colId]?.aggregationFunction;
+            acc[colId] = typeof defaultFn === 'string' ? defaultFn : '';
+        }
+        else if (isParameterizedAggregation(AggFunc)) {
+            const fnName = getAggFuncName(AggFunc);
+            acc[colId] = typeof fnName === 'string' ? fnName : '';
+        }
+        else if (typeof AggFunc === 'string') {
+            acc[colId] = AggFunc;
+        }
+        return acc;
+    }, {});
+}
+export function resolveAggFuncValueFromWizardSelection(fnName) {
+    const definition = getParameterizedAggregationDefinitionByAgGridName(fnName);
+    if (definition) {
+        return definition.createInitialDefinition();
+    }
+    return fnName;
+}
+export function upsertColumnAggregationEntry(entries, columnId, aggFunc) {
+    let aggCols = [...(entries || [])];
+    let found = false;
+    aggCols = aggCols.map((entry) => {
+        if (entry.ColumnId === columnId) {
+            found = true;
+            return { ColumnId: columnId, AggFunc: aggFunc };
+        }
+        return entry;
+    });
+    if (!found) {
+        aggCols.push({ ColumnId: columnId, AggFunc: aggFunc });
+    }
+    return aggCols;
+}
+export function getParameterizedArgColumnLabel(aggFuncName) {
+    return getParameterizedAggregationDefinitionByAgGridName(aggFuncName)?.argColumnLabel ?? 'Argument';
+}
+export function formatParameterizedArgSelectionLabel(api, valueColumnId, aggValue) {
+    if (!isParameterizedAggregation(aggValue)) {
+        return 'Select';
+    }
+    const definition = getParameterizedAggregationDefinition(aggValue.type);
+    if (!definition) {
+        return 'Select';
+    }
+    if (definition.isComplete(aggValue) && definition.formatSummaryLabel) {
+        const shortLabel = definition.formatSummaryLabel(api, valueColumnId, aggValue);
+        const argPart = shortLabel.match(/\(([^)]+)\)/)?.[1];
+        if (argPart?.includes('-')) {
+            return argPart.split('-').slice(1).join('-');
+        }
+        return argPart ?? 'Select';
+    }
+    return `Select ${definition.argColumnLabel ?? 'value'}`;
+}

package/src/Aggregation/validateParameterizedAggregations.d.ts

@@ -0,0 +1,4 @@
+import { Layout, PivotLayout, TableLayout } from '../AdaptableState/LayoutState';
+export declare function validateParameterizedAggregationsInLayout(layout: Layout): true | string;
+export declare function validateTableLayoutAggregations(layout: TableLayout): true | string;
+export declare function validatePivotLayoutAggregations(layout: PivotLayout): true | string;

package/src/Aggregation/validateParameterizedAggregations.js

@@ -0,0 +1,20 @@
+import { getParameterizedAggregationDefinition, isParameterizedAggregation, } from './ParameterizedAggregationRegistry';
+import { getAggregationColumnsFromLayout } from './parameterizedAggregationHelpers';
+export function validateParameterizedAggregationsInLayout(layout) {
+    const entries = getAggregationColumnsFromLayout(layout) || [];
+    for (const { AggFunc } of entries) {
+        if (isParameterizedAggregation(AggFunc)) {
+            const definition = getParameterizedAggregationDefinition(AggFunc.type);
+            if (definition && !definition.isComplete(AggFunc)) {
+                return `${definition.label} requires all arguments to be selected.`;
+            }
+        }
+    }
+    return true;
+}
+export function validateTableLayoutAggregations(layout) {
+    return validateParameterizedAggregationsInLayout(layout);
+}
+export function validatePivotLayoutAggregations(layout) {
+    return validateParameterizedAggregationsInLayout(layout);
+}

package/src/Api/AdaptableApi.d.ts

@@ -24,7 +24,6 @@ import { SystemStatusApi } from './SystemStatusApi';
 import { ThemeApi } from './ThemeApi';
 import { UserInterfaceApi } from './UserInterfaceApi';
 import { GridApi } from './GridApi';
-import { ScheduleApi } from './ScheduleApi';
 import { ExpressionApi } from './ExpressionApi';
 import { TeamSharingApi } from './TeamSharingApi';
 import { ColumnApi } from './ColumnApi';
@@ -204,10 +203,6 @@ export interface AdaptableApi {
      * Creates Row Forms
      */
     rowFormApi: RowFormApi;
-    /**
-     * Provides access to the Schedule Module
-     */
-    scheduleApi: ScheduleApi;
     /**
      * Provides access to the Settings Panel
      */