@lcap/nasl 1.0.0-alpha.7 → 1.0.0

package/src/concepts/Function__.ts

@@ -170,7 +170,7 @@ export class Function extends BaseNode {
                 name: options,
             }, this, 'typeParams');
         } else if (options instanceof TypeParam) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             typeParam = options;
             Object.assign(typeParam, relationOptions);
         } else {
@@ -258,7 +258,7 @@ export class Function extends BaseNode {
 
     addTypeParam(options?: string | Partial<TypeParam> | TypeParam) {
         const node = this._addTypeParam(options as any);
-        const index = this.typeParams.length;
+        const index = this.typeParams.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -308,7 +308,7 @@ export class Function extends BaseNode {
                 name: options,
             }, this, 'params');
         } else if (options instanceof Param) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             param = options;
             Object.assign(param, relationOptions);
         } else {
@@ -396,7 +396,7 @@ export class Function extends BaseNode {
 
     addParam(options?: string | Partial<Param> | Param) {
         const node = this._addParam(options as any);
-        const index = this.params.length;
+        const index = this.params.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -406,7 +406,7 @@ export class Function extends BaseNode {
     }
 
 
-    getReturnUniqueName(name = 'result1') {
+    getReturnUniqueName(name = 'result') {
         return utils.unique(name, this.getVarExistingNames());
     }
 
@@ -446,7 +446,7 @@ export class Function extends BaseNode {
                 name: options,
             }, this, 'returns');
         } else if (options instanceof Return) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             ret = options;
             Object.assign(ret, relationOptions);
         } else {
@@ -534,7 +534,7 @@ export class Function extends BaseNode {
 
     addReturn(options?: string | Partial<Return> | Return) {
         const node = this._addReturn(options as any);
-        const index = this.returns.length;
+        const index = this.returns.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -584,7 +584,7 @@ export class Function extends BaseNode {
                 name: options,
             }, this, 'variables');
         } else if (options instanceof Variable) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             variable = options;
             Object.assign(variable, relationOptions);
         } else {
@@ -672,7 +672,7 @@ export class Function extends BaseNode {
 
     addVariable(options?: string | Partial<Variable> | Variable) {
         const node = this._addVariable(options as any);
-        const index = this.variables.length;
+        const index = this.variables.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/Identifier__.ts

@@ -1,5 +1,5 @@
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
-import { BindAttribute, CallFunction, CallLogic, Argument } from '..';
+import { BindAttribute, CallFunction, CallLogic, Argument, MemberExpression, TypeAnnotation } from '..';
 import { ElementToVueOptions } from './ViewElement__';
 
 //================================================================================
@@ -64,46 +64,91 @@ export class Identifier extends LogicItem {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+
+    // 选中的数据类型，这个用作暂存
+    typeAnnotation: TypeAnnotation = undefined;
+
     globalDataMap: {
-        [name: string]: boolean
+        [name: string]: boolean;
     } = {
         $route: true,
         $global: true,
         $refs: true,
     };
 
+    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;
+    }
+
     toVue(options?: ElementToVueOptions): string {
-        return this.name;
+        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'))) {
+                name = `$global.${this.name}`;
+            } else if (this.isEnum()) {
+                name = `$utils.EnumList("${this.name}")`;
+            }
+        }
+        return name;
     }
 
     toUI(): string {
-        return this.name;
+        let name = this.name;
+        const namespace = this.namespace;
+        if (namespace) {
+            if (namespace.startsWith('nasl.')) {
+                name = `${namespace}.${this.name}`;
+            } else if (this.isEnum()) {
+                name = `$utils.EnumList("${this.name}")`;
+            }
+        }
+        return name;
     }
 
     toJS(): string {
         const dataMap: {
-            [name: string]: boolean
+            [name: string]: boolean;
         } = {};
-        if (this.view) {
-            const { params, variables } = this.view;
-            if (Array.isArray(params)) {
-                params.forEach((param) => {
-                    dataMap[param.name] = true;
-                });
-            }
-            if (Array.isArray(variables)) {
-                variables.forEach((variable) => {
-                    dataMap[variable.name] = true;
-                });
-            }
-        }
+
+        this.view?.params?.forEach((param) => {
+            dataMap[param.name] = true;
+        });
+        this.view?.variables?.forEach((variable) => {
+            dataMap[variable.name] = true;
+        });
         const parentNode = this.parentNode;
-        const grandParentNode = parentNode?.parentNode;
-        let isMemberExpression = false;
-        if (parentNode?.concept === 'MemberExpression' && (grandParentNode?.concept === 'MemberExpression' || this.parentKey === 'property')) {
-            isMemberExpression = true;
+        let isMemberExpressionProperty = false;
+        if (parentNode?.concept === 'MemberExpression' && this.parentKey === 'property') {
+            isMemberExpressionProperty = true;
         }
-        return (dataMap[this.name] || this.globalDataMap[this.name]) && !isMemberExpression ? `this.${this.name}` : this.name;
+        let name = this.name;
+        const namespace = this.namespace;
+        if (namespace) {
+            if (namespace.endsWith('nasl.browser') || namespace.endsWith('nasl.auth') || namespace.endsWith('nasl.configuration')) {
+                name = `$global.${this.name}`;
+            } else if (this.isEnum()) {
+                name = `$utils.EnumList("${this.name}")`;
+            }
+        }
+        return (dataMap[name]
+            || this.globalDataMap[name]
+            || namespace?.endsWith('nasl.browser')
+            || namespace?.endsWith('nasl.auth')
+            || namespace?.endsWith('nasl.configuration')
+            || this.isEnum())
+            && !isMemberExpressionProperty ? `this.${name}` : name;
     }
 
     @withSourceMap()
@@ -114,7 +159,7 @@ export class Identifier extends LogicItem {
             const viewLogics = view.logics;
             const findLogic = viewLogics.find((item) => item.name === this.name);
             if (findLogic) {
-                return 'logics.' + this.name;
+                return this.name;
             }
         }
         // 因为右侧枚举要赋值就赋值toList方法一下
@@ -122,21 +167,25 @@ export class Identifier extends LogicItem {
             // 绑定类型
             if (this.parentNode instanceof BindAttribute) {
                 // this.parentNode.name === 'data-source'
-                return ((this.namespace + '.') || '') + this.name + '.toList';
+                return (this.namespace + '.' || '') + this.name + '.toList';
             }
         }
 
         // 如果是nasl.util.Enum 的子集里的 Identifier > MemberExpression > Argument > callfunction
         // nasl.util.Enum 的 右侧是转成字符串的
         // 如果是identifier 而且枚举
-        if (this.parentNode.parentNode.parentNode instanceof CallFunction) {
-            const Argument = this.parentNode.parentNode;
-            const argIndex = this.parentNode.parentNode.parentNode.arguments.findIndex((item) => item === Argument);
-            const calleeNamespace = this.parentNode.parentNode.parentNode.calleeNamespace;
-            const calleeName = this.parentNode.parentNode.parentNode.calleeName;
-            if (calleeNamespace + '.' + calleeName === 'nasl.util.Enum' && argIndex === 1) {
-                return (this.namespace ? this.namespace + '.' : '') + this.name + '.toString()';
-            }
+        // if (this.parentNode?.parentNode?.parentNode instanceof CallFunction) {
+        //     const calleeNamespace = this.parentNode.parentNode.parentNode.calleeNamespace;
+        //     const calleeName = this.parentNode.parentNode.parentNode.calleeName;
+        //     if (calleeNamespace + '.' + calleeName === 'nasl.util.Enum') {
+        //         const str = (this.namespace ? this.namespace + '.' : '') + this.name;
+        //         return str.includes('.enums.') ? str : str + '.toString()';
+        //     }
+        // }
+
+        // having 下选择的变量不生成 namespace 前缀
+        if (this.namespace === 'inner' && this.getAncestor('CallQueryComponent')) {
+            return `__${this.name}` || '__IDENTIFIER__';
         }
 
         return this.namespace ? this.namespace + '.' + this.name : this.name || '__IDENTIFIER__';

package/src/concepts/IfStatement__.ts

@@ -96,7 +96,7 @@ export class IfStatement 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 {
@@ -170,7 +170,7 @@ export class IfStatement extends LogicItem {
 
     addItemInConsequent(options?: Partial<LogicItem> | LogicItem) {
         const node = this._addItemInConsequent(options as any);
-        const index = this.consequent.length;
+        const index = this.consequent.indexOf(node);
         node.create({
             index,
             parentNode: this,
@@ -200,7 +200,7 @@ export class IfStatement extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'alternate' };
         let logicItem: LogicItem;
         if (options instanceof LogicItem) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             logicItem = options;
             Object.assign(logicItem, relationOptions);
         } else {
@@ -274,7 +274,7 @@ export class IfStatement extends LogicItem {
 
     addItemInAlternate(options?: Partial<LogicItem> | LogicItem) {
         const node = this._addItemInAlternate(options as any);
-        const index = this.alternate.length;
+        const index = this.alternate.indexOf(node);
         node.create({
             index,
             parentNode: this,

package/src/concepts/InterfaceParam__.ts

@@ -2,6 +2,7 @@ import { dataTypesMap } from './basics/types';
 import { TranslatorState, shiftState, withSourceMap, indent, createCompilerState } from '../translator';
 import Entity from './Entity__';
 import Structure from './Structure__';
+import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -52,7 +53,7 @@ export class InterfaceParam extends BaseNode {
      * in
      */
     @property()
-    in: 'query' | 'body' | 'header' | 'cookie' = undefined;
+    in: 'query' | 'path' | 'body' | 'header' | 'cookie' = undefined;
 
     /**
      * 是否必填
@@ -137,7 +138,7 @@ export class InterfaceParam extends BaseNode {
     /**
      * 设置in
      */
-    setIn(inWhich: 'query' | 'body' | 'header' | 'cookie') {
+    setIn(inWhich: 'query' | 'path' | 'body' | 'header' | 'cookie') {
         const object = {
             in: inWhich,
         };
@@ -243,7 +244,7 @@ export class InterfaceParam 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);
         }
@@ -263,34 +264,63 @@ export class InterfaceParam extends BaseNode {
     }
 
     @withSourceMap()
-    toEmbeddedTS(state?: TranslatorState): string {
-        let code = this.name;
+    toEmbeddedTS(state?: TranslatorState, isOptionalParameter?: boolean): string {
+        let code = this.tsName;
+        if (isOptionalParameter) {
+            code += '?';
+        }
         if (this.typeAnnotation) {
             code += ': ';
             code += this.typeAnnotation.toEmbeddedTS(shiftState(state, code));
         }
+        // toTS暂时不需要默认值
+        // if (this.defaultValue) {
+        //     code += ` = ${this.defaultValue}`;
+        // }
         return code;
     }
 
+    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;
-        const moduleNames = typeNamespace.split('.');
-        let completionChildren;
-        if (typeKind === 'reference') {
-            let type: 'entities' | 'structures';
-            if (typeNamespace.endsWith('entities')) {
-                type = 'entities';
-            } else if (typeNamespace.endsWith('structures')) {
-                // 数据结构比较复杂，会有
-                type = 'structures';
+        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;
             }
-            const data = this.app.dependencies.find((item) => item.name === moduleNames[2]);
-            const properties = (data[type] as Array<Entity | Structure>).find((item) => item.name === typeName)?.properties;
-            completionChildren = properties;
-        } else {
-            completionChildren = undefined;
+            return completionChildren;
+        } catch (err) {
+            console.log(err);
         }
-        return completionChildren;
     }
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！