@guihz/trading-vue-editor-tes 0.0.1

package/lib/components/editor/parseScript/enum.d.ts

@@ -0,0 +1,248 @@
+export declare enum VType {
+    BOOL = "bool",
+    INT = "int",
+    FLOAT = "float",
+    ARRAY = "array",
+    BOX = "box",
+    CHART_POINT = "chart.point",
+    COLOR = "color",
+    CONST = "const",
+    LABEL = "label",
+    LINE = "line",
+    LINEFILL = "linefill",
+    MAP = "map",
+    MATRIX = "matrix",
+    POLYLINE = "polyline",
+    SERIES = "series",
+    SIMPLE = "simple",
+    STRING = "string",
+    TABLE = "table",
+    UNDETERMINED = "undetermined type",
+    INPUT = "input",
+    NA = "na",
+    VOID = "void"
+}
+export declare enum VRuleType {
+    FlowStmt = "FlowStmt",
+    DeclareAssign = "DeclareAssign",
+    VarBlockStmt = "VarBlockStmt",
+    VarSingle = "VarSingle",
+    VarMultiple = "VarMultiple",
+    ParenthesizedExpression = "ParenthesizedExpression",
+    AdditiveExpression = "AdditiveExpression",
+    RelationalExpression = "RelationalExpression",
+    EqualityExpression = "EqualityExpression",
+    TernaryExpression = "TernaryExpression",
+    UnaryExpression = "UnaryExpression",
+    NotExpression = "NotExpression",
+    MemberIndexExpression = "MemberIndexExpression",
+    MethodExpression = "MethodExpression",
+    LogicalAndExpression = "LogicalAndExpression",
+    LogicalOrExpression = "LogicalOrExpression",
+    MultiplicativeExpression = "MultiplicativeExpression",
+    Brackethesized = "Brackethesized",
+    IfStatement = "IfStatement",
+    ForToStatement = "ForToStatement",
+    ForInStatement = "ForInStatement",
+    SwitchStatement = "SwitchStatement",
+    CaseClause = "CaseClause",
+    DefaultCaluse = "DefaultCaluse",
+    WhileStatement = "WhileStatement",
+    ImportElement = "ImportElement",
+    Literal = "Literal",
+    ArrowFunction = "ArrowFunction",
+    ArrowMethod = "ArrowMethod",
+    TypeStatement = "TypeStatement",
+    Name = "Name",
+    AgainAssign = "AgainAssign"
+}
+export declare enum VAdjustment {
+    dividends = "dividends",
+    none = "none",
+    splits = "splits"
+}
+export declare enum VAlert {
+    freqAll = "freq_all",
+    freqOncePerBar = "freq_once_per_bar",
+    freqOncePerBarClose = "freq_once_per_bar_close"
+}
+export declare enum VBarmergeGaps {
+    gapsOff = "gaps_off",
+    gapsOn = "gaps_on",
+    lookaheadOff = "lookahead_off",
+    lookaheadOn = "lookahead_on"
+}
+export declare enum VPlotDisplay {
+    all = "all",
+    dataWindow = "data_window",
+    none = "none",
+    pane = "pane",
+    priceScale = "price_scale",
+    statusLine = "status_line"
+}
+export declare enum VExtend {
+    both = "both",
+    left = "left",
+    none = "none",
+    right = "right"
+}
+export declare enum VFormatType {
+    inherit = "inherit",
+    mintick = "mintick",
+    percent = "percent",
+    price = "price",
+    volume = "volume"
+}
+export declare enum VHlineStyle {
+    styleDashed = "style_dashed",
+    styleDotted = "style_dotted",
+    styleSolid = "style_solid"
+}
+export declare enum VLabelStyle {
+    styleArrowdown = "style_arrowdown",
+    styleArrowup = "style_arrowup",
+    styleCircle = "style_circle",
+    styleCross = "style_cross",
+    styleDiamond = "style_diamond",
+    styleFlag = "style_flag",
+    styleLabelCenter = "style_label_center",
+    styleLabelDown = "style_label_down",
+    styleLabelLeft = "style_label_left",
+    styleLabelLowerLeft = "style_label_lower_left",
+    styleLabelLowerRight = "style_label_lower_right",
+    styleLabelRight = "style_label_right",
+    styleLabelUp = "style_label_up",
+    styleLabelUpperLeft = "style_label_upper_left",
+    styleLabelUpperRight = "style_label_upper_right",
+    styleNone = "style_none",
+    styleSquare = "style_square",
+    styleTextOutline = "style_text_outline",
+    styleTriangledown = "style_triangledown",
+    styleTriangleup = "style_triangleup",
+    styleXcross = "style_xcross"
+}
+export declare enum VLineStyle {
+    styleArrowBoth = "style_arrow_both",
+    styleArrowLeft = "style_arrow_left",
+    styleArrowRight = "style_arrow_right",
+    styleDashed = "style_dashed",
+    styleDotted = "style_dotted",
+    styleSolid = "style_solid"
+}
+export declare enum VLocation {
+    abovebar = "abovebar",
+    absolute = "absolute",
+    belowbar = "belowbar",
+    bottom = "bottom",
+    top = "top"
+}
+export declare enum VSortOrder {
+    ascending = "ascending",// 从小到大
+    descending = "descending"
+}
+export declare enum VPlotStyle {
+    styleArea = "Area",
+    styleAreabr = "Area With Breaks",
+    styleCircles = "Circles",
+    styleColumns = "Columns",
+    styleCross = "Cross",
+    styleHistogram = "Histogram",
+    styleLine = "Line",
+    styleLinebr = "Line With Breaks",
+    styleStepline = "Step Line",
+    styleSteplineDiamond = "Step Line With Diamonds",
+    styleSteplinebr = "Step line with Breaks"
+}
+export declare enum VPosition {
+    bottomCenter = "bottom_center",
+    bottomLeft = "bottom_left",
+    bottomRight = "bottom_right",
+    middleCenter = "middle_center",
+    middleLeft = "middle_left",
+    middleRight = "middle_right",
+    topCenter = "top_center",
+    topLeft = "top_left",
+    topRight = "top_right"
+}
+export declare enum VScale {
+    left = "left",
+    none = "none",
+    right = "right"
+}
+export declare enum VSession {
+    extended = "extended",
+    regular = "regular"
+}
+export declare enum VShape {
+    arrowdown = "arrowdown",
+    arrowup = "arrowup",
+    circle = "circle",
+    cross = "cross",
+    diamond = "diamond",
+    flag = "flag",
+    labeldown = "labeldown",
+    labelup = "labelup",
+    square = "square",
+    triangledown = "triangledown",
+    triangleup = "triangleup",
+    xcross = "xcross"
+}
+export declare enum VSize {
+    auto = "auto",
+    huge = "huge",
+    large = "large",
+    normal = "normal",
+    small = "small",
+    tiny = "tiny"
+}
+export declare enum VStrategy {
+    cash = "cash",
+    fixed = "fixed",
+    percentOfEquity = "percent_of_equity"
+}
+export declare enum VCommission {
+    cashPerContract = "cash_per_contract",
+    cashPerOrder = "cash_per_order",
+    percent = "percent"
+}
+export declare enum VDirection {
+    all = "all",
+    long = "long",
+    short = "short"
+}
+export declare enum VOca {
+    cancel = "cancel",
+    none = "none",
+    reduce = "reduce"
+}
+export declare enum VText {
+    alignBottom = "align_bottom",
+    alignCenter = "align_center",
+    alignLeft = "align_left",
+    alignRight = "align_right",
+    alignTop = "align_top",
+    wrapAuto = "wrap_auto",
+    wrapNone = "wrap_none"
+}
+export declare enum VXloc {
+    bar_index = "bar_index",
+    bar_time = "bar_time"
+}
+export declare enum VYloc {
+    abovebar = "abovebar",
+    belowbar = "belowbar",
+    price = "price"
+}
+export declare enum VEarnings {
+    actual = "actual",
+    estimate = "estimate",
+    standardized = "standardized"
+}
+export declare enum VPivotType {
+    traditional = "Traditional",
+    fibonacci = "Fibonacci",
+    woodie = "Woodie",
+    classic = "Classic",
+    dm = "DM",
+    camarilla = "Camarilla"
+}

