udm-rules-vue 0.0.1

package/dist/grammar/CaretTokenDetection.d.ts

@@ -0,0 +1,123 @@
+import { TerminalNode } from 'antlr4ng';
+import { CaretData } from '../completion/CompletionBuilder';
+import { Datatype } from '../model/Datatype';
+import { PredefineSourceType } from '../model/expression/PredefineExpression';
+import { ActionsContext, ExpressionContext, PreconditionContext, PredefineObjectValueContext, RuleStatementContext } from './rule/RuleParser';
+/**
+ * 根据当前解析树以及光标位置，获取当前光标所在位置对应的Token信息
+ * @param context 解析树对象
+ * @param caretData 当前光标位置相关数据
+ * @returns 返回当前光标所在位置对应的Token信息，如果没找到Token信息，则返回undefined
+ */
+export declare const findRuleCaretTokenData: (context: RuleStatementContext, caretData: CaretData) => CaretTokenData | undefined;
+/**
+ * 根据当前解析树以及光标位置，获取当前光标所在位置对应的Token信息
+ * @param context 解析树对象
+ * @param caretData 当前光标位置相关数据
+ * @returns 返回当前光标所在位置对应的Token信息，如果没找到Token信息，则返回undefined
+ */
+export declare const findPreconditionCaretTokenData: (context: PreconditionContext, caretData: CaretData) => CaretTokenData | undefined;
+/**
+ * 根据当前解析树以及光标位置，获取当前光标所在位置对应的Token信息
+ * @param context 解析树对象
+ * @param caretData 当前光标位置相关数据
+ * @returns 返回当前光标所在位置对应的Token信息，如果没找到Token信息，则返回undefined
+ */
+export declare const findActionCaretTokenData: (context: ExpressionContext | ActionsContext, caretData: CaretData) => CaretTokenData | undefined;
+/**
+ * 根据当前解析树以及光标位置，获取当前光标所在位置对应的Token信息
+ * @param context 解析树对象
+ * @param caretData 当前光标位置相关数据
+ * @returns 返回当前光标所在位置对应的Token信息，如果没找到Token信息，则返回undefined
+ */
+export declare const findConditionCaretTokenData: (context: ExpressionContext, caretData: CaretData) => CaretTokenData | undefined;
+export declare const parsePredefineValueObjectType: (context: PredefineObjectValueContext) => Datatype | undefined;
+export type CaretTokenData = {
+    /**
+     * 记录当前光标所在位置之前的Other类开的Token文本，用于过滤提示项
+     */
+    filterText?: string;
+    /**
+     * token对象的tokenIndex属性值
+     */
+    index: number;
+    /**
+     * 当前光标所在位置上的Token对象对应的节点对象
+     */
+    terminalNode: TerminalNode;
+    /**
+     * 记录当前光标所在位置相对于当前Token的位置
+     */
+    caretTokenPosition: CaretTokenPosition;
+    /**
+     * 记录当前光标所在位置需要的对象类型信息，如果当前光标位置在预定义变量处，这里就记录当前预定义对象的类型信息;如果在一个动作导航里，这里就记录当前动作导航的类型信息
+     */
+    datatype?: Datatype;
+    /**
+     * 当前光标所在位置位于一个预定义变量的条件中，那么这里就记录当前预定义变量的来源：in/from
+     */
+    predefineSourceType?: PredefineSourceType;
+    /**
+     * 标识当前光标所在位置目标对象数量，对应的这里的datatype属性，以方便在编辑时提示代码提示；
+     * 如果为false，那么代码提示就应该是：当前这个xxx；如果为true，则提示内容为： 每个xxx
+     */
+    multipleObject?: boolean;
+    /**
+     * 标识当前光标所在位置，可能是predefine，if，action之类
+     */
+    location?: CaretLocation;
+    /**
+     * 标识当前光标所在位置是否位于一个预定义变量的条件中，如果是才允许提示当前这个xxx变量，否则不允许提示
+     */
+    inPredefineCondition?: boolean;
+    /**
+     * 标识当前光标是否位于数组表达式中，数组表达式格式为：{expr1,expr2,...}，数组表达式用来定义集合对象，其中对象用,号分隔，数量不固定
+     */
+    inArray?: boolean;
+    /**
+     * 标识当前光标是否位于表达式中
+     */
+    inExpression?: boolean;
+    /**
+     * 标识当前光标是否位于批量条件中，用于后续代码提示时是否提示~字符
+     */
+    inBatchCondition?: boolean;
+    /**
+     * 记录当前光标所在位置的未完成的变量导航信息，便于在代码补全时根据这些信息补全后续描述信息
+     */
+    variableSegments?: VariableSegments;
+    /**
+     * 用来记录当前光标处存在的静态方法描述片断，以及光标之前没有完成的方法描述片断，以便于后续根据这个信息找到未完成的方法以及当前光标位置方法参数类型
+     */
+    staticMethodDescriptorNodes?: TerminalNode[];
+    /**
+     * 用来记录当前光标处存在的变量方法描述片断，以及光标之前没有完成的方法描述片断，以便于后续根据这个信息找到未完成的方法以及当前光标位置方法参数类型
+     */
+    variableMethodDescriptorNodes?: TerminalNode[];
+};
+/**
+ * 一个枚举值，用来表示当前光标所在位置相对于当前Token的位置
+ */
+export declare enum CaretTokenPosition {
+    before = 0,
+    in = 1,
+    after = 2
+}
+export declare enum CaretLocation {
+    documentation = 0,
+    predefine = 1,
+    if = 2,
+    then = 3,
+    else = 4,
+    action = 5
+}
+/**
+ * 用于记录当前光标所在位置的变量某一部分描述信息，那么这里就用来记录这部分信息之前的描述信息，以便于的代码补全时根据这些信息补充后续描述信息
+ */
+export type VariableSegments = {
+    segments: string[];
+    /**
+     * 这里记录具体变量名，以便于在过滤时先直接筛选变量，以缩小过滤范围
+     */
+    variableName: string;
+};

