@lcap/nasl 2.20.0-beta.2 → 2.20.0

package/src/concepts/App__.ts

@@ -9,7 +9,6 @@ import { getNaslNodeByNodeCallee, getNodeByNodeCallee } from '../automate/engine
 import ConfigProperty from './ConfigProperty__';
 import TypeAnnotation from './TypeAnnotation__';
 import View from './View__';
-// import CallLogic from './CallLogic__';
 interface MessageData {
     logicName: string
     param?: string
@@ -18,6 +17,8 @@ interface MessageData {
     type: number
     resultName?:string,
 }
+// import CallLogic from './CallLogic__';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -2224,8 +2225,13 @@ export class App extends BaseNode {
                 return null;
             }
             const nameItem = nameArr[index];
-            const isKeyword = index % 2 === mod;
-            if (!isKeyword && Array.isArray(node)) {
+            // const isKeyword = index % 2 === mod;
+            // if (!isKeyword && Array.isArray(node)) {
+            //     node = node.find(({ name }) => name === nameItem);
+            // } else {
+            //     node = node[nameItem];
+            // }
+            if (Array.isArray(node)) {
                 node = node.find(({ name }) => name === nameItem);
             } else {
                 node = node[nameItem];
@@ -2460,7 +2466,7 @@ export class App extends BaseNode {
                         interfaceName: item.name,
                         param: param.name,
                         type: 1,
-                        message: `参数“${param.name}”已被删除，请确定请求类型无误后点击“重新导出”为接口`,
+                        message: `参数“${param.name}”已被删除，请确定请求类型无误后点击“重新导出”`,
                     });
                 }
                 const interfaceTypeAnnotation = param.typeAnnotation.toJSON() as TypeAnnotation;
@@ -2479,7 +2485,7 @@ export class App extends BaseNode {
                         interfaceName: item.name,
                         param: param.name,
                         type: 2,
-                        message: `参数“${param.name}”数据类型变更，请确定请求类型无误后点击“重新导出”为接口`,
+                        message: `参数“${param.name}”数据类型变更，请确定请求类型无误后点击“重新导出”`,
                     });
                 }
             });
@@ -2530,7 +2536,7 @@ export class App extends BaseNode {
                                 type: 7,
                                 message: `输出参数“${logicReturns[0].name}”没有数据类型，无法导出`,
                             });
