udm-rules-vue 0.0.1

package/dist/model/NavigationTree.d.ts

@@ -0,0 +1,207 @@
+import { FieldDefine, MethodDefine, ObjectDefine, VariableDefine } from './BO';
+import { Datatype } from './Datatype';
+export declare const THIS_REGEX: RegExp;
+export declare const BO_LOADED = "BO_LOADED";
+/**
+ * 语法解析时使用的BOM对象导航树，里面包含对BOM对象本身，也就是变量，以及其属性和方法的树结构定义，同时还有枚举类型的树结构定义
+ */
+declare class NavigationTree {
+    private nodeMap;
+    /**
+     * 用来存储那些有operator描述的方法定义，这些方法定义可以用在决策表条件单元格中或决策树连线里，用来重定义条件。
+     * key为方法在voc文件中定义的operatorExpression，value为方法定义对象
+     */
+    methodOperatorExpressionMap: Map<string, MethodDefine>;
+    /**
+     * 用来存储那些有operator属性值的静态方法定义，这些静态方法定义可以用在决策表条件单元格中，用来改变单元格绑定的条件
+     */
+    operatorStaticMethodDefines: MethodDefine[];
+    /**
+     * 用来存在业务对象名称，专门用于词法分析时对业务对象进行匹配，在填充完所有的业务对象后，
+     * 需要对这个集合进行排序，排序方式为按长度阡序排列，以保证词法解析时找到的第一个对象就是匹配到的对象
+     */
+    businessObjectNames: string[];
+    /**
+     * 用来存放所有的业务对象的占位符，key为具体占位符值，value为对应对象的{@link Datatype}对象
+     */
+    businessObjectPlaceHolderMap: Map<string, Datatype>;
+    /**
+     * key为对对应业务对象的完整类名
+     */
+    businessObjectNodesClassNameMap: Map<string, ObjectNodeType>;
+    /**
+     * key为对对应业务对象的 verbalization
+     */
+    businessObjectNodesVerbalizationMap: Map<string, ObjectNodeType>;
+    /**
+     * 用于存储变量的入口节点Map，key为具体的以单引号包裹的变量描述名，value为对应的{@link VariableData}对象
+     */
+    variableVerbaliztionMap: Map<string, VariableData>;
+    /**
+     * 用于存储变量的入口节点Map，key为具体的以单引号包裹的变量名，value为对应的{@link VariableData}对象
+     */
+    variableNameMap: Map<string, VariableData>;
+    /**
+     * 保存所有静态方法(导航类型/赋值类型)根节点（含以参数开头和以描述开头的方法），以便于在词法解析时使用。
+     * 目前该集合主要用于词法解析，但在解析时需要找到最长匹配的方法描述符，所以从性能角度考虑，需要在所有方法添加进去之后对其进行排序，排序按描述符长度进行
+     */
+    allMethodNodes: NavigationNode[];
+    /**
+     * 保存普通的不以参数开头的字段赋值类型的静态方法根节点保存在这个Map中，以便于在词法解析时可以快速根据第一个方法描述符找到所有可能的方法
+     */
+    normalActionMethodsMap: Map<string, NavigationNode[]>;
+    /**
+     * 保存普通的不以参数开头的导航类型的静态方法根节点保存在这个Map中，以便于在词法解析时可以快速根据第一个方法描述符找到所有可能的方法
+     */
+    normalNavigationMethodsMap: Map<string, NavigationNode[]>;
+    /**
+     * 用来存放那些以参数开头的赋值类型的静态方法
+     */
+    parameterStartActionMethods: NavigationNode[];
+    /**
+     * 用来存放那些以参数开头的赋值类型的静态方法，这里忽略其第一个参数，以第一个描述符作为key
+     */
+    parameterStartActionMethodsMap: Map<string, NavigationNode[]>;
+    /**
+     * 用来存放那些以参数开头的导航类型的静态方法，比如比较用的大于、小于、等于之类
+     */
+    parameterStartNavigationMethods: NavigationNode[];
+    /**
+     * 用来存放那些以参数开头的导航类型的静态方法，比如比较用的大于、小于、等于之类，这里忽略其第一个参数，以第一个描述符作为key
+     */
+    parameterStartMethodsMap: Map<string, NavigationNode[]>;
+    /**
+     * 存储enum类型（静态属性）的Map，key为这个枚举类型的类型对应的类名，value为对应字段的FieldDefine。
+     * 这种类型的值只用于填充方法参数，或者赋值字段属性（赋值类型的静态方法）的导航类型。
+     */
+    enumClassNameMap: Map<string, FieldDefine[]>;
+    /**
+     * 用来存储所有的枚举类型的 verbalization，key为枚举属性对应的verbalization，value为枚举属性对象，该集合主要用于语法解析，让词法解析器可以快速判断当前Token是否为一个枚举类型的静态属性。
+     */
+    enumVerbalizationMap: Map<string, FieldDefine>;
+    private clean;
+    /**
+     * 根据给出的预定义变量名，返回可能存在的预定义变量对应的对象信息
+     * @param variableName 预定义变量名
+     * @returns 返回可能存在的预定义变量对应的对象信息
+     */
+    findObjectByPredefineVariable(variableName: string, avaliablePredefineVariablesMap: Map<string, Datatype>): {
+        datatype: Datatype;
+        objectNodeType: ObjectNodeType | undefined;
+    } | undefined;
+    addVariableDefine(variableDefine: VariableDefine): void;
+    private buildVariableNodes;
+    addObjectDefines(objectDefines: ObjectDefine[], variableDefines: VariableDefine[]): void;
+    /**
+     * 将一个业务对象中的所有枚举字段，添加到枚举字段集合中，便于在解析及代码提示时使用
+     * @param objectDefine 业务对象定义
+     * @param enumVerbalizationSet 一个用来防止重复枚举 verbalization 的Set
+     */
+    private buildObjectDefineEnumFields;
+    /**
+     * 将当前方法导航根节点添加到静态方法导航根节点数组中，以便于在词法解析时使用
+     * @param rootMethodNode 根方法导航节点
+     * @param forAction 是否是动作方法，如果不是则为导航用方法
+     */
+    private buildMethods;
+    private nodeContainsMethodOrField;
+    private buildFieldChildrenDatatypesMap;
+    private addObjectDefine;
+    private buildMethodDefineOperatorExpression;
+    /**
+     * 将类型为对象的属性最后一个节点与目标对象的子节点链接起来
+     * @param fieldDefineNavigationNodes 对象属性导航节点数组
+     */
+    private linkFieldDefineNavigationNodes;
+    private buildFieldDefineDatatype;
+    private createMethodTreeNode;
+    private createStaticMethodTreeNode;
+    /**
+     * 如果当前方法是一个列表方法（方法名为list，只有一个集合参数且参数类型为对象类型，且返回值也是一个集合对象类型），
+     * 则创建一个由大括号、对象类型以及逗号组成的循环链表，通过这个循环链表就可以实现导航时由对象和逗号组成的无限输入。
+     *
+     * 注意：在创建这个循环链表时，不能缓存节点，也就是说它是独立于其它节点存在的，以免导致错误。
+     * @param method 对象方法定义
+     * @param parentNode 父节点
+     * @returns 返回当前方法定义是否为一个内置的数组类型的方法定义
+     */
+    private buildCircleListMethod;
+    /**
+     * 创建字段描述的导航树节点
+     * @param field 字段定义对象
+     * @param fullClassName 字段所属对象类名
+     * @param parentNode 父节点
+     * @returns 返回最后一个描述节点
+     */
+    private createFieldTreeNode;
+    private createActionTreeNode;
+    private buildKey;
+    private newDescriptorNode;
+}
+export interface NavigationNode {
+    element: any;
+    children: NavigationNode[];
+    key?: string;
+}
+export declare class DescriptorNode implements NavigationNode {
+    /**
+     * 记录element对应的去空格后的值，用于在语法解析时查询方法使用
+     */
+    descriptor: string;
+    /**
+     * 记录当前节点原始值，包含空格在内的所有字符
+     */
+    element: string;
+    /**
+     * 标识当前节点是否为方法参数，如果是那么这个属性就存储对应参数的Datatype
+     */
+    parameterDatatype?: Datatype;
+    /**
+     * 父节点的key+当前节点的label
+     */
+    key: string;
+    /**
+     * 目标对象集合，这里是一个Set对象，因为在构建导航树时，节点是共享的，共享的节点可能只有label相同，
+     * 但对应的数据类型和目标对象不同，同时为了更快检查当前对象是否在这个节点中存在，所以这里使用Set保存目标对象，
+     */
+    targets: Set<ObjectDefine | FieldDefine | MethodDefine>;
+    /**
+     * 表示绑定当前节点的对象或方法的描述信息到这个节点已经完成，那么就将目标对象设置到这个属性上，而不放置在上面的targets属性中
+     */
+    target: MethodDefine | undefined;
+    children: NavigationNode[];
+    constructor(element: string, key: string, target?: FieldDefine | MethodDefine | undefined);
+}
+export declare const buildTip: (set: Set<ObjectDefine | FieldDefine | MethodDefine>) => string;
+export declare class VariableNamePlaceholderNode implements NavigationNode {
+    element: any;
+    children: NavigationNode[];
+    key?: string | undefined;
+    static readonly this = "this";
+    static readonly element: string;
+}
+export declare class ObjectDefineNode implements NavigationNode {
+    element: ObjectDefine;
+    children: NavigationNode[];
+    constructor(element: ObjectDefine);
+    key?: string | undefined;
+}
+export type ObjectNodeType = {
+    /**
+     * 对应导航属性的节点
+     */
+    navigation: ObjectDefineNode;
+    /**
+     * 目标对象
+     */
+    objectDefine: ObjectDefine;
+};
+export type VariableData = {
+    variable: VariableDefine;
+    objectNodeType: ObjectNodeType | undefined;
+};
+export type MethodData = {
+    allMethodNodes: NavigationNode[];
+};
+declare let navigationTree: NavigationTree;
+export default navigationTree;

