@lcap/nasl 1.0.1 → 2.12.0-beta.1

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 需要合并的部分参数
@@ -107,7 +114,6 @@ export class Entity extends BaseNode {
         }
         return params;
     }
-
     /**
      * 设置实体描述
      */
@@ -120,7 +126,7 @@ export class Entity extends BaseNode {
         });
     }
 
-    getPropertyExistingNames(excludedList: Array<EntityProperty> = []) {
+        getPropertyExistingNames(excludedList: Array<EntityProperty> = []) {
         const excludedSet = new Set(excludedList);
         return (this.properties || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
     }
@@ -261,6 +267,7 @@ export class Entity extends BaseNode {
         return node;
     }
 
+
     getEntityIndexExistingNames(excludedList: Array<EntityIndex> = []) {
         const excludedSet = new Set(excludedList);
         return (this.indexes || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
@@ -402,6 +409,9 @@ export class Entity extends BaseNode {
         return node;
     }
 
+
+    
+
     /**
     * 删除实体字段
     * @param name 实体字段名称
@@ -450,6 +460,8 @@ export class Entity extends BaseNode {
         return params;
     }
 
+
+
     /**
     * 删除实体索引
     * @param name 实体索引名称
@@ -503,6 +515,13 @@ 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);
+    }
     /**
      * 设置实体表名并修改表名
      */
@@ -632,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！');
     }
@@ -675,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()
@@ -716,7 +740,7 @@ export class Entity extends BaseNode {
     //================================================================================
 }
 
-classMap.Entity = Entity;
+classMap['Entity'] = Entity;
 export default Entity;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑

package/src/concepts/Enum__.ts

@@ -286,13 +286,18 @@ export class Enum extends BaseNode {
     @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} 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';
         });
@@ -306,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/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;
     }

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 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -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);
@@ -895,13 +963,39 @@ export class Function extends BaseNode {
         if (this.parentNode) {
             let parentNodeNamespace = '';
             if ((this.parentNode as Namespace).getNamespace) {
-                parentNodeNamespace = (this.parentNode as Namespace).getNamespace();
+                parentNodeNamespace = [(this.parentNode as Namespace).getNamespace(), this.parentNode.name].join('.');
             }
             return `${parentNodeNamespace}`;
         } 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;

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 自动生成，请不手动修改！
@@ -77,25 +78,14 @@ 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 {
         let name = this.name;
         const namespace = this.namespace;
         if (namespace) {
-            if ((this.namespace.endsWith('nasl.browser') || this.namespace.endsWith('nasl.auth') || this.namespace.endsWith('nasl.configuration'))) {
+            if ((this.namespace.endsWith('nasl.browser') || this.namespace.endsWith('nasl.auth') || this.namespace.endsWith('nasl.configuration') || this.namespace.endsWith('nasl.process'))) {
                 name = `$global.${this.name}`;
             } else if (this.isEnum()) {
                 name = `$utils.EnumList("${this.name}")`;
@@ -136,7 +126,7 @@ export class Identifier extends LogicItem {
         let name = this.name;
         const namespace = this.namespace;
         if (namespace) {
-            if (namespace.endsWith('nasl.browser') || namespace.endsWith('nasl.auth') || namespace.endsWith('nasl.configuration')) {
+            if (namespace.endsWith('nasl.browser') || namespace.endsWith('nasl.auth') || namespace.endsWith('nasl.configuration') || this.namespace.endsWith('nasl.process')) {
                 name = `$global.${this.name}`;
             } else if (this.isEnum()) {
                 name = `$utils.EnumList("${this.name}")`;
@@ -147,6 +137,7 @@ export class Identifier extends LogicItem {
             || namespace?.endsWith('nasl.browser')
             || namespace?.endsWith('nasl.auth')
             || namespace?.endsWith('nasl.configuration')
+            || namespace?.endsWith('nasl.process')
             || this.isEnum())
             && !isMemberExpressionProperty ? `this.${name}` : name;
     }

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;
     }

package/src/concepts/InterfaceParam__.ts

@@ -309,11 +309,16 @@ export class InterfaceParam extends BaseNode {
                     completionChildren = properties;
                 }
             } else if (typeKind === 'generic') {
-                if (typeNamespace === 'nasl.collection') {
-                    const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
-                    const properties = node.properties || [];
-                    completionChildren = properties;
+                const node = getNaslNodeByNodeCallee(typeNamespace, typeName);
+                const properties = node.properties || [];
+                for (let i = 0; i < properties.length; i++) {
+                    const item = properties[i];
+                    if (item?.typeAnnotation?.typeKind === 'typeParam') {
+                        properties[i].typeAnnotation = this?.typeAnnotation?.typeArguments[0];
+                        properties[i].parentNode = this;
+                    }
                 }
+                completionChildren = properties;
             } else {
                 completionChildren = undefined;
             }

package/src/concepts/Interface__.ts

@@ -581,7 +581,7 @@ export class Interface extends BaseNode {
     }
 
     get calleeKey(): string {
-        return `${this.getTsNamespace()}.${this.name} `;
+        return `${this.getTsNamespace()}.${this.name}`;
     }
 
     get calleewholeKey() {
@@ -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> = []) {

package/src/concepts/JSBlock__.ts

@@ -35,8 +35,6 @@ export class JSBlock extends LogicItem {
     @property()
     code: string = undefined;
 
-    
-
     /**
      * @param source 需要合并的部分参数
      */
@@ -50,7 +48,6 @@ export class JSBlock extends LogicItem {
         return super.from(source, parentNode, parentKey) as JSBlock;
     }
 
-    
     /**
      * 设置代码内容
      */
@@ -63,10 +60,6 @@ export class JSBlock extends LogicItem {
         });
     }
 
-    
-
-    
-
     //================================================================================
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
@@ -76,11 +69,9 @@ export class JSBlock extends LogicItem {
         /**
          * 生成 JS 脚本
          */
-        return `const jsBlock_number = async () => {
+        return `await (async () => {
             ${this.code}
-        }
-    
-        await jsBlock_number();`;
+        })();`;
     }
 
     toEmbeddedTS(state?: TranslatorState): string {
@@ -93,7 +84,7 @@ export class JSBlock extends LogicItem {
     //================================================================================
 }
 
-classMap['JSBlock'] = JSBlock;
+classMap.JSBlock = JSBlock;
 export default JSBlock;
 //================================================================================
 // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