package/dist/grammar/DatatypeBuilder.d.ts

@@ -0,0 +1,16 @@
+import { ParseTree, TerminalNode } from 'antlr4ng';
+import { Datatype } from '../model/Datatype';
+import { ExpressionContext, LiteralContext, Method1Context, Method2Context, Method3Context, PrimaryContext, VariableContext } from './rule/RuleParser';
+/**
+ * 给出解析树对象，返回对应的数据类型。这个方法专门供代码提示使用，用于解析光标所在位置的数据类型。
+ *
+ * @param parseTree 解析树对象
+ * @param avaliablePredefineVariablesMap 可用的预定义变量
+ * @returns 解析树对应的对象数据类型
+ */
+export declare const buildParseTreeDatatypeForCaret: (parseTree: ParseTree | null, avaliablePredefineVariablesMap: Map<string, Datatype>) => Datatype | undefined;
+export declare const buildExpressionDatatype: (context: ExpressionContext | PrimaryContext, avaliablePredefineVariablesMap: Map<string, Datatype>) => Datatype | undefined;
+export declare const buildPlaceholderDatatype: (placeholder: TerminalNode) => Datatype | undefined;
+export declare const buildMethodDatatype: (context: Method1Context | Method2Context | Method3Context) => Datatype | undefined;
+export declare const buildVariableContextDatatype: (context: VariableContext, avaliablePredefineVariablesMap: Map<string, Datatype>) => Datatype | undefined;
+export declare const buildLiteralDatatype: (parent: LiteralContext) => Datatype | undefined;

package/dist/grammar/LexerTokenConsumer.d.ts

