@lcap/nasl 3.7.0-alpha.1 → 3.7.0-beta.1

package/src/concepts/BindAttribute__.ts

@@ -14,30 +14,29 @@ import { ElementToVueOptions } from './ViewElement__';
 import type Namespace from './Namespace__';
 import type MemberExpression from './MemberExpression__';
 
+import ViewElement from './ViewElement__';
+import View from './View__';
+import Module from './Module__';
+import Frontend from './Frontend__';
+import ProcessElement from './ProcessElement__';
+import Process from './Process__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor } from '../decorators';
 
 import * as utils from '../utils';
 import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
-import type LogicItem from './LogicItem__';
-import type Destination from './Destination__';
-import type ExternalDestination from './ExternalDestination__';
-import type ValidationRule from './ValidationRule__';
-import type Assignee from './Assignee__';
-import type ViewElement from './ViewElement__';
-import type ProcessElement from './ProcessElement__';
-import type View from './View__';
-import type Module from './Module__';
-import type App from './App__';
-import type Frontend from './Frontend__';
-import type Process from './Process__';
+import LogicItem from './LogicItem__';
+import Destination from './Destination__';
+import ExternalDestination from './ExternalDestination__';
+import ValidationRule from './ValidationRule__';
+import Assignee from './Assignee__';
 
 /**
  * 元素绑定属性
@@ -46,7 +45,11 @@ import type Process from './Process__';
 export class BindAttribute extends BaseNode {
   /** 类名 */
   static readonly ConceptName: string = 'BindAttribute';
-
+  /**
+   * 是否为抽象类
+   * 抽象类不能产生 concept: string
+   */
+  static isAbstract: boolean = false;
   /** 继承链 */
   static readonly inheritanceChain: string[] = ['BaseNode'];
 
