@lcap/nasl 3.5.0-beta.4 → 3.6.0-alpha.1

package/src/concepts/utils/asserts.ts

@@ -1,7 +1,6 @@
 import type { App } from '../App__';
 import type { Module } from '../Module__';
 import type { Namespace } from '../Namespace__';
-import type { FrontendType } from '../FrontendType__';
 import type { Frontend } from '../Frontend__';
 import type { Backend } from '../Backend__';
 import type { Integration } from '../Integration__';
@@ -25,7 +24,6 @@ import type { BindDirective } from '../BindDirective__';
 import type { BindEvent } from '../BindEvent__';
 import type { BindStyle } from '../BindStyle__';
 import type { ViewComponent } from '../ViewComponent__';
-import type { BusinessComponent } from '../BusinessComponent__';
 import type { Attribute } from '../Attribute__';
 import type { Event } from '../Event__';
 import type { Slot } from '../Slot__';
@@ -33,12 +31,10 @@ import type { Theme } from '../Theme__';
 import type { StaticString } from '../StaticString__';
 import type { Logic } from '../Logic__';
 import type { AuthLogic } from '../AuthLogic__';
-import type { BusinessLogic } from '../BusinessLogic__';
 import type { AuthLogicForCallInterface } from '../AuthLogicForCallInterface__';
 import type { OverriddenLogic } from '../OverriddenLogic__';
 import type { AbstractInterface } from '../AbstractInterface__';
 import type { Param } from '../Param__';
-import type { ParamWithGroup } from '../ParamWithGroup__';
 import type { Return } from '../Return__';
 import type { Variable } from '../Variable__';
 import type { BackendVariable } from '../BackendVariable__';
@@ -64,7 +60,6 @@ import type { Assignment } from '../Assignment__';
 import type { BatchAssignment } from '../BatchAssignment__';
 import type { Comment } from '../Comment__';
 import type { CallLogic } from '../CallLogic__';
-import type { CallEvent } from '../CallEvent__';
 import type { CallFunction } from '../CallFunction__';
 import type { CallInterface } from '../CallInterface__';
 import type { Destination } from '../Destination__';
@@ -218,21 +213,6 @@ export function isStrictNamespace(node: unknown): node is Namespace {
   return isBaseNode(node) && node.concept === 'Namespace';
 }
 