package/dist/model/PureWebBomFilesReader.d.ts

@@ -0,0 +1,13 @@
+export declare const loadBomFilesForWeb: (loadBomFilesCallback: () => Promise<{
+    fileName: string;
+    content: string;
+}[]>, loadVocFilesCallback: () => Promise<{
+    fileName: string;
+    content: string;
+}[]>, loadVarFilesCallback: () => Promise<{
+    fileName: string;
+    content: string;
+}[]>, loadProjectFilesCallback: () => Promise<{
+    fileName: string;
+    content: string;
+}[]>) => Promise<void>;

package/dist/model/RuleProperty.d.ts

@@ -0,0 +1,6 @@
+import { Datatype } from './Datatype';
+export declare const getRulePropertyMap: () => Map<string, RulePropertyValue>;
+export type RulePropertyValue = {
+    datatype: Datatype;
+    insertText: string;
+};

package/dist/model/VarFilesReader.d.ts

@@ -0,0 +1,9 @@
+import { ObjectDefine, VariableDefine } from './BO';
+export declare class VarFilesReader {
+    private objectDefines;
+    private variableDefines;
+    constructor(objectDefines: ObjectDefine[]);
+    doReadVarFile(xml: string, file: string): void;
+    getVariableDefines(): VariableDefine[];
+    getObjectDefines(): ObjectDefine[];
+}

