@lcap/nasl 1.0.0-alpha.13 → 1.0.0-alpha.16

package/src/concepts/Return__.ts

@@ -7,7 +7,6 @@ import Structure from './Structure__';
 import StructureProperty from './StructureProperty__';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
-
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -240,9 +239,9 @@ export class Return extends BaseNode {
             code += ': ';
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
-        if (this.defaultValue) {
-            code += ` = ${this.defaultValue}`;
-        }
+        // if (this.defaultValue) {
+        //     code += ` = ${this.defaultValue}`;
+        // }
         return code;
     }
 
@@ -279,7 +278,7 @@ export class Return extends BaseNode {
             if (!typeAnnotation)
                 throw new Error('找不到类型：' + typeAnnotation);
         } else {
-            typeAnnotation._delete();
+            typeAnnotation._delete?.();
             const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
             Object.assign(typeAnnotation, relationOptions);
         }
@@ -317,35 +316,46 @@ export class Return extends BaseNode {
         return !!this.module;
     }
     get hasChildren() {
-        const { typeKind } = this.typeAnnotation;
+        const { typeKind, typeNamespace } = this.typeAnnotation;
         if (typeKind === 'reference' || typeKind === 'generic') {
+            if (typeNamespace.endsWith('.enums'))
+                return null;
             return [{}];
         }
         return null;
     }
