@lcap/nasl 1.0.2 → 2.12.0-beta

package/src/concepts/Entity__.ts

@@ -15,6 +15,7 @@ import classMap from '../common/classMap';
 import EntityProperty from './EntityProperty__';
 import EntityIndex from './EntityIndex__';
 import Module from './Module__';
+import DataSource from './DataSource__';
 import App from './App__';
 
 /**
@@ -82,6 +83,12 @@ export class Entity extends BaseNode {
     get app() {
         return this.getAncestor('App') as App;
     }
+    /**
+     * 祖先 DataSource
+     */
+    get dataSource() {
+        return this.getAncestor('DataSource') as DataSource;
+    }
 
     /**
      * @param source 需要合并的部分参数
@@ -644,40 +651,45 @@ export class Entity extends BaseNode {
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = `export class ${this.name} {\n`;
-        code += indent(state.tabSize + 1);
+        code += indent((state?.tabSize || 0) + 1);
         code += `__name: '${this.getNamespace()}.${this.name}';\n`;
         this.properties.forEach((property) => {
-            code += indent(state.tabSize + 1);
+            code += indent((state?.tabSize || 0) + 1);
             code += property.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
             code += ';\n';
         });
         if (this.indexes && this.indexes.length) {
-            code += indent(state.tabSize + 1);
+            code += indent((state?.tabSize || 0) + 1);
             code += `__IndexList() {\n`;
             code += `            return [`;
             this.indexes.forEach((entityIndex) => {
-                code += indent(state.tabSize + 1);
+                code += indent((state?.tabSize || 0) + 1);
                 code += '\n                ';
                 code += entityIndex.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
             });
-            code += indent(state.tabSize) + `\n            ];\n        }\n`;
+            code += indent((state?.tabSize || 0)) + `\n            ];\n        }\n`;
         }
 
         const ns = this.ns;
+
+        /**
+         * 8个函数的总行数
+         * 如果修改这里,可能会影响到dataSource的重命名,  在naslserver中,可能要一起修改
+         */
         code += `\nstatic logics = {\n`;
         ns.logics.forEach((logic) => {
-            code += indent(state.tabSize + 1);
+            code += indent((state?.tabSize || 0) + 1);
             code += logic.toEmbeddedTS(shiftState(state, code), 'inObject');
         });
         code += '}\n';
-        code += indent(state.tabSize) + '}\n';
+        code += indent((state?.tabSize || 0)) + '}\n';
 
         return code;
     }
 
     getNamespace() {
-        if (this.parentNode && (this.parentNode as Namespace).getNamespace)
-            return `${(this.parentNode as Namespace).getNamespace()}.entities`;
+        if (this.parentNode && (this.parentNode as DataSource).getNamespace)
+            return `${(this.parentNode as DataSource).getNamespace()}.${this.parentNode.name}.entities`;
         else
             throw new Error('无法获取命名空间，请设置 parentNode！');
     }
@@ -687,12 +699,12 @@ export class Entity extends BaseNode {
      * @param name 一般不用传，用于 rename
      */
     getEmbeddedFilePath(name = this.name) {
-        return `/embedded/${this.app.name}/entities/${name}.ts`;
+        return `/embedded/${this.app.name}/datasources/${this.parentNode.name}/entities/${name}.ts`;
     }
 
     get ns() {
         const ns: Namespace = entity2LogicNamespace(this);
-        ns.path = this.getNamespace() + '.' + ns.name;
+        ns.path = this.getNamespace();
         return ns;
     }
     // @excludedInJSON()
@@ -728,7 +740,7 @@ export class Entity extends BaseNode {
     //================================================================================
 }
 
-classMap['Entity'] = Entity;
+classMap.Entity = Entity;
 export default Entity;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/EnumItem__.ts

@@ -132,7 +132,7 @@ export class EnumItem extends BaseNode {
     //================================================================================
 }
 
-classMap['EnumItem'] = EnumItem;
+classMap.EnumItem = EnumItem;
 export default EnumItem;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/Enum__.ts

@@ -125,6 +125,10 @@ export class Enum extends BaseNode {
         });
     }
 