@@ -0,0 +1,27 @@
+import { DescriptorNode } from '../model/NavigationTree';
+import { RuleLexer } from './rule/RuleLexer';
+declare class LexerTokenConsumer {
+    consumeMatchedToken(lexer: RuleLexer, matchedToken: MatchedToken): void;
+    isWS(lexer: RuleLexer): boolean;
+    /**
+     * 判断当前位置字符串是否与给定的字符串是否匹配，如果匹配则返回匹配的Token对象，否则返回上一次可能存在的匹配的Token对象
+     * @param lexer 词法器对象
+     * @param word 要判断的字符串
+     * @param matchedToken 已存在的匹配的Token对象
+     * @param node 当前判断字符串所属性导航节点
+     * @returns 返回匹配的Token对象
+     */
+    aheadWord(lexer: RuleLexer, word: string, matchedToken: MatchedToken | undefined, node: DescriptorNode | undefined): MatchedToken | undefined;
+    private ahead;
+}
+export type MatchedToken = {
+    word: string;
+    position: number;
+    /**
+     * 包含该属性且值为true，表示当前已赢取到文件末尾
+     */
+    eof?: boolean;
+    node?: DescriptorNode;
+};
+declare const lexerTokenConsumer: LexerTokenConsumer;
+export default lexerTokenConsumer;

package/dist/grammar/MethodHelper.d.ts

@@ -0,0 +1,43 @@
+import { TerminalNode } from 'antlr4ng';
+import { Datatype } from '../model/Datatype';
+import { NavigationNode } from '../model/NavigationTree';
+import { CaretTokenData } from './CaretTokenDetection';
+import { MethodData } from './SearchMethod';
+declare class MethodHelper {
+    /**
+     * 根据当前光标位置相关数据信息以及可能存在的数据类型，计算出当前是否位于静态方法中，如果是那还要计算出当前光标位置对应的方法参数以及可能存在的未完成的方法节点
+     * @param data 当前光标位置相关数据信息
+     * @returns 返回方法参数及未完成的方法描述节点
+     */
+    buildParameterDatatypeAndIncompleteMethods(data: CaretTokenData, avaliablePredefineVariablesMap: Map<string, Datatype>): {
+        expectDatatype: Datatype | undefined;
+        caretCompletedMethodDatatype: Datatype | undefined;
+        currentMethodData: MethodData | undefined;
+        incompleteMethodNodes: NavigationNode[];
+    } | undefined;
+    findTargetMethodParameterDatatype(parameterIndex: number, targetMethods: NavigationNode[]): Datatype | undefined;
+    /**
+     * 根据匹配到的方法节点，如果当前匹配的节点是最后一个方法参数或描述符，那么这里就返回该方法的返回值对应的数据类型
+     * @param matchedNodes 匹配到的方法节点
+     * @param caretDatatype 当前位置的数据类型
+     * @param terminalNode 当前匹配到的方法的最后一个节点对象
+     * @returns 返回匹配到的最后一个方法节点的返回值对应的数据类型
+     */
+    buildCompletedMethodsReturnDatatype(matchedNodes: NavigationNode[], caretDatatype: Datatype | undefined, terminalNode: TerminalNode | undefined): Datatype | undefined;
+    /**
+     * 从已匹配到的方法节点中，获取其第一个参数的类型
+     * @param matchedMethodNodes 已匹配到的方法节点
+     */
+    buildFirstParameterDatatype(matchedMethodNodes: NavigationNode[]): Datatype[];
+    private buildMethodReturnDatatype;
+    /**
+     * 根据已匹配的方法节点，构建当前位置的方法参数类型。
+     *
+     * @param methodNodes 已匹配的方法节点
+     * @param flat 是否需要展开
+     * @returns 返回已匹配的方法节点对应的参数类型与当前可能存在的表达式参数类型是否匹配，如果匹配则不需要返回方法参数类型，否则返回
+     */
+    private buildMethodsParameterDatatype;
+}
+declare const methodHelper: MethodHelper;
+export default methodHelper;

package/dist/grammar/ParserException.d.ts

@@ -0,0 +1,3 @@
+export declare class ParserException extends Error {
+    constructor(message: string);
+}

package/dist/grammar/ParserHelper.d.ts