+    get isTreeLeaf() {
+        return !this.hasChildren;
+    }
     getSelectRef() {
-        const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
-        let completionChildren;
-        if (typeKind === 'reference') {
-            if (typeNamespace === 'nasl.ui') {
-                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                const properties = node.properties || [];
-                completionChildren = properties;
+        try {
+            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            let completionChildren;
+            if (typeKind === 'reference') {
+                if (typeNamespace === 'nasl.ui') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                } else if (typeNamespace.endsWith('.enums')) {
+                    completionChildren = undefined;
+                } else {
+                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else if (typeKind === 'generic') {
+                if (typeNamespace === 'nasl.collection') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
             } else {
-                const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
-                const properties = node.properties || [];
-                completionChildren = properties;
+                completionChildren = undefined;
             }
-        } else if (typeKind === 'generic') {
-            if (typeNamespace === 'nasl.collection') {
-                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                const properties = node.properties || [];
-                completionChildren = properties;
-            }
-        } else {
-            completionChildren = undefined;
+            return completionChildren;
+        } catch (err) {
+            console.log(err);
         }
-        return completionChildren;
     }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！

package/src/concepts/SqlQueryComponent__.ts

@@ -129,7 +129,7 @@ export class SqlQueryComponent extends LogicItem {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = `(function(): nasl.collection.List<`
-        code +=`${this.typeAnnotation ? this.typeAnnotation.toEmbeddedTS(shiftState(state, code)): 'unknown'}> {\n`;
+        code +=`${this.typeAnnotation ? this.typeAnnotation.toEmbeddedTS(shiftState(state, code)): '__IDENTIFIER__'}> {\n`;
         code += '\n';
         code += indent(state.tabSize + 1) + 'return;\n';
         code += indent(state.tabSize) + '})();\n';

package/src/concepts/StringLiteral__.ts

@@ -101,7 +101,7 @@ export class StringLiteral extends LogicItem {
     }
 
     @withSourceMap()
-    toEmbeddedTS(state?: TranslatorState): string {
+    toEmbeddedTS(state?: TranslatorState, isRequired?: boolean): string {
         let code = '';
         if (this.value) {
             if (!this.value.includes("'"))
@@ -113,7 +113,7 @@ export class StringLiteral extends LogicItem {
             else
                 code += `'${this.value.replace(/'/g, "\\'")}'`;
         } else {
-            code += `''`;
+            code += isRequired ? '__IDENTIFIER__' : `''`;
         }
         return code;
     }

package/src/concepts/StructureProperty__.ts

@@ -227,10 +227,55 @@ export class StructureProperty extends BaseNode {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+
+    get hasChildren() {
+        const { typeKind, typeNamespace } = this.typeAnnotation;
+        if (typeKind === 'reference' || typeKind === 'generic') {
+            if (typeNamespace.endsWith('.enums'))
+                return null;
+            return [{}];
+        }
+        return null;
+    }
+    get isTreeLeaf() {
+        return !this.hasChildren;
+    }
     /**
-     * 自动补全的字段列表
+     * 是否展开
      */
-    completionChildren: Array<EntityProperty | StructureProperty> = undefined;
+    @property()
+    isLeaf: boolean = true;
+
+    getSelectRef() {
+        try {
+            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            let completionChildren;
+            if (typeKind === 'reference') {
+                if (typeNamespace === 'nasl.ui') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                } else if (typeNamespace.endsWith('.enums')) {
+                    completionChildren = undefined;
+                } else {
+                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else if (typeKind === 'generic') {
+                if (typeNamespace === 'nasl.collection') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else {
+                completionChildren = undefined;
+            }
+            return completionChildren;
+        } catch (err) {
+            console.log(err);
+        }
+    }
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
@@ -262,7 +307,7 @@ export class StructureProperty extends BaseNode {
                 // eslint-disable-next-line prefer-rest-params
                 throw new Error('找不到类型：' + arguments[0]);
         } else {
-            typeAnnotation._delete();
+            typeAnnotation._delete?.();
             const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
             Object.assign(typeAnnotation, relationOptions);
         }
@@ -291,32 +336,7 @@ export class StructureProperty extends BaseNode {
      * 是否可编辑
      * */
     get readonly() {
-        return !!this.module;
-    }
-
-    getSelectRef() {
-        const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
-        let completionChildren;
-        if (typeKind === 'reference') {
-            if (typeNamespace === 'nasl.ui') {
-                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                const properties = node.properties || [];
-                completionChildren = properties;
-            } else {
-                const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
-                const properties = node.properties || [];
-                completionChildren = properties;
-            }
-        } else if (typeKind === 'generic') {
-            if (typeNamespace === 'nasl.collection') {
-                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                const properties = node.properties || [];
-                completionChildren = properties;
-            }
-        } else {
-            completionChildren = undefined;
-        }
-        return completionChildren;
+        return !!this.module || (this.parentNode as Structure).origin === 'CallQueryComponent';
     }
 
     //================================================================================

package/src/concepts/Structure__.ts

@@ -169,7 +169,7 @@ export class Structure extends BaseNode {
                 name: options,
             }, this, 'typeParams');
         } else if (options instanceof TypeParam) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             typeParam = options;
             Object.assign(typeParam, relationOptions);
         } else {
@@ -311,7 +311,7 @@ export class Structure extends BaseNode {
                 name: options,
             }, this, 'properties');
         } else if (options instanceof StructureProperty) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             property = options;
             Object.assign(property, relationOptions);
         } else {
@@ -518,7 +518,7 @@ export class Structure extends BaseNode {
      * 是否可编辑
      * */
     get readonly() {
-        return !!this.module;
+        return !!this.module || this.origin === 'CallQueryComponent';
     }
     /* 删除空数据模块 */
     deleteLogincAndModule() {
@@ -532,7 +532,7 @@ export class Structure extends BaseNode {
     toEmbeddedTS(state?: TranslatorState): string {
         let code = `export class ${this.tsName} {\n`;
         code += indent(state.tabSize + 1);
-        code += `__name: '${this.getNamespace()}.${this.tsName}';\n`;
+        code += `__name: '${this.getTsNamespace()}.${this.tsName}';\n`;
         this.properties.forEach((property) => {
             code += indent(state.tabSize + 1);
             code += property.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
@@ -550,6 +550,18 @@ export class Structure extends BaseNode {
             throw new Error('无法获取命名空间，请设置 parentNode！');
     }
 
+    getTsNamespace() {
+        if (this.parentNode.concept === 'App') {
+            return `${(this.parentNode as Namespace).getNamespace()}.structures`;
+        } else {
+            if (this.parentNode && (this.parentNode as Namespace).getTsNamespace) {
+                return `${(this.parentNode as Namespace).getTsNamespace()}.structures`;
+            } else {
+                throw new Error('无法获取命名空间，请设置 parentNode！');
+            }
+        }
+    }
+
     /**
      * 生成宿主语言的文件路径
      * @param name 一般不用传，用于 rename
@@ -560,7 +572,7 @@ export class Structure extends BaseNode {
     }
 
     toEmbeddedTSFile() {
-        let code = `namespace ${this.getNamespace()} {\n`;
+        let code = `namespace ${this.getTsNamespace()} {\n`;
 
         const state = createCompilerState(code, { tabSize: 1 });
         try {

package/src/concepts/SwitchCase__.ts

@@ -89,7 +89,7 @@ export class SwitchCase extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'consequent' };
         let logicItem: LogicItem;
         if (options instanceof LogicItem) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             logicItem = options;
             Object.assign(logicItem, relationOptions);
         } else {
@@ -249,7 +249,7 @@ export class SwitchCase extends LogicItem {
                 tabSize: 0,
             })) : '';
 
-            code += ')) {\n';
+            code += ') {\n';
 
             if (Array.isArray(this.consequent)) {
                 this.consequent.forEach((logicItem) => {
@@ -277,7 +277,7 @@ export class SwitchCase extends LogicItem {
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState, isLast?: boolean): string {
-        let code = '';
+        let code = '\n';
         if (!isLast) {
             code += 'if (nasl.core.ensureBoolean(';
             code += this.test ? this.test.toEmbeddedTS(shiftState(state, code, {

package/src/concepts/SwitchStatement__.ts

@@ -72,7 +72,7 @@ export class SwitchStatement extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'cases' };
         let switchCase: SwitchCase;
         if (options instanceof SwitchCase) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             switchCase = options;
             Object.assign(switchCase, relationOptions);
         } else {

package/src/concepts/TypeAnnotation__.ts

@@ -14,6 +14,20 @@ export enum PRIMITIVE_TYPE {
     Email = 'Email'
 }
 
+export const PRIMITIVE_TITLE: Record<string, string> = {
+    Boolean: '布尔值',
+    Integer: '整数',
+    Long: '长整数',
+    Double: '小数',
+    String: '字符串',
+    Text: '长文本',
+    Binary: '二进制流',
+    Date: '日期',
+    Time: '时间',
+    DateTime: '日期时间',
+    Email: '电子邮箱',
+};
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -62,13 +76,6 @@ export class TypeAnnotation extends BaseNode {
     @property('TypeAnnotation')
     typeArguments?: Array<TypeAnnotation> = null;
 
-    /**
-     * 显示文本
-     */
-    @excludedInJSON()
-    @property()
-    text?: string = undefined;
-
     /**
      * 是否是推断出来的
      */
@@ -116,7 +123,7 @@ export class TypeAnnotation extends BaseNode {
         const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
         let typeAnnotation: TypeAnnotation;
         if (options instanceof TypeAnnotation) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             typeAnnotation = options;
             Object.assign(typeAnnotation, relationOptions);
         } else {
@@ -252,13 +259,18 @@ export class TypeAnnotation extends BaseNode {
     }
 
     /**
-     * 临时展示 type 标题
+     * 用于展示的 type 标题
      */
     get typeTitle(): string {
-        if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
+        if (this.typeKind === 'primitive') {
+            return `${this.typeName} ${PRIMITIVE_TITLE[this.typeName]}`;
+        } else if (this.typeKind === 'reference') {
             return `${this.typeName}`;
         } else if (this.typeKind === 'generic') {
-            return `${this.typeName}<${(this.typeArguments || []).map((arg) => arg.typeTitle)}>`;
+            if (this.typeArguments && this.typeArguments.length)
+                return `${this.typeName}<${(this.typeArguments || []).map((arg) => arg.typeName || 'T')}>`;
+            else
+                return this.typeName;
         } else {
             return this.typeName;
         }
@@ -319,6 +331,10 @@ export class TypeAnnotation extends BaseNode {
         return '';
     }
 
+    toJS(state?: TranslatorState): string {
+        return JSON.stringify(this);
+    }
+
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         if (this.typeKind === 'primitive' || this.typeKind === 'reference') {
@@ -330,7 +346,13 @@ export class TypeAnnotation extends BaseNode {
             let code = `${this.tsCalleeNamespace}.${this.typeName}<`;
             return (code += `${(this.typeArguments || []).map((arg) => arg.toEmbeddedTS(shiftState(state, code, { inline: true })))}>`);
         } else {
-            return this.typeName;
+            if (this.tsCalleeNamespace && this.typeName) {
+                return `${this.tsCalleeNamespace}.${this.typeName}`;
+            } else if (this.typeName) {
+                return this.typeName;
+            } else {
+                return '__IDENTIFIER__';
+            }
         }
     }
 

package/src/concepts/UnaryExpression__.ts

@@ -137,7 +137,7 @@ export class UnaryExpression extends LogicItem {
         if (this.operator === 'isNull') {
             return this.argument.toUI(state);
         } else {
-            return '!' + this.argument.toUI(state);
+            return '!(' + this.argument.toUI(state) + ')';
         }
     }
 
@@ -162,7 +162,9 @@ export class UnaryExpression extends LogicItem {
 
         let code = '';
         if (this.argument) {
-            code += `${this.operator}(${this.argument.toEmbeddedTS(shiftState(state, code))})`;
+            code += `${this.operator}(`;
+            code += `${this.argument.toEmbeddedTS(shiftState(state, code))}`;
+            code += `)`;
         } else {
             code += `${this.operator}(__IDENTIFIER__)`;
         }

package/src/concepts/ValidationRule__.ts

@@ -92,7 +92,7 @@ export class ValidationRule extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'arguments' };
         let argument: Argument;
         if (options instanceof Argument) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             argument = options;
             Object.assign(argument, relationOptions);
         } else {
@@ -258,6 +258,29 @@ export class ValidationRule extends LogicItem {
         return code;
     }
 
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState): string {
+        let code = '';
+        if (this.calleeName) {
+            if (this.arguments.length) {
+                code += this.calleeKey;
+                code += '(';
+                this.arguments.forEach((arg, index) => {
+                    code += arg.toEmbeddedTS(shiftState(state, code), false, false);
+                    if (index !== this.arguments.length - 1)
+                        code += ', ';
+                });
+                code += ')';
+            } else {
+                // 没有入参数的不需要校验
+                return 'null';
+            }
+        } else {
+            code += '__IDENTIFIER__';
+        }
+        return code;
+    }
+
     get calleeKey(): string {
         return `${this.calleeNamespace}.${this.calleeName}`;
     }

package/src/concepts/Variable__.ts

@@ -240,9 +240,9 @@ export class Variable extends BaseNode {
             code += ': ';
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
-        if (this.defaultValue) {
-            code += ` = ${this.defaultValue}`;
-        }
+        // if (this.defaultValue) {
+        //     code += ` = ${this.defaultValue}`;
+        // }
         return code;
     }
 
@@ -275,7 +275,7 @@ export class Variable extends BaseNode {
             if (!typeAnnotation)
                 throw new Error('找不到类型：' + arguments[0]);
         } else {
-            typeAnnotation._delete();
+            typeAnnotation._delete?.();
             const relationOptions = { parentId: this.id, parentConcept: this.concept, parentNode: this };
             Object.assign(typeAnnotation, relationOptions);
         }
@@ -313,35 +313,46 @@ export class Variable extends BaseNode {
         return !!this.module;
     }
     get hasChildren() {
-        const { typeKind } = this.typeAnnotation;
+        const { typeKind, typeNamespace } = this.typeAnnotation;
         if (typeKind === 'reference' || typeKind === 'generic') {
+            if (typeNamespace.endsWith('.enums'))
+                return null;
             return [{}];
         }
         return null;
     }
+    get isTreeLeaf() {
+        return !this.hasChildren;
+    }
     getSelectRef() {
-        const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
-        let completionChildren;
-        if (typeKind === 'reference') {
-            if (typeNamespace === 'nasl.ui') {
-                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                const properties = node.properties || [];
-                completionChildren = properties;
+        try {
+            const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
+            let completionChildren;
+            if (typeKind === 'reference') {
+                if (typeNamespace === 'nasl.ui') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                } else if (typeNamespace.endsWith('.enums')) {
+                    completionChildren = undefined;
+                } else {
+                    const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
+            } else if (typeKind === 'generic') {
+                if (typeNamespace === 'nasl.collection') {
+                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                    const properties = node.properties || [];
+                    completionChildren = properties;
+                }
             } else {
-                const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
-                const properties = node.properties || [];
-                completionChildren = properties;
+                completionChildren = undefined;
             }
-        } else if (typeKind === 'generic') {
-            if (typeNamespace === 'nasl.collection') {
-                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                const properties = node.properties || [];
-                completionChildren = properties;
-            }
-        } else {
-            completionChildren = undefined;
+            return completionChildren;
+        } catch (err) {
+            console.log(err);
         }
-        return completionChildren;
     }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！

package/src/concepts/ViewComponent__.ts

@@ -164,7 +164,7 @@ export class ViewComponent extends BaseNode {
                 name: options,
             }, this, 'attrs');
         } else if (options instanceof Attribute) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             attribute = options;
             Object.assign(attribute, relationOptions);
         } else {
@@ -306,7 +306,7 @@ export class ViewComponent extends BaseNode {
                 name: options,
             }, this, 'events');
         } else if (options instanceof Event) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             event = options;
             Object.assign(event, relationOptions);
         } else {
@@ -448,7 +448,7 @@ export class ViewComponent extends BaseNode {
                 name: options,
             }, this, 'slots');
         } else if (options instanceof Slot) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             slot = options;
             Object.assign(slot, relationOptions);
         } else {
@@ -590,7 +590,7 @@ export class ViewComponent extends BaseNode {
                 name: options,
             }, this, 'methods');
         } else if (options instanceof Logic) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             logic = options;
             Object.assign(logic, relationOptions);
         } else {
@@ -732,7 +732,7 @@ export class ViewComponent extends BaseNode {
                 name: options,
             }, this, 'children');
         } else if (options instanceof ViewComponent) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             viewComponent = options;
             Object.assign(viewComponent, relationOptions);
         } else {