Class Max

packages/core/src/formula_parser/functions/numeric.ts:240–292

}

export class Max extends NumericFunc {
  static override acceptValueType = new Set([BasicValueType.DateTime, BasicValueType.Array, ...FormulaFunc.acceptValueType]);

  static override validateParams(_params: AstNode[]) {
    //
  }

  static override getReturnType(params: AstNode[]) {
    params && this.validateParams(params);
    if (!params) {
      return BasicValueType.Number;
    }

    if (isArrayNodes(params)) {
      const innerValueType = (params[0] as ValueOperandNodeBase).innerValueType;
      if (innerValueType === BasicValueType.DateTime) {
        return BasicValueType.DateTime;
      }
      return BasicValueType.Number;
    }

    // All parameters are date type, return date type
    if (params.every(node => node.valueType === BasicValueType.DateTime)) {
      return BasicValueType.DateTime;
    }

    return BasicValueType.Number;
  }

  static override func(params: IFormulaParam<number>[]): NumericType {
    return this.calc(params, max);
  }

  static calc(params: IFormulaParam<number>[], calcFn: (collection: any[]) => any): NumericType {
    // If there is only one parameter and it is an array, it means that the value of the array type field is summed
    if (isArrayParam(params)) {
      if (!params[0].value) {
        return null;
      }
      const v = calcFn(params[0].value.map(Number).filter(d => !isNaN(d)));
      return v == null ? null : Number(v);
    }

    // If the return value is DateTime, the node of DateTime type should be filtered out,
    // otherwise the timestamp will be introduced to disturb the calculation result
    if (this.getReturnType(params.map(p => p.node)) !== BasicValueType.DateTime) {
      params = params.filter(p => p.node.valueType !== BasicValueType.DateTime);
    }

    const v = calcFn(params.map(p => Number(p.value)).filter(d => !isNaN(d)));
    return v == null ? 0 : Number(v);
  }
}

// The Min function is different from Max only in the calculation method calcFn
export class Min extends Max {