package/lib/components/editor/parseScript/parseToJs.d.ts

@@ -0,0 +1,44 @@
+import { IKeyObjectValue } from "../type";
+export default class ParseToJs {
+    private _nameMap;
+    private _prefixNameVar;
+    private _prefixNameFunc;
+    private _prefixNameConst;
+    private _userTypes;
+    private _memberIndexCache;
+    private _isInFunc;
+    constructor(prefix: string);
+    preParser(values: IKeyObjectValue[]): string | undefined;
+    parser(values: IKeyObjectValue[]): string | undefined;
+    private _parserStmt;
+    private _parserTypeStatement;
+    private _parserVarBlockStmt;
+    private _parserForToStatement;
+    private _parserForInStatement;
+    private _parserAgainAssign;
+    private _parserSwitchStatement;
+    private _parserCases;
+    private _parserDefaultCase;
+    private _parserCase;
+    private _parserWhileStatement;
+    private _parserIfStatement;
+    private _parserBlockLine;
+    private _parserReturnBlock;
+    private _parserArrowMethod;
+    private _parserArrowFunction;
+    private _parserParameters;
+    private _parserBlock;
+    private _parserDeclareAssign;
+    private _parserDeclareAssignNames;
+    private _parserSingleExpression;
+    private _parserAdditiveExpression;
+    private _parserMemberIndexExpression;
+    private _parseLiteral;
+    private _colorToRgba;
+    private _parserName;
+    private _parserMethodExpression;
+    private _parserMethodElement;
+    private _parserArguments;
+    private _parserBrackethesized;
+    private _functionalProcess;
+}

