@lcap/nasl 3.5.0-beta.1 → 3.5.0-beta.3

package/sandbox/stdlib/nasl.util.ts

@@ -66,6 +66,7 @@ declare namespace nasl.util {
   export function ListDistinct<T>(list: nasl.collection.List<T>): void;
   export function ListDistinctBy<A>(list: nasl.collection.List<A>, by: nasl.collection.List<{ items: Array<(elem: A) => any> }>): nasl.collection.List<A>;
   export function ListSlice<T>(list: nasl.collection.List<T>, start: nasl.core.Long, end: nasl.core.Long): nasl.collection.List<T>;
+  export function SliceToListPage<T>(list: nasl.collection.List<T>, page: nasl.core.Long, size: nasl.core.Long): { list: nasl.collection.List<T>, total: nasl.core.Long };
 
   export function MapGet<K, V>(map: nasl.collection.Map<K, V>, key: K): V;
   export function MapPut<K, V>(map: nasl.collection.Map<K, V>, key: K, value: V): void;
@@ -139,6 +140,4 @@ declare namespace nasl.util {
   export function autoHandleError<T extends (...args: any[]) => any>(func: T): (...args: Parameters<T>) => Exclude<ReturnType<T>, nasl.ui.Error>;
   // 逻辑调用和验证器函数的包装器
   export function callLogicWithChecker<T extends (...args: any[]) => any>(func: T, checker: (...args: Parameters<T>) => any): T;
-  // 分页组件函数
-  export function paginateLimit<T>(list: nasl.collection.List<T>, page: nasl.core.Long, size: nasl.core.Long): { list: nasl.collection.List<T>, total: nasl.core.Long };
 }

package/src/bak/translator.js

@@ -4,24 +4,103 @@ function safeCodeAsKey(name) {
   return `['${name}']`;
 }
 
-function tryJSONParse(str) {
-  let result;
+/**
+ * 获取变量初始值
+ * @param {*} variable
+ * @param {*} URLParamRetrieval 从地址栏获取
+ * @returns
+ */
+function genVarInitialVal(variable, URLParamRetrieval) {
+  const typeAnnotation = variable.typeAnnotation || variable.__TypeAnnotation;
+  let { typeKind, typeNamespace, typeName, sortedTypeKey } = typeAnnotation || {};
+  if (typeNamespace?.endsWith('.metadataTypes')) {
+    const referenceNode = variable.getAncestor('App').findNodeByCompleteName(typeNamespace + '.' + typeName) || {}
+    const typeAn = referenceNode.typeAnnotation || {};
+    typeKind = typeAn.typeKind;
+    typeNamespace = typeAn.typeNamespace;
+    typeName = typeAn.typeName;
+    sortedTypeKey = `${typeNamespace}.${typeName}`;
+  }
+  const needGenInitFromSchema =
+      typeAnnotation && (!['primitive', 'union'].includes(typeKind) || typeName === 'DateTime');
 
-  try {
-    result = JSON.parse(str);
-  } catch (e) { }
+  let code = '';
+  if (needGenInitFromSchema) {
+    code += `this.$genInitFromSchema('${sortedTypeKey}', `;
+  }
+  if (variable.concept === 'Param' && URLParamRetrieval) {
+    code += `this.$route.query.hasOwnProperty('${variable.name}') ? this.$genInitFromSchema('${sortedTypeKey}', this.$route.query.${variable.name}) :`;
+  }
+  const { defaultValue } = variable;
+  // 设置成null，才能同步给后端清除该值，但是null对checkbox组件是一种特殊状态
+  const parsedValue = defaultValue?.expression?.toJS?.() ?? undefined;
 
-  return result;
+  code += parsedValue;
+  if (needGenInitFromSchema) {
+    code += `)`;
+  }
+  return code;
+}
+
+/**
+ * 获取组件入参的类型
+ * @param {*} typeAnnotation
+ */
+function getPropsType(typeAnnotation) {
+  let type = 'Object';
+  const { typeKind, typeNamespace, typeName, typeArguments } = typeAnnotation || {};
+  if (
+    typeKind === 'union'
+    && typeNamespace === 'nasl.core'
+    && typeName === 'Union'
+    && Array.isArray(typeArguments)
+    && typeArguments.length
+  ) {
+    const arr = typeArguments.map((typeArgument) => {
+      return getPropsType(typeArgument);
+    });
+    type = `[${arr.join(', ')}]`;
+  } else {
+    if (typeKind === 'primitive' && typeNamespace === 'nasl.core') {
+      const typeMap = {
+        Boolean: 'Boolean',
+        Decimal: 'Number',
+        Long: 'Number',
+        String: 'String',
+        Date: 'String',
+        Time: 'String',
+        DateTime: 'String',
+      };
+      if (typeMap[typeName]) {
+        type = typeMap[typeName];
+      }
+    } else if (typeKind === "generic" && typeNamespace === "nasl.collection" && typeName === 'List') {
+      type = 'Array';
+    }
+  }
+  return type;
 }
 
 export default function (definition, view) {
+  let isBusinessComponent = false;
+  if (view.concept === 'BusinessComponent') {
+    isBusinessComponent = true;
+  }
   /**
    * 页面的 data
    * 包含 页面变量 / 页面入参 / 页面元素绑定的表达式的返回
    */
   const viewVariablesData = [];
+  // 组件入参
+  const viewProps = [];
   // 所有的页面变量
-  const viewVariables = [...(definition.params || []), ...(definition.variables || [])];
+  const viewVariables = [...(definition.variables || [])];
+  if (isBusinessComponent) {
+    viewProps.push(...(definition.params || []));
+  } else {
+    viewVariables.push(...(definition.params || []));
+  }
+
   // 页面元素绑定的表达式
   const { viewExpressions } = definition;
   const hasViewExpressions = Array.isArray(viewExpressions) && viewExpressions.length;
@@ -29,38 +108,8 @@ export default function (definition, view) {
    * genInitFromSchema 是为了将数据类型的处理和页面逻辑的生成分开
    * 比如 param a.b 的 schema 有变化，View 代码无需再次生成
    */
-  const dataMap = {};
   viewVariables.forEach((viewVariable) => {
-    dataMap[viewVariable.code || viewVariable.name] = true;
-    const typeAnnotation = viewVariable.typeAnnotation || viewVariable.__TypeAnnotation;
-    let { typeKind, typeNamespace, typeName, sortedTypeKey } = typeAnnotation || {};
-    if (typeNamespace?.endsWith('.metadataTypes')) {
-      const referenceNode = view.getAncestor('App').findNodeByCompleteName(typeNamespace + '.' + typeName) || {}
-      const typeAn = referenceNode.typeAnnotation || {};
-      typeKind = typeAn.typeKind;
-      typeNamespace = typeAn.typeNamespace;
-      typeName = typeAn.typeName;
-      sortedTypeKey = `${typeNamespace}.${typeName}`;
-    }
-    const needGenInitFromSchema =
-      typeAnnotation && (!['primitive', 'union'].includes(typeKind) || typeName === 'DateTime');
-    let code = `${safeCodeAsKey(viewVariable.name)}:`;
-    if (needGenInitFromSchema) {
-      code += `this.$genInitFromSchema('${sortedTypeKey}', `;
-    }
-    if (viewVariable.concept === 'Param') {
-      code += `this.$route.query.hasOwnProperty('${viewVariable.name}') ? this.$genInitFromSchema('${sortedTypeKey}', this.$route.query.${viewVariable.name}) :`;
-    }
-
-    const { defaultValue } = viewVariable;
-    // 设置成null，才能同步给后端清除该值，但是null对checkbox组件是一种特殊状态
-    const parsedValue = defaultValue?.expression?.toJS?.() ?? undefined;
-
-    code += parsedValue;
-    if (needGenInitFromSchema) {
-      code += `)`;
-    }
-    viewVariablesData.push(code);
+    viewVariablesData.push(`${safeCodeAsKey(viewVariable.name)}: ${genVarInitialVal(viewVariable, !isBusinessComponent)}`);
   });
   /**
    * 页面的 computed
@@ -152,7 +201,9 @@ export default function (definition, view) {
 
   const events = Array.from(eventMap).map(([name, bindEvents]) => {
     let code = `async ${name} () {
-        ${bindEvents.map((event) => `await this.${event.view.name}_${event.name}();`).join('\n')}`;
+      ${bindEvents.map((event) =>{
+        const likeComponent = event.view || event.getAncestor('BusinessComponent');
+        return `await this.${likeComponent?.name}_${event.name}();`}).join('\n')}`;
     code += '}';
     return code;
   });
@@ -167,15 +218,42 @@ export default function (definition, view) {
       tabSize: 1,
     })
   );
-
-  const output = `
+  const viewPropArr = [];
+  // 监听
+  const watcherArr = [];
+  let output = '';
+  if (Array.isArray(viewProps) && viewProps.length) {
+    viewProps.forEach((viewProp) => {
+      const typeAnnotation = viewProp.typeAnnotation || viewProp.__TypeAnnotation;
+      viewPropArr.push(`${safeCodeAsKey(viewProp.name)}: {
+        type: ${getPropsType(typeAnnotation)},
+        default: ${genVarInitialVal(viewProp, !isBusinessComponent)}
+      }`);
+      watcherArr.push(`${safeCodeAsKey(viewProp.name)}: {
+        handler(val) {
+          this.$emit('update:${viewProp.name}', val);
+        },
+      }`);
+    });
+  }
+  if (Array.isArray(viewPropArr) && viewPropArr.length) {
+    output += `props: {
+      ${viewPropArr.join(',\n')}
+    },\n`;
+  }
+  if (Array.isArray(watcherArr) && watcherArr.length) {
+    output += `watch: {
+      ${watcherArr.join(',\n')}
+    },\n`;
+  }
+  output += `
         data() {
             return {
-                ${viewVariablesData.join(',\n').trim()}
+              ${viewVariablesData.join(',\n').trim()}
             };
         },
         computed: {
-            ${viewComputedData.join(',\n').trim()}
+          ${viewComputedData.join(',\n').trim()}
         },
 meta: {
     title: ${JSON.stringify(definition.title)},

package/src/breakpoint/generator/BreakpointNode.ts

@@ -349,6 +349,18 @@ export default class BreakpointNode extends BaseNode {
     return this.logic || this.variable;
   }
 
+  get items() {
+    return (this.node as any)?.items;
+  }
+
+  get concept() {
+    return (this.node as any)?.concept;
+  }
+
+  get getCallNode() {
+    return (this.node as any)?.getCallNode;
+  }
+
   init() {
     const source = this.logic || this.variable;
     const node = getRealNode(source);

package/src/breakpoint/generator/CallbackNode.ts

@@ -1,5 +1,17 @@
 import BreakpointNode from './BreakpointNode';
 
+const isFunctional = (node: any): boolean => {
+  try {
+    const a = node?.toJS && node?.toJS();
+    const b = node?.toJSOfEntityLogicProperties && node?.toJSOfEntityLogicProperties();
+
+    return a && a !== b;
+  } catch (error) {
+    console.error(error);
+    return true;
+  }
+};
+
 export default class CallbackNode extends BreakpointNode {
   toJS() {
     const { logic, variable } = this;
@@ -10,6 +22,11 @@ export default class CallbackNode extends BreakpointNode {
     }
 
     const code = node.toJS();
+    const founctional = isFunctional(node);
+
+    if (!founctional) {
+      return code;
+    }
 
     if (!code) {
       return code;

package/src/breakpoint/shared/constants.ts

@@ -54,10 +54,10 @@ export const BREAKPOINT_CONCEPTS = [
   'NewMap',
   'NewList',
   'NewComposite',
-  'Paginate',
   'Unparsed',
   'CallFunction',
   'CallLogic',
+  'CallEvent',
   'CallInterface',
   'CallConnector',
   'CallAuthInterface',

package/src/breakpoint/shared/utils.ts

@@ -3,6 +3,7 @@ import {
   View,
   BaseNode,
   ViewElement,
+  BusinessComponent,
 } from '../../concepts';
 
 import {
@@ -219,7 +220,7 @@ export const getLogics = (app: App) => {
     return [];
   }
 
-  const { frontends = [] } = app;
+  const { frontendTypes = [] } = app;
 
   let result = getGlobalLogics(app) || [];
 
@@ -242,7 +243,7 @@ export const getLogics = (app: App) => {
     viewElementChildren.forEach(forViewElement);
   };
 
-  const forView = (view: View) => {
+  const forView = (view: View | BusinessComponent) => {
     if (!view) {
       return;
     }
@@ -250,7 +251,6 @@ export const getLogics = (app: App) => {
     const {
       logics: viewLogics = [],
       elements: viewElements = [],
-      children: viewChildren = [],
       bindEvents: viewBindEvents = [],
     } = view;
 
@@ -263,13 +263,18 @@ export const getLogics = (app: App) => {
     });
 
     viewElements.forEach(forViewElement);
-    viewChildren.forEach(forView);
+    (view as View)?.children?.forEach(forView);
   };
 
-  frontends.forEach((frontend) => {
-    const { views = [] } = frontend;
-
-    views && views.forEach(forView);
+  frontendTypes.forEach((frontendType) => {
+    frontendType?.frontends?.forEach((frontend) => {
+      const { views = [] } = frontend;
+      views && views.forEach(forView);
+    });
+    const { businessComponents } = frontendType || {};
+    if (Array.isArray(businessComponents) && businessComponents.length) {
+      businessComponents.forEach(forView);
+    }
   });
 
   return result;

package/src/common/BaseNode.ts

@@ -8,10 +8,11 @@ import * as utils from '../utils';
 import { EventEmitter, EventPayload, Params } from './EventEmitter';
 import { action, circular, excludedInJSON, property, getConceptConstructor, getConceptPropertyMap, classMap } from '../decorators';
 import { Diagnostic } from '../manager/diagnostic';
-
 import { sentryMonitorNaslNode } from '../sentry';
 import operations from '../breakpoint/shared/operations';
-import type { TypeAnnotation, App, Namespace, Type } from '../concepts';
+import type { TypeAnnotation, App, Namespace } from '../concepts';
+import * as asserts from '../concepts/utils/asserts';
+import * as types from '../concepts/utils/types';
 import eventBus from '../eventBus';
 
 let actionable = true;
@@ -19,38 +20,6 @@ export function setActionable(value: boolean) {
   actionable = value;
 }
 
-// 确保属性都是定义过的
-function ensureDefined(object: any, concept: string) {
-  if (!object) {
-    return object;
-  }
-  const newObject: any = {};
-  const actualConcept = object?.concept || concept;
-  if (actualConcept) {
-    const propertyMap = getConceptPropertyMap(actualConcept);
-    for (const key in object) {
-      const property = propertyMap.get(key);
-      if (property) {
-        const objProperty = object[key] ?? null;
-        const propertyConcept = property?.objectRef;
-        if (propertyConcept) {
-          if (Array.isArray(objProperty)) {
-            newObject[key] = objProperty.map((objItem: any) => {
-              return ensureDefined(objItem, propertyConcept);
-            });
-          } else {
-            newObject[key] = ensureDefined(objProperty, propertyConcept);
-          }
-        } else {
-          newObject[key] = objProperty;
-        }
-      }
-    }
-
-    newObject.concept = actualConcept;
-  }
-  return newObject;
-}
 
 type NodePathOption = {
   useName?: boolean,
@@ -140,7 +109,7 @@ export class BaseNode extends EventEmitter {
    * 父节点
    */
   @circular()
-  parentNode: Type.SyntaxNode = null;
+  parentNode: types.SyntaxNode = null;
 
   parentKey: string = '';
 
@@ -235,6 +204,9 @@ export class BaseNode extends EventEmitter {
    */
   tsErrorDetail!: Diagnostic | undefined;
 
+  /**
+   * 组件属性名称
+   */
   @property()
   name: string = '';
 
@@ -409,14 +381,14 @@ export class BaseNode extends EventEmitter {
     this.parentNode?.emit('node:Editing', $event);
   }
 
-  createNode({ parentNode, parentKey, index }: { parentNode: Type.SyntaxNode; parentKey: string; index: number }) {
+  createNode({ parentNode, parentKey, index }: { parentNode: types.SyntaxNode; parentKey: string; index: number }) {
     if(!actionable) {
       eventBus.emit('NotActionable')
       return;
     }
 
     if (parentNode) {
-      const property = parentNode[parentKey as keyof Type.SyntaxNode];
+      const property = parentNode[parentKey as keyof types.SyntaxNode];
       if (Array.isArray(property) && index !== -1) {
         property.splice(index, 0, this);
       } else {
@@ -844,13 +816,13 @@ export class BaseNode extends EventEmitter {
   /**
    * 上层节点
    */
-  get upperNode(): Type.SyntaxNode {
+  get upperNode(): types.SyntaxNode {
     // eslint-disable-next-line consistent-this
     let _upperNode: BaseNode = this;
     while (!!_upperNode && _upperNode.concept === this.concept) {
       _upperNode = _upperNode.parentNode;
     }
-    return _upperNode as Type.SyntaxNode;
+    return _upperNode as types.SyntaxNode;
   }
 
   /**
@@ -863,9 +835,9 @@ export class BaseNode extends EventEmitter {
   /**
    * 获取祖先节点
    */
-  getAncestor(concept: Type.SyntaxNode['concept']): Type.SyntaxNode;
-  getAncestor<Node extends Type.SyntaxNode>(concept: Node['concept']): Node;
-  getAncestor<Node extends Type.SyntaxNode = Type.SyntaxNode>(concept: Type.SyntaxNode['concept']): Node {
+  getAncestor(concept: types.SyntaxNode['concept']): types.SyntaxNode;
+  getAncestor<Node extends types.SyntaxNode>(concept: Node['concept']): Node;
+  getAncestor<Node extends types.SyntaxNode = types.SyntaxNode>(concept: types.SyntaxNode['concept']): Node {
     let { upperNode } = this;
     while (upperNode && upperNode.concept && (
       (upperNode.concept !== concept)
@@ -944,7 +916,7 @@ export class BaseNode extends EventEmitter {
   instantiate(source: any, parentNode: BaseNode, parentKey: string) {
     if (source instanceof BaseNode) {
       if (!source.parentNode || !source.parentKey) {
-        source.parentNode = parentNode as Type.SyntaxNode;
+        source.parentNode = parentNode as types.SyntaxNode;
         source.parentKey = parentKey;
       }
       return source;
@@ -1081,7 +1053,27 @@ export class BaseNode extends EventEmitter {
     });
     return JSON.parse(JSON.stringify(temp));
   }
-
+  // 给国际化展示用
+  getNodeChinesePath(useIndex: boolean | string[] | NodePathOption) {
+    let node: BaseNode = this;
+    const pathArr: string[] = [];
+    while (node && node.concept) {
+      let pathText = '';
+      const { parentNode } = node;
+      if (parentNode) {
+        const { name, title, label } = parentNode as any;
+        pathText = `${(parentNode.constructor as any)?.nodeTitle || ''}${name || ''}`;
+        if (title && label) {
+          pathText += `(${title} | ${label})`;
+        } else if (title || label) {
+          pathText += `(${title || label})`;
+        }
+        pathArr.unshift(pathText);
+      }
+      node = parentNode;
+    }
+    return pathArr.join('/');
+  }
   /**
    * 查找引用
    */
@@ -1318,7 +1310,7 @@ export class BaseNode extends EventEmitter {
       for (const property of propertyMap.keys()) {
         const child = node[property as keyof BaseNode];
         if (!child) continue;
-        else if (Array.isArray(child)) child.forEach((node: Type.SyntaxNode) => traverse(node));
+        else if (Array.isArray(child)) child.forEach((node: types.SyntaxNode) => traverse(node));
         else traverse(child);
       }
     }
@@ -1331,8 +1323,8 @@ export class BaseNode extends EventEmitter {
    *
    * @description 与`traverseChildren`不同，此方法会过滤掉非节点值
    */
-  *traverseChildrenGenerator(cb: (node: Type.SyntaxNode) => (void | Generator<any, any, any>)) {
-    const isNode = (node: unknown): node is Type.SyntaxNode => {
+  *traverseChildrenGenerator(cb: (node: types.SyntaxNode) => (void | Generator<any, any, any>)) {
+    const isNode = (node: unknown): node is types.SyntaxNode => {
       return Boolean(node) && typeof node === 'object' && ('concept' in node) && typeof (node as any).concept === 'string';
     };
 
@@ -1382,14 +1374,10 @@ export class BaseNode extends EventEmitter {
    *
    * @description 严格迭代所有子节点！排除属性！
    */
-  traverseStrictChildren(cb: (el: Type.SyntaxNode) => void): void {
-    const isNode = (node: unknown): node is Type.SyntaxNode => {
-      return Boolean(node) && typeof node === 'object' && ('concept' in node) && typeof (node as any).concept === 'string';
-    };
-
+  traverseStrictChildren(cb: (el: types.SyntaxNode) => void): void {
     this.traverseChildren((el) => {
-      if (isNode(el)) {
-        cb(el);
+      if (asserts.isBaseNode(el)) {
+        cb(el as types.SyntaxNode);
       }
     });
   }
@@ -1469,7 +1457,7 @@ export class BaseNode extends EventEmitter {
     if (typeAnnotation) {
       const { typeKind, typeNamespace, typeName, properties } = typeAnnotation;
       if (typeKind === 'reference' || typeKind === 'generic') {
-        if (typeNamespace.endsWith('.enums')) return null;
+        if (typeNamespace?.endsWith('.enums')) return null;
         return [{}];
       }
       if (typeNamespace === 'nasl.core' && ['String', 'Text', 'Email'].includes(typeName)) {
@@ -1486,7 +1474,7 @@ export class BaseNode extends EventEmitter {
   /**
    * 使用新的 concept 在当前节点生成新的数据
    */
-  changeConceptNode(concept: Type.SyntaxNodeConcept) {
+  changeConceptNode(concept: types.SyntaxNodeConcept) {
     return new Proxy(this, {
       get(target, p: keyof BaseNode, receiver) {
         if (p === 'concept') {
@@ -1499,20 +1487,20 @@ export class BaseNode extends EventEmitter {
   }
 
   /** 收集所有节点 */
-  collectNodes(): Type.SyntaxNode[];
+  collectNodes(): types.SyntaxNode[];
   /** 收集特定类型的子节点 */
-  collectNodes(concept: Type.SyntaxNodeConcept): Type.SyntaxNode[];
+  collectNodes(concept: types.SyntaxNodeConcept): types.SyntaxNode[];
   /** 收集断言返回`true`的子节点 */
-  collectNodes(pre: (node?: Type.SyntaxNode) => boolean): Type.SyntaxNode[];
-  collectNodes(input?: Type.SyntaxNodeConcept | ((node?: Type.SyntaxNode) => boolean)) {
+  collectNodes(pre: (node?: types.SyntaxNode) => boolean): types.SyntaxNode[];
+  collectNodes(input?: types.SyntaxNodeConcept | ((node?: types.SyntaxNode) => boolean)) {
     const pre =
       typeof input === 'undefined'
-        ? (node: Type.SyntaxNode) => node && typeof node.concept === 'string'
+        ? (node: types.SyntaxNode) => asserts.isBaseNode(node)
         : typeof input === 'string'
-          ? (node: Type.SyntaxNode) => node?.concept === input
+          ? (node: types.SyntaxNode) => asserts[`isStrict${input}`]?.(node) ?? false
           : input;
-    const nodes: Type.SyntaxNode[] = [];
-    const self = this as unknown as Type.SyntaxNode;
+    const nodes: types.SyntaxNode[] = [];
+    const self = this as unknown as types.SyntaxNode;
 
     if (pre(self)) {
       nodes.push(self);

package/src/common/utils.ts

@@ -1,6 +1,6 @@
-import type { Type } from '../concepts';
+import type { types } from '../concepts';
 
-export function waitOqlQueryComponentChildrenFinish(node: Type.SyntaxNode) {
+export function waitOqlQueryComponentChildrenFinish(node: types.SyntaxNode) {
   const needGetSourceMapOqlList: Promise<any>[] = [];
 
   node.traverseStrictChildren((el) => {

package/src/concepts/Abort__.ts

@@ -14,8 +14,8 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
-import * as Type from './utils/types';
-import * as Assert from './utils/asserts';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import LogicItem from './LogicItem__';
 
@@ -23,13 +23,12 @@ import LogicItem from './LogicItem__';
  * 中止表达式
  */
 @concept('中止表达式')
-// @ts-ignore
 export class Abort extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'Abort';
+  static readonly ConceptName: string = 'Abort';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念

package/src/concepts/AbstractInterface__.ts

@@ -6,8 +6,8 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
-import * as Type from './utils/types';
-import * as Assert from './utils/asserts';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 
@@ -15,13 +15,12 @@ import BaseNode from '../common/BaseNode';
  * 接口
  */
 @concept('接口')
-// @ts-ignore
 export abstract class AbstractInterface extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'AbstractInterface';
+  static readonly ConceptName: string = 'AbstractInterface';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * @param source 需要合并的部分参数

package/src/concepts/Anchor__.ts

@@ -18,8 +18,8 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
-import * as Type from './utils/types';
-import * as Assert from './utils/asserts';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import LogicItem from './LogicItem__';
 
@@ -27,13 +27,12 @@ import LogicItem from './LogicItem__';
  * 锚点参数
  */
 @concept('锚点参数')
-// @ts-ignore
 export class Anchor extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'Anchor';
+  static readonly ConceptName: string = 'Anchor';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -48,7 +47,6 @@ export class Anchor extends LogicItem {
   @property({
     objectRef: 'LogicItem',
   })
-  // @ts-ignore
   expression!: LogicItem;
 
   /**