@lcap/nasl 3.6.0-alpha.4 → 3.6.0-alpha.6

package/src/natural/prompt/executeClaims.ts

@@ -0,0 +1,69 @@
+export const executeClaims = async (params: any) => {
+  const { logicName, logicType } = params;
+  const claims = `
+-   语法
+    -   请使用 ts + es6 的语法
+-   函数名
+    -   函数名请使用 ${logicName}
+-   函数内的变量声明
+    -   在使用变量或者参数前，请先查找低代码平台的 ts 定义中是否已声明，如果没有声明，请先声明，并遵循 nasl.core 中的规范
+    -   变量名称禁止使用 'result'，请使用其它名称代替
+    -   类型禁止出现 any 和 undefined
+    -   在使用枚举的时候，必须加上前缀, 格式为: app.enums.枚举['属性']
+        -   例如 app.enums.UserStatusEnum['Normal']
+-   函数体
+    -   只能返回一个函数体，你需要在一个函数体中实现所有的功能
+    -   只能对 'Boolean', 'Integer', 'Double', 'Decimal', 'Long' 使用 new 关键字
+    -   禁止使用 import
+    -   禁止使用 for/forEach 语句，如果需要循环或者遍历，你**只能**使用 ForEach 方法
+    -   只获取单条数据时使用 Entity.get()，避免频繁操作实体
+    -   字符串或者变量之间的拼接或者 concat 请使用字符串插值(模板字符串)语法
+    -   需要使用 nasl.ui 中类的方法时，请使用 $refs 的前缀，例如 $refs.tableView1.reload()，禁止使用 new 创建实例
+    -   nasl.core 中的方法，请直接使用，例如 plus(left, right)，禁止出现 nasl.util.plus 等
+    -   禁止使用 标准内置对象(例如 Math、Number、Array、String 等内置对象)的方法
+    -   禁止使用 Object 的所有方法，如果想使用对象或者想要获取属性的值时，请使用 Map 系列函数
+    -   优先使用 nasl.util 中的内置函数或方法
+    -   禁止方法的连续调用
+    -   禁止使用三元表达式，可使用 if 语句或者 while 语句替换
+    -   直接输出代码结果，其他描述请以注释的形式出现
+-   返回值
+    -   如果用户没有特别指明是打印(日志/输出结果)，"输出结果"一律按照"返回输出结果"处理
+  `;
+
+  const claimsMap = {
+    global_logic: `
+-   语法
+    -   请使用 ts + es6 的语法
+-   函数名
+    -   函数名请使用 ${logicName}
+-   函数内的变量声明
+    -   在使用变量或者参数前，请先查找低代码平台的 ts 定义中是否已声明，如果没有声明，请先声明，并遵循 nasl.core 中的规范
+    -   变量名称禁止使用 'result'，请使用其它名称代替
+    -   类型禁止出现 any 和 undefined
+    -   在使用枚举的时候，必须加上前缀, 格式为: app.enums.枚举['属性']
+        -   例如 app.enums.UserStatusEnum['Normal']
+-   函数体
+    -   只能返回一个函数体，你需要在一个函数体中实现所有的功能
+    -   只能对 'Boolean', 'Integer', 'Double', 'Decimal', 'Long' 使用 new 关键字
+    -   禁止使用 import
+    -   禁止使用 for/forEach 语句，如果需要循环或者遍历，你**只能**使用 ForEach 方法
+    -   分析用户的需求，优先使用数据库的查询和数据操纵能力，例如 JOIN、SUM、GROUP_BY 等能力，使用 SQL 语句同时实现查询和计算
+    -   如果要查询，则使用 nasl.oql.query，同时分析整个需求，尽量用一句 SQL 实现
+        -   只获取单条数据时使用 Entity.get()，其它查询都使用 nasl.oql.query
+        -   禁止对 nasl.oql.query 的结果进行连续调用
+    -   避免频繁操作实体
+    -   字符串或者变量之间的拼接或者 concat 请使用字符串插值(模板字符串)语法
+    -   需要使用 nasl.ui 中类的方法时，请使用 $refs 的前缀，例如 $refs.tableView1.reload()，禁止使用 new 创建实例
+    -   nasl.core 中的方法，请直接使用，例如 plus(left, right)，禁止出现 nasl.util.plus 等
+    -   禁止使用 标准内置对象(例如 Math、Number、Array、String 等内置对象)的方法
+    -   禁止使用 Object 的所有方法，如果想使用对象或者想要获取属性的值时，请使用 Map 系列函数
+    -   优先使用 nasl.util 中的内置函数或方法
+    -   禁止方法的连续调用
+    -   禁止使用三元表达式，可使用 if 语句或者 while 语句替换
+    -   直接输出代码结果，其他描述请以注释的形式出现
+-   返回值
+    -   如果用户没有特别指明是打印(日志/输出结果)，"输出结果"一律按照"返回输出结果"处理
+    `,
+  } as any;
+  return claimsMap?.[logicType] || claims;
+};