package/dist/model/VocFilesReader.d.ts

@@ -0,0 +1,77 @@
+import { SemanticErrorData } from '../grammar/diagnostic/SemanticDiagnostic';
+import { BusinessObject, BusinessObjectBunch, ObjectDefine } from './BO';
+export default class VocFilesReader {
+    private objectDefines;
+    private declareMap;
+    /**
+     * key为对象的className，与入参的bomMap对象不同的是，bomMap的key为对象名的描述
+     */
+    private bomClassNameMap;
+    /**
+     * 用来记录产生的所有的字段定义信息，在解析完成所有的对象后，在最后统一设置字段对象的type属性
+     */
+    private fileDefines;
+    constructor(declareMap: Map<string, BusinessObjectBunch>);
+    doReadVocFile(content: string, path: string): void;
+    /**
+     * 处理静态属性，也就是用于枚举的属性描述信息。
+     * @param tag 类名及属性名
+     * @param businessObjectBunch 对应的在BOM文件的对象的声明
+     * @param className 完整的类名
+     * @param desc 具体描述
+     * @param vocFileName 当前voc文件名
+     * @param info  错误相关描述信息
+     */
+    processInstance(tag: string, businessObjectBunch: BusinessObjectBunch, className: string, desc: string, vocFileName: string, info: DiagnosticInfo): void;
+    /**
+     * 处理对象属性或方法的描述声明，先处理可能存在的documentation，如果不是documentation，那么就认为是对象的属性或方法声明描述
+     * @param phraseTag 类型部分
+     * @param businessObjectBunch 所属的对象声明
+     * @param className 对象类型名
+     * @param desc 对象描述
+     * @param info 错误相关描述信息
+     */
+    processPhrase(phraseTag: string, businessObjectBunch: BusinessObjectBunch, className: string, desc: string, info: DiagnosticInfo): void;
+    /**
+     * 处理当前描述，如果是针对一个方法的，则返回true，否则返回false。
+     * @param phraseType 当前phrase类型，可以为navigation或action
+     * @param fieldMethodName 完整方法名
+     * @param targetBusinessObject 目标业务对象
+     * @param targetObjectDefine 目标业务定义对象
+     * @param className 完整类型
+     * @param desc 描述值
+     * @param businessObjectBunch 当前对象所属的BOM文件
+     * @returns 返回true表示当前为方法描述，否则返回false,
+     * @param info 错误描述信息
+     */
+    processPhraseMethod(phraseType: string, fieldMethodName: string, targetBusinessObject: BusinessObject, targetObjectDefine: ObjectDefine, className: string, desc: string, businessObjectBunch: BusinessObjectBunch, info: DiagnosticInfo): boolean;
+    /**
+     * 处理phrase中的documentation，phrase类型有navigation和action两种，documentation标记位于最后，所以它的长度为3
+     * @param phrase phrase字符以.分隔的数组
+     * @param targetObjectDefine 当前对象定义
+     * @param fieldMethodName 当前phrase对应的属性或者方法名
+     * @param desc 当前phrase对应的documentation的具体描述
+     * @returns 返回一个boolean值，true表示存在documentation，false表示不存在
+     */
+    processPhraseDocumentation(phrase: string[], targetObjectDefine: ObjectDefine, fieldMethodName: string, desc: string): boolean;
+    /**
+     * 处理类的concept声明部分，这部分声明可能包含两块内容：一是documentation，是对类声明的描述；二是label是对类名的描述
+     * @param conceptTag concept部分声明
+     * @param businessObjectBunch 当前解析voc文件对应的bom文件对象
+     * @param className 当前解析到的类名
+     * @param desc 当前解析到的属性的值，也就是描述部分
+     * @param info 错误相关信息
+     */
+    processConcept(conceptTag: string, businessObjectBunch: BusinessObjectBunch, className: string, desc: string, info: DiagnosticInfo): void;
+    /**
+     * 此方法最后调用，用于设置所有字段定义的type属性对象的对象类型
+     */
+    buildFieldDefines(): void;
+    getObjectDefines(): ObjectDefine[];
+}
+type DiagnosticInfo = {
+    line: number;
+    startColumn: number;
+    semanticErrorDatas: SemanticErrorData[];
+};
+export {};