@@ -56,24 +59,29 @@ export class BindAttribute extends BaseNode {
   @property('concept')
   // @ts-ignore
   readonly concept!: 'BindAttribute';
-
   /**
    * 元素绑定属性名称
    */
-  @property()
-  name!: string;
+  @property({
+    objectRef: '',
+  })
+  name: string = '';
 
   /**
    * type
    */
-  @property()
-  type!: 'string' | 'static' | 'dynamic';
+  @property({
+    objectRef: '',
+  })
+  type: 'string' | 'static' | 'dynamic';
 
   /**
    * 属性值
    */
-  @property()
-  value!: string;
+  @property({
+    objectRef: '',
+  })
+  value: string;
 
   /**
    * 属性表达式
@@ -81,7 +89,7 @@ export class BindAttribute extends BaseNode {
   @property({
     objectRef: 'LogicItem',
   })
-  expression!: LogicItem;
+  expression: LogicItem;
 
   /**
    * 跳转页面
@@ -89,7 +97,7 @@ export class BindAttribute extends BaseNode {
   @property({
     objectRef: 'Destination',
   })
-  destination!: Destination;
+  destination: Destination;
 
   /**
    * 跳转页面
@@ -97,7 +105,7 @@ export class BindAttribute extends BaseNode {
   @property({
     objectRef: 'ExternalDestination',
   })
-  externalDestination!: ExternalDestination;
+  externalDestination: ExternalDestination;
 
   /**
    * 验证规则
@@ -115,19 +123,23 @@ export class BindAttribute extends BaseNode {
   @property({
     objectRef: 'Assignee',
   })
-  assignee!: Assignee;
+  assignee: Assignee;
 
   /**
    * 是否使用 v-model
    */
-  @property()
-  model!: boolean;
+  @property({
+    objectRef: '',
+  })
+  model: boolean;
 
   /**
    * 是否开启双向绑定
    */
-  @property()
-  sync!: boolean;
+  @property({
+    objectRef: '',
+  })
+  sync: boolean;
 
   /**
    * 草稿态
@@ -140,53 +152,12 @@ export class BindAttribute extends BaseNode {
   playground: Array<LogicItem> = [];
 
   /**
-   * i18nKey
-   */
-  @property()
-  i18nKey!: string;
-
-  /**
-   * 祖先 ViewElement
-   */
-  get viewElement() {
-    return this.getAncestor('ViewElement') as ViewElement;
-  }
-  /**
-   * 祖先 View
+   * 国际化键
    */
-  get view() {
-    return this.getAncestor('View') as View;
-  }
-  /**
-   * 祖先 Module
-   */
-  get module() {
-    return this.getAncestor('Module') as Module;
-  }
-  /**
-   * 祖先 App
-   */
-  get app() {
-    return this.getAncestor('App') as App;
-  }
-  /**
-   * 祖先 Frontend
-   */
-  get frontend() {
-    return this.getAncestor('Frontend') as Frontend;
-  }
-  /**
-   * 祖先 ProcessElement
-   */
-  get processElement() {
-    return this.getAncestor('ProcessElement') as ProcessElement;
-  }
-  /**
-   * 祖先 Process
-   */
-  get process() {
-    return this.getAncestor('Process') as Process;
-  }
+  @property({
+    objectRef: '',
+  })
+  i18nKey: string = uuidv4().replace(/-/g, '');
 
   /**
    * @param source 需要合并的部分参数
@@ -201,17 +172,6 @@ export class BindAttribute extends BaseNode {
     return super.from(source, parentNode, parentKey) as BindAttribute;
   }
 
-  /**
-   * 从父级删除该节点
-   * @internal
-   */
-  _delete() {
-    let params: Params = null;
-    if (this.parentNode) {
-      params = (this.parentNode as any)?.__removeBindAttribute?.(this);
-    }
-    return params;
-  }
   /**
    * 设置属性值
    */
@@ -298,7 +258,7 @@ export class BindAttribute extends BaseNode {
 
   getValidationRuleExistingNames(excludedList: Array<ValidationRule> = []) {
     const excludedSet = new Set(excludedList);
-    return ((this.rules as ValidationRule[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item?.name);
+    return ((this.rules as ValidationRule[]) || []).filter((item) => !excludedSet.has(item)).map((item) => item.name);
   }
   getValidationRuleUniqueName(name = 'validationRule1') {
     return utils.unique(name, this.getValidationRuleExistingNames(), undefined, false);
@@ -309,23 +269,23 @@ export class BindAttribute extends BaseNode {
    * @internal
    * @param name 验证规则名称，如果不填会自动生成一个唯一名称
    */
-  _insertValidationRuleInRulesAt(name: string, index: number): ValidationRule;
+  _insertValidationRuleAt(name: string, index: number): ValidationRule;
 
   /**
    * 插入验证规则
    * @internal
    * @param validationRuleOptions 验证规则参数
    */
-  _insertValidationRuleInRulesAt(validationRuleOptions: Partial<ValidationRule>, index: number): ValidationRule;
+  _insertValidationRuleAt(validationRuleOptions: Partial<ValidationRule>, index: number): ValidationRule;
 
   /**
    * 插入验证规则
    * @internal
    * @param validationRule 已有的验证规则实例
    */
-  _insertValidationRuleInRulesAt(validationRule: ValidationRule, index: number): ValidationRule;
+  _insertValidationRuleAt(validationRule: ValidationRule, index: number): ValidationRule;
 
-  _insertValidationRuleInRulesAt(options: string | Partial<ValidationRule> | ValidationRule, index: number) {
+  _insertValidationRuleAt(options: string | Partial<ValidationRule> | ValidationRule, index: number) {
     const validationRuleOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'rules' };
     const ValidationRule = getConceptConstructor('ValidationRule');
@@ -370,22 +330,22 @@ export class BindAttribute extends BaseNode {
    * 插入验证规则
    * @param name 验证规则名称，如果不填会自动生成一个唯一名称
    */
-  insertValidationRuleInRulesAt(name: string, index: number): ValidationRule;
+  insertValidationRuleAt(name: string, index: number): ValidationRule;
 
   /**
    * 插入验证规则
    * @param validationRuleOptions 验证规则参数
    */
-  insertValidationRuleInRulesAt(validationRuleOptions: Partial<ValidationRule>, index: number): ValidationRule;
+  insertValidationRuleAt(validationRuleOptions: Partial<ValidationRule>, index: number): ValidationRule;
 
   /**
    * 插入验证规则
    * @param validationRule 已有的验证规则实例
    */
-  insertValidationRuleInRulesAt(validationRule: ValidationRule, index: number): ValidationRule;
+  insertValidationRuleAt(validationRule: ValidationRule, index: number): ValidationRule;
 
-  insertValidationRuleInRulesAt(options: string | Partial<ValidationRule> | ValidationRule, index: number) {
-    const node = this._insertValidationRuleInRulesAt(options as any, index);
+  insertValidationRuleAt(options: string | Partial<ValidationRule> | ValidationRule, index: number) {
+    const node = this._insertValidationRuleAt(options as any, index);
     node.create({
       index,
       parentNode: this,
@@ -399,25 +359,25 @@ export class BindAttribute extends BaseNode {
    * @internal
    * @param name 验证规则名称，如果不填会自动生成一个唯一名称
    */
-  _addValidationRuleInRules(name?: string): ValidationRule;
+  _addValidationRule(name?: string): ValidationRule;
 
   /**
    * 添加验证规则
    * @internal
    * @param validationRuleOptions 验证规则参数
    */
-  _addValidationRuleInRules(validationRuleOptions: Partial<ValidationRule>): ValidationRule;
+  _addValidationRule(validationRuleOptions: Partial<ValidationRule>): ValidationRule;
 
   /**
    * 添加验证规则
    * @internal
    * @param validationRule 已有的验证规则实例
    */
-  _addValidationRuleInRules(validationRule: ValidationRule): ValidationRule;
+  _addValidationRule(validationRule: ValidationRule): ValidationRule;
 
-  _addValidationRuleInRules(options?: string | Partial<ValidationRule> | ValidationRule) {
+  _addValidationRule(options?: string | Partial<ValidationRule> | ValidationRule) {
     const index = this.rules.length;
-    return this._insertValidationRuleInRulesAt(options as any, index);
+    return this._insertValidationRuleAt(options as any, index);
   }
 
   /**
@@ -425,22 +385,22 @@ export class BindAttribute extends BaseNode {
    * @internal
    * @param name 验证规则名称，如果不填会自动生成一个唯一名称
    */
-  addValidationRuleInRules(name?: string): ValidationRule;
+  addValidationRule(name?: string): ValidationRule;
 
   /**
    * 添加验证规则
    * @param validationRuleOptions 验证规则参数
    */
-  addValidationRuleInRules(validationRuleOptions: Partial<ValidationRule>): ValidationRule;
+  addValidationRule(validationRuleOptions: Partial<ValidationRule>): ValidationRule;
 
   /**
    * 添加验证规则
    * @param validationRule 已有的验证规则实例
    */
-  addValidationRuleInRules(validationRule: ValidationRule): ValidationRule;
+  addValidationRule(validationRule: ValidationRule): ValidationRule;
 
-  addValidationRuleInRules(options?: string | Partial<ValidationRule> | ValidationRule) {
-    const node = this._addValidationRuleInRules(options as any);
+  addValidationRule(options?: string | Partial<ValidationRule> | ValidationRule) {
+    const node = this._addValidationRule(options as any);
     const index = this.rules.indexOf(node);
     node.create({
       index,
@@ -455,16 +415,16 @@ export class BindAttribute extends BaseNode {
    * @internal
    * @param logicItemOptions 逻辑项参数
    */
-  _insertItemInPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+  _insertItemAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
 
   /**
    * 插入逻辑项
    * @internal
    * @param logicItem 已有的逻辑项实例
    */
-  _insertItemInPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+  _insertItemAt(logicItem: LogicItem, index: number): LogicItem;
 
-  _insertItemInPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
+  _insertItemAt(options: Partial<LogicItem> | LogicItem, index: number) {
     const logicItemOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'playground' };
     const LogicItem = getConceptConstructor('LogicItem');
@@ -491,16 +451,16 @@ export class BindAttribute extends BaseNode {
    * 插入逻辑项
    * @param logicItemOptions 逻辑项参数
    */
-  insertItemInPlaygroundAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
+  insertItemAt(logicItemOptions: Partial<LogicItem>, index: number): LogicItem;
 
   /**
    * 插入逻辑项
    * @param logicItem 已有的逻辑项实例
    */
-  insertItemInPlaygroundAt(logicItem: LogicItem, index: number): LogicItem;
+  insertItemAt(logicItem: LogicItem, index: number): LogicItem;
 
-  insertItemInPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
-    const node = this._insertItemInPlaygroundAt(options as any, index);
+  insertItemAt(options: Partial<LogicItem> | LogicItem, index: number) {
+    const node = this._insertItemAt(options as any, index);
     node.create({
       index,
       parentNode: this,
@@ -514,34 +474,34 @@ export class BindAttribute extends BaseNode {
    * @internal
    * @param logicItemOptions 逻辑项参数
    */
-  _addItemInPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+  _addItem(logicItemOptions: Partial<LogicItem>): LogicItem;
 
   /**
    * 添加逻辑项
    * @internal
    * @param logicItem 已有的逻辑项实例
    */
-  _addItemInPlayground(logicItem: LogicItem): LogicItem;
+  _addItem(logicItem: LogicItem): LogicItem;
 
-  _addItemInPlayground(options?: Partial<LogicItem> | LogicItem) {
+  _addItem(options?: Partial<LogicItem> | LogicItem) {
     const index = this.playground.length;
-    return this._insertItemInPlaygroundAt(options as any, index);
+    return this._insertItemAt(options as any, index);
   }
 
   /**
    * 添加逻辑项
    * @param logicItemOptions 逻辑项参数
    */
-  addItemInPlayground(logicItemOptions: Partial<LogicItem>): LogicItem;
+  addItem(logicItemOptions: Partial<LogicItem>): LogicItem;
 
   /**
    * 添加逻辑项
    * @param logicItem 已有的逻辑项实例
    */
-  addItemInPlayground(logicItem: LogicItem): LogicItem;
+  addItem(logicItem: LogicItem): LogicItem;
 
-  addItemInPlayground(options?: Partial<LogicItem> | LogicItem) {
-    const node = this._addItemInPlayground(options as any);
+  addItem(options?: Partial<LogicItem> | LogicItem) {
+    const node = this._addItem(options as any);
     const index = this.playground.indexOf(node);
     node.create({
       index,
@@ -551,94 +511,19 @@ export class BindAttribute extends BaseNode {
     return node;
   }
 
-  /**
-   * 删除逻辑项
-   * @param name 逻辑项名称
-   */
-  removeExpression(name: string): void;
-
-  /**
-   * 删除逻辑项
-   * @param expression 已有的逻辑项实例
-   */
-  removeExpression(expression: LogicItem): void;
-
-  removeExpression(options: string | LogicItem) {
-    let expression: LogicItem;
-    if (typeof options === 'string') {
-      expression = this.expression;
-      if (!expression) {
-        throw new Error('找不到逻辑项 ' + options);
-      }
-    } else {
-      expression = options;
-    }
-    return expression.delete();
-  }
-
-  /**
-   * 删除跳转页面
-   * @param name 跳转页面名称
-   */
-  removeDestination(name: string): void;
-
-  /**
-   * 删除跳转页面
-   * @param destination 已有的跳转页面实例
-   */
-  removeDestination(destination: Destination): void;
-
-  removeDestination(options: string | Destination) {
-    let destination: Destination;
-    if (typeof options === 'string') {
-      destination = this.destination;
-      if (!destination) {
-        throw new Error('找不到跳转页面 ' + options);
-      }
-    } else {
-      destination = options;
-    }
-    return destination.delete();
-  }
-
-  /**
-   * 删除跳转到外部链接
-   * @param name 跳转到外部链接名称
-   */
-  removeExternalDestination(name: string): void;
-
-  /**
-   * 删除跳转到外部链接
-   * @param externalDestination 已有的跳转到外部链接实例
-   */
-  removeExternalDestination(externalDestination: ExternalDestination): void;
-
-  removeExternalDestination(options: string | ExternalDestination) {
-    let externalDestination: ExternalDestination;
-    if (typeof options === 'string') {
-      externalDestination = this.externalDestination;
-      if (!externalDestination) {
-        throw new Error('找不到跳转到外部链接 ' + options);
-      }
-    } else {
-      externalDestination = options;
-    }
-    return externalDestination.delete();
-  }
-
   /**
    * 删除验证规则
    * @param name 验证规则名称
    */
-  removeValidationRuleInRules(name: string): void;
+  removeValidationRule(name: string): void;
 
   /**
    * 删除验证规则
    * @param validationRule 已有的验证规则实例
    */
-  removeValidationRuleInRules(validationRule: ValidationRule): void;
+  removeValidationRule(validationRule: ValidationRule): void;
 
-  removeValidationRuleInRules(options: string | ValidationRule) {
+  removeValidationRule(options: string | ValidationRule) {
     let validationRule: ValidationRule;
     if (typeof options === 'string') {
       validationRule = (this.rules as ValidationRule[]).find((item) => item.name === options);
@@ -651,77 +536,59 @@ export class BindAttribute extends BaseNode {
     return validationRule.delete();
   }
 
-  /**
-   * 删除经办人
-   * @param name 经办人名称
-   */
-  removeAssignee(name: string): void;
-
-  /**
-   * 删除经办人
-   * @param assignee 已有的经办人实例
-   */
-  removeAssignee(assignee: Assignee): void;
-
-  removeAssignee(options: string | Assignee) {
-    let assignee: Assignee;
-    if (typeof options === 'string') {
-      assignee = this.assignee;
-      if (!assignee) {
-        throw new Error('找不到经办人 ' + options);
-      }
-    } else {
-      assignee = options;
-    }
-    return assignee.delete();
-  }
-
   /**
    * 删除逻辑项
    * @param logicItem 已有的逻辑项实例
    */
-  removeItemInPlayground(logicItem: LogicItem): void;
+  removeItem(logicItem: LogicItem): void;
 
-  removeItemInPlayground(options: LogicItem) {
+  removeItem(options: LogicItem) {
     let logicItem: LogicItem = options;
     return logicItem.delete();
   }
 
-  __removeLogicItem(logicItem: LogicItem) {
-    const parentKey = logicItem.parentKey;
-    const params: Params = {
-      parentNode: this,
-      parentKey,
-      index: -1,
-      object: null,
-      oldObject: logicItem,
-    };
-    if (parentKey) {
-      params.parentKey = parentKey;
-      // @ts-ignore
-      const t = this.__v_raw || this;
-      // @ts-ignore
-      const n = logicItem.__v_raw || logicItem;
-      if (Array.isArray((t as any)[parentKey])) {
-        // @ts-ignore
-        const index = (t as any)[parentKey].findIndex((el) => (el.__v_raw || el) === n);
-        ~index && (this as any)[parentKey].splice(index, 1);
-        params.index = index;
-      } else {
-        const q = (t as any)[parentKey];
-        if ((q.__v_raw || q) === n) {
-          params.index = 0;
-          (this as any)[parentKey] = undefined;
-        }
-      }
-    }
-    return params;
-  }
-
   //================================================================================
   // ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑   ↑
   // 自动生成的代码已结束。下面可以手动编写。
   //================================================================================
+  /**
+   * 祖先 ViewElement
+   */
+  get viewElement() {
+    return this.getAncestor('ViewElement') as ViewElement;
+  }
+  /**
+   * 祖先 View
+   */
+  get view() {
+    return this.getAncestor('View') as View;
+  }
+  /**
+   * 祖先 Module
+   */
+  get module() {
+    return this.getAncestor('Module') as Module;
+  }
+  /**
+   * 祖先 Frontend
+   */
+  get frontend() {
+    return this.getAncestor('Frontend') as Frontend;
+  }
+  /**
+   * 祖先 ProcessElement
+   */
+  get processElement() {
+    return this.getAncestor('ProcessElement') as ProcessElement;
+  }
+  /**
+   * 祖先 Process
+   */
+  get process() {
+    return this.getAncestor('Process') as Process;
+  }
+
+  toHump = (name: string) => (name ? name.replace(/\-(\w)/g, (all, letter) => letter.toUpperCase()) : '');
 
   onChange($event?: EventPayload): void {
     this.emit('change', $event);
@@ -1084,16 +951,66 @@ export class BindAttribute extends BaseNode {
   *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     const self = this;
     const { name, type, value, rules, expression, playground } = self;
+    const humpName = self.toHump(name);
+
     let code = '';
-    // 业务组件
-    const isBusinessComponent = self.viewElement?.isCorrespondingBusinessComponent;
-    if (isBusinessComponent) {
-      code += `${name}: `;
-    } else if (self?.name === 'data-source' && self?.expression?.concept === 'CallLogic') {
-      code += `() => {\n`;
-    } else {
-      code += '() => {\n';
+    if (!name) {
+      return code;
+    }
+
+    // 过滤掉vusion-的属性
+    if (/^vusion-/.test(name)) {
+      return code;
+    }
+
+    // 不翻译的属性
+    const excludeProps = ['dataSchema', 'key'];
+    if (excludeProps.includes(humpName)) {
+      return code;
+    }
+
+    // feild属性需要特殊处理
+    if (['valueField', 'textField', 'parentField', 'childrenField'].includes(humpName)) {
+      if (type !== 'dynamic') {
+        code += `${self.toHump(name)}: item => item.${value}`;
+      }
+      return code;
+    }
+
+    // 特殊处理dataSource
+    if (['dataSource'].includes(humpName)) {
+      code += `${humpName}: (()`;
+
+      // if (!expression) {
+      code += ': any';
+      // }
+
+      code += ' => {\n';
+
+      if (expression) {
+        // if (expression.concept === 'Identifier') {
+        //   const { name: n } = expression;
+        //   const identifierCode = yield* expression.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+        //   code += `let result: typeof ${identifierCode} extends ((...args: any[]) => any) ? ReturnType<typeof ${identifierCode}> : typeof ${identifierCode};\n`;
+        //   code += `return result;\n`;
+        // } else {
+        //   code += `return `;
+        //   code += yield* expression.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+        //   code += ';\n';
+        // }
+
+        code += `return `;
+        code += yield* expression.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
+        code += ';\n';
+      }
+
+      code += `})()`;
+      return code;
     }
+
+    code += `${humpName}: ((): any => {\n`;
+    code += `return `;
+
     if (['destination', 'externalDestination'].includes(name) && type === 'dynamic') {
       code += yield* (self as any)[name].toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
       code += ';\n';
@@ -1104,7 +1021,7 @@ export class BindAttribute extends BaseNode {
       });
     } else if (expression) {
       code += yield* expression.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
-      code += '\n';
+      code += ';\n';
     } else if (name === 'url' && value) {
       /**
        * ls定制化处理
@@ -1129,90 +1046,24 @@ export class BindAttribute extends BaseNode {
         code += `app.dataSources.${dataSourceName || 'defaultDS'}.entities.${entityName}`;
         code += ';\n';
       }
+    } else if (['static', 'string'].includes(type)) {
+      code +=
+        typeof value === 'boolean'
+          ? value
+          : ['true', 'false'].includes(value)
+          ? value.replace(/'/g, '')
+          : JSON.stringify(value);
+      code += ';\n';
     }
-    if (type === 'dynamic' && !isBusinessComponent) {
+
+    if (type === 'dynamic') {
       yield* wrapForEach(playground, function* warpForEachGenerator(item, index) {
         code += yield* item.toEmbeddedTS(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 }));
         code += ';\n';
       });
     }
-    if (!isBusinessComponent) {
-      code += '\n}';
-    }
-    return code;
-  }
 
-  @withGenerator
-  *toEmbeddedTSVariableDefinition(
-    state = createCompilerState(),
-    attrList?: string[],
-    elementName?: string,
-    currentLevel?: string,
-  ): TranslatorGenerator {
-    const self = this;
-    let code = '';
-    let arrCode = '';
-    code += indent((state?.tabSize || 0) + 3);
-    code += `${attrConvertCamelCase(self.name)}: `;
-    if (self.expression) {
-      if (self.name === 'data-source') {
-        code += `ReturnType<typeof __elements_stashFunctionVariable.${elementName}_${attrConvertCamelCase(self.name)}>`;
-      } else {
-        code += `ReturnType<typeof __elements_stashFunctionVariable.${elementName}_${attrConvertCamelCase(self.name)}>`;
-      }
-      arrCode = `() => {
-        return __elements_variable_function.${currentLevel}?.${attrConvertCamelCase(self.name)}?.()
-      }`;
-    } else if (self.name === 'sorting') {
-      code += `{
-              field: nasl.core.String
-              order: nasl.core.String
-          }`;
-    } else if (self.type === 'static') {
-      let type = 'nasl.core.String';
-      if (typeof self.value === 'number') {
-        type = `${self.value}`.includes('.') ? 'nasl.core.Decimal' : 'nasl.core.Long';
-      } else if (typeof self.value === 'boolean') {
-        type = 'nasl.core.Boolean';
-      } else if (['page-size', 'page-number'].includes(self.name) && self.value === null) {
-        type = 'nasl.core.Long'
-      }
-      code += `${type}`;
-    } else {
-      code += 'undefined';
-    }
-    code += `\n`;
-    if (arrCode.length > 0) {
-      attrList.push(`${elementName}_${attrConvertCamelCase(self.name)}: ${arrCode},\n`);
-    }
-    return code;
-  }
-  @withGenerator
-  *toEmbeddedTSVariableFunctionDefinition(state = createCompilerState()): TranslatorGenerator {
-    const self = this;
-    let code = '';
-    if (self.expression) {
-      code += indent((state?.tabSize || 0) + 4);
-      code += `${attrConvertCamelCase(self.name)}: `;
-      let stashVariable;
-      if (self.name === 'data-source') {
-        const extraParams = {
-          tabSize: 4,
-          inline: true,
-          noNeedParams: true,
-        };
-        stashVariable = `${yield* self.expression.toEmbeddedTS(
-          shiftState(state, code, self?.expression?.concept === 'CallLogic' ? extraParams : {}),
-        )}`;
-      } else {
-        stashVariable = `${yield* self.expression.toEmbeddedTS()}`;
-      }
-      code += `() => {\n`;
-      code += indent((state?.tabSize || 0) + 5);
-      code += `return ${stashVariable}\n`;
-      code += indent((state?.tabSize || 0) + 4);
-      code += `},\n`;
-    }
+    code += `})()`;
     return code;
   }