@adaptabletools/adaptable 23.0.0-canary.4 → 23.0.0-canary.5

package/src/Aggregation/ParameterizedAggregationRegistry.d.ts

@@ -1,35 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

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

package/src/Aggregation/definitions/weightedAverageAggregationDefinition.js

@@ -1,55 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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/View/Layout/Wizard/sections/ParameterizedAggFuncPicker.d.ts

@@ -1,12 +0,0 @@
-import * as React from 'react';
-import { AdaptableColumn } from '../../../../AdaptableState/Common/AdaptableColumn';
-import { AggregationColumnValue, TableAggregationColumns } from '../../../../AdaptableState/Common/AggregationColumns';
-export declare const ParameterizedAggFuncPicker: React.FunctionComponent<{
-    column: AdaptableColumn;
-    aggValue?: AggregationColumnValue;
-    aggregationColumnsMap: Record<string, string>;
-    numberColumns: AdaptableColumn[];
-    aggregationEntries: TableAggregationColumns;
-    onChangeEntries: (entries: TableAggregationColumns) => void;
-    availableAggregationFunctions?: string[];
-}>;