udm-rules-vue 0.0.1

package/dist/java-C_jlkwoG.js

@@ -0,0 +1,238 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Version: 0.52.2(404545bded1df6ffa41ea0af4e8ddb219018c6c1)
+ * Released under the MIT license
+ * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
+ *-----------------------------------------------------------------------------*/
+var e = {
+  // the default separators except `@$`
+  wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+  comments: {
+    lineComment: "//",
+    blockComment: ["/*", "*/"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" },
+    { open: "<", close: ">" }
+  ],
+  folding: {
+    markers: {
+      start: new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),
+      end: new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")
+    }
+  }
+}, t = {
+  defaultToken: "",
+  tokenPostfix: ".java",
+  keywords: [
+    "abstract",
+    "continue",
+    "for",
+    "new",
+    "switch",
+    "assert",
+    "default",
+    "goto",
+    "package",
+    "synchronized",
+    "boolean",
+    "do",
+    "if",
+    "private",
+    "this",
+    "break",
+    "double",
+    "implements",
+    "protected",
+    "throw",
+    "byte",
+    "else",
+    "import",
+    "public",
+    "throws",
+    "case",
+    "enum",
+    "instanceof",
+    "return",
+    "transient",
+    "catch",
+    "extends",
+    "int",
+    "short",
+    "try",
+    "char",
+    "final",
+    "interface",
+    "static",
+    "void",
+    "class",
+    "finally",
+    "long",
+    "strictfp",
+    "volatile",
+    "const",
+    "float",
+    "native",
+    "super",
+    "while",
+    "true",
+    "false",
+    "yield",
+    "record",
+    "sealed",
+    "non-sealed",
+    "permits"
+  ],
+  operators: [
+    "=",
+    ">",
+    "<",
+    "!",
+    "~",
+    "?",
+    ":",
+    "==",
+    "<=",
+    ">=",
+    "!=",
+    "&&",
+    "||",
+    "++",
+    "--",
+    "+",
+    "-",
+    "*",
+    "/",
+    "&",
+    "|",
+    "^",
+    "%",
+    "<<",
+    ">>",
+    ">>>",
+    "+=",
+    "-=",
+    "*=",
+    "/=",
+    "&=",
+    "|=",
+    "^=",
+    "%=",
+    "<<=",
+    ">>=",
+    ">>>="
+  ],
+  // we include these common regular expressions
+  symbols: /[=><!~?:&|+\-*\/\^%]+/,
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  digits: /\d+(_+\d+)*/,
+  octaldigits: /[0-7]+(_+[0-7]+)*/,
+  binarydigits: /[0-1]+(_+[0-1]+)*/,
+  hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [
+      // Special keyword with a dash
+      ["non-sealed", "keyword.non-sealed"],
+      // identifiers and keywords
+      [
+        /[a-zA-Z_$][\w$]*/,
+        {
+          cases: {
+            "@keywords": { token: "keyword.$0" },
+            "@default": "identifier"
+          }
+        }
+      ],
+      // whitespace
+      { include: "@whitespace" },
+      // delimiters and operators
+      [/[{}()\[\]]/, "@brackets"],
+      [/[<>](?!@symbols)/, "@brackets"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "delimiter",
+            "@default": ""
+          }
+        }
+      ],
+      // @ annotations.
+      [/@\s*[a-zA-Z_\$][\w\$]*/, "annotation"],
+      // numbers
+      [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, "number.float"],
+      [/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, "number.float"],
+      [/0[xX](@hexdigits)[Ll]?/, "number.hex"],
+      [/0(@octaldigits)[Ll]?/, "number.octal"],
+      [/0[bB](@binarydigits)[Ll]?/, "number.binary"],
+      [/(@digits)[fFdD]/, "number.float"],
+      [/(@digits)[lL]?/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/"""/, "string", "@multistring"],
+      [/"/, "string", "@string"],
+      // characters
+      [/'[^\\']'/, "string"],
+      [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+      [/'/, "string.invalid"]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/\/\*\*(?!\/)/, "comment.doc", "@javadoc"],
+      [/\/\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ],
+    comment: [
+      [/[^\/*]+/, "comment"],
+      // [/\/\*/, 'comment', '@push' ],    // nested comment not allowed :-(
+      // [/\/\*/,    'comment.invalid' ],    // this breaks block comments in the shape of /* //*/
+      [/\*\//, "comment", "@pop"],
+      [/[\/*]/, "comment"]
+    ],
+    //Identical copy of comment above, except for the addition of .doc
+    javadoc: [
+      [/[^\/*]+/, "comment.doc"],
+      // [/\/\*/, 'comment.doc', '@push' ],    // nested comment not allowed :-(
+      [/\/\*/, "comment.doc.invalid"],
+      [/\*\//, "comment.doc", "@pop"],
+      [/[\/*]/, "comment.doc"]
+    ],
+    string: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, "string", "@pop"]
+    ],
+    multistring: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"""/, "string", "@pop"],
+      [/./, "string"]
+    ]
+  }
+};
+export {
+  e as conf,
+  t as language
+};

