@lcap/nasl 1.0.0-alpha.9 → 1.0.2

package/src/concepts/Destination__.ts

@@ -1,6 +1,8 @@
 import View from './View__';
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState, embeddedTSEmitter } from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
+import { BindAttribute } from '..';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -50,8 +52,6 @@ export class Destination extends LogicItem {
     @property('Argument')
     arguments: Array<Argument> = [];
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -65,7 +65,6 @@ export class Destination extends LogicItem {
         return super.from(source, parentNode, parentKey) as Destination;
     }
 
-    
     /**
      * 设置viewNamespace
      */
@@ -90,10 +89,6 @@ export class Destination extends LogicItem {
         });
     }
 
-    
-
-    
-
     /**
     * 插入实际参数
     * @internal
@@ -113,7 +108,7 @@ export class Destination 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 {
@@ -126,8 +121,6 @@ export class Destination extends LogicItem {
         return argument;
     }
 
-    
-
     /**
      * 插入实际参数
      * @param argumentOptions 实际参数参数
@@ -150,8 +143,6 @@ export class Destination extends LogicItem {
         return node;
     }
 
-    
-
     /**
      * 添加实际参数
      * @internal
@@ -171,8 +162,6 @@ export class Destination extends LogicItem {
         return this._insertArgumentAt(options as any, index);
     }
 
-    
-
     /**
      * 添加实际参数
      * @param argumentOptions 实际参数参数
@@ -187,7 +176,7 @@ export class Destination 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,
@@ -196,9 +185,6 @@ export class Destination extends LogicItem {
         return node;
     }
 
-
-    
-
     /**
      * 删除实际参数
      * @param argument 已有的实际参数实例
@@ -206,7 +192,7 @@ export class Destination extends LogicItem {
     removeArgument(argument: Argument): void;
 
     removeArgument(options: Argument) {
-        let argument: Argument = options;
+        const argument: Argument = options;
         return argument.delete();
     }
 
@@ -248,8 +234,24 @@ export class Destination extends LogicItem {
         return '';
     }
 
+    get tsName() {
+        if (this.viewName) {
+            let tsName = this.viewName;
+            // 匹配所有特殊字符都转为_
+            tsName = tsName.replace(/\W/g, '_');
+            if (/^\d/.test(tsName)) {
+                tsName = '$' + tsName;
+            }
+            return tsName;
+        }
+        return '';
+    }
     genViewArr() {
-        const viewArr = this.viewNamespace?.split('.').splice(1).filter((item, index) => index % 2 === 1) || [];
+        const viewArr
+            = this.viewNamespace
+                ?.split('.')
+                .splice(1)
+                .filter((item, index) => index % 2 === 1) || [];
         if (this.viewName) {
             viewArr.push(this.viewName);
         }
@@ -260,10 +262,17 @@ export class Destination extends LogicItem {
         let url = '';
         const viewArr = this.genViewArr();
         if (Array.isArray(viewArr) && viewArr.length) {
-            url += ':href="`';
+            url += ':destination="`';
             url += `/${viewArr.join('/')}`;
             if (Array.isArray(this.arguments) && this.arguments.length) {
-                const args = this.arguments.map((arg) => `${arg.keyword}=` + '${' + `${arg.toVue()}` + '}');
+                const args = this.arguments.map((arg) => {
+                    const value = arg?.toVue();
+                    let argStr = '';
+                    if (value) {
+                        argStr += `${arg.keyword}=` + '${' + `${value}` + '}';
+                    }
+                    return argStr;
+                }).filter((arg) => !!arg);
                 url += `?${args.join('&')}`;
             }
             url += '`"';
@@ -278,7 +287,7 @@ export class Destination extends LogicItem {
             url += '`';
             url += `/${viewArr.join('/')}`;
             if (Array.isArray(this.arguments) && this.arguments.length) {
-                const args = this.arguments.map((arg) => `${arg.keyword}=` + '${' + `${arg.toUI()}` + '}');
+                const args = this.arguments?.map((arg) => `${arg?.keyword}=` + '${' + `${arg?.toUI()}` + '}');
                 url += `?${args.join('&')}`;
             }
             url += '`';
@@ -293,7 +302,14 @@ export class Destination extends LogicItem {
             url += 'this.$destination(`';
             url += `/${viewArr.join('/')}`;
             if (Array.isArray(this.arguments) && this.arguments.length) {
-                const args = this.arguments.map((arg) => `${arg.keyword}=` + '${' + `${arg.toJS()}` + '}');
+                const args = this.arguments.map((arg) => {
+                    const value = arg?.toJS();
+                    let argStr = '';
+                    if (value) {
+                        argStr += `${arg.keyword}=` + '${' + `${value}` + '}';
+                    }
+                    return argStr;
+                }).filter((arg) => !!arg);
                 url += `?${args.join('&')}`;
             }
             url += '`)';
@@ -323,6 +339,38 @@ export class Destination extends LogicItem {
         });
     }
 
+    /**
+     * 设置view的argument
+     */
+    setViewArgument(view: View) {
+        const params = view.params;
+        const argument = this.arguments;
+        if (params.length > argument.length) {
+            params.forEach((item) => {
+                const arg = argument.find((arg) => arg.keyword === item.name);
+                if (!arg) {
+                    this.addArgument({
+                        keyword: item.name,
+                    });
+                }
+            });
+        } else {
+            argument.forEach((item) => {
+                const param = params.find((param) => param.name === item.keyword);
+                if (!param) {
+                    item.delete();
+                }
+            });
+        }
+    }
+    /**
+     * 设置Arguments的KeyWord
+     */
+    setArgumentsKeyWord(options: { findArgument: Argument; newKeyword: string }) {
+        const { findArgument, newKeyword } = options;
+        findArgument.setKeyword(newKeyword);
+    }
+
     get viewPath() {
         if (!this.viewNamespace) {
             return '';
@@ -338,23 +386,61 @@ export class Destination extends LogicItem {
         }
         return `${viewNameAttr.join('/')}/`;
     }
-
     @withSourceMap()
-    toEmbeddedTS(state?: TranslatorState): string {
-        let code = `${utils.firstLowerCase(this.concept)}: () => {\n`;
-        code += indent(state.tabSize + 2);
+    toEmbeddedTSInProcess(state: TranslatorState, prependCode: string): string {
+        // const tab = indent(state.tabSize);
         if (this.tsCalleeNamespace && this.tsName) {
-            code += `${this.tsCalleeNamespace}.${this.tsName}.$destination(`;
-            if (Array.isArray(this.arguments)) {
-                this.arguments.forEach((argument: Argument) => {
-                    code += argument.toEmbeddedTS(shiftState(state, code)) + ', ';
-                });
+            let code = `destination: function() {\n`;
+            code += prependCode;
+            code += '\n';
+            if (this.tsCalleeNamespace && this.viewName) {
+                code += `${this.tsCalleeNamespace}.${this.viewName}.$destination({`;
+                if (Array.isArray(this.arguments)) {
+                    this.arguments.forEach((argument: Argument) => {
+                        code += argument.toEmbeddedTS(shiftState(state, code), false, true) + ', ';
+                    });
+                }
+                code += `});\n`;
             }
-            code += `);\n`;
+            code += indent(state.tabSize + 1) + `}\n`;
+            return code;
+        } else {
+            return '__IDENTIFIER__';
         }
+    }
 
-        code += indent(state.tabSize + 1) + `},\n`;
-        return code;
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState): string {
+        let code = '';
+
+        if (this.parentNode instanceof BindAttribute) {
+            code = `${utils.firstLowerCase(this.concept)}: () => {\n`;
+            code += indent(state.tabSize + 2);
+            if (this.tsCalleeNamespace && this.tsName) {
+                code += `${this.tsCalleeNamespace}.${this.tsName}.$destination({`;
+                if (Array.isArray(this.arguments)) {
+                    this.arguments.forEach((argument: Argument) => {
+                        code += argument.toEmbeddedTS(shiftState(state, code), false, true) + ', ';
+                    });
+                }
+                code += `});\n`;
+            }
+            code += indent(state.tabSize + 1) + `},\n`;
+            return code;
+        } else {
+            if (this.tsCalleeNamespace && this.tsName) {
+                code += `${this.tsCalleeNamespace}.${this.tsName}.$destination({`;
+                if (Array.isArray(this.arguments)) {
+                    this.arguments.forEach((argument: Argument) => {
+                        code += argument.toEmbeddedTS(shiftState(state, code), false, true) + ', ';
+                    });
+                }
+                code += `});\n`;
+            } else {
+                code += '__IDENTIFIER__';
+            }
+            return code;
+        }
     }
     @withSourceMap()
     toEmbeddedTSNormalFunction(state?: TranslatorState): string {
@@ -378,7 +464,7 @@ export class Destination extends LogicItem {
     //================================================================================
 }
 
-classMap['Destination'] = Destination;
+classMap.Destination = Destination;
 export default Destination;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/End__.ts

@@ -56,7 +56,14 @@ export class End extends LogicItem {
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
     toJS(state?: TranslatorState): string {
-        return '';
+        let code = '';
+        const ret = this.logic.returns[0];
+        if (ret) {
+            code += 'return ' + ret.name + ';';
+        } else {
+            code += 'return;';
+        }
+        return code;
     }
 
     toEmbeddedTS(state?: TranslatorState): string {

package/src/concepts/EntityIndex__.ts

@@ -177,7 +177,8 @@ export class EntityIndex extends BaseNode {
      */
     moveUp() {
         const indexes = [...(this.parentNode as Entity).indexes];
-        const oldIndex = indexes.indexOf(this);
+        const indexesNameList = indexes.map((item) => item.name);
+        const oldIndex = indexesNameList.indexOf(this.name);
         this.changeSort(indexes, oldIndex, 'up');
         this.parentNode.update({
             indexes,
@@ -188,7 +189,8 @@ export class EntityIndex extends BaseNode {
      */
     moveDown() {
         const indexes = [...(this.parentNode as Entity).indexes];
-        const oldIndex = indexes.indexOf(this);
+        const indexesNameList = indexes.map((item) => item.name);
+        const oldIndex = indexesNameList.indexOf(this.name);
         this.changeSort(indexes, oldIndex, 'down');
         this.parentNode.update({
             indexes,

package/src/concepts/EntityProperty__.ts

@@ -1,5 +1,6 @@
 import { dataTypesMap } from './basics/types';
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
+import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 type changeType = 'up' | 'down';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -331,6 +332,54 @@ export class EntityProperty 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;
+    }
+
+    /**
+     * 是否展开
+     */
+    @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') {
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = node.properties || [];
+                completionChildren = properties;
+            } else {
+                completionChildren = undefined;
+            }
+            return completionChildren;
+        } catch (err) {
+            console.log(err);
+        }
+    }
     /**
      * 设置是否必填
      */
@@ -378,8 +427,8 @@ export class EntityProperty extends BaseNode {
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
         if (this.defaultValue) {
-            code += ` = ${this.defaultValue}`;
-        } // else
+            code += '= ' + this.typeAnnotation.getDefaultValue(this.defaultValue);
+        }
         return code;
     }
     /**
@@ -399,7 +448,7 @@ export class EntityProperty 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);
         }
@@ -439,7 +488,8 @@ export class EntityProperty extends BaseNode {
      */
     moveUp() {
         const properties = [...(this.parentNode as Entity).properties];
-        const oldIndex = properties.indexOf(this);
+        const propertiesNameList = properties.map((item) => item.name);
+        const oldIndex = propertiesNameList.indexOf(this.name);
         this.changeSort(properties, oldIndex, 'up');
         this.parentNode.update({
             properties,
@@ -450,7 +500,8 @@ export class EntityProperty extends BaseNode {
      */
     moveDown() {
         const properties = [...(this.parentNode as Entity).properties];
-        const oldIndex = properties.indexOf(this);
+        const propertiesNameList = properties.map((item) => item.name);
+        const oldIndex = propertiesNameList.indexOf(this.name);
         this.changeSort(properties, oldIndex, 'down');
         this.parentNode.update({
             properties,

package/src/concepts/Entity__.ts

@@ -107,19 +107,6 @@ export class Entity extends BaseNode {
         }
         return params;
     }
-    /**
-     * 设置实体名称
-     */
-    setName(name: string) {
-        const object = {
-            name,
-        };
-        this.update({
-            ...object,
-            field: 'name',
-        });
-    }
-
     /**
      * 设置实体描述
      */
@@ -137,7 +124,7 @@ export class Entity extends BaseNode {
         return (this.properties || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getPropertyUniqueName(name = 'property1') {
-        return utils.unique(name, this.getPropertyExistingNames());
+        return utils.unique(name, this.getPropertyExistingNames(), undefined, false);
     }
 
     /**
@@ -176,7 +163,7 @@ export class Entity extends BaseNode {
                 name: options,
             }, this, 'properties');
         } else if (options instanceof EntityProperty) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             property = options;
             Object.assign(property, relationOptions);
         } else {
@@ -264,7 +251,7 @@ export class Entity extends BaseNode {
 
     addProperty(options?: string | Partial<EntityProperty> | EntityProperty) {
         const node = this._addProperty(options as any);
-        const index = this.properties.length;
+        const index = this.properties.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -279,7 +266,7 @@ export class Entity extends BaseNode {
         return (this.indexes || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
     getEntityIndexUniqueName(name = 'entityIndex1') {
-        return utils.unique(name, this.getEntityIndexExistingNames());
+        return utils.unique(name, this.getEntityIndexExistingNames(), undefined, false);
     }
 
     /**
@@ -318,7 +305,7 @@ export class Entity extends BaseNode {
                 name: options,
             }, this, 'indexes');
         } else if (options instanceof EntityIndex) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             entityIndex = options;
             Object.assign(entityIndex, relationOptions);
         } else {
@@ -406,7 +393,7 @@ export class Entity extends BaseNode {
 
     addEntityIndex(options?: string | Partial<EntityIndex> | EntityIndex) {
         const node = this._addEntityIndex(options as any);
-        const index = this.indexes.length;
+        const index = this.indexes.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -520,6 +507,29 @@ export class Entity extends BaseNode {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+
+    getPropertyExistingNameList(excludedList: Array<EntityProperty> = []) {
+        const excludedSet = Array.from(new Set(excludedList));
+        const namelist = excludedSet.map((item) => item.name);
+        console.log(namelist);
+
+        return (this.properties || []).filter((item) => !namelist.includes(item.name)).map((item) => item.name);
+    }
+    /**
+     * 设置实体表名并修改表名
+     */
+    setName(name: string) {
+        const object: { name: string; tableName?: string } = {
+            name,
+        };
+        if (this.name === this.tableName && (this.origin === 'ide' || this.origin === 'sql')) {
+            object.tableName = name;
+        }
+        this.update({
+            ...object,
+            field: 'name',
+        });
+    }
     /**
      * 设置实体表名
      */
@@ -681,10 +691,13 @@ export class Entity extends BaseNode {
     }
 
     get ns() {
-        const ns = entity2LogicNamespace(this);
+        const ns: Namespace = entity2LogicNamespace(this);
         ns.path = this.getNamespace() + '.' + ns.name;
         return ns;
     }
+    // @excludedInJSON()
+    // nslogic: Namespace;
+
     get logics() {
         const ns = this.ns;
         return ns.logics;
@@ -695,7 +708,11 @@ export class Entity extends BaseNode {
         code += '    @nasl.annotation.Entity()\n';
 
         const state = createCompilerState(code, { tabSize: 1 });
-        code += this.toEmbeddedTS(state);
+        try {
+            code += this.toEmbeddedTS(state);
+        } catch (err) {
+            code += '';
+        }
         code += '}\n';
 
         return {

package/src/concepts/Enum__.ts

@@ -125,10 +125,6 @@ export class Enum extends BaseNode {
         });
     }
 
-    
-
-    
-
     /**
     * 插入枚举项
     * @internal
@@ -148,7 +144,7 @@ export class Enum extends BaseNode {
         const relationOptions = { parentNode: this, parentKey: 'enumItems' };
         let enumItem: EnumItem;
         if (options instanceof EnumItem) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             enumItem = options;
             Object.assign(enumItem, relationOptions);
         } else {
@@ -161,8 +157,6 @@ export class Enum extends BaseNode {
         return enumItem;
     }
 
-    
-
     /**
      * 插入枚举项
      * @param enumItemOptions 枚举项参数
@@ -185,8 +179,6 @@ export class Enum extends BaseNode {
         return node;
     }
 
-    
-
     /**
      * 添加枚举项
      * @internal
@@ -206,8 +198,6 @@ export class Enum extends BaseNode {
         return this._insertEnumItemAt(options as any, index);
     }
 
-    
-
     /**
      * 添加枚举项
      * @param enumItemOptions 枚举项参数
@@ -222,7 +212,7 @@ export class Enum extends BaseNode {
 
     addEnumItem(options?: Partial<EnumItem> | EnumItem) {
         const node = this._addEnumItem(options as any);
-        const index = this.enumItems.length;
+        const index = this.enumItems.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -231,9 +221,6 @@ export class Enum extends BaseNode {
         return node;
     }
 
-
-    
-
     /**
      * 删除枚举项
      * @param enumItem 已有的枚举项实例
@@ -241,7 +228,7 @@ export class Enum extends BaseNode {
     removeEnumItem(enumItem: EnumItem): void;
 
     removeEnumItem(options: EnumItem) {
-        let enumItem: EnumItem = options;
+        const enumItem: EnumItem = options;
         return enumItem.delete();
     }
 
@@ -280,24 +267,30 @@ export class Enum extends BaseNode {
     @property()
     children: any;
 
+    /**
+     * 是否展开
+     */
+    @property()
+    isLeaf: boolean = true;
+
+    getEnumItemExistingNames(excludedList: Array<EnumItem> = []) {
+        const excludedSet = new Set(excludedList);
+        return (this.enumItems || []).filter((item) => !excludedSet.has(item)).map((item) => item.value);
+    }
+
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = `export class ${this.name} {\n`;
+        let code = `export class ${this.name} extends nasl.core.Enums {\n`;
         // 增加一个单独的标签
-        code += indent(state.tabSize + 1) + `static __name: '${this.getNamespace()}.${this.name}';\n`;
-        let enumItemStr = '';
+        code += indent(state.tabSize + 1) + `__name: '${this.getNamespace()}.${this.name}';\n`;
         this.enumItems.forEach((property) => {
             code += indent(state.tabSize + 1);
             code += property.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
             code += ';\n';
-
-            enumItemStr += `${property.value}: ${this.name},\n`;
         });
         code += `
         static toList() {
-            let value: nasl.collection.List<{
-                ${enumItemStr}
-            }>
+            let value: nasl.collection.List<nasl.ui.EnumItem>
             return value;
         }
         static toString() {
@@ -330,7 +323,11 @@ export class Enum extends BaseNode {
         let code = `namespace ${this.getNamespace()} {\n`;
 
         const state = createCompilerState(code, { tabSize: 1 });
-        code += this.toEmbeddedTS(state);
+        try {
+            code += this.toEmbeddedTS(state);
+        } catch (err) {
+            code += '';
+        }
         code += '}\n';
 
         return {
@@ -346,7 +343,7 @@ export class Enum extends BaseNode {
     //================================================================================
 }
 
-classMap['Enum'] = Enum;
+classMap.Enum = Enum;
 export default Enum;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