udm-rules-vue 0.0.2 → 0.0.4

package/dist/bom/bomSerialize.d.ts

@@ -1,2 +1,3 @@
-import { BomTreeNode } from './model';
+import { BomTreeNode, ClassData } from './model';
 export declare const buildBomB2xVocJson: (bomTreeNodeList: BomTreeNode[], bomFileUuid: string, vocFileUuid: string, b2xFileUuid: string) => string;
+export declare const buildClassB2x: (classData: ClassData, runtime: boolean) => string;

package/dist/bom/model.d.ts

@@ -37,7 +37,7 @@ export type PackageData = {
 };
 export declare const findTargetClass: (className: string, packageData: PackageData) => ClassData | undefined;
 export declare const findTargetField: (classData: ClassData, memberName: string) => FieldData | undefined;
-export declare const findTargetMethod: (classData: ClassData, methodName: string) => MethodData | undefined;
+export declare const findTargetMethod: (classData: ClassData, methodName: string, methodParameterCount: number) => MethodData | undefined;
 export type ClassData = {
     name: string;
     oldName?: string;
@@ -83,6 +83,7 @@ export type FieldData = {
     setterScript: string;
     final: boolean;
     static: boolean;
+    private: boolean;
     readonly: boolean;
     writeonly: boolean;
     deprecated: boolean;

package/dist/brl/PureWebRuleEditor.vue.d.ts

@@ -21,6 +21,7 @@ type __VLS_Props = {
 };
 declare const _default: DefineComponent<__VLS_Props, {
     serializeToXml: () => any;
+    serializeToJson: () => any;
     showQuickTestDialog: () => any;
     setShowFloatingActions: (value: boolean) => void;
     setReadonlyMode: (value: boolean) => void;
@@ -32,7 +33,7 @@ declare const _default: DefineComponent<__VLS_Props, {
     }> & Readonly<{
         "onRule-editor-mounted"?: (() => any) | undefined;
     }>, {
-        serializeToXml: () => string;
+        serialize: () => string;
         setShowFloatingActions: (value: boolean) => void;
         setReadonlyMode: (value: boolean) => void;
         getReadonlyMode: () => boolean;
@@ -42,7 +43,7 @@ declare const _default: DefineComponent<__VLS_Props, {
         "rule-editor-mounted": () => any;
     }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
         codeEditorContainer: HTMLDivElement;
-    }, any, ComponentProvideOptions, {
+    }, HTMLDivElement, ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
@@ -55,7 +56,7 @@ declare const _default: DefineComponent<__VLS_Props, {
     }> & Readonly<{
         "onRule-editor-mounted"?: (() => any) | undefined;
     }>, {
-        serializeToXml: () => string;
+        serialize: () => string;
         setShowFloatingActions: (value: boolean) => void;
         setReadonlyMode: (value: boolean) => void;
         getReadonlyMode: () => boolean;

package/dist/brl/RuleDocument.d.ts

@@ -1,4 +1,4 @@
-import { CancellationToken, CustomDocument, CustomDocumentBackup, Uri, ExtensionContext, Event } from 'vscode';
+import { CancellationToken, CustomDocument, CustomDocumentBackup, ExtensionContext, Uri, Event } from 'vscode';
 import { DocumentDelegate, ViewEdit } from '../view&document';
 export declare class RuleDocument implements CustomDocument {
     private readonly _context;

package/dist/brl/RuleEditor.vue.d.ts

@@ -4,7 +4,7 @@ type __VLS_Props = {
     readonly?: boolean;
 };
 declare const _default: DefineComponent<__VLS_Props, {
-    serializeToXml: () => string;
+    serialize: () => string;
     setShowFloatingActions: (value: boolean) => void;
     setReadonlyMode: (value: boolean) => void;
     getReadonlyMode: () => boolean;
@@ -16,5 +16,5 @@ declare const _default: DefineComponent<__VLS_Props, {
     "onRule-editor-mounted"?: (() => any) | undefined;
 }>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
     codeEditorContainer: HTMLDivElement;
-}, any>;
+}, HTMLDivElement>;
 export default _default;

package/dist/brl/RuleEditorComponent.vue.d.ts

@@ -6,7 +6,7 @@ declare const _default: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixi
     }> & Readonly<{
         "onRule-editor-mounted"?: (() => any) | undefined;
     }>, {
-        serializeToXml: () => string;
+        serialize: () => string;
         setShowFloatingActions: (value: boolean) => void;
         setReadonlyMode: (value: boolean) => void;
         getReadonlyMode: () => boolean;
@@ -16,7 +16,7 @@ declare const _default: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixi
         "rule-editor-mounted": () => any;
     }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
         codeEditorContainer: HTMLDivElement;
-    }, any, ComponentProvideOptions, {
+    }, HTMLDivElement, ComponentProvideOptions, {
         P: {};
         B: {};
         D: {};
@@ -29,7 +29,7 @@ declare const _default: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixi
     }> & Readonly<{
         "onRule-editor-mounted"?: (() => any) | undefined;
     }>, {
-        serializeToXml: () => string;
+        serialize: () => string;
         setShowFloatingActions: (value: boolean) => void;
         setReadonlyMode: (value: boolean) => void;
         getReadonlyMode: () => boolean;

package/dist/brl/RuleUtils.d.ts

@@ -8,5 +8,5 @@ export type RuleData = {
     priority?: string;
     status?: string;
     document?: string;
-    script?: string;
+    definition?: string;
 };

package/dist/command/CompileB2xFilesCommand.d.ts

@@ -0,0 +1,4 @@
+import { Uri, Disposable } from 'vscode';
+export declare const COMPILE_B2X_FILES_COMMAND_NAME = "udmp.compileB2xFiles";
+export declare const registerCompileB2xFilesCommand: () => Disposable;
+export declare const doCompileB2xFile: (b2xFileUri: Uri) => Promise<void>;

package/dist/command/CompileRuleFilesCommand.d.ts

@@ -1,15 +1,20 @@
-import { ExtensionContext, Uri, Disposable, FileStat } from 'vscode';
+import { ExtensionContext, Progress, Uri, Disposable, FileStat } from 'vscode';
+import { CompileContext } from '../compile/FileCompiler';
 export declare const COMPILE_RULE_FILES_COMMAND_NAME = "udmp.compileRuleFiles";
 export declare const registerCompileRuleFilesCommand: () => Disposable;
 export declare const doCompileFiles: (currentFileUri: Uri | null, targetOutFolder?: string) => Promise<false | undefined>;
-export declare const compileRuleFilesData: (uris: Uri[], parentFolder: string) => Promise<FileData[]>;
+export declare const compileRuleFilesData: (uris: Uri[], parentFolder: string, compileContext: CompileContext) => Promise<FileData[]>;
 /**
  * 解析规则文件数据，找出规则文件中可能存在的各种类型的错误信息
  * @param uris 规则文件的uri列表
  * @param parentFolder 规则文件所在的父目录
+ * @param progress 进度条对象
  */
-export declare const resolveRuleFilesData: (uris: Uri[], parentFolder: string) => Promise<void>;
-export declare const doCompileFile: (context: ExtensionContext, content: Uint8Array, targetUri: Uri) => Promise<void>;
+export declare const resolveRuleFilesData: (uris: Uri[], parentFolder: string, progress: Progress<{
+    message?: string;
+    increment?: number;
+}>) => Promise<void>;
+export declare const doCompileFile: (context: ExtensionContext, content: Uint8Array, targetUri: Uri, compileContext: CompileContext) => Promise<void>;
 export declare const checkFileExists: (uri: Uri) => Promise<false | FileStat>;
 type FileData = {
     outExtName: string;

package/dist/command/DiagnoseFileCommand.d.ts

@@ -0,0 +1,6 @@
+import { Disposable } from 'vscode';
+export declare const DIAGNOSE_COMMAND = "udmp.diagnoseFile";
+/**
+ * 注册诊断决策流命令
+ */
+export declare const registerDiagnoseFileCommand: () => Disposable;

package/dist/command/SyncCompiledFilesCommand.d.ts

@@ -0,0 +1,3 @@
+import { Disposable } from 'vscode';
+export declare const SYNC_COMPILED_FILES_COMMAND = "udmp.projectSyncCompiledFiles";
+export declare const registerSyncComiledFilesCommand: () => Disposable;

package/dist/command/UpdateUuidCommand.d.ts

@@ -1,3 +1,3 @@
-import { Disposable } from 'vscode';
+import { ExtensionContext, Disposable } from 'vscode';
 export declare const UPDATE_UUID_COMMAND = "udmp.updateUuid";
-export declare const registerUpdateUuidCommand: () => Disposable;
+export declare const registerUpdateUuidCommand: (context: ExtensionContext) => Disposable;

package/dist/compile/BomCompiler.d.ts

@@ -0,0 +1,96 @@
+import { DomainValue, ObjectProperty } from '../model/BO';
+export declare const compileBomB2xXml: (bomContent: string, vocContent: string, b2xContent: string) => string;
+export declare const parseBomFile: (content: string) => {
+    bomFileUuid: string;
+    vocFileUuid: string;
+    b2xFileUuid: string;
+    packageDataMap: Map<string, PackageData>;
+};
+export type PackageData = {
+    packageName: string;
+    classes: ClassData[];
+    children: PackageData[];
+};
+export declare const findTargetClass: (className: string, packageData: PackageData) => ClassData | undefined;
+export declare const findTargetField: (classData: ClassData, memberName: string) => FieldData | undefined;
+export declare const findTargetMethod: (classData: ClassData, methodName: string, methodParameterCount: number) => MethodData | undefined;
+export type ClassData = {
+    name: string;
+    oldName?: string;
+    verbalization?: string;
+    oldVerbalization?: string;
+    documentation?: string;
+    domain?: DomainValue;
+    packageName: string;
+    oldPackageName: string;
+    staticClass: boolean;
+    abstractClass: boolean;
+    interfaceClass: boolean;
+    enumClass: boolean;
+    innerClass: boolean;
+    extends?: string;
+    implements?: string;
+    fields: FieldData[];
+    methods: MethodData[];
+    innerClasses: ClassData[];
+    importClasses: string[];
+    extenderName: string;
+    executionName: string;
+    categories: string[];
+    properties: ObjectProperty[];
+};
+export type FieldData = {
+    name: string;
+    type: string;
+    classData: ClassData;
+    verbalization?: string;
+    oldVerbalization?: string;
+    actionDocumentation?: string;
+    navigationDocumentation?: string;
+    actionVerbalization?: string;
+    oldActionVerbalization?: string;
+    actionVerbalizationError?: string;
+    navigationVerbalization?: string;
+    oldNavigationVerbalization?: string;
+    navigationVerbalizationError?: string;
+    documentation?: string;
+    domain?: DomainValue;
+    getterScript: string;
+    setterScript: string;
+    final: boolean;
+    static: boolean;
+    private: boolean;
+    readonly: boolean;
+    writeonly: boolean;
+    deprecated: boolean;
+    update: boolean;
+    array: boolean;
+    collection: boolean;
+    categories: string[];
+    properties: ObjectProperty[];
+};
+export type ParameterData = {
+    name: string;
+    type: string;
+    array: boolean;
+    domain?: DomainValue;
+};
+export type MethodData = {
+    name: string;
+    classData: ClassData;
+    verbalization?: string;
+    verbalizationError?: string;
+    oldVerbalization?: string;
+    documentation?: string;
+    methodScript: string;
+    returnType: string;
+    static: boolean;
+    final: boolean;
+    deprecated: boolean;
+    update: boolean;
+    throws?: string;
+    domain?: DomainValue;
+    categories: string[];
+    parameters: ParameterData[];
+    properties: ObjectProperty[];
+};

package/dist/compile/DecisionTableCompiler.d.ts

@@ -1,10 +1,10 @@
 import { Datatype } from '../model/Datatype';
 import { PlaceholderExpression } from '../model/expression/PlaceholderExpression';
-import { default as FileCompiler } from './FileCompiler';
+import { default as FileCompiler, CompileContext } from './FileCompiler';
 export default class implements FileCompiler {
     support(url: string): boolean;
-    doCompile(path: string, content: string, absolutePath: string): string;
-    doDiagnose(path: string, content: string, absolutePath: string): void;
+    doCompile(path: string, content: string, absolutePath: string, compileContext: CompileContext): string;
+    doDiagnose(path: string, content: string, absolutePath: string, cacheMap: Map<string, any>): void;
     getOutExtName(): string;
 }
 export declare const replaceTargetScriptPlaceholder: (targetScript: string, placeholderExpressions: PlaceholderExpression[], params: string[]) => string | undefined;
@@ -27,7 +27,7 @@ export declare class ConditionData {
      */
     children: ConditionData[];
     constructor(conditionScript: string, parent?: ConditionData);
-    buildCurrentOtherwiseCondition(parentScript?: string): string;
+    buildCurrentOtherwiseCondition(): string;
     buildNegationCondition(root: boolean, parentScript?: string): string;
 }
 export declare class OtherwiseRule {

package/dist/compile/ExpressionBuilder.d.ts

@@ -8,9 +8,6 @@ declare class ExpressionBuilder {
     parseExpression(context: ExpressionContext, avaliablePredefineVariablesMap: Map<string, Datatype>, semanticErrorDatas: SemanticErrorData[]): Expression | undefined;
     private parseArithmetic;
     private parseMethod;
-    private findTargetMethodNodesByDescriptor;
-    private doFindTargetMethodNodesByDescriptor;
-    private findTargetDefines;
     private parseBasic;
     private parseObject;
     private parsePlaceholder;

package/dist/compile/FileCompiler.d.ts

@@ -1,7 +1,16 @@
+import { Expression } from '../model/expression/Expression';
+import { PredefineExpression } from '../model/expression/PredefineExpression';
 export default interface FileCompiler {
-    doCompile(relativePath: string, content: string, absolutePath: string): string;
-    doDiagnose(relativePath: string, content: string, absolutePath: string): void;
+    doCompile(relativePath: string, content: string, absolutePath: string, compileContext: CompileContext): string;
+    doDiagnose(relativePath: string, content: string, absolutePath: string, cacheMap: Map<string, any>): void;
     support(url: string): boolean;
     getOutExtName(): string;
 }
+export declare class CompileContext {
+    /**
+     * 用来缓存编译后的表达式，避免重复编译，这里的key是表达式的字符串，value是编译后的表达式
+     */
+    compiledExpressionsMap: Map<string, string>;
+}
+export declare const compileExpressionWithCache: (expression: Expression, predefineVariableExpressionMap: Map<string, PredefineExpression>, compileContext: CompileContext) => string;
 export declare const parseXml: (xml: string) => any;

package/dist/compile/FlowCompiler.d.ts

@@ -1,13 +1,29 @@
 import { SemanticErrorData } from '../grammar/diagnostic/SemanticDiagnostic';
 import { default as FlowProcessDef } from '../rfl/definition/ProcessDef';
 import { default as ProcessNodeDef } from '../rfl/definition/ProcessNodeDef';
-import { default as FileCompiler } from './FileCompiler';
+import { default as FileCompiler, CompileContext } from './FileCompiler';
 export declare class FlowCompiler implements FileCompiler {
-    doCompile(path: string, content: string, absolutePath: string): string;
+    doCompile(path: string, content: string, absolutePath: string, compileContext: CompileContext): string;
     doDiagnose(path: string, content: string, absolutePath: string): void;
-    buildFlowCompiledContent(processDef: FlowProcessDef, absolutePath: string): string;
-    builderNodeXml(nodeId: string, nodeDef: ProcessNodeDef, semanticErrorDatas: SemanticErrorData[], grammarDiagnostic?: boolean): string;
+    buildFlowCompiledContent(processDef: FlowProcessDef, absolutePath: string, compileContext: CompileContext): string;
+    /**
+     * 转换节点语义错误数据为关联问题位置列表
+     * @param msg 错误消息
+     * @param semanticErrorDatas 语义错误数据数组
+     * @returns 转换后的语义错误数据或null
+     */
+    convertToNodeSemanticErrorDatas(msg: string, semanticErrorDatas: SemanticErrorData[]): SemanticErrorData | null;
+    builderNodeXml(nodeId: string, nodeDef: ProcessNodeDef, semanticErrorDatas: SemanticErrorData[], compileContext: CompileContext, grammarDiagnostic?: boolean): string;
     private buildTaskNodeAttributes;
+    /**
+     * 构建自定义任务节点的属性
+     * 从注册表的 propertySchema 中读取字段定义，将值序列化为 XML 属性
+     */
+    private buildCustomTaskNodeAttributes;
+    /**
+     * XML 属性值转义
+     */
+    private escapeXmlAttr;
     private buildCommonElements;
     private compileActionScripts;
     private compileSingleAction;

package/dist/compile/PureWebCompiler.d.ts

@@ -1 +1,2 @@
 export declare const pureWebCompileFile: (path: string, content: string) => string | undefined;
+export declare const pureWebDiagnoseFile: (path: string, content: string, cacheMap: Map<string, any>) => void;

package/dist/compile/RuleCompiler.d.ts

@@ -1,7 +1,7 @@
-import { default as FileCompiler } from './FileCompiler';
+import { default as FileCompiler, CompileContext } from './FileCompiler';
 export default class RuleCompiler implements FileCompiler {
     support(url: string): boolean;
-    doCompile(path: string, content: string, absolutePath: string): string;
+    doCompile(path: string, content: string, absolutePath: string, compileContext: CompileContext): string;
     doDiagnose(path: string, content: string, absolutePath: string): void;
     getOutExtName(): string;
 }

package/dist/compile/ScoreCardCompiler.d.ts

@@ -0,0 +1,14 @@
+import { default as FileCompiler, CompileContext } from './FileCompiler';
+export default class ScoreCardCompiler implements FileCompiler {
+    support(url: string): boolean;
+    doCompile(path: string, xmlContent: string, absolutePath: string, compileContext: CompileContext): string;
+    private buildPostActionsScript;
+    private buildScoreCardScript;
+    private buildExpressionScript;
+    private buildPredefineVariableExpressionMap;
+    private buildConditionScript;
+    private buildPredefineScript;
+    buildHeaderVisibleMap(resources: any): Map<number, boolean>;
+    doDiagnose(path: string, content: string, absolutePath: string): void;
+    getOutExtName(): string;
+}

package/dist/compile/compileRuleScript.d.ts

@@ -1,5 +1,10 @@
 import { SemanticErrorData } from '../grammar/diagnostic/SemanticDiagnostic';
+import { PredefineStatementContext } from '../grammar/rule/RuleParser';
+import { Datatype } from '../model/Datatype';
+import { PredefineExpression } from '../model/expression/PredefineExpression';
 import { RuleExpression } from '../model/expression/RuleExpression';
-export declare const buildRulesCompiledContent: (ruleExpressions: RuleExpression[], path: string) => string;
+import { CompileContext } from './FileCompiler';
+export declare const buildRulesCompiledContent: (ruleExpressions: RuleExpression[], path: string, compileContext: CompileContext) => string;
 export declare const buildRuleExpression: (ruleScript: string, location: string, semanticErrorDatas: SemanticErrorData[], grammarDiagnostic?: boolean) => RuleExpression;
+export declare const parsePredefineStatement: (predefineStatementContext: PredefineStatementContext | null, avaliablePredefineVariablesMap: Map<string, Datatype>, semanticErrorDatas: SemanticErrorData[]) => PredefineExpression[] | undefined;
 export declare const buildPackageName: (folder: string) => string;

package/dist/components/message/Toast.vue.d.ts

@@ -0,0 +1,6 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from '../../../npmconfig/vue/dist/vue.esm-bundler.js';
+type __VLS_Props = {
+    darkMode?: boolean;
+};
+declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/message/events.d.ts

@@ -4,13 +4,33 @@ export declare const SHOW_LOADING = "show_loading";
 export declare const HIDE_LOADING = "hide_loading";
 export declare const CHANGE_LOAD_LOADING_TIP = "change_loading_tip";
 export declare const SHOW_CONFIRM = "show_confirm";
+export declare const SHOW_TOAST = "show_toast";
 export declare function showAlert(msg: string, title?: string): void;
+export declare function showError(msg: string, stackTrace: string): void;
 export declare function showConfirm(msg: string, callback: (confirm: boolean) => void, title?: string): void;
 export declare function showLoading(keepLoadingTip?: boolean): void;
 export declare function hideLoading(): void;
+export declare function toast(msg: string, type?: ToastType, duration?: number): void;
+export declare function toastSuccess(msg: string, duration?: number): void;
+export declare function toastError(msg: string, duration?: number): void;
+export declare function toastWarning(msg: string, duration?: number): void;
+export declare function toastInfo(msg: string, duration?: number): void;
+export type ToastType = "success" | "error" | "warning" | "info";
+export type ToastConfig = {
+    msg: string;
+    type?: ToastType;
+    duration?: number;
+};
+export type ToastMessage = {
+    id: number;
+    msg: string;
+    type: ToastType;
+    duration?: number;
+};
 export type AlertMessage = {
     title?: string;
     msg: string;
+    stackTrace?: string;
 };
 export type ConfirmMessage = {
     title?: string;

package/dist/components/process/events.d.ts

@@ -1,7 +1,4 @@
-export declare const SELECT_NODE = "select_node";
 export declare const SELECT_STAGE = "select_stage";
-export declare const SELECT_PROCESS = "select_process";
-export declare const SELECT_CONNECTION = "select_connection";
 export declare const MULTI_SELECT_NODES = "multi_select_nodes";
 export declare const REMOVE_CONNECTION = "remove_connection";
 export declare const NODE_NAME_CHANGE = "node_name_change";

package/dist/components/tree/TreeNode.vue.d.ts

@@ -6,6 +6,7 @@ type __VLS_Props = {
     paddingLeft?: number;
     marginLeft?: number;
     marginBlock?: number;
+    depth?: number;
     darkMode?: boolean;
     nodeFilterCallback?: (key: string, node: any) => boolean;
 };
@@ -15,5 +16,6 @@ declare const _default: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOp
     paddingLeft: number;
     marginLeft: number;
     marginBlock: number;
+    depth: number;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLUListElement>;
 export default _default;

package/dist/content.d.ts

@@ -23,3 +23,5 @@ export declare enum BINDING_FILE_TYPE {
  * XML头部
  */
 export declare const XML_HEADER = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
+export declare const SCA_FULL_CLASSNAME = "udm.Scorecard";
+export declare const CURRENT_SCA_NAME = "'\u5F53\u524D\u8FD9\u4E2A\u8BB0\u5206\u5361'";

package/dist/dta/DecisionTableDeserialize.d.ts

@@ -1,3 +1,4 @@
 import { Datatype } from '../model/Datatype';
 import { DecisionTableModel } from './model/DecisionTableModel';
-export declare const deserializeDecisionTable: (xml: string, decisionTableModel: DecisionTableModel) => Map<string, Datatype>;
+export declare const deserializeDecisionTableFromJson: (json: string, decisionTableModel: DecisionTableModel) => Map<string, Datatype>;
+export declare const deserializeDecisionTableFromXml: (xml: string, decisionTableModel: DecisionTableModel) => Map<string, Datatype>;

package/dist/dta/DecisionTableJsonSerialize.d.ts

@@ -0,0 +1,2 @@
+import { DecisionTableModel } from './model/DecisionTableModel';
+export declare const serializeDecisionTableToJson: (model: DecisionTableModel) => string;

package/dist/dta/DecisionTableXmlSerialize.d.ts

@@ -0,0 +1,2 @@
+import { DecisionTableModel } from './model/DecisionTableModel';
+export declare const serializeDecisionTableToXml: (model: DecisionTableModel) => string;

package/dist/dta/component/DecisionTable.d.ts

@@ -93,6 +93,7 @@ export declare class DecisionTable {
     private bindingEditor;
     private bindingCellEvents;
     private checkCellContentError;
+    private enumDatatypeCompatibilityTest;
     private cleanCellError;
     private setCellError;
     buildResizeRowCallback(): (rowIndex: number, newHeight: number) => void;

package/dist/dta/model/DecisionTableModel.d.ts

@@ -4,6 +4,7 @@ import { Definition } from './Definition';
 import { Partition } from './Partition';
 import { ResourceData } from './ResourceData';
 export declare class DecisionTableModel {
+    private filePath;
     private name;
     private uuid;
     private effectiveDate;
@@ -59,6 +60,8 @@ export declare class DecisionTableModel {
     setPartition(partition: Partition): void;
     setName(name: string): void;
     getName(): string;
+    setFilePath(filePath: string): void;
+    getFilePath(): string;
     setUuid(uuid: string): void;
     getUuid(): string;
     setStatus(status: string): void;

package/dist/dta/webview/DecisionTableDocument.d.ts

@@ -1,4 +1,4 @@
-import { CancellationToken, CustomDocument, CustomDocumentBackup, Uri, ExtensionContext, Event } from 'vscode';
+import { CancellationToken, CustomDocument, CustomDocumentBackup, ExtensionContext, Uri, Event } from 'vscode';
 import { DocumentDelegate, ViewEdit } from '../../view&document';
 export declare class DecisionTableDocument implements CustomDocument {
     private readonly _context;

package/dist/dtr/webview/DecisionTreeDocument.d.ts

@@ -1,4 +1,4 @@
-import { CancellationToken, CustomDocument, CustomDocumentBackup, Uri, ExtensionContext, Event } from 'vscode';
+import { CancellationToken, CustomDocument, CustomDocumentBackup, ExtensionContext, Uri, Event } from 'vscode';
 import { DocumentDelegate, ViewEdit } from '../../view&document';
 export declare class DecisionTreeDocument implements CustomDocument {
     private readonly _context;

package/dist/extension.d.ts

@@ -2,9 +2,10 @@ import { RuleEditorProvider } from './brl/RuleEditorProvider';
 import { DecisionTableEditorProvider } from './dta/webview/DecisionTableEditorProvider';
 import { RuleFlowEditorProvider } from './rfl/webview/RuleFlowEditorProvider';
 import { DecisionTreeEditorProvider } from './dtr/webview/DecisionTreeEditorProvider';
+import { ScoreCardEditorProvider } from './sca/webview/ScoreCardEditorProvider';
 import * as vscode from "vscode";
 export declare function activate(context: vscode.ExtensionContext): void;
 export declare const getExtensionPath: () => string;
-export declare const refactorListener: (ruleProvider: RuleEditorProvider, ruleFlowProvider: RuleFlowEditorProvider, decisionTableProvider: DecisionTableEditorProvider, decisionTreeProvider: DecisionTreeEditorProvider) => Promise<void>;
+export declare const refactorListener: (ruleProvider: RuleEditorProvider, scoreCardProvider: ScoreCardEditorProvider, ruleFlowProvider: RuleFlowEditorProvider, decisionTableProvider: DecisionTableEditorProvider, decisionTreeProvider: DecisionTreeEditorProvider) => Promise<void>;
 export declare const deleteDeployFolder: () => void;
 export declare function deactivate(): void;

package/dist/grammar/BusinessParseRuleContext.d.ts

@@ -0,0 +1,5 @@
+import { ParserRuleContext } from 'antlr4ng';
+export declare class BusinessParseRuleContext extends ParserRuleContext {
+    _obj: any;
+    constructor(parent: ParserRuleContext | null, invokingStateNumber?: number);
+}

package/dist/grammar/ParserHelper.d.ts

@@ -2,6 +2,7 @@ import { Token } from 'antlr4ng';
 import { ObjectDefine } from '../model/BO';
 import { Datatype } from '../model/Datatype';
 import { NavigationNode } from '../model/NavigationTree';
+import { default as BoostRuleParser } from './parser/BoostRuleParser';
 import { RuleLexer } from './rule/RuleLexer';
 import { ParsePosition } from './TokenAssertor';
 export declare class ParserHelper {
@@ -18,11 +19,17 @@ export declare class ParserHelper {
      * 用来记录匹配到的方法导航节点，将匹配的方法导航节点保存到这里，以备在Parser中使用，因为Parser在拿到当前的方法描述符对应的Token时，
      * 也需要根据这个Token来找到对应的目标方法，所以为了在Parser中少查询一次，就将匹配的方法导航节点保存到这里。
      */
-    private currentMatchedMethodNode;
+    private currentMatchedMethodNextNodes;
     /**
      * 记录当前匹配的变量导航树节点，以为下次匹配判断做准备。
      */
     private matchedVariableNavigationNodes;
+    /**
+     * 记录在语法解析中遇到的方法返回值对应的类型可能存在的对应的变量导航树节点，
+     * 这样在方法解析完成后，如果后面出现字段描述，那么就可以通过解析这里记录的节点信息解析出对应的字段Token
+     */
+    private parserMethodVariableNavigationNodes;
+    boostRuleParser: BoostRuleParser | undefined;
     private clean;
     /**
      * 词法解析中每次解析一个Token都需要通过这个方法来判断当前解析的位置，
@@ -38,6 +45,16 @@ export declare class ParserHelper {
      * @param avaliablePredefineVariablesMap 当前位置上可用的预定义变量信息
      */
     encounterVariableName(variableName: string, avaliablePredefineVariablesMap: Map<string, Datatype>): void;
+    getParserMethodVariableNavigationNodes(): NavigationNode[];
+    /**
+     * 应用Parser中解析出来的已完成的方法的返回值类型，如果这个类型存在对应的业务对象，就将这个业务对象的属性节点作为后续匹配节点
+     * @param matchedMethodNodes Parser中解析出来的已完成的方法的导航节点
+     * @param clean 是否需要先清空可能存在的变量字段节点信息
+     * @returns void
+     */
+    applyCurrentParserMethodReturnDatatype(matchedMethodNodes?: NavigationNode[]): void;
+    applyOldCurrentParserMethodReturnDatatype(matchedMethodNodes?: NavigationNode[]): void;
+    private buildParserMethodVariableNavigationNodes;
     assertEnumDescriptor(lexer: RuleLexer): boolean;
     assertFieldDescriptor(lexer: RuleLexer): boolean;
     assertMethodDescriptor(lexer: RuleLexer): boolean;
@@ -50,7 +67,8 @@ export declare class ParserHelper {
      */
     private loadTargetIndexMatchedMethodNodes;
     private aheadTokenDetection;
-    getCurrentMatchedMethodNode(): NavigationNode | undefined;
+    private aheadTokenDetectionByIndex;
+    getCurrentMatchedMethodNextNodes(): NavigationNode[];
     allowSearch(type: AllowSearchType): boolean;
     get currentPrsePosition(): ParsePosition;
     set currentAllowSearchType(type: AllowSearchType);

package/dist/grammar/TokenAssertor.d.ts

@@ -15,10 +15,6 @@ export declare const isLiteralToken: (token: Token) => boolean;
  * 用于在词法解析时标记当前解析的位置
  */
 export declare enum ParsePosition {
-    /**
-     * 当前解析处于规则开始部分
-     */
-    Property = "Property",
     /**
      * 当前解析处于预定义部分
      */