@lcap/nasl 3.4.0-beta.6 → 3.5.0-alpha.1

package/src/concepts/OverriddenLogic__.ts

@@ -18,20 +18,20 @@ import {
   TranslatorGenerator,
 } from '../translator';
 import { waitOqlQueryComponentChildrenFinish } from '../common';
-import Namespace from './Namespace__';
-import CallQueryComponent from './CallQueryComponent__';
-import ForEachStatement from './ForEachStatement__';
-import Assignment from './Assignment__';
-import Identifier from './Identifier__';
-import BindEvent from './BindEvent__';
-import BatchAssignment from './BatchAssignment__';
-import OqlQueryComponent from './OqlQueryComponent__';
-import Match from './Match__';
-import MatchCase from './MatchCase__';
-import TypeAnnotation from './TypeAnnotation__';
-import CallInterface from './CallInterface__';
-import CallLogic from './CallLogic__';
-import Logic from './Logic__';
+import type Namespace from './Namespace__';
+import type CallQueryComponent from './CallQueryComponent__';
+import type ForEachStatement from './ForEachStatement__';
+import type Assignment from './Assignment__';
+import type Identifier from './Identifier__';
+import type BindEvent from './BindEvent__';
+import type BatchAssignment from './BatchAssignment__';
+import type OqlQueryComponent from './OqlQueryComponent__';
+import type Match from './Match__';
+import type MatchCase from './MatchCase__';
+import type TypeAnnotation from './TypeAnnotation__';
+import type CallInterface from './CallInterface__';
+import type CallLogic from './CallLogic__';
+import type Logic from './Logic__';
 import type Interface from './Interface__';
 
 //================================================================================
@@ -39,36 +39,36 @@ import type Interface from './Interface__';
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } 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 Transactional from './Transactional__';
-import TypeParam from './TypeParam__';
-import Param from './Param__';
-import Return from './Return__';
-import Variable from './Variable__';
-import LogicItem from './LogicItem__';
-import Module from './Module__';
-import View from './View__';
-import ProcessElement from './ProcessElement__';
-import App from './App__';
-import Frontend from './Frontend__';
-import Process from './Process__';
+import type Transactional from './Transactional__';
+import type TypeParam from './TypeParam__';
+import type Param from './Param__';
+import type Return from './Return__';
+import type Variable from './Variable__';
+import type LogicItem from './LogicItem__';
+import type Module from './Module__';
+import type View from './View__';
+import type ProcessElement from './ProcessElement__';
+import type App from './App__';
+import type Frontend from './Frontend__';
+import type Process from './Process__';
 
 /**
  * 覆写逻辑
  */
-@className
 @concept('覆写逻辑')
-// @ts-ignore
 export class OverriddenLogic extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'OverriddenLogic';
