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

package/src/concepts/utils/asserts.ts

@@ -1,6 +1,7 @@
 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__';
@@ -24,6 +25,7 @@ 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__';
@@ -31,10 +33,12 @@ 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__';
@@ -60,6 +64,7 @@ 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__';
@@ -86,7 +91,6 @@ import type { New } from '../New__';
 import type { NewComposite } from '../NewComposite__';
 import type { NewList } from '../NewList__';
 import type { NewMap } from '../NewMap__';
-import type { Paginate } from '../Paginate__';
 import type { CallQueryComponent } from '../CallQueryComponent__';
 import type { QueryFromExpression } from '../QueryFromExpression__';
 import type { QueryJoinExpression } from '../QueryJoinExpression__';
@@ -214,6 +218,21 @@ 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 节点
  *
@@ -559,6 +578,21 @@ 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 节点
  *
@@ -664,6 +698,21 @@ 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 节点
  *
@@ -709,6 +758,21 @@ 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 节点
  *
@@ -1054,6 +1118,21 @@ 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 节点
  *
@@ -1444,21 +1523,6 @@ export function isStrictNewMap(node: unknown): node is NewMap {
   return isBaseNode(node) && node.concept === 'NewMap';
 }
 
-/**
- * 严格判断输入为 Paginate 节点
- *
- * @description 仅判断节点本身，不包含继承类
- * @example
- * ```ts
- * if (isStrictPaginate(node)) {
- *   // 在这个花括号内，node 的类型为 Paginate
- * }
- * ```
- */
-export function isStrictPaginate(node: unknown): node is Paginate {
-  return isBaseNode(node) && node.concept === 'Paginate';
-}
-
 /**
  * 严格判断输入为 CallQueryComponent 节点
  *
@@ -2187,6 +2251,27 @@ 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 节点实例
  *
@@ -2670,6 +2755,27 @@ 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 节点实例
  *
@@ -2793,6 +2899,7 @@ export function isLogic(node: unknown): node is Type.LogicNode {
     (
       node.concept === 'Logic' ||
       node.concept === 'AuthLogic' ||
+      node.concept === 'BusinessLogic' ||
       node.concept === 'AuthLogicForCallInterface'
     )
   );
@@ -2820,6 +2927,27 @@ 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 节点实例
  *
@@ -2890,7 +3018,7 @@ export function isAbstractInterface(node: unknown): node is Type.AbstractInterfa
  * 判断输入为 Param 节点实例
  *
  * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Param 节点没有继承类，此判断等价于`isStrictParam`
+ * @description 等价于`instanceof`运算
  * @example
  * ```ts
  * if (isParam(node)) {
@@ -2898,11 +3026,33 @@ export function isAbstractInterface(node: unknown): node is Type.AbstractInterfa
  * }
  * ```
  */
-export function isParam(node: unknown): node is Param {
+export function isParam(node: unknown): node is Type.ParamNode {
   return (
     isBaseNode(node) &&
     (
-      node.concept === 'Param'
+      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'
     )
   );
 }
@@ -3043,6 +3193,7 @@ 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' ||
@@ -3069,7 +3220,6 @@ export function isLogicItem(node: unknown): node is Type.LogicItemNode {
       node.concept === 'NewComposite' ||
       node.concept === 'NewList' ||
       node.concept === 'NewMap' ||
-      node.concept === 'Paginate' ||
       node.concept === 'CallQueryComponent' ||
       node.concept === 'QueryFromExpression' ||
       node.concept === 'QueryJoinExpression' ||
@@ -3493,6 +3643,27 @@ 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 节点实例
  *
@@ -4040,27 +4211,6 @@ export function isNewMap(node: unknown): node is NewMap {
   );
 }
 
-/**
- * 判断输入为 Paginate 节点实例
- *
- * @description 包含节点类以及节点继承类的判断
- * @description 等价于`instanceof`运算，Paginate 节点没有继承类，此判断等价于`isStrictPaginate`
- * @example
- * ```ts
- * if (isPaginate(node)) {
- *   // 在这个花括号内，node 的类型是 Paginate 或者 Paginate 继承类型
- * }
- * ```
- */
-export function isPaginate(node: unknown): node is Paginate {
-  return (
-    isBaseNode(node) &&
-    (
-      node.concept === 'Paginate'
-    )
-  );
-}
-
 /**
  * 判断输入为 CallQueryComponent 节点实例
  *
@@ -5044,6 +5194,23 @@ 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 节点
  *
@@ -5435,6 +5602,23 @@ 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 节点
  *
@@ -5554,6 +5738,23 @@ 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 节点
  *
@@ -5605,6 +5806,23 @@ 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 节点
  *
@@ -5996,6 +6214,23 @@ 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 节点
  *
@@ -6438,23 +6673,6 @@ export function assertStrictNewMap(node: unknown): asserts node is NewMap {
   }
 }
 
-/**
- * 严格断言为 Paginate 节点
- *
- * @description 仅断言节点本身，不包含继承类
- * @example
- * ```ts
- * assertStrictPaginate(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Paginate 类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertStrictPaginate(node: unknown): asserts node is Paginate {
-  if (!isStrictPaginate(node)) {
-    throw new Error(`Paginate 节点严格断言失败`);
-  }
-}
-
 /**
  * 严格断言为 CallQueryComponent 节点
  *
@@ -7261,6 +7479,24 @@ 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 节点
  *
@@ -7675,6 +7911,24 @@ 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 节点
  *
@@ -7801,6 +8055,24 @@ 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 节点
  *
@@ -7867,12 +8139,30 @@ export function assertAbstractInterface(node: unknown): asserts node is Type.Abs
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertParam(node: unknown): asserts node is Param {
+export function assertParam(node: unknown): asserts node is Type.ParamNode {
   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 节点
  *
@@ -8323,6 +8613,24 @@ 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 节点
  *
@@ -8791,24 +9099,6 @@ export function assertNewMap(node: unknown): asserts node is NewMap {
   }
 }
 
-/**
- * 断言为 Paginate 节点
- *
- * @description 包含节点类以及节点继承类的判断
- * @description 节点没有继承类时，等价于`assertStrictPaginate`方法
- * @example
- * ```ts
- * assertPaginate(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 Paginate 或者 Paginate 继承类型
- * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
- * ```
- */
-export function assertPaginate(node: unknown): asserts node is Paginate {
-  if (!isPaginate(node)) {
-    throw new Error(`Paginate 节点断言失败`);
-  }
-}
-
 /**
  * 断言为 CallQueryComponent 节点
  *