@lcap/nasl 3.7.0-beta.3 → 3.7.0-beta.5

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

@@ -1088,6 +1088,7 @@ export function initialize() {
     new Function({
       name: 'FormatDate',
       description: '返回格式化日期字符串',
+      composedBy: ['Format'],
       params: [
         new Param({
           name: 'date',
@@ -1103,6 +1104,28 @@ export function initialize() {
           }),
           defaultExpression: new StringLiteral({ value: 'yyyy-MM-dd' }),
           typeAnnotation: TypeAnnotation.createPrimitive('String'),
+          options: [
+            {
+              text: 'yyyy年MM月dd日',
+              value: 'yyyy年MM月dd日',
+              description: 'yyyy年MM月dd日',
+            },
+            {
+              text: 'yyyy-MM-dd',
+              value: 'yyyy-MM-dd',
+              description: 'yyyy-MM-dd',
+            },
+            {
+              text: 'dd/MM/yyyy',
+              value: 'dd/MM/yyyy',
+              description: 'dd/MM/yyyy',
+            },
+            {
+              text: 'MM/dd/yyyy',
+              value: 'MM/dd/yyyy',
+              description: 'MM/dd/yyyy',
+            },
+          ]
         })
       ],
       returns: [
@@ -1114,6 +1137,7 @@ export function initialize() {
     new Function({
       name: 'FormatDateTime',
       description: '返回格式化日期时间字符串。当输入为 DateTime 类型时，会把数据转到目标时区的当地时间进行格式化。',
+      composedBy: ['Format'],
       params: [
         new Param({
           name: 'date',
@@ -1129,6 +1153,154 @@ export function initialize() {
             concept: 'DefaultValue',
           }),
           defaultExpression: new StringLiteral({ value: 'yyyy-MM-dd HH:mm:ss' }),
+          options: [
+            {
+              text: 'yyyy年MM月dd日 HH时mm分ss秒',
+              value: 'yyyy年MM月dd日 HH时mm分ss秒',
+              description: 'yyyy年MM月dd日 HH时mm分ss秒',
+            },
+            {
+              text: 'yyyy-MM-dd HH:mm:ss',
+              value: 'yyyy-MM-dd HH:mm:ss',
+              description: 'yyyy-MM-dd HH:mm:ss',
+            },
+            {
+              text: 'dd/MM/yyyy HH:mm:ss',
+              value: 'dd/MM/yyyy HH:mm:ss',
+              description: 'dd/MM/yyyy HH:mm:ss',
+            },
+            {
+              text: 'MM/dd/yyyy HH:mm:ss',
+              value: 'MM/dd/yyyy HH:mm:ss',
+              description: 'MM/dd/yyyy HH:mm:ss',
+            },
+          ]
+        }),
+        new Param({
+          name: '时区',
+          description: '以此时区为基准',
+          useComponent: { type: 's-bidirectional-bind-switch' },
+          defaultExpression: new StringLiteral({
+            name: 'FormatDateTimeTimeZoneDefaultExpression',
+            value: 'global'
+          }),
+          options: TIMEZONES,
+          hidden: true,
+        }),
+      ],
+      returns: [
+        new Return({
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+    }),
+    new Function({
+      name: 'FormatTime',
+      description: '返回格式化时间字符串',
+      composedBy: ['Format'],
+      params: [
+        new Param({
+          name: 'date',
+          description: '指定需要格式化时间的字段',
+          typeAnnotation: TypeAnnotation.createPrimitive('Time'),
+        }),
+        new Param({
+          name: 'formatter',
+          description: '格式化规则，默认为HH:mm:ss，即时分秒格式',
+          defaultValue: new DefaultValue({
+            expression: new StringLiteral({ value: 'HH:mm:ss' }),
+            concept: 'DefaultValue',
+          }),
+          defaultExpression: new StringLiteral({ value: 'HH:mm:ss' }),
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+          options: [
+            {
+              text: 'HH:mm:ss',
+              value: 'HH:mm:ss',
+              description: 'HH:mm:ss',
+            },
+            {
+              text: 'HH时mm分ss秒',
+              value: 'HH时mm分ss秒',
+              description: 'HH时mm分ss秒',
+            },
+            {
+              text: 'HH:mm',
+              value: 'HH:mm',
+              description: 'HH:mm',
+            },
+            {
+              text: 'HH时mm分',
+              value: 'HH时mm分',
+              description: 'HH时mm分',
+            },
+          ]
+        })
+      ],
+      returns: [
+        new Return({
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+        }),
+      ],
+    }),
+    new Function({
+      name: 'Format',
+      description: '返回格式化字符串，如数值、百分比、日期时间等',
+      composedBy: ['Format'],
+    }),
+    new Function({
+      name: 'FormatPercent',
+      description: '返回格式化字符串，如数值、百分比、日期时间等',
+      composedBy: ['Format'],
+      params: [
+        new Param({
+          name: 'value',
+          description: '指定格式化字段',
+          typeAnnotation: TypeAnnotation.createPrimitive('Decimal'),
+          defaultExpression: new Identifier(),
+        }),
+        new Param({
+          name: 'digits',
+          typeAnnotation: TypeAnnotation.createPrimitive('Long'),
+          description: '保留小数位数',
+          defaultValue: new DefaultValue({
+            expression: new NumericLiteral({ value: '2' }),
+            concept: 'DefaultValue',
+          }),
+          defaultExpression: new NumericLiteral({ value: '2' }),
+        }),
+        new Param({
+          name: 'omit',
+          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+          description: '是否隐藏末尾0',
+          useComponent: { type: 's-checkbox' },
+          defaultValue: new DefaultValue({
+            expression: new BooleanLiteral({ value: 'true' }),
+            concept: 'DefaultValue',
+          }),
+          defaultExpression: new BooleanLiteral({ value: 'true' }),
+        }),
+        new Param({
+          name: 'showGroups',
+          description: '是否显示千分位：true显示，false不显示',
+          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+          defaultValue: new DefaultValue({
+            expression: new BooleanLiteral({ value: 'false' }),
+            concept: 'DefaultValue',
+          }),
+          defaultExpression: new BooleanLiteral({ value: 'false' }),
+          options: [
+            {
+              text: 'true',
+              value: 'true',
+              description: '显示千分位',
+            },
+            {
+              text: 'false',
+              value: 'false',
+              description: '不显示千分位',
+            },
+          ],
         }),
       ],
       returns: [
@@ -1140,10 +1312,11 @@ export function initialize() {
     new Function({
       name: 'FormatNumber',
       description: '返回格式化的数字字符串',
+      composedBy: ['Format'],
       params: [
         new Param({
           name: 'value',
-          description: '指定需要格式化小数位数的字段',
+          description: '指定格式化字段',
           typeAnnotation: TypeAnnotation.createPrimitive('Decimal'),
           defaultExpression: new Identifier(),
         }),
@@ -1157,6 +1330,17 @@ export function initialize() {
           }),
           defaultExpression: new NumericLiteral({ value: '2' }),
         }),
+        new Param({
+          name: 'omit',
+          typeAnnotation: TypeAnnotation.createPrimitive('Boolean'),
+          description: '是否隐藏末尾0',
+          useComponent: { type: 's-checkbox' },
+          defaultValue: new DefaultValue({
+            expression: new BooleanLiteral({ value: 'true' }),
+            concept: 'DefaultValue',
+          }),
+          defaultExpression: new BooleanLiteral({ value: 'true' }),
+        }),
         new Param({
           name: 'showGroups',
           description: '是否显示千分位：true显示，false不显示',
@@ -1179,6 +1363,38 @@ export function initialize() {
             },
           ],
         }),
+        new Param({
+          name: 'fix',
+          description: '前缀和后缀',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+          defaultValue: new DefaultValue({
+            expression: new StringLiteral({ value: 'prefix' }),
+            concept: 'DefaultValue',
+          }),
+          defaultExpression: new StringLiteral({ value: 'prefix' }),
+          options: [
+            {
+              text: '前缀',
+              value: 'prefix',
+              description: '前缀',
+            },
+            {
+              text: '后缀',
+              value: 'suffix',
+              description: '后缀',
+            },
+          ]
+        }),
+        new Param({
+          name: 'unit',
+          description: '表示前缀和后缀的内容',
+          typeAnnotation: TypeAnnotation.createPrimitive('String'),
+          defaultValue: new DefaultValue({
+            expression: new StringLiteral({ value: '' }),
+            concept: 'DefaultValue',
+          }),
+          defaultExpression: new StringLiteral({ value: '' }),
+        }),
       ],
       returns: [
         new Return({

package/src/concepts/index__.ts

@@ -145,9 +145,12 @@ export * from './AuthInterface__';
 export * from './CallAuthInterface__';
 export * from './TriggerEvent__';
 export * from './MsgTriggerEvent__';
+export * from './InterfaceTriggerEvent__';
 export * from './ConnectorTrigger__';
 export * from './TriggerLauncher__';
+export * from './ConnectorTriggerLauncher__';
 export * from './MsgTriggerLauncher__';
 export * from './Connector__';
 export * from './CallConnector__';
 export * from './Connection__';
+export * from './ConnectorLogic__';

package/src/concepts/utils/asserts.ts

@@ -145,12 +145,15 @@ import type { AuthInterface } from '../AuthInterface__';
 import type { CallAuthInterface } from '../CallAuthInterface__';
 import type { TriggerEvent } from '../TriggerEvent__';
 import type { MsgTriggerEvent } from '../MsgTriggerEvent__';
+import type { InterfaceTriggerEvent } from '../InterfaceTriggerEvent__';
 import type { ConnectorTrigger } from '../ConnectorTrigger__';
 import type { TriggerLauncher } from '../TriggerLauncher__';
+import type { ConnectorTriggerLauncher } from '../ConnectorTriggerLauncher__';
 import type { MsgTriggerLauncher } from '../MsgTriggerLauncher__';
 import type { Connector } from '../Connector__';
 import type { CallConnector } from '../CallConnector__';
 import type { Connection } from '../Connection__';
+import type { ConnectorLogic } from '../ConnectorLogic__';
 import type * as types from './types';
 import type { BaseNode } from '../../common';
 import type { FileNode } from '../../utils';
@@ -2290,33 +2293,33 @@ export function isStrictCallAuthInterface(node: unknown): node is CallAuthInterf
 }
 
 /**
- * 严格判断输入为 TriggerEvent 节点
+ * 严格判断输入为 MsgTriggerEvent 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictTriggerEvent(node)) {
- *   // 在这个花括号内，node 的类型为 TriggerEvent
+ * if (isStrictMsgTriggerEvent(node)) {
+ *   // 在这个花括号内，node 的类型为 MsgTriggerEvent
  * }
  * ```
  */
-export function isStrictTriggerEvent(node: unknown): node is TriggerEvent {
-  return isBaseNode(node) && node.concept === 'TriggerEvent';
+export function isStrictMsgTriggerEvent(node: unknown): node is MsgTriggerEvent {
+  return isBaseNode(node) && node.concept === 'MsgTriggerEvent';
 }
 
 /**
- * 严格判断输入为 MsgTriggerEvent 节点
+ * 严格判断输入为 InterfaceTriggerEvent 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictMsgTriggerEvent(node)) {
- *   // 在这个花括号内，node 的类型为 MsgTriggerEvent
+ * if (isStrictInterfaceTriggerEvent(node)) {
+ *   // 在这个花括号内，node 的类型为 InterfaceTriggerEvent
  * }
  * ```
  */
-export function isStrictMsgTriggerEvent(node: unknown): node is MsgTriggerEvent {
-  return isBaseNode(node) && node.concept === 'MsgTriggerEvent';
+export function isStrictInterfaceTriggerEvent(node: unknown): node is InterfaceTriggerEvent {
+  return isBaseNode(node) && node.concept === 'InterfaceTriggerEvent';
 }
 
 /**
@@ -2349,6 +2352,21 @@ export function isStrictTriggerLauncher(node: unknown): node is TriggerLauncher
   return isBaseNode(node) && node.concept === 'TriggerLauncher';
 }
 
+/**
+ * 严格判断输入为 ConnectorTriggerLauncher 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictConnectorTriggerLauncher(node)) {
+ *   // 在这个花括号内，node 的类型为 ConnectorTriggerLauncher
+ * }
+ * ```
+ */
+export function isStrictConnectorTriggerLauncher(node: unknown): node is ConnectorTriggerLauncher {
+  return isBaseNode(node) && node.concept === 'ConnectorTriggerLauncher';
+}
+
 /**
  * 严格判断输入为 MsgTriggerLauncher 节点
  *
@@ -2409,6 +2427,21 @@ export function isStrictConnection(node: unknown): node is Connection {
   return isBaseNode(node) && node.concept === 'Connection';
 }
 
+/**
+ * 严格判断输入为 ConnectorLogic 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictConnectorLogic(node)) {
+ *   // 在这个花括号内，node 的类型为 ConnectorLogic
+ * }
+ * ```
+ */
+export function isStrictConnectorLogic(node: unknown): node is ConnectorLogic {
+  return isBaseNode(node) && node.concept === 'ConnectorLogic';
+}
+
 
 
 //=========== 以下为继承类型判断 ===========
@@ -3407,7 +3440,8 @@ export function isLogic(node: unknown): node is types.LogicNode {
       node.concept === 'Logic' ||
       node.concept === 'AuthLogic' ||
       node.concept === 'AuthLogicForCallInterface' ||
-      node.concept === 'BusinessLogic'
+      node.concept === 'BusinessLogic' ||
+      node.concept === 'ConnectorLogic'
     )
   );
 }
@@ -5558,7 +5592,8 @@ export function isTriggerEvent(node: unknown): node is types.TriggerEventNode {
     isBaseNode(node) &&
     (
       node.concept === 'TriggerEvent' ||
-      node.concept === 'MsgTriggerEvent'
+      node.concept === 'MsgTriggerEvent' ||
+      node.concept === 'InterfaceTriggerEvent'
     )
   );
 }
@@ -5584,6 +5619,27 @@ export function isMsgTriggerEvent(node: unknown): node is MsgTriggerEvent {
   );
 }
 
+/**
+ * 判断输入为 InterfaceTriggerEvent 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，InterfaceTriggerEvent 节点没有继承类，此判断等价于`isStrictInterfaceTriggerEvent`
+ * @example
+ * ```ts
+ * if (isInterfaceTriggerEvent(node)) {
+ *   // 在这个花括号内，node 的类型是 InterfaceTriggerEvent 或者 InterfaceTriggerEvent 继承类型
+ * }
+ * ```
+ */
+export function isInterfaceTriggerEvent(node: unknown): node is InterfaceTriggerEvent {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'InterfaceTriggerEvent'
+    )
+  );
+}
+
 /**
  * 判断输入为 ConnectorTrigger 节点实例
  *
@@ -5622,6 +5678,29 @@ export function isTriggerLauncher(node: unknown): node is types.TriggerLauncherN
     isBaseNode(node) &&
     (
       node.concept === 'TriggerLauncher' ||
+      node.concept === 'ConnectorTriggerLauncher' ||
+      node.concept === 'MsgTriggerLauncher'
+    )
+  );
+}
+
+/**
+ * 判断输入为 ConnectorTriggerLauncher 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算
+ * @example
+ * ```ts
+ * if (isConnectorTriggerLauncher(node)) {
+ *   // 在这个花括号内，node 的类型是 ConnectorTriggerLauncher 或者 ConnectorTriggerLauncher 继承类型
+ * }
+ * ```
+ */
+export function isConnectorTriggerLauncher(node: unknown): node is types.ConnectorTriggerLauncherNode {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'ConnectorTriggerLauncher' ||
       node.concept === 'MsgTriggerLauncher'
     )
   );
@@ -5711,6 +5790,27 @@ export function isConnection(node: unknown): node is Connection {
   );
 }
 
+/**
+ * 判断输入为 ConnectorLogic 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ConnectorLogic 节点没有继承类，此判断等价于`isStrictConnectorLogic`
+ * @example
+ * ```ts
+ * if (isConnectorLogic(node)) {
+ *   // 在这个花括号内，node 的类型是 ConnectorLogic 或者 ConnectorLogic 继承类型
+ * }
+ * ```
+ */
+export function isConnectorLogic(node: unknown): node is ConnectorLogic {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'ConnectorLogic'
+    )
+  );
+}
+
 
 
 //=========== 以下为严格类型断言 ===========
@@ -8096,36 +8196,36 @@ export function assertStrictCallAuthInterface(node: unknown): asserts node is Ca
 }
 
 /**
- * 严格断言为 TriggerEvent 节点
+ * 严格断言为 MsgTriggerEvent 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictTriggerEvent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 TriggerEvent 类型
+ * assertStrictMsgTriggerEvent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MsgTriggerEvent 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictTriggerEvent(node: unknown): asserts node is TriggerEvent {
-  if (!isStrictTriggerEvent(node)) {
-    throw new Error(`TriggerEvent 节点严格断言失败`);
+export function assertStrictMsgTriggerEvent(node: unknown): asserts node is MsgTriggerEvent {
+  if (!isStrictMsgTriggerEvent(node)) {
+    throw new Error(`MsgTriggerEvent 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 MsgTriggerEvent 节点
+ * 严格断言为 InterfaceTriggerEvent 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictMsgTriggerEvent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MsgTriggerEvent 类型
+ * assertStrictInterfaceTriggerEvent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 InterfaceTriggerEvent 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictMsgTriggerEvent(node: unknown): asserts node is MsgTriggerEvent {
-  if (!isStrictMsgTriggerEvent(node)) {
-    throw new Error(`MsgTriggerEvent 节点严格断言失败`);
+export function assertStrictInterfaceTriggerEvent(node: unknown): asserts node is InterfaceTriggerEvent {
+  if (!isStrictInterfaceTriggerEvent(node)) {
+    throw new Error(`InterfaceTriggerEvent 节点严格断言失败`);
   }
 }
 
@@ -8163,6 +8263,23 @@ export function assertStrictTriggerLauncher(node: unknown): asserts node is Trig
   }
 }
 
+/**
+ * 严格断言为 ConnectorTriggerLauncher 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictConnectorTriggerLauncher(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorTriggerLauncher 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictConnectorTriggerLauncher(node: unknown): asserts node is ConnectorTriggerLauncher {
+  if (!isStrictConnectorTriggerLauncher(node)) {
+    throw new Error(`ConnectorTriggerLauncher 节点严格断言失败`);
+  }
+}
+
 /**
  * 严格断言为 MsgTriggerLauncher 节点
  *
@@ -8231,6 +8348,23 @@ export function assertStrictConnection(node: unknown): asserts node is Connectio
   }
 }
 
+/**
+ * 严格断言为 ConnectorLogic 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictConnectorLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorLogic 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictConnectorLogic(node: unknown): asserts node is ConnectorLogic {
+  if (!isStrictConnectorLogic(node)) {
+    throw new Error(`ConnectorLogic 节点严格断言失败`);
+  }
+}
+
 
 
 //=========== 以下为继承类型断言 ===========
@@ -10881,6 +11015,24 @@ export function assertMsgTriggerEvent(node: unknown): asserts node is MsgTrigger
   }
 }
 
+/**
+ * 断言为 InterfaceTriggerEvent 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictInterfaceTriggerEvent`方法
+ * @example
+ * ```ts
+ * assertInterfaceTriggerEvent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 InterfaceTriggerEvent 或者 InterfaceTriggerEvent 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertInterfaceTriggerEvent(node: unknown): asserts node is InterfaceTriggerEvent {
+  if (!isInterfaceTriggerEvent(node)) {
+    throw new Error(`InterfaceTriggerEvent 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 ConnectorTrigger 节点
  *
@@ -10917,6 +11069,24 @@ export function assertTriggerLauncher(node: unknown): asserts node is types.Trig
   }
 }
 
+/**
+ * 断言为 ConnectorTriggerLauncher 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictConnectorTriggerLauncher`方法
+ * @example
+ * ```ts
+ * assertConnectorTriggerLauncher(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorTriggerLauncher 或者 ConnectorTriggerLauncher 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertConnectorTriggerLauncher(node: unknown): asserts node is types.ConnectorTriggerLauncherNode {
+  if (!isConnectorTriggerLauncher(node)) {
+    throw new Error(`ConnectorTriggerLauncher 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 MsgTriggerLauncher 节点
  *
@@ -10989,3 +11159,21 @@ export function assertConnection(node: unknown): asserts node is Connection {
   }
 }
 
+/**
+ * 断言为 ConnectorLogic 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictConnectorLogic`方法
+ * @example
+ * ```ts
+ * assertConnectorLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorLogic 或者 ConnectorLogic 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertConnectorLogic(node: unknown): asserts node is ConnectorLogic {
+  if (!isConnectorLogic(node)) {
+    throw new Error(`ConnectorLogic 节点断言失败`);
+  }
+}
+