@lcap/nasl 3.8.2-alpha.2 → 3.8.2-alpha.4

package/src/concepts/MemberExpression__.ts

@@ -8,13 +8,14 @@ import {
   withGenerator,
   TranslatorGenerator,
 } from '../translator';
-import { ComponentCompletionPropertyMap, Enum, TypeAnnotation, BusinessComponent, View } from '..';
+import { Enum, TypeAnnotation, BusinessComponent, View } from '..';
 import { ElementToVueOptions } from './ViewElement__';
 import type Identifier from './Identifier__';
 import BindAttribute, { attrConvertCamelCase } from './BindAttribute__';
 import type Assignment from './Assignment__';
 import type BatchAssignment from './BatchAssignment__';
 import DefaultValue from './DefaultValue__';
+import { config } from '../config';
 
 const Identifier_RE = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 
@@ -138,11 +139,13 @@ export class MemberExpression extends LogicItem {
       }
 
       if (
-        ComponentCompletionPropertyMap[elementTag] &&
-        ComponentCompletionPropertyMap[elementTag][this.property.name] &&
-        ComponentCompletionPropertyMap[elementTag][this.property.name].state
+        config?.allNodesAPI &&
+        config?.allNodesAPI[elementTag] &&
+        config?.allNodesAPI[elementTag].readablePropsMap &&
+        config?.allNodesAPI[elementTag].readablePropsMap[this.property.name] &&
+        config?.allNodesAPI[elementTag].readablePropsMap[this.property.name].state
       ) {
-        const { prop } = ComponentCompletionPropertyMap[elementTag][this.property.name];
+        const { prop } = config?.allNodesAPI[elementTag].readablePropsMap[this.property.name];
         if (!['data'].includes(this.property.name)) {
           return `this && this.__${elementName}_params && this.__${elementName}_params.${this.property.name}`;
         }
@@ -263,11 +266,13 @@ export class MemberExpression extends LogicItem {
       }
 
       if (
-        ComponentCompletionPropertyMap[elementTag] &&
-        ComponentCompletionPropertyMap[elementTag][this.property.name] &&
-        ComponentCompletionPropertyMap[elementTag][this.property.name].state
+        config?.allNodesAPI &&
+        config?.allNodesAPI[elementTag] &&
+        config?.allNodesAPI[elementTag].readablePropsMap &&
+        config?.allNodesAPI[elementTag].readablePropsMap[this.property.name] &&
+        config?.allNodesAPI[elementTag].readablePropsMap[this.property.name].state
       ) {
-        const { prop } = ComponentCompletionPropertyMap[elementTag][this.property.name];
+        const { prop } = config?.allNodesAPI[elementTag].readablePropsMap[this.property.name];
 
         if (!['data'].includes(this.property.name)) {
           return `this['__${elementName}_params'] && this['__${elementName}_params'].${this.property.name}`;
@@ -422,11 +427,13 @@ export class MemberExpression extends LogicItem {
     const prefix = type === 'toVue' ? '' : 'this.';
 
     if (
-      ComponentCompletionPropertyMap[elementTag] &&
-      ComponentCompletionPropertyMap[elementTag][this.property.name] &&
-      ComponentCompletionPropertyMap[elementTag][this.property.name].state
+      config?.allNodesAPI &&
+      config?.allNodesAPI[elementTag] &&
+      config?.allNodesAPI[elementTag].readablePropsMap &&
+      config?.allNodesAPI[elementTag].readablePropsMap[this.property.name] &&
+      config?.allNodesAPI[elementTag].readablePropsMap[this.property.name].state
     ) {
-      const { prop } = ComponentCompletionPropertyMap[elementTag][this.property.name];
+      const { prop } = config?.allNodesAPI[elementTag].readablePropsMap[this.property.name];
 
       if (!['data'].includes(this.property.name)) {
         return `${prefix}__${elementName}_params && ${prefix}__${elementName}_params.${this.property.name}`;

package/src/concepts/OverriddenLogic__.ts

@@ -1769,22 +1769,39 @@ export class OverriddenLogic extends BaseNode {
         ],
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
-            code += `const __${key}_${node?.name} = `;
+            code += `let __${key}_${node?.name}`;
             let itemCode = '';
+            // 匿名数据结构 / 未设置类型的List/map 才进getInitCode
             if (
-              asserts.isNewComposite(itemNode)
-              || asserts.isNewList(itemNode)
-              || asserts.isNewMap(itemNode)
+              (
+                asserts.isNewComposite(itemNode)
+                && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
+              )
+              || (
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                && !(itemNode?.typeAnnotation)
+              )
             ) {
-              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+              code += ' = ';
+              itemCode += yield* itemNode?.getInitCode?.(shiftState(state, code, {
                 inline: true
               })) ??
               returnOrigin('');
+            } else if (asserts.isNewComposite(itemNode) && itemNode.typeAnnotation?.typeKind === 'generic') { // new 带泛型的数据结构/实体 进这里
+              code += ' = ';
+              itemCode += (yield* itemNode?.getNewCompositeCode?.(shiftState(state, code, { inline: true }))) || 'null';
+            } else if ((itemNode as any)?.typeAnnotation && !(asserts.isCallQueryComponent(itemNode) && !itemNode.isAutoInfer())) {
+              code += ': ';
+              code += yield* (itemNode as any)?.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+              returnOrigin('');
             } else {
+              code += ' = ';
               itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
                 returnOrigin('');
             }
-            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            if (itemCode) {
+              code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            }
             code += ';\n';
           }
         },

package/src/concepts/Param__.ts

@@ -329,12 +329,13 @@ export class Param extends BaseNode {
     if (asserts.isFunction(this.defaultExpression) || asserts.isAnonymousFunction(this.defaultExpression)) {
       code += this.defaultValue?.expression || this.defaultExpression ? '?: ' : ': ';
       code += runSync(this.defaultExpression.toEmbeddedTSDefinition(shiftState(state, code)));
-    } else if (!dontType && this.typeAnnotation) {
+    } else if (!dontType && (this.typeAnnotation || this.__TypeAnnotation)) {
+      const typeAnnotation = this.typeAnnotation || this.__TypeAnnotation;
       code += ': ';
-      code += this.typeAnnotation.toNaturalTS(shiftState(state, code));
-      if (this.typeAnnotation?.typeKind !== 'primitive' && this.defaultValue) {
+      code += typeAnnotation.toNaturalTS(shiftState(state, code));
+      if (typeAnnotation?.typeKind !== 'primitive' && this.defaultValue) {
         if (this.isEnum()) {
-          code += `= ${this.typeAnnotation.typeKey}['${this.defaultValue}']`;
+          code += `= ${typeAnnotation.typeKey}['${this.defaultValue}']`;
         }
       }
     }

package/src/concepts/Structure__.ts

@@ -573,10 +573,10 @@ export class Structure extends BaseNode {
         .join(', ')}>`;
     }
 
-    code += ` {`;
-    if (state.descriptionComment && this.description)
-      code += `/* ${this.description} */`;
-    code += '\n';
+    code += ` {\n`;
+    // if (state.descriptionComment && this.description)
+    //   code += `/* ${this.description} */`;
+    // code += '\n';
 
     // code += `${indent(state.tabSize + 1)}__name: '${this.getNamespace()}.${this.name}';\n`;
     this.properties.forEach((property) => {

package/src/concepts/ViewElement__.ts

@@ -27,7 +27,6 @@ import type Identifier from './Identifier__';
 import { PAGE_COMPONENT_INCLUDE_TAG_MAP } from './View__';
 import type BusinessComponent from './BusinessComponent__';
 import type FrontendType from './FrontendType__';
-import { ComponentCompletionPropertyMap } from './View__';
 
 import { kebab2Camel } from '../utils';
 export interface ParseContext {
@@ -2460,12 +2459,7 @@ export class ViewElement extends Annotatable {
 
     if (['u-button', 'u-form', 'u-modal', 'u-table-view', 'u-select', 'u-input', 'u-number-input'].includes(this.tag)) {
       code += indent(state.tabSize + 1);
-      // 登录组件不翻译
-      // if (this.toHump(this.tag) === 'lcapLogin' || this.staticClass === 'login-form') {
-      //     code += `${this.name}: nasl.ui.div;\n`;
-      // } else {
-      code += `${this.name}: nasl.ui.${kebab2Camel(this.tag.replace(/^\w-/, ''))},\n`;
-      // }
+        code += `${this.name}: nasl.ui.${kebab2Camel(this.tag.replace(/^\w-/, ''))},\n`;
     }
 
     if (Array.isArray(this.children)) {

package/src/concepts/View__.ts

@@ -46,6 +46,8 @@ const removedViewElementCache: {
   [key: string]: number | bigint;
 } = {};
 
+import { config } from '../config';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -1857,7 +1859,7 @@ export class View extends Annotatable {
                 document.addEventListener('keydown', this.onKeyDown);
                 document.addEventListener('keyup', this.onKeyUp);
             },
-            beforeDestory() {
+            beforeDestroy() {
                 document.removeEventListener('keydown', this.onKeyDown);
                 document.removeEventListener('keyup', this.onKeyUp);
             },
@@ -2125,7 +2127,7 @@ export class View extends Annotatable {
         if (item.tag === 'template' && item.haveScope()) {
           index += 1;
         }
-        if (ComponentCompletionPropertyMap[item.tag]) {
+        if (config?.allNodesAPI && config?.allNodesAPI[item.tag]?.readablePropsMap) {
           componentList.push(item);
         }
         item.currentIndex = index;
@@ -2359,22 +2361,39 @@ export class View extends Annotatable {
         ],
         function* warpForEachGenerator({ key, node: itemNode }) {
           if (itemNode) {
-            code += `const __${key}_${node?.name} = `;
+            code += `let __${key}_${node?.name}`;
             let itemCode = '';
+            // 匿名数据结构 / 未设置类型的List/map 才进getInitCode
             if (
-              asserts.isNewComposite(itemNode)
-              || asserts.isNewList(itemNode)
-              || asserts.isNewMap(itemNode)
+              (
+                asserts.isNewComposite(itemNode)
+                && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
+              )
+              || (
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode))
+                && !(itemNode?.typeAnnotation)
+              )
             ) {
-              itemCode += yield* itemNode?.getInitCode(shiftState(state, code, {
+              code += ' = ';
+              itemCode += yield* itemNode?.getInitCode?.(shiftState(state, code, {
                 inline: true
               })) ??
                 returnOrigin('');
+            } else if (asserts.isNewComposite(itemNode) && itemNode.typeAnnotation?.typeKind === 'generic') { // new 带泛型的数据结构/实体 进这里
+              code += ' = ';
+              itemCode += (yield* itemNode?.getNewCompositeCode?.(shiftState(state, code, { inline: true }))) || 'null';
+            } else if ((itemNode as any)?.typeAnnotation && !(asserts.isCallQueryComponent(itemNode) && !itemNode.isAutoInfer())) {
+              code += ': ';
+              code += yield* (itemNode as any)?.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                returnOrigin('');
             } else {
+              code += ' = ';
               itemCode = yield* itemNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
                 returnOrigin('');
             }
-            code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            if (itemCode) {
+              code += yield* self.getRightCode(itemCode, assignment, itemNode);
+            }
             code += ';\n';
           }
         },
@@ -2572,20 +2591,35 @@ export class View extends Annotatable {
         code += ';\n';
       });
       if (this.variables.length) code += '\n';
+      if (!callback) {
+        this.bindEvents.forEach((bindEvent) => {
+          bindEvent.logics.forEach((logic) => {
+            const logicCode = logic.toNaturalTS(
+              shiftState(state, code, {
+                tabSize: state.tabSize + 1,
+                // declaration: true,
+                autoPrefixName: true,
+              })
+            );
+            code += logicCode.replace('function ', 'private function ');
+            code += '\n';
+          });
+          if (bindEvent.logics.length) code += '\n';
+        });
 
-      this.logics.forEach((logic) => {
-        const logicCode = logic.toNaturalTS(
-          shiftState(state, code, {
-            tabSize: state.tabSize + 1,
-            declaration: true,
-            autoPrefixName: true,
-          })
-        );
-        code += logicCode.replace('declare function', 'function');
-        code += '\n';
-      });
-      if (this.logics.length) code += '\n';
-
+        this.logics.forEach((logic) => {
+          const logicCode = logic.toNaturalTS(
+            shiftState(state, code, {
+              tabSize: state.tabSize + 1,
+              declaration: true,
+              autoPrefixName: true,
+            })
+          );
+          code += logicCode.replace('declare function', 'function');
+          code += '\n';
+        });
+        if (this.logics.length) code += '\n';
+      }
       if (callback) {
         code += callback.call(this, state);
       } else {

package/src/concepts/basics/stdlib/nasl.processV2.ts

@@ -378,6 +378,51 @@ export function initialize() {
         }),
       ],
     }),
+    new Structure({
+      name: 'TaskInst',
+      properties: [
+        new StructureProperty({
+          name: 'processDefUniqueKey',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'processDefinitionId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'processInstanceId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'taskDefName',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'taskTitle',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'taskId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'completeBy',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'finished',
+          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+        }),
+        new StructureProperty({
+          name: 'createTime',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+        new StructureProperty({
+          name: 'completeTime',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+    }),
   );
 
   processV2TypeList.push(
@@ -820,6 +865,24 @@ export function initialize() {
       ],
       returns: [],
     }),
+    new Logic({
+      name: 'getUsersForAddSign',
+      description: '查询可加签用户列表',
+      params: [
+        new Param({
+          name: 'taskId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+      returns: [
+        new Return({
+          name: 'result',
+          typeAnnotation: TypeAnnotation.createGeneric('List', {
+            typeArguments: [TypeAnnotation.createReference('LCAPUser', { typeNamespace: 'nasl.processV2' })],
+          }),
+        }),
+      ],
+    }),
     new Logic({
       name: 'terminateProcess',
       description: '终止',
@@ -919,6 +982,22 @@ export function initialize() {
         }),
       ],
     }),
+    new Logic({
+      name: 'getTaskInfo',
+      description: '查询流程任务信息',
+      params: [
+        new Param({
+          name: 'taskId',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+      returns: [
+        new Return({
+          name: 'result',
+          typeAnnotation: TypeAnnotation.createReference('TaskInst', { typeNamespace: 'nasl.processV2' }),
+        }),
+      ],
+    }),
   ];
 
   const processComponents = [

package/src/generator/genBundleFiles.ts

@@ -860,7 +860,7 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
         if (window.annotationAllData) {
               resolve(window.annotationAllData);
           } else {
-           let sysPrefixPath =  window.appInfo && window.appInfo.sysPrefixPath || '';
+           let sysPrefixPath =  ${ config?.sysPrefixPath ? "'" + config?.sysPrefixPath + "'" : "'" + "'" } ||'';
            let urlEntity = sysPrefixPath + '/api/system/annotation/entityAll'
            let urlLogic = sysPrefixPath + '/api/system/annotation/logicAll'
            Promise.all([

package/src/natural/genNaturalTS.ts

@@ -27,10 +27,10 @@ import {
   getConnectorsCode,
   getDependenciesCode,
   getFrontendViewsCode,
+  getCurrentComponentDeclaration,
   wrapTSBlock,
 } from './getContext';
 import { createCompilerState } from '../translator';
-import { fr } from 'date-fns/locale';
 
 export * as getNaturalContext from './getContext';
 
@@ -66,11 +66,12 @@ export function genNaturalTSContextJSONForLogic(
       description: string;
       tsDescription: string;
     }[];
-  }
+  },
+  restParams?: any
 ) {
   const frontend = currentNode?.getAncestor('Frontend') as Frontend;
   const logicType = currentNode?.parentNode?.concept === 'App' ? 'global_logic' : 'view_logic';
-  const state = createCompilerState('', { descriptionComment: true });
+  const state = createCompilerState('', { descriptionComment: true, typeMap: restParams?.typeMap });
 
   const { naslCore } = getNaslCore(logicType);
   const { naslUtil } = getNaslUtil();
@@ -113,8 +114,8 @@ export function genNaturalTSContextJSONForLogic(
   const { backendVariables } = getServerVariables(app, state);
 
   const { views } = getFrontendViews(frontend, state, currentNode, false);
-  const { currentLogic } = getCurrentNodeContext(currentNode, focusedNodePath, experimental);
-
+  const { currentLogic } = getCurrentNodeContext(currentNode, focusedNodePath, experimental, restParams?.typeMap);
+  const { componentDeclaration } = getCurrentComponentDeclaration(currentNode, components);
   return {
     naslCore,
     naslUtil,
@@ -133,6 +134,7 @@ export function genNaturalTSContextJSONForLogic(
     views,
     currentLogic,
     logicType,
+    componentDeclaration
   };
 }
 
@@ -166,13 +168,14 @@ export const genNaturalTSContextFromJSONForLogic = (
     views,
     currentLogic,
     logicType,
+    componentDeclaration
   } = tsContextJSON;
 
   let code = '';
-  code += '### [1] 标准库\n';
+  code += '### [1]标准库与类型定义\n';
   code += wrapTSBlock(naslCore);
 
-  code += '\n### [2] nasl.util\n';
+  code += '\n### [2]平台内置函数库\n';
   code += wrapTSBlock(naslUtil);
 
   if (naslUI && logicType === 'view_logic') {
@@ -182,10 +185,14 @@ export const genNaturalTSContextFromJSONForLogic = (
     } else {
       code += getNaslUICode(naslUI, codeType, requiredIndexes);
     }
+    if (componentDeclaration) {
+      code += '\n#### [3-1] 组件声明\n';
+      code += wrapTSBlock(`declare namespace nasl.ui {\n${componentDeclaration}}`);
+    }
   }
 
   if (naslOql && logicType === 'global_logic') {
-    code += '\n### [4] nasl.oql\n';
+    code += '\n### [4]数据查询定义\n';
     code += wrapTSBlock(naslOql);
   }
 
@@ -265,7 +272,8 @@ export function genNaturalTSContextForLogic(
     }[];
   },
   restParams?: {
-    codeType?: 'detail' | 'short';
+    codeType: 'detail' | 'short';
+    typeMap?: any;
   }
 ) {
   const tsContextJSON = genNaturalTSContextJSONForLogic(
@@ -273,11 +281,12 @@ export function genNaturalTSContextForLogic(
     currentNode,
     focusedNodePath,
     experimental,
-    material
+    material,
+    restParams
   );
   const code = genNaturalTSContextFromJSONForLogic(
     tsContextJSON,
-    restParams.codeType,
+    restParams?.codeType || 'short',
     requiredIndexes
   );
   return code;
@@ -303,17 +312,19 @@ export function genNaturalTSContextJSONForUI(
     moduleInterfaces: any;
     connectors: any;
     dependencies: any;
-  }
+  },
+  restParams?: any
 ) {
   const frontend = currentNode.getAncestor('Frontend') as Frontend;
-  const state = createCompilerState('', { descriptionComment: true, needNamespace: true });
+  const state = createCompilerState('', { descriptionComment: true, needNamespace: true, typeMap: restParams?.typeMap });
 
   const { naslCore } = getNaslCore('view_logic');
   const { naslUtil } = getNaslUtil();
-  const { naslUI } = getNaslUI(app, frontend.type, {
+  const { naslUI } = getNaslUIOld();
+  const components = getNaslUI(app, frontend.type, {
     basicMaterials: material?.basicMaterials,
     extensionMaterials: material?.extensionMaterials,
-  });
+  }).naslUI;
   const { enums } = getEnums(app, state);
   const { entities } = getEntities(app, state);
   const { structures } = getStructures(app, state);
@@ -330,12 +341,15 @@ export function genNaturalTSContextJSONForUI(
   );
   const { frontendVariables } = getFrontendVariables(frontend, state);
   const { views } = getFrontendViews(frontend, state, currentNode, false);
-  const { currentLogic } = getCurrentNodeContextForUI(currentNode);
+  const { currentLogic } = getCurrentNodeContextForUI(currentNode, restParams?.typeMap);
+  const { componentDeclaration } = getCurrentComponentDeclaration(currentNode, components);
 
   return {
     naslCore,
     naslUtil,
     naslUI,
+    components,
+    componentDeclaration,
     enums,
     entities,
     structures,
@@ -364,7 +378,8 @@ export const genNaturalTSContextFromJSONForUI = (
   const {
     naslCore,
     naslUtil,
-    naslUI,
+    components,
+    componentDeclaration,
     enums,
     entities,
     structures,
@@ -377,18 +392,18 @@ export const genNaturalTSContextFromJSONForUI = (
   } = tsContextJSON;
 
   let code = '';
-  code += '### [1] 标准库\n';
+  code += '### [1] 标准库与类型定义\n';
   code += wrapTSBlock(naslCore);
 
-  code += '\n### [2] nasl.util\n';
+  code += '\n### [2] 平台内置函数库\n';
   code += wrapTSBlock(naslUtil);
 
-  if (naslUI) {
+  if (components) {
     code += '\n### [3] nasl.ui\n';
-    if (typeof naslUI === 'string') {
-      code += wrapTSBlock(naslUI);
-    } else {
-      code += getNaslUICode(naslUI, codeType, requiredIndexes);
+    code += getNaslUICode(components, codeType, requiredIndexes);
+    if (componentDeclaration) {
+      code += '\n#### [3-1] 组件声明\n';
+      code += wrapTSBlock(`declare namespace nasl.ui {\n${componentDeclaration}\n}`);
     }
   }
 
@@ -459,13 +474,14 @@ export function genNaturalTSContextForUI(
     dependencies: any;
   },
   restParams?: {
-    codeType?: 'detail' | 'short';
+    codeType: 'detail' | 'short';
+    typeMap?: any;
   }
 ) {
-  const tsContextJSON = genNaturalTSContextJSONForUI(app, currentNode, material);
+  const tsContextJSON = genNaturalTSContextJSONForUI(app, currentNode, material, restParams);
   const code = genNaturalTSContextFromJSONForUI(
     tsContextJSON,
-    restParams.codeType,
+    restParams?.codeType || 'short',
     requiredIndexes
   );
   return code;

package/src/natural/getContext/getUILib.ts

@@ -50,7 +50,10 @@ export function handleMaterial({ json, tsDeclaration }: { json: Array<{ name: st
   snippets.forEach((code) => {
     const cap = code.match(/class ([a-zA-Z]+).+?extends ViewComponent/);
     if (cap) {
-      snippetMap[cap[1]] = `declare namespace nasl.ui${code}`;
+      const newCode = code
+        .replace(/nasl\.core\./g, "")
+        .replace(/Integer/g, "Long");
+      snippetMap[cap[1]] = `declare namespace nasl.ui${newCode}`;
     }
   });
   json.forEach((item) => {
@@ -79,12 +82,12 @@ export function getPreDeclaration() {
   /// #if process.env.BUILD_TARGET === 'node'
   if (globalThis.process) { // For TS build
     const fs = require('fs');
-    code = fs.readFileSync(require.resolve(`../../../sandbox-natural/stdlib/nasl.ui.pre.d.ts`), 'utf8');
+    code = fs.readFileSync(require.resolve(`../../../sandbox-natural/stdlib/nasl.ui.d.ts`), 'utf8');
   }
   /// #endif
   /// #if process.env.BUILD_TARGET !== 'node'
   if (globalThis.window) { // For TS build
-    code = require('!!raw-loader!../../../sandbox-natural/stdlib/nasl.ui.pre.d.ts').default;
+    code = require('!!raw-loader!../../../sandbox-natural/stdlib/nasl.ui.d.ts').default;
   }
   /// #endif
   return code;