-/**
- * 严格判断输入为 FrontendType 节点
- *
- * @description 仅判断节点本身，不包含继承类
- * @example
- * ```ts
- * if (isStrictFrontendType(node)) {
- *   // 在这个花括号内，node 的类型为 FrontendType
- * }
- * ```
- */
-export function isStrictFrontendType(node: unknown): node is FrontendType {
-  return isBaseNode(node) && node.concept === 'FrontendType';
-}
-
 /**
  * 严格判断输入为 Frontend 节点
  *
@@ -578,21 +558,6 @@ export function isStrictViewComponent(node: unknown): node is ViewComponent {
   return isBaseNode(node) && node.concept === 'ViewComponent';
 }
 
-/**
- * 严格判断输入为 BusinessComponent 节点
- *
- * @description 仅判断节点本身，不包含继承类
- * @example
- * ```ts
- * if (isStrictBusinessComponent(node)) {
- *   // 在这个花括号内，node 的类型为 BusinessComponent
- * }
- * ```
- */
-export function isStrictBusinessComponent(node: unknown): node is BusinessComponent {
-  return isBaseNode(node) && node.concept === 'BusinessComponent';
-}
-
 /**
  * 严格判断输入为 Attribute 节点
  *
@@ -698,21 +663,6 @@ export function isStrictAuthLogic(node: unknown): node is AuthLogic {
   return isBaseNode(node) && node.concept === 'AuthLogic';
 }
 
-/**
- * 严格判断输入为 BusinessLogic 节点
- *
- * @description 仅判断节点本身，不包含继承类
- * @example
- * ```ts
- * if (isStrictBusinessLogic(node)) {
- *   // 在这个花括号内，node 的类型为 BusinessLogic
- * }
- * ```
- */
-export function isStrictBusinessLogic(node: unknown): node is BusinessLogic {
-  return isBaseNode(node) && node.concept === 'BusinessLogic';
-}
-
 /**
  * 严格判断输入为 AuthLogicForCallInterface 节点
  *
@@ -758,21 +708,6 @@ export function isStrictParam(node: unknown): node is Param {
   return isBaseNode(node) && node.concept === 'Param';
 }
 
-/**
- * 严格判断输入为 ParamWithGroup 节点
- *
- * @description 仅判断节点本身，不包含继承类
- * @example
- * ```ts
- * if (isStrictParamWithGroup(node)) {
- *   // 在这个花括号内，node 的类型为 ParamWithGroup
- * }
- * ```
- */
-export function isStrictParamWithGroup(node: unknown): node is ParamWithGroup {
-  return isBaseNode(node) && node.concept === 'ParamWithGroup';
-}
-
 /**
  * 严格判断输入为 Return 节点
  *
@@ -1118,21 +1053,6 @@ export function isStrictCallLogic(node: unknown): node is CallLogic {
   return isBaseNode(node) && node.concept === 'CallLogic';
 }
 
-/**
- * 严格判断输入为 CallEvent 节点
- *
- * @description 仅判断节点本身，不包含继承类
- * @example
- * ```ts
- * if (isStrictCallEvent(node)) {
- *   // 在这个花括号内，node 的类型为 CallEvent
- * }
- * ```
- */
-export function isStrictCallEvent(node: unknown): node is CallEvent {
-  return isBaseNode(node) && node.concept === 'CallEvent';
-}
-
 /**
  * 严格判断输入为 CallFunction 节点
  *
@@ -2251,27 +2171,6 @@ export function isNamespace(node: unknown): node is Namespace {
   );
 }
 
-/**
- * 判断输入为 FrontendType 节点实例
- *
- * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，FrontendType 节点没有继承类，此判断等价于`isStrictFrontendType`
- * @example
- * ```ts
- * if (isFrontendType(node)) {
- *   // 在这个花括号内，node 的类型是 FrontendType 或者 FrontendType 继承类型
- * }
- * ```
- */
-export function isFrontendType(node: unknown): node is FrontendType {
-  return (
-    isBaseNode(node) &&
-    (
-      node.concept === 'FrontendType'
-    )
-  );
-}
-
 /**
  * 判断输入为 Frontend 节点实例
  *
@@ -2755,27 +2654,6 @@ export function isViewComponent(node: unknown): node is ViewComponent {
   );
 }
 
-/**
- * 判断输入为 BusinessComponent 节点实例
- *
- * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，BusinessComponent 节点没有继承类，此判断等价于`isStrictBusinessComponent`
- * @example
- * ```ts
- * if (isBusinessComponent(node)) {
- *   // 在这个花括号内，node 的类型是 BusinessComponent 或者 BusinessComponent 继承类型
- * }
- * ```
- */
-export function isBusinessComponent(node: unknown): node is BusinessComponent {
-  return (
-    isBaseNode(node) &&
-    (
-      node.concept === 'BusinessComponent'
-    )
-  );
-}
-
 /**
  * 判断输入为 Attribute 节点实例
  *
@@ -2899,7 +2777,6 @@ export function isLogic(node: unknown): node is Type.LogicNode {
     (
       node.concept === 'Logic' ||
       node.concept === 'AuthLogic' ||
-      node.concept === 'BusinessLogic' ||
       node.concept === 'AuthLogicForCallInterface'
     )
   );
@@ -2927,27 +2804,6 @@ export function isAuthLogic(node: unknown): node is Type.AuthLogicNode {
   );
 }
 
-/**
- * 判断输入为 BusinessLogic 节点实例
- *
- * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，BusinessLogic 节点没有继承类，此判断等价于`isStrictBusinessLogic`
- * @example
- * ```ts
- * if (isBusinessLogic(node)) {
- *   // 在这个花括号内，node 的类型是 BusinessLogic 或者 BusinessLogic 继承类型
- * }
- * ```
- */
-export function isBusinessLogic(node: unknown): node is BusinessLogic {
-  return (
-    isBaseNode(node) &&
-    (
-      node.concept === 'BusinessLogic'
-    )
-  );
-}
-
 /**
  * 判断输入为 AuthLogicForCallInterface 节点实例
  *
@@ -3018,7 +2874,7 @@ export function isAbstractInterface(node: unknown): node is Type.AbstractInterfa
  * 判断输入为 Param 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算
+ * @description 等价于`instanceof`运算，Param 节点没有继承类，此判断等价于`isStrictParam`
  * @example
  * ```ts
  * if (isParam(node)) {
@@ -3026,33 +2882,11 @@ export function isAbstractInterface(node: unknown): node is Type.AbstractInterfa
  * }
  * ```
  */
