Skip to content

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.

fix(formula): parser error (#3174)

Univer6e2db5a346a6
diff --git a/packages/engine-formula/src/basics/error-type.ts b/packages/engine-formula/src/basics/error-type.ts
index 8d64fd34ce..fc8b3a51ce 100644
--- a/packages/engine-formula/src/basics/error-type.ts
+++ b/packages/engine-formula/src/basics/error-type.ts
@@ -47,3 +47,5 @@ export enum ErrorType {
}
export const ERROR_TYPE_SET = new Set(Object.values(ErrorType));
+
+export const ERROR_TYPE_COUNT_ARRAY = [...new Set(Object.values(ErrorType).map((error) => error.length))];
diff --git a/packages/engine-formula/src/engine/analysis/__tests__/lexer-tree-builder.spec.ts b/packages/engine-formula/src/engine/analysis/__tests__/lexer-tree-builder.spec.ts
index 0d36b91040..13e9ce8e23 100644
--- a/packages/engine-formula/src/engine/analysis/__tests__/lexer-tree-builder.spec.ts
+++ b/packages/engine-formula/src/engine/analysis/__tests__/lexer-tree-builder.spec.ts
@@ -135,10 +135,10 @@ describe('lexer nodeMaker test', () => {
expect(elapsed).toBeGreaterThan(0);
});
- it('error', () => {
+ it('error include function test', () => {
const node = lexerTreeBuilder.treeBuilder('=sum(#REF! + 5 , #REF!)') as LexerNode;
expect(JSON.stringify(node.serialize())).toStrictEqual(
- '{"token":"R_1","st":-1,"ed":-1,"children":[{"token":"sum","st":0,"ed":2,"children":[{"token":"P_1","st":0,"ed":2,"children":["#REF! "," 5 ","+"]},{"token":"P_1","st":11,"ed":13,"children":[" #REF!"]}]}]}'
+ '{"token":"R_1","st":-1,"ed":-1,"children":[{"token":"sum","st":0,"ed":2,"children":[{"token":"P_1","st":0,"ed":2,"children":["#REF!"," 5 "," +"]},{"token":"P_1","st":11,"ed":13,"children":["#REF!"]}]}]}'
);
});
@@ -206,6 +206,21 @@ describe('lexer nodeMaker test', () => {
const node = lexerTreeBuilder.treeBuilder('={"2007/1/1", "2008/1/1"}') as LexerNode;
expect(JSON.stringify(node.serialize())).toStrictEqual('{"token":"R_1","st":-1,"ed":-1,"children":["{\\"2007/1/1\\", \\"2008/1/1\\"}"]}');
});
+
+ it('error as parameter', () => {
+ const node = lexerTreeBuilder.treeBuilder('=sum(#NUM! + #VALUE!) + #SPILL! - (#CALC!)') as LexerNode;
+ expect(JSON.stringify(node.serialize())).toStrictEqual('{"token":"R_1","st":-1,"ed":-1,"children":[{"token":"sum","st":0,"ed":2,"children":[{"token":"P_1","st":0,"ed":2,"children":["#NUM!","#VALUE!"," +"]}]},"#SPILL!"," +","#CALC!","-"]}');
+ });
+
+ it('error type lexer function', () => {
+ const node = lexerTreeBuilder.treeBuilder('=ERROR.TYPE(#DIV/0!)/ERROR.TYPE(#N/A)') as LexerNode;
+ expect(JSON.stringify(node.serialize())).toStrictEqual('{"token":"R_1","st":-1,"ed":-1,"children":[{"token":"ERROR.TYPE","st":0,"ed":9,"children":[{"token":"P_1","st":7,"ed":9,"children":["#DIV/0!"]}]},{"token":"ERROR.TYPE","st":20,"ed":29,"children":[{"token":"P_1","st":27,"ed":29,"children":["#N/A"]}]},"/"]}');
+ });
+
+ it('array error lexer text', () => {
+ const node = lexerTreeBuilder.treeBuilder('=RANK({1,2,121,#NAME?},A1:F1,0)') as LexerNode;
+ expect(JSON.stringify(node.serialize())).toStrictEqual('{"token":"R_1","st":-1,"ed":-1,"children":[{"token":"RANK","st":0,"ed":3,"children":[{"token":"P_1","st":1,"ed":3,"children":["{1,2,121,#NAME?}"]},{"token":"P_1","st":18,"ed":20,"children":[{"token":":","st":-1,"ed":-1,"children":[{"token":"P_1","st":-1,"ed":-1,"children":[{"token":"A1","st":-1,"ed":-1,"children":[]}]},{"token":"P_1","st":-1,"ed":-1,"children":[{"token":"F1","st":-1,"ed":-1,"children":[]}]}]}]},{"token":"P_1","st":24,"ed":26,"children":["0"]}]}]}');
+ });
});
describe('check error', () => {
@@ -228,6 +243,31 @@ describe('lexer nodeMaker test', () => {
const node = lexerTreeBuilder.treeBuilder('=(1+3)9') as LexerNode;
expect(node).toStrictEqual(ErrorType.VALUE);
});
+
+ it('Error for spell check!', () => {
+ const node = lexerTreeBuilder.treeBuilder('=PI()0.1') as LexerNode;
+ expect(node).toStrictEqual(ErrorType.VALUE);
+ });
+
+ it('Sum error for spell check!', () => {
+ const node = lexerTreeBuilder.treeBuilder('=sum(PI()0.1)') as LexerNode;
+ expect(node).toStrictEqual(ErrorType.VALUE);
+ });
+
+ it('Braces together error!', () => {
+ const node = lexerTreeBuilder.treeBuilder('=sum({}{})') as LexerNode;
+ expect(node).toStrictEqual(ErrorType.VALUE);
+ });
+
+ it('Zero braces together error!', () => {
+ const node = lexerTreeBuilder.treeBuilder('=sum({0}{0})') as LexerNode;
+ expect(node).toStrictEqual(ErrorType.VALUE);
+ });
+
+ it('Lack braces error!', () => {
+ const node = lexerTreeBuilder.treeBuilder('=sum((1)') as LexerNode;
+ expect(node).toStrictEqual(ErrorType.VALUE);
+ });
});
describe('checkIfAddBracket', () => {
@@ -250,6 +290,10 @@ describe('lexer nodeMaker test', () => {
it('nest blank function bracket', () => {
expect(lexerTreeBuilder.checkIfAddBracket('=sum(sum(sum(sum(')).toStrictEqual(4);
});
+
+ // it('nest one function bracket', () => {
+ // expect(lexerTreeBuilder.checkIfAddBracket('=sum((1)')).toStrictEqual(1);
+ // });
});
describe('sequenceNodesBuilder', () => {
@@ -422,6 +466,15 @@ describe('lexer nodeMaker test', () => {
},
]);
});
+
+ it('Array format for sequence', () => {
+ expect(lexerTreeBuilder.sequenceNodesBuilder('={"2007/1/1", "2008/1/1"}')).toStrictEqual([{
+ endIndex: 23,
+ nodeType: 5,
+ startIndex: 0,
+ token: '{"2007/1/1", "2008/1/1"}',
+ }]);
+ });
});
describe('convertRefersToAbsolute', () => {
diff --git a/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts b/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts
index aaef0afc7d..7ef71c92ee 100644
--- a/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts
+++ b/packages/engine-formula/src/engine/analysis/__tests__/parser.spec.ts
@@ -17,7 +17,6 @@
import type { Injector } from '@univerjs/core';
import { beforeEach, describe, expect, it } from 'vitest';
-import { ErrorType } from '../../../basics/error-type';
import { FUNCTION_NAMES_MATH } from '../../../functions/math/function-names';
import { Sum } from '../../../functions/math/sum';
import { FUNCTION_NAMES_META } from '../../../functions/meta/function-names';
@@ -33,6 +32,8 @@ import type { LexerNode } from '../lexer-node';
import { AstTreeBuilder } from '../parser';
import type { ArrayValueObject } from '../../value-object/array-value-object';
import { Minus } from '../../../functions/meta/minus';
+import { Pi } from '../../../functions/math/pi';
+import { ErrorType } from '../../../basics/error-type';
import { createCommandTestBed } from './create-command-test-bed';
describe('Test indirect', () => {
@@ -81,7 +82,12 @@ describe('Test indirect', () => {
testBed.unitId
);
- functionService.registerExecutors(new Sum(FUNCTION_NAMES_MATH.SUM), new Plus(FUNCTION_NAMES_META.PLUS), new Minus(FUNCTION_NAMES_META.MINUS));
+ functionService.registerExecutors(
+ new Sum(FUNCTION_NAMES_MATH.SUM),
+ new Plus(FUNCTION_NAMES_META.PLUS),
+ new Minus(FUNCTION_NAMES_META.MINUS),
+ new Pi(FUNCTION_NAMES_MATH.PI)
+ );
});
describe('normal', () => {
@@ -214,5 +220,25 @@ describe('Test indirect', () => {
expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.NAME);
});
+
+ it('Root node has multiple parameter!', async () => {
+ const lexerNode = lexer.treeBuilder('=PI()/1.570796327,M54');
+
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
+
+ const result = interpreter.execute(astNode as BaseAstNode);
+
+ expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.NAME);
+ });
+
+ it('error as return #NUM!', async () => {
+ const lexerNode = lexer.treeBuilder('=SUM(#NUM! + #VALUE!) + #SPILL! - (#CALC!)');
+
+ const astNode = astTreeBuilder.parse(lexerNode as LexerNode);
+
+ const result = interpreter.execute(astNode as BaseAstNode);
+
+ expect((result as BaseValueObject).getValue()).toStrictEqual(ErrorType.NUM);
+ });
});
});
diff --git a/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts b/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts
index ffa4da47b2..1ed7ae3acd 100644
--- a/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts
+++ b/packages/engine-formula/src/engine/analysis/lexer-tree-builder.ts
@@ -18,7 +18,7 @@ import type { IRange, Nullable } from '@univerjs/core';
import { AbsoluteRefType, Disposable, isValidRange, moveRangeByOffset, Tools } from '@univerjs/core';
import { FormulaAstLRU } from '../../basics/cache-lru';
-import { ErrorType } from '../../basics/error-type';
+import { ERROR_TYPE_COUNT_ARRAY, ERROR_TYPE_SET, ErrorType } from '../../basics/error-type';
import { isFormulaLexerToken } from '../../basics/match-token';
import { REFERENCE_SINGLE_RANGE_REGEX } from '../../basics/regex';
import {
@@ -374,7 +374,36 @@ export class LexerTreeBuilder extends Disposable {
return `=${generateStringWithSequence(newSequenceNodes)}`;
}
- getSequenceNode(sequenceArray: ISequenceArray[]) {
+ /**
+ * univer-pro/issues/1684
+ * =sum({}{})
+ */
+ private _formulaSpellCheck(): boolean {
+ if (this._currentLexerNode.getChildren().length === 0) {
+ return true;
+ }
+ const node = this._currentLexerNode.getChildren()[0];
+
+ if (node instanceof LexerNode) {
+ return true;
+ }
+
+ if (
+ OPERATOR_TOKEN_SET.has(node)
+ || SUFFIX_TOKEN_SET.has(node)
+ || node === prefixToken.AT
+ || node === matchToken.COMMA
+ || node === matchToken.COLON
+ || node === matchToken.OPEN_BRACKET
+ ) {
+ return true;
+ }
+
+ return false;
+ }
+
+ // eslint-disable-next-line complexity
+ getSequenceNode(sequenceArray: ISequenceArray[]): (string | ISequenceNode)[] {
const sequenceNodes: Array<ISequenceNode | string> = [];
let maybeString = false;
@@ -418,7 +447,7 @@ export class LexerTreeBuilder extends Disposable {
const preSegmentNotPrefixToken = this._replacePrefixString(preSegmentTrim);
- if (maybeString === true && preSegmentTrim[preSegmentTrim.length - 1] === matchToken.DOUBLE_QUOTATION) {
+ if (maybeString === true && preSegmentTrim[preSegmentTrim.length - 1] === matchToken.DOUBLE_QUOTATION && preSegmentTrim[0] !== matchToken.OPEN_BRACES) {
maybeString = false;
this._processPushSequenceNode(sequenceNodes, sequenceNodeType.STRING, preSegment, startIndex, endIndex, deleteEndIndex);
} else if (new RegExp(REFERENCE_SINGLE_RANGE_REGEX).test(preSegmentNotPrefixToken) && isReferenceStringWithEffectiveColumn(preSegmentNotPrefixToken)) {
@@ -472,7 +501,7 @@ export class LexerTreeBuilder extends Disposable {
* Merge array and handle ref operations
*
*/
- private _mergeSequenceNodeReference(sequenceNodes: Array<string | ISequenceNode>) {
+ private _mergeSequenceNodeReference(sequenceNodes: Array<string | ISequenceNode>): (string | ISequenceNode)[] {
const newSequenceNodes: Array<string | ISequenceNode> = [];
const sequenceNodesCount = sequenceNodes.length;
@@ -634,7 +663,8 @@ export class LexerTreeBuilder extends Disposable {
return this._currentLexerNode;
}
- private _suffixExpressionHandler(lexerNode: LexerNode) {
+ // eslint-disable-next-line complexity
+ private _suffixExpressionHandler(lexerNode: LexerNode): boolean {
const children = lexerNode.getChildren();
if (!children) {
return false;
@@ -643,6 +673,9 @@ export class LexerTreeBuilder extends Disposable {
const baseStack: Array<string | LexerNode> = []; // S2
const symbolStack: string[] = []; // S1
+
+ let isChildValid = true;
+
for (let i = 0; i < childrenCount; i++) {
const node = children[i];
if (!(node instanceof LexerNode)) {
@@ -693,15 +726,19 @@ export class LexerTreeBuilder extends Disposable {
baseStack.push(node as string);
}
} else {
- this._suffixExpressionHandler(node as LexerNode);
+ isChildValid = this._suffixExpressionHandler(node as LexerNode);
baseStack.push(node);
}
}
+ if (!isChildValid) {
+ return false;
+ }
+
return this._processSuffixExpressionRemain(baseStack, symbolStack, lexerNode);
}
- private _processSuffixExpressionRemain(baseStack: (string | LexerNode)[], symbolStack: string[], lexerNode: LexerNode) {
+ private _processSuffixExpressionRemain(baseStack: (string | LexerNode)[], symbolStack: string[], lexerNode: LexerNode): boolean {
const baseStackLength = baseStack.length;
const lastBaseStack = baseStack[baseStackLength - 1];
while (symbolStack.length > 0) {
@@ -741,7 +778,7 @@ export class LexerTreeBuilder extends Disposable {
}
private _checkCloseBracket(node: Nullable<string | LexerNode>) {
- return node === matchToken.CLOSE_BRACKET;
+ return node === matchToken.CLOSE_BRACKET || node instanceof LexerNode;
}
private _checkOpenBracket(node: Nullable<string | LexerNode>) {
@@ -938,7 +975,8 @@ export class LexerTreeBuilder extends Disposable {
this._segment += value;
}
- private _pushNodeToChildren(value: LexerNode | string, isUnshift = false) {
+ private _pushNodeToChildren(valueRaw: LexerNode | string, isUnshift = false) {
+ let value = valueRaw;
if (value !== '') {
const children = this._currentLexerNode.getChildren();
if (!(value instanceof LexerNode) && this.isColonOpen()) {
@@ -987,7 +1025,8 @@ export class LexerTreeBuilder extends Disposable {
children.splice(-1);
}
- private _findPreviousToken(data: string[], index: number) {
+ private _findPreviousToken(data: string[], indexRaw: number) {
+ let index = indexRaw;
while (index >= 0) {
const token = data[index];
if (token !== ' ') {
@@ -1009,7 +1048,7 @@ export class LexerTreeBuilder extends Disposable {
return false;
}
- private _getSequenceArray(formulaString: string) {
+ private _getSequenceArray(formulaString: string): ISequenceArray[] {
const sequenceArray: ISequenceArray[] = [];
this._nodeMaker(formulaString, sequenceArray);
@@ -1017,7 +1056,7 @@ export class LexerTreeBuilder extends Disposable {
return sequenceArray;
}
- private _resetTemp() {
+ private _resetTemp(): void {
this._currentLexerNode = new LexerNode();
this._upLevel = 0;
@@ -1037,7 +1076,28 @@ export class LexerTreeBuilder extends Disposable {
this._colonState = false; // :
}
- private _checkSimilarErrorToken(currentString: string, cur: number, formulaStringArray: string[]) {
+ private _checkErrorState(): boolean {
+ if (this._bracketState.length > 0) {
+ return true;
+ }
+
+ if (this._bracesState > 0) {
+ return true;
+ }
+
+ if (this._singleQuotationState > 0) {
+ return true;
+ }
+
+ if (this._doubleQuotationState > 0) {
+ return true;
+ }
+
+ return false;
+ }
+
+ private _checkSimilarErrorToken(currentString: string, curRow: number, formulaStringArray: string[]): boolean {
+ let cur = curRow;
if (currentString !== suffixToken.POUND) {
return true;
}
@@ -1055,8 +1115,31 @@ export class LexerTreeBuilder extends Disposable {
return false;
}
+ private _checkIfErrorObject(cur: number, formulaStringArray: string[]): boolean {
+ const errorType = this._findErrorObject(cur, formulaStringArray);
+ if (!errorType) {
+ return false;
+ }
+
+ return true;
+ }
+
+ private _findErrorObject(curRaw: number, formulaStringArray: string[]): Nullable<string> {
+ for (let i = 0; i < ERROR_TYPE_COUNT_ARRAY.length; i++) {
+ const errorTypeCount = ERROR_TYPE_COUNT_ARRAY[i];
+
+ const errorType = formulaStringArray.slice(curRaw, curRaw + errorTypeCount).join('').toUpperCase();
+
+ if (ERROR_TYPE_SET.has(errorType as ErrorType)) {
+ return errorType;
+ }
+ }
+ }
+
// eslint-disable-next-line max-lines-per-function, complexity
- private _nodeMaker(formulaString: string, sequenceArray?: ISequenceArray[], matchCurrentNodeIndex?: number) {
+ private _nodeMaker(formulaStringRaw: string, sequenceArray?: ISequenceArray[], matchCurrentNodeIndex?: number) {
+ let formulaString = formulaStringRaw.replace(/\r/g, ' ').replace(/\n/g, ' ');
+
if (formulaString.substring(0, 1) === operatorToken.EQUALS) {
formulaString = formulaString.substring(1);
}
@@ -1078,7 +1161,29 @@ export class LexerTreeBuilder extends Disposable {
return [this._currentLexerNode, currentString];
}
- if (
+ if (currentString === suffixToken.POUND &&
+ this.isSingleQuotationClose() &&
+ this.isDoubleQuotationClose() &&
+ this.isBracesClose() &&
+ this.isSquareBracketClose() &&
+ this._checkIfErrorObject(cur, formulaStringArray)
+ ) {
+ const errorType = this._findErrorObject(cur, formulaStringArray);
+ if (errorType == null) {
+ return ErrorType.VALUE;
+ }
+ this._pushNodeToChildren(errorType);
+ for (let i = 0; i < errorType.length; i++) {
+ const curStr = formulaStringArray[cur];
+ this._pushSegment(curStr);
+ this._addSequenceArray(sequenceArray, curStr, cur, isZeroAdded);
+ cur++;
+ }
+ this._resetSegment();
+ // this._addSequenceArray(sequenceArray, currentString, cur, isZeroAdded);
+ // cur += errorType.length;
+ continue;
+ } else if (
currentString === matchToken.OPEN_BRACKET &&
this.isSingleQuotationClose() &&
this.isDoubleQuotationClose()
@@ -1154,6 +1259,10 @@ export class LexerTreeBuilder extends Disposable {
) {
this._pushSegment(currentString);
this._openBraces();
+
+ if (!this._formulaSpellCheck()) {
+ return ErrorType.VALUE;
+ }
} else if (
currentString === matchToken.CLOSE_BRACES &&
this.isSingleQuotationClose() &&
@@ -1454,6 +1563,10 @@ export class LexerTreeBuilder extends Disposable {
}
this._pushNodeToChildren(this._segment);
+
+ if (this._checkErrorState()) {
+ return ErrorType.VALUE;
+ }
}
private _isScientificNotation(formulaStringArray: string[], cur: number, currentString: string) {
diff --git a/packages/engine-formula/src/engine/ast-node/ast-root-node.ts b/packages/engine-formula/src/engine/ast-node/ast-root-node.ts
index 25c530c85e..05010c4faa 100644
--- a/packages/engine-formula/src/engine/ast-node/ast-root-node.ts
+++ b/packages/engine-formula/src/engine/ast-node/ast-root-node.ts
@@ -29,6 +29,12 @@ export class AstRootNode extends BaseAstNode {
override execute() {
const children = this.getChildren();
+
+ if (children.length > 1) {
+ this.setValue(ErrorValueObject.create(ErrorType.VALUE));
+ return;
+ }
+
const node = children[0];
// if (node.nodeType === NodeType.FUNCTION) {
// await node.executeAsync(interpreterCalculateProps);
diff --git a/packages/engine-formula/src/engine/ast-node/value-node.ts b/packages/engine-formula/src/engine/ast-node/value-node.ts
index 4d4e40644d..a6f8b75bf9 100644
--- a/packages/engine-formula/src/engine/ast-node/value-node.ts
+++ b/packages/engine-formula/src/engine/ast-node/value-node.ts
@@ -28,21 +28,21 @@ export class ValueNode extends BaseAstNode {
super(_operatorString);
}
- override get nodeType() {
+ override get nodeType(): NodeType {
return NodeType.VALUE;
}
- override execute() {
+ override execute(): void {
this.setValue(ValueObjectFactory.create(this._operatorString));
}
}
export class ValueNodeFactory extends BaseAstNodeFactory {
- override get zIndex() {
+ override get zIndex(): number {
return NODE_ORDER_MAP.get(NodeType.VALUE) || DEFAULT_AST_NODE_FACTORY_Z_INDEX;
}
- _checkValueNode(token: string) {
+ _checkValueNode(token: string): BaseAstNode | undefined {
if (Number.isNaN(Number(token))) {
const tokenTrim = token.trim();
const startToken = tokenTrim.charAt(0);
@@ -72,7 +72,7 @@ export class ValueNodeFactory extends BaseAstNodeFactory {
return new ValueNode(param);
}
- override checkAndCreateNodeType(param: LexerNode | string) {
+ override checkAndCreateNodeType(param: LexerNode | string): BaseAstNode | undefined {
if (param instanceof LexerNode) {
return;
}
diff --git a/packages/engine-formula/src/engine/utils/reference.ts b/packages/engine-formula/src/engine/utils/reference.ts
index 7d6dae3c54..c2d0628cc3 100644
--- a/packages/engine-formula/src/engine/utils/reference.ts
+++ b/packages/engine-formula/src/engine/utils/reference.ts
@@ -292,11 +292,21 @@ export function deserializeRangeWithSheet(refString: string): IUnitRangeName {
};
}
+/**
+ * LOG10 is a formula, google sheet support it on Log10:L
+ * EXCEL support it on Log10:Log10
+ */
+const EXCEPTION_REF_STRINGS = ['LOG10'];
+
export function isReferenceStringWithEffectiveColumn(refString: string) {
if (!isReferenceString(refString)) {
return false;
}
+ if (EXCEPTION_REF_STRINGS.includes(refString.toUpperCase().trim())) {
+ return false;
+ }
+
const { range } = deserializeRangeWithSheet(refString);
/**
diff --git a/packages/sheets-formula/src/controllers/prompt.controller.ts b/packages/sheets-formula/src/controllers/prompt.controller.ts
index a986bdc2b2..f8948878ea 100644
--- a/packages/sheets-formula/src/controllers/prompt.controller.ts
+++ b/packages/sheets-formula/src/controllers/prompt.controller.ts
@@ -799,7 +799,7 @@ export class PromptController extends Disposable {
this._contextService.setContextValue(UNI_DISABLE_CHANGING_FOCUS_KEY, true);
const lastSequenceNodes =
- this._lexerTreeBuilder.sequenceNodesBuilder(config.dataStream.replace(/\r/g, '').replace(/\n/g, '')) ||
+ this._lexerTreeBuilder.sequenceNodesBuilder(config.dataStream) ||
[];
this._formulaPromptService.setSequenceNodes(lastSequenceNodes);
diff --git a/packages/sheets-formula/src/services/description.service.ts b/packages/sheets-formula/src/services/description.service.ts
index 552db1709d..b0b4c20b5c 100644
--- a/packages/sheets-formula/src/services/description.service.ts
+++ b/packages/sheets-formula/src/services/description.service.ts
@@ -147,11 +147,11 @@ export class DescriptionService implements IDescriptionService, IDisposable {
getSearchListByName(searchText: string) {
const searchList: ISearchItem[] = [];
const functionList = this._functionService.getDescriptions();
- searchText = searchText.toLocaleUpperCase();
+ const _searchText = searchText.toLocaleUpperCase().trim();
functionList.forEach((item) => {
const { functionName, abstract, functionType } = item;
// Exclude DefinedName
- if ((functionName.toLocaleUpperCase().indexOf(searchText) > -1) && functionType !== FunctionType.DefinedName) {
+ if ((functionName.toLocaleUpperCase().indexOf(_searchText) > -1) && functionType !== FunctionType.DefinedName) {
searchList.push({ name: functionName, desc: abstract });
}
});
@@ -162,10 +162,10 @@ export class DescriptionService implements IDescriptionService, IDisposable {
getSearchListByNameFirstLetter(searchText: string) {
const searchList: ISearchItem[] = [];
const functionList = this._functionService.getDescriptions();
- searchText = searchText.toLocaleUpperCase();
+ const _searchText = searchText.toLocaleUpperCase().trim();
functionList.forEach((item) => {
const { functionName, abstract } = item;
- if (functionName.toLocaleUpperCase().indexOf(searchText) === 0) {
+ if (functionName.toLocaleUpperCase().indexOf(_searchText) === 0) {
searchList.push({ name: functionName, desc: abstract });
}
});