-                        } else if (JSON.stringify(logicReturns[0]?.__TypeAnnotation?.toJSON()) !== JSON.stringify(interfaceReturns[0]?.typeAnnotation?.toJSON())) {
+                        } else if (!logicReturns[0]?.__TypeAnnotation.isSame(interfaceReturns[0]?.typeAnnotation)) {
                             errorList.push({
                                 logicName: logic.name,
                                 interfaceName: item.name,
@@ -2554,7 +2560,7 @@ export class App extends BaseNode {
                 errorList.push({
                     logicName: logic.name,
                     param: i,
-                    message: `新增参数“${i}”，请确定请求类型无误后点击“重新导出”为接口`,
+                    message: `新增参数“${i}”，请确定请求类型无误后点击“重新导出”`,
                     type: 3,
                 });
             }
@@ -2595,6 +2601,29 @@ export class App extends BaseNode {
         return Array.from(new Set(resultLogics));
     }
 
+    genAllCustomComponents() {
+        const frontends = this.frontends;
+        const compMap: {
+            pc: Array<any>
+            h5: Array<any>
+        } = {
+            pc: [],
+            h5: [],
+        };
+        const existingSet = new Set();
+        frontends.forEach((frontend) => {
+            if (frontend.componentDependencies) {
+                frontend.componentDependencies.forEach((dep) => {
+                    const { name } = dep;
+                    if (!existingSet.has(name)) {
+                        compMap[frontend.type].push(dep);
+                    }
+                });
+            }
+        });
+        return compMap;
+    }
+
     //================================================================================
     // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
     // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/Assignee__.ts

@@ -664,10 +664,11 @@ export class Assignee extends LogicItem {
                 code += `${logic.toEmbeddedTSInProcess(shiftState(state, code, { tabSize: (state?.tabSize || 0) }), prevCode, false, true)}\n`;
             });
         }
-        code += `${tab}return nasl.util.concatString(`;
-        this.dynamicUsers.forEach((u) => {
+        code += `${tab}nasl.util.concatString(`;
+        this.dynamicUsers.forEach((u, index) => {
             code += u.toEmbeddedTS(shiftState(state, code));
-            code += ', ';
+            if (index + 1 < this.dynamicUsers.length)
+                code += ', ';
         });
         code += ')\n';
         // code += `${this.dynamicUsers.map(u => u.toEmbeddedTS(shiftState(state, code))).join(',\n')})\n`;

package/src/concepts/BatchAssignment__.ts

@@ -634,7 +634,7 @@ export class BatchAssignment extends LogicItem {
         let count = 0;
         const typeAnnotationEnd = () => {
             const l = this.left.members.every((item) => item.__isCorrectTypeAnnotation);
-            const r = this.rights.every((right) => right.members.every((item) => item.__isCorrectTypeAnnotation));
+            const r = this.rights.every((right) => right.members.every((item) => item.__isCorrectTypeAnnotation) && right.expression.__isCorrectTypeAnnotation);
             count++;
             if (l && r) {
                 autoConnection();
@@ -780,7 +780,7 @@ export class BatchAssignment extends LogicItem {
         // 修改连线
         if (selectMember.parentKey === 'left') {
             members.forEach((item: any, index: any) => {
-                if (keepMembers.has(item.completeName)) {
+                if (keepMembers?.has(item.completeName)) {
                     const lines = this.findlines(item, selectMember);
                     lines.forEach((line) => {
                         const newLine = Object.assign({}, line, { leftIndex: [line.leftIndex[0], index] });
@@ -796,7 +796,7 @@ export class BatchAssignment extends LogicItem {
             const splitIndex = this.rights.findIndex((right) => selectMember === right);
             newLines = this.assignmentLines.filter(({ rightIndex }) => rightIndex[0] !== splitIndex);
             members.forEach((item, index) => {
-                if (keepMembers.has(item.completeName)) {
+                if (keepMembers?.has(item.completeName)) {
                     const lines = this.findlines(item, selectMember);
                     lines.forEach((line) => {
                         const newLine = Object.assign({}, line, { rightIndex: [line.rightIndex[0], index] });

package/src/concepts/BindAttribute__.ts

@@ -1,6 +1,8 @@
 import { TranslatorState, shiftState, withSourceMap } from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
 import Namespace from './Namespace__';
+import MemberExpression from './MemberExpression__';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -24,6 +26,7 @@ import Module from './Module__';
 import App from './App__';
 import Frontend from './Frontend__';
 import Process from './Process__';
+import Identifier from './Identifier__';
 
 /**
  * 元素绑定属性
@@ -394,6 +397,8 @@ export class BindAttribute extends BaseNode {
         return node;
     }
 
+
+
     /**
     * 插入逻辑项
     * @internal
@@ -426,6 +431,8 @@ export class BindAttribute extends BaseNode {
         return logicItem;
     }
 
+
+
     /**
      * 插入逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -448,6 +455,8 @@ export class BindAttribute extends BaseNode {
         return node;
     }
 
+
+
     /**
      * 添加逻辑项
      * @internal
@@ -467,6 +476,8 @@ export class BindAttribute extends BaseNode {
         return this._insertItemInPlaygroundAt(options as any, index);
     }
 
+
+
     /**
      * 添加逻辑项
      * @param logicItemOptions 逻辑项参数
@@ -490,6 +501,9 @@ export class BindAttribute extends BaseNode {
         return node;
     }
 
+
+
+
     /**
     * 删除逻辑项
     * @param name 逻辑项名称
@@ -515,6 +529,8 @@ export class BindAttribute extends BaseNode {
         return expression.delete();
     }
 
+
+
     /**
     * 删除跳转页面
     * @param name 跳转页面名称
@@ -540,6 +556,8 @@ export class BindAttribute extends BaseNode {
         return destination.delete();
     }
 
+
+
     /**
     * 删除外部链接
     * @param name 外部链接名称
@@ -565,6 +583,8 @@ export class BindAttribute extends BaseNode {
         return externalDestination.delete();
     }
 
+
+
     /**
     * 删除验证规则
     * @param name 验证规则名称
@@ -590,6 +610,8 @@ export class BindAttribute extends BaseNode {
         return validationRule.delete();
     }
 
+
+
     /**
     * 删除经办人
     * @param name 经办人名称
@@ -615,6 +637,8 @@ export class BindAttribute extends BaseNode {
         return assignee.delete();
     }
 
+
+
     /**
      * 删除逻辑项
      * @param logicItem 已有的逻辑项实例
@@ -622,7 +646,7 @@ export class BindAttribute extends BaseNode {
     removeItemInPlayground(logicItem: LogicItem): void;
 
     removeItemInPlayground(options: LogicItem) {
-        const logicItem: LogicItem = options;
+        let logicItem: LogicItem = options;
         return logicItem.delete();
     }
 
@@ -680,59 +704,296 @@ export class BindAttribute extends BaseNode {
             throw new Error('无法获取命名空间，请设置 parentNode！');
     }
 
+    // 属性上绑定的表达式
+    get bindExpressions() {
+        const expressions: any[] = [];
+        // 跳转需要特殊处理
+        if (['externalDestination', 'destination'].includes(this.name)) {
+            const { link, arguments: params, anchor } = (this as any)[this.name] || {};
+            // externalDestination有跳转链接表达式
+            if (link) {
+                expressions.push(link);
+            }
+            // destination有参数
+            if (Array.isArray(params)) {
+                expressions.push(...params);
+            }
+            // 锚点表达式
+            if (anchor?.expression) {
+                expressions.push(anchor?.expression);
+            }
+        } else if (this.name === 'rules') {
+            if (Array.isArray(this.rules)) {
+                this.rules.forEach((rule) => {
+                    const { arguments: args, errorMessage } = rule || {};
+                    if (Array.isArray(args)) {
+                        expressions.push(...args);
+                    }
+                    expressions.push(errorMessage);
+                });
+            }
+        } else if (this.expression) {
+            expressions.push(this.expression);
+        }
+        return expressions;
+    }
+
+    // 是否需要用标识符替换
+    get needReplaceWithIdentifier() {
+        let bindExpression = false;
+        const expressions: any[] = this.bindExpressions;
+        if (Array.isArray(expressions) && expressions.length) {
+            expressions.forEach((expression) => {
+                let rootMemberExpression: any;
+                let tempNode = expression;
+                while (tempNode?.concept === 'MemberExpression') {
+                    rootMemberExpression = tempNode;
+                    tempNode = (tempNode as MemberExpression)?.object;
+                }
+                // 变量和变量的成员表达式不进行替换
+                if (
+                    !(
+                        ['Identifier', 'StringLiteral'].includes(expression?.concept)
+                        || (rootMemberExpression && rootMemberExpression.object?.concept === 'Identifier')
+                    )
+                    && (this.type === 'dynamic' || (this.name === 'rules' && this.rules))
+                ) {
+                    bindExpression = true;
+                }
+            });
+        }
+        return bindExpression;
+    }
+
+    // 获取表达式在页面中的名字
+    get expressionNameInView() {
+        const nameList: string[] = [];
+        let node: BaseNode = this;
+        while (node) {
+            nameList.unshift(node.name);
+            if (node.concept === 'ViewElement') {
+                node = null;
+            } else {
+                nameList.unshift(node.parentKey);
+                node = node.parentNode;
+            }
+        }
+        return nameList.join('_').replace(/-/g, '_');
+    }
+
+    // 获取表达式生成器名称
+    get expressionBuilderName() {
+        let expressionInViewName = this.expressionNameInView;
+        expressionInViewName = expressionInViewName.charAt(0).toUpperCase() + expressionInViewName.slice(1);
+        return `gen${expressionInViewName}`;
+    }
+
+    // 获取参数列表
+    getArgsList() {
+        const viewElement = this?.getAncestor('ViewElement');
+        const argsList = [];
+        let parent = viewElement?.parentNode;
+        let index = 0;
+        while (parent && parent.concept !== 'View') {
+            if ((parent as ViewElement).slotScope) {
+                argsList.unshift(index === 0 ? 'current' : 'current' + index);
+                index++;
+            }
+            parent = parent.parentNode;
+        }
+        return argsList;
+    }
+
+    // 表达式中需要被监听的变量
+    get watchedVariableMap() {
+        const map: any = {};
+        // 页面中表达式用到的变量需要监听，从而重新执行match表达式
+        utils.traverse((current: any) => {
+            const { node } = current || {};
+            const { concept } = node || {};
+            if (['Identifier'].includes(concept)) {
+                let expressionNode = node;
+                let memberExpressionNode = node?.parentNode;
+                while (memberExpressionNode?.concept === 'MemberExpression') {
+                    expressionNode = memberExpressionNode;
+                    const { concept: objConcept } = memberExpressionNode.object || {};
+                    if (!['MemberExpression', 'Identifier'].includes(objConcept)) {
+                        memberExpressionNode = null;
+                        expressionNode = null;
+                    } else {
+                        memberExpressionNode = memberExpressionNode.object;
+                    }
+                }
+                if (expressionNode) {
+                    map[expressionNode.toJS()] = true;
+                }
+            }
+        }, {
+            node: this,
+        }, {
+            mode: 'anyObject',
+            excludedKeySet: new Set([
+                // 排除playground里的表达式
+                'playground',
+                'parentNode',
+                'sourceMap',
+                'storageJSON',
+                'tsErrorDetail',
+                'NaslAnnotatedJSON',
+                'calledFrom',
+                '_events',
+                '_collectingList',
+                '_historyList',
+            ]),
+        });
+        return map;
+    }
+
+    getInViewMethod(state?: TranslatorState) {
+        const argsList = this.getArgsList() || [];
+        const hasArgs = !!argsList.length;
+        let argStr = '';
+
+        // 容错代码
+        let ftCode = '';
+        if (hasArgs) {
+            argsList.forEach((arg) => {
+                ftCode += `if (!this.${this.expressionNameInView}${argStr}) {
+                    this.${this.expressionNameInView}${argStr} = {};
+                }\n`;
+                argStr += `[${arg}.hasOwnProperty('__nodeKey') ? ${arg}.__nodeKey : ${arg}.index]`;
+            });
+        }
+        ftCode += `if (!this.${this.expressionNameInView}${argStr}) {
+            this.${this.expressionNameInView}${argStr} = {};
+        }`;
+
+        // 新的参数
+        const paramList = Object.keys(this.watchedVariableMap);
+        let newParams = `const newParams = [];`;
+        if (Array.isArray(paramList) && paramList.length) {
+            paramList.forEach((param) => {
+                newParams += `newParams.push(${param});\n`;
+            });
+        }
+
+        // 表达式主体
+        let expressionStr = '';
+        if (this.type === 'dynamic') {
+            if (['externalDestination', 'destination'].includes(this.name)) {
+                expressionStr = (this as any)[this.name].toInViewMethod() || '';
+            } else {
+                expressionStr = this.expression?.toJS() || '';
+            }
+        }
+        if (this.name === 'rules' && this.rules) {
+            const ruleStrs = this.rules.map((rule) => rule.toInViewMethod());
+            expressionStr = `[${ruleStrs.join(' , ')}]`;
+        }
+        // 变量重新设置，为了触发重新调用
+        let setVarStr = `this.${this.expressionNameInView}${argStr} = {
+            ...(this.${this.expressionNameInView}${argStr} || {}),
+            value: value,
+        };`;
+        if (Array.isArray(argsList) && argsList.length) {
+            setVarStr += `this.${this.expressionNameInView} = {...this.${this.expressionNameInView}};\n`;
+        }
+        const code = `${this.expressionBuilderName} (${argsList.join(', ')}) {
+            // 容错代码
+            ${ftCode}
+            (async () => {
+                // 旧的参数
+                const oldParams = this.${this.expressionNameInView}${argStr}.params;
+                // 新的参数
+                ${newParams}
+                const isLooseEqual = this.$isLooseEqualFn(oldParams, newParams);
+                if (!isLooseEqual) {
+                    this.${this.expressionNameInView}${argStr}.params = newParams;
+                    const value = ${expressionStr};
+                    ${setVarStr}
+                }
+            })();
+            return this.${this.expressionNameInView}${argStr}.value;
+        }`;
+
+        return code;
+    }
+
     /**
      * 转换成 Vue 的模板格式
      */
     toVue(options?: ElementToVueOptions) {
+        let str = '';
         let value = this.value;
-        if (this.type === 'dynamic') {
-            value = this.expression?.toVue(options) || '';
-        } else if (value !== undefined && value !== null && typeof value === 'string') {
-            value = value.replace(/"/g, "'");
+        if (this.type === 'dynamic' || (this.name === 'rules' && this.rules)) {
+            // 需要用标识符替换
+            if (options?.finalCode !== false && this.needReplaceWithIdentifier) {
+                const argsList = this.getArgsList();
+                value = `${this.expressionBuilderName}(${argsList.join(', ')})`;
+            } else if (this.name === 'rules' && this.rules) {
+                const ruleStrs = this.rules.map((rule) => rule.toVue(options));
+                value = `[${ruleStrs.join(' , ')}]`;
+            } else if (['destination', 'externalDestination'].includes(this.name)) {
+                value = (this as any)?.[this.name]?.toVue(options) || '';
+            } else {
+                value = this.expression?.toVue(options) || '';
+            }
+        } else if (this.type === 'string') {
+            if (this.name === 'destination') {
+                if (this.frontend?.basePath) {
+                    value = `${this.frontend?.basePath}${value}`;
+                }
+            }
+            if (this.name === 'href' && value.startsWith('/')) {
+                if (this.frontend?.basePath) {
+                    value = `${this.frontend?.basePath}${value}`;
+                }
+            }
         }
+
         if (value !== undefined && value !== null && typeof value === 'string') {
             value = value.replace(/"/g, "'");
         }
-        if (this.name === 'destination' && this.type === 'dynamic') {
-            return this.destination ? this.destination.toVue(options) : '';
-        } else if (this.name === 'externalDestination' && this.type === 'dynamic') {
-            return this.externalDestination ? this.externalDestination.toVue(options) : '';
-        } else if (this.name === 'rules' && this.rules) {
-            const ruleStrs = this.rules.map((rule) => rule.toVue(options));
-            value = ruleStrs.join(' , ');
-            return value !== undefined && value !== null ? `:${this.name}="[${value}]"` : '';
-        } else {
-            let str = '';
-            let name = this.name;
-            if (value !== undefined && value !== null && value !== '') {
-                if (name === 'download') {
-                    str += 'download="true" ';
-                    name = 'href';
-                }
-                // 文本默认要经过toString转换
-                if (options.finalCode !== false && name === 'text' && !this.sync && this.type === 'dynamic') {
-                    const expTypeAnnotation = (this.expression as any)?.typeAnnotation || this.expression?.__TypeAnnotation;
-                    value = `$utils['ToString'](${value}, '${expTypeAnnotation?.sortedTypeKey}')`;
-                }
-                if (this.type === 'string') {
-                    str += `${name}="${value}"`;
+        let name = this.name;
+        if (value !== undefined && value !== null && value !== '') {
+            if (name === 'download') {
+                str += 'download="true" ';
+                name = 'href';
+            }
+            // 文本默认要经过toString转换
+            if (options?.finalCode !== false && name === 'text' && !this.sync && this.type === 'dynamic') {
+                const expTypeAnnotation = (this.expression as any)?.typeAnnotation || this.expression?.__TypeAnnotation;
+                value = `$utils['ToString'](${value}, '${expTypeAnnotation?.sortedTypeKey}')`;
+            }
+            if (this.type === 'string' && name !== 'rules') {
+                str += `${name}="${value}"`;
+            } else {
+                if (this.sync) {
+                    str += `:${name}.sync="${value}"`;
                 } else {
-                    str += `:${name}${this.sync ? '.sync' : ''}="${value}"`;
+                    if (name === 'destination') {
+                        str += `:destination="${value}"`;
+                    } else if (name === 'externalDestination') {
+                        str += `:link="${value}"`;
+                    } else if (name === 'rules') {
+                        str += `:${name}="${value}"`;
+                    } else {
+                        str += `:${name}="${value}"`;
+                    }
                 }
-            } else if (this.type === 'string' && this.value === '')
-                if (!['destination', 'externalDestination'].includes(this.name)) {
-                    str = `${name}="${this.value}"`;
-                }
-
-            return str;
-        }
+            }
+        } else if (this.type === 'string' && this.value === '')
+            if (!['destination', 'externalDestination'].includes(this.name)) {
+                str = `${name}="${this.value}"`;
+            }
+        return str;
     }
 
     @withSourceMap()
     toEmbeddedTS(state?: TranslatorState): string {
         let code = '() => {';
-        if (this.name === 'destination' && this.type === 'dynamic') {
-            code += this.destination.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+        if (['destination', 'externalDestination'].includes(this.name) && this.type === 'dynamic') {
+            code += (this as any)[this.name].toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
             code += ';\n';
         } else if (this.name === 'rules') {
             this.rules?.forEach((item, index) => {