@@ -0,0 +1,80 @@
+import { Token } from 'antlr4ng';
+import { ObjectDefine } from '../model/BO';
+import { Datatype } from '../model/Datatype';
+import { NavigationNode } from '../model/NavigationTree';
+import { RuleLexer } from './rule/RuleLexer';
+import { ParsePosition } from './TokenAssertor';
+export declare class ParserHelper {
+    /**
+     * 在进行导航匹配时，如果遇到了一个静态方法导航节点，那么就将这个匹配的方法导航节点保存到当前这个栈中。
+     * 后续在匹配时，会先检查这个栈中是否为空，如果不为空，则尝试取栈中最后一个节点进行匹配测试；如果匹配后的节点下没有子节点，则将栈中这个最后的节点从栈中移除。
+     * 如果栈中不存在节点，或者最后一个节点与当前Token不匹配，那么就从导航树的根部查找可能存在的方法导航节点，同样，如果存在那么就push当前栈中。
+     */
+    private matchedMethodNodesStack;
+    private allowSearchType;
+    private parsePosition;
+    private previsousToken;
+    /**
+     * 用来记录匹配到的方法导航节点，将匹配的方法导航节点保存到这里，以备在Parser中使用，因为Parser在拿到当前的方法描述符对应的Token时，
+     * 也需要根据这个Token来找到对应的目标方法，所以为了在Parser中少查询一次，就将匹配的方法导航节点保存到这里。
+     */
+    private currentMatchedMethodNode;
+    /**
+     * 记录当前匹配的变量导航树节点，以为下次匹配判断做准备。
+     */
+    private matchedVariableNavigationNodes;
+    private clean;
+    /**
+     * 词法解析中每次解析一个Token都需要通过这个方法来判断当前解析的位置，
+     * 同时决定在当前Token之后是否需要判断后续Token是否为变量、方法等。此方法用于Lexer的nextToken方法中调用。
+     * @param token 在词法解析中的Token对象
+     * @returns 返回可能经过处理的Token
+     */
+    assertToken(token: Token): void;
+    assertObjectName(lexer: RuleLexer): boolean;
+    /**
+     * 在词法解析器中遇到的变量名时需要调用的方法，尝试通过这个变量名以确定后续的导航树
+     * @param variableName 在词法解析器中遇到的变量名
+     * @param avaliablePredefineVariablesMap 当前位置上可用的预定义变量信息
+     */
+    encounterVariableName(variableName: string, avaliablePredefineVariablesMap: Map<string, Datatype>): void;
+    assertEnumDescriptor(lexer: RuleLexer): boolean;
+    assertFieldDescriptor(lexer: RuleLexer): boolean;
+    assertMethodDescriptor(lexer: RuleLexer): boolean;
+    removeMatchedMethodNodes(needRemoveNodes: NavigationNode[] | undefined): void;
+    private existClassParameter;
+    /**
+     * 构建当前已匹配的方法堆栈中最后一个匹配的方法
+     * @param index 从栈顶开始数的索引，为0，也就是最后一个匹配的方法
+     * @returns 返回当前已匹配的方法堆栈中最后一个匹配的方法导航节点对象
+     */
+    private loadTargetIndexMatchedMethodNodes;
+    private aheadTokenDetection;
+    getCurrentMatchedMethodNode(): NavigationNode | undefined;
+    allowSearch(type: AllowSearchType): boolean;
+    get currentPrsePosition(): ParsePosition;
+    set currentAllowSearchType(type: AllowSearchType);
+    set currentParsePosition(position: ParsePosition);
+}
+export declare enum AllowSearchType {
+    /**
+     * 搜索对象
+     */
+    Object = 0,
+    /**
+     * 搜索参数
+     */
+    Variable = 1,
+    /**
+     * 搜索方法描述符
+     */
+    Descriptor = 2,
+    /**
+     * 不允许搜索任何内容
+     */
+    None = 3
+}
+export type FieldDefineNavigationNode = {
+    node: NavigationNode;
+    object: ObjectDefine;
+};

package/dist/grammar/SearchMethod.d.ts