package/lib/components/editor/parseScript/type.d.ts

@@ -0,0 +1,27 @@
+interface IBase {
+    startColumn: number;
+    startLineNumber: number;
+    endColumn: number;
+    endLineNumber: number;
+}
+export declare enum VMarkerSeverity {
+    Hint = 1,
+    Info = 2,
+    Warning = 4,
+    Error = 8
+}
+export interface IPosition {
+    readonly lineNumber: number;
+    readonly column: number;
+}
+export interface IRange {
+    readonly startLineNumber: number;
+    readonly startColumn: number;
+    readonly endLineNumber: number;
+    readonly endColumn: number;
+}
+export interface IError extends IBase {
+    message: string;
+    type?: VMarkerSeverity;
+}
+export {};

package/lib/components/editor/parseScript/userTypeClass.d.ts

@@ -0,0 +1,12 @@
+import { IKeyObjectValue } from "../type";
+declare class UserTypeClass {
+    private _defaultParams;
+    private _UserTypeFileds;
+    private _varipKeys;
+    constructor(params: IKeyObjectValue, keys: string[]);
+    copy(typeObject: IKeyObjectValue): IKeyObjectValue;
+    new(params?: IKeyObjectValue): any;
+    addNewMethod(name: string, func: any): void;
+    private _createDynamicClass;
+}
+export default UserTypeClass;

package/lib/components/editor/parseScript/utils.d.ts

@@ -0,0 +1,8 @@
+import { IKeyValue } from "../type";
+import dayjs from "dayjs";
+export declare function replaceTemplate(template: string, replacements: IKeyValue): string;
+export declare function parsePerid(period: string): (string | number)[];
+export declare function generateRandomId(length?: number): string;
+export declare function parseTimezoneOffset(timezone: string): number;
+export declare function parserTimezone(time?: number, timezone?: string): dayjs.Dayjs;
+export declare function periodConvert(period: string): number;

package/lib/components/editor/parseScript/visitorParser.d.ts