+  static readonly ConceptName: string = 'OverriddenLogic';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -81,35 +81,30 @@ export class OverriddenLogic extends BaseNode {
    * 覆写的模块
    */
   @property()
-  // @ts-ignore
   overriddenModule!: string;
 
   /**
    * 覆写逻辑名称
    */
   @property()
-  // @ts-ignore
   name!: string;
 
   /**
    * 覆写逻辑描述
    */
   @property()
-  // @ts-ignore
   description!: string;
 
   /**
    * 触发方式
    */
   @property()
-  // @ts-ignore
   triggerType!: string;
 
   /**
    * 定时任务表达式
    */
   @property()
-  // @ts-ignore
   cron!: string;
 
   /**
@@ -118,7 +113,6 @@ export class OverriddenLogic extends BaseNode {
   @property({
     objectRef: 'Transactional',
   })
-  // @ts-ignore
   transactional!: Transactional;
 
   /**
@@ -350,6 +344,7 @@ export class OverriddenLogic extends BaseNode {
   _insertTypeParamAt(options: string | Partial<TypeParam> | TypeParam, index: number) {
     const typeParamOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'typeParams' };
+    const TypeParam = getConceptConstructor('TypeParam');
     let typeParam: TypeParam;
     if (!options) {
       typeParam = TypeParam.from(
@@ -369,7 +364,7 @@ export class OverriddenLogic extends BaseNode {
         this,
         'typeParams',
       );
-    } else if (options instanceof TypeParam) {
+    } else if (asserts.isTypeParam(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       typeParam = options;
       Object.assign(typeParam, relationOptions);
@@ -499,6 +494,7 @@ export class OverriddenLogic extends BaseNode {
   _insertParamAt(options: string | Partial<Param> | Param, index: number) {
     const paramOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'params' };
+    const Param = getConceptConstructor('Param');
     let param: Param;
     if (!options) {
       param = Param.from(
@@ -518,7 +514,7 @@ export class OverriddenLogic extends BaseNode {
         this,
         'params',
       );
-    } else if (options instanceof Param) {
+    } else if (asserts.isParam(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       param = options;
       Object.assign(param, relationOptions);
@@ -648,6 +644,7 @@ export class OverriddenLogic extends BaseNode {
   _insertReturnAt(options: string | Partial<Return> | Return, index: number) {
     const retOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'returns' };
+    const Return = getConceptConstructor('Return');
     let ret: Return;
     if (!options) {
       ret = Return.from(
@@ -667,7 +664,7 @@ export class OverriddenLogic extends BaseNode {
         this,
         'returns',
       );
-    } else if (options instanceof Return) {
+    } else if (asserts.isReturn(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       ret = options;
       Object.assign(ret, relationOptions);
@@ -797,6 +794,7 @@ export class OverriddenLogic extends BaseNode {
   _insertVariableAt(options: string | Partial<Variable> | Variable, index: number) {
     const variableOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'variables' };
+    const Variable = getConceptConstructor('Variable');
     let variable: Variable;
     if (!options) {
       variable = Variable.from(
@@ -816,7 +814,7 @@ export class OverriddenLogic extends BaseNode {
         this,
         'variables',
       );
-    } else if (options instanceof Variable) {
+    } else if (asserts.isVariable(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       variable = options;
       Object.assign(variable, relationOptions);
@@ -935,8 +933,9 @@ export class OverriddenLogic extends BaseNode {
   _insertItemInBodyAt(options: Partial<LogicItem> | LogicItem, index: number) {
     const logicItemOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'body' };
+    const LogicItem = getConceptConstructor('LogicItem');
     let logicItem: LogicItem;
-    if (options instanceof LogicItem) {
+    if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);
@@ -1035,8 +1034,9 @@ export class OverriddenLogic extends BaseNode {
   _insertItemInPlaygroundAt(options: Partial<LogicItem> | LogicItem, index: number) {
     const logicItemOptions: any = {};
     const relationOptions = { parentNode: this, parentKey: 'playground' };
+    const LogicItem = getConceptConstructor('LogicItem');
     let logicItem: LogicItem;
-    if (options instanceof LogicItem) {
+    if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);
@@ -1475,6 +1475,7 @@ export class OverriddenLogic extends BaseNode {
    * 创建的时候 打开事务 通过开关设置数据库事务
    */
   openTransactional(flag: boolean) {
+    const Transactional = getConceptConstructor('Transactional');
     if (flag) {
       const transactional = new Transactional({
         enabled: flag,
@@ -1546,7 +1547,7 @@ export class OverriddenLogic extends BaseNode {
     if (Array.isArray(this.params)) {
       this.params.forEach((param) => {
         code += `${indent((state?.tabSize || 0) + 1)}`;
-        code += param.toJS(shiftState(state, code, { inline: true }));
+        code += param.toJS(state);
         code += ';\n';
       });
     }
@@ -1554,7 +1555,7 @@ export class OverriddenLogic extends BaseNode {
     if (Array.isArray(this.variables)) {
       this.variables.forEach((variable) => {
         code += `${indent((state?.tabSize || 0) + 1)}let `;
-        code += variable.toJS(shiftState(state, code, { inline: true }));
+        code += variable.toJS(state);
         code += ';\n';
       });
     }
@@ -1563,7 +1564,7 @@ export class OverriddenLogic extends BaseNode {
     if (Array.isArray(this.returns)) {
       this.returns.forEach((ret) => {
         code += `${indent((state?.tabSize || 0) + 1)}let `;
-        code += ret.toJS(shiftState(state, code, { inline: true }));
+        code += ret.toJS(state);
         code += ';\n';
       });
     }
@@ -1744,14 +1745,15 @@ export class OverriddenLogic extends BaseNode {
         }
       } else if (
         self.body.length <= 2 &&
-        !(self.parentNode instanceof Namespace) &&
-        !(self.parentNode instanceof Process)
+        !asserts.isNamespace(self.parentNode) &&
+        !asserts.isProcess(self.parentNode)
       ) {
         code += indent((state?.tabSize || 0) + 1);
         code += `${indent(state?.tabSize || 0 + 4)}const __LogicEmpty: any = null;`;
       }
       yield* wrapForEach(self.body, function* warpForEachGenerator(item) {
-        code += yield* item.toEmbeddedTS?.(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 })) ?? returnOrigin('');
+        code += yield* item.toEmbeddedTS?.(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 })) ??
+          returnOrigin('');
         code += ';\n';
       });
     }
@@ -1807,8 +1809,8 @@ export class OverriddenLogic extends BaseNode {
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
     const needGetSourceMapOqlList: Promise<any>[] = [];
     yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (el && (el instanceof BatchAssignment || (el instanceof Assignment && el.left?.name))) {
-        if (el instanceof Assignment) {
+      if (el && (asserts.isBatchAssignment(el) || (asserts.isAssignment(el) && el.left?.name))) {
+        if (asserts.isAssignment(el)) {
           const advanceVar = self.variables?.find(
             (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
           );
@@ -1819,12 +1821,13 @@ export class OverriddenLogic extends BaseNode {
           if (advanceRn && !advanceMap.get(advanceRn)) {
             advanceMap.set(advanceRn, el);
           }
-        } else if (el instanceof BatchAssignment) {
+        } else if (asserts.isBatchAssignment(el)) {
           yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
             const leftCode =
               leftIndex.length === 1
                 ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-                : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
+                : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                    returnOrigin('');
             const advanceVar = self.variables?.find(
               (variable) => !variable.typeAnnotation && leftCode === variable.name,
             );
@@ -1842,7 +1845,8 @@ export class OverriddenLogic extends BaseNode {
     // 兼容 return 没有类型情况
     if (self.returns.length && self.returns[0].typeAnnotation) {
       code += ': ';
-      code += yield* self.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
+      code += yield* self.returns[0].typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+        returnOrigin('');
     }
     code += '{\n';
     // 用于虚拟节点的查找引用
@@ -1871,12 +1875,13 @@ export class OverriddenLogic extends BaseNode {
       code += `${indent((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
       code += `${indent((state?.tabSize || 0) + 1)}let `;
       code += yield* node.toEmbeddedTS(shiftState(state, code, { inline: true }));
-      if (assignment instanceof BatchAssignment) {
+      if (asserts.isBatchAssignment(assignment)) {
         yield* wrapForEach(assignment.assignmentLines, function* warpForEachGenerator({ leftIndex, rightIndex }) {
           const leftCode =
             leftIndex.length === 1
               ? yield* assignment.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-              : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
+              : yield* assignment.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                  returnOrigin('');
           if (leftCode === node.name) {
             const rightNode: any =
               rightIndex.length === 1
@@ -1885,13 +1890,15 @@ export class OverriddenLogic extends BaseNode {
             // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
             if (
               rightNode?.typeAnnotation &&
-              !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')
+              !(asserts.isCallQueryComponent(rightNode) && rightNode.ideVersion !== '2.11')
             ) {
               code += ': ';
-              code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('null');
+              code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                returnOrigin('null');
             } else {
               code += ' = ';
-              const rightCode = yield* rightNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('');
+              const rightCode = yield* rightNode?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+                returnOrigin('');
               code += yield* self.getRightCode(rightCode, assignment, rightNode);
             }
           }
@@ -1915,17 +1922,18 @@ export class OverriddenLogic extends BaseNode {
         // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
         if (
           rightNode?.typeAnnotation &&
-          !(rightNode instanceof CallQueryComponent && rightNode.ideVersion !== '2.11')
+          !(asserts.isCallQueryComponent(rightNode) && rightNode.ideVersion !== '2.11')
         ) {
           code += ': ';
-          code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ?? returnOrigin('null');
+          code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
+            returnOrigin('null');
         } else {
           code += ' = ';
           let rightCode = '';
           // 因为右侧枚举要赋值就得new 一下；
           if (
             rightNode &&
-            rightNode instanceof Identifier &&
+            asserts.isIdentifier(rightNode) &&
             rightNode.namespace &&
             rightNode.namespace.endsWith('enums')
           ) {
@@ -1944,12 +1952,13 @@ export class OverriddenLogic extends BaseNode {
       code += `${indent((state?.tabSize || 0) + 1)}return ${self.returns[0].name};\n`;
     } else {
       // 如果长度小于2 并且不是虚拟节点就 加 报错，
-      if (self.body.length <= 2 && !(self.parentNode instanceof Namespace)) {
+      if (self.body.length <= 2 && !asserts.isNamespace(self.parentNode)) {
         code += indent((state?.tabSize || 0) + 1);
         code += 'const __LogicEmpty: any = null;';
       }
       yield* wrapForEach(self.body, function* warpForEachGenerator(item) {
-        code += yield* item.toEmbeddedTS?.(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 })) ?? returnOrigin('');
+        code += yield* item.toEmbeddedTS?.(shiftState(state, code, { tabSize: (state?.tabSize || 0) + 1 })) ??
+          returnOrigin('');
         code += ';\n';
       });
     }
@@ -1968,10 +1977,10 @@ export class OverriddenLogic extends BaseNode {
 
   *getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any) {
     code = code.replaceAll('\n', ' ');
-    if (assignment instanceof Assignment && !assignment.right) return code;
+    if (asserts.isAssignment(assignment) && !assignment.right) return code;
 
     // 调用接口，参数替换成 null
-    if (rightNode instanceof CallInterface) {
+    if (asserts.isCallInterface(rightNode)) {
       const { _interface } = rightNode.getModuleInterface();
       return _interface
         ? `${rightNode.tsCalleeKey}(${(_interface as Interface).params.map(() => 'null').join(',')})`
@@ -1979,7 +1988,7 @@ export class OverriddenLogic extends BaseNode {
     }
 
     // 调用服务端逻辑，参数替换成 null
-    if (rightNode instanceof CallLogic && rightNode.calleeNamespace === 'app.logics') {
+    if (asserts.isCallLogic(rightNode) && rightNode.calleeNamespace === 'app.logics') {
       const calleeName = rightNode?.calleeName;
       const calleeLogic = this.app.logics.find((l) => l.name === calleeName);
       return calleeLogic ? `app.logics.${calleeName}(${calleeLogic.params.map(() => 'null').join(',')})` : null;
@@ -2043,7 +2052,7 @@ export class OverriddenLogic extends BaseNode {
     if (code.includes(expressionTsCode)) {
       let typeCode = '';
       yield* wrapForEach(matchCase.patterns, function* wrapForEach(pattern, index) {
-        if (pattern instanceof TypeAnnotation) {
+        if (asserts.isTypeAnnotation(pattern)) {
           if (index === 0) {
             typeCode += yield* pattern.toEmbeddedTS();
           } else {
@@ -2132,7 +2141,7 @@ export class OverriddenLogic extends BaseNode {
    */
   getEmbeddedFilePath(name = this.name) {
     let _path = this.module ? `/${this.module.parentKey}/${this.module.name}` : '';
-    if (this.parentNode instanceof FrontendLibrary) {
+    if (asserts.isFrontendLibrary(this.parentNode)) {
       _path += `/frontends/${this.parentNode.type}`;
     }
     return `/embedded/${this.app.name}${_path}/overriddenLogics/${name}.ts`;
@@ -2181,7 +2190,7 @@ export class OverriddenLogic extends BaseNode {
     const set = new Set();
     utils.traverse(
       ({ node }) => {
-        if (node instanceof CallQueryComponent) {
+        if (asserts.isCallQueryComponent(node)) {
           set.add(node);
         }
       },
@@ -2198,6 +2207,7 @@ export class OverriddenLogic extends BaseNode {
 
   // 通过开关设置数据库事务
   setTransactionEnabled(flag: boolean) {
+    const Transactional = getConceptConstructor('Transactional');
     this.setTransactional(
       new Transactional({
         enabled: flag,
@@ -2253,7 +2263,7 @@ export class OverriddenLogic extends BaseNode {
 
   // 获取bindEvent下的logic的名称
   getEventLogicName(type?: string) {
-    if (this.parentNode instanceof BindEvent) {
+    if (asserts.isBindEvent(this.parentNode)) {
       if (type === 'chinese') {
         const bindEvent = this.parentNode;
         const bindChineseName = bindEvent.getPageViewEventChineseName();

package/src/concepts/Param__.ts

@@ -10,18 +10,18 @@ import {
   TranslatorGenerator,
 } from '../translator';
 import LogicItem from './LogicItem__';
-import EntityProperty from './EntityProperty__';
-import Structure from './Structure__';
-import StructureProperty from './StructureProperty__';
-import Function from './Function__';
-import AnonymousFunction from './AnonymousFunction__';
+import type EntityProperty from './EntityProperty__';
+import type Structure from './Structure__';
+import type StructureProperty from './StructureProperty__';
+import type Function from './Function__';
+import type AnonymousFunction from './AnonymousFunction__';
 
 function tryJSONParse(str: string) {
   let result;
 
   try {
     result = JSON.parse(str);
-  } catch (e) { }
+  } catch (e) {}
 
   return result;
 }
@@ -30,34 +30,34 @@ function tryJSONParse(str: string) {
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } 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 TypeAnnotation from './TypeAnnotation__';
-import DefaultValue from './DefaultValue__';
-import Logic from './Logic__';
-import View from './View__';
-import Module from './Module__';
-import App from './App__';
-import Connector from './Connector__';
-import Frontend from './Frontend__';
-import ProcessElement from './ProcessElement__';
-import Process from './Process__';
+import type TypeAnnotation from './TypeAnnotation__';
+import type DefaultValue from './DefaultValue__';
+import type Logic from './Logic__';
+import type View from './View__';
+import type Module from './Module__';
+import type App from './App__';
+import type Connector from './Connector__';
+import type Frontend from './Frontend__';
+import type ProcessElement from './ProcessElement__';
+import type Process from './Process__';
 
 /**
  * 输入参数
  */
-@className
 @concept('输入参数')
-// @ts-ignore
 export class Param extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'Param';
+  static readonly ConceptName: string = 'Param';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -70,14 +70,12 @@ export class Param extends BaseNode {
    * 输入参数名称
    */
   @property()
-  // @ts-ignore
   name!: string;
 
   /**
    * 输入参数描述
    */
   @property()
-  // @ts-ignore
   description!: string;
 
   /**
@@ -86,14 +84,12 @@ export class Param extends BaseNode {
   @property({
     objectRef: 'TypeAnnotation',
   })
-  // @ts-ignore
   typeAnnotation!: TypeAnnotation;
 
   /**
    * 是否必填
    */
   @property()
-  // @ts-ignore
   required!: boolean;
 
   /**
@@ -102,7 +98,6 @@ export class Param extends BaseNode {
   @property({
     objectRef: 'DefaultValue',
   })
-  // @ts-ignore
   defaultValue!: DefaultValue;
 
   /**
@@ -344,13 +339,13 @@ export class Param extends BaseNode {
   @property()
   useComponent: {
     type:
-    | 's-member-identifier-select'
-    | 's-enum-select'
-    | 's-schema-select'
-    | 's-datatype-select'
-    | 's-config-select'
-    | 's-options-select'
-    | 's-bidirectional-bind-switch';
+      | 's-member-identifier-select'
+      | 's-enum-select'
+      | 's-schema-select'
+      | 's-datatype-select'
+      | 's-config-select'
+      | 's-options-select'
+      | 's-bidirectional-bind-switch';
     attrs?: any;
   } = undefined;
 
@@ -374,8 +369,7 @@ export class Param extends BaseNode {
         code += `this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}',`;
       }
 
-      const expressionJS = this.defaultValue?.expression?.toJS?.() || `""`;
-      const { typeKind, typeName } = typeAnnotation || {};
+      const expressionJS = this.defaultValue?.toJS?.();
 
       code += `${this.name} || (this.$route.query.hasOwnProperty('${this.name}') ? this.$genInitFromSchema('${typeAnnotation?.sortedTypeKey}', this.$route.query.${this.name}) : ${expressionJS})`;
       if (needGenInitFromSchema) {
@@ -414,15 +408,21 @@ export class Param extends BaseNode {
       code += '}';
       return code;
     }
-
-    if (self.defaultExpression instanceof Function || self.defaultExpression instanceof AnonymousFunction) {
+    const { typeNamespace, typeName } = self.typeAnnotation || {};
+    let typeKey = self.typeAnnotation?.typeKey;
+    if (typeNamespace?.endsWith('.metadataTypes')) {
+      const referenceNode = this.app?.findNodeByCompleteName(typeNamespace + '.' + typeName);
+      const { typeAnnotation } = referenceNode || {};
+      typeKey = `${typeAnnotation.typeNamespace}.${typeAnnotation.typeName}`;
+    }
+    if (asserts.isFunction(self.defaultExpression) || asserts.isAnonymousFunction(self.defaultExpression)) {
       code += self.required ? ': ' : '?: ';
       code += yield* self.defaultExpression.toEmbeddedTSDefinition(shiftState(state, code));
     } else if (!dontType && self.typeAnnotation) {
       code += ': ';
       code += yield* self.typeAnnotation.toEmbeddedTS(shiftState(state, code));
       if (!hideDefaultValue && self.defaultValue?.expression) {
-        if (['nasl.core.DateTime', 'nasl.core.Time', 'nasl.core.Date'].includes(this.typeAnnotation.typeKey)) {
+        if (['nasl.core.DateTime', 'nasl.core.Time', 'nasl.core.Date'].includes(typeKey)) {
           code += yield* self.defaultValue.toEmbeddedTS(shiftState(state, code), true);
         } else {
           code += ` = `;
@@ -457,7 +457,7 @@ export class Param extends BaseNode {
       return code;
     }
 
-    if (this.defaultExpression instanceof Function || this.defaultExpression instanceof AnonymousFunction) {
+    if (asserts.isFunction(this.defaultExpression) || asserts.isAnonymousFunction(this.defaultExpression)) {
       code += this.required ? ': ' : '?: ';
       code += runSync(this.defaultExpression.toEmbeddedTSDefinition(shiftState(state, code)));
     } else if (!dontType && this.typeAnnotation) {
@@ -546,7 +546,7 @@ export class Param extends BaseNode {
 
   setnNewTypeAnnotation(oldTypeAnnotation: TypeAnnotation) {
     const json = oldTypeAnnotation.toJSON();
-    const typeAnnotation = TypeAnnotation.from(json);
+    const typeAnnotation = getConceptConstructor('TypeAnnotation').from(json);
     this.typeAnnotation = typeAnnotation;
   }
 

package/src/concepts/Point__.ts

@@ -3,24 +3,24 @@
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 import { EventPayload, Params } from '../common/EventEmitter';
-import { concept, excludedInJSON, property, className } from '../decorators';
+import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } 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';
 
 /**
  * 点信息
  */
-@className
 @concept('点信息')
-// @ts-ignore
 export class Point extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'Point';
+  static readonly ConceptName: string = 'Point';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
@@ -33,14 +33,12 @@ export class Point extends BaseNode {
    * x
    */
   @property()
-  // @ts-ignore
   x!: number;
 
   /**
    * y
    */
   @property()
-  // @ts-ignore
   y!: number;
 
   /**