Build your own AI office with Univer Office SDK. Bring editing, calculation, collaboration, and file processing into your product for people and AI agents. Built on an extensible open-source core.
TypeScript boardcollaborationdocdocxexceloffce365officepdfpptpptxpresentationsdksheetslidesspreadsheetuniverwordwordprocessorworkspacexlsx
fix(formula): fix the issue in some formulas where the range parameter is not a reference object (#5872)
wpxp12345603d0ee5b87ea
diff --git a/packages/engine-formula/src/engine/utils/value-object.ts b/packages/engine-formula/src/engine/utils/value-object.tsindex b1f2a62e46..bebc49dc9c 100644--- a/packages/engine-formula/src/engine/utils/value-object.ts+++ b/packages/engine-formula/src/engine/utils/value-object.ts@@ -16,7 +16,6 @@import type { ICellData, Nullable } from '@univerjs/core';import type { BaseReferenceObject, FunctionVariantType } from '../reference-object/base-reference-object';-import type { ArrayValueObject } from '../value-object/array-value-object';import type { BaseValueObject } from '../value-object/base-value-object';import { CellValueType } from '@univerjs/core';import { ErrorType } from '../../basics/error-type';@@ -24,6 +23,7 @@ import { compareToken } from '../../basics/token';import { CellReferenceObject } from '../reference-object/cell-reference-object';import { ColumnReferenceObject } from '../reference-object/column-reference-object';import { RowReferenceObject } from '../reference-object/row-reference-object';+import { ArrayValueObject } from '../value-object/array-value-object';import { ErrorValueObject } from '../value-object/base-value-object';import { BooleanValueObject, NumberValueObject } from '../value-object/primitive-object';import { expandArrayValueObject } from './array-object';@@ -176,23 +176,138 @@ export function calculateMaxDimensions(variants: BaseValueObject[]) {return { maxRowLength, maxColumnLength };}-export function getErrorArray(variants: BaseValueObject[], sumRange: BaseValueObject, maxRowLength: number, maxColumnLength: number) {- const sumRowLength = (sumRange as ArrayValueObject).getRowCount();- const sumColumnLength = (sumRange as ArrayValueObject).getColumnCount();+/**+ * Parse the paired range and criteria in functions like COUNTIFS, SUMIFS, etc.+ * @param variants - The range and criteria pairs+ * @param targetRange - The target range for calculation (e.g., sumRange in SUMIFS)+ * @returns An object containing parsed information+ */+// eslint-disable-next-line max-lines-per-function+export function parsePairedRangeAndCriteria(+ variants: FunctionVariantType[],+ targetRange?: FunctionVariantType+): {+ isError: boolean;+ errorObject: Nullable<ErrorValueObject>;+ rangeIsDifferentSize: boolean;+ criteriaMaxRowLength: number;+ criteriaMaxColumnLength: number;+ targetRange: Nullable<BaseValueObject>;+ variants: BaseValueObject[];+} {+ /**+ * The range and criteria must be in pairs.+ * If not, Excel will prevent the operation. But we can't do it like that, so we just return a #VALUE! error.+ */+ if (variants.length === 0 || variants.length % 2 !== 0) {+ return {+ isError: true,+ errorObject: ErrorValueObject.create(ErrorType.VALUE),+ rangeIsDifferentSize: false,+ criteriaMaxRowLength: 0,+ criteriaMaxColumnLength: 0,+ targetRange: null,+ variants: [],+ };+ }++ let _targetRange: Nullable<BaseValueObject> = null;+ let targetRangeRowCount = -1;+ let targetRangeColumnCount = -1;++ if (targetRange) {+ /**+ * If the target range is provided, it must be a reference object.+ * If not, Excel will prevent the operation. But we can't do it like that, so we just return a #VALUE! error.+ */+ if (!targetRange.isReferenceObject()) {+ return {+ isError: true,+ errorObject: ErrorValueObject.create(ErrorType.VALUE),+ rangeIsDifferentSize: false,+ criteriaMaxRowLength: 0,+ criteriaMaxColumnLength: 0,+ targetRange: null,+ variants: [],+ };+ }++ _targetRange = (targetRange as BaseReferenceObject).toArrayValueObject();+ targetRangeRowCount = (_targetRange as ArrayValueObject).getRowCount();+ targetRangeColumnCount = (_targetRange as ArrayValueObject).getColumnCount();+ }++ let criteriaMaxRowLength = 0;+ let criteriaMaxColumnLength = 0;+ let rangeIsDifferentSize = false;++ const _variants: BaseValueObject[] = [];for (let i = 0; i < variants.length; i++) {- if (i % 2 === 1) continue;+ if (i % 2 === 1) {+ const range = variants[i - 1];+ const criteria = variants[i];++ /**+ * The range must be a reference object.+ * If not, Excel will prevent the operation. But we can't do it like that, so we just return a #VALUE! error.+ */+ if (!range.isReferenceObject()) {+ return {+ isError: true,+ errorObject: ErrorValueObject.create(ErrorType.VALUE),+ rangeIsDifferentSize: false,+ criteriaMaxRowLength: 0,+ criteriaMaxColumnLength: 0,+ targetRange: null,+ variants: [],+ };+ }- const range = variants[i];+ const _range = (range as BaseReferenceObject).toArrayValueObject();+ const rangeRowCount = _range.getRowCount();+ const rangeColumnCount = _range.getColumnCount();++ if (i === 1 && targetRangeRowCount === -1 && targetRangeColumnCount === -1) {+ // If the target range is not specified, use the first range as the target range. e.g. COUNTIFS(A1:A3, ">1", B1:B3, "<5").+ targetRangeRowCount = rangeRowCount;+ targetRangeColumnCount = rangeColumnCount;+ } else if (!rangeIsDifferentSize && (targetRangeRowCount !== rangeRowCount || targetRangeColumnCount !== rangeColumnCount)) {+ // The size of each range must be the same as the target range+ rangeIsDifferentSize = true;+ }++ let _criteria = criteria;- const rangeRowLength = (range as ArrayValueObject).getRowCount();- const rangeColumnLength = (range as ArrayValueObject).getColumnCount();- if (rangeRowLength !== sumRowLength || rangeColumnLength !== sumColumnLength) {- return expandArrayValueObject(maxRowLength, maxColumnLength, ErrorValueObject.create(ErrorType.VALUE));+ if (criteria.isReferenceObject()) {+ _criteria = (criteria as BaseReferenceObject).toArrayValueObject();+ }++ criteriaMaxRowLength = Math.max(criteriaMaxRowLength, _criteria.isArray() ? (_criteria as ArrayValueObject).getRowCount() : 1);+ criteriaMaxColumnLength = Math.max(criteriaMaxColumnLength, _criteria.isArray() ? (_criteria as ArrayValueObject).getColumnCount() : 1);++ _variants.push(_range);+ _variants.push(_criteria as BaseValueObject);}}- return null;+ return {+ isError: false,+ errorObject: null,+ rangeIsDifferentSize,+ criteriaMaxRowLength,+ criteriaMaxColumnLength,+ targetRange: _targetRange,+ variants: _variants,+ };+}++export function baseValueObjectToArrayValueObject(valueObject: BaseValueObject): ArrayValueObject {+ if (valueObject.isArray()) {+ return valueObject as ArrayValueObject;+ }++ return ArrayValueObject.createByArray([[valueObject.getValue()]]);}export function getBooleanResults(variants: BaseValueObject[], maxRowLength: number, maxColumnLength: number, isNumberSensitive: boolean = false) {diff --git a/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts b/packages/engine-formula/src/functions/__tests__/nested-functions.spec.tsindex 85bf3691d7..a5e925ce02 100644--- a/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts+++ b/packages/engine-formula/src/functions/__tests__/nested-functions.spec.ts@@ -600,24 +600,16 @@ describe('Test nested functions', () => {it('Sumifs test, range is number, criteria is number string', () => {let result = calculate('=SUMIFS(A11:C11,A11:C11,"2")');- expect(result).toStrictEqual([- [2],- ]);+ expect(result).toBe(2);result = calculate('=SUMIFS(A11:C11,A11:C11,A12)');- expect(result).toStrictEqual([- [2],- ]);+ expect(result).toBe(2);result = calculate('=SUMIFS(A11:C11,A11:C11,"2",A11:C11,3)');- expect(result).toStrictEqual([- [0],- ]);+ expect(result).toBe(0);result = calculate('=SUMIFS(A11:C11,A11:C11,"2",A11:C11,2)');- expect(result).toStrictEqual([- [2],- ]);+ expect(result).toBe(2);result = calculate('=SUMIF(A11:C11,"1",A11:C11)');expect(result).toBe(1);diff --git a/packages/engine-formula/src/functions/lookup/xlookup/index.ts b/packages/engine-formula/src/functions/lookup/xlookup/index.tsindex 7f31363c6c..9bebdb8eab 100644--- a/packages/engine-formula/src/functions/lookup/xlookup/index.ts+++ b/packages/engine-formula/src/functions/lookup/xlookup/index.ts@@ -20,6 +20,7 @@ import type { ArrayValueObject } from '../../../engine/value-object/array-value-import type { BaseValueObject } from '../../../engine/value-object/base-value-object';import { ErrorType } from '../../../basics/error-type';import { ArrayOrderSearchType, getMatchModeValue, getSearchModeValue } from '../../../engine/utils/compare';+import { baseValueObjectToArrayValueObject } from '../../../engine/utils/value-object';import { ErrorValueObject } from '../../../engine/value-object/base-value-object';import { NumberValueObject } from '../../../engine/value-object/primitive-object';import { BaseFunction } from '../../base-function';@@ -32,12 +33,12 @@ export class Xlookup extends BaseFunction {// eslint-disable-next-lineoverride calculate(lookupValue: BaseValueObject,- lookupArray: ArrayValueObject,- returnArray: ArrayValueObject,+ lookupArray: BaseValueObject,+ returnArray: BaseValueObject,ifNotFound?: BaseValueObject,matchMode?: BaseValueObject,searchMode?: BaseValueObject- ) {+ ): BaseValueObject {let _ifNotFound = ifNotFound ?? ErrorValueObject.create(ErrorType.NA);if (ifNotFound?.isNull()) {_ifNotFound = ErrorValueObject.create(ErrorType.NA);@@ -57,18 +58,10 @@ export class Xlookup extends BaseFunction {return lookupValue;}- if (lookupArray.isError() || returnArray.isError()) {- return ErrorValueObject.create(ErrorType.REF);- }-- if (!lookupArray.isArray() || !returnArray.isArray()) {- return ErrorValueObject.create(ErrorType.VALUE);- }-- const rowCountLookup = lookupArray.getRowCount();- const columnCountLookup = lookupArray.getColumnCount();- const rowCountReturn = returnArray.getRowCount();- const columnCountReturn = returnArray.getColumnCount();+ const rowCountLookup = lookupArray.isArray() ? (lookupArray as ArrayValueObject).getRowCount() : 1;+ const columnCountLookup = lookupArray.isArray() ? (lookupArray as ArrayValueObject).getColumnCount() : 1;+ const rowCountReturn = returnArray.isArray() ? (returnArray as ArrayValueObject).getRowCount() : 1;+ const columnCountReturn = returnArray.isArray() ? (returnArray as ArrayValueObject).getColumnCount() : 1;if ((rowCountLookup !== 1 && columnCountLookup !== 1) ||@@ -100,8 +93,8 @@ export class Xlookup extends BaseFunction {return this._getResult(lookupValue,- lookupArray,- returnArray,+ baseValueObjectToArrayValueObject(lookupArray),+ baseValueObjectToArrayValueObject(returnArray),_ifNotFound,matchModeValue,searchModeValue,diff --git a/packages/engine-formula/src/functions/lookup/xmatch/index.ts b/packages/engine-formula/src/functions/lookup/xmatch/index.tsindex 1e45c84b76..3b2b6742ff 100644--- a/packages/engine-formula/src/functions/lookup/xmatch/index.ts+++ b/packages/engine-formula/src/functions/lookup/xmatch/index.ts@@ -15,101 +15,129 @@*/import type { Nullable } from '@univerjs/core';-+import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';import { ErrorType } from '../../../basics/error-type';import { compareToken } from '../../../basics/token';+import { expandArrayValueObject } from '../../../engine/utils/array-object';import { ArrayOrderSearchType, getMatchModeValue, getSearchModeValue } from '../../../engine/utils/compare';+import { baseValueObjectToArrayValueObject } from '../../../engine/utils/value-object';import { ErrorValueObject } from '../../../engine/value-object/base-value-object';import { NumberValueObject } from '../../../engine/value-object/primitive-object';import { BaseFunction } from '../../base-function';-import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';-import type { BaseValueObject } from '../../../engine/value-object/base-value-object';export class Xmatch extends BaseFunction {override minParams = 2;override maxParams = 4;- override calculate(- lookupValue: BaseValueObject,- lookupArray: ArrayValueObject,- matchMode?: BaseValueObject,- searchMode?: BaseValueObject- ) {- if (lookupValue.isError()) {- return lookupValue;+ override calculate(lookupValue: BaseValueObject, lookupArray: BaseValueObject, matchMode?: BaseValueObject, searchMode?: BaseValueObject): BaseValueObject {+ let _matchMode: BaseValueObject = NumberValueObject.create(0);+ if (matchMode && !matchMode.isNull()) {+ _matchMode = matchMode;}- if (lookupArray.isError()) {- return ErrorValueObject.create(ErrorType.REF);+ let _searchMode: BaseValueObject = NumberValueObject.create(1);+ if (searchMode && !searchMode.isNull()) {+ _searchMode = searchMode;}- if (!lookupArray.isArray()) {- return ErrorValueObject.create(ErrorType.VALUE);+ const maxRowLength = Math.max(+ lookupValue.isArray() ? (lookupValue as ArrayValueObject).getRowCount() : 1,+ _matchMode.isArray() ? (_matchMode as ArrayValueObject).getRowCount() : 1,+ _searchMode.isArray() ? (_searchMode as ArrayValueObject).getRowCount() : 1+ );++ const maxColumnLength = Math.max(+ lookupValue.isArray() ? (lookupValue as ArrayValueObject).getColumnCount() : 1,+ _matchMode.isArray() ? (_matchMode as ArrayValueObject).getColumnCount() : 1,+ _searchMode.isArray() ? (_searchMode as ArrayValueObject).getColumnCount() : 1+ );++ const lookupValueArray = expandArrayValueObject(maxRowLength, maxColumnLength, lookupValue, ErrorValueObject.create(ErrorType.NA));+ const matchModeArray = expandArrayValueObject(maxRowLength, maxColumnLength, _matchMode, ErrorValueObject.create(ErrorType.NA));+ const searchModeArray = expandArrayValueObject(maxRowLength, maxColumnLength, _searchMode, ErrorValueObject.create(ErrorType.NA));++ const resultArray = lookupValueArray.mapValue((lookupValueObject, rowIndex, columnIndex) => {+ if (lookupValueObject.isError()) {+ return lookupValueObject;+ }++ const matchModeObject = matchModeArray.get(rowIndex, columnIndex) as BaseValueObject;+ const searchModeObject = searchModeArray.get(rowIndex, columnIndex) as BaseValueObject;++ if (matchModeObject.isError()) {+ return matchModeObject;+ }++ if (searchModeObject.isError()) {+ return searchModeObject;+ }++ return this._handleSingleObject(lookupValueObject, lookupArray, matchModeObject, searchModeObject);+ });++ if (maxRowLength === 1 && maxColumnLength === 1) {+ return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject;}- const rowCountLookup = lookupArray.getRowCount();+ return resultArray;+ }- const columnCountLookup = lookupArray.getColumnCount();+ private _handleSingleObject(lookupValue: BaseValueObject, lookupArray: BaseValueObject, matchMode: BaseValueObject, searchMode: BaseValueObject): BaseValueObject {+ const lookupArrayRowCount = lookupArray.isArray() ? (lookupArray as ArrayValueObject).getRowCount() : 1;+ const lookupArrayColumnCount = lookupArray.isArray() ? (lookupArray as ArrayValueObject).getColumnCount() : 1;- if (rowCountLookup !== 1 && columnCountLookup !== 1) {+ // Single row or single column+ if (lookupArrayRowCount !== 1 && lookupArrayColumnCount !== 1) {return ErrorValueObject.create(ErrorType.VALUE);}- if (matchMode?.isError()) {- return ErrorValueObject.create(ErrorType.NA);+ let _matchMode = matchMode;++ if (matchMode.isString() || matchMode.isBoolean() || matchMode.isNull()) {+ _matchMode = matchMode.convertToNumberObjectValue();}- if (searchMode?.isError()) {- return ErrorValueObject.create(ErrorType.NA);+ if (_matchMode.isError()) {+ return _matchMode;}- const matchModeValue = this.getIndexNumValue(matchMode || NumberValueObject.create(0));+ let _searchMode = searchMode;- if (matchModeValue instanceof ErrorValueObject) {- return matchModeValue;+ if (searchMode.isString() || searchMode.isBoolean() || searchMode.isNull()) {+ _searchMode = searchMode.convertToNumberObjectValue();}- const searchModeValue = this.getIndexNumValue(searchMode || NumberValueObject.create(1));-- if (searchModeValue instanceof ErrorValueObject) {- return searchModeValue;+ if (_searchMode.isError()) {+ return _searchMode;}- if (lookupValue.isArray()) {- return lookupValue.map((value) => this._handleSingleObject(- value,- lookupArray,- matchModeValue,- searchModeValue- ));+ const matchModeValue = (_matchMode as NumberValueObject).getValue();+ const searchModeValue = (_searchMode as NumberValueObject).getValue();++ if (![-1, 0, 1, 2].includes(matchModeValue) || ![-1, 1, 2].includes(searchModeValue)) {+ return ErrorValueObject.create(ErrorType.VALUE);}- return this._handleSingleObject(- lookupValue,- lookupArray,- matchModeValue,- searchModeValue- );+ return this._getResult(lookupValue, lookupArray, matchModeValue, searchModeValue);}- private _handleSingleObject(- value: BaseValueObject,- searchArray: ArrayValueObject,- matchModeValue: number,- searchModeValue: number- ) {+ private _getResult(lookupValue: BaseValueObject, lookupArray: BaseValueObject, matchMode: number, searchMode: number) {+ const _lookupArray = baseValueObjectToArrayValueObject(lookupArray);+let rowOrColumn: Nullable<number>;- if ((searchModeValue === 2 || searchModeValue === -2) && matchModeValue !== 2) {- const searchType = getSearchModeValue(searchModeValue);- const matchType = getMatchModeValue(matchModeValue);- rowOrColumn = searchArray.binarySearch(value, searchType, matchType);- } else if (matchModeValue === 2) {- const matchObject = searchArray.compare(value, compareToken.EQUALS) as ArrayValueObject;++ if ((searchMode === 2 || searchMode === -2) && matchMode !== 2) {+ const searchType = getSearchModeValue(searchMode);+ const matchType = getMatchModeValue(matchMode);+ rowOrColumn = _lookupArray.binarySearch(lookupValue, searchType, matchType);+ } else if (matchMode === 2) {+ const matchObject = _lookupArray.compare(lookupValue, compareToken.EQUALS) as ArrayValueObject;let position: Nullable<{ row: number; column: number }>;- if (searchModeValue !== -1) {+ if (searchMode !== -1) {position = matchObject.getFirstTruePosition();} else {position = matchObject.getLastTruePosition();@@ -118,9 +146,9 @@ export class Xmatch extends BaseFunction {return ErrorValueObject.create(ErrorType.NA);}- rowOrColumn = searchArray.getRowCount() === 1 ? position.column : position.row;- } else if (matchModeValue === -1 || matchModeValue === 1) {- const position = searchArray.orderSearch(value, matchModeValue === 1 ? ArrayOrderSearchType.MAX : ArrayOrderSearchType.MIN, searchModeValue === -1);+ rowOrColumn = _lookupArray.getRowCount() === 1 ? position.column : position.row;+ } else if (matchMode === -1 || matchMode === 1) {+ const position = _lookupArray.orderSearch(lookupValue, matchMode === 1 ? ArrayOrderSearchType.MAX : ArrayOrderSearchType.MIN, searchMode === -1);if (position == null) {return ErrorValueObject.create(ErrorType.NA);@@ -130,13 +158,13 @@ export class Xmatch extends BaseFunction {return position;}- rowOrColumn = searchArray.getRowCount() === 1 ? position.column : position.row;+ rowOrColumn = _lookupArray.getRowCount() === 1 ? position.column : position.row;} else {- const matchObject = searchArray.isEqual(value) as ArrayValueObject;+ const matchObject = _lookupArray.isEqual(lookupValue) as ArrayValueObject;let position: Nullable<{ row: number; column: number }>;- if (searchModeValue !== -1) {+ if (searchMode !== -1) {position = matchObject.getFirstTruePosition();} else {position = matchObject.getLastTruePosition();@@ -146,7 +174,7 @@ export class Xmatch extends BaseFunction {return ErrorValueObject.create(ErrorType.NA);}- rowOrColumn = searchArray.getRowCount() === 1 ? position.column : position.row;+ rowOrColumn = _lookupArray.getRowCount() === 1 ? position.column : position.row;}if (rowOrColumn == null) {diff --git a/packages/engine-formula/src/functions/math/sumif/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/sumif/__tests__/index.spec.tsindex bd60409f36..4392d0b031 100644--- a/packages/engine-formula/src/functions/math/sumif/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/math/sumif/__tests__/index.spec.ts@@ -16,7 +16,6 @@import type { Injector, IWorkbookData } from '@univerjs/core';import type { LexerNode } from '../../../../engine/analysis/lexer-node';-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';import { CellValueType, LocaleType } from '@univerjs/core';import { beforeEach, describe, expect, it } from 'vitest';@@ -244,18 +243,13 @@ describe('Test sumif function', () => {const error = ErrorValueObject.create(ErrorType.NAME);const result = await calculate(`=SUMIF(${error},A1:A4)`);- expect(result).toStrictEqual([- [ErrorType.NAME],- [ErrorType.NAME],- [ErrorType.NAME],- [ErrorType.NAME],- ]);+ expect(result).toBe(ErrorType.VALUE);const result2 = await calculate(`=SUMIF(A1:A4,${error})`);- expect(result2).toBe(ErrorType.NAME);+ expect(result2).toBe(0);const result3 = await calculate(`=SUMIF(A1:A4,">40",${error})`);- expect(result3).toBe(ErrorType.NAME);+ expect(result3).toBe(ErrorType.VALUE);});it('Range or sumRange is not referenceObject', async () => {diff --git a/packages/engine-formula/src/functions/math/sumif/index.ts b/packages/engine-formula/src/functions/math/sumif/index.tsindex 7200014259..fb6da9bec0 100644--- a/packages/engine-formula/src/functions/math/sumif/index.ts+++ b/packages/engine-formula/src/functions/math/sumif/index.ts@@ -31,6 +31,10 @@ export class Sumif extends BaseFunction {override needsReferenceObject = true;override calculate(range: FunctionVariantType, criteria: FunctionVariantType, sumRange?: FunctionVariantType): BaseValueObject {+ if (!range.isReferenceObject() || (sumRange && !sumRange.isReferenceObject())) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }+let _criteria = criteria;if (criteria.isReferenceObject()) {@@ -51,22 +55,6 @@ export class Sumif extends BaseFunction {}private _handleSingleObject(range: FunctionVariantType, criteria: BaseValueObject, sumRange?: FunctionVariantType): BaseValueObject {- if (range.isError()) {- return range as ErrorValueObject;- }-- if (criteria.isError()) {- return criteria;- }-- if (sumRange?.isError()) {- return sumRange as ErrorValueObject;- }-- if (!range.isReferenceObject() || (sumRange && !sumRange.isReferenceObject())) {- return ErrorValueObject.create(ErrorType.VALUE);- }-const _range = (range as BaseReferenceObject).toArrayValueObject();let resultArrayObject = valueObjectCompare(_range, criteria);diff --git a/packages/engine-formula/src/functions/math/sumifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/math/sumifs/__tests__/index.spec.tsindex 1e3621c187..cb6aad6872 100644--- a/packages/engine-formula/src/functions/math/sumifs/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/math/sumifs/__tests__/index.spec.ts@@ -14,181 +14,219 @@* limitations under the License.*/-import { describe, expect, it } from 'vitest';+import type { Injector, IWorkbookData } from '@univerjs/core';+import type { LexerNode } from '../../../../engine/analysis/lexer-node';+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';+import { CellValueType, LocaleType } from '@univerjs/core';+import { beforeEach, describe, expect, it } from 'vitest';import { ErrorType } from '../../../../basics/error-type';-import { ArrayValueObject, transformToValue } from '../../../../engine/value-object/array-value-object';-import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';+import { Lexer } from '../../../../engine/analysis/lexer';+import { AstTreeBuilder } from '../../../../engine/analysis/parser';+import { Interpreter } from '../../../../engine/interpreter/interpreter';+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';+import { IFunctionService } from '../../../../services/function.service';+import { IFormulaRuntimeService } from '../../../../services/runtime.service';+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_MATH } from '../../function-names';import { Sumifs } from '../index';-describe('Test sumifs function', () => {- const testFunction = new Sumifs(FUNCTION_NAMES_MATH.SUMIF);+const getTestWorkbookData = (): IWorkbookData => {+ return {+ id: 'test',+ appVersion: '3.0.0-alpha',+ sheets: {+ sheet1: {+ id: 'sheet1',+ cellData: {+ 0: {+ 0: {+ v: 1,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 2,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ },+ 1: {+ 0: {+ v: 2,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ },+ 2: {+ 0: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 6,+ t: CellValueType.NUMBER,+ },+ },+ 3: {+ 0: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 6,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 7,+ t: CellValueType.NUMBER,+ },+ },+ },+ },+ },+ locale: LocaleType.ZH_CN,+ name: '',+ sheetOrder: [],+ styles: {},+ };+};- describe('Sumifs', () => {- it('Range and criteria', async () => {- const sumRange = ArrayValueObject.create(/*ts*/ `{- 1;- 1;- 1- }`);- const range = ArrayValueObject.create(/*ts*/ `{- 2;- 3;- 4- }`);-- const criteria = StringValueObject.create('>2');-- const resultObject = testFunction.calculate(sumRange, range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);+describe('Test sumifs function', () => {+ let get: Injector['get'];+ let lexer: Lexer;+ let astTreeBuilder: AstTreeBuilder;+ let interpreter: Interpreter;+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;++ beforeEach(() => {+ const testBed = createFunctionTestBed(getTestWorkbookData());++ get = testBed.get;++ lexer = get(Lexer);+ astTreeBuilder = get(AstTreeBuilder);+ interpreter = get(Interpreter);++ const functionService = get(IFunctionService);++ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);++ const formulaRuntimeService = get(IFormulaRuntimeService);++ formulaCurrentConfigService.load({+ formulaData: {},+ arrayFormulaCellData: {},+ arrayFormulaRange: {},+ forceCalculate: false,+ dirtyRanges: [],+ dirtyNameMap: {},+ dirtyDefinedNameMap: {},+ dirtyUnitFeatureMap: {},+ dirtyUnitOtherFormulaMap: {},+ excludedCell: {},+ allUnitData: {+ [testBed.unitId]: testBed.sheetData,+ },});- it('Range and criteria, compare string', async () => {- const sumRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);- const range = ArrayValueObject.create(`{- a;- b;- c- }`);-- const criteria = StringValueObject.create('>2');- const resultObject = testFunction.calculate(sumRange, range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[0]]);- });+ const sheetItem = testBed.sheetData[testBed.sheetId];- it('Range and array criteria', async () => {- const sumRange = ArrayValueObject.create(/*ts*/ `{- 1;- 1;- 1- }`);- const range = ArrayValueObject.create(/*ts*/ `{- 2;- 3;- 4- }`);-- const criteria = ArrayValueObject.create(/*ts*/ `{- >2;- >3;- >4- }`);-- const resultObject = testFunction.calculate(sumRange, range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [1], [0]]);- });+ formulaRuntimeService.setCurrent(+ 0,+ 0,+ sheetItem.rowCount,+ sheetItem.columnCount,+ testBed.sheetId,+ testBed.unitId+ );- it('2 ranges and criteria', async () => {- const sumRange = ArrayValueObject.create(/*ts*/ `{- 1;- 1;- 1- }`);+ functionService.registerExecutors(+ new Sumifs(FUNCTION_NAMES_MATH.SUMIFS)+ );- const range1 = ArrayValueObject.create(/*ts*/ `{- 2;- 3;- 4- }`);+ calculate = (formula: string) => {+ const lexerNode = lexer.treeBuilder(formula);- const criteria1 = StringValueObject.create('>2');+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const range2 = ArrayValueObject.create(/*ts*/ `{- 3;- 4;- 5- }`);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));- const criteria2 = StringValueObject.create('<5');+ return getObjectValue(result);+ };+ });- const resultObject = testFunction.calculate(sumRange, range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1]]);+ describe('Sumifs', () => {+ it('Value is normal', async () => {+ const result = await calculate('=SUMIFS(A1:A4,B1:B4,">3")');+ expect(result).toBe(7);+ });++ it('Value is array', async () => {+ const result = await calculate('=SUMIFS({1;2;3;4},B1:B4,">3")');+ expect(result).toBe(ErrorType.VALUE);});- it('2 ranges and criteria, 1 array criteria', async () => {- const sumRange = ArrayValueObject.create(/*ts*/ `{- 1;- 1;- 1- }`);-- const range1 = ArrayValueObject.create(/*ts*/ `{- 2;- 3;- 4- }`);-- const criteria1 = ArrayValueObject.create(/*ts*/ `{- >2;- >3;- >4- }`);-- const range2 = ArrayValueObject.create(/*ts*/ `{- 3;- 4;- 5- }`);-- const criteria2 = NumberValueObject.create(5);-- const resultObject = testFunction.calculate(sumRange, range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1], [1], [0]]);+ it('Range and criteria is not paired', async () => {+ const result = await calculate('=SUMIFS(A1:A4,B1:B4,">3",C1:C4)');+ expect(result).toBe(ErrorType.VALUE);});- it('2 ranges and criteria, 2 array criteria', async () => {- const sumRange = ArrayValueObject.create(/*ts*/ `{- 1;- 1;- 1- }`);-- const range1 = ArrayValueObject.create(/*ts*/ `{- 2;- 3;- 4- }`);-- const criteria1 = ArrayValueObject.create(/*ts*/ `{- >2;- >3;- >4- }`);-- const range2 = ArrayValueObject.create(/*ts*/ `{- 3;- 4;- 5- }`);-- const criteria2 = ArrayValueObject.create(/*ts*/ `{- 4;- 4;- 4;- 4- }`);-- const resultObject = testFunction.calculate(sumRange, range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1], [0], [0], [0]]);+ it('Range is different size', async () => {+ const result = await calculate('=SUMIFS(A1:A4,B1:B4,">3",C1:C3,{"=5","=6"})');+ expect(result).toStrictEqual([+ [ErrorType.VALUE, ErrorType.VALUE],+ ]);});- it('Includes REF error', async () => {- const range = ErrorValueObject.create(ErrorType.REF);+ it('Range and array criteria', async () => {+ const result = await calculate('=SUMIFS(A1:A4,B1:B4,{">1";">2"})');+ expect(result).toStrictEqual([+ [10],+ [9],+ ]);+ });- const criteria = ArrayValueObject.create(/*ts*/ `{- 4;- 4;- 44;- 444- }`);+ it('Two ranges and criteria', async () => {+ const result = await calculate('=SUMIFS(A1:A4,B1:B4,">2",C1:C4,"=5")');+ expect(result).toBe(3);+ });- const resultObject = testFunction.calculate(range, criteria);- expect(resultObject.getValue()).toStrictEqual(ErrorType.REF);+ it('Two ranges and criteria, criteria is array', async () => {+ const result = await calculate('=SUMIFS(A1:A4,B1:B4,">2",C1:C4,{">4";">5"})');+ expect(result).toStrictEqual([+ [7],+ [4],+ ]);});});});diff --git a/packages/engine-formula/src/functions/math/sumifs/index.ts b/packages/engine-formula/src/functions/math/sumifs/index.tsindex fdcf8afaeb..4f7ec8ee5d 100644--- a/packages/engine-formula/src/functions/math/sumifs/index.ts+++ b/packages/engine-formula/src/functions/math/sumifs/index.ts@@ -14,9 +14,11 @@* limitations under the License.*/-import type { BaseValueObject, IArrayValueObject } from '../../../engine/value-object/base-value-object';+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';import { ErrorType } from '../../../basics/error-type';-import { calculateMaxDimensions, getBooleanResults, getErrorArray } from '../../../engine/utils/value-object';+import { expandArrayValueObject } from '../../../engine/utils/array-object';+import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';import { ArrayValueObject } from '../../../engine/value-object/array-value-object';import { ErrorValueObject } from '../../../engine/value-object/base-value-object';import { BaseFunction } from '../../base-function';@@ -26,55 +28,55 @@ export class Sumifs extends BaseFunction {override maxParams = 255;- override calculate(sumRange: BaseValueObject, ...variants: BaseValueObject[]) {- if (sumRange.isError()) {- return sumRange;- }+ override needsReferenceObject = true;- if (!sumRange.isArray()) {- return ErrorValueObject.create(ErrorType.VALUE);- }+ override calculate(sumRange: FunctionVariantType, ...variants: FunctionVariantType[]) {+ const {+ isError,+ errorObject,+ rangeIsDifferentSize,+ criteriaMaxRowLength,+ criteriaMaxColumnLength,+ targetRange: _sumRange,+ variants: _variants,+ } = parsePairedRangeAndCriteria(variants, sumRange);- // Range and criteria must be paired- if (variants.length < 2 || variants.length % 2 !== 0) {- return ErrorValueObject.create(ErrorType.VALUE);+ if (isError) {+ return errorObject as ErrorValueObject;}- // Every range must be array- if (variants.some((variant, i) => i % 2 === 0 && !variant.isArray())) {- return ErrorValueObject.create(ErrorType.VALUE);- }-- const { maxRowLength, maxColumnLength } = calculateMaxDimensions(variants);-- const errorArray = getErrorArray(variants, sumRange, maxRowLength, maxColumnLength);+ if (rangeIsDifferentSize) {+ if (criteriaMaxRowLength === 1 && criteriaMaxColumnLength === 1) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }- if (errorArray) {- return errorArray;+ return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));}- const booleanResults = getBooleanResults(variants, maxRowLength, maxColumnLength, true);+ const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);- return this._aggregateResults(sumRange, booleanResults);+ return this._aggregateResults(_sumRange as BaseValueObject, booleanResults);}- private _aggregateResults(sumRange: BaseValueObject, booleanResults: BaseValueObject[][]): ArrayValueObject {- const sumResults = booleanResults.map((row) => {+ private _aggregateResults(sumRange: BaseValueObject, booleanResults: BaseValueObject[][]): BaseValueObject {+ const results = booleanResults.map((row) => {return row.map((booleanResult) => {return (sumRange as ArrayValueObject).pick(booleanResult as ArrayValueObject).sum();});});- const arrayValueObjectData: IArrayValueObject = {- calculateValueList: sumResults,- rowCount: sumResults.length,- columnCount: sumResults[0].length,+ if (results.length === 1 && results[0].length === 1) {+ return results[0][0];+ }++ return ArrayValueObject.create({+ calculateValueList: results,+ rowCount: results.length,+ columnCount: results[0].length,unitId: this.unitId || '',sheetId: this.subUnitId || '',row: this.row,column: this.column,- };-- return ArrayValueObject.create(arrayValueObjectData);+ });}}diff --git a/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.tsindex 5b21676edb..aefa65f9c9 100644--- a/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/statistical/averageif/__tests__/index.spec.ts@@ -16,10 +16,7 @@import type { Injector, IWorkbookData } from '@univerjs/core';import type { LexerNode } from '../../../../engine/analysis/lexer-node';-import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';-import type { ArrayValueObject } from '../../../../engine/value-object/array-value-object';-import type { BaseValueObject, ErrorValueObject } from '../../../../engine/value-object/base-value-object';import { CellValueType, LocaleType } from '@univerjs/core';import { beforeEach, describe, expect, it } from 'vitest';import { ErrorType } from '../../../../basics/error-type';@@ -27,10 +24,11 @@ import { Lexer } from '../../../../engine/analysis/lexer';import { AstTreeBuilder } from '../../../../engine/analysis/parser';import { Interpreter } from '../../../../engine/interpreter/interpreter';import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';import { IFunctionService } from '../../../../services/function.service';import { IFormulaRuntimeService } from '../../../../services/runtime.service';-import { createFunctionTestBed } from '../../../__tests__/create-function-test-bed';+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_STATISTICAL } from '../../function-names';import { Averageif } from '../index';@@ -48,98 +46,86 @@ const getTestWorkbookData = (): IWorkbookData => {t: CellValueType.NUMBER,},1: {- v: 2,- t: CellValueType.NUMBER,- },- },- 1: {- 0: {- v: 3,- t: CellValueType.NUMBER,- },- 1: {- v: 4,- t: CellValueType.NUMBER,+ v: true,+ t: CellValueType.BOOLEAN,},2: {- v: 'B2',+ v: 'Ada',t: CellValueType.STRING,},3: {- v: 'R2C2',- t: CellValueType.STRING,+ v: 4,+ t: CellValueType.NUMBER,+ },+ 4: {+ v: 5,+ t: CellValueType.NUMBER,},},- 2: {+ 1: {0: {- v: 1,+ v: 4,t: CellValueType.NUMBER,},1: {- v: ' ',- t: CellValueType.STRING,+ v: false,+ t: CellValueType.BOOLEAN,},2: {- v: 1.23,- t: CellValueType.NUMBER,+ v: 'test1',+ t: CellValueType.STRING,},3: {- v: true,- t: CellValueType.BOOLEAN,+ v: 4,+ t: CellValueType.NUMBER,},4: {- v: false,- t: CellValueType.BOOLEAN,+ v: 4,+ t: CellValueType.NUMBER,},},- 3: {+ 2: {0: {- v: 0,+ v: 44,t: CellValueType.NUMBER,},1: {- v: '100',+ v: null,+ t: CellValueType.NUMBER,},2: {- v: '2.34',+ v: 'test12',+ t: CellValueType.STRING,},3: {- v: 'test',- t: CellValueType.STRING,+ v: 44,+ t: CellValueType.NUMBER,},4: {- v: -3,+ v: 44,t: CellValueType.NUMBER,},},- 4: {- 3: {- v: 'test1',- t: CellValueType.STRING,- },- },- 5: {+ 3: {0: {- v: 'Tom',- t: CellValueType.STRING,+ v: 444,+ t: CellValueType.NUMBER,},1: {- v: 'Sarah',- t: CellValueType.STRING,+ v: null,+ t: CellValueType.NUMBER,},- 3: {+ 2: {v: 'Univer',t: CellValueType.STRING,},- },- 6: {- 0: {- v: 'Alex',- t: CellValueType.STRING,+ 3: {+ v: 444,+ t: CellValueType.NUMBER,},- 1: {- v: 'Mickey',- t: CellValueType.STRING,+ 4: {+ v: 444,+ t: CellValueType.NUMBER,},},},@@ -151,7 +137,8 @@ const getTestWorkbookData = (): IWorkbookData => {styles: {},};};-describe('Test isref function', () => {++describe('Test averageif function', () => {let get: Injector['get'];let lexer: Lexer;let astTreeBuilder: AstTreeBuilder;@@ -182,11 +169,11 @@ describe('Test isref function', () => {dirtyNameMap: {},dirtyDefinedNameMap: {},dirtyUnitFeatureMap: {},+ dirtyUnitOtherFormulaMap: {},excludedCell: {},allUnitData: {[testBed.unitId]: testBed.sheetData,},- dirtyUnitOtherFormulaMap: {},});const sheetItem = testBed.sheetData[testBed.sheetId];@@ -211,68 +198,68 @@ describe('Test isref function', () => {const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));- if ((result as ErrorValueObject).isError()) {- return (result as ErrorValueObject).getValue();- } else if ((result as ArrayValueObject).isArray()) {- return (result as ArrayValueObject).toValue();- }- return (result as BaseValueObject).getValue();+ return getObjectValue(result);};});describe('Averageif', () => {it('Range and criteria', async () => {- const result = await calculate('=AVERAGEIF(A1:A4,">0")');-- expect(result).toBe(1.6666666666666667);+ const result = await calculate('=AVERAGEIF(A1:A4,">40")');+ expect(result).toBe(244);});- it('Range and criteria, compare number', async () => {- const result = await calculate('=AVERAGEIF(A6:A7,">1")');+ it('Range and criteria, different type', async () => {+ const result = await calculate('=AVERAGEIF(B1,">4",A1)');expect(result).toBe(ErrorType.DIV_BY_ZERO);});- it('Range number', async () => {- const result = await calculate('=AVERAGEIF(1,1)');-- expect(result).toBe(1);- });-- it('Range string', async () => {- const result = await calculate('=AVERAGEIF("test",">1")');-- expect(result).toBe(ErrorType.DIV_BY_ZERO);+ it('averageRange with wildcard asterisk', async () => {+ const result = await calculate('=AVERAGEIF(C1:C4,"test*",A1:A4)');+ expect(result).toBe(24);});- it('Range string, average range number', async () => {- const result = await calculate('=AVERAGEIF("test",1,1)');-- expect(result).toBe(ErrorType.NA);+ it('ArrayValueObject range and ArrayValueObject criteria', async () => {+ const result = await calculate('=AVERAGEIF(A1:A4,D1:D4)');+ expect(result).toStrictEqual([+ [4],+ [4],+ [44],+ [444],+ ]);++ const result2 = await calculate('=AVERAGEIF(A1:A4,E1:E4)');+ expect(result2).toStrictEqual([+ [ErrorType.DIV_BY_ZERO],+ [4],+ [44],+ [444],+ ]);++ const result3 = await calculate('=AVERAGEIF(A1:A4,A2)');+ expect(result3).toBe(4);});- it('Range blank cell', async () => {- const result = await calculate('=AVERAGEIF(A5,">1")');+ it('Includes error', async () => {+ const error = ErrorValueObject.create(ErrorType.NAME);- expect(result).toBe(ErrorType.DIV_BY_ZERO);- });+ const result = await calculate(`=AVERAGEIF(${error},A1:A4)`);+ expect(result).toBe(ErrorType.VALUE);- it('Average range with wildcard asterisk', async () => {- const result = await calculate('=AVERAGEIF(D4:D6,"test*",A1)');+ const result2 = await calculate(`=AVERAGEIF(A1:A4,${error})`);+ expect(result2).toBe(ErrorType.DIV_BY_ZERO);- expect(result).toBe(2);+ const result3 = await calculate(`=AVERAGEIF(A1:A4,">40",${error})`);+ expect(result3).toBe(ErrorType.VALUE);});- it('ArrayValueObject range and ArrayValueObject criteria', async () => {- const result = await calculate('=AVERAGEIF(A3:F4,A3:F4)');-- // [0][1] ErrorType.DIV_BY_ZERO refer to Google Sheets- expect(result).toStrictEqual([[1, ErrorType.DIV_BY_ZERO, 1.23, ErrorType.DIV_BY_ZERO, ErrorType.DIV_BY_ZERO, 0], [0, 100, 2.34, ErrorType.DIV_BY_ZERO, -3, 0]]);+ it('Range or averageRange is not referenceObject', async () => {+ const result = await calculate('=AVERAGEIF(1,"test*",A1:A4)');+ expect(result).toBe(ErrorType.VALUE);});- it('ArrayValueObject range and string criteria', async () => {- const result = await calculate('=AVERAGEIF(A3:F4," ")');-- expect(result).toBe(ErrorType.DIV_BY_ZERO);+ it('Range length is not equal to averageRange length', async () => {+ const result = await calculate('=AVERAGEIF(A1:A4,">40",E1:E2)');+ expect(result).toBe(244);});});});diff --git a/packages/engine-formula/src/functions/statistical/averageif/index.ts b/packages/engine-formula/src/functions/statistical/averageif/index.tsindex 47a9318d0b..274c63ccd9 100644--- a/packages/engine-formula/src/functions/statistical/averageif/index.ts+++ b/packages/engine-formula/src/functions/statistical/averageif/index.ts@@ -18,7 +18,6 @@ import type { BaseReferenceObject, FunctionVariantType } from '../../../engine/rimport type { ArrayValueObject } from '../../../engine/value-object/array-value-object';import type { BaseValueObject } from '../../../engine/value-object/base-value-object';import { ErrorType } from '../../../basics/error-type';-import { createNewArray } from '../../../engine/utils/array-object';import { valueObjectCompare } from '../../../engine/utils/object-compare';import { filterSameValueObjectResult } from '../../../engine/utils/value-object';import { ErrorValueObject } from '../../../engine/value-object/base-value-object';@@ -31,105 +30,66 @@ export class Averageif extends BaseFunction {override needsReferenceObject = true;- override calculate(range: FunctionVariantType, criteria: FunctionVariantType, averageRange?: FunctionVariantType) {- if (range.isError()) {- return range;+ override calculate(range: FunctionVariantType, criteria: FunctionVariantType, averageRange?: FunctionVariantType): BaseValueObject {+ if (!range.isReferenceObject() || (averageRange && !averageRange.isReferenceObject())) {+ return ErrorValueObject.create(ErrorType.VALUE);}- if (criteria.isError()) {- return criteria;- }+ let _criteria = criteria;- if (averageRange?.isError()) {- return averageRange;+ if (criteria.isReferenceObject()) {+ _criteria = (criteria as BaseReferenceObject).toArrayValueObject();}- let _range = range;+ if (_criteria.isArray()) {+ const resultArray = (_criteria as ArrayValueObject).mapValue((criteriaObject) => this._handleSingleObject(range, criteriaObject, averageRange));- if (_range.isReferenceObject()) {- _range = (_range as BaseReferenceObject).toArrayValueObject();- }+ if ((resultArray as ArrayValueObject).getRowCount() === 1 && (resultArray as ArrayValueObject).getColumnCount() === 1) {+ return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject;+ }- if (!_range.isArray()) {- _range = createNewArray([[_range as BaseValueObject]], 1, 1);+ return resultArray;}- let _criteria = criteria;-- if (_criteria.isReferenceObject()) {- _criteria = (_criteria as BaseReferenceObject).toArrayValueObject();- }+ return this._handleSingleObject(range, _criteria as BaseValueObject, averageRange);+ }- if (averageRange && !averageRange?.isReferenceObject()) {- return ErrorValueObject.create(ErrorType.NA);- }+ private _handleSingleObject(range: FunctionVariantType, criteria: BaseValueObject, averageRange?: FunctionVariantType): BaseValueObject {+ const _range = (range as BaseReferenceObject).toArrayValueObject();- _criteria = _criteria as BaseValueObject;+ let resultArrayObject = valueObjectCompare(_range, criteria);- if (_criteria.isArray()) {- return (_criteria as ArrayValueObject).map((criteriaItem) => this._handleSingleObject(_range as BaseValueObject, criteriaItem, averageRange as BaseReferenceObject));- }+ // When comparing non-numbers and numbers, it does not take the result+ resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, _range, criteria);- return this._handleSingleObject(_range as BaseValueObject, _criteria, averageRange as BaseReferenceObject);- }+ const rangeRowCount = _range.getRowCount();+ const rangeColumnCount = _range.getColumnCount();- private _handleSingleObject(range: BaseValueObject, criteria: BaseValueObject, averageRange?: BaseReferenceObject) {- let resultArrayObject = valueObjectCompare(range, criteria);+ let _averageRange = _range;- // When comparing non-numbers and numbers, it does not take the result- resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, range as ArrayValueObject, criteria);+ if (averageRange) {+ _averageRange = (averageRange as BaseReferenceObject).toArrayValueObject();- // averageRange has the same dimensions as range- let averageRangeArray = averageRange- ? this._createRangeReferenceObject(averageRange, range)- : (range as ArrayValueObject);+ const averageRangeRowCount = _averageRange.getRowCount();+ const averageRangeColumnCount = _averageRange.getColumnCount();- if (!averageRangeArray) {- return ErrorValueObject.create(ErrorType.VALUE);- }+ // averageRange has different dimensions than range, then adjust averageRange dimensions to match range dimensions+ // TODO: @DR-Univer The current situation is that the cell value in the extended range changes,+ // but it is not within the formula parameter range, so it will not trigger the formula to recalculate.+ if (rangeRowCount !== averageRangeRowCount || rangeColumnCount !== averageRangeColumnCount) {+ const rangeData = (averageRange as BaseReferenceObject).getRangeData();+ rangeData.endRow = rangeData.startRow + rangeRowCount - 1;+ rangeData.endColumn = rangeData.startColumn + rangeColumnCount - 1;- if (averageRangeArray.isError()) {- return averageRangeArray as ErrorValueObject;- }+ (averageRange as BaseReferenceObject).setRangeData(rangeData);- if (averageRangeArray.isReferenceObject()) {- averageRangeArray = (averageRangeArray as BaseReferenceObject).toArrayValueObject();+ _averageRange = (averageRange as BaseReferenceObject).toArrayValueObject();+ }}- averageRangeArray = averageRangeArray as ArrayValueObject;-- const picked = averageRangeArray.pick(resultArrayObject as ArrayValueObject);+ const picked = _averageRange.pick(resultArrayObject as ArrayValueObject);const sum = picked.sum();const count = picked.count();return sum.divided(count);}-- /**- * Create reference object, starting from the first cell in the upper left corner, the height is rowCount and the width is columnCount- * @param averageRange- * @param rowCount- * @param columnCount- * @returns- */- private _createRangeReferenceObject(averageRange: BaseReferenceObject, range: BaseValueObject) {- const averageRangeRow = averageRange.getRowCount();- const averageRangeColumn = averageRange.getColumnCount();-- const rowCount = range.isArray() ? (range as ArrayValueObject).getRowCount() : 1;- const columnCount = range.isArray() ? (range as ArrayValueObject).getColumnCount() : 1;-- if (averageRangeRow === rowCount && averageRangeColumn === columnCount) {- return averageRange;- }-- const { startRow, startColumn } = averageRange.getRangePosition();- const rangeData = {- startRow,- startColumn,- endRow: startRow + rowCount - 1,- endColumn: startColumn + columnCount - 1,- };-- return this.createReferenceObject(averageRange, rangeData);- }}diff --git a/packages/engine-formula/src/functions/statistical/averageifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/averageifs/__tests__/index.spec.tsindex dbc11d43c2..e768f7d526 100644--- a/packages/engine-formula/src/functions/statistical/averageifs/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/statistical/averageifs/__tests__/index.spec.ts@@ -14,166 +14,219 @@* limitations under the License.*/-import { describe, expect, it } from 'vitest';+import type { Injector, IWorkbookData } from '@univerjs/core';+import type { LexerNode } from '../../../../engine/analysis/lexer-node';+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';+import { CellValueType, LocaleType } from '@univerjs/core';+import { beforeEach, describe, expect, it } from 'vitest';+import { ErrorType } from '../../../../basics/error-type';+import { Lexer } from '../../../../engine/analysis/lexer';+import { AstTreeBuilder } from '../../../../engine/analysis/parser';+import { Interpreter } from '../../../../engine/interpreter/interpreter';+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';+import { IFunctionService } from '../../../../services/function.service';+import { IFormulaRuntimeService } from '../../../../services/runtime.service';+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_STATISTICAL } from '../../function-names';import { Averageifs } from '../index';-import { ArrayValueObject, transformToValue } from '../../../../engine/value-object/array-value-object';-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';-import { ErrorType } from '../../../../basics/error-type';-describe('Test averageifs function', () => {- const testFunction = new Averageifs(FUNCTION_NAMES_STATISTICAL.AVERAGEIFS);+const getTestWorkbookData = (): IWorkbookData => {+ return {+ id: 'test',+ appVersion: '3.0.0-alpha',+ sheets: {+ sheet1: {+ id: 'sheet1',+ cellData: {+ 0: {+ 0: {+ v: 1,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 2,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ },+ 1: {+ 0: {+ v: 2,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ },+ 2: {+ 0: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 6,+ t: CellValueType.NUMBER,+ },+ },+ 3: {+ 0: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 6,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 7,+ t: CellValueType.NUMBER,+ },+ },+ },+ },+ },+ locale: LocaleType.ZH_CN,+ name: '',+ sheetOrder: [],+ styles: {},+ };+};- describe('Averageifs', () => {- it('Range and criteria', async () => {- const averageRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);- const range = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria = StringValueObject.create('>2');- const resultObject = testFunction.calculate(averageRange, range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2.5]]);+describe('Test averageifs function', () => {+ let get: Injector['get'];+ let lexer: Lexer;+ let astTreeBuilder: AstTreeBuilder;+ let interpreter: Interpreter;+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;++ beforeEach(() => {+ const testBed = createFunctionTestBed(getTestWorkbookData());++ get = testBed.get;++ lexer = get(Lexer);+ astTreeBuilder = get(AstTreeBuilder);+ interpreter = get(Interpreter);++ const functionService = get(IFunctionService);++ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);++ const formulaRuntimeService = get(IFormulaRuntimeService);++ formulaCurrentConfigService.load({+ formulaData: {},+ arrayFormulaCellData: {},+ arrayFormulaRange: {},+ forceCalculate: false,+ dirtyRanges: [],+ dirtyNameMap: {},+ dirtyDefinedNameMap: {},+ dirtyUnitFeatureMap: {},+ dirtyUnitOtherFormulaMap: {},+ excludedCell: {},+ allUnitData: {+ [testBed.unitId]: testBed.sheetData,+ },});- it('Range and criteria, compare string', async () => {- const averageRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);- const range = ArrayValueObject.create(`{- a;- b;- c- }`);-- const criteria = StringValueObject.create('>2');- const resultObject = testFunction.calculate(averageRange, range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[ErrorType.DIV_BY_ZERO]]);- });+ const sheetItem = testBed.sheetData[testBed.sheetId];- it('Range and array criteria', async () => {- const averageRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);-- const range = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria = ArrayValueObject.create(`{- >2;- >3;- >4- }`);-- const resultObject = testFunction.calculate(averageRange, range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2.5], [3], [ErrorType.DIV_BY_ZERO]]);- });+ formulaRuntimeService.setCurrent(+ 0,+ 0,+ sheetItem.rowCount,+ sheetItem.columnCount,+ testBed.sheetId,+ testBed.unitId+ );- it('2 ranges and criteria', async () => {- const averageRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);+ functionService.registerExecutors(+ new Averageifs(FUNCTION_NAMES_STATISTICAL.AVERAGEIFS)+ );- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4- }`);+ calculate = (formula: string) => {+ const lexerNode = lexer.treeBuilder(formula);- const criteria1 = StringValueObject.create('>2');+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const range2 = ArrayValueObject.create(`{- 3;- 4;- 5- }`);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));- const criteria2 = StringValueObject.create('<5');+ return getObjectValue(result);+ };+ });- const resultObject = testFunction.calculate(averageRange, range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);+ describe('Averageifs', () => {+ it('Value is normal', async () => {+ const result = await calculate('=AVERAGEIFS(A1:A4,B1:B4,">3")');+ expect(result).toBe(3.5);+ });++ it('Value is array', async () => {+ const result = await calculate('=AVERAGEIFS({1;2;3;4},B1:B4,">3")');+ expect(result).toBe(ErrorType.VALUE);+ });++ it('Range and criteria is not paired', async () => {+ const result = await calculate('=AVERAGEIFS(A1:A4,B1:B4,">3",C1:C4)');+ expect(result).toBe(ErrorType.VALUE);+ });++ it('Range is different size', async () => {+ const result = await calculate('=AVERAGEIFS(A1:A4,B1:B4,">3",C1:C3,{"=5","=6"})');+ expect(result).toStrictEqual([+ [ErrorType.VALUE, ErrorType.VALUE],+ ]);+ });++ it('Range and array criteria', async () => {+ const result = await calculate('=AVERAGEIFS(A1:A4,B1:B4,{">1";">2"})');+ expect(result).toStrictEqual([+ [2.5],+ [3],+ ]);});- it('2 ranges and criteria, 1 array criteria', async () => {- const averageRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);-- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria1 = ArrayValueObject.create(`{- >2;- >3;- >4- }`);-- const range2 = ArrayValueObject.create(`{- 3;- 4;- 5- }`);-- const criteria2 = NumberValueObject.create(5);-- const resultObject = testFunction.calculate(averageRange, range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[3], [3], [ErrorType.DIV_BY_ZERO]]);+ it('Two ranges and criteria', async () => {+ const result = await calculate('=AVERAGEIFS(A1:A4,B1:B4,">2",C1:C4,"=5")');+ expect(result).toBe(3);});- it('2 ranges and criteria, 2 array criteria', async () => {- const averageRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);-- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria1 = ArrayValueObject.create(`{- >2;- >3;- >4- }`);-- const range2 = ArrayValueObject.create(`{- 3;- 4;- 5- }`);-- const criteria2 = ArrayValueObject.create(`{- 4;- 4;- 4;- 4- }`);-- const resultObject = testFunction.calculate(averageRange, range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [ErrorType.DIV_BY_ZERO], [ErrorType.DIV_BY_ZERO], [ErrorType.DIV_BY_ZERO]]);+ it('Two ranges and criteria, criteria is array', async () => {+ const result = await calculate('=AVERAGEIFS(A1:A4,B1:B4,">2",C1:C4,{">4";">5"})');+ expect(result).toStrictEqual([+ [3.5],+ [4],+ ]);});});});diff --git a/packages/engine-formula/src/functions/statistical/averageifs/index.ts b/packages/engine-formula/src/functions/statistical/averageifs/index.tsindex e8ce56b030..e78caed5dc 100644--- a/packages/engine-formula/src/functions/statistical/averageifs/index.ts+++ b/packages/engine-formula/src/functions/statistical/averageifs/index.ts@@ -14,10 +14,12 @@* limitations under the License.*/+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';import { ErrorType } from '../../../basics/error-type';-import { calculateMaxDimensions, getBooleanResults, getErrorArray } from '../../../engine/utils/value-object';+import { expandArrayValueObject } from '../../../engine/utils/array-object';+import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';import { ArrayValueObject } from '../../../engine/value-object/array-value-object';-import type { BaseValueObject, IArrayValueObject } from '../../../engine/value-object/base-value-object';import { ErrorValueObject } from '../../../engine/value-object/base-value-object';import { BaseFunction } from '../../base-function';@@ -26,40 +28,38 @@ export class Averageifs extends BaseFunction {override maxParams = 255;- override calculate(averageRange: BaseValueObject, ...variants: BaseValueObject[]) {- if (averageRange.isError()) {- return ErrorValueObject.create(ErrorType.NA);- }+ override needsReferenceObject = true;- if (!averageRange.isArray()) {- return ErrorValueObject.create(ErrorType.VALUE);- }+ override calculate(averageRange: FunctionVariantType, ...variants: FunctionVariantType[]): BaseValueObject {+ const {+ isError,+ errorObject,+ rangeIsDifferentSize,+ criteriaMaxRowLength,+ criteriaMaxColumnLength,+ targetRange: _averageRange,+ variants: _variants,+ } = parsePairedRangeAndCriteria(variants, averageRange);- // Range and criteria must be paired- if (variants.length % 2 !== 0) {- return ErrorValueObject.create(ErrorType.VALUE);+ if (isError) {+ return errorObject as ErrorValueObject;}- // Every range must be array- if (variants.some((variant, i) => i % 2 === 0 && !variant.isArray())) {- return ErrorValueObject.create(ErrorType.VALUE);- }-- const { maxRowLength, maxColumnLength } = calculateMaxDimensions(variants);-- const errorArray = getErrorArray(variants, averageRange, maxRowLength, maxColumnLength);+ if (rangeIsDifferentSize) {+ if (criteriaMaxRowLength === 1 && criteriaMaxColumnLength === 1) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }- if (errorArray) {- return errorArray;+ return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));}- const booleanResults = getBooleanResults(variants, maxRowLength, maxColumnLength, true);+ const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);- return this._aggregateResults(averageRange, booleanResults);+ return this._aggregateResults(_averageRange as BaseValueObject, booleanResults);}- private _aggregateResults(averageRange: BaseValueObject, booleanResults: BaseValueObject[][]): ArrayValueObject {- const maxResults = booleanResults.map((row) => {+ private _aggregateResults(averageRange: BaseValueObject, booleanResults: BaseValueObject[][]): BaseValueObject {+ const results = booleanResults.map((row) => {return row.map((booleanResult) => {const picked = (averageRange as ArrayValueObject).pick(booleanResult as ArrayValueObject);const sum = picked.sum();@@ -68,16 +68,18 @@ export class Averageifs extends BaseFunction {});});- const arrayValueObjectData: IArrayValueObject = {- calculateValueList: maxResults,- rowCount: maxResults.length,- columnCount: maxResults[0].length,+ if (results.length === 1 && results[0].length === 1) {+ return results[0][0];+ }++ return ArrayValueObject.create({+ calculateValueList: results,+ rowCount: results.length,+ columnCount: results[0].length,unitId: this.unitId || '',sheetId: this.subUnitId || '',row: this.row,column: this.column,- };-- return ArrayValueObject.create(arrayValueObjectData);+ });}}diff --git a/packages/engine-formula/src/functions/statistical/countif/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/countif/__tests__/index.spec.tsindex d64a26f81e..ebb508dd69 100644--- a/packages/engine-formula/src/functions/statistical/countif/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/statistical/countif/__tests__/index.spec.ts@@ -14,140 +14,229 @@* limitations under the License.*/-import { describe, expect, it } from 'vitest';+import type { Injector, IWorkbookData } from '@univerjs/core';+import type { LexerNode } from '../../../../engine/analysis/lexer-node';+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';+import { CellValueType, LocaleType } from '@univerjs/core';+import { beforeEach, describe, expect, it } from 'vitest';import { ErrorType } from '../../../../basics/error-type';-import { ArrayValueObject, transformToValue, transformToValueObject } from '../../../../engine/value-object/array-value-object';-import { StringValueObject } from '../../../../engine/value-object/primitive-object';+import { Lexer } from '../../../../engine/analysis/lexer';+import { AstTreeBuilder } from '../../../../engine/analysis/parser';+import { Interpreter } from '../../../../engine/interpreter/interpreter';+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';+import { ErrorValueObject } from '../../../../engine/value-object/base-value-object';+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';+import { IFunctionService } from '../../../../services/function.service';+import { IFormulaRuntimeService } from '../../../../services/runtime.service';+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_STATISTICAL } from '../../function-names';import { Countif } from '../index';-describe('Test countif function', () => {- const testFunction = new Countif(FUNCTION_NAMES_STATISTICAL.COUNTIF);+const getTestWorkbookData = (): IWorkbookData => {+ return {+ id: 'test',+ appVersion: '3.0.0-alpha',+ sheets: {+ sheet1: {+ id: 'sheet1',+ cellData: {+ 0: {+ 0: {+ v: 1,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: true,+ t: CellValueType.BOOLEAN,+ },+ 2: {+ v: 'Ada',+ t: CellValueType.STRING,+ },+ 3: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 4: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ },+ 1: {+ 0: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: false,+ t: CellValueType.BOOLEAN,+ },+ 2: {+ v: 'test1',+ t: CellValueType.STRING,+ },+ 3: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 4: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ },+ 2: {+ 0: {+ v: 44,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: null,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 'test12',+ t: CellValueType.STRING,+ },+ 3: {+ v: 44,+ t: CellValueType.NUMBER,+ },+ 4: {+ v: 44,+ t: CellValueType.NUMBER,+ },+ },+ 3: {+ 0: {+ v: 444,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: null,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 'Univer',+ t: CellValueType.STRING,+ },+ 3: {+ v: 444,+ t: CellValueType.NUMBER,+ },+ 4: {+ v: 444,+ t: CellValueType.NUMBER,+ },+ },+ },+ },+ },+ locale: LocaleType.ZH_CN,+ name: '',+ sheetOrder: [],+ styles: {},+ };+};- describe('Countif', () => {- it('Range and criteria', async () => {- const range = ArrayValueObject.create(/*ts*/ `{- 1;- 4;- 44;- 444;- Univer- }`);-- const criteria = StringValueObject.create('>40');-- const resultObject = testFunction.calculate(range, criteria);- expect(resultObject.getValue()).toBe(2);+describe('Test countif function', () => {+ let get: Injector['get'];+ let lexer: Lexer;+ let astTreeBuilder: AstTreeBuilder;+ let interpreter: Interpreter;+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;++ beforeEach(() => {+ const testBed = createFunctionTestBed(getTestWorkbookData());++ get = testBed.get;++ lexer = get(Lexer);+ astTreeBuilder = get(AstTreeBuilder);+ interpreter = get(Interpreter);++ const functionService = get(IFunctionService);++ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);++ const formulaRuntimeService = get(IFormulaRuntimeService);++ formulaCurrentConfigService.load({+ formulaData: {},+ arrayFormulaCellData: {},+ arrayFormulaRange: {},+ forceCalculate: false,+ dirtyRanges: [],+ dirtyNameMap: {},+ dirtyDefinedNameMap: {},+ dirtyUnitFeatureMap: {},+ dirtyUnitOtherFormulaMap: {},+ excludedCell: {},+ allUnitData: {+ [testBed.unitId]: testBed.sheetData,+ },});- it('Average range with wildcard asterisk', async () => {- const range = ArrayValueObject.create(/*ts*/ `{- Ada;- test1;- test12;- Univer- }`);+ const sheetItem = testBed.sheetData[testBed.sheetId];- const criteria = StringValueObject.create('test*');+ formulaRuntimeService.setCurrent(+ 0,+ 0,+ sheetItem.rowCount,+ sheetItem.columnCount,+ testBed.sheetId,+ testBed.unitId+ );- const resultObject = testFunction.calculate(range, criteria);- expect(resultObject.getValue()).toBe(2);- });+ functionService.registerExecutors(+ new Countif(FUNCTION_NAMES_STATISTICAL.COUNTIF)+ );- it('Average range with boolean', async () => {- const range = ArrayValueObject.create(/*ts*/ `{- TRUE;- FALSE- }`);+ calculate = (formula: string) => {+ const lexerNode = lexer.treeBuilder(formula);- const criteria = StringValueObject.create('>FALSE');+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const resultObject = testFunction.calculate(range, criteria);- expect(resultObject.getValue()).toBe(1);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));++ return getObjectValue(result);+ };+ });++ describe('Countif', () => {+ it('Range and criteria', async () => {+ const result = await calculate('=COUNTIF(A1:A4,">40")');+ expect(result).toBe(2);});it('ArrayValueObject range and ArrayValueObject criteria', async () => {- const range = ArrayValueObject.create(/*ts*/ `{- 1;- 4;- 44;- 444- }`);-- const criteria = ArrayValueObject.create(/*ts*/ `{- 4;- 4;- 44;- 444- }`);-- const resultObject = testFunction.calculate(range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1], [1], [1], [1]]);- });+ const result = await calculate('=COUNTIF(A1:A4,D1:D4)');+ expect(result).toStrictEqual([+ [1],+ [1],+ [1],+ [1],+ ]);++ const result2 = await calculate('=COUNTIF(A1:A4,E1:E4)');+ expect(result2).toStrictEqual([+ [0],+ [1],+ [1],+ [1],+ ]);- it('ArrayValueObject range and ArrayValueObject criteria multi type cell', async () => {- const range = ArrayValueObject.create({- calculateValueList: transformToValueObject([- [1, ' ', 1.23, true, false, null],- [0, '100', '2.34', 'test', -3, ErrorType.NAME],- ]),- rowCount: 2,- columnCount: 6,- unitId: '',- sheetId: '',- row: 0,- column: 0,- });-- const criteria = ArrayValueObject.create({- calculateValueList: transformToValueObject([- ['>1', '> ', '>1.23', '>true', '>false', '>'],- ['>0', '>100', '>2.34', '>test', '>-3', ErrorType.NAME],- ]),- rowCount: 2,- columnCount: 6,- unitId: '',- sheetId: '',- row: 0,- column: 0,- });-- const resultObject = testFunction.calculate(range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[3, 1, 2, 0, 1, 0], [4, 0, 1, 0, 5, 1]]);+ const result3 = await calculate('=COUNTIF(A1:A4,A2)');+ expect(result3).toBe(1);});- it('ArrayValueObject range equals ArrayValueObject criteria multi types cell', async () => {- const range = ArrayValueObject.create({- calculateValueList: transformToValueObject([- [1, ' ', 1.23, true, false, null],- [0, '100', '2.34', 'test', -3, ErrorType.NAME],- ]),- rowCount: 2,- columnCount: 6,- unitId: '',- sheetId: '',- row: 0,- column: 0,- });-- const criteria = ArrayValueObject.create({- calculateValueList: transformToValueObject([- ['=1', '= ', '=1.23', '=true', '=false', '=0'],- ['=0', '=100', '=2.34', '=test', '=-3', ErrorType.NAME],- ]),- rowCount: 2,- columnCount: 6,- unitId: '',- sheetId: '',- row: 0,- column: 0,- });-- const resultObject = testFunction.calculate(range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([- [1, 1, 1, 1, 1, 1],- [1, 1, 1, 1, 1, 1],- ]);+ it('Includes error', async () => {+ const error = ErrorValueObject.create(ErrorType.NAME);++ const result = await calculate(`=COUNTIF(${error},A1:A4)`);+ expect(result).toBe(ErrorType.VALUE);++ const result2 = await calculate(`=COUNTIF(A1:A4,${error})`);+ expect(result2).toBe(0);});});});diff --git a/packages/engine-formula/src/functions/statistical/countif/index.ts b/packages/engine-formula/src/functions/statistical/countif/index.tsindex b9809f478d..ba1a44dfd7 100644--- a/packages/engine-formula/src/functions/statistical/countif/index.ts+++ b/packages/engine-formula/src/functions/statistical/countif/index.ts@@ -14,6 +14,7 @@* limitations under the License.*/+import type { BaseReferenceObject, FunctionVariantType } from '../../../engine/reference-object/base-reference-object';import type { ArrayValueObject } from '../../../engine/value-object/array-value-object';import type { BaseValueObject } from '../../../engine/value-object/base-value-object';import { ErrorType } from '../../../basics/error-type';@@ -28,29 +29,41 @@ export class Countif extends BaseFunction {override maxParams = 2;- override calculate(range: BaseValueObject, criteria: BaseValueObject) {- if (range.isError() || criteria.isError()) {- return ErrorValueObject.create(ErrorType.NA);- }+ override needsReferenceObject = true;- if (!range.isArray()) {+ override calculate(range: FunctionVariantType, criteria: FunctionVariantType): BaseValueObject {+ if (!range.isReferenceObject()) {return ErrorValueObject.create(ErrorType.VALUE);}- if (criteria.isArray()) {- return criteria.mapValue((criteriaItem) => this._handleSingleObject(range, criteriaItem));+ let _criteria = criteria;++ if (criteria.isReferenceObject()) {+ _criteria = (criteria as BaseReferenceObject).toArrayValueObject();+ }++ if (_criteria.isArray()) {+ const resultArray = (_criteria as ArrayValueObject).mapValue((criteriaObject) => this._handleSingleObject(range, criteriaObject));++ if ((resultArray as ArrayValueObject).getRowCount() === 1 && (resultArray as ArrayValueObject).getColumnCount() === 1) {+ return (resultArray as ArrayValueObject).get(0, 0) as BaseValueObject;+ }++ return resultArray;}- return this._handleSingleObject(range, criteria);+ return this._handleSingleObject(range, _criteria as BaseValueObject);}- private _handleSingleObject(range: BaseValueObject, criteria: BaseValueObject) {- let resultArrayObject = valueObjectCompare(range, criteria);+ private _handleSingleObject(range: FunctionVariantType, criteria: BaseValueObject): BaseValueObject {+ const _range = (range as BaseReferenceObject).toArrayValueObject();++ let resultArrayObject = valueObjectCompare(_range, criteria);// If the condition is a numeric comparison, only numbers are counted, otherwise text is counted.- resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, range as ArrayValueObject, criteria);+ resultArrayObject = filterSameValueObjectResult(resultArrayObject as ArrayValueObject, _range, criteria);- const picked = (range as ArrayValueObject).pick(resultArrayObject as ArrayValueObject);+ const picked = (_range as ArrayValueObject).pick(resultArrayObject as ArrayValueObject);return this._countA(picked);}diff --git a/packages/engine-formula/src/functions/statistical/countifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/countifs/__tests__/index.spec.tsindex fa6667b6dc..4f2110dc09 100644--- a/packages/engine-formula/src/functions/statistical/countifs/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/statistical/countifs/__tests__/index.spec.ts@@ -14,227 +14,219 @@* limitations under the License.*/-import { describe, expect, it } from 'vitest';+import type { Injector, IWorkbookData } from '@univerjs/core';+import type { LexerNode } from '../../../../engine/analysis/lexer-node';+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';+import { CellValueType, LocaleType } from '@univerjs/core';+import { beforeEach, describe, expect, it } from 'vitest';import { ErrorType } from '../../../../basics/error-type';-import { ArrayValueObject, transformToValue } from '../../../../engine/value-object/array-value-object';-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';+import { Lexer } from '../../../../engine/analysis/lexer';+import { AstTreeBuilder } from '../../../../engine/analysis/parser';+import { Interpreter } from '../../../../engine/interpreter/interpreter';+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';+import { IFunctionService } from '../../../../services/function.service';+import { IFormulaRuntimeService } from '../../../../services/runtime.service';+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_STATISTICAL } from '../../function-names';import { Countifs } from '../index';-describe('Test countifs function', () => {- const testFunction = new Countifs(FUNCTION_NAMES_STATISTICAL.COUNTIFS);+const getTestWorkbookData = (): IWorkbookData => {+ return {+ id: 'test',+ appVersion: '3.0.0-alpha',+ sheets: {+ sheet1: {+ id: 'sheet1',+ cellData: {+ 0: {+ 0: {+ v: 1,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 2,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ },+ 1: {+ 0: {+ v: 2,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ },+ 2: {+ 0: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 6,+ t: CellValueType.NUMBER,+ },+ },+ 3: {+ 0: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 6,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 7,+ t: CellValueType.NUMBER,+ },+ },+ },+ },+ },+ locale: LocaleType.ZH_CN,+ name: '',+ sheetOrder: [],+ styles: {},+ };+};- describe('Countifs', () => {- it('Array criteria with number and string', async () => {- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4;- test1;- test12- }`);-- const criteria1 = ArrayValueObject.create(`{- >2;- >3;- >4;- test*- }`);-- const resultObject = testFunction.calculate(range1, criteria1);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [1], [0], [2]]);+describe('Test countifs function', () => {+ let get: Injector['get'];+ let lexer: Lexer;+ let astTreeBuilder: AstTreeBuilder;+ let interpreter: Interpreter;+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;++ beforeEach(() => {+ const testBed = createFunctionTestBed(getTestWorkbookData());++ get = testBed.get;++ lexer = get(Lexer);+ astTreeBuilder = get(AstTreeBuilder);+ interpreter = get(Interpreter);++ const functionService = get(IFunctionService);++ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);++ const formulaRuntimeService = get(IFormulaRuntimeService);++ formulaCurrentConfigService.load({+ formulaData: {},+ arrayFormulaCellData: {},+ arrayFormulaRange: {},+ forceCalculate: false,+ dirtyRanges: [],+ dirtyNameMap: {},+ dirtyDefinedNameMap: {},+ dirtyUnitFeatureMap: {},+ dirtyUnitOtherFormulaMap: {},+ excludedCell: {},+ allUnitData: {+ [testBed.unitId]: testBed.sheetData,+ },});- it('Range and criteria, compare string', async () => {- const range = ArrayValueObject.create(`{- a;- b;- c- }`);+ const sheetItem = testBed.sheetData[testBed.sheetId];- const criteria = StringValueObject.create('>2');- const resultObject = testFunction.calculate(range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[0]]);- });+ formulaRuntimeService.setCurrent(+ 0,+ 0,+ sheetItem.rowCount,+ sheetItem.columnCount,+ testBed.sheetId,+ testBed.unitId+ );- it('Different ranges, error reporting', async () => {- const range1 = ArrayValueObject.create(`{- 1;- 2;- 3- }`);-- const criteria1 = StringValueObject.create('>2');-- const rang2 = ArrayValueObject.create(`{- 2;- 3;- 4;- 5- }`);-- const criteria2 = StringValueObject.create('>3');- const resultObject = testFunction.calculate(range1, criteria1, rang2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[ErrorType.VALUE]]);- });+ functionService.registerExecutors(+ new Countifs(FUNCTION_NAMES_STATISTICAL.COUNTIFS)+ );- it('Range and criteria, count number', async () => {- const range = ArrayValueObject.create(`{- 2;- 3;- 4;- Univer- }`);-- const criteria = StringValueObject.create('>2');- const resultObject = testFunction.calculate(range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);- });+ calculate = (formula: string) => {+ const lexerNode = lexer.treeBuilder(formula);- it('Range and array criteria', async () => {- const range = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria = ArrayValueObject.create(`{- >2;- >3;- >4;- >5- }`);-- const resultObject = testFunction.calculate(range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [1], [0], [0]]);- });+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- it('2 ranges and criteria', async () => {- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4- }`);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));- const criteria1 = StringValueObject.create('>2');+ return getObjectValue(result);+ };+ });- const range2 = ArrayValueObject.create(`{- 3;- 4;- 5- }`);+ describe('Countifs', () => {+ it('Value is normal', async () => {+ const result = await calculate('=COUNTIFS(A1:A4,">3")');+ expect(result).toBe(1);+ });- const criteria2 = StringValueObject.create('<5');+ it('Value is array', async () => {+ const result = await calculate('=COUNTIFS({1;2;3;4},">3")');+ expect(result).toBe(ErrorType.VALUE);+ });- const resultObject = testFunction.calculate(range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1]]);+ it('Range and criteria is not paired', async () => {+ const result = await calculate('=COUNTIFS(A1:A4,">3",C1:C4)');+ expect(result).toBe(ErrorType.VALUE);});- it('2 ranges and criteria, 1 array criteria with number', async () => {- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria1 = ArrayValueObject.create(`{- >2;- >3;- >4- }`);-- const range2 = ArrayValueObject.create(`{- 3;- 4;- 5- }`);-- const criteria2 = NumberValueObject.create(5);-- const resultObject = testFunction.calculate(range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1], [1], [0]]);+ it('Range is different size', async () => {+ const result = await calculate('=COUNTIFS(A1:A4,">3",C1:C3,{"=5","=6"})');+ expect(result).toStrictEqual([+ [ErrorType.VALUE, ErrorType.VALUE],+ ]);});- it('2 ranges and criteria, 1 array criteria with string', async () => {- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria1 = ArrayValueObject.create(`{- >2;- >3;- >4- }`);-- const range2 = ArrayValueObject.create(`{- test1;- test12;- Univer123- }`);-- const criteria2 = StringValueObject.create('test*');-- const resultObject = testFunction.calculate(range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1], [0], [0]]);+ it('Range and array criteria', async () => {+ const result = await calculate('=COUNTIFS(A1:A4,{">1";">2"})');+ expect(result).toStrictEqual([+ [3],+ [2],+ ]);});- it('2 ranges and criteria, 2 array criteria', async () => {- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria1 = ArrayValueObject.create(`{- >2;- >3;- >4- }`);-- const range2 = ArrayValueObject.create(`{- 3;- 4;- 5- }`);-- const criteria2 = ArrayValueObject.create(`{- 4;- 4;- 4;- 4- }`);-- const resultObject = testFunction.calculate(range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[1], [0], [0], [0]]);+ it('Two ranges and criteria', async () => {+ const result = await calculate('=COUNTIFS(A1:A4,">2",C1:C4,"=5")');+ expect(result).toBe(1);});- it('2 ranges and criteria, 2 array criteria, compare string', async () => {- const range1 = ArrayValueObject.create(`{- 1;- 2;- 3;- 4;- 5;- 6- }`);-- const criteria1 = StringValueObject.create('<5');-- const range2 = ArrayValueObject.create(`{- 40664;- 40665;- 40666;- 40667;- 40668;- 40669- }`);-- const criteria2 = StringValueObject.create('<5/3/2011');-- const resultObject = testFunction.calculate(range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);+ it('Two ranges and criteria, criteria is array', async () => {+ const result = await calculate('=COUNTIFS(A1:A4,">2",C1:C4,{">4";">5"})');+ expect(result).toStrictEqual([+ [2],+ [1],+ ]);});});});diff --git a/packages/engine-formula/src/functions/statistical/countifs/index.ts b/packages/engine-formula/src/functions/statistical/countifs/index.tsindex a9981e35e5..0fbe9bc955 100644--- a/packages/engine-formula/src/functions/statistical/countifs/index.ts+++ b/packages/engine-formula/src/functions/statistical/countifs/index.ts@@ -14,10 +14,12 @@* limitations under the License.*/+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';import { ErrorType } from '../../../basics/error-type';-import { calculateMaxDimensions, getBooleanResults, getErrorArray } from '../../../engine/utils/value-object';+import { expandArrayValueObject } from '../../../engine/utils/array-object';+import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';import { ArrayValueObject } from '../../../engine/value-object/array-value-object';-import type { BaseValueObject, IArrayValueObject } from '../../../engine/value-object/base-value-object';import { ErrorValueObject } from '../../../engine/value-object/base-value-object';import { NumberValueObject } from '../../../engine/value-object/primitive-object';import { BaseFunction } from '../../base-function';@@ -27,48 +29,55 @@ export class Countifs extends BaseFunction {override maxParams = 255;- override calculate(...variants: BaseValueObject[]) {- // Range and criteria must be paired- if (variants.length % 2 !== 0) {- return ErrorValueObject.create(ErrorType.VALUE);- }+ override needsReferenceObject = true;- // Every range must be array- if (variants.some((variant, i) => i % 2 === 0 && !variant.isArray())) {- return ErrorValueObject.create(ErrorType.VALUE);- }+ override calculate(...variants: FunctionVariantType[]): BaseValueObject {+ const {+ isError,+ errorObject,+ rangeIsDifferentSize,+ criteriaMaxRowLength,+ criteriaMaxColumnLength,+ variants: _variants,+ } = parsePairedRangeAndCriteria(variants);- const { maxRowLength, maxColumnLength } = calculateMaxDimensions(variants);+ if (isError) {+ return errorObject as ErrorValueObject;+ }- const errorArray = getErrorArray(variants, variants[0], maxRowLength, maxColumnLength);+ if (rangeIsDifferentSize) {+ if (criteriaMaxRowLength === 1 && criteriaMaxColumnLength === 1) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }- if (errorArray) {- return errorArray;+ return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));}- const booleanResults = getBooleanResults(variants, maxRowLength, maxColumnLength, true);+ const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);return this._aggregateResults(booleanResults);}- private _aggregateResults(booleanResults: BaseValueObject[][]): ArrayValueObject {- const maxResults = booleanResults.map((row) => {+ private _aggregateResults(booleanResults: BaseValueObject[][]): BaseValueObject {+ const results = booleanResults.map((row) => {return row.map((booleanResult) => {return countTrueValue(booleanResult as ArrayValueObject);});});- const arrayValueObjectData: IArrayValueObject = {- calculateValueList: maxResults,- rowCount: maxResults.length,- columnCount: maxResults[0].length,+ if (results.length === 1 && results[0].length === 1) {+ return results[0][0];+ }++ return ArrayValueObject.create({+ calculateValueList: results,+ rowCount: results.length,+ columnCount: results[0].length,unitId: this.unitId || '',sheetId: this.subUnitId || '',row: this.row,column: this.column,- };-- return ArrayValueObject.create(arrayValueObjectData);+ });}}diff --git a/packages/engine-formula/src/functions/statistical/maxifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/maxifs/__tests__/index.spec.tsindex 940d277ab7..209b91fe84 100644--- a/packages/engine-formula/src/functions/statistical/maxifs/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/statistical/maxifs/__tests__/index.spec.ts@@ -14,165 +14,219 @@* limitations under the License.*/-import { describe, expect, it } from 'vitest';+import type { Injector, IWorkbookData } from '@univerjs/core';+import type { LexerNode } from '../../../../engine/analysis/lexer-node';+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';+import { CellValueType, LocaleType } from '@univerjs/core';+import { beforeEach, describe, expect, it } from 'vitest';+import { ErrorType } from '../../../../basics/error-type';+import { Lexer } from '../../../../engine/analysis/lexer';+import { AstTreeBuilder } from '../../../../engine/analysis/parser';+import { Interpreter } from '../../../../engine/interpreter/interpreter';+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';+import { IFunctionService } from '../../../../services/function.service';+import { IFormulaRuntimeService } from '../../../../services/runtime.service';+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_STATISTICAL } from '../../function-names';import { Maxifs } from '../index';-import { ArrayValueObject, transformToValue } from '../../../../engine/value-object/array-value-object';-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';-describe('Test maxifs function', () => {- const testFunction = new Maxifs(FUNCTION_NAMES_STATISTICAL.MAXIFS);+const getTestWorkbookData = (): IWorkbookData => {+ return {+ id: 'test',+ appVersion: '3.0.0-alpha',+ sheets: {+ sheet1: {+ id: 'sheet1',+ cellData: {+ 0: {+ 0: {+ v: 1,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 2,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ },+ 1: {+ 0: {+ v: 2,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ },+ 2: {+ 0: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 6,+ t: CellValueType.NUMBER,+ },+ },+ 3: {+ 0: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 6,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 7,+ t: CellValueType.NUMBER,+ },+ },+ },+ },+ },+ locale: LocaleType.ZH_CN,+ name: '',+ sheetOrder: [],+ styles: {},+ };+};- describe('Maxifs', () => {- it('Range and criteria', async () => {- const maxRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);- const range = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria = StringValueObject.create('>2');- const resultObject = testFunction.calculate(maxRange, range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[3]]);+describe('Test maxifs function', () => {+ let get: Injector['get'];+ let lexer: Lexer;+ let astTreeBuilder: AstTreeBuilder;+ let interpreter: Interpreter;+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;++ beforeEach(() => {+ const testBed = createFunctionTestBed(getTestWorkbookData());++ get = testBed.get;++ lexer = get(Lexer);+ astTreeBuilder = get(AstTreeBuilder);+ interpreter = get(Interpreter);++ const functionService = get(IFunctionService);++ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);++ const formulaRuntimeService = get(IFormulaRuntimeService);++ formulaCurrentConfigService.load({+ formulaData: {},+ arrayFormulaCellData: {},+ arrayFormulaRange: {},+ forceCalculate: false,+ dirtyRanges: [],+ dirtyNameMap: {},+ dirtyDefinedNameMap: {},+ dirtyUnitFeatureMap: {},+ dirtyUnitOtherFormulaMap: {},+ excludedCell: {},+ allUnitData: {+ [testBed.unitId]: testBed.sheetData,+ },});- it('Range and criteria, compare string', async () => {- const maxRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);- const range = ArrayValueObject.create(`{- a;- b;- c- }`);-- const criteria = StringValueObject.create('>2');- const resultObject = testFunction.calculate(maxRange, range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[0]]);- });+ const sheetItem = testBed.sheetData[testBed.sheetId];- it('Range and array criteria', async () => {- const maxRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);-- const range = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria = ArrayValueObject.create(`{- >2;- >3;- >4- }`);-- const resultObject = testFunction.calculate(maxRange, range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[3], [3], [0]]);- });+ formulaRuntimeService.setCurrent(+ 0,+ 0,+ sheetItem.rowCount,+ sheetItem.columnCount,+ testBed.sheetId,+ testBed.unitId+ );- it('2 ranges and criteria', async () => {- const maxRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);+ functionService.registerExecutors(+ new Maxifs(FUNCTION_NAMES_STATISTICAL.MAXIFS)+ );- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4- }`);+ calculate = (formula: string) => {+ const lexerNode = lexer.treeBuilder(formula);- const criteria1 = StringValueObject.create('>2');+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const range2 = ArrayValueObject.create(`{- 3;- 4;- 5- }`);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));- const criteria2 = StringValueObject.create('<5');+ return getObjectValue(result);+ };+ });- const resultObject = testFunction.calculate(maxRange, range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);+ describe('Maxifs', () => {+ it('Value is normal', async () => {+ const result = await calculate('=MAXIFS(A1:A4,B1:B4,">3")');+ expect(result).toBe(4);+ });++ it('Value is array', async () => {+ const result = await calculate('=MAXIFS({1;2;3;4},B1:B4,">3")');+ expect(result).toBe(ErrorType.VALUE);+ });++ it('Range and criteria is not paired', async () => {+ const result = await calculate('=MAXIFS(A1:A4,B1:B4,">3",C1:C4)');+ expect(result).toBe(ErrorType.VALUE);+ });++ it('Range is different size', async () => {+ const result = await calculate('=MAXIFS(A1:A4,B1:B4,">3",C1:C3,{"=5","=6"})');+ expect(result).toStrictEqual([+ [ErrorType.VALUE, ErrorType.VALUE],+ ]);+ });++ it('Range and array criteria', async () => {+ const result = await calculate('=MAXIFS(A1:A4,B1:B4,{">1";">2"})');+ expect(result).toStrictEqual([+ [4],+ [4],+ ]);});- it('2 ranges and criteria, 1 array criteria', async () => {- const maxRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);-- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria1 = ArrayValueObject.create(`{- >2;- >3;- >4- }`);-- const range2 = ArrayValueObject.create(`{- 3;- 4;- 5- }`);-- const criteria2 = NumberValueObject.create(5);-- const resultObject = testFunction.calculate(maxRange, range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[3], [3], [0]]);+ it('Two ranges and criteria', async () => {+ const result = await calculate('=MAXIFS(A1:A4,B1:B4,">2",C1:C4,"=5")');+ expect(result).toBe(3);});- it('2 ranges and criteria, 2 array criteria', async () => {- const maxRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);-- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria1 = ArrayValueObject.create(`{- >2;- >3;- >4- }`);-- const range2 = ArrayValueObject.create(`{- 3;- 4;- 5- }`);-- const criteria2 = ArrayValueObject.create(`{- 4;- 4;- 4;- 4- }`);-- const resultObject = testFunction.calculate(maxRange, range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [0], [0], [0]]);+ it('Two ranges and criteria, criteria is array', async () => {+ const result = await calculate('=MAXIFS(A1:A4,B1:B4,">2",C1:C4,{">4";">5"})');+ expect(result).toStrictEqual([+ [4],+ [4],+ ]);});});});diff --git a/packages/engine-formula/src/functions/statistical/maxifs/index.ts b/packages/engine-formula/src/functions/statistical/maxifs/index.tsindex c8b7dbf301..0cb9565193 100644--- a/packages/engine-formula/src/functions/statistical/maxifs/index.ts+++ b/packages/engine-formula/src/functions/statistical/maxifs/index.ts@@ -14,9 +14,11 @@* limitations under the License.*/-import type { BaseValueObject, IArrayValueObject } from '../../../engine/value-object/base-value-object';+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';import { ErrorType } from '../../../basics/error-type';-import { calculateMaxDimensions, getBooleanResults, getErrorArray } from '../../../engine/utils/value-object';+import { expandArrayValueObject } from '../../../engine/utils/array-object';+import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';import { ArrayValueObject } from '../../../engine/value-object/array-value-object';import { ErrorValueObject } from '../../../engine/value-object/base-value-object';import { BaseFunction } from '../../base-function';@@ -26,40 +28,38 @@ export class Maxifs extends BaseFunction {override maxParams = 255;- override calculate(maxRange: BaseValueObject, ...variants: BaseValueObject[]) {- if (maxRange.isError()) {- return ErrorValueObject.create(ErrorType.NA);+ override needsReferenceObject = true;++ override calculate(maxRange: FunctionVariantType, ...variants: FunctionVariantType[]): BaseValueObject {+ const {+ isError,+ errorObject,+ rangeIsDifferentSize,+ criteriaMaxRowLength,+ criteriaMaxColumnLength,+ targetRange: _maxRange,+ variants: _variants,+ } = parsePairedRangeAndCriteria(variants, maxRange);++ if (isError) {+ return errorObject as ErrorValueObject;}- if (!maxRange.isArray()) {- return ErrorValueObject.create(ErrorType.VALUE);- }-- // Range and criteria must be paired- if (variants.length % 2 !== 0) {- return ErrorValueObject.create(ErrorType.VALUE);- }+ if (rangeIsDifferentSize) {+ if (criteriaMaxRowLength === 1 && criteriaMaxColumnLength === 1) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }- // Every range must be array- if (variants.some((variant, i) => i % 2 === 0 && !variant.isArray())) {- return ErrorValueObject.create(ErrorType.VALUE);+ return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));}- const { maxRowLength, maxColumnLength } = calculateMaxDimensions(variants);-- const errorArray = getErrorArray(variants, maxRange, maxRowLength, maxColumnLength);-- if (errorArray) {- return errorArray;- }+ const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);- const booleanResults = getBooleanResults(variants, maxRowLength, maxColumnLength, true);-- return this._aggregateResults(maxRange, booleanResults);+ return this._aggregateResults(_maxRange as BaseValueObject, booleanResults);}- private _aggregateResults(maxRange: BaseValueObject, booleanResults: BaseValueObject[][]): ArrayValueObject {- const maxResults = booleanResults.map((row) => {+ private _aggregateResults(maxRange: BaseValueObject, booleanResults: BaseValueObject[][]): BaseValueObject {+ const results = booleanResults.map((row) => {return row.map((booleanResult) => {const picked = (maxRange as ArrayValueObject).pick(booleanResult as ArrayValueObject);if (picked.getColumnCount() === 0) {@@ -70,16 +70,18 @@ export class Maxifs extends BaseFunction {});});- const arrayValueObjectData: IArrayValueObject = {- calculateValueList: maxResults,- rowCount: maxResults.length,- columnCount: maxResults[0].length,+ if (results.length === 1 && results[0].length === 1) {+ return results[0][0];+ }++ return ArrayValueObject.create({+ calculateValueList: results,+ rowCount: results.length,+ columnCount: results[0].length,unitId: this.unitId || '',sheetId: this.subUnitId || '',row: this.row,column: this.column,- };-- return ArrayValueObject.create(arrayValueObjectData);+ });}}diff --git a/packages/engine-formula/src/functions/statistical/minifs/__tests__/index.spec.ts b/packages/engine-formula/src/functions/statistical/minifs/__tests__/index.spec.tsindex b836187d6d..4d28bbca9c 100644--- a/packages/engine-formula/src/functions/statistical/minifs/__tests__/index.spec.ts+++ b/packages/engine-formula/src/functions/statistical/minifs/__tests__/index.spec.ts@@ -14,165 +14,219 @@* limitations under the License.*/-import { describe, expect, it } from 'vitest';+import type { Injector, IWorkbookData } from '@univerjs/core';+import type { LexerNode } from '../../../../engine/analysis/lexer-node';+import type { BaseAstNode } from '../../../../engine/ast-node/base-ast-node';+import { CellValueType, LocaleType } from '@univerjs/core';+import { beforeEach, describe, expect, it } from 'vitest';+import { ErrorType } from '../../../../basics/error-type';+import { Lexer } from '../../../../engine/analysis/lexer';+import { AstTreeBuilder } from '../../../../engine/analysis/parser';+import { Interpreter } from '../../../../engine/interpreter/interpreter';+import { generateExecuteAstNodeData } from '../../../../engine/utils/ast-node-tool';+import { IFormulaCurrentConfigService } from '../../../../services/current-data.service';+import { IFunctionService } from '../../../../services/function.service';+import { IFormulaRuntimeService } from '../../../../services/runtime.service';+import { createFunctionTestBed, getObjectValue } from '../../../__tests__/create-function-test-bed';import { FUNCTION_NAMES_STATISTICAL } from '../../function-names';import { Minifs } from '../index';-import { ArrayValueObject, transformToValue } from '../../../../engine/value-object/array-value-object';-import { NumberValueObject, StringValueObject } from '../../../../engine/value-object/primitive-object';-describe('Test minifs function', () => {- const testFunction = new Minifs(FUNCTION_NAMES_STATISTICAL.MINIFS);+const getTestWorkbookData = (): IWorkbookData => {+ return {+ id: 'test',+ appVersion: '3.0.0-alpha',+ sheets: {+ sheet1: {+ id: 'sheet1',+ cellData: {+ 0: {+ 0: {+ v: 1,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 2,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ },+ 1: {+ 0: {+ v: 2,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ },+ 2: {+ 0: {+ v: 3,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 6,+ t: CellValueType.NUMBER,+ },+ },+ 3: {+ 0: {+ v: 4,+ t: CellValueType.NUMBER,+ },+ 1: {+ v: 5,+ t: CellValueType.NUMBER,+ },+ 2: {+ v: 6,+ t: CellValueType.NUMBER,+ },+ 3: {+ v: 7,+ t: CellValueType.NUMBER,+ },+ },+ },+ },+ },+ locale: LocaleType.ZH_CN,+ name: '',+ sheetOrder: [],+ styles: {},+ };+};- describe('Minifs', () => {- it('Range and criteria', async () => {- const minRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);- const range = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria = StringValueObject.create('>2');- const resultObject = testFunction.calculate(minRange, range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);+describe('Test minifs function', () => {+ let get: Injector['get'];+ let lexer: Lexer;+ let astTreeBuilder: AstTreeBuilder;+ let interpreter: Interpreter;+ let calculate: (formula: string) => (string | number | boolean | null)[][] | string | number | boolean;++ beforeEach(() => {+ const testBed = createFunctionTestBed(getTestWorkbookData());++ get = testBed.get;++ lexer = get(Lexer);+ astTreeBuilder = get(AstTreeBuilder);+ interpreter = get(Interpreter);++ const functionService = get(IFunctionService);++ const formulaCurrentConfigService = get(IFormulaCurrentConfigService);++ const formulaRuntimeService = get(IFormulaRuntimeService);++ formulaCurrentConfigService.load({+ formulaData: {},+ arrayFormulaCellData: {},+ arrayFormulaRange: {},+ forceCalculate: false,+ dirtyRanges: [],+ dirtyNameMap: {},+ dirtyDefinedNameMap: {},+ dirtyUnitFeatureMap: {},+ dirtyUnitOtherFormulaMap: {},+ excludedCell: {},+ allUnitData: {+ [testBed.unitId]: testBed.sheetData,+ },});- it('Range and criteria, compare string', async () => {- const minRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);- const range = ArrayValueObject.create(`{- a;- b;- c- }`);-- const criteria = StringValueObject.create('>2');- const resultObject = testFunction.calculate(minRange, range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[0]]);- });+ const sheetItem = testBed.sheetData[testBed.sheetId];- it('Range and array criteria', async () => {- const minRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);-- const range = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria = ArrayValueObject.create(`{- >2;- >3;- >4- }`);-- const resultObject = testFunction.calculate(minRange, range, criteria);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [3], [0]]);- });+ formulaRuntimeService.setCurrent(+ 0,+ 0,+ sheetItem.rowCount,+ sheetItem.columnCount,+ testBed.sheetId,+ testBed.unitId+ );- it('2 ranges and criteria', async () => {- const minRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);+ functionService.registerExecutors(+ new Minifs(FUNCTION_NAMES_STATISTICAL.MINIFS)+ );- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4- }`);+ calculate = (formula: string) => {+ const lexerNode = lexer.treeBuilder(formula);- const criteria1 = StringValueObject.create('>2');+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);- const range2 = ArrayValueObject.create(`{- 3;- 4;- 5- }`);+ const result = interpreter.execute(generateExecuteAstNodeData(astNode as BaseAstNode));- const criteria2 = StringValueObject.create('<5');+ return getObjectValue(result);+ };+ });- const resultObject = testFunction.calculate(minRange, range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2]]);+ describe('Minifs', () => {+ it('Value is normal', async () => {+ const result = await calculate('=MINIFS(A1:A4,B1:B4,">3")');+ expect(result).toBe(3);+ });++ it('Value is array', async () => {+ const result = await calculate('=MINIFS({1;2;3;4},B1:B4,">3")');+ expect(result).toBe(ErrorType.VALUE);+ });++ it('Range and criteria is not paired', async () => {+ const result = await calculate('=MINIFS(A1:A4,B1:B4,">3",C1:C4)');+ expect(result).toBe(ErrorType.VALUE);+ });++ it('Range is different size', async () => {+ const result = await calculate('=MINIFS(A1:A4,B1:B4,">3",C1:C3,{"=5","=6"})');+ expect(result).toStrictEqual([+ [ErrorType.VALUE, ErrorType.VALUE],+ ]);+ });++ it('Range and array criteria', async () => {+ const result = await calculate('=MINIFS(A1:A4,B1:B4,{">1";">2"})');+ expect(result).toStrictEqual([+ [1],+ [2],+ ]);});- it('2 ranges and criteria, 1 array criteria', async () => {- const minRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);-- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria1 = ArrayValueObject.create(`{- >2;- >3;- >4- }`);-- const range2 = ArrayValueObject.create(`{- 3;- 4;- 5- }`);-- const criteria2 = NumberValueObject.create(5);-- const resultObject = testFunction.calculate(minRange, range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[3], [3], [0]]);+ it('Two ranges and criteria', async () => {+ const result = await calculate('=MINIFS(A1:A4,B1:B4,">2",C1:C4,"=5")');+ expect(result).toBe(3);});- it('2 ranges and criteria, 2 array criteria', async () => {- const minRange = ArrayValueObject.create(`{- 1;- 2;- 3- }`);-- const range1 = ArrayValueObject.create(`{- 2;- 3;- 4- }`);-- const criteria1 = ArrayValueObject.create(`{- >2;- >3;- >4- }`);-- const range2 = ArrayValueObject.create(`{- 3;- 4;- 5- }`);-- const criteria2 = ArrayValueObject.create(`{- 4;- 4;- 4;- 4- }`);-- const resultObject = testFunction.calculate(minRange, range1, criteria1, range2, criteria2);- expect(transformToValue(resultObject.getArrayValue())).toStrictEqual([[2], [0], [0], [0]]);+ it('Two ranges and criteria, criteria is array', async () => {+ const result = await calculate('=MINIFS(A1:A4,B1:B4,">2",C1:C4,{">4";">5"})');+ expect(result).toStrictEqual([+ [3],+ [4],+ ]);});});});diff --git a/packages/engine-formula/src/functions/statistical/minifs/index.ts b/packages/engine-formula/src/functions/statistical/minifs/index.tsindex 218e08cc03..15206554d0 100644--- a/packages/engine-formula/src/functions/statistical/minifs/index.ts+++ b/packages/engine-formula/src/functions/statistical/minifs/index.ts@@ -14,10 +14,12 @@* limitations under the License.*/+import type { FunctionVariantType } from '../../../engine/reference-object/base-reference-object';+import type { BaseValueObject } from '../../../engine/value-object/base-value-object';import { ErrorType } from '../../../basics/error-type';-import { calculateMaxDimensions, getBooleanResults, getErrorArray } from '../../../engine/utils/value-object';+import { expandArrayValueObject } from '../../../engine/utils/array-object';+import { getBooleanResults, parsePairedRangeAndCriteria } from '../../../engine/utils/value-object';import { ArrayValueObject } from '../../../engine/value-object/array-value-object';-import type { BaseValueObject, IArrayValueObject } from '../../../engine/value-object/base-value-object';import { ErrorValueObject } from '../../../engine/value-object/base-value-object';import { BaseFunction } from '../../base-function';@@ -26,40 +28,38 @@ export class Minifs extends BaseFunction {override maxParams = 255;- override calculate(minRange: BaseValueObject, ...variants: BaseValueObject[]) {- if (minRange.isError()) {- return ErrorValueObject.create(ErrorType.NA);+ override needsReferenceObject = true;++ override calculate(minRange: FunctionVariantType, ...variants: FunctionVariantType[]): BaseValueObject {+ const {+ isError,+ errorObject,+ rangeIsDifferentSize,+ criteriaMaxRowLength,+ criteriaMaxColumnLength,+ targetRange: _minRange,+ variants: _variants,+ } = parsePairedRangeAndCriteria(variants, minRange);++ if (isError) {+ return errorObject as ErrorValueObject;}- if (!minRange.isArray()) {- return ErrorValueObject.create(ErrorType.VALUE);- }-- // Range and criteria must be paired- if (variants.length % 2 !== 0) {- return ErrorValueObject.create(ErrorType.VALUE);- }+ if (rangeIsDifferentSize) {+ if (criteriaMaxRowLength === 1 && criteriaMaxColumnLength === 1) {+ return ErrorValueObject.create(ErrorType.VALUE);+ }- // Every range must be array- if (variants.some((variant, i) => i % 2 === 0 && !variant.isArray())) {- return ErrorValueObject.create(ErrorType.VALUE);+ return expandArrayValueObject(criteriaMaxRowLength, criteriaMaxColumnLength, ErrorValueObject.create(ErrorType.VALUE));}- const { maxRowLength, maxColumnLength } = calculateMaxDimensions(variants);-- const errorArray = getErrorArray(variants, minRange, maxRowLength, maxColumnLength);-- if (errorArray) {- return errorArray;- }+ const booleanResults = getBooleanResults(_variants, criteriaMaxRowLength, criteriaMaxColumnLength, true);- const booleanResults = getBooleanResults(variants, maxRowLength, maxColumnLength, true);-- return this._aggregateResults(minRange, booleanResults);+ return this._aggregateResults(_minRange as BaseValueObject, booleanResults);}- private _aggregateResults(minRange: BaseValueObject, booleanResults: BaseValueObject[][]): ArrayValueObject {- const maxResults = booleanResults.map((row) => {+ private _aggregateResults(minRange: BaseValueObject, booleanResults: BaseValueObject[][]): BaseValueObject {+ const results = booleanResults.map((row) => {return row.map((booleanResult) => {const picked = (minRange as ArrayValueObject).pick(booleanResult as ArrayValueObject);if (picked.getColumnCount() === 0) {@@ -70,16 +70,18 @@ export class Minifs extends BaseFunction {});});- const arrayValueObjectData: IArrayValueObject = {- calculateValueList: maxResults,- rowCount: maxResults.length,- columnCount: maxResults[0].length,+ if (results.length === 1 && results[0].length === 1) {+ return results[0][0];+ }++ return ArrayValueObject.create({+ calculateValueList: results,+ rowCount: results.length,+ columnCount: results[0].length,unitId: this.unitId || '',sheetId: this.subUnitId || '',row: this.row,column: this.column,- };-- return ArrayValueObject.create(arrayValueObjectData);+ });}}