@@ -0,0 +1,303 @@
+import { IKeyObjectValue, IDocValue, IKeyValue } from '../type';
+import { VRuleType } from './enum';
+import { ParserUtils } from './visitorUtils';
+import { IError, IPosition } from "./type";
+export default class ParserVisitor extends ParserUtils {
+    private _loopCount;
+    private _errors;
+    private _variables;
+    private _functions;
+    private _methods;
+    private _types;
+    private _currentBlockVars;
+    private _currentFuncParams;
+    private _isNeedCalc;
+    private _blockCount;
+    private _isInFunc;
+    private _onlyStatementsCount;
+    private _blockRanges;
+    private _overloadsFuncs;
+    private _hasMemberIndex;
+    private _isInLocalScop;
+    constructor(props: IKeyObjectValue);
+    get overloadsFuncs(): IKeyValue[];
+    get errors(): IError[];
+    get userTypes(): Map<string, IDocValue[]>;
+    get userFunctions(): Map<string, IDocValue[]>;
+    get userVariables(): Map<string, IDocValue[]>;
+    get userMethods(): Map<string, IDocValue[]>;
+    visitProgram: (ctx: IKeyObjectValue) => any[];
+    visitGlobalStmt: (ctx: IKeyObjectValue) => any;
+    visitBlockStmt: (ctx: IKeyObjectValue) => IKeyObjectValue[];
+    visitStmt: (ctx: IKeyObjectValue) => any;
+    visitSimpleStmt: (ctx: IKeyObjectValue) => any;
+    visitFlowStmt: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        value: any;
+    };
+    visitBlock: (ctx: IKeyObjectValue) => any;
+    visitBlockLine: (ctx: IKeyObjectValue) => any[] | null;
+    visitDeclareAssign: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitAgainAssign: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        name: IKeyObjectValue;
+        operator: string;
+        type: string;
+        value: IKeyObjectValue;
+    } | null;
+    visitVarModifier: (ctx: IKeyObjectValue) => any;
+    visitExpressionSequence: (ctx: IKeyObjectValue) => IKeyObjectValue[];
+    visitExpressionBlockSequence: (ctx: IKeyObjectValue) => IKeyObjectValue[];
+    visitBlockSequence: (ctx: IKeyObjectValue) => IKeyObjectValue[];
+    visitVariableDeclarationStmt: (ctx: IKeyObjectValue) => IKeyObjectValue[];
+    visitVarBlockStmt: (ctx: IKeyObjectValue) => IKeyObjectValue | {
+        ruleType: VRuleType;
+        name: IKeyObjectValue;
+        operator: string;
+        type: string;
+        value: IKeyObjectValue;
+    };
+    visitVarSingle: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitVarMultiple: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        names: IKeyObjectValue[];
+        posList: IPosition[];
+    };
+    visitBlockExpression: (ctx: IKeyObjectValue) => any;
+    visitParenthesizedExpression: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        type: any;
+        ctx: IKeyObjectValue;
+        exprs: any;
+    };
+    visitAdditiveExpression: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitRelationalExpression: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        operator: string;
+        ctx: IKeyObjectValue;
+        type: string;
+        exprs: IKeyObjectValue[];
+    };
+    visitEqualityExpression: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        operator: string;
+        ctx: IKeyObjectValue;
+        type: string;
+        exprs: IKeyObjectValue[];
+    };
+    visitTernaryExpression: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        type: string;
+        ctx: IKeyObjectValue;
+        exprs: IKeyObjectValue[];
+    };
+    visitNameExpression: (ctx: IKeyObjectValue) => any;
+    visitLiteralExpression: (ctx: IKeyObjectValue) => any;
+    visitUnaryExpression: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        operator: any;
+        type: any;
+        ctx: IKeyObjectValue;
+        exprs: IKeyObjectValue[];
+    };
+    visitNotExpression: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        ctx: IKeyObjectValue;
+        type: string;
+        exprs: IKeyObjectValue[];
+    };
+    visitMemberIndexExpression: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        type: any;
+        ctx: IKeyObjectValue;
+        isInFunc: boolean;
+        exprs: IKeyObjectValue[];
+    };
+    visitMethodStmt: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        types: any;
+        ctx: IKeyObjectValue;
+        type: any;
+        exprs: any[];
+    };
+    visitMethodExpression: (ctx: IKeyObjectValue) => any;
+    visitLogicalAndExpression: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        type: string;
+        operator: string;
+        ctx: IKeyObjectValue;
+        exprs: IKeyObjectValue[];
+    };
+    visitLogicalOrExpression: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        operator: string;
+        ctx: IKeyObjectValue;
+        type: string;
+        exprs: IKeyObjectValue[];
+    };
+    visitMultiplicativeExpression: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        operator: string;
+        ctx: IKeyObjectValue;
+        type: string;
+        exprs: IKeyObjectValue[];
+    };
+    visitBrackethesized: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        ctx: IKeyObjectValue;
+        exprs: any;
+    };
+    visitArguments: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitArgument: (ctx: IKeyObjectValue) => any;
+    visitIfStatement: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitForToStatement: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitForInStatement: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitSwitchStatement: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitCaseClause: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitDefaultCaluse: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitWhileStatement: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitImportStmt: (ctx: IKeyObjectValue) => IKeyObjectValue[];
+    visitImportElement: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitLiteral: (ctx: IKeyObjectValue) => {
+        ruleType: VRuleType;
+        ctx: IKeyObjectValue;
+        type: string;
+        value: any;
+    };
+    visitMethodElement: (ctx: IKeyObjectValue) => {
+        name: any;
+        type: any;
+        args: any;
+        expr: any;
+    };
+    visitMethodName: (ctx: IKeyObjectValue) => any[];
+    visitArrowFunction: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitArrowFunctionParameters: (ctx: IKeyObjectValue) => IKeyObjectValue[];
+    visitFormalParameterList: (ctx: IKeyObjectValue) => IKeyObjectValue[];
+    visitFormalParameterArg: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitArrowMethod: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitArrowMethodParameters: (ctx: IKeyObjectValue) => any[];
+    visitTypeStatement: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitTypeElement: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    visitAssignmentOperator: (ctx: IKeyObjectValue) => any;
+    visitTypeMap: (ctx: IKeyObjectValue) => string;
+    visitTypeSeries: (ctx: IKeyObjectValue) => string;
+    visitTypeArray: (ctx: IKeyObjectValue) => string;
+    visitTypeGather: (ctx: IKeyObjectValue) => any;
+    visitIdentifier: (ctx: IKeyObjectValue) => any;
+    visitTypeName: (ctx: IKeyObjectValue) => string;
+    visitName: (ctx: IKeyObjectValue) => IKeyObjectValue;
+    private _typeElementVerify;
+    private _memberIndexVerify;
+    private _setFuncParams;
+    private _pushBlockRanges;
+    private _setUserType;
+    private _againAssignHandle;
+    private _typeCheck;
+    private _verifyName;
+    private _nameCheck;
+    private _inBlock;
+    private _errorHandle;
+    private _boolTypeJudge;
+    private _calcTypeJudge;
+    private _typeJudge;
+    /**
+     * 判断数组中的对象类型是否一致，支持根据操作符和指定的类型集合对类型进行动态判断和调整。
+     * @param arr - 用于判断类型的对象数组
+     * @param children - 与 arr 对应的子对象数组，用于在类型不匹配时进行错误处理
+     * @param operator - 当前操作符，影响类型判断的逻辑
+     * @param supportTypes - 支持的类型数组，会根据操作符动态调整
+     * @returns 返回一个数组，包含每个对象根据判断逻辑确定的类型
+     */
+    private _sameTypeJudge;
+    private _getUserVar;
+    private _repeatVarJudge;
+    private _judgeVarBuildIn;
+    private _updateUserVar;
+    private _variablesHandle;
+    private _checkVarMultiple;
+    private _addVarToMap;
+    private _setVariablesMap;
+    private _varTypeJudge;
+    private _getAllowTypes;
+    private _setNewFunc;
+    private _setCopyFunc;
+    private _setCopyMethod;
+    private _setFunc;
+    private _setMethod;
+    private _getMethodTypes;
+    private _globalFuncVerify;
+    private _hasMemberIndexVerify;
+    private _tempFuncNameHandle;
+    private _getOtherNamesMethodType;
+    private _expandMethodHandle;
+    /**
+     * 根据函数参数和上下文获取内置返回类型。
+     * @param res 函数匹配结果数组，包含返回类型、语法和参数信息。
+     * @param args 函数调用时的实际参数对象。
+     * @param name 函数名，用于错误处理时的提示。
+     * @param ctx 函数调用的上下文对象。
+     * @param fArg 函数的首个特定参数，可选，用于某些特殊场景下的类型检查。
+     * @param type 预期的返回类型数组，可选，用于进一步筛选返回类型。
+     * @returns 返回可能的返回类型数组。可能是一个确定的类型数组，或者在类型不匹配时返回[VType.UNDETERMINED]。
+     */
+    private _getBuildInReturnTypes;
+    /**
+      * 根据提供的函数列表和当前参数，获取匹配的函数返回类型。
+      * @param funcs 函数列表，每个函数包含参数信息、返回类型、函数名和this类型。
+      * @param currentArgs 当前调用的参数对象。
+      * @param ctx 当前上下文对象，包含代码位置等信息。
+      * @param fArg 可选，指定的首个参数，用于重载判断。
+      * @returns 匹配的函数返回类型，如果没有匹配则返回'UNDETERMINED'。
+      */
+    private _overloadsFuncGetTypes;
+    private _funcArgsAddOriginName;
+    /**
+     * 检查函数参数数量和类型是否符合预期
+     * @param args 提供的参数对象，包含实际参数和参数对象
+     * @param originArgs 预期的参数列表
+     * @param name 函数名称
+     * @param ctx 上下文信息，用于错误定位
+     * @param firstArg 第一个参数的对象，用于某些特定的参数检查
+     * @returns 返回一个对象，包含错误信息和警告信息
+     */
+    private _overloadsCheckArgs;
+    /**
+      * 检查传入参数的数量和类型是否符合预期
+      * @param args 包含所有参数的对象
+      * @param originArgs 原始参数列表
+      * @param name 函数或方法的名称
+      * @param ctx 上下文信息，用于错误处理
+      * @param returnType 函数预期的返回类型
+      * @param firstArg 第一个参数的详细信息，可选
+      * @returns 返回一个对象，包含是否有错误和可能的类型信息
+      */
+    private _checkArgs;
+    /**
+     * 校验参数是否符合给定的规则。
+     * @param arg 需要校验的参数对象，包含参数的规则类型、表达式和名称等信息。
+     * @param originArg 原始参数对象，包含参数的允许类型ID、显示类型和名称等信息。
+     * @param name 参数的当前名称。
+     * @param firstArg 如果是重载函数，第一个参数的对象。
+     * @param ctx 参数的上下文信息，可选。
+     * @param isOverloads 是否为重载函数的标志，可选。
+     * @returns 如果参数校验通过，返回true；否则返回false。
+     */
+    private _checkArg;
+    /**
+     * 将键值对对象转换为检查对象，用于验证参数类型是否匹配
+     * @param arg         要检查的键值对对象，包含规则类型和表达式数组
+     * @param originArg   原始参数对象，包含参数名和允许的类型ID
+     * @param needType    需要检查的类型数组
+     * @param name        操作符名称
+     * @param type        当前参数的类型
+     * @returns           如果类型不匹配，返回错误提示字符串；否则，返回undefined
+     */
+    private _tupleToCheck;
+    /**
+     * 获取块的返回类型
+     * @param block 可以是单个对象或者对象数组，代表一个代码块
+     * @returns 返回一个类型数组，表示该代码块可能的返回类型
+     */
+    private _getBlockReturnTypes;
+}