package/dist/model/VscodeBomFilesReader.d.ts

@@ -0,0 +1,2 @@
+export declare const bomFilesData: Record<string, Record<string, string>[]>;
+export declare const readAllBomFilesForVscode: () => Promise<void>;

package/dist/model/VscodeBuiltinObjectsLoader.d.ts

@@ -0,0 +1,14 @@
+import { ObjectDefine } from './BO';
+export default class VscodeBuiltinObjectsLoader {
+    private declareMap;
+    private vocFilesReader;
+    private decoder;
+    constructor();
+    loadBuiltinStaticMethods(callback: (objectDefines: ObjectDefine[]) => void): Promise<void>;
+    private readBasicObjectBomFile;
+    private readConstantsObjectBomFile;
+    private readStaticMethodBomFile;
+    private readBasicObjectVocFile;
+    private readConstantsObjectVocFile;
+    private readStaticMethodVocFile;
+}

package/dist/model/WebBuiltinObjectsLoader.d.ts

@@ -0,0 +1,13 @@
+import { ObjectDefine } from './BO';
+export default class WebBuiltinObjectsLoader {
+    private declareMap;
+    private vocFilesReader;
+    constructor();
+    getObjectDefines(): ObjectDefine[];
+    private readBasicObjectBomFile;
+    private readConstantsObjectBomFile;
+    private readStaticMethodBomFile;
+    private readBasicObjectVocFile;
+    private readStaticMethodVocFile;
+    private readConstantsVocFile;
+}

