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

package/src/concepts/Namespace__.ts

@@ -200,7 +200,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'children');
         } else if (options instanceof Namespace) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             namespace = options;
             Object.assign(namespace, relationOptions);
         } else {
@@ -342,7 +342,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'processes');
         } else if (options instanceof Process) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             process = options;
             Object.assign(process, relationOptions);
         } else {
@@ -484,7 +484,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'entities');
         } else if (options instanceof Entity) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             entity = options;
             Object.assign(entity, relationOptions);
         } else {
@@ -626,7 +626,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'structures');
         } else if (options instanceof Structure) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             structure = options;
             Object.assign(structure, relationOptions);
         } else {
@@ -768,7 +768,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'enums');
         } else if (options instanceof Enum) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             enumeration = options;
             Object.assign(enumeration, relationOptions);
         } else {
@@ -910,7 +910,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'logics');
         } else if (options instanceof Logic) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             logic = options;
             Object.assign(logic, relationOptions);
         } else {
@@ -1052,7 +1052,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'functions');
         } else if (options instanceof Function) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             func = options;
             Object.assign(func, relationOptions);
         } else {
@@ -1194,7 +1194,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'interfaces');
         } else if (options instanceof Interface) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             itface = options;
             Object.assign(itface, relationOptions);
         } else {
@@ -1336,7 +1336,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'views');
         } else if (options instanceof View) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             view = options;
             Object.assign(view, relationOptions);
         } else {
@@ -1478,7 +1478,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'variables');
         } else if (options instanceof Variable) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             variable = options;
             Object.assign(variable, relationOptions);
         } else {
@@ -1620,7 +1620,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'viewComponents');
         } else if (options instanceof ViewComponent) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             viewComponent = options;
             Object.assign(viewComponent, relationOptions);
         } else {
@@ -1762,7 +1762,7 @@ export class Namespace extends BaseNode {
                 name: options,
             }, this, 'processComponents');
         } else if (options instanceof ProcessComponent) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             processComponent = options;
             Object.assign(processComponent, relationOptions);
         } else {

package/src/concepts/Param__.ts

@@ -345,6 +345,9 @@ export class Param extends BaseNode {
         }
         return null;
     }
+    get isTreeLeaf() {
+        return !this.hasChildren;
+    }
     getSelectRef() {
         const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
         let completionChildren;

package/src/concepts/ProcessComponent__.ts

@@ -144,7 +144,7 @@ export class ProcessComponent extends BaseNode {
                 name: options,
             }, this, 'attrs');
         } else if (options instanceof Attribute) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             attribute = options;
             Object.assign(attribute, relationOptions);
         } else {
@@ -286,7 +286,7 @@ export class ProcessComponent extends BaseNode {
                 name: options,
             }, this, 'logics');
         } else if (options instanceof Logic) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             logic = options;
             Object.assign(logic, relationOptions);
         } else {

package/src/concepts/ProcessElement__.ts

@@ -292,7 +292,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'waypoints');
         } else if (options instanceof Point) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             point = options;
             Object.assign(point, relationOptions);
         } else {
@@ -434,7 +434,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'variables');
         } else if (options instanceof Variable) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             variable = options;
             Object.assign(variable, relationOptions);
         } else {
@@ -576,7 +576,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'returns');
         } else if (options instanceof Return) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             ret = options;
             Object.assign(ret, relationOptions);
         } else {
@@ -718,7 +718,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'constants');
         } else if (options instanceof Constant) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             constant = options;
             Object.assign(constant, relationOptions);
         } else {
@@ -860,7 +860,7 @@ export class ProcessElement extends BaseNode {
                 name: options,
             }, this, 'bindAttrs');
         } else if (options instanceof BindAttribute) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             bindAttribute = options;
             Object.assign(bindAttribute, relationOptions);
         } else {

package/src/concepts/ProcessOutcome__.ts

@@ -74,7 +74,7 @@ export class ProcessOutcome extends LogicItem {
     //================================================================================
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        const code = `return () => ${this.flowRef ? this.flowRef : '__IDENTIFIER__'}`;
+        const code = `return () => ${this.flowRef ? `"${this.flowRef}"` : '__IDENTIFIER__'}`;
         return code;
     }
 

package/src/concepts/Process__.ts

@@ -194,7 +194,7 @@ export class Process extends BaseNode {
                 name: options,
             }, this, 'params');
         } else if (options instanceof Param) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             param = options;
             Object.assign(param, relationOptions);
         } else {
@@ -336,7 +336,7 @@ export class Process extends BaseNode {
                 name: options,
             }, this, 'returns');
         } else if (options instanceof Return) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             ret = options;
             Object.assign(ret, relationOptions);
         } else {
@@ -478,7 +478,7 @@ export class Process extends BaseNode {
                 name: options,
             }, this, 'constants');
         } else if (options instanceof Constant) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             constant = options;
             Object.assign(constant, relationOptions);
         } else {
@@ -620,7 +620,7 @@ export class Process extends BaseNode {
                 name: options,
             }, this, 'elements');
         } else if (options instanceof ProcessElement) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             element = options;
             Object.assign(element, relationOptions);
         } else {

package/src/concepts/QueryFromExpression__.ts

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

package/src/concepts/QueryJoinExpression__.ts

@@ -132,7 +132,7 @@ export class QueryJoinExpression extends LogicItem {
                 name: options,
             }, this, 'onExpressions');
         } else if (options instanceof BinaryExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             binaryExpression = options;
             Object.assign(binaryExpression, relationOptions);
         } else {
@@ -250,7 +250,7 @@ export class QueryJoinExpression extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'joinParts' };
         let queryJoinExpression: QueryJoinExpression;
         if (options instanceof QueryJoinExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             queryJoinExpression = options;
             Object.assign(queryJoinExpression, relationOptions);
         } else {

package/src/concepts/QuerySelectExpression__.ts

@@ -113,7 +113,7 @@ export class QuerySelectExpression extends LogicItem {
                 name: options,
             }, this, 'selectElements');
         } else if (options instanceof QueryAggregateExpression) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             queryAggregateExpression = options;
             Object.assign(queryAggregateExpression, relationOptions);
         } else {

package/src/concepts/Return__.ts

@@ -240,9 +240,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;
     }
 
@@ -323,6 +323,9 @@ export class Return extends BaseNode {
         }
         return null;
     }
+    get isTreeLeaf() {
+        return !this.hasChildren;
+    }
     getSelectRef() {
         const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
         let completionChildren;

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,41 @@ export class StructureProperty extends BaseNode {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
-    /**
-     * 自动补全的字段列表
-     */
-    completionChildren: Array<EntityProperty | StructureProperty> = undefined;
+
+    get hasChildren() {
+        const { typeKind } = this.typeAnnotation;
+        if (typeKind === 'reference' || typeKind === 'generic') {
+            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;
+            } 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;
+    }
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
@@ -291,33 +322,9 @@ export class StructureProperty extends BaseNode {
      * 是否可编辑
      * */
     get readonly() {
-        return !!this.module;
+        return !!this.module || (this.parentNode as Structure).origin === 'CallQueryComponent';
     }
 
-    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;
-    }
 
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！

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() {

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

@@ -116,7 +116,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 {
@@ -330,7 +330,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) + ')';
         }
     }
 

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));
+                    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;
     }
 
@@ -319,6 +319,9 @@ export class Variable extends BaseNode {
         }
         return null;
     }
+    get isTreeLeaf() {
+        return !this.hasChildren;
+    }
     getSelectRef() {
         const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
         let completionChildren;

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 {