package/lib/components/editor/parseScript/visitorUtils.d.ts

@@ -0,0 +1,30 @@
+import { IDocValue, IKeyObjectValue } from "../type";
+import TccScriptParserVisitor from '../../../tccParser/tccScriptParserVisitor';
+export declare class ParserUtils extends TccScriptParserVisitor<any> {
+    protected _buildinVariables: Map<string, IDocValue[]>;
+    protected _buildinTypes: Map<string, IDocValue[]>;
+    protected _buildinConstants: Map<string, IDocValue[]>;
+    protected _buildinMethods: Map<string, IDocValue[]>;
+    protected _buildinFunctions: Map<string, IDocValue[]>;
+    constructor(buildinObj: IKeyObjectValue);
+    private _buildinHandle;
+    protected _typeHandle(types?: string[], rType?: string): string;
+    protected _returnTypesOtherHandle(firstArg: IKeyObjectValue, returnType: string, returnTypes: string[], name: string): string[];
+    protected _checkMethodThisType(thisType: string[], type: string): boolean;
+    protected _priorityComparison(currentType: string, targetType: string): boolean;
+    protected _compareType(currentType: string, targetType: string): boolean;
+    protected _typeAddSeries(type: string): string;
+    protected _typeAddConst(type: string): string;
+    protected _getOriginMethodName(type: string, lastName: string): string;
+    protected _returnedTypesParse(returnedTypes?: string[]): string[];
+    protected _removePrefix(type?: string): string;
+    protected _getPrefix(type: string): string;
+    protected _getArrayType(name: string): string | undefined;
+    protected _getMapType(name: string): "" | string[] | undefined;
+    protected _isMatrixType(type: string): boolean;
+    protected _isArrayType(type: string): boolean;
+    protected _isMapType(type: string): boolean;
+    protected _arrayTypeConvert(type: string): string;
+    protected _getMethodTypeName(type: string): string;
+    protected _typeReplace(returnType: string, type: string): string;
+}

package/lib/components/editor/parseScript/workerStorage.d.ts

@@ -0,0 +1,12 @@
+import { IKeyObjectValue } from "../type";
+export declare class WorkerStorage {
+    private _cache;
+    constructor();
+    set(key: string, value: IKeyObjectValue): void;
+    setValue(mapKey: string, valKey: string, value: IKeyObjectValue): void;
+    updateValue(mapKey: string, valKey: string, value: IKeyObjectValue): void;
+    get(key: string): IKeyObjectValue | undefined;
+    has(key: string): boolean;
+    delete(key: string): void;
+    clear(): void;
+}