package/dist/model/WebViewBomFilesReader.d.ts

@@ -0,0 +1 @@
+export declare const parseAllBomFilesForWebView: (bomFilesData: Record<string, Record<string, string>[]>) => void;

package/dist/model/datatypeCompatibility.d.ts

@@ -0,0 +1,2 @@
+import { Datatype } from './Datatype';
+export declare const doDatatypeCompatibilityTest: (datatype: Datatype, targetDatatype: Datatype) => boolean;

package/dist/model/domainValidate.d.ts

@@ -0,0 +1,5 @@
+import { SemanticErrorData } from '../grammar/diagnostic/SemanticDiagnostic';
+import { ExpressionContext } from '../grammar/rule/RuleParser';
+import { BusinessObject, MethodParameter, ObjectField, ObjectMethod } from './BO';
+import { Datatype } from './Datatype';
+export declare const domainValidate: (host: BusinessObject | ObjectMethod | ObjectField | MethodParameter, expression: ExpressionContext, avaliablePredefineVariablesMap: Map<string, Datatype>) => SemanticErrorData | undefined;

package/dist/model/expression/ArithExpression.d.ts

@@ -0,0 +1,17 @@
+import { Expression } from './Expression';
+import { PredefineExpression } from './PredefineExpression';
+export declare class ArithExpression extends Expression {
+    private expressions;
+    private types;
+    constructor(expressions: Expression[], types: ArithType[], text: string);
+    toCompileScript(predefineVariableExpressionMap: Map<string, PredefineExpression>): string;
+    private buildScript;
+    buildArithSymbol(type: ArithType): "*" | "/" | "+" | "-" | "%";
+}
+export declare enum ArithType {
+    Add = 0,
+    Sub = 1,
+    Mul = 2,
+    Div = 3,
+    Mod = 4
+}

package/dist/model/expression/BatchExpression.d.ts

@@ -0,0 +1,14 @@
+import { Expression } from './Expression';
+import { PredefineExpression } from './PredefineExpression';
+export declare class BatchExpression extends Expression {
+    private expressions;
+    private type;
+    constructor(expressions: Expression[], type: BatchType, text: string);
+    toCompileScript(predefineVariableExpressionMap: Map<string, PredefineExpression>): string;
+    private buildScript;
+}
+export declare enum BatchType {
+    AllTrue = 0,
+    AnyTrue = 1,
+    AllNotTrue = 2
+}

package/dist/model/expression/CharExpression.d.ts

@@ -0,0 +1,6 @@
+import { Expression } from './Expression';
+export declare class CharExpression extends Expression {
+    private value;
+    constructor(value: string);
+    toCompileScript(): string;
+}

package/dist/model/expression/CurrentObjectExpression.d.ts

@@ -0,0 +1,9 @@
+import { Expression } from './Expression';
+export declare class CurrentObjectExpression extends Expression {
+    private objectName;
+    private fields;
+    constructor(objectName: string, fields: string[], text: string);
+    toCompileScript(): string;
+    getObjectName(): string;
+    getFields(): string[];
+}

package/dist/model/expression/DateExpression.d.ts

@@ -0,0 +1,6 @@
+import { Expression } from './Expression';
+export declare class DateExpression extends Expression {
+    private value;
+    constructor(value: string);
+    toCompileScript(): string;
+}

