@adaptabletools/adaptable 18.1.0 → 18.1.2

package/src/parser/src/types.d.ts

@@ -1,5 +1,5 @@
 import { IRowNode } from '@ag-grid-community/core';
-import { AdaptableApi, BaseContext } from '../../../types';
+import { BaseContext } from '../../../types';
 export type AST = AST_Expression[];
 export type PredicateType = 'VALUE_REF' | 'INFIX' | 'UNARY' | 'FUNCTION' | 'CONDITIONAL';
 /**
@@ -129,103 +129,148 @@ args: any[],
  */
 context: ExpressionContext) => any;
 export declare const isAST_Function: (node: AST_Expression) => node is AST_Function;
-export interface AggregatedScalarExpressionReducerContext extends BaseContext {
+export interface AggregatedExpressionFunction {
     /**
-     * Current row node
+     * Expression description
      */
-    rowNode: IRowNode;
+    description?: string;
+    /**
+     * Example Signatures for the function
+     */
+    signatures?: string[];
+    /**
+     * Examples how the function can be used
+     */
+    examples?: string[];
+    /**
+     * Mandaatory Initial Value for the aggregation
+     */
+    initialValue: any;
+    /**
+     * Mandatory Reducer function which is called for each value(row) in the Column Data
+     */
+    reducer: (context: AggregatedExpressionReducerContext) => any;
+    /**
+     * Called AFTER the reducer() has processed all values / rows
+     * Can be used to change result of reducer based on the values array (e.g. average = aggregated value / count)
+     */
+    processAggregatedValue?: (context: AggregatedExpressionProcessAggregatedValueContext) => any;
+    /**
+     * Called for each row AFTER the reducer() and processAggregatedValue() functions
+     * Can be used when each row has a different aggregated value (e.g. percentage = row value / aggregated value).
+     * Returns return value for each individual row
+     */
+    prepareRowValue?: (context: AggregatedExpressionPrepareRowValueContext) => number | string | Date | undefined;
     /**
-     * Adaptable API
+     * Optional filter which is applied to each row before the reducer is called. If the filter returns false, the row is NOT included in the aggregation.
      */
-    adaptableApi: AdaptableApi;
+    filterRow?: (context: AggregatedExpressionFilteRowContext) => boolean;
+}
+export interface AggregatedExpressionReducerContext extends BaseContext {
     /**
-     * Arguments passed to the function
-     * Column arguments are transformed to their values, e.g. [colId] -> args = [value-of-colId]
+     * Value returned by the previous call to the reducer function, or the initialValue if this is the first call. You return the new accumulator value from this function.
+     */
+    accumulator: any;
+    /**
+     * Current value being processed in the Column Data
+     */
+    currentValue: any;
+    /**
+     * Index of the current value in the Column Data
+     */
+    index: number;
+    /**
+     * Current row node
+     */
+    rowNode: IRowNode;
+    /**
+     * Arguments passed to the function. Column arguments are transformed to their values, e.g. [colId] -> args = [value-of-colId]. Aggregation column and group by column are not included as they are passed as separate arguments.
      */
     args: any[];
     /**
      * Column Id of the column being aggregated
      */
     aggColumnId: string;
+    /**
+     * Column Id(s) of the column(s) being grouped by
+     */
+    groupByColumnIds?: string[];
     /**
      * Helper function to get the value of a column
      * @param colId column id
-     * @returns
      */
     getValueForColId: (colId: string) => any;
 }
-export interface AggregatedScalarExpressionProcessReducerValueContext extends BaseContext {
+export interface AggregatedExpressionProcessAggregatedValueContext extends BaseContext {
     /**
-     * Arguments passed to the function
+     * Result of the reducer
      */
-    args: any[];
-}
-export interface AggregatedScalarExpressionPrepareRowValueContext extends BaseContext {
+    aggregatedValue: any;
     /**
-     * Arguments passed to the function
+     * Array of row nodes; if aggregation is grouped, this will be the array of row nodes for the group
+     */
+    rowNodes: IRowNode[];
+    /**
+     * Arguments passed to the function. Aggregation column and group by column are not included as they are passed as separate arguments.
      */
     args: any[];
-    aggColumnId: string;
-    getValueForColId: (colId: string) => any;
-}
-export interface AggregatedScalarExpressionRowFilterContext extends BaseContext {
     /**
      * Column Id of the column being aggregated
-     * Usualy the first Col argument, e.g. [colId]
      */
     aggColumnId: string;
     /**
-     * Utility function to get the value of a column
-     * @param colId column id
-     * @returns
+     * Column Id(s) of the column(s) being grouped by
      */
-    getValueForColId: (colId: string) => any;
+    groupByColumnIds?: string[];
 }
-export interface AggregatedScalarExpressionFunction {
+export interface AggregatedExpressionPrepareRowValueContext extends BaseContext {
     /**
-     * Expression description.
+     * Current Row Node
      */
-    description?: string;
+    rowNode: IRowNode;
     /**
-     * Examples how this function ca be used.
+     * Result of the reducer
      */
-    signatures?: string[];
+    aggregatedValue: any;
     /**
-     * How the function can be used.
+     * Arguments passed to the function. Column arguments are transformed to their values, e.g. [colId] -> args = [value-of-colId]. Aggregation column and group by column are not included as they are passed as separate arguments.
      */
-    examples?: string[];
+    args: any[];
     /**
-     * Initial Value for the aggregation
+     * Column Id of the column being aggregated
      */
-    initialValue: any;
+    aggColumnId: string;
     /**
-     * Reducer function which is called for each value in the Column Data.
-     * @param accumulator - the value returned by the previous call to the reducer function, or the initialValue if this is the first call. You return the new accumulator value from this function.
-     * @param currentValue - the current value being processed in the Column Data
-     * @param index - index of the current value in the Column Data
-     * @param context - context object with the current row node, adaptableApi, aggColumnId and other possible custom arguments
+     * Column Id(s) of the column(s) being grouped by
      */
-    reducer: (accumulator: any, currentValue: any, index: number, context: AggregatedScalarExpressionReducerContext) => any;
+    groupByColumnIds?: string[];
     /**
-     * If specified, this function is called after the reducer has processed all values.
-     * Can be used to change the result of the reducer based on the values array (e.g. average).
-     * @param aggregatedValue - result of the reducer
-     * @param dataArray - array of values. If aggregation was grouped, this will be the array of values for the group.
-     * @param context - context object with the args
+     * Helper function to get the value of a column
+     * @param colId column id
      */
-    processReducerValue?: (aggregatedValue: any, dataArray: any[], context: AggregatedScalarExpressionProcessReducerValueContext) => number | string | Date;
+    getValueForColId: (colId: string) => any;
+}
+export interface AggregatedExpressionFilteRowContext extends BaseContext {
+    /**
+     * Current row node
+     */
+    rowNode: IRowNode;
+    /**
+     * Arguments passed to the function. Column arguments are transformed to their values, e.g. [colId] -> args = [value-of-colId]. Aggregation column and group by column are not included as they are passed as separate arguments.
+     */
+    args: any[];
+    /**
+     * Column Id of the column being aggregated
+     * Usually the first Col argument, e.g. [colId]
+     */
+    aggColumnId: string;
     /**
-     * If specified, this function is be called for each row.
-     * This can be used when each row has a different value (e.g. percentage).
-     * @param rowNode - current row node
-     * @param context - context object with the args, aggColumnId, getValueForColId
-     * @returns return value for each individual row
+     * Column Id(s) of the column(s) being grouped by
      */
-    prepareRowValue?: (rowNode: IRowNode, aggregatedValue: any, context: AggregatedScalarExpressionPrepareRowValueContext) => number | string | Date;
+    groupByColumnIds?: string[];
     /**
-     * If specified, this function filters the rows that are included in the aggregation.
-     * @param rowNode - current row node
-     * @param context - context object with the aggColumnId, getValueForColId
+     * Utility function to get the value of a column
+     * @param colId column id
      */
-    rowFilter?: (rowNode: IRowNode, context: AggregatedScalarExpressionRowFilterContext) => boolean;
+    getValueForColId: (colId: string) => any;
 }

package/src/types.d.ts

@@ -1,4 +1,4 @@
-export type { ExpressionFunction, ExpressionFunctionDocBlock, ExpressionFunctionHandler, ExpressionContext, ExpressionFunctionMap, ExpressionCategory, ExpressionFunctionInputType, AggregatedScalarExpressionFunction, AggregatedScalarExpressionReducerContext, AST, AST_Function, AST_Expression, Token, } from './../src/parser/src/types';
+export type { ExpressionFunction, ExpressionFunctionDocBlock, ExpressionFunctionHandler, ExpressionContext, ExpressionFunctionMap, ExpressionCategory, ExpressionFunctionInputType, AggregatedExpressionFunction, AggregatedExpressionReducerContext, AggregatedExpressionProcessAggregatedValueContext, AggregatedExpressionPrepareRowValueContext, AggregatedExpressionFilteRowContext, AST, AST_Function, AST_Expression, Token, } from './../src/parser/src/types';
 export type { AgGridConfig } from './AdaptableInterfaces/IAdaptable';
 export type { AdaptableConfig } from './View/AdaptableWizardView/AdaptableConfigurationDialog/AdaptableConfig';
 export type { AdaptableNoCodeWizardOptions, IAdaptableNoCodeWizard, } from './AdaptableInterfaces/AdaptableNoCodeWizard';