@lcap/nasl 1.0.0-alpha.9 → 1.0.0

package/src/concepts/BindEvent__.ts

@@ -165,7 +165,7 @@ export class BindEvent extends BaseNode {
         const relationOptions = { parentNode: this, parentKey: 'arguments' };
         let argument: Argument;
         if (options instanceof Argument) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             argument = options;
             Object.assign(argument, relationOptions);
         } else {
@@ -239,7 +239,7 @@ export class BindEvent extends BaseNode {
 
     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,
@@ -289,7 +289,10 @@ export class BindEvent extends BaseNode {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
-
+    // 用于logic回填
+    get calleewholeKey(): string {
+        return this.calleeNamespace + '.' + this.calleeName;
+    }
     get tsCalleeNamespace() {
         if (this.calleeNamespace) {
             let tsCalleeNamespace = this.calleeNamespace;
@@ -303,7 +306,7 @@ export class BindEvent extends BaseNode {
     get calleeKey(): string {
         const tsCalleeNamespace = this.tsCalleeNamespace;
         if (!tsCalleeNamespace) {
-            return `logics.${this.calleeName}`;
+            return `${this.calleeName}`;
         }
         // elements单独处理相对路径，和后缀的问题
         if (tsCalleeNamespace.startsWith('elements') && tsCalleeNamespace.endsWith('logics')) {
@@ -326,17 +329,24 @@ export class BindEvent extends BaseNode {
         return `${randerNameSpace}.${this.calleeName}`;
     }
     // 绑定事件转驼峰
-    toHump = (name: string) => name ? name.replace(/\-(\w)/g, (all, letter) => letter.toUpperCase()) : '';
+    toHump = (name: string) => (name ? name.replace(/\-(\w)/g, (all, letter) => letter.toUpperCase()) : '');
 
     @withSourceMap()
-    toEmbeddedTS(state?: TranslatorState): string {
-        let code = `${this.toHump(this.name) || '__IDENTIFIER__'}: (event) => [\n`;
-        code += indent(state.tabSize + 1);
-        code += `() => {${this.calleeKey}()}`;
-        code += '\n';
-        code += indent(state.tabSize);
-        code += '],\n';
-        return code;
+    toEmbeddedTS(state?: TranslatorState, isPageCycle?: Boolean): string {
+        // 如果有绑定的事件名
+        if (this.calleeName) {
+            if (isPageCycle) {
+                return `${this.calleeKey}();`;
+            }
+            let code = `${this.toHump(this.name) || '__IDENTIFIER__'}: (event) => [\n`;
+            code += indent(state.tabSize + 1);
+            code += `() => {${this.calleeKey}()}`;
+            code += '\n';
+            code += indent(state.tabSize);
+            code += '],\n';
+            return code;
+        }
+        return '';
     }
 
     // @withSourceMap()
@@ -369,19 +379,53 @@ export class BindEvent extends BaseNode {
      * 转换成 Vue 的模板格式
      */
     toVue(options?: ElementToVueOptions) {
-        const calleeName = this.calleeName;
+        const calleeNamespace = this.calleeNamespace;
+        let isComponentLogic = false;
+        let componentName = '';
+        if (calleeNamespace) {
+            const namespaceArr = calleeNamespace.split('.');
+            const start = namespaceArr.shift();
+            if (start === 'elements' && namespaceArr.length === 2 && namespaceArr[1] === 'logics') {
+                isComponentLogic = true;
+                componentName = namespaceArr[0];
+            }
+        }
+        let callee = '';
+        if (isComponentLogic)
+            callee = `$refs.${componentName}.${this.calleeName}`;
+        else if (calleeNamespace?.startsWith('nasl.'))
+            callee = `$global.${this.calleeName}`;
+        else
+            callee = this.calleeName;
         let code = '';
-        if (calleeName) {
-            code += `@${this.name}="${calleeName}`;
-            if (Array.isArray(this.arguments)) {
-                code += '(';
-                this.arguments.forEach((arg, index) => {
-                    code += arg.toJS();
-                    if (index !== this.arguments.length - 1)
-                        code += ', ';
+        if (callee) {
+            code += `@${this.name}="${callee}`;
+            const argsList: string[] = [];
+            const argsMap: any = {};
+            if (Array.isArray(this.arguments) && this.arguments.length) {
+                this.arguments.forEach((arg) => {
+                    const argStr = arg.toJS();
+                    argsList.push(argStr);
+                    argsMap[argStr] = true;
                 });
-                code += ')';
             }
+            const additionalArgs: string[] = ['$event'];
+            if (Array.isArray(options?.scopeList) && options?.scopeList.length) {
+                additionalArgs.push(...options.scopeList);
+            }
+            additionalArgs.forEach((arg) => {
+                if (!argsMap[arg]) {
+                    argsList.push(arg);
+                    argsMap[arg] = true;
+                }
+            });
+            code += '(';
+            argsList.forEach((arg, index) => {
+                code += arg;
+                if (index !== argsList.length - 1)
+                    code += ', ';
+            });
+            code += ')';
             code += `"`;
         }
         return code;

package/src/concepts/BooleanLiteral__.ts

@@ -68,6 +68,14 @@ export class BooleanLiteral extends LogicItem {
         return this.value;
     }
 
+    @withSourceMap()
+    toEmbeddedTS(state?: TranslatorState) {
+        return this.value;
+    }
+    getValue() {
+        return this.value;
+    }
+
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/CallFunction__.ts

@@ -1,6 +1,7 @@
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import Function from './Function__';
 import { ElementToVueOptions } from './ViewElement__';
+import Identifier from './Identifier__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -31,7 +32,7 @@ export class CallFunction extends LogicItem {
      * 调用函数标题
      */
     @property()
-    label: string = '调用逻辑';
+    label: string = '内置函数';
 
     /**
      * calleeNamespace
@@ -104,7 +105,7 @@ export class CallFunction extends LogicItem {
         const relationOptions = { parentNode: this, parentKey: 'typeArguments' };
         let typeAnnotation: TypeAnnotation;
         if (options instanceof TypeAnnotation) {
-            options.delete(); // 同一实例不支持多处存在
+            options.ensureDelete(); // 同一实例不支持多处存在
             typeAnnotation = options;
             Object.assign(typeAnnotation, relationOptions);
         } else {
@@ -178,7 +179,7 @@ export class CallFunction extends LogicItem {
 
     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,
@@ -211,7 +212,7 @@ export class CallFunction 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 {
@@ -285,7 +286,7 @@ export class CallFunction 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,
@@ -374,9 +375,9 @@ export class CallFunction extends LogicItem {
     toVue(options?: ElementToVueOptions): string {
         let code = `$utils['${this.calleeName}']`;
         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 += ')';
@@ -386,9 +387,9 @@ export class CallFunction extends LogicItem {
     toUI(): string {
         let code = this.calleeName;
         code += '(';
-        this.arguments.forEach((arg, index) => {
-            code += arg.toUI();
-            if (index !== this.arguments.length - 1)
+        this.arguments?.forEach((arg, index) => {
+            code += arg?.toUI();
+            if (index !== this.arguments?.length - 1)
                 code += ', ';
         });
         code += ')';
@@ -398,11 +399,19 @@ export class CallFunction extends LogicItem {
     toJS(state?: TranslatorState): string {
         let code = `this.$utils['${this.calleeName}']`;
         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 += ', ';
         });
+        if (this.typeArguments && this.typeArguments.length) {
+            code += ', ';
+            this.typeArguments?.forEach((arg, index) => {
+                code += arg?.toJS(shiftState(state, code));
+                if (index !== this.arguments?.length - 1)
+                    code += ', ';
+            });
+        }
         code += ')';
         return code;
     }
@@ -412,10 +421,10 @@ export class CallFunction extends LogicItem {
     }
 
     _setCallee(func: Function) {
-        this.calleeNamespace = func.getNamespace();
-        this.calleeName = func.name;
+        this.calleeNamespace = func?.getNamespace();
+        this.calleeName = func?.name;
         this.arguments = [];
-        func.params.forEach((param) => {
+        func?.params?.forEach((param) => {
             this._addArgument(undefined);
         });
     }
@@ -428,6 +437,9 @@ export class CallFunction extends LogicItem {
             const argument = Argument.from({
                 keyword: param.name,
             }, this);
+            if (param.defaultExpression instanceof Identifier) {
+                argument.expression = BaseNode.from(param.defaultExpression, argument, 'expression') as Identifier;
+            }
             Object.assign(argument, relationOptions);
             return argument;
         });
@@ -466,14 +478,19 @@ export class CallFunction extends LogicItem {
             code += ')';
             // 如果有内容
             const typeAnnotation = this.typeArguments[0];
-            if (typeAnnotation.typeNamespace && typeAnnotation.typeName) {
-                code += `<${typeAnnotation.typeNamespace}.${typeAnnotation.typeName}>()`;
-            }
+            code += `<`;
+            code += `${typeAnnotation.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }))}>()`;
             code += '\n';
         } else {
             code = this.calleeKey;
+            if (Array.isArray(this.typeArguments) && this.typeArguments.length) {
+                // 如果有内容
+                const typeAnnotation = this.typeArguments[0];
+                code += `<`;
+                code += `${typeAnnotation.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }))}>`;
+            }
             code += '(';
-            this.arguments.forEach((arg, index) => {
+            Array.isArray(this.arguments) && this.arguments.forEach((arg, index) => {
                 code += arg.toEmbeddedTS(shiftState(state, code, { tabSize: 0 }));
                 if (index !== this.arguments.length - 1)
                     code += ', ';

package/src/concepts/CallInterface__.ts

@@ -1,6 +1,8 @@
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import Interface from './Interface__';
+import NullLiteral from './NullLiteral__';
 import { ElementToVueOptions } from './ViewElement__';
+import { getConceptConstructor } from '../decorators';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -97,7 +99,7 @@ export class CallInterface 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 {
@@ -171,7 +173,7 @@ export class CallInterface 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,
@@ -221,12 +223,23 @@ export class CallInterface extends LogicItem {
     // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
     // 自动生成的代码已结束。下面可以手动编写。
     //================================================================================
+
+    get tsCalleeNamespace() {
+        if (this.calleeNamespace) {
+            let tsCalleeNamespace = this.calleeNamespace;
+            tsCalleeNamespace = tsCalleeNamespace.replace(/\.[0-9]/g, (m) => m.replace('.', '.$'));
+            tsCalleeNamespace = tsCalleeNamespace.replace(/-/g, '_');
+            return tsCalleeNamespace;
+        }
+        return '';
+    }
+
     toVue(options?: ElementToVueOptions): string {
         let code = this.calleeName;
         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 += ')';
@@ -236,9 +249,9 @@ export class CallInterface extends LogicItem {
     toUI(state?: TranslatorState): string {
         let code = this.calleeName;
         code += '(';
-        this.arguments.forEach((arg, index) => {
-            code += arg.toUI();
-            if (index !== this.arguments.length - 1)
+        this.arguments?.forEach((arg, index) => {
+            code += arg?.toUI();
+            if (index !== this.arguments?.length - 1)
                 code += ', ';
         });
         code += ')';
@@ -246,32 +259,208 @@ export class CallInterface extends LogicItem {
     }
 
     toJS(state?: TranslatorState): string {
-        let code = this.calleeName;
-        code += '(';
-        this.arguments.forEach((arg, index) => {
-            code += arg.toJS(shiftState(state, code));
-            if (index !== this.arguments.length - 1)
-                code += ', ';
-        });
-        code += ')';
+        const _arr = this.calleewholeKey.split('.');
+        const _name = _arr[1];
+        const _interfaceName = _arr[3];
+        const _module = this.app.interfaceDependencies.find((item) => item.name === _name);
+        const _interface = _module.interfaces.find((item) => item.name === _interfaceName);
+        if (!_interface) {
+            throw new Error(`${_name}下的${_interfaceName}接口未找到`);
+        }
+        let isSimpleBody = false; // 兼容body只有基本类型的
+        const _params = _interface.params;
+        const _queries = _params.filter((item) => item.in === 'query').map((item) => item.name);
+        const _headers = _params.filter((item) => item.in === 'header').map((item) => item.name);
+        const _body = _params
+            .filter((item) => item.in === 'body')
+            .map((item) => {
+                if (item.typeAnnotation.typeKind === 'primitive') {
+                    isSimpleBody = true;
+                }
+                return item.name;
+            });
+        const _paths = _params.filter((item) => item.in === 'path').map((item) => item.name);
+
+        let code = `await this.$services['_custom']['${this.calleeNamespace}.${this.calleeName}']`;
+        code += `({
+            config: {
+                download: false,
+            },
+            query: {`;
+        this.arguments?.filter((arg) => _queries.includes(arg?.keyword))
+            .forEach((arg, index) => {
+                code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
+                if (index !== this.arguments?.length - 1)
+                    code += ', ';
+            });
+        code += `},
+            path: {`;
+        this.arguments?.filter((arg) => _paths.includes(arg?.keyword))
+            .forEach((arg, index) => {
+                code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
+                if (index !== this.arguments?.length - 1)
+                    code += ', ';
+            });
+        code += `},
+            headers: {`;
+        this.arguments?.filter((arg) => _headers.includes(arg?.keyword))
+            .forEach((arg, index) => {
+                code += `\n'${arg?.keyword}': ${arg?.toJS(shiftState(state, code))}`;
+                if (index !== this.arguments?.length - 1)
+                    code += ', ';
+            });
+        code += `},\n`;
+        if (isSimpleBody) {
+            code += `body: `;
+            this.arguments?.forEach((arg, index) => {
+                code += ` ${arg?.toJS(shiftState(state, code))}`;
+            });
+        } else {
+            code += `body: {`;
+            this.arguments?.filter((arg) => _body.includes(arg?.keyword))
+                .forEach((arg, index) => {
+                    code += ` ...${arg?.toJS(shiftState(state, code))}`;
+                    if (index !== this.arguments?.length - 1)
+                        code += ', ';
+                });
+            code += '}';
+        }
+
+        code += '\n})';
         return code;
     }
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
-        let code = this.calleeKey;
-        code += '({';
-        this.arguments.forEach((arg, index) => {
-            code += `${arg.keyword}:` + arg.toEmbeddedTS(shiftState(state, code));
-            if (index !== this.arguments.length - 1)
-                code += ', ';
-        });
-        code += '});\n';
+        let code = this.tsCalleeKey;
+        const _keys = this.calleeDefaultKey.split('.');
+        const _module = this.app.interfaceDependencies.find((item) => item.name === _keys[1]);
+        let params: string[] = [];
+        const _interface = _module?.interfaces?.find((item) => item.name === _keys[3]);
+        if (_interface) {
+            params = _interface.params.filter((item) => item.required).map((item) => item.name) || [];
+            // const _bodyParams = _interface.params.find((item) => item.name === 'Body');
+            // if (_bodyParams) {
+            //     const _typeKey = _bodyParams.typeAnnotation.typeKey;
+            //     const _list = _typeKey.split('.');
+            //     const _structure = _module.structures.find((item) => item.name === _list[3]);
+            //     const isBodyRequired = _structure.properties.some((item) => item.required === true);
+            //     if (isBodyRequired) {
+            //         params.push('Body');
+            //     }
+            // }
+        }
+        code += '(';
+        if (this.arguments?.length) {
+            code += '{';
+            this.arguments?.forEach((arg, index) => {
+                code += arg?.toEmbeddedTS(shiftState(state, code), params.includes(arg?.keyword), true);
+                if (index !== this.arguments?.length - 1)
+                    code += ', ';
+            });
+            code += '}';
+        }
 
+        code += ');\n';
         return code;
     }
 
     get calleeKey(): string {
+        const tsCalleeNamespace = this.tsCalleeNamespace;
+        const calleeName = this.calleeName;
+        return calleeName ? `${tsCalleeNamespace}.${calleeName}` : '__IDENTIFIER__';
+    }
+    // 用于logic回填
+    get calleewholeKey(): string {
+        return this.calleeNamespace + '.' + this.calleeName;
+    }
+    get tsCalleeName(): string {
+        const excludeds = [
+            'abstract',
+            'arguments',
+            'await',
+            'boolean',
+            'break',
+            'byte',
+            'case',
+            'catch',
+            'char',
+            'class',
+            'const',
+            'continue',
+            'debugger',
+            'default',
+            'delete',
+            'do',
+            'double',
+            'else',
+            'enum',
+            'eval',
+            'export',
+            'extends',
+            'false',
+            'final',
+            'finally',
+            'float',
+            'for',
+            'function',
+            'goto',
+            'if',
+            'implements',
+            'import',
+            'in',
+            'instanceof',
+            'int',
+            'interface',
+            'let',
+            'long',
+            'native',
+            'new',
+            'null',
+            'package',
+            'private',
+            'protected',
+            'public',
+            'return',
+            'short',
+            'static',
+            'super',
+            'switch',
+            'synchronized',
+            'this',
+            'throw',
+            'throws',
+            'transient',
+            'true',
+            'try',
+            'typeof',
+            'var',
+            'void',
+            'volatile',
+            'while',
+            'with',
+            'yield,as',
+            'any',
+            'number',
+            'string',
+            'get',
+            'type',
+            'typeof',
+            'instanceof',
+            'require',
+        ];
+        if (excludeds.includes(this.calleeName)) {
+            return '_' + this.calleeName;
+        }
+        return this.calleeName;
+    }
+
+    get tsCalleeKey(): string {
+        const tsCalleeNamespace = this.tsCalleeNamespace;
+        const calleeName = this.tsCalleeName;
+        return calleeName ? `${tsCalleeNamespace}.${calleeName}` : '__IDENTIFIER__';
+    }
+    get calleeDefaultKey(): string {
         return `${this.calleeNamespace}.${this.calleeName}`;
     }
     _setCallee(_interface: Interface) {
@@ -288,9 +477,30 @@ export class CallInterface extends LogicItem {
         const calleeName = _interface.name;
         const params = _interface.params.map((param) => {
             const relationOptions = { parentNode: this, parentKey: 'arguments' };
-            const argument = Argument.from({
+            let expression;
+            if (param.defaultValue && param.typeAnnotation.typeKind === 'primitive') {
+                const conceptMap: { [name: string]: string } = {
+                    String: 'StringLiteral',
+                    Boolean: 'BooleanLiteral',
+                    Integer: 'NumericLiteral',
+                    Double: 'NumericLiteral',
+                    Long: 'NumericLiteral',
+                };
+                const typeName = param.typeAnnotation.typeName;
+                const concept: string = conceptMap[typeName] || 'StringLiteral';
+                const Ctor = getConceptConstructor(concept);
+                expression = new Ctor({
+                    concept,
+                    value: param.defaultValue,
+                    typeAnnotation: param.typeAnnotation,
+                });
+            } else if (!param.required) {
+                expression = new NullLiteral();
+            }
+            const argument = new Argument({
                 keyword: param.name,
-            }, this);
+                expression,
+            });
             Object.assign(argument, relationOptions);
             return argument;
         });