package/dist/model/BO.d.ts

@@ -0,0 +1,281 @@
+import { Datatype } from './Datatype';
+export declare const UTILS_CLASSNAME = "udm.Utils";
+export declare const COMMON_UTILS_CLASSNAME = "udm.CommonUtils";
+export declare const COMPARE_UTILS_CLASSNAME = "udm.CompareUtils";
+export declare const COMMON_ACTION_UTILS_CLASSNAME = "udm.ActionUtils";
+export declare const VARIABLE_ASSIGN_METHOD = "variableAssign";
+export declare const FROM_LIST = "\u6765\u81EA(in)";
+export declare const ONLY_VARIABLE = "umd.OnlyVariable";
+export declare class VariableDefine {
+    path: string;
+    name: string;
+    /**
+     * 对应数据类型的完整类名
+     */
+    fullClassName: string;
+    datatype: Datatype;
+    /**
+     * 描述名称，在规则中使用时用''包裹
+     */
+    verbalization: string;
+    initialValue: string | undefined;
+    documentation: string | undefined;
+    /**
+     * 关于当前对象的提示信息，用于代码完成时提示项或hover项提示
+     */
+    private tip;
+    constructor(name: string, type: string, verbalization: string, path: string, genericity?: string);
+    buildVerbalizationName(): string;
+    buildName(): string;
+    buildTip(): string;
+}
+export declare class ObjectDefine {
+    verbalization: string;
+    /**
+     * 对象的详细描述
+     */
+    documentation: string | undefined;
+    /**
+     * 关于当前对象的提示信息，用于代码完成时提示项或hover项提示
+     */
+    private tip;
+    businessObject: BusinessObject;
+    /**
+     * 用于记录当前对象下所有属性字段中使用的数据类型，以便于在代码提示时根据允许显示的类型决定要不要显示当前对象
+     */
+    childrenDatatypesMap: Map<string, Datatype> | undefined;
+    /**
+     * 保存在VOC文件中定义的navigation类型的描述，在navigation中可以是一个对象属性，也可以是一个普通方法，或者是一是静态方法。
+     *
+     * navigation可以用在规则的条件部分，也可以用于规则的动作部分。这里的fields是一个Map，map的key为voc文件中的字段名描述，value为字段定义对象
+     */
+    navigations: {
+        fields: Map<string, FieldDefine>;
+        methods: MethodDefine[];
+        staticMethods: MethodDefine[];
+    };
+    /**
+     * 规则的动作部分，动作部分只支持对对象的属性进行赋值，不支持对象方法。
+     *
+     * 这里的的Map的key为字段名在voc文件中的描述，value为字段定义对象.
+     */
+    actionFields: Map<string, FieldDefine>;
+    /**
+     * 用来记录action类型的普通方法
+     */
+    actionMethods: MethodDefine[];
+    /**
+     * 用来记录action类型的静态方法
+     */
+    actionStaticMethods: MethodDefine[];
+    /**
+     * 用来记录那些字段为static且类型就是当前字段所在类的属性。
+     *
+     * 这个Map的key为当前字段在voc文件中定义的字段名描述，value为字段定义对象。
+     */
+    enumFields: Map<string, FieldDefine>;
+    /**
+     * key为字段名，value为字段定义对象，定义该对象是为了在解析voc文件时可以快速的根据字段名获取字段定义对象
+     */
+    fieldsMap: Map<string, FieldDefine>;
+    /**
+     * key为字段描述名称,而不是字段名，value为字段定义对象，定义该对象是为了在解析规则时，使用当前这个xxx来表示当前对象时获取对应的字段定义对象
+     */
+    fieldsDescriptorMap: Map<string, FieldDefine>;
+    /**
+     * key为方法名，value为方法定义对象，定义这个Map主要是为了在解析voc文件时可以快速的根据方法名获取方法定义对象
+     */
+    methodsMap: Map<string, MethodDefine>;
+    /**
+     * 存放所有的静态方法，包含navigation和action两种类型的，key为静态方法名，value为方法定义对象，
+     *
+     * 定义这个Map主要是为了在解析voc文件时可以快速的根据方法名获取方法定义对象
+     */
+    allStaticMethodsMap: Map<string, MethodDefine>;
+    constructor(verbalization: string, businessObject: BusinessObject);
+    buildTip(): string;
+}
+export declare class FieldDefine {
+    /**
+     * 字段名
+     */
+    name: string;
+    /**
+     * 字段名描述
+     */
+    verbalization: string;
+    /**
+     * 数据类型，简单的如:java.lang.String，复杂的就是一个对象类型，与下面的type对应
+     */
+    datatype: Datatype;
+    /**
+     * 对应的BusinessObject对象
+     */
+    businessObject: BusinessObject;
+    /**
+     * 针对当前字段的详细描述
+     */
+    documentation: string | undefined;
+    /**
+     * 关于当前对象的提示信息，用于代码完成时提示项或hover项提示
+     */
+    private tip;
+    /**
+     * 当前字段数据类型对象的ObjectDefine对象，如果是一个类似string的简单类型，这个type属性就是undefined
+     */
+    type: ObjectDefine | undefined;
+    /**
+     * 如果当前字段对应的是一个赋值动作，那么在将该赋值动作构建成导航树时需要将从描述中提取的参数构建成MethodParameter对象，并放在这个属性中，
+     *
+     * 普通导航用字段该属性值为空。
+     */
+    parameters: MethodParameter[];
+    /**
+     * 如果当前字段属性是一个业务对象类型，那么这里就用来记录该字段对应的对象的所有字段的数据类型，key为类型对应的完整类名。
+     * 需要注意的是，这里既包含当前对象的所有字段，也包括子对象中的字段，以及更下级子对象的字段类型。
+     * 定义该属性主要是为了在编辑器代码完成时，能根据当前位置所需要的数据类型，判断当前字段及其子字段是否符合要求。
+     */
+    childrenDatatypesMap: Map<string, Datatype> | undefined;
+    constructor(name: string, verbalization: string, datatype: Datatype, businessObject: BusinessObject);
+    buildTip(): string;
+}
+export declare const METHOD_NAME_REGEX: RegExp;
+export declare class MethodDefine {
+    /**
+     * 方法名描述
+     */
+    verbalization: string;
+    operator?: string;
+    operatorExpression?: string;
+    objectMethod: ObjectMethod;
+    documentation: string | undefined;
+    /**
+     * 关于当前对象的提示信息，用于代码完成时提示项或hover项提示
+     */
+    private tip;
+    parameterIndexes: number[];
+    methodDescriptorSegments: string[];
+    methodDescriptorKey: string;
+    constructor(verbalization: string, objectMethod: ObjectMethod);
+    private initMethodDescriptor;
+    buildTip(): string;
+}
+export declare class MethodParameter {
+    name: string;
+    datatype: Datatype;
+    domain: DomainValue | undefined;
+    constructor(name: string, datatype: Datatype);
+}
+export declare class BusinessObjectBunch {
+    fileName: string;
+    properties: ObjectProperty[];
+    objectsMap: Map<string, BusinessObject>;
+    constructor(fileName: string);
+}
+export declare class BusinessObject {
+    path: string;
+    fullClassName: string;
+    enum: boolean;
+    interface: boolean;
+    update: boolean;
+    deprecated: boolean;
+    static: boolean;
+    extends: string | undefined;
+    implements: string[] | undefined;
+    constructors: ObjectConstructor[];
+    properties: ObjectProperty[];
+    fields: Map<string, ObjectField>;
+    methods: Map<string, ObjectMethod>;
+    domain: DomainValue | undefined;
+    constructor(fullName: string, path: string);
+}
+export declare class ObjectConstructor {
+    name: string;
+    properties: ObjectProperty[];
+    constructor(name: string);
+}
+export declare class ObjectMethod {
+    name: string;
+    static: boolean;
+    abstract: boolean;
+    returnDatatype: Datatype;
+    targetObject: BusinessObject;
+    properties: ObjectProperty[];
+    parameters: MethodParameter[];
+    domain: DomainValue | undefined;
+    constructor(name: string, datatype: Datatype, targetObject: BusinessObject, isStatic: boolean);
+    key(): string;
+    buildKey(methodName: string, methodParameters: MethodParameter[]): string;
+}
+export declare class ObjectField {
+    name: string;
+    datatype: Datatype;
+    static: boolean;
+    final: boolean;
+    readonly: boolean;
+    writeonly: boolean;
+    abstract: boolean;
+    domain: DomainValue | undefined;
+    properties: ObjectProperty[];
+    constructor(name: string, datatype: Datatype);
+}
+export declare class ObjectProperty {
+    name: string;
+    value: string;
+    constructor(name: string, value: string);
+}
+export interface DomainValue {
+    type: string;
+    typeLabel: string;
+    toScript(): string;
+    toString(): string;
+}
+export declare class LiteralDomainValue implements DomainValue {
+    values: string[];
+    type: string;
+    typeLabel: string;
+    valueSet: Set<string>;
+    constructor(values: string[]);
+    toScript(): string;
+    toString(): string;
+}
+export declare class OtherDomainValue implements DomainValue {
+    value: string;
+    type: string;
+    typeLabel: string;
+    constructor(value: string);
+    toScript(): string;
+    toString(): string;
+}
+export declare class LimitDomainValue implements DomainValue {
+    includeMin: boolean | undefined;
+    includeMax: boolean | undefined;
+    min?: number;
+    max?: number;
+    type: string;
+    typeLabel: string;
+    constructor(min?: number, max?: number, includeMin?: boolean, includeMax?: boolean);
+    toScript(): string;
+    toString(): string;
+}
+export declare class StaticDomainValue implements DomainValue {
+    values: StaticValue[];
+    type: string;
+    typeLabel: string;
+    constructor(values: StaticValue[]);
+    toScript(): string;
+    toString(): string;
+}
+export declare class StaticValue {
+    value: string;
+    valueType: "field" | "string";
+    constructor(value: string, valueType: "field" | "string");
+}
+export declare class GenericityDomainValue implements DomainValue {
+    genericity?: string;
+    type: string;
+    typeLabel: string;
+    constructor(genericity?: string);
+    toScript(): string;
+    toString(): string;
+}