+    
+
+    
+
     /**
     * 插入枚举项
     * @internal
@@ -157,6 +161,8 @@ export class Enum extends BaseNode {
         return enumItem;
     }
 
+    
+
     /**
      * 插入枚举项
      * @param enumItemOptions 枚举项参数
@@ -179,6 +185,8 @@ export class Enum extends BaseNode {
         return node;
     }
 
+    
+
     /**
      * 添加枚举项
      * @internal
@@ -198,6 +206,8 @@ export class Enum extends BaseNode {
         return this._insertEnumItemAt(options as any, index);
     }
 
+    
+
     /**
      * 添加枚举项
      * @param enumItemOptions 枚举项参数
@@ -221,6 +231,9 @@ export class Enum extends BaseNode {
         return node;
     }
 
+
+    
+
     /**
      * 删除枚举项
      * @param enumItem 已有的枚举项实例
@@ -228,7 +241,7 @@ export class Enum extends BaseNode {
     removeEnumItem(enumItem: EnumItem): void;
 
     removeEnumItem(options: EnumItem) {
-        const enumItem: EnumItem = options;
+        let enumItem: EnumItem = options;
         return enumItem.delete();
     }
 
@@ -282,9 +295,9 @@ export class Enum extends BaseNode {
     toEmbeddedTS(state?: TranslatorState): string {
         let code = `export class ${this.name} extends nasl.core.Enums {\n`;
         // 增加一个单独的标签
-        code += indent(state.tabSize + 1) + `__name: '${this.getNamespace()}.${this.name}';\n`;
+        code += indent((state?.tabSize || 0) + 1) + `__name: '${this.getNamespace()}.${this.name}';\n`;
         this.enumItems.forEach((property) => {
-            code += indent(state.tabSize + 1);
+            code += indent((state?.tabSize || 0) + 1);
             code += property.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
             code += ';\n';
         });
@@ -298,14 +311,20 @@ export class Enum extends BaseNode {
             return str;
         }
         `;
-        code += indent(state.tabSize) + '}\n';
+        code += indent((state?.tabSize || 0)) + '}\n';
 
         return code;
     }
 
     getNamespace() {
         if (this.parentNode && (this.parentNode as Namespace).getNamespace) {
-            return `${(this.parentNode as Namespace).getNamespace()}.enums`;
+            const parentNamespace = (this.parentNode as Namespace).getNamespace();
+            const parentName = this.parentNode.name;
+            const arr = [parentNamespace];
+            if (this.parentNode.concept !== 'App' && parentName) {
+                arr.push(parentName);
+            }
+            return `${arr.join('.')}.enums`;
         } else
             throw new Error('无法获取命名空间，请设置 parentNode！');
     }

package/src/concepts/Event__.ts

@@ -309,7 +309,7 @@ export class Event extends BaseNode {
     //================================================================================
 }
 
-classMap['Event'] = Event;
+classMap.Event = Event;
 export default Event;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/ForEachStatement__.ts

@@ -548,11 +548,11 @@ export class ForEachStatement extends LogicItem {
             this.body.forEach((logicItem) => {
                 code
                     += logicItem.toEmbeddedTS(shiftState(state, code, {
-                        tabSize: state.tabSize + 1,
+                        tabSize: (state?.tabSize || 0) + 1,
                     })) + '\n';
             });
         }
-        code += indent(state.tabSize) + '})\n';
+        code += indent((state?.tabSize || 0)) + '})\n';
 
         return code;
     }
@@ -562,7 +562,7 @@ export class ForEachStatement extends LogicItem {
     //================================================================================
 }
 
-classMap['ForEachStatement'] = ForEachStatement;
+classMap.ForEachStatement = ForEachStatement;
 export default ForEachStatement;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/Function__.ts

@@ -1,4 +1,7 @@
 import Namespace from './Namespace__';
+import { TranslatorState, shiftState, withSourceMap, indent } from '../translator';
+import LogicItem from './LogicItem__';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -682,7 +685,7 @@ export class Function extends BaseNode {
     }
 
 
-    
+
 
     /**
     * 删除类型参数
@@ -886,7 +889,72 @@ export class Function extends BaseNode {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+    /**
+     * returnExpression 输出的Lambda 表达式
+     */
+    @property('LogicItem')
+    returnExpression: LogicItem = undefined;
 