package/src/natural/transformTSCode.ts

@@ -224,7 +224,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
   }
 
   function isPageLogic(logicName: string) {
-    return logicName.includes('on_') || logicName.includes('viewLogic_');
+    return logicName.includes('on_') || logicName.includes('viewLogic_') || logicName.includes('businessLogic_');
   }
 
   function transformLogicNode(node: babelTypes.Node, typeAnnotation?: naslTypes.TypeAnnotation): naslTypes.LogicItem {
@@ -387,6 +387,14 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           }))],
         });
       }
+      if (calleeName === 'PaginateLimit') {
+        const newCallee = node?.arguments || [];
+        return new naslTypes.Paginate({
+          list: newCallee?.[0] && transformLogicNode(newCallee?.[0]),
+          page: newCallee?.[1] && transformLogicNode(newCallee?.[1]),
+          size: newCallee?.[2] && transformLogicNode(newCallee?.[2]),
+        });
+      }
       if (calleeName === 'ForEach') {
         const newCallee = node.arguments;
         const arrowFunction = node.arguments[3] as babelTypes.ArrowFunctionExpression;
@@ -430,7 +438,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
             expression: transformLogicNode(arg),
           })) as naslTypes.Argument[],
         });
-      } else if (/^app.dataSources|app.logics|load/.test(calleeName)) {
+      } else if (/^app.dataSources|app.logics/.test(calleeName)) {
         return new naslTypes.CallLogic({
           calleeNamespace: generate((node.callee as any).object).code,
           calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
@@ -838,6 +846,8 @@ export function transformTSCodeEx(answer: any, activeLogic: any, context: any) {
     logicName = `viewLogic_${activeLogic.name}`;
   } else if (activeLogic.parentNode instanceof nasl.BindEvent && activeLogic.parentNode.parentNode instanceof nasl.ViewElement) {
     logicName = `on_${(activeLogic.parentNode).element.name}_${activeLogic.name}`;
+  } else if (activeLogic?.concept === 'BusinessLogic') {
+    logicName = `businessLogic_${activeLogic?.name}`;
   } else {
     logicName = activeLogic.name;
   }

package/src/server/extendBaseNode.ts

@@ -23,13 +23,14 @@ import {
   Connector,
   MsgTriggerLauncher,
   Connection,
-  MetadataType
+  MetadataType,
 } from '../concepts';
-import { FileNode } from '../utils';
+import { FileNode, traverse } from '../utils';
 import { EventPayload, invokeCommand, registerCommand } from '../common';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
 import { extendSentryMonitorNaslNode } from '../sentry';
+import { ca } from 'date-fns/locale';
 
 interface SetNameNode extends BaseNode {
   setName(name: string): any;
@@ -135,7 +136,10 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
     if (res.length <= 1) {
       if (this.concept === 'enumItem') {
         (this as any).setValue(newValue);
-      } else if (this.concept === 'Process' || (this.concept === 'ProcessElement' && ['InitiateTask', 'ApprovalTask', 'UserTask'].includes((this as any).type))) {
+      } else if (
+        this.concept === 'Process' ||
+        (this.concept === 'ProcessElement' && ['InitiateTask', 'ApprovalTask', 'UserTask'].includes((this as any).type))
+      ) {
         const confirmParms: any = {
           actionType: 'rename',
           node: this,
@@ -147,13 +151,13 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
           confirmParms.title = '重命名流程名称';
           confirmParms.process = true;
         } else if (this.concept === 'ProcessElement') {
-          confirmParms.title = '修改节点名称'
+          confirmParms.title = '修改节点名称';
           confirmParms.process = true;
         }
         const callback = () => {
           (this as SetNameNode).setName(newValue);
-        }
-        invokeCommand('tsConfirm.open', confirmParms, callback)
+        };
+        invokeCommand('tsConfirm.open', confirmParms, callback);
       } else (this as SetNameNode).setName(newValue);
     } else {
       const callback = (value: boolean, toast?: Function) => {
@@ -207,7 +211,7 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
         confirmParms.title = '重命名流程名称';
         confirmParms.process = true;
       } else if (this.concept === 'ProcessElement' && ['InitiateTask', 'ApprovalTask', 'UserTask'].includes((this as any).type)) {
-        confirmParms.title = '修改节点名称'
+        confirmParms.title = '修改节点名称';
         confirmParms.process = true;
       }
 
@@ -225,7 +229,7 @@ BaseNode.prototype.removeBindEntityPropertyViewEelment = async function removeBi
   const naslServer = (app as any).naslServer as NaslServer;
   const refsList = await naslServer._isHaveRef(this); // 查找到引用链
 
-  refsList.forEach(record => {
+  refsList.forEach((record) => {
     const fileNode = naslServer.file2NodeMap.get(record.file);
     if (!fileNode) return null;
     const minRange: MinRange = naslServer._findMinRange(record, fileNode as FileNode); // 查找到引用节点
@@ -233,13 +237,12 @@ BaseNode.prototype.removeBindEntityPropertyViewEelment = async function removeBi
     let node = minRange.node;
     while (node) {
       if (node instanceof ViewElement && node.getBindAttribute('bindEntityProperty')) {
-          node.delete();
-        }
-        node = node.parentNode;
+        node.delete();
       }
-    })
-
-}
+      node = node.parentNode;
+    }
+  });
+};
 
 /** 删除连接器 */
 function delConnection(node: Connection) {
@@ -307,6 +310,34 @@ BaseNode.prototype.prepareDelete = async function prepareDelete(cb?: Function) {
           if (cb) {
             cb();
           }
+        } else if (node instanceof View || node instanceof Frontend) {
+          (this as any).app.emit('collect:start', {
+            actionMsg: `删除节点`,
+          });
+          // 删除页面或端的时候，如果存在表单设计器，需要同步删除分组内容
+          const excludedKeySet = new Set([
+            'parentNode',
+            'sourceMap',
+            'storageJSON',
+            'tsErrorDetail',
+            'NaslAnnotatedJSON',
+            'calledFrom',
+            '_events',
+            '_collectingList',
+            '_historyList',
+          ]);
+          traverse(
+            (current) => {
+              const currentNode: any = current.node;
+              if (currentNode && currentNode?.concept === 'ViewElement' && currentNode?.name === currentNode?.composedBy?.[0]) {
+                currentNode.app.deleteCompose(currentNode.composedBy);
+              }
+            },
+            { node: this },
+            { mode: 'anyObject', excludedKeySet }
+          );
+          this.delete();
+          (this as any).app.emit('collect:end');
         } else {
           this.delete();
         }

package/src/server/getLogics.ts

@@ -321,7 +321,7 @@ export function getLogicsSync(node: CallLogic | BindEvent | Identifier | Logic,
             name: 'category',
             path: `auth`,
             title: '认证与权限',
-            logics: getStdlibNamespace().findChild('auth').logics.filter((item) => item.name !== 'getCurrentUser'),
+            logics: getStdlibNamespace().findChild('auth').logics.filter((item) => !['getCurrentUser', 'encryptPassword', 'validatePassword', 'generateUserId'].includes(item.name)),
             expanded: false,
           }),
           new Namespace({
@@ -438,8 +438,8 @@ export function getLogicsSync(node: CallLogic | BindEvent | Identifier | Logic,
           new Namespace({
             name: 'category',
             path: `auth`,
-            title: '用户',
-            logics: getStdlibNamespace().findChild('auth').logics.filter((item) => item.name === 'getCurrentUser'),
+            title: '认证与权限',
+            logics: getStdlibNamespace().findChild('auth').logics.filter((item) => ['getCurrentUser', 'encryptPassword', 'validatePassword', 'generateUserId'].includes(item.name)),
             expanded: false,
           }),
         ],

package/src/server/getMemberIdentifier.ts

@@ -98,22 +98,22 @@ function formatGlobalVariable() {
     value: 'userInfo',
     children: [
       { name: 'Status', value: 'userInfo.Status' },
-      {
-        name: 'UserInfoExtend',
-        value: 'userInfo.UserInfoExtend',
-        children: [
-          { name: 'Company', value: 'userInfo.UserInfoExtend.Company' },
-          { name: 'JobLevel', value: 'userInfo.UserInfoExtend.JobLevel' },
-          { name: 'JobNum', value: 'userInfo.UserInfoExtend.JobNum' },
-          { name: 'JobYear', value: 'userInfo.UserInfoExtend.JobYear' },
-          { name: 'RealName', value: 'userInfo.UserInfoExtend.RealName' },
-          { name: 'NickName', value: 'userInfo.UserInfoExtend.NickName' },
-          { name: 'NameAndEmail', value: 'userInfo.UserInfoExtend.NameAndEmail' },
-          { name: 'Position', value: 'userInfo.UserInfoExtend.Position' },
-          { name: 'Department', value: 'userInfo.UserInfoExtend.Department' },
-          { name: 'EmployeeId', value: 'userInfo.UserInfoExtend.EmployeeId' },
-        ],
-      },
+      // {
+      //   name: 'UserInfoExtend',
+      //   value: 'userInfo.UserInfoExtend',
+      //   children: [
+      //     { name: 'Company', value: 'userInfo.UserInfoExtend.Company' },
+      //     { name: 'JobLevel', value: 'userInfo.UserInfoExtend.JobLevel' },
+      //     { name: 'JobNum', value: 'userInfo.UserInfoExtend.JobNum' },
+      //     { name: 'JobYear', value: 'userInfo.UserInfoExtend.JobYear' },
+      //     { name: 'RealName', value: 'userInfo.UserInfoExtend.RealName' },
+      //     { name: 'NickName', value: 'userInfo.UserInfoExtend.NickName' },
+      //     { name: 'NameAndEmail', value: 'userInfo.UserInfoExtend.NameAndEmail' },
+      //     { name: 'Position', value: 'userInfo.UserInfoExtend.Position' },
+      //     { name: 'Department', value: 'userInfo.UserInfoExtend.Department' },
+      //     { name: 'EmployeeId', value: 'userInfo.UserInfoExtend.EmployeeId' },
+      //   ],
+      // },
       { name: 'UserName', value: 'userInfo.UserName' },
       { name: 'Email', value: 'userInfo.Email' },
       { name: 'UserId', value: 'userInfo.UserId' },
@@ -143,9 +143,9 @@ function formatGlobalVariable() {
     (item as any).expression = expression;
     const completionProperty = new CompletionProperty(item as any);
     completionProperty.icon = 'literal';
-    if (item.children) {
+    if ((item as any).children ) {
       const children: LogicItem[] = [];
-      item.children.forEach((child) => {
+      (item as any).children.forEach((child:any) => {
         const childExpression = new MemberExpression({
           object: expression,
           property: new Identifier({ name: child.name }),

package/src/server/naslServer.ts

@@ -1590,10 +1590,12 @@ class NaslServer {
    * 是否符合 触发器规则
    * 规则：
    * 1. 入参仅有一个，且必须为string类型
+   * 2. 不允许有返回值
    */
   isTriggerRule(fileNode: BaseNode): boolean {
     const { sourceMap } = fileNode;
     let paramsLength = 0;
+    let returnLength = 0;
     let flag = true;
     sourceMap.forEach((_, k) => {
       if (k instanceof Param) {
@@ -1605,8 +1607,11 @@ class NaslServer {
           flag = false;
         }
       }
+      if (k instanceof Return)  {
+        returnLength ++;
+      }
     });
-    return paramsLength === 1 && flag;
+    return paramsLength === 1 && flag && returnLength === 0;
   }
 
   /**
@@ -2103,7 +2108,7 @@ class NaslServer {
         const diagnostic = {
           node: fileNode,
           severity: 'error',
-          message: `${fileNode.name} 已被Kafka消息订阅配置 ${fRefName} 引用，该逻辑入参只有一个入参，且入参类型为string，否则会导致无法接收Kafka消息`,
+          message: `${fileNode.name} 已被Kafka消息订阅配置 ${fRefName} 引用：该逻辑入参只有一个入参，入参类型为string；且不允许存在返回值。否则会导致无法接收Kafka消息`,
         };
         diagnostics.push(diagnostic);
       }

package/src/server/translator.ts

@@ -458,6 +458,11 @@ Object.keys(NAMESPACE_CONCEPT_MAP).forEach((key) => {
 });
 
 export function translateDiagnosticMessage(message: string) {
+  // 业务组件先处理
+  const businessComponent = /Namespace 'app.frontendTypes.(.+?).businessComponents' has no exported member '(.+?)'./.exec(message);
+  if (businessComponent?.[1] && businessComponent?.[2]) {
+    return `找不到${businessComponent?.[1]}端下的业务组件${businessComponent?.[2]}`;
+  }
   for (const rule of TS_RULES) {
     const cap = rule.re.exec(message);
     if (cap) {
@@ -489,6 +494,8 @@ export function naslNodeTranslateMessage(minRange: MinRange, tsErrorDetail: Diag
       return null;
     } else if (text.startsWith(`Function expression, which lacks return-type annotation, implicitly has an 'any[]' return type.`)) {
       return null;
+    } else if (/Property 'businessComponents' does not exist on type 'typeof (pc|h5)'./.exec(text)) {
+      return null;
     }
   }
   // 处理bindevent参数没传递的报错

package/src/service/storage/init.ts

@@ -381,7 +381,7 @@ const handleAIPoint = (app: any, actionItem: any) => {
   if (actionMsg.includes('自然语言生成代码') && !action) {
     aiExecuted += 1;
     // eslint-disable-next-line prefer-destructuring
-    sessionPath = actionMsg.match(/:(.*)/)[1];
+    sessionPath = actionMsg?.match(/:(.*)/)?.[1];
   }
 }
 
@@ -421,7 +421,7 @@ async function doAction(app: any, actionItem: any) {
   let hasBackEnd = false;
   const actionList: any[] = [];
   const allRiskList: any[] = [];
-  const { list, actionMsg, action } = actionItem || {};
+  const { list, actionMsg, action, extra} = actionItem || {};
   handleAIPoint(app, actionItem);
   const itemloop = (_i: LogicItem, app: any, diffArr: string[]) => {
     const _l = getStatement(_i, app, diffArr);
@@ -683,6 +683,7 @@ async function doAction(app: any, actionItem: any) {
     }
     app._historyList.push({
       actionMsg,
+      extra: extra,
       list: list.map((item: any) => item?.originEvent),
     });
     app._historyIndex = app._historyList.length;
@@ -1000,6 +1001,7 @@ export interface ProxyApp extends App {
   _noTimer: NodeJS.Timeout;
   _actionMsg: string;
   _action: string;
+  _extra?: any;
   naslServer: NaslServer;
 }
 
@@ -1048,6 +1050,7 @@ export function handleApp(app: ProxyApp) {
     if (!proxyApp._isCollectingCount) {
       proxyApp._actionMsg = event?.actionMsg;
       proxyApp._action = event?.action;
+      proxyApp._extra = event?.extra;
     }
     proxyApp._isCollectingCount++;
   });
@@ -1066,6 +1069,7 @@ export function handleApp(app: ProxyApp) {
       const collectingList = proxyApp._collectingList;
       const actionMsg = proxyApp._actionMsg;
       const action = proxyApp._action;
+      const extra = proxyApp._extra;
       proxyApp._collectingList = [];
       proxyApp._actionMsg = '';
       proxyApp._action = '';
@@ -1079,6 +1083,7 @@ export function handleApp(app: ProxyApp) {
           list: collectingList,
           actionMsg,
           action,
+          extra
         });
       }
     } else if (proxyApp._isCollectingCount < 0) {

package/src/translator/types.ts

@@ -48,6 +48,9 @@ export interface TranslatorState {
   finalCode?: boolean;
   focusedNodePath?: string;
   getVuePrototype?: boolean;
+
+  // CallLogic 节点翻译时不使用立即运行函数
+  callLogicNoIife?: boolean;
 }
 
 export type SourceMapItem = Range;

package/test/concepts/view-element/__snapshots__/toEmbeddedTS.spec.ts.snap

@@ -116,6 +116,205 @@ exports[`view-element:toEmbeddedTS default-not-found 1`] = `
 "
 `;
 
+exports[`view-element:toEmbeddedTS table-data-source-calllogic-with-server-validation 1`] = `
+"new nasl.ui.uLinearLayout({
+  name: __elements.uLinearLayout1,
+  bindAttr: () => [() => {}, () => {}],
+  slotDefault: () => {
+    return [
+      new nasl.ui.uLinearLayout({
+        name: __elements.linear_layout_1,
+        bindAttr: () => [() => {}],
+        slotDefault: () => {
+          type datasourceNametableView_1 = nasl.ui.GetItemTypeFromDataSource<
+            typeof app.logics.loadTestTableView_1
+          >;
+
+          return [
+            new nasl.ui.uTableView<datasourceNametableView_1>({
+              name: __elements.tableView_1,
+              bindAttr: () => [
+                () => {
+                  (() => {
+                    const wrapper = nasl.util.callLogicWithChecker(
+                      app.logics.loadTestTableView_1,
+                      (page, size, sort, order, filter) => {
+                        () => {};
+                      }
+                    );
+                    return wrapper(
+                      __elements_completionProperty[\\"tableView_1\\"].pageNumber,
+                      __elements_completionProperty[\\"tableView_1\\"].pageSize,
+                      __elements_completionProperty[\\"tableView_1\\"].sorting
+                        .field,
+                      __elements_completionProperty[\\"tableView_1\\"].sorting
+                        .order,
+                      filter
+                    );
+                  })();
+                },
+                () => {},
+                () => {},
+                () => {},
+                () => {},
+                () => {},
+                () => {},
+              ],
+              slotDefault: () => {
+                return [
+                  new nasl.ui.uTableViewColumn({
+                    name: __elements.table_view_column_1,
+                    bindAttr: () => [() => {}, () => {}],
+                    slotExpander: (current) => {
+                      return [
+                        new nasl.ui.uTableViewExpander({
+                          name: __elements.table_view_expander_1,
+                          bindAttr: () => [
+                            () => {
+                              current.item;
+                            },
+                          ],
+                          slotDefault: () => {
+                            return [];
+                          },
+                        }),
+                      ];
+                    },
+                    slotCell: (current) => {
+                      return [];
+                    },
+                    slotTitle: () => {
+                      return [
+                        new nasl.ui.uText({
+                          name: __elements.text_9,
+                          bindAttr: () => [() => {}],
+                          slotDefault: () => {
+                            return [];
+                          },
+                        }),
+                      ];
+                    },
+                  }),
+
+                  new nasl.ui.uTableViewColumn({
+                    name: __elements.table_view_column_2,
+                    bindAttr: () => [() => {}],
+                    slotExpander: (current) => {
+                      return [
+                        new nasl.ui.uTableViewExpander({
+                          name: __elements.table_view_expander_2,
+                          bindAttr: () => [
+                            () => {
+                              current.item;
+                            },
+                          ],
+                          slotDefault: () => {
+                            return [];
+                          },
+                        }),
+                      ];
+                    },
+                    slotCell: (current) => {
+                      return [
+                        new nasl.ui.uLinearLayout({
+                          name: __elements.linear_layout_4,
+                          bindAttr: () => [() => {}],
+                          slotDefault: () => {
+                            return [
+                              new nasl.ui.uText({
+                                name: __elements.text_10,
+                                bindAttr: () => [
+                                  () => {
+                                    current.item.entity1.createdTime;
+                                  },
+                                ],
+                                slotDefault: () => {
+                                  return [];
+                                },
+                              }),
+                            ];
+                          },
+                        }),
+                      ];
+                    },
+                    slotTitle: () => {
+                      return [
+                        new nasl.ui.uText({
+                          name: __elements.text_11,
+                          bindAttr: () => [() => {}],
+                          slotDefault: () => {
+                            return [];
+                          },
+                        }),
+                      ];
+                    },
+                  }),
+
+                  new nasl.ui.uTableViewColumn({
+                    name: __elements.table_view_column_3,
+                    bindAttr: () => [() => {}],
+                    slotExpander: (current) => {
+                      return [
+                        new nasl.ui.uTableViewExpander({
+                          name: __elements.table_view_expander_3,
+                          bindAttr: () => [
+                            () => {
+                              current.item;
+                            },
+                          ],
+                          slotDefault: () => {
+                            return [];
+                          },
+                        }),
+                      ];
+                    },
+                    slotCell: (current) => {
+                      return [
+                        new nasl.ui.uLinearLayout({
+                          name: __elements.linear_layout_5,
+                          bindAttr: () => [() => {}],
+                          slotDefault: () => {
+                            return [
+                              new nasl.ui.uText({
+                                name: __elements.text_12,
+                                bindAttr: () => [
+                                  () => {
+                                    current.item.entity1.updatedTime;
+                                  },
+                                ],
+                                slotDefault: () => {
+                                  return [];
+                                },
+                              }),
+                            ];
+                          },
+                        }),
+                      ];
+                    },
+                    slotTitle: () => {
+                      return [
+                        new nasl.ui.uText({
+                          name: __elements.text_13,
+                          bindAttr: () => [() => {}],
+                          slotDefault: () => {
+                            return [];
+                          },
+                        }),
+                      ];
+                    },
+                  }),
+                ];
+              },
+            }),
+          ];
+        },
+      }),
+    ];
+  },
+});
+"
+`;
+
 exports[`view-element:toEmbeddedTS with-role-auth 1`] = `
 "new nasl.ui.uLinearLayout({
   name: __elements.uLinearLayout1,