package/dist/model/BomFilesReader.d.ts

@@ -0,0 +1,13 @@
+import { DomainDeclareContext, PropertyItemContext } from '../grammar/bom/BomParser';
+import { BusinessObjectBunch, GenericityDomainValue, LimitDomainValue, LiteralDomainValue, ObjectProperty, OtherDomainValue, StaticDomainValue } from './BO';
+declare class BomFilesReader {
+    doReadBomFile(content: string, path: string, map: Map<string, BusinessObjectBunch>): void;
+}
+export declare const bomFilesReader: BomFilesReader;
+export declare const parseDomain: (context: DomainDeclareContext | null) => LiteralDomainValue | OtherDomainValue | LimitDomainValue | StaticDomainValue | GenericityDomainValue | undefined;
+export declare const parseProperties: (properties: PropertyItemContext[]) => {
+    props: ObjectProperty[];
+    update: boolean;
+    deprecated: boolean;
+};
+export {};

package/dist/model/Datatype.d.ts

@@ -0,0 +1,84 @@
+export declare class Datatype {
+    typeNumber: TypeNumber;
+    fullClassName: string;
+    genericityClassName?: string;
+    originalFullClassName: string;
+    /**
+     * 用于判断当前对象是不是为一个简单类型对象，比如String、Integer、Long等
+     */
+    private sample;
+    /**
+     * 用来记录当前数据类型的简单类名，比如string,int,long,float等
+     */
+    private simpleClassName;
+    /**
+     * 一个标记属性，用于标记当采用当前这个datatype进行代码提示时，只提示与当前datatype兼容的项，不兼容的项将不提示。
+     *
+     * 该属性主要用于动作的对字段进行赋值时选择目标字段时使用，还有就是当前位置需要提示对象时使用，在需要提示对象时就不需要提示变量。
+     */
+    force: boolean;
+    /**
+     * 用于标记当前数据类型是否透明，主要用在方法返回值当中，比如括号方法(...)的返回值这个属性就为true，表达它的返回值为其参数具体类型，
+     * 通过这个透明属性解决在代码提示过程当中使用(...)包裹代码块后无法识别数据类型的问题
+     */
+    private transparent;
+    private childrenDatatypes;
+    static readonly CLASS = "java.lang.Class";
+    static readonly OBJECT = "java.lang.Object";
+    static readonly STRING = "java.lang.String";
+    static readonly STRING_BASIC = "String";
+    static readonly NUMBER = "java.lang.Number";
+    static readonly DOUBLE = "java.lang.Double";
+    static readonly DOUBLE_BASIC = "double";
+    static readonly LONG = "java.lang.Long";
+    static readonly LONG_BASIC = "long";
+    static readonly INTEGER = "java.lang.Integer";
+    static readonly INTEGER_BASIC = "int";
+    static readonly FLOAT = "java.lang.Float";
+    static readonly FLOAT_BASIC = "float";
+    static readonly BIGDECIMAL = "java.math.BigDecimal";
+    static readonly BOOLEAN = "java.lang.Boolean";
+    static readonly BOOLEAN_BASIC = "boolean";
+    static readonly DATE = "java.util.Date";
+    static readonly TIME = "java.util.Time";
+    static readonly CHAR = "java.lang.Character";
+    static readonly CHAR_BASIC = "char";
+    static readonly VOID = "Void";
+    static readonly VOID_BASIC = "void";
+    static readonly COLLECTION_TAG = "[]";
+    constructor(fullClassName: string, typeNumber: TypeNumber);
+    static parseDatatype(fullClassName: string, genericity?: string): Datatype;
+    isNumber(): boolean;
+    compatibilityDatatype(targetDatatype: Datatype): boolean;
+    /**
+     * @returns true表示当前数据类型是简单类型，比如String、Integer、Long等，false表示当前数据类型是复杂类型，也就是具体业务对象类型
+     */
+    isSample(): boolean;
+    isTransparent(): boolean;
+    compatibilityBoolean(): boolean;
+    isClass(): boolean;
+    private isSampleType;
+    addChild(datatype: Datatype): void;
+    isVoid(): boolean;
+    /**
+     * @returns 返回当前数据类型的key，如果当前类型不是集合类型，直接返回类名，否则返回类名+"[]"
+     */
+    toKey(): string;
+    getSimpleClassName(): string;
+    clone(): Datatype;
+    getChildrenDatatypes(): Datatype[];
+    static newVoidDatatype(): Datatype;
+    static newObjectDatatype(typeNumber: TypeNumber): Datatype;
+    static newStringDatatype(typeNumber: TypeNumber): Datatype;
+    static newNumberDatatype(typeNumber: TypeNumber): Datatype;
+    static newBooleanDatatype(typeNumber: TypeNumber): Datatype;
+    static newDateDatatype(typeNumber: TypeNumber): Datatype;
+    static newTimeDatatype(typeNumber: TypeNumber): Datatype;
+    static newStringNumberDatatype(typeNumber: TypeNumber): Datatype;
+}
+export declare enum TypeNumber {
+    ONE = 0,
+    MANY = 1,
+    ANY = 2
+}
+export declare const getOnlyVariableDatatype: () => Datatype;