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

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 { SyntaxNode, SyntaxNodeConcept, ViewElement, TypeAnnotation, App, Namespace } 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;
@@ -140,7 +141,7 @@ export class BaseNode extends EventEmitter {
    * 父节点
    */
   @circular()
-  parentNode: SyntaxNode = null;
+  parentNode: types.SyntaxNode = null;
 
   parentKey: string = '';
 
@@ -235,6 +236,9 @@ export class BaseNode extends EventEmitter {
    */
   tsErrorDetail!: Diagnostic | undefined;
 
+  /**
+   * 组件属性名称
+   */
   @property()
   name: string = '';
 
@@ -409,14 +413,14 @@ export class BaseNode extends EventEmitter {
     this.parentNode?.emit('node:Editing', $event);
   }
 
-  createNode({ parentNode, parentKey, index }: { parentNode: 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 SyntaxNode];
+      const property = parentNode[parentKey as keyof types.SyntaxNode];
       if (Array.isArray(property) && index !== -1) {
         property.splice(index, 0, this);
       } else {
@@ -844,13 +848,13 @@ export class BaseNode extends EventEmitter {
   /**
    * 上层节点
    */
-  get upperNode(): 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 SyntaxNode;
+    return _upperNode as types.SyntaxNode;
   }
 
   /**
@@ -863,9 +867,9 @@ export class BaseNode extends EventEmitter {
   /**
    * 获取祖先节点
    */
-  getAncestor(concept: SyntaxNode['concept']): SyntaxNode;
-  getAncestor<Node extends SyntaxNode>(concept: Node['concept']): Node;
-  getAncestor<Node extends SyntaxNode = SyntaxNode>(concept: 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 +948,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 SyntaxNode;
+        source.parentNode = parentNode as types.SyntaxNode;
         source.parentKey = parentKey;
       }
       return source;
@@ -1318,7 +1322,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: SyntaxNode) => traverse(node));
+        else if (Array.isArray(child)) child.forEach((node: types.SyntaxNode) => traverse(node));
         else traverse(child);
       }
     }
@@ -1331,8 +1335,8 @@ export class BaseNode extends EventEmitter {
    *
    * @description 与`traverseChildren`不同，此方法会过滤掉非节点值
    */
-  *traverseChildrenGenerator(cb: (node: SyntaxNode) => (void | Generator<any, any, any>)) {
-    const isNode = (node: unknown): node is 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 +1386,10 @@ export class BaseNode extends EventEmitter {
    *
    * @description 严格迭代所有子节点！排除属性！
    */
-  traverseStrictChildren(cb: (el: SyntaxNode) => void): void {
-    const isNode = (node: unknown): node is 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);
       }
     });
   }
