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

package/src/AdaptableState/Common/FilterActionOnDataChange.d.ts

@@ -1,17 +0,0 @@
-/**
- * Whether Adaptable re-applies filtering after data edits; if `applyFilter` value is 'Throttle', `throttleDelay` should be set
- */
-export interface FilterActionOnDataChange {
-    /**
-     * When to re-apply Filters: 'Always', 'Never' or 'Throttle'
-     */
-    applyFilter: ApplyFilterAction;
-    /**
-     * Delay in ms (when `applyFilter` is set to 'Throttle')
-     */
-    throttleDelay?: number;
-}
-/**
- * When to apply a Filter: 'Always', 'Never' or 'Throttle'
- */
-export type ApplyFilterAction = 'Always' | 'Never' | 'Throttle';

package/src/AdaptableState/Common/FilterActionOnDataChange.js

@@ -1,5 +0,0 @@
-"use strict";
-/**
- * Whether Adaptable re-applies filtering after data edits; if `applyFilter` value is 'Throttle', `throttleDelay` should be set
- */
-Object.defineProperty(exports, "__esModule", { value: true });

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,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getParameterizedAggregationDefinitions = getParameterizedAggregationDefinitions;
-exports.getParameterizedAggregationDefinition = getParameterizedAggregationDefinition;
-exports.getParameterizedAggregationDefinitionByAgGridName = getParameterizedAggregationDefinitionByAgGridName;
-exports.isParameterizedAggFuncName = isParameterizedAggFuncName;
-exports.isParameterizedAggregation = isParameterizedAggregation;
-exports.getParameterizedAggFuncName = getParameterizedAggFuncName;
-exports.aggregationValueToColumnAggregationModel = aggregationValueToColumnAggregationModel;
-exports.aggregationValueFromColumnAggregationModel = aggregationValueFromColumnAggregationModel;
-exports.computeParameterizedAggregation = computeParameterizedAggregation;
-const weightedAverageAggregationDefinition_1 = require("./definitions/weightedAverageAggregationDefinition");
-const PARAMETERIZED_AGGREGATION_DEFINITIONS = [
-    weightedAverageAggregationDefinition_1.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,
-]));
-function getParameterizedAggregationDefinitions() {
-    return PARAMETERIZED_AGGREGATION_DEFINITIONS;
-}
-function getParameterizedAggregationDefinition(type) {
-    return definitionsByType.get(type);
-}
-function getParameterizedAggregationDefinitionByAgGridName(agGridAggFuncName) {
-    return definitionsByAgGridName.get(agGridAggFuncName);
-}
-function isParameterizedAggFuncName(aggFunc) {
-    return definitionsByAgGridName.has(aggFunc);
-}
-function isParameterizedAggregation(aggFunc) {
-    return (typeof aggFunc === 'object' &&
-        aggFunc != null &&
-        'type' in aggFunc &&
-        definitionsByType.has(aggFunc.type));
-}
-function getParameterizedAggFuncName(aggFunc) {
-    if (!isParameterizedAggregation(aggFunc)) {
-        return undefined;
-    }
-    return getParameterizedAggregationDefinition(aggFunc.type)?.agGridAggFuncName;
-}
-function aggregationValueToColumnAggregationModel(aggFunc) {
-    if (isParameterizedAggregation(aggFunc)) {
-        const definition = getParameterizedAggregationDefinition(aggFunc.type);
-        if (definition) {
-            return definition.toColumnAggregationModel(aggFunc);
-        }
-    }
-    return { aggFunc: aggFunc };
-}
-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;
-}
-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,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.weightedAverageAggregationDefinition = void 0;
-const AggregationColumns_1 = require("../../AdaptableState/Common/AggregationColumns");
-const weightedAverage_1 = require("../../Utilities/weightedAverage");
-function formatValueAndArgColumnHeaderLabel(api, valueColumnId, argColumnId) {
-    const valueName = api.columnApi.getFriendlyNameForColumnId(valueColumnId);
-    const argName = api.columnApi.getFriendlyNameForColumnId(argColumnId);
-    return `${valueName}-${argName}`;
-}
-exports.weightedAverageAggregationDefinition = {
-    type: 'weightedAverage',
-    agGridAggFuncName: AggregationColumns_1.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 (0, weightedAverage_1.weightedAverage)(params, valueColumnId, def.weightedColumnId);
-    },
-    toColumnAggregationModel(def) {
-        return {
-            aggFunc: AggregationColumns_1.WEIGHTED_AVERAGE_AGG_FN_NAME,
-            weightedColumnId: def.weightedColumnId,
-        };
-    },
-    fromColumnAggregationModel(model) {
-        if (model.aggFunc !== AggregationColumns_1.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 `${AggregationColumns_1.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,143 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildParameterizedAggregationMenuItems = buildParameterizedAggregationMenuItems;
-exports.buildConsolidatedAggregationColumnMenuItem = buildConsolidatedAggregationColumnMenuItem;
-exports.isValueAggregationMenuItem = isValueAggregationMenuItem;
-exports.findParameterizedAggMenuInsertIndex = findParameterizedAggMenuInsertIndex;
-const LayoutHelpers_1 = require("../Api/Implementation/LayoutHelpers");
-const parameterizedAggregationHelpers_1 = require("./parameterizedAggregationHelpers");
-const ParameterizedAggregationRegistry_1 = require("./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;
-}
-function buildParameterizedAggregationMenuItems(api, column, onSelect) {
-    const layout = api.layoutApi.getCurrentLayout();
-    const features = api.layoutApi.internalApi.getLayoutSupportedFeatures();
-    const supportsAggregations = (0, LayoutHelpers_1.isPivotLayout)(layout)
-        ? features.PivotAggregationColumns
-        : features.TableAggregationColumns;
-    if (!supportsAggregations) {
-        return [];
-    }
-    // Match AG Grid: "Value Aggregation" is only offered when the grid is grouped.
-    if (!(0, parameterizedAggregationHelpers_1.isValueAggregationColumnMenuAvailable)(api, layout)) {
-        return [];
-    }
-    const layoutAgg = (0, parameterizedAggregationHelpers_1.getAggregationValueForColumn)(column.columnId, layout);
-    const weightColumnCandidates = (0, parameterizedAggregationHelpers_1.getNumericWeightColumnCandidates)(api, column.columnId);
-    return (0, ParameterizedAggregationRegistry_1.getParameterizedAggregationDefinitions)()
-        .filter((definition) => definition.isAvailableForColumn(column) &&
-        (0, parameterizedAggregationHelpers_1.isParameterizedAggFuncAllowedForColumn)(api, column, definition.agGridAggFuncName))
-        .map((definition) => {
-        const isCurrentType = (0, ParameterizedAggregationRegistry_1.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 &&
-                        (0, ParameterizedAggregationRegistry_1.isParameterizedAggregation)(layoutAgg) &&
-                        layoutAgg.weightedColumnId === weightColumn.columnId;
-                    return {
-                        name: weightColumn.friendlyName,
-                        checked: isSelected,
-                        action: () => {
-                            if (definition.createDefinition) {
-                                onSelect(column.columnId, definition.createDefinition(weightColumn.columnId));
-                            }
-                        },
-                    };
-                }),
-        };
-    });
-}
-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 = (0, parameterizedAggregationHelpers_1.getAggregationValueForColumn)(column.columnId, layout);
-    const currentParameterizedDefinition = (0, ParameterizedAggregationRegistry_1.isParameterizedAggregation)(layoutAgg)
-        ? (0, ParameterizedAggregationRegistry_1.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,
-    };
-}
-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')));
-}
-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,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isParameterizedAggregationActiveOnColumn = isParameterizedAggregationActiveOnColumn;
-exports.getParameterizedAggregationHeaderParenthesisValue = getParameterizedAggregationHeaderParenthesisValue;
-exports.getParameterizedAggregationDisplayName = getParameterizedAggregationDisplayName;
-const ParameterizedAggregationRegistry_1 = require("./ParameterizedAggregationRegistry");
-const parameterizedAggregationHelpers_1 = require("./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.
- */
-function isParameterizedAggregationActiveOnColumn(api, valueColumnId, layout) {
-    const layoutDef = (0, parameterizedAggregationHelpers_1.getParameterizedAggForColumn)(valueColumnId, layout);
-    if (!layoutDef) {
-        return false;
-    }
-    const definition = (0, ParameterizedAggregationRegistry_1.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' || !(0, ParameterizedAggregationRegistry_1.isParameterizedAggFuncName)(activeAggFunc)) {
-        return false;
-    }
-    return (0, ParameterizedAggregationRegistry_1.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.
- */
-function getParameterizedAggregationHeaderParenthesisValue(api, valueColumnId, layout) {
-    if (!isParameterizedAggregationActiveOnColumn(api, valueColumnId, layout)) {
-        return null;
-    }
-    const def = (0, parameterizedAggregationHelpers_1.getParameterizedAggForColumn)(valueColumnId, layout);
-    if (!def) {
-        return null;
-    }
-    const definition = (0, ParameterizedAggregationRegistry_1.getParameterizedAggregationDefinition)(def.type);
-    if (!definition?.isComplete(def) || !definition.getHeaderParenthesisValue) {
-        return null;
-    }
-    return definition.getHeaderParenthesisValue(api, valueColumnId, def);
-}
-function getParameterizedAggregationDisplayName(api, aggFunc, valueColumnId) {
-    if ((0, ParameterizedAggregationRegistry_1.isParameterizedAggregation)(aggFunc)) {
-        const definition = (0, ParameterizedAggregationRegistry_1.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,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAggregationColumnsFromLayout = getAggregationColumnsFromLayout;
-exports.getParameterizedAggForColumn = getParameterizedAggForColumn;
-exports.getAggregationValueForColumn = getAggregationValueForColumn;
-exports.upsertColumnAggregationInLayout = upsertColumnAggregationInLayout;
-exports.removeColumnAggregationFromLayout = removeColumnAggregationFromLayout;
-exports.isValueAggregationColumnMenuAvailable = isValueAggregationColumnMenuAvailable;
-exports.isParameterizedAggFuncAllowedForColumn = isParameterizedAggFuncAllowedForColumn;
-exports.getNumericWeightColumnCandidates = getNumericWeightColumnCandidates;
-const LayoutHelpers_1 = require("../Api/Implementation/LayoutHelpers");
-const ParameterizedAggregationRegistry_1 = require("./ParameterizedAggregationRegistry");
-function getAggregationColumnsFromLayout(layout) {
-    if ((0, LayoutHelpers_1.isPivotLayout)(layout)) {
-        return layout.PivotAggregationColumns;
-    }
-    return layout.TableAggregationColumns;
-}
-function getParameterizedAggForColumn(columnId, layout) {
-    if (!columnId) {
-        return null;
-    }
-    const aggregationColumns = getAggregationColumnsFromLayout(layout) || [];
-    const aggFunc = aggregationColumns.find((col) => col.ColumnId === columnId)?.AggFunc;
-    if ((0, ParameterizedAggregationRegistry_1.isParameterizedAggregation)(aggFunc) && (0, ParameterizedAggregationRegistry_1.getParameterizedAggregationDefinition)(aggFunc.type)) {
-        return aggFunc;
-    }
-    return null;
-}
-function getAggregationValueForColumn(columnId, layout) {
-    if (!columnId) {
-        return undefined;
-    }
-    const aggregationColumns = getAggregationColumnsFromLayout(layout) || [];
-    return aggregationColumns.find((col) => col.ColumnId === columnId)?.AggFunc;
-}
-function upsertColumnAggregationInLayout(layout, columnId, aggFunc) {
-    if ((0, LayoutHelpers_1.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;
-}
-function removeColumnAggregationFromLayout(layout, columnId) {
-    if ((0, LayoutHelpers_1.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.
- */
-function isValueAggregationColumnMenuAvailable(api, layout) {
-    const rowGroupColumnCount = api.agGridApi.getRowGroupColumns?.()?.length ?? 0;
-    if (rowGroupColumnCount > 0) {
-        return true;
-    }
-    if ((0, LayoutHelpers_1.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.
- */
-function isParameterizedAggFuncAllowedForColumn(api, column, agGridAggFuncName) {
-    const userAllowedAggFuncs = getUserAllowedAggFuncsForColumn(api, column.columnId);
-    if (!userAllowedAggFuncs) {
-        return true;
-    }
-    return userAllowedAggFuncs.includes(agGridAggFuncName);
-}
-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;