-export function isParam(node: unknown): node is Type.ParamNode {
+export function isParam(node: unknown): node is Param {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'Param' ||
-      node.concept === 'ParamWithGroup'
-    )
-  );
-}
-
-/**
- * 判断输入为 ParamWithGroup 节点实例
- *
- * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，ParamWithGroup 节点没有继承类，此判断等价于`isStrictParamWithGroup`
- * @example
- * ```ts
- * if (isParamWithGroup(node)) {
- *   // 在这个花括号内，node 的类型是 ParamWithGroup 或者 ParamWithGroup 继承类型
- * }
- * ```
- */
-export function isParamWithGroup(node: unknown): node is ParamWithGroup {
-  return (
-    isBaseNode(node) &&
-    (
-      node.concept === 'ParamWithGroup'
+      node.concept === 'Param'
     )
   );
 }
@@ -3193,7 +3027,6 @@ export function isLogicItem(node: unknown): node is Type.LogicItemNode {
       node.concept === 'BatchAssignment' ||
       node.concept === 'Comment' ||
       node.concept === 'CallLogic' ||
-      node.concept === 'CallEvent' ||
       node.concept === 'CallFunction' ||
       node.concept === 'CallInterface' ||
       node.concept === 'Destination' ||
@@ -3643,27 +3476,6 @@ export function isCallLogic(node: unknown): node is Type.CallLogicNode {
   );
 }
 