@@ -1486,7 +1486,7 @@ export class BaseNode extends EventEmitter {
   /**
    * 使用新的 concept 在当前节点生成新的数据
    */
-  changeConceptNode(concept: SyntaxNodeConcept) {
+  changeConceptNode(concept: types.SyntaxNodeConcept) {
     return new Proxy(this, {
       get(target, p: keyof BaseNode, receiver) {
         if (p === 'concept') {
@@ -1499,20 +1499,20 @@ export class BaseNode extends EventEmitter {
   }
 
   /** 收集所有节点 */
-  collectNodes(): SyntaxNode[];
+  collectNodes(): types.SyntaxNode[];
   /** 收集特定类型的子节点 */
-  collectNodes(concept: SyntaxNodeConcept): SyntaxNode[];
+  collectNodes(concept: types.SyntaxNodeConcept): types.SyntaxNode[];
   /** 收集断言返回`true`的子节点 */
-  collectNodes(pre: (node?: SyntaxNode) => boolean): SyntaxNode[];
-  collectNodes(input?: SyntaxNodeConcept | ((node?: SyntaxNode) => boolean)) {
+  collectNodes(pre: (node?: types.SyntaxNode) => boolean): types.SyntaxNode[];
+  collectNodes(input?: types.SyntaxNodeConcept | ((node?: types.SyntaxNode) => boolean)) {
     const pre =
       typeof input === 'undefined'
-        ? (node: SyntaxNode) => node && typeof node.concept === 'string'
+        ? (node: types.SyntaxNode) => asserts.isBaseNode(node)
         : typeof input === 'string'
-          ? (node: SyntaxNode) => node?.concept === input
+          ? (node: types.SyntaxNode) => asserts[`isStrict${input}`]?.(node) ?? false
           : input;
-    const nodes: SyntaxNode[] = [];
-    const self = this as unknown as SyntaxNode;
+    const nodes: types.SyntaxNode[] = [];
+    const self = this as unknown as types.SyntaxNode;
 
     if (pre(self)) {
       nodes.push(self);

package/src/common/Command.ts

@@ -67,7 +67,7 @@ export function invokeOnlyCommand(command: string, ...args: any[]) {
   if (process.env.NODE === 'development') {
     console.log('invokeOnlyCommand', command);
   }
-  return cmds[0]?.execute(...args);
+  return cmds?.[0]?.execute(...args);
 }
 
 export function hasCommand(command: string) {

package/src/common/EventEmitter.ts

@@ -27,7 +27,12 @@ export class EventEmitter {
    * @param eventName 事件名
    * @param listener 监听器
    */
-  off(eventName: string, listener: EventListener) {
+  off(eventName?: string, listener?: EventListener) {
+    if (!eventName) {
+      (this as any)._events = {};
+      return;
+    }
+
     const listeners = this._events[eventName];
     if (listeners) {
       const index = listeners.indexOf(listener);

package/src/common/utils.ts

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

package/src/concepts/Abort__.ts

@@ -11,25 +11,24 @@ import {
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 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 LogicItem from './LogicItem__';
 
 /**
  * 中止表达式
  */
-@className
 @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

@@ -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 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

@@ -9,31 +9,30 @@ import {
   TranslatorGenerator,
 } from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
-import StringLiteral from './StringLiteral__';
+import type StringLiteral from './StringLiteral__';
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 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 LogicItem from './LogicItem__';
 
 /**
  * 锚点参数
  */
-@className
 @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;
 
   /**
@@ -157,7 +155,7 @@ export class Anchor extends LogicItem {
   toJS(state?: TranslatorState): string {
     let code = '';
     if (this.expression) {
-      code += this.expression.toJS(shiftState(state, code));
+      code += this.expression.toJS(state);
     } else {
       code += '';
     }

package/src/concepts/AnonymousFunction__.ts

@@ -1,5 +1,5 @@
 import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
-import Namespace from './Namespace__';
+import type Namespace from './Namespace__';
 import {
   TranslatorState,
   shiftState,
@@ -11,11 +11,9 @@ import {
   TranslatorGenerator,
 } from '../translator';
 import { ElementToVueOptions } from './ViewElement__';
-import ForEachStatement from './ForEachStatement__';
-import NewList from './NewList__';
-import CallLogic from './CallLogic__';
-import MemberExpression from './MemberExpression__';
-import Entity from './Entity__';
+import type NewList from './NewList__';
+import type MemberExpression from './MemberExpression__';
+import type Entity from './Entity__';
 import asyncFuncMap from '../common/asyncFuncMap';
 
 //================================================================================
@@ -23,30 +21,28 @@ import asyncFuncMap from '../common/asyncFuncMap';
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
 //================================================================================
 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 Param from './Param__';
 import LogicItem from './LogicItem__';
-import TypeAnnotation from './TypeAnnotation__';
-import Module from './Module__';
-import App from './App__';
-import { SyntaxNode } from './types__';
+import type Param from './Param__';
+import type TypeAnnotation from './TypeAnnotation__';
+import type Module from './Module__';
+import type App from './App__';
 
 /**
  * 匿名函数
  */
-@className
 @concept('匿名函数')
-// @ts-ignore
 export class AnonymousFunction extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'AnonymousFunction';
+  static readonly ConceptName: string = 'AnonymousFunction';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -59,7 +55,6 @@ export class AnonymousFunction extends LogicItem {
    * 匿名函数描述
    */
   @property()
-  // @ts-ignore
   description!: string;
 
   /**
@@ -78,7 +73,6 @@ export class AnonymousFunction extends LogicItem {
   @property({
     objectRef: 'LogicItem',
   })
-  // @ts-ignore
   body!: LogicItem;
 
   /**
@@ -87,7 +81,6 @@ export class AnonymousFunction extends LogicItem {
   @property({
     objectRef: 'TypeAnnotation',
   })
-  // @ts-ignore
   typeAnnotation!: TypeAnnotation;
 
   /**
@@ -171,6 +164,7 @@ export class AnonymousFunction extends LogicItem {
   _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(
@@ -190,7 +184,7 @@ export class AnonymousFunction extends LogicItem {
         this,
         'params',
       );
-    } else if (options instanceof Param) {
+    } else if (asserts.isParam(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       param = options;
       Object.assign(param, relationOptions);
@@ -468,7 +462,7 @@ export class AnonymousFunction extends LogicItem {
   toJS(state?: TranslatorState): string {
     const grandParent = this.parentNode?.parentNode;
     if (
-      grandParent instanceof CallLogic &&
+      asserts.isCallLogic(grandParent) &&
       /dataSources\.[^.]+\.entities\.[^.]+\.logics/.test(grandParent.calleeNamespace) &&
       ['update', 'updateBy', 'createOrUpdate', 'batchUpdate'].includes(grandParent.calleeName)
     )
@@ -484,7 +478,7 @@ export class AnonymousFunction extends LogicItem {
     code += ')';
     code += ' => (';
     if (this.body) {
-      code += this.body.toJS(shiftState(state, code));
+      code += this.body.toJS(state);
     }
     code += ')';
     let resultCode = '';
@@ -500,9 +494,9 @@ export class AnonymousFunction extends LogicItem {
 
   toJSOfEntityLogicProperties(state?: TranslatorState): string {
     let code = '[';
-    if (this.body && this.body instanceof NewList) {
+    if (this.body && asserts.isNewList(this.body)) {
       this.body.items.forEach((item: MemberExpression, index, array) => {
-        code += `'${item.property.toJS(shiftState(state, code))}'`;
+        code += `'${item.property.toJS(state)}'`;
         if (index !== array.length - 1) code += ',';
       });
     }
@@ -544,7 +538,7 @@ export class AnonymousFunction extends LogicItem {
     let updateNoPropertyCode = '';
     const grandParent = self.parentNode?.parentNode;
     if (
-      grandParent instanceof CallLogic &&
+      asserts.isCallLogic(grandParent) &&
       /dataSources\.[^.]+\.entities\.[^.]+\.logics/.test(grandParent.calleeNamespace) &&
       ['update', 'updateBy', 'createOrUpdate', 'batchUpdate'].includes(grandParent.calleeName)
     ) {
@@ -656,17 +650,17 @@ export class AnonymousFunction extends LogicItem {
   }
 
   checkParamName() {
-    let node: SyntaxNode = this;
+    let node: types.SyntaxNode = this;
     const names: Set<string> = new Set();
     while (node && node.concept !== 'Logic') {
       node = node.parentNode;
-      if (node instanceof AnonymousFunction) {
+      if (asserts.isAnonymousFunction(node)) {
         node.params.forEach((param) => {
           names.add(param.name);
         });
       }
 
-      if (node instanceof ForEachStatement) {
+      if (asserts.isForEachStatement(node)) {
         names.add(node.item.name);
         names.add(node.index.name);
       }