+    /**
+     * 设置returnExpression 输出的Lambda 表达式
+     */
+    setReturnExpression(expression: LogicItem) {
+        expression._delete();
+        const relationOptions = { parentNode: this, parentKey: 'returnExpression' };
+        Object.assign(expression, relationOptions);
+        const object = {
+            returnExpression: expression,
+        };
+        this.update({
+            ...object,
+        });
+    }
+
+    toJS(state?: TranslatorState): String {
+        let code = '';
+        code += '(';
+        this.params.forEach((param, index) => {
+            code += param.toJS(shiftState(state, code));
+            if (index !== this.params.length - 1) {
+                code += ',';
+            }
+        });
+        code += ')';
+        code += ' => (';
+        if (this.returnExpression) {
+            code += this.returnExpression.toJS(shiftState(state, code));
+        }
+        code += ')';
+        return code;
+    }
+
+    /**
+     * 刪除LogicItem
+     * @param logicItem
+     * @returns
+     */
+    __removeLogicItem(logicItem: LogicItem) {
+        const parentKey = logicItem.parentKey;
+        const params: Params = {
+            parentNode: this,
+            parentKey,
+            index: -1,
+            object: null,
+            oldObject: logicItem,
+        };
+        if (parentKey) {
+            params.parentKey = parentKey;
+            if (Array.isArray((this as any)[parentKey])) {
+                const index = (this as any)[parentKey].indexOf(logicItem);
+                ~index && (this as any)[parentKey].splice(index, 1);
+                params.index = index;
+            } else if ((this as any)[parentKey] === logicItem) {
+                params.index = 0;
+                (this as any)[parentKey] = undefined;
+            }
+        }
+        return params;
+    }
     getVarExistingNames(excludedList: Array<Param | Return | Variable> = []) {
         const excludedSet = new Set(excludedList);
         return [...this.params, ...this.returns, ...this.variables].filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -901,7 +969,33 @@ export class Function extends BaseNode {
         } else
             throw new Error('无法获取命名空间，请设置 parentNode！');
     }
