@lcap/nasl 0.3.10-beta → 0.3.10-beta.5

package/src/types/logic/translator.js

@@ -1,34 +1,44 @@
 import { Vertex } from '..';
 
-function switchCase2If(node, cases, idx = 0) {
+function switchCase2If(cases) {
     const cas = cases.shift();
 
     const result = {
         type: 'IfStatement',
         test: cas.test,
-        level: 'logicNode',
-        id: cas.id,
         consequent: {
             type: 'BlockStatement',
-            body: cas.consequent || [],
+            body: [
+                {
+                    type: 'CallConsoleInfo',
+                    content: 'SWITCHCASE',
+                },
+                ...cas.consequent || [],
+            ]
         },
         alternate: null,
     };
 
     if (cases.length) {
-        result.alternate = switchCase2If(node, cases, idx + 1);
+        result.alternate = switchCase2If(cases);
     } else {
         return {
             type: 'BlockStatement',
-            body: cas.consequent || [],
-            id: cas.id,
+            body: [
+                {
+                    type: 'CallConsoleInfo',
+                    content: 'SWITCHDEFAULT',
+                },
+                ...cas.consequent || [],
+            ]
         };
     }
 
     return result;
 }
 
-export default function (source, preScript) {
+export default function (source) {
+    const isGONGHANG = window.appInfo.env === 'gonghang' || global.appInfoEnv === 'gonghang';
     const definition = typeof source === 'string' ? JSON.parse(source) : source;
 
     function traverse(node, func, parent, index) {
@@ -124,35 +134,6 @@ export default function (source, preScript) {
 }
         }`);
 
-    let output = `
-        const methods = componentOptions.methods = componentOptions.methods || {};
-        const computed = componentOptions.computed = componentOptions.computed || {};
-        const oldDataFunc = componentOptions.data;
-        const data = function () {
-            const oldData = oldDataFunc ? oldDataFunc.call(this) : {};
-            return Object.assign(oldData, {
-                ${paramsData ? paramsData + ',' : ''}
-                ${variablesData}
-            });
-        };
-        componentOptions.data = data;
-        const meta = componentOptions.meta = componentOptions.meta || {};
-        Object.assign(meta, {
-            title: ${JSON.stringify(definition.title)},
-            crumb: ${JSON.stringify(definition.crumb)},
-            first: ${JSON.stringify(definition.first)},
-        });
-
-        ${lifecycles.join('\n\n')}
-
-    `;
-
-    let startLineNumber = output.split('\n').length;
-    if (preScript && typeof preScript === 'string') {
-        startLineNumber += (preScript.split('\n').length - 2);
-    }
-    // console.log(preScript.split('\n').length, output.split('\n').length, startLineNumber);
-    const sourceMap = {};
     const methods = (definition.logics || []).map((logic) => {
         let returnObj = {
             type: 'Identifier',
@@ -162,18 +143,10 @@ export default function (source, preScript) {
         if (logic.returns[0])
             returnObj = logic.returns[0];
 
-        // let lineRecorder = 0;
-        const recorder = {
-            line: startLineNumber,
-        };
-        const _newLine = () => '\n';
-        const newLine = () => {
-            recorder.line += 1;
-            return _newLine();
-        };
+        const newLine = () => '\n';
         const colon = () => ';';
 
-        const _generateNode = (node, logicItemIndex) => {
+        const generateNode = (node, logicItemIndex) => {
             if (!node)
                 return '';
             if (node.type === 'End') {
@@ -218,7 +191,7 @@ export default function (source, preScript) {
                     return `${object}[${property.value}]`;
             }
             if (node.type === 'AssignmentExpression') {
-                return `${generateNode(node.left)} = ${generateNode(node.right)}${colon()}${newLine()}`;
+                return `${newLine()}${generateNode(node.left)} = ${generateNode(node.right)}${colon()}${newLine()}`;
             }
             if (node.type === 'CallExpression') {
                 const args = [];
@@ -267,29 +240,23 @@ export default function (source, preScript) {
                     const interfaceKeyTarget = Vertex.getVertexByRef(key);
                     const arr = key.split('/');
                     const download = interfaceKeyTarget && interfaceKeyTarget.name && interfaceKeyTarget.name.includes('export');
-                    return `await (async () => { console.debug('logic-trace');let result = await this.$services['_custom']['ID_${arr[arr.length - 1]}']({
+                    return `await this.$services['_custom']['ID_${arr[arr.length - 1]}']({
                         config: {
                             download: ${download},
                         },
                         path: {
-                            ${getParams('path').join(',')}
+                            ${getParams('path').join(',\n')}
                         },
                         query: {
-                            ${getParams('query').join(',')}
+                            ${getParams('query').join(',\n')}
                         },
                         headers: {
-                            ${getParams('header').join(',')}
+                            ${getParams('header').join(',\n')}
                         },
                         body: ${getParams('body') || '{}'},
-                    });
-                    console.debug('logic-trace-end');
-                    return result; 
-                    })();
-                    `;
+                    })`;
                 } else {
-                    return `await (async () => {console.debug('logic-trace');let result = await this.${node.calleeCode}(${node.params.map((param) => generateNode(param.callInterParamValue) || 'undefined').join(',')});
-                    console.debug('logic-trace-end');return result; })()
-                    `;
+                    return `await this.${node.calleeCode}(${node.params.map((param) => generateNode(param.callInterParamValue) || 'undefined').join(',')})`;
                 }
             }
 
@@ -328,24 +295,21 @@ export default function (source, preScript) {
                 const interfaceKeyTarget = Vertex.getVertexByRef(node.interfaceKey);
                 const download = interfaceKeyTarget && interfaceKeyTarget.name && interfaceKeyTarget.name.includes('export');
 
-                return `await (async () => {console.debug('logic-trace');let result = await this.$services['_custom']['ID_${arr[arr.length - 1]}']({
+                return `await this.$services['_custom']['ID_${arr[arr.length - 1]}']({
                     config: {
                         download: ${download},
                     },
                     path: {
-                        ${getParams('path').join(',')}
+                        ${getParams('path').join(',\n')}
                     },
                     query: {
-                        ${getParams('query').join(',')}
+                        ${getParams('query').join(',\n')}
                     },
                     headers: {
-                        ${getParams('header').join(',')}
+                        ${getParams('header').join(',\n')}
                     },
                     body: ${getParams('body') || '{}'},
-                });
-                console.debug('logic-trace-end');
-                return result; })()
-                `;
+                })`;
             }
 
             if (node.type === 'CallGraphQL') {
@@ -400,13 +364,13 @@ export default function (source, preScript) {
                         download: ${key.includes('export')},
                     },
                     path: {
-                        ${getParams('path').join(',')}
+                        ${getParams('path').join(',\n')}
                     },
                     query: {
-                        ${getParams('query').join(',')}
+                        ${getParams('query').join(',\n')}
                     },
                     headers: {
-                        ${getParams('header').join(',')}
+                        ${getParams('header').join(',\n')}
                     },
                     body: ${getParams('body') || '{}'},
                 })).Data`;
@@ -417,7 +381,7 @@ export default function (source, preScript) {
                     .filter((param) => param.in === undefined) // 放在body内部的参数
                     .filter((param) => generateNode(param.value) !== '')
                     .map((param) => `${safeKey(param.name)}: ${generateNode(param.value)}`)
-                    .join(',');
+                    .join(',\n');
                 const getObj = (type) =>
                     (node.params || [])
                         .filter((param) => param.in === type)
@@ -500,11 +464,19 @@ export default function (source, preScript) {
             }
 
             if (node.type === 'CallMessageShow') {
-                return `this.$toast.show(${generateNode(node.arguments[0])})${colon()}${newLine()}`;
+                return `${newLine()}this.$toast.show(${generateNode(node.arguments[0])})${colon()}${newLine()}`;
             }
 
             if (node.type === 'CallConsoleLog') {
-                return `console.log(${generateNode(node.arguments[0])})${colon()}${newLine()}`;
+                return `${newLine()}console.log(${generateNode(node.arguments[0])})${colon()}${newLine()}`;
+            }
+
+            if(node.type === 'CallConsoleInfo') {
+                if(isGONGHANG) {
+                    return `console.info(${node.content})${colon()}`;
+                }
+                return '';
+
             }
 
             if (node.type === 'Destination') {
@@ -527,21 +499,33 @@ export default function (source, preScript) {
                 if (Array.isArray(node.consequent)) {
                     node.consequent = {
                         type: 'BlockStatement',
-                        body: node.consequent,
+                        body: [
+                            {
+                                type: 'CallConsoleInfo',
+                                content: 'IF',
+                            },
+                            ...node.consequent,
+                        ]
                     };
                 }
-                if (Array.isArray(node.alternate)) {
+                if (Array.isArray(node.alternate) && node.alternate.length > 0) {
                     node.alternate = {
                         type: 'BlockStatement',
-                        body: node.alternate,
+                        body: [
+                            {
+                                type: 'CallConsoleInfo',
+                                content: 'ELSE',
+                            },
+                            ...node.alternate,
+                        ]
                     };
                 }
-
-                let resultScript = `if(${generateNode(node.test)}) ${generateNode(node.consequent)}`;
                 let alternateScript = '';
                 if (node.alternate) {
                     alternateScript = generateNode(node.alternate);
                 }
+
+                let resultScript = `if(${generateNode(node.test)}) ${generateNode(node.consequent)}`;
                 resultScript = alternateScript ? `${resultScript} else ${alternateScript}` : resultScript;
                 return resultScript;
             }
@@ -550,41 +534,51 @@ export default function (source, preScript) {
                 if (!node.body) {
                     return '';
                 }
-                const str = `{${newLine()}`;
                 const body = (node.body || []).map((body) => `${generateNode(body)}${colon()}${newLine()}`);
-                return `${str}${body.join(' ')}${newLine()}}`;
+                return `{
+                    ${body.join(' ')}
+                }`;
             }
 
             if (node.type === 'WhileStatement') {
-                let bodyScript = `(['WhileStatement']);${newLine()}while(${generateNode(node.test)}) {${newLine()}`;
+                let bodyScript = '';
                 if (Array.isArray(node.body)) {
                     node.body.forEach((body) => {
                         bodyScript += `${generateNode(body)}${newLine()}`;
                     });
                 }
-                return `${bodyScript}${newLine()}}${newLine()}`;
+                return `${newLine()}while(${generateNode(node.test)}) {
+                    ${bodyScript}
+                }${newLine()}`;
             }
 
             if (node.type === 'SwitchStatement') {
-                const nextNode = Object.assign({}, node, switchCase2If(node, node.cases));
-                return `(['SwitchStatement']);${newLine()}${generateNode(nextNode)}`;
+                Object.assign(node, switchCase2If(node.cases));
+                return generateNode(node);
             }
 
             if (node.type === 'ForEachStatement') {
-                const generateBodyScript = () => {
-                    let bodyScript = '';
-                    if (Array.isArray(node.body)) {
-                        node.body.forEach((body) => {
-                            bodyScript += `${generateNode(body)}${newLine()}`;
-                        });
-                    }
-                    return bodyScript;
-                };
+                let bodyScript = '';
+                if (Array.isArray(node.body)) {
+                    node.body.forEach((body) => {
+                        bodyScript += `${generateNode(body)}${newLine()}`;
+                    });
+                }
+                const indexScript = generateNode(node.index);
+                const startScript = generateNode(node.start);
+                const itemScript = generateNode(node.item);
+                const endScript = generateNode(node.end);
+                const eachScript = generateNode(node.each);
 
                 if (node.label === 'async') { // 临时测试 async 的方式
-                    return `(['ForEachStatement']);${newLine()}await Promise.all(${generateNode(node.each)}.slice(${generateNode(node.start)}, ${generateNode(node.end)}).map(async (${generateNode(node.item)}, ${generateNode(node.index)}) => {${newLine()}${generateBodyScript()}})${newLine()}`;
+                    return `${newLine()}await Promise.all(${eachScript}.slice(${startScript}, ${endScript}).map(async (${itemScript}, ${indexScript}) => {
+                        ${bodyScript}
+                    })${newLine()}`;
                 } else {
-                    return `(['ForEachStatement']);${newLine()}for (let ${generateNode(node.index)}=${generateNode(node.start)}; ${generateNode(node.index)} < ${generateNode(node.end)}; ${generateNode(node.index)}++){${newLine()}const ${generateNode(node.item)} = ${generateNode(node.each)}[${generateNode(node.index)}];${newLine()}${generateBodyScript()}}${newLine()}`;
+                    return `${newLine()}for (let ${indexScript}=${startScript}; ${indexScript} < ${endScript}; ${indexScript}++){
+                        const ${itemScript} = ${eachScript}[${indexScript}];
+                        ${bodyScript}
+                    }${newLine()}`;
                 }
             }
 
@@ -601,16 +595,12 @@ export default function (source, preScript) {
             }
 
             if (node.type === 'JSBlock') {
-                // return `${newLine()}{
-                //     const jsBlock_${logicItemIndex} = async () => {
-                //         ${node.code}
-                //     }
-
-                //     await jsBlock_${logicItemIndex}();
-                // }${newLine()}`;
+                return `${newLine()}{
+                    const jsBlock_${logicItemIndex} = async () => {
+                        ${node.code}
+                    }
 
-                return `(['JSBlock_${logicItemIndex}']);${newLine()}{
-                    ${node.code}
+                    await jsBlock_${logicItemIndex}();
                 }${newLine()}`;
             }
 
@@ -633,60 +623,42 @@ export default function (source, preScript) {
             return '';
         };
 
-        // source map for debugger!!!
-        const generateNode = (node, logicItemIndex) => {
-            const startLine = recorder.line;
-
-            const str = _generateNode(node, logicItemIndex);
-            const length = String(str).split('\n').length - 1;
-            recorder.line = startLine + length;
-            // console.log(node.type, startLine);
-            // if (node.type === 'JSBlock') {
-            //     startLine = recorder.line - 2;
-            // }
-            sourceMap[node.id] = {
-                node,
-                // jsBlockFrom: recorder.line - 2,
-                from: startLine,
-                to: recorder.line,
-            };
-            return str;
-        };
-
-        // console.info("JSON generate:", JSON.stringify(logic.body));
-        // console.log(generate({ type: 'Program', body: logic.body }).code);
-        sourceMap[logic.id] = {
-            node: logic,
-            isLogic: true,
-            from: startLineNumber,
-        };
-        // console.log(logic.name, startLineNumber);
-        let mstr = `methods['${logic.name}'] = async function (${logic.params.map((param) => param.name).join(', ')}) {
-            ${logic.params.length ? logic.params.map((param) => `${param.name} = ${param.name} !== undefined ? ${param.name} : this.$genInitFromSchema(${JSON.stringify(param.schema)}, ${JSON.stringify(param.defaultValue)});`).join('\n') + '' : ''}
-            ${logic.variables.length ? logic.variables.map((variable) => `let ${variable.name} = this.$genInitFromSchema(${JSON.stringify(variable.schema)}, ${JSON.stringify(variable.defaultValue)});`).join('\n') + '' : ''}
-            let ${returnObj.name} = this.$genInitFromSchema(${JSON.stringify(returnObj.schema)}, ${JSON.stringify(returnObj.defaultValue)});
-            `;
-
         let script = '';
-        // vital
-        recorder.line += mstr.split('\n').length - 1;
         logic.body.forEach((node, index) => {
             script += `${generateNode(node, index)}${newLine()}`;
         });
 
-        mstr += script;
-        mstr += `
-        }\n\n`;
-        // vital
-        startLineNumber += mstr.split('\n').length - 1;
-        sourceMap[logic.id].to = startLineNumber - 1;
-        return mstr;
+        return `methods['${logic.name}'] = async function (${logic.params.map((param) => param.name).join(', ')}) {
+            ${logic.params.length ? logic.params.map((param) => `${param.name} = ${param.name} !== undefined ? ${param.name} : this.$genInitFromSchema(${JSON.stringify(param.schema)}, ${JSON.stringify(param.defaultValue)});` + (isGONGHANG ? `console.info(${param.name})` : '')).join('\n') + '' : ''}
+            ${logic.variables.length ? logic.variables.map((variable) => `let ${variable.name} = this.$genInitFromSchema(${JSON.stringify(variable.schema)}, ${JSON.stringify(variable.defaultValue)});` + (isGONGHANG ? `console.info(${variable.name})` : '')).join('\n') + '' : ''}
+            let ${returnObj.name} = this.$genInitFromSchema(${JSON.stringify(returnObj.schema)}, ${JSON.stringify(returnObj.defaultValue)});` + (isGONGHANG ? `console.info(${returnObj.name})` : '') + `
+            ${script}
+        }`;
     });
 
-    output += methods.join('');
+    const output = `
+        const methods = componentOptions.methods = componentOptions.methods || {};
+        const computed = componentOptions.computed = componentOptions.computed || {};
+        const oldDataFunc = componentOptions.data;
+        const data = function () {
+            const oldData = oldDataFunc ? oldDataFunc.call(this) : {};
+            return Object.assign(oldData, {
+                ${paramsData ? paramsData + ',' : ''}
+                ${variablesData}
+            });
+        };
+        componentOptions.data = data;
+        const meta = componentOptions.meta = componentOptions.meta || {};
+        Object.assign(meta, {
+            title: ${JSON.stringify(definition.title)},
+            crumb: ${JSON.stringify(definition.crumb)},
+            first: ${JSON.stringify(definition.first)},
+        });
 
-    return {
-        output,
-        sourceMap,
-    };
+        ${lifecycles.join('\n\n')}
+
+        ${methods.join('\n\n')}
+    `;
+
+    return output;
 }