package/dist/model/expression/DateTimeExpression.d.ts

@@ -0,0 +1,6 @@
+import { Expression } from './Expression';
+export declare class DateTimeExpression extends Expression {
+    private value;
+    constructor(value: string);
+    toCompileScript(): string;
+}

package/dist/model/expression/EnumExpression.d.ts

@@ -0,0 +1,8 @@
+import { FieldDefine } from '../BO';
+import { Expression } from './Expression';
+export declare class EnumExpression extends Expression {
+    private fieldDefine;
+    constructor(fieldDefine: FieldDefine, text: string);
+    toCompileScript(): string;
+    getFieldDefine(): FieldDefine;
+}

package/dist/model/expression/Expression.d.ts

@@ -0,0 +1,8 @@
+import { PredefineExpression } from './PredefineExpression';
+export declare abstract class Expression {
+    private text;
+    constructor(text: string);
+    abstract toCompileScript(predefineVariableMap: Map<string, PredefineExpression>): string;
+    getText(): string;
+}
+export declare const buildIndent: (level: number) => string;

package/dist/model/expression/MethodExpression.d.ts

@@ -0,0 +1,12 @@
+import { FieldDefine, MethodDefine } from '../BO';
+import { Expression } from './Expression';
+import { PredefineExpression } from './PredefineExpression';
+export declare class MethodExpression extends Expression {
+    private define;
+    private parameters;
+    constructor(define: MethodDefine | FieldDefine, parameters: Expression[], text: string);
+    toCompileScript(predefineVariableExpressionMap: Map<string, PredefineExpression>): string;
+    buildScript(predefineVariableExpressionMap: Map<string, PredefineExpression>): string;
+    getParameters(): Expression[];
+    getDefine(): MethodDefine | FieldDefine;
+}

package/dist/model/expression/NumberExpression.d.ts

@@ -0,0 +1,6 @@
+import { Expression } from './Expression';
+export declare class NumberExpression extends Expression {
+    private value;
+    constructor(value: string);
+    toCompileScript(): string;
+}

package/dist/model/expression/ObjectExpression.d.ts

@@ -0,0 +1,7 @@
+import { Expression } from './Expression';
+export declare class ObjectExpression extends Expression {
+    private name;
+    constructor(name: string, text: string);
+    getName(): string;
+    toCompileScript(): string;
+}

package/dist/model/expression/PlaceholderExpression.d.ts

@@ -0,0 +1,20 @@
+import { TerminalNode } from 'antlr4ng';
+import { Datatype } from '../Datatype';
+import { Expression } from './Expression';
+export declare class PlaceholderExpression extends Expression {
+    private label;
+    private line;
+    private column;
+    private start;
+    private stop;
+    private datatype;
+    constructor(placeholder: TerminalNode, datatype: Datatype);
+    toCompileScript(): string;
+    getLine(): number;
+    getColumn(): number;
+    getStart(): number;
+    getStop(): number;
+    getDatatype(): Datatype;
+    getLabel(): string;
+    setLabel(label: string): void;
+}

package/dist/model/expression/PredefineExpression.d.ts

@@ -0,0 +1,25 @@
+import { BusinessObject } from '../BO';
+import { Expression } from './Expression';
+export declare class PredefineExpression extends Expression {
+    name: string;
+    object?: BusinessObject;
+    objectType?: PredefineObjectType;
+    value?: Expression;
+    sourceType?: PredefineSourceType;
+    source?: Expression;
+    condition?: Expression;
+    private hashCode?;
+    constructor(name: string, text: string);
+    toCompileScript(predefineVariableExpressionMap: Map<string, PredefineExpression>): string;
+    private buildPredefineValue;
+    private buildScript;
+    getHashCode(): string | undefined;
+}
+export declare enum PredefineObjectType {
+    one = 0,
+    many = 1
+}
+export declare enum PredefineSourceType {
+    in = 0,
+    from = 1
+}

package/dist/model/expression/RuleExpression.d.ts