-/**
- * 判断输入为 CallEvent 节点实例
- *
- * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，CallEvent 节点没有继承类，此判断等价于`isStrictCallEvent`
- * @example
- * ```ts
- * if (isCallEvent(node)) {
- *   // 在这个花括号内，node 的类型是 CallEvent 或者 CallEvent 继承类型
- * }
- * ```
- */
-export function isCallEvent(node: unknown): node is CallEvent {
-  return (
-    isBaseNode(node) &&
-    (
-      node.concept === 'CallEvent'
-    )
-  );
-}
-
 /**
  * 判断输入为 CallFunction 节点实例
  *
@@ -5194,23 +5006,6 @@ export function assertStrictNamespace(node: unknown): asserts node is Namespace
   }
 }
 
-/**
- * 严格断言为 FrontendType 节点
- *
- * @description 仅断言节点本身，不包含继承类
- * @example
- * ```ts
- * assertStrictFrontendType(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FrontendType 类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertStrictFrontendType(node: unknown): asserts node is FrontendType {
-  if (!isStrictFrontendType(node)) {
-    throw new Error(`FrontendType 节点严格断言失败`);
-  }
-}
-
 /**
  * 严格断言为 Frontend 节点
  *
@@ -5602,23 +5397,6 @@ export function assertStrictViewComponent(node: unknown): asserts node is ViewCo
   }
 }
 
-/**
- * 严格断言为 BusinessComponent 节点
- *
- * @description 仅断言节点本身，不包含继承类
- * @example
- * ```ts
- * assertStrictBusinessComponent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessComponent 类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertStrictBusinessComponent(node: unknown): asserts node is BusinessComponent {
-  if (!isStrictBusinessComponent(node)) {
-    throw new Error(`BusinessComponent 节点严格断言失败`);
-  }
-}
-
 /**
  * 严格断言为 Attribute 节点
  *
@@ -5738,23 +5516,6 @@ export function assertStrictAuthLogic(node: unknown): asserts node is AuthLogic
   }
 }
 
-/**
- * 严格断言为 BusinessLogic 节点
- *
- * @description 仅断言节点本身，不包含继承类
- * @example
- * ```ts
- * assertStrictBusinessLogic(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertStrictBusinessLogic(node: unknown): asserts node is BusinessLogic {
-  if (!isStrictBusinessLogic(node)) {
-    throw new Error(`BusinessLogic 节点严格断言失败`);
-  }
-}
-
 /**
  * 严格断言为 AuthLogicForCallInterface 节点
  *
@@ -5806,23 +5567,6 @@ export function assertStrictParam(node: unknown): asserts node is Param {
   }
 }
 
-/**
- * 严格断言为 ParamWithGroup 节点
- *
- * @description 仅断言节点本身，不包含继承类
- * @example
- * ```ts
- * assertStrictParamWithGroup(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ParamWithGroup 类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertStrictParamWithGroup(node: unknown): asserts node is ParamWithGroup {
-  if (!isStrictParamWithGroup(node)) {
-    throw new Error(`ParamWithGroup 节点严格断言失败`);
-  }
-}
-
 /**
  * 严格断言为 Return 节点
  *
@@ -6214,23 +5958,6 @@ export function assertStrictCallLogic(node: unknown): asserts node is CallLogic
   }
 }
 
-/**
- * 严格断言为 CallEvent 节点
- *
- * @description 仅断言节点本身，不包含继承类
- * @example
- * ```ts
- * assertStrictCallEvent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallEvent 类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertStrictCallEvent(node: unknown): asserts node is CallEvent {
-  if (!isStrictCallEvent(node)) {
-    throw new Error(`CallEvent 节点严格断言失败`);
-  }
-}
-
 /**
  * 严格断言为 CallFunction 节点
  *
@@ -7479,24 +7206,6 @@ export function assertNamespace(node: unknown): asserts node is Namespace {
   }
 }
 
-/**
- * 断言为 FrontendType 节点
- *
- * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictFrontendType`方法
- * @example
- * ```ts
- * assertFrontendType(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 FrontendType 或者 FrontendType 继承类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertFrontendType(node: unknown): asserts node is FrontendType {
-  if (!isFrontendType(node)) {
-    throw new Error(`FrontendType 节点断言失败`);
-  }
-}
-
 /**
  * 断言为 Frontend 节点
  *
@@ -7911,24 +7620,6 @@ export function assertViewComponent(node: unknown): asserts node is ViewComponen
   }
 }
 
-/**
- * 断言为 BusinessComponent 节点
- *
- * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictBusinessComponent`方法
- * @example
- * ```ts
- * assertBusinessComponent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessComponent 或者 BusinessComponent 继承类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertBusinessComponent(node: unknown): asserts node is BusinessComponent {
-  if (!isBusinessComponent(node)) {
-    throw new Error(`BusinessComponent 节点断言失败`);
-  }
-}
-
 /**
  * 断言为 Attribute 节点
  *
@@ -8055,24 +7746,6 @@ export function assertAuthLogic(node: unknown): asserts node is Type.AuthLogicNo
   }
 }
 
-/**
- * 断言为 BusinessLogic 节点
- *
- * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictBusinessLogic`方法
- * @example
- * ```ts
- * assertBusinessLogic(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 BusinessLogic 或者 BusinessLogic 继承类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertBusinessLogic(node: unknown): asserts node is BusinessLogic {
-  if (!isBusinessLogic(node)) {
-    throw new Error(`BusinessLogic 节点断言失败`);
-  }
-}
-
 /**
  * 断言为 AuthLogicForCallInterface 节点
  *
@@ -8139,30 +7812,12 @@ export function assertAbstractInterface(node: unknown): asserts node is Type.Abs
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertParam(node: unknown): asserts node is Type.ParamNode {
+export function assertParam(node: unknown): asserts node is Param {
   if (!isParam(node)) {
     throw new Error(`Param 节点断言失败`);
   }
 }
 
-/**
- * 断言为 ParamWithGroup 节点
- *
- * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictParamWithGroup`方法
- * @example
- * ```ts
- * assertParamWithGroup(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ParamWithGroup 或者 ParamWithGroup 继承类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertParamWithGroup(node: unknown): asserts node is ParamWithGroup {
-  if (!isParamWithGroup(node)) {
-    throw new Error(`ParamWithGroup 节点断言失败`);
-  }
-}
-
 /**
  * 断言为 Return 节点
  *
@@ -8613,24 +8268,6 @@ export function assertCallLogic(node: unknown): asserts node is Type.CallLogicNo
   }
 }
 
-/**
- * 断言为 CallEvent 节点
- *
- * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictCallEvent`方法
- * @example
- * ```ts
- * assertCallEvent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 CallEvent 或者 CallEvent 继承类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertCallEvent(node: unknown): asserts node is CallEvent {
-  if (!isCallEvent(node)) {
-    throw new Error(`CallEvent 节点断言失败`);
-  }
-}
-
 /**
  * 断言为 CallFunction 节点
  *