-
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState): string {
+        let code = '';
+        if (this.returnExpression) {
+            code += `(`;
+            this.params.forEach((param, index) => {
+                code += param.toEmbeddedTS(shiftState(state, code, { inline: true }));
+                if (index !== this.params.length - 1)
+                    code += ', ';
+            });
+            code += `)`;
+            if (this.returns.length) {
+                code += ': ';
+                code += this.returns[0].typeAnnotation.toEmbeddedTS(shiftState(state, code, { inline: true }));
+            }
+            code += ` => (`;
+    
+            if (this.returnExpression) {
+                code += this.returnExpression.toEmbeddedTS && this.returnExpression.toEmbeddedTS(shiftState(state, code, { tabSize: state.tabSize + 1 }));
+            }
+            code += indent(state.tabSize) + ')';
+        } else {
+            code += '__IDENTIFIER__';
+        }
+     
+        return code;
+    }
     get calleeKey() {
         const calleeNamespace = this.getNamespace();
         const calleeName = this.name;
@@ -914,7 +1008,7 @@ export class Function extends BaseNode {
     //================================================================================
 }
 
-classMap['Function'] = Function;
+classMap.Function = Function;
 export default Function;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/Identifier__.ts

@@ -1,6 +1,7 @@
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
 import { BindAttribute, CallFunction, CallLogic, Argument, MemberExpression, TypeAnnotation } from '..';
 import { ElementToVueOptions } from './ViewElement__';
+import { findConceptKeyWordByNamespace } from '../utils';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -38,6 +39,8 @@ export class Identifier extends LogicItem {
     @property()
     name: string = undefined;
 
+    
+
     /**
      * @param source 需要合并的部分参数
      */
@@ -51,6 +54,13 @@ export class Identifier extends LogicItem {
         return super.from(source, parentNode, parentKey) as Identifier;
     }
 
+    
+    
+
+    
+
+    
+
     //================================================================================
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
@@ -68,18 +78,7 @@ export class Identifier extends LogicItem {
     };
 
     isEnum() {
-        const namespace = this.namespace;
-        if (namespace) {
-            const namespaceArr = namespace.split('.');
-            const start = namespaceArr.shift();
-            if (start === 'app' || start === 'extensions') {
-                const mod = start === 'app' ? 0 : 1;
-                const keywordViews = namespaceArr.filter((namespaceItem, index) => index % 2 === mod);
-                const last = keywordViews.pop();
-                return last === 'enums';
-            }
-        }
-        return false;
+        return findConceptKeyWordByNamespace(this.namespace) === 'enums';
     }
 
     toVue(options?: ElementToVueOptions): string {
@@ -215,7 +214,7 @@ export class Identifier extends LogicItem {
     //================================================================================
 }
 
-classMap.Identifier = Identifier;
+classMap['Identifier'] = Identifier;
 export default Identifier;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/IfStatement__.ts

@@ -367,13 +367,13 @@ export class IfStatement extends LogicItem {
     public static getDefaultOptions() {
         return {
             label: '条件分支',
-        }
+        };
     }
     toJS(state?: TranslatorState) {
         let code = '';
         code += 'if (';
         code += this.test ? this.test.toJS(shiftState(state, code, {
-            tabSize: state.tabSize + 1,
+            tabSize: (state?.tabSize || 0) + 1,
         })) : '';
 
         code += ') {\n';
@@ -382,17 +382,17 @@ export class IfStatement extends LogicItem {
             this.consequent.forEach((logicItem) => {
                 code
                     += logicItem.toJS(shiftState(state, code, {
-                        tabSize: state.tabSize + 1,
+                        tabSize: (state?.tabSize || 0) + 1,
                     })) + '\n';
             });
         }
         code += '}';
         if (Array.isArray(this.alternate)) {
-            code += indent(state.tabSize) + ' else {\n';
+            code += indent((state?.tabSize || 0)) + ' else {\n';
             this.alternate.forEach((logicItem) => {
                 code
                     += logicItem.toJS(shiftState(state, code, {
-                        tabSize: state.tabSize + 1,
+                        tabSize: (state?.tabSize || 0) + 1,
                     })) + '\n';
             });
             code += '}\n';
@@ -414,21 +414,21 @@ export class IfStatement extends LogicItem {
             this.consequent.forEach((logicItem) => {
                 code
                     += logicItem.toEmbeddedTS(shiftState(state, code, {
-                        tabSize: state.tabSize + 1,
+                        tabSize: (state?.tabSize || 0) + 1,
                     })) + '\n';
             });
         }
 
-        code += indent(state.tabSize) + '}';
+        code += indent((state?.tabSize || 0)) + '}';
         if (Array.isArray(this.alternate)) {
             code += ' else {\n';
             this.alternate.forEach((logicItem) => {
                 code
                     += logicItem.toEmbeddedTS(shiftState(state, code, {
-                        tabSize: state.tabSize + 1,
+                        tabSize: (state?.tabSize || 0) + 1,
                     })) + '\n';
             });
-            code += indent(state.tabSize) + '}\n';
+            code += indent((state?.tabSize || 0)) + '}\n';
         }
         return code;
     }
@@ -438,7 +438,7 @@ export class IfStatement extends LogicItem {
     //================================================================================
 }
 
-classMap['IfStatement'] = IfStatement;
+classMap.IfStatement = IfStatement;
 export default IfStatement;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/InterfaceParam__.ts

@@ -333,7 +333,7 @@ export class InterfaceParam extends BaseNode {
     //================================================================================
 }
 
-classMap['InterfaceParam'] = InterfaceParam;
+classMap.InterfaceParam = InterfaceParam;
 export default InterfaceParam;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/Interface__.ts

@@ -726,21 +726,29 @@ export class Interface extends BaseNode {
     }
 
     getNamespace() {
-        if (this.parentNode && (this.parentNode as Namespace).getNamespace)
-            return `${(this.parentNode as Namespace).getNamespace()}.interfaces`;
-        else
+        if (this.parentNode && (this.parentNode as Namespace).getNamespace) {
+            const parentNamespace = (this.parentNode as Namespace).getNamespace();
+            const parentName = this.parentNode.name;
+            const arr = [parentNamespace];
+            if (this.parentNode.concept !== 'App' && parentName) {
+                arr.push(parentName);
+            }
+            return `${arr.join('.')}.interfaces`;
+        } else
             throw new Error('无法获取命名空间，请设置 parentNode！');
     }
+
     getTsNamespace() {
-        if (this.parentNode.concept === 'App') {
-            return `${(this.parentNode as Namespace).getNamespace()}.interfaces`;
-        } else {
-            if (this.parentNode && (this.parentNode as Namespace).getTsNamespace) {
-                return `${(this.parentNode as Namespace).getTsNamespace()}.interfaces`;
-            } else {
-                throw new Error('无法获取命名空间，请设置 parentNode！');
+        if (this.parentNode && (this.parentNode as Namespace).getTsNamespace) {
+            const parentNamespace = (this.parentNode as Namespace).getTsNamespace();
+            const parentName = this.parentNode.tsName || this.parentNode.name;
+            const arr = [parentNamespace];
+            if (this.parentNode.concept !== 'App' && parentName) {
+                arr.push(parentName);
             }
-        }
+            return `${arr.join('.')}.interfaces`;
+        } else
+            throw new Error('无法获取命名空间，请设置 parentNode！');
     }
 
     getVarExistingNames(excludedList: Array<InterfaceParam | Return> = []) {
@@ -754,7 +762,7 @@ export class Interface extends BaseNode {
     //================================================================================
 }
 
-classMap['Interface'] = Interface;
+classMap.Interface = Interface;
 export default Interface;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/JSBlock__.ts

@@ -93,7 +93,7 @@ export class JSBlock extends LogicItem {
     //================================================================================
 }
 
-classMap['JSBlock'] = JSBlock;
+classMap.JSBlock = JSBlock;
 export default JSBlock;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/LogicItem__.ts

@@ -245,7 +245,7 @@ export class LogicItem extends BaseNode {
     //================================================================================
 }
 
-classMap['LogicItem'] = LogicItem;
+classMap.LogicItem = LogicItem;
 export default LogicItem;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