@@ -0,0 +1,15 @@
+import { ParseTree, TerminalNode } from 'antlr4ng';
+import { MethodDefine } from '../model/BO';
+import { Datatype } from '../model/Datatype';
+import { NavigationNode } from '../model/NavigationTree';
+export declare const findMethodsByDescriptorNodes: (staticMethodDescriptorNodes: TerminalNode[]) => {
+    parentMethodData: MethodData | undefined;
+    parentMethodContext: ParseTree | undefined;
+    currentMethodData: MethodData | undefined;
+    incompleteMethodNodes: NavigationNode[];
+};
+export type MethodData = {
+    targetMethod?: MethodDefine;
+    methodReturnDatatype?: Datatype;
+    currentParameterDatatype?: Datatype;
+};

package/dist/grammar/TokenAssertor.d.ts

@@ -0,0 +1,34 @@
+import { Token } from 'antlr4ng';
+import { AllowSearchType } from './ParserHelper';
+/**
+ * 根据当前Token的位置，来判断当前的解析位置以及是否允许搜索变量或者对象
+ * @param token Token对象
+ * @returns 返回当前Token的解析位置以及是否允许搜索变量或者对象
+ */
+export declare const doAssertToken: (token: Token, parsePosition: ParsePosition) => {
+    parsePosition: ParsePosition;
+    allowSearchType: AllowSearchType;
+};
+export declare const isOperateToken: (token: Token) => boolean;
+export declare const isLiteralToken: (token: Token) => boolean;
+/**
+ * 用于在词法解析时标记当前解析的位置
+ */
+export declare enum ParsePosition {
+    /**
+     * 当前解析处于规则开始部分
+     */
+    Property = "Property",
+    /**
+     * 当前解析处于预定义部分
+     */
+    PredefinePart = "PredefinePart",
+    /**
+     * 当前解析处于条件部分
+     */
+    IfPart = "IfPart",
+    /**
+     * 当前解析处于动作部分
+     */
+    ActionPart = "ActionPart"
+}

package/dist/grammar/bom/BomLexer.d.ts

@@ -0,0 +1,55 @@
+import * as antlr from "antlr4ng";
+export declare class BomLexer extends antlr.Lexer {
+    static readonly Public = 1;
+    static readonly Class = 2;
+    static readonly Interface = 3;
+    static readonly Static = 4;
+    static readonly Abstract = 5;
+    static readonly Final = 6;
+    static readonly ReadOnly = 7;
+    static readonly Writeonly = 8;
+    static readonly Property = 9;
+    static readonly Domain = 10;
+    static readonly Package = 11;
+    static readonly Extends = 12;
+    static readonly Implements = 13;
+    static readonly Throws = 14;
+    static readonly EnumClass = 15;
+    static readonly GenericityObjectCount = 16;
+    static readonly Dot = 17;
+    static readonly Colon = 18;
+    static readonly Comma = 19;
+    static readonly Null = 20;
+    static readonly LeftBrace = 21;
+    static readonly RightBrace = 22;
+    static readonly Semicolon = 23;
+    static readonly LeftBracket = 24;
+    static readonly RightBracket = 25;
+    static readonly LeftParen = 26;
+    static readonly RightParen = 27;
+    static readonly String = 28;
+    static readonly Float = 29;
+    static readonly Integer = 30;
+    static readonly Identifier = 31;
+    static readonly Char = 32;
+    static readonly WS = 33;
+    static readonly channelNames: string[];
+    static readonly literalNames: (string | null)[];
+    static readonly symbolicNames: (string | null)[];
+    static readonly modeNames: string[];
+    static readonly ruleNames: string[];
+    constructor(input: antlr.CharStream);
+    get grammarFileName(): string;
+    get literalNames(): (string | null)[];
+    get symbolicNames(): (string | null)[];
+    get ruleNames(): string[];
+    get serializedATN(): number[];
+    get channelNames(): string[];
+    get modeNames(): string[];
+    static readonly _serializedATN: number[];
+    private static __ATN;
+    static get _ATN(): antlr.ATN;
+    private static readonly vocabulary;
+    get vocabulary(): antlr.Vocabulary;
+    private static readonly decisionsToDFA;
+}