@@ -0,0 +1,18 @@
+import { Expression } from './Expression';
+import { PredefineExpression } from './PredefineExpression';
+export declare class RuleExpression {
+    predefineExpressions?: PredefineExpression[];
+    ifExpression?: Expression;
+    thenExpression?: Expression[];
+    elseExpression?: Expression[];
+    toScript(name: string, predefineVariableMap: Map<string, PredefineExpression>): string;
+    buildElseRule(name: string, predefineVariableMap: Map<string, PredefineExpression>): string;
+}
+export declare class RuleProperty {
+    private name;
+    private value;
+    constructor(name: string, value: string);
+    toScript(): string;
+    getName(): string;
+    getValue(): string;
+}

package/dist/model/expression/StringExpression.d.ts

@@ -0,0 +1,7 @@
+import { Expression } from './Expression';
+export declare class StringExpression extends Expression {
+    private value;
+    constructor(value: string);
+    toCompileScript(): string;
+    getValue(): string;
+}

package/dist/model/expression/TimeExpression.d.ts

@@ -0,0 +1,6 @@
+import { Expression } from './Expression';
+export declare class TimeExpression extends Expression {
+    private value;
+    constructor(value: string);
+    toCompileScript(): string;
+}

package/dist/model/expression/VariableExpression.d.ts

@@ -0,0 +1,10 @@
+import { Expression } from './Expression';
+import { PredefineExpression } from './PredefineExpression';
+export declare class VariableExpression extends Expression {
+    private name;
+    private fields;
+    constructor(name: string, fields: string[], text: string);
+    toCompileScript(predefineVariableExpressionMap: Map<string, PredefineExpression>): string;
+    getName(): string;
+    getFields(): string[];
+}

package/dist/model/expression/compile/commonMethodScriptCompile.d.ts

@@ -0,0 +1,4 @@
+import { ObjectMethod } from '../../BO';
+import { Expression } from '../Expression';
+import { PredefineExpression } from '../PredefineExpression';
+export declare const doCompileCommonMethodScript: (text: string, parameters: Expression[], objectMethod: ObjectMethod, predefineVariableExpressionMap: Map<string, PredefineExpression>) => string;

package/dist/model/expression/compile/compareMethodScriptCompile.d.ts

@@ -0,0 +1,4 @@
+import { ObjectMethod } from '../../BO';
+import { Expression } from '../Expression';
+import { PredefineExpression } from '../PredefineExpression';
+export declare const doCompileCompareMethodScript: (text: string, parameters: Expression[], objectMethod: ObjectMethod, predefineVariableExpressionMap: Map<string, PredefineExpression>) => string;

package/dist/monaco/ExpressionFinder.d.ts

@@ -0,0 +1,32 @@
+import { ParserRuleContext } from 'antlr4ng';
+import { ExpressionContext, VariableContext } from '../grammar/rule/RuleParser';
+import { Datatype } from '../model/Datatype';
+import { Expression } from '../model/expression/Expression';
+import { VariableExpression } from '../model/expression/VariableExpression';
+declare class ExpressionFinder {
+    private parseBatchCondition;
+    parseExpression(context: ExpressionContext, finderContext: ExpressionFinderContext): Expression | undefined;
+    private parseArithmetic;
+    private parseMethod;
+    private findTargetMethodNodesByDescriptor;
+    private doFindTargetMethodNodesByDescriptor;
+    private findTargetDefine;
+    private parseBasic;
+    private parseObject;
+    private parsePlaceholder;
+    private parseEnum;
+    private parseCurrentLoopItemObject;
+    private parseLiteral;
+    parseVariable(variableContext: VariableContext, finderContext: ExpressionFinderContext): VariableExpression;
+    private findTargetFieldNode;
+}
+export declare class ExpressionFinderContext {
+    targetOffset: number;
+    targetExpression?: Expression;
+    targetExpressionContext?: ParserRuleContext;
+    avaliablePredefineVariablesMap: Map<string, Datatype>;
+    constructor(targetOffset: number, avaliablePredefineVariablesMap: Map<string, Datatype>);
+    assertTargetExpression(context: ParserRuleContext, targetExpression: Expression): void;
+}
+declare const expressionFinder: ExpressionFinder;
+export default expressionFinder;