@lcap/nasl 3.4.0-alpha.1 → 3.4.0-alpha.2

package/src/bak/translator.js

@@ -91,10 +91,13 @@ export default function (definition) {
               }`
               viewMethodData.push(code)
           } else {
-              const code = `['__${element.name}_${attr.name}']() {
-                  return ${variable}
+              const code = `'__${element.name}_${attr.name}'(${variable.includes('(current || {}).item') ? 'current' : ''}) {
+                  return ${variable?.trim()?.length > 0 ? variable : undefined}
               }`
-              viewComputedData.push(code)
+              if (element.name === 'table_view1') {
+                console.log('在这里', code, variable)
+              }
+              viewMethodData.push(code)
           }
       })
       if (['u-select', 'van-pickerson'].includes(element.tag)) {
@@ -102,9 +105,9 @@ export default function (definition) {
           const code = `['__${element.name}_page-number']() {
               return this['__${element.name}_params']?.number ?? 1
           }`
-          viewComputedData.push(code)
+          viewMethodData.push(code)
       } else if (['u-list-view', 'u-grid-view', 'u-table-view', 'van-list-view', 'van-grid-view'].includes(element.tag) && element.bindAttrs?.findIndex((attr) => attr.name === 'sorting') === -1) {
-          viewComputedData.push(`['__${element.name}_sorting']() {
+        viewMethodData.push(`['__${element.name}_sorting']() {
               return {
                   field: undefined,
                   order: undefined

package/src/breakpoint/generator/AfterStartNode.ts

@@ -1,4 +1,5 @@
 import BreakpointNode from './BreakpointNode';
+import { getLogicAncestor } from '../shared/utils';
 
 export default class AfterStartNode extends BreakpointNode {
   _logicNodePath: string = '';
@@ -13,7 +14,7 @@ export default class AfterStartNode extends BreakpointNode {
     super.init();
 
     const { logic } = this;
-    const ancestor = logic.getAncestor('Logic');
+    const ancestor = getLogicAncestor(logic);
     this._logicNodePath = ancestor && ancestor.nodePath;
   }
 

package/src/breakpoint/generator/BeforeEndNode.ts

@@ -1,4 +1,5 @@
 import BreakpointNode from './BreakpointNode';
+import { getLogicAncestor } from '../shared/utils';
 
 export default class BeforeEndNode extends BreakpointNode {
   _logicNodePath: string = '';
@@ -13,7 +14,7 @@ export default class BeforeEndNode extends BreakpointNode {
     super.init();
 
     const { logic } = this;
-    const ancestor = logic.getAncestor('Logic');
+    const ancestor = getLogicAncestor(logic);
     this._logicNodePath = ancestor && ancestor.nodePath;
   }
 

package/src/breakpoint/generator/BreakpointNode.ts

@@ -72,14 +72,14 @@ const callLogicGenerator = (instance: BreakpointNode) => (breaker: string) => {
       return callback();
     }
 
-    const logic = source.getCallNode() || {};
-    const { params: logicParams } = logic;
+    const callNode = source.getCallNode() || {};
+    const { params: callNodeParams } = callNode;
 
-    const logicBase = logicParams || [];
-    logic.params = logicBase.concat({ name: attribute });
+    const callNodeBase = callNodeParams || [];
+    callNode.params = callNodeBase.concat({ name: attribute });
 
     const result = callback();
-    logic.params = logicParams;
+    callNode.params = callNodeParams;
 
     return result;
   };
@@ -90,6 +90,7 @@ const callLogicGenerator = (instance: BreakpointNode) => (breaker: string) => {
   const base = args || [];
 
   breakpointArgument.name = attribute;
+  breakpointArgument.keyword = attribute;
   breakpointArgument.expression = breakpointExpression as any;
   breakpointExpression._nodePath = _nodePath;
   source.arguments = base.concat(breakpointArgument);
@@ -116,20 +117,46 @@ const callFunctionGenerator = (instance: BreakpointNode) => (breaker: string) =>
     return;
   }
 
-  const { typeArguments } = source;
+  const {
+    arguments: sourceArguments,
+    typeArguments: sourceTypeArguments,
+  } = source;
 
   // eslint-disable-next-line @typescript-eslint/no-use-before-define
   const breakpointExpression = new BreakpointNode();
   const breakpointArgument = new Argument();
-  const base = typeArguments || [];
+
+  const baseArguments = sourceArguments || [];
+  const baseTypeArguments = sourceTypeArguments || [];
+  const addToTypeArguments = baseTypeArguments?.length;
 
   breakpointArgument.name = attribute;
+  breakpointArgument.keyword = attribute;
   breakpointArgument.expression = breakpointExpression as any;
   breakpointExpression._nodePath = _nodePath;
-  source.typeArguments = base.concat(breakpointArgument);
+
+  if (addToTypeArguments) {
+    source.typeArguments = baseTypeArguments.concat(breakpointArgument);
+  } else {
+    const { length } = baseArguments;
+
+    if (length) {
+      const lastBaseArgument = baseArguments[length - 1];
+      const beforeBaseArguments = baseArguments.slice(0, -1);
+      const combinedLastBaseArgument = new BreakpointNode();
+
+      combinedLastBaseArgument.variable = lastBaseArgument;
+      combinedLastBaseArgument._nodePath = _nodePath;
+      source.arguments = beforeBaseArguments.concat(combinedLastBaseArgument);
+    } else {
+      source.arguments = baseArguments.concat(breakpointArgument);
+    }
+  }
 
   const code = source.toJS();
-  source.typeArguments = typeArguments;
+
+  source.arguments = sourceArguments;
+  source.typeArguments = sourceTypeArguments;
 
   return assemble(instance)(code);
 };

package/src/breakpoint/shared/constants.ts

@@ -1,5 +1,12 @@
 export const JSON_VOID = 'new String(\'void\')';
 
+export const LOGIC_CONCEPTS = [
+  'Logic',
+  'AuthLogic',
+  'OverriddenLogic',
+  'AuthLogicForCallInterface',
+] as const;
+
 export const VARIABLE_KEYS = [
   'test',
   'left',

package/src/breakpoint/shared/utils.ts

@@ -6,6 +6,7 @@ import {
 } from '../../concepts';
 
 import {
+  LOGIC_CONCEPTS,
   STATUS_ENABLED,
   STATUS_DISABLED,
   TRAVERSE_NODE_KEYS,
@@ -84,6 +85,7 @@ export const getRealNode = (node: BaseNode): BaseNode => {
 const unbrakableAncestors = [
   'Process',
   'BindAttribute',
+  'CallAuthInterface',
 ] as const;
 
 const isBreakableByAncestors = (node: BaseNode): Boolean => {
@@ -150,14 +152,34 @@ export const isDisabled = (node: BaseNode): Boolean => {
 
 export const getUniqueIdFromNode = (node: BaseNode) => node && node.nodePath;
 
+export const getGlobalLogics = (app: App) => {
+  if (!app) {
+    return [];
+  }
+
+  const {
+    logics = [],
+    authLogics = [],
+    overriddenLogics = [],
+    authLogicsForCallInterface = [],
+  } = app;
+
+  return [
+    ...(logics || []),
+    ...(authLogics || []),
+    ...(overriddenLogics || []),
+    ...(authLogicsForCallInterface || []),
+  ];
+};
+
 export const getLogics = (app: App) => {
   if (!app) {
     return [];
   }
 
-  const { logics = [], frontends = [] } = app;
+  const { frontends = [] } = app;
 
-  let result = logics;
+  let result = getGlobalLogics(app) || [];
 
   const forViewElement = (viewElement: ViewElement) => {
     if (!viewElement) {
@@ -205,7 +227,7 @@ export const getLogics = (app: App) => {
   frontends.forEach((frontend) => {
     const { views = [] } = frontend;
 
-    views.forEach(forView);
+    views && views.forEach(forView);
   });
 
   return result;
@@ -257,3 +279,14 @@ export const toString = (value: any, type: string) => {
 };
 
 export const toStringVoid = () => toString('void', 'undefined');
+
+export const getLogicAncestor = (node: BaseNode): BaseNode | undefined => {
+  if (!node) {
+    return;
+  }
+
+  return LOGIC_CONCEPTS.reduce(
+    (result, concpet) => result || node.getAncestor(concpet),
+    undefined,
+  ) as BaseNode | undefined;
+};