@lcap/nasl 1.0.0-alpha.9 → 1.0.0

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 {
@@ -190,7 +197,7 @@ export class TypeAnnotation extends BaseNode {
 
     addTypeAnnotation(options?: Partial<TypeAnnotation> | TypeAnnotation) {
         const node = this._addTypeAnnotation(options as any);
-        const index = this.typeArguments.length;
+        const index = this.typeArguments.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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,21 +331,52 @@ 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') {
-            if (this.typeKind === 'reference' && this.typeNamespace.endsWith('enums')) {
+            if (this.typeKind === 'reference' && this.typeNamespace && this.typeNamespace.endsWith('enums')) {
                 return `${this.tsCalleeNamespace}.${this.typeName}`;
             }
             return `${this.tsCalleeNamespace}.${this.typeName}`;
         } else if (this.typeKind === 'generic') {
             let code = `${this.tsCalleeNamespace}.${this.typeName}<`;
-            return code += `${(this.typeArguments || []).map((arg) => arg.toEmbeddedTS(shiftState(state, code, { inline: true })))}>`;
+            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__';
+            }
         }
     }
 
+    getDefaultValue(value: string) {
+        let code = '';
+        if (this.typeKind === 'primitive') {
+            if (this.typeName === 'String') {
+                code = `   "${value}" `;
+            } else {
+                if (['Long', 'Text'].includes(this.typeName)) {
+                    code = `  new ${this.typeNamespace}.${this.typeName}("${value}")`;
+                } else if (['Boolean'].includes(this.typeName)) {
+                    code = value;
+                } else {
+                    code = ` new ${this.typeNamespace}.${this.typeName}(${value})`;
+                }
+            }
+        } else {
+            code = ` ${this.typeNamespace}.${this.typeName}.${value}`;
+        }
+
+        return code;
+    }
+
     /**
      *
      * @param code 233

package/src/concepts/UnaryExpression__.ts

@@ -127,25 +127,25 @@ export class UnaryExpression extends LogicItem {
 
     toVue(options?: ElementToVueOptions) {
         if (this.operator === 'isNull') {
-            return this.argument.toVue(options);
+            return this.argument?.toVue(options);
         } else {
-            return '!' + this.argument.toVue(options);
+            return '!(' + this.argument?.toVue(options) + ')';
         }
     }
 
     toUI(state?: TranslatorState): string {
         if (this.operator === 'isNull') {
-            return this.argument.toUI(state);
+            return this.argument?.toUI(state);
         } else {
-            return '!' + this.argument.toUI(state);
+            return '!(' + this.argument?.toUI(state) + ')';
         }
     }
 
     toJS(state?: TranslatorState): string {
         if (this.operator === 'isNull') {
-            return this.argument.toJS(state);
+            return this.argument?.toJS(state);
         } else {
-            return '!' + this.argument.toJS(state);
+            return '!(' + this.argument?.toJS(state) + ')';
         }
     }
 
@@ -162,9 +162,11 @@ export class UnaryExpression extends LogicItem {
 
         let code = '';
         if (this.argument) {
-            code += `${this.operator}${this.argument}`;
+            code += `${this.operator}(`;
+            code += `${this.argument.toEmbeddedTS(shiftState(state, code))}`;
+            code += `)`;
         } else {
-            code += `${this.operator}__IDENTIFIER__`;
+            code += `${this.operator}(__IDENTIFIER__)`;
         }
         return code;
     }

package/src/concepts/Unparsed__.ts

@@ -81,7 +81,7 @@ export class Unparsed extends LogicItem {
 
     @withSourceMap()
     toEmbeddedTS(): string {
-        return this.code ? ` ${this.code} ` : '__IDENTIFIER__';
+        return 'nasl.core.universalVariable';
     }
 
     //================================================================================

package/src/concepts/ValidationRule__.ts

@@ -1,7 +1,7 @@
 import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
 import Function from './Function__';
 import { ElementToVueOptions } from './ViewElement__';
-
+import { getValidationInFunction } from '../server/getFunctions';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -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 {
@@ -166,7 +166,7 @@ export class ValidationRule extends LogicItem {
 
     addArgument(options?: Partial<Argument> | Argument) {
         const node = this._addArgument(options as any);
-        const index = this.arguments.length;
+        const index = this.arguments.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -220,9 +220,9 @@ export class ValidationRule extends LogicItem {
         let code = this.calleeName;
         if (this.arguments.length) {
             code += '(';
-            this.arguments.forEach((arg, index) => {
-                code += arg.toVue(options);
-                if (index !== this.arguments.length - 1)
+            this.arguments?.forEach((arg, index) => {
+                code += arg?.toVue(options);
+                if (index !== this.arguments?.length - 1)
                     code += ', ';
             });
             code += ')';
@@ -232,11 +232,11 @@ export class ValidationRule extends LogicItem {
 
     toUI(state?: TranslatorState): string {
         let code = this.calleeName;
-        if (this.arguments.length) {
+        if (this.arguments?.length) {
             code += '(';
-            this.arguments.forEach((arg, index) => {
-                code += arg.toUI(shiftState(state, code));
-                if (index !== this.arguments.length - 1)
+            this.arguments?.forEach((arg, index) => {
+                code += arg?.toUI(shiftState(state, code));
+                if (index !== this.arguments?.length - 1)
                     code += ', ';
             });
             code += ')';
@@ -246,11 +246,11 @@ export class ValidationRule extends LogicItem {
 
     toJS(state?: TranslatorState): string {
         let code = this.calleeName;
-        if (this.arguments.length) {
+        if (this.arguments?.length) {
             code += '(';
-            this.arguments.forEach((arg, index) => {
-                code += arg.toJS(shiftState(state, code));
-                if (index !== this.arguments.length - 1)
+            this.arguments?.forEach((arg, index) => {
+                code += arg?.toJS(shiftState(state, code));
+                if (index !== this.arguments?.length - 1)
                     code += ', ';
             });
             code += ')';
@@ -258,6 +258,36 @@ export class ValidationRule extends LogicItem {
         return code;
     }
 
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState): string {
+        let code = '';
+        if (this.calleeName) {
+            if (this.arguments.length) {
+                const validationInFunction = getValidationInFunction(this.calleeName);
+                code += this.calleeKey;
+                code += '(';
+                this.arguments.forEach((arg, index) => {
+                    // 如果找到函数而且有参数，就用参数的必填非必填
+                    if (validationInFunction && validationInFunction.params[index]) {
+                        code += arg.toEmbeddedTS(shiftState(state, code), validationInFunction.params[index].required, false);
+                    } else {
+                        // 如果没有就默认不必填
+                        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

@@ -3,8 +3,10 @@ import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import Entity from './Entity__';
 import Structure from './Structure__';
 import { ElementToVueOptions } from './ViewElement__';
-import { getNodeByNodeCallee } from '@nasl/automate/engine/utils';
 import EntityProperty from './EntityProperty__';
+import StructureProperty from './StructureProperty__';
+import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -238,8 +240,21 @@ export class Variable extends BaseNode {
             code += ': ';
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
+        // if (this.defaultValue) {
+        //     code += ` = ${this.defaultValue}`;
+        // }
+        return code;
+    }
+
+    @withSourceMap()
+    toEmbeddedTSInProcess(state?: TranslatorState): string {
+        let code = this.name;
+        if (this.typeAnnotation) {
+            code += ': undefined as ';
+            code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
+        }
         if (this.defaultValue) {
-            code += ` = ${this.defaultValue}`;
+            code += `: ${this.defaultValue}`;
         }
         return code;
     }
@@ -260,12 +275,17 @@ 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);
         }
         // 处理下拉属性
-        this.completionChildren = this.getSelectRef();
+        try {
+            this.completionChildren = this.getSelectRef();
+        } catch (err) {
+            this.completionChildren = [];
+            console.log(err);
+        }
         const object = {
             typeAnnotation,
         };
@@ -292,18 +312,47 @@ export class Variable extends BaseNode {
     get readonly() {
         return !!this.module;
     }
-
+    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;
+    }
     getSelectRef() {
-        const { typeName, typeKind, typeNamespace } = this.typeAnnotation;
-        let completionChildren;
-        if (typeKind === 'reference') {
-            const node = getNodeByNodeCallee(this.app, typeNamespace + '.' + typeName);
-            const properties = node.properties || [];
-            completionChildren = properties;
-        } else {
-            completionChildren = undefined;
+        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);
         }
-        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 {
@@ -252,7 +252,7 @@ export class ViewComponent extends BaseNode {
 
     addAttribute(options?: string | Partial<Attribute> | Attribute) {
         const node = this._addAttribute(options as any);
-        const index = this.attrs.length;
+        const index = this.attrs.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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 {
@@ -394,7 +394,7 @@ export class ViewComponent extends BaseNode {
 
     addEvent(options?: string | Partial<Event> | Event) {
         const node = this._addEvent(options as any);
-        const index = this.events.length;
+        const index = this.events.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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 {
@@ -536,7 +536,7 @@ export class ViewComponent extends BaseNode {
 
     addSlot(options?: string | Partial<Slot> | Slot) {
         const node = this._addSlot(options as any);
-        const index = this.slots.length;
+        const index = this.slots.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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 {
@@ -678,7 +678,7 @@ export class ViewComponent extends BaseNode {
 
     addLogic(options?: string | Partial<Logic> | Logic) {
         const node = this._addLogic(options as any);
-        const index = this.methods.length;
+        const index = this.methods.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -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 {
@@ -820,7 +820,7 @@ export class ViewComponent extends BaseNode {
 
     addViewComponent(options?: string | Partial<ViewComponent> | ViewComponent) {
         const node = this._addViewComponent(options as any);
-        const index = this.children.length;
+        const index = this.children.indexOf(node);
         node.create({
             index,
             parentNode: this,